@visulima/task-runner 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/computeTaskHash-BoCnnvIJ.js

@@ -0,0 +1,356 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  execFile
+} = __cjs_getBuiltinModule("node:child_process");
+const {
+  readFile
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { b as hashStrings, s as sortObjectKeys, c as collectFiles, x as xxh3Hash, e as createXxh3Hasher } from './utils-zO0ZRgtf.js';
+import { join, resolve, relative } from '@visulima/path';
+import { getFrameworkEnvVariables } from './detectFrameworks-CeFzKE6J.js';
+import { LockfileHasher } from './extractPackageName-CbVNW-dr.js';
+import { loadNativeBindings } from './isNativeAvailable-BWhnZ4ES.js';
+
+const DEFAULT_GLOBAL_INPUTS = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "tsconfig.base.json", "tsconfig.json", ".env"];
+const IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "coverage", "dist", "node_modules"]);
+const LOCKFILE_NAMES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]);
+let cachedNative;
+const getNativeBindings = () => {
+  if (cachedNative === void 0) {
+    cachedNative = loadNativeBindings();
+  }
+  return cachedNative;
+};
+const hashSortedEntries = (hash, record, prefix) => {
+  for (const key of Object.keys(record).toSorted()) {
+    {
+      hash.update(`${key}\0`);
+    }
+    hash.update(record[key]);
+  }
+};
+const executeRuntimeCommand = (runtime) => {
+  if (runtime === "node -v" || runtime === "node --version") {
+    return Promise.resolve(process.version);
+  }
+  const parts = runtime.split(/\s+/);
+  const command = parts[0];
+  const args = parts.slice(1);
+  return new Promise((resolve2) => {
+    execFile(command, args, { timeout: 1e4 }, (error, stdout) => {
+      if (error) {
+        resolve2(`__runtime_error__:${runtime}`);
+      } else {
+        resolve2(stdout.trim());
+      }
+    });
+  });
+};
+const runtimeCache = /* @__PURE__ */ new Map();
+const hashRuntimeValue = async (runtime) => {
+  let output = runtimeCache.get(runtime);
+  if (output === void 0) {
+    output = await executeRuntimeCommand(runtime);
+    runtimeCache.set(runtime, output);
+  }
+  return hashStrings(runtime, output);
+};
+const isFileSetInput = (input) => "fileset" in input;
+const isRuntimeInput = (input) => "runtime" in input;
+const isEnvironmentInput = (input) => "env" in input;
+const isExternalDependencyInput = (input) => "externalDependencies" in input;
+class InProcessTaskHasher {
+  #workspaceRoot;
+  #projects;
+  #namedInputs;
+  #targetDefaults;
+  #envVars;
+  #globalInputs;
+  #globalEnv;
+  #fileHashCache = /* @__PURE__ */ new Map();
+  #native;
+  #smartLockfileHashing;
+  #lockfileHasher;
+  #frameworkInference;
+  #globalHash = void 0;
+  constructor(options) {
+    this.#workspaceRoot = options.workspaceRoot;
+    this.#projects = options.projects;
+    this.#namedInputs = options.namedInputs ?? {};
+    this.#targetDefaults = options.targetDefaults ?? {};
+    this.#envVars = options.envVars ?? [];
+    this.#globalInputs = options.globalInputs ?? DEFAULT_GLOBAL_INPUTS;
+    this.#globalEnv = options.globalEnv ?? [];
+    this.#native = getNativeBindings();
+    this.#smartLockfileHashing = options.smartLockfileHashing ?? false;
+    this.#lockfileHasher = this.#smartLockfileHashing ? new LockfileHasher(options.workspaceRoot) : void 0;
+    this.#frameworkInference = options.frameworkInference ?? false;
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async hashTask(task) {
+    const commandHash = this.#hashCommand(task);
+    const nodes = {};
+    const implicitDeps = {};
+    const runtime = {};
+    const globalHash = await this.#computeGlobalHash();
+    if (globalHash) {
+      implicitDeps["__global__"] = globalHash;
+    }
+    const inputs = this.#resolveInputs(task);
+    const negationPatterns = this.#collectNegationPatterns(inputs, task.target.project);
+    for (const input of inputs) {
+      if (isFileSetInput(input)) {
+        const fileHashes = await this.#hashFileSet(task, input.fileset, negationPatterns);
+        for (const [filePath, hash] of Object.entries(fileHashes)) {
+          nodes[filePath] = hash;
+        }
+      } else if (isRuntimeInput(input)) {
+        runtime[input.runtime] = await hashRuntimeValue(input.runtime);
+      } else if (isEnvironmentInput(input)) {
+        runtime[`env:${input.env}`] = hashStrings(input.env, process.env[input.env] ?? "");
+      } else if (isExternalDependencyInput(input)) {
+        const depHashes = await Promise.all(input.externalDependencies.map(async (dep) => [dep, await this.#hashExternalDependency(dep)]));
+        for (const [dep, hash] of depHashes) {
+          implicitDeps[dep] = hash;
+        }
+      }
+    }
+    for (const envVariable of this.#envVars) {
+      runtime[`env:${envVariable}`] = hashStrings(envVariable, process.env[envVariable] ?? "");
+    }
+    const project = this.#projects[task.target.project];
+    if (project) {
+      if (this.#lockfileHasher) {
+        const lockfileHash = await this.#lockfileHasher.hashForPackage(join(project.root, "package.json"));
+        if (lockfileHash) {
+          implicitDeps["__lockfile__"] = lockfileHash.hash;
+        }
+      }
+      if (this.#frameworkInference) {
+        const packageJsonPath = resolve(this.#workspaceRoot, project.root, "package.json");
+        const frameworkEnvVariables = await getFrameworkEnvVariables(packageJsonPath);
+        for (const envName of Object.keys(frameworkEnvVariables)) {
+          runtime[`framework-env:${envName}`] = hashStrings(envName, process.env[envName] ?? "");
+        }
+      }
+    }
+    return {
+      command: commandHash,
+      implicitDeps: Object.keys(implicitDeps).length > 0 ? implicitDeps : void 0,
+      nodes,
+      runtime: Object.keys(runtime).length > 0 ? runtime : void 0
+    };
+  }
+  /**
+   * Hashes the command identity for a task using xxh3-128.
+   * Uses native Rust implementation when available, otherwise pure TS xxh3-ts.
+   * Both produce identical xxh3-128 output.
+   */
+  #hashCommand(task) {
+    const overridesJson = JSON.stringify(sortObjectKeys(task.overrides));
+    if (this.#native) {
+      return this.#native.hashCommand(task.target.project, task.target.target, task.target.configuration ?? void 0, overridesJson);
+    }
+    const hash = createXxh3Hasher();
+    hash.update(task.target.project);
+    hash.update(task.target.target);
+    if (task.target.configuration) {
+      hash.update(task.target.configuration);
+    }
+    hash.update(overridesJson);
+    return hash.digest();
+  }
+  #resolveInputs(task) {
+    const project = this.#projects[task.target.project];
+    const targetConfig = project?.targets?.[task.target.target];
+    const defaultConfig = this.#targetDefaults[task.target.target];
+    const rawInputs = targetConfig?.inputs ?? defaultConfig?.inputs;
+    if (!rawInputs) {
+      return [{ fileset: "{projectRoot}/**/*" }];
+    }
+    return this.#expandInputs(rawInputs, task.target.project);
+  }
+  #expandInputs(inputs, projectName) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const input of inputs) {
+      if (typeof input === "string") {
+        if (input.startsWith("{") || input.startsWith("!{")) {
+          result.push({ fileset: input });
+        } else if (input.startsWith("^")) {
+          continue;
+        } else if (this.#namedInputs[input] && !seen.has(input)) {
+          seen.add(input);
+          result.push(...this.#expandInputs(this.#namedInputs[input], projectName));
+        } else {
+          result.push({ fileset: input });
+        }
+      } else {
+        result.push(input);
+      }
+    }
+    return result;
+  }
+  #collectNegationPatterns(inputs, projectName) {
+    const project = this.#projects[projectName];
+    const projectRoot = project?.root ?? "";
+    const patterns = [];
+    for (const input of inputs) {
+      if (!isFileSetInput(input)) {
+        continue;
+      }
+      const resolved = input.fileset.replace("{projectRoot}", projectRoot).replace("{workspaceRoot}", ".");
+      if (resolved.startsWith("!")) {
+        patterns.push(
+          resolved.slice(1).replace(/\/\*\*\/\*$/, "").replace(/\/\*$/, "")
+        );
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Hashes all files matching a fileset pattern.
+   * Uses native Rust parallel hashing (via rayon) when available.
+   */
+  async #hashFileSet(task, pattern, negationPatterns = []) {
+    const project = this.#projects[task.target.project];
+    const projectRoot = project?.root ?? "";
+    const resolvedPattern = pattern.replace("{projectRoot}", projectRoot).replace("{workspaceRoot}", ".");
+    if (resolvedPattern.startsWith("!")) {
+      return {};
+    }
+    const absoluteBase = resolve(this.#workspaceRoot, resolvedPattern.replace(/\/\*\*\/\*$/, "").replace(/\/\*$/, ""));
+    const absoluteNegations = negationPatterns.map((p) => resolve(this.#workspaceRoot, p));
+    const result = {};
+    const isExcluded = (filePath) => absoluteNegations.some((neg) => filePath.startsWith(`${neg}/`) || filePath === neg);
+    try {
+      if (this.#native) {
+        const fileHashes = this.#native.hashFilesInDirectory(absoluteBase, this.#workspaceRoot);
+        for (const { hash, path } of fileHashes) {
+          const absPath = resolve(this.#workspaceRoot, path);
+          if (!isExcluded(absPath)) {
+            result[path] = hash;
+            this.#fileHashCache.set(absPath, hash);
+          }
+        }
+        return result;
+      }
+      const files = await collectFiles(absoluteBase, IGNORED_DIRS);
+      const hashPromises = files.map(async (filePath) => {
+        if (isExcluded(filePath)) {
+          return;
+        }
+        const hash = await this.#hashFile(filePath);
+        if (hash) {
+          result[relative(this.#workspaceRoot, filePath)] = hash;
+        }
+      });
+      await Promise.all(hashPromises);
+    } catch {
+    }
+    return result;
+  }
+  async #hashFile(filePath) {
+    const cached = this.#fileHashCache.get(filePath);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const content = await readFile(filePath);
+      const hash = xxh3Hash(content);
+      this.#fileHashCache.set(filePath, hash);
+      return hash;
+    } catch {
+      return void 0;
+    }
+  }
+  async #hashExternalDependency(depName) {
+    try {
+      const packageJsonPath = join(this.#workspaceRoot, "node_modules", depName, "package.json");
+      const packageJsonContent = await readFile(packageJsonPath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      return hashStrings(depName, packageJson.version ?? "unknown");
+    } catch {
+      return hashStrings(depName, "not-installed");
+    }
+  }
+  /**
+   * Computes a combined hash of all global inputs and global env vars.
+   * Cached after first computation.
+   */
+  async #computeGlobalHash() {
+    if (this.#globalHash !== void 0) {
+      return this.#globalHash;
+    }
+    const hash = createXxh3Hasher();
+    let hasContent = false;
+    const globalFileHashes = await Promise.all(
+      this.#globalInputs.filter((input) => !(this.#smartLockfileHashing && LOCKFILE_NAMES.has(input))).map(async (globalInput) => {
+        const fileHash = await this.#hashFile(join(this.#workspaceRoot, globalInput));
+        return fileHash ? { hash: fileHash, name: globalInput } : void 0;
+      })
+    );
+    for (const entry of globalFileHashes) {
+      if (entry) {
+        hash.update(entry.name);
+        hash.update(entry.hash);
+        hasContent = true;
+      }
+    }
+    for (const envName of this.#globalEnv) {
+      hash.update(`globalEnv:${envName}=${process.env[envName] ?? ""}`);
+      hasContent = true;
+    }
+    this.#globalHash = hasContent ? hash.digest() : "";
+    return this.#globalHash || void 0;
+  }
+  clearCache() {
+    this.#fileHashCache.clear();
+    this.#globalHash = void 0;
+    this.#lockfileHasher?.clearCache();
+  }
+}
+const computeTaskHash = (hashDetails) => {
+  const native = getNativeBindings();
+  if (native) {
+    const nodes = Object.keys(hashDetails.nodes).toSorted().map((key) => [key, hashDetails.nodes[key]]);
+    const implicitDeps = hashDetails.implicitDeps ? Object.keys(hashDetails.implicitDeps).toSorted().map((key) => [key, hashDetails.implicitDeps[key]]) : void 0;
+    const runtime = hashDetails.runtime ? Object.keys(hashDetails.runtime).toSorted().map((key) => [key, hashDetails.runtime[key]]) : void 0;
+    return native.computeTaskHash({
+      command: hashDetails.command,
+      implicit_deps: implicitDeps,
+      nodes,
+      runtime
+    });
+  }
+  const hash = createXxh3Hasher();
+  hash.update(hashDetails.command);
+  hashSortedEntries(hash, hashDetails.nodes);
+  if (hashDetails.implicitDeps) {
+    hashSortedEntries(hash, hashDetails.implicitDeps);
+  }
+  if (hashDetails.runtime) {
+    hashSortedEntries(hash, hashDetails.runtime);
+  }
+  return hash.digest();
+};
+
+export { InProcessTaskHasher, computeTaskHash };

package/dist/packem_shared/createTaskGraph-CcsFaSrz.js

@@ -0,0 +1,164 @@
+const getTaskId = (target) => {
+  const parts = [target.project, target.target];
+  if (target.configuration) {
+    parts.push(target.configuration);
+  }
+  return parts.join(":");
+};
+const parseTaskId = (taskId) => {
+  const parts = taskId.split(":");
+  if (parts.length < 2) {
+    throw new Error(`Invalid task ID: ${taskId}`);
+  }
+  return {
+    configuration: parts[2],
+    project: parts[0],
+    target: parts[1]
+  };
+};
+const getTaskOutputs = (projectName, targetName, workspace, targetDefaults) => {
+  const project = workspace.projects[projectName];
+  const targetConfig = project?.targets?.[targetName];
+  const defaultConfig = targetDefaults?.[targetName];
+  const outputs = targetConfig?.outputs ?? defaultConfig?.outputs ?? [];
+  return outputs.map((output) => output.replace("{projectRoot}", project?.root ?? "").replace("{projectName}", projectName));
+};
+const getSameProjectTask = (projectName, targetName, overrides, workspace, targetDefaults) => {
+  const project = workspace.projects[projectName];
+  if (!project) {
+    return [];
+  }
+  const hasTarget = project.targets?.[targetName] !== void 0 || targetDefaults?.[targetName] !== void 0;
+  if (!hasTarget) {
+    return [];
+  }
+  const target = {
+    project: projectName,
+    target: targetName
+  };
+  return [
+    {
+      cache: project.targets?.[targetName]?.cache ?? targetDefaults?.[targetName]?.cache,
+      id: getTaskId(target),
+      outputs: getTaskOutputs(projectName, targetName, workspace, targetDefaults),
+      overrides,
+      parallelism: project.targets?.[targetName]?.parallelism ?? targetDefaults?.[targetName]?.parallelism,
+      projectRoot: project.root,
+      target
+    }
+  ];
+};
+const getDependencyProjectTasks = (projectName, targetName, overrides, workspace, projectGraph, targetDefaults) => {
+  const tasks = [];
+  const deps = projectGraph.dependencies[projectName] ?? [];
+  for (const dep of deps) {
+    const depProject = workspace.projects[dep.target];
+    if (!depProject) {
+      continue;
+    }
+    const hasTarget = depProject.targets?.[targetName] !== void 0 || targetDefaults?.[targetName] !== void 0;
+    if (hasTarget) {
+      const target = {
+        project: dep.target,
+        target: targetName
+      };
+      tasks.push({
+        cache: depProject.targets?.[targetName]?.cache ?? targetDefaults?.[targetName]?.cache,
+        id: getTaskId(target),
+        outputs: getTaskOutputs(dep.target, targetName, workspace, targetDefaults),
+        overrides,
+        parallelism: depProject.targets?.[targetName]?.parallelism ?? targetDefaults?.[targetName]?.parallelism,
+        projectRoot: depProject.root,
+        target
+      });
+    }
+  }
+  return tasks;
+};
+const resolveStringDependency = (task, dep, workspace, projectGraph, targetDefaults) => {
+  if (dep.startsWith("^")) {
+    const targetName = dep.slice(1);
+    return getDependencyProjectTasks(task.target.project, targetName, task.overrides, workspace, projectGraph, targetDefaults);
+  }
+  return getSameProjectTask(task.target.project, dep, task.overrides, workspace, targetDefaults);
+};
+const resolveConfigDependency = (task, dep, workspace, projectGraph, targetDefaults) => {
+  const tasks = [];
+  if (dep.dependencies) {
+    tasks.push(
+      ...getDependencyProjectTasks(
+        task.target.project,
+        dep.target,
+        dep.params === "forward" ? task.overrides : {},
+        workspace,
+        projectGraph,
+        targetDefaults
+      )
+    );
+  } else if (dep.projects) {
+    const projects = Array.isArray(dep.projects) ? dep.projects : [dep.projects];
+    for (const projectName of projects) {
+      tasks.push(...getSameProjectTask(projectName, dep.target, dep.params === "forward" ? task.overrides : {}, workspace, targetDefaults));
+    }
+  } else {
+    tasks.push(...getSameProjectTask(task.target.project, dep.target, dep.params === "forward" ? task.overrides : {}, workspace, targetDefaults));
+  }
+  return tasks;
+};
+const resolveDependency = (task, dep, workspace, projectGraph, targetDefaults) => {
+  if (typeof dep === "string") {
+    return resolveStringDependency(task, dep, workspace, projectGraph, targetDefaults);
+  }
+  return resolveConfigDependency(task, dep, workspace, projectGraph, targetDefaults);
+};
+const resolveTaskDependencies = (task, options) => {
+  const { projectGraph, targetDefaults, workspace } = options;
+  const project = workspace.projects[task.target.project];
+  if (!project) {
+    return [];
+  }
+  const targetConfig = project.targets?.[task.target.target];
+  const defaultConfig = targetDefaults?.[task.target.target];
+  const dependsOn = targetConfig?.dependsOn ?? defaultConfig?.dependsOn ?? [];
+  const depTasks = [];
+  for (const dep of dependsOn) {
+    const resolved = resolveDependency(task, dep, workspace, projectGraph, targetDefaults);
+    depTasks.push(...resolved);
+  }
+  return depTasks;
+};
+const createTaskGraph = (initialTasks, options) => {
+  const tasks = {};
+  const dependencies = {};
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [...initialTasks];
+  while (queue.length > 0) {
+    const task = queue.shift();
+    if (!task) {
+      break;
+    }
+    if (visited.has(task.id)) {
+      continue;
+    }
+    visited.add(task.id);
+    tasks[task.id] = task;
+    dependencies[task.id] = [];
+    const deps = resolveTaskDependencies(task, options);
+    for (const depTask of deps) {
+      dependencies[task.id]?.push(depTask.id);
+      if (!visited.has(depTask.id)) {
+        queue.push(depTask);
+      }
+    }
+  }
+  const allDeps = /* @__PURE__ */ new Set();
+  for (const deps of Object.values(dependencies)) {
+    for (const dep of deps) {
+      allDeps.add(dep);
+    }
+  }
+  const roots = Object.keys(tasks).filter((taskId) => !allDeps.has(taskId));
+  return { dependencies, roots, tasks };
+};
+
+export { createTaskGraph, getTaskId, parseTaskId };

package/dist/packem_shared/defaultTaskRunner-CrW4v5Ye.js

@@ -0,0 +1,79 @@
+import { Cache } from './Cache-IYpTYVUC.js';
+import { inferFrameworkEnvPatterns } from './detectFrameworks-CeFzKE6J.js';
+import { EmptyLifeCycle } from './CompositeLifeCycle-7AtYw1dv.js';
+import { RemoteCache } from './RemoteCache-BDqrnDEi.js';
+import { InProcessTaskHasher } from './computeTaskHash-BoCnnvIJ.js';
+import { TaskOrchestrator } from './TaskOrchestrator-BvYs3ONw.js';
+import { TaskScheduler } from './TaskScheduler-CJilHDta.js';
+
+const resolveParallel = (parallel) => {
+  if (typeof parallel === "number") {
+    return Math.max(1, parallel);
+  }
+  if (parallel === false) {
+    return 1;
+  }
+  return 3;
+};
+const defaultTaskRunner = async (_tasks, options, context) => {
+  const { lifeCycle = new EmptyLifeCycle(), projectGraph, taskExecutor, taskGraph, workspaceRoot } = context;
+  const cache = new Cache({
+    cacheDirectory: options.cacheDirectory,
+    maxCacheAge: options.maxCacheAge,
+    maxCacheSize: options.maxCacheSize,
+    workspaceRoot
+  });
+  cache.removeOldEntries().catch(() => {
+  });
+  const projects = {};
+  for (const [name, node] of Object.entries(projectGraph.nodes)) {
+    projects[name] = node.data;
+  }
+  const taskHasher = new InProcessTaskHasher({
+    envVars: options.envVars,
+    frameworkInference: options.frameworkInference,
+    globalEnv: options.globalEnv,
+    globalInputs: options.globalInputs,
+    namedInputs: options.namedInputs,
+    projects,
+    smartLockfileHashing: options.smartLockfileHashing,
+    targetDefaults: options.targetDefaults,
+    workspaceRoot
+  });
+  const maxParallel = resolveParallel(options.parallel);
+  const scheduler = new TaskScheduler(taskGraph, projectGraph, maxParallel);
+  const resolveCommand = (task) => {
+    const project = projectGraph.nodes[task.target.project];
+    const targetConfig = project?.data.targets?.[task.target.target];
+    const defaultConfig = options.targetDefaults?.[task.target.target];
+    return targetConfig?.command ?? defaultConfig?.command;
+  };
+  const remoteCache = options.remoteCache ? new RemoteCache(options.remoteCache) : void 0;
+  let fingerprintEnvPatterns = options.fingerprintEnvPatterns ?? [];
+  if (options.frameworkInference && options.autoFingerprint) {
+    const inferredPatterns = await inferFrameworkEnvPatterns(workspaceRoot, projects);
+    fingerprintEnvPatterns = [.../* @__PURE__ */ new Set([...fingerprintEnvPatterns, ...inferredPatterns])];
+  }
+  const orchestrator = new TaskOrchestrator({
+    autoFingerprint: options.autoFingerprint,
+    cache,
+    cacheDiagnostics: options.cacheDiagnostics,
+    captureOutput: true,
+    dryRun: options.dryRun,
+    fingerprintEnvPatterns,
+    lifeCycle,
+    remoteCache,
+    resolveCommand: options.autoFingerprint ? resolveCommand : void 0,
+    scheduler,
+    skipCache: options.skipNxCache,
+    summarize: options.summarize,
+    taskExecutor,
+    taskGraph,
+    taskHasher,
+    untrackedEnvVars: options.untrackedEnvVars,
+    workspaceRoot
+  });
+  return orchestrator.run();
+};
+
+export { defaultTaskRunner };

package/dist/packem_shared/detectFrameworks-CeFzKE6J.js

@@ -0,0 +1,101 @@
+import { join } from '@visulima/path';
+import { r as readPackageDeps } from './utils-zO0ZRgtf.js';
+
+const FRAMEWORK_DEFINITIONS = [
+  {
+    envPrefixes: ["NEXT_PUBLIC_"],
+    name: "Next.js",
+    packages: ["next"]
+  },
+  {
+    envPrefixes: ["VITE_"],
+    name: "Vite",
+    packages: ["vite"]
+  },
+  {
+    envPrefixes: ["REACT_APP_"],
+    name: "Create React App",
+    packages: ["react-scripts"]
+  },
+  {
+    envPrefixes: ["GATSBY_"],
+    name: "Gatsby",
+    packages: ["gatsby"]
+  },
+  {
+    envPrefixes: ["NUXT_PUBLIC_"],
+    name: "Nuxt",
+    packages: ["nuxt", "nuxt3"]
+  },
+  {
+    envPrefixes: ["EXPO_PUBLIC_"],
+    name: "Expo",
+    packages: ["expo"]
+  },
+  {
+    envPrefixes: ["REMIX_PUBLIC_"],
+    name: "Remix",
+    packages: ["@remix-run/react", "@remix-run/node"]
+  },
+  {
+    envPrefixes: ["PUBLIC_"],
+    name: "Astro",
+    packages: ["astro"]
+  },
+  {
+    envPrefixes: ["PUBLIC_"],
+    name: "SvelteKit",
+    packages: ["@sveltejs/kit"]
+  },
+  {
+    envPrefixes: ["VITE_"],
+    name: "Solid Start",
+    packages: ["@solidjs/start", "solid-start"]
+  }
+];
+const detectFrameworks = async (packageJsonPath) => {
+  const allDeps = await readPackageDeps(packageJsonPath, { optional: false, peer: false });
+  if (!allDeps) {
+    return [];
+  }
+  const detected = [];
+  for (const framework of FRAMEWORK_DEFINITIONS) {
+    if (framework.packages.some((pkg) => allDeps.has(pkg))) {
+      detected.push({
+        envPrefixes: framework.envPrefixes,
+        name: framework.name
+      });
+    }
+  }
+  return detected;
+};
+const inferFrameworkEnvPatterns = async (workspaceRoot, projects) => {
+  const allPrefixes = /* @__PURE__ */ new Set();
+  const detectionPromises = Object.values(projects).map(async (project) => {
+    const packageJsonPath = join(workspaceRoot, project.root, "package.json");
+    const frameworks = await detectFrameworks(packageJsonPath);
+    for (const fw of frameworks) {
+      for (const prefix of fw.envPrefixes) {
+        allPrefixes.add(prefix);
+      }
+    }
+  });
+  await Promise.all(detectionPromises);
+  return [...allPrefixes].toSorted().map((prefix) => `${prefix}*`);
+};
+const getFrameworkEnvVariables = async (packageJsonPath, env = process.env) => {
+  const frameworks = await detectFrameworks(packageJsonPath);
+  const result = {};
+  for (const framework of frameworks) {
+    for (const prefix of framework.envPrefixes) {
+      for (const [key, value] of Object.entries(env)) {
+        if (key.startsWith(prefix) && value !== void 0) {
+          result[key] = value;
+        }
+      }
+    }
+  }
+  return result;
+};
+
+export { detectFrameworks, getFrameworkEnvVariables, inferFrameworkEnvPatterns };