@tstdl/base 0.93.48 → 0.93.49

package/ai/ai.service.js

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var _a;
 var AiService_1;
-import { FinishReason, FunctionCallingConfigMode as GoogleFunctionCallingMode, GoogleGenAI } from '@google/genai';
+import { ApiError, FinishReason, FunctionCallingConfigMode as GoogleFunctionCallingMode, GoogleGenAI } from '@google/genai';
 import { match } from 'ts-pattern';
 import { CancellationSignal } from '../cancellation/index.js';
 import { NotSupportedError } from '../errors/not-supported.error.js';
@@ -15,7 +15,7 @@ import { inject, injectArgument } from '../injector/inject.js';
 import { Logger } from '../logger/logger.js';
 import { DeferredPromise } from '../promise/deferred-promise.js';
 import { LazyPromise } from '../promise/lazy-promise.js';
-import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
+import { convertToOpenApiSchema } from '../schema/converters/open-api-converter.js';
 import { Schema } from '../schema/index.js';
 import { toArray } from '../utils/array/array.js';
 import { mapAsync } from '../utils/async-iterable-helpers/map.js';
@@ -23,7 +23,7 @@ import { toArrayAsync } from '../utils/async-iterable-helpers/to-array.js';
 import { backoffGenerator } from '../utils/backoff.js';
 import { lazyObject } from '../utils/object/lazy-property.js';
 import { hasOwnProperty, objectEntries } from '../utils/object/object.js';
