@pawells/typescript-common 2.0.0 → 2.1.5

package/{build → dist}/array/assert.d.ts

@@ -59,7 +59,7 @@ export interface IAssertArray2DArgs {
 }
 /**
  * Asserts that a value is an array, optionally validating its size.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional size constraints.
  * @param exception - Optional custom exception to throw.
@@ -68,7 +68,7 @@ export interface IAssertArray2DArgs {
 export declare function AssertArray<T = unknown>(value: unknown, args?: IAssertArrayArgs, exception?: IAssertException): asserts value is T[];
 /**
  * Asserts that a value is a 2D array, optionally validating its dimensions.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional dimension constraints.
  * @param exception - Optional custom exception to throw.
@@ -77,7 +77,7 @@ export declare function AssertArray<T = unknown>(value: unknown, args?: IAssertA
 export declare function AssertArray2D<T = unknown>(value: unknown, args?: IAssertArray2DArgs, exception?: IAssertException): asserts value is T[][];
 /**
  * Asserts that an array is not empty.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The array to validate.
  * @param exception - Optional custom exception to throw.
  * @throws {ArrayError} If the array is empty.
@@ -89,7 +89,7 @@ export declare function AssertArrayNotEmpty<T>(value: T[] | unknown, exception?:
  * Uses `array.every()` to check if all elements satisfy the predicate condition.
  * Throws an error if any element fails the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.
@@ -102,7 +102,7 @@ export declare function AssertArrayAll<T>(array: T[], predicate: (el: T, idx: nu
  * Uses `array.some()` to check if any element satisfies the predicate condition.
  * Throws an error if no elements pass the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.

package/{build → dist}/array/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/array/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,WAAW;gBAC9B,OAAO,CAAC,EAAE,MAAM;CAG5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,gBAAgB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CA2BxI;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,kBAAuB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,EAAE,CAoElJ;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CAYnH;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/array/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,WAAW;gBAC9B,OAAO,CAAC,EAAE,MAAM;CAG5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,gBAAgB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CA2BxI;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,kBAAuB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,EAAE,CAqElJ;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CAYnH;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I"}

package/{build → dist}/array/assert.js

@@ -13,7 +13,7 @@ export class ArrayError extends SimpleError {
 }
 /**
  * Asserts that a value is an array, optionally validating its size.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional size constraints.
  * @param exception - Optional custom exception to throw.
@@ -44,7 +44,7 @@ export function AssertArray(value, args, exception = {}) {
 }
 /**
  * Asserts that a value is a 2D array, optionally validating its dimensions.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional dimension constraints.
  * @param exception - Optional custom exception to throw.
@@ -57,14 +57,14 @@ export function AssertArray2D(value, args = {}, exception = {}) {
     AssertValueType(value, 'array', exception);
     // Type cast is safe after array validation
     const array = value;
-    // Validate that all elements are arrays (making it 2D)
-    if (!array.every((row) => Array.isArray(row))) {
-        let invalidPositions = array.map((row, idx) => {
-            if (!Array.isArray(row))
-                return idx;
-            return null;
-        });
-        invalidPositions = invalidPositions.filter((idx) => idx !== null);
+    // Validate that all elements are arrays (making it 2D) with single-pass collection of invalid positions
+    const invalidPositions = [];
+    for (let i = 0; i < array.length; i++) {
+        if (!Array.isArray(array[i])) {
+            invalidPositions.push(i);
+        }
+    }
+    if (invalidPositions.length > 0) {
         SetExceptionMessage(exception, `Expected 2D array but found non-array elements at positions: ${invalidPositions.join(', ')}`);
         ThrowException(exception);
     }
@@ -111,7 +111,7 @@ export function AssertArray2D(value, args = {}, exception = {}) {
 }
 /**
  * Asserts that an array is not empty.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The array to validate.
  * @param exception - Optional custom exception to throw.
  * @throws {ArrayError} If the array is empty.
@@ -141,7 +141,7 @@ function assertIsArray(array, exception) {
  * Uses `array.every()` to check if all elements satisfy the predicate condition.
  * Throws an error if any element fails the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.
@@ -161,7 +161,7 @@ export function AssertArrayAll(array, predicate, exception = {}) {
  * Uses `array.some()` to check if any element satisfies the predicate condition.
  * Throws an error if no elements pass the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.
@@ -175,4 +175,3 @@ export function AssertArrayAny(array, predicate, exception = {}) {
         ThrowException(exception);
     }
 }
-//# sourceMappingURL=assert.js.map

package/{build → dist}/array/index.js

@@ -23,4 +23,3 @@ export * from './array-sort-by.js';
 export * from './array-count-by.js';
 export * from './array-sample.js';
 export * from './assert.js';
-//# sourceMappingURL=index.js.map

package/{build → dist}/array/types.d.ts

@@ -35,9 +35,27 @@ export type TEqualityComparator<T> = (a: T, b: T) => boolean;
  *
  * @template T - The type of array elements
  */
