@cedarjs/prerender 0.9.1-next.0 → 0.9.1-next.20

package/dist/browserUtils/index.js

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

package/dist/build-and-import/buildAndImport.d.ts

@@ -0,0 +1,12 @@
+interface Options {
+    /** The filepath to bundle and require */
+    filepath: string;
+    /**
+     * Preserve compiled temporary file for debugging
+     * Default to `process.env.BUNDLE_REQUIRE_PRESERVE`
+     */
+    preserveTemporaryFile?: boolean;
+}
+export declare function buildAndImport(options: Options): Promise<Record<string, React.FunctionComponent>>;
+export {};
+//# sourceMappingURL=buildAndImport.d.ts.map

package/dist/build-and-import/buildAndImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildAndImport.d.ts","sourceRoot":"","sources":["../../src/build-and-import/buildAndImport.ts"],"names":[],"mappings":"AAoCA,UAAU,OAAO;IACf,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAA;IAEhB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC;AAED,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAmIlD"}

package/dist/build-and-import/buildAndImport.js

@@ -0,0 +1,142 @@
+import fs from "node:fs";
+import path from "node:path";
+import alias from "@rollup/plugin-alias";
+import commonjs from "@rollup/plugin-commonjs";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import replace from "@rollup/plugin-replace";
+import { rollup } from "rollup";
+import { swc } from "rollup-plugin-swc3";
+import unimportPlugin from "unimport/unplugin";
+import { getConfig, getPaths, projectIsEsm } from "@cedarjs/project-config";
+import {
+  getPathsFromTypeScriptConfig,
+  parseTypeScriptConfigFiles
+} from "../internal.js";
+import { cellTransformPlugin } from "./rollupPlugins/rollup-plugin-cedarjs-cell.js";
+import { cedarjsDirectoryNamedImportPlugin } from "./rollupPlugins/rollup-plugin-cedarjs-directory-named-imports.js";
+import { externalPlugin } from "./rollupPlugins/rollup-plugin-cedarjs-external.js";
+import { ignoreHtmlAndCssImportsPlugin } from "./rollupPlugins/rollup-plugin-cedarjs-ignore-html-and-css-imports.js";
+import { injectFileGlobalsPlugin } from "./rollupPlugins/rollup-plugin-cedarjs-inject-file-globals.js";
+import { cedarjsPrerenderMediaImportsPlugin } from "./rollupPlugins/rollup-plugin-cedarjs-prerender-media-imports.js";
+import { cedarjsRoutesAutoLoaderPlugin } from "./rollupPlugins/rollup-plugin-cedarjs-routes-auto-loader.js";
+import { getPkgType, isValidJsFile, makeFilePath } from "./utils.js";
+const fix = (f) => f;
+const tsconfigPathsToRegExp = (paths) => {
+  return Object.keys(paths || {}).map((key) => {
+    return new RegExp(`^${key.replace(/\*/g, ".*")}$`);
+  });
+};
+async function buildAndImport(options) {
+  if (!isValidJsFile(options.filepath)) {
+    throw new Error(`${options.filepath} is not a valid JS file`);
+  }
+  const tsConfigs = parseTypeScriptConfigFiles();
+  const resolvePaths = tsconfigPathsToRegExp(
+    tsConfigs.web?.compilerOptions?.paths || {}
+  );
+  const config = getConfig();
+  const useTrustedDocumentsGqlTag = config.graphql.trustedDocuments;
+  const webBase = getPaths().web.base;
+  const outDir = path.join(getPaths().web.dist, "__prerender");
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+  }
+  const isEsm = projectIsEsm();
+  const build = await rollup({
+    input: [options.filepath],
+    output: {
+      dir: outDir
+    },
+    jsx: "react-jsx",
+    logLevel: "debug",
+    external: ["react", "react-dom"],
+    plugins: [
+      externalPlugin({
+        notExternal: resolvePaths,
+        filepath: options.filepath
+      }),
+      nodeResolve({
+        preferBuiltins: true,
+        exportConditions: ["node"],
+        extensions: [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"]
+      }),
+      // @ts-expect-error - Ignore type errors for now
+      replace({
+        preventAssignment: true,
+        "process.env.NODE_ENV": '"production"'
+      }),
+      fix(alias)({
+        entries: [
+          {
+            find: "src",
+            replacement: getPaths().web.src
+          },
+          {
+            find: "$api",
+            replacement: getPaths().api.base
+          },
+          ...getPathsFromTypeScriptConfig(tsConfigs.web, webBase)
+        ]
+      }),
+      ignoreHtmlAndCssImportsPlugin(),
+      cellTransformPlugin(),
+      cedarjsRoutesAutoLoaderPlugin(),
+      cedarjsDirectoryNamedImportPlugin(),
+      cedarjsPrerenderMediaImportsPlugin(),
+      fix(commonjs)(),
+      swc({ sourceMaps: true }),
+      unimportPlugin.rollup({
+        imports: [
+          // import React from 'react'
+          {
+            name: "default",
+            as: "React",
+            from: "react"
+          },
+          // import { gql } from 'graphql-tag'
+          !useTrustedDocumentsGqlTag && isEsm && {
+            name: "gql",
+            from: "graphql-tag"
+          },
+          // import gql from 'graphql-tag'
+          !useTrustedDocumentsGqlTag && !isEsm && {
+            name: "default",
+            as: "gql",
+            from: "graphql-tag"
+          },
+          // import { gql } from 'src/graphql/gql'
+          useTrustedDocumentsGqlTag && {
+            name: "gql",
+            from: `src/graphql/gql.js`
+          }
+        ].filter((v) => Boolean(v))
+      }),
+      injectFileGlobalsPlugin()
+    ]
+  });
+  try {
+    const { output } = await build.generate({
+      dir: outDir,
+      format: getPkgType() === "module" ? "es" : "cjs",
+      exports: "auto",
+      sourcemap: "inline"
+    });
+    for (const chunk of output) {
+      if (chunk.type !== "chunk") {
+        throw new Error("[bundle-require] Expected chunk output");
+      }
+      const chunkPath = path.join(outDir, chunk.fileName);
+      await fs.promises.writeFile(chunkPath, chunk.code, "utf8");
+    }
+    const importPath = makeFilePath(path.join(outDir, output[0].fileName));
+    return import(importPath);
+  } finally {
+    if (!options.preserveTemporaryFile) {
+      await fs.promises.rm(outDir, { recursive: true, force: true });
+    }
+    await build.close();
+  }
+}
+export {
+  buildAndImport
+};

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-cell.d.ts

