[Summary view] [Print] [Text view]

   1  var __create = Object.create;
   2  var __defProp = Object.defineProperty;
   3  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   4  var __getOwnPropNames = Object.getOwnPropertyNames;
   5  var __getProtoOf = Object.getPrototypeOf;
   6  var __hasOwnProp = Object.prototype.hasOwnProperty;
   7  var __commonJS = (cb, mod) => function __require() {
   8    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   9  };
  10  var __copyProps = (to, from, except, desc) => {
  11    if (from && typeof from === "object" || typeof from === "function") {
  12      for (let key of __getOwnPropNames(from))
  13        if (!__hasOwnProp.call(to, key) && key !== except)
  14          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  15    }
  16    return to;
  17  };
  18  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  19    // If the importer is in node compatibility mode or this is not an ESM
  20    // file that has been converted to a CommonJS file using a Babel-
  21    // compatible transform (i.e. "__esModule" has not been set), then set
  22    // "default" to the CommonJS "module.exports" for node compatibility.
  23    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  24    mod
  25  ));
  26  
  27  // package-external:@wordpress/element
  28  var require_element = __commonJS({
  29    "package-external:@wordpress/element"(exports, module) {
  30      module.exports = window.wp.element;
  31    }
  32  });
  33  
  34  // vendor-external:react/jsx-runtime
  35  var require_jsx_runtime = __commonJS({
  36    "vendor-external:react/jsx-runtime"(exports, module) {
  37      module.exports = window.ReactJSXRuntime;
  38    }
  39  });
  40  
  41  // packages/widget-primitives/build-module/tools/get-lazy-widget-component/get-lazy-widget-component.mjs
  42  var import_element = __toESM(require_element(), 1);
  43  function isValidWidgetModule(module) {
  44    return typeof module === "object" && module !== null && "default" in module && typeof module.default === "function";
  45  }
  46  var componentCache = /* @__PURE__ */ new Map();
  47  function getLazyWidgetComponent(renderModule, resolveWidgetModule) {
  48    const cached = componentCache.get(renderModule);
  49    if (cached) {
  50      return cached;
  51    }
  52    const lazyComponent = (0, import_element.lazy)(async () => {
  53      const module = await resolveWidgetModule(renderModule);
  54      if (!isValidWidgetModule(module)) {
  55        throw new Error(`Invalid widget module: $renderModule}`);
  56      }
  57      return module;
  58    });
  59    componentCache.set(renderModule, lazyComponent);
  60    return lazyComponent;
  61  }
  62  
  63  // packages/widget-primitives/build-module/components/widget-render/widget-render.mjs
  64  var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
  65  function WidgetRender({
  66    widgetType,
  67    attributes,
  68    setAttributes,
  69    resolveWidgetModule
  70  }) {
  71    const WidgetComponent = getLazyWidgetComponent(
  72      widgetType.renderModule,
  73      resolveWidgetModule
  74    );
  75    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
  76      WidgetComponent,
  77      {
  78        attributes,
  79        setAttributes
  80      }
  81    ) });
  82  }
  83  
  84  // packages/widget-primitives/build-module/hooks/use-widget-types.mjs
  85  var import_element2 = __toESM(require_element(), 1);
  86  
  87  // packages/widget-primitives/build-module/field-types/field-types.mjs
  88  var FIELD_TYPE_NAME_PATTERN = /^[a-z][a-z0-9-]*(\/[a-z][a-z0-9-]*)?$/;
  89  var fieldTypes = /* @__PURE__ */ new Map();
  90  function registerFieldType(fieldType) {
  91    if (!FIELD_TYPE_NAME_PATTERN.test(fieldType.name) || fieldTypes.has(fieldType.name)) {
  92      return void 0;
  93    }
  94    fieldTypes.set(fieldType.name, fieldType);
  95    return fieldType;
  96  }
  97  function resolveFields(fields) {
  98    return fields.map((field) => {
  99      const fieldType = field.type ? fieldTypes.get(field.type) : void 0;
 100      if (!fieldType) {
 101        return field;
 102      }
 103      const { name, baseType, isValid, ...fieldDefaults } = fieldType;
 104      const { type, isValid: fieldIsValid, ...rest } = field;
 105      return {
 106        ...fieldDefaults,
 107        ...rest,
 108        type: baseType,
 109        ...isValid || fieldIsValid ? { isValid: { ...isValid, ...fieldIsValid } } : {}
 110      };
 111    });
 112  }
 113  
 114  // packages/widget-primitives/build-module/icon-resolver/icon-resolver.mjs
 115  var iconResolver;
 116  function registerIconResolver(resolver) {
 117    if (iconResolver) {
 118      return void 0;
 119    }
 120    iconResolver = resolver;
 121    return resolver;
 122  }
 123  async function resolveIcon(reference) {
 124    if (!iconResolver) {
 125      return null;
 126    }
 127    try {
 128      return await iconResolver(reference);
 129    } catch {
 130      return null;
 131    }
 132  }
 133  
 134  // packages/widget-primitives/build-module/hooks/use-widget-types.mjs
 135  var pendingIcon = (0, import_element2.createElement)("svg", {
 136    viewBox: "0 0 24 24"
 137  });
 138  function withRenderableIcons(actions, holdPending) {
 139    return actions.map(({ icon, ...action }) => {
 140      if ((0, import_element2.isValidElement)(icon)) {
 141        return { ...action, icon };
 142      }
 143      if (holdPending && typeof icon === "string") {
 144        return { ...action, icon: pendingIcon };
 145      }
 146      return action;
 147    });
 148  }
 149  var DEFAULT_API_VERSION = 1;
 150  function recordOverlay(record) {
 151    return {
 152      name: record.name,
 153      renderModule: record.render_module ?? "",
 154      ...record.presentation ? { presentation: record.presentation } : {},
 155      ...record.category ? { category: record.category } : {},
 156      ...record.description ? { description: record.description } : {},
 157      ...record.help ? { help: record.help } : {},
 158      ...record.keywords ? { keywords: record.keywords } : {}
 159    };
 160  }
 161  function useWidgetTypes(records) {
 162    const [widgetTypes, setWidgetTypes] = (0, import_element2.useState)([]);
 163    const [isResolvingWidgetTypes, setIsResolvingWidgetTypes] = (0, import_element2.useState)(true);
 164    (0, import_element2.useEffect)(() => {
 165      if (records === null || records === void 0) {
 166        setIsResolvingWidgetTypes(true);
 167        return;
 168      }
 169      if (records.length === 0) {
 170        setWidgetTypes([]);
 171        setIsResolvingWidgetTypes(false);
 172        return;
 173      }
 174      let cancelled = false;
 175      setIsResolvingWidgetTypes(true);
 176      Promise.all(
 177        records.map(async (record) => {
 178          if (!record.widget_module) {
 179            if (!record.render_module) {
 180              return null;
 181            }
 182            return {
 183              apiVersion: DEFAULT_API_VERSION,
 184              title: record.title ?? record.name,
 185              ...record.icon ? { icon: pendingIcon } : {},
 186              ...record.actions ? {
 187                actions: withRenderableIcons(
 188                  record.actions,
 189                  true
 190                )
 191              } : {},
 192              ...recordOverlay(record)
 193            };
 194          }
 195          try {
 196            const module = await import(
 197              /* webpackIgnore: true */
 198              record.widget_module
 199            );
 200            if (!module?.default) {
 201              return null;
 202            }
 203            const metadata = module.default;
 204            const moduleIcon = (0, import_element2.isValidElement)(metadata.icon) ? metadata.icon : void 0;
 205            const icon = moduleIcon ?? (record.icon ? pendingIcon : void 0);
 206            const actions = record.actions ?? metadata.actions;
 207            return {
 208              apiVersion: DEFAULT_API_VERSION,
 209              ...metadata,
 210              ...metadata.attributes ? {
 211                attributes: resolveFields(
 212                  metadata.attributes
 213                )
 214              } : {},
 215              icon,
 216              /*
 217               * `title` is required:
 218               * - Server-side title wins
 219               * - Then the module's title
 220               * - Then the record's name as fallback
 221               */
 222              title: record.title ?? metadata.title ?? record.name,
 223              ...actions ? {
 224                actions: withRenderableIcons(
 225                  actions,
 226                  actions === record.actions
 227                )
 228              } : {},
 229              ...recordOverlay(record)
 230            };
 231          } catch {
 232            return null;
 233          }
 234        })
 235      ).then((results) => {
 236        if (cancelled) {
 237          return;
 238        }
 239        setWidgetTypes(
 240          results.filter((t) => t !== null)
 241        );
 242        setIsResolvingWidgetTypes(false);
 243        for (const record of records) {
 244          if (!record.icon) {
 245            continue;
 246          }
 247          void resolveIcon(record.icon).then((resolved) => {
 248            if (cancelled) {
 249              return;
 250            }
 251            setWidgetTypes(
 252              (prev) => prev.map((widgetType) => {
 253                if (widgetType.name !== record.name) {
 254                  return widgetType;
 255                }
 256                if (resolved) {
 257                  return { ...widgetType, icon: resolved };
 258                }
 259                return widgetType.icon === pendingIcon ? { ...widgetType, icon: void 0 } : widgetType;
 260              })
 261            );
 262          });
 263        }
 264        for (const record of records) {
 265          for (const action of record.actions ?? []) {
 266            if (typeof action.icon !== "string") {
 267              continue;
 268            }
 269            void resolveIcon(action.icon).then((resolved) => {
 270              if (cancelled) {
 271                return;
 272              }
 273              setWidgetTypes(
 274                (prev) => prev.map((type) => {
 275                  if (type.name !== record.name) {
 276                    return type;
 277                  }
 278                  return {
 279                    ...type,
 280                    actions: type.actions?.map((entry) => {
 281                      if (entry.id !== action.id) {
 282                        return entry;
 283                      }
 284                      if (resolved) {
 285                        return {
 286                          ...entry,
 287                          icon: resolved
 288                        };
 289                      }
 290                      return entry.icon === pendingIcon ? { ...entry, icon: void 0 } : entry;
 291                    })
 292                  };
 293                })
 294              );
 295            });
 296          }
 297        }
 298      });
 299      return () => {
 300        cancelled = true;
 301      };
 302    }, [records]);
 303    return [widgetTypes, isResolvingWidgetTypes];
 304  }
 305  
 306  // packages/widget-primitives/build-module/widget-host/widget-host.mjs
 307  var import_element3 = __toESM(require_element(), 1);
 308  var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
 309  var WidgetHostContext = (0, import_element3.createContext)({});
 310  function WidgetHostProvider({
 311    value,
 312    children
 313  }) {
 314    const inherited = (0, import_element3.useContext)(WidgetHostContext);
 315    const merged = (0, import_element3.useMemo)(
 316      () => ({ ...inherited, ...value }),
 317      [inherited, value]
 318    );
 319    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WidgetHostContext.Provider, { value: merged, children });
 320  }
 321  function useWidgetHost() {
 322    return (0, import_element3.useContext)(WidgetHostContext);
 323  }
 324  export {
 325    WidgetHostProvider,
 326    WidgetRender,
 327    registerFieldType,
 328    registerIconResolver,
 329    useWidgetHost,
 330    useWidgetTypes
 331  };