@tstdl/base 0.90.92 → 0.91.0-beta10

package/schema/schemas/date.d.ts

@@ -1,8 +1,10 @@
-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;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type DateSchemaOptions = SimpleSchemaOptions & {
+    integer?: boolean;
 };
-export declare function date(options?: DateOptions): ValueSchema<Date>;
-export declare function DateProperty(options?: DateOptions): Decorator<'property' | 'accessor'>;
+export declare class DateSchema extends SimpleSchema<globalThis.Date> {
+    constructor(options?: DateSchemaOptions);
+}
+export declare function date(options?: DateSchemaOptions): DateSchema;
+export declare function DateProperty(options?: SchemaPropertyDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/date.js

@@ -1,22 +1,28 @@
-/* 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));
+import { isValidDate } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SimpleSchema } from './simple.js';
+export class DateSchema extends SimpleSchema {
+    constructor(options) {
+        super('date', isValidDate, options, {
+            coercers: {
+                string: (value, path, options) => {
+                    const result = new globalThis.Date(value);
+                    return globalThis.Number.isNaN(result.getTime())
+                        ? { success: false, error: SchemaError.couldNotCoerce('date', 'string', path, { fast: options.fastErrors }) }
+                        : { success: true, value: result, valid: true };
+                },
+                number: (value) => ({ success: true, value: new globalThis.Date(value), valid: false })
+            },
+            constraints: [
+                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
+            ]
+        });
     }
-    if (isDefined(options.maximum)) {
-        constraints.push(new MaximumDateConstraint(options.maximum));
-    }
-    return valueSchema(Date, {
-        ...options,
-        valueConstraints: constraints
-    });
+}
+export function date(options) {
+    return new DateSchema(options);
 }
 export function DateProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(date(options));
+    return Property(date(options), options);
 }

package/schema/schemas/defaulted.d.ts

@@ -1,6 +1,11 @@
-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'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class DefaultSchema<T, D> extends Schema<T | D> {
+    readonly schema: Schema<T>;
+    readonly defaultValue: D;
+    constructor(schema: SchemaTestable<T>, defaultValue: D);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | D>;
+}
+export declare function defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D): DefaultSchema<T, D>;
+export declare function Defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/defaulted.js

@@ -1,10 +1,25 @@
-/* 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
+import { isNullOrUndefined } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class DefaultSchema extends Schema {
+    schema;
+    defaultValue;
+    constructor(schema, defaultValue) {
+        super();
+        this.schema = schemaTestableToSchema(schema);
+        this.defaultValue = defaultValue;
+    }
+    _test(value, path, options) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true, value: this.defaultValue };
+        }
+        return this.schema._test(value, path, options);
+    }
 }
-export function Defaulted(type, defaultValue) {
-    return createSchemaPropertyDecoratorFromSchema(defaulted(type, defaultValue));
+export function defaulted(schema, defaultValue) {
+    return new DefaultSchema(schema, defaultValue);
+}
+export function Defaulted(schema, defaultValue, options) {
+    return Property(defaulted(schema, defaultValue), options);
 }

package/schema/schemas/enumeration.d.ts

@@ -1,6 +1,11 @@
-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'>;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type EnumerationSchemaOptions = SimpleSchemaOptions;
+export declare class EnumerationSchema<T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
+    #private;
+    readonly enumeration: EnumerationType;
+    constructor(enumeration: T, options?: EnumerationSchemaOptions);
+}
+export declare function enumeration<T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions): EnumerationSchema<T>;
+export declare function Enumeration(enumeration: EnumerationType, options?: EnumerationSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/enumeration.js

@@ -1,17 +1,27 @@
-/* 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
-    });
+import { enumValues } from '../../utils/enum.js';
+import { isArray, isString } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class EnumerationSchema extends SimpleSchema {
+    #allowedValuesSet;
+    enumeration;
+    constructor(enumeration, options) {
+        const allowedValues = isArray(enumeration) ? enumeration : enumValues(enumeration);
+        const allowedValuesString = allowedValues.map((value) => (isString(value) ? `"${value}"` : String(value))).join(', ');
+        super(`one of [${allowedValuesString}]`, (value) => this.#allowedValuesSet.has(value), options, {
+            coercers: {
+                string: (value) => ({ success: true, value: Number(value), valid: false }),
+                number: (value) => ({ success: true, value: String(value), valid: false })
+            },
+            gotValueFormatter: (value) => isString(value) ? `"${value}"` : String(value)
+        });
+        this.enumeration = enumeration;
+        this.#allowedValuesSet = new Set(allowedValues);
+    }
 }
-export function Enumeration(enumerationValue, options) {
-    return createSchemaPropertyDecoratorFromSchema(enumeration(enumerationValue, options));
+export function enumeration(enumeration, options) {
+    return new EnumerationSchema(enumeration, options);
+}
+export function Enumeration(enums, options) {
+    return Property(enumeration(enums, options), options);
 }

package/schema/schemas/function.d.ts

@@ -0,0 +1,8 @@
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type FunctionSchemaOptions = SimpleSchemaOptions;
+export declare class FunctionSchema extends SimpleSchema<Function> {
+    constructor(options?: FunctionSchemaOptions);
+}
+export declare function func(): FunctionSchema;
+export declare function FunctionProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/function.js

@@ -0,0 +1,14 @@
+import { isFunction } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class FunctionSchema extends SimpleSchema {
+    constructor(options) {
+        super('function', isFunction, options);
+    }
+}
+export function func() {
+    return new FunctionSchema();
+}
+export function FunctionProperty(options) {
+    return Property(func(), options);
+}

package/schema/schemas/index.d.ts

@@ -1,25 +1,24 @@
 export * from './any.js';
 export * from './array.js';
-export * from './assign.js';
+export * from './bigint.js';
 export * from './boolean.js';
-export * from './constraint.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './enumeration.js';
+export * from './function.js';
 export * from './instance.js';
 export * from './literal.js';
+export * from './never.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 './simple.js';
 export * from './string.js';
+export * from './symbol.js';
 export * from './transform.js';
 export * from './uint8-array.js';
 export * from './union.js';

package/schema/schemas/index.js

@@ -1,25 +1,24 @@
 export * from './any.js';
 export * from './array.js';
-export * from './assign.js';
+export * from './bigint.js';
 export * from './boolean.js';
-export * from './constraint.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './enumeration.js';
+export * from './function.js';
 export * from './instance.js';
 export * from './literal.js';
+export * from './never.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 './simple.js';
 export * from './string.js';
+export * from './symbol.js';
 export * from './transform.js';
 export * from './uint8-array.js';
 export * from './union.js';

package/schema/schemas/instance.d.ts

@@ -1,3 +1,11 @@
-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>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { AbstractConstructor } from '../../types.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {
+    readonly type: T;
+    constructor(type: T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<InstanceType<T>>;
+}
+export declare function instance<T extends AbstractConstructor>(type: T): InstanceSchema<T>;
+export declare function Instance(type: AbstractConstructor, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/instance.js

@@ -1,5 +1,26 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { valueSchema } from '../types/index.js';
-export function instance(type, options) {
-    return valueSchema(type, options);
+import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { Schema } from '../schema.js';
+export class InstanceSchema extends Schema {
+    type;
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    _test(value, path, options) {
+        if (value instanceof this.type) {
+            return { valid: true, value };
+        }
+        return {
+            valid: false,
+            error: SchemaError.expectedButGot(typeOf(this.type), typeOf(value), path, { fast: options.fastErrors })
+        };
+    }
+}
+export function instance(type) {
+    return new InstanceSchema(type);
+}
+export function Instance(type, options) {
+    return Property(instance(type), options);
 }

package/schema/schemas/literal.d.ts

@@ -1,5 +1,10 @@
-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'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class LiteralSchema<const T> extends Schema<T> {
+    readonly value: T;
+    constructor(value: T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export declare function literal<const T>(value: T): LiteralSchema<T>;
+export declare function Literal(value: any, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/literal.js

@@ -1,17 +1,27 @@
-/* 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
-    });
+import { isPrimitive } from '../../utils/type-guards.js';
+import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { Schema } from '../schema.js';
+export class LiteralSchema extends Schema {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    _test(value, path, options) {
+        if (value === this.value) {
+            return { valid: true, value };
+        }
+        return {
+            valid: false,
+            error: SchemaError.expectedButGot(isPrimitive(this.value) ? String(this.value) : typeOf(this.value), isPrimitive(value) ? String(value) : typeOf(value), path, { fast: options.fastErrors })
+        };
+    }
 }
-export function Literal(value) {
-    return createSchemaPropertyDecoratorFromSchema(literal(value));
+export function literal(value) {
+    return new LiteralSchema(value);
+}
+export function Literal(value, options) {
+    return Property(literal(value), options);
 }

package/schema/schemas/never.d.ts

@@ -0,0 +1,6 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class NeverSchema extends Schema<never> {
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<never>;
+}
+export declare function never(): NeverSchema;

package/schema/schemas/never.js

@@ -0,0 +1,11 @@
+import { SchemaError } from '../../schema/schema.error.js';
+import { typeOf } from '../../utils/type-of.js';
+import { Schema } from '../schema.js';
+export class NeverSchema extends Schema {
+    _test(value, path, options) {
+        return { valid: false, error: SchemaError.expectedButGot('never', typeOf(value), path, { fast: options.fastErrors }) };
+    }
+}
+export function never() {
+    return new NeverSchema();
+}

package/schema/schemas/nullable.d.ts

@@ -1,6 +1,11 @@
-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'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { TypedOmit } from '../../types.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class NullableSchema<T> extends Schema<T | null> {
+    readonly schema: Schema<T>;
+    constructor(schema: SchemaTestable<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null>;
+}
+export declare function nullable<T>(schema: SchemaTestable<T>): NullableSchema<T>;
+export declare function Nullable(schema?: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'nullable'>): SchemaPropertyDecorator;

package/schema/schemas/nullable.js

@@ -1,9 +1,26 @@
-import { createSchemaPropertyDecorator } from '../decorators/utils.js';
-import { valueSchema } from '../types/index.js';
-export function nullable(schema, options) {
-    return valueSchema(schema, { ...options, nullable: true });
+import { isNull } from '../../utils/type-guards.js';
+import { createSchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class NullableSchema extends Schema {
+    schema;
+    constructor(schema) {
+        if ((schema instanceof NullableSchema) && (schema == schema.schema)) {
+            return schema; // eslint-disable-line no-constructor-return
+        }
+        super();
+        this.schema = schemaTestableToSchema(schema);
+    }
+    _test(value, path, options) {
+        if (isNull(value)) {
+            return { valid: true, value };
+        }
+        return this.schema._test(value, path, options);
+    }
 }
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export function Nullable(options) {
-    return createSchemaPropertyDecorator({ ...options, nullable: true });
+export function nullable(schema) {
+    return new NullableSchema(schema);
+}
+export function Nullable(schema, options) {
+    return createSchemaPropertyDecorator({ schema, ...options, nullable: true });
 }

package/schema/schemas/number.d.ts

@@ -1,9 +1,11 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type NumberOptions = ValueSchemaOptions & {
-    minimum?: number;
-    maximum?: number;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type NumberSchemaOptions = SimpleSchemaOptions & {
     integer?: boolean;
 };
-export declare function number(options?: NumberOptions): ValueSchema<number>;
-export declare function NumberProperty(options?: NumberOptions): Decorator<'property' | 'accessor'>;
+export declare class NumberSchema extends SimpleSchema<number> {
+    constructor(options?: NumberSchemaOptions);
+}
+export declare function number(options?: NumberSchemaOptions): NumberSchema;
+export declare function NumberProperty(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
+export declare function Integer(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/number.js

@@ -1,27 +1,32 @@
-/* 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));
+import { isNumber } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SimpleSchema } from './simple.js';
+export class NumberSchema extends SimpleSchema {
+    constructor(options) {
+        super('number', isNumber, options, {
+            coercers: {
+                string: (value, path, options) => {
+                    const result = globalThis.Number(value);
+                    return globalThis.Number.isNaN(result)
+                        ? { success: false, error: SchemaError.couldNotCoerce('number', 'string', path, { fast: options.fastErrors }) }
+                        : { success: true, value: result, valid: true };
+                },
+                boolean: (value) => ({ success: true, value: globalThis.Number(value), valid: true }),
+                bigint: (value) => ({ success: true, value: globalThis.Number(value), valid: false })
+            },
+            constraints: [
+                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
+            ]
+        });
     }
-    if (isDefined(options.maximum)) {
-        valueConstraints.push(new MaximumConstraint(options.maximum));
-    }
-    if (options.integer == true) {
-        valueConstraints.push(integerConstraint);
-    }
-    return valueSchema(Number, {
-        ...options,
-        valueConstraints
-    });
+}
+export function number(options) {
+    return new NumberSchema(options);
 }
 export function NumberProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(number(options));
+    return Property(number(options), options);
+}
+export function Integer(options) {
+    return Property(number({ ...options, integer: true }), options);
 }