@tstdl/base 0.90.91 → 0.91.0-beta1

package/schema/schemas/transform.js

@@ -1,7 +1,20 @@
-import { GenericTransformer } from '../transformers/generic.js';
-import { valueSchema } from '../types/index.js';
-export function transform(schema, transformFunction, sourceType) {
-    return valueSchema(schema, {
-        transformers: new GenericTransformer(transformFunction, sourceType)
-    });
+import { Schema } from '../schema.js';
+export class TransformSchema extends Schema {
+    schema;
+    transformFn;
+    constructor(schema, transformFn) {
+        super();
+        this.schema = schema;
+        this.transformFn = transformFn;
+    }
+    _test(value, path, options) {
+        const result = this.schema._test(value, path, options);
+        if (!result.valid) {
+            return result;
+        }
+        return { valid: true, value: this.transformFn(result.value) };
+    }
+}
+export function transform(schema, transformFn) {
+    return new TransformSchema(schema, transformFn);
 }

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

@@ -1,10 +1,14 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type Uint8ArraySchemaOptions = ValueSchemaOptions & {
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type Uint8ArraySchemaOptions = SimpleSchemaOptions & {
     /** Minimum byte length */
     minimumLength?: number;
     /** Maximum byte length */
     maximumLength?: number;
 };
-export declare function uint8Array(options?: Uint8ArraySchemaOptions): ValueSchema<Uint8Array>;
-export declare function Uint8ArrayProperty(options?: Uint8ArraySchemaOptions): Decorator<'property' | 'accessor'>;
+export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
+    readonly options: Uint8ArraySchemaOptions;
+    constructor(options?: Uint8ArraySchemaOptions);
+}
+export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;
+export declare function Uint8Array(schemaOptions?: Uint8ArraySchemaOptions, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/uint8-array.js

@@ -1,29 +1,20 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { uint8ArrayCoercer } from '../coercers/uint8-array.coercer.js';
-import { MaximumLengthConstraint } from '../constraints/maximum-length.js';
-import { MinimumLengthConstraint } from '../constraints/minimum-length.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { valueSchema } from '../types/types.js';
-export function uint8Array(options = {}) {
-    const coercers = toArrayCopy(options.coercers ?? []);
-    const valueConstraints = toArrayCopy(options.valueConstraints ?? []);
-    if (options.coerce == true) {
-        coercers.push(uint8ArrayCoercer);
+import { isDefined, isUint8Array } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class Uint8ArraySchema extends SimpleSchema {
+    options;
+    constructor(options) {
+        super('Uint8Array', isUint8Array, options, {
+            constraints: [
+                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= options.minimumLength) ? ({ success: true }) : ({ success: false, error: `size must be at least ${options.minimumLength} bytes.` }) : null,
+                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= options.maximumLength) ? ({ success: true }) : ({ success: false, error: `size must be at most ${options.maximumLength} bytes.` }) : null
+            ]
+        });
     }
-    if (isDefined(options.minimumLength)) {
-        valueConstraints.push(new MinimumLengthConstraint(options.minimumLength));
-    }
-    if (isDefined(options.maximumLength)) {
-        valueConstraints.push(new MaximumLengthConstraint(options.maximumLength));
-    }
-    return valueSchema(Uint8Array, {
-        ...options,
-        coercers,
-        valueConstraints
-    });
 }
-export function Uint8ArrayProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(uint8Array(options));
+export function uint8Array(options) {
+    return new Uint8ArraySchema(options);
+}
+export function Uint8Array(schemaOptions, options) {
+    return Property(uint8Array(schemaOptions), options);
 }

package/schema/schemas/union.d.ts

@@ -1,7 +1,14 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { SchemaTestable } from '../schema.js';
-import type { SchemaOutput, ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type UnionOptions = ValueSchemaOptions;
-export declare function union<T extends SchemaTestable[]>(...schemas: [...T]): ValueSchema<SchemaOutput<T[number]>>;
-export declare function union<T extends SchemaTestable[]>(schemas: [...T], options?: UnionOptions): ValueSchema<SchemaOutput<T[number]>>;
-export declare function Union(...schemas: SchemaTestable[]): Decorator<'property' | 'accessor'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+type UnionSchemaType<T extends [SchemaTestable, ...SchemaTestable[]]> = T[number] extends SchemaTestable<infer V> ? V : never;
+export declare class UnionSchema<T extends [SchemaTestable, ...SchemaTestable[]]> extends Schema<UnionSchemaType<T>> {
+    readonly schemas: {
+        [P in keyof T]: T[P] extends Schema ? T[P] : Schema<SchemaOutput<T[P]>>;
+    };
+    constructor(schemas: T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<UnionSchemaType<T>>;
+}
+export declare function union<T extends [SchemaTestable, ...SchemaTestable[]]>(...schemas: T): UnionSchema<T>;
+export declare function Union(...schemasAndOptions: [SchemaTestable, ...SchemaTestable[]] | [SchemaTestable, ...SchemaTestable[], options: SchemaPropertyDecoratorOptions]): SchemaPropertyDecorator;
+export {};

package/schema/schemas/union.js

@@ -1,13 +1,32 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { assert, isArray } from '../../utils/type-guards.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
-export function union(...args) {
-    const schemas = isArray(args[0]) ? args[0] : args;
-    const options = isArray(args[0]) ? args[1] : undefined;
-    assert(schemas.length >= 2, 'Union requires at least 2 schemas.');
-    return valueSchema(schemas, options);
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { isSchemaTestable, schemaTestableToSchema } from '../testable.js';
+export class UnionSchema extends Schema {
+    schemas;
+    constructor(schemas) {
+        super();
+        this.schemas = schemas.map((schema) => schemaTestableToSchema(schema));
+    }
+    _test(value, path, options) {
+        let firstInvalidResult;
+        for (const schema of this.schemas) {
+            const result = schema._test(value, path, options);
+            if (result.valid) {
+                return result;
+            }
+            firstInvalidResult ??= result;
+        }
+        return firstInvalidResult;
+    }
 }
-export function Union(...schemas) {
-    return createSchemaPropertyDecoratorFromSchema(union(...schemas));
+export function union(...schemas) {
+    return new UnionSchema(schemas);
+}
+export function Union(...schemasAndOptions) {
+    const schemaOrOptions = schemasAndOptions.at(-1);
+    if (isSchemaTestable(schemaOrOptions)) {
+        return Property(union(...schemasAndOptions));
+    }
+    const schemas = schemasAndOptions.slice(0, -1);
+    return Property(union(...schemas), schemaOrOptions);
 }

package/schema/schemas/unknown.d.ts

@@ -1,5 +1,7 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type UnknownOptions = ValueSchemaOptions;
-export declare function unknown(options?: UnknownOptions): ValueSchema<unknown>;
-export declare function UnknownProperty(options?: UnknownOptions): Decorator<'property' | 'accessor'>;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestResult } from '../schema.js';
+export declare class UnknownSchema extends Schema<unknown> {
+    _test(value: unknown): SchemaTestResult<unknown>;
+}
+export declare function unknown(): UnknownSchema;
+export declare function Unknown(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/unknown.js

@@ -1,9 +1,13 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
-export function unknown(options) {
-    return valueSchema('any', options);
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+export class UnknownSchema extends Schema {
+    _test(value) {
+        return { valid: true, value };
+    }
 }
-export function UnknownProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(unknown(options));
+export function unknown() {
+    return new UnknownSchema();
+}
+export function Unknown(options) {
+    return Property(unknown(), options);
 }

package/schema/testable.d.ts

@@ -0,0 +1,3 @@
+import { Schema, type SchemaTestable } from './schema.js';
+export declare function schemaTestableToSchema<T>(testable: SchemaTestable<T>): Schema<T>;
+export declare function isSchemaTestable(value: any): value is SchemaTestable;

package/schema/testable.js

@@ -0,0 +1,30 @@
+import { isFunction } from '../utils/type-guards.js';
+import { Schema } from './schema.js';
+import { bigint } from './schemas/bigint.js';
+import { boolean } from './schemas/boolean.js';
+import { number } from './schemas/number.js';
+import { getSchemaFromReflection } from './schemas/object.js';
+import { string } from './schemas/string.js';
+import { symbol } from './schemas/symbol.js';
+export function schemaTestableToSchema(testable) {
+    if (testable instanceof Schema) {
+        return testable;
+    }
+    switch (testable) {
+        case String:
+            return string();
+        case Number:
+            return number();
+        case Boolean:
+            return boolean();
+        case BigInt:
+            return bigint();
+        case Symbol:
+            return symbol();
+        default:
+            return getSchemaFromReflection(testable);
+    }
+}
+export function isSchemaTestable(value) {
+    return (value instanceof Schema) || isFunction(value);
+}

package/schema/types.d.ts

@@ -0,0 +1,31 @@
+import type { SchemaError } from './schema.error.js';
+export type Coercible = {
+    /**
+     * Try to convert wrong input into desired output.
+     * Can be specified on definition and validation. If specified on both, definition has higher priority
+     */
+    coerce?: boolean;
+};
+export type Maskable = {
+    /**
+     * Remove unspecified fields on input data instead of raising an error.
+     * Can be specified on definition and validation. If specified on both, definition has higher priority
+     */
+    mask?: boolean;
+};
+export type CoerceResult<T> = {
+    success: true;
+    value: T;
+    valid: boolean;
+} | {
+    success: false;
+    value?: undefined;
+    error?: SchemaError;
+};
+export type ConstraintResult = {
+    success: true;
+    error?: undefined;
+} | {
+    success: false;
+    error: string | SchemaError;
+};

package/schema/types.js

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

package/schema-old/decorators/class.d.ts

@@ -0,0 +1,3 @@
+import type { Decorator } from '../../reflection/index.js';
+import type { SchemaTypeReflectionData } from './types.js';
+export declare function Class(options?: SchemaTypeReflectionData): Decorator<'class'>;

package/schema-old/decorators/class.js

@@ -0,0 +1,5 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createClassDecorator } from '../../reflection/index.js';
+export function Class(options = {}) {
+    return createClassDecorator({ data: { schema: options }, mergeData: true });
+}

package/schema-old/decorators/index.d.ts

@@ -0,0 +1,6 @@
+export * from './class.js';
+export * from './coerce.js';
+export * from './constraint.js';
+export * from './property.js';
+export * from './types.js';
+export * from './utils.js';

package/schema-old/decorators/index.js

@@ -0,0 +1,6 @@
+export * from './class.js';
+export * from './coerce.js';
+export * from './constraint.js';
+export * from './property.js';
+export * from './types.js';
+export * from './utils.js';

package/schema-old/decorators/property.d.ts

@@ -0,0 +1,6 @@
+import type { Decorator } from '../../reflection/index.js';
+import type { OneOrMany, TypedOmit } from '../../types.js';
+import type { ValueType } from '../types/index.js';
+import type { PropertyOptions } from './types.js';
+export declare function Property(options?: PropertyOptions): Decorator<'property' | 'accessor'>;
+export declare function Property(schema?: OneOrMany<ValueType>, options?: TypedOmit<PropertyOptions, 'schema'>): Decorator<'property' | 'accessor'>;

package/schema-old/decorators/property.js

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { toArray } from '../../utils/array/array.js';
+import { isDefined, isFunction, isString, isUndefined } from '../../utils/type-guards.js';
+import { typeSchema } from '../types/index.js';
+import { createSchemaPropertyDecorator } from './utils.js';
+export function Property(optionsOrTypes = {}, optionsOrNothing) {
+    const schema = (isFunction(optionsOrTypes) || isString(optionsOrTypes)) ? typeSchema(optionsOrTypes) : undefined;
+    const options = isUndefined(schema) ? optionsOrTypes : optionsOrNothing ?? {};
+    return createSchemaPropertyDecorator({
+        schema,
+        ...options,
+        coercers: isDefined(options.coercers) ? toArray(options.coercers) : undefined,
+        transformers: isDefined(options.transformers) ? toArray(options.transformers) : undefined,
+        arrayConstraints: isDefined(options.arrayConstraints) ? toArray(options.arrayConstraints) : undefined,
+        valueConstraints: isDefined(options.valueConstraints) ? toArray(options.valueConstraints) : undefined
+    });
+}

package/schema-old/decorators/types.d.ts

@@ -0,0 +1,19 @@
+import type { OneOrMany } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { ObjectSchema, SchemaArrayConstraint, SchemaFactoryFunction, SchemaValueCoercer, SchemaValueConstraint, SchemaValueTransformer, TypeSchema, ValueSchema, ValueType } from '../types/index.js';
+export type SchemaTypeReflectionData = Partial<Pick<ObjectSchema, 'mask' | 'unknownProperties' | 'unknownPropertiesKey'>> & {
+    schema?: ObjectSchema | TypeSchema | ValueType;
+    factory?: SchemaFactoryFunction<any>;
+};
+export type SchemaPropertyReflectionData = {
+    schema?: OneOrMany<SchemaTestable>;
+    array?: boolean;
+    optional?: boolean;
+    nullable?: boolean;
+    coerce?: boolean;
+    coercers?: readonly SchemaValueCoercer[];
+    transformers?: readonly SchemaValueTransformer[];
+    arrayConstraints?: readonly SchemaArrayConstraint[];
+    valueConstraints?: readonly SchemaValueConstraint[];
+};
+export type PropertyOptions = Partial<ValueSchema<any>>;

package/schema-old/decorators/types.js

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

package/schema-old/decorators/utils.d.ts

@@ -0,0 +1,15 @@
+import type { Decorator, PropertyMetadata } from '../../reflection/index.js';
+import type { OneOrMany } from '../../types.js';
+import type { Schema } from '../schema.js';
+import type { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
+import type { SchemaValueCoercer } from '../types/schema-value-coercer.js';
+import type { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import type { SchemaValueTransformer } from '../types/schema-value-transformer.js';
+import type { PropertyOptions, SchemaPropertyReflectionData } from './types.js';
+export declare function createSchemaPropertyDecorator(options: PropertyOptions): Decorator<'property' | 'accessor'>;
+export declare function createSchemaPropertyDecoratorFromSchema(schema: Schema): Decorator<'property' | 'accessor'>;
+export declare function createSchemaValueCoercerDecorator(coercer: SchemaValueCoercer, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
+export declare function createSchemaValueTransformerDecorator(transformer: SchemaValueTransformer, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
+export declare function createSchemaArrayConstraintDecorator(constraint: SchemaArrayConstraint, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
+export declare function createSchemaValueConstraintDecorator(constraints: OneOrMany<SchemaValueConstraint>, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
+export declare function tryGetSchemaPropertyReflectionData(metadata: PropertyMetadata): SchemaPropertyReflectionData | undefined;

package/schema-old/decorators/utils.js

@@ -0,0 +1,48 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createPropertyOrAccessorDecorator } from '../../reflection/index.js';
+import { toArray } from '../../utils/array/array.js';
+import { merge } from '../../utils/merge.js';
+import { filterObject } from '../../utils/object/object.js';
+import { isArray, isDefined, isUndefined } from '../../utils/type-guards.js';
+import { isValueSchema, valueSchema } from '../types/types.js';
+export function createSchemaPropertyDecorator(options) {
+    return createPropertyOrAccessorDecorator({
+        handler(_, metadata) {
+            const schemaData = getOrCreateSchemaPropertyReflectionData(metadata);
+            const newSchemaData = {
+                ...options,
+                coercers: (isDefined(options.coercers) && (!isArray(options.coercers) || options.coercers.length > 0)) ? merge(toArray(options.coercers), schemaData.coercers) : undefined,
+                transformers: (isDefined(options.transformers) && (!isArray(options.transformers) || options.transformers.length > 0)) ? merge(toArray(options.transformers), schemaData.transformers) : undefined,
+                arrayConstraints: (isDefined(options.arrayConstraints) && (!isArray(options.arrayConstraints) || options.arrayConstraints.length > 0)) ? merge(toArray(options.arrayConstraints), schemaData.arrayConstraints) : undefined,
+                valueConstraints: (isDefined(options.valueConstraints) && (!isArray(options.valueConstraints) || options.valueConstraints.length > 0)) ? merge(toArray(options.valueConstraints), schemaData.valueConstraints) : undefined
+            };
+            metadata.data.set('schema', filterObject(newSchemaData, isDefined), true);
+        }
+    });
+}
+export function createSchemaPropertyDecoratorFromSchema(schema) {
+    return createSchemaPropertyDecorator(isValueSchema(schema) ? schema : valueSchema(schema));
+}
+export function createSchemaValueCoercerDecorator(coercer, options) {
+    return createSchemaPropertyDecorator({ ...options, coercers: coercer });
+}
+export function createSchemaValueTransformerDecorator(transformer, options) {
+    return createSchemaPropertyDecorator({ ...options, transformers: transformer });
+}
+export function createSchemaArrayConstraintDecorator(constraint, options) {
+    return createSchemaPropertyDecorator({ ...options, arrayConstraints: constraint });
+}
+export function createSchemaValueConstraintDecorator(constraints, options) {
+    return createSchemaPropertyDecorator({ ...options, valueConstraints: constraints });
+}
+export function tryGetSchemaPropertyReflectionData(metadata) {
+    return metadata.data.tryGet('schema');
+}
+function getOrCreateSchemaPropertyReflectionData(metadata) {
+    let schemaData = tryGetSchemaPropertyReflectionData(metadata);
+    if (isUndefined(schemaData)) {
+        schemaData = {};
+        metadata.data.set('schema', schemaData);
+    }
+    return schemaData;
+}

package/schema-old/index.d.ts

@@ -0,0 +1,10 @@
+export * from './array-constraints/index.js';
+export * from './coercers/index.js';
+export * from './constraints/index.js';
+export * from './decorators/index.js';
+export * from './schema.error.js';
+export * from './schema.js';
+export * from './schemas/index.js';
+export * from './transformers/index.js';
+export * from './types/index.js';
+export * from './utils/index.js';

package/schema-old/index.js

@@ -0,0 +1,10 @@
+export * from './array-constraints/index.js';
+export * from './coercers/index.js';
+export * from './constraints/index.js';
+export * from './decorators/index.js';
+export * from './schema.error.js';
+export * from './schema.js';
+export * from './schemas/index.js';
+export * from './transformers/index.js';
+export * from './types/index.js';
+export * from './utils/index.js';

package/schema-old/schema.d.ts

@@ -0,0 +1,15 @@
+import { JsonPath } from '../json-path/index.js';
+import type { NormalizedObjectSchema, NormalizedTypeSchema, NormalizedValueSchema, ObjectSchema, SchemaOutput, SchemaTestOptions, SchemaTestResult, SchemaValueCoercer, TupleSchemaOutput, TypeSchema, ValueSchema, ValueType } from './types/index.js';
+export type Schema<T = any> = ObjectSchema<T> | ValueSchema<T> | TypeSchema<T>;
+export type SchemaTestable<T = any> = Schema<T> | ValueType<T>;
+export type NormalizedSchema<T = any> = NormalizedObjectSchema<T> | NormalizedValueSchema<T> | NormalizedTypeSchema<T>;
+export declare const Schema: {
+    registerDefaultCoercer(coercer: SchemaValueCoercer): void;
+    test<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
+    validate<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions): boolean;
+    parse<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions): T;
+    function<T extends readonly SchemaTestable[], R extends SchemaTestable, F extends (...args: TupleSchemaOutput<T>) => SchemaOutput<R>>(argumentSchemas: T, returnSchema: R, handler: F): F;
+    asyncFunction<T extends readonly SchemaTestable[], R extends SchemaTestable, F extends (...args: TupleSchemaOutput<T>) => Promise<SchemaOutput<R>>>(argumentSchemas: T, returnSchema: R, handler: F): F;
+};
+export declare function testSchema<T>(schema: Schema<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
+export declare function getExpectString(schema: SchemaTestable): string;

package/schema-old/schema.error.d.ts

@@ -0,0 +1,26 @@
+import type { CustomErrorOptions } from '../errors/custom.error.js';
+import { CustomError } from '../errors/custom.error.js';
+import type { JsonPath } from '../json-path/index.js';
+import type { OneOrMany, TypedOmit, UndefinableJson } from '../types.js';
+import type { ErrorExtraInfo } from '../utils/format-error.js';
+import type { ValueType } from './types/index.js';
+export type SchemaErrorOptions = Pick<CustomErrorOptions, 'fast'> & {
+    path: string | JsonPath;
+    details?: UndefinableJson;
+    inner?: OneOrMany<SchemaError>;
+    cause?: any;
+};
+export declare class SchemaError extends CustomError implements ErrorExtraInfo {
+    static readonly errorName = "SchemaError";
+    readonly path: string;
+    readonly details?: UndefinableJson;
+    readonly inner?: OneOrMany<SchemaError>;
+    constructor(message: string, options: SchemaErrorOptions, cause?: any);
+    static expectedButGot(expected: OneOrMany<string | ValueType>, got: string | ValueType, path: string | JsonPath, options?: TypedOmit<SchemaErrorOptions, 'path'> & {
+        customMessage?: string;
+    }): SchemaError;
+    static couldNotCoerce(expected: OneOrMany<string | ValueType>, got: string | ValueType, path: string | JsonPath, options: TypedOmit<SchemaErrorOptions, 'path'> & {
+        customMessage?: string;
+    }): SchemaError;
+    getExtraInfo(includeMessage?: boolean): UndefinableJson | undefined;
+}

package/schema-old/schema.error.js

@@ -0,0 +1,64 @@
+import { CustomError } from '../errors/custom.error.js';
+import { toArray } from '../utils/array/array.js';
+import { isArray, isDefined, isNotNullOrUndefined, isString } from '../utils/type-guards.js';
+import { getExpectString } from './schema.js';
+import { getValueTypeName } from './utils/index.js';
+export class SchemaError extends CustomError {
+    static errorName = 'SchemaError';
+    path;
+    details;
+    inner;
+    constructor(message, options, cause) {
+        super({ message, cause: cause ?? options.cause, fast: options.fast });
+        this.path = isString(options.path) ? options.path : options.path.path;
+        if (isDefined(options.inner) && (!isArray(options.inner) || (options.inner.length > 0))) {
+            this.inner = isArray(options.inner)
+                ? (options.inner.length == 1)
+                    ? options.inner[0]
+                    : options.inner
+                : options.inner;
+        }
+        if (isNotNullOrUndefined(options.details)) {
+            this.details = options.details;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    static expectedButGot(expected, got, path, options) {
+        const expectedNames = toArray(expected).map((exp) => (isString(exp) ? exp : getExpectString(exp)));
+        const gotName = isString(got) ? got : getValueTypeName(got);
+        const expectedString = expectedNames.length == 1
+            ? expectedNames[0]
+            : `(${expectedNames.join(' | ')})`;
+        const customMessage = isDefined(options?.customMessage) ? `: ${options.customMessage}` : '.';
+        const message = `Expected ${expectedString} but got ${gotName}${customMessage}`;
+        return new SchemaError(message, { path, ...options });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+    static couldNotCoerce(expected, got, path, options) {
+        const expectedNames = toArray(expected).map((exp) => (isString(exp) ? exp : getValueTypeName(exp)));
+        const gotText = isString(got) ? got : getValueTypeName(got);
+        const expectedString = expectedNames.length == 1
+            ? expectedNames[0]
+            : `[${expectedNames.join(', ')}]`;
+        const customMessageString = isDefined(options.customMessage) ? `: ${options.customMessage}` : '.';
+        const errorMessage = `Could not coerce ${gotText} to ${expectedString}${customMessageString}`;
+        return new SchemaError(errorMessage, { path, ...options });
+    }
+    getExtraInfo(includeMessage = false) {
+        const obj = {
+            path: this.path
+        };
+        if (includeMessage) {
+            obj['message'] = this.message;
+        }
+        if (isDefined(this.inner)) {
+            obj['inner'] = isArray(this.inner)
+                ? this.inner.map((error) => error.getExtraInfo(true))
+                : this.inner.getExtraInfo(true);
+        }
+        if (isNotNullOrUndefined(this.details)) {
+            obj['details'] = this.details;
+        }
+        return obj;
+    }
+}