@cedarjs/prerender 0.9.1-next.21 → 0.10.0-rc.24

package/dist/cjs/graphql/graphql.js

@@ -0,0 +1,152 @@
+"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 graphql_exports = {};
+__export(graphql_exports, {
+  executeQuery: () => executeQuery,
+  getGqlHandler: () => getGqlHandler
+});
+module.exports = __toCommonJS(graphql_exports);
+var import_path = __toESM(require("path"), 1);
+var import_graphql = require("graphql");
+var import_project_config = require("@cedarjs/project-config");
+var import_graphql2 = require("@cedarjs/web/dist/graphql.js");
+var import_errors = require("../errors.js");
+async function executeQuery(fileImporter, gqlHandler, query, variables) {
+  const config = (0, import_project_config.getConfig)();
+  const operationName = (0, import_graphql2.getOperationName)(query);
+  const operation = {
+    operationName,
+    query: (0, import_graphql.print)(query),
+    variables
+  };
+  if (config.graphql.trustedDocuments) {
+    const documentsPath = import_path.default.join((0, import_project_config.getPaths)().web.graphql, "graphql");
+    const documents = await fileImporter(documentsPath);
+    const documentName = operationName[0].toUpperCase() + operationName.slice(1) + "Document";
+    const queryHash = documents?.[documentName]?.__meta__?.hash;
+    operation.query = void 0;
+    operation.extensions = {
+      persistedQuery: {
+        version: 1,
+        sha256Hash: queryHash
+      }
+    };
+  }
+  const handlerResult = await gqlHandler(operation);
+  return handlerResult?.body;
+}
+async function getGqlHandler(fileImporter) {
+  const gqlPath = import_path.default.join((0, import_project_config.getPaths)().api.functions, "graphql");
+  try {
+    const { handler } = await fileImporter(gqlPath);
+    return async (operation) => {
+      return await handler(buildApiEvent(operation), buildContext());
+    };
+  } catch {
+    return () => {
+      throw new import_errors.GqlHandlerImportError(
+        `Unable to import GraphQL handler at ${gqlPath}`
+      );
+    };
+  }
+}
+function buildApiEvent(body) {
+  return {
+    body: JSON.stringify(body),
+    headers: {
+      origin: "http://localhost:8910",
+      "content-type": "application/json",
+      accept: "*/*",
+      host: "localhost:8910"
+    },
+    multiValueHeaders: {},
+    httpMethod: "POST",
+    isBase64Encoded: false,
+    path: "/graphql",
+    pathParameters: null,
+    queryStringParameters: {},
+    multiValueQueryStringParameters: null,
+    stageVariables: null,
+    resource: "",
+    requestContext: {
+      requestId: "req-3",
+      identity: {
+        sourceIp: "::1",
+        accessKey: null,
+        accountId: null,
+        apiKey: null,
+        apiKeyId: null,
+        caller: null,
+        clientCert: null,
+        cognitoAuthenticationProvider: null,
+        cognitoAuthenticationType: null,
+        cognitoIdentityId: null,
+        cognitoIdentityPoolId: null,
+        principalOrgId: null,
+        user: null,
+        userAgent: null,
+        userArn: null
+      },
+      authorizer: {},
+      protocol: "http",
+      httpMethod: "POST",
+      path: "/graphql",
+      stage: "",
+      requestTimeEpoch: 0,
+      resourceId: "",
+      resourcePath: "",
+      accountId: "",
+      apiId: ""
+    }
+  };
+}
+function buildContext() {
+  return {
+    callbackWaitsForEmptyEventLoop: false,
+    functionName: "",
+    functionVersion: "",
+    invokedFunctionArn: "",
+    memoryLimitInMB: "",
+    awsRequestId: "",
+    logGroupName: "",
+    logStreamName: "",
+    getRemainingTimeInMillis: () => 100,
+    done: () => {
+    },
+    fail: () => {
+    },
+    succeed: () => {
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeQuery,
+  getGqlHandler
+});

package/dist/cjs/graphql/node-runner.js

@@ -0,0 +1,109 @@
+"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 node_runner_exports = {};
+__export(node_runner_exports, {
+  NodeRunner: () => NodeRunner
+});
+module.exports = __toCommonJS(node_runner_exports);
+var import_vite = require("vite");
+var import_client = require("vite-node/client");
+var import_server = require("vite-node/server");
+var import_source_map = require("vite-node/source-map");
+var import_project_config = require("@cedarjs/project-config");
+var import_vite2 = require("@cedarjs/vite");
+var import_vite_plugin_cedar_auto_import = require("./vite-plugin-cedar-auto-import.js");
+var import_vite_plugin_cedar_import_dir = require("./vite-plugin-cedar-import-dir.js");
+async function createViteServer(customConfig = {}) {
+  const defaultConfig = {
+    mode: "production",
+    optimizeDeps: {
+      // This is recommended in the vite-node readme
+      noDiscovery: true,
+      include: void 0
+    },
+    resolve: {
+      alias: [
+        {
+          find: /^src\/(.*?)(\.([jt]sx?))?$/,
+          replacement: (0, import_project_config.getPaths)().api.src + "/$1"
+        }
+      ]
+    },
+    plugins: [
+      (0, import_vite_plugin_cedar_import_dir.cedarImportDirPlugin)(),
+      (0, import_vite_plugin_cedar_auto_import.cedarAutoImportsPlugin)(),
+      (0, import_vite2.cedarjsDirectoryNamedImportPlugin)(),
+      (0, import_vite2.cedarCellTransform)(),
+      (0, import_vite2.cedarjsJobPathInjectorPlugin)(),
+      (0, import_vite2.cedarSwapApolloProvider)()
+    ]
+  };
+  const mergedConfig = (0, import_vite.mergeConfig)(defaultConfig, customConfig);
+  const server = await (0, import_vite.createServer)(mergedConfig);
+  if (Number(import_vite.version.split(".")[0]) < 6) {
+    await server.pluginContainer.buildStart({});
+  }
+  return server;
+}
+class NodeRunner {
+  viteServer = void 0;
+  runner = void 0;
+  customViteConfig;
+  constructor(customViteConfig = {}) {
+    this.customViteConfig = customViteConfig;
+  }
+  async init() {
+    this.viteServer = await createViteServer(this.customViteConfig);
+    const nodeServer = new import_server.ViteNodeServer(this.viteServer, {
+      transformMode: {
+        ssr: [/.*/],
+        web: [/\/web\//]
+      },
+      deps: {
+        fallbackCJS: true
+      }
+    });
+    (0, import_source_map.installSourcemapsSupport)({
+      getSourceMap: (source) => nodeServer?.getSourceMap(source)
+    });
+    this.runner = new import_client.ViteNodeRunner({
+      root: this.viteServer.config.root,
+      base: this.viteServer.config.base,
+      fetchModule(id) {
+        return nodeServer.fetchModule(id);
+      },
+      resolveId(id, importer) {
+        return nodeServer.resolveId(id, importer);
+      }
+    });
+  }
+  async importFile(filePath) {
+    if (!this.runner) {
+      await this.init();
+    }
+    return this.runner?.executeFile(filePath);
+  }
+  async close() {
+    await this.viteServer?.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodeRunner
+});

package/dist/cjs/graphql/vite-plugin-cedar-auto-import.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_auto_import_exports = {};
+__export(vite_plugin_cedar_auto_import_exports, {
+  cedarAutoImportsPlugin: () => cedarAutoImportsPlugin
+});
+module.exports = __toCommonJS(vite_plugin_cedar_auto_import_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_unplugin = __toESM(require("unimport/unplugin"), 1);
+var import_vite = __toESM(require("unplugin-auto-import/vite"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function cedarAutoImportsPlugin() {
+  const config = (0, import_project_config.getConfig)();
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const useTrustedDocumentsGqlTag = config?.graphql?.trustedDocuments;
+  return [
+    (0, import_vite.default)({
+      // targets to transform
+      include: [
+        /web\/.*\.[tj]sx?$/,
+        // Assume we want the trusted documents gql tag import in all .jsx and
+        // .tsx files
+        /\.[tj]sx$/
+      ],
+      // global imports to register
+      imports: [
+        // import gql from 'graphql-tag'
+        !useTrustedDocumentsGqlTag && {
+          "graphql-tag": ["gql"]
+        },
+        // import { gql } from 'src/graphql/gql'
+        useTrustedDocumentsGqlTag && {
+          [(0, import_project_config.importStatementPath)(
+            import_node_path.default.join(cedarPaths.web.base, "src", "graphql", "gql")
+          )]: ["gql"]
+        }
+      ].filter((v) => Boolean(v)),
+      // Types aren't important since the output is ephemeral
+      dts: false
+    }),
+    (0, import_vite.default)({
+      // targets to transform
+      include: [/\.[tj]sx?$/],
+      // global imports to register
+      imports: [
+        {
+          "@cedarjs/context": ["context"]
+        }
+      ],
+      // Types aren't important since the output is ephemeral
+      dts: false
+    }),
+    (0, import_vite.default)({
+      // targets to transform
+      include: [/api\/.*\.[tj]sx?$/],
+      // global imports to register
+      imports: [
+        // import gql from 'graphql-tag'
+        {
+          "graphql-tag": ["gql"]
+        }
+      ],
+      // Types aren't important since the output is ephemeral
+      dts: false
+    }),
+    import_unplugin.default.vite({
+      imports: [
+        // import React from 'react'
+        {
+          name: "default",
+          as: "React",
+          from: "react"
+        }
+      ]
+    })
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarAutoImportsPlugin
+});

package/dist/cjs/graphql/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/{index.d.ts.map → cjs/index.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./runPrerender.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./runPrerender.js")
+});

package/dist/cjs/internal.d.ts

@@ -0,0 +1,28 @@
+export declare const getRootHtmlPath: () => string;
+export declare const registerShims: (routerPath: string) => void;
+export declare const writeToDist: (outputHtmlPath: string, renderOutput: string) => void;
+/**
+ * Finds, reads and parses the [ts|js]config.json file
+ * @returns The config object
+ */
+export declare const parseTypeScriptConfigFiles: () => {
+    api: any;
+    web: any;
+};
+type CompilerOptionsForPaths = {
+    compilerOptions: {
+        baseUrl: string;
+        paths: Record<string, string[]>;
+    };
+};
+/**
+ * Extracts and formats the paths from the [ts|js]config.json file
+ * @param config The config object
+ * @param rootDir {string} Where the jsconfig/tsconfig is loaded from
+ */
+export declare function getPathsFromTypeScriptConfig(config: CompilerOptionsForPaths, rootDir: string): {
+    find: string;
+    replacement: string;
+}[];
+export {};
+//# sourceMappingURL=internal.d.ts.map

package/dist/cjs/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/internal.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,eAAe,cAM3B,CAAA;AAED,eAAO,MAAM,aAAa,eAAgB,MAAM,SAiC/C,CAAA;AAED,eAAO,MAAM,WAAW,mBAAoB,MAAM,gBAAgB,MAAM,SAQvE,CAAA;AAGD;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;CA0BtC,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,eAAe,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;KAAE,CAAA;CACtE,CAAA;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,MAAM;UAsBQ,MAAM;iBAAe,MAAM;IAkBnD"}

package/dist/cjs/internal.js

@@ -0,0 +1,135 @@
+"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 internal_exports = {};
+__export(internal_exports, {
+  getPathsFromTypeScriptConfig: () => getPathsFromTypeScriptConfig,
+  getRootHtmlPath: () => getRootHtmlPath,
+  parseTypeScriptConfigFiles: () => parseTypeScriptConfigFiles,
+  registerShims: () => registerShims,
+  writeToDist: () => writeToDist
+});
+module.exports = __toCommonJS(internal_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_fetch = require("@whatwg-node/fetch");
+var import_typescript = require("typescript");
+var import_project_config = require("@cedarjs/project-config");
+const INDEX_FILE = import_path.default.join((0, import_project_config.getPaths)().web.dist, "index.html");
+const DEFAULT_INDEX = import_path.default.join((0, import_project_config.getPaths)().web.dist, "200.html");
+const getRootHtmlPath = () => {
+  if (import_fs.default.existsSync(DEFAULT_INDEX)) {
+    return DEFAULT_INDEX;
+  } else {
+    return INDEX_FILE;
+  }
+};
+const registerShims = (routerPath) => {
+  const rwjsConfig = (0, import_project_config.getConfig)();
+  globalThis.RWJS_ENV = {
+    RWJS_API_GRAPHQL_URL: rwjsConfig.web.apiGraphQLUrl ?? rwjsConfig.web.apiUrl + "/graphql",
+    RWJS_API_URL: rwjsConfig.web.apiUrl,
+    __REDWOOD__APP_TITLE: rwjsConfig.web.title
+  };
+  globalThis.RWJS_DEBUG_ENV = {
+    RWJS_SRC_ROOT: (0, import_project_config.getPaths)().web.src
+  };
+  globalThis.__REDWOOD__PRERENDERING = true;
+  globalThis.__REDWOOD__HELMET_CONTEXT = {};
+  process.env.__REDWOOD__PRERENDERING = "1";
+  globalThis.location = {
+    ...globalThis.location,
+    pathname: routerPath
+  };
+  if (!globalThis.fetch) {
+    globalThis.fetch = import_fetch.fetch;
+  }
+};
+const writeToDist = (outputHtmlPath, renderOutput) => {
+  const dirName = import_path.default.dirname(outputHtmlPath);
+  const exist = import_fs.default.existsSync(dirName);
+  if (!exist) {
+    import_fs.default.mkdirSync(dirName, { recursive: true });
+  }
+  import_fs.default.writeFileSync(outputHtmlPath, renderOutput);
+};
+const parseTypeScriptConfigFiles = () => {
+  const rwPaths = (0, import_project_config.getPaths)();
+  const parseConfigFile = (basePath) => {
+    let configPath = import_path.default.join(basePath, "tsconfig.json");
+    if (!import_fs.default.existsSync(configPath)) {
+      configPath = import_path.default.join(basePath, "jsconfig.json");
+      if (!import_fs.default.existsSync(configPath)) {
+        return null;
+      }
+    }
+    return (0, import_typescript.parseConfigFileTextToJson)(
+      configPath,
+      import_fs.default.readFileSync(configPath, "utf-8")
+    );
+  };
+  const apiConfig = parseConfigFile(rwPaths.api.base);
+  const webConfig = parseConfigFile(rwPaths.web.base);
+  return {
+    api: apiConfig?.config ?? null,
+    web: webConfig?.config ?? null
+  };
+};
+function getPathsFromTypeScriptConfig(config, rootDir) {
+  if (!config) {
+    return [];
+  }
+  if (!config.compilerOptions?.paths) {
+    return [];
+  }
+  const { baseUrl, paths } = config.compilerOptions;
+  let absoluteBase;
+  if (baseUrl) {
+    absoluteBase = import_path.default.isAbsolute(baseUrl) ? baseUrl : import_path.default.join(rootDir, baseUrl);
+  } else {
+    absoluteBase = rootDir;
+  }
+  const aliases = [];
+  for (const [key, value] of Object.entries(paths)) {
+    if (key.match(/src\/|\$api\/\*|types\/\*|\@cedarjs\/.*/g)) {
+      continue;
+    }
+    const aliasKey = key.replace("/*", "");
+    const aliasValue = import_path.default.join(absoluteBase, value[0].replace("/*", ""));
+    aliases.push({ find: aliasKey, replacement: aliasValue });
+  }
+  return aliases;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPathsFromTypeScriptConfig,
+  getRootHtmlPath,
+  parseTypeScriptConfigFiles,
+  registerShims,
+  writeToDist
+});

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}