@tstdl/base 0.93.51 → 0.93.53

package/schema/schemas/object.js

@@ -2,8 +2,8 @@ import { createDecorator, reflectionRegistry } from '../../reflection/index.js';
 import { SchemaError } from '../../schema/schema.error.js';
 import { toArray } from '../../utils/array/array.js';
 import { memoizeSingle } from '../../utils/function/memoize.js';
-import { filterObject, fromEntries, mapObjectValues, objectKeys } from '../../utils/object/object.js';
-import { assert, isArray, isDefined, isFunction, isLiteralObject, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
+import { filterObject, fromEntries, mapObjectValues, objectEntries } from '../../utils/object/object.js';
+import { assert, isArray, isDefined, isFunction, isNotFunction, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
 import { Class, PropertySchema } from '../decorators/index.js';
 import { schemaReflectionDataToSchema } from '../decorators/utils.js';
@@ -13,8 +13,10 @@ import { getFunctionSchemaFromReflection } from './function.js';
 import { optional } from './optional.js';
 export const tryGetSchemaFromReflection = memoizeSingle(_tryGetSchemaFromReflection, { weak: true });
 export class ObjectSchema extends Schema {
-    propertyKeys;
+    propertyEntries;
+    knownPropertyKeys;
     allowUnknownProperties;
+    resultValueConstructor;
     name;
     properties;
     mask;
@@ -33,7 +35,9 @@ export class ObjectSchema extends Schema {
         this.maximumPropertiesCount = options.maximumPropertiesCount ?? null;
         this.factory = options.factory ?? null;
         this.allowUnknownProperties = isNotNull(this.unknownProperties) || isNotNull(this.unknownPropertiesKey);
-        this.propertyKeys = new Set(objectKeys(properties));
+        this.propertyEntries = objectEntries(this.properties);
+        this.knownPropertyKeys = new Set(this.propertyEntries.map((entry) => entry[0]));
+        this.resultValueConstructor = (isNotNullOrUndefined(options.factory) && isNotFunction(options.factory)) ? () => new options.factory.type() : () => ({});
         this.name = options.name ?? 'Object';
     }
     _test(value, path, options) {
@@ -41,41 +45,63 @@ export class ObjectSchema extends Schema {
             return { valid: false, error: SchemaError.expectedButGot('object', typeOf(value), path) };
         }
         const mask = this.mask ?? options.mask ?? false;
-        const resultValue = isLiteralObject(this.factory) ? new this.factory.type() : {};
-        const keys = objectKeys(value);
-        if (isNotNull(this.minimumPropertiesCount) && (keys.length < this.minimumPropertiesCount)) {
-            return { valid: false, error: new SchemaError(`Object has too few properties (minimum ${this.minimumPropertiesCount}, got ${keys.length}).`, { path, fast: options.fastErrors }) };
+        const resultValue = this.resultValueConstructor();
+        const requiresInputKeyScan = isNotNull(this.minimumPropertiesCount) || isNotNull(this.maximumPropertiesCount) || (!mask && !this.allowUnknownProperties) || this.allowUnknownProperties;
+        let inputKeys = null;
+        let inputKeyCount = 0;
+        if (requiresInputKeyScan) {
+            inputKeys = Object.keys(value);
+            inputKeyCount = inputKeys.length;
         }
-        if (isNotNull(this.maximumPropertiesCount) && (keys.length > this.maximumPropertiesCount)) {
-            return { valid: false, error: new SchemaError(`Object has too many properties (maximum ${this.maximumPropertiesCount}, got ${keys.length}).`, { path, fast: options.fastErrors }) };
+        if (isNotNull(this.minimumPropertiesCount) && (inputKeyCount < this.minimumPropertiesCount)) {
+            return { valid: false, error: new SchemaError(`Object has too few properties (minimum ${this.minimumPropertiesCount}, got ${inputKeyCount}).`, { path, fast: options.fastErrors }) };
         }
-        const valueKeys = new Set(keys);
-        const unknownValuePropertyKeys = valueKeys.difference(this.propertyKeys);
-        if ((unknownValuePropertyKeys.size > 0) && !mask && !this.allowUnknownProperties) {
-            return { valid: false, error: new SchemaError('Unexpected property', { path: path.add(unknownValuePropertyKeys.values().next().value), fast: options.fastErrors }) };
+        if (isNotNull(this.maximumPropertiesCount) && (inputKeyCount > this.maximumPropertiesCount)) {
+            return { valid: false, error: new SchemaError(`Object has too many properties (maximum ${this.maximumPropertiesCount}, got ${inputKeyCount}).`, { path, fast: options.fastErrors }) };
         }
-        for (const key of this.propertyKeys) {
-            const propertyResult = this.properties[key]._test(value[key], path.add(key), options);
+        let matchedInputKeysCount = 0;
+        const propertyEntriesLength = this.propertyEntries.length;
+        for (let i = 0; i < propertyEntriesLength; i++) {
+            const entry = this.propertyEntries[i];
+            const key = entry[0];
+            const propertySchema = entry[1];
+            if (requiresInputKeyScan && Object.hasOwn(value, key)) {
+                matchedInputKeysCount++;
+            }
+            const propertyResult = propertySchema._test(value[key], path.add(key), options);
             if (!propertyResult.valid) {
                 return propertyResult;
             }
             resultValue[key] = propertyResult.value;
         }
-        if (this.allowUnknownProperties) {
-            for (const key of unknownValuePropertyKeys) {
-                const propertyPath = path.add(key);
-                const keyResult = this.unknownPropertiesKey?._test(key, propertyPath, options) ?? { valid: true };
-                if (!keyResult.valid) {
-                    if (mask) {
+        if (requiresInputKeyScan && (matchedInputKeysCount < inputKeyCount)) {
+            if (mask && !this.allowUnknownProperties) {
+                // Do nothing (Masking)
+            }
+            else {
+                const keyLength = inputKeys.length;
+                for (let i = 0; i < keyLength; i++) {
+                    const key = inputKeys[i];
+                    if (this.knownPropertyKeys.has(key)) {
                         continue;
                     }
-                    return { valid: false, error: new SchemaError('Invalid property key.', { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
-                }
-                const innerValueResult = this.unknownProperties?._test(value[key], propertyPath, options) ?? { valid: true, value: value[key] };
-                if (!innerValueResult.valid) {
-                    return innerValueResult;
+                    const propertyPath = path.add(key);
+                    if (!this.allowUnknownProperties) {
+                        return { valid: false, error: new SchemaError('Unexpected property', { path: propertyPath, fast: options.fastErrors }) };
+                    }
+                    const keyResult = this.unknownPropertiesKey?._test(key, propertyPath, options) ?? { valid: true };
+                    if (!keyResult.valid) {
+                        if (mask) {
+                            continue;
+                        }
+                        return { valid: false, error: new SchemaError('Invalid property key.', { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
+                    }
+                    const innerValueResult = this.unknownProperties?._test(value[key], propertyPath, options) ?? { valid: true, value: value[key] };
+                    if (!innerValueResult.valid) {
+                        return innerValueResult;
+                    }
+                    resultValue[key] = innerValueResult.value;
                 }
-                resultValue[key] = innerValueResult.value;
             }
         }
         const testResultValue = isFunction(this.factory) ? this.factory(resultValue) : resultValue;

package/schema/schemas/simple.d.ts

@@ -6,7 +6,7 @@ export type SimpleSchemaOptions<T> = SchemaOptions<T> & Coercible;
 type SimpleSchemaRefinements<T> = {
     coercers?: SimpleSchemaCoercers<T>;
     constraints?: (SimpleSchemaConstraint<T> | null)[];
-    transformers?: SimpleSchemaTransformer<T>;
+    transformers?: OneOrMany<SimpleSchemaTransformer<T> | null>;
     gotValueFormatter?: SimpleSchemaGotValueFormatter;
 };
 export type SimpleSchemaCoercers<T> = {
@@ -23,6 +23,11 @@ export type SimpleSchemaGotValueFormatter = (value: unknown) => string;
 export type SimpleSchemaTransformer<T> = (value: T) => T;
 export declare abstract class SimpleSchema<T> extends Schema<T> {
     #private;
+    /**
+     * Whether to coerce wrong input into desired output if possible.
+     * If null, uses the option at validation time.
+     */
+    readonly coerce: boolean | null;
     constructor(expected: OneOrMany<string | AbstractConstructor>, guardFn: (value: any) => value is T, options?: SimpleSchemaOptions<T>, refinements?: SimpleSchemaRefinements<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
 }

package/schema/schemas/simple.js

@@ -1,3 +1,4 @@
+import { toArray } from '../../utils/array/array.js';
 import { isDefined, isError, isNotNull, isNull, isUndefined } from '../../utils/type-guards.js';
 import { typeOf } from '../../utils/type-of.js';
 import { SchemaError } from '../schema.error.js';
@@ -10,6 +11,11 @@ export class SimpleSchema extends Schema {
     #constraints;
     #transformers;
     #gotValueFormatter;
+    /**
+     * Whether to coerce wrong input into desired output if possible.
+     * If null, uses the option at validation time.
+     */
+    coerce;
     constructor(expected, guardFn, options = {}, refinements = {}) {
         super(options);
         this.#expected = expected;
@@ -17,8 +23,9 @@ export class SimpleSchema extends Schema {
         this.#options = options;
         this.#coercers = refinements.coercers ?? {};
         this.#constraints = refinements.constraints?.filter(isNotNull) ?? [];
-        this.#transformers = refinements.transformers ?? ((value) => value);
+        this.#transformers = isDefined(refinements.transformers) ? toArray(refinements.transformers).filter(isNotNull) : [];
         this.#gotValueFormatter = refinements.gotValueFormatter ?? typeOf;
+        this.coerce = options.coerce ?? null;
     }
     _test(value, path, options) {
         let result;
@@ -45,6 +52,9 @@ export class SimpleSchema extends Schema {
         if (isUndefined(result)) {
             return { valid: false, error: SchemaError.expectedButGot(this.#expected, this.#gotValueFormatter(value), path, { fast: options.fastErrors }) };
         }
+        for (const transformer of this.#transformers) {
+            result.value = transformer(result.value);
+        }
         for (const constraint of this.#constraints) {
             const constraintResult = constraint(result.value);
             if (!constraintResult.success) {
@@ -54,7 +64,6 @@ export class SimpleSchema extends Schema {
                 return { valid: false, error: new SchemaError(`Constraint validation failed: ${constraintResult.error}`, { path, fast: options.fastErrors }) };
             }
         }
-        result.value = this.#transformers(result.value);
         return result;
     }
 }

package/schema/schemas/string.d.ts

@@ -1,17 +1,19 @@
 import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type StringSchemaOptions = SimpleSchemaOptions<string> & {
-    pattern?: RegExp | string;
+    trim?: boolean;
     lowercase?: boolean;
+    pattern?: RegExp | string;
     minimumLength?: number;
     maximumLength?: number;
 };
 export declare class StringSchema extends SimpleSchema<string> {
     readonly name: string;
-    readonly pattern: RegExp | null;
+    readonly trim: boolean;
     readonly lowercase: boolean;
     readonly minimumLength: number | null;
     readonly maximumLength: number | null;
+    readonly pattern: RegExp | null;
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;

package/schema/schemas/string.js

@@ -3,10 +3,11 @@ import { PropertySchema } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
 export class StringSchema extends SimpleSchema {
     name = 'string';
-    pattern;
+    trim;
     lowercase;
     minimumLength;
     maximumLength;
+    pattern;
     constructor(options) {
         super('string', isString, options, {
             coercers: {
@@ -15,17 +16,20 @@ export class StringSchema extends SimpleSchema {
                 bigint: (value) => ({ success: true, value: globalThis.String(value), valid: true }),
             },
             constraints: [
-                isDefined(options?.pattern)
-                    ? (value) => this.pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })
-                    : null,
                 isDefined(options?.minimumLength)
                     ? (value) => (value.length >= this.minimumLength) ? ({ success: true }) : ({ success: false, error: `String length is less than minimum length of ${this.minimumLength}.` })
                     : null,
                 isDefined(options?.maximumLength)
                     ? (value) => (value.length <= this.maximumLength) ? ({ success: true }) : ({ success: false, error: `String length exceeds maximum length of ${this.maximumLength}.` })
                     : null,
+                isDefined(options?.pattern)
+                    ? (value) => this.pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })
+                    : null,
+            ],
+            transformers: [
+                (options?.trim ?? false) ? (value) => value.trim() : null,
+                (options?.lowercase ?? false) ? (value) => value.toLowerCase() : null,
             ],
-            transformers: (options?.lowercase ?? false) ? (value) => value.toLowerCase() : undefined,
         });
         this.pattern = isString(options?.pattern)
             ? RegExp(options.pattern, 'u')
@@ -33,6 +37,7 @@ export class StringSchema extends SimpleSchema {
                 ? options.pattern
                 : null;
         this.lowercase = options?.lowercase ?? false;
+        this.trim = options?.trim ?? false;
         this.minimumLength = options?.minimumLength ?? null;
         this.maximumLength = options?.maximumLength ?? null;
     }

package/schema/schemas/transform.d.ts

@@ -1,5 +1,9 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+/**
+ * Schema that transforms input of type I to output of type O.
+ * Validates input using the provided schema before transformation.
+ */
 export declare class TransformSchema<I, O> extends Schema<O> {
     readonly name: string;
     readonly schema: Schema<I>;

package/schema/schemas/transform.js

@@ -1,6 +1,10 @@
 import { lazyProperty } from '../../utils/object/lazy-property.js';
 import { Schema } from '../schema.js';
 import { schemaTestableToSchema } from '../testable.js';
+/**
+ * Schema that transforms input of type I to output of type O.
+ * Validates input using the provided schema before transformation.
+ */
 export class TransformSchema extends Schema {
     name;
     schema;

package/schema/schemas/uint8-array.d.ts

@@ -14,6 +14,7 @@ export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
     readonly maximumLength: number | null;
     readonly coerceType: 'base64' | 'base64url' | 'zbase32' | 'hex' | null;
     constructor(options?: Uint8ArraySchemaOptions);
+    static coerce(value: string, type: 'base64' | 'base64url' | 'zbase32' | 'hex'): Uint8Array;
 }
 export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;
 export declare function Uint8ArrayProperty(options?: Uint8ArraySchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/uint8-array.js

@@ -1,4 +1,3 @@
-import { match } from 'ts-pattern';
 import { AssertionError } from '../../errors/index.js';
 import { decodeBase64, decodeBase64Url } from '../../utils/base64.js';
 import { decodeHex } from '../../utils/encoding.js';
@@ -18,12 +17,7 @@ export class Uint8ArraySchema extends SimpleSchema {
                 string: isDefined(options?.coerceType)
                     ? (value, path, options) => {
                         try {
-                            const coerced = match(this.coerceType)
-                                .with('base64', () => decodeBase64(value))
-                                .with('base64url', () => decodeBase64Url(value))
-                                .with('zbase32', () => zBase32Decode(value))
-                                .with('hex', () => decodeHex(value))
-                                .exhaustive();
+                            const coerced = Uint8ArraySchema.coerce(value, this.coerceType);
                             return { success: true, valid: true, value: coerced };
                         }
                         catch (error) {
@@ -44,6 +38,15 @@ export class Uint8ArraySchema extends SimpleSchema {
         this.maximumLength = options?.maximumLength ?? null;
         this.coerceType = options?.coerceType ?? null;
     }
+    static coerce(value, type) {
+        switch (type) {
+            case 'base64': return decodeBase64(value);
+            case 'base64url': return decodeBase64Url(value);
+            case 'zbase32': return zBase32Decode(value);
+            case 'hex': return decodeHex(value);
+            default: throw new AssertionError(`Unsupported coerce type: ${type}`);
+        }
+    }
 }
 export function uint8Array(options) {
     return new Uint8ArraySchema(options);

package/templates/template.model.js

@@ -53,8 +53,8 @@ export function simpleTemplate(name, template, options) {
     return {
         name,
         fields: {
-            template
+            template,
         },
-        options
+        options,
     };
 }

package/test6.js

@@ -1,38 +1,121 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
+import z from 'zod';
 import { Application } from './application/application.js';
 import { provideModule, provideSignalHandler } from './application/providers.js';
-import { NotImplementedError } from './errors/not-implemented.error.js';
-import { Singleton } from './injector/decorators.js';
-import { inject } from './injector/index.js';
-import { injectionToken } from './injector/token.js';
 import { PrettyPrintLogFormatter, provideConsoleLogTransport } from './logger/index.js';
-import { _throw } from './utils/throw.js';
-const MY_INTEGER = injectionToken('MyInteger');
-// current method
-let Foo = class Foo {
-    bar = inject(Bar);
+import { array, boolean, literal, number, object, optional, string, union } from './schema/index.js';
+import { benchmark } from './utils/benchmark.js';
+function logResult(name, tstdl, zod) {
+    const faster = tstdl.millisecondsPerOperation < zod.millisecondsPerOperation ? 'TSTDL' : 'Zod';
+    const factor = tstdl.millisecondsPerOperation < zod.millisecondsPerOperation ? zod.millisecondsPerOperation / tstdl.millisecondsPerOperation : tstdl.millisecondsPerOperation / zod.millisecondsPerOperation;
+    console.log(`\n--- ${name} ---`);
+    console.log(`TSTDL: ${tstdl.operationsPerMillisecond.toFixed(2)} ops/ms`);
+    console.log(`Zod:   ${zod.operationsPerMillisecond.toFixed(2)} ops/ms`);
+    console.log(`Result: ${faster} is ${factor.toFixed(2)}x faster`);
+}
+// --- SETUP SCHEMAS ---
+// 1. Primitive Schema
+const tstdlString = string();
+const zodString = z.string();
+// 2. Simple Object
+const tstdlUser = object({
+    name: string(),
+    age: number(),
+    isActive: boolean(),
+});
+const zodUser = z.object({
+    name: z.string(),
+    age: z.number(),
+    isActive: z.boolean(),
+});
+// 3. Complex Nested Schema
+const tstdlComplex = object({
+    id: number(),
+    tags: array(string()),
+    metadata: optional(object({
+        createdAt: number(),
+        source: union(literal('web'), literal('mobile')),
+    })),
+});
+const zodComplex = z.object({
+    id: z.number(),
+    tags: z.array(z.string()),
+    metadata: z.object({
+        createdAt: z.number(),
+        source: z.union([z.literal('web'), z.literal('mobile')]),
+    }).optional(),
+});
+// 4. Large Array
+const tstdlArray = array(number());
+const zodArray = z.array(z.number());
+// --- DATA ---
+const validString = 'Hello World';
+const validUser = {
+    name: 'Alice',
+    age: 30,
+    isActive: true,
+};
+const validComplex = {
+    id: 101,
+    tags: ['admin', 'staff', 'verified'],
+    metadata: {
+        createdAt: 1678900000,
+        source: 'web',
+    },
 };
-Foo = __decorate([
-    Singleton({
-        providers: [
-            { provide: MY_INTEGER, useFactory: () => _throw(new NotImplementedError()) },
-        ],
-    })
-], Foo);
-let Bar = class Bar {
-    myInteger = inject(MY_INTEGER);
+const largeArrayData = Array.from({ length: 1000 }, (_, i) => i);
+const invalidUser = {
+    name: 'Bob',
+    age: '30', // Invalid: string instead of number
+    isActive: true,
 };
-Bar = __decorate([
-    Singleton()
-], Bar);
+// --- RUN BENCHMARKS ---
+console.log('Starting Benchmarks...');
+// 1. Primitive Parsing
+const ITERATIONS_PRIMITIVE = 1_000_000;
+const zodPrim = benchmark(ITERATIONS_PRIMITIVE, () => zodString.parse(validString));
+const tstdlPrim = benchmark(ITERATIONS_PRIMITIVE, () => tstdlString.parse(validString));
+logResult(`Primitive String Parse (${ITERATIONS_PRIMITIVE} ops)`, tstdlPrim, zodPrim);
+// 2. Simple Object Parsing
+const ITERATIONS_OBJ = 500_000;
+const zodObj = benchmark(ITERATIONS_OBJ, () => zodUser.parse(validUser));
+const tstdlObj = benchmark(ITERATIONS_OBJ, () => tstdlUser.parse(validUser));
+logResult(`Simple Object Parse (${ITERATIONS_OBJ} ops)`, tstdlObj, zodObj);
+// 3. Complex Nested Object Parsing
+const ITERATIONS_COMPLEX = 200_000;
+const zodCmplx = benchmark(ITERATIONS_COMPLEX, () => zodComplex.parse(validComplex));
+const tstdlCmplx = benchmark(ITERATIONS_COMPLEX, () => tstdlComplex.parse(validComplex));
+logResult(`Complex Object Parse (${ITERATIONS_COMPLEX} ops)`, tstdlCmplx, zodCmplx);
+// 4. Large Array Parsing
+const ITERATIONS_ARRAY = 5_000;
+const zodArr = benchmark(ITERATIONS_ARRAY, () => zodArray.parse(largeArrayData));
+const tstdlArr = benchmark(ITERATIONS_ARRAY, () => tstdlArray.parse(largeArrayData));
+logResult(`Large Array (1k items) Parse (${ITERATIONS_ARRAY} ops)`, tstdlArr, zodArr);
+// 5. Error Handling (Exceptions)
+// Note: TSTDL creates stack traces by default, Zod does not.
+const ITERATIONS_ERROR = 100_000;
+const tstdlErr = benchmark(ITERATIONS_ERROR, () => {
+    try {
+        tstdlUser.parse(invalidUser);
+    }
+    catch (e) { }
+});
+const zodErr = benchmark(ITERATIONS_ERROR, () => {
+    try {
+        zodUser.parse(invalidUser);
+    }
+    catch (e) { }
+});
+logResult(`Error Handling / Throwing (${ITERATIONS_ERROR} ops)`, tstdlErr, zodErr);
+// 6. Error Handling (TSTDL Fast Errors vs Zod)
+// TSTDL has a 'fastErrors' option which might improve performance by skipping stack traces
+const tstdlErrFast = benchmark(ITERATIONS_ERROR, () => {
+    try {
+        tstdlUser.parse(invalidUser, { fastErrors: true });
+    }
+    catch (e) { }
+});
+logResult(`Error Handling (TSTDL fastErrors=true) (${ITERATIONS_ERROR} ops)`, tstdlErrFast, zodErr);
 function main() {
-    const foo = inject(Foo);
-    console.log(foo);
 }
 Application.run('Test', [
     provideModule(main),

package/types/types.d.ts

@@ -46,7 +46,7 @@ export type UndefinableJsonArray = UndefinableJsonInnerNode[] | readonly Undefin
 export type ArrayItem<T extends readonly any[]> = T extends readonly (infer U)[] ? U : never;
 export type Enumeration = EnumerationArray | EnumerationObject;
 export type EnumerationArray = readonly [string | number, ...(string | number)[]];
-export type EnumerationObject<V extends string | number = string | number> = Record<string, V>;
+export type EnumerationObject<V extends string | number = string | number> = Readonly<Record<string, V>>;
 export type EnumerationKey<T extends EnumerationObject = EnumerationObject> = Extract<keyof T, string>;
 export type EnumerationMap<T extends EnumerationObject = EnumerationObject> = SimplifyObject<{
     [P in EnumerationKey<T>]: (T[P] extends number ? (`${T[P]}` extends `${infer U extends number}` ? U : never) : T[P]) | T[P];

package/utils/base64.js

@@ -23,8 +23,7 @@ export function encodeBase64(array, bytesOffset, bytesLength) {
 }
 export function decodeBase64(base64) {
     if (supportsBuffer) {
-        const buffer = Buffer.from(base64, 'base64');
-        return buffer;
+        return Buffer.from(base64, 'base64');
     }
     return decodeBase64Fallback(base64);
 }

package/utils/encoding.js

@@ -1,7 +1,6 @@
-import { AssertionError } from '../errors/assertion.error.js';
 import { createArray } from './array/array.js';
 import { toUint8Array } from './binary.js';
-import { isUndefined } from './type-guards.js';
+import { assertDefined } from './type-guards.js';
 const byteToHex = createArray(2 ** 8, (i) => i).map((value) => value.toString(16).padStart(2, '0'));
 const hexToByte = new Map(byteToHex.map((hex, value) => [hex, value]));
 /**
@@ -61,9 +60,7 @@ export function decodeHex(hex) {
     for (let i = 0; i < hex.length; i += 2) {
         const hexPart = hex.substring(i, i + 2);
         const byte = hexToByte.get(hexPart);
-        if (isUndefined(byte)) {
-            throw new AssertionError(`Invalid hex string at position ${i}.`);
-        }
+        assertDefined(byte, `Invalid hex string at position ${i}.`);
         bytes[i / 2] = byte;
     }
     return bytes;

package/utils/format-error.js

@@ -36,7 +36,7 @@ export function formatError(error, options = {}) {
         }
     }
     // If no message, serialize the whole object as a fallback
-    if (isUndefined(message) || String(message).trim().length === 0) { // eslint-disable-line @typescript-eslint/no-unnecessary-type-conversion
+    if (isUndefined(message) || (String(message).trim().length == 0)) { // eslint-disable-line @typescript-eslint/no-unnecessary-type-conversion
         // Handle primitives directly
         if (!isObject(actualError)) {
             message = String(actualError);

package/utils/object/object.js

@@ -147,5 +147,11 @@ export function omit(object, ...keys) {
     return filterObject(object, (_, key) => !keys.includes(key));
 }
 export function pick(object, ...keys) {
-    return filterObject(object, (_, key) => keys.includes(key));
+    const result = {};
+    for (const key of keys) {
+        if (hasOwnProperty(object, key)) {
+            result[key] = object[key];
+        }
+    }
+    return result;
 }

package/utils/z-base32.js

@@ -1,6 +1,6 @@
-import { AssertionError } from '../errors/index.js';
 import { Alphabet } from './alphabet.js';
 import { toUint8Array } from './binary.js';
+import { assertDefined } from './type-guards.js';
 const alphabet = Alphabet.ZBase32;
 const charValueMap = new Map(alphabet.split('').map((char, index) => [char, index]));
 export function zBase32Encode(buffer) {
@@ -30,9 +30,7 @@ export function zBase32Decode(input) {
     for (let i = 0; i < input.length; i++) {
         const char = input[i];
         const charValue = charValueMap.get(char);
-        if (charValue == undefined) {
-            throw new AssertionError(`Invalid character at index ${i}.`);
-        }
+        assertDefined(charValue, `Invalid zbase32 character at index ${i}.`);
         value = (value << 5) | charValue;
         bits += 5;
         if (bits >= 8) {