@oscarpalmer/jhunal 0.8.0 → 0.10.0

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/array/compact.js

@@ -0,0 +1,12 @@
+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;
+}
+export { compact };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/is.js

@@ -0,0 +1,20 @@
+/**
+* Is the value an array or a record?
+* @param value Value to check
+* @returns `true` if the value is an array or a record, otherwise `false`
+*/
+function isArrayOrPlainObject(value) {
+	return Array.isArray(value) || isPlainObject(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;
+}
+export { isArrayOrPlainObject };

package/dist/node_modules/@oscarpalmer/atoms/dist/internal/string.js

@@ -0,0 +1,24 @@
+import { compact } from "./array/compact.js";
+/**
+* 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 : "");
+}
+export { join };

package/dist/node_modules/@oscarpalmer/atoms/dist/value/smush.js

@@ -0,0 +1,36 @@
+import { isArrayOrPlainObject } from "../internal/is.js";
+import { join } from "../internal/string.js";
+function flattenObject(value, depth, smushed, prefix) {
+	if (depth >= MAX_DEPTH) return {};
+	if (smushed.has(value)) return smushed.get(value);
+	const keys = Object.keys(value);
+	const { length } = keys;
+	const flattened = {};
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const val = value[key];
+		if (isArrayOrPlainObject(val)) {
+			const prefixedKey = join([prefix, key], ".");
+			flattened[prefixedKey] = Array.isArray(val) ? [...val] : { ...val };
+			const nested = flattenObject(val, depth + 1, smushed, prefixedKey);
+			const nestedKeys = Object.keys(nested);
+			const nestedLength = nestedKeys.length;
+			for (let nestedIndex = 0; nestedIndex < nestedLength; nestedIndex += 1) {
+				const nestedKey = nestedKeys[nestedIndex];
+				flattened[nestedKey] = nested[nestedKey];
+			}
+		} else flattened[join([prefix, key], ".")] = val;
+	}
+	smushed.set(value, flattened);
+	return flattened;
+}
+/**
+* Smush an object into a flat object that uses dot notation keys
+* @param value Object to smush
+* @returns Smushed object with dot notation keys
+*/
+function smush(value) {
+	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
+}
+var MAX_DEPTH = 100;
+export { smush };

package/dist/validation/schema.validation.js

@@ -1,7 +1,8 @@
-import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
-import { isConstructor, isInstance, isSchematic } from "../is.js";
-import { smush } from "@oscarpalmer/atoms/value";
-function addPropertyType(to, key, values, required) {
+import { EXPRESSION_HAS_NUMBER, EXPRESSION_INDEX, EXPRESSION_PROPERTY, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
+import { isInstance, isSchematic } from "../is.js";
+import { smush } from "../node_modules/@oscarpalmer/atoms/dist/value/smush.js";
+import { isConstructor } from "@oscarpalmer/atoms/is";
+function addPropertyType(to, key, values, validators, required) {
 	if (to.keys.set.has(key)) {
 		const property = to.properties[key];
 		for (const type of values) if (!property.types.includes(type)) property.types.push(type);
@@ -10,10 +11,12 @@ function addPropertyType(to, key, values, required) {
 		to.keys.set.add(key);
 		to.properties[key] = {
 			required,
-			types: values
+			types: values,
+			validators: {}
 		};
 	}
 	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push(TYPE_UNDEFINED);
+	to.properties[key].validators = validators;
 }
 function getSchema(schema) {
 	const validated = {
@@ -46,7 +49,7 @@ function getTypes(value, validated, prefix) {
 			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
 		}
-		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
 		propertyTypes.push(TYPE_OBJECT);
 		getValidatedSchema(type, validated, prefix);
 	}
@@ -66,12 +69,24 @@ function getValidatedSchema(schema, validated, prefix) {
 		if (EXPRESSION_PROPERTY.test(key)) continue;
 		if (EXPRESSION_HAS_NUMBER.test(key) && arrayKeys.has(key.replace(EXPRESSION_INDEX, ""))) continue;
 		let required = true;
-		if (typeof value === "object" && value !== null && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		let validators = {};
+		const isObject = typeof value === "object" && value !== null;
+		if (isObject && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		if (isObject && "$validators" in value) validators = getValidators(value[PROPERTY_VALIDATORS]);
 		const prefixedKey = `${prefix}${key}`;
 		const types = getTypes(value, validated, prefixedKey);
-		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
+		if (types.length > 0) addPropertyType(validated, prefixedKey, types, validators, required);
 	}
 	if (noPrefix) validated.keys.array.sort();
 	return validated;
 }
+function getValidators(original) {
+	const validators = {};
+	if (typeof original !== "object" || original === null) return validators;
+	for (const type of TYPE_ALL) {
+		const value = original[type];
+		validators[type] = (Array.isArray(value) ? value : [value]).filter((validator) => typeof validator === "function");
+	}
+	return validators;
+}
 export { getSchema };

package/dist/validation/value.validation.js

@@ -1,9 +1,9 @@
 import "../constants.js";
-import { smush } from "@oscarpalmer/atoms/value";
-function validateType(type, value) {
+import { smush } from "../node_modules/@oscarpalmer/atoms/dist/value/smush.js";
+function validateType(type, property, value) {
 	switch (true) {
 		case typeof type === "function": return type(value);
-		case typeof type === "string": return validators[type](value);
+		case typeof type === "string": return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
 		default: return type.is(value);
 	}
 }
@@ -22,12 +22,12 @@ function validateValue(validated, obj) {
 		if (value === void 0 && property.required && !property.types.includes("undefined")) return false;
 		const typesLength = property.types.length;
 		if (typesLength === 1) {
-			if (!validateType(property.types[0], value)) return false;
+			if (!validateType(property.types[0], property, value)) return false;
 			continue;
 		}
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
-			if (validateType(type, value)) {
+			if (validateType(type, property, value)) {
 				if (type !== "object") ignore.add(key);
 				continue outer;
 			}

package/package.json

@@ -4,15 +4,15 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.136"
+		"@oscarpalmer/atoms": "^0.141.2"
 	},
 	"description": "Flies free beneath the glistening moons…",
 	"devDependencies": {
 		"@types/node": "^25.3",
 		"@vitest/coverage-istanbul": "^4",
 		"jsdom": "^28.1",
-		"oxfmt": "^0.34",
-		"oxlint": "^1.49",
+		"oxfmt": "^0.35",
+		"oxlint": "^1.50",
 		"rolldown": "1.0.0-rc.5",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
@@ -22,8 +22,8 @@
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
-				"types": "./types/index.d.ts",
-				"default": "./dist/index.js"
+			"types": "./types/index.d.ts",
+			"default": "./dist/index.js"
 		}
 	},
 	"files": ["dist", "src", "types"],
@@ -45,5 +45,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.8.0"
+	"version": "0.10.0"
 }

package/src/constants.ts

@@ -4,12 +4,14 @@ export const EXPRESSION_HAS_NUMBER = /\d+/;
 
 export const EXPRESSION_INDEX = /\.\d+$/;
 
-export const EXPRESSION_PROPERTY = /\.\$(required|type)(\.|$)/;
+export const EXPRESSION_PROPERTY = /\.\$(required|type|validators)(\.|$)/;
 
 export const PROPERTY_REQUIRED = '$required';
 
 export const PROPERTY_TYPE = '$type';
 
+export const PROPERTY_VALIDATORS = '$validators';
+
 export const SCHEMATIC_NAME = '$schematic';
 
 export const TYPE_OBJECT = 'object';

package/src/is.ts

@@ -1,11 +1,8 @@
+import {isConstructor} from '@oscarpalmer/atoms/is';
 import {SCHEMATIC_NAME} from './constants';
 import type {Constructor} from './models';
 import type {Schematic} from './schematic';
 
-export function isConstructor(value: unknown): value is Constructor<unknown> {
-	return typeof value === 'function' && value.prototype !== undefined;
-}
-
 export function isInstance<Instance>(
 	constructor: Constructor<Instance>,
 ): (value: unknown) => value is Instance {

package/src/models.ts

@@ -12,6 +12,14 @@ type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Va
 		: DeduplicateTuple<Tail, [...Seen, Head]>
 	: Seen;
 
+type ExtractValueNames<Value> = Value extends ValueName
+	? Value
+	: Value extends (infer Item)[]
+		? ExtractValueNames<Item>
+		: Value extends readonly (infer Item)[]
+			? ExtractValueNames<Item>
+			: never;
+
 /**
  * Infer the TypeScript type from a schema definition
  */
@@ -93,6 +101,12 @@ type OptionalKeys<Value> = {
 	[Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
 
+type PropertyValidators<Value> = {
+	[Key in ExtractValueNames<Value>]?:
+		| ((value: Values[Key]) => boolean)
+		| Array<(value: Values[Key]) => boolean>;
+};
+
 type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
 
 /**
@@ -112,6 +126,7 @@ interface SchemaIndex {
 export type SchemaProperty = {
 	$required?: boolean;
 	$type: SchemaPropertyType | SchemaPropertyType[];
+	$validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 
 type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
@@ -173,13 +188,33 @@ type TupleRemoveAt<
 	: Prefix;
 
 export type TypedPropertyOptional<Value> = {
+	/**
+	 * The property is not required
+	 */
 	$required: false;
+	/**
+	 * The type(s) of the property
+	 */
 	$type: ToSchemaPropertyType<Exclude<Value, undefined>>;
+	/**
+	 * Custom validators for the property and its types
+	 */
+	$validators?: PropertyValidators<ToSchemaPropertyType<Exclude<Value, undefined>>>;
 };
 
 export type TypedPropertyRequired<Value> = {
+	/**
+	 * The property is required _(defaults to `true`)_
+	 */
 	$required?: true;
+	/**
+	 * The type(s) of the property
+	 */
 	$type: ToSchemaPropertyType<Value>;
+	/**
+	 * Custom validators for the property and its types
+	 */
+	$validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
 };
 
 /**
@@ -224,10 +259,15 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only]
 export type ValidatedProperty = {
 	required: boolean;
 	types: ValidatedPropertyType[];
+	validators: ValidatedPropertyValidators;
 };
 
 export type ValidatedPropertyType = Schematic<unknown> | ValueName;
 
+export type ValidatedPropertyValidators = {
+	[Key in ValueName]?: Array<(value: unknown) => boolean>;
+};
+
 export type ValidatedSchema = {
 	enabled: boolean;
 	keys: {

package/src/validation/schema.validation.ts

@@ -1,22 +1,30 @@
+import {isConstructor} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value';
+import {smush} from '@oscarpalmer/atoms/value/misc';
 import {
 	EXPRESSION_HAS_NUMBER,
 	EXPRESSION_INDEX,
 	EXPRESSION_PROPERTY,
 	PROPERTY_REQUIRED,
 	PROPERTY_TYPE,
+	PROPERTY_VALIDATORS,
 	TYPE_ALL,
 	TYPE_OBJECT,
 	TYPE_UNDEFINED,
 } from '../constants';
-import {isConstructor, isInstance, isSchematic} from '../is';
-import type {Schema, ValidatedPropertyType, ValidatedSchema} from '../models';
+import {isInstance, isSchematic} from '../is';
+import type {
+	Schema,
+	ValidatedPropertyType,
+	ValidatedPropertyValidators,
+	ValidatedSchema,
+} from '../models';
 
 function addPropertyType(
 	to: ValidatedSchema,
 	key: string,
 	values: ValidatedPropertyType[],
+	validators: ValidatedPropertyValidators,
 	required: boolean,
 ): void {
 	if (to.keys.set.has(key)) {
@@ -34,12 +42,15 @@ function addPropertyType(
 		to.properties[key] = {
 			required,
 			types: values,
+			validators: {},
 		};
 	}
 
 	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) {
 		to.properties[key].types.push(TYPE_UNDEFINED);
 	}
+
+	to.properties[key].validators = validators;
 }
 
 export function getSchema(schema: unknown): ValidatedSchema {
@@ -93,7 +104,7 @@ function getTypes(
 			continue;
 		}
 
-		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		addPropertyType(validated, prefix, [TYPE_OBJECT], {}, type[PROPERTY_REQUIRED] !== false);
 
 		propertyTypes.push(TYPE_OBJECT);
 
@@ -134,17 +145,24 @@ function getValidatedSchema(
 		}
 
 		let required = true;
+		let validators: ValidatedPropertyValidators = {};
+
+		const isObject = typeof value === 'object' && value !== null;
 
-		if (typeof value === 'object' && value !== null && PROPERTY_REQUIRED in value) {
+		if (isObject && PROPERTY_REQUIRED in value) {
 			required = typeof value[PROPERTY_REQUIRED] === 'boolean' ? value[PROPERTY_REQUIRED] : true;
 		}
 
+		if (isObject && PROPERTY_VALIDATORS in value) {
+			validators = getValidators(value[PROPERTY_VALIDATORS]);
+		}
+
 		const prefixedKey = `${prefix}${key}`;
 
 		const types = getTypes(value, validated, prefixedKey);
 
 		if (types.length > 0) {
-			addPropertyType(validated, prefixedKey, types, required);
+			addPropertyType(validated, prefixedKey, types, validators, required);
 		}
 	}
 
@@ -154,3 +172,21 @@ function getValidatedSchema(
 
 	return validated;
 }
+
+function getValidators(original: unknown): ValidatedPropertyValidators {
+	const validators: ValidatedPropertyValidators = {};
+
+	if (typeof original !== 'object' || original === null) {
+		return validators;
+	}
+
+	for (const type of TYPE_ALL) {
+		const value = (original as PlainObject)[type];
+
+		validators[type] = (Array.isArray(value) ? value : [value]).filter(
+			validator => typeof validator === 'function',
+		);
+	}
+
+	return validators;
+}

package/src/validation/value.validation.ts

@@ -1,15 +1,22 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {smush} from '@oscarpalmer/atoms/value';
+import {smush} from '@oscarpalmer/atoms/value/misc';
 import {TYPE_UNDEFINED} from '../constants';
-import type {ValidatedPropertyType, ValidatedSchema, Values} from '../models';
+import type {ValidatedProperty, ValidatedPropertyType, ValidatedSchema, Values} from '../models';
 
-export function validateType(type: ValidatedPropertyType, value: unknown): boolean {
+export function validateType(
+	type: ValidatedPropertyType,
+	property: ValidatedProperty,
+	value: unknown,
+): boolean {
 	switch (true) {
 		case typeof type === 'function':
 			return (type as any)(value);
 
 		case typeof type === 'string':
-			return validators[type](value);
+			return (
+				validators[type](value) &&
+				(property.validators[type]?.every(validator => validator(value)) ?? true)
+			);
 
 		default:
 			return type.is(value);
@@ -47,7 +54,7 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 		const typesLength = property.types.length;
 
 		if (typesLength === 1) {
-			if (!validateType(property.types[0], value)) {
+			if (!validateType(property.types[0], property, value)) {
 				return false;
 			}
 
@@ -57,7 +64,7 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
 			const type = property.types[typeIndex];
 
-			if (validateType(type, value)) {
+			if (validateType(type, property, value)) {
 				if ((type as never) !== 'object') {
 					ignore.add(key);
 				}

package/types/constants.d.ts

@@ -4,6 +4,7 @@ export declare const EXPRESSION_INDEX: RegExp;
 export declare const EXPRESSION_PROPERTY: RegExp;
 export declare const PROPERTY_REQUIRED = "$required";
 export declare const PROPERTY_TYPE = "$type";
+export declare const PROPERTY_VALIDATORS = "$validators";
 export declare const SCHEMATIC_NAME = "$schematic";
 export declare const TYPE_OBJECT = "object";
 export declare const TYPE_UNDEFINED = "undefined";

package/types/is.d.ts

@@ -1,5 +1,4 @@
 import type { Constructor } from './models';
 import type { Schematic } from './schematic';
-export declare function isConstructor(value: unknown): value is Constructor<unknown>;
 export declare function isInstance<Instance>(constructor: Constructor<Instance>): (value: unknown) => value is Instance;
 export declare function isSchematic(value: unknown): value is Schematic<never>;

package/types/models.d.ts

@@ -5,6 +5,7 @@ type DeduplicateTuple<Value extends unknown[], Seen extends unknown[] = []> = Va
     infer Head,
     ...infer Tail
 ] ? Head extends Seen[number] ? DeduplicateTuple<Tail, Seen> : DeduplicateTuple<Tail, [...Seen, Head]> : Seen;
+type ExtractValueNames<Value> = Value extends ValueName ? Value : Value extends (infer Item)[] ? ExtractValueNames<Item> : Value extends readonly (infer Item)[] ? ExtractValueNames<Item> : never;
 /**
  * Infer the TypeScript type from a schema definition
  */
@@ -36,6 +37,9 @@ export type NestedSchema = {
 type OptionalKeys<Value> = {
     [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
 }[keyof Value];
+type PropertyValidators<Value> = {
+    [Key in ExtractValueNames<Value>]?: ((value: Values[Key]) => boolean) | Array<(value: Values[Key]) => boolean>;
+};
 type RequiredKeys<Value> = Exclude<keyof Value, OptionalKeys<Value>>;
 /**
  * A schema for validating objects
@@ -51,6 +55,7 @@ interface SchemaIndex {
 export type SchemaProperty = {
     $required?: boolean;
     $type: SchemaPropertyType | SchemaPropertyType[];
+    $validators?: PropertyValidators<SchemaPropertyType | SchemaPropertyType[]>;
 };
 type SchemaPropertyType = Constructor | Schema | Schematic<unknown> | ValueName;
 type ToSchemaPropertyType<Value> = UnwrapSingle<DeduplicateTuple<MapToSchemaPropertyTypes<UnionToTuple<Value>>>>;
@@ -65,12 +70,32 @@ type TuplePermutations<Tuple extends unknown[], Elput extends unknown[] = []> =
 }[keyof Tuple & `${number}`];
 type TupleRemoveAt<Items extends unknown[], Item extends string, Prefix extends unknown[] = []> = Items extends [infer Head, ...infer Tail] ? `${Prefix['length']}` extends Item ? [...Prefix, ...Tail] : TupleRemoveAt<Tail, Item, [...Prefix, Head]> : Prefix;
 export type TypedPropertyOptional<Value> = {
+    /**
+     * The property is not required
+     */
     $required: false;
+    /**
+     * The type(s) of the property
+     */
     $type: ToSchemaPropertyType<Exclude<Value, undefined>>;
+    /**
+     * Custom validators for the property and its types
+     */
+    $validators?: PropertyValidators<ToSchemaPropertyType<Exclude<Value, undefined>>>;
 };
 export type TypedPropertyRequired<Value> = {
+    /**
+     * The property is required _(defaults to `true`)_
+     */
     $required?: true;
+    /**
+     * The type(s) of the property
+     */
     $type: ToSchemaPropertyType<Value>;
+    /**
+     * Custom validators for the property and its types
+     */
+    $validators?: PropertyValidators<ToSchemaPropertyType<Value>>;
 };
 /**
  * Create a schema type constrained to match a TypeScript type
@@ -92,8 +117,12 @@ type UnwrapSingle<Value extends unknown[]> = Value extends [infer Only] ? Only :
 export type ValidatedProperty = {
     required: boolean;
     types: ValidatedPropertyType[];
+    validators: ValidatedPropertyValidators;
 };
 export type ValidatedPropertyType = Schematic<unknown> | ValueName;
+export type ValidatedPropertyValidators = {
+    [Key in ValueName]?: Array<(value: unknown) => boolean>;
+};
 export type ValidatedSchema = {
     enabled: boolean;
     keys: {

package/types/validation/value.validation.d.ts

@@ -1,3 +1,3 @@
-import type { ValidatedPropertyType, ValidatedSchema } from '../models';
-export declare function validateType(type: ValidatedPropertyType, value: unknown): boolean;
+import type { ValidatedProperty, ValidatedPropertyType, ValidatedSchema } from '../models';
+export declare function validateType(type: ValidatedPropertyType, property: ValidatedProperty, value: unknown): boolean;
 export declare function validateValue(validated: ValidatedSchema, obj: unknown): boolean;