@socketsecurity/lib 6.0.5 → 6.0.7

package/dist/argv/flag-types.d.ts

@@ -8,22 +8,22 @@
  */
 export interface FlagValues {
     [key: string]: unknown;
-    quiet?: boolean;
-    silent?: boolean;
-    verbose?: boolean;
-    help?: boolean;
-    all?: boolean;
-    fix?: boolean;
-    force?: boolean;
-    'dry-run'?: boolean;
-    json?: boolean;
-    debug?: boolean;
-    watch?: boolean;
-    coverage?: boolean;
-    cover?: boolean;
-    update?: boolean;
-    staged?: boolean;
-    changed?: boolean;
+    quiet?: boolean | undefined;
+    silent?: boolean | undefined;
+    verbose?: boolean | undefined;
+    help?: boolean | undefined;
+    all?: boolean | undefined;
+    fix?: boolean | undefined;
+    force?: boolean | undefined;
+    'dry-run'?: boolean | undefined;
+    json?: boolean | undefined;
+    debug?: boolean | undefined;
+    watch?: boolean | undefined;
+    coverage?: boolean | undefined;
+    cover?: boolean | undefined;
+    update?: boolean | undefined;
+    staged?: boolean | undefined;
+    changed?: boolean | undefined;
 }
 /**
  * Accepted input types for flag checking functions. Can be parsed flag values,
@@ -45,12 +45,12 @@ export declare const COMMON_FLAGS: {
         default: boolean;
         description: string;
     };
-    coverage: {
+    cover: {
         type: 'boolean';
         default: boolean;
         description: string;
     };
-    cover: {
+    coverage: {
         type: 'boolean';
         default: boolean;
         description: string;

package/dist/argv/flag-types.js

@@ -18,15 +18,15 @@ const COMMON_FLAGS = {
 		default: false,
 		description: "Target changed files"
 	},
-	coverage: {
+	cover: {
 		type: "boolean",
 		default: false,
-		description: "Run with coverage"
+		description: "Run with coverage (alias)"
 	},
-	cover: {
+	coverage: {
 		type: "boolean",
 		default: false,
-		description: "Run with coverage (alias)"
+		description: "Run with coverage"
 	},
 	debug: {
 		type: "boolean",

package/dist/argv/parse.d.ts

@@ -8,7 +8,7 @@
  */
 interface YargsArguments extends Record<string, unknown> {
     _: string[];
-    $0?: string;
+    $0?: string | undefined;
 }
 /**
  * Options for configuring argument parsing, similar to Node.js util.parseArgs.

package/dist/arrays/_internal.js

@@ -1,6 +1,7 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_intl = require('../primordials/intl.js');
 
 //#region src/arrays/_internal.ts
 /**
@@ -8,8 +9,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *   instances for conjunction (and) and disjunction (or) joins. Constructed
 *   lazily because `new Intl.ListFormat(...)` is a measurable startup cost.
 */
