@tstdl/base 0.93.36 → 0.93.37

package/source/schema/schemas/function.ts

@@ -1,94 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
-
-import { reflectionRegistry } from '#/reflection/registry.js';
-import { createMethodDecorator } from '#/reflection/utils.js';
-import type { AbstractConstructor, Function } from '#/types/index.js';
-import { isArray, isDefined, isFunction, isNull, isUndefined } from '#/utils/type-guards.js';
-import { type CombinedSchemaDecorator, createSchemaDecorator, Property, type SchemaDecoratorOptions, type SchemaReflectionData } from '../decorators/index.js';
-import { schemaReflectionDataToSchema } from '../decorators/utils.js';
-import type { Schema, SchemaTestable } from '../schema.js';
-import { schemaTestableToSchema } from '../testable.js';
-import { never } from './never.js';
-import { optional } from './optional.js';
-import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-
-export type FunctionSchemaOptions<T extends Function> = SimpleSchemaOptions<T> & { parameterNames?: (string | null)[] };
-
-type MappedParameters<T> = { [I in keyof T]: SchemaTestable<T[I]> };
-
-export class FunctionSchema<T extends (...args: any[]) => any> extends SimpleSchema<T> {
-  override readonly name = 'function';
-
-  readonly parameterSchemas: MappedParameters<Parameters<T>> | null;
-  readonly parameterNames: (string | null)[];
-  readonly returnValueSchema: SchemaTestable<ReturnType<T>> | null;
-
-  constructor(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T>) {
-    super('function', isFunction, options);
-
-    this.parameterSchemas = parameterSchemas;
-    this.parameterNames = options?.parameterNames ?? [];
-    this.returnValueSchema = returnValueSchema;
-  }
-}
-
-export function func<T extends (...args: any[]) => any>(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T>): FunctionSchema<T> {
-  return new FunctionSchema(parameterSchemas, returnValueSchema, options);
-}
-
-export function Method<T extends (...args: any[]) => any>(options?: FunctionSchemaOptions<T> & SchemaDecoratorOptions): CombinedSchemaDecorator;
-export function Method<T extends (...args: any[]) => any>(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T> & SchemaDecoratorOptions): CombinedSchemaDecorator;
-export function Method<T extends (...args: any[]) => any>(parameterSchemasOrOptions?: MappedParameters<Parameters<T>> | null | (FunctionSchemaOptions<T> & SchemaDecoratorOptions), returnValueSchema?: SchemaTestable<ReturnType<T>> | null, optionsOrNothing?: FunctionSchemaOptions<T> & SchemaDecoratorOptions): CombinedSchemaDecorator {
-  if (isArray(parameterSchemasOrOptions) || isNull(parameterSchemasOrOptions)) {
-    return Property({
-      ...optionsOrNothing,
-      schema: (data) => func(parameterSchemasOrOptions, returnValueSchema as SchemaTestable, { description: data.description, example: data.example, ...optionsOrNothing })
-    });
-  }
-
-  return createMethodDecorator({
-    handler: (data, _metdata, originalArguments) => {
-      createSchemaDecorator(parameterSchemasOrOptions)(...originalArguments);
-      Property(getFunctionSchemaFromReflection(data.constructor, data.methodKey), parameterSchemasOrOptions);
-    }
-  }) as CombinedSchemaDecorator;
-}
-
-export function getFunctionSchemaFromReflection(type: AbstractConstructor, method: string | symbol): Schema<Function> | FunctionSchema<(...args: any[]) => any> {
-  const schema = tryGetFunctionSchemaFromReflection(type, method);
-
-  if (isNull(schema)) {
-    throw new Error(`Could not get functions schema for ${type.name}["${String(method)}"] from reflection data.`);
-  }
-
-  return schema;
-}
-
-export function tryGetFunctionSchemaFromReflection(type: AbstractConstructor, method: string | symbol): Schema<Function> | FunctionSchema<(...args: any[]) => any> | null {
-  const typeMetadata = reflectionRegistry.getMetadata(type);
-  const methodMetadata = typeMetadata?.methods.get(method);
-
-  if (isUndefined(methodMetadata)) {
-    return null;
-  }
-
-  const methodData = methodMetadata.data.tryGet<SchemaReflectionData>('schema') ?? {};
-
-  if (isFunction(methodData.schema)) {
-    return schemaTestableToSchema(methodData.schema(methodData)) as Schema<Function>;
-  }
-
-  const parameterSchemas = methodMetadata.parameters.map((parameterMetadata) => {
-    const parameterData = parameterMetadata.data.tryGet<SchemaReflectionData>('schema') ?? {};
-    return schemaReflectionDataToSchema(parameterData, parameterMetadata.type, { type, key: `${String(method)}(parameter:${parameterMetadata.index})` });
-  });
-
-  const parameterNames = methodMetadata.parameters.map((parameterMetadata) => {
-    const parameterData = parameterMetadata.data.tryGet<SchemaReflectionData>('schema') ?? {};
-    return parameterData.parameter?.name ?? null;
-  });
-
-  const returnTypeSchema = isDefined(methodData.method?.returnType) ? methodData.method.returnType(methodData) : (methodMetadata.returnType ?? optional(never()));
-
-  return func(parameterSchemas, returnTypeSchema, { parameterNames, description: methodData.description, example: methodData.example });
-}

