@oscarpalmer/jhunal 0.20.0 → 0.22.0

package/dist/models/validation.model.d.mts

@@ -1,21 +1,20 @@
 import { Schematic } from "../schematic.mjs";
 import { ValueName } from "./misc.model.mjs";
-import { GenericCallback } from "@oscarpalmer/atoms/models";
+import { GenericCallback, PlainObject } from "@oscarpalmer/atoms/models";
 
 //#region src/models/validation.model.d.ts
-/**
- * Maps each {@link ReportingType} to a boolean flag
- */
+type NamedValidatorHandlers = { [Key in ValueName]?: Array<(value: unknown) => boolean> };
+type NamedValidators = Record<ValueName, (value: unknown) => boolean>;
 type ReportingInformation = Record<ReportingType, boolean> & {
   type: ReportingType;
 };
 /**
  * Controls how validation failures are reported
  *
- * - `'none'` — returns a boolean _(default)_
- * - `'first'` — returns the first failure as a `Result`
- * - `'all'` — returns all failures as a `Result` _(from same level)_
- * - `'throw'` — throws a {@link ValidationError} on failure
+ * - `'none'`, returns a boolean _(default)_
+ * - `'first'`, returns the first failure as a `Result`
+ * - `'all'`, returns all failures as a `Result` _(from same level)_
+ * - `'throw'`, throws a {@link ValidationError} on failure
  */
 type ReportingType = 'all' | 'first' | 'none' | 'throw';
 /**
@@ -24,58 +23,6 @@ type ReportingType = 'all' | 'first' | 'none' | 'throw';
 declare class SchematicError extends Error {
   constructor(message: string);
 }
-/**
- * The runtime representation of a parsed schema property, used internally during validation
- *
- * @example
- * ```ts
- * const parsed: ValidatedProperty = {
- *   key: 'age',
- *   required: true,
- *   types: ['number'],
- *   validators: { number: [(v) => v > 0] },
- * };
- * ```
- */
-type ValidatedProperty = {
-  /**
-   * The property name in the schema
-   */
-  key: ValidatedPropertyKey;
-  /**
-   * Whether the property is required
-   */
-  required: boolean;
-  /**
-   * The allowed types for this property
-   */
-  types: ValidatedPropertyType[];
-  /**
-   * Custom validators grouped by {@link ValueName}
-   */
-  validators: ValidatedPropertyValidators;
-};
-/**
- * The full and short forms of a property's key path
- *
- * For a nested property `address.street`: `full` is `'address.street'`, `short` is `'street'`
- */
-type ValidatedPropertyKey = {
-  full: string;
-  short: string;
-};
-/**
- * A union of valid types for a {@link ValidatedProperty}'s `types` array
- *
- * Can be a callback _(custom validator)_, a {@link Schematic}, a nested {@link ValidatedProperty}, or a {@link ValueName} string
- */
-type ValidatedPropertyType = GenericCallback | ValidatedProperty[] | Schematic<unknown> | ValueName;
-/**
- * A map of validator functions keyed by {@link ValueName}, used at runtime in {@link ValidatedProperty}
- *
- * Each key holds an array of validator functions that receive an `unknown` value and return a `boolean`
- */
-type ValidatedPropertyValidators = { [Key in ValueName]?: Array<(value: unknown) => boolean> };
 /**
  * Thrown in `'throw'` mode when one or more properties fail validation; `information` holds all failures
  */
@@ -93,9 +40,12 @@ type ValidationInformation = {
   value: unknown;
 };
 /**
- * Same shape as {@link ValidatedPropertyKey}; the key path of a failed property
+ *
  */
-type ValidationInformationKey = ValidatedPropertyKey;
+type ValidationInformationKey = {
+  full: string;
+  short: string;
+};
 /**
  * Options for validation
  */
@@ -109,9 +59,13 @@ type ValidationOptions<Errors extends ReportingType> = {
    */
   strict?: boolean;
 };