+/**
+ * Comparison options for array operations.
+ *
+ * Provides a discriminated union where callers must choose exactly one strategy:
+ * - `comparator`: Custom equality function for specialized comparison logic
+ * - `useDeepEqual`: Deep structural equality checking
+ * - `keyFn`: Function to extract a primitive key for O(n+m) Set-based lookup
+ *
+ * Mutually exclusive at compile time via `never` literals.
+ */
 export type TArrayComparisonOptions<T> = {
-    comparator?: TEqualityComparator<T>;
+    comparator: TEqualityComparator<T>;
+    useDeepEqual?: never;
+    keyFn?: never;
+} | {
+    useDeepEqual: true;
+    comparator?: never;
+    keyFn?: never;
 } | {
-    useDeepEqual?: boolean;
+    keyFn: (item: T) => unknown;
+    comparator?: never;
+    useDeepEqual?: never;
 };
 //# sourceMappingURL=types.d.ts.map

package/{build → dist}/array/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/array/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAClC;IAAE,UAAU,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;CAAE,GACvC;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/array/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE7D;;;;;GAKG;AACH;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAClC;IAAE,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAAC,YAAY,CAAC,EAAE,KAAK,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAC3E;IAAE,YAAY,EAAE,IAAI,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GACzD;IAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAC;IAAC,YAAY,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC"}

package/dist/array/types.js

@@ -0,0 +1 @@
+export {};

package/{build → dist}/array/unique.d.ts

@@ -5,7 +5,7 @@
  *
  * @template T - The type of array elements
  * @param array - The input array
- * @returns A new array containing only unique values (preserves first occurrence order)
+ * @returns A new array containing only unique values (preserves first occurrence order). Returns `[]` if `array` is `null`, `undefined`, or empty.
  *
  * @remarks Uses reference equality for objects. Two distinct objects with
  * identical property values are **not** considered equal and will both be kept.

package/{build → dist}/array/unique.js

@@ -5,7 +5,7 @@
  *
  * @template T - The type of array elements
  * @param array - The input array
- * @returns A new array containing only unique values (preserves first occurrence order)
+ * @returns A new array containing only unique values (preserves first occurrence order). Returns `[]` if `array` is `null`, `undefined`, or empty.
  *
  * @remarks Uses reference equality for objects. Two distinct objects with
  * identical property values are **not** considered equal and will both be kept.
@@ -23,4 +23,3 @@ export function Unique(array) {
     }
     return [...new Set(array)];
 }
-//# sourceMappingURL=unique.js.map

package/dist/asserts/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/asserts/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAY,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAM3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,SAAU,SAAQ,KAAK;IACnC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,SAAgB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAE7D;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAkB5E;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAC7C;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG9D;AAED;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC5C;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG9D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGnF;AAED;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C;;;OAGG;gBACS,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGhE;AAED;;;;;;;;;GASG;AACH,qBAAa,aAAc,SAAQ,SAAS;IAC3C;;;OAGG;gBACS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG3D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG9D"}

