@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/git/staged.js

@@ -1,71 +1,181 @@
 "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 staged_exports = {};
-__export(staged_exports, {
-  getStagedFiles: () => getStagedFiles,
-  getStagedFilesSync: () => getStagedFilesSync,
-  isStaged: () => isStaged,
-  isStagedSync: () => isStagedSync
-});
-module.exports = __toCommonJS(staged_exports);
-var import_normalize = require("../paths/normalize");
-var import_array = require("../primordials/array");
-var import_internal = require("./_internal");
-var import_repo = require("./repo");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_paths_normalize = require('../paths/normalize.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_node_path = require('../node/path.js');
+const require_git_repo = require('./repo.js');
+const require_git__internal = require('./_internal.js');
+
+//#region src/git/staged.ts
+/**
+* @file "Ready for the next commit" helpers — `git diff --cached` over only the
+*   index. Excludes unstaged tracked-file edits and untracked paths; use
+*   `changed.ts` if you need the broader view.
+*/
+/**
+* Get staged files ready for commit (changes added with `git add`).
+*
+* Uses `git diff --cached --name-only` which returns only staged changes. Does
+* NOT include: - Unstaged modifications (changes not added with `git add`) -
+* Untracked files (new files not added to git)
+*
+* This is a focused check for what will be included in the next commit. Useful
+* for validating changes before committing or running pre-commit hooks.
+*
+* @example
+*   ;```typescript
+*   // Get currently staged files
+*   const files = await getStagedFiles()
+*   // => ['src/foo.ts']
+*
+*   // Stage more files
+*   await spawn('git', ['add', 'src/bar.ts'])
+*   const files = await getStagedFiles()
+*   // => ['src/foo.ts', 'src/bar.ts']
+*
+*   // Get absolute paths
+*   const files = await getStagedFiles({ absolute: true })
+*   // => ['/path/to/repo/src/foo.ts', ...]
+*   ```
+*
+* @param options - Options controlling path format and filtering.
+*
+* @returns Promise resolving to array of staged file paths.
+*/
 async function getStagedFiles(options) {
-  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).staged;
-  return await (0, import_internal.innerDiff)(args, options);
+	const args = require_git__internal.getGitDiffSpawnArgs(options?.cwd).staged;
+	return await require_git__internal.innerDiff(args, options);
 }
+/**
+* Get staged files ready for commit (changes added with `git add`).
+*
+* Synchronous version of `getStagedFiles()`. Uses `git diff --cached
+* --name-only` which returns only staged changes. Does NOT include: - Unstaged
+* modifications (changes not added with `git add`) - Untracked files (new files
+* not added to git)
+*
+* This is a focused check for what will be included in the next commit. Useful
+* for validating changes before committing or running pre-commit hooks.
+*
+* @example
+*   ;```typescript
+*   // Get currently staged files
+*   const files = getStagedFilesSync()
+*   // => ['src/foo.ts']
+*
+*   // Stage more files
+*   spawnSync('git', ['add', 'src/bar.ts'])
+*   const files = getStagedFilesSync()
+*   // => ['src/foo.ts', 'src/bar.ts']
+*
+*   // Get absolute paths
+*   const files = getStagedFilesSync({ absolute: true })
+*   // => ['/path/to/repo/src/foo.ts', ...]
+*   ```
+*
+* @param options - Options controlling path format and filtering.
+*
+* @returns Array of staged file paths.
+*/
 function getStagedFilesSync(options) {
-  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).staged;
-  return (0, import_internal.innerDiffSync)(args, options);
+	const args = require_git__internal.getGitDiffSpawnArgs(options?.cwd).staged;
+	return require_git__internal.innerDiffSync(args, options);
 }
