@pawells/typescript-common 2.0.0 → 2.1.6

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,CAIhE;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"}

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

@@ -1,30 +1,4 @@
-/**
- * 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 function GetActualType(value) {
-    if (value === null)
-        return 'null';
-    if (value === undefined)
-        return 'undefined';
-    if (Array.isArray(value))
-        return 'array';
-    return typeof value;
-}
+import { safeDisplay, GetValueType } from './generic.js';
 /**
  * Throws an exception using the configured error class and message.
  *
@@ -35,6 +9,7 @@ export function GetActualType(value) {
  *
  * @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
@@ -54,9 +29,8 @@ export function GetActualType(value) {
  * ```
  */
 export function ThrowException(exception) {
-    if (!exception.class) {
-        throw new Error(exception.message ?? 'An assertion error occurred');
-    }
+    // exception.class is always set by SetExceptionClass before this is called
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     throw new exception.class(exception.message ?? 'An assertion error occurred');
 }
 /**
@@ -70,6 +44,7 @@ export function ThrowException(exception) {
  * @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
@@ -104,6 +79,7 @@ export function SetExceptionClass(exception, errorClass, force = false) {
  * @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
@@ -150,33 +126,32 @@ export function AssertValueType(value, expectedType, exception) {
     }
     if (expectedType === 'array') {
         if (!Array.isArray(value)) {
-            const actualType = GetActualType(value);
-            SetExceptionMessage(exception, `Expected array but received ${actualType}: ${String(value)}`);
+            const actualType = GetValueType(value);
+            SetExceptionMessage(exception, `Expected array but received ${actualType}: ${safeDisplay(value)}`);
             ThrowException(exception);
         }
         return;
     }
     if (expectedType === 'object') {
         if (typeof value !== 'object') {
-            const actualType = GetActualType(value);
-            SetExceptionMessage(exception, `Expected object but received ${actualType}: ${String(value)}`);
+            const actualType = GetValueType(value);
+            SetExceptionMessage(exception, `Expected object but received ${actualType}: ${safeDisplay(value)}`);
             ThrowException(exception);
         }
         return;
     }
     if (expectedType === 'number') {
         if (typeof value !== 'number' || Number.isNaN(value)) {
-            const actualType = typeof value === 'number' ? 'NaN' : GetActualType(value);
-            SetExceptionMessage(exception, `Expected number but received ${actualType}: ${JSON.stringify(value)}`);
+            const actualType = typeof value === 'number' ? 'NaN' : GetValueType(value);
+            SetExceptionMessage(exception, `Expected number but received ${actualType}: ${safeDisplay(value)}`);
             ThrowException(exception);
         }
         return;
     }
     // For string and boolean
-    const actualType = GetActualType(value);
+    const actualType = GetValueType(value);
     if (actualType !== expectedType) {
-        SetExceptionMessage(exception, `Expected ${expectedType} but received ${actualType}: ${String(value)}`);
+        SetExceptionMessage(exception, `Expected ${expectedType} but received ${actualType}: ${safeDisplay(value)}`);
         ThrowException(exception);
     }
 }
-//# sourceMappingURL=utils.js.map

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

@@ -24,8 +24,7 @@ export declare class BooleanError extends SimpleError {
  * @param value - The value to validate and assert as a boolean primitive
  * @param exception - Optional exception configuration for custom error handling.
  *                   Can include custom error message, error type, or other metadata.
- * @throws {Error} When value is not a boolean primitive. The specific error type
- *                 depends on the exception configuration provided.
+ * @throws {BooleanError} When value is not a boolean primitive
  *
  * @example
  * Basic usage with valid boolean values:

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

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/boolean/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,WAAW;gBAChC,OAAO,CAAC,EAAE,MAAM;CAG5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAGxG"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/boolean/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,WAAW;gBAChC,OAAO,CAAC,EAAE,MAAM;CAG5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAGxG"}

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

@@ -26,8 +26,7 @@ export class BooleanError extends SimpleError {
  * @param value - The value to validate and assert as a boolean primitive
  * @param exception - Optional exception configuration for custom error handling.
  *                   Can include custom error message, error type, or other metadata.
- * @throws {Error} When value is not a boolean primitive. The specific error type
- *                 depends on the exception configuration provided.
+ * @throws {BooleanError} When value is not a boolean primitive
  *
  * @example
  * Basic usage with valid boolean values:
@@ -69,4 +68,3 @@ export function AssertBoolean(value, exception = {}) {
     SetExceptionClass(exception, BooleanError);
     AssertValueType(value, 'boolean', exception);
 }
-//# sourceMappingURL=assert.js.map

package/dist/boolean/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Boolean assertion functions and types.
+ *
+ * Provides assertion helpers for validating boolean values at runtime.
+ *
+ * Currently contains only assertion utilities. This module structure is designed
+ * to accommodate additional boolean utilities in the future (e.g., conversion,
+ * parsing functions).
+ *
+ * @module boolean
+ */
+export * from './assert.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/boolean/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,aAAa,CAAC"}