@@ -0,0 +1,23 @@
+import type { Plugin } from 'rollup';
+/**
+ * Vite plugin that wraps files with a suffix of `Cell` in Redwood's `createCell`
+ * higher order component. The HOC deals with the lifecycle methods during a GraphQL query.
+ *
+ * This transforms:
+ * ```js
+ * export const QUERY = gql`...`
+ * export const Loading = () => <div>Loading...</div>
+ * export const Success = ({ data }) => <div>{data}</div>
+ * ```
+ *
+ * Into:
+ * ```js
+ * import { createCell } from '@cedarjs/web'
+ * export const QUERY = gql`...`
+ * export const Loading = () => <div>Loading...</div>
+ * export const Success = ({ data }) => <div>{data}</div>
+ * export default createCell({ QUERY, Loading, Success, displayName: 'MyCell' })
+ * ```
+ */
+export declare function cellTransformPlugin(): Plugin;
+//# sourceMappingURL=rollup-plugin-cedarjs-cell.d.ts.map

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-cell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-plugin-cedarjs-cell.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/rollup-plugin-cedarjs-cell.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAmBpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAmK5C"}

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-cell.js

@@ -0,0 +1,149 @@
+import { parse as parsePath } from "node:path";
+import babelGenerator from "@babel/generator";
+import { parse } from "@babel/parser";
+import babelTraverse from "@babel/traverse";
+const traverse = babelTraverse.default;
+const generate = babelGenerator.default;
+const EXPECTED_EXPORTS_FROM_CELL = [
+  "beforeQuery",
+  "QUERY",
+  "data",
+  "isEmpty",
+  "afterQuery",
+  "Loading",
+  "Success",
+  "Failure",
+  "Empty"
+];
+function cellTransformPlugin() {
+  return {
+    name: "cedar-cell-transform",
+    transform(code, id) {
+      if (!id.match(/Cell\.[jt]sx?$/)) {
+        return null;
+      }
+      try {
+        const ast = parse(code, {
+          sourceType: "module",
+          plugins: [
+            "jsx",
+            "typescript",
+            "decorators-legacy",
+            "classProperties",
+            "objectRestSpread",
+            "asyncGenerators",
+            "functionBind",
+            "exportDefaultFrom",
+            "exportNamespaceFrom",
+            "dynamicImport",
+            "nullishCoalescingOperator",
+            "optionalChaining"
+          ]
+        });
+        const exportNames = [];
+        let hasDefaultExport = false;
+        traverse(ast, {
+          ExportDefaultDeclaration() {
+            hasDefaultExport = true;
+          },
+          ExportNamedDeclaration(path) {
+            const declaration = path.node.declaration;
+            if (!declaration) {
+              return;
+            }
+            let name;
+            if (declaration.type === "VariableDeclaration") {
+              const id2 = declaration.declarations[0].id;
+              name = id2.name;
+            }
+            if (declaration.type === "FunctionDeclaration") {
+              name = declaration?.id?.name;
+            }
+            if (name && EXPECTED_EXPORTS_FROM_CELL.includes(name)) {
+              exportNames.push(name);
+            }
+          }
+        });
+        const hasQueryOrDataExport = exportNames.includes("QUERY") || exportNames.includes("data");
+        if (hasDefaultExport || !hasQueryOrDataExport) {
+          return null;
+        }
+        const createCellHookName = exportNames.includes("data") ? "createServerCell" : "createCell";
+        const importFrom = exportNames.includes("data") ? "@cedarjs/web/dist/components/cell/createServerCell" : "@cedarjs/web";
+        traverse(ast, {
+          Program(path) {
+            const importDeclaration = {
+              type: "ImportDeclaration",
+              specifiers: [
+                {
+                  type: "ImportSpecifier",
+                  imported: {
+                    type: "Identifier",
+                    name: createCellHookName
+                  },
+                  local: {
+                    type: "Identifier",
+                    name: createCellHookName
+                  }
+                }
+              ],
+              source: { type: "StringLiteral", value: importFrom }
+            };
+            path.node.body.unshift(importDeclaration);
+            const objectProperties = [
+              ...exportNames.map((name) => ({
+                type: "ObjectProperty",
+                key: { type: "Identifier", name },
+                value: { type: "Identifier", name },
+                shorthand: true,
+                computed: false
+              })),
+              // Add the displayName property
+              {
+                type: "ObjectProperty",
+                key: { type: "Identifier", name: "displayName" },
+                value: {
+                  type: "StringLiteral",
+                  value: parsePath(id).name
+                },
+                shorthand: false,
+                computed: false
+              }
+            ];
+            const exportDefaultDeclaration = {
+              type: "ExportDefaultDeclaration",
+              declaration: {
+                type: "CallExpression",
+                callee: {
+                  type: "Identifier",
+                  name: createCellHookName
+                },
+                arguments: [
+                  {
+                    type: "ObjectExpression",
+                    properties: objectProperties
+                  }
+                ]
+              }
+            };
+            path.node.body.push(exportDefaultDeclaration);
+          }
+        });
+        const result = generate(ast, {
+          retainLines: true,
+          compact: false
+        });
+        return {
+          code: result.code,
+          map: result.map
+        };
+      } catch (error) {
+        console.warn(`Failed to transform Cell file ${id}:`, error);
+        return null;
+      }
+    }
+  };
+}
+export {
+  cellTransformPlugin
+};

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-directory-named-imports.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'rollup';
+export declare function cedarjsDirectoryNamedImportPlugin(): Plugin;
+//# sourceMappingURL=rollup-plugin-cedarjs-directory-named-imports.d.ts.map

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-directory-named-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-plugin-cedarjs-directory-named-imports.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/rollup-plugin-cedarjs-directory-named-imports.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAmCpC,wBAAgB,iCAAiC,IAAI,MAAM,CA+B1D"}

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-directory-named-imports.js

