@oscarpalmer/jhunal 0.5.0 → 0.7.0

package/dist/constants.js

@@ -0,0 +1,21 @@
+const PROPERTY_REQUIRED = "$required";
+const PROPERTY_TYPE = "$type";
+const SCHEMATIC_NAME = "$schematic";
+const TYPE_OBJECT = "object";
+const TYPE_UNDEFINED = "undefined";
+const TYPE_ALL = new Set([
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"date-like",
+	"function",
+	"null",
+	"number",
+	"numerical",
+	"string",
+	"symbol",
+	TYPE_OBJECT,
+	TYPE_UNDEFINED
+]);
+export { PROPERTY_REQUIRED, PROPERTY_TYPE, SCHEMATIC_NAME, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED };

package/dist/is.js

@@ -1,9 +1,10 @@
+import { SCHEMATIC_NAME } from "./constants.js";
 function isDateLike(value) {
 	if (value instanceof Date) return true;
 	if (typeof value === "number") return value >= -864e13 && value <= 864e13;
 	return typeof value === "string" && !Number.isNaN(Date.parse(value));
 }
 function isSchematic(value) {
-	return typeof value === "object" && value !== null && "$schematic" in value && value.$schematic === true;
+	return typeof value === "object" && value !== null && "$schematic" in value && value["$schematic"] === true;
 }
 export { isDateLike, isSchematic };

package/dist/jhunal.full.js

@@ -1,103 +1,203 @@
+const PROPERTY_REQUIRED = "$required";
+const PROPERTY_TYPE = "$type";
+const SCHEMATIC_NAME = "$schematic";
+const TYPE_OBJECT = "object";
+const TYPE_UNDEFINED = "undefined";
+const TYPE_ALL = new Set([
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"date-like",
+	"function",
+	"null",
+	"number",
+	"numerical",
+	"string",
+	"symbol",
+	TYPE_OBJECT,
+	TYPE_UNDEFINED
+]);
+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;
+}
+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;
+}
+function join(value, delimiter) {
+	return compact(value).map(getString).join(typeof delimiter === "string" ? delimiter : "");
+}
+function isArrayOrPlainObject(value) {
+	return Array.isArray(value) || isPlainObject(value);
+}
+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;
+}
+new Set([
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	BigInt64Array,
+	BigUint64Array
+]);
+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;
+}
+function smush(value) {
+	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
+}
+var MAX_DEPTH = 100;
 function isDateLike(value) {
 	if (value instanceof Date) return true;
 	if (typeof value === "number") return value >= -864e13 && value <= 864e13;
 	return typeof value === "string" && !Number.isNaN(Date.parse(value));
 }
 function isSchematic(value) {
-	return typeof value === "object" && value !== null && "$schematic" in value && value.$schematic === true;
+	return typeof value === "object" && value !== null && SCHEMATIC_NAME in value && value[SCHEMATIC_NAME] === true;
+}
+function addPropertyType(to, key, values, 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);
+	} else {
+		to.keys.array.push(key);
+		to.keys.set.add(key);
+		to.properties[key] = {
+			required,
+			types: values
+		};
+	}
+	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) to.properties[key].types.push(TYPE_UNDEFINED);
 }
