@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/git/_internal.js

@@ -1,236 +1,271 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var internal_exports = {};
-__export(internal_exports, {
-  GIT_CACHE_MAX_SIZE: () => GIT_CACHE_MAX_SIZE,
-  GIT_CACHE_TTL_MS: () => GIT_CACHE_TTL_MS,
-  getCachedGitDiff: () => getCachedGitDiff,
-  getGitDiffSpawnArgs: () => getGitDiffSpawnArgs,
-  getGitPath: () => getGitPath,
-  gitDiffCache: () => gitDiffCache,
-  innerDiff: () => innerDiff,
-  innerDiffSync: () => innerDiffSync,
-  parseGitDiffStdout: () => parseGitDiffStdout,
-  setCachedGitDiff: () => setCachedGitDiff,
-  stableKey: () => stableKey
-});
-module.exports = __toCommonJS(internal_exports);
-var import_which = require("../bin/which");
-var import_output = require("../debug/output");
-var import_matcher = require("../globs/matcher");
-var import_normalize = require("../paths/normalize");
-var import_array = require("../primordials/array");
-var import_buffer = require("../primordials/buffer");
-var import_json = require("../primordials/json");
-var import_map_set = require("../primordials/map-set");
-var import_object = require("../primordials/object");
-var import_string = require("../primordials/string");
-var import_child = require("../process/spawn/child");
-var import_strip = require("../ansi/strip");
-var import_repo = require("./repo");
-const gitDiffCache = new import_map_set.MapCtor();
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_buffer = require('../primordials/buffer.js');
+const require_primordials_string = require('../primordials/string.js');
+const require_paths_normalize = require('../paths/normalize.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_primordials_map_set = require('../primordials/map-set.js');
+const require_node_path = require('../node/path.js');
+const require_primordials_object = require('../primordials/object.js');
+const require_primordials_json = require('../primordials/json.js');
+const require_bin_which = require('../bin/which.js');
+const require_ansi_strip = require('../ansi/strip.js');
+const require_process_spawn_child = require('../process/spawn/child.js');
+const require_debug_output = require('../debug/output.js');
+const require_globs_matcher = require('../globs/matcher.js');
+const require_git_repo = require('./repo.js');
+
+//#region src/git/_internal.ts
+/**
+* @file Cross-leaf diff machinery for `git/*`. Owns the LRU+TTL git-diff cache,
+*   the spawn-args builder, the porcelain-output parser, and the async/sync
+*   `innerDiff` runners. Public-surface leaves (`changed.ts`, `staged.ts`,
+*   `unstaged.ts`) call into these helpers; nothing else should.
+*/
+const gitDiffCache = new require_primordials_map_set.MapCtor();
 const GIT_CACHE_MAX_SIZE = 100;
 const GIT_CACHE_TTL_MS = 2e3;
 let _gitPath;
 function getCachedGitDiff(key) {
-  const entry = gitDiffCache.get(key);
-  if (!entry) {
-    return void 0;
-  }
-  if (Date.now() >= entry.expiresAt) {
-    gitDiffCache.delete(key);
-    return void 0;
-  }
-  gitDiffCache.delete(key);
-  gitDiffCache.set(key, entry);
-  return entry.result;
+	const entry = gitDiffCache.get(key);
+	if (!entry) return;
+	if (Date.now() >= entry.expiresAt) {
+		gitDiffCache.delete(key);
+		return;
+	}
+	gitDiffCache.delete(key);
+	gitDiffCache.set(key, entry);
+	return entry.result;
 }
+/**
+* Get spawn arguments for different git diff operations.
+*
+* Prepares argument arrays for `spawn()`/`spawnSync()` calls that retrieve: -
+* `all`: All changed files (staged, unstaged, untracked) via `git status
+* --porcelain` - `unstaged`: Unstaged modifications via `git diff --name-only`
+* - `staged`: Staged changes via `git diff --cached --name-only`
+*
+* Automatically resolves symlinks in the provided `cwd` and enables shell mode
+* on Windows for proper command execution.
+*
+* @param cwd - Working directory for git operations, defaults to
+*   `process.cwd()`.
+*
+* @returns Object containing spawn arguments for all, unstaged, and staged
+*   operations.
+*/
 function getGitDiffSpawnArgs(cwd) {
-  const resolvedCwd = cwd ? (0, import_repo.getCachedRealpath)(cwd) : (0, import_repo.getCwd)();
-  return {
-    all: [
-      getGitPath(),
-      ["status", "--porcelain"],
-      {
-        cwd: resolvedCwd
-      }
-    ],
-    unstaged: [
-      getGitPath(),
-      ["diff", "--name-only"],
-      {
-        cwd: resolvedCwd
-      }
-    ],
-    staged: [
-      getGitPath(),
-      ["diff", "--cached", "--name-only"],
-      {
-        cwd: resolvedCwd
-      }
-    ]
-  };
+	const resolvedCwd = cwd ? require_git_repo.getCachedRealpath(cwd) : require_git_repo.getCwd();
+	return {
+		all: [
+			getGitPath(),
+			["status", "--porcelain"],
+			{ cwd: resolvedCwd }
+		],
+		unstaged: [
+			getGitPath(),
+			["diff", "--name-only"],
+			{ cwd: resolvedCwd }
+		],
+		staged: [
+			getGitPath(),
+			[
+				"diff",
+				"--cached",
+				"--name-only"
+			],
+			{ cwd: resolvedCwd }
+		]
+	};
 }
+/**
+* Get the git executable path.
+*
+* Resolves the git binary path via PATH on first call and caches it. Falls back
+* to 'git' if not found in PATH.
+*
+* @example
+*   ;```typescript
+*   const git = getGitPath()
+*   // => '/usr/bin/git' or 'git' if not found
+*   ```
+*
+* @returns The git executable path (resolved from PATH on first call).
+*/
 function getGitPath() {
-  if (_gitPath === void 0) {
-    const resolved = (0, import_which.whichSync)("git", { nothrow: true });
-    _gitPath = typeof resolved === "string" ? resolved : "git";
-  }
-  return _gitPath;
+	/* c8 ignore start */
+	if (_gitPath === void 0) {
+		const resolved = require_bin_which.whichSync("git", { nothrow: true });
+		_gitPath = typeof resolved === "string" ? resolved : "git";
+	}
+	/* c8 ignore stop */
+	return _gitPath;
 }
+/**
+* Execute git diff command asynchronously and parse results.
+*
+* Internal helper for async git operations. Handles caching, command execution,
+* and result parsing. Returns empty array on git command failure.
+*
+* @param args - Spawn arguments tuple `[command, args, options]`.
+* @param options - Git diff options for caching and parsing.
+*
+* @returns Promise resolving to array of file paths.
+*/
 async function innerDiff(args, options) {
-  const { cache = true, ...parseOptions } = { __proto__: null, ...options };
-  const cacheKey = cache ? stableKey({ args, parseOptions }) : void 0;
-  if (cache && cacheKey) {
-    const result2 = getCachedGitDiff(cacheKey);
-    if (result2) {
-      return result2;
-    }
-  }
-  let result;
-  try {
-    const spawnResult = await (0, import_child.spawn)(args[0], args[1], {
-      ...args[2],
-      stdioString: false
-    });
-    const stdout = (0, import_buffer.BufferIsBuffer)(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : (
-      // String fallback only fires if spawn returns non-Buffer stdout.
-      /* c8 ignore next */
-      String(spawnResult.stdout)
-    );
-    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
-    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
-  } catch (e) {
-    (0, import_output.debugNs)(
-      "git",
-      `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`
-    );
-    return [];
-  }
-  if (cache && cacheKey) {
-    setCachedGitDiff(cacheKey, result);
-  }
-  return result;
+	const { cache = true, ...parseOptions } = {
+		__proto__: null,
+		...options
+	};
+	const cacheKey = cache ? stableKey({
+		args,
+		parseOptions
+	}) : void 0;
+	if (cache && cacheKey) {
+		const result = getCachedGitDiff(cacheKey);
+		if (result) return result;
+	}
+	let result;
+	try {
+		const spawnResult = await require_process_spawn_child.spawn(args[0], args[1], {
+			...args[2],
+			stdioString: false
+		});
+		/* c8 ignore stop */
+		result = parseGitDiffStdout(require_primordials_buffer.BufferIsBuffer(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : 
+		/* c8 ignore next */
+String(spawnResult.stdout), parseOptions, typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0);
+	} catch (e) {
+		require_debug_output.debugNs("git", `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`);
+		return [];
+	}
+	if (cache && cacheKey) setCachedGitDiff(cacheKey, result);
+	return result;
 }
+/**
+* Execute git diff command synchronously and parse results.
+*
+* Internal helper for sync git operations. Handles caching, command execution,
+* and result parsing. Returns empty array on git command failure.
+*
+* @param args - Spawn arguments tuple `[command, args, options]`.
+* @param options - Git diff options for caching and parsing.
+*
+* @returns Array of file paths.
+*/
 function innerDiffSync(args, options) {
-  const { cache = true, ...parseOptions } = { __proto__: null, ...options };
-  const cacheKey = cache ? stableKey({ args, parseOptions }) : void 0;
-  if (cache && cacheKey) {
-    const result2 = getCachedGitDiff(cacheKey);
-    if (result2) {
-      return result2;
-    }
-  }
-  let result;
-  try {
-    const spawnResult = (0, import_child.spawnSync)(args[0], args[1], {
-      ...args[2],
-      stdioString: false
-    });
-    const stdout = (0, import_buffer.BufferIsBuffer)(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : (
-      // String fallback only fires if spawn returns non-Buffer stdout.
-      /* c8 ignore next */
-      String(spawnResult.stdout)
-    );
-    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
-    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
-  } catch (e) {
-    (0, import_output.debugNs)(
-      "git",
-      `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`
-    );
-    return [];
-  }
-  if (cache && cacheKey) {
-    setCachedGitDiff(cacheKey, result);
-  }
-  return result;
+	const { cache = true, ...parseOptions } = {
+		__proto__: null,
+		...options
+	};
+	const cacheKey = cache ? stableKey({
+		args,
+		parseOptions
+	}) : void 0;
+	if (cache && cacheKey) {
+		const result = getCachedGitDiff(cacheKey);
+		if (result) return result;
+	}
+	let result;
+	try {
+		const spawnResult = require_process_spawn_child.spawnSync(args[0], args[1], {
+			...args[2],
+			stdioString: false
+		});
+		/* c8 ignore stop */
+		result = parseGitDiffStdout(require_primordials_buffer.BufferIsBuffer(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : 
+		/* c8 ignore next */
+String(spawnResult.stdout), parseOptions, typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0);
+	} catch (e) {
+		require_debug_output.debugNs("git", `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`);
+		return [];
+	}
+	if (cache && cacheKey) setCachedGitDiff(cacheKey, result);
+	return result;
 }
+/**
+* Parse git diff stdout output into file path array.
+*
+* Internal helper that processes raw git command output by: 1. Finding git
+* repository root from spawn cwd 2. Stripping ANSI codes and splitting into
+* lines 3. Parsing porcelain format status codes if requested 4. Normalizing
+* and optionally making paths absolute 5. Filtering paths based on cwd and glob
+* options.
+*
+* Git always returns paths relative to the repository root, regardless of where
+* the command was executed. This function handles the path resolution correctly
+* by finding the repo root and adjusting paths accordingly.
+*
+* @param stdout - Raw stdout from git command.
+* @param options - Git diff options for path processing.
+* @param spawnCwd - Working directory where git command was executed.
+*
+* @returns Array of processed file paths.
+*/
 function parseGitDiffStdout(stdout, options, spawnCwd) {
-  const defaultRoot = spawnCwd ? (0, import_repo.findGitRoot)(spawnCwd) : (0, import_repo.getCwd)();
-  const {
-    absolute = false,
-    cwd: cwdOption = defaultRoot,
-    porcelain = false,
-    ...matcherOptions
-  } = { __proto__: null, ...options };
-  const path = (0, import_repo.getPath)();
-  const cwd = cwdOption === defaultRoot ? defaultRoot : (0, import_repo.getCachedRealpath)(cwdOption);
-  const rootPath = defaultRoot;
-  let rawFiles = stdout ? (0, import_strip.stripAnsi)(stdout).split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line) : [];
-  if (porcelain) {
-    rawFiles = rawFiles.map((line) => {
-      return line.length > 3 ? (0, import_string.StringPrototypeSubstring)(line, 3) : line;
-    });
-  }
-  const files = absolute ? rawFiles.map((relPath2) => (0, import_normalize.normalizePath)(path.join(rootPath, relPath2))) : rawFiles.map((relPath2) => (0, import_normalize.normalizePath)(relPath2));
-  if (cwd === rootPath) {
-    return files;
-  }
-  const relPath = (0, import_normalize.normalizePath)(path.relative(rootPath, cwd));
-  const matcher = (0, import_matcher.getGlobMatcher)([`${relPath}/**`], {
-    ...matcherOptions,
-    absolute,
-    cwd: rootPath
-  });
-  const filtered = [];
-  for (const filepath of files) {
-    if (matcher(filepath)) {
-      filtered.push(filepath);
-    }
-  }
-  return filtered;
+	/* c8 ignore next */
+	const defaultRoot = spawnCwd ? require_git_repo.findGitRoot(spawnCwd) : require_git_repo.getCwd();
+	const { absolute = false, cwd: cwdOption = defaultRoot, porcelain = false, ...matcherOptions } = {
+		__proto__: null,
+		...options
+	};
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const cwd = cwdOption === defaultRoot ? defaultRoot : require_git_repo.getCachedRealpath(cwdOption);
+	const rootPath = defaultRoot;
+	let rawFiles = stdout ? (/* @__PURE__ */ require_ansi_strip.stripAnsi(stdout)).split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line) : [];
+	if (porcelain) rawFiles = rawFiles.map((line) => {
+		/* c8 ignore next */
+		return line.length > 3 ? require_primordials_string.StringPrototypeSubstring(line, 3) : line;
+	});
+	const files = absolute ? rawFiles.map((relPath) => /* @__PURE__ */ require_paths_normalize.normalizePath(path.join(rootPath, relPath))) : rawFiles.map((relPath) => /* @__PURE__ */ require_paths_normalize.normalizePath(relPath));
+	if (cwd === rootPath) return files;
+	const matcher = /* @__PURE__ */ require_globs_matcher.getGlobMatcher([`${/* @__PURE__ */ require_paths_normalize.normalizePath(path.relative(rootPath, cwd))}/**`], {
+		...matcherOptions,
+		absolute,
+		cwd: rootPath
+	});
+	const filtered = [];
+	for (const filepath of files) if (matcher(filepath)) filtered.push(filepath);
+	return filtered;
 }
 function setCachedGitDiff(key, result) {
-  if (gitDiffCache.size >= GIT_CACHE_MAX_SIZE) {
-    const oldest = gitDiffCache.keys().next().value;
-    if (oldest !== void 0) {
-      gitDiffCache.delete(oldest);
-    }
-  }
-  gitDiffCache.set(key, { expiresAt: Date.now() + GIT_CACHE_TTL_MS, result });
+	/* c8 ignore start */
+	if (gitDiffCache.size >= 100) {
+		const oldest = gitDiffCache.keys().next().value;
+		if (oldest !== void 0) gitDiffCache.delete(oldest);
+	}
+	/* c8 ignore stop */
+	gitDiffCache.set(key, {
+		expiresAt: Date.now() + GIT_CACHE_TTL_MS,
+		result
+	});
 }
+/**
+* Build a stable cache key that is insensitive to object-property insertion
+* order, so callers passing the same options with different shapes hit the same
+* cache slot.
+*/
 function stableKey(value) {
-  return (0, import_json.JSONStringify)(value, (_key, val) => {
-    if (val && typeof val === "object" && !(0, import_array.ArrayIsArray)(val)) {
-      const sorted = {};
-      for (const k of (0, import_object.ObjectKeys)(val).sort()) {
-        sorted[k] = val[k];
-      }
-      return sorted;
-    }
-    return val;
-  });
+	return require_primordials_json.JSONStringify(value, (_key, val) => {
+		if (val && typeof val === "object" && !require_primordials_array.ArrayIsArray(val)) {
+			const sorted = {};
+			for (const k of require_primordials_object.ObjectKeys(val).sort()) sorted[k] = val[k];
+			return sorted;
+		}
+		return val;
+	});
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GIT_CACHE_MAX_SIZE,
-  GIT_CACHE_TTL_MS,
-  getCachedGitDiff,
-  getGitDiffSpawnArgs,
-  getGitPath,
-  gitDiffCache,
-  innerDiff,
-  innerDiffSync,
-  parseGitDiffStdout,
-  setCachedGitDiff,
-  stableKey
-});
+
+//#endregion
+exports.GIT_CACHE_MAX_SIZE = GIT_CACHE_MAX_SIZE;
+exports.GIT_CACHE_TTL_MS = GIT_CACHE_TTL_MS;
+exports.getCachedGitDiff = getCachedGitDiff;
+exports.getGitDiffSpawnArgs = getGitDiffSpawnArgs;
+exports.getGitPath = getGitPath;
+exports.gitDiffCache = gitDiffCache;
+exports.innerDiff = innerDiff;
+exports.innerDiffSync = innerDiffSync;
+exports.parseGitDiffStdout = parseGitDiffStdout;
+exports.setCachedGitDiff = setCachedGitDiff;
+exports.stableKey = stableKey;