@tstdl/base 0.91.0-beta9 → 0.91.1

package/schema-old/types/types.d.ts

@@ -1,175 +0,0 @@
-import type { AbstractConstructor, OneOrMany, Record, Type, TypedOmit } from '../../types.js';
-import type { SchemaError } from '../schema.error.js';
-import type { NormalizedSchema, Schema, SchemaTestable } from '../schema.js';
-import type { SchemaArrayConstraint } from './schema-array-constraint.js';
-import type { SchemaValueCoercer } from './schema-value-coercer.js';
-import type { SchemaValueConstraint } from './schema-value-constraint.js';
-import type { SchemaValueTransformer } from './schema-value-transformer.js';
-declare const schemaOutputTypeSymbol: unique symbol;
-declare const optimized: unique symbol;
-export type SchemaFactoryFunction<T> = (data: T) => T;
-export type SchemaFactory<T> = {
-    type: Type<T>;
-    builder?: undefined;
-} | {
-    type?: undefined;
-    builder: SchemaFactoryFunction<T>;
-};
-export type ObjectSchemaProperties<T> = {
-    [K in keyof T]-?: OneOrMany<SchemaTestable<T[K]>>;
-};
-export type NormalizedObjectSchemaProperties<T> = {
-    [K in keyof T]-?: Schema<T[K]>;
-};
-export type SchemaOutput<T extends SchemaTestable> = T extends ObjectSchema<infer O> ? O : T extends ValueSchema<infer O> ? O : T extends TypeSchema<infer O> ? O : T extends ValueType<infer O> ? NormalizeValueType<O> : never;
-export type TupleSchemaOutput<T extends readonly SchemaTestable[]> = {
-    [P in keyof T]: SchemaOutput<T[P]>;
-};
-export type ObjectSchemaOrType<T = any> = ObjectSchema<T> | AbstractConstructor<T>;
-export type ObjectSchema<T = any> = {
-    [optimized]?: boolean;
-    [schemaOutputTypeSymbol]?: T;
-    sourceType?: ValueType;
-    factory?: SchemaFactory<T>;
-    properties: ObjectSchemaProperties<T>;
-    mask?: boolean;
-    unknownProperties?: OneOrMany<SchemaTestable>;
-    unknownPropertiesKey?: OneOrMany<SchemaTestable>;
-};
-export type TypedObjectSchemaUnknownProperties<K extends PropertyKey, V> = {
-    unknownProperties?: OneOrMany<SchemaTestable<V>>;
-    unknownPropertiesKey?: OneOrMany<SchemaTestable<K>>;
-};
-export type TypeSchema<T = any> = {
-    type: ValueType<T>;
-};
-export type NormalizedTypeSchema<T = any> = {
-    type: ResolvedValueType<T>;
-};
-export type ValueSchema<T = unknown> = {
-    [optimized]?: boolean;
-    [schemaOutputTypeSymbol]?: T;
-    schema: OneOrMany<SchemaTestable<T>>;
-    array?: boolean;
-    optional?: boolean;
-    nullable?: boolean;
-    /** Use default coercers */
-    coerce?: boolean;
-    /** Custom coercers */
-    coercers?: OneOrMany<SchemaValueCoercer>;
-    transformers?: OneOrMany<SchemaValueTransformer>;
-    arrayConstraints?: OneOrMany<SchemaArrayConstraint>;
-    valueConstraints?: OneOrMany<SchemaValueConstraint>;
-};
-export type ValueSchemaOptions = TypedOmit<ValueSchema, 'schema' | typeof schemaOutputTypeSymbol>;
-export type NormalizedObjectSchema<T = any> = {
-    [schemaOutputTypeSymbol]?: T;
-    factory?: SchemaFactory<T>;
-    properties: NormalizedObjectSchemaProperties<T>;
-    mask?: boolean;
-    allowUnknownProperties: boolean;
-    unknownProperties?: Schema;
-    unknownPropertiesKey?: Schema;
-};
-export type NormalizedValueSchema<T = any> = {
-    [schemaOutputTypeSymbol]?: T;
-    schema: Schema<T>[];
-    array: boolean;
-    optional: boolean;
-    nullable: boolean;
-    coerce: boolean;
-    coercers: Map<ValueType, SchemaValueCoercer[]>;
-    transformers: readonly SchemaValueTransformer[];
-    arrayConstraints: readonly SchemaArrayConstraint[];
-    valueConstraints: readonly SchemaValueConstraint[];
-};
-export type SchemaContext = {
-    schema: NormalizedSchema;
-    options: SchemaTestOptions;
-};
-export type ConstraintContext = SchemaContext;
-export type TransformerContext = SchemaContext;
-export type CoercerContext = SchemaContext;
-export type NormalizeValueType<T> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends BigInt ? bigint : T extends Symbol ? symbol : T extends 'undefined' ? undefined : T extends 'null' ? null : T extends 'any' ? any : T;
-export type NormalizeToValueType<T> = T extends string | String ? typeof String : T extends number | Number ? typeof Number : T extends boolean | Boolean ? typeof Boolean : T extends bigint | BigInt ? typeof BigInt : T extends symbol | Symbol ? typeof Symbol : T extends undefined ? 'undefined' : T extends null ? 'null' : T extends any ? 'any' : never;
-export type ValueType<T = any> = AbstractConstructor<T> | NormalizeToValueType<T> | DeferredValueType<T>;
-export type DeferredValueType<T = any> = {
-    deferred: () => ValueType<T>;
-};
-export type ResolvedValueType<T = any> = Exclude<ValueType<T>, DeferredValueType>;
-export type Coercible = {
-    coerce?: boolean;
-};
-export declare const primitiveConstructors: ValueType[];
-export declare const primitiveConstructorSet: Set<ValueType<any>>;
-export type OptionKeys<T extends Record> = readonly (keyof T)[];
-export type SchemaTestOptions = {
-    /**
-     * Try to convert wrong input into desired output.
-     * Can be specified on definition and validation. If specified on both, definition has higher priority
-     */
-    coerce?: boolean;
-    /**
-     * Remove unspecified fields on input data instead of raising an error.
-     * Can be specified on definition and validation. If specified on both, definition has higher priority
-     */
-    mask?: boolean;
-    /**
-     * Use fast errors which can improve performance a lot but misses detailed stack traces.
-     */
-    fastErrors?: boolean;
-};
-export type SchemaTestResult<T> = {
-    valid: true;
-    value: T;
-    error?: undefined;
-} | {
-    valid: false;
-    value?: undefined;
-    error: SchemaError;
-};
-export type ConstraintResult = {
-    valid: true;
-    error?: undefined;
-} | {
-    valid: false;
-    error: SchemaError;
-};
-export type CoerceResult = {
-    success: true;
-    value: any;
-    error?: undefined;
-} | {
-    success: false;
-    value?: undefined;
-    error: SchemaError;
-};
-export declare const transformErrorResultSymbol: unique symbol;
-export type TransformErrorResult = {
-    [transformErrorResultSymbol]: SchemaError;
-};
-export type TransformResult<T> = T | TransformErrorResult;
-export declare function transformErrorResult(error: SchemaError): TransformErrorResult;
-export declare function isTransformErrorResult(value: any): value is TransformErrorResult;
-export declare function objectSchemaProperties<T extends Record>(properties: ObjectSchemaProperties<T>): ObjectSchemaProperties<T>;
-export declare function objectSchema<T extends Record>(schema: ObjectSchema<T>): ObjectSchema<T>;
-export declare function valueSchema<T>(schema: OneOrMany<SchemaTestable<T>>, options?: TypedOmit<ValueSchema<T>, 'schema'>): ValueSchema<T>;
-export declare function typeSchema<T>(type: ValueType<T>): TypeSchema<NormalizeValueType<T>>;
-export declare function isSchema<T>(value: any): value is Schema<T>;
-export declare function isObjectSchema<T extends Record = any>(schema: SchemaTestable<T>): schema is ObjectSchema<T>;
-export declare function isObjectSchema<T extends Record = any>(schema: any): schema is ObjectSchema<T>;
-export declare function isValueSchema<T>(schema: SchemaTestable<T>): schema is ValueSchema<T>;
-export declare function isValueSchema<T>(schema: any): schema is ValueSchema<T>;
-export declare function isTypeSchema<T>(schema: SchemaTestable<T>): schema is TypeSchema<T>;
-export declare function isTypeSchema<T>(schema: any): schema is TypeSchema<T>;
-export declare function isDeferredValueType<T>(value: SchemaTestable<T>): value is DeferredValueType<T>;
-export declare function isDeferredValueType(value: any): value is DeferredValueType;
-export declare function resolveValueTypes<T>(valueTypes: OneOrMany<ValueType<T>>): OneOrMany<ResolvedValueType<T>>;
-export declare function resolveValueType<T>(valueType: ValueType<T>): ResolvedValueType<T>;
-export declare function schemaTestablesToSchemas<T>(schemaTestables: OneOrMany<SchemaTestable<T>>): OneOrMany<Schema<T>>;
-export declare function schemaTestableToSchema<T>(valueTypeOrSchema: SchemaTestable<T>): Schema<T>;
-export declare function optimizeObjectSchema<T>(schema: ObjectSchema<T>): ObjectSchema<T>;
-export declare function optimizeObjectSchemaProperties<T>(properties: ObjectSchemaProperties<T>): ObjectSchemaProperties<T>;
-export declare function optimizeValueSchema<T>(schema: ValueSchema<T>): ValueSchema<T>;
-export declare function optimizeSchema<T>(schema: OneOrMany<SchemaTestable<T>>): OneOrMany<SchemaTestable<T>>;
-export {};

