@cedarjs/prerender 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/cjs/runPrerenderEsm.js

@@ -1,304 +0,0 @@
-"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/vite-plugin-cedar-import-dir.d.ts

@@ -1,19 +0,0 @@
-import type { Plugin } from 'vite';
-/**
- * This Vite plugin will search for import statements that include a glob double
- * star `**` in the source part of the statement. The files that are matched are
- * imported and appended to an object.
- *
- * @example
- * Given a directory "src/services" that contains "a.js", "b.ts" and
- * "nested/c.js" will produce the following results:
- * ```js
- * import services from 'src/services/**\/*.{js,ts}'
- * console.log(services)
- * // services.a = import('src/services/a')
- * // services.b = import('src/services/b')
- * // services.nested_c = import('src/services/nested/c')
- * ```
- */
-export declare function cedarImportDirPlugin(): Plugin;
-//# sourceMappingURL=vite-plugin-cedar-import-dir.d.ts.map

package/dist/graphql/vite-plugin-cedar-import-dir.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-plugin-cedar-import-dir.d.ts","sourceRoot":"","sources":["../../src/graphql/vite-plugin-cedar-import-dir.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAIlC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAgH7C"}

package/dist/graphql/vite-plugin-cedar-import-dir.js

@@ -1,84 +0,0 @@
-import path from "node:path";
-import { parse, Lang } from "@ast-grep/napi";
-import fg from "fast-glob";
-import { importStatementPath, getPaths } from "@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 = path.extname(id);
-      const language = ext === ".ts" || ext === ".tsx" ? Lang.TypeScript : Lang.JavaScript;
-      let ast;
-      try {
-        ast = 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 = importStatementPath(sourceValue);
-        const cwd = importGlob.startsWith("src/") ? getPaths().api.base : path.dirname(id);
-        try {
-          const dirFiles = fg.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 } = path.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;
-    }
-  };
-}
-export {
-  cedarImportDirPlugin
-};

package/dist/runPrerenderEsm.d.ts

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,GAAU,6BAGhC,eAAe,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAwHzC,CAAA;AAGD,eAAO,MAAM,wBAAwB,GACnC,gBAAgB,MAAM,EACtB,SAAS,MAAM,SAchB,CAAA"}