@oscarpalmer/jhunal 0.13.0 → 0.15.0

package/dist/constants.js

@@ -1,12 +1,9 @@
 const ERROR_NAME = "SchematicError";
-const EXPRESSION_INDEX = /\.\d+$/;
-const EXPRESSION_KEY_PREFIX = /\.\w+$/;
-const EXPRESSION_KEY_VALUE = /^.*\.(\w+)$/;
 const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
 const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED = "'<>.$required' property is not allowed for schemas in $type";
-const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE = "'<>.$required' property must be a boolean";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<key>.<property>' property is not allowed for schemas in $type";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
 const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
 const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
@@ -17,6 +14,8 @@ 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";
 const TYPE_UNDEFINED = "undefined";
 const VALIDATABLE_TYPES = new Set([
@@ -35,4 +34,4 @@ const TYPE_ALL = new Set([
 	"null",
 	TYPE_UNDEFINED
 ]);
-export { ERROR_NAME, EXPRESSION_INDEX, EXPRESSION_KEY_PREFIX, EXPRESSION_KEY_VALUE, EXPRESSION_PROPERTY, MESSAGE_CONSTRUCTOR, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_SCHEMA_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_NAME, TEMPLATE_PATTERN, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES };
+export { ERROR_NAME, EXPRESSION_PROPERTY, MESSAGE_CONSTRUCTOR, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_SCHEMA_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, SCHEMATIC_NAME, TEMPLATE_PATTERN, TEMPLATE_PATTERN_KEY, TEMPLATE_PATTERN_PROPERTY, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES };

package/dist/helpers.js

@@ -1,11 +1,22 @@
 import { MESSAGE_CONSTRUCTOR } from "./constants.js";
 import { isConstructor } from "@oscarpalmer/atoms/is";
+/**
+* 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" in value && value["$schematic"] === true;
 }

package/dist/index.js

@@ -1,4 +1,4 @@
-import { instanceOf } from "./helpers.js";
+import { instanceOf, isSchematic } from "./helpers.js";
 import { SchematicError } from "./models.js";
 import { schematic } from "./schematic.js";
-export { SchematicError, instanceOf, schematic };
+export { SchematicError, instanceOf, isSchematic, schematic };

package/dist/jhunal.full.js

@@ -51,12 +51,11 @@ function join(value, delimiter) {
 	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
 }
 const ERROR_NAME = "SchematicError";
-const EXPRESSION_INDEX = /\.\d+$/;
 const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
 const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED = "'<>.$required' property is not allowed for schemas in $type";
-const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE = "'<>.$required' property must be a boolean";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<key>.<property>' property is not allowed for schemas in $type";
+const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
 const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
 const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
@@ -67,6 +66,8 @@ 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";
 const TYPE_UNDEFINED = "undefined";
 const VALIDATABLE_TYPES = new Set([
@@ -85,30 +86,57 @@ const TYPE_ALL = new Set([
 	"null",
 	TYPE_UNDEFINED
 ]);
+/**
+* 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;
 }
+/**
+* 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;
 	}
 };
-function getProperties(original, prefix, fromTypes) {
+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;
+}
+function getProperties(original, prefix, fromType) {
 	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
-	if (PROPERTY_REQUIRED in original && (fromTypes ?? false) && prefix != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED.replace(TEMPLATE_PATTERN, prefix));
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+		if (property != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN_KEY, prefix).replace(TEMPLATE_PATTERN_PROPERTY, property));
+	}
 	const keys = Object.keys(original);
 	const keysLength = keys.length;
 	const properties = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
-		if (EXPRESSION_INDEX.test(key) || EXPRESSION_PROPERTY.test(key)) continue;
+		if (EXPRESSION_PROPERTY.test(key)) continue;
 		const value = original[key];
 		const types = [];
 		let required = true;
@@ -116,8 +144,8 @@ function getProperties(original, prefix, fromTypes) {
 		if (isPlainObject(value)) {
 			required = getRequired(key, value) ?? required;
 			validators = getValidators(value[PROPERTY_VALIDATORS]);
-			if (PROPERTY_TYPE in value) types.push("object", ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
-			else types.push("object", ...getTypes(key, value, prefix));
+			if (PROPERTY_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);
 		properties.push({
@@ -131,10 +159,10 @@ function getProperties(original, prefix, fromTypes) {
 }
 function getRequired(key, obj) {
 	if (!(PROPERTY_REQUIRED in obj)) return;
-	if (typeof obj[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE.replace(TEMPLATE_PATTERN, key));
+	if (typeof obj[PROPERTY_REQUIRED] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace(TEMPLATE_PATTERN, key));
 	return obj[PROPERTY_REQUIRED];
 }
-function getTypes(key, original, prefix, fromTypes) {
+function getTypes(key, original, prefix, fromType) {
 	const array = Array.isArray(original) ? original : [original];
 	const { length } = array;
 	const types = [];
@@ -145,7 +173,7 @@ function getTypes(key, original, prefix, fromTypes) {
 				types.push(isConstructor(value) ? instanceOf(value) : value);
 				break;
 			case isPlainObject(value):
-				types.push(...getProperties(value, join([prefix, key], "."), fromTypes));
+				types.push(...getProperties(value, join([prefix, key], "."), fromType));
 				break;
 			case isSchematic(value):
 				types.push(value);
@@ -225,6 +253,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);
@@ -235,4 +265,4 @@ function schematic(schema) {
 	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
 	return new Schematic(getProperties(schema));
 }
-export { SchematicError, instanceOf, schematic };
+export { SchematicError, instanceOf, isSchematic, schematic };

package/dist/models.js

@@ -1,4 +1,12 @@
 import { ERROR_NAME } from "./constants.js";
+/**
+* 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);

package/dist/schematic.js

@@ -15,6 +15,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);

package/dist/validation/property.validation.js

@@ -1,17 +1,25 @@
-import { EXPRESSION_INDEX, EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TYPE_ALL, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.js";
+import { EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TEMPLATE_PATTERN_KEY, TEMPLATE_PATTERN_PROPERTY, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.js";
 import { instanceOf, isSchematic } from "../helpers.js";
 import { SchematicError } from "../models.js";
-import { join } from "../node_modules/@oscarpalmer/atoms/dist/internal/string.js";
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
-function getProperties(original, prefix, fromTypes) {
+import { join } from "@oscarpalmer/atoms/string/misc";
+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 getProperties(original, prefix, fromType) {
 	if (Object.keys(original).length === 0) throw new SchematicError(MESSAGE_SCHEMA_INVALID_EMPTY);
-	if ("$required" in original && (fromTypes ?? false) && prefix != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED.replace("<>", prefix));
+	if (fromType ?? false) {
+		const property = getDisallowedProperty(original);
+		if (property != null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED.replace(TEMPLATE_PATTERN_KEY, prefix).replace(TEMPLATE_PATTERN_PROPERTY, property));
+	}
 	const keys = Object.keys(original);
 	const keysLength = keys.length;
 	const properties = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
-		if (EXPRESSION_INDEX.test(key) || EXPRESSION_PROPERTY.test(key)) continue;
+		if (EXPRESSION_PROPERTY.test(key)) continue;
 		const value = original[key];
 		const types = [];
 		let required = true;
@@ -19,8 +27,8 @@ function getProperties(original, prefix, fromTypes) {
 		if (isPlainObject(value)) {
 			required = getRequired(key, value) ?? required;
 			validators = getValidators(value[PROPERTY_VALIDATORS]);
-			if ("$type" in value) types.push("object", ...getTypes(key, value[PROPERTY_TYPE], prefix, true));
-			else types.push("object", ...getTypes(key, value, prefix));
+			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("undefined")) types.push(TYPE_UNDEFINED);
 		properties.push({
@@ -34,10 +42,10 @@ function getProperties(original, prefix, fromTypes) {
 }
 function getRequired(key, obj) {
 	if (!("$required" in obj)) return;
-	if (typeof obj["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE.replace("<>", key));
+	if (typeof obj["$required"] !== "boolean") throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED.replace("<>", key));
 	return obj[PROPERTY_REQUIRED];
 }
-function getTypes(key, original, prefix, fromTypes) {
+function getTypes(key, original, prefix, fromType) {
 	const array = Array.isArray(original) ? original : [original];
 	const { length } = array;
 	const types = [];
@@ -48,7 +56,7 @@ function getTypes(key, original, prefix, fromTypes) {
 				types.push(isConstructor(value) ? instanceOf(value) : value);
 				break;
 			case isPlainObject(value):
-				types.push(...getProperties(value, join([prefix, key], "."), fromTypes));
+				types.push(...getProperties(value, join([prefix, key], "."), fromType));
 				break;
 			case isSchematic(value):
 				types.push(value);

package/package.json

@@ -45,5 +45,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.13.0"
+	"version": "0.15.0"
 }

package/src/constants.ts

@@ -2,22 +2,16 @@ import type {ValueName} from './models';
 
 export const ERROR_NAME = 'SchematicError';
 
-export const EXPRESSION_INDEX = /\.\d+$/;
-
-export const EXPRESSION_KEY_PREFIX = /\.\w+$/;
-
-export const EXPRESSION_KEY_VALUE = /^.*\.(\w+)$/;
-
 export const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
 
 export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
 
 export const MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one property';
 
-export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_DISALLOWED =
-	"'<>.$required' property is not allowed for schemas in $type";
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED =
+	"'<key>.<property>' property is not allowed for schemas in $type";
 
-export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED_TYPE =
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED =
 	"'<>.$required' property must be a boolean";
 
 export const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
@@ -41,6 +35,10 @@ export const SCHEMATIC_NAME = '$schematic';
 
 export const TEMPLATE_PATTERN = '<>';
 
+export const TEMPLATE_PATTERN_KEY = '<key>';
+
+export const TEMPLATE_PATTERN_PROPERTY = '<property>';
+
 export const TYPE_OBJECT = 'object';
 
 export const TYPE_UNDEFINED = 'undefined';

package/src/helpers.ts

@@ -1,8 +1,14 @@
 import {isConstructor} from '@oscarpalmer/atoms/is';
+import type {Constructor} from '@oscarpalmer/atoms/models';
 import {MESSAGE_CONSTRUCTOR, SCHEMATIC_NAME} from './constants';
-import type {Constructor} from './models';
 import type {Schematic} from './schematic';
 
+/**
+ * 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
+ */
 export function instanceOf<Instance>(
 	constructor: Constructor<Instance>,
 ): (value: unknown) => value is Instance {
@@ -15,6 +21,11 @@ export function instanceOf<Instance>(
 	};
 }
 
+/**
+ * Is the value a schematic?
+ * @param value Value to check
+ * @returns `true` if the value is a schematic, `false` otherwise
+ */
 export function isSchematic(value: unknown): value is Schematic<never> {
 	return (
 		typeof value === 'object' &&

package/src/index.ts

@@ -1,3 +1,3 @@
-export {instanceOf} from './helpers';
+export {instanceOf, isSchematic} from './helpers';
 export {SchematicError, type Schema, type TypedSchema} from './models';
 export {schematic, type Schematic} from './schematic';