@cedarjs/vite 0.0.4

package/dist/cjs/index.js

@@ -0,0 +1,184 @@
+"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 index_exports = {};
+__export(index_exports, {
+  default: () => redwoodPluginVite
+});
+module.exports = __toCommonJS(index_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_plugin_react = __toESM(require("@vitejs/plugin-react"), 1);
+var import_vite = require("vite");
+var import_vite_plugin_node_polyfills = require("vite-plugin-node-polyfills");
+var import_babel_config = require("@cedarjs/babel-config");
+var import_project_config = require("@cedarjs/project-config");
+var import_getMergedConfig = require("./lib/getMergedConfig.js");
+var import_vite_plugin_jsx_loader = require("./plugins/vite-plugin-jsx-loader.js");
+var import_vite_plugin_remove_from_bundle = require("./plugins/vite-plugin-remove-from-bundle.js");
+var import_vite_plugin_swap_apollo_provider = require("./plugins/vite-plugin-swap-apollo-provider.js");
+function redwoodPluginVite() {
+  const rwPaths = (0, import_project_config.getPaths)();
+  const rwConfig = (0, import_project_config.getConfig)();
+  const clientEntryPath = rwPaths.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 = import_path.default.relative(rwPaths.web.src, clientEntryPath);
+  const apiPackageJsonPath = import_path.default.join(rwPaths.api.base, "package.json");
+  const realtimeEnabled = import_fs.default.existsSync(apiPackageJsonPath) && import_fs.default.readFileSync(apiPackageJsonPath, "utf-8").includes("@cedarjs/realtime");
+  const streamingEnabled = rwConfig.experimental.streamingSsr.enabled;
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  const webSideDefaultBabelConfig = (0, import_babel_config.getWebSideDefaultBabelConfig)();
+  const babelConfig = {
+    ...webSideDefaultBabelConfig,
+    // For RSC we don't want to include the routes auto-loader plugin as we
+    // handle that differently in each specific RSC build stage
+    overrides: rscEnabled ? webSideDefaultBabelConfig.overrides.filter((override) => {
+      return !override.plugins?.some((plugin) => {
+        return Array.isArray(plugin) && plugin[2] === "babel-plugin-redwood-routes-auto-loader";
+      });
+    }) : webSideDefaultBabelConfig.overrides
+  };
+  return [
+    // Only include the Buffer polyfill for non-rsc dev, for DevFatalErrorPage
+    // Including the polyfill plugin in any form in RSC breaks
+    !rscEnabled && {
+      ...(0, import_vite_plugin_node_polyfills.nodePolyfills)({
+        include: ["buffer"],
+        globals: {
+          Buffer: true
+        }
+      }),
+      apply: "serve"
+    },
+    {
+      name: "redwood-plugin-vite-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;
+          rwConfig.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;
+        }
+      }
+    },
+    {
+      name: "redwood-plugin-vite",
+      // ---------- Bundle injection ----------
+      // Used by Vite during dev, to inject the entrypoint.
+      transformIndexHtml: {
+        order: "pre",
+        handler: (html) => {
+          if (import_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_fs.default.existsSync(clientEntryPath) && (0, import_vite.normalizePath)(id) === (0, import_vite.normalizePath)(rwPaths.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
+          };
+        }
+      },
+      // ---------- End Bundle injection ----------
+      // @MARK: Using the config hook here let's us modify the config
+      // but returning plugins will **not** work
+      config: (0, import_getMergedConfig.getMergedConfig)(rwConfig, rwPaths)
+    },
+    // We can remove when streaming is stable
+    streamingEnabled && (0, import_vite_plugin_swap_apollo_provider.swapApolloProvider)(),
+    (0, import_vite_plugin_jsx_loader.handleJsAsJsx)(),
+    // Remove the splash-page from the bundle.
+    (0, import_vite_plugin_remove_from_bundle.removeFromBundle)(
+      [
+        {
+          id: /@cedarjs\/router\/dist\/splash-page/
+        }
+      ],
+      ["SplashPage"]
+    ),
+    !realtimeEnabled && (0, import_vite_plugin_remove_from_bundle.removeFromBundle)([
+      {
+        id: /@cedarjs\/web\/dist\/apollo\/sseLink/
+      }
+    ]),
+    (0, import_plugin_react.default)({
+      babel: babelConfig
+    })
+  ];
+}