package/source/schema/schemas/index.ts

@@ -1,26 +0,0 @@
-export * from './any.js';
-export * from './array.js';
-export * from './bigint.js';
-export * from './boolean.js';
-export * from './date.js';
-export * from './defaulted.js';
-export * from './deferred.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 './one-or-many.js';
-export * from './optional.js';
-export * from './readable-stream.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';
-export * from './unknown.js';

package/source/schema/schemas/instance.ts

@@ -1,46 +0,0 @@
-import type { JsonPath } from '#/json-path/json-path.js';
-import type { AbstractConstructor } from '#/types/index.js';
-import { lazyProperty } from '#/utils/object/lazy-property.js';
-import { typeOf } from '#/utils/type-of.js';
-import { PropertySchema, type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-
-export type InstanceSchemaOptions<T extends AbstractConstructor> = SchemaOptions<InstanceType<T>>;
-
-export class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {
-  override readonly name: string;
-  readonly type: T;
-
-  constructor(type: T, options?: InstanceSchemaOptions<T>) {
-    super(options);
-
-    this.type = type;
-
-    lazyProperty(this, 'name', () => `Instance[${type.name}]`);
-  }
-
-  override _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<InstanceType<T>> {
-    if (value instanceof (this.type as AbstractConstructor)) {
-      return { valid: true, value };
-    }
-
-    return {
-      valid: false,
-      error: SchemaError.expectedButGot(
-        typeOf(this.type),
-        typeOf(value),
-        path,
-        { fast: options.fastErrors }
-      )
-    };
-  }
-}
-
-export function instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T>): InstanceSchema<T> {
-  return new InstanceSchema(type, options);
-}
-
-export function Instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator {
-  return PropertySchema((data) => instance(type, { description: data.description, example: data.example, ...options }), options);
-}

package/source/schema/schemas/literal.ts