package/dist/boolean/index.js

@@ -0,0 +1,12 @@
+/**
+ * Boolean assertion functions and types.
+ *
+ * Provides assertion helpers for validating boolean values at runtime.
+ *
+ * Currently contains only assertion utilities. This module structure is designed
+ * to accommodate additional boolean utilities in the future (e.g., conversion,
+ * parsing functions).
+ *
+ * @module boolean
+ */
+export * from './assert.js';

package/{build → dist}/enum/enum-entries.d.ts

@@ -1,4 +1,4 @@
-import { TEnumType, TEnumValue } from './types.js';
+import type { TEnumType, TEnumValue } from './types.js';
 /**
  * Returns non-numeric key-value pairs from an enum.
  *

package/dist/enum/enum-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-entries.d.ts","sourceRoot":"","sources":["../../src/enum/enum-entries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExD;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,CAIzF"}

package/{build → dist}/enum/enum-entries.js

@@ -16,4 +16,3 @@ export function EnumEntries(e) {
         return [];
     return Object.entries(e).filter(([key]) => Number.isNaN(Number(key)));
 }
-//# sourceMappingURL=enum-entries.js.map

package/{build → dist}/enum/enum-key-by-value.d.ts

@@ -1,4 +1,4 @@
-import { TEnumType, TEnumValue } from './types.js';
+import type { TEnumType, TEnumValue } from './types.js';
 /**
  * Gets the enum key for a given value.
  *

package/dist/enum/enum-key-by-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-key-by-value.d.ts","sourceRoot":"","sources":["../../src/enum/enum-key-by-value.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAQ3G"}

package/{build → dist}/enum/enum-key-by-value.js

@@ -23,4 +23,3 @@ export function EnumKeyByValue(e, value) {
         return found[0];
     return undefined;
 }
-//# sourceMappingURL=enum-key-by-value.js.map

package/{build → dist}/enum/enum-keys.js

@@ -20,4 +20,3 @@ export function EnumKeys(obj) {
         return [];
     return Object.keys(obj).filter((k) => Number.isNaN(Number(k)));
 }
-//# sourceMappingURL=enum-keys.js.map

package/{build → dist}/enum/enum-safe-value.d.ts

@@ -1,4 +1,4 @@
-import { TEnumType, TEnumValue } from './types.js';
+import type { TEnumType, TEnumValue } from './types.js';
 /**
  * Gets an enum value safely, returning a fallback if the value is not a valid enum member.
  *

package/dist/enum/enum-safe-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum-safe-value.d.ts","sourceRoot":"","sources":["../../src/enum/enum-safe-value.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,UAAU,CAExH"}

package/{build → dist}/enum/enum-safe-value.js

@@ -18,4 +18,3 @@ import { ValidateEnumValue } from './validate-enum-value.js';
 export function EnumSafeValue(e, value, fallback) {
     return ValidateEnumValue(e, value) ? value : fallback;
 }
-//# sourceMappingURL=enum-safe-value.js.map

package/{build → dist}/enum/enum-values.js

@@ -22,4 +22,3 @@ export function EnumValues(enumObj) {
         .filter(key => Number.isNaN(Number(key))) // Filter out reverse mappings
         .map(key => enumObj[key]);
 }
-//# sourceMappingURL=enum-values.js.map

package/{build → dist}/enum/index.d.ts

@@ -1,4 +1,3 @@
-export * from './types.js';
 /**
  * Enum utility functions.
  *
@@ -14,4 +13,5 @@ export * from './enum-entries.js';
 export * from './validate-enum-value.js';
 export * from './enum-key-by-value.js';
 export * from './enum-safe-value.js';
+export * from './types.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/enum/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC"}

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

@@ -1,4 +1,3 @@
-export * from './types.js';
 /**
  * Enum utility functions.
  *
@@ -14,4 +13,4 @@ export * from './enum-entries.js';
 export * from './validate-enum-value.js';
 export * from './enum-key-by-value.js';
 export * from './enum-safe-value.js';
-//# sourceMappingURL=index.js.map
+export * from './types.js';

package/dist/enum/types.js

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

package/{build → dist}/enum/validate-enum-value.d.ts

@@ -1,4 +1,4 @@
-import { TEnumType, TEnumValue } from './types.js';
+import type { TEnumType, TEnumValue } from './types.js';
 /**
  * Checks if a value is a valid member of the given enum.
  *

package/dist/enum/validate-enum-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-enum-value.d.ts","sourceRoot":"","sources":["../../src/enum/validate-enum-value.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAKnG"}

package/{build → dist}/enum/validate-enum-value.js

@@ -20,4 +20,3 @@ export function ValidateEnumValue(e, value) {
     const possibleValues = EnumValues(e);
     return possibleValues.includes(value);
 }
-//# sourceMappingURL=validate-enum-value.js.map

package/{build → dist}/function/compose.d.ts

@@ -5,6 +5,9 @@ import type { TAnyFunction } from './types.js';
  * Overloads are provided for up to five functions with distinct types.
  * For same-type pipelines of any length, use the variadic form.
  *
+ * @param fns - One or more functions to compose
+ * @returns A function that applies the input through the composed pipeline
+ *
  * @example
  * ```typescript
  * const process = Compose(trim, toLowerCase, removeSpaces);
@@ -23,6 +26,9 @@ export declare function Compose(...fns: TAnyFunction[]): TAnyFunction;
  * Overloads are provided for up to five functions with distinct types.
  * For same-type pipelines of any length, use the variadic form.
  *
+ * @param fns - One or more functions to pipe
+ * @returns A function that applies the input through the piped pipeline
+ *
  * @example
  * ```typescript
  * const process = Pipe(trim, toLowerCase, removeSpaces);

package/dist/function/compose.d.ts.map

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

package/{build → dist}/function/compose.js

@@ -4,4 +4,3 @@ export function Compose(...fns) {
 export function Pipe(...fns) {
     return (arg) => fns.reduce((v, fn) => fn(v), arg);
 }
-//# sourceMappingURL=compose.js.map

package/{build → dist}/function/debounce.d.ts

@@ -6,6 +6,12 @@ import type { TAnyFunction } from './types.js';
  * The returned function also exposes a `.cancel()` method to discard any
  * pending invocation.
  *
+ * @remarks
+ * Debounce differs from throttle in that it **delays execution** until silence.
+ * Each call resets the timer; the function executes only after `ms` milliseconds
+ * of inactivity. Throttle, by contrast, limits calls to **at most once per `ms` milliseconds**
+ * regardless of how frequently calls are made.
+ *
  * @template T - The wrapped function type
  * @param fn - The function to debounce
  * @param ms - Delay in milliseconds

package/dist/function/debounce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../src/function/debounce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,YAAY,EAC9C,EAAE,EAAE,CAAC,EACL,EAAE,EAAE,MAAM,GACR,CAAC,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,GAAG;IAAE,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAiB7D"}

package/{build → dist}/function/debounce.js

@@ -5,6 +5,12 @@
  * The returned function also exposes a `.cancel()` method to discard any
  * pending invocation.
  *
+ * @remarks
+ * Debounce differs from throttle in that it **delays execution** until silence.
+ * Each call resets the timer; the function executes only after `ms` milliseconds
+ * of inactivity. Throttle, by contrast, limits calls to **at most once per `ms` milliseconds**
+ * regardless of how frequently calls are made.
+ *
  * @template T - The wrapped function type
  * @param fn - The function to debounce
  * @param ms - Delay in milliseconds
@@ -34,4 +40,3 @@ export function Debounce(fn, ms) {
     };
     return debounced;
 }
-//# sourceMappingURL=debounce.js.map

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

@@ -13,4 +13,3 @@ export * from './memoize.js';
 export * from './once.js';
 export * from './compose.js';
 export * from './sleep.js';
-//# sourceMappingURL=index.js.map

package/dist/function/memoize.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Returns a memoized version of `fn` that caches results by serialising its
+ * arguments with `JSON.stringify` (or a custom `keyFn`).
+ *
+ * Only suitable for **pure functions** with serialisable arguments.
+ *
+ * Uses an LRU (Least Recently Used) eviction policy: when the cache reaches
+ * `maxCacheSize`, the entry that was accessed least recently is evicted.
+ *
+ * @template T - The function type to memoize
+ * @param fn - The function to memoize
+ * @param keyFn - Optional custom cache key function. If not provided, arguments are serialized with JSON.stringify
+ * @param maxCacheSize - Maximum number of cached results before LRU eviction (default: 1000)
+ * @returns A memoized function with the same signature as `fn`
+ *
+ * @warning Do not memoize functions with sensitive parameters (passwords, tokens, API keys).
+ * The cache stores return values keyed by serialized arguments, which could expose sensitive
+ * data if the cache is inspected or if the keyFn inadvertently includes sensitive data
+ * in the cache key. For functions handling sensitive data, consider:
+ * - Not memoizing at all
+ * - Using a custom keyFn that excludes sensitive parameters
+ * - Implementing manual cache invalidation after processing sensitive data
+ *
+ * @example
+ * ```typescript
+ * const expensiveCalc = Memoize((n: number) => n * n);
+ * expensiveCalc(4); // computed
+ * expensiveCalc(4); // cached → same value returned immediately
+ *
+ * // Custom key function:
+ * const getUser = Memoize(fetchUser, (id) => `user:${id}`);
+ *
+ * // With custom cache size:
+ * const cached = Memoize(fn, undefined, 500);
+ *
+ * const add = (a: number, b: number) => a + b;
+ * const cachedAdd = Memoize(add);
+ * console.log(cachedAdd(1, 2)); // Computes: 3
+ * console.log(cachedAdd(1, 2)); // Returns cached result: 3
+ * ```
+ */
+/**
+ * Memoizes a function using an LRU cache.
+ *
+ * @remarks
+ * - Default key function uses JSON.stringify(args)
+ * - Non-serializable arguments (functions, symbols, circular refs) will produce incorrect cache behavior
+ * - Supply a custom `keyFn` for non-serializable arguments or for content-addressed keys
+ *
+ * @param fn - The function to memoize
+ * @param keyFn - Optional custom cache key function; defaults to JSON.stringify(args)
+ * @param maxCacheSize - Maximum number of entries in the cache; defaults to 1000
+ * @returns Memoized version of the function
+ */
+export declare function Memoize<T extends (...args: any[]) => any>(fn: T, keyFn?: (...args: Parameters<T>) => string, maxCacheSize?: number): T;
+//# sourceMappingURL=memoize.d.ts.map

package/dist/function/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/function/memoize.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;;;;;;;;;;;;GAYG;AAEH,wBAAgB,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,EAAE,EAAE,CAAC,EACL,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,EAC1C,YAAY,SAAO,GACjB,CAAC,CAkBH"}