@tstdl/base 0.87.13 → 0.88.0-alpha1

package/schema/schema.js

@@ -1,301 +1,283 @@
-"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();
+import { JsonPath } from '../json-path/index.js';
+import { toArray } from '../utils/array/array.js';
+import { noop } from '../utils/noop.js';
+import { objectKeys } from '../utils/object/object.js';
+import { differenceSets } from '../utils/set.js';
+import { isArray, isDefined, isFunction, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
+import { booleanCoercer, dateCoercer, numberCoercer, regExpCoercer, stringCoercer, uint8ArrayCoercer } from './coercers/index.js';
+import { SchemaError } from './schema.error.js';
+import { isObjectSchema, isTransformErrorResult, isTypeSchema, isValueSchema, resolveValueType, resolveValueTypes, schemaTestableToSchema, transformErrorResultSymbol } from './types/index.js';
+import { getArrayItemSchema, getSchemaTypeNames, getSchemaValueTypes, getValueType, includesValueType, normalizeObjectSchema, normalizeValueSchema, tryGetObjectSchemaFromReflection } from './utils/index.js';
+const defaultCoercers = new Map();
 let initialize = () => {
-  Schema.registerDefaultCoercer(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;
+    Schema.registerDefaultCoercer(numberCoercer);
+    Schema.registerDefaultCoercer(booleanCoercer);
+    Schema.registerDefaultCoercer(stringCoercer);
+    Schema.registerDefaultCoercer(dateCoercer);
+    Schema.registerDefaultCoercer(regExpCoercer);
+    Schema.registerDefaultCoercer(uint8ArrayCoercer);
+    initialize = noop;
 };
-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);
-    }
-  },
-  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 ((0, import_type_guards.isUndefined)(result.error.stack)) {
-      result.error.stack = new Error().stack;
-    }
-    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;
+// 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];
     }
-    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;
+    const schema = {
+        factory: { type: Array },
+        properties: {}
+    };
+    argumentSchemas.forEach((arg, index) => (schema.properties[index] = arg));
+    return schema;
 }
-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");
+export function testSchema(schema, value, options, path = JsonPath.ROOT) {
+    initialize();
+    if (isValueSchema(schema)) {
+        return testValue(schema, value, options, path);
+    }
+    if (isTypeSchema(schema)) {
+        return testType(schema, value, options, path);
+    }
+    if (isObjectSchema(schema)) {
+        return testObject(schema, value, options, path);
+    }
+    throw new Error('Unsupported schema');
 }
-function testType(schema, value, options = {}, path = 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 };
+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);
+        }
     }
-    const objectSchema = (0, import_utils.tryGetObjectSchemaFromReflection)(resolvedValueType);
-    if ((0, import_type_guards.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 };
     }
-  } 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 }) };
+    return { valid: false, error: SchemaError.expectedButGot(resolvedValueType, 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;
+// 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 }) };
     }
-    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 schema = normalizeObjectSchema(objectSchema);
+    const mask = schema.mask ?? options.mask ?? false;
+    const resultValue = isDefined(schema.factory?.type) ? new schema.factory.type() : {};
+    const schemaPropertyKeys = objectKeys(schema.properties);
+    const valuePropertyKeys = objectKeys(value);
+    const unknownValuePropertyKeys = differenceSets(new Set(valuePropertyKeys), new Set(schemaPropertyKeys));
+    if ((unknownValuePropertyKeys.length > 0) && !mask && !schema.allowUnknownProperties) {
+        return { valid: false, error: new SchemaError('Unknown property', { path: path.add(unknownValuePropertyKeys[0]), fast: options.fastErrors }) };
+    }
+    for (const key of schemaPropertyKeys) {
+        const propertyResult = testSchema(schema.properties[key], value[key], options, path.add(key));
+        if (!propertyResult.valid) {
+            return propertyResult;
+        }
+        resultValue[key] = propertyResult.value;
+    }
+    if (schema.allowUnknownProperties) {
+        for (const key of unknownValuePropertyKeys) {
+            const propertyPath = path.add(key);
+            if (isDefined(schema.unknownPropertiesKey)) {
+                const keyResult = testSchema(schema.unknownPropertiesKey, key, options);
+                if (!keyResult.valid && !mask) {
+                    return { valid: false, error: new SchemaError('Invalid property key.', { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
+                }
+            }
+            const propertyResult = testSchema(schema.unknownProperties, value[key], options, path.add(key));
+            if (!propertyResult.valid && !mask) {
+                return propertyResult;
+            }
+            resultValue[key] = propertyResult.value;
         }
-      }
-      const propertyResult = testSchema(schema.unknownProperties, value[key], options, path.add(key));
-      if (!propertyResult.valid && !mask) {
-        return propertyResult;
-      }
-      resultValue[key] = propertyResult.value;
     }
-  }
-  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 };
+    const testResultValue = isUndefined(schema.factory) ? resultValue : isDefined(schema.factory.type) ? resultValue : schema.factory.builder(resultValue);
+    return { valid: true, value: testResultValue };
 }