package/schema-old/types/types.js

@@ -1,172 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { distinct } from '../../utils/array/array.js';
-import { filterObject, hasOwnProperty, mapObjectValues, objectEntries, objectKeys } from '../../utils/object/object.js';
-import { assert, isArray, isDefined, isFunction, isObject, isString, isUndefined } from '../../utils/type-guards.js';
-const optimized = Symbol('schema optimized');
-export const primitiveConstructors = [String, Number, Boolean, Symbol, BigInt, Function, 'undefined', 'null'];
-export const primitiveConstructorSet = new Set(primitiveConstructors);
-export const transformErrorResultSymbol = Symbol('Transform error');
-export function transformErrorResult(error) {
-    return { [transformErrorResultSymbol]: error };
-}
-export function isTransformErrorResult(value) {
-    return isObject(value) && hasOwnProperty(value, transformErrorResultSymbol);
-}
-export function objectSchemaProperties(properties) {
-    return optimizeObjectSchemaProperties(properties);
-}
-export function objectSchema(schema) {
-    return optimizeObjectSchema(schema);
-}
-export function valueSchema(schema, options) {
-    assert(!isArray(schema) || (schema.length > 0), 'No schema provided.');
-    return optimizeValueSchema({ schema, ...options });
-}
-export function typeSchema(type) {
-    return { type };
-}
-export function isSchema(value) {
-    return isObjectSchema(value) || isValueSchema(value) || isTypeSchema(value);
-}
-export function isObjectSchema(schema) {
-    return isObject(schema?.properties);
-}
-export function isValueSchema(schema) {
-    return isObject(schema) && isDefined(schema?.schema);
-}
-export function isTypeSchema(schema) {
-    if (!isObject(schema)) {
-        return false;
-    }
-    const type = schema.type;
-    return isFunction(type)
-        || (isObject(type) && isFunction(type.deferred))
-        || (type == 'undefined')
-        || (type == 'null')
-        || (type == 'any');
-}
-export function isDeferredValueType(value) {
-    return isObject(value) && isFunction(value.deferred);
-}
-export function resolveValueTypes(valueTypes) {
-    if (isArray(valueTypes)) {
-        return valueTypes.map(resolveValueType);
-    }
-    return resolveValueType(valueTypes);
-}
-export function resolveValueType(valueType) {
-    return isDeferredValueType(valueType)
-        ? resolveValueType(valueType.deferred())
-        : valueType;
-}
-export function schemaTestablesToSchemas(schemaTestables) {
-    if (isArray(schemaTestables)) {
-        if (schemaTestables.length == 1) {
-            return schemaTestableToSchema(schemaTestables[0]);
-        }
-        if (schemaTestables.length == 0) {
-            throw new Error('No schema provided.');
-        }
-        return schemaTestables.map(schemaTestableToSchema);
-    }
-    return schemaTestableToSchema(schemaTestables);
-}
-export function schemaTestableToSchema(valueTypeOrSchema) {
-    if (isSchema(valueTypeOrSchema)) {
-        return valueTypeOrSchema;
-    }
-    return typeSchema(valueTypeOrSchema);
-}
-export function optimizeObjectSchema(schema) {
-    if (schema[optimized] == true) {
-        return schema;
-    }
-    return filterObject({
-        [optimized]: true,
-        ...schema,
-        properties: optimizeObjectSchemaProperties(schema.properties),
-        unknownProperties: (isUndefined(schema.unknownProperties) || (isArray(schema.unknownProperties) && (schema.unknownProperties.length == 0))) ? undefined : optimizeSchema(schema.unknownProperties),
-        unknownPropertiesKey: (isUndefined(schema.unknownPropertiesKey) || (isArray(schema.unknownPropertiesKey) && (schema.unknownPropertiesKey.length == 0))) ? undefined : optimizeSchema(schema.unknownPropertiesKey)
-    }, isDefined);
-}
-export function optimizeObjectSchemaProperties(properties) {
-    return mapObjectValues(properties, optimizeSchema);
-}
-export function optimizeValueSchema(schema) {
-    const optimizedSchema = optimizeSchema(schema);
-    return isValueSchema(optimizedSchema) ? optimizedSchema : { [optimized]: true, schema: optimizedSchema };
-}
-export function optimizeSchema(schema) {
-    if (isArray(schema)) {
-        if (schema[optimized] == true) {
-            return schema;
-        }
-        if (schema.length == 1) {
-            return optimizeSchema(schema[0]);
-        }
-        if (schema.length == 0) {
-            throw new Error('No schema provided.');
-        }
-        const optimizedSchemas = distinct(distinct(schema).flatMap(optimizeSchema));
-        optimizedSchemas[optimized] = true;
-        return optimizedSchemas;
-    }
-    if (isFunction(schema) || isString(schema) || isDeferredValueType(schema)) {
-        return schema;
-    }
-    if (isTypeSchema(schema)) {
-        return schema.type;
-    }
-    if (isValueSchema(schema)) {
-        if (schema[optimized] == true) {
-            return schema;
-        }
-        const entries = objectEntries(schema).filter(([, value]) => isDefined(value));
-        if (entries.length == 1) {
-            return optimizeSchema(schema.schema);
-        }
-        if (isValueSchema(schema.schema)) {
-            const combinedProperties = new Set([...objectKeys(schema), ...objectKeys(schema.schema)]);
-            if (isValueSchema(schema.schema)
-                && !combinedProperties.has('array')
-                && !combinedProperties.has('coerce')
-                && !combinedProperties.has('coercers')
-                && !combinedProperties.has('transformers')
-                && !combinedProperties.has('arrayConstraints')
-                && !combinedProperties.has('valueConstraints')) {
-                return {
-                    [optimized]: true,
-                    schema: optimizeSchema(schema.schema.schema),
-                    ...filterObject({
-                        optional: ((schema.optional ?? false) || (schema.schema.optional ?? false)) ? true : undefined,
-                        nullable: ((schema.nullable ?? false) || (schema.schema.nullable ?? false)) ? true : undefined
-                    }, isDefined)
-                };
-            }
-        }
-        const { schema: innerSchema, optional, nullable, coercers, transformers, arrayConstraints, valueConstraints, ...rest } = schema;
-        return filterObject({
-            [optimized]: true,
-            schema: optimizeSchema(innerSchema),
-            optional: (optional ?? false) ? true : undefined,
-            nullable: (nullable ?? false) ? true : undefined,
-            coercers: optimizeOneOrMany(coercers),
-            transformers: optimizeOneOrMany(transformers),
-            arrayConstraints: optimizeOneOrMany(arrayConstraints),
-            valueConstraints: optimizeOneOrMany(valueConstraints),
-            ...rest
-        }, isDefined);
-    }
-    return optimizeObjectSchema(schema);
-}
-function optimizeOneOrMany(values) {
-    if (isArray(values)) {
-        if (values.length == 0) {
-            return undefined;
-        }
-        if (values.length == 1) {
-            return values[0];
-        }
-    }
-    return values;
-}

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

