@tstdl/base 0.91.0 → 0.91.1

package/schema-old/constraints/maximum-date.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class MaximumDateConstraint extends SchemaValueConstraint {
-    private readonly maximum;
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: string;
-    constructor(maximum: Date | number);
-    validate(value: Date, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function MaximumDate(maximum: number): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/maximum-date.js

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { assertValidDate, isNumber } from '../../utils/type-guards.js';
-import { createSchemaValueConstraintDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { typeSchema } from '../types/types.js';
-export class MaximumDateConstraint extends SchemaValueConstraint {
-    maximum;
-    suitableTypes = Number;
-    expects;
-    constructor(maximum) {
-        super();
-        this.maximum = isNumber(maximum) ? new Date(maximum) : maximum;
-        this.expects = `<= ${this.maximum.toISOString()}`;
-        assertValidDate(this.maximum);
-    }
-    validate(value, path, context) {
-        if (value > this.maximum) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toISOString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function MaximumDate(maximum) {
-    return createSchemaValueConstraintDecorator(new MaximumDateConstraint(maximum), { schema: typeSchema(Number) });
-}

package/schema-old/constraints/maximum-length.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class MaximumLengthConstraint extends SchemaValueConstraint {
-    private readonly maximumLength;
-    readonly suitableTypes: (ArrayBufferConstructor | Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor | ArrayConstructor | StringConstructor)[];
-    readonly expects: string;
-    constructor(maximumLength: number);
-    validate(value: string, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function MaximumLength(maximumLength: number): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/maximum-length.js

@@ -1,25 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isArrayBuffer, isArrayBufferView } from '../../utils/type-guards.js';
-import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-export class MaximumLengthConstraint extends SchemaValueConstraint {
-    maximumLength;
-    suitableTypes = [String, Array, ArrayBuffer, Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
-    expects;
-    constructor(maximumLength) {
-        super();
-        this.maximumLength = maximumLength;
-        this.expects = `a maximum length of ${this.maximumLength}`;
-    }
-    validate(value, path, context) {
-        const length = (isArrayBuffer(value) || isArrayBufferView(value)) ? value.byteLength : value.length;
-        if (length > this.maximumLength) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, `a length of ${length}`, path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function MaximumLength(maximumLength) {
-    return createSchemaValueConstraintDecorator(new MaximumLengthConstraint(maximumLength));
-}

package/schema-old/constraints/maximum.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { type ConstraintContext, type ConstraintResult } from '../types/types.js';
-export declare class MaximumConstraint extends SchemaValueConstraint {
-    private readonly maximum;
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: string;
-    constructor(maximum: number);
-    validate(value: number, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function Maximum(maximum: number): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/maximum.js

@@ -1,24 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaValueConstraintDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { typeSchema } from '../types/types.js';
-export class MaximumConstraint extends SchemaValueConstraint {
-    maximum;
-    suitableTypes = Number;
-    expects;
-    constructor(maximum) {
-        super();
-        this.maximum = maximum;
-        this.expects = `<= ${this.maximum}`;
-    }
-    validate(value, path, context) {
-        if (value > this.maximum) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function Maximum(maximum) {
-    return createSchemaValueConstraintDecorator(new MaximumConstraint(maximum), { schema: typeSchema(Number) });
-}

package/schema-old/constraints/minimum-date.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { type ConstraintContext, type ConstraintResult } from '../types/types.js';
-export declare class MinimumDateConstraint extends SchemaValueConstraint {
-    private readonly minimum;
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: string;
-    constructor(minimum: Date | number);
-    validate(value: Date, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function MinimumDate(minimum: number): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/minimum-date.js

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { assertValidDate, isNumber } from '../../utils/type-guards.js';
-import { createSchemaValueConstraintDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { typeSchema } from '../types/types.js';
-export class MinimumDateConstraint extends SchemaValueConstraint {
-    minimum;
-    suitableTypes = Number;
-    expects;
-    constructor(minimum) {
-        super();
-        this.minimum = isNumber(minimum) ? new Date(minimum) : minimum;
-        this.expects = `>= ${this.minimum.toISOString()}`;
-        assertValidDate(this.minimum);
-    }
-    validate(value, path, context) {
-        if (value > this.minimum) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toISOString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function MinimumDate(minimum) {
-    return createSchemaValueConstraintDecorator(new MinimumDateConstraint(minimum), { schema: typeSchema(Number) });
-}

package/schema-old/constraints/minimum-length.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class MinimumLengthConstraint extends SchemaValueConstraint {
-    private readonly minimumLength;
-    readonly suitableTypes: (ArrayBufferConstructor | Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor | ArrayConstructor | StringConstructor)[];
-    readonly expects: string;
-    constructor(minimumLength: number);
-    validate(value: string | ArrayLike<any> | ArrayBuffer, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function MinimumLength(minimumLength: number): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/minimum-length.js

@@ -1,25 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isArrayBuffer, isArrayBufferView } from '../../utils/type-guards.js';
-import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-export class MinimumLengthConstraint extends SchemaValueConstraint {
-    minimumLength;
-    suitableTypes = [String, Array, ArrayBuffer, Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
-    expects;
-    constructor(minimumLength) {
-        super();
-        this.minimumLength = minimumLength;
-        this.expects = `a minimum length of ${this.minimumLength}`;
-    }
-    validate(value, path, context) {
-        const length = (isArrayBuffer(value) || isArrayBufferView(value)) ? value.byteLength : value.length;
-        if (length < this.minimumLength) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, `a length of ${length}`, path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function MinimumLength(minimumLength) {
-    return createSchemaValueConstraintDecorator(new MinimumLengthConstraint(minimumLength));
-}

package/schema-old/constraints/minimum.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { type ConstraintContext, type ConstraintResult } from '../types/types.js';
-export declare class MinimumConstraint extends SchemaValueConstraint {
-    private readonly minimum;
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: string;
-    constructor(minimum: number);
-    validate(value: number, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function Minimum(minimum: number): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/minimum.js

@@ -1,24 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { typeSchema } from '../types/types.js';
-export class MinimumConstraint extends SchemaValueConstraint {
-    minimum;
-    suitableTypes = Number;
-    expects;
-    constructor(minimum) {
-        super();
-        this.minimum = minimum;
-        this.expects = `>= ${this.minimum}`;
-    }
-    validate(value, path, context) {
-        if (value < this.minimum) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function Minimum(minimum) {
-    return createSchemaValueConstraintDecorator(new MinimumConstraint(minimum), { schema: typeSchema(Number) });
-}

package/schema-old/constraints/pattern.d.ts

@@ -1,13 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { type ConstraintContext, type ConstraintResult } from '../types/types.js';
-export declare class PatternConstraint extends SchemaValueConstraint {
-    private readonly pattern;
-    private readonly patternName;
-    readonly suitableTypes: StringConstructor;
-    readonly expects: string;
-    constructor(pattern: RegExp, patternName?: string);
-    validate(value: string, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function Pattern(pattern: RegExp, patternName?: string): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/pattern.js

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { typeSchema } from '../types/types.js';
-export class PatternConstraint extends SchemaValueConstraint {
-    pattern;
-    patternName;
-    suitableTypes = String;
-    expects;
-    constructor(pattern, patternName = 'a pattern') {
-        super();
-        this.pattern = pattern;
-        this.patternName = patternName;
-        this.expects = `matching ${this.patternName}`;
-    }
-    validate(value, path, context) {
-        if (!this.pattern.test(value)) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, `"${value}"`, path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function Pattern(pattern, patternName) {
-    return createSchemaValueConstraintDecorator(new PatternConstraint(pattern, patternName), { schema: typeSchema(String) });
-}

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

@@ -1,3 +0,0 @@
-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

@@ -1,5 +0,0 @@
-/* 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/coerce.d.ts

@@ -1,2 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-export declare function Coerce(): Decorator<'property' | 'accessor'>;

package/schema-old/decorators/coerce.js

@@ -1,5 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecorator } from './utils.js';
-export function Coerce() {
-    return createSchemaPropertyDecorator({ coerce: true });
-}

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

@@ -1,4 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { OneOrMany } from '../../types.js';
-import type { GenericConstraintFunction } from '../constraints/generic.js';
-export declare function Constraint<T>(constraintFunction: GenericConstraintFunction<T>, expects?: OneOrMany<string>): Decorator<'property' | 'accessor'>;

package/schema-old/decorators/constraint.js

@@ -1,7 +0,0 @@
-import { GenericConstraint } from '../constraints/generic.js';
-import { createSchemaValueConstraintDecorator } from './utils.js';
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export function Constraint(constraintFunction, expects) {
-    const constraint = new GenericConstraint(constraintFunction, expects);
-    return createSchemaValueConstraintDecorator(constraint);
-}

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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,17 +0,0 @@
-/* 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

@@ -1,19 +0,0 @@
-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

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

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

@@ -1,15 +0,0 @@
-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

@@ -1,48 +0,0 @@
-/* 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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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;
-    }
-}