@cedarjs/prerender 0.9.1-next.21 → 0.9.1-next.23

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

@@ -0,0 +1 @@
+{"version":3,"file":"runPrerender.d.ts","sourceRoot":"","sources":["../../src/runPrerender.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAmO7C,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,CAkIzC,CAAA;AAGD,eAAO,MAAM,wBAAwB,mBACnB,MAAM,WACb,MAAM,SAchB,CAAA"}

package/dist/cjs/runPrerender.js

@@ -0,0 +1,307 @@
+"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_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_react = __toESM(require("react"), 1);
+var apolloClient = __toESM(require("@apollo/client"), 1);
+var import_cheerio = require("cheerio");
+var import_server = __toESM(require("react-dom/server"), 1);
+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_cell = require("./babelPlugins/babel-plugin-redwood-cell.js");
+var import_babel_plugin_redwood_prerender_media_imports = require("./babelPlugins/babel-plugin-redwood-prerender-media-imports.js");
+var import_detection = require("./detection/detection.js");
+var import_errors = require("./errors.js");
+var import_graphql = require("./graphql/graphql.js");
+var import_internal = require("./internal.js");
+const { ApolloClient, InMemoryCache } = apolloClient.default || apolloClient;
+const prerenderApolloClient = new ApolloClient({ cache: new InMemoryCache() });
+async function recursivelyRender(App, Routes, renderPath, fileImporter, 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)(
+          fileImporter,
+          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") {
+            const queryName = getOperationName(value.query);
+            console.error(
+              `
+ 
+ \u{1F6D1}  Cannot prerender the query ${queryName} 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,
+      fileImporter,
+      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_node_fs.default.readFileSync(
+      import_node_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_node_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_node_path.default.join((0, import_project_config.getPaths)().web.dist, chunkPath);
+    const jsChunk = import_node_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_node_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)(require);
+  (0, import_babel_config.registerWebSideBabelHook)({
+    overrides: [
+      {
+        plugins: [
+          ["ignore-html-and-css-imports"],
+          // webpack/postcss handles CSS imports
+          [import_babel_plugin_redwood_prerender_media_imports.babelPluginRedwoodPrerenderMediaImports]
+        ]
+      },
+      {
+        test: /.+Cell.(js|tsx|jsx)$/,
+        plugins: [import_babel_plugin_redwood_cell.babelPluginRedwoodCell]
+      }
+    ],
+    options: {
+      forPrerender: true
+    }
+  });
+  const indexContent = import_node_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,
+    require,
+    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_node_path.default.join((0, import_project_config.getPaths)().base, outputHtmlPath);
+  if (outputHtmlPath === "web/dist/index.html") {
+    const html200Path = import_node_path.default.join((0, import_project_config.getPaths)().web.dist, "200.html");
+    if (!import_node_fs.default.existsSync(html200Path)) {
+      import_node_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/dist/cjs/runPrerenderEsm.js

@@ -0,0 +1,304 @@
+"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 runPrerenderEsm_exports = {};
+__export(runPrerenderEsm_exports, {
+  runPrerender: () => runPrerender,
+  writePrerenderedHtmlFile: () => writePrerenderedHtmlFile
+});
+module.exports = __toCommonJS(runPrerenderEsm_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_react = __toESM(require("react"), 1);
+var apolloClient = __toESM(require("@apollo/client"), 1);
+var import_cheerio = require("cheerio");
+var import_server = __toESM(require("react-dom/server"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_util = require("@cedarjs/router/dist/util");
+var import_buildAndImport = require("./build-and-import/buildAndImport.js");
+var import_detection = require("./detection/detection.js");
+var import_errors = require("./errors.js");
+var import_graphql = require("./graphql/graphql.js");
+var import_node_runner = require("./graphql/node-runner.js");
+var import_internal = require("./internal.js");
+const { ApolloClient, InMemoryCache } = apolloClient.default;
+const prerenderApolloClient = new ApolloClient({ cache: new InMemoryCache() });
+async function recursivelyRender(App, Routes, CellCacheContextProvider, LocationProvider, renderPath, fileImporter, gqlHandler, queryCache) {
+  const { getOperationName } = await import("@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)(
+          fileImporter,
+          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") {
+            const queryName = getOperationName(value.query);
+            console.error(
+              `
+ 
+ \u{1F6D1}  Cannot prerender the query ${queryName} 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(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,
+      CellCacheContextProvider,
+      LocationProvider,
+      renderPath,
+      fileImporter,
+      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_node_fs.default.readFileSync(
+      import_node_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_node_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_node_path.default.join((0, import_project_config.getPaths)().web.dist, chunkPath);
+    const jsChunk = import_node_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_node_fs.default.writeFileSync(
+      fullChunkPath,
+      jsChunk + `globalThis.__REDWOOD__PRERENDER_PAGES = globalThis.__REDWOOD__PRERENDER_PAGES || {};
+globalThis.__REDWOOD__PRERENDER_PAGES.${route?.pageIdentifier}=${varNameMatch?.[1]};
+`
+    );
+  });
+}
+async function createCombinedEntry({ appPath, routesPath, outDir }) {
+  const combinedContent = `
+    import { LocationProvider } from '@cedarjs/router'
+    import { CellCacheContextProvider } from '@cedarjs/web'
+
+    import App from "${(0, import_project_config.importStatementPath)(appPath.replace(".tsx", ""))}";
+    import Routes from "${(0, import_project_config.importStatementPath)(routesPath.replace(".tsx", ""))}";
+
+    export { LocationProvider, CellCacheContextProvider, App, Routes };
+  `;
+  const tempFilePath = import_node_path.default.join(outDir, "__prerender-temp-entry.tsx");
+  await import_node_fs.default.promises.writeFile(tempFilePath, combinedContent, "utf8");
+  return tempFilePath;
+}
+const renderCache = {};
+const runPrerender = async ({
+  queryCache,
+  renderPath
+}) => {
+  (0, import_internal.registerShims)(renderPath);
+  const nodeRunner = new import_node_runner.NodeRunner();
+  const gqlHandler = await (0, import_graphql.getGqlHandler)(nodeRunner.importFile.bind(nodeRunner));
+  const prerenderDistPath = import_node_path.default.join((0, import_project_config.getPaths)().web.dist, "__prerender");
+  import_node_fs.default.mkdirSync(prerenderDistPath, { recursive: true });
+  if (!renderCache.App) {
+    const entryPath = await createCombinedEntry({
+      appPath: (0, import_project_config.getPaths)().web.app,
+      routesPath: (0, import_project_config.getPaths)().web.routes,
+      outDir: prerenderDistPath
+    });
+    const required = await (0, import_buildAndImport.buildAndImport)({
+      filepath: entryPath,
+      preserveTemporaryFile: true
+    });
+    renderCache.App = required.App;
+    renderCache.Routes = required.Routes;
+    renderCache.CellCacheContextProvider = required.CellCacheContextProvider;
+    renderCache.LocationProvider = required.LocationProvider;
+  }
+  const { LocationProvider, App, Routes, CellCacheContextProvider } = renderCache;
+  if (!App) {
+    throw new Error("App not found");
+  }
+  if (!Routes) {
+    throw new Error("Routes not found");
+  }
+  if (!CellCacheContextProvider) {
+    throw new Error("CellCacheContextProvider not found");
+  }
+  if (!LocationProvider) {
+    throw new Error("LocationProvider not found");
+  }
+  const componentAsHtml = await recursivelyRender(
+    App,
+    Routes,
+    CellCacheContextProvider,
+    LocationProvider,
+    renderPath,
+    nodeRunner.importFile.bind(nodeRunner),
+    gqlHandler,
+    queryCache
+  );
+  nodeRunner.close();
+  const { helmet } = globalThis.__REDWOOD__HELMET_CONTEXT;
+  Object.keys(queryCache).forEach((queryKey) => {
+    const { query, variables, data } = queryCache[queryKey];
+    prerenderApolloClient.writeQuery({
+      query,
+      variables,
+      data
+    });
+  });
+  const indexContent = import_node_fs.default.readFileSync((0, import_internal.getRootHtmlPath)()).toString();
+  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_node_path.default.join((0, import_project_config.getPaths)().base, outputHtmlPath);
+  if (outputHtmlPath === "web/dist/index.html") {
+    const html200Path = import_node_path.default.join((0, import_project_config.getPaths)().web.dist, "200.html");
+    if (!import_node_fs.default.existsSync(html200Path)) {
+      import_node_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/dist/graphql/graphql.d.ts

@@ -1,5 +1,5 @@
 import type { DocumentNode } from 'graphql';
-import type { NodeRunner } from './node-runner.js';
+export type FileImporter = (path: string) => Promise<any>;
 /**
  * Loads the graphql server, with all the user's settings
  * And execute the query against it
@@ -8,12 +8,12 @@ import type { NodeRunner } from './node-runner.js';
  * there is a GraphQL error. Instead, it returns the result with the graphql
  * error.
  */
-export declare function executeQuery(nodeRunner: NodeRunner, gqlHandler: (args: any) => Promise<any>, query: DocumentNode, variables?: Record<string, unknown>): Promise<any>;
+export declare function executeQuery(fileImporter: FileImporter, 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(nodeRunner: NodeRunner): Promise<(operation: Record<string, unknown>) => Promise<any>>;
+export declare function getGqlHandler(fileImporter: FileImporter): Promise<(operation: Record<string, unknown>) => Promise<any>>;
 //# sourceMappingURL=graphql.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/graphql/graphql.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAS3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AASlD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,UAAU,EACtB,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,gBAmCpC;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,UAAU,EAAE,UAAU,uBAM7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mBAUnD"}
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/graphql/graphql.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAS3C,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;AASzD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,YAAY,EAAE,YAAY,EAC1B,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,gBAmCpC;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,YAAY,EAAE,YAAY,uBAMjC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,mBAUnD"}

package/dist/graphql/graphql.js

@@ -3,7 +3,7 @@ import { print } from "graphql";
 import { getConfig, getPaths } from "@cedarjs/project-config";
 import { getOperationName } from "@cedarjs/web/dist/graphql.js";
 import { GqlHandlerImportError } from "../errors.js";
-async function executeQuery(nodeRunner, gqlHandler, query, variables) {
+async function executeQuery(fileImporter, gqlHandler, query, variables) {
   const config = getConfig();
   const operationName = getOperationName(query);
   const operation = {
@@ -13,7 +13,7 @@ async function executeQuery(nodeRunner, gqlHandler, query, variables) {
   };
   if (config.graphql.trustedDocuments) {
     const documentsPath = path.join(getPaths().web.graphql, "graphql");
-    const documents = await nodeRunner.importFile(documentsPath);
+    const documents = await fileImporter(documentsPath);
     const documentName = operationName[0].toUpperCase() + operationName.slice(1) + "Document";
     const queryHash = documents?.[documentName]?.__meta__?.hash;
     operation.query = void 0;
@@ -27,10 +27,10 @@ async function executeQuery(nodeRunner, gqlHandler, query, variables) {
   const handlerResult = await gqlHandler(operation);
   return handlerResult?.body;
 }
-async function getGqlHandler(nodeRunner) {
+async function getGqlHandler(fileImporter) {
   const gqlPath = path.join(getPaths().api.functions, "graphql");
   try {
-    const { handler } = await nodeRunner.importFile(gqlPath);
+    const { handler } = await fileImporter(gqlPath);
     return async (operation) => {
       return await handler(buildApiEvent(operation), buildContext());
     };

package/dist/runPrerenderEsm.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=runPrerenderEsm.d.ts.map

package/dist/runPrerenderEsm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runPrerenderEsm.d.ts","sourceRoot":"","sources":["../src/runPrerenderEsm.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAoQ7C,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,CAwHzC,CAAA;AAGD,eAAO,MAAM,wBAAwB,mBACnB,MAAM,WACb,MAAM,SAchB,CAAA"}