obsidian-integration-testing 9.2.2 → 10.0.0

package/dist/lib/cjs/exec.cjs

@@ -40,29 +40,29 @@ function exec(command, options = {}) {
     if (batchResult) {
       return batchResult;
     }
-    const args = command.filter((part) => typeof part === "string");
-    const commandLine = toCommandLine(args);
+    const commandArguments = command.filter((part) => typeof part === "string");
+    const commandLine = toCommandLine(commandArguments);
     const maxCommandLength2 = getMaxCommandLength();
     if (commandLine.length > maxCommandLength2) {
       return Promise.reject(
         new Error(
-          `Command line is too long (${String(commandLine.length)} chars, max ${String(maxCommandLength2)} on ${import_node_process.default.platform}). Consider using ExecArg with batchedArgs.`
+          `Command line is too long (${String(commandLine.length)} chars, max ${String(maxCommandLength2)} on ${import_node_process.default.platform}). Consider using ExecArgument with batchedArguments.`
         )
       );
     }
-    return execString(commandLine, options, args);
+    return execString(commandLine, options, commandArguments);
   }
   const maxCommandLength = getMaxCommandLength();
   if (command.length > maxCommandLength) {
     return Promise.reject(
       new Error(
-        `Command line is too long (${String(command.length)} chars, max ${String(maxCommandLength)} on ${import_node_process.default.platform}). Consider using ExecArg with batchedArgs.`
+        `Command line is too long (${String(command.length)} chars, max ${String(maxCommandLength)} on ${import_node_process.default.platform}). Consider using ExecArgument with batchedArguments.`
       )
     );
   }
   return execString(command, options);
 }
