@cedarjs/vite 5.0.4-next.167 → 5.0.4

package/dist/cjs/plugins/vite-plugin-cedar-context-wrapping.js

@@ -0,0 +1,95 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_context_wrapping_exports = {};
+__export(vite_plugin_cedar_context_wrapping_exports, {
+  applyContextWrapping: () => applyContextWrapping,
+  cedarContextWrappingPlugin: () => cedarContextWrappingPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_context_wrapping_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_vite = require("vite");
+var import_project_config = require("@cedarjs/project-config");
+function cedarContextWrappingPlugin({
+  projectIsEsm = false
+} = {}) {
+  return {
+    name: "cedar-context-wrapping",
+    transform(code, id) {
+      let paths;
+      try {
+        paths = (0, import_project_config.getPaths)();
+      } catch {
+        return null;
+      }
+      const functionsDir = (0, import_vite.normalizePath)(import_node_path.default.join(paths.api.src, "functions"));
+      if (!(0, import_vite.normalizePath)(id).startsWith(functionsDir + "/")) {
+        return null;
+      }
+      const wrapped = applyContextWrapping(code, { projectIsEsm });
+      return wrapped ? { code: wrapped, map: null } : null;
+    }
+  };
+}
+function applyContextWrapping(code, { projectIsEsm = false } = {}) {
+  const handlerRe = /^export\s+(?:const|let|var)\s+handler(?:[^=]|=>)*?=(?![>=])/m;
+  const handlerMatch = handlerRe.exec(code);
+  if (!handlerMatch) {
+    return null;
+  }
+  const afterEquals = code.slice(handlerMatch.index + handlerMatch[0].length).trimStart();
+  const isAsync = /^async(?:\s*[\(\*]|\s+function)/.test(afterEquals);
+  const storePath = projectIsEsm ? "@cedarjs/context/dist/store.js" : "@cedarjs/context/dist/store";
+  const importStatement = `import { getAsyncStoreInstance as __rw_getAsyncStoreInstance } from '${storePath}'
+`;
+  const handlerStart = handlerMatch.index;
+  const before = code.slice(0, handlerStart);
+  const after = code.slice(handlerStart);
+  const renamed = after.replace(handlerRe, "const __rw_handler =");
+  const wrappedHandler = `
+export const handler = ${isAsync ? "async " : ""}(__rw_event, __rw__context) => {
+  // The store will be undefined if no context isolation has been performed yet
+  const __rw_contextStore = __rw_getAsyncStoreInstance().getStore()
+  if (__rw_contextStore === undefined) {
+    return __rw_getAsyncStoreInstance().run(
+      new Map(),
+      __rw_handler,
+      __rw_event,
+      __rw__context
+    )
+  }
+  return __rw_handler(__rw_event, __rw__context)
+}
+`;
+  return before + importStatement + renamed + wrappedHandler;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyContextWrapping,
+  cedarContextWrappingPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-entry-injection.js

@@ -0,0 +1,107 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_entry_injection_exports = {};
+__export(vite_plugin_cedar_entry_injection_exports, {
+  cedarEntryInjectionPlugin: () => cedarEntryInjectionPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_entry_injection_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_vite = require("vite");
+var import_project_config = require("@cedarjs/project-config");
+function cedarEntryInjectionPlugin() {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const clientEntryPath = cedarPaths.web.entryClient;
+  if (!clientEntryPath) {
+    throw new Error(
+      "Vite client entry point not found. Please check that your project has an entry.client.{jsx,tsx} file in the web/src directory."
+    );
+  }
+  const relativeEntryPath = (0, import_vite.normalizePath)(
+    import_node_path.default.relative(cedarPaths.web.base, clientEntryPath)
+  );
+  return {
+    name: "cedar-entry-injection",
+    // Vite's dependency optimizer and dev server resolve the script tag
+    // src="/src/entry.client.{tsx,jsx}" as an absolute filesystem path
+    // (/src/entry.client.tsx) instead of relative to the Vite root.
+    // This hook maps it to the real file path so Vite can find it.
+    resolveId(id) {
+      if (id === "/" + relativeEntryPath) {
+        return clientEntryPath;
+      }
+      return null;
+    },
+    // ---------- Bundle injection ----------
+    // Used by Vite during dev, to inject the entrypoint.
+    transformIndexHtml: {
+      order: "pre",
+      handler: (html, ctx) => {
+        if (!ctx.filename || (0, import_vite.normalizePath)(ctx.filename) !== (0, import_vite.normalizePath)(cedarPaths.web.html)) {
+          return html;
+        }
+        if (import_node_fs.default.existsSync(clientEntryPath)) {
+          return html.replace(
+            "</head>",
+            // @NOTE the slash in front, for windows compatibility and for
+            // pages in subdirectories
+            `<script type="module" src="/${relativeEntryPath}"></script>
+      </head>`
+          );
+        } else {
+          return html;
+        }
+      }
+    },
+    // Used by rollup during build to inject the entrypoint
+    // but note index.html does not come through as an id during dev
+    transform: (code, id) => {
+      if (import_node_fs.default.existsSync(clientEntryPath) && (0, import_vite.normalizePath)(id) === (0, import_vite.normalizePath)(cedarPaths.web.html)) {
+        return {
+          code: code.replace(
+            "</head>",
+            `<script type="module" src="/${relativeEntryPath}"></script>
+      </head>`
+          ),
+          map: null
+        };
+      } else {
+        return {
+          code,
+          map: null
+          // Returning null here preserves the original sourcemap
+        };
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarEntryInjectionPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-html-env.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_html_env_exports = {};
+__export(vite_plugin_cedar_html_env_exports, {
+  cedarHtmlEnvPlugin: () => cedarHtmlEnvPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_html_env_exports);
+var import_project_config = require("@cedarjs/project-config");
+function cedarHtmlEnvPlugin() {
+  return {
+    name: "cedar-html-env",
+    // Vite can support replacing environment variables in index.html but
+    // there are currently two issues with that:
+    // 1. It requires the environment variables to be exposed on
+    //    `import.meta.env`, but we expose them on `process.env` in Redwood.
+    // 2. There's an open issue on Vite where it adds extra quotes around
+    //    the replaced values, which breaks trying to use environment
+    //    variables in src attributes for example.
+    // Until those issues are resolved, we'll do the replacement ourselves
+    // instead using transformIndexHtml. Doing it this was was also the
+    // recommended way until Vite added built-in support for it.
+    //
+    // Extra quotes issue: https://github.com/vitejs/vite/issues/13424
+    // transformIndexHtml being the recommended way:
+    //   https://github.com/vitejs/vite/issues/3105#issuecomment-1059975023
+    transformIndexHtml: {
+      // Setting order: 'pre' so that it runs before the built-in
+      // html env replacement.
+      order: "pre",
+      handler: (html) => {
+        let newHtml = html;
+        (0, import_project_config.getConfig)().web.includeEnvironmentVariables.map((envName) => {
+          newHtml = newHtml.replaceAll(
+            `%${envName}%`,
+            process.env[envName] || ""
+          );
+        });
+        Object.entries(process.env).forEach(([envName, value]) => {
+          if (envName.startsWith("REDWOOD_ENV_")) {
+            newHtml = newHtml.replaceAll(`%${envName}%`, value || "");
+          }
+        });
+        return newHtml;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarHtmlEnvPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-import-dir.js

@@ -0,0 +1,118 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_import_dir_exports = {};
+__export(vite_plugin_cedar_import_dir_exports, {
+  cedarImportDirPlugin: () => cedarImportDirPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_import_dir_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_napi = require("@ast-grep/napi");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function cedarImportDirPlugin() {
+  return {
+    name: "vite-plugin-cedar-import-dir",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!code.includes("/**/")) {
+        return null;
+      }
+      const ext = import_node_path.default.extname(id);
+      const language = ext === ".ts" || ext === ".tsx" ? import_napi.Lang.TypeScript : import_napi.Lang.JavaScript;
+      let ast;
+      try {
+        ast = (0, import_napi.parse)(language, code);
+      } catch (error) {
+        console.warn("Failed to parse file:", id);
+        console.warn(error);
+        return null;
+      }
+      const root = ast.root();
+      let hasTransformations = false;
+      const edits = [];
+      const globImports = root.findAll({
+        rule: {
+          pattern: "import $DEFAULT_IMPORT from $SOURCE"
+        }
+      });
+      for (const importNode of globImports) {
+        const sourceNode = importNode.getMatch("SOURCE");
+        const defaultImportNode = importNode.getMatch("DEFAULT_IMPORT");
+        if (!sourceNode || !defaultImportNode) {
+          continue;
+        }
+        const sourceValue = sourceNode.text().slice(1, -1);
+        if (!sourceValue.includes("/**/")) {
+          continue;
+        }
+        hasTransformations = true;
+        const importName = defaultImportNode.text();
+        const importGlob = (0, import_project_config.importStatementPath)(sourceValue);
+        const cwd = importGlob.startsWith("src/") ? (0, import_project_config.getPaths)().api.base : import_node_path.default.dirname(id);
+        try {
+          const dirFiles = import_fast_glob.default.sync(importGlob, { cwd }).filter(
+            (n) => !n.includes(".test.") && !n.includes(".scenarios.") && !n.includes(".d.ts")
+          );
+          const staticGlob = importGlob.split("*")[0];
+          const filePathToVarName = (filePath) => {
+            return filePath.replace(staticGlob, "").replace(/\.(js|ts)$/, "").replace(/[^a-zA-Z0-9]/g, "_");
+          };
+          let replacement = `let ${importName} = {};
+`;
+          for (const filePath of dirFiles) {
+            const { dir: fileDir, name: fileName } = import_node_path.default.parse(filePath);
+            const fileImportPath = fileDir + "/" + fileName;
+            const filePathVarName = filePathToVarName(filePath);
+            const namespaceImportName = `${importName}_${filePathVarName}`;
+            replacement += `import * as ${namespaceImportName} from '${fileImportPath}';
+`;
+            replacement += `${importName}.${filePathVarName} = ${namespaceImportName};
+`;
+          }
+          edits.push(importNode.replace(replacement.trim()));
+        } catch (error) {
+          console.warn(`Failed to process glob import: ${sourceValue}`, error);
+        }
+      }
+      if (hasTransformations && edits.length > 0) {
+        const transformedCode = root.commitEdits(edits);
+        return {
+          code: transformedCode,
+          map: null
+          // For simplicity, not generating source maps
+        };
+      }
+      return null;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarImportDirPlugin
+});

package/dist/cjs/plugins/vite-plugin-cedar-node-polyfills.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_node_polyfills_exports = {};
+__export(vite_plugin_cedar_node_polyfills_exports, {
+  cedarNodePolyfills: () => cedarNodePolyfills
+});
+module.exports = __toCommonJS(vite_plugin_cedar_node_polyfills_exports);
+var import_vite_plugin_node_polyfills = require("vite-plugin-node-polyfills");
+var import_project_config = require("@cedarjs/project-config");
+function cedarNodePolyfills() {
+  if ((0, import_project_config.getConfig)().experimental?.rsc?.enabled) {
+    return void 0;
+  }
+  return {
+    ...(0, import_vite_plugin_node_polyfills.nodePolyfills)({
+      include: ["buffer"],
+      globals: {
+        Buffer: true
+      }
+    }),
+    apply: "serve"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarNodePolyfills
+});

package/dist/cjs/plugins/vite-plugin-cedar-remove-dev-fatal-error-page.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_remove_dev_fatal_error_page_exports = {};
+__export(vite_plugin_cedar_remove_dev_fatal_error_page_exports, {
+  cedarRemoveDevFatalErrorPage: () => cedarRemoveDevFatalErrorPage
+});
+module.exports = __toCommonJS(vite_plugin_cedar_remove_dev_fatal_error_page_exports);
+const DEV_FATAL_ERROR_PAGE_MODULE = "@cedarjs/web/dist/components/DevFatalErrorPage";
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const ESCAPED_MODULE = escapeRegExp(DEV_FATAL_ERROR_PAGE_MODULE);
+const IMPORT_PATTERN = new RegExp(
+  `import\\s*\\{[^}]*\\bDevFatalErrorPage\\b[^}]*\\}\\s*from\\s*['"]${ESCAPED_MODULE}['"]`
+);
+function cedarRemoveDevFatalErrorPage() {
+  let config;
+  return {
+    name: "cedar-remove-dev-fatal-error-page",
+    apply: "build",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    transform(code) {
+      if (config.command === "build" && config.mode === "development") {
+        return null;
+      }
+      if (!code.includes(DEV_FATAL_ERROR_PAGE_MODULE)) {
+        return null;
+      }
+      const newCode = code.replace(
+        IMPORT_PATTERN,
+        "const DevFatalErrorPage = undefined"
+      );
+      if (newCode === code) {
+        return null;
+      }
+      return { code: newCode, map: null };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarRemoveDevFatalErrorPage
+});

package/dist/cjs/plugins/vite-plugin-cedar-remove-from-bundle.js

@@ -0,0 +1,76 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_cedar_remove_from_bundle_exports = {};
+__export(vite_plugin_cedar_remove_from_bundle_exports, {
+  cedarRemoveFromBundle: () => cedarRemoveFromBundle,
+  excludeOnMatch: () => excludeOnMatch
+});
+module.exports = __toCommonJS(vite_plugin_cedar_remove_from_bundle_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function cedarRemoveFromBundle() {
+  const apiPackageJsonPath = import_node_path.default.join((0, import_project_config.getPaths)().api.base, "package.json");
+  const realtimeEnabled = import_node_fs.default.existsSync(apiPackageJsonPath) && import_node_fs.default.readFileSync(apiPackageJsonPath, "utf-8").includes("@cedarjs/realtime");
+  const modulesToExclude = [
+    {
+      id: /@cedarjs\/router\/dist\/splash-page/,
+      exportNames: ["SplashPage"]
+    }
+  ];
+  if (!realtimeEnabled) {
+    modulesToExclude.push({
+      id: /@cedarjs\/web\/dist\/apollo\/sseLink/
+    });
+  }
+  return {
+    name: "remove-from-bundle",
+    apply: "build",
+    load: (id) => {
+      return excludeOnMatch(modulesToExclude, id);
+    }
+  };
+}
+function generateModuleWithExports(exportNames) {
+  return {
+    code: `export default {}; ${exportNames.map((name) => `export const ${name} = undefined;`).join("\n")}`
+  };
+}
+function excludeOnMatch(modulesToExclude, id) {
+  const moduleToExclude = modulesToExclude.find((module2) => module2.id.test(id));
+  if (moduleToExclude) {
+    return generateModuleWithExports(moduleToExclude.exportNames || []);
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarRemoveFromBundle,
+  excludeOnMatch
+});