@10up/wp-vite-plugins 1.0.0-alpha.3 → 1.0.0-alpha.4

package/dist/runner-jUVlAHlZ.d.ts

@@ -1,183 +0,0 @@
-/**
- * Shared internals for the `wp-vite` commands.
- *
- * `wp-vite build` and `wp-vite watch` are the same idea run two ways: take a
- * dual-pass project (`vite build` for classic scripts, `vite build --mode
- * modules` for Script Modules), clean the out dir once, then drive both passes
- * — sequentially for a build, concurrently for a watch — as a single process
- * with prefixed output and signal-clean shutdown.
- *
- * Everything they have in common lives here: out-dir cleaning, module-pass
- * detection, Vite binary resolution, child spawning with line prefixing,
- * signal forwarding, and argv parsing. The commands themselves are in
- * `./build` and `./watch`.
- *
- * No Vite internals are used — the commands only shell out to the consuming
- * package's own `vite` (or `vp`) binary.
- */
-
-/**
- * The Vite invocations the commands can drive. `script` / `modules` are the
- * two build passes; `dev` is the single serve-mode server `wp-vite dev` runs
- * (there is no second pass in dev — one server handles both, see
- * `wpDevServer`).
- */
-type PassName = 'script' | 'modules' | 'dev';
-/** Which command is driving the passes. Exposed to children as `WP_VITE_RUNNER`. */
-type RunnerName = 'build' | 'watch' | 'dev';
-/**
- * Signals the commands forward. Spelled out rather than pulled from the
- * ambient Node signal type, which this repo's ESLint config reports as an
- * undefined global.
- */
-type RunnerSignal = 'SIGINT' | 'SIGTERM';
-/** Sink for prefixed child output. `process.stdout` satisfies it. */
-interface OutputSink {
-    write(text: string): unknown;
-}
-/** Options shared by `build()` and `watch()`. */
-interface RunnerOptions {
-    /** Package directory the passes run in. Default: `process.cwd()`. */
-    cwd?: string;
-    /**
-     * Directory cleaned once at startup. Must match `build.outDir` of the
-     * Vite config. Default: `'dist'`.
-     */
-    outDir?: string;
-    /**
-     * Force the module pass on/off. When omitted, `detectModulePass` decides.
-     */
-    modules?: boolean;
-    /** `--mode` value for the module pass. Default: `'modules'`. */
-    modulesMode?: string;
-    /**
-     * Binary to run. A bare name (`'vite'`, `'vp'`) is looked up in the
-     * nearest `node_modules/.bin`; a path is used as-is. When omitted, `vite`
-     * is preferred over `vp` (see `resolveViteBin`).
-     */
-    bin?: string;
-    /** Extra arguments appended to both passes. */
-    args?: string[];
-    /** Skip the startup clean. Default: `false` (it cleans). */
-    clean?: boolean;
-    /** Install SIGINT/SIGTERM handlers on `process`. Default: `true`. */
-    handleSignals?: boolean;
-    /** Extra environment for the children. */
-    env?: Record<string, string | undefined>;
-    /** Output sinks. Default: `process.stdout` / `process.stderr`. */
-    stdout?: OutputSink;
-    stderr?: OutputSink;
-    /**
-     * Replaces the built-in argv (`DEFAULT_BUILD_ARGS` / `DEFAULT_WATCH_ARGS`)
-     * for every pass. Escape hatch for tests — it lets a stand-in child stand
-     * in for a real Vite invocation.
-     */
-    buildArgs?: string[];
-}
-/**
- * Arguments every `wp-vite build` pass gets, before the pass-specific
- * `--mode`.
- *
- * `--no-emptyOutDir` makes the runner's own one-time clean the single source
- * of truth, so no pass can delete another's output no matter how the config
- * sets `emptyOutDir`. `--no-clearScreen` keeps the second pass from erasing
- * the first pass' summary.
- */
-declare const DEFAULT_BUILD_ARGS: string[];
-/**
- * Arguments every `wp-vite watch` pass gets, before the pass-specific
- * `--mode`.
- *
- * `--no-emptyOutDir` is what stops the script pass from wiping the module
- * pass' chunks out of dist/ on every rebuild; it overrides `emptyOutDir: true`
- * from the config file (verified on Vite 8). `--no-clearScreen` stops two
- * watchers sharing one terminal from clearing each other's output.
- */
-declare const DEFAULT_WATCH_ARGS: string[];
-/** Binary names tried, in order, when `bin` is not given. */
-declare const BIN_CANDIDATES: readonly ["vite", "vp"];
-interface ModulePassDetection {
-    modules: boolean;
-    /** Why — surfaced in the startup log so the heuristic is never a mystery. */
-    reason: string;
-}
-interface DetectModulePassOptions {
-    cwd?: string;
-    modulesMode?: string;
-    /** Explicit override; wins over every heuristic. */
-    modules?: boolean;
-}
-/**
- * Decide whether this package has a module pass.
- *
- * The commands deliberately do not import the user's Vite config (top-level
- * side effects) and cannot discover Script Module entries themselves — that
- * needs `blocksDir` / `adminPagesDir`, which only the config knows. So they
- * use a cheap, predictable, read-only heuristic:
- *
- *   1. an explicit `modules` option (`--modules` / `--no-modules`) wins;
- *   2. a `package.json` script whose command contains `--mode <modulesMode>`;
- *   3. a Vite config file whose source text contains the mode as a string
- *      literal (`mode === 'modules'`, `'modules'` in a map, …).
- *
- * Everything else means "script pass only".
- */
-declare function detectModulePass(options?: DetectModulePassOptions): ModulePassDetection;
-interface ResolvedBin {
-    /** Binary name, or the raw value when an explicit path was given. */
-    name: string;
-    /** What gets handed to `spawn`. */
-    path: string;
-}
-/**
- * Find the Vite CLI the consuming package would use.
- *
- * Walks `node_modules/.bin` from `cwd` upwards, so workspace packages find a
- * hoisted binary at the monorepo root. `vite` is preferred over `vp`: plain
- * Vite is present in every setup (Vite+ installs it too) and `vp build`'s
- * extra orchestration buys these commands nothing. Packages that need `vp` —
- * for its caching or remote-cache layer — pass `--bin vp`.
- */
-declare function resolveViteBin(cwd?: string, candidates?: readonly string[]): ResolvedBin;
-/**
- * Remove `outDir` — once, before any pass runs. Returns the absolute path that
- * was cleaned.
- */
-declare function cleanOutDir(outDir?: string, cwd?: string): Promise<string>;
-interface LinePrefixer {
-    /** Feed a (possibly partial) chunk of child output. */
-    write(chunk: string): void;
-    /** Emit a trailing line that never got its newline. */
-    flush(): void;
-}
-/**
- * Prefix child output line by line. Chunks arrive on arbitrary boundaries, so
- * a partial trailing line is buffered until its newline shows up.
- *
- * Two cosmetic rules keep interleaved passes readable: blank lines pass
- * through unprefixed (Vite prints plenty, and `[script] ` alone is noise), and
- * a line redrawn with carriage returns is reduced to what a terminal would
- * actually show — the text after the last CR, minus the erase codes.
- */
-declare function createLinePrefixer(prefix: string, write: (text: string) => void): LinePrefixer;
-interface ParsedCliArgs {
-    command: string | undefined;
-    options: RunnerOptions;
-    help: boolean;
-    version: boolean;
-    /** Flags that are not recognised — the CLI reports these and exits 1. */
-    unknown: string[];
-}
-/**
- * Hand-rolled argv parser (no dependency). Supports:
- *
- *   wp-vite <build|watch> [--out-dir dist] [--modules|--no-modules]
- *                         [--modules-mode modules] [--bin vite|vp|<path>]
- *                         [--no-clean] [--cwd <dir>] [-- <extra vite args>]
- *
- * `--flag=value` and `--flag value` are both accepted. Everything after a
- * bare `--` is forwarded verbatim to both Vite passes.
- */
-declare function parseCliArgs(argv: readonly string[]): ParsedCliArgs;
-
-export { BIN_CANDIDATES as B, DEFAULT_BUILD_ARGS as D, type LinePrefixer as L, type ModulePassDetection as M, type OutputSink as O, type ParsedCliArgs as P, type RunnerOptions as R, DEFAULT_WATCH_ARGS as a, type DetectModulePassOptions as b, type PassName as c, type ResolvedBin as d, type RunnerName as e, type RunnerSignal as f, cleanOutDir as g, createLinePrefixer as h, detectModulePass as i, parseCliArgs as p, resolveViteBin as r };

