@cedarjs/vite 7.0.1-next.466 → 7.1.0-rc.32

package/dist/lib/sandboxChildren.js

@@ -1,157 +0,0 @@
-import fs from "node:fs";
-import { isBuiltin } from "node:module";
-import path from "node:path";
-import fg from "fast-glob";
-const SANDBOX_CHILDREN_DIR = "sandbox-children";
-function findSandboxChildScripts(apiSrc) {
-  const files = fg.sync("**/*.child.{ts,js,mts,mjs}", {
-    cwd: apiSrc,
-    absolute: true,
-    ignore: ["**/node_modules/**", "**/__tests__/**"]
-  }).sort();
-  const entries = {};
-  for (const file of files) {
-    const name = path.basename(file).replace(/\.(ts|js|mts|mjs)$/, "");
-    const key = `${SANDBOX_CHILDREN_DIR}/${name}`;
-    if (entries[key]) {
-      throw new Error(
-        `Two sandboxed child scripts are named ${name}: ${path.relative(apiSrc, entries[key])} and ${path.relative(apiSrc, file)}. A bundled build puts every child script in one folder, so their names must be unique.`
-      );
-    }
-    entries[key] = path.normalize(file);
-  }
-  return entries;
-}
-const packageName = (specifier) => {
-  const parts = specifier.split("/");
-  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
-};
-const readPackageJson = (dir) => {
-  const parsed = JSON.parse(
-    fs.readFileSync(path.join(dir, "package.json"), "utf8")
-  );
-  return parsed && typeof parsed === "object" ? parsed : {};
-};
-const findPackage = (name, dir) => {
-  let current = dir;
-  for (; ; ) {
-    const candidate = path.join(current, "node_modules", name);
-    if (fs.existsSync(path.join(candidate, "package.json"))) {
-      return { realDir: fs.realpathSync(candidate), foundIn: current };
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-};
-function vendorSandboxChildPackages(childrenDir, children) {
-  const copyOf = /* @__PURE__ */ new Map();
-  const occupied = /* @__PURE__ */ new Map();
-  const inNodeModules = (dir) => dir.split(path.sep).includes("node_modules");
-  const reachableFrom = (copy, name) => {
-    let dir = copy;
-    for (; ; ) {
-      const there = occupied.get(path.join(dir, "node_modules", name));
-      if (there || dir === childrenDir) {
-        return there?.realDir;
-      }
-      dir = path.dirname(dir);
-    }
-  };
-  const visit = (name, fromDir, dependentCopy, required, dependent) => {
-    const found = findPackage(name, fromDir);
-    if (!found) {
-      if (required) {
-        throw new Error(
-          `Can't find package "${name}", which ${dependent} imports, in a node_modules folder above ${fromDir}`
-        );
-      }
-      return;
-    }
-    const { realDir, foundIn } = found;
-    const reachable = reachableFrom(dependentCopy, name);
-    if (reachable === realDir) {
-      return;
-    }
-    const copiedFolder = copyOf.get(foundIn);
-    const besideDependent = path.join(dependentCopy, "node_modules", name);
-    const target = copiedFolder ? path.join(copiedFolder, "node_modules", name) : inNodeModules(foundIn) || reachable ? besideDependent : path.join(childrenDir, "node_modules", name);
-    const there = occupied.get(target);
-    if (there) {
-      throw new Error(
-        `Sandboxed child scripts need two versions of "${name}" in one place: ${there.realDir} (for ${there.neededBy}) and ${realDir} (for ${dependent}). Install a single version of it, or move the children so their imports resolve the same way.`
-      );
-    }
-    occupied.set(target, { realDir, neededBy: dependent });
-    if (!copyOf.has(realDir)) {
-      copyOf.set(realDir, target);
-    }
-    fs.cpSync(realDir, target, {
-      recursive: true,
-      dereference: true,
-      // Its own node_modules are copied as dependencies, when they're needed
-      filter: (src) => src !== path.join(realDir, "node_modules")
-    });
-    const pkg = readPackageJson(realDir);
-    const optional = /* @__PURE__ */ new Set([
-      ...Object.keys(pkg.optionalDependencies ?? {}),
-      ...Object.keys(pkg.peerDependencies ?? {})
-    ]);
-    for (const dep of Object.keys(pkg.dependencies ?? {})) {
-      visit(dep, realDir, target, !optional.has(dep), name);
-    }
-    for (const dep of optional) {
-      visit(dep, realDir, target, false, name);
-    }
-  };
-  for (const { source, imports } of children) {
-    for (const specifier of imports) {
-      if (isBuiltin(specifier) || specifier.startsWith("#")) {
-        continue;
-      }
-      visit(
-        packageName(specifier),
-        fs.realpathSync(path.dirname(source)),
-        childrenDir,
-        true,
-        path.basename(source)
-      );
-    }
-  }
-}
-const findVercelFunctionDirs = (dir) => fs.existsSync(dir) ? fs.readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
-  const entryPath = path.join(dir, entry.name);
-  return entry.name.endsWith(".func") ? [entryPath] : findVercelFunctionDirs(entryPath);
-}) : [];
-function copySandboxChildrenIntoVercelFunctions({
-  appRoot,
-  childrenDir,
-  functionsDir
-}) {
-  const childrenDirInApp = path.relative(appRoot, childrenDir);
-  if (!fs.existsSync(childrenDir)) {
-    return [];
-  }
-  const functionDirs = findVercelFunctionDirs(functionsDir).filter((dir) => {
-    const config = path.join(dir, ".vc-config.json");
-    if (!fs.existsSync(config)) {
-      return false;
-    }
-    const parsed = JSON.parse(fs.readFileSync(config, "utf8"));
-    return !!parsed && typeof parsed === "object" && "runtime" in parsed && typeof parsed.runtime === "string" && parsed.runtime.startsWith("nodejs");
-  });
-  for (const dir of functionDirs) {
-    fs.cpSync(childrenDir, path.join(dir, childrenDirInApp), {
-      recursive: true
-    });
-  }
-  return functionDirs;
-}
-export {
-  SANDBOX_CHILDREN_DIR,
-  copySandboxChildrenIntoVercelFunctions,
-  findSandboxChildScripts,
-  vendorSandboxChildPackages
-};

