@vltpkg/cli-js 1.4.0 → 1.6.0

package/{chunk-GIIAODRI.js → chunk-PC2HOBAQ.js}

@@ -12,16 +12,17 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   init,
   install
-} from "./chunk-OVPHE4O7.js";
+} from "./chunk-36UIE654.js";
 import {
   commandUsage
-} from "./chunk-LHPEBLOU.js";
+} from "./chunk-HT6FS4VB.js";
 import {
   assertWSConfig,
+  migratableWSConfig,
   minimatch,
   resolveWSConfig,
   splitNegatedPatterns
-} from "./chunk-I7UMHYZX.js";
+} from "./chunk-TQQO2F56.js";
 import {
   load,
   save
@@ -75,11 +76,12 @@ Modify/add properties using \`vlt pkg\`. For example:
 var command = async (conf) => {
   const allowScripts = conf.get("allow-scripts") ? String(conf.get("allow-scripts")) : ":not(*)";
   if (conf.values.workspace?.length) {
-    const { config: parsedWSConfig, source } = resolveWSConfig(
+    const resolved = resolveWSConfig(
       conf.options.projectRoot,
       conf.options.packageJson
     );
-    const workspacesConfig = load("workspaces", assertWSConfig) ?? (source ? Object.values(parsedWSConfig).flat() : void 0);
+    const parsedWSConfig = resolved.config;
+    const workspacesConfig = load("workspaces", assertWSConfig) ?? migratableWSConfig(resolved);
     const results = [];
     const addToConfig = [];
     for (const workspace of conf.values.workspace) {

package/{chunk-APMYKJI2.js → chunk-QNHBAGXQ.js}

@@ -12,7 +12,7 @@ var require = _vlt_createRequire(import.meta.filename);
 import {
   promiseSpawn,
   which
-} from "./chunk-U7TEQCBN.js";
+} from "./chunk-SUU2WETN.js";
 
 // ../../src/url-open/src/index.ts
 import { release } from "node:os";

package/chunk-RBQO54TG.js

@@ -0,0 +1,59 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  stderr
+} from "./chunk-KVWGMSPW.js";
+import {
+  migratableWSConfig,
+  resolveWSConfig
+} from "./chunk-TQQO2F56.js";
+import {
+  save
+} from "./chunk-HTOTG4TS.js";
+
+// ../../src/cli-sdk/src/migrate-workspaces.ts
+var found = (conf) => {
+  const resolved = resolveWSConfig(
+    conf.options.projectRoot,
+    conf.options.packageJson,
+    false
+  );
+  const workspaces = migratableWSConfig(resolved);
+  const { source } = resolved;
+  if (!workspaces?.length || !source) return;
+  return { source, workspaces };
+};
+var migrateWorkspaces = (conf) => {
+  if (!conf.options["migrate-workspaces"]) return;
+  const migrated = found(conf);
+  if (migrated) save("workspaces", migrated.workspaces);
+  return migrated;
+};
+var warnIgnoredWorkspaces = (conf) => {
+  const { loglevel } = conf.values;
+  if (loglevel === "silent" || loglevel === "error") return;
+  let migrated;
+  try {
+    migrated = found(conf);
+  } catch {
+    return;
+  }
+  if (!migrated) return;
+  stderr(
+    `Warning: vlt ci reads workspaces from vlt.json only; ignoring ${migrated.source}, its workspaces are not installed. Run \`vlt install\` to save them to vlt.json, or add them there.`
+  );
+};
+
+export {
+  migrateWorkspaces,
+  warnIgnoredWorkspaces
+};

package/chunk-SUU2WETN.js

