@visulima/vis 1.0.0-alpha.10 → 1.0.0-alpha.11

package/dist/config/index.js

@@ -0,0 +1,2 @@
+export { CONFIG_FILES, SECURITY_DEFAULTS, TASK_CONFIG_FILES, applyDefaults, defineConfig, definePlugin, defineTaskConfig, findVisConfigFile, findVisTaskConfigFile, loadVisConfig, loadVisTaskConfig } from '../packem_chunks/applyDefaults.js';
+export { o as otelPlugin } from '../packem_shared/otel-DCvqCTz_.js';

package/dist/generate/index.d.ts

@@ -147,7 +147,7 @@ interface DiscoveredTemplate {
   /** Absolute path on disk (file for native, directory for moon). */
   path: string;
   /** Source classification — affects load + listing. */
-  source: "config" | "moon" | "native" | "remote";
+  source: "builtin" | "config" | "moon" | "native" | "remote";
 }
 /**
 * Identity helper for type inference. Authors get autocomplete + checks

package/dist/generate/index.js

@@ -1 +1,3 @@
-var t=Object.defineProperty;var r=(e,a)=>t(e,"name",{value:a,configurable:!0});var c=Object.defineProperty,l=r((e,a)=>c(e,"name",{value:a,configurable:!0}),"a");const o=l(e=>e,"createTemplate");export{o as createTemplate};
+const createTemplate = (template) => template;
+
+export { createTemplate };

package/dist/packem_chunks/applyDefaults.js

@@ -0,0 +1,336 @@
+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 {
+  createHash
+} = __cjs_getBuiltinModule("node:crypto");
+const {
+  readdirSync,
+  copyFileSync,
+  unlinkSync,
+  readFileSync
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  createRequire
+} = __cjs_getBuiltinModule("node:module");
+const {
+  tmpdir
+} = __cjs_getBuiltinModule("node:os");
+import { findCacheDirSync } from '@visulima/find-cache-dir';
+import { isAccessibleSync, ensureDirSync, readJsonSync, writeJsonSync } from '@visulima/fs';
+import { join, dirname, isAbsolute } from '@visulima/path';
+import { createJiti } from 'jiti';
+import { V as VisConfigCycleError, m as mergeTargetWithInherit, a as VisConfigLoadError, b as VisConfigNotFoundError } from '../packem_shared/otel-DCvqCTz_.js';
+export { o as otelPlugin } from '../packem_shared/otel-DCvqCTz_.js';
+
+const CONFIG_FILES = ["vis.config.ts", "vis.config.mts", "vis.config.cts", "vis.config.js", "vis.config.mjs", "vis.config.cjs"];
+const CONFIG_FILE_SET = new Set(CONFIG_FILES);
+const TASK_CONFIG_FILES = ["vis.task.ts", "vis.task.mts", "vis.task.cts", "vis.task.js", "vis.task.mjs", "vis.task.cjs"];
+const TASK_CONFIG_FILE_SET = new Set(TASK_CONFIG_FILES);
+const SECURITY_DEFAULTS = {
+  /** Block transitive dependencies from using git repos or tarball URLs. */
+  blockExoticSubdeps: true,
+  /** Make unapproved build scripts a hard error instead of a warning. */
+  strictDepBuilds: true,
+  /** Fail if a package's trust level has decreased compared to prior releases. */
+  trustPolicy: "no-downgrade",
+  /** Skip trust policy check for packages published more than 30 days ago. */
+  trustPolicyIgnoreAfter: 43200
+};
+const mergeSecurityDefaults = (security) => {
+  return {
+    ...SECURITY_DEFAULTS,
+    ...security
+  };
+};
+const applyDefaults = (config) => {
+  return {
+    ...config,
+    security: mergeSecurityDefaults(config.security),
+    update: {
+      security: true,
+      target: "minor",
+      ...config.update
+    }
+  };
+};
+const findVisConfigFile = (directory) => {
+  let entries;
+  try {
+    entries = readdirSync(directory);
+  } catch {
+    return void 0;
+  }
+  const present = new Set(entries.filter((name) => CONFIG_FILE_SET.has(name)));
+  for (const file of CONFIG_FILES) {
+    if (present.has(file)) {
+      return join(directory, file);
+    }
+  }
+  return void 0;
+};
+const findVisTaskConfigFile = (projectDirectory) => {
+  let entries;
+  try {
+    entries = readdirSync(projectDirectory);
+  } catch {
+    return void 0;
+  }
+  const present = new Set(entries.filter((name) => TASK_CONFIG_FILE_SET.has(name)));
+  for (const file of TASK_CONFIG_FILES) {
+    if (present.has(file)) {
+      return join(projectDirectory, file);
+    }
+  }
+  return void 0;
+};
+const hashFileContents = (filePath) => createHash("sha256").update(readFileSync(filePath)).digest("hex");
+const hashConfigChain = (paths) => {
+  const hasher = createHash("sha256");
+  const sorted = [...paths].sort();
+  for (const path of sorted) {
+    hasher.update(path);
+    hasher.update(":");
+    hasher.update(hashFileContents(path));
+    hasher.update("\n");
+  }
+  return hasher.digest("hex");
+};
+const getConfigCachePath = (workspaceRoot) => {
+  const nodeModulesDir = join(workspaceRoot, "node_modules");
+  if (isAccessibleSync(nodeModulesDir)) {
+    const directCacheDir = join(nodeModulesDir, ".cache", "vis");
+    ensureDirSync(directCacheDir);
+    return join(directCacheDir, "vis-config-cache.json");
+  }
+  const cacheDir = findCacheDirSync("vis", { create: true, cwd: workspaceRoot });
+  return cacheDir ? join(cacheDir, "vis-config-cache.json") : void 0;
+};
+const readConfigCache = (cachePath, hash) => {
+  if (!isAccessibleSync(cachePath)) {
+    return void 0;
+  }
+  try {
+    const cache = readJsonSync(cachePath);
+    if (cache.hash === hash) {
+      return cache.config;
+    }
+  } catch {
+  }
+  return void 0;
+};
+const writeConfigCache = (cachePath, hash, config) => {
+  try {
+    ensureDirSync(dirname(cachePath));
+    writeJsonSync(cachePath, { config, hash });
+  } catch {
+  }
+};
+const normalizeExtends = (value) => {
+  if (value === void 0) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+};
+const resolveExtendsSpecifier = (specifier, parentFile, chain) => {
+  if (isAbsolute(specifier)) {
+    throw new VisConfigNotFoundError(
+      specifier,
+      [...chain, parentFile],
+      ["Absolute paths in `extends` are not supported. Use a relative path or an npm package name."]
+    );
+  }
+  const attempted = [];
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    const parentDirectory = dirname(parentFile);
+    const resolved = join(parentDirectory, specifier);
+    attempted.push(resolved);
+    if (isAccessibleSync(resolved)) {
+      return resolved;
+    }
+    throw new VisConfigNotFoundError(specifier, [...chain, parentFile], attempted);
+  }
+  try {
+    const requireFromParent = createRequire(parentFile);
+    return requireFromParent.resolve(specifier);
+  } catch {
+    attempted.push(`require.resolve("${specifier}") from ${parentFile}`);
+    throw new VisConfigNotFoundError(specifier, [...chain, parentFile], attempted);
+  }
+};
+const loadRawConfig = async (jiti, configPath, chain) => {
+  const hash = hashFileContents(configPath);
+  const extension = configPath.slice(configPath.lastIndexOf("."));
+  const temporaryConfigPath = join(tmpdir(), `vis-config-${hash}${extension}`);
+  copyFileSync(configPath, temporaryConfigPath);
+  let loaded;
+  try {
+    loaded = await jiti.import(temporaryConfigPath, { default: true, try: true }) ?? {};
+  } catch (error) {
+    throw new VisConfigLoadError(configPath, chain, error);
+  } finally {
+    try {
+      unlinkSync(temporaryConfigPath);
+    } catch {
+    }
+  }
+  try {
+    return (typeof loaded === "function" ? await loaded() ?? {} : loaded) ?? {};
+  } catch (error) {
+    throw new VisConfigLoadError(configPath, chain, error);
+  }
+};
+const mergeVisConfigs = (parent, child) => {
+  const merged = { ...parent, ...child };
+  if (parent.targetDefaults || child.targetDefaults) {
+    const names = /* @__PURE__ */ new Set([...Object.keys(parent.targetDefaults ?? {}), ...Object.keys(child.targetDefaults ?? {})]);
+    const out = {};
+    for (const name of names) {
+      out[name] = mergeTargetWithInherit(parent.targetDefaults?.[name], child.targetDefaults?.[name]);
+    }
+    merged.targetDefaults = out;
+  }
+  if (parent.taskDefaults || child.taskDefaults) {
+    merged.taskDefaults = [...parent.taskDefaults ?? [], ...child.taskDefaults ?? []];
+  }
+  if (parent.fileGroups || child.fileGroups) {
+    merged.fileGroups = { ...parent.fileGroups, ...child.fileGroups };
+  }
+  if (parent.taskGroups || child.taskGroups) {
+    merged.taskGroups = { ...parent.taskGroups, ...child.taskGroups };
+  }
+  if (parent.security || child.security) {
+    merged.security = { ...parent.security, ...child.security };
+  }
+  if (parent.update || child.update) {
+    merged.update = { ...parent.update, ...child.update };
+  }
+  if (parent.taskRunnerOptions || child.taskRunnerOptions) {
+    merged.taskRunnerOptions = { ...parent.taskRunnerOptions, ...child.taskRunnerOptions };
+  }
+  delete merged.extends;
+  return merged;
+};
+const resolveConfigChain = async (jiti, configPath, chain, inFlight, loaded, order) => {
+  if (inFlight.has(configPath)) {
+    throw new VisConfigCycleError(configPath, chain);
+  }
+  if (loaded.has(configPath)) {
+    return;
+  }
+  inFlight.add(configPath);
+  try {
+    const raw = await loadRawConfig(jiti, configPath, chain);
+    const extendsList = normalizeExtends(raw.extends);
+    for (const specifier of extendsList) {
+      const resolved = resolveExtendsSpecifier(specifier, configPath, chain);
+      await resolveConfigChain(jiti, resolved, [...chain, configPath], inFlight, loaded, order);
+    }
+    loaded.set(configPath, raw);
+    order.push(configPath);
+  } finally {
+    inFlight.delete(configPath);
+  }
+};
+const loadVisConfig = async (workspaceRoot) => {
+  const rootConfigPath = findVisConfigFile(workspaceRoot);
+  if (!rootConfigPath) {
+    return applyDefaults({});
+  }
+  const jiti = createJiti(workspaceRoot, { fsCache: false, moduleCache: false });
+  const inFlight = /* @__PURE__ */ new Set();
+  const loaded = /* @__PURE__ */ new Map();
+  const order = [];
+  await resolveConfigChain(jiti, rootConfigPath, [], inFlight, loaded, order);
+  const chainHash = hashConfigChain(order);
+  const cachePath = getConfigCachePath(workspaceRoot);
+  if (cachePath) {
+    const cached = readConfigCache(cachePath, chainHash);
+    if (cached) {
+      return cached;
+    }
+  }
+  let merged = {};
+  for (const path of order) {
+    merged = mergeVisConfigs(merged, loaded.get(path));
+  }
+  const finalConfig = applyDefaults(merged);
+  if (cachePath) {
+    writeConfigCache(cachePath, chainHash, finalConfig);
+  }
+  return finalConfig;
+};
+const sanitizeProjectName = (projectName) => projectName.replaceAll(/[^\w.-]+/g, "_");
+const getVisTaskCachePath = (workspaceRoot, projectName) => {
+  const nodeModulesDir = join(workspaceRoot, "node_modules");
+  const safeName = sanitizeProjectName(projectName);
+  if (isAccessibleSync(nodeModulesDir)) {
+    const directCacheDir = join(nodeModulesDir, ".cache", "vis", "task-configs");
+    ensureDirSync(directCacheDir);
+    return join(directCacheDir, `${safeName}.json`);
+  }
+  const cacheDir = findCacheDirSync("vis", { create: true, cwd: workspaceRoot });
+  return cacheDir ? join(cacheDir, "task-configs", `${safeName}.json`) : void 0;
+};
+const readVisTaskCache = (cachePath, hash) => {
+  if (!isAccessibleSync(cachePath)) {
+    return void 0;
+  }
+  try {
+    const cache = readJsonSync(cachePath);
+    if (cache.hash === hash) {
+      return cache.config;
+    }
+  } catch {
+  }
+  return void 0;
+};
+const writeVisTaskCache = (cachePath, hash, config) => {
+  try {
+    ensureDirSync(dirname(cachePath));
+    writeJsonSync(cachePath, { config, hash });
+  } catch {
+  }
+};
+const loadVisTaskConfig = async (workspaceRoot, projectDirectory, projectName) => {
+  const taskConfigPath = findVisTaskConfigFile(projectDirectory);
+  if (!taskConfigPath) {
+    return void 0;
+  }
+  const hash = hashFileContents(taskConfigPath);
+  const cachePath = getVisTaskCachePath(workspaceRoot, projectName);
+  if (cachePath) {
+    const cached = readVisTaskCache(cachePath, hash);
+    if (cached) {
+      return cached;
+    }
+  }
+  const jiti = createJiti(projectDirectory, { fsCache: false, moduleCache: false });
+  const raw = await loadRawConfig(jiti, taskConfigPath, []);
+  const taskConfig = raw;
+  if (cachePath) {
+    writeVisTaskCache(cachePath, hash, taskConfig);
+  }
+  return taskConfig;
+};
+const defineTaskConfig = (config) => config;
+const defineConfig = (config) => applyDefaults(config);
+const definePlugin = (plugin) => plugin;
+
+export { CONFIG_FILES, SECURITY_DEFAULTS, TASK_CONFIG_FILES, applyDefaults, defineConfig, definePlugin, defineTaskConfig, findVisConfigFile, findVisTaskConfigFile, loadVisConfig, loadVisTaskConfig };