@@ -0,0 +1,49 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveFile } from "@cedarjs/project-config";
+function getNewPath(value, filename) {
+  const dirname = path.dirname(value);
+  const basename = path.basename(value);
+  const indexImportPath = [dirname, basename, "index"].join("/");
+  const resolvedFile = resolveFile(
+    path.resolve(path.dirname(filename), indexImportPath)
+  );
+  if (resolvedFile) {
+    return resolvedFile;
+  } else {
+    const dirnameImportPath = [dirname, basename, basename].join("/");
+    const dirnameResolvedFile = resolveFile(
+      path.resolve(path.dirname(filename), dirnameImportPath)
+    );
+    if (dirnameResolvedFile) {
+      return dirnameResolvedFile;
+    }
+  }
+  return null;
+}
+function cedarjsDirectoryNamedImportPlugin() {
+  return {
+    name: "cedarjs-directory-named-import",
+    resolveId(id, importer) {
+      if (!importer || importer.includes("/node_modules/")) {
+        return null;
+      }
+      const resolvedPath = path.resolve(path.dirname(importer), id);
+      if (fs.existsSync(resolvedPath)) {
+        const stats = fs.statSync(resolvedPath);
+        if (stats.isFile()) {
+          return null;
+        }
+      }
+      const newPath = getNewPath(id, importer);
+      if (!newPath) {
+        return null;
+      }
+      const resolvedDirnamePath = path.resolve(path.dirname(importer), newPath);
+      return resolvedDirnamePath;
+    }
+  };
+}
+export {
+  cedarjsDirectoryNamedImportPlugin
+};

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-external.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin as RollupPlugin } from 'rollup';
+/** A rollup plugin to mark node_modules as external */
+export declare const externalPlugin: ({ external, notExternal, filepath, externalNodeModules, }: {
+    filepath: string;
+    external?: (string | RegExp)[];
+    notExternal?: (string | RegExp)[];
+    externalNodeModules?: boolean;
+}) => RollupPlugin;
+//# sourceMappingURL=rollup-plugin-cedarjs-external.d.ts.map

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-external.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-plugin-cedarjs-external.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/rollup-plugin-cedarjs-external.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,QAAQ,CAAA;AAKpD,uDAAuD;AACvD,eAAO,MAAM,cAAc,8DAKxB;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IAC9B,WAAW,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IACjC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B,KAAG,YAmFH,CAAA"}

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-external.js