package/dist/cjs/lib/StatusError.js

@@ -0,0 +1,36 @@
+"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 StatusError_exports = {};
+__export(StatusError_exports, {
+  StatusError: () => StatusError,
+  hasStatusCode: () => hasStatusCode
+});
+module.exports = __toCommonJS(StatusError_exports);
+class StatusError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+}
+const hasStatusCode = (x) => typeof x?.statusCode === "number";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StatusError,
+  hasStatusCode
+});

package/dist/cjs/lib/entries.js

@@ -0,0 +1,53 @@
+"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 entries_exports = {};
+__export(entries_exports, {
+  getEntries: () => getEntries,
+  getEntriesFromDist: () => getEntriesFromDist
+});
+module.exports = __toCommonJS(entries_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_dist = require("@cedarjs/structure/dist/index.js");
+var import_utils = require("../utils.js");
+function getEntries() {
+  const entries = {};
+  const rwProject = (0, import_dist.getProject)((0, import_project_config.getPaths)().base);
+  const routes = rwProject.getRouter().routes;
+  const pages = routes.map((route) => route.page);
+  for (const page of pages) {
+    entries[page.constName] = (0, import_project_config.ensurePosixPath)((0, import_project_config.importStatementPath)(page.path));
+  }
+  const serverEntry = (0, import_project_config.getPaths)().web.entryServer;
+  if (!serverEntry) {
+    throw new Error("Server Entry file not found");
+  }
+  entries["__rwjs__ServerEntry"] = serverEntry;
+  entries["__rwjs__Routes"] = (0, import_project_config.getPaths)().web.routes;
+  return entries;
+}
+async function getEntriesFromDist() {
+  const entriesDist = (0, import_project_config.getPaths)().web.distRscEntries;
+  const { serverEntries } = await import((0, import_utils.makeFilePath)(entriesDist));
+  return serverEntries;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEntries,
+  getEntriesFromDist
+});

package/dist/cjs/lib/envVarDefinitions.js

