@oscarpalmer/jhunal 0.4.0 → 0.6.0

package/dist/index.js

@@ -1 +1,2 @@
-export { schematic } from './schematic.js';
+import { schematic } from "./schematic.js";
+export { schematic };

package/dist/is.js

@@ -1,14 +1,9 @@
 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));
+	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

@@ -0,0 +1,211 @@
+function compact(array, strict) {
+	if (!Array.isArray(array)) return [];
+	const { length } = array;
+	const isStrict = strict ?? false;
+	const compacted = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		if (isStrict && !!item || !isStrict && 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)) Object.assign(flattened, {
+			[join([prefix, key], ".")]: Array.isArray(val) ? [...val] : { ...val },
+			...flattenObject(val, depth + 1, smushed, join([prefix, key], "."))
+		});
+		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;
+}
+function addPropertyType(to, key, values, required) {
+	if (to.keys.set.has(key)) to.properties[key].types.push(...values);
+	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("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" && types.has(type)) {
+			propertyTypes.push(type);
+			continue;
+		}
+		if (typeof type !== "object" || type === null) continue;
+		if ("$type" in type) {
+			propertyTypes.push(...getTypes(type.$type, validated, prefix));
+			continue;
+		}
+		addPropertyType(validated, prefix, ["object"], typeof type.$required === "boolean" ? type.$required : true);
+		propertyTypes.push("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 = 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;
+		if (typeof value === "object" && value !== null && "$required" in value) required = typeof value.$required === "boolean" ? value.$required : true;
+		const prefixedKey = `${prefix}${key}`;
+		const types$1 = getTypes(value, validated, prefixedKey);
+		if (types$1.length > 0) addPropertyType(validated, prefixedKey, types$1, required);
+	}
+	if (noPrefix) validated.keys.array.sort();
+	return validated;
+}
+function validateSchema(schema) {
+	const validated = {
+		keys: {
+			array: [],
+			set: /* @__PURE__ */ new Set()
+		},
+		properties: {}
+	};
+	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
+}
+const types = new Set([
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"date-like",
+	"function",
+	"null",
+	"number",
+	"numerical",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
+]);
+function validateType(type, value) {
+	return typeof type === "string" ? validators[type](value) : type.is(value);
+}
+function validateValue(validated, obj) {
+	if (typeof obj !== "object" || obj === null) return false;
+	const { keys, properties } = validated;
+	const keysLength = keys.array.length;
+	const smushed = smush(obj);
+	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys.array[keyIndex];
+		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;
+		return false;
+	}
+	return true;
+}
+const validators = {
+	array: Array.isArray,
+	bigint: (value) => typeof value === "bigint",
+	boolean: (value) => typeof value === "boolean",
+	date: (value) => value instanceof Date,
+	"date-like": isDateLike,
+	function: (value) => typeof value === "function",
+	null: (value) => value === null,
+	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",
+	symbol: (value) => typeof value === "symbol",
+	undefined: (value) => value === void 0
+};
+var Schematic = class {
+	#schema;
+	#validatable;
+	get validatable() {
+		return this.#validatable;
+	}
+	constructor(schema) {
+		Object.defineProperty(this, "$schematic", { value: true });
+		this.#schema = validateSchema(schema);
+		this.#validatable = this.#schema.keys.array.length > 0;
+	}
+	is(value) {
+		return this.#validatable && validateValue(this.#schema, value);
+	}
+};
+function schematic(schema) {
+	return new Schematic(schema);
+}
+export { schematic };

package/dist/model.js

@@ -1 +0,0 @@
-

package/dist/schematic.js

@@ -1,13 +1,21 @@
-import { validateSchema } from './validation/schema.validation.js';
-import { validateValue } from './validation/value.validation.js';
-
+import { validateSchema } from "./validation/schema.validation.js";
+import { validateValue } from "./validation/value.validation.js";
+var Schematic = class {
+	#schema;
+	#validatable;
+	get validatable() {
+		return this.#validatable;
+	}
+	constructor(schema) {
+		Object.defineProperty(this, "$schematic", { value: true });
+		this.#schema = validateSchema(schema);
+		this.#validatable = this.#schema.keys.array.length > 0;
+	}
+	is(value) {
+		return this.#validatable && validateValue(this.#schema, value);
+	}
+};
 function schematic(schema) {
-  const validated = validateSchema(schema);
-  const canValidate = validated.length > 0;
-  return Object.freeze({
-    $schematic: true,
-    is: (value) => canValidate && validateValue(validated, value)
-  });
+	return new Schematic(schema);
 }
-
-export { schematic };
+export { Schematic, schematic };

package/dist/validation/schema.validation.js