-import { assertDefinedPass, isDefined, isError, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
+import { assertDefinedPass, isDefined, isError, isInstanceOf, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
 import { resolveValueOrAsyncProvider } from '../utils/value-or-provider.js';
 import { AiFileService } from './ai-file.service.js';
 import { AiSession } from './ai-session.js';
@@ -57,7 +57,7 @@ let AiService = AiService_1 = class AiService {
     #backoffOptions = {
         cancellationSignal: this.#cancellationSignal,
         strategy: 'exponential',
-        initialDelay: 2500,
+        initialDelay: 5000,
         increase: 1.5,
         jitter: 0.2,
         maximumDelay: 30000,
@@ -215,7 +215,7 @@ let AiService = AiService_1 = class AiService {
                 }
                 catch (error) {
                     triesLeft -= 1;
-                    if ((triesLeft > 0) && isError(error) && (error.message.includes('429 Too Many Requests') || error.message.includes('503 Service Unavailable'))) {
+                    if ((triesLeft > 0) && isInstanceOf(error, ApiError) && ((error.status == 429) || (error.status == 503))) {
                         this.#logger.verbose(`Retrying after transient error: ${error.message}`);
                         backoff();
                         continue;
@@ -304,7 +304,7 @@ let AiService = AiService_1 = class AiService {
             for (const call of generation.functionCalls) {
                 const fn = assertDefinedPass(options.functions[call.name], 'Function in response not declared.');
                 const parametersSchema = await resolveValueOrAsyncProvider(fn.parameters);
-                const parameters = isDefined(parametersSchema) ? parametersSchema.parse(call.parameters) : call.parameters;
+                const parameters = isDefined(parametersSchema) ? parametersSchema.parse(call.parameters, { coerce: true }) : call.parameters;
                 const handlerResult = isSchemaFunctionDeclarationWithHandler(fn) ? await fn.handler(parameters) : undefined;
                 yield {
                     functionName: call.name,
@@ -470,7 +470,7 @@ export function mergeGenerationStreamItems(items, schema) {
             catch (error) {
                 throw new Error(`Failed to parse model output as JSON. Raw text: "${this.text}"`, { cause: error });
             }
-            return Schema.parse(schema, parsed);
+            return Schema.parse(schema, parsed, { coerce: true });
         },
         functionCalls() {
             return parts.filter((part) => hasOwnProperty(part, 'functionCall')).map((part) => part.functionCall);

package/ai/functions.js

@@ -1,4 +1,4 @@
-import { convertToOpenApiSchema } from '../schema/converters/openapi-converter.js';
+import { convertToOpenApiSchema } from '../schema/converters/open-api-converter.js';
 import { FunctionSchema, getObjectSchema, object } from '../schema/index.js';
 import { fromEntries, objectEntries } from '../utils/object/object.js';
 import { isNotNull, isNull, isString } from '../utils/type-guards.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.48",
+  "version": "0.93.49",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -101,6 +101,8 @@
     "./rxjs-utils": "./rxjs-utils/index.js",
     "./schema": "./schema/index.js",
     "./schema/converters": "./schema/converters/index.js",
+    "./schema/converters/open-api": "./schema/converters/open-api-converter.js",
+    "./schema/converters/zod": "./schema/converters/zod-converter.js",
     "./serializer": "./serializer/index.js",
     "./serializer/handlers": "./serializer/handlers/index.js",
     "./signals": "./signals/index.js",
@@ -149,12 +151,13 @@
     "mjml": "^4.17",
     "nodemailer": "^7.0",
     "pg": "^8.16",
-    "playwright": "^1.56",
+    "playwright": "^1.57",
     "preact": "^10.27",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
     "undici": "^7.16",
-    "urlpattern-polyfill": "^10.1"
+    "urlpattern-polyfill": "^10.1",
+    "zod": "^4.1"
   },
   "peerDependenciesMeta": {
     "@tstdl/angular": {
@@ -178,7 +181,7 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.47"
+    "typescript-eslint": "8.48"
   },
   "overrides": {
     "drizzle-kit": {

package/schema/converters/{openapi-converter.js → open-api-converter.js}

@@ -1,17 +1,7 @@
 import { NotSupportedError } from '../../errors/not-supported.error.js';
 import { filterUndefinedObjectProperties, fromEntries, hasOwnProperty, objectEntries } from '../../utils/object/object.js';
 import { isDefined, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
-import { ArraySchema } from '../schemas/array.js';
-import { BooleanSchema } from '../schemas/boolean.js';
-import { DateSchema } from '../schemas/date.js';
-import { EnumerationSchema } from '../schemas/enumeration.js';
-import { LiteralSchema } from '../schemas/literal.js';
-import { nullable, NullableSchema } from '../schemas/nullable.js';
-import { NumberSchema } from '../schemas/number.js';
-import { ObjectSchema } from '../schemas/object.js';
-import { OptionalSchema } from '../schemas/optional.js';
-import { StringSchema } from '../schemas/string.js';
-import { UnionSchema } from '../schemas/union.js';
+import { ArraySchema, BooleanSchema, DateSchema, DefaultSchema, EnumerationSchema, LiteralSchema, nullable, NullableSchema, NumberSchema, ObjectSchema, OptionalSchema, StringSchema, TransformSchema, Uint8ArraySchema, UnionSchema } from '../schemas/index.js';
 import { schemaTestableToSchema } from '../testable.js';
 export function convertToOpenApiSchema(testable) {
     const schema = schemaTestableToSchema(testable);
@@ -39,12 +29,21 @@ function convertToOpenApiSchemaBase(schema) {
             maxProperties: isNumber(schema.maximumPropertiesCount) ? schema.maximumPropertiesCount : undefined,
         });
     }
+    if (schema instanceof DefaultSchema) { // You'd need to import DefaultedSchema
+        return {
+            ...convertToOpenApiSchema(schema.schema),
+            default: schema.defaultValue,
+        };
+    }
+    if (schema instanceof TransformSchema) { // You'd need to import TransformSchema
+        return convertToOpenApiSchema(schema.schema);
+    }
     if (schema instanceof StringSchema) {
         return filterUndefinedObjectProperties({
             type: 'string',
             minLength: isNumber(schema.minimumLength) ? schema.minimumLength : undefined,
             maxLength: isNumber(schema.maximumLength) ? schema.maximumLength : undefined,
-            pattern: isString(schema.pattern) ? schema.pattern : undefined,
+            pattern: isString(schema.pattern) ? schema.pattern : schema.pattern?.source,
         });
     }
     if (schema instanceof DateSchema) {
@@ -79,6 +78,14 @@ function convertToOpenApiSchemaBase(schema) {
             maxItems: isNumber(schema.maximum) ? schema.maximum : undefined,
         });
     }
+    if ((schema instanceof Uint8ArraySchema) && (schema.coerceType == 'base64')) {
+        return filterUndefinedObjectProperties({
+            type: 'string',
+            format: 'byte',
+            minLength: isNumber(schema.minimumLength) ? schema.minimumLength : undefined,
+            maxLength: isNumber(schema.maximumLength) ? schema.maximumLength : undefined,
+        });
+    }
     if (schema instanceof EnumerationSchema) {
         const hasString = schema.allowedValues.some(isString);
         const hasNumber = schema.allowedValues.some(isNumber);

package/schema/converters/zod-converter.d.ts

@@ -0,0 +1,3 @@
+import * as z from 'zod/mini';
+import type { SchemaTestable } from '../schema.js';
+export declare function convertToZodSchema<O, I = unknown>(testable: SchemaTestable<O>): z.ZodMiniType<O, I>;

package/schema/converters/zod-converter.js

@@ -0,0 +1,172 @@
+import * as z from 'zod/mini';
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { objectEntries, objectKeys } from '../../utils/object/object.js';
+import { isArray, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
+import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, RegExpSchema, StringSchema, SymbolSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
+import { schemaTestableToSchema } from '../testable.js';
+export function convertToZodSchema(testable) {
+    const schema = schemaTestableToSchema(testable);
+    return convertToZodSchemaBase(schema);
+}
+function convertToZodSchemaBase(schema) {
+    if (schema instanceof AnySchema) {
+        return z.any();
+    }
+    if (schema instanceof UnknownSchema) {
+        return z.unknown();
+    }
+    if (schema instanceof NeverSchema) {
+        return z.never();
+    }
+    if (schema instanceof NullableSchema) {
+        return z.nullable(convertToZodSchema(schema.schema));
+    }
+    if (schema instanceof OptionalSchema) {
+        return z.optional(convertToZodSchema(schema.schema));
+    }
+    if (schema instanceof OneOrManySchema) {
+        return convertToZodSchema(schema.schema);
+    }
+    if (schema instanceof StringSchema) {
+        const checks = [];
+        if (isNumber(schema.minimumLength)) {
+            checks.push(z.minLength(schema.minimumLength));
+        }
+        if (isNumber(schema.maximumLength)) {
+            checks.push(z.maxLength(schema.maximumLength));
+        }
+        if (isNotNull(schema.pattern)) {
+            checks.push(z.regex(isString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern));
+        }
+        if (schema.lowercase) {
+            checks.push(z.toLowerCase());
+        }
+        const zodSchema = z.string();
+        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
+    }
+    if (schema instanceof NumberSchema) {
+        const checks = [];
+        if (isNumber(schema.minimum)) {
+            checks.push(z.gte(schema.minimum));
+        }
+        if (isNumber(schema.maximum)) {
+            checks.push(z.lte(schema.maximum));
+        }
+        const zodSchema = (schema.integer) ? z.int() : z.number();
+        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
+    }
+    if (schema instanceof BooleanSchema) {
+        return z.boolean();
+    }
+    if (schema instanceof BigIntSchema) {
+        return z.bigint();
+    }
+    if (schema instanceof SymbolSchema) {
+        return z.symbol();
+    }
+    if (schema instanceof DateSchema) {
+        const checks = [];
+        if (isNotNull(schema.minimum)) {
+            checks.push(z.gte(schema.minimum));
+        }
+        if (isNotNull(schema.maximum)) {
+            checks.push(z.lte(schema.maximum));
+        }
+        const zodSchema = z.date();
+        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
+    }
+    if (schema instanceof LiteralSchema) {
+        return z.literal(schema.value);
+    }
+    if (schema instanceof ArraySchema) {
+        const itemSchema = convertToZodSchema(schema.itemSchema);
+        const checks = [];
+        if (isNumber(schema.minimum)) {
+            checks.push(z.minSize(schema.minimum));
+        }
+        if (isNumber(schema.maximum)) {
+            checks.push(z.maxSize(schema.maximum));
+        }
+        const zodSchema = z.array(itemSchema);
+        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
+    }
+    if (schema instanceof ObjectSchema) {
+        const propertyEntries = objectEntries(schema.properties);
+        if ((propertyEntries.length == 0) && (isNotNull(schema.unknownPropertiesKey) || isNotNull(schema.unknownProperties))) {
+            return z.record(convertToZodSchema(schema.unknownPropertiesKey ?? any()), convertToZodSchema(schema.unknownProperties ?? any()));
+        }
+        const shape = {};
+        for (const [key, propertySchema] of propertyEntries) {
+            shape[key] = convertToZodSchema(propertySchema);
+        }
+        const loose = isNotNull(schema.unknownPropertiesKey) || isNotNull(schema.unknownProperties);
+        const zodSchema = loose
+            ? z.looseObject(shape)
+            : schema.mask
+                ? z.object(shape)
+                : z.strictObject(shape);
+        if (loose) {
+            const propertiesSchema = convertToZodSchema(schema.unknownProperties ?? any());
+            const propertiesKeySchema = convertToZodSchema(schema.unknownPropertiesKey ?? any());
+            const knownPropertyKeys = new Set(objectKeys(shape));
+            return zodSchema.check(z.superRefine((record, context) => {
+                for (const [key, value] of objectEntries(record)) {
+                    if (knownPropertyKeys.has(key)) {
+                        continue;
+                    }
+                    const keyParseResult = propertiesKeySchema.safeParse(key);
+                    const valueParseResult = propertiesSchema.safeParse(value);
+                    if (!keyParseResult.success) {
+                        context.addIssue({
+                            code: 'invalid_key',
+                            origin: 'record',
+                            issues: keyParseResult.error.issues,
+                        });
+                    }
+                    if (!valueParseResult.success) {
+                        context.addIssue({
+                            code: 'custom',
+                            input: value,
+                            path: [key],
+                            message: valueParseResult.error.message,
+                        });
+                    }
+                }
+            }));
+        }
+        return zodSchema;
+    }
+    if (schema instanceof UnionSchema) {
+        const schemas = schema.schemas.map((s) => convertToZodSchema(s));
+        return z.union(schemas);
+    }
+    if (schema instanceof EnumerationSchema) {
+        if (isArray(schema.enumeration) && schema.enumeration.some((v) => isNumber(v))) {
+            const types = schema.allowedValues.map((value) => z.literal(value));
+            return z.union(types);
+        }
+        return z.enum(schema.enumeration);
+    }
+    if (schema instanceof DefaultSchema) {
+        return z._default(convertToZodSchema(schema.schema), schema.defaultValue);
+    }
+    if (schema instanceof TransformSchema) {
+        return z.transform((input) => schema.transformFn(input));
+    }
+    if (schema instanceof DeferredSchema) {
+        return z.lazy(() => convertToZodSchema(schema.schema));
+    }
+    if (schema instanceof Uint8ArraySchema) {
+        return z.instanceof(Uint8Array);
+    }
+    if (schema instanceof ReadableStreamSchema) {
+        return z.instanceof(ReadableStream);
+    }
+    if (schema instanceof RegExpSchema) {
+        return z.instanceof(RegExp);
+    }
+    if (schema instanceof InstanceSchema) {
+        return z.instanceof(schema.type);
+    }
+    throw new NotSupportedError(`Schema "${schema.name}" cannot be converted to Zod schema.`);
+}

package/schema/schemas/array.js

@@ -27,10 +27,10 @@ export class ArraySchema extends Schema {
             return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
         }
         if (isNotNull(this.maximum) && (value.length > this.maximum)) {
-            throw new Error(`A maximum of ${this.maximum} items are allowed.`);
+            return { valid: false, error: new SchemaError(`A maximum of ${this.maximum} items are allowed.`, { path, fast: options.fastErrors }) };
         }
         if (isNotNull(this.minimum) && (value.length < this.minimum)) {
-            throw new Error(`A minimum of ${this.minimum} items are required.`);
+            return { valid: false, error: new SchemaError(`A minimum of ${this.minimum} items are required.`, { path, fast: options.fastErrors }) };
         }
         const values = [];
         for (let i = 0; i < value.length; i++) {

package/schema/schemas/date.d.ts

@@ -1,10 +1,13 @@
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-export type DateSchemaOptions = SimpleSchemaOptions<globalThis.Date> & {
-    integer?: boolean;
+export type DateSchemaOptions = SimpleSchemaOptions<Date> & {
+    minimum?: Date | number | null;
+    maximum?: Date | number | null;
 };
-export declare class DateSchema extends SimpleSchema<globalThis.Date> {
+export declare class DateSchema extends SimpleSchema<Date> {
     readonly name = "date";
+    readonly minimum: Date | null;
+    readonly maximum: Date | null;
     constructor(options?: DateSchemaOptions);
 }
 export declare function date(options?: DateSchemaOptions): DateSchema;

package/schema/schemas/date.js

@@ -1,24 +1,29 @@
-import { isValidDate } from '../../utils/type-guards.js';
+import { isNotNullOrUndefined, isValidDate } from '../../utils/type-guards.js';
 import { PropertySchema } from '../decorators/index.js';
 import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class DateSchema extends SimpleSchema {
     name = 'date';
+    minimum;
+    maximum;
     constructor(options) {
         super('date', isValidDate, options, {
             coercers: {
                 string: (value, path, options) => {
-                    const result = new globalThis.Date(value);
-                    return globalThis.Number.isNaN(result.getTime())
+                    const result = new Date(value);
+                    return Number.isNaN(result.getTime())
                         ? { success: false, error: SchemaError.couldNotCoerce('date', 'string', path, { fast: options.fastErrors }) }
                         : { success: true, value: result, valid: true };
                 },
-                number: (value) => ({ success: true, value: new globalThis.Date(value), valid: false })
+                number: (value) => ({ success: true, value: new Date(value), valid: false }),
             },
             constraints: [
-                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
-            ]
+                isNotNullOrUndefined(options?.minimum) ? (value) => (value >= this.minimum) ? ({ success: true }) : ({ success: false, error: `Value ${value.toDateString()} is less than minimum ${this.minimum.toDateString()}` }) : null,
+                isNotNullOrUndefined(options?.maximum) ? (value) => (value <= this.maximum) ? ({ success: true }) : ({ success: false, error: `Value ${value.toDateString()} is greater than maximum ${this.maximum.toDateString()}` }) : null,
+            ],
         });
+        this.minimum = isNotNullOrUndefined(options?.minimum) ? new Date(options.minimum) : null;
+        this.maximum = isNotNullOrUndefined(options?.maximum) ? new Date(options.maximum) : null;
     }
 }
 export function date(options) {

package/schema/schemas/function.js

@@ -27,14 +27,14 @@ export function Method(parameterSchemasOrOptions, returnValueSchema, optionsOrNo
     if (isArray(parameterSchemasOrOptions) || isNull(parameterSchemasOrOptions)) {
         return Property({
             ...optionsOrNothing,
-            schema: (data) => func(parameterSchemasOrOptions, returnValueSchema, { description: data.description, example: data.example, ...optionsOrNothing })
+            schema: (data) => func(parameterSchemasOrOptions, returnValueSchema, { description: data.description, example: data.example, ...optionsOrNothing }),
         });
     }
     return createMethodDecorator({
         handler: (data, _metdata, originalArguments) => {
             createSchemaDecorator(parameterSchemasOrOptions)(...originalArguments);
             Property(getFunctionSchemaFromReflection(data.constructor, data.methodKey), parameterSchemasOrOptions);
-        }
+        },
     });
 }
 export function getFunctionSchemaFromReflection(type, method) {

package/schema/schemas/instance.d.ts

@@ -1,6 +1,6 @@
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { AbstractConstructor } from '../../types/index.js';
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type InstanceSchemaOptions<T extends AbstractConstructor> = SchemaOptions<InstanceType<T>>;
 export declare class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {

package/schema/schemas/instance.js

@@ -17,7 +17,7 @@ export class InstanceSchema extends Schema {
         }
         return {
             valid: false,
-            error: SchemaError.expectedButGot(typeOf(this.type), typeOf(value), path, { fast: options.fastErrors })
+            error: SchemaError.expectedButGot(typeOf(this.type), typeOf(value), path, { fast: options.fastErrors }),
         };
     }
 }

package/schema/schemas/object.d.ts

@@ -47,6 +47,11 @@ export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
     readonly factory: ObjectSchemaFactory<T> | null;
     constructor(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+    pick<const K extends keyof T>(keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Pick<T, K>>>;
+    omit<const K extends keyof T>(keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+    partial(): ObjectSchema<Partial<T>>;
+    partial<const K extends keyof T>(keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
+    assign<T extends Record>(other: ObjectSchemaOrType<T>): ObjectSchema<Merge<T, T>>;
 }
 export declare function object<const K extends PropertyKey, const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
     unknownProperties: SchemaTestable<V>;

package/schema/schemas/object.js

@@ -81,6 +81,18 @@ export class ObjectSchema extends Schema {
         const testResultValue = isFunction(this.factory) ? this.factory(resultValue) : resultValue;
         return { valid: true, value: testResultValue };
     }
+    pick(keys) {
+        return pick(this, keys);
+    }
+    omit(keys) {
+        return omit(this, keys);
+    }
+    partial(keys) {
+        return partial(this, keys);
+    }
+    assign(other) {
+        return assign(this, other);
+    }
 }
 export function object(properties, options) {
     return new ObjectSchema(properties, options);

package/schema/schemas/regexp.d.ts

@@ -1,4 +1,4 @@
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type RegExpSchemaOptions = SimpleSchemaOptions<RegExp>;
 export declare class RegExpSchema extends SimpleSchema<RegExp> {

package/schema/schemas/regexp.js

@@ -15,8 +15,8 @@ export class RegExpSchema extends SimpleSchema {
                     catch (error) {
                         return { success: false, error: SchemaError.couldNotCoerce(globalThis.RegExp, 'string', path, { fast: options.fastErrors, customMessage: error.message }) };
                     }
-                }
-            }
+                },
+            },
         });
     }
 }

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

@@ -1,15 +1,18 @@
-import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
 import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
 export type Uint8ArraySchemaOptions = SimpleSchemaOptions<Uint8Array> & {
     /** Minimum byte length */
     minimumLength?: number;
     /** Maximum byte length */
     maximumLength?: number;
+    /** Type to coerce from string */
+    coerceType?: Uint8ArraySchema['coerceType'];
 };
 export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
     readonly name = "Uint8Array";
     readonly minimumLength: number | null;
     readonly maximumLength: number | null;
+    readonly coerceType: 'base64' | 'base64url' | 'zbase32' | 'hex' | null;
     constructor(options?: Uint8ArraySchemaOptions);
 }
 export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;

package/schema/schemas/uint8-array.js

@@ -1,19 +1,48 @@
-import { isDefined, isUint8Array } from '../../utils/type-guards.js';
+import { match } from 'ts-pattern';
+import { AssertionError } from '../../errors/index.js';
+import { decodeBase64, decodeBase64Url } from '../../utils/base64.js';
+import { decodeHex } from '../../utils/encoding.js';
+import { isDefined, isInstanceOf, isUint8Array } from '../../utils/type-guards.js';
+import { zBase32Decode } from '../../utils/z-base32.js';
 import { PropertySchema } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
 import { SimpleSchema } from './simple.js';
 export class Uint8ArraySchema extends SimpleSchema {
     name = 'Uint8Array';
     minimumLength;
     maximumLength;
+    coerceType;
     constructor(options) {
         super('Uint8Array', isUint8Array, options, {
+            coercers: {
+                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();
+                            return { success: true, valid: true, value: coerced };
+                        }
+                        catch (error) {
+                            if (isInstanceOf(error, AssertionError)) {
+                                return { success: false, error: SchemaError.couldNotCoerce(`${this.coerceType} formatted string`, 'string', path, { fast: options.fastErrors, customMessage: error.message }) };
+                            }
+                            throw error;
+                        }
+                    }
+                    : undefined,
+            },
             constraints: [
                 isDefined(options?.minimumLength) ? (value) => (value.byteLength >= this.minimumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at least ${this.minimumLength} bytes.` }) : null,
-                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= this.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${this.maximumLength} bytes.` }) : null
-            ]
+                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= this.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${this.maximumLength} bytes.` }) : null,
+            ],
         });
         this.minimumLength = options?.minimumLength ?? null;
         this.maximumLength = options?.maximumLength ?? null;
+        this.coerceType = options?.coerceType ?? null;
     }
 }
 export function uint8Array(options) {

package/utils/encoding.js

@@ -62,7 +62,7 @@ export function decodeHex(hex) {
         const hexPart = hex.substring(i, i + 2);
         const byte = hexToByte.get(hexPart);
         if (isUndefined(byte)) {
-            throw new AssertionError(`invalid hex string at position ${i}`);
+            throw new AssertionError(`Invalid hex string at position ${i}.`);
         }
         bytes[i / 2] = byte;
     }

package/utils/z-base32.d.ts

@@ -1,3 +1,3 @@
 import type { BinaryData } from '../types/index.js';
 export declare function zBase32Encode(buffer: BinaryData): string;
-export declare function zBase32Decode(input: string): Uint8Array;
+export declare function zBase32Decode(input: string): Uint8Array<ArrayBuffer>;

package/utils/z-base32.js

@@ -1,3 +1,4 @@
+import { AssertionError } from '../errors/index.js';
 import { Alphabet } from './alphabet.js';
 import { toUint8Array } from './binary.js';
 const alphabet = Alphabet.ZBase32;
@@ -30,7 +31,7 @@ export function zBase32Decode(input) {
         const char = input[i];
         const charValue = charValueMap.get(char);
         if (charValue == undefined) {
-            throw new Error(`invalid character at index ${i}`);
+            throw new AssertionError(`Invalid character at index ${i}.`);
         }
         value = (value << 5) | charValue;
         bits += 5;

package/schema/converters/index.d.ts

@@ -1 +0,0 @@
-export * from './openapi-converter.js';

package/schema/converters/index.js

@@ -1 +0,0 @@
-export * from './openapi-converter.js';