@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/schema/schema.js

@@ -1,283 +1,301 @@
-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();
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  Schema: () => Schema,
+  getExpectString: () => getExpectString,
+  testSchema: () => testSchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_json_path = require("../json-path/index.js");
+var import_array = require("../utils/array/array.js");
+var import_noop = require("../utils/noop.js");
+var import_object = require("../utils/object/object.js");
+var import_set = require("../utils/set.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_coercers = require("./coercers/index.js");
+var import_schema_error = require("./schema.error.js");
+var import_types = require("./types/index.js");
+var import_utils = require("./utils/index.js");
+const defaultCoercers = /* @__PURE__ */ new Map();
 let initialize = () => {
-    Schema.registerDefaultCoercer(numberCoercer);
-    Schema.registerDefaultCoercer(booleanCoercer);
-    Schema.registerDefaultCoercer(stringCoercer);
-    Schema.registerDefaultCoercer(dateCoercer);
-    Schema.registerDefaultCoercer(regExpCoercer);
-    Schema.registerDefaultCoercer(uint8ArrayCoercer);
-    initialize = noop;
+  Schema.registerDefaultCoercer(import_coercers.numberCoercer);
+  Schema.registerDefaultCoercer(import_coercers.booleanCoercer);
+  Schema.registerDefaultCoercer(import_coercers.stringCoercer);
+  Schema.registerDefaultCoercer(import_coercers.dateCoercer);
+  Schema.registerDefaultCoercer(import_coercers.regExpCoercer);
+  Schema.registerDefaultCoercer(import_coercers.uint8ArrayCoercer);
+  initialize = import_noop.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];
+const Schema = {
+  registerDefaultCoercer(coercer) {
+    for (const sourceType of (0, import_array.toArray)(coercer.sourceType)) {
+      if (!defaultCoercers.has(sourceType)) {
+        defaultCoercers.set(sourceType, []);
+      }
+      defaultCoercers.get(sourceType).push(coercer);
     }
-};
-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);
+  },
+  test(schemaOrValueType, value, options, path = import_json_path.JsonPath.ROOT) {
+    const normalizedOptions = { fastErrors: true, ...options };
+    const schema = (0, import_types.schemaTestableToSchema)(schemaOrValueType);
+    const result = testSchema(schema, value, normalizedOptions, path);
+    if (result.valid) {
+      return result;
     }
-    if (isTypeSchema(schema)) {
-        return testType(schema, value, options, path);
+    if ((0, import_type_guards.isUndefined)(result.error.stack)) {
+      result.error.stack = new Error().stack;
     }
-    if (isObjectSchema(schema)) {
-        return testObject(schema, value, options, path);
+    return result;
+  },
+  validate(schemaOrValueType, value, options) {
+    const schema = (0, import_types.schemaTestableToSchema)(schemaOrValueType);
+    const result = this.test(schema, value, options);
+    return result.valid;
+  },
+  parse(schemaOrValueType, value, options) {
+    const schema = (0, import_types.schemaTestableToSchema)(schemaOrValueType);
+    const result = this.test(schema, value, options);
+    if (result.valid) {
+      return result.value;
     }
-    throw new Error('Unsupported schema');
+    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 });
+        const unsafeResult = handler(...safeArgs);
+        return Schema.parse(returnSchema, unsafeResult);
+      }
+    }[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 });
+        const unsafeResult = await handler(...safeArgs);
+        return Schema.parse(returnSchema, unsafeResult);
+      }
+    }[name];
+  }
+};
+function getFunctionParametersSchema(argumentSchemas) {
+  const schema = {
+    factory: { type: Array },
+    properties: {}
+  };
+  argumentSchemas.forEach((arg, index) => schema.properties[index] = arg);
+  return 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 }) };
+function testSchema(schema, value, options, path = import_json_path.JsonPath.ROOT) {
+  initialize();
+  if ((0, import_types.isValueSchema)(schema)) {
+    return testValue(schema, value, options, path);
+  }
+  if ((0, import_types.isTypeSchema)(schema)) {
+    return testType(schema, value, options, path);
+  }
+  if ((0, import_types.isObjectSchema)(schema)) {
+    return testObject(schema, value, options, path);
+  }
+  throw new Error("Unsupported schema");
 }
