@pawells/typescript-common 1.0.1 → 1.1.0

package/build/object/assert.d.ts

@@ -0,0 +1,138 @@
+import { IAssertException } from '../asserts/types.js';
+/**
+ * Error thrown when a value is not a valid object or fails an object assertion.
+ *
+ * @example
+ * throw new ObjectError('Value is not a valid object');
+ */
+export declare class ObjectError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Error thrown when an object is missing a required property or a property fails an assertion.
+ *
+ * @example
+ * throw new PropertyError('Object is missing required property');
+ */
+export declare class ObjectPropertyError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Asserts that a value is a plain object (not null, not an array, not a function).
+ *
+ * This method validates that the provided value is an object type, excluding null,
+ * arrays, and functions which are technically objects in JavaScript but not plain
+ * objects. After this assertion, the value is typed as Record<string, unknown>
+ * for safe property access.
+ *
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate as an object
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {ObjectError} When value is not a plain object
+ *
+ * @example
+ * ```typescript
+ * AssertObject({ name: "John" });       // ✓ Valid (plain object)
+ * AssertObject({});                     // ✓ Valid (empty object)
+ * AssertObject(new Date());             // ✓ Valid (object instance)
+ * AssertObject([1, 2, 3]);              // ✗ Throws ObjectError (array)
+ * AssertObject(null);                   // ✗ Throws ObjectError (null)
+ * AssertObject("string");               // ✗ Throws ObjectError (primitive)
+ * AssertObject(() => {});               // ✗ Throws ObjectError (function)
+ * ```
+ */
+export declare function AssertObject(value: unknown, exception?: IAssertException): asserts value is Record<string, unknown>;
+/**
+ * Asserts that an object has a specific property (inherited or own).
+ *
+ * This method validates that the specified property exists in the object,
+ * including properties from the prototype chain. Uses the 'in' operator
+ * for property detection. This is useful for checking if an object conforms
+ * to an expected interface or has required properties.
+ *
+ * @template T - The object type
+ * @template K - The property key type
+ * @template TError - Custom error type to throw on failure
+ * @param value - The object to check for the property
+ * @param property - The property key to check for
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {PropertyError} When object does not have the specified property
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: "John", age: 30 };
+ * AssertHasProperty(obj, "name");           // ✓ Valid (own property)
+ * AssertHasProperty(obj, "toString");       // ✓ Valid (inherited property)
+ * AssertHasProperty(obj, "invalid");        // ✗ Throws PropertyError
+ *
+ * // Type narrowing with property presence
+ * function processUser(obj: unknown) {
+ *   AssertObject(obj);
+ *   AssertHasProperty(obj, "name");
+ *   // obj["name"] is now accessible safely
+ * }
+ * ```
+ */
+export declare function AssertObjectHasProperty<T extends object, K extends PropertyKey>(value: T, property: K, exception?: IAssertException): void;
+/**
+ * Asserts that an object has a specific own property (not inherited).
+ *
+ * This method validates that the specified property exists as an own property
+ * of the object, excluding properties from the prototype chain. Uses
+ * Object.prototype.hasOwnProperty.call() for reliable detection. This is useful
+ * when you need to ensure a property is directly defined on the object.
+ *
+ * @template T - The object type
+ * @template K - The property key type
+ * @template TError - Custom error type to throw on failure
+ * @param value - The object to check for the own property
+ * @param property - The property key to check for
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {PropertyError} When object does not have the specified own property
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: "John" };
+ * AssertHasOwnProperty(obj, "name");          // ✓ Valid (own property)
+ * AssertHasOwnProperty(obj, "toString");      // ✗ Throws (inherited property)
+ * AssertHasOwnProperty(obj, "invalid");       // ✗ Throws (doesn't exist)
+ *
+ * // Checking for data vs inherited methods
+ * function validateUserData(obj: object) {
+ *   AssertHasOwnProperty(obj, "id");          // Must be own property
+ *   AssertHasOwnProperty(obj, "name");        // Must be own property
+ * }
+ * ```
+ */
+export declare function AssertObjectHasOwnProperty<T extends object, K extends PropertyKey>(value: T, property: K, exception?: IAssertException): void;
+/**
+ * Asserts that a specific property of an object is not null or undefined.
+ *
+ * This method validates that the specified property exists and has a non-nullish value.
+ * It combines property existence checking with null/undefined validation. Useful for
+ * validating that required object properties have been properly initialized.
+ *
+ * @template T - The object type
+ * @template K - The property key type (must be a key of T)
+ * @template TError - Custom error type to throw on failure
+ * @param value - The object to check
+ * @param property - The property key to validate for non-null value
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {PropertyError} When property is null, undefined, or doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const user = { id: 123, name: "John", email: null };
+ * AssertPropertyNotNull(user, "id");        // ✓ Valid (123 is not null/undefined)
+ * AssertPropertyNotNull(user, "name");      // ✓ Valid ("John" is not null/undefined)
+ * AssertPropertyNotNull(user, "email");     // ✗ Throws PropertyError (null)
+ *
+ * // Type narrowing for property values
+ * function processUser(user: { name?: string | null }) {
+ *   AssertPropertyNotNull(user, "name");
+ *   // user.name is now typed as string (null/undefined excluded)
+ * }
+ * ```
+ */
+export declare function AssertObjectPropertyNotNull<T extends object, K extends keyof T>(value: T, property: K, exception?: IAssertException): void;
+//# sourceMappingURL=assert.d.ts.map