@@ -1,46 +0,0 @@
-import type { JsonPath } from '#/json-path/json-path.js';
-import { lazyProperty } from '#/utils/object/lazy-property.js';
-import { isPrimitive } from '#/utils/type-guards.js';
-import { typeOf } from '#/utils/type-of.js';
-import { PropertySchema, type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-
-export type LiteralSchemaOptions<T> = SchemaOptions<T>;
-
-export class LiteralSchema<const T> extends Schema<T> {
-  override readonly name: string;
-  readonly value: T;
-
-  constructor(value: T, options?: LiteralSchemaOptions<T>) {
-    super(options);
-
-    this.value = value;
-
-    lazyProperty(this, 'name', () => `Literal[${String(value)}]`);
-  }
-
-  override _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T> {
-    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<const T>(value: T, options?: LiteralSchemaOptions<T>): LiteralSchema<T> {
-  return new LiteralSchema(value, options);
-}
-
-export function Literal<const T>(value: T, options?: LiteralSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator {
-  return PropertySchema((data) => literal(value, { description: data.description, example: data.example, ...options }), options);
-}

package/source/schema/schemas/never.ts

@@ -1,18 +0,0 @@
-import type { JsonPath } from '#/json-path/json-path.js';
-import { SchemaError } from '#/schema/schema.error.js';
-import { typeOf } from '#/utils/type-of.js';
-import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-
-export type NeverSchemaOptions = SchemaOptions<never>;
-
-export class NeverSchema extends Schema<never> {
-  override readonly name = 'never';
-
-  override _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<never> {
-    return { valid: false, error: SchemaError.expectedButGot('never', typeOf(value), path, { fast: options.fastErrors }) };
-  }
-}
-
-export function never(options?: NeverSchemaOptions): NeverSchema {
-  return new NeverSchema(options);
-}

package/source/schema/schemas/nullable.ts

@@ -1,40 +0,0 @@
-import type { JsonPath } from '#/json-path/json-path.js';
-import type { TypedOmit } from '#/types/index.js';
-import { lazyProperty } from '#/utils/object/lazy-property.js';
-import { isNull } from '#/utils/type-guards.js';
-import { createSchemaDecorator, type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
-import { schemaTestableToSchema } from '../testable.js';
-
-export class NullableSchema<T> extends Schema<T | null> {
-  override readonly name: string;
-  readonly schema: Schema<T>;
-
-  constructor(schema: SchemaTestable<T>) {
-    if ((schema instanceof NullableSchema) && (schema == schema.schema)) {
-      return schema; // eslint-disable-line no-constructor-return
-    }
-
-    super();
-
-    this.schema = schemaTestableToSchema(schema);
-
-    lazyProperty(this, 'name', () => `Nullable[${this.schema.name}]`);
-  }
-
-  override _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null> {
-    if (isNull(value)) {
-      return { valid: true, value };
-    }
-
-    return this.schema._test(value, path, options);
-  }
-}
-
-export function nullable<T>(schema: SchemaTestable<T>): NullableSchema<T> {
-  return new NullableSchema(schema);
-}
-
-export function Nullable<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaDecoratorOptions, 'nullable'>): SchemaPropertyDecorator {
-  return createSchemaDecorator({ schema: () => schema as SchemaTestable, ...options, nullable: true });
-}

package/source/schema/schemas/number.ts

@@ -1,60 +0,0 @@
-import type { TypedOmit } from '#/types/index.js';
-import { isNumber } from '#/utils/type-guards.js';
-import { PropertySchema, type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
-
-export type NumberSchemaOptions = SimpleSchemaOptions<number> & {
-  integer?: boolean,
-  minimum?: number,
-  maximum?: number,
-};
-
-export class NumberSchema extends SimpleSchema<number> {
-  override readonly name: string = 'number';
-
-  readonly integer: boolean;
-  readonly minimum: number | null;
-  readonly maximum: number | null;
-
-  constructor(options?: NumberSchemaOptions) {
-    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,
-        isNumber(options?.minimum) ? (value) => (value >= this.minimum!) ? ({ success: true }) : ({ success: false, error: `Value must be more than or equal to ${this.minimum}.` }) : null,
-        isNumber(options?.maximum) ? (value) => (value <= this.maximum!) ? ({ success: true }) : ({ success: false, error: `Value must be less than or equal to ${this.maximum}.` }) : null,
-      ],
-    });
-
-    this.integer = options?.integer ?? false;
-    this.minimum = options?.minimum ?? null;
-    this.maximum = options?.maximum ?? null;
-  }
-}
-
-export function number(options?: NumberSchemaOptions): NumberSchema {
-  return new NumberSchema(options);
-}
-
-export function integer(options?: TypedOmit<NumberSchemaOptions, 'integer'>): NumberSchema {
-  return number({ ...options, integer: true });
-}
-
-export function NumberProperty(options?: SchemaDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator {
-  return PropertySchema((data) => number({ description: data.description, example: data.example, ...options }), options);
-}
-
-export function Integer(options?: SchemaDecoratorOptions & TypedOmit<NumberSchemaOptions, 'integer'>): SchemaPropertyDecorator {
-  return PropertySchema((data) => number({ description: data.description, example: data.example, ...options, integer: true }), options);
-}