@pawells/typescript-common 1.0.1 → 1.1.0

package/build/asserts/generic.js

@@ -0,0 +1,539 @@
+import { ObjectEquals } from './internal-utils.js';
+import { SetExceptionClass, SetExceptionMessage, ThrowException } from './utils.js';
+/** Maximum number of characters to include from a value in an error message. */
+const MAX_VALUE_DISPLAY_LENGTH = 50;
+/**
+ * Error thrown when a value is unexpectedly null or undefined.
+ *
+ * @example
+ * throw new NotNullError('Value must not be null or undefined');
+ */
+export class NullError extends Error {
+    constructor(message) {
+        super(message ?? 'Value is not null or undefined.');
+        this.name = 'NullError';
+        Object.setPrototypeOf(this, NullError.prototype);
+    }
+}
+/**
+ * Error thrown when a value is unexpectedly null or undefined.
+ *
+ * @example
+ * throw new NotNullError('Value must not be null or undefined');
+ */
+export class NotNullError extends Error {
+    constructor(message) {
+        super(message ?? 'Value is null or undefined.');
+        this.name = 'NotNullError';
+        Object.setPrototypeOf(this, NotNullError.prototype);
+    }
+}
+/**
+ * Error thrown when a custom predicate assertion fails.
+ *
+ * @example
+ * throw new PredicateError('Predicate assertion failed');
+ */
+export class PredicateError extends Error {
+    constructor(message) {
+        super(message ?? 'Value does not satisfy the predicate condition');
+        this.name = 'PredicateError';
+        Object.setPrototypeOf(this, PredicateError.prototype);
+    }
+}
+/**
+ * Error thrown when a value does not conform to a user-supplied type guard.
+ *
+ * @example
+ * throw new TypeGuardError('Value does not conform to the required type');
+ */
+export class TypeGuardError extends Error {
+    constructor(message) {
+        super(message ?? 'Type guard assertion failed');
+        this.name = 'TypeGuardError';
+        Object.setPrototypeOf(this, TypeGuardError.prototype);
+    }
+}
+/**
+ * Error thrown when a value is not an instance of the expected constructor.
+ *
+ * @example
+ * throw new InstanceOfError('Value is not an instance of the expected type');
+ */
+export class InstanceOfError extends Error {
+    constructor(message) {
+        super(message ?? 'InstanceOf assertion failed');
+        this.name = 'InstanceOfError';
+        Object.setPrototypeOf(this, InstanceOfError.prototype);
+    }
+}
+/**
+ * Error thrown when a value is not a function.
+ *
+ * @example
+ * throw new FunctionError('Value is not a function');
+ */
+export class FunctionError extends Error {
+    constructor(message) {
+        super(message ?? 'Function assertion failed');
+        this.name = 'FunctionError';
+        Object.setPrototypeOf(this, FunctionError.prototype);
+    }
+}
+/**
+ * Error thrown when a value is not a symbol.
+ *
+ * @example
+ * throw new SymbolError('Value is not a symbol');
+ */
+export class SymbolError extends Error {
+    constructor(message) {
+        super(message ?? 'Symbol assertion failed');
+        this.name = 'SymbolError';
+        Object.setPrototypeOf(this, SymbolError.prototype);
+    }
+}
+/**
+ * Error thrown when a class does not extend the expected base class.
+ *
+ * @example
+ * throw new ExtendsError('Class does not extend the expected base class');
+ */
+export class ExtendsError extends Error {
+    constructor(message) {
+        super(message ?? 'Extends assertion failed');
+        this.name = 'ExtendsError';
+        Object.setPrototypeOf(this, ExtendsError.prototype);
+    }
+}
+/**
+ * Asserts that a value equals an expected value using deep equality comparison.
+ *
+ * This function performs a comprehensive deep equality check between the provided value and
+ * the expected value using ObjectUtils.Equals. The comparison algorithm handles:
+ * - Primitive values (numbers, strings, booleans, null, undefined)
+ * - Complex nested objects with multiple levels of nesting
+ * - Arrays with elements in the same order
+ * - Mixed data structures combining objects and arrays
+ * - Special values like NaN, Infinity, and -0
+ *
+ * The deep comparison ensures that all nested properties and array elements are
+ * recursively compared, making it suitable for complex data structure validation
+ * in testing scenarios and runtime assertions.
+ *
+ * @template T - The type of values being compared (both value and expected must be of same type)
+ * @param value - The actual value to compare against the expected value
+ * @param expected - The expected value that the actual value should equal
+ * @param exception - Configuration object for custom error handling and messaging.
+ *                   Allows customization of error type, message, and additional metadata
+ * @throws {PropertyError} When values are not deeply equal, with descriptive error message
+ * @throws {TError} When custom exception type is specified and values don't match
+ *
+ * @example
+ * ```typescript
+ * // Primitive value comparisons
+ * AssertEquals(5, 5);                               // ✓ Valid (numbers)
+ * AssertEquals("hello", "hello");                   // ✓ Valid (strings)
+ * AssertEquals(true, true);                         // ✓ Valid (booleans)
+ *
+ * // Array comparisons (order matters)
+ * AssertEquals([1, 2, 3], [1, 2, 3]);              // ✓ Valid (same elements, same order)
+ * AssertEquals([1, 2], [2, 1]);                     // ✗ Throws (different order)
+ * AssertEquals([], []);                             // ✓ Valid (empty arrays)
+ *
+ * // Object comparisons (deep equality)
+ * AssertEquals({a: 1, b: 2}, {a: 1, b: 2});        // ✓ Valid (same properties)
+ * AssertEquals({a: {b: 1}}, {a: {b: 1}});          // ✓ Valid (nested objects)
+ * AssertEquals({}, {});                             // ✓ Valid (empty objects)
+ *
+ * // Complex nested structures
+ * const obj1 = {users: [{id: 1, name: "John"}], count: 1};
+ * const obj2 = {users: [{id: 1, name: "John"}], count: 1};
+ * AssertEquals(obj1, obj2);                         // ✓ Valid (deeply equal)
+ *
+ * // Failure cases
+ * AssertEquals(5, 10);                              // ✗ Throws PropertyError
+ * AssertEquals({a: 1}, {a: 2});                     // ✗ Throws PropertyError
+ * AssertEquals([1, 2], [1, 2, 3]);                  // ✗ Throws PropertyError
+ *
+ * // Custom exception handling
+ * AssertEquals(1, 2, {
+ *   message: "Values should be equal"
+ * });                                               // ✗ Throws with custom message
+ * ```
+ */
+export function AssertEquals(value, expected, exception = {}) {
+    if (!ObjectEquals(value, expected)) {
+        SetExceptionMessage(exception, `Expected ${value} to equal ${expected}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a value does not equal an expected value using deep equality comparison.
+ *
+ * This function performs a comprehensive deep equality check and ensures the values are NOT equal.
+ * It uses the same sophisticated comparison logic as AssertEquals but with inverted logic,
+ * making it perfect for validating that values have changed, are distinct from unwanted values,
+ * or ensuring that mutations have occurred successfully.
+ *
+ * The deep comparison algorithm checks:
+ * - All primitive values for strict inequality
+ * - Nested object properties at all levels
+ * - Array elements and their ordering
+ * - Mixed data structures with complex nesting
+ * - Special numeric values (NaN, Infinity, -0)
+ *
+ * This function is particularly useful in testing scenarios where you need to verify
+ * that data transformations, mutations, or state changes have actually occurred.
+ *
+ * @template T - The type of values being compared (both value and expected must be of same type)
+ * @param value - The actual value to compare against the unwanted value
+ * @param expected - The value that should NOT be equal to the actual value
+ * @param exception - Configuration object for custom error handling and messaging.
+ *                   Defaults to empty object if not provided, allowing for optional customization
+ * @throws {PropertyError} When values are deeply equal (and shouldn't be), with descriptive error message
+ * @throws {TError} When custom exception type is specified and values are unexpectedly equal
+ *
+ * @example
+ * ```typescript
+ * // Primitive value comparisons (should be different)
+ * AssertNotEquals(5, 10);                           // ✓ Valid (different numbers)
+ * AssertNotEquals("hello", "world");                // ✓ Valid (different strings)
+ * AssertNotEquals(true, false);                     // ✓ Valid (different booleans)
+ *
+ * // Array comparisons (should be different)
+ * AssertNotEquals([1, 2], [1, 3]);                  // ✓ Valid (different elements)
+ * AssertNotEquals([1, 2], [2, 1]);                  // ✓ Valid (different order)
+ * AssertNotEquals([1], [1, 2]);                     // ✓ Valid (different lengths)
+ *
+ * // Object comparisons (should be different)
+ * AssertNotEquals({a: 1}, {a: 2});                  // ✓ Valid (different property values)
+ * AssertNotEquals({a: 1}, {b: 1});                  // ✓ Valid (different property names)
+ * AssertNotEquals({a: {b: 1}}, {a: {b: 2}});        // ✓ Valid (different nested values)
+ *
+ * // Testing mutations and transformations
+ * const original = {users: [{id: 1, name: "John"}]};
+ * const modified = {users: [{id: 1, name: "Jane"}]};
+ * AssertNotEquals(original, modified);              // ✓ Valid (data was modified)
+ *
+ * // Verifying state changes
+ * let counter = 0;
+ * const initialState = counter;
+ * counter++;
+ * AssertNotEquals(counter, initialState);           // ✓ Valid (state changed)
+ *
+ * // Failure cases (when values are unexpectedly equal)
+ * AssertNotEquals(5, 5);                            // ✗ Throws PropertyError
+ * AssertNotEquals([1, 2], [1, 2]);                  // ✗ Throws PropertyError
+ * AssertNotEquals({a: 1}, {a: 1});                  // ✗ Throws PropertyError
+ *
+ * // Custom exception handling
+ * AssertNotEquals(1, 1, {
+ *   message: "Values should be different"
+ * });                                               // ✗ Throws with custom message
+ * ```
+ */
+export function AssertNotEquals(value, expected, exception = {}) {
+    if (ObjectEquals(value, expected)) {
+        SetExceptionMessage(exception, `Expected ${value} to not equal ${expected}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a value is null or undefined (nullish assertion).
+ *
+ * This method validates that the provided value is either null or undefined,
+ * effectively performing a nullish assertion. This is useful for validating
+ * that optional values are properly unset, that cleanup operations succeeded,
+ * or that certain conditions result in null/undefined states.
+ *
+ * @template T - The type of the value being validated
+ * @param value - The value to validate as null or undefined
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {NullError} When value is not null or undefined
+ *
+ * @example
+ * ```typescript
+ * AssertNull(null);                 // ✓ Valid
+ * AssertNull(undefined);            // ✓ Valid
+ * AssertNull("hello");              // ✗ Throws NullError
+ * AssertNull(0);                    // ✗ Throws NullError
+ * AssertNull(false);                // ✗ Throws NullError
+ * AssertNull("");                   // ✗ Throws NullError
+ *
+ * // Validation of cleanup operations
+ * function cleanup(resource: Resource | null) {
+ *   resource?.dispose();
+ *   resource = null;
+ *   AssertNull(resource); // Verify cleanup succeeded
+ * }
+ * ```
+ */
+export function AssertNull(value, exception = {}) {
+    SetExceptionClass(exception, NullError);
+    if (value !== null && value !== undefined) {
+        SetExceptionMessage(exception, `Expected null or undefined but received ${typeof value}: ${JSON.stringify(value)}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a value is not null or undefined (non-nullish assertion).
+ *
+ * This method validates that the provided value is neither null nor undefined,
+ * effectively performing a non-nullish assertion. This is particularly useful
+ * for validating function parameters, API responses, and optional values that
+ * should have been initialized. After this assertion, TypeScript will narrow
+ * the type to exclude null and undefined.
+ *
+ * @template T - The type of the value being validated
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate for non-null/undefined
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {NotNullError} When value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * AssertNotNull("hello");           // ✓ Valid
+ * AssertNotNull(0);                 // ✓ Valid (0 is not null/undefined)
+ * AssertNotNull(false);             // ✓ Valid (false is not null/undefined)
+ * AssertNotNull("");                // ✓ Valid (empty string is not null/undefined)
+ * AssertNotNull(null);              // ✗ Throws NotNullError
+ * AssertNotNull(undefined);         // ✗ Throws NotNullError
+ *
+ * // Type narrowing example
+ * function process(value: string | null | undefined) {
+ *   AssertNotNull(value);
+ *   // value is now typed as string (null/undefined excluded)
+ *   return value.toUpperCase();
+ * }
+ * ```
+ */
+export function AssertNotNull(value, exception = {}) {
+    SetExceptionClass(exception, NotNullError);
+    if (value === null || value === undefined) {
+        const actualValue = value === null ? 'null' : 'undefined';
+        SetExceptionMessage(exception, `Expected non-null/non-undefined value but received ${actualValue}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Generic assertion method that validates a value using a custom predicate function.
+ *
+ * This method provides a flexible way to perform custom validations using any
+ * predicate function that returns a boolean. It's the most generic assertion
+ * in the library and can be used to implement complex validation logic that
+ * doesn't fit into other specific assertion methods.
+ *
+ * @template T - The type of value being validated
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate
+ * @param predicate - A TValidationPredicate function that returns true if the value is valid
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {PredicateError} When predicate returns false
+ *
+ * @example
+ * ```typescript
+ * // Simple numeric validation
+ * AssertPredicate(42, (x) => x > 0 && x < 100);   // ✓ Valid
+ *
+ * // String validation
+ * AssertPredicate("hello", (s) => s.length > 3);   // ✓ Valid
+ * AssertPredicate("hi", (s) => s.length > 3);      // ✗ Throws PredicateError
+ *
+ * // Complex object validation
+ * AssertPredicate(user, (u) =>
+ *   typeof u.name === 'string' &&
+ *   u.age >= 0 &&
+ *   u.email.includes('@')
+ * );
+ *
+ * // Array validation
+ * AssertPredicate([1, 2, 3], (arr) =>
+ *   arr.every(n => typeof n === 'number')
+ * );
+ * ```
+ */
+export function AssertPredicate(value, predicate, exception = {}) {
+    SetExceptionClass(exception, PredicateError);
+    if (!predicate(value)) {
+        SetExceptionMessage(exception, 'Value does not satisfy the predicate condition');
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a value matches a specific type using a type guard function.
+ *
+ * This method validates that the provided value passes a custom type guard,
+ * enabling complex type validations beyond primitive type checks. Type guards
+ * are functions that return `value is T` and provide runtime type checking
+ * with TypeScript type narrowing. This is particularly useful for validating
+ * complex object structures and custom types.
+ *
+ * @template T - The target type to validate for
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate
+ * @param typeGuard - A TGuard function that returns `value is T`
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {TypeGuardError} When value does not pass the type guard
+ *
+ * @example
+ * ```typescript
+ * // Define interfaces and type guards
+ * interface User { name: string; age: number; }
+ * const isUser = (obj: unknown): obj is User =>
+ *   typeof obj === 'object' && obj !== null &&
+ *   'name' in obj && typeof obj.name === 'string' &&
+ *   'age' in obj && typeof obj.age === 'number';
+ *
+ * // Usage
+ * AssertIsType(data, isUser);
+ * // data is now typed as User
+ *
+ * // Array of specific type
+ * const isStringArray = (arr: unknown): arr is string[] =>
+ *   Array.isArray(arr) && arr.every(item => typeof item === 'string');
+ *
+ * AssertIsType(someArray, isStringArray);
+ * // someArray is now typed as string[]
+ * ```
+ */
+export function AssertIsType(value, typeGuard, exception = {}) {
+    SetExceptionClass(exception, TypeGuardError);
+    if (!typeGuard(value)) {
+        const actualType = value === null ? 'null' : value === undefined ? 'undefined' : typeof value;
+        SetExceptionMessage(exception, `Expected value to conform to required type but received ${actualType}: ${JSON.stringify(value).slice(0, MAX_VALUE_DISPLAY_LENGTH)}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a value is an instance of a specific class or constructor function.
+ *
+ * This method validates that the provided value is an instance of the specified
+ * constructor function using the instanceof operator. This is useful for validating
+ * object instances, built-in types like Date and Error, and custom class instances.
+ * After this assertion, the value is properly typed as an instance of the constructor.
+ *
+ * @template T - The instance type to validate for
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate as an instance
+ * @param constructor - The constructor function to check against
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {InstanceOfError} When value is not an instance of the constructor
+ *
+ * @example
+ * ```typescript
+ * // Built-in types
+ * AssertInstanceOf(new Date(), Date);                    // ✓ Valid
+ * AssertInstanceOf(new Error(), Error);                  // ✓ Valid
+ * AssertInstanceOf([], Array);                           // ✓ Valid
+ * AssertInstanceOf(/regex/, RegExp);                     // ✓ Valid
+ *
+ * // Custom classes
+ * class Person { constructor(public name: string) {} }
+ * const person = new Person("John");
+ * AssertInstanceOf(person, Person);                      // ✓ Valid
+ *
+ * // Invalid cases
+ * AssertInstanceOf("string", Date);                      // ✗ Throws InstanceOfError
+ * AssertInstanceOf(123, Error);                          // ✗ Throws InstanceOfError
+ * AssertInstanceOf({}, Array);                           // ✗ Throws InstanceOfError
+ * ```
+ */
+export function AssertInstanceOf(value, constructor, exception = {}) {
+    SetExceptionClass(exception, InstanceOfError);
+    if (!(value instanceof constructor)) {
+        const actualType = value === null ? 'null' : value === undefined ? 'undefined' : value.constructor?.name || typeof value;
+        SetExceptionMessage(exception, `Expected instance of ${constructor.name} but received ${actualType}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a value is a function.
+ *
+ * This method validates that the provided value is a function (typeof === 'function').
+ * Useful for runtime validation of callbacks, API hooks, and dynamic invocations.
+ * Throws FunctionError or custom error if assertion fails.
+ *
+ * @param value - The value to validate as a function
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {FunctionError} When value is not a function
+ *
+ * @example
+ * AssertFunction(() => {}); // ✓ Valid
+ * AssertFunction(function() {}); // ✓ Valid
+ * AssertFunction(123); // ✗ Throws FunctionError
+ * AssertFunction(null); // ✗ Throws FunctionError
+ */
+export function AssertFunction(value, exception = {}) {
+    SetExceptionClass(exception, FunctionError);
+    if (typeof value !== 'function') {
+        const actualType = value === null ? 'null' : value === undefined ? 'undefined' : typeof value;
+        SetExceptionMessage(exception, `Expected function but received ${actualType}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a value is a symbol.
+ *
+ * This method validates that the provided value is a symbol (typeof === 'symbol').
+ * Useful for runtime validation of unique keys, metadata, and advanced API contracts.
+ * Throws SymbolError or custom error if assertion fails.
+ *
+ * @param value - The value to validate as a symbol
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {SymbolError} When value is not a symbol
+ *
+ * @example
+ * AssertSymbol(Symbol('foo')); // ✓ Valid
+ * AssertSymbol(Symbol.iterator); // ✓ Valid
+ * AssertSymbol('not-a-symbol'); // ✗ Throws SymbolError
+ * AssertSymbol(123); // ✗ Throws SymbolError
+ */
+export function AssertSymbol(value, exception = {}) {
+    SetExceptionClass(exception, SymbolError);
+    if (typeof value !== 'symbol') {
+        const actualType = value === null ? 'null' : value === undefined ? 'undefined' : typeof value;
+        SetExceptionMessage(exception, `Expected symbol but received ${actualType}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a class extends another class.
+ *
+ * This method validates that the provided derived class extends the specified base class.
+ * Useful for runtime validation of inheritance relationships in TypeScript and JavaScript.
+ * Throws ExtendsError or custom error if assertion fails.
+ *
+ * @param derived - The class to validate as extending base
+ * @param base - The base class to check against
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {ExtendsError} When derived does not extend base
+ *
+ * @example
+ * class Base {}
+ * class Derived extends Base {}
+ * AssertExtends(Derived, Base); // ✓ Valid
+ * AssertExtends(Base, Derived); // ✗ Throws ExtendsError
+ */
+export function AssertExtends(derived, base, exception = {}) {
+    SetExceptionClass(exception, ExtendsError);
+    if (typeof derived !== 'function' || typeof base !== 'function') {
+        SetExceptionMessage(exception, 'Both arguments must be class constructors');
+        ThrowException(exception);
+    }
+    let proto = Object.getPrototypeOf(derived.prototype);
+    const baseProto = base.prototype;
+    let found = false;
+    while (proto) {
+        if (proto === baseProto) {
+            found = true;
+            break;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    if (!found) {
+        SetExceptionMessage(exception, `Expected ${derived.name} to extend ${base.name}`);
+        ThrowException(exception);
+    }
+}
+//# sourceMappingURL=generic.js.map

package/build/asserts/generic.js.map

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

package/build/asserts/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Main entry point for the asserts package.
+ * Provides assertion utilities for various data types including arrays, booleans, numbers, objects, and strings.
+ */
+/**
+ * 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 all generic assertion functions and types
+ */
+export * 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 utility functions for advanced usage
+ */
+export * from './utils.js';
+/**
+ * Export error classes for standardized error handling
+ */
+export * from './errors.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/asserts/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,cAAc,oBAAoB,CAAC;AAEnC;;GAEG;AACH,cAAc,sBAAsB,CAAC;AAErC;;GAEG;AACH,cAAc,cAAc,CAAC;AAE7B;;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,YAAY,CAAC;AAE3B;;GAEG;AACH,cAAc,aAAa,CAAC"}

package/build/asserts/index.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Main entry point for the asserts package.
+ * Provides assertion utilities for various data types including arrays, booleans, numbers, objects, and strings.
+ */
+/**
+ * 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 all generic assertion functions and types
+ */
+export * 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 utility functions for advanced usage
+ */
+export * from './utils.js';
+/**
+ * Export error classes for standardized error handling
+ */
+export * from './errors.js';
+//# sourceMappingURL=index.js.map

package/build/asserts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/asserts/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,cAAc,oBAAoB,CAAC;AAEnC;;GAEG;AACH,cAAc,sBAAsB,CAAC;AAErC;;GAEG;AACH,cAAc,cAAc,CAAC;AAE7B;;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,YAAY,CAAC;AAE3B;;GAEG;AACH,cAAc,aAAa,CAAC"}