@cedarjs/vite 5.0.4-next.167 → 5.0.4

package/dist/cjs/cedar-unified-dev.js

@@ -0,0 +1,310 @@
+"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 cedar_unified_dev_exports = {};
+__export(cedar_unified_dev_exports, {
+  openDebugger: () => openDebugger,
+  parseCliArgs: () => parseCliArgs,
+  startUnifiedDevServer: () => startUnifiedDevServer
+});
+module.exports = __toCommonJS(cedar_unified_dev_exports);
+var import_server = require("@whatwg-node/server");
+var import_vite = require("vite");
+var import_yargs_parser = __toESM(require("yargs-parser"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_apiDevMiddleware = require("./apiDevMiddleware.js");
+function isViteInternalRequest(url) {
+  const pathname = url.split("?")[0];
+  return pathname.startsWith("/@") || pathname.startsWith("/__vite") || pathname.startsWith("/__hmr");
+}
+function isApiRequest(url, apiUrl, apiGqlUrl) {
+  return url === apiUrl || url.startsWith(apiUrl + "/") || url.startsWith(apiUrl + "?") || url === apiGqlUrl || url.startsWith(apiGqlUrl + "/") || url.startsWith(apiGqlUrl + "?");
+}
+function parseCliArgs(argv = process.argv) {
+  const {
+    force: forceOptimize,
+    debug,
+    port: portArg,
+    apiPort: _apiPortArg,
+    "debug-port": debugPort,
+    "debug-brk": debugBrk,
+    _: _positional,
+    ...serverArgs
+  } = (0, import_yargs_parser.default)(argv.slice(2), {
+    boolean: [
+      "https",
+      "open",
+      "strictPort",
+      "force",
+      "cors",
+      "debug",
+      "debug-brk"
+    ],
+    number: ["port", "apiPort", "debug-port"]
+  });
+  return { forceOptimize, debug, portArg, debugPort, debugBrk, serverArgs };
+}
+async function clearPendingPause() {
+  const inspector = await import("node:inspector");
+  const s = new inspector.Session();
+  try {
+    s.connect();
+    await new Promise((resolve, reject) => {
+      s.post("Debugger.enable", (err) => err ? reject(err) : resolve());
+    });
+    await new Promise((resolve) => {
+      let done = false;
+      s.once("Debugger.paused", () => {
+        s.post("Debugger.resume", () => {
+          done = true;
+          resolve();
+        });
+      });
+      s.post("Runtime.evaluate", { expression: "1" }, () => {
+        if (!done) {
+          resolve();
+        }
+      });
+    });
+  } catch {
+  } finally {
+    s.disconnect();
+  }
+}
+async function openDebugger(port, waitForDebugger = false) {
+  const inspector = await import("node:inspector");
+  inspector.open(port, "127.0.0.1");
+  if (waitForDebugger) {
+    inspector.waitForDebugger();
+    const session = new inspector.Session();
+    session.connect();
+    await session.post("Debugger.enable");
+    let resumedResolve;
+    const resumedPromise = new Promise((resolve) => {
+      resumedResolve = resolve;
+    });
+    const onSessionDead = () => {
+      if (paused) {
+        tryResume();
+      } else {
+        clearPendingPause().then(
+          () => resumedResolve?.(),
+          () => resumedResolve?.()
+        );
+      }
+    };
+    session.once("error", onSessionDead);
+    session.once("Inspector.detached", onSessionDead);
+    let paused = false;
+    session.once("Debugger.paused", () => {
+      paused = true;
+      tryResume();
+    });
+    session.once("Debugger.resumed", () => {
+      resumedResolve?.();
+    });
+    const FIVE_MINUTES_MS = 5 * 60 * 1e3;
+    const timeout = setTimeout(() => {
+      if (paused) {
+        tryResume();
+      } else {
+        resumedResolve?.();
+      }
+    }, FIVE_MINUTES_MS);
+    let hasTriedResume = false;
+    const tryResume = () => {
+      if (hasTriedResume) {
+        return;
+      }
+      if (!paused) {
+        return;
+      }
+      hasTriedResume = true;
+      (async () => {
+        for (let attempt = 0; attempt < 3; attempt++) {
+          const s = attempt === 0 ? session : new inspector.Session();
+          if (attempt > 0) {
+            try {
+              s.connect();
+              await new Promise((resolve, reject) => {
+                s.post(
+                  "Debugger.enable",
+                  (err) => err ? reject(err) : resolve()
+                );
+              });
+            } catch {
+              continue;
+            }
+          }
+          const ok = await new Promise((resolve) => {
+            s.post("Debugger.resume", (err) => resolve(!err));
+          });
+          if (attempt > 0) {
+            s.disconnect();
+          }
+          if (ok) {
+            resumedResolve?.();
+            return;
+          }
+        }
+        console.warn(
+          "[cedar-unified-dev] Failed to clear debugger pause after external debugger disconnect.  API functions may pause on next execution."
+        );
+        resumedResolve?.();
+      })();
+    };
+    void new Promise((resolve, reject) => {
+      session.post("Debugger.pause", (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    }).catch(() => {
+      resumedResolve?.();
+    });
+    void new Promise((resolve, reject) => {
+      session.post("Runtime.evaluate", { expression: "1" }, (err) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    }).catch(() => {
+      clearPendingPause().then(
+        () => resumedResolve?.(),
+        () => resumedResolve?.()
+      );
+    });
+    await resumedPromise;
+    clearTimeout(timeout);
+  }
+}
+async function startUnifiedDevServer() {
+  process.env.__CEDAR_UNIFIED_DEV = "true";
+  const rwPaths = (0, import_project_config.getPaths)();
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const configFile = rwPaths.web.viteConfig;
+  if (!configFile) {
+    throw new Error("Could not locate your web/vite.config.{js,ts} file");
+  }
+  const { forceOptimize, debug, portArg, debugPort, debugBrk, serverArgs } = parseCliArgs();
+  if (debugPort !== void 0) {
+    await openDebugger(debugPort, debugBrk);
+  }
+  const webPort = portArg ?? cedarConfig.web.port ?? 8910;
+  const { close: closeApi, handler: apiHandler } = await (0, import_apiDevMiddleware.startApiDevMiddleware)();
+  const apiAdapter = (0, import_server.createServerAdapter)(apiHandler);
+  const devServer = await (0, import_vite.createServer)({
+    configFile,
+    // env file is handled by Cedar's plugins
+    envFile: false,
+    optimizeDeps: {
+      // This is the only value that isn't a server option
+      force: forceOptimize
+    },
+    server: {
+      port: webPort,
+      ...serverArgs
+    },
+    logLevel: debug ? "info" : void 0,
+    plugins: [
+      {
+        name: "cedar-api-middleware",
+        apply: "serve",
+        configureServer(server) {
+          const apiUrl = cedarConfig.web.apiUrl.replace(/\/$/, "");
+          const apiGqlUrl = cedarConfig.web.apiGraphQLUrl ?? apiUrl + "/graphql";
+          server.middlewares.use(
+            async (req, res, next) => {
+              const url = req.url ?? "/";
+              if (isViteInternalRequest(url)) {
+                return next();
+              }
+              if (!isApiRequest(url, apiUrl, apiGqlUrl)) {
+                return next();
+              }
+              try {
+                await apiAdapter(req, res);
+              } catch (err) {
+                console.error(
+                  "[cedar-api-middleware] Error handling API request:",
+                  err
+                );
+                if (!res.headersSent) {
+                  res.writeHead(500, { "Content-Type": "application/json" });
+                }
+                res.end(
+                  JSON.stringify(
+                    {
+                      errors: [
+                        {
+                          message: err instanceof Error ? err.message : "Internal Server Error"
+                        }
+                      ]
+                    },
+                    null,
+                    2
+                  )
+                );
+              }
+            }
+          );
+        }
+      }
+    ]
+  });
+  await devServer.listen();
+  process.stdin.on("data", async (data) => {
+    const str = data.toString().trim().toLowerCase();
+    if (str === "rs" || str === "restart") {
+      await devServer.restart(true);
+    }
+  });
+  devServer.printUrls();
+  if (debug) {
+    console.log("~~~ Vite Server Config ~~~");
+    console.log(JSON.stringify(devServer.config, null, 2));
+    console.log("~~~~~~~~~~~~~~~~~~~~~~~~~~");
+  }
+  const shutdown = async () => {
+    await devServer.close();
+    await closeApi();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDebugger,
+  parseCliArgs,
+  startUnifiedDevServer
+});

package/dist/cjs/client.d.ts

@@ -0,0 +1 @@
+export type * from "../client.d.ts"

package/dist/cjs/clientSsr.d.ts

@@ -0,0 +1 @@
+export type * from "../clientSsr.d.ts"

package/dist/cjs/devFeServer.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+"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 __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 import_server = require("@whatwg-node/server");
+var import_express = __toESM(require("express"), 1);
+var import_vite = require("vite");
+var import_vite_plugin_cjs_interop = require("vite-plugin-cjs-interop");
+var import_routes = require("@cedarjs/internal/dist/routes.js");
+var import_project_config = require("@cedarjs/project-config");
+var import_server_store = require("@cedarjs/server-store");
+var import_registerFwGlobalsAndShims = require("./lib/registerFwGlobalsAndShims.js");
+var import_invokeMiddleware = require("./middleware/invokeMiddleware.js");
+var import_register = require("./middleware/register.js");
+var import_vite_plugin_rsc_routes_auto_loader = require("./plugins/vite-plugin-rsc-routes-auto-loader.js");
+var import_collectCss = require("./streaming/collectCss.js");
+var import_createReactStreamingHandler = require("./streaming/createReactStreamingHandler.js");
+var import_utils = require("./utils.js");
+globalThis.__REDWOOD__PRERENDER_PAGES = {};
+async function createServer() {
+  (0, import_utils.ensureProcessDirWeb)();
+  (0, import_registerFwGlobalsAndShims.registerFwGlobalsAndShims)();
+  const app = (0, import_express.default)();
+  const rwPaths = (0, import_project_config.getPaths)();
+  const rscEnabled = (0, import_project_config.getConfig)().experimental.rsc?.enabled ?? false;
+  const serverStorage = (0, import_server_store.createServerStorage)();
+  app.use("*", (req, _res, next) => {
+    const fullUrl = (0, import_utils.getFullUrl)(req, rscEnabled);
+    const perReqStore = (0, import_server_store.createPerRequestMap)({
+      // Convert express headers to fetch header
+      headers: (0, import_utils.convertExpressHeaders)(req.headersDistinct),
+      fullUrl
+    });
+    serverStorage.run(perReqStore, next);
+  });
+  if (!rwPaths.web.entryServer || !rwPaths.web.entryClient) {
+    throw new Error(
+      "Vite entry points not found. Please check that your project has an entry.client.{jsx,tsx} and entry.server.{jsx,tsx} file in the web/src directory."
+    );
+  }
+  if (!rwPaths.web.viteConfig) {
+    throw new Error(
+      "Vite config not found. Please set up Vite before running the dev server."
+    );
+  }
+  const vite = await (0, import_vite.createServer)({
+    configFile: rwPaths.web.viteConfig,
+    plugins: [
+      (0, import_vite_plugin_cjs_interop.cjsInterop)({
+        dependencies: [
+          // Skip ESM modules: rwjs/auth, rwjs/web, rwjs/auth-*-middleware, rwjs/router
+          "@cedarjs/forms",
+          "@cedarjs/prerender/*",
+          "@cedarjs/auth-*-api",
+          // Add more to the pattern below as they're converted to dual ESM/CJS
+          // modules
+          // '@cedarjs/auth-!(dbauth|auth0|clerk)-web',
+          "@cedarjs/auth-!(dbauth)-web"
+        ]
+      }),
+      rscEnabled && (0, import_vite_plugin_rsc_routes_auto_loader.rscRoutesAutoLoader)()
+    ],
+    server: { middlewareMode: true },
+    logLevel: "info",
+    clearScreen: false,
+    appType: "custom"
+  });
+  const handleWithMiddleware = (route) => {
+    return (0, import_server.createServerAdapter)(async (req) => {
+      const middlewareRouter = await (0, import_register.createMiddlewareRouter)(vite);
+      const middleware = middlewareRouter.find(
+        req.method,
+        req.url
+      )?.handler;
+      if (!middleware) {
+        return new Response("No middleware found", { status: 404 });
+      }
+      const [mwRes] = await (0, import_invokeMiddleware.invoke)(req, middleware, {
+        route,
+        viteDevServer: vite
+      });
+      return mwRes.toResponse();
+    });
+  };
+  app.use(vite.middlewares);
+  if (rscEnabled) {
+    const { createRscRequestHandler } = await import("./rsc/rscRequestHandler.js");
+    app.use(
+      "/rw-rsc",
+      createRscRequestHandler({
+        getMiddlewareRouter: async () => (0, import_register.createMiddlewareRouter)(vite),
+        viteDevServer: vite
+      })
+    );
+  }
+  const routes = (0, import_routes.getProjectRoutes)();
+  const routeHandler = await (0, import_createReactStreamingHandler.createReactStreamingHandler)(
+    {
+      routes,
+      clientEntryPath: rwPaths.web.entryClient,
+      getStylesheetLinks: (route) => {
+        return getCssLinks({ rwPaths, route, vite });
+      },
+      // Recreate middleware router on each request in dev
+      getMiddlewareRouter: async () => (0, import_register.createMiddlewareRouter)(vite)
+    },
+    vite
+  );
+  app.get("*", (0, import_server.createServerAdapter)(routeHandler));
+  app.post("*", handleWithMiddleware());
+  const port = (0, import_project_config.getConfig)().web.port;
+  console.log(`Started server on http://localhost:${port}`);
+  return app.listen(port);
+}
+let devApp = createServer();
+process.stdin.on("data", async (data) => {
+  const str = data.toString().trim().toLowerCase();
+  if (str === "rs" || str === "restart") {
+    console.log("Restarting dev web server.....");
+    (await devApp).close(() => {
+      devApp = createServer();
+    });
+  }
+});
+function getCssLinks({
+  rwPaths,
+  route,
+  vite
+}) {
+  const appAndRouteModules = (0, import_collectCss.componentsModules)(
+    [rwPaths.web.app, route?.filePath].filter(Boolean),
+    vite
+  );
+  const collectedCss = (0, import_collectCss.collectCssPaths)(appAndRouteModules);
+  const cssLinks = Array.from(collectedCss);
+  return cssLinks;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1 @@
+export type * from "../index.d.ts"

package/dist/cjs/index.js

@@ -0,0 +1,141 @@
+"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, {
+  applyContextWrapping: () => import_vite_plugin_cedar_context_wrapping2.applyContextWrapping,
+  cedar: () => cedar,
+  cedarAutoImportsPlugin: () => import_vite_plugin_cedar_auto_import.cedarAutoImportsPlugin,
+  cedarCellTransform: () => import_vite_plugin_cedar_cell2.cedarCellTransform,
+  cedarCjsCompatPlugin: () => import_vite_plugin_cedar_cjs_compat.cedarCjsCompatPlugin,
+  cedarContextWrappingPlugin: () => import_vite_plugin_cedar_context_wrapping.cedarContextWrappingPlugin,
+  cedarEntryInjectionPlugin: () => import_vite_plugin_cedar_entry_injection2.cedarEntryInjectionPlugin,
+  cedarHtmlEnvPlugin: () => import_vite_plugin_cedar_html_env2.cedarHtmlEnvPlugin,
+  cedarImportDirPlugin: () => import_vite_plugin_cedar_import_dir.cedarImportDirPlugin,
+  cedarMergedConfig: () => import_vite_plugin_merged_config2.cedarMergedConfig,
+  cedarNodePolyfills: () => import_vite_plugin_cedar_node_polyfills2.cedarNodePolyfills,
+  cedarRemoveDevFatalErrorPage: () => import_vite_plugin_cedar_remove_dev_fatal_error_page2.cedarRemoveDevFatalErrorPage,
+  cedarRemoveFromBundle: () => import_vite_plugin_cedar_remove_from_bundle2.cedarRemoveFromBundle,
+  cedarRoutesAutoLoaderPlugin: () => import_vite_plugin_cedar_routes_auto_loader2.cedarRoutesAutoLoaderPlugin,
+  cedarSwapApolloProvider: () => import_vite_plugin_swap_apollo_provider2.cedarSwapApolloProvider,
+  cedarTransformJsAsJsx: () => import_vite_plugin_jsx_loader2.cedarTransformJsAsJsx,
+  cedarUniversalDeployPlugin: () => import_vite_plugin_cedar_universal_deploy.cedarUniversalDeployPlugin,
+  cedarWaitForApiServer: () => import_vite_plugin_cedar_wait_for_api_server2.cedarWaitForApiServer,
+  cedarjsJobPathInjectorPlugin: () => import_vite_plugin_cedarjs_job_path_injector.cedarjsJobPathInjectorPlugin,
+  cedarjsResolveCedarStyleImportsPlugin: () => import_vite_plugin_cedarjs_resolve_cedar_style_imports2.cedarjsResolveCedarStyleImportsPlugin,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_plugin_react = __toESM(require("@vitejs/plugin-react"), 1);
+var import_babel_config = require("@cedarjs/babel-config");
+var import_project_config = require("@cedarjs/project-config");
+var import_vitest = require("@cedarjs/testing/web/vitest");
+var import_vite_plugin_cedar_cell = require("./plugins/vite-plugin-cedar-cell.js");
+var import_vite_plugin_cedar_entry_injection = require("./plugins/vite-plugin-cedar-entry-injection.js");
+var import_vite_plugin_cedar_html_env = require("./plugins/vite-plugin-cedar-html-env.js");
+var import_vite_plugin_cedar_node_polyfills = require("./plugins/vite-plugin-cedar-node-polyfills.js");
+var import_vite_plugin_cedar_remove_dev_fatal_error_page = require("./plugins/vite-plugin-cedar-remove-dev-fatal-error-page.js");
+var import_vite_plugin_cedar_remove_from_bundle = require("./plugins/vite-plugin-cedar-remove-from-bundle.js");
+var import_vite_plugin_cedar_routes_auto_loader = require("./plugins/vite-plugin-cedar-routes-auto-loader.js");
+var import_vite_plugin_cedar_wait_for_api_server = require("./plugins/vite-plugin-cedar-wait-for-api-server.js");
+var import_vite_plugin_cedarjs_resolve_cedar_style_imports = require("./plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js");
+var import_vite_plugin_jsx_loader = require("./plugins/vite-plugin-jsx-loader.js");
+var import_vite_plugin_merged_config = require("./plugins/vite-plugin-merged-config.js");
+var import_vite_plugin_swap_apollo_provider = require("./plugins/vite-plugin-swap-apollo-provider.js");
+var import_vite_plugin_cedar_auto_import = require("./plugins/vite-plugin-cedar-auto-import.js");
+var import_vite_plugin_cedar_cjs_compat = require("./plugins/vite-plugin-cedar-cjs-compat.js");
+var import_vite_plugin_cedar_cell2 = require("./plugins/vite-plugin-cedar-cell.js");
+var import_vite_plugin_cedar_context_wrapping = require("./plugins/vite-plugin-cedar-context-wrapping.js");
+var import_vite_plugin_cedar_context_wrapping2 = require("./plugins/vite-plugin-cedar-context-wrapping.js");
+var import_vite_plugin_cedar_entry_injection2 = require("./plugins/vite-plugin-cedar-entry-injection.js");
+var import_vite_plugin_cedar_html_env2 = require("./plugins/vite-plugin-cedar-html-env.js");
+var import_vite_plugin_cedar_import_dir = require("./plugins/vite-plugin-cedar-import-dir.js");
+var import_vite_plugin_cedar_node_polyfills2 = require("./plugins/vite-plugin-cedar-node-polyfills.js");
+var import_vite_plugin_cedar_remove_dev_fatal_error_page2 = require("./plugins/vite-plugin-cedar-remove-dev-fatal-error-page.js");
+var import_vite_plugin_cedar_routes_auto_loader2 = require("./plugins/vite-plugin-cedar-routes-auto-loader.js");
+var import_vite_plugin_cedar_remove_from_bundle2 = require("./plugins/vite-plugin-cedar-remove-from-bundle.js");
+var import_vite_plugin_cedarjs_resolve_cedar_style_imports2 = require("./plugins/vite-plugin-cedarjs-resolve-cedar-style-imports.js");
+var import_vite_plugin_cedarjs_job_path_injector = require("./plugins/vite-plugin-cedarjs-job-path-injector.js");
+var import_vite_plugin_jsx_loader2 = require("./plugins/vite-plugin-jsx-loader.js");
+var import_vite_plugin_merged_config2 = require("./plugins/vite-plugin-merged-config.js");
+var import_vite_plugin_swap_apollo_provider2 = require("./plugins/vite-plugin-swap-apollo-provider.js");
+var import_vite_plugin_cedar_universal_deploy = require("./plugins/vite-plugin-cedar-universal-deploy.js");
+var import_vite_plugin_cedar_wait_for_api_server2 = require("./plugins/vite-plugin-cedar-wait-for-api-server.js");
+function cedar({ mode } = {}) {
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const rscEnabled = cedarConfig.experimental?.rsc?.enabled;
+  const webSideDefaultBabelConfig = (0, import_babel_config.getWebSideDefaultBabelConfig)({
+    forVite: true
+  });
+  const babelConfig = {
+    ...webSideDefaultBabelConfig
+  };
+  return [
+    mode === "test" && (0, import_vitest.cedarJsRouterImportTransformPlugin)(),
+    mode === "test" && (0, import_vitest.createAuthImportTransformPlugin)(),
+    mode === "test" && (0, import_vitest.autoImportsPlugin)(),
+    (0, import_vite_plugin_cedar_wait_for_api_server.cedarWaitForApiServer)(),
+    (0, import_vite_plugin_cedar_node_polyfills.cedarNodePolyfills)(),
+    (0, import_vite_plugin_cedar_html_env.cedarHtmlEnvPlugin)(),
+    (0, import_vite_plugin_cedar_entry_injection.cedarEntryInjectionPlugin)(),
+    (0, import_vite_plugin_merged_config.cedarMergedConfig)(),
+    (0, import_vite_plugin_cedarjs_resolve_cedar_style_imports.cedarjsResolveCedarStyleImportsPlugin)(),
+    (0, import_vite_plugin_swap_apollo_provider.cedarSwapApolloProvider)(),
+    (0, import_vite_plugin_cedar_cell.cedarCellTransform)(),
+    (0, import_vite_plugin_jsx_loader.cedarTransformJsAsJsx)(),
+    (0, import_vite_plugin_cedar_remove_from_bundle.cedarRemoveFromBundle)(),
+    (0, import_vite_plugin_cedar_remove_dev_fatal_error_page.cedarRemoveDevFatalErrorPage)(),
+    // RSC handles route auto-loading differently in each build stage
+    !rscEnabled && (0, import_vite_plugin_cedar_routes_auto_loader.cedarRoutesAutoLoaderPlugin)(),
+    (0, import_plugin_react.default)({ babel: babelConfig })
+  ];
+}
+var index_default = cedar;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyContextWrapping,
+  cedar,
+  cedarAutoImportsPlugin,
+  cedarCellTransform,
+  cedarCjsCompatPlugin,
+  cedarContextWrappingPlugin,
+  cedarEntryInjectionPlugin,
+  cedarHtmlEnvPlugin,
+  cedarImportDirPlugin,
+  cedarMergedConfig,
+  cedarNodePolyfills,
+  cedarRemoveDevFatalErrorPage,
+  cedarRemoveFromBundle,
+  cedarRoutesAutoLoaderPlugin,
+  cedarSwapApolloProvider,
+  cedarTransformJsAsJsx,
+  cedarUniversalDeployPlugin,
+  cedarWaitForApiServer,
+  cedarjsJobPathInjectorPlugin,
+  cedarjsResolveCedarStyleImportsPlugin
+});

package/dist/cjs/lib/StatusError.js

@@ -0,0 +1,37 @@
+"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;
+  }
+  statusCode;
+}
+const hasStatusCode = (x) => typeof x?.statusCode === "number";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StatusError,
+  hasStatusCode
+});