obsidian-dev-utils 85.1.0 → 86.1.0

package/dist/lib/esm/script-utils/exec.mjs

@@ -31,6 +31,26 @@ import {
   cmdEscapeCommandLine,
   toCommandLine
 } from "./cli-utils.mjs";
+function appendNodeOption(existingNodeOptions, option) {
+  const trimmed = (existingNodeOptions ?? "").trim();
+  if (trimmed === "") {
+    return option;
+  }
+  if (trimmed.split(/\s+/).includes(option)) {
+    return trimmed;
+  }
+  return `${trimmed} ${option}`;
+}
+function buildChildEnv(baseEnv, allowedNodeEnvironmentFlags) {
+  const env = {
+    DEBUG_COLORS: "1",
+    ...baseEnv
+  };
+  if (allowedNodeEnvironmentFlags.has("--localstorage-file")) {
+    env["NODE_OPTIONS"] = appendNodeOption(baseEnv["NODE_OPTIONS"], LOCAL_STORAGE_NODE_OPTION);
+  }
+  return env;
+}
 function exec(command, options = {}) {
   if (Array.isArray(command)) {
     const batchResult = handleBatchedCommand(command, options);
@@ -74,6 +94,8 @@ function execString(params) {
   } = params;
   const {
     cwd = process.cwd(),
+    env,
+    isInteractive = false,
     isQuiet: quiet = false,
     shouldIgnoreExitCode: ignoreExitCode = false,
     shouldIncludeDetails = false,
@@ -84,36 +106,48 @@ function execString(params) {
     const child = spawnViaShell(normalizeOptionalProperties({
       command,
       cwd,
+      env,
+      isInteractive,
       rawArgs
     }));
     let stdout = "";
     let stderr = "";
-    child.stdin.write(stdin);
-    child.stdin.end();
-    child.stdout.on("data", (data) => {
-      if (!quiet) {
-        process.stdout.write(data);
-      }
-      stdout += data.toString("utf-8");
-    });
-    child.stdout.on("end", () => {
-      stdout = trimEnd({
-        str: stdout,
-        suffix: "\n"
+    if (!isInteractive) {
+      const {
+        stderr: childStderr,
+        stdin: childStdin,
+        stdout: childStdout
+      } = child;
+      assertNonNullable(childStdin, "Child process stdin is not available");
+      assertNonNullable(childStdout, "Child process stdout is not available");
+      assertNonNullable(childStderr, "Child process stderr is not available");
+      childStdin.write(stdin);
+      childStdin.end();
+      childStdout.on("data", (data) => {
+        if (!quiet) {
+          process.stdout.write(data);
+        }
+        stdout += data.toString("utf-8");
       });
-    });
-    child.stderr.on("data", (data) => {
-      if (!quiet) {
-        process.stderr.write(data);
-      }
-      stderr += data.toString("utf-8");
-    });
-    child.stderr.on("end", () => {
-      stderr = trimEnd({
-        str: stderr,
-        suffix: "\n"
+      childStdout.on("end", () => {
+        stdout = trimEnd({
+          str: stdout,
+          suffix: "\n"
+        });
       });
-    });
+      childStderr.on("data", (data) => {
+        if (!quiet) {
+          process.stderr.write(data);
+        }
+        stderr += data.toString("utf-8");
+      });
+      childStderr.on("end", () => {
+        stderr = trimEnd({
+          str: stderr,
+          suffix: "\n"
+        });
+      });
+    }
     child.on("close", (exitCode, exitSignal) => {
       if (exitCode !== 0 && !ignoreExitCode) {
         reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : "(null)"}
@@ -149,10 +183,8 @@ ${stderr}`));
     });
   });
 }
-const CHILD_ENV = {
-  DEBUG_COLORS: "1",
-  ...process.env
-};
+const LOCAL_STORAGE_NODE_OPTION = "--localstorage-file=:memory:";
+const CHILD_ENV = buildChildEnv(process.env, process.allowedNodeEnvironmentFlags);
 async function executeBatches(params) {
   const { baseCommand, batches, options } = params;
   const results = [];
@@ -227,7 +259,12 @@ function isExecArg(part) {
   return typeof part === "object" && "batchedArgs" in part;
 }
 function spawnViaShell(params) {
-  const { command, cwd, rawArgs } = params;
+  const { command, cwd, env: extraEnv, isInteractive = false, rawArgs } = params;
+  const env = {
+    ...CHILD_ENV,
+    ...extraEnv
+  };
+  const stdio = isInteractive ? "inherit" : "pipe";
   if (process.platform === "win32" && command.includes("\n")) {
     if (!rawArgs) {
       throw new Error("Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.");
@@ -236,19 +273,21 @@ function spawnViaShell(params) {
     assertNonNullable(program, "Command array must not be empty");
     return spawn(program, args, {
       cwd,
-      env: CHILD_ENV,
-      stdio: "pipe"
+      env,
+      stdio
     });
   }
   const shellCommand = process.platform === "win32" ? cmdEscapeCommandLine(command) : command;
   return spawn(shellCommand, [], {
     cwd,
-    env: CHILD_ENV,
+    env,
     shell: true,
-    stdio: "pipe"
+    stdio
   });
 }
 export {
+  appendNodeOption,
+  buildChildEnv,
   exec
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/exec.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcessWithoutNullStreams } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\nimport { getLibDebugger } from '../debug.ts';\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport { trimEnd } from '../string.ts';\nimport { assertNonNullable } from '../type-guards.ts';\nimport {\n  cmdEscapeCommandLine,\n  toCommandLine\n} from './cli-utils.ts';\n\n/**\n * A command part: either a plain string or an {@link ExecArg} with batched arguments.\n */\nexport type CommandPart = ExecArg | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArg {\n  /**\n   * The arguments to batch.\n   */\n  readonly batchedArgs: readonly string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOptions {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  readonly shouldIncludeDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOptions {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   *\n   * @default `false`\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, throws an error if the command fails.\n   *\n   * @default `true`\n   */\n  readonly shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `false`, only returns the output of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   *\n   * @default `''`\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  readonly exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  readonly stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  readonly stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOptions {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: false;\n}\n\n/**\n * Parameters for {@link execString}.\n */\ninterface ExecStringParams {\n  /**\n   * The command string.\n   */\n  readonly command: string;\n\n  /**\n   * The exec options.\n   */\n  readonly options?: ExecOptions;\n\n  /**\n   * The original argument array (if available), used by the PowerShell\n   * fallback path to quote arguments with PowerShell-native single quotes.\n   */\n  readonly rawArgs?: string[];\n}\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport async function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: CommandPart[] | string, options: ExecOptions = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const args = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(args);\n\n    const maxCommandLength = getMaxCommandLength();\n    if (commandLine.length > maxCommandLength) {\n      return Promise.reject(\n        new Error(\n          `Command line is too long (${String(commandLine.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n        )\n      );\n    }\n\n    return execString({\n      command: commandLine,\n      options,\n      rawArgs: args\n    });\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  if (command.length > maxCommandLength) {\n    return Promise.reject(\n      new Error(\n        `Command line is too long (${String(command.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n      )\n    );\n  }\n\n  return execString({\n    command,\n    options\n  });\n}\n\n/**\n * Executes a single string command.\n *\n * @param params - The parameters for the execution.\n * @returns A Promise resolving to the result.\n */\nfunction execString(params: ExecStringParams): Promise<ExecResult | string> {\n  const {\n    command,\n    options = {},\n    rawArgs\n  } = params;\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n\n    const child = spawnViaShell(normalizeOptionalProperties<SpawnViaShellParams>({\n      command,\n      cwd,\n      rawArgs\n    }));\n\n    let stdout = '';\n    let stderr = '';\n\n    child.stdin.write(stdin);\n    child.stdin.end();\n\n    child.stdout.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stdout.write(data);\n      }\n      stdout += data.toString('utf-8');\n    });\n\n    child.stdout.on('end', () => {\n      stdout = trimEnd({\n        str: stdout,\n        suffix: '\\n'\n      });\n    });\n\n    child.stderr.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stderr.write(data);\n      }\n      stderr += data.toString('utf-8');\n    });\n\n    child.stderr.on('end', () => {\n      stderr = trimEnd({\n        str: stderr,\n        suffix: '\\n'\n      });\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * Default environment variables passed to child processes.\n */\nconst CHILD_ENV = {\n  DEBUG_COLORS: '1',\n  ...process.env\n};\n\n/**\n * Parameters for {@link executeBatches}.\n */\ninterface ExecuteBatchesParams {\n  /**\n   * The base command without batched args.\n   */\n  readonly baseCommand: string;\n\n  /**\n   * The batches of args.\n   */\n  readonly batches: string[][];\n\n  /**\n   * The exec options.\n   */\n  readonly options: ExecOptions;\n}\n\n/**\n * Parameters for {@link spawnViaShell}.\n */\ninterface SpawnViaShellParams {\n  /**\n   * The command string to execute.\n   */\n  readonly command: string;\n\n  /**\n   * The working directory.\n   */\n  readonly cwd: string;\n\n  /**\n   * The original argument array (if available).\n   */\n  readonly rawArgs?: string[];\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param params - The parameters for the batched execution.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(params: ExecuteBatchesParams): Promise<ExecResult | string> {\n  const { baseCommand, batches, options } = params;\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString({\n      command: batchCommand,\n      options\n    });\n    if (typeof result === 'string') {\n      results.push(result);\n    }\n  }\n\n  if (options.shouldIncludeDetails) {\n    return { exitCode: 0, exitSignal: null, stderr: '', stdout: results.join('\\n') };\n  }\n\n  return results.join('\\n');\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArg}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOptions): Promise<ExecResult | string> | undefined {\n  const execArgs = parts.filter(isExecArg);\n  if (execArgs.length === 0) {\n    return undefined;\n  }\n  if (execArgs.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArgs is allowed per command'));\n  }\n\n  const execArg = execArgs[0];\n  assertNonNullable(execArg);\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  // Try expanding all args inline\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString({\n      command: fullCommand,\n      options\n    });\n  }\n\n  // Split into batches\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const arg of execArg.batchedArgs) {\n    const tentative = `${baseCommand} ${[...currentBatch, arg].join(' ')}`;\n    if (tentative.length > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [arg];\n    } else {\n      currentBatch.push(arg);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArgs is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches({\n    baseCommand,\n    batches,\n    options\n  });\n}\n\n/**\n * Checks if a command part is an {@link ExecArg}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArg(part: CommandPart): part is ExecArg {\n  return typeof part === 'object' && 'batchedArgs' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param params - The parameters for spawning the child process.\n * @returns The spawned child process.\n */\nfunction spawnViaShell(params: SpawnViaShellParams): ChildProcessWithoutNullStreams {\n  const { command, cwd, rawArgs } = params;\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArgs) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...args] = rawArgs;\n    assertNonNullable(program, 'Command array must not be empty');\n    return spawn(program, args, {\n      cwd,\n      env: CHILD_ENV,\n      stdio: 'pipe'\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? cmdEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env: CHILD_ENV,\n    shell: true,\n    stdio: 'pipe'\n  });\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/exec.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\nimport { getLibDebugger } from '../debug.ts';\nimport { normalizeOptionalProperties } from '../object-utils.ts';\nimport { trimEnd } from '../string.ts';\nimport { assertNonNullable } from '../type-guards.ts';\nimport {\n  cmdEscapeCommandLine,\n  toCommandLine\n} from './cli-utils.ts';\n\n/**\n * A command part: either a plain string or an {@link ExecArg} with batched arguments.\n */\nexport type CommandPart = ExecArg | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArg {\n  /**\n   * The arguments to batch.\n   */\n  readonly batchedArgs: readonly string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOptions {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  readonly shouldIncludeDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOptions {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * Additional environment variables for the child process, merged over the inherited environment.\n   *\n   * @default `{}`\n   */\n  readonly env?: NodeJS.ProcessEnv;\n\n  /**\n   * If `true`, attaches the child process's stdio directly to the terminal (`stdio: 'inherit'`) instead\n   * of capturing it. Use for long-running or interactive commands such as dev servers and watch mode.\n   * Because the output is not captured, the resolved stdout is an empty string.\n   *\n   * @default `false`\n   */\n  readonly isInteractive?: boolean;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   *\n   * @default `false`\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, throws an error if the command fails.\n   *\n   * @default `true`\n   */\n  readonly shouldFailIfCalledFromOutsideRoot?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `false`, only returns the output of the command.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   *\n   * @default `''`\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  readonly exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  readonly stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  readonly stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOptions {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   *\n   * @default `false`\n   */\n  readonly shouldIncludeDetails?: false;\n}\n\n/**\n * Parameters for {@link execString}.\n */\ninterface ExecStringParams {\n  /**\n   * The command string.\n   */\n  readonly command: string;\n\n  /**\n   * The exec options.\n   */\n  readonly options?: ExecOptions;\n\n  /**\n   * The original argument array (if available), used by the PowerShell\n   * fallback path to quote arguments with PowerShell-native single quotes.\n   */\n  readonly rawArgs?: string[];\n}\n/**\n * Appends a single `node` CLI option to a `NODE_OPTIONS` string, preserving any options already present.\n *\n * @param existingNodeOptions - The current `NODE_OPTIONS` value (e.g. `process.env.NODE_OPTIONS`), if any.\n * @param option - The `node` CLI option to append (e.g. `--localstorage-file=:memory:`).\n * @returns The combined `NODE_OPTIONS` string. If `option` is already present, the value is returned unchanged.\n */\nexport function appendNodeOption(existingNodeOptions: string | undefined, option: string): string {\n  const trimmed = (existingNodeOptions ?? '').trim();\n  if (trimmed === '') {\n    return option;\n  }\n  if (trimmed.split(/\\s+/).includes(option)) {\n    return trimmed;\n  }\n  return `${trimmed} ${option}`;\n}\n\n/**\n * Builds the environment for child processes: the parent environment plus `DEBUG_COLORS`, and \u2014 when\n * the running `node` supports it \u2014 {@link LOCAL_STORAGE_NODE_OPTION} appended to `NODE_OPTIONS`.\n *\n * The support check guards against older `node` (< 22): passing an option `node` does not recognize via\n * `NODE_OPTIONS` makes it exit before running, which would break every spawned tool.\n *\n * @param baseEnv - The parent environment to extend (typically `process.env`).\n * @param allowedNodeEnvironmentFlags - The `node` options accepted via `NODE_OPTIONS` (typically `process.allowedNodeEnvironmentFlags`).\n * @returns The environment to pass to spawned child processes.\n */\nexport function buildChildEnv(baseEnv: NodeJS.ProcessEnv, allowedNodeEnvironmentFlags: ReadonlySet<string>): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = {\n    DEBUG_COLORS: '1',\n    ...baseEnv\n  };\n  if (allowedNodeEnvironmentFlags.has('--localstorage-file')) {\n    env['NODE_OPTIONS'] = appendNodeOption(baseEnv['NODE_OPTIONS'], LOCAL_STORAGE_NODE_OPTION);\n  }\n  return env;\n}\n\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport async function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n *          The ExecResult object contains the exit code, exit signal, stderr, and stdout.\n * @throws If the command fails with a non-zero exit code and ignoreExitCode is `false`.\n *         The error message includes the exit code and stderr.\n *         If an error occurs during the execution and ignoreExitCode is `true`,\n *         the error is resolved with the stdout and stderr.\n */\nexport function exec(command: CommandPart[] | string, options: ExecOptions = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const args = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(args);\n\n    const maxCommandLength = getMaxCommandLength();\n    if (commandLine.length > maxCommandLength) {\n      return Promise.reject(\n        new Error(\n          `Command line is too long (${String(commandLine.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n        )\n      );\n    }\n\n    return execString({\n      command: commandLine,\n      options,\n      rawArgs: args\n    });\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  if (command.length > maxCommandLength) {\n    return Promise.reject(\n      new Error(\n        `Command line is too long (${String(command.length)} chars, max ${String(maxCommandLength)} on ${process.platform}). Consider splitting into smaller batches or use ExecArg.`\n      )\n    );\n  }\n\n  return execString({\n    command,\n    options\n  });\n}\n\n/**\n * Executes a single string command.\n *\n * @param params - The parameters for the execution.\n * @returns A Promise resolving to the result.\n */\nfunction execString(params: ExecStringParams): Promise<ExecResult | string> {\n  const {\n    command,\n    options = {},\n    rawArgs\n  } = params;\n  const {\n    cwd = process.cwd(),\n    env,\n    isInteractive = false,\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    getLibDebugger('Exec')(`Executing command: ${command}`);\n\n    const child = spawnViaShell(normalizeOptionalProperties<SpawnViaShellParams>({\n      command,\n      cwd,\n      env,\n      isInteractive,\n      rawArgs\n    }));\n\n    let stdout = '';\n    let stderr = '';\n\n    // In interactive mode the child's stdio is inherited by the terminal, so there are no streams to read and nothing is captured.\n    if (!isInteractive) {\n      const {\n        stderr: childStderr,\n        stdin: childStdin,\n        stdout: childStdout\n      } = child;\n      assertNonNullable(childStdin, 'Child process stdin is not available');\n      assertNonNullable(childStdout, 'Child process stdout is not available');\n      assertNonNullable(childStderr, 'Child process stderr is not available');\n\n      childStdin.write(stdin);\n      childStdin.end();\n\n      childStdout.on('data', (data: Buffer) => {\n        if (!quiet) {\n          process.stdout.write(data);\n        }\n        stdout += data.toString('utf-8');\n      });\n\n      childStdout.on('end', () => {\n        stdout = trimEnd({\n          str: stdout,\n          suffix: '\\n'\n        });\n      });\n\n      childStderr.on('data', (data: Buffer) => {\n        if (!quiet) {\n          process.stderr.write(data);\n        }\n        stderr += data.toString('utf-8');\n      });\n\n      childStderr.on('end', () => {\n        stderr = trimEnd({\n          str: stderr,\n          suffix: '\\n'\n        });\n      });\n    }\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!shouldIncludeDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * A `node` CLI option (passed via `NODE_OPTIONS`) that provides an in-memory `localStorage` to every\n * spawned `node` process. Node 22+ exposes an experimental Web Storage `localStorage`, but accessing it\n * without `--localstorage-file` emits an `ExperimentalWarning` and leaves `localStorage` unavailable.\n * Pointing it at the special `:memory:` database gives each process a working, non-persistent\n * `localStorage` (no file on disk, no state shared between processes) \u2014 matching the real Obsidian\n * (Electron) runtime and silencing the warning by addressing its root cause rather than suppressing it.\n *\n * It is applied only when the running `node` actually supports it (see {@link buildChildEnv}): passing\n * an option `node` does not recognize via `NODE_OPTIONS` makes it refuse to start, so an older `node`\n * (< 22) must be left untouched.\n */\nconst LOCAL_STORAGE_NODE_OPTION = '--localstorage-file=:memory:';\n\n/**\n * Default environment variables passed to child processes.\n */\nconst CHILD_ENV = buildChildEnv(process.env, process.allowedNodeEnvironmentFlags);\n\n/**\n * Parameters for {@link executeBatches}.\n */\ninterface ExecuteBatchesParams {\n  /**\n   * The base command without batched args.\n   */\n  readonly baseCommand: string;\n\n  /**\n   * The batches of args.\n   */\n  readonly batches: string[][];\n\n  /**\n   * The exec options.\n   */\n  readonly options: ExecOptions;\n}\n\n/**\n * Parameters for {@link spawnViaShell}.\n */\ninterface SpawnViaShellParams {\n  /**\n   * The command string to execute.\n   */\n  readonly command: string;\n\n  /**\n   * The working directory.\n   */\n  readonly cwd: string;\n\n  /**\n   * Additional environment variables merged over the inherited child environment.\n   */\n  readonly env?: NodeJS.ProcessEnv;\n\n  /**\n   * If `true`, attaches the child's stdio to the terminal instead of piping it.\n   */\n  readonly isInteractive?: boolean;\n\n  /**\n   * The original argument array (if available).\n   */\n  readonly rawArgs?: string[];\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param params - The parameters for the batched execution.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(params: ExecuteBatchesParams): Promise<ExecResult | string> {\n  const { baseCommand, batches, options } = params;\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString({\n      command: batchCommand,\n      options\n    });\n    if (typeof result === 'string') {\n      results.push(result);\n    }\n  }\n\n  if (options.shouldIncludeDetails) {\n    return { exitCode: 0, exitSignal: null, stderr: '', stdout: results.join('\\n') };\n  }\n\n  return results.join('\\n');\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArg}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOptions): Promise<ExecResult | string> | undefined {\n  const execArgs = parts.filter(isExecArg);\n  if (execArgs.length === 0) {\n    return undefined;\n  }\n  if (execArgs.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArgs is allowed per command'));\n  }\n\n  const execArg = execArgs[0];\n  assertNonNullable(execArg);\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  // Try expanding all args inline\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString({\n      command: fullCommand,\n      options\n    });\n  }\n\n  // Split into batches\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const arg of execArg.batchedArgs) {\n    const tentative = `${baseCommand} ${[...currentBatch, arg].join(' ')}`;\n    if (tentative.length > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [arg];\n    } else {\n      currentBatch.push(arg);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArgs is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches({\n    baseCommand,\n    batches,\n    options\n  });\n}\n\n/**\n * Checks if a command part is an {@link ExecArg}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArg(part: CommandPart): part is ExecArg {\n  return typeof part === 'object' && 'batchedArgs' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param params - The parameters for spawning the child process.\n * @returns The spawned child process.\n */\nfunction spawnViaShell(params: SpawnViaShellParams): ChildProcess {\n  const { command, cwd, env: extraEnv, isInteractive = false, rawArgs } = params;\n  const env: NodeJS.ProcessEnv = {\n    ...CHILD_ENV,\n    ...extraEnv\n  };\n  const stdio: 'inherit' | 'pipe' = isInteractive ? 'inherit' : 'pipe';\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArgs) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...args] = rawArgs;\n    assertNonNullable(program, 'Command array must not be empty');\n    return spawn(program, args, {\n      cwd,\n      env,\n      stdio\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? cmdEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env,\n    shell: true,\n    stdio\n  });\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength"]
}


package/dist/lib/esm/script-utils/index.d.mts

@@ -5,6 +5,7 @@ export * as 'check-project-types' from './check-project-types.mjs';
 export * as 'cli-utils' from './cli-utils.mjs';
 export * as 'code-generator' from './code-generator.mjs';
 export * as 'commitlint-config' from './commitlint-config.mjs';
+export * as 'demo-vault' from './demo-vault.mjs';
 export * as 'exec' from './exec.mjs';
 export * as 'formatters' from './formatters/index.mjs';
 export * as 'fs' from './fs.mjs';
@@ -19,3 +20,4 @@ export * as 'root' from './root.mjs';
 export * as 'test-runners' from './test-runners/index.mjs';
 export * as 'validate-declarations' from './validate-declarations.mjs';
 export * as 'version' from './version.mjs';
+export * as 'warnings-as-errors' from './warnings-as-errors.mjs';

package/dist/lib/esm/script-utils/index.mjs

@@ -27,6 +27,7 @@ import * as check_project_types from "./check-project-types.mjs";
 import * as cli_utils from "./cli-utils.mjs";
 import * as code_generator from "./code-generator.mjs";
 import * as commitlint_config from "./commitlint-config.mjs";
+import * as demo_vault from "./demo-vault.mjs";
 import * as exec from "./exec.mjs";
 import * as formatters from "./formatters/index.mjs";
 import * as fs from "./fs.mjs";
@@ -41,6 +42,7 @@ import * as root from "./root.mjs";
 import * as test_runners from "./test-runners/index.mjs";
 import * as validate_declarations from "./validate-declarations.mjs";
 import * as version from "./version.mjs";
+import * as warnings_as_errors from "./warnings-as-errors.mjs";
 export {
   build,
   bundlers,
@@ -48,6 +50,7 @@ export {
   cli_utils as "cli-utils",
   code_generator as "code-generator",
   commitlint_config as "commitlint-config",
+  demo_vault as "demo-vault",
   exec,
   formatters,
   fs,
@@ -61,6 +64,7 @@ export {
   root,
   test_runners as "test-runners",
   validate_declarations as "validate-declarations",
-  version
+  version,
+  warnings_as_errors as "warnings-as-errors"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/script-utils/linters/eslint-no-restricted-syntax.mjs

@@ -62,10 +62,6 @@ const noRestrictedSyntaxRuleEntries = [
     message: 'Do not rename imports with "Mock" in the alias. Mock classes are the canonical types \u2014 use the original name.',
     selector: "ImportSpecifier[local.name=/Mock/]:not([imported.name=/Mock/])"
   },
-  {
-    message: "Avoid dynamic import(). Use static imports instead. Only use dynamic imports for lazy/conditional loading.",
-    selector: "ImportExpression"
-  },
   {
     message: "Do not use `declare` on class properties. Initialize the property or use a regular type annotation.",
     selector: "PropertyDefinition[declare=true]"
@@ -74,4 +70,4 @@ const noRestrictedSyntaxRuleEntries = [
 export {
   noRestrictedSyntaxRuleEntries
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL3NjcmlwdC11dGlscy9saW50ZXJzL2VzbGludC1uby1yZXN0cmljdGVkLXN5bnRheC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIGBuby1yZXN0cmljdGVkLXN5bnRheGAgcnVsZSBlbnRyaWVzIGZvciB0aGUgc2hhcmVkIEVTTGludCBjb25maWcuXG4gKlxuICogRXhwb3J0ZWQgYXMgYSBzdGFuZGFsb25lIGNvbnN0YW50IHNvIGVhY2ggc2VsZWN0b3IgY2FuIGJlIHVuaXQtdGVzdGVkXG4gKiBpbmRlcGVuZGVudGx5IG9mIHRoZSBsYXJnZXIgZGVjbGFyYXRpdmUgY29uZmlnLlxuICovXG5cbi8qKlxuICogQSBzaW5nbGUgYG5vLXJlc3RyaWN0ZWQtc3ludGF4YCBlbnRyeSBwYWlyaW5nIGFuIEVTTGludCBBU1Qgc2VsZWN0b3Igd2l0aCBhXG4gKiBodW1hbi1yZWFkYWJsZSBtZXNzYWdlIGV4cGxhaW5pbmcgd2h5IHRoZSBwYXR0ZXJuIGlzIGJhbm5lZC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBOb1Jlc3RyaWN0ZWRTeW50YXhSdWxlRW50cnkge1xuICAvKipcbiAgICogSHVtYW4tcmVhZGFibGUgbWVzc2FnZSBzaG93biB3aGVuIHRoZSBzZWxlY3RvciBtYXRjaGVzLlxuICAgKi9cbiAgbWVzc2FnZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBFU0xpbnQgQVNUIHNlbGVjdG9yIGlkZW50aWZ5aW5nIHRoZSBiYW5uZWQgcGF0dGVybi5cbiAgICovXG4gIHNlbGVjdG9yOiBzdHJpbmc7XG59XG5cbi8qKlxuICogUmVzdHJpY3RlZC1zeW50YXggZW50cmllcyBlbmZvcmNlZCBieSB0aGUgc2hhcmVkIEVTTGludCBjb25maWcuXG4gKi9cbmV4cG9ydCBjb25zdCBub1Jlc3RyaWN0ZWRTeW50YXhSdWxlRW50cmllczogcmVhZG9ubHkgTm9SZXN0cmljdGVkU3ludGF4UnVsZUVudHJ5W10gPSBbXG4gIHtcbiAgICBtZXNzYWdlOiAnRG8gbm90IHVzZSBkZWZpbml0ZSBhc3NpZ25tZW50IGFzc2VydGlvbnMgKCEpLiBJbml0aWFsaXplIHRoZSBmaWVsZCBvciBtYWtlIGl0IG9wdGlvbmFsLicsXG4gICAgc2VsZWN0b3I6ICdQcm9wZXJ0eURlZmluaXRpb25bZGVmaW5pdGU9dHJ1ZV0nXG4gIH0sXG4gIHtcbiAgICBtZXNzYWdlOiAnRG8gbm90IHVzZSBkZWZpbml0ZSBhc3NpZ25tZW50IGFzc2VydGlvbnMgKCEpIG9uIGFic3RyYWN0IGZpZWxkcy4nLFxuICAgIHNlbGVjdG9yOiAnVFNBYnN0cmFjdFByb3BlcnR5RGVmaW5pdGlvbltkZWZpbml0ZT10cnVlXSdcbiAgfSxcbiAge1xuICAgIG1lc3NhZ2U6ICdEbyBub3QgdXNlIGFub255bW91cyBpbmxpbmUgb2JqZWN0IHR5cGVzLiBEZWZpbmUgYSBuYW1lZCBpbnRlcmZhY2Ugb3IgYHR5cGVgIGFsaWFzIGluc3RlYWQuJyxcbiAgICBzZWxlY3RvcjogJ1RTVHlwZUxpdGVyYWw6bm90KFRTVHlwZUFsaWFzRGVjbGFyYXRpb24gPiBUU1R5cGVMaXRlcmFsKSdcbiAgfSxcbiAge1xuICAgIG1lc3NhZ2U6ICdEbyBub3QgdXNlIGFub255bW91cyBpbmxpbmUgbWFwcGVkIHR5cGVzLiBEZWZpbmUgYSBuYW1lZCBgdHlwZWAgYWxpYXMgaW5zdGVhZC4nLFxuICAgIHNlbGVjdG9yOiAnVFNNYXBwZWRUeXBlOm5vdChUU1R5cGVBbGlhc0RlY2xhcmF0aW9uID4gVFNNYXBwZWRUeXBlKSdcbiAgfSxcbiAge1xuICAgIG1lc3NhZ2U6ICdEbyBub3QgdXNlIGRvdWJsZSB0eXBlIGFzc2VydGlvbnMgKGFzIFggYXMgWSkuJyxcbiAgICBzZWxlY3RvcjogJ1RTQXNFeHByZXNzaW9uID4gVFNBc0V4cHJlc3Npb24nXG4gIH0sXG4gIHtcbiAgICBtZXNzYWdlOiAnRG8gbm90IHVzZSBgYXMgbmV2ZXJgLiBJdCBzaWxlbnRseSBzYXRpc2ZpZXMgdHlwZSBjb25zdHJhaW50cyBieSBjbGFpbWluZyBcInRoaXMgdmFsdWUgaXMgb2YgZXZlcnkgdHlwZVwiIFx1MjAxNCBhbG1vc3QgYWx3YXlzIG1hc2tzIGEgcmVhbCB0eXBlIG1pc21hdGNoLiBGaXggdGhlIHVuZGVybHlpbmcgdHlwZXMgaW5zdGVhZC4nLFxuICAgIHNlbGVjdG9yOiAnVFNBc0V4cHJlc3Npb24gPiBUU05ldmVyS2V5d29yZCdcbiAgfSxcbiAge1xuICAgIG1lc3NhZ2U6ICdEbyBub3QgdXNlIGA8bmV2ZXI+YCB0eXBlIGFzc2VydGlvbnMuIFNhbWUgcmVhc29uaW5nIGFzIGBhcyBuZXZlcmAuJyxcbiAgICBzZWxlY3RvcjogJ1RTVHlwZUFzc2VydGlvbiA+IFRTTmV2ZXJLZXl3b3JkJ1xuICB9LFxuICB7XG4gICAgbWVzc2FnZTogJ0RvIG5vdCB1c2UgXyBwcmVmaXggb24gbWV0aG9kcyBvciBmdW5jdGlvbnMuIFRoZSBfIHByZWZpeCBpcyBmb3IgdW51c2VkIHBhcmFtZXRlcnMgb25seS4nLFxuICAgIHNlbGVjdG9yOiAnTWV0aG9kRGVmaW5pdGlvbltrZXkubmFtZT0vXl8vXTpub3QoW292ZXJyaWRlPXRydWVdKSdcbiAgfSxcbiAge1xuICAgIG1lc3NhZ2U6ICdEbyBub3QgdXNlIF8gcHJlZml4IG9uIG1ldGhvZHMgb3IgZnVuY3Rpb25zLiBUaGUgXyBwcmVmaXggaXMgZm9yIHVudXNlZCBwYXJhbWV0ZXJzIG9ubHkuJyxcbiAgICBzZWxlY3RvcjogJ0Z1bmN0aW9uRGVjbGFyYXRpb25baWQubmFtZT0vXl8vXSdcbiAgfSxcbiAge1xuICAgIG1lc3NhZ2U6ICdEbyBub3QgcmVuYW1lIGltcG9ydHMgd2l0aCBcIk1vY2tcIiBpbiB0aGUgYWxpYXMuIE1vY2sgY2xhc3NlcyBhcmUgdGhlIGNhbm9uaWNhbCB0eXBlcyBcdTIwMTQgdXNlIHRoZSBvcmlnaW5hbCBuYW1lLicsXG4gICAgc2VsZWN0b3I6ICdJbXBvcnRTcGVjaWZpZXJbbG9jYWwubmFtZT0vTW9jay9dOm5vdChbaW1wb3J0ZWQubmFtZT0vTW9jay9dKSdcbiAgfSxcbiAge1xuICAgIG1lc3NhZ2U6ICdEbyBub3QgdXNlIGBkZWNsYXJlYCBvbiBjbGFzcyBwcm9wZXJ0aWVzLiBJbml0aWFsaXplIHRoZSBwcm9wZXJ0eSBvciB1c2UgYSByZWd1bGFyIHR5cGUgYW5ub3RhdGlvbi4nLFxuICAgIHNlbGVjdG9yOiAnUHJvcGVydHlEZWZpbml0aW9uW2RlY2xhcmU9dHJ1ZV0nXG4gIH1cbl07XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQTRCTyxNQUFNLGdDQUF3RTtBQUFBLEVBQ25GO0FBQUEsSUFDRSxTQUFTO0FBQUEsSUFDVCxVQUFVO0FBQUEsRUFDWjtBQUFBLEVBQ0E7QUFBQSxJQUNFLFNBQVM7QUFBQSxJQUNULFVBQVU7QUFBQSxFQUNaO0FBQUEsRUFDQTtBQUFBLElBQ0UsU0FBUztBQUFBLElBQ1QsVUFBVTtBQUFBLEVBQ1o7QUFBQSxFQUNBO0FBQUEsSUFDRSxTQUFTO0FBQUEsSUFDVCxVQUFVO0FBQUEsRUFDWjtBQUFBLEVBQ0E7QUFBQSxJQUNFLFNBQVM7QUFBQSxJQUNULFVBQVU7QUFBQSxFQUNaO0FBQUEsRUFDQTtBQUFBLElBQ0UsU0FBUztBQUFBLElBQ1QsVUFBVTtBQUFBLEVBQ1o7QUFBQSxFQUNBO0FBQUEsSUFDRSxTQUFTO0FBQUEsSUFDVCxVQUFVO0FBQUEsRUFDWjtBQUFBLEVBQ0E7QUFBQSxJQUNFLFNBQVM7QUFBQSxJQUNULFVBQVU7QUFBQSxFQUNaO0FBQUEsRUFDQTtBQUFBLElBQ0UsU0FBUztBQUFBLElBQ1QsVUFBVTtBQUFBLEVBQ1o7QUFBQSxFQUNBO0FBQUEsSUFDRSxTQUFTO0FBQUEsSUFDVCxVQUFVO0FBQUEsRUFDWjtBQUFBLEVBQ0E7QUFBQSxJQUNFLFNBQVM7QUFBQSxJQUNULFVBQVU7QUFBQSxFQUNaO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/script-utils/obsidian-dev-utils-repo-paths.d.mts

@@ -26,6 +26,8 @@ export declare enum ObsidianDevUtilsRepoPaths {
     AnyPath = "**",
     /** Any TypeScript file. */
     AnyTs = "*.ts",
+    /** Astro configuration file (documentation site) at the repo root. */
+    AstroConfigTs = "astro.config.ts",
     /** CommonJS folder. */
     Cjs = "cjs",
     /** CommonJS file extension. */
@@ -46,6 +48,10 @@ export declare enum ObsidianDevUtilsRepoPaths {
     DjsExtension = ".d.js",
     /** ESM TypeScript declaration file extension. */
     DmtsExtension = ".d.mts",
+    /** Documentation site folder (Astro + Starlight API-docs sub-project). */
+    Docs = "docs",
+    /** Build output folder of the documentation site. */
+    DocsDist = "docs/dist",
     /** Dprint configuration file. */
     DprintJson = "dprint.json",
     /** TypeScript declaration file extension. */
@@ -74,6 +80,8 @@ export declare enum ObsidianDevUtilsRepoPaths {
     MarkdownlintCli2ConfigMjs = ".markdownlint-cli2.mjs",
     /** Markdownlint CLI2 configuration schema TypeScript declaration file. */
     MarkdownlintTypesMarkdownlintCli2ConfigSchemaDts = "src/script-utils/linters/markdownlint-types/@types/markdownlint-cli2-config-schema.d.ts",
+    /** Generated flat re-export barrel file. */
+    MergedTs = "__merged.ts",
     /** ESM JavaScript file extension. */
     MjsExtension = ".mjs",
     /** Node modules folder. */

package/dist/lib/esm/script-utils/obsidian-dev-utils-repo-paths.mjs

@@ -30,6 +30,7 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
   ObsidianDevUtilsRepoPaths2["AnyMjs"] = "*.mjs";
   ObsidianDevUtilsRepoPaths2["AnyPath"] = "**";
   ObsidianDevUtilsRepoPaths2["AnyTs"] = "*.ts";
+  ObsidianDevUtilsRepoPaths2["AstroConfigTs"] = "astro.config.ts";
   ObsidianDevUtilsRepoPaths2["Cjs"] = "cjs";
   ObsidianDevUtilsRepoPaths2["CjsExtension"] = ".cjs";
   ObsidianDevUtilsRepoPaths2["CurrentFolder"] = ".";
@@ -40,6 +41,8 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
   ObsidianDevUtilsRepoPaths2["DistTemplates"] = "dist/templates";
   ObsidianDevUtilsRepoPaths2["DjsExtension"] = ".d.js";
   ObsidianDevUtilsRepoPaths2["DmtsExtension"] = ".d.mts";
+  ObsidianDevUtilsRepoPaths2["Docs"] = "docs";
+  ObsidianDevUtilsRepoPaths2["DocsDist"] = "docs/dist";
   ObsidianDevUtilsRepoPaths2["DprintJson"] = "dprint.json";
   ObsidianDevUtilsRepoPaths2["DtsExtension"] = ".d.ts";
   ObsidianDevUtilsRepoPaths2["EslintConfigMts"] = "eslint.config.mts";
@@ -54,6 +57,7 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
   ObsidianDevUtilsRepoPaths2["JsExtension"] = ".js";
   ObsidianDevUtilsRepoPaths2["MarkdownlintCli2ConfigMjs"] = ".markdownlint-cli2.mjs";
   ObsidianDevUtilsRepoPaths2["MarkdownlintTypesMarkdownlintCli2ConfigSchemaDts"] = "src/script-utils/linters/markdownlint-types/@types/markdownlint-cli2-config-schema.d.ts";
+  ObsidianDevUtilsRepoPaths2["MergedTs"] = "__merged.ts";
   ObsidianDevUtilsRepoPaths2["MjsExtension"] = ".mjs";
   ObsidianDevUtilsRepoPaths2["NodeModules"] = "node_modules";
   ObsidianDevUtilsRepoPaths2["PackageJson"] = "package.json";
@@ -75,4 +79,4 @@ var ObsidianDevUtilsRepoPaths = /* @__PURE__ */ ((ObsidianDevUtilsRepoPaths2) =>
 export {
   ObsidianDevUtilsRepoPaths
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/obsidian-dev-utils-repo-paths.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module defines an enumeration of common file paths and patterns used in the Obsidian development utilities repository.\n * These paths are used throughout the build process and other utilities, ensuring consistency and reducing the likelihood\n * of errors due to hardcoded strings.\n */\n\n/**\n * Enumeration of common file paths and patterns used in the Obsidian development utilities repository.\n */\nexport enum ObsidianDevUtilsRepoPaths {\n  /** Any file or folder. */\n  Any = '*',\n\n  /** CommonJS file. */\n  AnyCjs = '*.cjs',\n\n  /** CommonJS TypeScript declaration file. */\n  AnyDcts = '*.d.cts',\n\n  /** ESM TypeScript declaration file. */\n  AnyDmts = '*.d.mts',\n\n  /** TypeScript declaration file. */\n  AnyDts = '*.d.ts',\n\n  /** ESM JavaScript file. */\n  AnyMjs = '*.mjs',\n\n  /** Any path recursively. */\n  AnyPath = '**',\n\n  /** Any TypeScript file. */\n  AnyTs = '*.ts',\n\n  /** Astro configuration file (documentation site) at the repo root. */\n  AstroConfigTs = 'astro.config.ts',\n\n  /** CommonJS folder. */\n  Cjs = 'cjs',\n\n  /** CommonJS file extension. */\n  CjsExtension = '.cjs',\n\n  /** Current folder. */\n  CurrentFolder = '.',\n\n  /** Dataview types. */\n  DataviewTypes = 'src/obsidian/@types/dataview/**',\n\n  /** CommonJS TypeScript declaration file extension. */\n  DctsExtension = '.d.cts',\n\n  /** Distribution folder. */\n  Dist = 'dist',\n\n  /** A path to the `lib` folder within the {@link Dist} folder. */\n  DistLib = 'dist/lib',\n\n  /** A path to the `templates` folder within the {@link Dist} folder, holding the consumer-facing templates. */\n  DistTemplates = 'dist/templates',\n\n  /** Transpiled TypeScript declaration file extension. */\n  DjsExtension = '.d.js',\n\n  /** ESM TypeScript declaration file extension. */\n  DmtsExtension = '.d.mts',\n\n  /** Documentation site folder (Astro + Starlight API-docs sub-project). */\n  Docs = 'docs',\n\n  /** Build output folder of the documentation site. */\n  DocsDist = 'docs/dist',\n\n  /** Dprint configuration file. */\n  DprintJson = 'dprint.json',\n\n  /** TypeScript declaration file extension. */\n  DtsExtension = '.d.ts',\n\n  /** ESM TypeScript ESLint configuration file. */\n  EslintConfigMts = 'eslint.config.mts',\n\n  /** ESM JavaScript folder. */\n  Esm = 'esm',\n\n  /** Generated-during-build CommonJS file. */\n  GeneratedDuringBuildCjs = 'generated-during-build.cjs',\n\n  /** Generated-during-build ESM JavaScript file. */\n  GeneratedDuringBuildMjs = 'generated-during-build.mjs',\n\n  /** CommonJS JavaScript index file. */\n  IndexCjs = 'index.cjs',\n\n  /** CommonJS TypeScript declaration file index file. */\n  IndexDcts = 'index.d.cts',\n\n  /** ESM TypeScript declaration file index file. */\n  IndexDmts = 'index.d.mts',\n\n  /** ESM JavaScript index file. */\n  IndexMjs = 'index.mjs',\n\n  /** TypeScript index file. */\n  IndexTs = 'index.ts',\n\n  /** JavaScript file extension. */\n  JsExtension = '.js',\n\n  /** ESM Markdownlint CLI2 configuration file. */\n  MarkdownlintCli2ConfigMjs = '.markdownlint-cli2.mjs',\n\n  /** Markdownlint CLI2 configuration schema TypeScript declaration file. */\n  MarkdownlintTypesMarkdownlintCli2ConfigSchemaDts = 'src/script-utils/linters/markdownlint-types/@types/markdownlint-cli2-config-schema.d.ts',\n\n  /** Generated flat re-export barrel file. */\n  MergedTs = '__merged.ts',\n\n  /** ESM JavaScript file extension. */\n  MjsExtension = '.mjs',\n\n  /** Node modules folder. */\n  NodeModules = 'node_modules',\n\n  /** Package JSON file. */\n  PackageJson = 'package.json',\n\n  /** Root folder. */\n  RootFolder = '/',\n\n  /** Scripts folder. */\n  Scripts = 'scripts',\n\n  /** ScriptUtils folder. */\n  ScriptUtils = 'script-utils',\n\n  /** Source folder. */\n  Src = 'src',\n\n  /** Styles folder. */\n  Styles = 'styles',\n\n  /** Styles CSS file. */\n  StylesCss = 'styles.css',\n\n  /** Templates folder. */\n  Templates = 'templates',\n\n  /** Test helpers folder. */\n  TestHelpers = 'test-helpers',\n\n  /** TypeScript configuration file. */\n  TsConfigJson = 'tsconfig.json',\n\n  /** TypeScript configuration file that validates the generated CommonJS declarations. */\n  TsConfigValidateDeclarationsCjsJson = 'tsconfig.validate-declarations-cjs.json',\n\n  /** TypeScript configuration file that validates the generated ESM declarations. */\n  TsConfigValidateDeclarationsJson = 'tsconfig.validate-declarations.json',\n\n  /** TypeScript file extension. */\n  TsExtension = '.ts',\n\n  /** Types folder. */\n  Types = '@types'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAWO,IAAK,4BAAL,kBAAKA,+BAAL;AAEL,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,WAAQ;AAGR,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,UAAO;AAGP,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,mBAAgB;AAGhB,EAAAA,2BAAA,UAAO;AAGP,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,gBAAa;AAGb,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,qBAAkB;AAGlB,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,6BAA0B;AAG1B,EAAAA,2BAAA,6BAA0B;AAG1B,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,+BAA4B;AAG5B,EAAAA,2BAAA,sDAAmD;AAGnD,EAAAA,2BAAA,cAAW;AAGX,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,gBAAa;AAGb,EAAAA,2BAAA,aAAU;AAGV,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,SAAM;AAGN,EAAAA,2BAAA,YAAS;AAGT,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,eAAY;AAGZ,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,kBAAe;AAGf,EAAAA,2BAAA,yCAAsC;AAGtC,EAAAA,2BAAA,sCAAmC;AAGnC,EAAAA,2BAAA,iBAAc;AAGd,EAAAA,2BAAA,WAAQ;AA3JE,SAAAA;AAAA,GAAA;",
  "names": ["ObsidianDevUtilsRepoPaths"]
}


package/dist/lib/esm/script-utils/version.d.mts

@@ -56,6 +56,13 @@ export interface UpdateVersionOptions {
      * @returns A {@link Promise} that resolves when the GitHub release has been prepared.
      */
     prepareGitHubRelease?(this: void, newVersion: string): Promise<void>;
+    /**
+     * Whether to archive the plugin's demo vault (`demo-vault/` in the repo root) as a release
+     * artifact. Only applies to Obsidian plugins; ignored when the repo has no `demo-vault/` folder.
+     *
+     * @default `true`
+     */
+    readonly shouldArchiveDemoVault?: boolean;
     /**
      * Whether to run the build step. The build is a publishing prerequisite, not a verification check,
      * so it is governed by this flag independently of {@link shouldRunChecks} — it runs even when the
@@ -226,6 +233,7 @@ export declare function gitPush(): Promise<void>;
  * - `--no-changelog-editing` — generate the changelog without opening it for manual review.
  * - `--no-checks` — skip the clean-repo check, format, spellcheck, lint, over-exposure analysis, and tests (the build still runs).
  * - `--no-commit-verification` — pass `--no-verify` to the release commit, skipping the pre-commit hook.
+ * - `--no-demo-vault` — skip archiving the plugin's demo vault (`demo-vault/`) as a release artifact.
  * - `--no-release` — run all local steps but skip the push and the GitHub release.
  *
  * @param args - The command-line arguments to parse (typically `process.argv.slice(2)`).