@@ -0,0 +1,91 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const PATH_NODE_MODULES_RE = /[\/\\]node_modules[\/\\]/;
+const externalPlugin = ({
+  external,
+  notExternal,
+  filepath,
+  externalNodeModules = true
+}) => {
+  const extNodeModules = externalNodeModules ?? !filepath.match(PATH_NODE_MODULES_RE);
+  const builtinModules = /* @__PURE__ */ new Set([
+    "assert",
+    "buffer",
+    "child_process",
+    "cluster",
+    "crypto",
+    "dgram",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "https",
+    "net",
+    "os",
+    "path",
+    "punycode",
+    "querystring",
+    "readline",
+    "stream",
+    "string_decoder",
+    "tls",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "zlib",
+    "constants",
+    "sys",
+    "module",
+    "process",
+    "inspector",
+    "async_hooks",
+    "http2",
+    "perf_hooks",
+    "trace_events",
+    "worker_threads",
+    "repl",
+    "timers"
+  ]);
+  return {
+    name: "bundle-require:external",
+    resolveId(id, importer) {
+      if (builtinModules.has(id) || id.startsWith("node:")) {
+        return { id, external: true };
+      }
+      if (match(id, external)) {
+        return { id, external: true };
+      }
+      if (match(id, notExternal)) {
+        return null;
+      }
+      if (extNodeModules && id.match(PATH_NODE_MODULES_RE)) {
+        const resolved = id.startsWith(".") && importer ? path.resolve(path.dirname(importer), id) : id;
+        return {
+          id: pathToFileURL(resolved).toString(),
+          external: true
+        };
+      }
+      if (id.startsWith(".") || path.isAbsolute(id)) {
+        return null;
+      }
+      return { id, external: true };
+    }
+  };
+};
+function match(id, patterns) {
+  if (!patterns) {
+    return false;
+  }
+  return patterns.some((p) => {
+    if (p instanceof RegExp) {
+      return p.test(id);
+    }
+    return id === p || id.startsWith(p + "/");
+  });
+}
+export {
+  externalPlugin
+};

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-ignore-html-and-css-imports.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin as RollupPlugin } from 'rollup';
+/**
+ * A Rollup plugin that ignores imports of HTML and CSS files by replacing them with empty modules.
+ * This is useful when bundling code that imports these files for webpack or other bundlers,
+ * but you want Rollup to ignore them during the build process.
+ *
+ * @param options Configuration options
+ * @returns Rollup plugin
+ *
+ * @example
+ * ```js
+ * import { ignoreHtmlAndCssImportsPlugin } from './rollup-plugin-ignore-html-and-css-imports'
+ *
+ * export default {
+ *   plugins: [
+ *     ignoreHtmlAndCssImportsPlugin({
+ *       removeExtensions: ['.html', '.css', '.scss', '.sass']
+ *     })
+ *   ]
+ * }
+ * ```
+ */
+export declare const ignoreHtmlAndCssImportsPlugin: () => RollupPlugin;
+//# sourceMappingURL=rollup-plugin-cedarjs-ignore-html-and-css-imports.d.ts.map

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-ignore-html-and-css-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-plugin-cedarjs-ignore-html-and-css-imports.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/rollup-plugin-cedarjs-ignore-html-and-css-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,QAAQ,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,6BAA6B,QAAO,YAyBhD,CAAA"}

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-ignore-html-and-css-imports.js