package/{build → dist}/asserts/errors.js

@@ -55,9 +55,12 @@ export class BaseError extends Error {
         this.name = this.constructor.name;
         this.Code = code;
         this.Context = context;
-        if (typeof Error.captureStackTrace === 'function') {
-            Error.captureStackTrace(this, this.constructor);
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        const ErrorWithCapture = Error;
+        if (typeof ErrorWithCapture.captureStackTrace === 'function') {
+            ErrorWithCapture.captureStackTrace(this, this.constructor);
         }
+        /* eslint-enable @typescript-eslint/no-explicit-any */
     }
 }
 /**
@@ -173,4 +176,3 @@ export class BufferOverflowError extends BaseError {
         super(`Buffer overflow: maximum size ${maxSize} exceeded`, 'BUFFER_OVERFLOW', context);
     }
 }
-//# sourceMappingURL=errors.js.map

package/{build → dist}/asserts/generic.d.ts

@@ -1,5 +1,25 @@
 import type { IAssertException, TGuard, TValidationPredicate } from './types.js';
 import { SimpleError } from './errors.js';
+/**
+ * Serializes a value to a human-readable string, safe for any value type.
+ *
+ * Prevents sensitive data exposure in error messages by:
+ * - Masking object contents (shows type name only, not property values)
+ * - Truncating long strings with a clear indication
+ * - Handling non-serializable values gracefully
+ *
+ * @param value - The value to serialize for display
+ * @param maxLength - Maximum characters to display for primitives (default: 50, capped at 10,000)
+ * @returns A safe string representation (at most maxLength chars plus "[truncated]" suffix)
+ *
+ * @example
+ * safeDisplay({ apiKey: 'secret123', username: 'john' }); // '[Object]'
+ * safeDisplay('x'.repeat(100)); // 'xxx....[truncated]'
+ * safeDisplay(circularRef); // '[non-serializable]'
+ *
+ * @internal Used internally by assertion functions to safely display values in error messages
+ */
+export declare function safeDisplay(value: unknown, maxLength?: number): string;
 /**
  * Gets the display type of a value including null and undefined.
  * Used for error messages in null/undefined assertions and type checking.
@@ -13,7 +33,7 @@ export declare function GetValueType(value: unknown): string;
  * Type alias for constructor functions.
  * Represents any class constructor that can be instantiated.
  */
-export type TConstructorFunction<T = any> = new (...args: any[]) => T;
+export type TConstructorFunction<T = unknown> = new (...args: any[]) => T;
 /**
  * Error thrown when a nullish assertion fails — the value is not null or undefined
  * but was expected to be. Used by {@link AssertNull} when the provided value is a
@@ -403,7 +423,7 @@ export declare function AssertInstanceOf<T>(value: unknown, constructor: TConstr
  * AssertFunction(123); // ✗ Throws FunctionError
  * AssertFunction(null); // ✗ Throws FunctionError
  */
-export declare function AssertFunction(value: unknown, exception?: IAssertException): asserts value is (...args: any[]) => any;
+export declare function AssertFunction(value: unknown, exception?: IAssertException): asserts value is (...args: unknown[]) => unknown;
 /**
  * Asserts that a value is a symbol.
  *
@@ -440,5 +460,5 @@ export declare function AssertSymbol(value: unknown, exception?: IAssertExceptio
  * AssertExtends(Derived, Base); // ✓ Valid
  * AssertExtends(Base, Derived); // ✗ Throws ExtendsError
  */
-export declare function AssertExtends(derived: abstract new (...args: any[]) => any, base: abstract new (...args: any[]) => any, exception?: IAssertException): void;
+export declare function AssertExtends(derived: abstract new (...args: any[]) => unknown, base: abstract new (...args: any[]) => unknown, exception?: IAssertException): void;
 //# sourceMappingURL=generic.d.ts.map

