@oscarpalmer/jhunal 0.3.0 → 0.5.0

package/README.md

@@ -1,5 +1,7 @@
 # Jhunal
 
+[![npm](https://badge.fury.io/js/@oscarpalmer%2Fjhunal.svg)](https://www.npmjs.com/package/@oscarpalmer/jhunal) [![Tests](https://github.com/oscarpalmer/jhunal/actions/workflows/test.yml/badge.svg)](https://github.com/oscarpalmer/jhunal/actions/workflows/test.yml)
+
 > Jhunal, sage God of Runes,  
 > Flies free beneath the glistening moons.  
 > A night owl who's so droll,  

package/dist/helpers.js

@@ -1,20 +1,39 @@
+import { isSchematic } from "./is.js";
+import { validateSchema } from "./validation/schema.validation.js";
 function getTypes(value) {
-  return (Array.isArray(value) ? value : [value]).filter(
-    (item) => types.has(item)
-  );
+	const returned = [];
+	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;
+		}
+	}
+	return returned;
 }
-const types = /* @__PURE__ */ new Set([
-  "array",
-  "bigint",
-  "boolean",
-  "date",
-  "function",
-  "null",
-  "number",
-  "object",
-  "string",
-  "symbol",
-  "undefined"
+var types = new Set([
+	"array",
+	"bigint",
+	"boolean",
+	"date",
+	"date-like",
+	"function",
+	"null",
+	"number",
+	"numerical",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
 ]);
-
 export { getTypes };

package/dist/index.js

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

package/dist/is.js

@@ -0,0 +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));
+}
+function isSchematic(value) {
+	return typeof value === "object" && value !== null && "$schematic" in value && value.$schematic === true;
+}
+export { isDateLike, isSchematic };

package/dist/jhunal.full.js

@@ -0,0 +1,134 @@
+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 getTypes(value) {
+	const returned = [];
+	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;
+		}
+	}
+	return returned;
+}
+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);
+	const { length } = keys;
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const value = schema[key];
+		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;
+		}
+	}
+	validatedSchemas.set(schema, validated);
+	return validated;
+}
+const validatedSchemas = /* @__PURE__ */ new WeakMap();
+function validateType(type, value) {
+	if (typeof type === "string") return validators[type](value);
+	if (isSchematic(type)) return type.is(value);
+	return validateValue(type, 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;
+}
+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",
+	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.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,11 +1,21 @@
-import { getValidatedSchema, validate } from './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.length > 0;
+	}
+	is(value) {
+		return this.#validatable && validateValue(this.#schema, value);
+	}
+};
 function schematic(schema) {
-  const validated = getValidatedSchema(schema);
-  const canValidate = validated.length > 0;
-  return Object.freeze({
-    is: (value) => canValidate && validate(validated, value)
-  });
+	return new Schematic(schema);
 }
-
-export { schematic };
+export { Schematic, schematic };

package/dist/validation/schema.validation.js

@@ -0,0 +1,36 @@
+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);
+	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 validatedSchemas = /* @__PURE__ */ new WeakMap();
+export { validateSchema, validatedSchemas };

package/dist/validation/value.validation.js

@@ -0,0 +1,39 @@
+import { isDateLike, isSchematic } from "../is.js";
+function validateType(type, value) {
+	if (typeof type === "string") return validators[type](value);
+	if (isSchematic(type)) return type.is(value);
+	return validateValue(type, 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;
+}
+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",
+	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,31 +4,26 @@
 		"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.3",
+		"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"],
@@ -42,13 +37,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.3.0"
+	"version": "0.5.0"
 }

package/src/helpers.ts

@@ -1,9 +1,35 @@
-import type {Values} from './model';
+import {isSchematic} from './is';
+import type {ValidatedPropertyType, Values} from './model';
+import {validateSchema} from './validation/schema.validation';
 
-export function getTypes(value: unknown): (keyof Values)[] {
-	return (Array.isArray(value) ? value : [value]).filter(item =>
-		types.has(item),
-	);
+export function getTypes(value: unknown): ValidatedPropertyType[] {
+	const returned: ValidatedPropertyType[] = [];
+	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 as never):
+				returned.push(type as never);
+				break;
+
+			case typeof type === 'object' && type !== null: {
+				returned.push(validateSchema(type));
+				break;
+			}
+
+			default:
+				break;
+		}
+	}
+
+	return returned;
 }
 
 const types = new Set<keyof Values>([
@@ -11,9 +37,11 @@ const types = new Set<keyof Values>([
 	'bigint',
 	'boolean',
 	'date',
+	'date-like',
 	'function',
 	'null',
 	'number',
+	'numerical',
 	'object',
 	'string',
 	'symbol',

package/src/index.ts

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

package/src/is.ts

@@ -0,0 +1,22 @@
+import type {Schematic} from './schematic';
+
+export function isDateLike(value: unknown): value is Date {
+	if (value instanceof Date) {
+		return true;
+	}
+
+	if (typeof value === 'number') {
+		return value >= -8_640e12 && value <= 8_640e12;
+	}
+
+	return typeof value === 'string' && !Number.isNaN(Date.parse(value));
+}
+
+export function isSchematic(value: unknown): value is Schematic<never> {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		'$schematic' in value &&
+		value.$schematic === true
+	);
+}