-type ValidationOptionsExtended = {
+type Validator = (input: unknown, parameters: ValidatorParameters, get: boolean) => boolean | ValidationInformation[];
+type ValidatorParameters = {
+  information?: ValidationInformation[];
+  output: PlainObject;
   reporting: ReportingInformation;
   strict: boolean;
 };
+type ValidatorType = Function | PlainObject | Schematic<unknown> | ValueName;
 //#endregion
-export { ReportingInformation, ReportingType, SchematicError, ValidatedProperty, ValidatedPropertyKey, ValidatedPropertyType, ValidatedPropertyValidators, ValidationError, ValidationInformation, ValidationInformationKey, ValidationOptions, ValidationOptionsExtended };
+export { NamedValidatorHandlers, NamedValidators, ReportingInformation, ReportingType, SchematicError, ValidationError, ValidationInformation, ValidationInformationKey, ValidationOptions, Validator, ValidatorParameters, ValidatorType };

package/dist/schematic.d.mts

@@ -1,6 +1,6 @@
 import { Infer } from "./models/infer.model.mjs";
 import { TypedSchema } from "./models/schema.typed.model.mjs";
-import { ValidatedProperty, ValidationInformation, ValidationOptions } from "./models/validation.model.mjs";
+import { ValidationInformation, ValidationOptions, Validator } from "./models/validation.model.mjs";
 import { Schema } from "./models/schema.plain.model.mjs";
 import { PlainObject } from "@oscarpalmer/atoms/models";
 import { Result } from "@oscarpalmer/atoms/result/models";
@@ -12,11 +12,74 @@ import { Result } from "@oscarpalmer/atoms/result/models";
 declare class Schematic<Model> {
   #private;
   private readonly $schematic;
-  constructor(properties: ValidatedProperty[]);
+  constructor(validator: Validator);
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or throws an error for the first property that fails validation
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Deeply cloned version of the value if it matches the schema, otherwise throws an error
+   */
+  get(value: unknown, options: ValidationOptions<'throw'>): Model;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or throws an error for the first property that fails validation
+   * @param value Value to parse
+   * @param errors Reporting type
+   * @returns Deeply cloned version of the value if it matches the schema, otherwise throws an error
+   */
+  get(value: unknown, errors: 'throw'): Model;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a result of a deeply cloned version of the value or all validation information for validation failures from the same depth in the value
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, options: ValidationOptions<'all'>): Result<Model, ValidationInformation[]>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a result of a deeply cloned version of the value or all validation information for validation failures from the same depth in the value
+   * @param value Value to parse
+   * @param errors Reporting type
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, errors: 'all'): Result<Model, ValidationInformation[]>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or all validation information for the first failing property
+   * @param value Value to parse
+   * @param options Validation options
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, options: ValidationOptions<'first'>): Result<Model, ValidationInformation>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or all validation information for the first failing property
+   * @param value Value to parse
+   * @param errors Reporting type
+   * @returns Result holding deeply cloned value or all validation information
+   */
+  get(value: unknown, errors: 'first'): Result<Model, ValidationInformation>;
+  /**
+   * Parse a value according to the schema
+   *
+   * Returns a deeply cloned version of the value or `undefined` if the value does not match the schema
+   * @param value Value to parse
+   * @param strict Validate if unknown keys are present in the object? _(defaults to `false`)_
+   * @returns Deeply cloned value, or `undefined` if it's invalid
+   */
+  get(value: unknown, strict?: true): Model | undefined;
   /**
    * Does the value match the schema?
    *
-   * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation.
+   * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation
    * @param value Value to validate
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise throws an error
@@ -25,7 +88,7 @@ declare class Schematic<Model> {
   /**
    * Does the value match the schema?
    *
-   * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation.
+   * Will assert that the values matches the schema and throw an error if it does not. The error will contain all validation information for the first property that fails validation
    * @param value Value to validate
    * @param errors Reporting type
    * @returns `true` if the value matches the schema, otherwise throws an error
@@ -34,25 +97,25 @@ declare class Schematic<Model> {
   /**
    * Does the value match the schema?
    *
-   * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the object.
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the value
    * @param value Value to validate
    * @param options Validation options
-   * @returns `true` if the value matches the schema, otherwise `false`
+   * @returns Result holding `true` or all validation information
    */
   is(value: unknown, options: ValidationOptions<'all'>): Result<true, ValidationInformation[]>;
   /**
    * Does the value match the schema?
    *
-   * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the object.
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for validation failures from the same depth in the value
    * @param value Value to validate
    * @param errors Reporting type
-   * @returns `true` if the value matches the schema, otherwise `false`
+   * @returns Result holding `true` or all validation information
    */
   is(value: unknown, errors: 'all'): Result<true, ValidationInformation[]>;
   /**
    * Does the value match the schema?
    *
-   * Will validate that the value matches the schema and return a result of `true` or all validation information for the failing property.
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for the first failing property
    * @param value Value to validate
    * @param options Validation options
    * @returns `true` if the value matches the schema, otherwise `false`
@@ -61,7 +124,7 @@ declare class Schematic<Model> {
   /**
    * Does the value match the schema?
    *
-   * Will validate that the value matches the schema and return a result of `true` or all validation information for the failing property.
+   * Will validate that the value matches the schema and return a result of `true` or all validation information for the first failing property
    * @param value Value to validate
    * @param errors Reporting type
    * @returns `true` if the value matches the schema, otherwise `false`
@@ -70,7 +133,7 @@ declare class Schematic<Model> {
   /**
    * Does the value match the schema?
    *
-   * Will validate that the value matches the schema and return `true` or `false`, without any validation information for validation failures.
+   * Will validate that the value matches the schema and return `true` or `false`, without any validation information for validation failures
    * @param value Value to validate
    * @param strict Validate if unknown keys are present in the object? _(defaults to `false`)_
    * @returns `true` if the value matches the schema, otherwise `false`
@@ -93,6 +156,6 @@ declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer
  * @returns A schematic for the given typed schema
  */
 declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
