@cedarjs/prerender 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# Prerender
+
+- [Prerender](#prerender)
+  - [Purpose and Vision](#purpose-and-vision)
+  - [Package Leads](#package-leads)
+  - [Contributing](#contributing)
+
+## Purpose and Vision
+
+Build-time prerender for pages that don't have dynamic content. See:  
+https://redwoodjs.com/docs/prerender
+
+## Package Leads
+
+- Daniel Choudhury (@dac09)
+
+## Contributing
+
+**ToDo**

package/dist/babelPlugins/babel-plugin-redwood-prerender-media-imports.d.ts

@@ -0,0 +1,5 @@
+import type { PluginObj, types } from '@babel/core';
+export default function ({ types: t }: {
+    types: typeof types;
+}): PluginObj;
+//# sourceMappingURL=babel-plugin-redwood-prerender-media-imports.d.ts.map

package/dist/babelPlugins/babel-plugin-redwood-prerender-media-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-redwood-prerender-media-imports.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/babel-plugin-redwood-prerender-media-imports.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAY,MAAM,aAAa,CAAA;AAsC7D,MAAM,CAAC,OAAO,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,GAAG,SAAS,CAqDzE"}

package/dist/babelPlugins/babel-plugin-redwood-prerender-media-imports.js

@@ -0,0 +1,94 @@
+"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 babel_plugin_redwood_prerender_media_imports_exports = {};
+__export(babel_plugin_redwood_prerender_media_imports_exports, {
+  default: () => babel_plugin_redwood_prerender_media_imports_default
+});
+module.exports = __toCommonJS(babel_plugin_redwood_prerender_media_imports_exports);
+var import_path = require("path");
+var import_project_config = require("@cedarjs/project-config");
+var import_utils = require("./utils");
+const defaultOptions = {
+  // This list of extensions matches config for file-loader in
+  extensions: [
+    ".ico",
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".gif",
+    ".svg",
+    ".eot",
+    ".otf",
+    ".webp",
+    ".ttf",
+    ".woff",
+    ".woff2",
+    ".cur",
+    ".ani",
+    ".pdf",
+    ".bmp"
+  ]
+};
+function getVariableName(p) {
+  if (p.node.specifiers?.[0]?.local) {
+    return p.node.specifiers[0].local.name;
+  }
+  return null;
+}
+function babel_plugin_redwood_prerender_media_imports_default({ types: t }) {
+  const manifestPath = (0, import_path.join)((0, import_project_config.getPaths)().web.dist, "client-build-manifest.json");
+  const buildManifest = require(manifestPath);
+  return {
+    name: "babel-plugin-redwood-prerender-media-imports",
+    visitor: {
+      ImportDeclaration(p, state) {
+        const importPath = p.node.source.value;
+        const ext = (0, import_path.extname)(importPath);
+        const options = {
+          ...defaultOptions,
+          ...state.opts
+        };
+        if (ext && options.extensions.includes(ext)) {
+          const importConstName = getVariableName(p);
+          if (state.filename === void 0) {
+            return;
+          }
+          const absPath = (0, import_path.join)((0, import_path.dirname)(state.filename), p.node.source.value);
+          const viteManifestKey = (0, import_project_config.ensurePosixPath)(
+            (0, import_path.relative)((0, import_project_config.getPaths)().web.src, absPath)
+          );
+          const copiedAssetPath = buildManifest[viteManifestKey]?.file;
+          const assetSrc = copiedAssetPath ?? (0, import_utils.convertToDataUrl)(
+            (0, import_path.join)(state.file.opts.sourceRoot || "./", importPath)
+          );
+          if (importConstName) {
+            p.replaceWith(
+              t.variableDeclaration("const", [
+                t.variableDeclarator(
+                  t.identifier(importConstName),
+                  t.stringLiteral(assetSrc)
+                )
+              ])
+            );
+          }
+        }
+      }
+    }
+  };
+}

package/dist/babelPlugins/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function convertToDataUrl(assetPath: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/babelPlugins/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/utils.ts"],"names":[],"mappings":"AAQA,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,UASjD"}

package/dist/babelPlugins/utils.js

@@ -0,0 +1,49 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  convertToDataUrl: () => convertToDataUrl
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_mime_types = __toESM(require("mime-types"));
+function convertToDataUrl(assetPath) {
+  try {
+    const base64AssetContents = import_fs.default.readFileSync(assetPath, "base64");
+    const mimeType = import_mime_types.default.lookup(assetPath);
+    return `data:${mimeType};base64,${base64AssetContents}`;
+  } catch {
+    console.warn(`Could not read file ${assetPath} for conversion to data uri`);
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertToDataUrl
+});

package/dist/browserUtils/index.d.ts

@@ -0,0 +1,8 @@
+import type { ReactElement } from 'react';
+export declare const isPrerendering: () => boolean;
+export declare const isBrowser: boolean;
+export declare const useIsBrowser: () => boolean;
+export declare const BrowserOnly: ({ children }: {
+    children: ReactElement;
+}) => ReactElement<any, string | React.JSXElementConstructor<any>> | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/browserUtils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/browserUtils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AAKzC,eAAO,MAAM,cAAc,QAAO,OAEjC,CAAA;AAED,eAAO,MAAM,SAAS,SAAoB,CAAA;AAE1C,eAAO,MAAM,YAAY,eAIxB,CAAA;AAED,eAAO,MAAM,WAAW,iBAAkB;IAAE,QAAQ,EAAE,YAAY,CAAA;CAAE,wEAInE,CAAA"}

package/dist/browserUtils/index.js

@@ -0,0 +1,47 @@
+"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 browserUtils_exports = {};
+__export(browserUtils_exports, {
+  BrowserOnly: () => BrowserOnly,
+  isBrowser: () => isBrowser,
+  isPrerendering: () => isPrerendering,
+  useIsBrowser: () => useIsBrowser
+});
+module.exports = __toCommonJS(browserUtils_exports);
+var import_react = require("react");
+const isPrerendering = () => {
+  return globalThis.__REDWOOD__PRERENDERING ?? false;
+};
+const isBrowser = !isPrerendering();
+const useIsBrowser = () => {
+  return (0, import_react.useMemo)(() => {
+    return !globalThis?.__REDWOOD__PRERENDERING;
+  }, []);
+};
+const BrowserOnly = ({ children }) => {
+  const isBrowser2 = useIsBrowser();
+  return isBrowser2 ? children : null;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserOnly,
+  isBrowser,
+  isPrerendering,
+  useIsBrowser
+});

package/dist/detection/index.d.ts

@@ -0,0 +1,11 @@
+export declare const detectPrerenderRoutes: () => {
+    name: string | undefined;
+    path: string | undefined;
+    routePath: string | undefined;
+    hasParams: boolean;
+    id: string;
+    isNotFound: boolean;
+    filePath: string | undefined;
+    pageIdentifier: string | undefined;
+}[];
+//# sourceMappingURL=index.d.ts.map

package/dist/detection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/detection/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB;;;;;;;;;GAsBjC,CAAA"}

package/dist/detection/index.js

@@ -0,0 +1,48 @@
+"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 detection_exports = {};
+__export(detection_exports, {
+  detectPrerenderRoutes: () => detectPrerenderRoutes
+});
+module.exports = __toCommonJS(detection_exports);
+var import_project_config = require("@cedarjs/project-config");
+var import_structure = require("@cedarjs/structure");
+const detectPrerenderRoutes = () => {
+  const rwProject = (0, import_structure.getProject)((0, import_project_config.getPaths)().base);
+  const routes = rwProject.getRouter().routes;
+  const prerenderRoutes = routes.filter((route) => route.prerender).map((route) => ({
+    name: route.isNotFound ? "404" : route.name,
+    // `path` will be updated/expanded later where route parameters will be
+    // replaced with actual values
+    path: route.isNotFound ? "/404" : route.path,
+    // `routePath` is always the path specified on the <Route> component
+    // (or the special /404 path)
+    routePath: route.isNotFound ? "/404" : route.path,
+    hasParams: route.hasParameters,
+    id: route.id,
+    isNotFound: route.isNotFound,
+    filePath: route.page?.filePath,
+    pageIdentifier: route.page_identifier_str
+  }));
+  return prerenderRoutes;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectPrerenderRoutes
+});

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+import type { DocumentNode } from 'graphql';
+export declare class PrerenderGqlError extends Error {
+    stack: string;
+    constructor(message: string);
+}
+export declare class GqlHandlerImportError extends Error {
+    stack: string;
+    constructor(message: string);
+}
+interface JSONParseErrorArgs {
+    query: DocumentNode;
+    variables?: Record<string, unknown>;
+    result: string;
+}
+export declare class JSONParseError extends Error {
+    constructor({ query, variables, result }: JSONParseErrorArgs);
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAG3C,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,KAAK,EAAE,MAAM,CAAA;gBAED,OAAO,EAAE,MAAM;CAO5B;AAED,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,KAAK,EAAE,MAAM,CAAA;gBAED,OAAO,EAAE,MAAM;CAO5B;AAED,UAAU,kBAAkB;IAC1B,KAAK,EAAE,YAAY,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACnC,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,kBAAkB;CAY7D"}

package/dist/errors.js

@@ -0,0 +1,52 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  GqlHandlerImportError: () => GqlHandlerImportError,
+  JSONParseError: () => JSONParseError,
+  PrerenderGqlError: () => PrerenderGqlError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_graphql = require("graphql");
+class PrerenderGqlError extends Error {
+  stack;
+  constructor(message) {
+    super("GQL error: " + message);
+    this.stack = this.message;
+  }
+}
+class GqlHandlerImportError extends Error {
+  stack;
+  constructor(message) {
+    super("Gql Handler Import Error:  " + message);
+    this.stack = this.message;
+  }
+}
+class JSONParseError extends Error {
+  constructor({ query, variables, result }) {
+    const message = "Could not parse the GraphQL response.\n  Request: " + (0, import_graphql.print)(query).split("\n").join("\n  ") + "\n  Variables: " + JSON.stringify(variables) + "\n  Response: " + result;
+    super(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GqlHandlerImportError,
+  JSONParseError,
+  PrerenderGqlError
+});

package/dist/graphql/graphql.d.ts

@@ -0,0 +1,19 @@
+import type { DocumentNode } from 'graphql';
+/**
+ * Loads the graphql server, with all the user's settings
+ * And execute the query against it
+ *
+ * Note that this function does NOT throw errors, even when
+ * there is a GraphQL error. Instead, it returns the result with the graphql error.
+ *
+ * @returns {Promise<QueryResult>}
+ */
+export declare function executeQuery(gqlHandler: (args: any) => Promise<any>, query: DocumentNode, variables?: Record<string, unknown>): Promise<any>;
+/**
+ * Finds the graphql handler, returns a function
+ * that can be used to execute queries against it
+ *
+ * Throws GqlHandlerImportError, so that we can warn the user (but not blow up)
+ */
+export declare function getGqlHandler(): Promise<(operation: Record<string, unknown>) => Promise<any>>;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/graphql/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/graphql/graphql.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAgB3C;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EACvC,KAAK,EAAE,YAAY,EACnB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,gBAkCpC;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,wBAMN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mBAUnD"}

package/dist/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"));
+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");
+async function executeQuery(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 = require(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() {
+  const gqlPath = import_path.default.join((0, import_project_config.getPaths)().api.functions, "graphql");
+  try {
+    const { handler } = require(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/index.d.ts

@@ -0,0 +1,2 @@
+export * from './runPrerender';
+//# 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":"AAAA,cAAc,gBAAgB,CAAA"}

package/dist/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"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./runPrerender")
+});

package/dist/internal.d.ts

@@ -0,0 +1,4 @@
+export declare const getRootHtmlPath: () => string;
+export declare const registerShims: (routerPath: string) => void;
+export declare const writeToDist: (outputHtmlPath: string, renderOutput: string) => void;
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe,cAM3B,CAAA;AAED,eAAO,MAAM,aAAa,eAAgB,MAAM,SAmC/C,CAAA;AAED,eAAO,MAAM,WAAW,mBAAoB,MAAM,gBAAgB,MAAM,SAQvE,CAAA"}

package/dist/internal.js

@@ -0,0 +1,83 @@
+"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, {
+  getRootHtmlPath: () => getRootHtmlPath,
+  registerShims: () => registerShims,
+  writeToDist: () => writeToDist
+});
+module.exports = __toCommonJS(internal_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_fetch = require("@whatwg-node/fetch");
+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);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRootHtmlPath,
+  registerShims,
+  writeToDist
+});

package/dist/runPrerender.d.ts

@@ -0,0 +1,9 @@
+import type { QueryInfo } from '@cedarjs/web';
+interface PrerenderParams {
+    queryCache: Record<string, QueryInfo>;
+    renderPath: string;
+}
+export declare const runPrerender: ({ queryCache, renderPath, }: PrerenderParams) => Promise<string | void>;
+export declare const writePrerenderedHtmlFile: (outputHtmlPath: string, content: string) => void;
+export {};
+//# sourceMappingURL=runPrerender.d.ts.map

package/dist/runPrerender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runPrerender.d.ts","sourceRoot":"","sources":["../src/runPrerender.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAsN7C,UAAU,eAAe;IACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACrC,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,eAAO,MAAM,YAAY,gCAGtB,eAAe,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CA4HzC,CAAA;AAGD,eAAO,MAAM,wBAAwB,mBACnB,MAAM,WACb,MAAM,SAchB,CAAA"}

package/dist/runPrerender.js

@@ -0,0 +1,293 @@
+"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 runPrerender_exports = {};
+__export(runPrerender_exports, {
+  runPrerender: () => runPrerender,
+  writePrerenderedHtmlFile: () => writePrerenderedHtmlFile
+});
+module.exports = __toCommonJS(runPrerender_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_react = __toESM(require("react"));
+var import_client = require("@apollo/client");
+var import_cheerio = require("cheerio");
+var import_server = __toESM(require("react-dom/server"));
+var import_babel_config = require("@cedarjs/babel-config");
+var import_project_config = require("@cedarjs/project-config");
+var import_router = require("@cedarjs/router");
+var import_util = require("@cedarjs/router/dist/util");
+var import_babel_plugin_redwood_prerender_media_imports = __toESM(require("./babelPlugins/babel-plugin-redwood-prerender-media-imports"));
+var import_detection = require("./detection");
+var import_errors = require("./errors");
+var import_graphql = require("./graphql/graphql");
+var import_internal = require("./internal");
+const prerenderApolloClient = new import_client.ApolloClient({ cache: new import_client.InMemoryCache() });
+async function recursivelyRender(App, Routes, renderPath, gqlHandler, queryCache) {
+  const { CellCacheContextProvider, getOperationName } = require("@cedarjs/web");
+  let shouldShowGraphqlHandlerNotFoundWarn = false;
+  await Promise.all(
+    Object.entries(queryCache).map(async ([cacheKey, value]) => {
+      if (value.hasProcessed) {
+        return Promise.resolve("");
+      }
+      try {
+        const resultString = await (0, import_graphql.executeQuery)(
+          gqlHandler,
+          value.query,
+          value.variables
+        );
+        let result;
+        try {
+          result = JSON.parse(resultString);
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            throw new import_errors.JSONParseError({
+              query: value.query,
+              variables: value.variables,
+              result: resultString
+            });
+          }
+        }
+        if (result.errors) {
+          const message = result.errors[0].message ?? JSON.stringify(result.errors, null, 4);
+          if (result.errors[0]?.extensions?.code === "UNAUTHENTICATED") {
+            console.error(
+              `
+ 
+ \u{1F6D1}  Cannot prerender the query ${getOperationName(
+                value.query
+              )} as it requires auth. 
+`
+            );
+          }
+          throw new import_errors.PrerenderGqlError(message);
+        }
+        queryCache[cacheKey] = {
+          ...value,
+          data: result.data,
+          hasProcessed: true
+        };
+        return result;
+      } catch (e) {
+        if (e instanceof import_errors.GqlHandlerImportError) {
+          shouldShowGraphqlHandlerNotFoundWarn = true;
+          queryCache[cacheKey] = {
+            ...value,
+            // tried to fetch, but failed
+            renderLoading: true,
+            hasProcessed: true
+          };
+          return;
+        } else {
+          throw e;
+        }
+      }
+    })
+  );
+  const prerenderUrl = process.env.RWJS_PRERENDER_ORIGIN || "http://localhost" + renderPath;
+  const componentAsHtml = import_server.default.renderToString(
+    /* @__PURE__ */ import_react.default.createElement(import_router.LocationProvider, { location: new URL(prerenderUrl) }, /* @__PURE__ */ import_react.default.createElement(CellCacheContextProvider, { queryCache }, /* @__PURE__ */ import_react.default.createElement(App, null, /* @__PURE__ */ import_react.default.createElement(Routes, null))))
+  );
+  if (Object.values(queryCache).some((value) => !value.hasProcessed)) {
+    return recursivelyRender(App, Routes, renderPath, gqlHandler, queryCache);
+  } else {
+    if (shouldShowGraphqlHandlerNotFoundWarn) {
+      console.warn(
+        '\n  \u26A0\uFE0F  Could not load your GraphQL handler. \n Your Cells have been prerendered in the "Loading" state. \n'
+      );
+    }
+    return Promise.resolve(componentAsHtml);
+  }
+}
+function insertChunkLoadingScript(indexHtmlTree, renderPath) {
+  const prerenderRoutes = (0, import_detection.detectPrerenderRoutes)();
+  const route = prerenderRoutes.find((route2) => {
+    if (!route2.routePath) {
+      return false;
+    }
+    return (0, import_util.matchPath)(route2.routePath, renderPath).match;
+  });
+  if (!route) {
+    throw new Error("Could not find a Route matching " + renderPath);
+  }
+  if (!route.pageIdentifier) {
+    throw new Error(`Route for ${renderPath} has no pageIdentifier`);
+  }
+  const buildManifest = JSON.parse(
+    import_fs.default.readFileSync(
+      import_path.default.join((0, import_project_config.getPaths)().web.dist, "client-build-manifest.json"),
+      "utf-8"
+    )
+  );
+  const chunkPaths = [];
+  if (route?.filePath) {
+    const pagesIndex = route.filePath.indexOf(import_path.default.join("web", "src", "pages")) + 8;
+    const pagePath = (0, import_project_config.ensurePosixPath)(route.filePath.slice(pagesIndex));
+    const pageChunkPath = buildManifest[pagePath]?.file;
+    if (pageChunkPath) {
+      chunkPaths.push("/" + pageChunkPath);
+    }
+  }
+  if (chunkPaths.length === 0) {
+    return;
+  }
+  chunkPaths.forEach((chunkPath) => {
+    indexHtmlTree("head").prepend(
+      `<script defer="defer" src="${chunkPath}" type="module"></script>`
+    );
+  });
+  chunkPaths.forEach((chunkPath) => {
+    const fullChunkPath = import_path.default.join((0, import_project_config.getPaths)().web.dist, chunkPath);
+    const jsChunk = import_fs.default.readFileSync(fullChunkPath, "utf-8");
+    const matches = jsChunk.match(/export\s*\{\s*\w+ as default\s*\}/g) || [];
+    const lastIndex = jsChunk.lastIndexOf(matches[matches.length - 1]);
+    const varNameMatch = jsChunk.slice(lastIndex).match(/export\s*\{\s*(\w+) as default\s*\}/);
+    import_fs.default.writeFileSync(
+      fullChunkPath,
+      jsChunk + `globalThis.__REDWOOD__PRERENDER_PAGES = globalThis.__REDWOOD__PRERENDER_PAGES || {};
+globalThis.__REDWOOD__PRERENDER_PAGES.${route?.pageIdentifier}=${varNameMatch?.[1]};
+`
+    );
+  });
+}
+const runPrerender = async ({
+  queryCache,
+  renderPath
+}) => {
+  (0, import_internal.registerShims)(renderPath);
+  (0, import_babel_config.registerApiSideBabelHook)({
+    plugins: [
+      [
+        "babel-plugin-module-resolver",
+        {
+          alias: {
+            api: (0, import_project_config.getPaths)().api.base,
+            web: (0, import_project_config.getPaths)().web.base
+          },
+          loglevel: "silent"
+          // to silence the unnecessary warnings
+        }
+      ]
+    ],
+    overrides: [
+      {
+        test: ["./api/"],
+        plugins: [
+          [
+            "babel-plugin-module-resolver",
+            {
+              alias: {
+                src: (0, import_project_config.getPaths)().api.src
+              },
+              loglevel: "silent"
+            },
+            "exec-api-src-module-resolver"
+          ]
+        ]
+      }
+    ]
+  });
+  const gqlHandler = await (0, import_graphql.getGqlHandler)();
+  (0, import_babel_config.registerWebSideBabelHook)({
+    overrides: [
+      {
+        plugins: [
+          ["ignore-html-and-css-imports"],
+          // webpack/postcss handles CSS imports
+          [import_babel_plugin_redwood_prerender_media_imports.default]
+        ]
+      }
+    ],
+    options: {
+      forPrerender: true
+    }
+  });
+  const indexContent = import_fs.default.readFileSync((0, import_internal.getRootHtmlPath)()).toString();
+  const { default: App } = require((0, import_project_config.getPaths)().web.app);
+  const { default: Routes } = require((0, import_project_config.getPaths)().web.routes);
+  const componentAsHtml = await recursivelyRender(
+    App,
+    Routes,
+    renderPath,
+    gqlHandler,
+    queryCache
+  );
+  const { helmet } = globalThis.__REDWOOD__HELMET_CONTEXT;
+  Object.keys(queryCache).forEach((queryKey) => {
+    const { query, variables, data } = queryCache[queryKey];
+    prerenderApolloClient.writeQuery({
+      query,
+      variables,
+      data
+    });
+  });
+  const indexHtmlTree = (0, import_cheerio.load)(indexContent);
+  if (helmet) {
+    const helmetElements = `
+  ${helmet?.link.toString()}
+  ${helmet?.meta.toString()}
+  ${helmet?.script.toString()}
+  ${helmet?.noscript.toString()}
+  `;
+    indexHtmlTree("head").prepend(helmetElements);
+    const titleHtmlTag = helmet.title.toString();
+    if ((0, import_cheerio.load)(titleHtmlTag)("title").text() !== "") {
+      if (indexHtmlTree("title").text().length === 0) {
+        indexHtmlTree("head").prepend(titleHtmlTag);
+      } else {
+        indexHtmlTree("title").replaceWith(titleHtmlTag);
+      }
+    }
+  }
+  indexHtmlTree("head").append(
+    `<script> globalThis.__REDWOOD__APOLLO_STATE = ${JSON.stringify(
+      prerenderApolloClient.extract()
+    )}</script>`
+  );
+  prerenderApolloClient.resetStore();
+  insertChunkLoadingScript(indexHtmlTree, renderPath);
+  indexHtmlTree("#redwood-app").append(componentAsHtml);
+  const renderOutput = indexHtmlTree.html();
+  return renderOutput;
+};
+const writePrerenderedHtmlFile = (outputHtmlPath, content) => {
+  const outputHtmlAbsPath = import_path.default.join((0, import_project_config.getPaths)().base, outputHtmlPath);
+  if (outputHtmlPath === "web/dist/index.html") {
+    const html200Path = import_path.default.join((0, import_project_config.getPaths)().web.dist, "200.html");
+    if (!import_fs.default.existsSync(html200Path)) {
+      import_fs.default.copyFileSync(outputHtmlAbsPath, html200Path);
+    }
+  }
+  (0, import_internal.writeToDist)(outputHtmlAbsPath, content);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runPrerender,
+  writePrerenderedHtmlFile
+});

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@cedarjs/prerender",
+  "version": "0.0.4",
+  "description": "CedarJS prerender",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cedarjs/cedar.git",
+    "directory": "packages/prerender"
+  },
+  "license": "MIT",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./browserUtils": {
+      "types": "./dist/browserUtils/index.d.ts",
+      "default": "./dist/browserUtils/index.js"
+    },
+    "./detection": {
+      "types": "./dist/detection/index.d.ts",
+      "default": "./dist/detection/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsx ./build.mts && yarn build:types",
+    "build:pack": "yarn pack -o cedar-prerender.tgz",
+    "build:types": "tsc --build --verbose ./tsconfig.build.json",
+    "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx,template\" --ignore dist --exec \"yarn build\"",
+    "check:attw": "yarn rw-fwtools-attw",
+    "check:package": "concurrently npm:check:attw yarn:publint",
+    "prepublishOnly": "yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@cedarjs/babel-config": "0.0.4",
+    "@cedarjs/project-config": "0.0.4",
+    "@cedarjs/router": "0.0.4",
+    "@cedarjs/structure": "0.0.4",
+    "@cedarjs/web": "0.0.4",
+    "@whatwg-node/fetch": "0.9.21",
+    "babel-plugin-ignore-html-and-css-imports": "0.1.0",
+    "cheerio": "1.0.0",
+    "graphql": "16.9.0",
+    "mime-types": "2.1.35"
+  },
+  "devDependencies": {
+    "@cedarjs/framework-tools": "0.0.4",
+    "@types/mime-types": "2.1.4",
+    "babel-plugin-tester": "11.0.4",
+    "concurrently": "8.2.2",
+    "publint": "0.3.11",
+    "tsx": "4.19.3",
+    "typescript": "5.6.2",
+    "vitest": "2.1.9"
+  },
+  "peerDependencies": {
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "externals": {
+    "react": "react",
+    "react-dom": "react-dom"
+  },
+  "gitHead": "5b4f77f985bd86ee31ee7338312627accf0cb85b"
+}