@socketsecurity/lib 5.28.0 → 6.0.0

package/dist/argv/flags.js

@@ -1,297 +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 flags_exports = {};
-__export(flags_exports, {
-  COMMON_FLAGS: () => COMMON_FLAGS,
-  getLogLevel: () => getLogLevel,
-  isAll: () => isAll,
-  isChanged: () => isChanged,
-  isCoverage: () => isCoverage,
-  isDebug: () => isDebug,
-  isDryRun: () => isDryRun,
-  isFix: () => isFix,
-  isForce: () => isForce,
-  isHelp: () => isHelp,
-  isJson: () => isJson,
-  isQuiet: () => isQuiet,
-  isStaged: () => isStaged,
-  isUpdate: () => isUpdate,
-  isVerbose: () => isVerbose,
-  isWatch: () => isWatch
-});
-module.exports = __toCommonJS(flags_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_primordials = require("../primordials");
-const processArg = [...import_node_process.default.argv];
-const COMMON_FLAGS = {
-  all: {
-    type: "boolean",
-    default: false,
-    description: "Target all files"
-  },
-  changed: {
-    type: "boolean",
-    default: false,
-    description: "Target changed files"
-  },
-  coverage: {
-    type: "boolean",
-    default: false,
-    description: "Run with coverage"
-  },
-  cover: {
-    type: "boolean",
-    default: false,
-    description: "Run with coverage (alias)"
-  },
-  debug: {
-    type: "boolean",
-    default: false,
-    description: "Enable debug output"
-  },
-  "dry-run": {
-    type: "boolean",
-    default: false,
-    description: "Perform a dry run"
-  },
-  fix: {
-    type: "boolean",
-    default: false,
-    description: "Automatically fix issues"
-  },
-  force: {
-    type: "boolean",
-    default: false,
-    description: "Force the operation"
-  },
-  help: {
-    type: "boolean",
-    default: false,
-    short: "h",
-    description: "Show help"
-  },
-  json: {
-    type: "boolean",
-    default: false,
-    description: "Output as JSON"
-  },
-  quiet: {
-    type: "boolean",
-    default: false,
-    short: "q",
-    description: "Suppress output"
-  },
-  silent: {
-    type: "boolean",
-    default: false,
-    description: "Suppress all output"
-  },
-  staged: {
-    type: "boolean",
-    default: false,
-    description: "Target staged files"
-  },
-  update: {
-    type: "boolean",
-    default: false,
-    short: "u",
-    description: "Update snapshots/deps"
-  },
-  verbose: {
-    type: "boolean",
-    default: false,
-    short: "v",
-    description: "Verbose output"
-  },
-  watch: {
-    type: "boolean",
-    default: false,
-    short: "w",
-    description: "Watch mode"
-  }
-};
-function getLogLevel(input) {
-  if (isQuiet(input)) {
-    return "silent";
-  }
-  if (isDebug(input)) {
-    return "debug";
-  }
-  if (isVerbose(input)) {
-    return "verbose";
-  }
-  return "info";
-}
-function isAll(input) {
-  if (!input) {
-    return processArg.includes("--all");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--all");
-  }
-  return !!input.all;
-}
-function isChanged(input) {
-  if (!input) {
-    return processArg.includes("--changed");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--changed");
-  }
-  return !!input.changed;
-}
-function isCoverage(input) {
-  if (!input) {
-    return processArg.includes("--coverage") || processArg.includes("--cover");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--coverage") || (0, import_primordials.StringPrototypeIncludes)(input, "--cover");
-  }
-  return !!(input.coverage || input.cover);
-}
-function isDebug(input) {
-  if (!input) {
-    return processArg.includes("--debug");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--debug");
-  }
-  return !!input.debug;
-}
-function isDryRun(input) {
-  if (!input) {
-    return processArg.includes("--dry-run");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--dry-run");
-  }
-  return !!input["dry-run"];
-}
-function isFix(input) {
-  if (!input) {
-    return processArg.includes("--fix");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--fix");
-  }
-  return !!input.fix;
-}
-function isForce(input) {
-  if (!input) {
-    return processArg.includes("--force");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--force");
-  }
-  return !!input.force;
-}
-function isHelp(input) {
-  if (!input) {
-    return processArg.includes("--help") || processArg.includes("-h");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--help") || (0, import_primordials.StringPrototypeIncludes)(input, "-h");
-  }
-  return !!input.help;
-}
-function isJson(input) {
-  if (!input) {
-    return processArg.includes("--json");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--json");
-  }
-  return !!input.json;
-}
-function isQuiet(input) {
-  if (!input) {
-    return processArg.includes("--quiet") || processArg.includes("--silent");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--quiet") || (0, import_primordials.StringPrototypeIncludes)(input, "--silent");
-  }
-  return !!(input.quiet || input.silent);
-}
-function isStaged(input) {
-  if (!input) {
-    return processArg.includes("--staged");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--staged");
-  }
-  return !!input.staged;
-}
-function isUpdate(input) {
-  if (!input) {
-    return processArg.includes("--update") || processArg.includes("-u");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--update") || (0, import_primordials.StringPrototypeIncludes)(input, "-u");
-  }
-  return !!input.update;
-}
-function isVerbose(input) {
-  if (!input) {
-    return processArg.includes("--verbose");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--verbose");
-  }
-  return !!input.verbose;
-}
-function isWatch(input) {
-  if (!input) {
-    return processArg.includes("--watch") || processArg.includes("-w");
-  }
-  if ((0, import_primordials.ArrayIsArray)(input)) {
-    return (0, import_primordials.StringPrototypeIncludes)(input, "--watch") || (0, import_primordials.StringPrototypeIncludes)(input, "-w");
-  }
-  return !!input.watch;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  COMMON_FLAGS,
-  getLogLevel,
-  isAll,
-  isChanged,
-  isCoverage,
-  isDebug,
-  isDryRun,
-  isFix,
-  isForce,
-  isHelp,
-  isJson,
-  isQuiet,
-  isStaged,
-  isUpdate,
-  isVerbose,
-  isWatch
-});

