@tstdl/base 0.91.0-beta9 → 0.91.1

package/utils/iterable-helpers/group-to-single-map.d.ts

@@ -1,2 +1,3 @@
-import type { IteratorFunction } from './types.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
 export declare function groupToSingleMap<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): Map<TGroup, TIn>;
+export declare function groupToSingleMap<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn>;

package/utils/iterable-helpers/group-to-single-map.js

@@ -1,12 +1,26 @@
-export function groupToSingleMap(iterable, selector) {
-    const map = new Map();
+import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
+export function groupToSingleMap(iterable, ...selectors) {
     let index = 0;
+    if (selectors.length == 1) {
+        const selector = selectors[0];
+        const map = new Map();
+        for (const item of iterable) {
+            const groupKey = selector(item, index++);
+            if (map.has(groupKey)) {
+                throw new Error(`Group ${String(groupKey)} has more than one item.`);
+            }
+            map.set(groupKey, item);
+        }
+        return map;
+    }
+    const map = new MultiKeyMap();
     for (const item of iterable) {
-        const groupKey = selector(item, index++);
-        if (map.has(groupKey)) {
-            throw new Error('group has more than one item');
+        const groupKeys = selectors.map((selector) => selector(item, index)); // eslint-disable-line @typescript-eslint/no-loop-func
+        index++;
+        if (map.has(groupKeys)) {
+            throw new Error(`Group [${groupKeys.map((key) => String(key)).join(', ')}] has more than one item.`);
         }
-        map.set(groupKey, item);
+        map.set(groupKeys, item);
     }
-    return map;
+    return map.toMap();
 }

package/utils/iterable-helpers/group.d.ts

@@ -1,2 +1,3 @@
-import type { IteratorFunction } from './types.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
 export declare function group<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): IterableIterator<[TGroup, TIn[]]>;
+export declare function group<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): IterableIterator<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn[]]>;

package/utils/iterable-helpers/group.js

@@ -1,4 +1,4 @@
 import { groupToMap } from './group-to-map.js';