-// 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 }) };
+function testType(schema, value, options = {}, path = import_json_path.JsonPath.ROOT) {
+  const resolvedValueType = (0, import_types.resolveValueType)(schema.type);
+  if ((0, import_type_guards.isFunction)(resolvedValueType)) {
+    if (value instanceof resolvedValueType || (0, import_utils.getValueType)(value) == resolvedValueType) {
+      return { valid: true, value };
     }
-    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 }) };
+    const objectSchema = (0, import_utils.tryGetObjectSchemaFromReflection)(resolvedValueType);
+    if ((0, import_type_guards.isNotNull)(objectSchema)) {
+      return testObject(objectSchema, value, options, path);
     }
-    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;
+  } else if (resolvedValueType == "any" || resolvedValueType == "null" && (0, import_type_guards.isNull)(value) || resolvedValueType == "undefined" && (0, import_type_guards.isUndefined)(value)) {
+    return { valid: true, value };
+  }
+  return { valid: false, error: import_schema_error.SchemaError.expectedButGot(resolvedValueType, (0, import_utils.getValueType)(value), path, { fast: options.fastErrors }) };
+}
+function testObject(objectSchema, value, options = {}, path = import_json_path.JsonPath.ROOT) {
+  if (!(value instanceof Object)) {
+    return { valid: false, error: import_schema_error.SchemaError.expectedButGot(objectSchema.sourceType ?? "object", (0, import_utils.getValueType)(value), path, { fast: options.fastErrors }) };
+  }
+  const schema = (0, import_utils.normalizeObjectSchema)(objectSchema);
+  const mask = schema.mask ?? options.mask ?? false;
+  const resultValue = (0, import_type_guards.isDefined)(schema.factory?.type) ? new schema.factory.type() : {};
+  const schemaPropertyKeys = (0, import_object.objectKeys)(schema.properties);
+  const valuePropertyKeys = (0, import_object.objectKeys)(value);
+  const unknownValuePropertyKeys = (0, import_set.differenceSets)(new Set(valuePropertyKeys), new Set(schemaPropertyKeys));
+  if (unknownValuePropertyKeys.length > 0 && !mask && !schema.allowUnknownProperties) {
+    return { valid: false, error: new import_schema_error.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;
     }
-    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;
+    resultValue[key] = propertyResult.value;
+  }
+  if (schema.allowUnknownProperties) {
+    for (const key of unknownValuePropertyKeys) {
+      const propertyPath = path.add(key);
+      if ((0, import_type_guards.isDefined)(schema.unknownPropertiesKey)) {
+        const keyResult = testSchema(schema.unknownPropertiesKey, key, options);
+        if (!keyResult.valid && !mask) {
+          return { valid: false, error: new import_schema_error.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 };
+  }
+  const testResultValue = (0, import_type_guards.isUndefined)(schema.factory) ? resultValue : (0, import_type_guards.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 };
+function testValue(schema, value, options = {}, path = import_json_path.JsonPath.ROOT) {
+  const normalizedValueSchema = (0, import_utils.normalizeValueSchema)(schema);
+  if (normalizedValueSchema.optional && (0, import_type_guards.isUndefined)(value)) {
+    return { valid: true, value };
+  }
+  if (normalizedValueSchema.nullable && (0, import_type_guards.isNull)(value)) {
+    return { valid: true, value };
+  }
+  const context = {
+    schema: normalizedValueSchema,
+    options
+  };
+  if (normalizedValueSchema.array) {
+    if (!(0, import_type_guards.isArray)(value)) {
+      if (normalizedValueSchema.coerce) {
+        return testValue(schema, [value], options, path);
+      }
+      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(Array, (0, import_utils.getValueType)(value), path, { fast: options.fastErrors }) };
     }
-    if (normalizedValueSchema.nullable && isNull(value)) {
-        return { valid: true, value: value };
+    for (const arrayConstraint of normalizedValueSchema.arrayConstraints) {
+      const result = arrayConstraint.validate(value, path, context);
+      if (!result.valid) {
+        return { valid: false, error: result.error };
+      }
     }
-    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 };
+    const itemSchema = (0, import_utils.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);
     }
-    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);
+    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 = (0, import_utils.getValueType)(resultValue);
+  }
+  updateCurrentState(value);
+  if (!valueTestResult.valid) {
+    const targetTypes = (0, import_utils.getSchemaValueTypes)(schema);
+    const coercers = [
+      ...normalizedValueSchema.coercers.get(valueType) ?? [],
+      ...normalizedValueSchema.coerce || options.coerce == true ? defaultCoercers.get(valueType) ?? [] : []
+    ].filter((coercer) => (0, import_utils.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;
     }
-    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 (!success && errors.length > 0) {
+      return { valid: false, error: errors.length == 1 ? errors[0] : new import_schema_error.SchemaError("Value could not be coerced.", { inner: errors, path, fast: options.fastErrors }) };
     }
-    if (!valueTestResult.valid) {
-        return valueTestResult;
+  }
+  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 (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 (errors.length > 0) {
+      return { valid: false, error: errors.length == 1 ? errors[0] : new import_schema_error.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 };
-        }
+  }
+  if (normalizedValueSchema.transformers.length > 0) {
+    for (const transformer of normalizedValueSchema.transformers) {
+      if ((0, import_type_guards.isDefined)(transformer.sourceType) && !(0, import_utils.includesValueType)(valueType, (0, import_types.resolveValueTypes)(transformer.sourceType))) {
+        continue;
+      }
+      const transformResult = transformer.transform(resultValue, path, context);
+      if ((0, import_types.isTransformErrorResult)(transformResult)) {
+        return { valid: false, error: transformResult[import_types.transformErrorResultSymbol] };
+      }
+      return { valid: true, value: transformResult };
     }
-    return { valid: true, value: resultValue };
+  }
+  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 errorResults = [];
+  for (const schema of validSchemas) {
+    const result = testSchema(schema, value, options, path);
+    if (result.valid) {
+      return result;
     }
-    const expectString = expectStrings.length > 1 ? `(${expectStrings.join(' | ')})` : expectStrings[0];
-    return { valid: false, error: SchemaError.expectedButGot(expectString, getValueType(value), path, { inner: errors, fast: options.fastErrors }) };
+    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: import_schema_error.SchemaError.expectedButGot(expectString, (0, import_utils.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}`;
+function getExpectString(schema) {
+  const expectedNames = (0, import_utils.getSchemaTypeNames)(schema);
+  const arraySuffix = (0, import_types.isValueSchema)(schema) && schema.array == true ? "[]" : "";
+  const expectedTypeString = expectedNames.length == 1 ? `${expectedNames[0]}${arraySuffix}` : `(${expectedNames.join(" | ")})${arraySuffix}`;
+  const expects = (0, import_types.isValueSchema)(schema) ? (0, import_array.toArray)(schema.valueConstraints ?? []).map((constraint) => constraint.expects) : [];
+  const expectsString = expects.length > 0 ? `[${expects.join(", ")}]` : "";
+  return `${expectedTypeString}${expectsString}`;
 }

package/schema/schemas/any.js

@@ -1,9 +1,32 @@
-/* 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);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var any_exports = {};
+__export(any_exports, {
+  Any: () => Any,
+  any: () => any
+});
+module.exports = __toCommonJS(any_exports);
+var import_decorators = require("../decorators/index.js");
+var import_types = require("../types/index.js");
+function any(options) {
+  return (0, import_types.valueSchema)("any", options);
 }
-export function Any(options) {
-    return createSchemaPropertyDecoratorFromSchema(any(options));
+function Any(options) {
+  return (0, import_decorators.createSchemaPropertyDecoratorFromSchema)(any(options));
 }