@wix/astro 2.18.0 → 2.20.0

package/build/integration/chunk-QHGDEGZS.js

@@ -0,0 +1,809 @@
+import { createRequire as _createRequire } from 'node:module';
+const require = _createRequire(import.meta.url);
+import {
+  appendToDevServerUrl,
+  buildAll,
+  cloneDeep,
+  createVirtualRouter,
+  defaultOutdent,
+  getAssetUrlForModuleId,
+  getChunkForEntryName,
+  init_esm_shims,
+  m,
+  merge,
+  normalizePath,
+  viteVirtualRouterPlugin
+} from "./chunk-WK4OVFTZ.js";
+
+// ../astro-context-providers-extensions/src/integration.ts
+init_esm_shims();
+import { ok } from "assert";
+import { createServer } from "vite";
+
+// ../astro-context-providers-extensions/src/utils/getResources.ts
+init_esm_shims();
+
+// ../astro-context-providers-extensions/src/utils/getClientResource.ts
+init_esm_shims();
+
+// ../astro-context-providers-extensions/src/vite/client/build-config.ts
+init_esm_shims();
+import { join as join2 } from "path";
+
+// ../astro-context-providers-extensions/src/vite/shared.ts
+init_esm_shims();
+var extensionName = "context-providers";
+var externalDeps = [
+  /^react$/,
+  /^react\/jsx-runtime$/,
+  /^react\/jsx-dev-runtime$/,
+  /^@preact\/signals-react$/,
+  /^@wix\/public-schemas$/
+];
+
+// ../astro-context-providers-extensions/src/vite/virtual-modules-plugin.ts
+init_esm_shims();
+
+// ../astro-context-providers-extensions/src/vite/client/virtual-module.ts
+init_esm_shims();
+
+// ../astro-context-providers-extensions/src/runtime/index.ts
+init_esm_shims();
+var sdkRuntimePath = normalizePath(
+  new URL(
+    "../dependencies/astro-context-providers-extensions/browser-runtime/sdk.js",
+    import.meta.url
+  )
+);
+var hmrRuntimePath = normalizePath(
+  new URL(
+    "../dependencies/astro-context-providers-extensions/browser-runtime/hmr.js",
+    import.meta.url
+  )
+);
+
+// ../astro-context-providers-extensions/src/utils/getContextProvider.ts
+init_esm_shims();
+
+// ../astro-context-providers-extensions/src/utils/getSupportedExtensions.ts
+init_esm_shims();
+import { join } from "path";
+function getSupportedExtensions({
+  extensions,
+  srcDir
+}) {
+  const contextProviderExtensions = extensions.filter(filterContextProviders);
+  return contextProviderExtensions.map((extension) => {
+    return {
+      ...extension,
+      componentPath: join(srcDir, extension.options.resources.client.url),
+      editorPreviewPath: extension.options.resources.editor?.url != null ? join(srcDir, extension.options.resources.editor.url) : null
+    };
+  });
+}
+function filterContextProviders(extension) {
+  return extension.type === "ContextProvider";
+}
+
+// ../astro-context-providers-extensions/src/utils/getContextProvider.ts
+function getContextProvider(model, id) {
+  return getSupportedExtensions(model).find(
+    (ext) => ext.options.id === id
+  );
+}
+
+// ../astro-context-providers-extensions/src/vite/client/virtual-module.ts
+function getClientComponentBuildTemplate(componentPath) {
+  return defaultOutdent`
+    import { createContext } from '${sdkRuntimePath}';
+
+    export const injectAccessTokenGetter = createContext();
+
+    export { default } from '${componentPath}';
+    export * from '${componentPath}';
+  `;
+}
+function getClientComponentServeTemplate(componentPath, hookName) {
+  return defaultOutdent`
+    import { createContext } from '${sdkRuntimePath}';
+    import { createComponentHmrWrapper } from '${hmrRuntimePath}';
+    import OriginalComponent from '${componentPath}';
+    import { ${hookName} as originalHook } from '${componentPath}';
+
+    let WrappedComponent = OriginalComponent;
+
+    if (import.meta.hot) {
+      import.meta.hot.data.contextHook = originalHook;
+      import.meta.hot.accept('${componentPath}', (newModule) => {
+        if (newModule) {
+          if (newModule['${hookName}']) {
+            import.meta.hot.data.contextHook = newModule['${hookName}'];
+          }
+
+          if (newModule.default) {
+            import.meta.hot.data.setComponent?.(newModule.default);
+          }
+        }
+      });
+
+      WrappedComponent = createComponentHmrWrapper(OriginalComponent, import.meta.hot.data);
+    }
+
+    export const injectAccessTokenGetter = createContext();
+    export const ${hookName} = (...args) => {
+      const hookToCall = import.meta.hot?.data.contextHook ?? originalHook;
+      return hookToCall(...args);
+    }
+    export default WrappedComponent;
+  `;
+}
+function getVirtualModuleIdForClientComponent(componentId) {
+  return `wix/context-provider/${componentId}`;
+}
+function registerClientVirtualRoute({
+  model,
+  router
+}) {
+  router.route(
+    getVirtualModuleIdForClientComponent(":id"),
+    ({ id }, { command }) => {
+      const extension = getContextProvider(model, id);
+      if (extension) {
+        const componentPath = normalizePath(extension.componentPath);
+        if (command === "build") {
+          return getClientComponentBuildTemplate(componentPath);
+        }
+        return getClientComponentServeTemplate(
+          componentPath,
+          extension.options.resources.contextSpecifier.hook
+        );
+      }
+      return null;
+    }
+  );
+}
+
+// ../astro-context-providers-extensions/src/vite/editor/virtual-module.ts
+init_esm_shims();
+function getVirtualModuleIdForEditorComponent(componentId) {
+  return `wix/context-provider-editor/${componentId}`;
+}
+function registerEditorVirtualRoute({
+  model,
+  router
+}) {
+  router.route(
+    getVirtualModuleIdForEditorComponent(":id"),
+    ({ id }, { command }) => {
+      const extension = getContextProvider(model, id);
+      if (extension?.editorPreviewPath != null) {
+        const componentPath = normalizePath(extension.editorPreviewPath);
+        if (command === "build") {
+          return getClientComponentBuildTemplate(componentPath);
+        }
+        return getClientComponentServeTemplate(
+          componentPath,
+          extension.options.resources.contextSpecifier.hook
+        );
+      }
+      return null;
+    }
+  );
+}
+
+// ../astro-context-providers-extensions/src/vite/virtual-modules-plugin.ts
+function virtualModulesPlugin({ model }) {
+  const router = createVirtualRouter();
+  registerClientVirtualRoute({ model, router });
+  registerEditorVirtualRoute({ model, router });
+  return viteVirtualRouterPlugin({
+    name: "wix:context-provider-virtual-modules-plugin",
+    router
+  });
+}
+
+// ../astro-context-providers-extensions/src/vite/client/build-config.ts
+var getClientBuildConfig = ({
+  createExtensionViteConfig,
+  extension: {
+    options: { id }
+  },
+  model
+}) => {
+  return createExtensionViteConfig({
+    name: join2(extensionName, "client"),
+    config: {
+      build: {
+        rollupOptions: {
+          external: externalDeps,
+          input: {
+            [getEntryNameForClientComponent(id)]: getVirtualModuleIdForClientComponent(id)
+          },
+          preserveEntrySignatures: "strict"
+        }
+      },
+      plugins: [virtualModulesPlugin({ model })]
+    }
+  });
+};
+function getEntryNameForClientComponent(componentId) {
+  return `context-provider-${componentId}`;
+}
+
+// ../astro-context-providers-extensions/src/utils/getClientResource.ts
+function getClientResource({
+  baseUrl,
+  buildOutput,
+  devServer,
+  extension
+}) {
+  if (buildOutput) {
+    return getClientResourceBuild({ baseUrl, buildOutput, extension });
+  }
+  if (devServer) {
+    return getClientResourceDev({ baseUrl, devServer, extension });
+  }
+  throw new Error("Unknown error: no build output or vite dev server");
+}
+function getClientResourceBuild({
+  baseUrl,
+  buildOutput,
+  extension
+}) {
+  const entryName = getEntryNameForClientComponent(extension.options.id);
+  const chunk = getChunkForEntryName({ buildOutput, entryName });
+  const componentFileName = chunk.fileName;
+  return {
+    url: appendToDevServerUrl(baseUrl, componentFileName)
+  };
+}
+function getClientResourceDev({
+  baseUrl,
+  devServer,
+  extension
+}) {
+  const moduleId = getVirtualModuleIdForClientComponent(extension.options.id);
+  return {
+    url: getAssetUrlForModuleId({ baseUrl, devServer, moduleId })
+  };
+}
+
+// ../astro-context-providers-extensions/src/utils/getEditorResource.ts
+init_esm_shims();
+
+// ../astro-context-providers-extensions/src/vite/editor/build-config.ts
+init_esm_shims();
+import { join as join3 } from "path";
+function getEntryNameForEditorComponent(componentId) {
+  return `component-${componentId}-editor`;
+}
+var getEditorBuildConfig = ({
+  createExtensionViteConfig,
+  extension: {
+    options: { id }
+  },
+  model
+}) => {
+  return createExtensionViteConfig({
+    name: join3(extensionName, "editor"),
+    config: {
+      build: {
+        rollupOptions: {
+          external: externalDeps,
+          input: {
+            [getEntryNameForEditorComponent(id)]: getVirtualModuleIdForEditorComponent(id)
+          },
+          preserveEntrySignatures: "strict"
+        }
+      },
+      plugins: [virtualModulesPlugin({ model })]
+    }
+  });
+};
+
+// ../astro-context-providers-extensions/src/utils/getEditorResource.ts
+function getEditorResource({
+  baseUrl,
+  buildOutput,
+  devServer,
+  extension
+}) {
+  if (extension.editorPreviewPath == null) {
+    return;
+  }
+  if (buildOutput) {
+    return getEditorResourceBuild({ baseUrl, buildOutput, extension });
+  }
+  if (devServer) {
+    return getEditorResourceDev({ baseUrl, devServer, extension });
+  }
+  throw new Error("Unknown error: no build output or vite dev server");
+}
+function getEditorResourceBuild({
+  baseUrl,
+  buildOutput,
+  extension
+}) {
+  const entryName = getEntryNameForEditorComponent(extension.options.id);
+  const chunk = getChunkForEntryName({ buildOutput, entryName });
+  const componentFileName = chunk.fileName;
+  return {
+    url: appendToDevServerUrl(baseUrl, componentFileName)
+  };
+}
+function getEditorResourceDev({
+  baseUrl,
+  devServer,
+  extension
+}) {
+  const moduleId = getVirtualModuleIdForEditorComponent(extension.options.id);
+  return {
+    url: getAssetUrlForModuleId({ baseUrl, devServer, moduleId })
+  };
+}
+
+// ../astro-context-providers-extensions/src/utils/getResources.ts
+function getResources(buildContext) {
+  return {
+    client: getClientResource(buildContext),
+    editor: getEditorResource(buildContext)
+  };
+}
+
+// ../astro-context-providers-extensions/src/vite/configs/build.ts
+init_esm_shims();
+function getBuildViteConfigs({
+  createExtensionViteConfig,
+  model
+}) {
+  const extensions = getSupportedExtensions(model);
+  return extensions.reduce((acc, extension) => {
+    const { editorPreviewPath } = extension;
+    acc.push(
+      getClientBuildConfig({
+        createExtensionViteConfig,
+        extension,
+        model
+      })
+    );
+    if (editorPreviewPath != null) {
+      acc.push(
+        getEditorBuildConfig({
+          createExtensionViteConfig,
+          extension,
+          model
+        })
+      );
+    }
+    return acc;
+  }, []);
+}
+
+// ../astro-context-providers-extensions/src/vite/configs/dev.ts
+init_esm_shims();
+function getDevViteConfig({
+  createExtensionViteConfig,
+  model
+}) {
+  const extensionEntries = getSupportedExtensions(model).map((ext) => [
+    ext.componentPath,
+    ...ext.editorPreviewPath != null ? [ext.editorPreviewPath] : []
+  ]).flat();
+  return createExtensionViteConfig({
+    name: extensionName,
+    config: {
+      optimizeDeps: {
+        entries: [...extensionEntries, sdkRuntimePath, hmrRuntimePath]
+      },
+      plugins: [
+        m({
+          externals: externalDeps
+        }),
+        virtualModulesPlugin({ model })
+      ]
+    }
+  });
+}
+
+// ../astro-context-providers-extensions/src/integration.ts
+var createIntegration = () => {
+  let model = null;
+  let customBuildOutput = null;
+  let customDevServer = null;
+  return {
+    name: "@wix/astro/context-providers",
+    hooks: {
+      "wix:model:setup"({ model: newModel }) {
+        model = newModel;
+      },
+      async "wix:server:start"({
+        createExtensionViteConfig,
+        setupExtensionProxy
+      }) {
+        ok(model);
+        customDevServer = await createServer(
+          getDevViteConfig({ createExtensionViteConfig, model })
+        );
+        await customDevServer.listen();
+        setupExtensionProxy(customDevServer);
+      },
+      async "astro:server:done"() {
+        ok(customDevServer);
+        await customDevServer.close();
+      },
+      async "wix:build:setup"({ createExtensionViteConfig }) {
+        ok(model);
+        const extensions = getSupportedExtensions(model);
+        if (extensions.length === 0) {
+          return;
+        }
+        customBuildOutput = await buildAll(
+          getBuildViteConfigs({ createExtensionViteConfig, model })
+        );
+      },
+      async "wix:app-manifest:setup"({
+        staticsUrlPlaceholder,
+        updateAppManifest
+      }) {
+        ok(model);
+        const extensions = getSupportedExtensions(model);
+        const components = [];
+        for (const extension of extensions) {
+          const buildContext = {
+            baseUrl: staticsUrlPlaceholder,
+            buildOutput: customBuildOutput,
+            devServer: customDevServer,
+            extension
+          };
+          components.push({
+            compId: extension.options.id,
+            compType: "EDITOR_CONTEXT_PROVIDER",
+            compData: {
+              editorContextProvider: merge(cloneDeep(extension.options), {
+                resources: getResources(buildContext)
+              })
+            }
+          });
+        }
+        updateAppManifest({ components });
+      }
+    }
+  };
+};
+
+// ../astro-context-providers-extensions/src/builders.ts
+init_esm_shims();
+function contextProvider(options) {
+  return {
+    type: "ContextProvider",
+    options
+  };
+}
+
+// ../astro-context-providers-extensions/src/index.ts
+init_esm_shims();
+
+// ../astro-function-libraries-extensions/src/integration.ts
+init_esm_shims();
+import { ok as ok2 } from "assert";
+import { createServer as createServer2 } from "vite";
+
+// ../astro-function-libraries-extensions/src/utils/getResources.ts
+init_esm_shims();
+
+// ../astro-function-libraries-extensions/src/utils/getClientResource.ts
+init_esm_shims();
+
+// ../astro-function-libraries-extensions/src/vite/client/virtual-module.ts
+init_esm_shims();
+
+// ../astro-function-libraries-extensions/src/utils/getFunctionLibrary.ts
+init_esm_shims();
+
+// ../astro-function-libraries-extensions/src/utils/getSupportedExtensions.ts
+init_esm_shims();
+import { join as join4 } from "path";
+function getSupportedExtensions2({
+  extensions,
+  srcDir
+}) {
+  const functionLibraryExtensions = extensions.filter(filterFunctionLibrary);
+  return functionLibraryExtensions.map((extension) => {
+    return {
+      ...extension,
+      componentPath: join4(srcDir, extension.options.resources.client.url)
+    };
+  });
+}
+function filterFunctionLibrary(extension) {
+  return extension.type === "FunctionLibrary";
+}
+
+// ../astro-function-libraries-extensions/src/utils/getFunctionLibrary.ts
+function getFunctionLibrary(model, id) {
+  return getSupportedExtensions2(model).find(
+    (ext) => ext.options.id === id
+  );
+}
+
+// ../astro-function-libraries-extensions/src/vite/client/virtual-module.ts
+function getVirtualModuleIdForClientComponent2(componentId) {
+  return `wix/function-library/${componentId}`;
+}
+function registerClientVirtualRoute2({
+  model,
+  router
+}) {
+  router.route(
+    getVirtualModuleIdForClientComponent2(":id"),
+    ({ id }, { command }) => {
+      const extension = getFunctionLibrary(model, id);
+      if (extension) {
+        const componentPath = normalizePath(extension.componentPath);
+        if (command === "build") {
+          return getClientComponentBuildTemplate2(componentPath);
+        }
+        return getClientComponentServeTemplate2(
+          componentPath,
+          Object.keys(extension.options.functions)
+        );
+      }
+      return null;
+    }
+  );
+}
+function getClientComponentBuildTemplate2(componentPath) {
+  return defaultOutdent`
+    export * from '${componentPath}';
+  `;
+}
+function getClientComponentServeTemplate2(componentPath, functionsNames) {
+  return defaultOutdent`
+    import * as originalFunctions from '${componentPath}';
+
+    if (import.meta.hot) {
+      import.meta.hot.data.functionLibrary = {};
+      import.meta.hot.accept('${componentPath}', (newModule) => {
+        if (newModule) {
+          Object.entries(newModule).forEach((name, fn) => {
+            import.meta.hot.data.functionLibrary[name] = fn;
+          })
+          if (newModule.default) {
+            import.meta.hot.data.setComponent?.(newModule?.default);
+          }
+        }
+      });
+    }
+
+    ${functionsNames.map(
+    (name) => defaultOutdent`
+          export const ${name} = (...args) => {
+            const fnToCall = import.meta.hot?.data.functionLibrary['${name}'] ?? originalFunctions['${name}'];
+            return fnToCall(...args);
+          }
+        `
+  ).join("\n")}
+
+    export * from '${componentPath}';
+  `;
+}
+
+// ../astro-function-libraries-extensions/src/vite/configs/build.ts
+init_esm_shims();
+import { join as join5 } from "path";
+
+// ../astro-function-libraries-extensions/src/vite/shared.ts
+init_esm_shims();
+var extensionName2 = "function-libraries";
+var externalDeps2 = [/^@wix\/public-schemas$/];
+
+// ../astro-function-libraries-extensions/src/vite/virtual-modules-plugin.ts
+init_esm_shims();
+function virtualModulesPlugin2({ model }) {
+  const router = createVirtualRouter();
+  registerClientVirtualRoute2({ model, router });
+  return viteVirtualRouterPlugin({
+    name: "wix:function-library-virtual-modules-plugin",
+    router
+  });
+}
+
+// ../astro-function-libraries-extensions/src/vite/configs/build.ts
+function getBuildViteConfigs2({
+  createExtensionViteConfig,
+  model
+}) {
+  const extensions = getSupportedExtensions2(model);
+  return extensions.reduce((acc, extension) => {
+    const {
+      options: { id: extensionId }
+    } = extension;
+    const input = {
+      [getEntryNameForClientComponent2(extensionId)]: getVirtualModuleIdForClientComponent2(extensionId)
+    };
+    acc.push(
+      createExtensionViteConfig({
+        name: join5(extensionName2, "client"),
+        config: {
+          build: {
+            rollupOptions: {
+              external: externalDeps2,
+              input,
+              preserveEntrySignatures: "strict"
+            }
+          },
+          plugins: [virtualModulesPlugin2({ model })]
+        }
+      })
+    );
+    return acc;
+  }, []);
+}
+function getEntryNameForClientComponent2(componentId) {
+  return `component-${componentId}`;
+}
+
+// ../astro-function-libraries-extensions/src/utils/getClientResource.ts
+function getClientResource2({
+  baseUrl,
+  buildOutput,
+  devServer,
+  extension
+}) {
+  if (buildOutput) {
+    return getClientResourceBuild2({ baseUrl, buildOutput, extension });
+  }
+  if (devServer) {
+    return getClientResourceDev2({ baseUrl, devServer, extension });
+  }
+  throw new Error("Unknown error: no build output or vite dev server");
+}
+function getClientResourceBuild2({
+  baseUrl,
+  buildOutput,
+  extension
+}) {
+  const entryName = getEntryNameForClientComponent2(extension.options.id);
+  const chunk = getChunkForEntryName({ buildOutput, entryName });
+  const componentFileName = chunk.fileName;
+  return {
+    url: appendToDevServerUrl(baseUrl, componentFileName)
+  };
+}
+function getClientResourceDev2({
+  baseUrl,
+  devServer,
+  extension
+}) {
+  const moduleId = getVirtualModuleIdForClientComponent2(extension.options.id);
+  return {
+    url: getAssetUrlForModuleId({ baseUrl, devServer, moduleId })
+  };
+}
+
+// ../astro-function-libraries-extensions/src/utils/getResources.ts
+function getResources2(buildContext) {
+  return {
+    client: getClientResource2(buildContext)
+  };
+}
+
+// ../astro-function-libraries-extensions/src/vite/configs/dev.ts
+init_esm_shims();
+
+// ../astro-function-libraries-extensions/src/runtime/index.ts
+init_esm_shims();
+var sdkRuntimePath2 = normalizePath(
+  new URL(
+    "../dependencies/astro-context-providers-extensions/browser-runtime/sdk.js",
+    import.meta.url
+  )
+);
+
+// ../astro-function-libraries-extensions/src/vite/configs/dev.ts
+function getDevViteConfig2({
+  createExtensionViteConfig,
+  model
+}) {
+  const extensionEntries = getSupportedExtensions2(model).map((ext) => [ext.componentPath]).flat();
+  return createExtensionViteConfig({
+    name: extensionName2,
+    config: {
+      optimizeDeps: {
+        entries: [...extensionEntries, sdkRuntimePath2]
+      },
+      plugins: [
+        m({
+          externals: externalDeps2
+        }),
+        virtualModulesPlugin2({ model })
+      ]
+    }
+  });
+}
+
+// ../astro-function-libraries-extensions/src/integration.ts
+var createIntegration2 = () => {
+  let model = null;
+  let customBuildOutput = null;
+  let customDevServer = null;
+  return {
+    name: "@wix/astro/function-libraries",
+    hooks: {
+      "wix:model:setup"({ model: newModel }) {
+        model = newModel;
+      },
+      async "wix:server:start"({
+        createExtensionViteConfig,
+        setupExtensionProxy
+      }) {
+        ok2(model);
+        customDevServer = await createServer2(
+          getDevViteConfig2({ createExtensionViteConfig, model })
+        );
+        await customDevServer.listen();
+        setupExtensionProxy(customDevServer);
+      },
+      async "astro:server:done"() {
+        ok2(customDevServer);
+        await customDevServer.close();
+      },
+      async "wix:build:setup"({ createExtensionViteConfig }) {
+        ok2(model);
+        const extensions = getSupportedExtensions2(model);
+        if (extensions.length === 0) {
+          return;
+        }
+        customBuildOutput = await buildAll(
+          getBuildViteConfigs2({ createExtensionViteConfig, model })
+        );
+      },
+      async "wix:app-manifest:setup"({
+        staticsUrlPlaceholder,
+        updateAppManifest
+      }) {
+        ok2(model);
+        const extensions = getSupportedExtensions2(model);
+        const components = [];
+        for (const extension of extensions) {
+          const buildContext = {
+            baseUrl: staticsUrlPlaceholder,
+            buildOutput: customBuildOutput,
+            devServer: customDevServer,
+            extension
+          };
+          components.push({
+            compId: extension.options.id,
+            compType: "EDITOR_FUNCTION_LIBRARY",
+            compData: {
+              editorFunctionLibrary: merge(cloneDeep(extension.options), {
+                resources: getResources2(buildContext)
+              })
+            }
+          });
+        }
+        updateAppManifest({ components });
+      }
+    }
+  };
+};
+
+// ../astro-function-libraries-extensions/src/builders.ts
+init_esm_shims();
+function functionLibrary(options) {
+  return {
+    type: "FunctionLibrary",
+    options
+  };
+}
+
+// ../astro-function-libraries-extensions/src/index.ts
+init_esm_shims();
+
+export {
+  createIntegration,
+  contextProvider,
+  createIntegration2,
+  functionLibrary
+};
+//# sourceMappingURL=chunk-QHGDEGZS.js.map