@@ -1,2 +0,0 @@
-export * from './schema.js';
-export * from './value-type.js';

package/schema-old/utils/index.js

@@ -1,2 +0,0 @@
-export * from './schema.js';
-export * from './value-type.js';

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

@@ -1,18 +0,0 @@
-import type { AbstractConstructor } from '../../types.js';
-import type { NormalizedSchema, Schema } from '../schema.js';
-import type { NormalizedObjectSchema, NormalizedTypeSchema, NormalizedValueSchema, ObjectSchema, ObjectSchemaOrType, TypeSchema, ValueSchema } from '../types/index.js';
-export declare const normalizeSchema: typeof _normalizeSchema;
-export declare const normalizeObjectSchema: typeof _normalizeObjectSchema;
-export declare const normalizeValueSchema: typeof _normalizeValueSchema;
-export declare const normalizeTypeSchema: typeof _normalizeTypeSchema;
-export declare const getArrayItemSchema: typeof _getArrayItemSchema;
-export declare const tryGetObjectSchemaFromReflection: typeof _tryGetObjectSchemaFromReflection;
-export declare function getObjectSchema<T>(schemaOrType: ObjectSchemaOrType<T>): ObjectSchema<T>;
-declare function _normalizeSchema<T>(schema: Schema<T>): NormalizedSchema<T>;
-declare function _normalizeObjectSchema<T>(schema: ObjectSchema<T>): NormalizedObjectSchema<T>;
-declare function _normalizeValueSchema<T>(schema: ValueSchema<T>): NormalizedValueSchema<T>;
-declare function _normalizeTypeSchema<T>(schema: TypeSchema<T>): NormalizedTypeSchema<T>;
-declare function _getArrayItemSchema<T>(schema: ValueSchema<T>): ValueSchema<T>;
-export declare function getObjectSchemaFromReflection<T>(type: AbstractConstructor<T>): ObjectSchema<T>;
-declare function _tryGetObjectSchemaFromReflection<T>(type: AbstractConstructor<T>): ObjectSchema<T> | null;
-export {};

