@visulima/vis 1.0.0-alpha.1 → 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

@@ -0,0 +1,157 @@
+/**
+* Type definitions for the `vis generate` template runtime.
+*
+* The shape intentionally echoes Bingo's `Template` so a future Bingo
+* adapter (re-exporting `bingo` Templates through this runtime) is a
+* one-pager. Authors do not depend on Bingo to write a vis generator.
+*/
+type VariableType = "array" | "boolean" | "enum" | "number" | "string";
+/** Common variable fields (all types). */
+interface VariableBase {
+  /**
+  * Default value when the user accepts the prompt without typing.
+  * For `boolean` this is `true|false`; for `enum` it must match `values`.
+  */
+  default?: boolean | number | string | string[];
+  /** Hide from prompts; can still be set via CLI or `--defaults`. */
+  internal?: boolean;
+  /** Sort order in prompts (lower first). Defaults to declaration order. */
+  order?: number;
+  /** Override the prompt text. Defaults to the variable name. */
+  prompt?: string;
+  /** When true, the user must provide a non-empty value. */
+  required?: boolean;
+}
+type StringVariable = VariableBase & {
+  type: "string";
+};
+type NumberVariable = VariableBase & {
+  type: "number";
+};
+type BooleanVariable = VariableBase & {
+  default?: boolean;
+  type: "boolean";
+};
+type ArrayVariable = VariableBase & {
+  type: "array";
+};
+interface EnumVariable extends VariableBase {
+  /** Allow multiple selections (returns `string[]`). */
+  multiple?: boolean;
+  type: "enum";
+  /** Selectable values. */
+  values: string[];
+}
+type Variable = ArrayVariable | BooleanVariable | EnumVariable | NumberVariable | StringVariable;
+/** Map of variable name → spec, as authors declare them. */
+type VariableMap = Record<string, Variable>;
+/** Resolved option values passed to `produce()`. */
+type Options = Record<string, unknown>;
+/** A file in a Creation can be a string, a Buffer (binary asset), or a nested directory. */
+type CreationFile = Buffer | string;
+interface CreationDirectory {
+  [key: string]: CreationDirectory | CreationFile;
+}
+/**
+* Script entry produced by `produce()`.
+* - `string`: shell command, runs in the destination directory.
+* - `object`: shell commands with optional phase ordering.
+*/
+type Script = ScriptObject | string;
+interface ScriptObject {
+  /** Shell command(s) to run sequentially. */
+  commands: string[];
+  /**
+  * Phase ordering. Phases run in ascending order; scripts within
+  * the same phase are dispatched concurrently. Default: 0.
+  */
+  phase?: number;
+  /** Suppress command output. Default: false. */
+  silent?: boolean;
+}
+/** Object returned by a template's `produce()` function. */
+interface Creation {
+  /** Recursive directory tree. Keys with `/` are auto-split. */
+  files?: CreationDirectory;
+  /**
+  * Per-file metadata keyed by the *flattened* destination path
+  * (e.g. `src/foo.ts`). Optional — native templates usually omit
+  * this; the moon adapter populates it from per-file frontmatter
+  * so `force: true` survives the trip to the runner without
+  * changing the shape of `files`.
+  */
+  filesMeta?: Record<string, FileMeta>;
+  /** Shell scripts to run after files are written. */
+  scripts?: Script[];
+  /** User-facing tips printed after the run. */
+  suggestions?: string[];
+}
+interface FileMeta {
+  /**
+  * Overwrite an existing file at this path without prompting or
+  * consulting the global `--force` flag.
+  */
+  force?: boolean;
+}
+/** Context object passed to `produce()`. */
+interface TemplateContext {
+  /** Built-in variables: `dest_dir`, `dest_rel_dir`, `working_dir`, `workspace_root`. */
+  builtins: BuiltinVars;
+  /** Resolved option values (after prompts + CLI overrides + defaults). */
+  options: Options;
+}
+interface BuiltinVars {
+  /** Absolute destination directory. */
+  dest_dir: string;
+  /** Destination relative to the workspace root. */
+  dest_rel_dir: string;
+  /** Caller's current working directory. */
+  working_dir: string;
+  /** Absolute workspace root (from `findMonorepoRootSync`, fallback to `working_dir`). */
+  workspace_root: string;
+}
+/** Top-level "About" metadata for a template. */
+interface TemplateAbout {
+  /** One-line description. */
+  description: string;
+  /** Short identifier shown in `vis generate --list` and prompts. */
+  name: string;
+}
+/**
+* The author-facing template shape.
+* Both native (`.vis/templates/&lt;name>.ts`) and moon-adapter outputs
+* normalize to this.
+*/
+interface Template {
+  about: TemplateAbout;
+  /**
+  * Default destination directory (relative to workspace root unless
+  * absolute or starting with `./`). Honored when the user does not
+  * pass `--to`. Maps to moon's `template.yml` `destination`.
+  */
+  destination?: string;
+  /** Variable schema for prompts. */
+  options?: VariableMap;
+  /** Build the Creation given resolved options and built-in vars. */
+  produce: (context: TemplateContext) => Creation | Promise<Creation>;
+}
+/**
+* Discovery record: a Template plus where it came from.
+* Surfaced by `vis generate --list`.
+*/
+interface DiscoveredTemplate {
+  /** Lazy loader — invoke to materialize the Template. */
+  load: () => Promise<Template>;
+  /** Stable name used by `vis generate &lt;name>`. */
+  name: string;
+  /** Absolute path on disk (file for native, directory for moon). */
+  path: string;
+  /** Source classification — affects load + listing. */
+  source: "builtin" | "config" | "moon" | "native" | "remote";
+}
+/**
+* Identity helper for type inference. Authors get autocomplete + checks
+* without having to annotate the export.
+*/
+declare const createTemplate: (template: Template) => Template;
+export { type ArrayVariable, type BooleanVariable, type BuiltinVars, type Creation, type CreationDirectory, type CreationFile, type DiscoveredTemplate, type EnumVariable, type FileMeta, type NumberVariable, type Options, type Script, type ScriptObject, type StringVariable, type Template, type TemplateAbout, type TemplateContext, type Variable, type VariableMap, type VariableType, createTemplate };

package/dist/generate/index.js

@@ -0,0 +1,3 @@
+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 };