package/dist/plugins/vite-plugin-cedar-parsed-scalars.d.ts

@@ -1,20 +0,0 @@
-import type { Plugin } from 'vite';
-/**
- * Gives `CedarApolloProvider` the cache config for the scalars in
- * `graphql.parsedScalars` in `cedar.toml`. Does nothing when no scalar is set
- * to be parsed.
- *
- * The config comes from the project's generated GraphQL schema, so it is built
- * into the virtual module `virtual:cedar-parsed-scalars` rather than into the
- * provider, which is a published package that Vite pre-bundles in dev. The
- * module puts the config on `globalThis.__CEDAR__PARSED_SCALARS`, where the
- * provider reads it when it creates the cache, and `App` and the web test
- * setup file import the module so that every entry point that renders the
- * provider has it. The module is a
- * dependency of the generated schema file, so a change to the schema reloads
- * the app. The generated schema is only read, and `graphql` and its schema
- * loader only imported, when the virtual module is actually resolved, so a
- * project that doesn't use this setting doesn't pay for loading them.
- */
-export declare function cedarParsedScalarsPlugin(): Plugin | undefined;
-//# sourceMappingURL=vite-plugin-cedar-parsed-scalars.d.ts.map

package/dist/plugins/vite-plugin-cedar-parsed-scalars.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-plugin-cedar-parsed-scalars.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-parsed-scalars.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAclC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,GAAG,SAAS,CA4E7D"}

package/dist/plugins/vite-plugin-cedar-parsed-scalars.js