package/schema-old/utils/schema.js

@@ -1,139 +0,0 @@
-import { reflectionRegistry } from '../../reflection/registry.js';
-import { toArray } from '../../utils/array/array.js';
-import { memoizeSingle } from '../../utils/function/memoize.js';
-import { mapObjectValues } from '../../utils/object/object.js';
-import { isArray, isDefined, isFunction, isNotNull, isNull, isUndefined } from '../../utils/type-guards.js';
-import { assign } from '../schemas/assign.js';
-import { isObjectSchema, isTypeSchema, isValueSchema, objectSchema, resolveValueType, schemaTestableToSchema, schemaTestablesToSchemas, valueSchema } from '../types/index.js';
-export const normalizeSchema = memoizeSingle(_normalizeSchema, { weak: true });
-export const normalizeObjectSchema = memoizeSingle(_normalizeObjectSchema, { weak: true });
-export const normalizeValueSchema = memoizeSingle(_normalizeValueSchema, { weak: true });
-export const normalizeTypeSchema = memoizeSingle(_normalizeTypeSchema, { weak: true });
-export const getArrayItemSchema = memoizeSingle(_getArrayItemSchema, { weak: true });
-export const tryGetObjectSchemaFromReflection = memoizeSingle(_tryGetObjectSchemaFromReflection, { weak: true });
-export function getObjectSchema(schemaOrType) {
-    return isFunction(schemaOrType)
-        ? getObjectSchemaFromReflection(schemaOrType)
-        : schemaOrType;
-}
-function _normalizeSchema(schema) {
-    if (isObjectSchema(schema)) {
-        return normalizeObjectSchema(schema);
-    }
-    if (isValueSchema(schema)) {
-        return normalizeValueSchema(schema);
-    }
-    if (isTypeSchema(schema)) {
-        return normalizeTypeSchema(schema);
-    }
-    throw new Error('Unsupported schema.');
-}
-function _normalizeObjectSchema(schema) {
-    const unknownPropertiesSchema = (isDefined(schema.unknownProperties) && (!isArray(schema.unknownProperties) || (schema.unknownProperties.length > 0))) ? schemaTestablesToSchemas(schema.unknownProperties) : undefined;
-    const unknownPropertiesKeySchema = (isDefined(schema.unknownPropertiesKey) && (!isArray(schema.unknownPropertiesKey) || (schema.unknownPropertiesKey.length > 0))) ? schemaTestablesToSchemas(schema.unknownPropertiesKey) : undefined;
-    const allowUnknownProperties = ((isArray(unknownPropertiesSchema) && (unknownPropertiesSchema.length > 0)) || isDefined(unknownPropertiesSchema));
-    const normalizedSchema = {
-        factory: schema.factory,
-        properties: mapObjectValues(schema.properties, (propertyValueType) => schemaTestablesToSchemas(propertyValueType)),
-        mask: schema.mask,
-        allowUnknownProperties,
-        unknownProperties: isArray(unknownPropertiesSchema) ? valueSchema(unknownPropertiesSchema) : unknownPropertiesSchema,
-        unknownPropertiesKey: isArray(unknownPropertiesKeySchema) ? valueSchema(unknownPropertiesKeySchema) : unknownPropertiesKeySchema
-    };
-    return normalizedSchema;
-}
-function _normalizeValueSchema(schema) {
-    const normalizedValueSchema = {
-        schema: [...new Set(toArray(schema.schema))].map(schemaTestableToSchema),
-        array: schema.array ?? false,
-        optional: schema.optional ?? false,
-        nullable: schema.nullable ?? false,
-        coerce: schema.coerce ?? false,
-        coercers: new Map(),
-        transformers: toArray(schema.transformers ?? []),
-        arrayConstraints: toArray(schema.arrayConstraints ?? []),
-        valueConstraints: toArray(schema.valueConstraints ?? [])
-    };
-    for (const coercer of toArray(schema.coercers ?? [])) {
-        for (const sourceType of toArray(coercer.sourceType)) {
-            if (!normalizedValueSchema.coercers.has(sourceType)) {
-                normalizedValueSchema.coercers.set(sourceType, []);
-            }
-            normalizedValueSchema.coercers.get(sourceType).push(coercer);
-        }
-    }
-    return normalizedValueSchema;
-}
-function _normalizeTypeSchema(schema) {
-    const normalizedSchema = {
-        type: resolveValueType(schema.type)
-    };
-    return normalizedSchema;
-}
-function _getArrayItemSchema(schema) {
-    const itemSchema = {
-        schema: schema.schema,
-        transformers: schema.transformers,
-        valueConstraints: schema.valueConstraints
-    };
-    return itemSchema;
-}
-export function getObjectSchemaFromReflection(type) {
-    const schema = tryGetObjectSchemaFromReflection(type);
-    if (isNull(schema)) {
-        throw new Error(`Could not get schema for ${type.name} from reflection data.`);
-    }
-    return schema;
-}
-function _tryGetObjectSchemaFromReflection(type) {
-    const metadata = reflectionRegistry.getMetadata(type);
-    if (isUndefined(metadata)) {
-        return null;
-    }
-    const typeData = metadata.data.tryGet('schema') ?? {};
-    const dataSchema = isTypeSchema(typeData.schema)
-        ? getObjectSchema(typeData.schema.type)
-        : isObjectSchema(typeData.schema)
-            ? typeData.schema
-            : isFunction(typeData.schema)
-                ? getObjectSchema(typeData.schema)
-                : undefined;
-    const schema = objectSchema({
-        sourceType: type,
-        factory: isDefined(typeData.factory) ? { builder: typeData.factory } : { type: type },
-        properties: dataSchema?.properties ?? getObjectSchemaPropertiesFromReflection(metadata, type),
-        mask: typeData.mask ?? dataSchema?.mask,
-        unknownProperties: ((isUndefined(typeData.unknownProperties) || (isArray(typeData.unknownProperties) && (typeData.unknownProperties.length == 0))) ? undefined : typeData.unknownProperties) ?? dataSchema?.unknownProperties,
-        unknownPropertiesKey: ((isUndefined(typeData.unknownPropertiesKey) || (isArray(typeData.unknownPropertiesKey) && (typeData.unknownPropertiesKey.length == 0))) ? undefined : typeData.unknownPropertiesKey) ?? dataSchema?.unknownPropertiesKey
-    });
-    if (isUndefined(dataSchema)) {
-        const prototype = Reflect.getPrototypeOf(type);
-        if (isNotNull(prototype) && reflectionRegistry.hasType(prototype)) {
-            const parentSchema = getObjectSchemaFromReflection(prototype);
-            return assign(parentSchema, schema);
-        }
-    }
-    return schema;
-}
-function getObjectSchemaPropertiesFromReflection(metadata, type) {
-    const properties = {};
-    for (const [key, propertyMetadata] of metadata.properties) {
-        const reflectionData = propertyMetadata.data.tryGet('schema');
-        const itemType = reflectionData?.schema;
-        const array = (reflectionData?.array == true) ? true : undefined;
-        if (array && (isUndefined(itemType) || (isArray(itemType) && (itemType.length == 0)))) {
-            throw new Error(`Item type missing on type ${type.name} at property "${String(key)}"`);
-        }
-        properties[key] = valueSchema(schemaTestablesToSchemas(itemType ?? propertyMetadata.type), {
-            array,
-            optional: reflectionData?.optional,
-            nullable: reflectionData?.nullable,
-            coerce: reflectionData?.coerce,
-            coercers: reflectionData?.coercers,
-            transformers: reflectionData?.transformers,
-            arrayConstraints: reflectionData?.arrayConstraints,
-            valueConstraints: reflectionData?.valueConstraints
-        });
-    }
-    return properties;
-}