package/dist/arrays.d.ts

@@ -1,168 +0,0 @@
-/**
- * @fileoverview Array utility functions for formatting lists and collections.
- * Provides conjunction and disjunction formatters using Intl.ListFormat.
- */
-/**
- * Split an array into chunks of a specified size.
- *
- * Divides an array into smaller arrays of the specified chunk size.
- * The last chunk may contain fewer elements if the array length is not
- * evenly divisible by the chunk size.
- *
- * @param arr - The array to split into chunks (can be readonly)
- * @param size - Size of each chunk. Must be greater than 0.
- * @default 2
- * @returns Array of chunks, where each chunk is an array of elements
- * @throws {Error} If chunk size is less than or equal to 0
- *
- * @example
- * ```ts
- * // Split into pairs (default)
- * arrayChunk([1, 2, 3, 4, 5])
- * // Returns: [[1, 2], [3, 4], [5]]
- *
- * // Split into groups of 3
- * arrayChunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3)
- * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
- *
- * // Works with readonly arrays
- * const readonlyArr = [1, 2, 3] as const
- * arrayChunk(readonlyArr)
- * // Returns: [[1, 2], [3]]
- * ```
- */
-export declare function arrayChunk<T>(arr: T[] | readonly T[], size?: number | undefined): T[][];
-/**
- * Get unique values from an array.
- *
- * Returns a new array containing only the unique values from the input array.
- * Uses `Set` internally for efficient deduplication. Order of first occurrence
- * is preserved.
- *
- * @param arr - The array to deduplicate (can be readonly)
- * @returns New array with duplicate values removed
- *
- * @example
- * ```ts
- * // Remove duplicate numbers
- * arrayUnique([1, 2, 2, 3, 1, 4])
- * // Returns: [1, 2, 3, 4]
- *
- * // Remove duplicate strings
- * arrayUnique(['apple', 'banana', 'apple', 'cherry'])
- * // Returns: ['apple', 'banana', 'cherry']
- *
- * // Works with readonly arrays
- * const readonlyArr = [1, 1, 2] as const
- * arrayUnique(readonlyArr)
- * // Returns: [1, 2]
- *
- * // Empty arrays return empty
- * arrayUnique([])
- * // Returns: []
- * ```
- */
-export declare function arrayUnique<T>(arr: T[] | readonly T[]): T[];
-/**
- * Alias for native Array.isArray.
- * Determines whether the passed value is an array.
- *
- * This is a direct reference to the native `Array.isArray` method,
- * providing a type guard that narrows the type to an array type.
- * Exported for consistency with other array utilities in this module.
- *
- * @param value - The value to check
- * @returns `true` if the value is an array, `false` otherwise
- *
- * @example
- * ```ts
- * // Check if value is an array
- * isArray([1, 2, 3])
- * // Returns: true
- *
- * isArray('not an array')
- * // Returns: false
- *
- * isArray(null)
- * // Returns: false
- *
- * // Type guard usage
- * function processValue(value: unknown) {
- *   if (isArray(value)) {
- *     // TypeScript knows value is an array here
- *     console.log(value.length)
- *   }
- * }
- * ```
- */
-export declare const isArray: (arg: any) => arg is any[];
-/**
- * Join array elements with proper "and" conjunction formatting.
- *
- * Formats an array of strings into a grammatically correct list using
- * "and" as the conjunction. Uses `Intl.ListFormat` for proper English
- * formatting with Oxford comma support.
- *
- * @param arr - Array of strings to join (can be readonly)
- * @returns Formatted string with proper "and" conjunction
- *
- * @example
- * ```ts
- * // Two items
- * joinAnd(['apples', 'oranges'])
- * // Returns: "apples and oranges"
- *
- * // Three or more items (Oxford comma)
- * joinAnd(['apples', 'oranges', 'bananas'])
- * // Returns: "apples, oranges, and bananas"
- *
- * // Single item
- * joinAnd(['apples'])
- * // Returns: "apples"
- *
- * // Empty array
- * joinAnd([])
- * // Returns: ""
- *
- * // Usage in messages
- * const items = ['React', 'Vue', 'Angular']
- * console.log(`You can choose ${joinAnd(items)}`)
- * // Outputs: "You can choose React, Vue, and Angular"
- * ```
- */
-export declare function joinAnd(arr: string[] | readonly string[]): string;
-/**
- * Join array elements with proper "or" disjunction formatting.
- *
- * Formats an array of strings into a grammatically correct list using
- * "or" as the disjunction. Uses `Intl.ListFormat` for proper English
- * formatting with Oxford comma support.
- *
- * @param arr - Array of strings to join (can be readonly)
- * @returns Formatted string with proper "or" disjunction
- *
- * @example
- * ```ts
- * // Two items
- * joinOr(['yes', 'no'])
- * // Returns: "yes or no"
- *
- * // Three or more items (Oxford comma)
- * joinOr(['red', 'green', 'blue'])
- * // Returns: "red, green, or blue"
- *
- * // Single item
- * joinOr(['maybe'])
- * // Returns: "maybe"
- *
- * // Empty array
- * joinOr([])
- * // Returns: ""
- *
- * // Usage in prompts
- * const options = ['npm', 'yarn', 'pnpm']
- * console.log(`Choose a package manager: ${joinOr(options)}`)
- * // Outputs: "Choose a package manager: npm, yarn, or pnpm"
- * ```
- */
-export declare function joinOr(arr: string[] | readonly string[]): string;