@@ -0,0 +1,87 @@
+"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 envVarDefinitions_exports = {};
+__export(envVarDefinitions_exports, {
+  getEnvVarDefinitions: () => getEnvVarDefinitions
+});
+module.exports = __toCommonJS(envVarDefinitions_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function getEnvVarDefinitions() {
+  const rwConfig = (0, import_project_config.getConfig)();
+  const rwPaths = (0, import_project_config.getPaths)();
+  return {
+    RWJS_ENV: {
+      RWJS_API_GRAPHQL_URL: rwConfig.web.apiGraphQLUrl ?? rwConfig.web.apiUrl + "/graphql",
+      RWJS_API_URL: rwConfig.web.apiUrl,
+      __REDWOOD__APP_TITLE: rwConfig.web.title || import_node_path.default.basename(rwPaths.base),
+      RWJS_EXP_STREAMING_SSR: rwConfig.experimental.streamingSsr?.enabled,
+      RWJS_EXP_RSC: rwConfig.experimental?.rsc?.enabled
+    },
+    RWJS_DEBUG_ENV: {
+      RWJS_SRC_ROOT: rwPaths.web.src,
+      REDWOOD_ENV_EDITOR: JSON.stringify(process.env.REDWOOD_ENV_EDITOR)
+    },
+    // Vite can automatically expose environment variables, but we
+    // disable that in `buildFeServer.ts` by setting `envFile: false`
+    // because we want to use our own logic for loading .env,
+    // .env.defaults, etc
+    // The two object spreads below will expose all environment
+    // variables listed in redwood.toml and all environment variables
+    // prefixed with REDWOOD_ENV_
+    ...Object.fromEntries(
+      rwConfig.web.includeEnvironmentVariables.flatMap((envName) => [
+        // TODO: Figure out if/why we need to disable eslint here, when we
+        // didn't have to before, when this code was in index.ts
+        // Re-enable if possible
+        // eslint-disable-next-line
+        [`import.meta.env.${envName}`, JSON.stringify(process.env[envName])],
+        // TODO: Figure out if/why we need to disable eslint here, when we
+        // didn't have to before, when this code was in index.ts
+        // Re-enable if possible
+        // eslint-disable-next-line
+        [`process.env.${envName}`, JSON.stringify(process.env[envName])]
+      ])
+    ),
+    ...Object.entries(process.env).reduce(
+      (acc, [key, value]) => {
+        if (key.startsWith("REDWOOD_ENV_")) {
+          acc[`import.meta.env.${key}`] = JSON.stringify(value);
+          acc[`process.env.${key}`] = JSON.stringify(value);
+        }
+        return acc;
+      },
+      {}
+    )
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEnvVarDefinitions
+});

package/dist/cjs/lib/getMergedConfig.js

@@ -0,0 +1,187 @@
+"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 getMergedConfig_exports = {};
+__export(getMergedConfig_exports, {
+  getMergedConfig: () => getMergedConfig
+});
+module.exports = __toCommonJS(getMergedConfig_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_vite = require("vite");
+var import_project_config = require("@cedarjs/project-config");
+var import_envVarDefinitions = require("./envVarDefinitions.js");
+function getMergedConfig(rwConfig, rwPaths) {
+  return (userConfig, env) => {
+    let apiHost = process.env.REDWOOD_API_HOST;
+    apiHost ??= rwConfig.api.host;
+    apiHost ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "[::]";
+    const streamingSsrEnabled = rwConfig.experimental.streamingSsr?.enabled;
+    const rscEnabled = rwConfig.experimental.rsc?.enabled;
+    let apiPort;
+    if (process.env.REDWOOD_API_PORT) {
+      apiPort = parseInt(process.env.REDWOOD_API_PORT);
+    } else {
+      apiPort = rwConfig.api.port;
+    }
+    const defaultRwViteConfig = {
+      root: rwPaths.web.src,
+      // @MARK: when we have these aliases, the warnings from the FE server go
+      // away BUT, if you have imports like this:
+      // ```
+      // import RandomNumberServerCell from
+      //   'src/components/RandomNumberServerCell/RandomNumberServerCell'
+      // ```
+      // they start failing (can't have the double
+      // `/RandomNumberServerCell/RandomNumberServerCell` at the end)
+      //
+      // resolve: {
+      //   alias: [
+      //     {
+      //       find: 'src',
+      //       replacement: rwPaths.web.src,
+      //     },
+      //   ],
+      // },
+      envPrefix: "REDWOOD_ENV_",
+      publicDir: import_node_path.default.join(rwPaths.web.base, "public"),
+      define: (0, import_envVarDefinitions.getEnvVarDefinitions)(),
+      css: {
+        // @NOTE config path is relative to where vite.config.js is if you use
+        // a relative path
+        postcss: rwPaths.web.config
+      },
+      server: {
+        open: rwConfig.browser.open,
+        port: rwConfig.web.port,
+        host: true,
+        // Listen to all hosts
+        proxy: {
+          [rwConfig.web.apiUrl]: {
+            target: `http://${apiHost}:${apiPort}`,
+            changeOrigin: false,
+            // Remove the `.redwood/functions` part, but leave the `/graphql`
+            rewrite: (path2) => path2.replace(rwConfig.web.apiUrl, ""),
+            configure: (proxy) => {
+              let waitingForApiServer = true;
+              setTimeout(() => {
+                waitingForApiServer = false;
+              }, 2500);
+              proxy.on("error", (err, _req, res) => {
+                if (waitingForApiServer && err.message.includes("ECONNREFUSED")) {
+                  err.stack = "\u231B API Server launching, please refresh your page...";
+                }
+                const msg = {
+                  errors: [
+                    {
+                      message: "The RedwoodJS API server is not available or is currently reloading. Please refresh."
+                    }
+                  ]
+                };
+                res.writeHead(203, {
+                  "Content-Type": "application/json",
+                  "Cache-Control": "no-cache"
+                });
+                res.write(JSON.stringify(msg));
+                res.end();
+              });
+            }
+          }
+        }
+      },
+      build: {
+        // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+        minify: false,
+        // NOTE this gets overridden when build gets called anyway!
+        outDir: streamingSsrEnabled || rscEnabled ? rwPaths.web.distBrowser : rwPaths.web.dist,
+        emptyOutDir: true,
+        manifest: !env.isSsrBuild ? "client-build-manifest.json" : void 0,
+        // Note that sourcemap can be boolean or 'inline'
+        sourcemap: !env.isSsrBuild && rwConfig.web.sourceMap,
+        rollupOptions: {
+          input: getRollupInput(!!env.isSsrBuild)
+        }
+      },
+      // @MARK: do not set buildSsrCjsExternalHeuristics here
+      // because rsc builds want false, client and server build wants true
+      optimizeDeps: {
+        esbuildOptions: {
+          // @MARK this is because JS projects in Redwood don't have .jsx
+          // extensions
+          loader: {
+            ".js": "jsx"
+          },
+          // Node.js global to browser globalThis
+          // @MARK unsure why we need this, but required for DevFatalErrorPage
+          // at least
+          define: {
+            global: "globalThis"
+          }
+        }
+      }
+    };
+    return (0, import_vite.mergeConfig)(defaultRwViteConfig, userConfig);
+  };
+}
+function getRollupInput(ssr) {
+  const rwConfig = (0, import_project_config.getConfig)();
+  const rwPaths = (0, import_project_config.getPaths)();
+  if (!rwPaths.web.entryClient) {
+    throw new Error("entryClient not defined");
+  }
+  const streamingEnabled = rwConfig.experimental?.streamingSsr?.enabled;
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  if (streamingEnabled) {
+    if (ssr) {
+      if (!rwPaths.web.entryServer) {
+        throw new Error("entryServer not defined");
+      }
+      if (rscEnabled) {
+        return {
+          Document: rwPaths.web.document,
+          "entry.server": rwPaths.web.entryServer
+        };
+      }
+      return {
+        // NOTE: We're building the server entry *without* the react-server
+        // condition when we include it here. This works when only SSR is
+        // enabled, but not when RSC + SSR are both enabled
+        // For RSC we have this configured in rscBuildForServer.ts to get a
+        // build with the proper resolution conditions set.
+        "entry.server": rwPaths.web.entryServer,
+        // We need the document for React's fallback
+        Document: rwPaths.web.document
+      };
+    }
+    return rwPaths.web.entryClient;
+  }
+  return rwPaths.web.html;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMergedConfig
+});

package/dist/cjs/lib/onWarn.js

@@ -0,0 +1,36 @@
+"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 onWarn_exports = {};
+__export(onWarn_exports, {
+  onWarn: () => onWarn
+});
+module.exports = __toCommonJS(onWarn_exports);
+function onWarn(warning, defaultHandler) {
+  const fileName = warning.loc?.file;
+  if (warning.code === "MODULE_LEVEL_DIRECTIVE" && /"use (client|server)"/.test(warning.message)) {
+    return;
+  } else if (warning.code === "SOURCEMAP_ERROR" && (fileName?.endsWith(".tsx") || fileName?.endsWith(".ts")) && warning.loc?.column === 0 && warning.loc?.line === 1) {
+    return;
+  }
+  defaultHandler(warning);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onWarn
+});