-function execString(command, options = {}, rawArgs) {
+function execString(command, options = {}, rawArguments) {
   const {
     cwd = import_node_process.default.cwd(),
     isQuiet: quiet = false,
@@ -72,7 +72,7 @@ function execString(command, options = {}, rawArgs) {
     timeoutInMilliseconds
   } = options;
   return new Promise((resolve, reject) => {
-    const child = spawnViaShell(command, cwd, rawArgs);
+    const child = spawnViaShell(command, cwd, rawArguments);
     let timeoutTimer;
     if (timeoutInMilliseconds !== void 0) {
       timeoutTimer = setTimeout(() => {
@@ -122,9 +122,9 @@ ${stderr}`));
         stdout
       });
     });
-    child.on("error", (err) => {
+    child.on("error", (error) => {
       if (!ignoreExitCode) {
-        reject(err);
+        reject(error);
         return;
       }
       if (!shouldIncludeDetails) {
@@ -145,37 +145,33 @@ const CHILD_ENV = {
   ...import_node_process.default.env
 };
 const CMD_META_RE = /[()%!^"<>&|]/g;
-function toCommandLine(args) {
-  return args.map((arg) => argvQuote(arg)).join(" ");
+function toCommandLine(commandArguments) {
+  return commandArguments.map((argument) => argvQuote(argument)).join(" ");
 }
-function argvQuote(arg) {
-  if (arg.length > 0 && !/[\s\t\n\v"]/.test(arg)) {
-    return arg;
+function argvQuote(argument) {
+  if (argument.length > 0 && !/[\s\t\n\v"]/.test(argument)) {
+    return argument;
   }
   const BACKSLASH_ESCAPE_FACTOR = 2;
   let result = '"';
-  for (let i = 0; i < arg.length; i++) {
-    let numBackslashes = 0;
-    while (i < arg.length && arg[i] === "\\") {
-      i++;
-      numBackslashes++;
+  for (let index = 0; index < argument.length; index++) {
+    let numberBackslashes = 0;
+    while (index < argument.length && argument[index] === "\\") {
+      index++;
+      numberBackslashes++;
     }
-    if (i === arg.length) {
-      result += "\\".repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);
+    if (index === argument.length) {
+      result += "\\".repeat(numberBackslashes * BACKSLASH_ESCAPE_FACTOR);
       break;
     }
-    const ch = arg.charAt(i);
-    if (ch === '"') {
-      result += `${"\\".repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}"`;
-    } else {
-      result += "\\".repeat(numBackslashes) + ch;
-    }
+    const ch = argument.charAt(index);
+    result += ch === '"' ? `${"\\".repeat(numberBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}"` : "\\".repeat(numberBackslashes) + ch;
   }
   result += '"';
   return result;
 }
-function cmdEscapeCommandLine(commandLine) {
-  return commandLine.replace(CMD_META_RE, "^$&");
+function commandEscapeCommandLine(commandLine) {
+  return commandLine.replaceAll(CMD_META_RE, "^$&");
 }
 async function executeBatches(baseCommand, batches, options) {
   const results = [];
@@ -197,40 +193,40 @@ function getMaxCommandLength() {
   return import_node_process.default.platform === "win32" ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;
 }
 function handleBatchedCommand(parts, options) {
-  const execArgs = parts.filter(isExecArg);
-  if (execArgs.length === 0) {
+  const execArguments = parts.filter(isExecArgument);
+  if (execArguments.length === 0) {
     return void 0;
   }
-  if (execArgs.length > 1) {
-    return Promise.reject(new Error("Only one ExecArg with batchedArgs is allowed per command"));
+  if (execArguments.length > 1) {
+    return Promise.reject(new Error("Only one ExecArgument with batchedArguments is allowed per command"));
   }
-  const execArg = execArgs[0];
-  if (!execArg) {
+  const execArgument = execArguments[0];
+  if (!execArgument) {
     return void 0;
   }
   const staticParts = parts.filter((part) => typeof part === "string");
   const baseCommand = toCommandLine(staticParts);
   const maxCommandLength = getMaxCommandLength();
-  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(" ")}`;
+  const fullCommand = `${baseCommand} ${execArgument.batchedArguments.join(" ")}`;
   if (fullCommand.length <= maxCommandLength) {
     return execString(fullCommand, options);
   }
   const batches = [];
   let currentBatch = [];
-  for (const arg of execArg.batchedArgs) {
-    const tentative = `${baseCommand} ${[...currentBatch, arg].join(" ")}`;
+  for (const argument of execArgument.batchedArguments) {
+    const tentative = `${baseCommand} ${[...currentBatch, argument].join(" ")}`;
     if (tentative.length > maxCommandLength) {
       if (currentBatch.length === 0) {
         return Promise.reject(
           new Error(
-            `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)}).`
+            `Cannot split command into batches: a single argument (${String(argument.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max command length (${String(maxCommandLength)}).`
           )
         );
       }
       batches.push(currentBatch);
-      currentBatch = [arg];
+      currentBatch = [argument];
     } else {
-      currentBatch.push(arg);
+      currentBatch.push(argument);
     }
   }
   if (currentBatch.length > 0) {
@@ -238,16 +234,16 @@ function handleBatchedCommand(parts, options) {
   }
   return executeBatches(baseCommand, batches, options);
 }
-function isExecArg(part) {
-  return typeof part === "object" && "batchedArgs" in part;
+function isExecArgument(part) {
+  return typeof part === "object" && "batchedArguments" in part;
 }
-function spawnViaShell(command, cwd, rawArgs) {
-  if (import_node_process.default.platform === "win32" && rawArgs) {
-    const [program, ...args] = rawArgs;
+function spawnViaShell(command, cwd, rawArguments) {
+  if (import_node_process.default.platform === "win32" && rawArguments) {
+    const [program, ...commandArguments] = rawArguments;
     if (!program) {
       throw new Error("Command array must not be empty");
     }
-    return (0, import_node_child_process.spawn)(program, args, {
+    return (0, import_node_child_process.spawn)(program, commandArguments, {
       cwd,
       env: CHILD_ENV,
       stdio: "pipe"
@@ -256,7 +252,7 @@ function spawnViaShell(command, cwd, rawArgs) {
   if (import_node_process.default.platform === "win32" && command.includes("\n")) {
     throw new Error("Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.");
   }
-  const shellCommand = import_node_process.default.platform === "win32" ? cmdEscapeCommandLine(command) : command;
+  const shellCommand = import_node_process.default.platform === "win32" ? commandEscapeCommandLine(command) : command;
   return (0, import_node_child_process.spawn)(shellCommand, [], {
     cwd,
     env: CHILD_ENV,
@@ -264,15 +260,15 @@ function spawnViaShell(command, cwd, rawArgs) {
     stdio: "pipe"
   });
 }
-function trimEnd(str, suffix) {
-  if (str.endsWith(suffix)) {
-    return str.slice(0, -suffix.length);
+function trimEnd(value, suffix) {
+  if (value.endsWith(suffix)) {
+    return value.slice(0, -suffix.length);
   }
-  return str;
+  return value;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   exec,
   toCommandLine
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/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\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 ExecOption {\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 ExecOption {\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  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `true`, returns detailed results.\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   */\n  readonly stdin?: string;\n\n  /**\n   * Timeout in milliseconds. The child process is killed if it exceeds this.\n   */\n  readonly timeoutInMilliseconds?: number;\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 ExecOption {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   */\n  readonly shouldIncludeDetails?: false;\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 */\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 */\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 */\nexport function exec(command: CommandPart[] | string, options: ExecOption = {}): 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 using ExecArg with batchedArgs.`\n        )\n      );\n    }\n\n    return execString(commandLine, options, args);\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 using ExecArg with batchedArgs.`\n      )\n    );\n  }\n\n  return execString(command, options);\n}\n\n/**\n * Executes a single string command.\n *\n * @param command - The command string.\n * @param options - The exec options.\n * @param rawArgs - The original argument array (if available), used by the\n *   direct-spawn fallback on Windows when the command contains newlines.\n * @returns A Promise resolving to the result.\n */\nfunction execString(command: string, options: ExecOption = {}, rawArgs?: string[]): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = '',\n    timeoutInMilliseconds\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    const child = spawnViaShell(command, cwd, rawArgs);\n    let timeoutTimer: ReturnType<typeof setTimeout> | undefined;\n\n    if (timeoutInMilliseconds !== undefined) {\n      timeoutTimer = setTimeout(() => {\n        child.kill();\n        reject(new Error(`Command timed out after ${String(timeoutInMilliseconds)}ms`));\n      }, timeoutInMilliseconds);\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(stdout, '\\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(stderr, '\\n');\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (timeoutTimer) {\n        clearTimeout(timeoutTimer);\n      }\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 * Matches `cmd.exe` metacharacters that must be `^`-escaped.\n */\nconst CMD_META_RE = /[()%!^\"<>&|]/g;\n\n/**\n * Converts an array of command-line arguments into a single command-line string\n * using the `CommandLineToArgvW` convention.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation.\n */\nexport function toCommandLine(args: string[]): string {\n  return args.map((arg) => argvQuote(arg)).join(' ');\n}\n\n/**\n * Quotes a single argument so that `CommandLineToArgvW` will decode it\n * unchanged.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction argvQuote(arg: string): string {\n  if (arg.length > 0 && !/[\\s\\t\\n\\v\"]/.test(arg)) {\n    return arg;\n  }\n\n  const BACKSLASH_ESCAPE_FACTOR = 2;\n  let result = '\"';\n  for (let i = 0; i < arg.length; i++) {\n    let numBackslashes = 0;\n    while (i < arg.length && arg[i] === '\\\\') {\n      i++;\n      numBackslashes++;\n    }\n\n    if (i === arg.length) {\n      result += '\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);\n      break;\n    }\n\n    const ch = arg.charAt(i);\n    if (ch === '\"') {\n      result += `${'\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}\"`;\n    } else {\n      result += '\\\\'.repeat(numBackslashes) + ch;\n    }\n  }\n\n  result += '\"';\n  return result;\n}\n\n/**\n * Escapes `cmd.exe` metacharacters with `^` so that `cmd.exe` passes them\n * through literally.\n *\n * @param commandLine - The already-quoted command line string.\n * @returns The string with all cmd metacharacters `^`-escaped.\n */\nfunction cmdEscapeCommandLine(commandLine: string): string {\n  return commandLine.replace(CMD_META_RE, '^$&');\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param baseCommand - The base command without batched args.\n * @param batches - The batches of args.\n * @param options - The exec options.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(baseCommand: string, batches: string[][], options: ExecOption): Promise<ExecResult | string> {\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString(batchCommand, options);\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: ExecOption): 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  /* v8 ignore start -- Always truthy after the length check above. */\n  if (!execArg) {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString(fullCommand, options);\n  }\n\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(baseCommand, batches, options);\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, when the raw args array is available, spawns the process\n * directly without any shell \u2014 passing args via `CreateProcess`, which\n * avoids all `cmd.exe` quoting/escaping issues (nested quotes, metacharacters,\n * newlines in args, etc.).\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param command - The command string to execute.\n * @param cwd - The working directory.\n * @param rawArgs - The original argument array (if available).\n * @returns The spawned child process.\n */\nfunction spawnViaShell(command: string, cwd: string, rawArgs?: string[]): ChildProcessWithoutNullStreams {\n  if (process.platform === 'win32' && rawArgs) {\n    const [program, ...args] = rawArgs;\n    /* v8 ignore start -- Always truthy; rawArgs comes from the array path which has at least one element. */\n    if (!program) {\n      throw new Error('Command array must not be empty');\n    }\n    /* v8 ignore stop */\n    return spawn(program, args, {\n      cwd,\n      env: CHILD_ENV,\n      stdio: 'pipe'\n    });\n  }\n\n  if (process.platform === 'win32' && command.includes('\\n')) {\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\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\n/**\n * Removes a suffix from the end of a string if present.\n *\n * @param str - The string to trim.\n * @param suffix - The suffix to remove.\n * @returns The trimmed string.\n */\nfunction trimEnd(str: string, suffix: string): string {\n  if (str.endsWith(suffix)) {\n    return str.slice(0, -suffix.length);\n  }\n  return str;\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength", "process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/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\n/**\n * A command part: either a plain string or an {@link ExecArgument} with batched arguments.\n */\nexport type CommandPart = ExecArgument | string;\n\n/**\n * A command argument that contains a list of commandArguments to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched commandArguments are split into sequential executions.\n */\nexport interface ExecArgument {\n  /**\n   * The arguments to batch.\n   */\n  readonly batchedArguments: readonly string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOption {\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 ExecOption {\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  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `true`, returns detailed results.\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An argument to be passed to the command.\n   */\n  readonly stdin?: string;\n\n  /**\n   * Timeout in milliseconds. The child process is killed if it exceeds this.\n   */\n  readonly timeoutInMilliseconds?: number;\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 ExecOption {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   */\n  readonly shouldIncludeDetails?: false;\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 */\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 */\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 */\nexport function exec(command: CommandPart[] | string, options: ExecOption = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const commandArguments = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(commandArguments);\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 using ExecArgument with batchedArguments.`\n        )\n      );\n    }\n\n    return execString(commandLine, options, commandArguments);\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 using ExecArgument with batchedArguments.`\n      )\n    );\n  }\n\n  return execString(command, options);\n}\n\n/**\n * Executes a single string command.\n *\n * @param command - The command string.\n * @param options - The exec options.\n * @param rawArguments - The original argument array (if available), used by the\n *   direct-spawn fallback on Windows when the command contains newlines.\n * @returns A Promise resolving to the result.\n */\nfunction execString(command: string, options: ExecOption = {}, rawArguments?: string[]): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails = false,\n    stdin = '',\n    timeoutInMilliseconds\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    const child = spawnViaShell(command, cwd, rawArguments);\n    let timeoutTimer: ReturnType<typeof setTimeout> | undefined;\n\n    if (timeoutInMilliseconds !== undefined) {\n      timeoutTimer = setTimeout(() => {\n        child.kill();\n        reject(new Error(`Command timed out after ${String(timeoutInMilliseconds)}ms`));\n      }, timeoutInMilliseconds);\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(stdout, '\\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(stderr, '\\n');\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (timeoutTimer) {\n        clearTimeout(timeoutTimer);\n      }\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', (error) => {\n      if (!ignoreExitCode) {\n        reject(error);\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 * Matches `cmd.exe` metacharacters that must be `^`-escaped.\n */\nconst CMD_META_RE = /[()%!^\"<>&|]/g;\n\n/**\n * Converts an array of command-line arguments into a single command-line string\n * using the `CommandLineToArgvW` convention.\n *\n * @param commandArguments - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation.\n */\nexport function toCommandLine(commandArguments: string[]): string {\n  return commandArguments.map((argument) => argvQuote(argument)).join(' ');\n}\n\n/**\n * Quotes a single argument so that `CommandLineToArgvW` will decode it\n * unchanged.\n *\n * @param argument - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction argvQuote(argument: string): string {\n  if (argument.length > 0 && !/[\\s\\t\\n\\v\"]/.test(argument)) {\n    return argument;\n  }\n\n  const BACKSLASH_ESCAPE_FACTOR = 2;\n  let result = '\"';\n  for (let index = 0; index < argument.length; index++) {\n    let numberBackslashes = 0;\n    while (index < argument.length && argument[index] === '\\\\') {\n      index++;\n      numberBackslashes++;\n    }\n\n    if (index === argument.length) {\n      result += '\\\\'.repeat(numberBackslashes * BACKSLASH_ESCAPE_FACTOR);\n      break;\n    }\n\n    const ch = argument.charAt(index);\n    result += ch === '\"' ? `${'\\\\'.repeat(numberBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}\"` : '\\\\'.repeat(numberBackslashes) + ch;\n  }\n\n  result += '\"';\n  return result;\n}\n\n/**\n * Escapes `cmd.exe` metacharacters with `^` so that `cmd.exe` passes them\n * through literally.\n *\n * @param commandLine - The already-quoted command line string.\n * @returns The string with all cmd metacharacters `^`-escaped.\n */\nfunction commandEscapeCommandLine(commandLine: string): string {\n  return commandLine.replaceAll(CMD_META_RE, '^$&');\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param baseCommand - The base command without batched commandArguments.\n * @param batches - The batches of commandArguments.\n * @param options - The exec options.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(baseCommand: string, batches: string[][], options: ExecOption): Promise<ExecResult | string> {\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString(batchCommand, options);\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 = 131_072;\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 ExecArgument}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArgument 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: ExecOption): Promise<ExecResult | string> | undefined {\n  const execArguments = parts.filter(isExecArgument);\n  if (execArguments.length === 0) {\n    return undefined;\n  }\n  if (execArguments.length > 1) {\n    return Promise.reject(new Error('Only one ExecArgument with batchedArguments is allowed per command'));\n  }\n\n  const execArgument = execArguments[0];\n  /* v8 ignore start -- Always truthy after the length check above. */\n  if (!execArgument) {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  const fullCommand = `${baseCommand} ${execArgument.batchedArguments.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString(fullCommand, options);\n  }\n\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const argument of execArgument.batchedArguments) {\n    const tentative = `${baseCommand} ${[...currentBatch, argument].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(argument.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 = [argument];\n    } else {\n      currentBatch.push(argument);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArguments is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches(baseCommand, batches, options);\n}\n\n/**\n * Checks if a command part is an {@link ExecArgument}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArgument.\n */\nfunction isExecArgument(part: CommandPart): part is ExecArgument {\n  return typeof part === 'object' && 'batchedArguments' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, when the raw commandArguments array is available, spawns the process\n * directly without any shell \u2014 passing commandArguments via `CreateProcess`, which\n * avoids all `cmd.exe` quoting/escaping issues (nested quotes, metacharacters,\n * newlines in commandArguments, etc.).\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param command - The command string to execute.\n * @param cwd - The working directory.\n * @param rawArguments - The original argument array (if available).\n * @returns The spawned child process.\n */\nfunction spawnViaShell(command: string, cwd: string, rawArguments?: string[]): ChildProcessWithoutNullStreams {\n  if (process.platform === 'win32' && rawArguments) {\n    const [program, ...commandArguments] = rawArguments;\n    /* v8 ignore start -- Always truthy; rawArguments comes from the array path which has at least one element. */\n    if (!program) {\n      throw new Error('Command array must not be empty');\n    }\n    /* v8 ignore stop */\n    return spawn(program, commandArguments, {\n      cwd,\n      env: CHILD_ENV,\n      stdio: 'pipe'\n    });\n  }\n\n  if (process.platform === 'win32' && command.includes('\\n')) {\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\n  const shellCommand = process.platform === 'win32' ? commandEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env: CHILD_ENV,\n    shell: true,\n    stdio: 'pipe'\n  });\n}\n\n/**\n * Removes a suffix from the end of a string if present.\n *\n * @param value - The string to trim.\n * @param suffix - The suffix to remove.\n * @returns The trimmed string.\n */\nfunction trimEnd(value: string, suffix: string): string {\n  if (value.endsWith(suffix)) {\n    return value.slice(0, -suffix.length);\n  }\n  return value;\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength", "process"]
}


package/dist/lib/cjs/exec.d.cts

@@ -4,19 +4,19 @@
  * Contains utility functions for executing commands.
  */
 /**
- * A command part: either a plain string or an {@link ExecArg} with batched arguments.
+ * A command part: either a plain string or an {@link ExecArgument} with batched arguments.
  */
-export type CommandPart = ExecArg | string;
+export type CommandPart = ExecArgument | string;
 /**
- * A command argument that contains a list of args to be batched.
+ * A command argument that contains a list of commandArguments to be batched.
  * If the expanded command exceeds the platform's max command length,
- * the batched args are split into sequential executions.
+ * the batched commandArguments are split into sequential executions.
  */
-export interface ExecArg {
+export interface ExecArgument {
     /**
      * The arguments to batch.
      */
-    readonly batchedArgs: readonly string[];
+    readonly batchedArguments: readonly string[];
 }
 /**
  * Options for {@link exec} that return detailed results.
@@ -48,7 +48,7 @@ export interface ExecOption {
      */
     readonly shouldIncludeDetails?: boolean;
     /**
-     * An input to be passed to the command.
+     * An argument to be passed to the command.
      */
     readonly stdin?: string;
     /**
@@ -106,7 +106,7 @@ export declare function exec(command: CommandPart[] | string, options: ExecDetai
  * Converts an array of command-line arguments into a single command-line string
  * using the `CommandLineToArgvW` convention.
  *
- * @param args - The array of command-line arguments to convert.
+ * @param commandArguments - The array of command-line arguments to convert.
  * @returns A string representing the command-line invocation.
  */
-export declare function toCommandLine(args: string[]): string;
+export declare function toCommandLine(commandArguments: string[]): string;

package/dist/lib/cjs/function-expression.cjs

@@ -21,16 +21,16 @@ __export(function_expression_exports, {
   getFunctionExpressionString: () => getFunctionExpressionString
 });
 module.exports = __toCommonJS(function_expression_exports);
-function getFunctionExpressionString(fn) {
-  const fnString = fn.toString();
-  if (FUNCTION_EXPRESSION_RE.test(fnString)) {
-    return fnString;
+function getFunctionExpressionString(callback) {
+  const functionString = callback.toString();
+  if (FUNCTION_EXPRESSION_RE.test(functionString)) {
+    return functionString;
   }
-  const asyncMatch = ASYNC_KEYWORD_RE.exec(fnString);
+  const asyncMatch = ASYNC_KEYWORD_RE.exec(functionString);
   if (asyncMatch) {
-    return `async function ${fnString.slice(asyncMatch[0].length)}`;
+    return `async function ${functionString.slice(asyncMatch[0].length)}`;
   }
-  return `function ${fnString}`;
+  return `function ${functionString}`;
 }
 const FUNCTION_EXPRESSION_RE = /^(?:function\b|async\b\s*(?:function\b|\()|\()/;
 const ASYNC_KEYWORD_RE = /^async\b\s*/;
@@ -38,4 +38,4 @@ const ASYNC_KEYWORD_RE = /^async\b\s*/;
 0 && (module.exports = {
   getFunctionExpressionString
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2Z1bmN0aW9uLWV4cHJlc3Npb24udHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBDb252ZXJ0cyBhIGZ1bmN0aW9uIGludG8gYSBzdHJpbmcgdGhhdCBpcyBhIHZhbGlkIGZ1bmN0aW9uIGV4cHJlc3Npb24uXG4gKi9cblxuLyoqXG4gKiBDb252ZXJ0cyBhIGZ1bmN0aW9uIGludG8gYSBzdHJpbmcgdGhhdCBpcyBhIHZhbGlkIGZ1bmN0aW9uIGV4cHJlc3Npb24uXG4gKlxuICogYEZ1bmN0aW9uLnByb3RvdHlwZS50b1N0cmluZygpYCBvbiBhIHNob3J0aGFuZCBtZXRob2QgbGlrZSBgeyBjYWxsYmFjaygpIHt9IH1gXG4gKiByZXR1cm5zIGBcImNhbGxiYWNrKCkge31cImAsIHdoaWNoIGlzIG5vdCBhIHZhbGlkIGV4cHJlc3Npb24uXG4gKiBUaGlzIGhlbHBlciBkZXRlY3RzIHRoYXQgZm9ybSBhbmQgcHJlZml4ZXMgaXQgd2l0aCBgZnVuY3Rpb24gYC5cbiAqXG4gKiBAcGFyYW0gY2FsbGJhY2sgLSBUaGUgZnVuY3Rpb24gdG8gY29udmVydC5cbiAqIEByZXR1cm5zIEEgc3RyaW5nIHRoYXQgaXMgYSB2YWxpZCBmdW5jdGlvbiBleHByZXNzaW9uLlxuICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVuc2FmZS1mdW5jdGlvbi10eXBlIC0tIFdlIG5lZWQgdG8gdXNlIGBGdW5jdGlvbmAgdHlwZS5cbmV4cG9ydCBmdW5jdGlvbiBnZXRGdW5jdGlvbkV4cHJlc3Npb25TdHJpbmcoY2FsbGJhY2s6IEZ1bmN0aW9uKTogc3RyaW5nIHtcbiAgY29uc3QgZnVuY3Rpb25TdHJpbmcgPSBjYWxsYmFjay50b1N0cmluZygpO1xuXG4gIGlmIChGVU5DVElPTl9FWFBSRVNTSU9OX1JFLnRlc3QoZnVuY3Rpb25TdHJpbmcpKSB7XG4gICAgcmV0dXJuIGZ1bmN0aW9uU3RyaW5nO1xuICB9XG5cbiAgY29uc3QgYXN5bmNNYXRjaCA9IEFTWU5DX0tFWVdPUkRfUkUuZXhlYyhmdW5jdGlvblN0cmluZyk7XG4gIGlmIChhc3luY01hdGNoKSB7XG4gICAgcmV0dXJuIGBhc3luYyBmdW5jdGlvbiAke2Z1bmN0aW9uU3RyaW5nLnNsaWNlKGFzeW5jTWF0Y2hbMF0ubGVuZ3RoKX1gO1xuICB9XG5cbiAgcmV0dXJuIGBmdW5jdGlvbiAke2Z1bmN0aW9uU3RyaW5nfWA7XG59XG5cbi8qKlxuICogTWF0Y2hlcyBzdHJpbmdzIHRoYXQgYXJlIGFscmVhZHkgdmFsaWQgZnVuY3Rpb24gZXhwcmVzc2lvbnM6XG4gKiAtIGBmdW5jdGlvbiAuLi5gIChrZXl3b3JkLCBub3QgaWRlbnRpZmllciBsaWtlIGBmdW5jdGlvbjFgKVxuICogLSBgKGAgKGFycm93IGZ1bmN0aW9uKVxuICogLSBgYXN5bmNcXGJgIGZvbGxvd2VkIGJ5IGBmdW5jdGlvblxcYmAgb3IgYChgIChhc3luYyBmdW5jdGlvbi9hcnJvdylcbiAqL1xuY29uc3QgRlVOQ1RJT05fRVhQUkVTU0lPTl9SRSA9IC9eKD86ZnVuY3Rpb25cXGJ8YXN5bmNcXGJcXHMqKD86ZnVuY3Rpb25cXGJ8XFwoKXxcXCgpLztcblxuLyoqXG4gKiBNYXRjaGVzIHRoZSBgYXN5bmNgIGtleXdvcmQgKHdvcmQgYm91bmRhcnksIG5vdCBgYXN5bmMxYCkgZm9sbG93ZWQgYnkgb3B0aW9uYWwgd2hpdGVzcGFjZS5cbiAqIFVzZWQgdG8gc3RyaXAgdGhlIGBhc3luY2AgcHJlZml4IGZyb20gYXN5bmMgc2hvcnRoYW5kIG1ldGhvZHMgYmVmb3JlIHJlLWFkZGluZyBgYXN5bmMgZnVuY3Rpb25gLlxuICovXG5jb25zdCBBU1lOQ19LRVlXT1JEX1JFID0gL15hc3luY1xcYlxccyovO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQWlCTyxTQUFTLDRCQUE0QixVQUE0QjtBQUN0RSxRQUFNLGlCQUFpQixTQUFTLFNBQVM7QUFFekMsTUFBSSx1QkFBdUIsS0FBSyxjQUFjLEdBQUc7QUFDL0MsV0FBTztBQUFBLEVBQ1Q7QUFFQSxRQUFNLGFBQWEsaUJBQWlCLEtBQUssY0FBYztBQUN2RCxNQUFJLFlBQVk7QUFDZCxXQUFPLGtCQUFrQixlQUFlLE1BQU0sV0FBVyxDQUFDLEVBQUUsTUFBTSxDQUFDO0FBQUEsRUFDckU7QUFFQSxTQUFPLFlBQVksY0FBYztBQUNuQztBQVFBLE1BQU0seUJBQXlCO0FBTS9CLE1BQU0sbUJBQW1COyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/function-expression.d.cts

@@ -6,11 +6,11 @@
 /**
  * Converts a function into a string that is a valid function expression.
  *
- * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`
- * returns `"fn() {}"`, which is not a valid expression.
+ * `Function.prototype.toString()` on a shorthand method like `{ callback() {} }`
+ * returns `"callback() {}"`, which is not a valid expression.
  * This helper detects that form and prefixes it with `function `.
  *
- * @param fn - The function to convert.
+ * @param callback - The function to convert.
  * @returns A string that is a valid function expression.
  */
-export declare function getFunctionExpressionString(fn: Function): string;
+export declare function getFunctionExpressionString(callback: Function): string;

package/dist/lib/cjs/generate-function-call.cjs

@@ -30,16 +30,16 @@ async function ensureLayoutReady(params) {
     params.app.workspace.onLayoutReady(resolve);
   });
 }
-function generateFunctionCall(fn, params) {
-  const fnExpr = (0, import_function_expression.getFunctionExpressionString)(fn);
+function generateFunctionCall(callback, params) {
+  const functionExpression = (0, import_function_expression.getFunctionExpressionString)(callback);
   const serializedParams = (0, import_json_with_functions.jsonWithFunctions)(params);
-  return `(${fnExpr})(Object.assign(${serializedParams}, { app: window.app }))`;
+  return `(${functionExpression})(Object.assign(${serializedParams}, { app: window.app }))`;
 }
 function generateNamespaceCall(params) {
   const serializedParams = (0, import_json_with_functions.jsonWithFunctions)({
-    args: params.args ?? {},
+    input: params.input ?? {},
     ...params.contextId !== void 0 && { contextId: params.contextId },
-    fn: params.fn
+    callback: params.callback
   });
   return `window.__obsidianIntegrationTesting.evalWrapper(${serializedParams})`;
 }
@@ -49,4 +49,4 @@ function generateNamespaceCall(params) {
   generateFunctionCall,
   generateNamespaceCall
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2dlbmVyYXRlLWZ1bmN0aW9uLWNhbGwudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBHZW5lcmF0ZXMgYSBKYXZhU2NyaXB0IGV4cHJlc3Npb24gdGhhdCBjYWxscyBhIHNlcmlhbGl6ZWQgZnVuY3Rpb24gd2l0aCBzZXJpYWxpemVkIGFyZ3VtZW50cy5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IEFwcCB9IGZyb20gJ29ic2lkaWFuJztcbmltcG9ydCB0eXBlIHsgUHJvbWlzYWJsZSB9IGZyb20gJ3R5cGUtZmVzdCc7XG5cbmltcG9ydCB7IGdldEZ1bmN0aW9uRXhwcmVzc2lvblN0cmluZyB9IGZyb20gJy4vZnVuY3Rpb24tZXhwcmVzc2lvbi5janMnO1xuaW1wb3J0IHsganNvbldpdGhGdW5jdGlvbnMgfSBmcm9tICcuL2pzb24td2l0aC1mdW5jdGlvbnMuY2pzJztcblxuLyoqXG4gKiBQYXJhbWV0ZXJzIHdpdGggYGVuc3VyZUxheW91dFJlYWR5YCBmdW5jdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBFbnN1cmVMYXlvdXRSZWFkeVBhcmFtcyB7XG4gIC8qKlxuICAgKiBXYWl0cyBmb3IgdGhlIE9ic2lkaWFuIHdvcmtzcGFjZSBsYXlvdXQgdG8gYmUgcmVhZHkuXG4gICAqXG4gICAqIEBwYXJhbSBwYXJhbXMgLSBQYXJhbWV0ZXJzIGluY2x1ZGluZyB0aGUgYGFwcGAgaW5zdGFuY2UuXG4gICAqIEByZXR1cm5zIEEgcHJvbWlzZSB0aGF0IHJlc29sdmVzIHdoZW4gdGhlIGxheW91dCBpcyByZWFkeS5cbiAgICovXG4gIGVuc3VyZUxheW91dFJlYWR5KHBhcmFtczogR2VuZXJhdGVGdW5jdGlvbkNhbGxQYXJhbXMpOiBQcm9taXNlPHZvaWQ+O1xufVxuXG4vKipcbiAqIFBhcmFtZXRlcnMgZm9yIGBnZW5lcmF0ZUZ1bmN0aW9uQ2FsbGAuXG4gKlxuICogQHR5cGVQYXJhbSBQYXJhbXMgLSBUaGUgdHlwZSBvZiB0aGUgYWRkaXRpb25hbCBwYXJhbWV0ZXJzIHRvIHBhc3MgdG8gdGhlIGZ1bmN0aW9uIGJlaW5nIGNhbGxlZC5cbiAqL1xuZXhwb3J0IHR5cGUgR2VuZXJhdGVGdW5jdGlvbkNhbGxQYXJhbXM8UGFyYW1zID0gdW5rbm93bj4gPSBBcHBQYXJhbXMgJiBQYXJhbXM7XG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIGdlbmVyYXRlTmFtZXNwYWNlQ2FsbH0uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgR2VuZXJhdGVOYW1lc3BhY2VDYWxsUGFyYW1zIHtcbiAgLyoqIFVzZXItc3VwcGxpZWQgYXJndW1lbnRzIHRvIHBhc3MgdG8gdGhlIGZ1bmN0aW9uLiAqL1xuICByZWFkb25seSBhcmdzPzogUmVjb3JkPHN0cmluZywgdW5rbm93bj47XG4gIC8qKiBPcHRpb25hbCBjb250ZXh0IElEIGZvciBwZXJzaXN0ZW50IHN0b3JhZ2UuICovXG4gIHJlYWRvbmx5IGNvbnRleHRJZD86IHN0cmluZztcbiAgLyoqIFRoZSB1c2VyIGZ1bmN0aW9uIHRvIGV2YWx1YXRlIGluc2lkZSBPYnNpZGlhbi4gKi9cbiAgcmVhZG9ubHkgZm46ICguLi5hcmdzOiBuZXZlcltdKSA9PiB1bmtub3duO1xufVxuXG5pbnRlcmZhY2UgQXBwUGFyYW1zIHtcbiAgcmVhZG9ubHkgYXBwOiBBcHA7XG59XG4vKiB2OCBpZ25vcmUgc3RvcCAqL1xuXG4vKipcbiAqIEdlbmVyYXRlcyBhIEphdmFTY3JpcHQgZXhwcmVzc2lvbiBzdHJpbmcgdGhhdCBpbW1lZGlhdGVseSBpbnZva2VzIHRoZSBnaXZlblxuICogZnVuY3Rpb24gd2l0aCB0aGUgZ2l2ZW4gYXJndW1lbnRzLlxuICpcbiAqIFRoZSBmdW5jdGlvbiBpcyBzZXJpYWxpemVkIHZpYSB7QGxpbmsgZ2V0RnVuY3Rpb25FeHByZXNzaW9uU3RyaW5nfSBhbmQgdGhlXG4gKiBhcmd1bWVudHMgYXJlIHNlcmlhbGl6ZWQgdmlhIHtAbGluayBqc29uV2l0aEZ1bmN0aW9uc30sIHByb2R1Y2luZyBhXG4gKiBzZWxmLWNvbnRhaW5lZCBJSUZFIG9mIHRoZSBmb3JtIGAoZm5FeHByKShhcmdzRXhwcilgLlxuICpcbiAqIEBwYXJhbSBmbiAtIFRoZSBmdW5jdGlvbiB0byBjYWxsLlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBhcmd1bWVudHMgdG8gcGFzcy4gV2hlbiBvbWl0dGVkLCB0aGUgZnVuY3Rpb24gaXMgY2FsbGVkIHdpdGggbm8gYXJndW1lbnRzLlxuICogQHJldHVybnMgQSBKYXZhU2NyaXB0IGV4cHJlc3Npb24gc3RyaW5nLlxuICovXG5cbi8qIHY4IGlnbm9yZSBzdGFydCAtLSBTZXJpYWxpemVkIHZpYSB0b1N0cmluZygpIGFuZCBleGVjdXRlZCBpbnNpZGUgT2JzaWRpYW4sIG5vdCBjYWxsYWJsZSBpbiB1bml0IHRlc3RzLiAqL1xuLyoqXG4gKiBXYWl0cyBmb3IgdGhlIE9ic2lkaWFuIHdvcmtzcGFjZSBsYXlvdXQgdG8gYmUgcmVhZHkuXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBwYXJhbWV0ZXJzLCBpbmNsdWRpbmcgdGhlIGBhcHBgIGluc3RhbmNlLlxuICogQHJldHVybnMgQSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgbGF5b3V0IGlzIHJlYWR5LlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZW5zdXJlTGF5b3V0UmVhZHkocGFyYW1zOiBHZW5lcmF0ZUZ1bmN0aW9uQ2FsbFBhcmFtcyk6IFByb21pc2U8dm9pZD4ge1xuICBhd2FpdCBuZXcgUHJvbWlzZTx2b2lkPigocmVzb2x2ZSkgPT4ge1xuICAgIHBhcmFtcy5hcHAud29ya3NwYWNlLm9uTGF5b3V0UmVhZHkocmVzb2x2ZSk7XG4gIH0pO1xufVxuXG4vKipcbiAqIEdlbmVyYXRlcyBhIEphdmFTY3JpcHQgZXhwcmVzc2lvbiBzdHJpbmcgdGhhdCBpbW1lZGlhdGVseSBpbnZva2VzIHRoZSBnaXZlblxuICogZnVuY3Rpb24gd2l0aCB0aGUgZ2l2ZW4gYXJndW1lbnRzLlxuICpcbiAqIEBwYXJhbSBmbiAtIFRoZSBmdW5jdGlvbiB0byBjYWxsLlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBhcmd1bWVudHMgdG8gcGFzcy5cbiAqIEByZXR1cm5zIEEgSmF2YVNjcmlwdCBleHByZXNzaW9uIHN0cmluZy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdlbmVyYXRlRnVuY3Rpb25DYWxsPFBhcmFtcz4oZm46IChwYXJhbXM6IEdlbmVyYXRlRnVuY3Rpb25DYWxsUGFyYW1zPFBhcmFtcz4pID0+IFByb21pc2FibGU8dW5rbm93bj4sIHBhcmFtczogUGFyYW1zKTogc3RyaW5nIHtcbiAgY29uc3QgZm5FeHByID0gZ2V0RnVuY3Rpb25FeHByZXNzaW9uU3RyaW5nKGZuKTtcbiAgY29uc3Qgc2VyaWFsaXplZFBhcmFtcyA9IGpzb25XaXRoRnVuY3Rpb25zKHBhcmFtcyk7XG4gIHJldHVybiBgKCR7Zm5FeHByfSkoT2JqZWN0LmFzc2lnbigke3NlcmlhbGl6ZWRQYXJhbXN9LCB7IGFwcDogd2luZG93LmFwcCB9KSlgO1xufVxuXG4vKipcbiAqIEdlbmVyYXRlcyBhIGxpZ2h0d2VpZ2h0IEphdmFTY3JpcHQgZXhwcmVzc2lvbiB0aGF0IGNhbGxzIHRoZSBwcmUtcmVnaXN0ZXJlZFxuICogYGV2YWxXcmFwcGVyYCBvbiB0aGUgYHdpbmRvdy5fX29ic2lkaWFuSW50ZWdyYXRpb25UZXN0aW5nYCBuYW1lc3BhY2UuXG4gKlxuICogVW5saWtlIHtAbGluayBnZW5lcmF0ZUZ1bmN0aW9uQ2FsbH0sIHRoaXMgZG9lcyBub3Qgc2VyaWFsaXplIGluZnJhc3RydWN0dXJlXG4gKiBmdW5jdGlvbnMgXHUyMDE0IG9ubHkgdGhlIHVzZXIncyBgZm5gLCBgYXJnc2AsIGFuZCBgY29udGV4dElkYC4gVGhlIGluZnJhc3RydWN0dXJlXG4gKiBtdXN0IGFscmVhZHkgYmUgYm9vdHN0cmFwcGVkIHZpYSB7QGxpbmsgZW5zdXJlTmFtZXNwYWNlQm9vdHN0cmFwcGVkfS5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIHVzZXIgZnVuY3Rpb24sIGFyZ3VtZW50cywgYW5kIG9wdGlvbmFsIGNvbnRleHQgSUQuXG4gKiBAcmV0dXJucyBBIEphdmFTY3JpcHQgZXhwcmVzc2lvbiBzdHJpbmcuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZW5lcmF0ZU5hbWVzcGFjZUNhbGwocGFyYW1zOiBHZW5lcmF0ZU5hbWVzcGFjZUNhbGxQYXJhbXMpOiBzdHJpbmcge1xuICBjb25zdCBzZXJpYWxpemVkUGFyYW1zID0ganNvbldpdGhGdW5jdGlvbnMoe1xuICAgIGFyZ3M6IHBhcmFtcy5hcmdzID8/IHt9LFxuICAgIC4uLihwYXJhbXMuY29udGV4dElkICE9PSB1bmRlZmluZWQgJiYgeyBjb250ZXh0SWQ6IHBhcmFtcy5jb250ZXh0SWQgfSksXG4gICAgZm46IHBhcmFtcy5mblxuICB9KTtcbiAgcmV0dXJuIGB3aW5kb3cuX19vYnNpZGlhbkludGVncmF0aW9uVGVzdGluZy5ldmFsV3JhcHBlcigke3NlcmlhbGl6ZWRQYXJhbXN9KWA7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVNBLGlDQUE0QztBQUM1QyxpQ0FBa0M7QUEyRGxDLGVBQXNCLGtCQUFrQixRQUFtRDtBQUN6RixRQUFNLElBQUksUUFBYyxDQUFDLFlBQVk7QUFDbkMsV0FBTyxJQUFJLFVBQVUsY0FBYyxPQUFPO0FBQUEsRUFDNUMsQ0FBQztBQUNIO0FBVU8sU0FBUyxxQkFBNkIsSUFBeUUsUUFBd0I7QUFDNUksUUFBTSxhQUFTLHdEQUE0QixFQUFFO0FBQzdDLFFBQU0sdUJBQW1CLDhDQUFrQixNQUFNO0FBQ2pELFNBQU8sSUFBSSxNQUFNLG1CQUFtQixnQkFBZ0I7QUFDdEQ7QUFhTyxTQUFTLHNCQUFzQixRQUE2QztBQUNqRixRQUFNLHVCQUFtQiw4Q0FBa0I7QUFBQSxJQUN6QyxNQUFNLE9BQU8sUUFBUSxDQUFDO0FBQUEsSUFDdEIsR0FBSSxPQUFPLGNBQWMsVUFBYSxFQUFFLFdBQVcsT0FBTyxVQUFVO0FBQUEsSUFDcEUsSUFBSSxPQUFPO0FBQUEsRUFDYixDQUFDO0FBQ0QsU0FBTyxtREFBbUQsZ0JBQWdCO0FBQzVFOyIsCiAgIm5hbWVzIjogW10KfQo=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/generate-function-call.d.cts

@@ -27,12 +27,18 @@ export type GenerateFunctionCallParams<Params = unknown> = AppParams & Params;
  * Parameters for {@link generateNamespaceCall}.
  */
 export interface GenerateNamespaceCallParams {
-    /** User-supplied arguments to pass to the function. */
-    readonly args?: Record<string, unknown>;
-    /** Optional context ID for persistent storage. */
+    /**
+    The user function to evaluate inside Obsidian.
+     */
+    readonly callback: (...input: never[]) => unknown;
+    /**
+    Optional context ID for persistent storage.
+     */
     readonly contextId?: string;
-    /** The user function to evaluate inside Obsidian. */
-    readonly fn: (...args: never[]) => unknown;
+    /**
+    User-supplied arguments to pass to the function.
+     */
+    readonly input?: Record<string, unknown>;
 }
 interface AppParams {
     readonly app: App;
@@ -45,7 +51,7 @@ interface AppParams {
  * arguments are serialized via {@link jsonWithFunctions}, producing a
  * self-contained IIFE of the form `(fnExpr)(argsExpr)`.
  *
- * @param fn - The function to call.
+ * @param callback - The function to call.
  * @param params - The arguments to pass. When omitted, the function is called with no arguments.
  * @returns A JavaScript expression string.
  */
@@ -60,17 +66,17 @@ export declare function ensureLayoutReady(params: GenerateFunctionCallParams): P
  * Generates a JavaScript expression string that immediately invokes the given
  * function with the given arguments.
  *
- * @param fn - The function to call.
+ * @param callback - The function to call.
  * @param params - The arguments to pass.
  * @returns A JavaScript expression string.
  */
-export declare function generateFunctionCall<Params>(fn: (params: GenerateFunctionCallParams<Params>) => Promisable<unknown>, params: Params): string;
+export declare function generateFunctionCall<Params>(callback: (params: GenerateFunctionCallParams<Params>) => Promisable<unknown>, params: Params): string;
 /**
  * Generates a lightweight JavaScript expression that calls the pre-registered
  * `evalWrapper` on the `window.__obsidianIntegrationTesting` namespace.
  *
  * Unlike {@link generateFunctionCall}, this does not serialize infrastructure
- * functions — only the user's `fn`, `args`, and `contextId`. The infrastructure
+ * functions — only the user's `callback`, `input`, and `contextId`. The infrastructure
  * must already be bootstrapped via {@link ensureNamespaceBootstrapped}.
  *
  * @param params - The user function, arguments, and optional context ID.