package/dist/bin.d.ts

@@ -1,181 +0,0 @@
-/**
- * @fileoverview Binary path resolution and execution utilities for package managers.
- * Provides cross-platform bin path lookup, command execution, and path normalization.
- */
-/**
- * Options for the which function.
- */
-export interface WhichOptions {
-    /** If true, return all matches instead of just the first one. */
-    all?: boolean | undefined;
-    /** If true, return null instead of throwing when no match is found. */
-    nothrow?: boolean | undefined;
-    /** Path to search in. */
-    path?: string | undefined;
-    /** Path separator character. */
-    pathExt?: string | undefined;
-    /** Environment variables to use. */
-    env?: Record<string, string | undefined> | undefined;
-    /** Current working directory for resolving relative paths. */
-    cwd?: string | undefined;
-}
-/**
- * Execute a binary with the given arguments.
- *
- * @example
- * ```typescript
- * await execBin('pnpm', ['install'])
- * await execBin('/usr/local/bin/node', ['script.js'], { cwd: '/tmp' })
- * ```
- */
-export declare function execBin(binPath: string, args?: string[], options?: import('./spawn').SpawnOptions): Promise<{
-    cmd: string;
-    args: string[] | readonly string[];
-    code: number;
-    signal: NodeJS.Signals | null;
-    stdout: string | Buffer;
-    stderr: string | Buffer;
-}>;
-/**
- * Find the real executable for a binary, bypassing shadow bins.
- *
- * @example
- * ```typescript
- * const npmPath = findRealBin('npm', ['/usr/local/bin/npm'])
- * const gitPath = findRealBin('git')
- * ```
- */
-export declare function findRealBin(binName: string, commonPaths?: string[]): string | undefined;
-/**
- * Find the real npm executable, bypassing any aliases and shadow bins.
- *
- * @example
- * ```typescript
- * const npmPath = findRealNpm()
- * // e.g. '/usr/local/bin/npm'
- * ```
- */
-export declare function findRealNpm(): string;
-/**
- * Find the real pnpm executable, bypassing any aliases and shadow bins.
- *
- * @example
- * ```typescript
- * const pnpmPath = findRealPnpm()
- * // e.g. '/usr/local/bin/pnpm'
- * ```
- */
-export declare function findRealPnpm(): string;
-/**
- * Find the real yarn executable, bypassing any aliases and shadow bins.
- *
- * @example
- * ```typescript
- * const yarnPath = findRealYarn()
- * // e.g. '/usr/local/bin/yarn'
- * ```
- */
-export declare function findRealYarn(): string;
-/**
- * Check if a directory path contains any shadow bin patterns.
- *
- * @example
- * ```typescript
- * isShadowBinPath('/tmp/project/node_modules/.bin')  // true
- * isShadowBinPath('/usr/local/bin')                   // false
- * ```
- */
-export declare function isShadowBinPath(dirPath: string | undefined): boolean;
-/**
- * Resolve a binary path to the real underlying script file.
- * Handles Windows .cmd wrappers and Unix shell scripts, resolving them to the actual .js files they execute.
- *
- * @example
- * ```typescript
- * const realPath = resolveRealBinSync('/usr/local/bin/npm')
- * // e.g. '/usr/local/lib/node_modules/npm/bin/npm-cli.js'
- * ```
- */
-export declare function resolveRealBinSync(binPath: string): string;
-/**
- * Find an executable in the system PATH asynchronously.
- *
- * This function resolves binary names to their full paths by searching the system PATH.
- * It should only be used for binary names (not paths). If the input is already a path
- * (absolute or relative), it will be returned as-is without PATH resolution.
- *
- * Binary name vs. path detection:
- * - Binary names: 'npm', 'git', 'node' - will be resolved via PATH
- * - Absolute paths: '/usr/bin/node', 'C:\\Program Files\\nodejs\\node.exe' - returned as-is
- * - Relative paths: './node', '../bin/npm' - returned as-is
- *
- * @param {string} binName - The binary name to resolve (e.g., 'npm', 'git')
- * @param {WhichOptions | undefined} options - Options for resolution
- * @returns {Promise<string | string[] | null>} Promise resolving to the full path, the original path, or null if not found
- *
- * @example
- * ```typescript
- * // Resolve binary names
- * await which('node')              // '/usr/local/bin/node'
- * await which('npm')               // '/usr/local/bin/npm'
- * await which('nonexistent')       // null
- *
- * // Paths are returned as-is
- * await which('/usr/bin/node')     // '/usr/bin/node'
- * await which('./local-script')    // './local-script'
- * ```
- */
-export declare function which(binName: string, options?: WhichOptions): Promise<string | string[] | null>;
-/**
- * Find a binary in the system PATH and resolve to the real underlying script asynchronously.
- * Resolves wrapper scripts (.cmd, .ps1, shell scripts) to the actual .js files they execute.
- * @throws {Error} If the binary is not found and nothrow is false.
- *
- * @example
- * ```typescript
- * const npmPath = await whichReal('npm')
- * // e.g. '/usr/local/lib/node_modules/npm/bin/npm-cli.js'
- * ```
- */
-export declare function whichReal(binName: string, options?: WhichOptions): Promise<string | string[] | undefined>;
-/**
- * Find a binary in the system PATH and resolve to the real underlying script synchronously.
- * Resolves wrapper scripts (.cmd, .ps1, shell scripts) to the actual .js files they execute.
- * @throws {Error} If the binary is not found and nothrow is false.
- *
- * @example
- * ```typescript
- * const npmPath = whichRealSync('npm')
- * // e.g. '/usr/local/lib/node_modules/npm/bin/npm-cli.js'
- * ```
- */
-export declare function whichRealSync(binName: string, options?: WhichOptions): string | string[] | undefined;
-/**
- * Find an executable in the system PATH synchronously.
- *
- * This function resolves binary names to their full paths by searching the system PATH.
- * It should only be used for binary names (not paths). If the input is already a path
- * (absolute or relative), it will be returned as-is without PATH resolution.
- *
- * Binary name vs. path detection:
- * - Binary names: 'npm', 'git', 'node' - will be resolved via PATH
- * - Absolute paths: '/usr/bin/node', 'C:\\Program Files\\nodejs\\node.exe' - returned as-is
- * - Relative paths: './node', '../bin/npm' - returned as-is
- *
- * @param {string} binName - The binary name to resolve (e.g., 'npm', 'git')
- * @param {WhichOptions | undefined} options - Options for resolution
- * @returns {string | string[] | null} The full path to the binary, the original path if input is a path, or null if not found
- *
- * @example
- * ```typescript
- * // Resolve binary names
- * whichSync('node')              // '/usr/local/bin/node'
- * whichSync('npm')               // '/usr/local/bin/npm'
- * whichSync('nonexistent')       // null
- *
- * // Paths are returned as-is
- * whichSync('/usr/bin/node')     // '/usr/bin/node'
- * whichSync('./local-script')    // './local-script'
- * ```
- */
-export declare function whichSync(binName: string, options?: WhichOptions): string | string[] | null;