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

package/dist/cjs/build-and-import/rollupPlugins/rollup-plugin-cedarjs-prerender-media-imports.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 rollup_plugin_cedarjs_prerender_media_imports_exports = {};
+__export(rollup_plugin_cedarjs_prerender_media_imports_exports, {
+  cedarjsPrerenderMediaImportsPlugin: () => cedarjsPrerenderMediaImportsPlugin
+});
+module.exports = __toCommonJS(rollup_plugin_cedarjs_prerender_media_imports_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = require("node:path");
+var import_project_config = require("@cedarjs/project-config");
+var import_utils = require("./utils.js");
+const defaultExtensions = [
+  ".ico",
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".svg",
+  ".eot",
+  ".otf",
+  ".webp",
+  ".ttf",
+  ".woff",
+  ".woff2",
+  ".cur",
+  ".ani",
+  ".pdf",
+  ".bmp"
+];
+function cedarjsPrerenderMediaImportsPlugin(options = {}) {
+  const extensions = options.extensions || defaultExtensions;
+  let buildManifest = null;
+  return {
+    name: "cedarjs-prerender-media-imports",
+    buildStart() {
+      try {
+        const manifestPath = (0, import_node_path.join)(
+          (0, import_project_config.getPaths)().web.dist,
+          "client-build-manifest.json"
+        );
+        buildManifest = JSON.parse(import_node_fs.default.readFileSync(manifestPath, "utf-8"));
+      } catch {
+        buildManifest = {};
+      }
+    },
+    resolveId(source, _importer) {
+      const ext = (0, import_node_path.extname)(source);
+      if (!ext || !extensions.includes(ext)) {
+        return null;
+      }
+      return {
+        id: source,
+        external: false
+      };
+    },
+    load(id) {
+      const ext = (0, import_node_path.extname)(id);
+      if (!ext || !extensions.includes(ext)) {
+        return null;
+      }
+      const importerModule = Array.from(this.getModuleIds()).find(
+        (moduleId) => {
+          const moduleInfo = this.getModuleInfo(moduleId);
+          return moduleInfo?.importedIds?.includes(id);
+        }
+      );
+      let absPath;
+      let viteManifestKey;
+      if (importerModule && importerModule !== "entry.js") {
+        const importerDir = (0, import_node_path.dirname)(importerModule);
+        absPath = (0, import_node_path.join)(importerDir, id);
+        viteManifestKey = (0, import_project_config.ensurePosixPath)((0, import_node_path.relative)((0, import_project_config.getPaths)().web.src, absPath));
+      } else {
+        const normalizedId = id.startsWith("./") ? id.slice(2) : id;
+        absPath = (0, import_node_path.join)((0, import_project_config.getPaths)().web.src, normalizedId);
+        viteManifestKey = (0, import_project_config.ensurePosixPath)(normalizedId);
+      }
+      const copiedAssetPath = buildManifest?.[viteManifestKey]?.file;
+      let assetSrc;
+      if (copiedAssetPath) {
+        assetSrc = copiedAssetPath;
+      } else {
+        assetSrc = (0, import_utils.convertToDataUrl)(absPath);
+      }
+      return `export default ${JSON.stringify(assetSrc)};`;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarjsPrerenderMediaImportsPlugin
+});

package/dist/cjs/build-and-import/rollupPlugins/rollup-plugin-cedarjs-routes-auto-loader.js

@@ -0,0 +1,146 @@
+"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 rollup_plugin_cedarjs_routes_auto_loader_exports = {};
+__export(rollup_plugin_cedarjs_routes_auto_loader_exports, {
+  cedarjsRoutesAutoLoaderPlugin: () => cedarjsRoutesAutoLoaderPlugin
+});
+module.exports = __toCommonJS(rollup_plugin_cedarjs_routes_auto_loader_exports);
+var import_path = __toESM(require("path"), 1);
+var import_pluginutils = require("@rollup/pluginutils");
+var import_project_config = require("@cedarjs/project-config");
+var import_utils = require("./utils.js");
+function getPathRelativeToSrc(maybeAbsolutePath) {
+  if (!import_path.default.isAbsolute(maybeAbsolutePath)) {
+    return maybeAbsolutePath;
+  }
+  return `./${import_path.default.relative((0, import_project_config.getPaths)().web.src, maybeAbsolutePath)}`;
+}
+function withRelativeImports(page) {
+  return {
+    ...page,
+    relativeImport: (0, import_project_config.ensurePosixPath)(getPathRelativeToSrc(page.importPath))
+  };
+}
+function cedarjsRoutesAutoLoaderPlugin() {
+  let pages = (0, import_project_config.processPagesDir)().map(withRelativeImports);
+  const duplicatePageImportNames = /* @__PURE__ */ new Set();
+  const sortedPageImportNames = pages.map((page) => page.importName).sort();
+  for (let i = 0; i < sortedPageImportNames.length - 1; i++) {
+    if (sortedPageImportNames[i + 1] === sortedPageImportNames[i]) {
+      duplicatePageImportNames.add(sortedPageImportNames[i]);
+    }
+  }
+  if (duplicatePageImportNames.size > 0) {
+    const dirList = Array.from(duplicatePageImportNames).map((name) => `'${name}'`).join(", ");
+    throw new Error(
+      `Unable to find only a single file ending in 'Page.{js,jsx,ts,tsx}' in the following page directories: ${dirList}`
+    );
+  }
+  const filter = (0, import_pluginutils.createFilter)(["**/src/Routes.{tsx,jsx,js}"]);
+  return {
+    name: "cedarjs-routes-auto-loader",
+    buildStart() {
+      pages = (0, import_project_config.processPagesDir)().map(withRelativeImports);
+    },
+    transform(code, id) {
+      if (!filter(id)) {
+        return null;
+      }
+      let currentPages = [...pages];
+      const importRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+      let match;
+      const excludedPages = /* @__PURE__ */ new Set();
+      while ((match = importRegex.exec(code)) !== null) {
+        const [_fullMatch, defaultImportName, importPath] = match;
+        const importPathWithoutExtension = importPath.replace(
+          /\.(js|jsx|ts|tsx)$/,
+          ""
+        );
+        const normalizedPathBase = importPathWithoutExtension.replace(
+          /\/[^/]+$/,
+          ""
+        );
+        const normalizedPathFull = importPathWithoutExtension;
+        const userImportRelativePaths = [
+          getPathRelativeToSrc((0, import_project_config.importStatementPath)(normalizedPathBase)),
+          getPathRelativeToSrc((0, import_project_config.importStatementPath)(normalizedPathFull))
+        ];
+        const pageThatUserImported = currentPages.find((page) => {
+          const pageRelativeImport = page.relativeImport.replace(
+            /\.(js|jsx|ts|tsx)$/,
+            ""
+          );
+          const importNameMatches = page.importName === defaultImportName;
+          const pathMatches = userImportRelativePaths.some(
+            (path2) => pageRelativeImport === (0, import_project_config.ensurePosixPath)(path2) || pageRelativeImport.endsWith(`/${path2.split("/").pop()}`)
+          );
+          return importNameMatches || pathMatches;
+        });
+        if (pageThatUserImported) {
+          excludedPages.add(pageThatUserImported.importName);
+          currentPages = currentPages.filter(
+            (page) => page !== pageThatUserImported
+          );
+        }
+      }
+      if (currentPages.length === 0) {
+        return { code, map: null };
+      }
+      const imports = [];
+      const declarations = [];
+      imports.push(`import { lazy } from 'react'`);
+      for (const { importName, relativeImport } of currentPages) {
+        if (excludedPages.has(importName)) {
+          continue;
+        }
+        imports.push(
+          `import __cedarjs_prerender__${importName} from '${relativeImport}';`
+        );
+        const declaration = (0, import_utils.dedent)(8)`const ${importName} = {
+          name: "${importName}",
+          prerenderLoader: (name) => ({ default: __cedarjs_prerender__${importName} }),
+          LazyComponent: lazy(() => import("${relativeImport}"))
+        }`;
+        declarations.push(declaration);
+      }
+      const autoLoaderCode = imports.join("\n") + "\n\n" + declarations.join("\n\n");
+      const finalCode = `${autoLoaderCode}
+
+${code}`;
+      return {
+        code: finalCode,
+        map: null
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cedarjsRoutesAutoLoaderPlugin
+});

package/dist/cjs/build-and-import/rollupPlugins/utils.js

@@ -0,0 +1,78 @@
+"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,
+  dedent: () => dedent
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = __toESM(require("fs"), 1);
+var import_mime_types = __toESM(require("mime-types"), 1);
+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 "";
+  }
+}
+function dedent(indentLevel) {
+  return (strings, ...values) => {
+    let result = strings[0];
+    for (let i = 0; i < values.length; i++) {
+      result += values[i] + strings[i + 1];
+    }
+    const lines = result.split("\n");
+    while (lines.length > 0 && lines[0].trim() === "") {
+      lines.shift();
+    }
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+      lines.pop();
+    }
+    const minIndent = indentLevel;
+    const dedentedLines = lines.map((line) => {
+      if (line.trim() === "") {
+        return "";
+      }
+      const match = line.match(/^(\s*)/);
+      if (match && match[1].length >= minIndent) {
+        return line.slice(minIndent);
+      }
+      return line;
+    });
+    return dedentedLines.join("\n");
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertToDataUrl,
+  dedent
+});

package/dist/cjs/build-and-import/utils.js

@@ -0,0 +1,68 @@
+"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, {
+  JS_EXT_RE: () => JS_EXT_RE,
+  getPkgType: () => getPkgType,
+  getRandomId: () => getRandomId,
+  isValidJsFile: () => isValidJsFile,
+  makeFilePath: () => makeFilePath
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+const JS_EXT_RE = /\.([mc]?[tj]s|[tj]sx)$/;
+function getPkgType() {
+  try {
+    const pkg = JSON.parse(
+      import_node_fs.default.readFileSync(import_node_path.default.resolve("package.json"), "utf-8")
+    );
+    return pkg.type;
+  } catch {
+  }
+  return void 0;
+}
+const getRandomId = () => {
+  return Math.random().toString(36).substring(2, 15);
+};
+function isValidJsFile(filepath) {
+  return JS_EXT_RE.test(filepath);
+}
+function makeFilePath(path2) {
+  return (0, import_node_url.pathToFileURL)(path2).href;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JS_EXT_RE,
+  getPkgType,
+  getRandomId,
+  isValidJsFile,
+  makeFilePath
+});

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

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

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

package/dist/cjs/detection/detection.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/cjs/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/cjs/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/cjs/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/cjs/graphql/graphql.d.ts

@@ -0,0 +1,19 @@
+import type { DocumentNode } from 'graphql';
+export type FileImporter = (path: string) => Promise<any>;
+/**
+ * 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.
+ */
+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(fileImporter: FileImporter): Promise<(operation: Record<string, unknown>) => Promise<any>>;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/cjs/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;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"}