-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 }) };
+// 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 };
     }
-    for (const arrayConstraint of normalizedValueSchema.arrayConstraints) {
-      const result = arrayConstraint.validate(value, path, context);
-      if (!result.valid) {
-        return { valid: false, error: result.error };
-      }
+    if (normalizedValueSchema.nullable && isNull(value)) {
+        return { valid: true, value: value };
     }
-    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);
+    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 };
     }
-    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;
+    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);
     }
-    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 }) };
+    updateCurrentState(value);
+    /** try to coerce */
+    if (!valueTestResult.valid) {
+        const targetTypes = getSchemaValueTypes(schema);
+        const coercers = [
+            ...(normalizedValueSchema.coercers.get(valueType) ?? []),
+            ...((normalizedValueSchema.coerce || options.coerce == true) ? (defaultCoercers.get(valueType) ?? []) : [])
+        ]
+            .filter((coercer) => includesValueType(coercer.targetType, targetTypes));
+        const errors = [];
+        let success = false;
+        for (const coercer of coercers) {
+            const coerceResult = coercer.coerce(resultValue, path, context);
+            if (!coerceResult.success) {
+                errors.push(coerceResult.error);
+                continue;
+            }
+            success = true;
+            updateCurrentState(coerceResult.value);
+            break;
+        }
+        if (!success && (errors.length > 0)) {
+            return { valid: false, error: (errors.length == 1) ? errors[0] : new SchemaError('Value could not be coerced.', { inner: errors, path, fast: options.fastErrors }) };
+        }
     }
-  }
-  if (!valueTestResult.valid) {
-    return valueTestResult;
-  }
-  if (normalizedValueSchema.valueConstraints.length > 0) {
-    const errors = [];
-    for (const constraint of normalizedValueSchema.valueConstraints) {
-      const result = constraint.validate(resultValue, path, context);
-      if (!result.valid) {
-        errors.push(result.error);
-      }
+    if (!valueTestResult.valid) {
+        return valueTestResult;
     }
-    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.valueConstraints.length > 0) {
+        const errors = [];
+        for (const constraint of normalizedValueSchema.valueConstraints) {
+            const result = constraint.validate(resultValue, path, context);
+            if (!result.valid) {
+                errors.push(result.error);
+            }
+        }
+        if (errors.length > 0) {
+            return { valid: false, error: (errors.length == 1) ? errors[0] : new SchemaError('Value did not match schema.', { path, inner: errors, fast: options.fastErrors }) };
+        }
     }
-  }
-  if (normalizedValueSchema.transformers.length > 0) {
-    for (const transformer of normalizedValueSchema.transformers) {
-      if ((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 };
+    if (normalizedValueSchema.transformers.length > 0) {
+        for (const transformer of normalizedValueSchema.transformers) {
+            if (isDefined(transformer.sourceType) && !includesValueType(valueType, resolveValueTypes(transformer.sourceType))) {
+                continue;
+            }
+            const transformResult = transformer.transform(resultValue, path, context);
+            if (isTransformErrorResult(transformResult)) {
+                return { valid: false, error: transformResult[transformErrorResultSymbol] };
+            }
+            return { valid: true, value: transformResult };
+        }
     }
-  }
-  return { valid: true, value: resultValue };
+    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;
+    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));
     }
-    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 }) };
+    const expectString = expectStrings.length > 1 ? `(${expectStrings.join(' | ')})` : expectStrings[0];
+    return { valid: false, error: SchemaError.expectedButGot(expectString, getValueType(value), path, { inner: errors, fast: options.fastErrors }) };
 }
-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}`;
+export function getExpectString(schema) {
+    const expectedNames = getSchemaTypeNames(schema);
+    const arraySuffix = (isValueSchema(schema) && (schema.array == true)) ? '[]' : '';
+    const expectedTypeString = (expectedNames.length == 1) ? `${expectedNames[0]}${arraySuffix}` : `(${expectedNames.join(' | ')})${arraySuffix}`;
+    const expects = isValueSchema(schema) ? toArray(schema.valueConstraints ?? []).map((constraint) => constraint.expects) : [];
+    const expectsString = (expects.length > 0) ? `[${expects.join(', ')}]` : '';
+    return `${expectedTypeString}${expectsString}`;
 }

package/schema/schemas/any.js

@@ -1,32 +1,9 @@
-"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);
+/* 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);
 }
-function Any(options) {
-  return (0, import_decorators.createSchemaPropertyDecoratorFromSchema)(any(options));
+export function Any(options) {
+    return createSchemaPropertyDecoratorFromSchema(any(options));
 }