@@ -1,49 +1,83 @@
-import { getTypes } from '../helpers.js';
-
+import { isSchematic } from "../is.js";
+import { smush } from "@oscarpalmer/atoms/value";
+function addPropertyType(to, key, values, required) {
+	if (to.keys.set.has(key)) to.properties[key].types.push(...values);
+	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("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" && types.has(type)) {
+			propertyTypes.push(type);
+			continue;
+		}
+		if (typeof type !== "object" || type === null) continue;
+		if ("$type" in type) {
+			propertyTypes.push(...getTypes(type.$type, validated, prefix));
+			continue;
+		}
+		addPropertyType(validated, prefix, ["object"], typeof type.$required === "boolean" ? type.$required : true);
+		propertyTypes.push("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 = 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;
+		if (typeof value === "object" && value !== null && "$required" in value) required = typeof value.$required === "boolean" ? value.$required : true;
+		const prefixedKey = `${prefix}${key}`;
+		const types$1 = getTypes(value, validated, prefixedKey);
+		if (types$1.length > 0) addPropertyType(validated, prefixedKey, types$1, required);
+	}
+	if (noPrefix) validated.keys.array.sort();
+	return validated;
+}
 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);
-  const { length } = keys;
-  for (let index = 0; index < length; index += 1) {
-    const key = keys[index];
-    const value = schema[key];
-    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;
-    }
-  }
-  validatedSchemas.set(schema, validated);
-  return validated;
+	const validated = {
+		keys: {
+			array: [],
+			set: /* @__PURE__ */ new Set()
+		},
+		properties: {}
+	};
+	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
 }
-const validatedSchemas = /* @__PURE__ */ new WeakMap();
-
-export { validateSchema, validatedSchemas };
+var types = new Set([
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"date-like",
+	"function",
+	"null",
+	"number",
+	"numerical",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
+]);
+export { validateSchema };

package/dist/validation/value.validation.js

@@ -1,31 +1,41 @@
-import { validateType } from './type.validation.js';
-
+import { isDateLike } from "../is.js";
+import { smush } from "@oscarpalmer/atoms/value";
+function validateType(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 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;
-      }
-    }
-    return false;
-  }
-  return true;
+	if (typeof obj !== "object" || obj === null) return false;
+	const { keys, properties } = validated;
+	const keysLength = keys.array.length;
+	const smushed = smush(obj);
+	outer: for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
+		const key = keys.array[keyIndex];
+		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;
+		return false;
+	}
+	return true;
 }
-
-export { validateValue };
+var validators = {
+	array: Array.isArray,
+	bigint: (value) => typeof value === "bigint",
+	boolean: (value) => typeof value === "boolean",
+	date: (value) => value instanceof Date,
+	"date-like": isDateLike,
+	function: (value) => typeof value === "function",
+	null: (value) => value === null,
+	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",
+	symbol: (value) => typeof value === "symbol",
+	undefined: (value) => value === void 0
+};
+export { validateType, validateValue };

package/package.json

@@ -4,37 +4,31 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.94",
-		"type-fest": "^4.39"
+		"@oscarpalmer/atoms": "^0.118"
 	},
 	"description": "Flies free beneath the glistening moons…",
 	"devDependencies": {
-		"@biomejs/biome": "^1.9",
-		"@types/node": "^22.14",
-		"@vitest/coverage-istanbul": "^3.1",
-		"dts-bundle-generator": "^9.5",
-		"glob": "^11",
-		"typescript": "^5.8",
-		"vite": "^6.2",
-		"vitest": "^3.1"
+		"@types/node": "^25",
+		"@vitest/coverage-istanbul": "^4",
+		"jsdom": "^27.4",
+		"oxfmt": "^0.20",
+		"oxlint": "^1.35",
+		"rolldown": "1.0.0-beta.57",
+		"tslib": "^2.8",
+		"typescript": "^5.9",
+		"vite": "8.0.0-beta.5",
+		"vitest": "^4"
 	},
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
-			"import": {
 				"types": "./types/index.d.ts",
 				"default": "./dist/index.js"
-			},
-			"require": {
-				"types": "./types/index.d.cts",
-				"default": "./dist/index.cjs"
-			}
 		}
 	},
 	"files": ["dist", "src", "types"],
-	"keywords": [],
+	"keywords": ["schema", "validation"],
 	"license": "MIT",
-	"main": "./dist/index.cjs",
 	"module": "./dist/index.js",
 	"name": "@oscarpalmer/jhunal",
 	"repository": {
@@ -42,13 +36,14 @@
 		"url": "git+https://github.com/oscarpalmer/jhunal.git"
 	},
 	"scripts": {
-		"build": "npm run clean && npx vite build && npm run types",
+		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
+		"rolldown:build": "npx rolldown -c",
+		"rolldown:watch": "npx rolldown -c ./rolldown.config.js --watch",
 		"test": "npx vitest --coverage",
-		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.cts --silent",
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
-	"types": "./types/index.d.cts",
-	"version": "0.4.0"
+	"types": "./types/index.d.ts",
+	"version": "0.6.0"
 }

package/src/index.ts

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

package/src/is.ts

@@ -1,4 +1,5 @@
-import type {Schematic} from './model';
+
+import type {Schematic} from './schematic';
 
 export function isDateLike(value: unknown): value is Date {
 	if (value instanceof Date) {