-export function group(iterable, selector) {
-    return groupToMap(iterable, selector)[Symbol.iterator]();
+export function group(iterable, ...selectors) {
+    return groupToMap(iterable, ...selectors)[Symbol.iterator]();
 }

package/utils/iterable-helpers/types.d.ts

@@ -12,3 +12,6 @@ export type IterableItemMetadata<T> = {
     isLast: boolean;
     value: T;
 };
+export type GroupSelectors<T, TGroup extends any[]> = {
+    [P in keyof TGroup]: IteratorFunction<T, TGroup[P]>;
+};

package/schema-old/array-constraints/index.d.ts

@@ -1,2 +0,0 @@
-export * from './maximum-length.js';
-export * from './minimum-length.js';

package/schema-old/array-constraints/index.js

@@ -1,2 +0,0 @@
-export * from './maximum-length.js';
-export * from './minimum-length.js';

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

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class ArrayMaximumLengthConstraint extends SchemaArrayConstraint {
-    private readonly maximumLength;
-    readonly expects: string;
-    constructor(maximumLength: number);
-    validate(value: any[], path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function ArrayMaximumLength(maximumLength: number): Decorator<'property' | 'accessor'>;

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

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaArrayConstraintDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-export class ArrayMaximumLengthConstraint extends SchemaArrayConstraint {
-    maximumLength;
-    expects;
-    constructor(maximumLength) {
-        super();
-        this.maximumLength = maximumLength;
-        this.expects = `a maximum array length of ${this.maximumLength}`;
-    }
-    validate(value, path, context) {
-        if (value.length > this.maximumLength) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function ArrayMaximumLength(maximumLength) {
-    return createSchemaArrayConstraintDecorator(new ArrayMaximumLengthConstraint(maximumLength));
-}

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

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class MinimumArrayLengthConstraint extends SchemaArrayConstraint {
-    private readonly minimumLength;
-    readonly expects: string;
-    constructor(minimumLength: number);
-    validate(value: any[], path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function MinimumArrayLength(minimumLength: number): Decorator<'property' | 'accessor'>;

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

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaArrayConstraintDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-export class MinimumArrayLengthConstraint extends SchemaArrayConstraint {
-    minimumLength;
-    expects;
-    constructor(minimumLength) {
-        super();
-        this.minimumLength = minimumLength;
-        this.expects = `a minimum array length of ${this.minimumLength}`;
-    }
-    validate(value, path, context) {
-        if (value.length < this.minimumLength) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function MinimumArrayLength(minimumLength) {
-    return createSchemaArrayConstraintDecorator(new MinimumArrayLengthConstraint(minimumLength));
-}

package/schema-old/coercers/boolean.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class BooleanCoercer extends SchemaValueCoercer {
-    readonly sourceType: (NumberConstructor | StringConstructor | BigIntConstructor)[];
-    readonly targetType: BooleanConstructor;
-    coerce(value: number | string | bigint, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const booleanCoercer: BooleanCoercer;

package/schema-old/coercers/boolean.coercer.js

@@ -1,27 +0,0 @@
-import { isString } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class BooleanCoercer extends SchemaValueCoercer {
-    sourceType = [Number, String, BigInt];
-    targetType = Boolean;
-    coerce(value, path, context) {
-        const normalizedValue = isString(value) ? value.toLowerCase() : value;
-        switch (normalizedValue) {
-            case 1:
-            case 1n:
-            case 'true':
-            case '1':
-            case 'yes':
-                return { success: true, value: true };
-            case 0:
-            case 0n:
-            case 'false':
-            case '0':
-            case 'no':
-                return { success: true, value: false };
-            default:
-                return { success: false, error: SchemaError.couldNotCoerce(Boolean, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-    }
-}
-export const booleanCoercer = new BooleanCoercer();

package/schema-old/coercers/date.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class DateCoercer extends SchemaValueCoercer {
-    readonly sourceType: (NumberConstructor | StringConstructor | BigIntConstructor)[];
-    readonly targetType: DateConstructor;
-    coerce(value: number | string | bigint, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const dateCoercer: DateCoercer;

package/schema-old/coercers/date.coercer.js

@@ -1,16 +0,0 @@
-import { isBigInt } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class DateCoercer extends SchemaValueCoercer {
-    sourceType = [Number, String, BigInt];
-    targetType = Date;
-    coerce(value, path, context) {
-        const parseValue = isBigInt(value) ? Number(value) : value;
-        const date = new Date(parseValue);
-        if (Number.isNaN(date.getTime())) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { success: true, value: date };
-    }
-}
-export const dateCoercer = new DateCoercer();

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

@@ -1,6 +0,0 @@
-export * from './boolean.coercer.js';
-export * from './date.coercer.js';
-export * from './number.coercer.js';
-export * from './regexp.coercer.js';
-export * from './string.coercer.js';
-export * from './uint8-array.coercer.js';

package/schema-old/coercers/index.js

@@ -1,6 +0,0 @@
-export * from './boolean.coercer.js';
-export * from './date.coercer.js';
-export * from './number.coercer.js';
-export * from './regexp.coercer.js';
-export * from './string.coercer.js';
-export * from './uint8-array.coercer.js';

package/schema-old/coercers/number.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class NumberCoercer extends SchemaValueCoercer {
-    readonly sourceType: (BooleanConstructor | StringConstructor | BigIntConstructor)[];
-    readonly targetType: NumberConstructor;
-    coerce(value: string | bigint | boolean, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const numberCoercer: NumberCoercer;

package/schema-old/coercers/number.coercer.js

@@ -1,14 +0,0 @@
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class NumberCoercer extends SchemaValueCoercer {
-    sourceType = [String, BigInt, Boolean];
-    targetType = Number;
-    coerce(value, path, context) {
-        const result = Number(value);
-        if (Number.isNaN(result)) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors, customMessage: 'Value is not a number.' }) };
-        }
-        return { success: true, value: result };
-    }
-}
-export const numberCoercer = new NumberCoercer();

package/schema-old/coercers/regexp.coercer.d.ts

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class RegExpCoercer extends SchemaValueCoercer {
-    readonly sourceType: StringConstructor;
-    readonly targetType: RegExpConstructor;
-    readonly flags: string | undefined;
-    constructor(flags?: string);
-    coerce(value: string, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const regExpCoercer: RegExpCoercer;

package/schema-old/coercers/regexp.coercer.js

@@ -1,20 +0,0 @@
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class RegExpCoercer extends SchemaValueCoercer {
-    sourceType = String;
-    targetType = RegExp;
-    flags;
-    constructor(flags = 'u') {
-        super();
-        this.flags = flags;
-    }
-    coerce(value, path, context) {
-        try {
-            return { success: true, value: RegExp(value, this.flags) };
-        }
-        catch (error) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid regexp pattern', path, { fast: context.options.fastErrors, customMessage: error.message }) };
-        }
-    }
-}
-export const regExpCoercer = new RegExpCoercer();

package/schema-old/coercers/string.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class StringCoercer extends SchemaValueCoercer {
-    readonly sourceType: (DateConstructor | NumberConstructor | BooleanConstructor | BigIntConstructor)[];
-    readonly targetType: StringConstructor;
-    coerce(value: number | boolean | bigint | Date, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const stringCoercer: StringCoercer;

package/schema-old/coercers/string.coercer.js

@@ -1,14 +0,0 @@
-import { isDate, isValidDate } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class StringCoercer extends SchemaValueCoercer {
-    sourceType = [Number, Boolean, BigInt, Date];
-    targetType = String;
-    coerce(value, path, context) {
-        if (isDate(value) && !isValidDate(value)) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid date', path, { fast: context.options.fastErrors }) };
-        }
-        return { success: true, value: value.toString() };
-    }
-}
-export const stringCoercer = new StringCoercer();

package/schema-old/coercers/uint8-array.coercer.d.ts

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Schema } from '../schema.js';
-import type { CoerceResult, CoercerContext } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class Uint8ArrayCoercer extends SchemaValueCoercer {
-    static readonly byteNumberArraySchema: Schema<number[]>;
-    readonly sourceType: ArrayConstructor;
-    readonly targetType: Uint8ArrayConstructor;
-    coerce(value: any[], path: JsonPath, { options }: CoercerContext): CoerceResult;
-}
-export declare const uint8ArrayCoercer: Uint8ArrayCoercer;

package/schema-old/coercers/uint8-array.coercer.js

@@ -1,22 +0,0 @@
-import { lazyProperty } from '../../utils/object/lazy-property.js';
-import { SchemaError } from '../schema.error.js';
-import { testSchema } from '../schema.js';
-import { array } from '../schemas/array.js';
-import { number } from '../schemas/number.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class Uint8ArrayCoercer extends SchemaValueCoercer {
-    static byteNumberArraySchema;
-    static {
-        lazyProperty(this, 'byteNumberArraySchema', () => array(number({ integer: true, minimum: 0, maximum: 255 })));
-    }
-    sourceType = Array;
-    targetType = Uint8Array;
-    coerce(value, path, { options }) {
-        const testResult = testSchema(Uint8ArrayCoercer.byteNumberArraySchema, value, options, path);
-        if (!testResult.valid) {
-            return { success: false, error: SchemaError.couldNotCoerce(Uint8Array, Array, path, { inner: testResult.error, fast: options.fastErrors }) };
-        }
-        return { success: true, value: Uint8Array.from(testResult.value) };
-    }
-}
-export const uint8ArrayCoercer = new Uint8ArrayCoercer();

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

@@ -1,13 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Enumeration, EnumerationValue, OneOrMany } from '../../types.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class EnumerationConstraint extends SchemaValueConstraint {
-    private readonly allowedValuesString;
-    readonly enumeration: Enumeration;
-    readonly allowedValuesSet: Set<EnumerationValue>;
-    readonly suitableTypes: SchemaValueConstraint['suitableTypes'];
-    readonly expects: OneOrMany<string>;
-    constructor(enumeration: Enumeration);
-    validate(value: number, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}

package/schema-old/constraints/enumeration.js

@@ -1,29 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { enumValues } from '../../utils/enum.js';
-import { distinct } from '../../utils/iterable-helpers/distinct.js';
-import { isArray, isString } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { getValueType } from '../utils/value-type.js';
-export class EnumerationConstraint extends SchemaValueConstraint {
-    allowedValuesString;
-    enumeration;
-    allowedValuesSet;
-    suitableTypes;
-    expects;
-    constructor(enumeration) {
-        super();
-        this.enumeration = enumeration;
-        const allowedValues = isArray(enumeration) ? enumeration : enumValues(enumeration);
-        this.allowedValuesSet = new Set(allowedValues);
-        this.allowedValuesString = allowedValues.map((value) => (isString(value) ? `"${value}"` : value)).join(', ');
-        this.suitableTypes = [...distinct(allowedValues.map((value) => getValueType(value)))];
-        this.expects = `one of [${this.allowedValuesString}]`;
-    }
-    validate(value, path, context) {
-        if (!this.allowedValuesSet.has(value)) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}

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

@@ -1,20 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { OneOrMany } from '../../types.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export type GenericConstraintResult = {
-    success: true;
-    error?: undefined;
-} | {
-    success: false;
-    error: string | SchemaError;
-};
-export type GenericConstraintFunction<T> = (value: T, path: JsonPath) => boolean | ConstraintResult;
-export declare class GenericConstraint<T> extends SchemaValueConstraint {
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: OneOrMany<string>;
-    readonly constraintFunction: GenericConstraintFunction<T>;
-    constructor(constraintFunction: GenericConstraintFunction<T>, expects?: OneOrMany<string>);
-    validate(value: T, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}

package/schema-old/constraints/generic.js

@@ -1,23 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isBoolean } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-export class GenericConstraint extends SchemaValueConstraint {
-    suitableTypes = Number;
-    expects;
-    constraintFunction;
-    constructor(constraintFunction, expects = 'valid value') {
-        super();
-        this.constraintFunction = constraintFunction;
-        this.expects = expects;
-    }
-    validate(value, path, context) {
-        const result = this.constraintFunction(value, path);
-        if (isBoolean(result)) {
-            return result
-                ? { valid: true }
-                : { valid: false, error: SchemaError.expectedButGot(this.expects, 'invalid value', path, { fast: context.options.fastErrors }) };
-        }
-        return result;
-    }
-}

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

@@ -1,12 +0,0 @@
-export * from './enumeration.js';
-export * from './generic.js';
-export * from './integer.js';
-export * from './length.js';
-export * from './literal.js';
-export * from './maximum.js';
-export * from './maximum-date.js';
-export * from './maximum-length.js';
-export * from './minimum.js';
-export * from './minimum-date.js';
-export * from './minimum-length.js';
-export * from './pattern.js';

package/schema-old/constraints/index.js

@@ -1,12 +0,0 @@
-export * from './enumeration.js';
-export * from './generic.js';
-export * from './integer.js';
-export * from './length.js';
-export * from './literal.js';
-export * from './maximum.js';
-export * from './maximum-date.js';
-export * from './maximum-length.js';
-export * from './minimum.js';
-export * from './minimum-date.js';
-export * from './minimum-length.js';
-export * from './pattern.js';

package/schema-old/constraints/integer.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 IntegerConstraint extends SchemaValueConstraint {
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: string;
-    constructor();
-    validate(value: number, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare const integerConstraint: IntegerConstraint;
-export declare function Integer(): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/integer.js

@@ -1,23 +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 IntegerConstraint extends SchemaValueConstraint {
-    suitableTypes = Number;
-    expects;
-    constructor() {
-        super();
-        this.expects = 'an integer';
-    }
-    validate(value, path, context) {
-        if (!Number.isInteger(value)) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export const integerConstraint = new IntegerConstraint();
-export function Integer() {
-    return createSchemaValueConstraintDecorator(integerConstraint, { schema: typeSchema(Number) });
-}

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

@@ -1,6 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-export type LengthConstraintOptions = {
-    minimum?: number;
-    maximum?: number;
-};
-export declare function Length(options: LengthConstraintOptions): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/length.js

@@ -1,15 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isDefined } from '../../utils/type-guards.js';
-import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
-import { MaximumLengthConstraint } from './maximum-length.js';
-import { MinimumLengthConstraint } from './minimum-length.js';
-export function Length(options) {
-    const constraints = [];
-    if (isDefined(options.minimum)) {
-        constraints.push(new MinimumLengthConstraint(options.minimum));
-    }
-    if (isDefined(options.maximum)) {
-        constraints.push(new MaximumLengthConstraint(options.maximum));
-    }
-    return createSchemaValueConstraintDecorator(constraints);
-}

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

@@ -1,10 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class LiteralConstraint extends SchemaValueConstraint {
-    readonly literal: any;
-    readonly suitableTypes: SchemaValueConstraint['suitableTypes'];
-    readonly expects: string;
-    constructor(literal: any);
-    validate(value: any, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}

package/schema-old/constraints/literal.js

@@ -1,24 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isPrimitive } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { getValueType, getValueTypeName } from '../utils/value-type.js';
-export class LiteralConstraint extends SchemaValueConstraint {
-    literal;
-    suitableTypes;
-    expects;
-    constructor(literal) {
-        super();
-        this.literal = literal;
-        this.suitableTypes = getValueType(literal);
-        const literalName = isPrimitive(literal) ? String(literal) : getValueTypeName(this.suitableTypes);
-        this.expects = `literal ${literalName}`;
-    }
-    validate(value, path, context) {
-        if (value !== this.literal) {
-            const valueType = getValueType(value);
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, getValueTypeName(valueType), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}

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'>;