@@ -1,60 +0,0 @@
-import { normalizePath } from "vite";
-import { getParsedScalars, getPaths } from "@cedarjs/project-config";
-const VIRTUAL_MODULE_ID = "virtual:cedar-parsed-scalars";
-const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-const APP_FILE_REGEXP = /web[\\/]src[\\/]App\.(ts|tsx|js|jsx)$/;
-const VITEST_WEB_SETUP_FILE_REGEXP = /[\\/]vitest-web\.setup\.(ts|js)$/;
-function cedarParsedScalarsPlugin() {
-  if (Object.keys(getParsedScalars()).length === 0) {
-    return void 0;
-  }
-  return {
-    name: "cedar-parsed-scalars",
-    resolveId(id) {
-      if (id === VIRTUAL_MODULE_ID) {
-        return RESOLVED_VIRTUAL_MODULE_ID;
-      }
-      return null;
-    },
-    async load(id) {
-      if (id !== RESOLVED_VIRTUAL_MODULE_ID) {
-        return null;
-      }
-      this.addWatchFile(getPaths().generated.schema);
-      const { loadParsedScalarsCacheConfig } = await import("@cedarjs/internal/dist/generate/parsedScalars.js");
-      const config = loadParsedScalarsCacheConfig();
-      return `globalThis.__CEDAR__PARSED_SCALARS = ${JSON.stringify(config)}`;
-    },
-    transform(code, id) {
-      if (!APP_FILE_REGEXP.test(id) && !VITEST_WEB_SETUP_FILE_REGEXP.test(id)) {
-        return null;
-      }
-      return `import '${VIRTUAL_MODULE_ID}'
-${code}`;
-    },
-    // `this.addWatchFile` in `load` only reruns the virtual module for a
-    // change to a file it has already watched. The schema doesn't exist yet
-    // on a clean `cedar dev` (the web server and `cedar-gen-watch` start
-    // concurrently), so its first appearance is a 'create' event on a path
-    // nothing has watched yet, and reaches here without an `addWatchFile`
-    // call ever having registered it. Reload the virtual module for exactly
-    // that file, on every event type, so the app picks up the first schema
-    // once `cedar-gen-watch` writes it, the same way it already does for a
-    // later edit.
-    hotUpdate(options) {
-      if (options.file !== normalizePath(getPaths().generated.schema)) {
-        return;
-      }
-      const moduleGraph = this.environment.moduleGraph;
-      const module = moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
-      if (!module) {
-        return;
-      }
-      moduleGraph.invalidateModule(module);
-      return [module];
-    }
-  };
-}
-export {
-  cedarParsedScalarsPlugin
-};

package/dist/plugins/vite-plugin-cedar-sandbox-children.d.ts

@@ -1,20 +0,0 @@
-import type { Plugin } from 'vite';
-/**
- * For the bundled API build (`cedar build --ud`): the sandboxed child
- * scripts in api/src are extra entries of the build (see
- * `findSandboxChildScripts()`), so each comes out as
- * `sandbox-children/<name>.child.js`. This plugin checks that each child
- * stands alone, importing only packages and Node builtins (it can read
- * nothing of the app), and then copies the packages they import into
- * `sandbox-children/node_modules`.
- *
- * `findChildScript()` from `@cedarjs/api/sandbox` finds the children there
- * from code in the bundle.
- */
-export declare function cedarSandboxChildrenPlugin({ environment, children, }: {
-    /** The bundled build's environment */
-    environment: string;
-    /** The child scripts' entries: `{ 'sandbox-children/x.child': file }` */
-    children: Record<string, string>;
-}): Plugin;
-//# sourceMappingURL=vite-plugin-cedar-sandbox-children.d.ts.map

package/dist/plugins/vite-plugin-cedar-sandbox-children.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vite-plugin-cedar-sandbox-children.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-cedar-sandbox-children.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AASlC;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,WAAW,EACX,QAAQ,GACT,EAAE;IACD,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjC,GAAG,MAAM,CAmDT"}

package/dist/plugins/vite-plugin-cedar-sandbox-children.js

@@ -1,58 +0,0 @@
-import path from "node:path";
-import { normalizePath } from "vite";
-import {
-  SANDBOX_CHILDREN_DIR,
-  vendorSandboxChildPackages
-} from "../lib/sandboxChildren.js";
-function cedarSandboxChildrenPlugin({
-  environment,
-  children
-}) {
-  const sources = new Set(
-    Object.values(children).map((file) => normalizePath(file))
-  );
-  let imports = [];
-  return {
-    name: "cedar-sandbox-children",
-    apply: "build",
-    applyToEnvironment(env) {
-      return env.name === environment;
-    },
-    generateBundle(_options, bundle) {
-      imports = [];
-      for (const chunk of Object.values(bundle)) {
-        if (chunk.type !== "chunk" || !chunk.facadeModuleId) {
-          continue;
-        }
-        const source = normalizePath(chunk.facadeModuleId);
-        if (!sources.has(source)) {
-          continue;
-        }
-        const bundled = [...chunk.imports, ...chunk.dynamicImports].filter(
-          (id) => id in bundle
-        );
-        if (bundled.length > 0) {
-          this.error(
-            `${path.basename(source)} imports your app's own code (${bundled.join(", ")}). A sandboxed child script may import only packages and Node builtins: it runs in a process that can't read the rest of your app.`
-          );
-        }
-        imports.push({
-          source,
-          imports: [...chunk.imports, ...chunk.dynamicImports]
-        });
-      }
-    },
-    writeBundle(options) {
-      if (imports.length === 0 || !options.dir) {
-        return;
-      }
-      vendorSandboxChildPackages(
-        path.join(options.dir, SANDBOX_CHILDREN_DIR),
-        imports
-      );
-    }
-  };
-}
-export {
-  cedarSandboxChildrenPlugin
-};