@cedarjs/vite 0.0.4

package/dist/cjs/streaming/transforms/serverInjectionTransform.js

@@ -0,0 +1,84 @@
+"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 serverInjectionTransform_exports = {};
+__export(serverInjectionTransform_exports, {
+  createServerInjectionTransform: () => createServerInjectionTransform
+});
+module.exports = __toCommonJS(serverInjectionTransform_exports);
+var import_encode_decode = require("./encode-decode.js");
+function createServerInjectionTransform({
+  injectionState,
+  createElement,
+  ServerInjectedHtml,
+  renderToString,
+  onlyOnFlush = false
+}) {
+  const transformStream = new TransformStream({
+    transform(chunk, controller) {
+      if (onlyOnFlush) {
+        controller.enqueue(chunk);
+      } else {
+        const mergedBytes = insertHtml(chunk);
+        controller.enqueue(mergedBytes);
+      }
+    },
+    flush(controller) {
+      const mergedBytes = insertHtml();
+      controller.enqueue(mergedBytes);
+      const moveTagsScript = (0, import_encode_decode.encodeText)(`<script>document.querySelectorAll('body [data-rwjs-head]').forEach((el) => {
+        document.querySelectorAll('head ' + el.tagName).forEach((e) => {
+          if (
+            el.tagName === 'TITLE' ||
+            (el.tagName === 'META' &&
+              el.getAttribute('name') === e.getAttribute('name') &&
+              el.getAttribute('property') === e.getAttribute('property'))
+          ) {
+            e.remove();
+          }
+          document.head.appendChild(el);
+        });
+      });
+        </script>`);
+      controller.enqueue(moveTagsScript);
+    }
+  });
+  return transformStream;
+  function insertHtml(chunk) {
+    const serverHtmlOutput = renderToString(
+      createElement(ServerInjectedHtml, {
+        injectionState
+      })
+    );
+    const injectedBytes = (0, import_encode_decode.encodeText)(serverHtmlOutput);
+    if (chunk !== void 0) {
+      const mergedBytes = new Uint8Array(chunk.length + injectedBytes.length);
+      mergedBytes.set(chunk);
+      mergedBytes.set(injectedBytes, chunk.length);
+      return mergedBytes;
+    } else {
+      const injectedHtmlOutput = new Uint8Array(injectedBytes.length);
+      injectedHtmlOutput.set(injectedBytes);
+      return injectedHtmlOutput;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServerInjectionTransform
+});

package/dist/cjs/streaming/triggerRouteHooks.js

@@ -0,0 +1,96 @@
+"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 triggerRouteHooks_exports = {};
+__export(triggerRouteHooks_exports, {
+  loadAndRunRouteHooks: () => loadAndRunRouteHooks,
+  triggerRouteHooks: () => triggerRouteHooks
+});
+module.exports = __toCommonJS(triggerRouteHooks_exports);
+var import_util = require("@cedarjs/router/util");
+const triggerRouteHooks = async ({
+  routeHooks,
+  req,
+  parsedParams = {},
+  previousOutput
+}) => {
+  const event = {
+    params: parsedParams,
+    headers: req.headers || {},
+    query: (0, import_util.parseSearch)(req.url),
+    // cookies: req.cookies || {}, // TODO (STREAMING) we probably need some sort of cookie parser
+    // TODO (STREAMING) called app routeHook, but its just the previous output
+    appRouteHook: previousOutput
+  };
+  let meta = previousOutput?.meta || [];
+  try {
+    const metaRouteHookOutput = await routeHooks?.meta?.(event) || [];
+    const currentMeta = Array.isArray(metaRouteHookOutput) ? metaRouteHookOutput : [metaRouteHookOutput];
+    meta = [...meta, ...currentMeta];
+  } catch (e) {
+    throw new Error(`Error in meta hook: ${e.message}`);
+  }
+  return {
+    meta
+  };
+};
+const defaultRouteHookOutput = {
+  meta: []
+};
+const loadAndRunRouteHooks = async ({
+  paths = [],
+  reqMeta,
+  viteDevServer,
+  previousOutput = defaultRouteHookOutput
+}) => {
+  const loadModule = async (path) => {
+    return viteDevServer ? viteDevServer.ssrLoadModule(path) : import(path);
+  };
+  let currentRouteHooks;
+  let rhOutput = defaultRouteHookOutput;
+  const routeHookPath = paths.shift();
+  try {
+    if (routeHookPath) {
+      currentRouteHooks = await loadModule(routeHookPath);
+      rhOutput = await triggerRouteHooks({
+        routeHooks: currentRouteHooks,
+        req: reqMeta.req,
+        parsedParams: reqMeta.parsedParams,
+        previousOutput
+      });
+    }
+    if (paths.length > 0) {
+      return loadAndRunRouteHooks({
+        paths,
+        reqMeta,
+        previousOutput: rhOutput,
+        viteDevServer
+      });
+    } else {
+      return rhOutput;
+    }
+  } catch (e) {
+    console.error(`Error loading route hooks in ${routeHookPath}}`);
+    throw e;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadAndRunRouteHooks,
+  triggerRouteHooks
+});

package/dist/cjs/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/utils.js

@@ -0,0 +1,91 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  convertExpressHeaders: () => convertExpressHeaders,
+  ensureProcessDirWeb: () => ensureProcessDirWeb,
+  getFullUrl: () => getFullUrl,
+  makeFilePath: () => makeFilePath,
+  ssrLoadEntryServer: () => ssrLoadEntryServer,
+  stripQueryStringAndHashFromPath: () => stripQueryStringAndHashFromPath
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_url = require("node:url");
+var import_project_config = require("@cedarjs/project-config");
+function stripQueryStringAndHashFromPath(url) {
+  return url.split("?")[0].split("#")[0];
+}
+function ensureProcessDirWeb(webDir = (0, import_project_config.getPaths)().web.base) {
+  if (process.cwd() !== webDir) {
+    console.error("\u26A0\uFE0F  Warning: CWD is ", process.cwd());
+    console.warn("~".repeat(50));
+    console.warn(
+      "The cwd must be web/. Please use `yarn rw <command>` or run the command from the web/ directory."
+    );
+    console.log(`Changing cwd to ${webDir}....`);
+    console.log();
+    process.chdir(webDir);
+  }
+}
+function makeFilePath(path) {
+  return (0, import_node_url.pathToFileURL)(path).href;
+}
+async function ssrLoadEntryServer(viteDevServer) {
+  const rwPaths = (0, import_project_config.getPaths)();
+  if (!rwPaths.web.entryServer) {
+    throw new Error("entryServer not defined");
+  }
+  return viteDevServer.ssrLoadModule(
+    rwPaths.web.entryServer
+    // Have to type cast here because ssrLoadModule just returns a generic
+    // Record<string, any> type
+  );
+}
+function convertExpressHeaders(expressDistinctHeaders) {
+  const headers = new Headers();
+  for (const name in expressDistinctHeaders) {
+    const values = expressDistinctHeaders[name];
+    if (Array.isArray(values)) {
+      for (const value of values) {
+        headers.append(name, value);
+      }
+    }
+  }
+  return headers;
+}
+const getFullUrl = (req, rscEnabled) => {
+  const baseUrl = req.protocol + "://" + req.headers.host;
+  const url = new URL(req.originalUrl || "", baseUrl);
+  const pathname = url.searchParams.get("__rwjs__pathname");
+  const search = url.searchParams.get("__rwjs__search");
+  let pathnamePlusSearch = req.originalUrl;
+  if (rscEnabled && pathname !== null && search !== null) {
+    pathnamePlusSearch = pathname + "?" + search;
+  }
+  return baseUrl + pathnamePlusSearch;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertExpressHeaders,
+  ensureProcessDirWeb,
+  getFullUrl,
+  makeFilePath,
+  ssrLoadEntryServer,
+  stripQueryStringAndHashFromPath
+});