package/dist/watch.d.ts

@@ -1,12 +0,0 @@
-import { R as RunnerOptions } from './runner-jUVlAHlZ.js';
-export { B as BIN_CANDIDATES, D as DEFAULT_BUILD_ARGS, a as DEFAULT_WATCH_ARGS, b as DetectModulePassOptions, L as LinePrefixer, M as ModulePassDetection, O as OutputSink, P as ParsedCliArgs, c as PassName, d as ResolvedBin, e as RunnerName, f as RunnerSignal, g as cleanOutDir, h as createLinePrefixer, i as detectModulePass, p as parseCliArgs, r as resolveViteBin } from './runner-jUVlAHlZ.js';
-
-/** Options for `watch()`. Identical to `build()`'s — see `RunnerOptions`. */
-type WatchOptions = RunnerOptions;
-/**
- * Run the unified watcher. Resolves with the process exit code: `0` for a
- * clean shutdown (SIGINT/SIGTERM), non-zero when a pass died unexpectedly.
- */
-declare function watch(options?: WatchOptions): Promise<number>;
-
-export { RunnerOptions, type WatchOptions, watch };

package/dist/watch.js

@@ -1,398 +0,0 @@
-import { spawn } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
-import { rm } from 'fs/promises';
-import { resolve, join, parse, dirname, isAbsolute, sep } from 'path';
-
-// src/runner.ts
-var DEFAULT_BUILD_ARGS = ["build", "--no-emptyOutDir", "--no-clearScreen"];
-var DEFAULT_WATCH_ARGS = ["build", "--watch", "--no-emptyOutDir", "--no-clearScreen"];
-var BIN_CANDIDATES = ["vite", "vp"];
-function spawnPass(options) {
-  const { pass, stdout, stderr } = options;
-  const child = spawn(options.bin, options.argv, {
-    cwd: options.cwd,
-    env: {
-      ...process.env,
-      ...options.env,
-      WP_VITE_RUNNER: options.runner,
-      WP_VITE_PASS: pass,
-      // Kept for the documented watch-only guard:
-      // `emptyOutDir: !isModulePass && !process.env.WP_VITE_UNIFIED_WATCH`.
-      ...options.runner === "watch" ? { WP_VITE_UNIFIED_WATCH: "1" } : {}
-    },
-    stdio: options.inherit ? "inherit" : ["ignore", "pipe", "pipe"],
-    // .cmd shims are not directly executable on Windows.
-    shell: process.platform === "win32"
-  });
-  if (options.inherit) {
-    const result2 = new Promise((settle) => {
-      let settled = false;
-      const finish = (passResult) => {
-        if (settled) return;
-        settled = true;
-        settle(passResult);
-      };
-      child.on("error", (error) => {
-        stderr.write(`[wp-vite] the ${pass} pass failed to start: ${error.message}
-`);
-        finish({ pass, code: null, signal: null, error });
-      });
-      child.on("close", (code, signal) => finish({ pass, code, signal }));
-    });
-    return { pass, child, result: result2 };
-  }
-  const outPrefixer = createLinePrefixer(`[${pass}] `, (text) => stdout.write(text));
-  const errPrefixer = createLinePrefixer(`[${pass}] `, (text) => stderr.write(text));
-  child.stdout?.setEncoding("utf8");
-  child.stdout?.on("data", (chunk) => outPrefixer.write(chunk));
-  child.stderr?.setEncoding("utf8");
-  child.stderr?.on("data", (chunk) => errPrefixer.write(chunk));
-  const result = new Promise((settle) => {
-    let settled = false;
-    const finish = (passResult) => {
-      if (settled) return;
-      settled = true;
-      outPrefixer.flush();
-      errPrefixer.flush();
-      settle(passResult);
-    };
-    child.on("error", (error) => {
-      stderr.write(`[wp-vite] the ${pass} pass failed to start: ${error.message}
-`);
-      finish({ pass, code: null, signal: null, error });
-    });
-    child.on("close", (code, signal) => finish({ pass, code, signal }));
-  });
-  return { pass, child, result };
-}
-function passArgs(base, pass, modulesMode, extra = []) {
-  return [...base, ...pass === "modules" ? ["--mode", modulesMode] : [], ...extra];
-}
-function forwardSignals(handler) {
-  const bound = ["SIGINT", "SIGTERM"].map(
-    (signal) => [signal, () => handler(signal)]
-  );
-  for (const [signal, listener] of bound) process.on(signal, listener);
-  return () => {
-    for (const [signal, listener] of bound) process.off(signal, listener);
-  };
-}
-function describeExit(code, signal) {
-  if (signal) return `signal ${signal}`;
-  if (code === null) return "unknown cause";
-  return `exit code ${code}`;
-}
-var VITE_CONFIG_FILES = [
-  "vite.config.ts",
-  "vite.config.mts",
-  "vite.config.cts",
-  "vite.config.js",
-  "vite.config.mjs",
-  "vite.config.cjs"
-];
-function detectModulePass(options = {}) {
-  if (typeof options.modules === "boolean") {
-    return {
-      modules: options.modules,
-      reason: `explicit --${options.modules ? "modules" : "no-modules"} flag`
-    };
-  }
-  const cwd = resolve(options.cwd ?? process.cwd());
-  const modulesMode = options.modulesMode ?? "modules";
-  const escapedMode = escapeRegExp(modulesMode);
-  const scriptMatch = new RegExp(`(?:--mode[=\\s]+|(?:^|\\s)-m\\s+)${escapedMode}(?![\\w-])`);
-  const packageJson = readJson(join(cwd, "package.json"));
-  const scripts = packageJson?.scripts;
-  if (scripts && typeof scripts === "object") {
-    for (const [name, command] of Object.entries(scripts)) {
-      if (typeof command === "string" && scriptMatch.test(command)) {
-        return {
-          modules: true,
-          reason: `package.json script "${name}" runs --mode ${modulesMode}`
-        };
-      }
-    }
-  }
-  const configMatch = new RegExp(`(['"\`])${escapedMode}\\1`);
-  for (const fileName of VITE_CONFIG_FILES) {
-    const filePath = join(cwd, fileName);
-    const source = readFileIfExists(filePath);
-    if (source === null) continue;
-    if (configMatch.test(source)) {
-      return { modules: true, reason: `${fileName} mentions the "${modulesMode}" mode` };
-    }
-    return {
-      modules: false,
-      reason: `${fileName} never mentions the "${modulesMode}" mode`
-    };
-  }
-  return {
-    modules: false,
-    reason: `no package.json script or Vite config mentions the "${modulesMode}" mode`
-  };
-}
-function resolveViteBin(cwd = process.cwd(), candidates = BIN_CANDIDATES) {
-  const searched = [];
-  for (const binDir of nodeModulesBinDirs(cwd)) {
-    for (const name of candidates) {
-      for (const fileName of binFileNames(name)) {
-        const candidatePath = join(binDir, fileName);
-        searched.push(candidatePath);
-        if (existsSync(candidatePath)) return { name, path: candidatePath };
-      }
-    }
-  }
-  throw new Error(
-    `[wp-vite] could not find a Vite binary (${candidates.join(" or ")}) in any node_modules/.bin above ${cwd}. Install vite in the package, or pass --bin <name|path>. Looked at:
-  ${searched.join("\n  ")}`
-  );
-}
-function resolveBin(bin, cwd) {
-  if (!bin) return resolveViteBin(cwd).path;
-  if (isAbsolute(bin) || bin.includes("/") || bin.includes("\\")) return bin;
-  try {
-    return resolveViteBin(cwd, [bin]).path;
-  } catch {
-    return bin;
-  }
-}
-function nodeModulesBinDirs(from) {
-  const dirs = [];
-  let current = resolve(from);
-  const { root } = parse(current);
-  while (true) {
-    dirs.push(join(current, "node_modules", ".bin"));
-    if (current === root) break;
-    const parent = dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return dirs;
-}
-function binFileNames(name) {
-  return process.platform === "win32" ? [`${name}.cmd`, name] : [name];
-}
-async function cleanOutDir(outDir = "dist", cwd = process.cwd()) {
-  const base = resolve(cwd);
-  const target = isAbsolute(outDir) ? resolve(outDir) : resolve(base, outDir);
-  if (target === parse(target).root || target === base || !target.startsWith(base + sep)) {
-    throw new Error(
-      `[wp-vite] refusing to clean ${target}: the out dir must be inside ${base}`
-    );
-  }
-  await rm(target, { recursive: true, force: true });
-  return target;
-}
-var ESCAPE = String.fromCharCode(27);
-var ERASE_SEQUENCE = new RegExp(`^(?:${ESCAPE}\\[[0-2]?[KJ])+`);
-function createLinePrefixer(prefix, write) {
-  let buffer = "";
-  const emit = (line) => {
-    const withoutCrlf = line.endsWith("\r") ? line.slice(0, -1) : line;
-    const rendered = withoutCrlf.split("\r").pop() ?? "";
-    const content = rendered.replace(ERASE_SEQUENCE, "");
-    write(content.length === 0 ? "\n" : `${prefix}${content}
-`);
-  };
-  return {
-    write(chunk) {
-      buffer += chunk;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) emit(line);
-    },
-    flush() {
-      if (buffer.length === 0) return;
-      const pending = buffer;
-      buffer = "";
-      emit(pending);
-    }
-  };
-}
-function parseCliArgs(argv) {
-  const parsed = {
-    command: void 0,
-    options: {},
-    help: false,
-    version: false,
-    unknown: []
-  };
-  const passthrough = [];
-  let index = 0;
-  for (; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === "--") {
-      passthrough.push(...argv.slice(index + 1));
-      break;
-    }
-    if (!arg.startsWith("-")) {
-      if (parsed.command === void 0) parsed.command = arg;
-      else parsed.unknown.push(arg);
-      continue;
-    }
-    const equalsAt = arg.indexOf("=");
-    const flag = equalsAt === -1 ? arg : arg.slice(0, equalsAt);
-    const inlineValue = equalsAt === -1 ? void 0 : arg.slice(equalsAt + 1);
-    const takeValue = () => {
-      if (inlineValue !== void 0) return inlineValue;
-      const next = argv[index + 1];
-      if (next === void 0 || next.startsWith("-")) return void 0;
-      index += 1;
-      return next;
-    };
-    switch (flag) {
-      case "-h":
-      case "--help":
-        parsed.help = true;
-        break;
-      case "-v":
-      case "--version":
-        parsed.version = true;
-        break;
-      case "--out-dir":
-      case "--outDir": {
-        const value = takeValue();
-        if (value === void 0) parsed.unknown.push(`${flag} (missing value)`);
-        else parsed.options.outDir = value;
-        break;
-      }
-      case "--modules-mode":
-      case "--modulesMode": {
-        const value = takeValue();
-        if (value === void 0) parsed.unknown.push(`${flag} (missing value)`);
-        else parsed.options.modulesMode = value;
-        break;
-      }
-      case "--bin": {
-        const value = takeValue();
-        if (value === void 0) parsed.unknown.push(`${flag} (missing value)`);
-        else parsed.options.bin = value;
-        break;
-      }
-      case "--cwd": {
-        const value = takeValue();
-        if (value === void 0) parsed.unknown.push(`${flag} (missing value)`);
-        else parsed.options.cwd = value;
-        break;
-      }
-      case "--modules":
-        parsed.options.modules = true;
-        break;
-      case "--no-modules":
-        parsed.options.modules = false;
-        break;
-      case "--clean":
-        parsed.options.clean = true;
-        break;
-      case "--no-clean":
-        parsed.options.clean = false;
-        break;
-      default:
-        parsed.unknown.push(flag);
-    }
-  }
-  if (passthrough.length > 0) parsed.options.args = passthrough;
-  return parsed;
-}
-async function prepareRun(options, runner) {
-  const cwd = resolve(options.cwd ?? process.cwd());
-  const outDir = options.outDir ?? "dist";
-  const modulesMode = options.modulesMode ?? "modules";
-  const stdout = options.stdout ?? process.stdout;
-  const stderr = options.stderr ?? process.stderr;
-  const bin = resolveBin(options.bin, cwd);
-  const detection = detectModulePass({ cwd, modulesMode, modules: options.modules });
-  const passes = detection.modules ? ["script", "modules"] : ["script"];
-  if (options.clean !== false) {
-    const cleaned = await cleanOutDir(outDir, cwd);
-    stdout.write(`[wp-vite] cleaned ${cleaned}
-`);
-  }
-  stdout.write(
-    `[wp-vite] module pass ${detection.modules ? "enabled" : "disabled"} \u2014 ${detection.reason}; ${"watching" } ${passes.join(" + " )} via ${bin}
-`
-  );
-  return { cwd, bin, modulesMode, passes, stdout, stderr };
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function readFileIfExists(filePath) {
-  try {
-    return readFileSync(filePath, "utf8");
-  } catch {
-    return null;
-  }
-}
-function readJson(filePath) {
-  const source = readFileIfExists(filePath);
-  if (source === null) return null;
-  try {
-    return JSON.parse(source);
-  } catch {
-    return null;
-  }
-}
-
-// src/watch.ts
-async function watch(options = {}) {
-  const { cwd, bin, modulesMode, passes, stdout, stderr } = await prepareRun(options);
-  const children = [];
-  let shuttingDown = false;
-  let exitCode = 0;
-  const shutdown = (signal) => {
-    shuttingDown = true;
-    for (const child of children) {
-      if (child.exitCode === null && child.signalCode === null) child.kill(signal);
-    }
-  };
-  const disposeSignals = options.handleSignals === false ? () => {
-  } : forwardSignals((signal) => {
-    if (shuttingDown) return;
-    exitCode = 0;
-    shutdown(signal);
-  });
-  const spawned = passes.map(
-    (pass) => spawnPass({
-      pass,
-      runner: "watch",
-      bin,
-      cwd,
-      argv: passArgs(
-        options.buildArgs ?? DEFAULT_WATCH_ARGS,
-        pass,
-        modulesMode,
-        options.args ?? []
-      ),
-      env: options.env,
-      stdout,
-      stderr
-    })
-  );
-  children.push(...spawned.map(({ child }) => child));
-  let running = spawned.length;
-  try {
-    await Promise.all(
-      spawned.map(async ({ pass, result }) => {
-        const passResult = await result;
-        running -= 1;
-        if (shuttingDown) return;
-        const unexpected = passResult.error != null || passResult.code === null || passResult.code !== 0 || running > 0;
-        if (!unexpected) return;
-        exitCode = passResult.code && passResult.code !== 0 ? passResult.code : 1;
-        stderr.write(
-          `[wp-vite] the ${pass} pass exited unexpectedly (${describeExit(passResult.code, passResult.signal)}) \u2014 stopping
-`
-        );
-        shutdown("SIGTERM");
-      })
-    );
-    return exitCode;
-  } finally {
-    disposeSignals();
-  }
-}
-
-export { BIN_CANDIDATES, DEFAULT_BUILD_ARGS, DEFAULT_WATCH_ARGS, cleanOutDir, createLinePrefixer, detectModulePass, parseCliArgs, resolveViteBin, watch };
-//# sourceMappingURL=watch.js.map
-//# sourceMappingURL=watch.js.map