-declare const schematicProperties: WeakMap<Schematic<unknown>, ValidatedProperty[]>;
+declare const schematicValidator: WeakMap<Schematic<unknown>, Validator>;
 //#endregion
-export { Schematic, schematic, schematicProperties };
+export { Schematic, schematic, schematicValidator };

package/dist/schematic.mjs

@@ -1,36 +1,38 @@
 import { PROPERTY_SCHEMATIC, SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE } from "./constants.mjs";
-import { getOptions, isSchematic } from "./helpers.mjs";
+import { getParameters, isSchematic } from "./helpers.mjs";
 import { SchematicError } from "./models/validation.model.mjs";
-import { getProperties } from "./validation/property.validation.mjs";
-import { validateObject } from "./validation/value.validation.mjs";
+import { getObjectValidator } from "./validation.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
-import { error } from "@oscarpalmer/atoms/result/misc";
+import { error, ok } from "@oscarpalmer/atoms/result/misc";
 //#region src/schematic.ts
 /**
 * A schematic for validating objects
 */
 var Schematic = class {
-	#properties;
-	constructor(properties) {
+	#validator;
+	constructor(validator) {
 		Object.defineProperty(this, PROPERTY_SCHEMATIC, { value: true });
-		this.#properties = properties;
-		schematicProperties.set(this, properties);
+		this.#validator = validator;
+		schematicValidator.set(this, validator);
+	}
+	get(value, options) {
+		const parameters = getParameters(options);
+		const result = this.#validator(value, parameters, true);
+		if (typeof result === "boolean") return parameters.reporting.none ? result ? parameters.output : void 0 : ok(parameters.output);
+		return error(parameters.reporting.all ? result : result[0]);
 	}
 	is(value, options) {
-		const { reporting, strict } = getOptions(options);
-		const result = validateObject(value, this.#properties, {
-			reporting,
-			strict
-		});
-		if (typeof result === "boolean") return result;
-		return error(reporting.all ? result : result[0]);
+		const parameters = getParameters(options);
+		const result = this.#validator(value, parameters, false);
+		if (typeof result === "boolean") return parameters.reporting.none ? result : ok(result);
+		return error(parameters.reporting.all ? result : result[0]);
 	}
 };
 function schematic(schema) {
 	if (isSchematic(schema)) return schema;
 	if (!isPlainObject(schema)) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_TYPE);
-	return new Schematic(getProperties(schema));
+	return new Schematic(getObjectValidator(schema));
 }
-const schematicProperties = /* @__PURE__ */ new WeakMap();
+const schematicValidator = /* @__PURE__ */ new WeakMap();
 //#endregion
-export { Schematic, schematic, schematicProperties };
+export { Schematic, schematic, schematicValidator };

package/dist/validation.d.mts

@@ -0,0 +1,7 @@
+import { ValidationInformationKey, Validator } from "./models/validation.model.mjs";
+import { PlainObject } from "@oscarpalmer/atoms";
+
+//#region src/validation.d.ts
+declare function getObjectValidator(original: PlainObject, origin?: ValidationInformationKey, fromType?: boolean): Validator;
+//#endregion
+export { getObjectValidator };