-function getTypes(value) {
-	const returned = [];
+function getTypes(value, validated, prefix) {
+	const propertyTypes = [];
 	const values = Array.isArray(value) ? value : [value];
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		switch (true) {
-			case isSchematic(type):
-				returned.push(type);
-				break;
-			case typeof type === "string" && types.has(type):
-				returned.push(type);
-				break;
-			case typeof type === "object" && type !== null:
-				returned.push(validateSchema(type));
-				break;
-			default: break;
+		if (isSchematic(type) || typeof type === "string" && TYPE_ALL.has(type)) {
+			propertyTypes.push(type);
+			continue;
+		}
+		if (typeof type !== "object" || type === null) continue;
+		if (PROPERTY_TYPE in type) {
+			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
+			continue;
 		}
+		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		propertyTypes.push(TYPE_OBJECT);
+		getValidatedSchema(type, validated, prefix);
 	}
-	return returned;
+	return propertyTypes;
 }
-const types = new Set([
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"date-like",
-	"function",
-	"null",
-	"number",
-	"numerical",
-	"object",
-	"string",
-	"symbol",
-	"undefined"
-]);
-function validateSchema(schema) {
-	if (validatedSchemas.has(schema)) return validatedSchemas.get(schema);
-	const validated = {
-		keys: [],
-		length: 0,
-		properties: {}
-	};
-	if (typeof schema !== "object" || schema === null) return validated;
-	const keys = Object.keys(schema);
+function getValidatedSchema(schema, validated, prefix) {
+	const smushed = smush(schema);
+	const keys = Object.keys(smushed);
 	const { length } = keys;
+	const arrayKeys = /* @__PURE__ */ new Set();
+	const noPrefix = prefix == null;
+	prefix = noPrefix ? "" : `${prefix}.`;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
-		const value = schema[key];
+		const value = smushed[key];
+		if (Array.isArray(value)) arrayKeys.add(key);
+		if (/\.\$(required|type)(\.|$)/.test(key)) continue;
+		if (/\d+/.test(key) && arrayKeys.has(key.replace(/\.\d+$/, ""))) continue;
 		let required = true;
-		let types$1;
-		if (Array.isArray(value)) types$1 = getTypes(value);
-		else if (typeof value === "object" && value !== null) {
-			if (typeof value.required === "boolean") required = value.required;
-			types$1 = getTypes(value.type);
-		} else types$1 = getTypes(value);
-		if (types$1.length > 0) {
-			if (!required && !types$1.includes("undefined")) types$1.push("undefined");
-			validated.keys.push(key);
-			validated.properties[key] = {
-				required,
-				types: types$1
-			};
-			validated.length += 1;
-		}
+		if (typeof value === "object" && value !== null && PROPERTY_REQUIRED in value) required = typeof value[PROPERTY_REQUIRED] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		const prefixedKey = `${prefix}${key}`;
+		const types = getTypes(value, validated, prefixedKey);
+		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
 	}
-	validatedSchemas.set(schema, validated);
+	if (noPrefix) validated.keys.array.sort();
 	return validated;
 }
-const validatedSchemas = /* @__PURE__ */ new WeakMap();
+function validateSchema(schema) {
+	const validated = {
+		keys: {
+			array: [],
+			set: /* @__PURE__ */ new Set()
+		},
+		properties: {}
+	};
+	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+}
 function validateType(type, value) {
-	if (typeof type === "string") return validators[type](value);
-	if (isSchematic(type)) return type.is(value);
-	return validateValue(type, value);
+	return typeof type === "string" ? validators[type](value) : type.is(value);
 }
 function validateValue(validated, obj) {
 	if (typeof obj !== "object" || obj === null) return false;
-	outer: for (let keyIndex = 0; keyIndex < validated.length; keyIndex += 1) {
-		const key = validated.keys[keyIndex];
-		const property = validated.properties[key];
-		const value = obj[key];
-		if (value === void 0 && property.required && !property.types.includes("undefined")) return false;
+	const { keys, properties } = validated;
+	const keysLength = keys.array.length;
+	const ignore = /* @__PURE__ */ new Set();
+	const smushed = smush(obj);
+	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys.array[keyIndex];
+		const prefix = key.replace(EXPRESSION_SUFFIX, "");
+		if (ignore.has(prefix)) continue;
+		const property = properties[key];
+		const value = smushed[key];
+		if (value === void 0 && property.required && !property.types.includes(TYPE_UNDEFINED)) return false;
 		const typesLength = property.types.length;
 		if (typesLength === 1) {
 			if (!validateType(property.types[0], value)) return false;
 			continue;
 		}
-		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) if (validateType(property.types[typeIndex], value)) continue outer;
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			const type = property.types[typeIndex];
+			if (validateType(type, value)) {
+				if (type !== TYPE_OBJECT) ignore.add(key);
+				continue outer;
+			}
+		}
 		return false;
 	}
 	return true;
 }