@@ -0,0 +1,268 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  error
+} from "./chunk-WZWDS3W4.js";
+
+// ../../src/promise-spawn/src/index.ts
+import { spawn } from "node:child_process";
+var isPipe = (stdio = "pipe", fd) => stdio === "pipe" || stdio === "overlapped" || stdio === null ? true : Array.isArray(stdio) ? isPipe(stdio[fd], fd) : false;
+function stdioResult(stdout, stderr, o) {
+  return {
+    stdout: !isPipe(o.stdio, 1) ? null : o.stdioString !== false ? Buffer.concat(stdout).toString().trim() : Buffer.concat(stdout),
+    stderr: !isPipe(o.stdio, 2) ? null : o.stdioString !== false ? Buffer.concat(stderr).toString().trim() : Buffer.concat(stderr)
+  };
+}
+var SpawnPromise = class extends Promise {
+  [Symbol.toStringTag] = "SpawnPromise";
+  /** The spawned process this promise references */
+  process;
+  /** Expose the child process stdin, if available */
+  stdin;
+  /**
+   * Set static `Symbol.species` back to the base Promise class so that
+   * v8 doesn't get confused by the changed constructor signature.
+   */
+  static get [Symbol.species]() {
+    return Promise;
+  }
+  constructor(command, args, opts, extra = {}) {
+    let proc;
+    super((res, rej) => {
+      proc = spawn(command, args, opts);
+      const stdout = [];
+      const stderr = [];
+      const reject = (er, status, signal) => {
+        const stdio = stdioResult(stdout, stderr, opts);
+        const errorResult = {
+          command,
+          args,
+          stdout: stdio.stdout,
+          stderr: stdio.stderr,
+          cwd: opts.cwd?.toString() ?? process.cwd()
+        };
+        if (er !== void 0) {
+          errorResult.cause = er;
+        }
+        if (status !== void 0) {
+          errorResult.status = status;
+        }
+        if (signal !== void 0) {
+          errorResult.signal = signal;
+        }
+        Object.assign(errorResult, extra);
+        rej(error("command failed", errorResult));
+      };
+      const resolve = (status, signal) => {
+        const stdio = stdioResult(stdout, stderr, opts);
+        const successResult = {
+          command,
+          args,
+          status,
+          signal,
+          stdout: stdio.stdout,
+          stderr: stdio.stderr,
+          cwd: opts.cwd?.toString() ?? process.cwd()
+        };
+        Object.assign(successResult, extra);
+        res(successResult);
+      };
+      proc.on("error", reject);
+      proc.stdout?.on("data", (c) => stdout.push(c)).on("error", reject);
+      proc.stderr?.on("data", (c) => stderr.push(c)).on("error", reject);
+      proc.on("close", (status, signal) => {
+        if ((status || signal) && !opts.acceptFail) {
+          reject(void 0, status, signal);
+        } else {
+          resolve(status, signal);
+        }
+      });
+    });
+    this.process = proc;
+    this.stdin = proc.stdin;
+  }
+};
+function promiseSpawn(command, args, opts = {}, extra = {}) {
+  return new SpawnPromise(command, args, opts, extra);
+}
+
+// ../../node_modules/.vlt/~npm~isexe@3.1.5/node_modules/isexe/dist/esm/index.min.js
+import { statSync as w } from "node:fs";
+import { stat as S } from "node:fs/promises";
+import { statSync as k } from "node:fs";
+import { stat as I } from "node:fs/promises";
+import { delimiter as _ } from "node:path";
+var y = Object.defineProperty;
+var u = (t, r) => {
+  for (var e in r) y(t, e, { get: r[e], enumerable: true });
+};
+var i = {};
+u(i, { isexe: () => C, sync: () => A });
+var C = async (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return d(await S(t), r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var A = (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return d(w(t), r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var d = (t, r) => t.isFile() && T(t, r);
+var T = (t, r) => {
+  let e = r.uid ?? process.getuid?.(), s = r.groups ?? process.getgroups?.() ?? [], o = r.gid ?? process.getgid?.() ?? s[0];
+  if (e === void 0 || o === void 0) throw new Error("cannot get uid or gid");
+  let c = /* @__PURE__ */ new Set([o, ...s]), n = t.mode, l = t.uid, E = t.gid, f = parseInt("100", 8), p = parseInt("010", 8), x = parseInt("001", 8), h = f | p;
+  return !!(n & x || n & p && c.has(E) || n & f && l === e || n & h && e === 0);
+};
+var a = {};
+u(a, { isexe: () => F, sync: () => L });
+var F = async (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return m(await I(t), t, r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var L = (t, r = {}) => {
+  let { ignoreErrors: e = false } = r;
+  try {
+    return m(k(t), t, r);
+  } catch (s) {
+    let o = s;
+    if (e || o.code === "EACCES") return false;
+    throw o;
+  }
+};
+var P = (t, r) => {
+  let { pathExt: e = process.env.PATHEXT || "" } = r, s = e.split(_);
+  if (s.indexOf("") !== -1) return true;
+  for (let o of s) {
+    let c = o.toLowerCase(), n = t.substring(t.length - c.length).toLowerCase();
+    if (c && n === c) return true;
+  }
+  return false;
+};
+var m = (t, r, e) => t.isFile() && P(r, e);
+var v = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+var g = v === "win32" ? a : i;
+var R = g.isexe;
+var U = g.sync;
+
+// ../../src/which/src/index.ts
+import { delimiter, join, sep } from "node:path";
+var isWindows = process.platform === "win32";
+var rSlash = sep === "/" ? /\// : /[\\/]/;
+var rRel = new RegExp(`^\\.${rSlash.source}`);
+var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+var getPathInfo = (cmd, {
+  path: optPath = process.env.PATH,
+  pathExt: optPathExt = process.env.PATHEXT,
+  delimiter: optDelimiter = delimiter
+}) => {
+  const pathEnv = cmd.match(rSlash) ? [""] : [
+    // windows always checks the cwd first
+    /* c8 ignore next - platform-specific */
+    ...isWindows ? [process.cwd()] : [],
+    ...(optPath ?? /* c8 ignore next - very unusual */
+    "").split(
+      optDelimiter
+    )
+  ];
+  if (isWindows) {
+    const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+    const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+    if (cmd.includes(".") && pathExt[0] !== "") {
+      pathExt.unshift("");
+    }
+    return { pathEnv, pathExt, pathExtExe };
+  }
+  return { pathEnv, pathExt: [""] };
+};
+var getPathPart = (raw, cmd) => {
+  const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+  const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+  return prefix + join(pathPart, cmd);
+};
+async function which(cmd, opt = {}) {
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+  for (const envPart of pathEnv) {
+    const p = getPathPart(envPart, cmd);
+    for (const ext of pathExt) {
+      const withExt = p + ext;
+      const is = await R(withExt, {
+        pathExt: pathExtExe,
+        ignoreErrors: true
+      });
+      if (is) {
+        if (!opt.all) {
+          return withExt;
+        }
+        found.push(withExt);
+      }
+    }
+  }
+  if (opt.all && found.length) {
+    return found;
+  }
+  if (opt.nothrow) {
+    return null;
+  }
+  throw getNotFoundError(cmd);
+}
+function whichSync(cmd, opt = {}) {
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+  const found = [];
+  for (const pathEnvPart of pathEnv) {
+    const p = getPathPart(pathEnvPart, cmd);
+    for (const ext of pathExt) {
+      const withExt = p + ext;
+      const is = U(withExt, {
+        pathExt: pathExtExe,
+        ignoreErrors: true
+      });
+      if (is) {
+        if (!opt.all) {
+          return withExt;
+        }
+        found.push(withExt);
+      }
+    }
+  }
+  if (opt.all && found.length) {
+    return found;
+  }
+  if (opt.nothrow) {
+    return null;
+  }
+  throw getNotFoundError(cmd);
+}
+
+export {
+  promiseSpawn,
+  which,
+  whichSync
+};