@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/cacache.js

@@ -1,156 +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 cacache_exports = {};
-__export(cacache_exports, {
-  clear: () => clear,
-  get: () => get,
-  getCacache: () => getCacache,
-  put: () => put,
-  remove: () => remove,
-  safeGet: () => safeGet,
-  withTmp: () => withTmp
-});
-module.exports = __toCommonJS(cacache_exports);
-var import_cacache = __toESM(require("./external/cacache"));
-var import_socket = require("./paths/socket");
-var import_primordials = require("./primordials");
-function createPatternMatcher(pattern) {
-  if (!pattern.includes("*")) {
-    return (key) => (0, import_primordials.StringPrototypeStartsWith)(key, pattern);
-  }
-  const escaped = (0, import_primordials.StringPrototypeReplaceAll)(
-    pattern,
-    /[.+?^${}()|[\]\\]/g,
-    "\\$&"
-  );
-  const regexPattern = (0, import_primordials.StringPrototypeReplaceAll)(escaped, "*", ".*");
-  const regex = new import_primordials.RegExpCtor(`^${regexPattern}$`);
-  return (key) => (0, import_primordials.RegExpPrototypeTest)(regex, key);
-}
-async function clear(options) {
-  const opts = { __proto__: null, ...options };
-  const cacache2 = getCacache();
-  const cacheDir = (0, import_socket.getSocketCacacheDir)();
-  if (!opts.prefix) {
-    try {
-      await cacache2.rm.all(cacheDir);
-      return;
-    } catch (e) {
-      if (e?.code !== "ENOTEMPTY") {
-        throw e;
-      }
-      return;
-    }
-  }
-  const hasWildcard = opts.prefix.includes("*");
-  if (!hasWildcard) {
-    let removed2 = 0;
-    const stream2 = cacache2.ls.stream(cacheDir);
-    for await (const entry of stream2) {
-      if (entry.key.startsWith(opts.prefix)) {
-        try {
-          await cacache2.rm.entry(cacheDir, entry.key);
-          removed2++;
-        } catch {
-        }
-      }
-    }
-    return removed2;
-  }
-  let removed = 0;
-  const matches = createPatternMatcher(opts.prefix);
-  const stream = cacache2.ls.stream(cacheDir);
-  for await (const entry of stream) {
-    if (matches(entry.key)) {
-      try {
-        await cacache2.rm.entry(cacheDir, entry.key);
-        removed++;
-      } catch {
-      }
-    }
-  }
-  return removed;
-}
-async function get(key, options) {
-  if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-    throw new import_primordials.TypeErrorCtor(
-      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
-    );
-  }
-  const cacache2 = getCacache();
-  return await cacache2.get((0, import_socket.getSocketCacacheDir)(), key, options);
-}
-function getCacache() {
-  return import_cacache.default;
-}
-async function put(key, data, options) {
-  if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-    throw new import_primordials.TypeErrorCtor(
-      'Cache key cannot contain wildcards (*). Wildcards are only supported in clear({ prefix: "pattern*" }).'
-    );
-  }
-  const cacache2 = getCacache();
-  return await cacache2.put((0, import_socket.getSocketCacacheDir)(), key, data, options);
-}
-async function remove(key) {
-  if ((0, import_primordials.StringPrototypeIncludes)(key, "*")) {
-    throw new import_primordials.TypeErrorCtor(
-      'Cache key cannot contain wildcards (*). Use clear({ prefix: "pattern*" }) to remove multiple entries.'
-    );
-  }
-  const cacache2 = getCacache();
-  return await cacache2.rm.entry((0, import_socket.getSocketCacacheDir)(), key);
-}
-async function safeGet(key, options) {
-  try {
-    return await get(key, options);
-  } catch {
-    return void 0;
-  }
-}
-async function withTmp(callback) {
-  const cacache2 = getCacache();
-  return await cacache2.tmp.withTmp(
-    (0, import_socket.getSocketCacacheDir)(),
-    {},
-    callback
-  );
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  clear,
-  get,
-  getCacache,
-  put,
-  remove,
-  safeGet,
-  withTmp
-});