package/dist/devFeServer.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=devFeServer.d.ts.map

package/dist/devFeServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devFeServer.d.ts","sourceRoot":"","sources":["../src/devFeServer.ts"],"names":[],"mappings":""}

package/dist/devFeServer.js

@@ -0,0 +1,134 @@
+import { createServerAdapter } from "@whatwg-node/server";
+import express from "express";
+import { createServer as createViteServer } from "vite";
+import { cjsInterop } from "vite-plugin-cjs-interop";
+import { getProjectRoutes } from "@cedarjs/internal/dist/routes.js";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { createPerRequestMap, createServerStorage } from "@cedarjs/server-store";
+import { registerFwGlobalsAndShims } from "./lib/registerFwGlobalsAndShims.js";
+import { invoke } from "./middleware/invokeMiddleware.js";
+import { createMiddlewareRouter } from "./middleware/register.js";
+import { rscRoutesAutoLoader } from "./plugins/vite-plugin-rsc-routes-auto-loader.js";
+import { collectCssPaths, componentsModules } from "./streaming/collectCss.js";
+import { createReactStreamingHandler } from "./streaming/createReactStreamingHandler.js";
+import {
+  convertExpressHeaders,
+  ensureProcessDirWeb,
+  getFullUrl
+} from "./utils.js";
+globalThis.__REDWOOD__PRERENDER_PAGES = {};
+async function createServer() {
+  ensureProcessDirWeb();
+  registerFwGlobalsAndShims();
+  const app = express();
+  const rwPaths = getPaths();
+  const rscEnabled = getConfig().experimental.rsc?.enabled ?? false;
+  const serverStorage = createServerStorage();
+  app.use("*", (req, _res, next) => {
+    const fullUrl = getFullUrl(req, rscEnabled);
+    const perReqStore = createPerRequestMap({
+      // Convert express headers to fetch header
+      headers: 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. You need to setup your project with Vite using `yarn rw setup vite`"
+    );
+  }
+  const vite = await createViteServer({
+    configFile: rwPaths.web.viteConfig,
+    plugins: [
+      cjsInterop({
+        dependencies: [
+          // Skip ESM modules: rwjs/auth, rwjs/web, rwjs/auth-*-middleware, rwjs/router
+          "@cedarjs/forms",
+          "@cedarjs/prerender/*",
+          "@cedarjs/auth-*-api",
+          "@cedarjs/auth-*-web"
+        ]
+      }),
+      rscEnabled && rscRoutesAutoLoader()
+    ],
+    server: { middlewareMode: true },
+    logLevel: "info",
+    clearScreen: false,
+    appType: "custom"
+  });
+  const handleWithMiddleware = (route) => {
+    return createServerAdapter(async (req) => {
+      const middlewareRouter = await createMiddlewareRouter(vite);
+      const middleware = middlewareRouter.find(
+        req.method,
+        req.url
+      )?.handler;
+      if (!middleware) {
+        return new Response("No middleware found", { status: 404 });
+      }
+      const [mwRes] = await 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 () => createMiddlewareRouter(vite),
+        viteDevServer: vite
+      })
+    );
+  }
+  const routes = getProjectRoutes();
+  const routeHandler = await createReactStreamingHandler(
+    {
+      routes,
+      clientEntryPath: rwPaths.web.entryClient,
+      getStylesheetLinks: (route) => {
+        return getCssLinks({ rwPaths, route, vite });
+      },
+      // Recreate middleware router on each request in dev
+      getMiddlewareRouter: async () => createMiddlewareRouter(vite)
+    },
+    vite
+  );
+  app.get("*", createServerAdapter(routeHandler));
+  app.post("*", handleWithMiddleware());
+  const port = 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 = componentsModules(
+    [rwPaths.web.app, route?.filePath].filter(Boolean),
+    vite
+  );
+  const collectedCss = collectCssPaths(appAndRouteModules);
+  const cssLinks = Array.from(collectedCss);
+  return cssLinks;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { PluginOption } from 'vite';
+/**
+ * Pre-configured vite plugin, with required config for Redwood apps.
+ */
+export default function redwoodPluginVite(): PluginOption[];
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAYxC;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,IAAI,YAAY,EAAE,CAwK1D"}

package/dist/index.js

@@ -0,0 +1,154 @@
+import fs from "fs";
+import path from "path";
+import react from "@vitejs/plugin-react";
+import { normalizePath } from "vite";
+import { nodePolyfills } from "vite-plugin-node-polyfills";
+import { getWebSideDefaultBabelConfig } from "@cedarjs/babel-config";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { getMergedConfig } from "./lib/getMergedConfig.js";
+import { handleJsAsJsx } from "./plugins/vite-plugin-jsx-loader.js";
+import { removeFromBundle } from "./plugins/vite-plugin-remove-from-bundle.js";
+import { swapApolloProvider } from "./plugins/vite-plugin-swap-apollo-provider.js";
+function redwoodPluginVite() {
+  const rwPaths = getPaths();
+  const rwConfig = 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 = path.relative(rwPaths.web.src, clientEntryPath);
+  const apiPackageJsonPath = path.join(rwPaths.api.base, "package.json");
+  const realtimeEnabled = fs.existsSync(apiPackageJsonPath) && fs.readFileSync(apiPackageJsonPath, "utf-8").includes("@cedarjs/realtime");
+  const streamingEnabled = rwConfig.experimental.streamingSsr.enabled;
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  const webSideDefaultBabelConfig = 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 && {
+      ...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 (fs.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 (fs.existsSync(clientEntryPath) && normalizePath(id) === 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: getMergedConfig(rwConfig, rwPaths)
+    },
+    // We can remove when streaming is stable
+    streamingEnabled && swapApolloProvider(),
+    handleJsAsJsx(),
+    // Remove the splash-page from the bundle.
+    removeFromBundle(
+      [
+        {
+          id: /@cedarjs\/router\/dist\/splash-page/
+        }
+      ],
+      ["SplashPage"]
+    ),
+    !realtimeEnabled && removeFromBundle([
+      {
+        id: /@cedarjs\/web\/dist\/apollo\/sseLink/
+      }
+    ]),
+    react({
+      babel: babelConfig
+    })
+  ];
+}
+export {
+  redwoodPluginVite as default
+};

package/dist/lib/StatusError.d.ts

@@ -0,0 +1,8 @@
+export declare class StatusError extends Error {
+    statusCode: number;
+    constructor(message: string, statusCode: number);
+}
+export declare const hasStatusCode: (x: unknown) => x is {
+    statusCode: number;
+};
+//# sourceMappingURL=StatusError.d.ts.map

package/dist/lib/StatusError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StatusError.d.ts","sourceRoot":"","sources":["../../src/lib/StatusError.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAY,SAAQ,KAAK;IAG3B,UAAU,EAAE,MAAM;gBADzB,OAAO,EAAE,MAAM,EACR,UAAU,EAAE,MAAM;CAI5B;AAGD,eAAO,MAAM,aAAa,MAAO,OAAO,KAAG,CAAC,IAAI;IAAE,UAAU,EAAE,MAAM,CAAA;CACxB,CAAA"}

package/dist/lib/StatusError.js

@@ -0,0 +1,11 @@
+class StatusError extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+  }
+}
+const hasStatusCode = (x) => typeof x?.statusCode === "number";
+export {
+  StatusError,
+  hasStatusCode
+};

package/dist/lib/entries.d.ts

@@ -0,0 +1,3 @@
+export declare function getEntries(): Record<string, string>;
+export declare function getEntriesFromDist(): Promise<Record<string, string>>;
+//# sourceMappingURL=entries.d.ts.map

package/dist/lib/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../src/lib/entries.ts"],"names":[],"mappings":"AAWA,wBAAgB,UAAU,2BA0BzB;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAI1E"}

package/dist/lib/entries.js

@@ -0,0 +1,32 @@
+import {
+  ensurePosixPath,
+  getPaths,
+  importStatementPath
+} from "@cedarjs/project-config";
+import { getProject } from "@cedarjs/structure/dist/index.js";
+import { makeFilePath } from "../utils.js";
+function getEntries() {
+  const entries = {};
+  const rwProject = getProject(getPaths().base);
+  const routes = rwProject.getRouter().routes;
+  const pages = routes.map((route) => route.page);
+  for (const page of pages) {
+    entries[page.constName] = ensurePosixPath(importStatementPath(page.path));
+  }
+  const serverEntry = getPaths().web.entryServer;
+  if (!serverEntry) {
+    throw new Error("Server Entry file not found");
+  }
+  entries["__rwjs__ServerEntry"] = serverEntry;
+  entries["__rwjs__Routes"] = getPaths().web.routes;
+  return entries;
+}
+async function getEntriesFromDist() {
+  const entriesDist = getPaths().web.distRscEntries;
+  const { serverEntries } = await import(makeFilePath(entriesDist));
+  return serverEntries;
+}
+export {
+  getEntries,
+  getEntriesFromDist
+};

package/dist/lib/envVarDefinitions.d.ts

@@ -0,0 +1,14 @@
+export declare function getEnvVarDefinitions(): {
+    RWJS_ENV: {
+        RWJS_API_GRAPHQL_URL: string;
+        RWJS_API_URL: string;
+        __REDWOOD__APP_TITLE: string;
+        RWJS_EXP_STREAMING_SSR: boolean;
+        RWJS_EXP_RSC: boolean;
+    };
+    RWJS_DEBUG_ENV: {
+        RWJS_SRC_ROOT: string;
+        REDWOOD_ENV_EDITOR: string;
+    };
+};
+//# sourceMappingURL=envVarDefinitions.d.ts.map

package/dist/lib/envVarDefinitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envVarDefinitions.d.ts","sourceRoot":"","sources":["../../src/lib/envVarDefinitions.ts"],"names":[],"mappings":"AAIA,wBAAgB,oBAAoB;;;;;;;;;;;;EAkDnC"}