-let _conjunctionFormatter;
-let _disjunctionFormatter;
+let conjunctionFormatter;
+let disjunctionFormatter;
 /**
 * Get a cached Intl.ListFormat instance for conjunction (and) formatting.
 *
@@ -28,15 +29,14 @@ let _disjunctionFormatter;
 * @returns Cached Intl.ListFormat instance configured for conjunction
 *   formatting.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function getConjunctionFormatter() {
-	if (_conjunctionFormatter === void 0)
- /* c8 ignore start */
-	_conjunctionFormatter = new Intl.ListFormat("en", {
+	if (conjunctionFormatter === void 0)
+ /* c8 ignore start - lazy singleton init runs once; not worth a dedicated test */
+	conjunctionFormatter = new require_primordials_intl.IntlListFormat("en", {
 		style: "long",
 		type: "conjunction"
 	});
-	return _conjunctionFormatter;
+	return conjunctionFormatter;
 }
 /**
 * Get a cached Intl.ListFormat instance for disjunction (or) formatting.
@@ -56,15 +56,14 @@ function getConjunctionFormatter() {
 * @returns Cached Intl.ListFormat instance configured for disjunction
 *   formatting.
 */
-/* @__NO_SIDE_EFFECTS__ */
 function getDisjunctionFormatter() {
-	if (_disjunctionFormatter === void 0)
- /* c8 ignore start */
-	_disjunctionFormatter = new Intl.ListFormat("en", {
+	if (disjunctionFormatter === void 0)
+ /* c8 ignore start - lazy singleton init runs once; not worth a dedicated test */
+	disjunctionFormatter = new require_primordials_intl.IntlListFormat("en", {
 		style: "long",
 		type: "disjunction"
 	});
-	return _disjunctionFormatter;
+	return disjunctionFormatter;
 }
 
 //#endregion

package/dist/arrays/chunk.js

@@ -40,7 +40,6 @@ const require_primordials_error = require('../primordials/error.js');
 *
 * @throws {Error} If chunk size is less than or equal to 0
 */
-/* @__NO_SIDE_EFFECTS__ */
 function arrayChunk(arr, size) {
 	const chunkSize = size ?? 2;
 	if (chunkSize <= 0) throw new require_primordials_error.ErrorCtor("Chunk size must be greater than 0");

package/dist/arrays/join.d.ts

@@ -1,13 +1,17 @@
 /**
  * @file Grammatical list joiners via `Intl.ListFormat` — Oxford-comma aware and
- *   locale-correct. `joinAnd` ("a, b, and c"), `joinOr` ("a, b, or c").
+ *   locale-correct. `joinList` (generalized), `joinAnd` ("a, b, and c"),
+ *   `joinOr` ("a, b, or c").
  */
+export interface JoinListOptions {
+    with?: string | undefined;
+}
 /**
  * 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.
+ * Oxford comma support. Delegates to `joinList`.
  *
  * @example
  *   ```ts
@@ -38,12 +42,42 @@
  * @returns Formatted string with proper "and" conjunction
  */
 export declare function joinAnd(arr: string[] | readonly string[]): string;
+/**
+ * Generalized list joiner covering bare join, comma-list, and
+ * conjunction/disjunction via `Intl.ListFormat`.
+ *
+ * - No options: bare concatenation (`'abc'`)
+ * - `{ with: 'and' }`: Oxford-comma "and" list via `Intl.ListFormat` (`'a, b, and
+ *   c'`)
+ * - `{ with: 'or' }`: Oxford-comma "or" list via `Intl.ListFormat` (`'a, b, or
+ *   c'`)
+ * - `{ with: <any other string> }`: `items.join(sep)` — e.g. `','` → `'a,b,c'`,
+ *   `', '` → `'a, b, c'`, `' '` → `'a b c'`
+ *
+ * Each item is coerced via `String()` before formatting.
+ *
+ * @example
+ *   ;```ts
+ *   joinList(['a', 'b', 'c'])                  // 'abc'
+ *   joinList(['a', 'b', 'c'], { with: ', ' })  // 'a, b, c'
+ *   joinList(['a', 'b', 'c'], { with: ' ' })   // 'a b c'
+ *   joinList(['a', 'b', 'c'], { with: 'and' }) // 'a, b, and c'
+ *   joinList(['a', 'b', 'c'], { with: 'or' })  // 'a, b, or c'
+ *   joinList([1, 2, 3], { with: 'and' })        // '1, 2, and 3'
+ *   ```
+ *
+ * @param items - Items to join (can be readonly, any type)
+ * @param options - Formatting options (optional)
+ *
+ * @returns Formatted string
+ */
+export declare function joinList(items: readonly unknown[], options?: JoinListOptions): 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.
+ * Oxford comma support. Delegates to `joinList`.
  *
  * @example
  *   ```ts

package/dist/arrays/join.js

@@ -6,14 +6,15 @@ const require_arrays__internal = require('./_internal.js');
 //#region src/arrays/join.ts
 /**
 * @file Grammatical list joiners via `Intl.ListFormat` — Oxford-comma aware and
-*   locale-correct. `joinAnd` ("a, b, and c"), `joinOr` ("a, b, or c").
+*   locale-correct. `joinList` (generalized), `joinAnd` ("a, b, and c"),
+*   `joinOr` ("a, b, or c").
 */
 /**
 * 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.
+* Oxford comma support. Delegates to `joinList`.
 *
 * @example
 *   ```ts
@@ -43,16 +44,51 @@ const require_arrays__internal = require('./_internal.js');
 *
 * @returns Formatted string with proper "and" conjunction
 */
-/* @__NO_SIDE_EFFECTS__ */
 function joinAnd(arr) {
-	return (/* @__PURE__ */ require_arrays__internal.getConjunctionFormatter()).format(arr);
+	return joinList(arr, { with: "and" });
+}
+/**
+* Generalized list joiner covering bare join, comma-list, and
+* conjunction/disjunction via `Intl.ListFormat`.
+*
+* - No options: bare concatenation (`'abc'`)
+* - `{ with: 'and' }`: Oxford-comma "and" list via `Intl.ListFormat` (`'a, b, and
+*   c'`)
+* - `{ with: 'or' }`: Oxford-comma "or" list via `Intl.ListFormat` (`'a, b, or
+*   c'`)
+* - `{ with: <any other string> }`: `items.join(sep)` — e.g. `','` → `'a,b,c'`,
+*   `', '` → `'a, b, c'`, `' '` → `'a b c'`
+*
+* Each item is coerced via `String()` before formatting.
+*
+* @example
+*   ;```ts
+*   joinList(['a', 'b', 'c'])                  // 'abc'
+*   joinList(['a', 'b', 'c'], { with: ', ' })  // 'a, b, c'
+*   joinList(['a', 'b', 'c'], { with: ' ' })   // 'a b c'
+*   joinList(['a', 'b', 'c'], { with: 'and' }) // 'a, b, and c'
+*   joinList(['a', 'b', 'c'], { with: 'or' })  // 'a, b, or c'
+*   joinList([1, 2, 3], { with: 'and' })        // '1, 2, and 3'
+*   ```
+*
+* @param items - Items to join (can be readonly, any type)
+* @param options - Formatting options (optional)
+*
+* @returns Formatted string
+*/
+function joinList(items, options) {
+	const w = options?.with;
+	if (w === "and") return require_arrays__internal.getConjunctionFormatter().format(items.map(String));
+	if (w === "or") return require_arrays__internal.getDisjunctionFormatter().format(items.map(String));
+	if (w !== void 0) return items.map(String).join(w);
+	return items.map(String).join("");
 }
 /**
 * 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.
+* Oxford comma support. Delegates to `joinList`.
 *
 * @example
 *   ```ts
@@ -82,11 +118,11 @@ function joinAnd(arr) {
 *
 * @returns Formatted string with proper "or" disjunction
 */
-/* @__NO_SIDE_EFFECTS__ */
 function joinOr(arr) {
-	return (/* @__PURE__ */ require_arrays__internal.getDisjunctionFormatter()).format(arr);
+	return joinList(arr, { with: "or" });
 }
 
 //#endregion
 exports.joinAnd = joinAnd;
+exports.joinList = joinList;
 exports.joinOr = joinOr;

package/dist/arrays/unique.js

@@ -39,7 +39,6 @@ const require_primordials_map_set = require('../primordials/map-set.js');
 *
 * @returns New array with duplicate values removed
 */
-/* @__NO_SIDE_EFFECTS__ */
 function arrayUnique(arr) {
 	return [...new require_primordials_map_set.SetCtor(arr)];
 }

package/dist/bin/_internal.d.ts

@@ -2,7 +2,7 @@
  * @file Private internals for `bin/*` modules — lazy `fs` / `path` accessors
  *   and the binary-resolution caches. Underscore prefix keeps this file out of
  *   the public exports map (see the `dist/<dir>/_<file>` ignore in
- *   scripts/fix/generate-package-exports.mts). Two caches:
+ *   scripts/post-build/make-package-exports.mts). Two caches:
  *
  *   1. `binPathCache` — maps a binary name to its first resolved path. Validated
  *      with `existsSync` before reuse so a stale cache doesn't survive a tool

package/dist/bin/_internal.js

@@ -10,7 +10,7 @@ const require_node_path = require('../node/path.js');
 * @file Private internals for `bin/*` modules — lazy `fs` / `path` accessors
 *   and the binary-resolution caches. Underscore prefix keeps this file out of
 *   the public exports map (see the `dist/<dir>/_<file>` ignore in
-*   scripts/fix/generate-package-exports.mts). Two caches:
+*   scripts/post-build/make-package-exports.mts). Two caches:
 *
 *   1. `binPathCache` — maps a binary name to its first resolved path. Validated
 *      with `existsSync` before reuse so a stale cache doesn't survive a tool