+/**
+* Check if a file or directory is staged for commit.
+*
+* Checks if the given pathname has changes staged with `git add` that will be
+* included in the next commit. Does NOT include: - Unstaged modifications
+* (changes not added with `git add`) - Untracked files (new files not in git)
+*
+* For directories, returns `true` if ANY file within the directory is staged.
+*
+* Symlinks in the pathname and cwd are automatically resolved using
+* `fs.realpathSync()` before comparison.
+*
+* @example
+*   ;```typescript
+*   // Check if file is staged
+*   const staged = await isStaged('src/foo.ts')
+*   // => false
+*
+*   // Stage the file
+*   await spawn('git', ['add', 'src/foo.ts'])
+*   const staged = await isStaged('src/foo.ts')
+*   // => true
+*
+*   // Check directory
+*   const staged = await isStaged('src/')
+*   // => true (if any file in src/ is staged)
+*   ```
+*
+* @param pathname - File or directory path to check.
+* @param options - Options for the git diff check.
+*
+* @returns Promise resolving to `true` if path is staged, `false` otherwise.
+*/
 async function isStaged(pathname, options) {
-  const files = await getStagedFiles({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = (0, import_repo.getPath)();
-  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
-  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+	const files = await getStagedFiles({
+		__proto__: null,
+		...options,
+		absolute: false
+	});
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const resolvedPathname = require_git_repo.getCachedRealpath(pathname);
+	/* c8 ignore start */
+	const baseCwd = options?.cwd ? require_git_repo.getCachedRealpath(options["cwd"]) : require_git_repo.getCwd();
+	return require_primordials_array.ArrayPrototypeIncludes(files, /* @__PURE__ */ require_paths_normalize.normalizePath(path.relative(baseCwd, resolvedPathname)));
 }
+/**
+* Check if a file or directory is staged for commit.
+*
+* Synchronous version of `isStaged()`. Checks if the given pathname has changes
+* staged with `git add` that will be included in the next commit. Does NOT
+* include: - Unstaged modifications (changes not added with `git add`) -
+* Untracked files (new files not in git)
+*
+* For directories, returns `true` if ANY file within the directory is staged.
+*
+* Symlinks in the pathname and cwd are automatically resolved using
+* `fs.realpathSync()` before comparison.
+*
+* @example
+*   ;```typescript
+*   // Check if file is staged
+*   const staged = isStagedSync('src/foo.ts')
+*   // => false
+*
+*   // Stage the file
+*   spawnSync('git', ['add', 'src/foo.ts'])
+*   const staged = isStagedSync('src/foo.ts')
+*   // => true
+*
+*   // Check directory
+*   const staged = isStagedSync('src/')
+*   // => true (if any file in src/ is staged)
+*   ```
+*
+* @param pathname - File or directory path to check.
+* @param options - Options for the git diff check.
+*
+* @returns `true` if path is staged, `false` otherwise.
+*/
 function isStagedSync(pathname, options) {
-  const files = getStagedFilesSync({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = (0, import_repo.getPath)();
-  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
-  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+	const files = getStagedFilesSync({
+		__proto__: null,
+		...options,
+		absolute: false
+	});
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const resolvedPathname = require_git_repo.getCachedRealpath(pathname);
+	/* c8 ignore start */
+	const baseCwd = options?.cwd ? require_git_repo.getCachedRealpath(options["cwd"]) : require_git_repo.getCwd();
+	return require_primordials_array.ArrayPrototypeIncludes(files, /* @__PURE__ */ require_paths_normalize.normalizePath(path.relative(baseCwd, resolvedPathname)));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getStagedFiles,
-  getStagedFilesSync,
-  isStaged,
-  isStagedSync
-});
+
+//#endregion
+exports.getStagedFiles = getStagedFiles;
+exports.getStagedFilesSync = getStagedFilesSync;
+exports.isStaged = isStaged;
+exports.isStagedSync = isStagedSync;

package/dist/git/types.js

@@ -1,18 +1,2 @@
 "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 __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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+/* Socket Lib - Built with rolldown */

package/dist/git/unstaged.js

@@ -1,71 +1,184 @@
 "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 unstaged_exports = {};
-__export(unstaged_exports, {
-  getUnstagedFiles: () => getUnstagedFiles,
-  getUnstagedFilesSync: () => getUnstagedFilesSync,
-  isUnstaged: () => isUnstaged,
-  isUnstagedSync: () => isUnstagedSync
-});
-module.exports = __toCommonJS(unstaged_exports);
-var import_normalize = require("../paths/normalize");
-var import_array = require("../primordials/array");
-var import_internal = require("./_internal");
-var import_repo = require("./repo");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_paths_normalize = require('../paths/normalize.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_node_path = require('../node/path.js');
+const require_git_repo = require('./repo.js');
+const require_git__internal = require('./_internal.js');
+
+//#region src/git/unstaged.ts
+/**
+* @file "Edited but not yet staged" helpers — `git diff` over the working tree
+*   only. Excludes index-staged changes and untracked paths; use `changed.ts`
+*   for the broader view or `staged.ts` for the index.
+*/
+/**
+* Get unstaged modified files (changes not yet staged for commit).
+*
+* Uses `git diff --name-only` which returns only unstaged modifications to
+* tracked files. Does NOT include: - Untracked files (new files not added to
+* git) - Staged changes (files added with `git add`)
+*
+* This is a focused check for uncommitted changes to existing tracked files.
+* Useful for detecting work-in-progress modifications before staging.
+*
+* @example
+*   ;```typescript
+*   // Get unstaged files
+*   const files = await getUnstagedFiles()
+*   // => ['src/foo.ts', 'src/bar.ts']
+*
+*   // After staging some files
+*   await spawn('git', ['add', 'src/foo.ts'])
+*   const files = await getUnstagedFiles()
+*   // => ['src/bar.ts'] (foo.ts no longer included)
+*
+*   // Get absolute paths
+*   const files = await getUnstagedFiles({ absolute: true })
+*   // => ['/path/to/repo/src/bar.ts']
+*   ```
+*
+* @param options - Options controlling path format and filtering.
+*
+* @returns Promise resolving to array of unstaged file paths.
+*/
 async function getUnstagedFiles(options) {
-  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).unstaged;
-  return await (0, import_internal.innerDiff)(args, options);
+	const args = require_git__internal.getGitDiffSpawnArgs(options?.cwd).unstaged;
+	return await require_git__internal.innerDiff(args, options);
 }
+/**
+* Get unstaged modified files (changes not yet staged for commit).
+*
+* Synchronous version of `getUnstagedFiles()`. Uses `git diff --name-only`
+* which returns only unstaged modifications to tracked files. Does NOT include:
+* - Untracked files (new files not added to git) - Staged changes (files added
+* with `git add`)
+*
+* This is a focused check for uncommitted changes to existing tracked files.
+* Useful for detecting work-in-progress modifications before staging.
+*
+* @example
+*   ;```typescript
+*   // Get unstaged files
+*   const files = getUnstagedFilesSync()
+*   // => ['src/foo.ts', 'src/bar.ts']
+*
+*   // After staging some files
+*   spawnSync('git', ['add', 'src/foo.ts'])
+*   const files = getUnstagedFilesSync()
+*   // => ['src/bar.ts'] (foo.ts no longer included)
+*
+*   // Get absolute paths
+*   const files = getUnstagedFilesSync({ absolute: true })
+*   // => ['/path/to/repo/src/bar.ts']
+*   ```
+*
+* @param options - Options controlling path format and filtering.
+*
+* @returns Array of unstaged file paths.
+*/
 function getUnstagedFilesSync(options) {
-  const args = (0, import_internal.getGitDiffSpawnArgs)(options?.cwd).unstaged;
-  return (0, import_internal.innerDiffSync)(args, options);
+	const args = require_git__internal.getGitDiffSpawnArgs(options?.cwd).unstaged;
+	return require_git__internal.innerDiffSync(args, options);
 }
+/**
+* Check if a file or directory has unstaged changes.
+*
+* Checks if the given pathname has modifications that are not yet staged for
+* commit (changes not added with `git add`). Does NOT include: - Staged changes
+* (already added with `git add`) - Untracked files (new files not in git)
+*
+* For directories, returns `true` if ANY file within the directory has unstaged
+* changes.
+*
+* Symlinks in the pathname and cwd are automatically resolved using
+* `fs.realpathSync()` before comparison.
+*
+* @example
+*   ;```typescript
+*   // Check if file has unstaged changes
+*   const unstaged = await isUnstaged('src/foo.ts')
+*   // => true
+*
+*   // After staging the file
+*   await spawn('git', ['add', 'src/foo.ts'])
+*   const unstaged = await isUnstaged('src/foo.ts')
+*   // => false
+*
+*   // Check directory
+*   const unstaged = await isUnstaged('src/')
+*   // => true (if any file in src/ has unstaged changes)
+*   ```
+*
+* @param pathname - File or directory path to check.
+* @param options - Options for the git diff check.
+*
+* @returns Promise resolving to `true` if path has unstaged changes, `false`
+*   otherwise.
+*/
 async function isUnstaged(pathname, options) {
-  const files = await getUnstagedFiles({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = (0, import_repo.getPath)();
-  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
-  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+	const files = await getUnstagedFiles({
+		__proto__: null,
+		...options,
+		absolute: false
+	});
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const resolvedPathname = require_git_repo.getCachedRealpath(pathname);
+	/* c8 ignore start */
+	const baseCwd = options?.cwd ? require_git_repo.getCachedRealpath(options["cwd"]) : require_git_repo.getCwd();
+	return require_primordials_array.ArrayPrototypeIncludes(files, /* @__PURE__ */ require_paths_normalize.normalizePath(path.relative(baseCwd, resolvedPathname)));
 }
+/**
+* Check if a file or directory has unstaged changes.
+*
+* Synchronous version of `isUnstaged()`. Checks if the given pathname has
+* modifications that are not yet staged for commit (changes not added with `git
+* add`). Does NOT include: - Staged changes (already added with `git add`) -
+* Untracked files (new files not in git)
+*
+* For directories, returns `true` if ANY file within the directory has unstaged
+* changes.
+*
+* Symlinks in the pathname and cwd are automatically resolved using
+* `fs.realpathSync()` before comparison.
+*
+* @example
+*   ;```typescript
+*   // Check if file has unstaged changes
+*   const unstaged = isUnstagedSync('src/foo.ts')
+*   // => true
+*
+*   // After staging the file
+*   spawnSync('git', ['add', 'src/foo.ts'])
+*   const unstaged = isUnstagedSync('src/foo.ts')
+*   // => false
+*
+*   // Check directory
+*   const unstaged = isUnstagedSync('src/')
+*   // => true (if any file in src/ has unstaged changes)
+*   ```
+*
+* @param pathname - File or directory path to check.
+* @param options - Options for the git diff check.
+*
+* @returns `true` if path has unstaged changes, `false` otherwise.
+*/
 function isUnstagedSync(pathname, options) {
-  const files = getUnstagedFilesSync({
-    __proto__: null,
-    ...options,
-    absolute: false
-  });
-  const path = (0, import_repo.getPath)();
-  const resolvedPathname = (0, import_repo.getCachedRealpath)(pathname);
-  const baseCwd = options?.cwd ? (0, import_repo.getCachedRealpath)(options["cwd"]) : (0, import_repo.getCwd)();
-  const relativePath = (0, import_normalize.normalizePath)(path.relative(baseCwd, resolvedPathname));
-  return (0, import_array.ArrayPrototypeIncludes)(files, relativePath);
+	const files = getUnstagedFilesSync({
+		__proto__: null,
+		...options,
+		absolute: false
+	});
+	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const resolvedPathname = require_git_repo.getCachedRealpath(pathname);
+	/* c8 ignore start */
+	const baseCwd = options?.cwd ? require_git_repo.getCachedRealpath(options["cwd"]) : require_git_repo.getCwd();
+	return require_primordials_array.ArrayPrototypeIncludes(files, /* @__PURE__ */ require_paths_normalize.normalizePath(path.relative(baseCwd, resolvedPathname)));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getUnstagedFiles,
-  getUnstagedFilesSync,
-  isUnstaged,
-  isUnstagedSync
-});
+
+//#endregion
+exports.getUnstagedFiles = getUnstagedFiles;
+exports.getUnstagedFilesSync = getUnstagedFilesSync;
+exports.isUnstaged = isUnstaged;
+exports.isUnstagedSync = isUnstagedSync;

package/dist/github/constants.js

@@ -1,36 +1,28 @@
 "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 constants_exports = {};
-__export(constants_exports, {
-  DEFAULT_CACHE_TTL_MS: () => DEFAULT_CACHE_TTL_MS,
-  GITHUB_API_BASE_URL: () => GITHUB_API_BASE_URL,
-  GITHUB_GRAPHQL_URL: () => GITHUB_GRAPHQL_URL
-});
-module.exports = __toCommonJS(constants_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/github/constants.ts
+/**
+* @file GitHub API URL + cache-TTL constants. Inlined so values are captured at
+*   coverage-mode bundle time rather than referenced through a module graph
+*   indirection.
+*/
+/**
+* GitHub REST API base URL.
+*/
 const GITHUB_API_BASE_URL = "https://api.github.com";
+/**
+* GitHub GraphQL API endpoint.
+*/
 const GITHUB_GRAPHQL_URL = "https://api.github.com/graphql";
-const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_CACHE_TTL_MS,
-  GITHUB_API_BASE_URL,
-  GITHUB_GRAPHQL_URL
-});
+/**
+* Default TTL for the GitHub cache (5 minutes). Used by ref resolution and the
+* GHSA cache layer.
+*/
+const DEFAULT_CACHE_TTL_MS = 300 * 1e3;
+
+//#endregion
+exports.DEFAULT_CACHE_TTL_MS = DEFAULT_CACHE_TTL_MS;
+exports.GITHUB_API_BASE_URL = GITHUB_API_BASE_URL;
+exports.GITHUB_GRAPHQL_URL = GITHUB_GRAPHQL_URL;