@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/git.js

@@ -1,409 +0,0 @@
-"use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var git_exports = {};
-__export(git_exports, {
-  findGitRoot: () => findGitRoot,
-  getChangedFiles: () => getChangedFiles,
-  getChangedFilesSync: () => getChangedFilesSync,
-  getStagedFiles: () => getStagedFiles,
-  getStagedFilesSync: () => getStagedFilesSync,
-  getUnstagedFiles: () => getUnstagedFiles,
-  getUnstagedFilesSync: () => getUnstagedFilesSync,
-  isChanged: () => isChanged,
-  isChangedSync: () => isChangedSync,
-  isStaged: () => isStaged,
-  isStagedSync: () => isStagedSync,
-  isUnstaged: () => isUnstaged,
-  isUnstagedSync: () => isUnstagedSync
-});
-module.exports = __toCommonJS(git_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_bin = require("./bin");
-var import_debug = require("./debug");
-var import_globs = require("./globs");
-var import_normalize = require("./paths/normalize");
-var import_spawn = require("./spawn");
-var import_strings = require("./strings");
-var import_primordials = require("./primordials");
-let _fs;
-let _path;
-const gitDiffCache = new import_primordials.MapCtor();
-const GIT_CACHE_MAX_SIZE = 100;
-let _gitPath;
-const realpathCache = new import_primordials.MapCtor();
-const gitRootCache = new import_primordials.MapCtor();
-function getCachedGitDiff(key) {
-  const result = gitDiffCache.get(key);
-  if (result) {
-    gitDiffCache.delete(key);
-    gitDiffCache.set(key, result);
-  }
-  return result;
-}
-function stableKey(value) {
-  return (0, import_primordials.JSONStringify)(value, (_key, val) => {
-    if (val && typeof val === "object" && !Array.isArray(val)) {
-      const sorted = {};
-      for (const k of Object.keys(val).sort()) {
-        sorted[k] = val[k];
-      }
-      return sorted;
-    }
-    return val;
-  });
-}
-function getCachedRealpath(pathname) {
-  const fs = /* @__PURE__ */ getFs();
-  const cached = realpathCache.get(pathname);
-  if (cached) {
-    if (fs.existsSync(cached)) {
-      return cached;
-    }
-    realpathCache.delete(pathname);
-  }
-  let resolved;
-  try {
-    resolved = fs.realpathSync(pathname);
-  } catch (e) {
-    const code = e.code;
-    if (code === "ENOENT" || code === "ENOTDIR") {
-      throw e;
-    }
-    resolved = pathname;
-  }
-  realpathCache.set(pathname, resolved);
-  return resolved;
-}
-function getCwd() {
-  return getCachedRealpath(import_node_process.default.cwd());
-}
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("node:fs");
-  }
-  return _fs;
-}
-function getGitDiffSpawnArgs(cwd) {
-  const resolvedCwd = cwd ? getCachedRealpath(cwd) : getCwd();
-  return {
-    all: [
-      getGitPath(),
-      ["status", "--porcelain"],
-      {
-        cwd: resolvedCwd
-      }
-    ],
-    unstaged: [
-      getGitPath(),
-      ["diff", "--name-only"],
-      {
-        cwd: resolvedCwd
-      }
-    ],
-    staged: [
-      getGitPath(),
-      ["diff", "--cached", "--name-only"],
-      {
-        cwd: resolvedCwd
-      }
-    ]
-  };
-}
-function getGitPath() {
-  if (_gitPath === void 0) {
-    const resolved = (0, import_bin.whichSync)("git", { nothrow: true });
-    _gitPath = typeof resolved === "string" ? resolved : "git";
-  }
-  return _gitPath;
-}
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("node:path");
-  }
-  return _path;
-}
-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_spawn.spawn)(args[0], args[1], {
-      ...args[2],
-      stdioString: false
-    });
-    const stdout = (0, import_primordials.BufferIsBuffer)(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : String(spawnResult.stdout);
-    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
-    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
-  } catch (e) {
-    (0, import_debug.debugNs)(
-      "git",
-      `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`
-    );
-    return [];
-  }
-  if (cache && cacheKey) {
-    setCachedGitDiff(cacheKey, result);
-  }
-  return result;
-}
-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_spawn.spawnSync)(args[0], args[1], {
-      ...args[2],
-      stdioString: false
-    });
-    const stdout = (0, import_primordials.BufferIsBuffer)(spawnResult.stdout) ? spawnResult.stdout.toString("utf8") : String(spawnResult.stdout);
-    const spawnCwd = typeof args[2]["cwd"] === "string" ? args[2]["cwd"] : void 0;
-    result = parseGitDiffStdout(stdout, parseOptions, spawnCwd);
-  } catch (e) {
-    (0, import_debug.debugNs)(
-      "git",
-      `Git command failed (${args[0]} ${args[1].join(" ")}): ${e.message}`
-    );
-    return [];
-  }
-  if (cache && cacheKey) {
-    setCachedGitDiff(cacheKey, result);
-  }
-  return result;
-}
-function parseGitDiffStdout(stdout, options, spawnCwd) {
-  const defaultRoot = spawnCwd ? findGitRoot(spawnCwd) : getCwd();
-  const {
-    absolute = false,
-    cwd: cwdOption = defaultRoot,
-    porcelain = false,
-    ...matcherOptions
-  } = { __proto__: null, ...options };
-  const path = /* @__PURE__ */ getPath();
-  const cwd = cwdOption === defaultRoot ? defaultRoot : getCachedRealpath(cwdOption);
-  const rootPath = defaultRoot;
-  let rawFiles = stdout ? (0, import_strings.stripAnsi)(stdout).split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line) : [];
-  if (porcelain) {
-    rawFiles = rawFiles.map((line) => {
-      return line.length > 3 ? (0, import_primordials.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_globs.getGlobMatcher)([`${relPath}/**`], {
-    ...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, result);
-}
-function findGitRoot(startPath) {
-  const fs = /* @__PURE__ */ getFs();
-  const path = /* @__PURE__ */ getPath();
-  const cached = gitRootCache.get(startPath);
-  if (cached) {
-    if (fs.existsSync(path.join(cached, ".git"))) {
-      return cached;
-    }
-    gitRootCache.delete(startPath);
-  }
-  let currentPath = startPath;
-  while (true) {
-    try {
-      const gitPath = path.join(currentPath, ".git");
-      if (fs.existsSync(gitPath)) {
-        gitRootCache.set(startPath, currentPath);
-        return currentPath;
-      }
-    } catch {
-    }
-    const parentPath = path.dirname(currentPath);
-    if (parentPath === currentPath) {
-      return startPath;
-    }
-    currentPath = parentPath;
-  }
-}
-async function getChangedFiles(options) {
-  const args = getGitDiffSpawnArgs(options?.cwd).all;
-  return await innerDiff(args, {
-    __proto__: null,
-    ...options,
-    porcelain: true
-  });
-}
-function getChangedFilesSync(options) {
-  const args = getGitDiffSpawnArgs(options?.cwd).all;
-  return innerDiffSync(args, {
-    __proto__: null,
-    ...options,
-    porcelain: true
-  });
-}
-async function getStagedFiles(options) {
-  const args = getGitDiffSpawnArgs(options?.cwd).staged;
-  return await innerDiff(args, options);
-}
-function getStagedFilesSync(options) {
-  const args = getGitDiffSpawnArgs(options?.cwd).staged;
-  return innerDiffSync(args, options);
-}
-async function getUnstagedFiles(options) {
-  const args = getGitDiffSpawnArgs(options?.cwd).unstaged;
-  return await innerDiff(args, options);
-}
-function getUnstagedFilesSync(options) {
-  const args = getGitDiffSpawnArgs(options?.cwd).unstaged;
-  return innerDiffSync(args, options);
-}
-async function isChanged(pathname, options) {
-  const files = await getChangedFiles({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = /* @__PURE__ */ getPath();
-  const resolvedPathname = getCachedRealpath(pathname);
-  const baseCwd = options?.cwd ? getCachedRealpath(options["cwd"]) : getCwd();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_primordials.ArrayPrototypeIncludes)(files, relativePath);
-}
-function isChangedSync(pathname, options) {
-  const files = getChangedFilesSync({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = /* @__PURE__ */ getPath();
-  try {
-    const resolvedPathname = getCachedRealpath(pathname);
-    const baseCwd = options?.cwd ? getCachedRealpath(options["cwd"]) : getCwd();
-    const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-    return (0, import_primordials.ArrayPrototypeIncludes)(files, relativePath);
-  } catch {
-    return false;
-  }
-}
-async function isStaged(pathname, options) {
-  const files = await getStagedFiles({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = /* @__PURE__ */ getPath();
-  const resolvedPathname = getCachedRealpath(pathname);
-  const baseCwd = options?.cwd ? getCachedRealpath(options["cwd"]) : getCwd();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_primordials.ArrayPrototypeIncludes)(files, relativePath);
-}
-function isStagedSync(pathname, options) {
-  const files = getStagedFilesSync({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = /* @__PURE__ */ getPath();
-  const resolvedPathname = getCachedRealpath(pathname);
-  const baseCwd = options?.cwd ? getCachedRealpath(options["cwd"]) : getCwd();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_primordials.ArrayPrototypeIncludes)(files, relativePath);
-}
-async function isUnstaged(pathname, options) {
-  const files = await getUnstagedFiles({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = /* @__PURE__ */ getPath();
-  const resolvedPathname = getCachedRealpath(pathname);
-  const baseCwd = options?.cwd ? getCachedRealpath(options["cwd"]) : getCwd();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_primordials.ArrayPrototypeIncludes)(files, relativePath);
-}
-function isUnstagedSync(pathname, options) {
-  const files = getUnstagedFilesSync({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = /* @__PURE__ */ getPath();
-  const resolvedPathname = getCachedRealpath(pathname);
-  const baseCwd = options?.cwd ? getCachedRealpath(options["cwd"]) : getCwd();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_primordials.ArrayPrototypeIncludes)(files, relativePath);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  findGitRoot,
-  getChangedFiles,
-  getChangedFilesSync,
-  getStagedFiles,
-  getStagedFilesSync,
-  getUnstagedFiles,
-  getUnstagedFilesSync,
-  isChanged,
-  isChangedSync,
-  isStaged,
-  isStagedSync,
-  isUnstaged,
-  isUnstagedSync
-});