package/schema-old/utils/value-type.d.ts

@@ -1,8 +0,0 @@
-import type { OneOrMany } from '../../types.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ResolvedValueType, ValueType } from '../types/types.js';
-export declare function getValueType(value: unknown): ResolvedValueType;
-export declare function includesValueType(valueType: ValueType, valueTypes: OneOrMany<ValueType>): boolean;
-export declare function getValueTypeName(valueType: ValueType): string;
-export declare function getSchemaTypeNames(schema: SchemaTestable): string[];
-export declare function getSchemaValueTypes(schema: OneOrMany<SchemaTestable>): ResolvedValueType[];

package/schema-old/utils/value-type.js

@@ -1,56 +0,0 @@
-import { toArray } from '../../utils/array/array.js';
-import { isArray, isFunction, isNull, isString, isUndefined } from '../../utils/type-guards.js';
-import { isDeferredValueType, isObjectSchema, isTypeSchema, isValueSchema, primitiveConstructorSet, resolveValueType, resolveValueTypes } from '../types/types.js';
-const lowercaseTypesSet = new Set([...primitiveConstructorSet, Object, Array]);
-export function getValueType(value) {
-    if (isUndefined(value)) {
-        return 'undefined';
-    }
-    if (isNull(value)) {
-        return 'null';
-    }
-    return value.constructor;
-}
-export function includesValueType(valueType, valueTypes) {
-    const resolvedValueTypes = resolveValueTypes(valueTypes);
-    const resolvedValueType = resolveValueType(valueType);
-    if (isArray(resolvedValueTypes)) {
-        return resolvedValueTypes.includes(resolvedValueType);
-    }
-    return resolvedValueType == resolvedValueTypes;
-}
-export function getValueTypeName(valueType) {
-    const resolvedValueType = resolveValueType(valueType);
-    return isString(resolvedValueType)
-        ? resolvedValueType
-        : lowercaseTypesSet.has(resolvedValueType)
-            ? resolvedValueType.name.toLowerCase()
-            : resolvedValueType.name;
-}
-export function getSchemaTypeNames(schema) {
-    return getSchemaValueTypes(schema).map(getValueTypeName);
-}
-export function getSchemaValueTypes(schema) {
-    if (isTypeSchema(schema)) {
-        return [resolveValueType(schema.type)];
-    }
-    if (isFunction(schema)) {
-        return [schema];
-    }
-    if (isString(schema)) {
-        return [schema];
-    }
-    if (isObjectSchema(schema)) {
-        return [resolveValueType(schema.sourceType ?? Object)];
-    }
-    if (isValueSchema(schema)) {
-        return [...new Set(toArray(schema.schema).flatMap(getSchemaValueTypes))];
-    }
-    if (isDeferredValueType(schema)) {
-        return getSchemaValueTypes(resolveValueType(schema));
-    }
-    if (isArray(schema)) {
-        return schema.flatMap(getSchemaValueTypes);
-    }
-    throw new Error('Unsupported schema');
-}