package/dist/validation.mjs

@@ -0,0 +1,245 @@
+import { PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE, SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE, TYPE_ALL } from "./constants.mjs";
+import { getInvalidInputMessage, getInvalidMissingMessage, getInvalidTypeMessage, getInvalidValidatorMessage, getUnknownKeysMessage, instanceOf, isSchematic } from "./helpers.mjs";
+import { SchematicError, ValidationError } from "./models/validation.model.mjs";
+import { schematicValidator } from "./schematic.mjs";
+import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
+import { join } from "@oscarpalmer/atoms";
+import { clone } from "@oscarpalmer/atoms/value/clone";
+//#region src/validation.ts
+function getDisallowedProperty(obj) {
+	if ("$required" in obj) return PROPERTY_REQUIRED;
+	if ("$type" in obj) return PROPERTY_TYPE;
+	if ("$validators" in obj) return PROPERTY_VALIDATORS;
+}
+function getFunctionValidator(fn) {
+	const validator = isConstructor(fn) ? instanceOf(fn) : fn;
+	return (input) => validator(input) === true;
+}
+function getNamedValidator(key, name, handlers) {
+	const validator = namedValidators[name];
+	const named = handlers[name] ?? [];
+	const { length } = named;
+	return (input, parameters) => {
+		if (!validator(input)) return false;
+		for (let index = 0; index < length; index += 1) {
+			const handler = named[index];
+			if (handler(input) === true) continue;
+			const information = {
+				key,
+				validator,
+				message: getInvalidValidatorMessage(key.full, name, index, length),
+				value: input
+			};
+			parameters.information?.push(information);
+			return parameters.reporting.none ? false : [information];
+		}
+		return true;
+	};
+}
+function getNamedHandlers(original, prefix) {
+	const handlers = {};
+	if (original == null) return handlers;
+	if (!isPlainObject(original)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_TYPE);
+	const keys = Object.keys(original);
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		if (!TYPE_ALL.has(key)) throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
+		const value = original[key];
+		handlers[key] = (Array.isArray(value) ? value : [value]).map((item) => {
+			if (typeof item !== "function") throw new TypeError(SCHEMATIC_MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key).replace("<>", prefix));
+			return item;
+		});
+	}
+	return handlers;
+}
+function getObjectValidator(original, origin, fromType) {
+	const keys = Object.keys(original);
+	const keysLength = keys.length;
+	if (keysLength === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_EMPTY);
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+		if (property != null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace("<>", origin.full).replace("<>", property));
+	}
+	const set = /* @__PURE__ */ new Set();
+	const items = [];
+	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys[keyIndex];
+		const value = original[key];
+		if (value == null) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", join([origin?.full, key], ".")));
+		const prefixedKey = origin == null ? key : join([origin.full, key], ".");
+		const fullKey = {
+			full: prefixedKey,
+			short: key
+		};
+		let handlers = {};
+		let required = true;
+		let typed = false;
+		let types;
+		const validators = [];
+		if (isPlainObject(value)) {
+			typed = PROPERTY_TYPE in value;
+			const type = typed ? value[PROPERTY_TYPE] : value;
+			handlers = getNamedHandlers(value[PROPERTY_VALIDATORS], prefixedKey);
+			required = getRequired(key, value) ?? required;
+			types = Array.isArray(type) ? type : [type];
+		} else types = Array.isArray(value) ? value : [value];
+		if (types.length === 0) throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(value)));
+		const typesLength = types.length;
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			const type = types[typeIndex];
+			let validator;
+			switch (true) {
+				case typeof type === "function":
+					validator = getFunctionValidator(type);
+					break;
+				case isPlainObject(type):
+					validator = getObjectValidator(type, fullKey, typed);
+					break;
+				case isSchematic(type):
+					validator = getSchematicValidator(type);
+					break;
+				case TYPE_ALL.has(type):
+					validator = getNamedValidator(fullKey, type, handlers);
+					break;
+				default: throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", prefixedKey).replace("<>", String(type)));
+			}
+			validators.push(validator);
+		}
+		set.add(key);
+		items.push({
+			types,
+			key: fullKey,
+			required: required && !types.includes("undefined"),
+			validator: getValidator(validators)
+		});
+	}
+	const validatorsLength = items.length;
+	return (input, parameters, get) => {
+		if (!isPlainObject(input)) {
+			if (origin != null) return false;
+			const information = {
+				key: {
+					full: "",
+					short: ""
+				},
+				value: input,
+				message: getInvalidInputMessage(input)
+			};
+			if (parameters.reporting.throw) throw new ValidationError([information]);
+			parameters.information?.push(information);
+			return parameters.reporting.none ? false : [information];
+		}
+		if (parameters.strict) {
+			const unknownKeys = Object.keys(input).filter((key) => !set.has(key));
+			if (unknownKeys.length > 0) {
+				const information = {
+					key: origin ?? {
+						full: "",
+						short: ""
+					},
+					message: getUnknownKeysMessage(unknownKeys),
+					value: input
+				};
+				if (parameters.reporting.throw) throw new ValidationError([information]);
+				parameters.information?.push(information);
+				return parameters.reporting.none ? false : [information];
+			}
+		}
+		const allInformation = [];
+		const output = {};
+		for (let validatorIndex = 0; validatorIndex < validatorsLength; validatorIndex += 1) {
+			const { key, required, types, validator } = items[validatorIndex];
+			const value = input[key.short];
+			if (value === void 0) {
+				if (required) {
+					if (parameters.reporting.none) return false;
+					const information = {
+						key,
+						value,
+						message: getInvalidMissingMessage(key.full, types)
+					};
+					if (parameters.reporting.throw) throw new ValidationError([information]);
+					parameters.information?.push(information);
+					if (parameters.reporting.all) {
+						allInformation.push(information);
+						continue;
+					}
+					return [information];
+				}
+				continue;
+			}
+			const previousOutput = parameters.output;
+			parameters.output = output;
+			const result = validator(value, parameters, get);
+			parameters.output = previousOutput;
+			if (result === false) continue;
+			if (result === true) {
+				if (get) output[key.short] = clone(value);
+				continue;
+			}
+			if (parameters.reporting.none) return false;
+			const information = typeof result !== "boolean" && result.length > 0 ? result : [{
+				key,
+				value,
+				message: getInvalidTypeMessage(key.full, types, value)
+			}];
+			if (parameters.reporting.throw) throw new ValidationError(information);
+			if (parameters.reporting.all) {
+				allInformation.push(...information);
+				continue;
+			}
+			return information;
+		}
+		if (get) if (origin == null) parameters.output = output;
+		else parameters.output[origin.short] = output;
+		return parameters.reporting.none || allInformation.length === 0 ? true : allInformation;
+	};
+}
+function getRequired(key, obj) {
+	if (!("$required" in obj)) return;
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(SCHEMATIC_MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
+	return obj[PROPERTY_REQUIRED];
+}
+function getSchematicValidator(schematic) {
+	const validator = schematicValidator.get(schematic);
+	return (input, parameters, get) => {
+		let result = false;
+		if (isPlainObject(input)) result = validator(input, parameters, get);
+		if (typeof result === "boolean") return result;
+		parameters.information?.push(...result);
+		return result.length === 0 ? true : result;
+	};
+}
+function getValidator(validators) {
+	const { length } = validators;
+	return (input, parameters, get) => {
+		const allInformation = [];
+		for (let index = 0; index < length; index += 1) {
+			const previousInformation = parameters.information;
+			parameters.information = [];
+			const result = validators[index](input, parameters, get);
+			parameters.information = previousInformation;
+			if (result === false) continue;
+			if (result === true) return true;
+			parameters.information?.push(...result);
+			allInformation.push(...result);
+		}
+		return allInformation;
+	};
+}
+const namedValidators = {
+	array: Array.isArray,
+	bigint: (value) => typeof value === "bigint",
+	boolean: (value) => typeof value === "boolean",
+	date: (value) => value instanceof Date,
+	function: (value) => typeof value === "function",
+	null: (value) => value === null,
+	number: (value) => typeof value === "number",
+	object: (value) => typeof value === "object" && value !== null,
+	string: (value) => typeof value === "string",
+	symbol: (value) => typeof value === "symbol",
+	undefined: (value) => value === void 0
+};
+//#endregion
+export { getObjectValidator };