@tstdl/base 0.91.0 → 0.91.2

package/schema-old/schema.js

@@ -1,283 +0,0 @@
-import { JsonPath } from '../json-path/index.js';
-import { toArray } from '../utils/array/array.js';
-import { noop } from '../utils/noop.js';
-import { objectKeys } from '../utils/object/object.js';
-import { differenceSets } from '../utils/set.js';
-import { isArray, isDefined, isFunction, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
-import { booleanCoercer, dateCoercer, numberCoercer, regExpCoercer, stringCoercer, uint8ArrayCoercer } from './coercers/index.js';
-import { SchemaError } from './schema.error.js';
-import { isObjectSchema, isTransformErrorResult, isTypeSchema, isValueSchema, resolveValueType, resolveValueTypes, schemaTestableToSchema, transformErrorResultSymbol } from './types/index.js';
-import { getArrayItemSchema, getSchemaTypeNames, getSchemaValueTypes, getValueType, includesValueType, normalizeObjectSchema, normalizeValueSchema, tryGetObjectSchemaFromReflection } from './utils/index.js';
-const defaultCoercers = new Map();
-let initialize = () => {
-    Schema.registerDefaultCoercer(numberCoercer);
-    Schema.registerDefaultCoercer(booleanCoercer);
-    Schema.registerDefaultCoercer(stringCoercer);
-    Schema.registerDefaultCoercer(dateCoercer);
-    Schema.registerDefaultCoercer(regExpCoercer);
-    Schema.registerDefaultCoercer(uint8ArrayCoercer);
-    initialize = noop;
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
-export const Schema = {
-    registerDefaultCoercer(coercer) {
-        for (const sourceType of toArray(coercer.sourceType)) {
-            if (!defaultCoercers.has(sourceType)) {
-                defaultCoercers.set(sourceType, []);
-            }
-            defaultCoercers.get(sourceType).push(coercer);
-        }
-    },
-    test(schemaOrValueType, value, options, path = JsonPath.ROOT) {
-        const normalizedOptions = { fastErrors: true, ...options };
-        const schema = schemaTestableToSchema(schemaOrValueType);
-        const result = testSchema(schema, value, normalizedOptions, path);
-        if (result.valid) {
-            return result;
-        }
-        if (isUndefined(result.error.stack)) {
-            result.error.stack = new Error().stack;
-        }
-        return result;
-    },
-    validate(schemaOrValueType, value, options) {
-        const schema = schemaTestableToSchema(schemaOrValueType);
-        const result = this.test(schema, value, options);
-        return result.valid;
-    },
-    parse(schemaOrValueType, value, options) {
-        const schema = schemaTestableToSchema(schemaOrValueType);
-        const result = this.test(schema, value, options);
-        if (result.valid) {
-            return result.value;
-        }
-        throw result.error;
-    },
-    function(argumentSchemas, returnSchema, handler) {
-        const name = `validated${handler.name.slice(0, 1).toUpperCase()}${handler.name.slice(1)}`;
-        const schema = getFunctionParametersSchema(argumentSchemas);
-        return {
-            [name](...unsafeArgs) {
-                const safeArgs = Schema.parse(schema, unsafeArgs, { mask: true }); // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
-                const unsafeResult = handler(...safeArgs);
-                return Schema.parse(returnSchema, unsafeResult); // eslint-disable-line @typescript-eslint/no-unsafe-return
-            }
-        }[name];
-    },
-    asyncFunction(argumentSchemas, returnSchema, handler) {
-        const name = `validated${handler.name.slice(0, 1).toUpperCase()}${handler.name.slice(1)}`;
-        const schema = getFunctionParametersSchema(argumentSchemas);
-        return {
-            async [name](...unsafeArgs) {
-                const safeArgs = Schema.parse(schema, unsafeArgs, { mask: true }); // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
-                const unsafeResult = await handler(...safeArgs);
-                return Schema.parse(returnSchema, unsafeResult); // eslint-disable-line @typescript-eslint/no-unsafe-return
-            }
-        }[name];
-    }
-};
-function getFunctionParametersSchema(argumentSchemas) {
-    const schema = {
-        factory: { type: Array },
-        properties: {}
-    };
-    argumentSchemas.forEach((arg, index) => (schema.properties[index] = arg));
-    return schema;
-}
-export function testSchema(schema, value, options, path = JsonPath.ROOT) {
-    initialize();
-    if (isValueSchema(schema)) {
-        return testValue(schema, value, options, path);
-    }
-    if (isTypeSchema(schema)) {
-        return testType(schema, value, options, path);
-    }
-    if (isObjectSchema(schema)) {
-        return testObject(schema, value, options, path);
-    }
-    throw new Error('Unsupported schema');
-}
-function testType(schema, value, options = {}, path = JsonPath.ROOT) {
-    const resolvedValueType = resolveValueType(schema.type);
-    if (isFunction(resolvedValueType)) {
-        if ((value instanceof resolvedValueType) || (getValueType(value) == resolvedValueType)) {
-            return { valid: true, value: value };
-        }
-        const objectSchema = tryGetObjectSchemaFromReflection(resolvedValueType);
-        if (isNotNull(objectSchema)) {
-            return testObject(objectSchema, value, options, path);
-        }
-    }
-    else if ((resolvedValueType == 'any') || ((resolvedValueType == 'null') && isNull(value)) || ((resolvedValueType == 'undefined') && isUndefined(value))) {
-        return { valid: true, value: value };
-    }
-    return { valid: false, error: SchemaError.expectedButGot(resolvedValueType, getValueType(value), path, { fast: options.fastErrors }) };
-}
-// eslint-disable-next-line complexity
-function testObject(objectSchema, value, options = {}, path = JsonPath.ROOT) {
-    if (!(value instanceof Object)) {
-        return { valid: false, error: SchemaError.expectedButGot(objectSchema.sourceType ?? 'object', getValueType(value), path, { fast: options.fastErrors }) };
-    }
-    const schema = normalizeObjectSchema(objectSchema);
-    const mask = schema.mask ?? options.mask ?? false;
-    const resultValue = isDefined(schema.factory?.type) ? new schema.factory.type() : {};
-    const schemaPropertyKeys = objectKeys(schema.properties);
-    const valuePropertyKeys = objectKeys(value);
-    const unknownValuePropertyKeys = differenceSets(new Set(valuePropertyKeys), new Set(schemaPropertyKeys));
-    if ((unknownValuePropertyKeys.length > 0) && !mask && !schema.allowUnknownProperties) {
-        return { valid: false, error: new SchemaError('Unknown property', { path: path.add(unknownValuePropertyKeys[0]), fast: options.fastErrors }) };
-    }
-    for (const key of schemaPropertyKeys) {
-        const propertyResult = testSchema(schema.properties[key], value[key], options, path.add(key));
-        if (!propertyResult.valid) {
-            return propertyResult;
-        }
-        resultValue[key] = propertyResult.value;
-    }
-    if (schema.allowUnknownProperties) {
-        for (const key of unknownValuePropertyKeys) {
-            const propertyPath = path.add(key);
-            if (isDefined(schema.unknownPropertiesKey)) {
-                const keyResult = testSchema(schema.unknownPropertiesKey, key, options);
-                if (!keyResult.valid && !mask) {
-                    return { valid: false, error: new SchemaError('Invalid property key.', { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
-                }
-            }
-            const propertyResult = testSchema(schema.unknownProperties, value[key], options, path.add(key));
-            if (!propertyResult.valid && !mask) {
-                return propertyResult;
-            }
-            resultValue[key] = propertyResult.value;
-        }
-    }
-    const testResultValue = isUndefined(schema.factory) ? resultValue : isDefined(schema.factory.type) ? resultValue : schema.factory.builder(resultValue);
-    return { valid: true, value: testResultValue };
-}
-// eslint-disable-next-line max-lines-per-function, max-statements, complexity
-function testValue(schema, value, options = {}, path = JsonPath.ROOT) {
-    const normalizedValueSchema = normalizeValueSchema(schema);
-    if (normalizedValueSchema.optional && isUndefined(value)) {
-        return { valid: true, value: value };
-    }
-    if (normalizedValueSchema.nullable && isNull(value)) {
-        return { valid: true, value: value };
-    }
-    const context = {
-        schema: normalizedValueSchema,
-        options
-    };
-    /** handle arrays */
-    if (normalizedValueSchema.array) {
-        if (!isArray(value)) {
-            if (normalizedValueSchema.coerce) {
-                return testValue(schema, [value], options, path);
-            }
-            return { valid: false, error: SchemaError.expectedButGot(Array, getValueType(value), path, { fast: options.fastErrors }) };
-        }
-        for (const arrayConstraint of normalizedValueSchema.arrayConstraints) {
-            const result = arrayConstraint.validate(value, path, context);
-            if (!result.valid) {
-                return { valid: false, error: result.error };
-            }
-        }
-        const itemSchema = getArrayItemSchema(schema);
-        const validatedItems = [];
-        for (let i = 0; i < value.length; i++) {
-            const result = testValue(itemSchema, value[i], options, path.add(i));
-            if (!result.valid) {
-                return result;
-            }
-            validatedItems.push(result.value);
-        }
-        return { valid: true, value: validatedItems };
-    }
-    let valueTestResult;
-    let resultValue;
-    let valueType;
-    function updateCurrentState(newValue) {
-        valueTestResult = isValidValue(normalizedValueSchema.schema, newValue, options, path);
-        resultValue = valueTestResult.valid ? valueTestResult.value : newValue;
-        valueType = getValueType(resultValue);
-    }
-    updateCurrentState(value);
-    /** try to coerce */
-    if (!valueTestResult.valid) {
-        const targetTypes = getSchemaValueTypes(schema);
-        const coercers = [
-            ...(normalizedValueSchema.coercers.get(valueType) ?? []),
-            ...((normalizedValueSchema.coerce || options.coerce == true) ? (defaultCoercers.get(valueType) ?? []) : [])
-        ]
-            .filter((coercer) => includesValueType(coercer.targetType, targetTypes));
-        const errors = [];
-        let success = false;
-        for (const coercer of coercers) {
-            const coerceResult = coercer.coerce(resultValue, path, context);
-            if (!coerceResult.success) {
-                errors.push(coerceResult.error);
-                continue;
-            }
-            success = true;
-            updateCurrentState(coerceResult.value);
-            break;
-        }
-        if (!success && (errors.length > 0)) {
-            return { valid: false, error: (errors.length == 1) ? errors[0] : new SchemaError('Value could not be coerced.', { inner: errors, path, fast: options.fastErrors }) };
-        }
-    }
-    if (!valueTestResult.valid) {
-        return valueTestResult;
-    }
-    if (normalizedValueSchema.valueConstraints.length > 0) {
-        const errors = [];
-        for (const constraint of normalizedValueSchema.valueConstraints) {
-            const result = constraint.validate(resultValue, path, context);
-            if (!result.valid) {
-                errors.push(result.error);
-            }
-        }
-        if (errors.length > 0) {
-            return { valid: false, error: (errors.length == 1) ? errors[0] : new SchemaError('Value did not match schema.', { path, inner: errors, fast: options.fastErrors }) };
-        }
-    }
-    if (normalizedValueSchema.transformers.length > 0) {
-        for (const transformer of normalizedValueSchema.transformers) {
-            if (isDefined(transformer.sourceType) && !includesValueType(valueType, resolveValueTypes(transformer.sourceType))) {
-                continue;
-            }
-            const transformResult = transformer.transform(resultValue, path, context);
-            if (isTransformErrorResult(transformResult)) {
-                return { valid: false, error: transformResult[transformErrorResultSymbol] };
-            }
-            return { valid: true, value: transformResult };
-        }
-    }
-    return { valid: true, value: resultValue };
-}
-function isValidValue(validSchemas, value, options, path) {
-    const errorResults = [];
-    for (const schema of validSchemas) {
-        const result = testSchema(schema, value, options, path);
-        if (result.valid) {
-            return result;
-        }
-        errorResults.push(result);
-    }
-    if (errorResults.length == 1) {
-        return errorResults[0];
-    }
-    const errors = errorResults.map((result) => result.error);
-    const expectStrings = [];
-    for (const schema of validSchemas) {
-        expectStrings.push(getExpectString(schema));
-    }
-    const expectString = expectStrings.length > 1 ? `(${expectStrings.join(' | ')})` : expectStrings[0];
-    return { valid: false, error: SchemaError.expectedButGot(expectString, getValueType(value), path, { inner: errors, fast: options.fastErrors }) };
-}
-export function getExpectString(schema) {
-    const expectedNames = getSchemaTypeNames(schema);
-    const arraySuffix = (isValueSchema(schema) && (schema.array == true)) ? '[]' : '';
-    const expectedTypeString = (expectedNames.length == 1) ? `${expectedNames[0]}${arraySuffix}` : `(${expectedNames.join(' | ')})${arraySuffix}`;
-    const expects = isValueSchema(schema) ? toArray(schema.valueConstraints ?? []).map((constraint) => constraint.expects) : [];
-    const expectsString = (expects.length > 0) ? `[${expects.join(', ')}]` : '';
-    return `${expectedTypeString}${expectsString}`;
-}

package/schema-old/schemas/any.d.ts

@@ -1,5 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type AnyOptions = ValueSchemaOptions;
-export declare function any(options?: AnyOptions): ValueSchema<any>;
-export declare function Any(options?: AnyOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/any.js

@@ -1,9 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
-export function any(options) {
-    return valueSchema('any', options);
-}
-export function Any(options) {
-    return createSchemaPropertyDecoratorFromSchema(any(options));
-}

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

@@ -1,12 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { OneOrMany } from '../../types.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type ArrayOptions = ValueSchemaOptions & {
-    /** minimum array length */
-    minimumLength?: number;
-    /** maximum array length */
-    maximumLength?: number;
-};
-export declare function array<T>(innerValues: OneOrMany<SchemaTestable<T>>, options?: ArrayOptions): ValueSchema<T[]>;
-export declare function Array(innerValues: OneOrMany<SchemaTestable>, options?: ArrayOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/array.js

@@ -1,23 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { ArrayMaximumLengthConstraint } from '../array-constraints/maximum-length.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { valueSchema } from '../types/types.js';
-export function array(innerValues, options = {}) {
-    const arrayConstraints = toArrayCopy(options.arrayConstraints ?? []);
-    if (isDefined(options.minimumLength)) {
-        arrayConstraints.push(new ArrayMaximumLengthConstraint(options.minimumLength));
-    }
-    if (isDefined(options.maximumLength)) {
-        arrayConstraints.push(new ArrayMaximumLengthConstraint(options.maximumLength));
-    }
-    return valueSchema(innerValues, {
-        ...options,
-        array: true,
-        arrayConstraints
-    });
-}
-export function Array(innerValues, options) {
-    return createSchemaPropertyDecoratorFromSchema(array(innerValues, options));
-}

package/schema-old/schemas/assign.d.ts

@@ -1,7 +0,0 @@
-import type { Merge } from '../../types.js';
-import type { ObjectSchema, ObjectSchemaOrType } from '../types/index.js';
-export declare function assign<T1, T2>(schema1: ObjectSchemaOrType<T1>, schema2: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
-export declare function assign<T1, T2, T3>(schema1: ObjectSchemaOrType<T1>, schema2: ObjectSchemaOrType<T2>, schema3: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
-export declare function assign<T1, T2, T3, T4>(schema1: ObjectSchemaOrType<T1>, schema2: ObjectSchemaOrType<T2>, schema3: ObjectSchemaOrType<T3>, schema4: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<T1, T2>, Merge<T3, T4>>>;
-export declare function assign<T1, T2, T3, T4, T5>(schema1: ObjectSchemaOrType<T1>, schema2: ObjectSchemaOrType<T2>, schema3: ObjectSchemaOrType<T3>, schema4: ObjectSchemaOrType<T4>, schema5: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<T1, T2>, Merge<T3, T4>>, T5>>;
-export declare function assign<T1, T2, T3, T4, T5, T6>(schema1: ObjectSchemaOrType<T1>, schema2: ObjectSchemaOrType<T2>, schema3: ObjectSchemaOrType<T3>, schema4: ObjectSchemaOrType<T4>, schema5: ObjectSchemaOrType<T5>, schema6: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<T1, T2>, Merge<T3, T4>>, Merge<T5, T6>>>;

package/schema-old/schemas/assign.js

@@ -1,24 +0,0 @@
-import { toArray } from '../../utils/array/array.js';
-import { assert } from '../../utils/type-guards.js';
-import { objectSchema } from '../types/index.js';
-import { getObjectSchema } from '../utils/index.js';
-export function assign(...inputs) {
-    const schemas = inputs.map(getObjectSchema);
-    assert(schemas.length >= 2, 'Assign requires at least 2 schemas.');
-    let result = schemas[0];
-    for (let i = 1; i < schemas.length; i++) {
-        result = {
-            ...result,
-            ...schemas[i],
-            properties: {
-                ...result.properties,
-                ...schemas[i].properties
-            },
-            unknownProperties: [...toArray(result.unknownProperties ?? []), ...toArray(schemas[i].unknownProperties ?? [])],
-            unknownPropertiesKey: [...toArray(result.unknownPropertiesKey ?? []), ...toArray(schemas[i].unknownPropertiesKey ?? [])]
-        };
-    }
-    result.sourceType = undefined;
-    result.factory = undefined;
-    return objectSchema(result);
-}

package/schema-old/schemas/boolean.d.ts

@@ -1,5 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type BooleanOptions = ValueSchemaOptions;
-export declare function boolean(options?: BooleanOptions): ValueSchema<boolean>;
-export declare function BooleanProperty(options?: BooleanOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/boolean.js

@@ -1,9 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
-export function boolean(options = {}) {
-    return valueSchema(Boolean, options);
-}
-export function BooleanProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(boolean(options));
-}

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

@@ -1,5 +0,0 @@
-import type { OneOrMany } from '../../types.js';
-import type { GenericConstraintFunction } from '../constraints/generic.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema } from '../types/index.js';
-export declare function constraint<T>(schema: SchemaTestable<T>, constraintFunction: GenericConstraintFunction<T>, expects?: OneOrMany<string>): ValueSchema<T>;

package/schema-old/schemas/constraint.js

@@ -1,7 +0,0 @@
-import { GenericConstraint } from '../constraints/generic.js';
-import { valueSchema } from '../types/index.js';
-export function constraint(schema, constraintFunction, expects) {
-    return valueSchema(schema, {
-        valueConstraints: new GenericConstraint(constraintFunction, expects)
-    });
-}

package/schema-old/schemas/date.d.ts

@@ -1,8 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type DateOptions = ValueSchemaOptions & {
-    minimum?: Date | number;
-    maximum?: Date | number;
-};
-export declare function date(options?: DateOptions): ValueSchema<Date>;
-export declare function DateProperty(options?: DateOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/date.js

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { MaximumDateConstraint, MinimumDateConstraint } from '../constraints/index.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/types.js';
-export function date(options = {}) {
-    const constraints = toArrayCopy(options.valueConstraints ?? []);
-    if (isDefined(options.minimum)) {
-        constraints.push(new MinimumDateConstraint(options.minimum));
-    }
-    if (isDefined(options.maximum)) {
-        constraints.push(new MaximumDateConstraint(options.maximum));
-    }
-    return valueSchema(Date, {
-        ...options,
-        valueConstraints: constraints
-    });
-}
-export function DateProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(date(options));
-}

package/schema-old/schemas/defaulted.d.ts

@@ -1,6 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { OneOrMany } from '../../types.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema } from '../types/index.js';
-export declare function defaulted<T, Default>(type: OneOrMany<SchemaTestable<T>>, defaultValue: Default): ValueSchema<NonNullable<T> | Default>;
-export declare function Defaulted(type: OneOrMany<SchemaTestable>, defaultValue: any): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/defaulted.js

@@ -1,10 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { valueSchema } from '../types/index.js';
-import { transform } from './transform.js';
-export function defaulted(type, defaultValue) {
-    return transform(valueSchema(type, { optional: true, nullable: true }), (value) => value ?? defaultValue); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-}
-export function Defaulted(type, defaultValue) {
-    return createSchemaPropertyDecoratorFromSchema(defaulted(type, defaultValue));
-}

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

@@ -1,6 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { Enumeration as EnumerationType, EnumerationValue } from '../../types.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type EnumerationOptions = ValueSchemaOptions;
-export declare function enumeration<T extends EnumerationType>(enumerationValue: T, options?: EnumerationOptions): ValueSchema<EnumerationValue<T>>;
-export declare function Enumeration(enumerationValue: EnumerationType, options?: EnumerationOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/enumeration.js

@@ -1,17 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { EnumerationConstraint } from '../constraints/index.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/types.js';
-export function enumeration(enumerationValue, options) {
-    const valueConstraints = toArrayCopy(options?.valueConstraints ?? []);
-    const enumerationConstraint = new EnumerationConstraint(enumerationValue);
-    valueConstraints.push(enumerationConstraint);
-    return valueSchema(enumerationConstraint.suitableTypes, {
-        ...options,
-        valueConstraints
-    });
-}
-export function Enumeration(enumerationValue, options) {
-    return createSchemaPropertyDecoratorFromSchema(enumeration(enumerationValue, options));
-}

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

@@ -1,26 +0,0 @@
-export * from './any.js';
-export * from './array.js';
-export * from './assign.js';
-export * from './boolean.js';
-export * from './constraint.js';
-export * from './date.js';
-export * from './defaulted.js';
-export * from './enumeration.js';
-export * from './instance.js';
-export * from './literal.js';
-export * from './nullable.js';
-export * from './number.js';
-export * from './object.js';
-export * from './omit.js';
-export * from './one-or-many.js';
-export * from './optional.js';
-export * from './partial.js';
-export * from './pick.js';
-export * from './readable-stream.js';
-export * from './record.js';
-export * from './regexp.js';
-export * from './string.js';
-export * from './transform.js';
-export * from './uint8-array.js';
-export * from './union.js';
-export * from './unknown.js';

package/schema-old/schemas/index.js

@@ -1,26 +0,0 @@
-export * from './any.js';
-export * from './array.js';
-export * from './assign.js';
-export * from './boolean.js';
-export * from './constraint.js';
-export * from './date.js';
-export * from './defaulted.js';
-export * from './enumeration.js';
-export * from './instance.js';
-export * from './literal.js';
-export * from './nullable.js';
-export * from './number.js';
-export * from './object.js';
-export * from './omit.js';
-export * from './one-or-many.js';
-export * from './optional.js';
-export * from './partial.js';
-export * from './pick.js';
-export * from './readable-stream.js';
-export * from './record.js';
-export * from './regexp.js';
-export * from './string.js';
-export * from './transform.js';
-export * from './uint8-array.js';
-export * from './union.js';
-export * from './unknown.js';

package/schema-old/schemas/instance.d.ts

@@ -1,3 +0,0 @@
-import type { ValueSchema, ValueSchemaOptions, ValueType } from '../types/index.js';
-export type InstanceOptions = ValueSchemaOptions;
-export declare function instance<T>(type: ValueType<T>, options?: InstanceOptions): ValueSchema<T>;

package/schema-old/schemas/instance.js

@@ -1,5 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { valueSchema } from '../types/index.js';
-export function instance(type, options) {
-    return valueSchema(type, options);
-}

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

@@ -1,5 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type LiteralOptions = ValueSchemaOptions;
-export declare function literal<const T>(value: T, options?: LiteralOptions): ValueSchema<T>;
-export declare function Literal(value: any): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/literal.js

@@ -1,17 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { LiteralConstraint } from '../constraints/index.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/types.js';
-import { getValueType } from '../utils/value-type.js';
-export function literal(value, options) {
-    const valueConstraints = toArrayCopy(options?.valueConstraints ?? []);
-    valueConstraints.push(new LiteralConstraint(value));
-    return valueSchema(getValueType(value), {
-        ...options,
-        valueConstraints
-    });
-}
-export function Literal(value) {
-    return createSchemaPropertyDecoratorFromSchema(literal(value));
-}

package/schema-old/schemas/nullable.d.ts

@@ -1,6 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type NullableOptions = ValueSchemaOptions;
-export declare function nullable<T>(schema: SchemaTestable<T>, options?: NullableOptions): ValueSchema<T | null>;
-export declare function Nullable(options?: NullableOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/nullable.js

@@ -1,9 +0,0 @@
-import { createSchemaPropertyDecorator } from '../decorators/utils.js';
-import { valueSchema } from '../types/index.js';
-export function nullable(schema, options) {
-    return valueSchema(schema, { ...options, nullable: true });
-}
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export function Nullable(options) {
-    return createSchemaPropertyDecorator({ ...options, nullable: true });
-}

package/schema-old/schemas/number.d.ts

@@ -1,9 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type NumberOptions = ValueSchemaOptions & {
-    minimum?: number;
-    maximum?: number;
-    integer?: boolean;
-};
-export declare function number(options?: NumberOptions): ValueSchema<number>;
-export declare function NumberProperty(options?: NumberOptions): Decorator<'property' | 'accessor'>;

package/schema-old/schemas/number.js

@@ -1,27 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { integerConstraint } from '../constraints/integer.js';
-import { MaximumConstraint } from '../constraints/maximum.js';
-import { MinimumConstraint } from '../constraints/minimum.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { valueSchema } from '../types/types.js';
-export function number(options = {}) {
-    const valueConstraints = toArrayCopy(options.valueConstraints ?? []);
-    if (isDefined(options.minimum)) {
-        valueConstraints.push(new MinimumConstraint(options.minimum));
-    }
-    if (isDefined(options.maximum)) {
-        valueConstraints.push(new MaximumConstraint(options.maximum));
-    }
-    if (options.integer == true) {
-        valueConstraints.push(integerConstraint);
-    }
-    return valueSchema(Number, {
-        ...options,
-        valueConstraints
-    });
-}
-export function NumberProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(number(options));
-}

package/schema-old/schemas/object.d.ts

@@ -1,7 +0,0 @@
-import type { ObjectLiteral, Optionalize, Record, SimplifyObject, TypedOmit } from '../../types.js';
-import type { IfNever } from 'type-fest';
-import { type ObjectSchema, type ObjectSchemaProperties, type TypedObjectSchemaUnknownProperties } from '../types/index.js';
-export type ObjectOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey'>;
-export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T>): ObjectSchema<T>;
-export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<Optionalize<T> & IfNever<V, ObjectLiteral, Record<K, V>>>>;
-export declare const emptyObjectSchema: ObjectSchema<ObjectLiteral>;