package/dist/cache-with-ttl.d.ts

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Generic TTL-based caching utility using cacache.
- *
- * Provides a simple interface for caching data with time-to-live (TTL) expiration.
- * Uses cacache for persistent storage with metadata for TTL tracking.
- *
- * Features:
- * - Automatic expiration based on TTL
- * - In-memory memoization for hot data
- * - Persistent storage across process restarts
- * - Type-safe with generics
- *
- * Usage:
- * ```ts
- * const cache = createTtlCache({ ttl: 5 * 60 * 1000 }) // 5 minutes
- * const data = await cache.getOrFetch('key', async () => fetchData())
- * ```
- */
-export interface ClearOptions {
-    /**
-     * Only clear in-memory memoization cache, not persistent cache.
-     * Useful for forcing a refresh of cached data without removing it from disk.
-     *
-     * @default false
-     */
-    memoOnly?: boolean | undefined;
-}
-export interface TtlCache {
-    /**
-     * Get cached data without fetching.
-     * Returns undefined if not found or expired.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     * @throws {TypeError} If key contains wildcards (*)
-     */
-    get<T>(key: string): Promise<T | undefined>;
-    /**
-     * Get all cached entries matching a pattern.
-     * Supports wildcards (*) for flexible matching.
-     *
-     * @param pattern - Key pattern (supports * wildcards, or use '*' for all entries)
-     * @returns Map of matching entries (key -> value)
-     *
-     * @example
-     * // Get all organization entries
-     * const orgs = await cache.getAll<OrgData>('organizations:*')
-     * for (const [key, org] of orgs) {
-     *   console.log(`${key}: ${org.name}`)
-     * }
-     *
-     * @example
-     * // Get all entries with this cache's prefix
-     * const all = await cache.getAll<unknown>('*')
-     */
-    getAll<T>(pattern: string): Promise<Map<string, T>>;
-    /**
-     * Get cached data or fetch and cache if missing/expired.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     */
-    getOrFetch<T>(key: string, fetcher: () => Promise<T>): Promise<T>;
-    /**
-     * Set cached data with TTL.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     * @throws {TypeError} If key contains wildcards (*)
-     */
-    set<T>(key: string, data: T): Promise<void>;
-    /**
-     * Delete a specific cache entry.
-     *
-     * @param key - Cache key (must not contain wildcards)
-     * @throws {TypeError} If key contains wildcards (*)
-     */
-    delete(key: string): Promise<void>;
-    /**
-     * Delete all cache entries matching a pattern.
-     * Supports wildcards (*) for flexible matching.
-     *
-     * @param pattern - Key pattern (supports * wildcards, or omit to delete all)
-     * @returns Number of entries deleted
-     *
-     * @example
-     * // Delete all entries with this cache's prefix
-     * await cache.deleteAll()
-     *
-     * @example
-     * // Delete entries matching prefix
-     * await cache.deleteAll('organizations')
-     *
-     * @example
-     * // Delete entries with wildcard pattern
-     * await cache.deleteAll('scans:abc*')
-     * await cache.deleteAll('npm/lodash/*')
-     */
-    deleteAll(pattern?: string | undefined): Promise<number>;
-    /**
-     * Clear all cache entries (like Map.clear()).
-     * Optionally clear only in-memory cache.
-     *
-     * @param options - Optional configuration
-     * @param options.memoOnly - If true, only clears in-memory cache
-     *
-     * @example
-     * // Clear everything (memory + disk)
-     * await cache.clear()
-     *
-     * @example
-     * // Clear only in-memory cache (force refresh)
-     * await cache.clear({ memoOnly: true })
-     */
-    clear(options?: ClearOptions | undefined): Promise<void>;
-}
-export interface TtlCacheEntry<T> {
-    data: T;
-    expiresAt: number;
-}
-export interface TtlCacheOptions {
-    /**
-     * Time-to-live in milliseconds.
-     * @default 5 * 60 * 1000 (5 minutes)
-     */
-    ttl?: number | undefined;
-    /**
-     * Enable in-memory memoization for hot data.
-     * @default true
-     */
-    memoize?: boolean | undefined;
-    /**
-     * Maximum number of entries to keep in the in-memory memo cache. When
-     * exceeded, the least-recently-used entry is evicted. The persistent
-     * (cacache) layer is unaffected.
-     * @default 1000
-     */
-    memoMaxSize?: number | undefined;
-    /**
-     * Custom cache key prefix.
-     * Must not contain wildcards (*).
-     * Use clear({ prefix: "pattern*" }) for wildcard matching instead.
-     *
-     * @default 'ttl-cache'
-     * @throws {TypeError} If prefix contains wildcards
-     *
-     * @example
-     * // Valid
-     * createTtlCache({ prefix: 'socket-sdk' })
-     * createTtlCache({ prefix: 'my-app:cache' })
-     *
-     * @example
-     * // Invalid - throws TypeError
-     * createTtlCache({ prefix: 'socket-*' })
-     */
-    prefix?: string | undefined;
-}
-/**
- * Create a TTL-based cache instance.
- *
- * @example
- * ```typescript
- * const cache = createTtlCache({ ttl: 60_000, prefix: 'my-app' })
- * await cache.set('key', { value: 42 })
- * const data = await cache.get('key') // { value: 42 }
- * ```
- */
-export declare function createTtlCache(options?: TtlCacheOptions): TtlCache;

