@oscarpalmer/jhunal 0.14.0 → 0.16.0

package/dist/{jhunal.full.js → index.mjs}

@@ -1,55 +1,6 @@
-/**
-* Is the value a constructor function?
-* @param value Value to check
-* @returns `true` if the value is a constructor function, otherwise `false`
-*/
-function isConstructor(value) {
-	return typeof value === "function" && value.prototype?.constructor === value;
-}
-/**
-* Is the value a plain object?
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-}
-function compact(array, strict) {
-	if (!Array.isArray(array)) return [];
-	if (strict === true) return array.filter(Boolean);
-	const { length } = array;
-	const compacted = [];
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		if (item != null) compacted.push(item);
-	}
-	return compacted;
-}
-/**
-* Get the string value from any value
-* @param value Original value
-* @returns String representation of the value
-*/
-function getString(value) {
-	if (typeof value === "string") return value;
-	if (value == null) return "";
-	if (typeof value === "function") return getString(value());
-	if (typeof value !== "object") return String(value);
-	const asString = String(value.valueOf?.() ?? value);
-	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
-}
-/**
-* Join an array of values into a string
-* @param value Array of values
-* @param delimiter Delimiter to use between values
-* @returns Joined string
-*/
-function join(value, delimiter) {
-	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
-}
+import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
+import { join } from "@oscarpalmer/atoms/string";
+//#region src/constants.ts
 const ERROR_NAME = "SchematicError";
 const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
@@ -65,7 +16,6 @@ const PROPERTY_REQUIRED = "$required";
 const PROPERTY_TYPE = "$type";
 const PROPERTY_VALIDATORS = "$validators";
 const SCHEMATIC_NAME = "$schematic";
-const TEMPLATE_PATTERN = "<>";
 const TEMPLATE_PATTERN_KEY = "<key>";
 const TEMPLATE_PATTERN_PROPERTY = "<property>";
 const TYPE_OBJECT = "object";
@@ -86,25 +36,50 @@ const TYPE_ALL = new Set([
 	"null",
 	TYPE_UNDEFINED
 ]);
+//#endregion
+//#region src/helpers.ts
+/**
+* Creates a validator function for a given constructor
+* @param constructor - Constructor to check against
+* @throws Will throw a `TypeError` if the provided argument is not a valid constructor
+* @returns Validator function that checks if a value is an instance of the constructor
+*/
 function instanceOf(constructor) {
 	if (!isConstructor(constructor)) throw new TypeError(MESSAGE_CONSTRUCTOR);
 	return (value) => {
 		return value instanceof constructor;
 	};
 }
+/**
+* Is the value a schematic?
+* @param value Value to check
+* @returns `true` if the value is a schematic, `false` otherwise
+*/
 function isSchematic(value) {
-	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
+	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
 }
+//#endregion
+//#region src/models.ts
+/**
+* A custom error class for schema validation failures, with its `name` set to {@link ERROR_NAME}
+*
+* @example
+* ```ts
+* throw new SchematicError('Expected a string, received a number');
+* ```
+*/
 var SchematicError = class extends Error {
 	constructor(message) {
 		super(message);
 		this.name = ERROR_NAME;
 	}
 };
+//#endregion
+//#region src/validation/property.validation.ts
 function getDisallowedProperty(obj) {
-	if (PROPERTY_REQUIRED in obj) return PROPERTY_REQUIRED;
-	if (PROPERTY_TYPE in obj) return PROPERTY_TYPE;
-	if (PROPERTY_VALIDATORS in obj) return PROPERTY_VALIDATORS;
+	if ("$required" in obj) return PROPERTY_REQUIRED;
+	if ("$type" in obj) return PROPERTY_TYPE;
+	if ("$validators" in obj) return PROPERTY_VALIDATORS;
 }
 function getProperties(original, prefix, fromType) {
 	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
@@ -125,22 +100,22 @@ function getProperties(original, prefix, fromType) {
 		if (isPlainObject(value)) {
 			required = getRequired(key, value) ?? required;
 			validators = getValidators(value[PROPERTY_VALIDATORS]);
-			if (PROPERTY_TYPE in value) types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
+			if ("$type" in value) types.push(TYPE_OBJECT, ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
 			else types.push(TYPE_OBJECT, ...getTypes(key, value, prefix));
 		} else types.push(...getTypes(key, value, prefix));
-		if (!required && !types.includes(TYPE_UNDEFINED)) types.push(TYPE_UNDEFINED);
+		if (!required && !types.includes("undefined")) types.push(TYPE_UNDEFINED);
 		properties.push({
 			key,
 			types,
 			validators,
-			required: required && !types.includes(TYPE_UNDEFINED)
+			required: required && !types.includes("undefined")
 		});
 	}
 	return properties;
 }
 function getRequired(key, obj) {
-	if (!(PROPERTY_REQUIRED in obj)) return;
-	if (typeof obj[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key));
+	if (!("$required" in obj)) return;
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
 	return obj[PROPERTY_REQUIRED];
 }
 function getTypes(key, original, prefix, fromType) {
@@ -162,10 +137,10 @@ function getTypes(key, original, prefix, fromType) {
 			case TYPE_ALL.has(value):
 				types.push(value);
 				break;
-			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
+			default: throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
 		}
 	}
-	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace(TEMPLATE_PATTERN, join([prefix, key], ".")));
+	if (types.length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE.replace("<>", join([prefix, key], ".")));
 	return types;
 }
 function getValidators(original) {
@@ -176,15 +151,17 @@ function getValidators(original) {
 	const { length } = keys;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
-		if (!VALIDATABLE_TYPES.has(key)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace(TEMPLATE_PATTERN, key));
+		if (!VALIDATABLE_TYPES.has(key)) throw new TypeError(MESSAGE_VALIDATOR_INVALID_KEY.replace("<>", key));
 		const value = original[key];
 		validators[key] = (Array.isArray(value) ? value : [value]).filter((item) => {
-			if (typeof item !== "function") throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace(TEMPLATE_PATTERN, key));
+			if (typeof item !== "function") throw new TypeError(MESSAGE_VALIDATOR_INVALID_VALUE.replace("<>", key));
 			return true;
 		});
 	}
 	return validators;
 }
+//#endregion
+//#region src/validation/value.validation.ts
 function validateObject(obj, properties) {
 	if (!isPlainObject(obj)) return false;
 	const propertiesLength = properties.length;
@@ -223,6 +200,8 @@ const validators = {
 	symbol: (value) => typeof value === "symbol",
 	undefined: (value) => value === void 0
 };
+//#endregion
+//#region src/schematic.ts
 /**
 * A schematic for validating objects
 */
@@ -234,6 +213,8 @@ var Schematic = class {
 	}
 	/**
 	* Does the value match the schema?
+	* @param value - Value to validate
+	* @returns `true` if the value matches the schema, otherwise `false`
 	*/
 	is(value) {
 		return validateObject(value, this.#properties);
@@ -244,4 +225,5 @@ function schematic(schema) {
 	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
 	return new Schematic(getProperties(schema));
 }
-export { SchematicError, instanceOf, schematic };
+//#endregion
+export { SchematicError, instanceOf, isSchematic, schematic };