package/dist/asserts/generic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/asserts/generic.ts"],"names":[],"mappings":"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"}

package/{build → dist}/asserts/generic.js

@@ -1,15 +1,41 @@
 import { ObjectEquals } from './internal-utils.js';
 import { SetExceptionClass, SetExceptionMessage, ThrowException } from './utils.js';
 import { AssertionError, SimpleError } from './errors.js';
-/** Maximum number of characters to include from a value in an error message. */
-const MAX_VALUE_DISPLAY_LENGTH = 100;
-/** Serialises a value to a human-readable string, safe for any value type. */
-function safeDisplay(value) {
+/**
+ * Serializes a value to a human-readable string, safe for any value type.
+ *
+ * Prevents sensitive data exposure in error messages by:
+ * - Masking object contents (shows type name only, not property values)
+ * - Truncating long strings with a clear indication
+ * - Handling non-serializable values gracefully
+ *
+ * @param value - The value to serialize for display
+ * @param maxLength - Maximum characters to display for primitives (default: 50, capped at 10,000)
+ * @returns A safe string representation (at most maxLength chars plus "[truncated]" suffix)
+ *
+ * @example
+ * safeDisplay({ apiKey: 'secret123', username: 'john' }); // '[Object]'
+ * safeDisplay('x'.repeat(100)); // 'xxx....[truncated]'
+ * safeDisplay(circularRef); // '[non-serializable]'
+ *
+ * @internal Used internally by assertion functions to safely display values in error messages
+ */
+export function safeDisplay(value, maxLength = 50) {
+    // Cap maxLength to prevent memory exhaustion from extremely large values
+    const effectiveMaxLength = Math.min(maxLength, 10_000);
+    // For objects, use type name instead of full serialization to avoid leaking structure
+    if (typeof value === 'object' && value !== null) {
+        return `[${Object.getPrototypeOf(value)?.constructor?.name ?? 'Object'}]`;
+    }
+    // For primitives, truncate with clear indication
     try {
-        return (JSON.stringify(value) ?? String(value)).slice(0, MAX_VALUE_DISPLAY_LENGTH);
+        const serialized = JSON.stringify(value) ?? String(value);
+        return serialized.length > effectiveMaxLength
+            ? serialized.slice(0, effectiveMaxLength) + '...[truncated]'
+            : serialized;
     }
     catch {
-        return String(value).slice(0, MAX_VALUE_DISPLAY_LENGTH);
+        return '[non-serializable]';
     }
 }
 /**
@@ -535,6 +561,7 @@ export function AssertSymbol(value, exception = {}) {
  * AssertExtends(Derived, Base); // ✓ Valid
  * AssertExtends(Base, Derived); // ✗ Throws ExtendsError
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function AssertExtends(derived, base, exception = {}) {
     SetExceptionClass(exception, ExtendsError);
     if (typeof derived !== 'function' || typeof base !== 'function') {
@@ -556,4 +583,3 @@ export function AssertExtends(derived, base, exception = {}) {
         ThrowException(exception);
     }
 }
-//# sourceMappingURL=generic.js.map

package/dist/asserts/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @module asserts
+ * @description Aggregation barrel for all assertion functions.
+ * Exports both generic assertion primitives (like AssertNull, AssertNotNull, AssertEquals, etc.)
+ * and domain-specific validators (AssertArray, AssertBoolean, AssertNumber, AssertObject, AssertString).
+ *
+ * Domain-specific assertions are re-exported here as a convenience so callers can import
+ * all assertion functions from a single entry point. They originate from their respective
+ * domain modules (array/, boolean/, number/, object/, string/).
+ *
+ * Note: Internal utility functions (SetExceptionClass, SetExceptionMessage, ThrowException,
+ * AssertValueType, safeDisplay, GetValueType) are NOT exported from this barrel as they are
+ * part of the internal assertion implementation contract and should not be relied upon by external code.
+ */
+/**
+ * Export all array assertion functions and types
+ */
+export * from '../array/assert.js';
+/**
+ * Export all boolean assertion functions and types
+ */
+export * from '../boolean/assert.js';
+/**
+ * Export generic assertion functions (but not internal utilities)
+ */
+export { AssertEquals, AssertNotEquals, AssertNull, AssertNotNull, AssertPredicate, AssertIsType, AssertInstanceOf, AssertFunction, AssertSymbol, AssertExtends, NullError, NotNullError, PredicateError, TypeGuardError, InstanceOfError, FunctionError, SymbolError, ExtendsError, type TConstructorFunction, } from './generic.js';
+/**
+ * Export all number assertion functions and types
+ */
+export * from '../number/assert.js';
+/**
+ * Export all object assertion functions and types
+ */
+export * from '../object/assert.js';
+/**
+ * Export all string assertion functions and types
+ */
+export * from '../string/assert.js';
+/**
+ * Export type definitions and interfaces
+ */
+export * from './types.js';
+/**
+ * Export error classes for standardized error handling
+ */
+export * from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/asserts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/asserts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,cAAc,oBAAoB,CAAC;AAEnC;;GAEG;AACH,cAAc,sBAAsB,CAAC;AAErC;;GAEG;AACH,OAAO,EACN,YAAY,EACZ,eAAe,EACf,UAAU,EACV,aAAa,EACb,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,SAAS,EACT,YAAY,EACZ,cAAc,EACd,cAAc,EACd,eAAe,EACf,aAAa,EACb,WAAW,EACX,YAAY,EACZ,KAAK,oBAAoB,GACzB,MAAM,cAAc,CAAC;AAEtB;;GAEG;AACH,cAAc,qBAAqB,CAAC;AAEpC;;GAEG;AACH,cAAc,qBAAqB,CAAC;AAEpC;;GAEG;AACH,cAAc,qBAAqB,CAAC;AAEpC;;GAEG;AACH,cAAc,YAAY,CAAC;AAE3B;;GAEG;AACH,cAAc,aAAa,CAAC"}

package/dist/asserts/index.js

@@ -0,0 +1,46 @@
+/**
+ * @module asserts
+ * @description Aggregation barrel for all assertion functions.
+ * Exports both generic assertion primitives (like AssertNull, AssertNotNull, AssertEquals, etc.)
+ * and domain-specific validators (AssertArray, AssertBoolean, AssertNumber, AssertObject, AssertString).
+ *
+ * Domain-specific assertions are re-exported here as a convenience so callers can import
+ * all assertion functions from a single entry point. They originate from their respective
+ * domain modules (array/, boolean/, number/, object/, string/).
+ *
+ * Note: Internal utility functions (SetExceptionClass, SetExceptionMessage, ThrowException,
+ * AssertValueType, safeDisplay, GetValueType) are NOT exported from this barrel as they are
+ * part of the internal assertion implementation contract and should not be relied upon by external code.
+ */
+/**
+ * Export all array assertion functions and types
+ */
+export * from '../array/assert.js';
+/**
+ * Export all boolean assertion functions and types
+ */
+export * from '../boolean/assert.js';
+/**
+ * Export generic assertion functions (but not internal utilities)
+ */
+export { AssertEquals, AssertNotEquals, AssertNull, AssertNotNull, AssertPredicate, AssertIsType, AssertInstanceOf, AssertFunction, AssertSymbol, AssertExtends, NullError, NotNullError, PredicateError, TypeGuardError, InstanceOfError, FunctionError, SymbolError, ExtendsError, } from './generic.js';
+/**
+ * Export all number assertion functions and types
+ */
+export * from '../number/assert.js';
+/**
+ * Export all object assertion functions and types
+ */
+export * from '../object/assert.js';
+/**
+ * Export all string assertion functions and types
+ */
+export * from '../string/assert.js';
+/**
+ * Export type definitions and interfaces
+ */
+export * from './types.js';
+/**
+ * Export error classes for standardized error handling
+ */
+export * from './errors.js';

package/{build → dist}/asserts/internal-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal-utils.d.ts","sourceRoot":"","sources":["../../src/asserts/internal-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAGxF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"internal-utils.d.ts","sourceRoot":"","sources":["../../src/asserts/internal-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AAEH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAGxF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/{build → dist}/asserts/internal-utils.js

@@ -3,4 +3,3 @@
  */
 // Single source of truth — the canonical implementation lives in the object module.
 export { ObjectEquals } from '../object/equals.js';
-//# sourceMappingURL=internal-utils.js.map

package/{build → dist}/asserts/types.d.ts

@@ -1,19 +1,4 @@
-import { TConstructableObject } from './internal-utils.js';
-/**
- * Type alias for constraint union patterns.
- * Represents common constraint combinations used across assertion modules.
- */
-export type TConstraintValue = string | number | boolean | null | undefined;
-/**
- * Type alias for comparison operators.
- * Represents the various comparison operations available in constraint validation.
- */
-export type TComparisonOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte';
-/**
- * Type alias for validation result patterns.
- * Represents the union of possible validation outcomes.
- */
-export type TValidationResult = true | Error;
+import type { TConstructableObject } from './internal-utils.js';
 /**
  * Configuration interface for assertion exception handling.
  *
@@ -27,7 +12,6 @@ export type TValidationResult = true | Error;
  * defaults for unconfigured options.
  *
  * @interface IAssertException
- * @since 1.0.0
  *
  * @example
  * Basic usage with custom messages:
@@ -139,6 +123,14 @@ export interface IAssertException {
  * @template T - The type being guarded
  * @param value - The value to check
  * @returns true if value is of type T, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isString: TGuard<string> = (value): value is string => typeof value === 'string';
+ * if (isString(input)) {
+ *   // input is now typed as string
+ * }
+ * ```
  */
 export type TGuard<T> = (value: unknown) => value is T;
 /**
@@ -146,6 +138,14 @@ export type TGuard<T> = (value: unknown) => value is T;
  * @template T - The type of value being validated
  * @param value - The value to validate
  * @returns true if valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isPositive: TValidationPredicate<number> = (value) => value > 0;
+ * if (isPositive(count)) {
+ *   // count is valid
+ * }
+ * ```
  */
 export type TValidationPredicate<T = unknown> = (value: T) => boolean;
 /**
@@ -153,6 +153,15 @@ export type TValidationPredicate<T = unknown> = (value: T) => boolean;
  * @template T - The element type
  * @param value - The value to check
  * @returns true if value is an array of type T[], false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isStringArray: TArrayTypeGuard<string> = (value): value is string[] =>
+ *   Array.isArray(value) && value.every(item => typeof item === 'string');
+ * if (isStringArray(items)) {
+ *   // items is now typed as string[]
+ * }
+ * ```
  */
 export type TArrayTypeGuard<T> = (value: unknown) => value is T[];
 /**
@@ -160,6 +169,16 @@ export type TArrayTypeGuard<T> = (value: unknown) => value is T[];
  * @template T - The object type
  * @param value - The value to check
  * @returns true if value is of object type T, false otherwise
+ *
+ * @example
+ * ```typescript
+ * interface User { id: number; name: string; }
+ * const isUser: TObjectTypeGuard<User> = (value): value is User =>
+ *   typeof value === 'object' && value !== null && 'id' in value && 'name' in value;
+ * if (isUser(data)) {
+ *   // data is now typed as User
+ * }
+ * ```
  */
 export type TObjectTypeGuard<T extends object> = (value: unknown) => value is T;
 /**
@@ -167,6 +186,15 @@ export type TObjectTypeGuard<T extends object> = (value: unknown) => value is T;
  * @template T - The non-null type
  * @param value - The value to check
  * @returns true if value is not null or undefined, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isDefined: TNonNullableGuard<string> = (value): value is string =>
+ *   value !== null && value !== undefined;
+ * if (isDefined(maybeString)) {
+ *   // maybeString is now typed as string
+ * }
+ * ```
  */
 export type TNonNullableGuard<T> = (value: T | null | undefined) => value is T;
 /**
@@ -175,6 +203,17 @@ export type TNonNullableGuard<T> = (value: T | null | undefined) => value is T;
  * @param value - The value to assert
  * @param message - Optional error message
  * @throws IAssertException if assertion fails
+ *
+ * @example
+ * ```typescript
+ * const AssertNumber: TAssertFunction<number> = (value, message) => {
+ *   if (typeof value !== 'number') {
+ *     throw new Error(message || 'Expected a number');
+ *   }
+ * };
+ * AssertNumber(input);
+ * // input is now typed as number
+ * ```
  */
 export type TAssertFunction<T = unknown> = (value: unknown, message?: string) => asserts value is T;
 //# sourceMappingURL=types.d.ts.map

package/dist/asserts/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/asserts/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,WAAW,gBAAgB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,KAAK,CAAC,EAAE,oBAAoB,CAAC;IAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC;AAEvD;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAEtE;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,EAAE,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,KAAK,KAAK,IAAI,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC"}

package/dist/asserts/types.js

@@ -0,0 +1 @@
+export {};

package/{build → dist}/asserts/utils.d.ts

@@ -1,24 +1,5 @@
-import { TConstructableObject } from './internal-utils.js';
-import { IAssertException } from './types.js';
-/**
- * Gets the actual type of a value for error messages.
- * Handles primitives, objects, arrays, null, and undefined.
- *
- * @param value - The value to get the type of
- * @returns A string representation suitable for error messages
- * @internal Used by assertion functions for consistent type naming
- *
- * @example
- * ```typescript
- * GetActualType(null);         // "null"
- * GetActualType(undefined);    // "undefined"
- * GetActualType([1, 2, 3]);    // "array"
- * GetActualType({a: 1});       // "object"
- * GetActualType("hello");      // "string"
- * GetActualType(42);           // "number"
- * ```
- */
-export declare function GetActualType(value: unknown): string;
+import type { TConstructableObject } from './internal-utils.js';
+import type { IAssertException } from './types.js';
 /**
  * Throws an exception using the configured error class and message.
  *
@@ -29,6 +10,7 @@ export declare function GetActualType(value: unknown): string;
  *
  * @param exception - Exception configuration containing error class and/or message
  * @throws {Error} The configured error class with the specified message, or generic Error if no class specified
+ * @internal
  *
  * @example
  * ```typescript
@@ -59,6 +41,7 @@ export declare function ThrowException(exception: IAssertException): void;
  * @param exception - Exception configuration object to modify
  * @param errorClass - The error class constructor to set as default
  * @param force - Whether to override existing error class configuration (default: false)
+ * @internal
  *
  * @example
  * ```typescript
@@ -89,6 +72,7 @@ export declare function SetExceptionClass(exception: IAssertException, errorClas
  * @param exception - Exception configuration object to modify
  * @param message - The error message to set as default
  * @param force - Whether to override existing error message configuration (default: false)
+ * @internal
  *
  * @example
  * ```typescript

package/dist/asserts/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/asserts/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAInD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAKhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,oBAAoB,EAAE,KAAK,UAAQ,GAAG,IAAI,CAGpH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,IAAI,CAGrG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,OAAO,EACd,YAAY,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,EAClE,SAAS,EAAE,gBAAgB,GACzB,OAAO,CAAC,KAAK,CAuCf"}