package/dist/colors.d.ts

@@ -1,49 +0,0 @@
-/**
- * @fileoverview Color utilities for RGB color conversion and manipulation.
- * Provides type-safe color handling with named colors and RGB tuples.
- */
-/**
- * Special 'inherit' color value that uses the current color context.
- * Used with effects like shimmer to dynamically inherit color.
- */
-export type ColorInherit = 'inherit';
-/**
- * Named color values supported by the library.
- * Maps to standard terminal colors with bright variants.
- */
-export type ColorName = 'black' | 'blue' | 'blueBright' | 'cyan' | 'cyanBright' | 'gray' | 'green' | 'greenBright' | 'magenta' | 'magentaBright' | 'red' | 'redBright' | 'white' | 'whiteBright' | 'yellow' | 'yellowBright';
-/**
- * RGB color tuple with values 0-255 for red, green, and blue channels.
- * @example [140, 82, 255] // Socket purple
- * @example [255, 0, 0]    // Red
- */
-export type ColorRgb = readonly [number, number, number];
-/**
- * Union of all supported color types: named colors or RGB tuples.
- */
-export type ColorValue = ColorName | ColorRgb;
-/**
- * Type guard to check if a color value is an RGB tuple.
- * @param value - Color value to check
- * @returns `true` if value is an RGB tuple, `false` if it's a color name
- *
- * @example
- * ```typescript
- * isRgbTuple([255, 0, 0]) // true
- * isRgbTuple('red')       // false
- * ```
- */
-export declare function isRgbTuple(value: ColorValue): value is ColorRgb;
-/**
- * Convert a color value to RGB tuple format.
- * Named colors are looked up in the `colorToRgb` map, RGB tuples are returned as-is.
- * @param color - Color name or RGB tuple
- * @returns RGB tuple with values 0-255
- *
- * @example
- * ```typescript
- * toRgb('red')       // [255, 0, 0]
- * toRgb([0, 128, 0]) // [0, 128, 0]
- * ```
- */
-export declare function toRgb(color: ColorValue): ColorRgb;

package/dist/constants/process.d.ts

@@ -1,20 +0,0 @@
-/**
- * @fileoverview Process control helpers.
- * Lazily creates and exposes a shared `AbortController` and its `AbortSignal`
- * so cooperating modules can coordinate cancellation from a single source.
- */
-/**
- * Get the process-scoped shared `AbortController` singleton.
- * Cooperating modules use this to coordinate cancellation across the library.
- *
- * @returns The lazily-created shared `AbortController` instance.
- */
-export declare function getAbortController(): AbortController;
-/**
- * Get the process-scoped shared `AbortSignal` singleton.
- * This is the `signal` property of {@link getAbortController}'s controller and
- * is intended to be passed to APIs that accept an `AbortSignal`.
- *
- * @returns The shared `AbortSignal` instance.
- */
-export declare function getAbortSignal(): AbortSignal;

package/dist/crypto.d.ts

@@ -1,36 +0,0 @@
-/**
- * @fileoverview Crypto helpers that prefer Node builtins where available.
- */
-/**
- * Resolve `crypto.hash` (or `undefined` if the runtime predates it).
- *
- * Exported for unit tests; not part of the public API.
- *
- * @internal
- */
-export declare function getNativeHash(): typeof import('node:crypto').hash | undefined;
-/**
- * Compute a one-shot cryptographic hash.
- *
- * Prefers Node's `crypto.hash(algorithm, data, outputEncoding)` (added
- * v21.7.0 / v20.12.0), which is ~30% faster than the
- * `createHash().update().digest()` chain on small-to-medium inputs
- * because it skips constructing the streaming `Hash` object. Falls
- * back to that chain on older runtimes.
- *
- * Use this only for the one-shot case where the entire input is
- * available as a single buffer or string; if you need to feed chunks,
- * stay on `createHash()`.
- *
- * @example
- * ```typescript
- * import { hash } from '@socketsecurity/lib/crypto'
- *
- * hash('sha256', 'hello', 'hex')
- * // '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824'
- *
- * hash('sha512', someBuffer, 'base64')
- * // 'z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg=='
- * ```
- */
-export declare function hash(algorithm: string, data: string | NodeJS.ArrayBufferView, outputEncoding: 'hex' | 'base64' | 'base64url' | 'binary'): string;