@socketsecurity/lib 5.18.1 → 5.19.0

package/dist/git.js

@@ -1,5 +1,6 @@
 "use strict";
 /* Socket Lib - Built with esbuild */
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -52,35 +53,32 @@ var import_normalize = require("./paths/normalize");
 var import_spawn = require("./spawn");
 var import_strings = require("./strings");
 let _fs;
-// @__NO_SIDE_EFFECTS__
-function getFs() {
-  if (_fs === void 0) {
-    _fs = require("fs");
-  }
-  return _fs;
-}
 let _path;
-// @__NO_SIDE_EFFECTS__
-function getPath() {
-  if (_path === void 0) {
-    _path = require("path");
-  }
-  return _path;
-}
 const gitDiffCache = /* @__PURE__ */ new Map();
-const gitDiffAccessOrder = [];
 const GIT_CACHE_MAX_SIZE = 100;
-function evictLRUGitCache() {
-  if (gitDiffCache.size >= GIT_CACHE_MAX_SIZE && gitDiffAccessOrder.length > 0) {
-    const oldest = gitDiffAccessOrder.shift();
-    if (oldest) {
-      gitDiffCache.delete(oldest);
-    }
-  }
-}
 let _gitPath;
 const realpathCache = /* @__PURE__ */ new Map();
 const gitRootCache = /* @__PURE__ */ new Map();
+function getCachedGitDiff(key) {
+  const result = gitDiffCache.get(key);
+  if (result) {
+    gitDiffCache.delete(key);
+    gitDiffCache.set(key, result);
+  }
+  return result;
+}
+function stableKey(value) {
+  return JSON.stringify(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);
@@ -90,22 +88,31 @@ function getCachedRealpath(pathname) {
     }
     realpathCache.delete(pathname);
   }
-  const resolved = fs.realpathSync(pathname);
+  let resolved;
+  try {
+    resolved = fs.realpathSync(pathname);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      throw error;
+    }
+    resolved = pathname;
+  }
   realpathCache.set(pathname, resolved);
   return resolved;
 }
-function getGitPath() {
-  if (_gitPath === void 0) {
-    const resolved = (0, import_bin.whichSync)("git", { nothrow: true });
-    _gitPath = typeof resolved === "string" ? resolved : "git";
-  }
-  return _gitPath;
-}
 function getCwd() {
-  return (/* @__PURE__ */ getFs()).realpathSync(import_node_process.default.cwd());
+  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 ? (/* @__PURE__ */ getFs()).realpathSync(cwd) : getCwd();
+  const resolvedCwd = cwd ? getCachedRealpath(cwd) : getCwd();
   return {
     all: [
       getGitPath(),
@@ -130,11 +137,25 @@ function getGitDiffSpawnArgs(cwd) {
     ]
   };
 }
+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 ? JSON.stringify({ args, parseOptions }) : void 0;
+  const cacheKey = cache ? stableKey({ args, parseOptions }) : void 0;
   if (cache && cacheKey) {
-    const result2 = gitDiffCache.get(cacheKey);
+    const result2 = getCachedGitDiff(cacheKey);
     if (result2) {
       return result2;
     }
@@ -156,17 +177,15 @@ async function innerDiff(args, options) {
     return [];
   }
   if (cache && cacheKey) {
-    evictLRUGitCache();
-    gitDiffCache.set(cacheKey, result);
-    gitDiffAccessOrder.push(cacheKey);
+    setCachedGitDiff(cacheKey, result);
   }
   return result;
 }
 function innerDiffSync(args, options) {
   const { cache = true, ...parseOptions } = { __proto__: null, ...options };
-  const cacheKey = cache ? JSON.stringify({ args, parseOptions }) : void 0;
+  const cacheKey = cache ? stableKey({ args, parseOptions }) : void 0;
   if (cache && cacheKey) {
-    const result2 = gitDiffCache.get(cacheKey);
+    const result2 = getCachedGitDiff(cacheKey);
     if (result2) {
       return result2;
     }
@@ -188,39 +207,10 @@ function innerDiffSync(args, options) {
     return [];
   }
   if (cache && cacheKey) {
-    evictLRUGitCache();
-    gitDiffCache.set(cacheKey, result);
-    gitDiffAccessOrder.push(cacheKey);
+    setCachedGitDiff(cacheKey, result);
   }
   return 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;
-  }
-}
 function parseGitDiffStdout(stdout, options, spawnCwd) {
   const defaultRoot = spawnCwd ? findGitRoot(spawnCwd) : getCwd();
   const {
@@ -232,7 +222,7 @@ function parseGitDiffStdout(stdout, options, spawnCwd) {
   const path = /* @__PURE__ */ getPath();
   const cwd = cwdOption === defaultRoot ? defaultRoot : getCachedRealpath(cwdOption);
   const rootPath = defaultRoot;
-  let rawFiles = stdout ? (0, import_strings.stripAnsi)(stdout).split("\n").map((line) => line.trimEnd()).filter((line) => line) : [];
+  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 ? line.substring(3) : line;
@@ -256,6 +246,42 @@ function parseGitDiffStdout(stdout, options, spawnCwd) {
   }
   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, {
@@ -272,14 +298,6 @@ function getChangedFilesSync(options) {
     porcelain: true
   });
 }
-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 getStagedFiles(options) {
   const args = getGitDiffSpawnArgs(options?.cwd).staged;
   return await innerDiff(args, options);
@@ -288,6 +306,14 @@ 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,
@@ -316,8 +342,8 @@ function isChangedSync(pathname, options) {
     return false;
   }
 }
-async function isUnstaged(pathname, options) {
-  const files = await getUnstagedFiles({
+async function isStaged(pathname, options) {
+  const files = await getStagedFiles({
     __proto__: null,
     ...options,
     absolute: false
@@ -328,8 +354,8 @@ async function isUnstaged(pathname, options) {
   const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
   return files.includes(relativePath);
 }
-function isUnstagedSync(pathname, options) {
-  const files = getUnstagedFilesSync({
+function isStagedSync(pathname, options) {
+  const files = getStagedFilesSync({
     __proto__: null,
     ...options,
     absolute: false
@@ -340,8 +366,8 @@ function isUnstagedSync(pathname, options) {
   const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
   return files.includes(relativePath);
 }
-async function isStaged(pathname, options) {
-  const files = await getStagedFiles({
+async function isUnstaged(pathname, options) {
+  const files = await getUnstagedFiles({
     __proto__: null,
     ...options,
     absolute: false
@@ -352,8 +378,8 @@ async function isStaged(pathname, options) {
   const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
   return files.includes(relativePath);
 }
-function isStagedSync(pathname, options) {
-  const files = getStagedFilesSync({
+function isUnstagedSync(pathname, options) {
+  const files = getUnstagedFilesSync({
     __proto__: null,
     ...options,
     absolute: false