@@ -0,0 +1,24 @@
+const ignoreHtmlAndCssImportsPlugin = () => {
+  const fileTypes = [".html", ".scss", ".css"];
+  return {
+    name: "ignore-html-and-css-imports",
+    resolveId(id) {
+      if (fileTypes.some((ext) => id.endsWith(ext))) {
+        return {
+          id: `\0virtual:ignore-${id}`,
+          external: false
+        };
+      }
+      return null;
+    },
+    load(id) {
+      if (id.startsWith("\0virtual:ignore-")) {
+        return "export default {};";
+      }
+      return null;
+    }
+  };
+};
+export {
+  ignoreHtmlAndCssImportsPlugin
+};

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-inject-file-globals.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin as RollupPlugin } from 'rollup';
+export declare const injectFileGlobalsPlugin: () => RollupPlugin;
+//# sourceMappingURL=rollup-plugin-cedarjs-inject-file-globals.d.ts.map

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-inject-file-globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-plugin-cedarjs-inject-file-globals.d.ts","sourceRoot":"","sources":["../../../src/build-and-import/rollupPlugins/rollup-plugin-cedarjs-inject-file-globals.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,QAAQ,CAAA;AAQpD,eAAO,MAAM,uBAAuB,QAAO,YA6B1C,CAAA"}

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-inject-file-globals.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { JS_EXT_RE } from "../utils.js";
+const DIRNAME_VAR_NAME = "__injected_dirname__";
+const FILENAME_VAR_NAME = "__injected_filename__";
+const IMPORT_META_URL_VAR_NAME = "__injected_import_meta_url__";
+const injectFileGlobalsPlugin = () => {
+  return {
+    name: "bundle-require:inject-file-globals",
+    transform(code, id) {
+      if (!JS_EXT_RE.test(id)) {
+        return null;
+      }
+      const transformedCode = code.replace(/\b__filename\b/g, FILENAME_VAR_NAME).replace(/\b__dirname\b/g, DIRNAME_VAR_NAME).replace(/\bimport\.meta\.url\b/g, IMPORT_META_URL_VAR_NAME);
+      const injectLines = [
+        `const ${FILENAME_VAR_NAME} = ${JSON.stringify(id)};`,
+        `const ${DIRNAME_VAR_NAME} = ${JSON.stringify(path.dirname(id))};`,
+        `const ${IMPORT_META_URL_VAR_NAME} = ${JSON.stringify(
+          pathToFileURL(id).href
+        )};`
+      ];
+      return {
+        code: injectLines.join("\n") + "\n" + transformedCode,
+        // TODO: Generate a proper source map
+        map: { mappings: "" }
+      };
+    }
+  };
+};
+export {
+  injectFileGlobalsPlugin
+};

package/dist/build-and-import/rollupPlugins/rollup-plugin-cedarjs-prerender-media-imports.d.ts

@@ -0,0 +1,25 @@
+import type { Plugin } from 'rollup';
+export interface PrerenderMediaImportsOptions {
+    extensions?: string[];
+}
+/**
+ * A Rollup plugin that transforms media imports during prerendering.
+ *
+ * This plugin processes imports of media files (images, fonts, etc.) and either:
+ * 1. Replaces them with the built asset path from the Vite manifest, or
+ * 2. Converts them to base64 data URLs if not found in the manifest
+ *
+ * # Example transformation
+ *
+ * ```javascript
+ * // Before
+ * import logo from './logo.png'
+ *
+ * // After (if in manifest)
+ * const logo = 'assets/logo-abc123.png'
+ *
+ * // After (if not in manifest)
+ * const logo = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...'
+ */
+export declare function cedarjsPrerenderMediaImportsPlugin(options?: PrerenderMediaImportsOptions): Plugin;
+//# sourceMappingURL=rollup-plugin-cedarjs-prerender-media-imports.d.ts.map