+const EXPRESSION_SUFFIX = /\.\w+$/;
 const validators = {
 	array: Array.isArray,
 	bigint: (value) => typeof value === "bigint",
@@ -106,7 +206,7 @@ const validators = {
 	"date-like": isDateLike,
 	function: (value) => typeof value === "function",
 	null: (value) => value === null,
-	number: (value) => typeof value === "number",
+	number: (value) => typeof value === "number" && !Number.isNaN(value),
 	numerical: (value) => validators.bigint(value) || validators.number(value),
 	object: (value) => typeof value === "object" && value !== null,
 	string: (value) => typeof value === "string",
@@ -120,9 +220,9 @@ var Schematic = class {
 		return this.#validatable;
 	}
 	constructor(schema) {
-		Object.defineProperty(this, "$schematic", { value: true });
+		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
 		this.#schema = validateSchema(schema);
-		this.#validatable = this.#schema.length > 0;
+		this.#validatable = this.#schema.keys.array.length > 0;
 	}
 	is(value) {
 		return this.#validatable && validateValue(this.#schema, value);

package/dist/schematic.js

@@ -1,3 +1,4 @@
+import { SCHEMATIC_NAME } from "./constants.js";
 import { validateSchema } from "./validation/schema.validation.js";
 import { validateValue } from "./validation/value.validation.js";
 var Schematic = class {
@@ -7,9 +8,9 @@ var Schematic = class {
 		return this.#validatable;
 	}
 	constructor(schema) {
-		Object.defineProperty(this, "$schematic", { value: true });
+		Object.defineProperty(this, SCHEMATIC_NAME, { value: true });
 		this.#schema = validateSchema(schema);
-		this.#validatable = this.#schema.length > 0;
+		this.#validatable = this.#schema.keys.array.length > 0;
 	}
 	is(value) {
 		return this.#validatable && validateValue(this.#schema, value);

package/dist/validation/schema.validation.js

@@ -1,36 +1,71 @@
-import { getTypes } from "../helpers.js";
-function validateSchema(schema) {
-	if (validatedSchemas.has(schema)) return validatedSchemas.get(schema);
-	const validated = {
-		keys: [],
-		length: 0,
-		properties: {}
-	};
-	if (typeof schema !== "object" || schema === null) return validated;
-	const keys = Object.keys(schema);
+import { PROPERTY_REQUIRED, PROPERTY_TYPE, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
+import { isSchematic } from "../is.js";
+import { smush } from "@oscarpalmer/atoms/value";
+function addPropertyType(to, key, values, 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);
+	} else {
+		to.keys.array.push(key);
+		to.keys.set.add(key);
+		to.properties[key] = {
+			required,
+			types: values
+		};
+	}
+	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push(TYPE_UNDEFINED);
+}
+function getTypes(value, validated, prefix) {
+	const propertyTypes = [];
+	const values = Array.isArray(value) ? value : [value];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) {
+		const type = values[index];
+		if (isSchematic(type) || typeof type === "string" && TYPE_ALL.has(type)) {
+			propertyTypes.push(type);
+			continue;
+		}
+		if (typeof type !== "object" || type === null) continue;
+		if ("$type" in type) {
+			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
+			continue;
+		}
+		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		propertyTypes.push(TYPE_OBJECT);
+		getValidatedSchema(type, validated, prefix);
+	}
+	return propertyTypes;
+}
+function getValidatedSchema(schema, validated, prefix) {
+	const smushed = smush(schema);
+	const keys = Object.keys(smushed);
 	const { length } = keys;
+	const arrayKeys = /* @__PURE__ */ new Set();
+	const noPrefix = prefix == null;
+	prefix = noPrefix ? "" : `${prefix}.`;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
-		const value = schema[key];
+		const value = smushed[key];
+		if (Array.isArray(value)) arrayKeys.add(key);
+		if (/\.\$(required|type)(\.|$)/.test(key)) continue;
+		if (/\d+/.test(key) && arrayKeys.has(key.replace(/\.\d+$/, ""))) continue;
 		let required = true;
-		let types;
-		if (Array.isArray(value)) types = getTypes(value);
-		else if (typeof value === "object" && value !== null) {
-			if (typeof value.required === "boolean") required = value.required;
-			types = getTypes(value.type);
-		} else types = getTypes(value);
-		if (types.length > 0) {
-			if (!required && !types.includes("undefined")) types.push("undefined");
-			validated.keys.push(key);
-			validated.properties[key] = {
-				required,
-				types
-			};
-			validated.length += 1;
-		}
+		if (typeof value === "object" && value !== null && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
+		const prefixedKey = `${prefix}${key}`;
+		const types = getTypes(value, validated, prefixedKey);
+		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
 	}
-	validatedSchemas.set(schema, validated);
+	if (noPrefix) validated.keys.array.sort();
 	return validated;
 }
-const validatedSchemas = /* @__PURE__ */ new WeakMap();
-export { validateSchema, validatedSchemas };
+function validateSchema(schema) {
+	const validated = {
+		keys: {
+			array: [],
+			set: /* @__PURE__ */ new Set()
+		},
+		properties: {}
+	};
+	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+}
+export { validateSchema };

package/dist/validation/value.validation.js

@@ -1,26 +1,39 @@
-import { isDateLike, isSchematic } from "../is.js";
+import { TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
+import { isDateLike } from "../is.js";
+import { smush } from "@oscarpalmer/atoms/value";
 function validateType(type, value) {
-	if (typeof type === "string") return validators[type](value);
-	if (isSchematic(type)) return type.is(value);
-	return validateValue(type, value);
+	return typeof type === "string" ? validators[type](value) : type.is(value);
 }
 function validateValue(validated, obj) {
 	if (typeof obj !== "object" || obj === null) return false;
-	outer: for (let keyIndex = 0; keyIndex < validated.length; keyIndex += 1) {
-		const key = validated.keys[keyIndex];
-		const property = validated.properties[key];
-		const value = obj[key];
+	const { keys, properties } = validated;
+	const keysLength = keys.array.length;
+	const ignore = /* @__PURE__ */ new Set();
+	const smushed = smush(obj);
+	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys.array[keyIndex];
+		const prefix = key.replace(EXPRESSION_SUFFIX, "");
+		if (ignore.has(prefix)) continue;
+		const property = properties[key];
+		const value = smushed[key];
 		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;
 			continue;
 		}
-		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) if (validateType(property.types[typeIndex], value)) continue outer;
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			const type = property.types[typeIndex];
+			if (validateType(type, value)) {
+				if (type !== "object") ignore.add(key);
+				continue outer;
+			}
+		}
 		return false;
 	}
 	return true;
 }
+var EXPRESSION_SUFFIX = /\.\w+$/;
 var validators = {
 	array: Array.isArray,
 	bigint: (value) => typeof value === "bigint",
@@ -29,7 +42,7 @@ var validators = {
 	"date-like": isDateLike,
 	function: (value) => typeof value === "function",
 	null: (value) => value === null,
-	number: (value) => typeof value === "number",
+	number: (value) => typeof value === "number" && !Number.isNaN(value),
 	numerical: (value) => validators.bigint(value) || validators.number(value),
 	object: (value) => typeof value === "object" && value !== null,
 	string: (value) => typeof value === "string",

package/package.json

@@ -4,15 +4,15 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.118"
+		"@oscarpalmer/atoms": "^0.123"
 	},
 	"description": "Flies free beneath the glistening moons…",
 	"devDependencies": {
 		"@types/node": "^25",
 		"@vitest/coverage-istanbul": "^4",
-		"jsdom": "^27.3",
-		"oxfmt": "^0.20",
-		"oxlint": "^1.35",
+		"jsdom": "^27.4",
+		"oxfmt": "^0.21",
+		"oxlint": "^1.36",
 		"rolldown": "1.0.0-beta.57",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
@@ -27,9 +27,8 @@
 		}
 	},
 	"files": ["dist", "src", "types"],
-	"keywords": [],
+	"keywords": ["schema", "validation"],
 	"license": "MIT",
-	"main": "./dist/index.cjs",
 	"module": "./dist/index.js",
 	"name": "@oscarpalmer/jhunal",
 	"repository": {
@@ -45,6 +44,6 @@
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
-	"types": "./types/index.d.cts",
-	"version": "0.5.0"
+	"types": "./types/index.d.ts",
+	"version": "0.7.0"
 }

package/src/constants.ts

@@ -0,0 +1,27 @@
+import type {Values} from './models';
+
+export const PROPERTY_REQUIRED = '$required';
+
+export const PROPERTY_TYPE = '$type';
+
+export const SCHEMATIC_NAME = '$schematic';
+
+export const TYPE_OBJECT = 'object';
+
+export const TYPE_UNDEFINED = 'undefined';
+
+export const TYPE_ALL = new Set<keyof Values>([
+	'array',
+	'bigint',
+	'boolean',
+	'date',
+	'date-like',
+	'function',
+	'null',
+	'number',
+	'numerical',
+	'string',
+	'symbol',
+	TYPE_OBJECT,
+	TYPE_UNDEFINED,
+]);

package/src/index.ts

@@ -1,2 +1,2 @@
-export type {Schema, TypedSchema} from './model';
+export type {Schema, TypedSchema} from './models';
 export {schematic, type Schematic} from './schematic';

package/src/is.ts

@@ -1,3 +1,4 @@
+import {SCHEMATIC_NAME} from './constants';
 import type {Schematic} from './schematic';
 
 export function isDateLike(value: unknown): value is Date {
@@ -16,7 +17,7 @@ export function isSchematic(value: unknown): value is Schematic<never> {
 	return (
 		typeof value === 'object' &&
 		value !== null &&
-		'$schematic' in value &&
-		value.$schematic === true
+		SCHEMATIC_NAME in value &&
+		value[SCHEMATIC_NAME] === true
 	);
 }