package/build/object/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/object/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAMvD;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAK5B;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBACjC,OAAO,CAAC,EAAE,MAAM;CAK5B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBvH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAU9I;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAUjJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAW9I"}

package/build/object/assert.js

@@ -0,0 +1,204 @@
+import { SetExceptionClass, SetExceptionMessage, ThrowException } from '../asserts/utils.js';
+/** Maximum number of characters to include from a value in an error message. */
+const MAX_VALUE_DISPLAY_LENGTH = 100;
+/**
+ * Error thrown when a value is not a valid object or fails an object assertion.
+ *
+ * @example
+ * throw new ObjectError('Value is not a valid object');
+ */
+export class ObjectError extends Error {
+    constructor(message) {
+        super(message ?? 'Object assertion failed');
+        this.name = 'ObjectError';
+        Object.setPrototypeOf(this, ObjectError.prototype);
+    }
+}
+/**
+ * Error thrown when an object is missing a required property or a property fails an assertion.
+ *
+ * @example
+ * throw new PropertyError('Object is missing required property');
+ */
+export class ObjectPropertyError extends Error {
+    constructor(message) {
+        super(message ?? 'Object Property Assertion Failed');
+        this.name = 'ObjectPropertyError';
+        Object.setPrototypeOf(this, ObjectPropertyError.prototype);
+    }
+}
+/**
+ * Asserts that a value is a plain object (not null, not an array, not a function).
+ *
+ * This method validates that the provided value is an object type, excluding null,
+ * arrays, and functions which are technically objects in JavaScript but not plain
+ * objects. After this assertion, the value is typed as Record<string, unknown>
+ * for safe property access.
+ *
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate as an object
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {ObjectError} When value is not a plain object
+ *
+ * @example
+ * ```typescript
+ * AssertObject({ name: "John" });       // ✓ Valid (plain object)
+ * AssertObject({});                     // ✓ Valid (empty object)
+ * AssertObject(new Date());             // ✓ Valid (object instance)
+ * AssertObject([1, 2, 3]);              // ✗ Throws ObjectError (array)
+ * AssertObject(null);                   // ✗ Throws ObjectError (null)
+ * AssertObject("string");               // ✗ Throws ObjectError (primitive)
+ * AssertObject(() => {});               // ✗ Throws ObjectError (function)
+ * ```
+ */
+export function AssertObject(value, exception = {}) {
+    SetExceptionClass(exception, ObjectError);
+    if (typeof value !== 'object' || value === null || Array.isArray(value) || typeof value === 'function') {
+        const actualType = value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
+        let valueStr;
+        try {
+            if (typeof value === 'function') {
+                valueStr = '[Function]';
+            }
+            else if (value === null) {
+                valueStr = 'null';
+            }
+            else if (value === undefined) {
+                valueStr = 'undefined';
+            }
+            else if (typeof value === 'symbol') {
+                valueStr = `[Symbol: ${String(value)}]`;
+            }
+            else {
+                valueStr = JSON.stringify(value);
+            }
+        }
+        catch {
+            valueStr = String(value);
+        }
+        SetExceptionMessage(exception, `Expected object but received ${actualType}: ${valueStr.slice(0, MAX_VALUE_DISPLAY_LENGTH)}`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that an object has a specific property (inherited or own).
+ *
+ * This method validates that the specified property exists in the object,
+ * including properties from the prototype chain. Uses the 'in' operator
+ * for property detection. This is useful for checking if an object conforms
+ * to an expected interface or has required properties.
+ *
+ * @template T - The object type
+ * @template K - The property key type
+ * @template TError - Custom error type to throw on failure
+ * @param value - The object to check for the property
+ * @param property - The property key to check for
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {PropertyError} When object does not have the specified property
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: "John", age: 30 };
+ * AssertHasProperty(obj, "name");           // ✓ Valid (own property)
+ * AssertHasProperty(obj, "toString");       // ✓ Valid (inherited property)
+ * AssertHasProperty(obj, "invalid");        // ✗ Throws PropertyError
+ *
+ * // Type narrowing with property presence
+ * function processUser(obj: unknown) {
+ *   AssertObject(obj);
+ *   AssertHasProperty(obj, "name");
+ *   // obj["name"] is now accessible safely
+ * }
+ * ```
+ */
+export function AssertObjectHasProperty(value, property, exception = {}) {
+    // First check if value is an object, using ObjectError
+    AssertObject(value, { class: ObjectError });
+    // Then check for property existence, using the configured exception class or default
+    SetExceptionClass(exception, ObjectPropertyError);
+    if (!(property in value)) {
+        SetExceptionMessage(exception, `Expected object to have property '${String(property)}' but property was not found`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that an object has a specific own property (not inherited).
+ *
+ * This method validates that the specified property exists as an own property
+ * of the object, excluding properties from the prototype chain. Uses
+ * Object.prototype.hasOwnProperty.call() for reliable detection. This is useful
+ * when you need to ensure a property is directly defined on the object.
+ *
+ * @template T - The object type
+ * @template K - The property key type
+ * @template TError - Custom error type to throw on failure
+ * @param value - The object to check for the own property
+ * @param property - The property key to check for
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {PropertyError} When object does not have the specified own property
+ *
+ * @example
+ * ```typescript
+ * const obj = { name: "John" };
+ * AssertHasOwnProperty(obj, "name");          // ✓ Valid (own property)
+ * AssertHasOwnProperty(obj, "toString");      // ✗ Throws (inherited property)
+ * AssertHasOwnProperty(obj, "invalid");       // ✗ Throws (doesn't exist)
+ *
+ * // Checking for data vs inherited methods
+ * function validateUserData(obj: object) {
+ *   AssertHasOwnProperty(obj, "id");          // Must be own property
+ *   AssertHasOwnProperty(obj, "name");        // Must be own property
+ * }
+ * ```
+ */
+export function AssertObjectHasOwnProperty(value, property, exception = {}) {
+    // First check if value is an object, using ObjectError
+    AssertObject(value, { class: ObjectError });
+    // Then check for own property existence, using the configured exception class or default
+    SetExceptionClass(exception, ObjectPropertyError);
+    if (!Object.prototype.hasOwnProperty.call(value, property)) {
+        SetExceptionMessage(exception, `Expected object to have own property '${String(property)}' but property was not found`);
+        ThrowException(exception);
+    }
+}
+/**
+ * Asserts that a specific property of an object is not null or undefined.
+ *
+ * This method validates that the specified property exists and has a non-nullish value.
+ * It combines property existence checking with null/undefined validation. Useful for
+ * validating that required object properties have been properly initialized.
+ *
+ * @template T - The object type
+ * @template K - The property key type (must be a key of T)
+ * @template TError - Custom error type to throw on failure
+ * @param value - The object to check
+ * @param property - The property key to validate for non-null value
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {PropertyError} When property is null, undefined, or doesn't exist
+ *
+ * @example
+ * ```typescript
+ * const user = { id: 123, name: "John", email: null };
+ * AssertPropertyNotNull(user, "id");        // ✓ Valid (123 is not null/undefined)
+ * AssertPropertyNotNull(user, "name");      // ✓ Valid ("John" is not null/undefined)
+ * AssertPropertyNotNull(user, "email");     // ✗ Throws PropertyError (null)
+ *
+ * // Type narrowing for property values
+ * function processUser(user: { name?: string | null }) {
+ *   AssertPropertyNotNull(user, "name");
+ *   // user.name is now typed as string (null/undefined excluded)
+ * }
+ * ```
+ */
+export function AssertObjectPropertyNotNull(value, property, exception = {}) {
+    // First check if value is an object, using ObjectError
+    AssertObject(value, { class: ObjectError });
+    // Then check for property value, using the configured exception class or default
+    SetExceptionClass(exception, ObjectPropertyError);
+    if (value[property] === null || value[property] === undefined) {
+        const actualValue = value[property] === null ? 'null' : 'undefined';
+        SetExceptionMessage(exception, `Expected property '${String(property)}' to be non-null/non-undefined but received ${actualValue}`);
+        ThrowException(exception);
+    }
+}
+//# sourceMappingURL=assert.js.map

package/build/object/assert.js.map

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

package/build/object/index.d.ts

@@ -26,6 +26,7 @@ export { isPropertyKeySafe, isPropertyPathSafe, sanitizePropertyKey, filterDange
 export { ObjectInvert } from './object-invert.js';
 export { ObjectFlatten } from './object-flatten.js';
 export { ObjectDiff } from './object-diff.js';
+export { ObjectError, ObjectPropertyError, AssertObjectHasProperty, AssertObjectHasOwnProperty, AssertObjectPropertyNotNull } from './assert.js';
 export type { IObjectDiffResult } from './object-diff.js';
 export type { TConstructableObject, TObjectOmitExtraProperties, TCachedObjectFilterFunction, TCachedObjectMapperFunction, TObjectPredicate, TObjectTransformer, TObjectComparator, TObjectEqualityComparator, TPropertyMapper, TPropertyFilter } from './types.js';
 export type { IObjectFilterOptions, ICachedObjectFilterOptions, ICachedObjectMapOptions } from './types.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACpK,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,YAAY,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGnQ,YAAY,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACpK,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AACjJ,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,YAAY,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGnQ,YAAY,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC"}

package/build/object/index.js

@@ -27,4 +27,5 @@ export { isPropertyKeySafe, isPropertyPathSafe, sanitizePropertyKey, filterDange
 export { ObjectInvert } from './object-invert.js';
 export { ObjectFlatten } from './object-flatten.js';
 export { ObjectDiff } from './object-diff.js';
+export { ObjectError, ObjectPropertyError, AssertObjectHasProperty, AssertObjectHasOwnProperty, AssertObjectPropertyNotNull } from './assert.js';
 //# sourceMappingURL=index.js.map

package/build/object/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,YAAY;AACZ,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACpK,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,YAAY;AACZ,OAAO,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACpK,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC"}

package/build/string/assert.d.ts

@@ -0,0 +1,100 @@
+import type { IAssertException } from '../asserts/types.js';
+/**
+ * Error thrown when a value is not a valid string or fails a string assertion.
+ *
+ * @example
+ * throw new StringError('Value is not a valid string');
+ */
+export declare class StringError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Asserts that a value is a string primitive type.
+ *
+ * This method validates that the provided value is of type 'string'. It accepts
+ * any string including empty strings. This is a strict type check that will
+ * reject string objects created with new String().
+ *
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate as a string
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {StringError} When value is not a string primitive
+ *
+ * @example
+ * ```typescript
+ * AssertString("hello");             // ✓ Valid
+ * AssertString("");                  // ✓ Valid (empty string is still a string)
+ * AssertString("123");               // ✓ Valid (numeric string)
+ * AssertString(123);                 // ✗ Throws StringError (number)
+ * AssertString(null);                // ✗ Throws StringError
+ * AssertString(new String("hello")); // ✗ Throws StringError (String object)
+ * ```
+ */
+export declare function AssertString(value: unknown, exception?: IAssertException): asserts value is string;
+/**
+ * Asserts that a value is a non-empty string (after trimming whitespace).
+ *
+ * This method validates that the provided value is a string and contains at least
+ * one non-whitespace character after trimming. This is useful for validating user
+ * inputs, form fields, and API parameters where empty or whitespace-only strings
+ * are not acceptable.
+ *
+ * @template TError - Custom error type to throw on failure
+ * @param value - The value to validate as a non-empty string
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {StringError} When value is not a string or is empty/whitespace-only
+ *
+ * @example
+ * ```typescript
+ * AssertStringNotEmpty("hello");         // ✓ Valid
+ * AssertStringNotEmpty("  a  ");         // ✓ Valid (has non-whitespace content)
+ * AssertStringNotEmpty("x");             // ✓ Valid (single character)
+ * AssertStringNotEmpty("");              // ✗ Throws StringError (empty)
+ * AssertStringNotEmpty("   ");           // ✗ Throws StringError (whitespace only)
+ * AssertStringNotEmpty("\t\n  ");        // ✗ Throws StringError (whitespace only)
+ * AssertStringNotEmpty(123);             // ✗ Throws StringError (not a string)
+ * ```
+ */
+export declare function AssertStringNotEmpty(value: unknown, exception?: IAssertException): asserts value is string;
+/**
+ * Asserts that a string matches a regular expression pattern.
+ *
+ * This method validates that the provided string matches the specified regular
+ * expression pattern. The string must be a valid string type (use AssertString first
+ * if needed). Useful for validating formats like emails, phone numbers, IDs, and
+ * other structured text data.
+ *
+ * For performance optimization, regex patterns are cached when possible to avoid
+ * recompilation of the same patterns. This provides significant performance benefits
+ * when validating many values against the same pattern.
+ *
+ * @template TError - Custom error type to throw on failure
+ * @param value - The string to test against the pattern
+ * @param regex - The regular expression pattern to match against
+ * @param exception - Optional exception configuration for custom error handling
+ * @throws {StringError} When string does not match the pattern
+ *
+ * @example
+ * ```typescript
+ * // Email validation
+ * AssertStringMatches("hello@example.com", /^[^\s@]+@[^\s@]+\.[^\s@]+$/);  // ✓ Valid
+ *
+ * // Digits only validation
+ * AssertStringMatches("123", /^\d+$/);                                     // ✓ Valid
+ * AssertStringMatches("12a", /^\d+$/);                                     // ✗ Throws StringError
+ *
+ * // Phone number format
+ * AssertStringMatches("(555) 123-4567", /^\(\d{3}\) \d{3}-\d{4}$/);       // ✓ Valid
+ *
+ * // Alphanumeric with length constraint
+ * AssertStringMatches("abc123", /^[a-zA-Z0-9]{3,10}$/);                   // ✓ Valid
+ * AssertStringMatches("ab", /^[a-zA-Z0-9]{3,10}$/);                       // ✗ Throws (too short)
+ *
+ * // Performance benefit with repeated pattern usage
+ * const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+ * AssertStringMatches("user1@example.com", emailPattern); // Cached for future use
+ * AssertStringMatches("user2@example.com", emailPattern); // Uses cached pattern
+ * ```
+ */
+export declare function AssertStringMatches(value: string, regex: RegExp, exception?: IAssertException): void;
+//# sourceMappingURL=assert.d.ts.map

package/build/string/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/string/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAqD5D;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;CAK5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAMtG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAe9G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAkBxG"}