@oscarpalmer/jhunal 0.6.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,11 +1,31 @@
+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 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);
+		if (item != null) compacted.push(item);
 	}
 	return compacted;
 }
@@ -51,11 +71,17 @@ function flattenObject(value, depth, smushed, prefix) {
 	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;
+		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;
@@ -70,11 +96,13 @@ function isDateLike(value) {
 	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)) to.properties[key].types.push(...values);
-	else {
+	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] = {
@@ -82,7 +110,7 @@ function addPropertyType(to, key, values, required) {
 			types: values
 		};
 	}
-	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push("undefined");
+	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) to.properties[key].types.push(TYPE_UNDEFINED);
 }
 function getTypes(value, validated, prefix) {
 	const propertyTypes = [];
@@ -90,17 +118,17 @@ function getTypes(value, validated, prefix) {
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		if (isSchematic(type) || typeof type === "string" && types.has(type)) {
+		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.$type, validated, prefix));
+		if (PROPERTY_TYPE in type) {
+			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
 		}
-		addPropertyType(validated, prefix, ["object"], typeof type.$required === "boolean" ? type.$required : true);
-		propertyTypes.push("object");
+		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		propertyTypes.push(TYPE_OBJECT);
 		getValidatedSchema(type, validated, prefix);
 	}
 	return propertyTypes;
@@ -119,10 +147,10 @@ function getValidatedSchema(schema, validated, prefix) {
 		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;
+		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$1 = getTypes(value, validated, prefixedKey);
-		if (types$1.length > 0) addPropertyType(validated, prefixedKey, types$1, required);
+		const types = getTypes(value, validated, prefixedKey);
+		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
 	}
 	if (noPrefix) validated.keys.array.sort();
 	return validated;
@@ -137,21 +165,6 @@ function validateSchema(schema) {
 	};
 	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);
 }
@@ -159,22 +172,32 @@ function validateValue(validated, obj) {
 	if (typeof obj !== "object" || obj === null) 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("undefined")) return false;
+		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",
@@ -197,7 +220,7 @@ 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.keys.array.length > 0;
 	}

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,7 +8,7 @@ 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.keys.array.length > 0;
 	}

package/dist/validation/schema.validation.js

@@ -1,8 +1,11 @@
+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)) to.properties[key].types.push(...values);
-	else {
+	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] = {
@@ -10,7 +13,7 @@ function addPropertyType(to, key, values, required) {
 			types: values
 		};
 	}
-	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push("undefined");
+	if (!required && !to.properties[key].types.includes("undefined")) to.properties[key].types.push(TYPE_UNDEFINED);
 }
 function getTypes(value, validated, prefix) {
 	const propertyTypes = [];
@@ -18,17 +21,17 @@ function getTypes(value, validated, prefix) {
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
-		if (isSchematic(type) || typeof type === "string" && types.has(type)) {
+		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.$type, validated, prefix));
+			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 			continue;
 		}
-		addPropertyType(validated, prefix, ["object"], typeof type.$required === "boolean" ? type.$required : true);
-		propertyTypes.push("object");
+		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
+		propertyTypes.push(TYPE_OBJECT);
 		getValidatedSchema(type, validated, prefix);
 	}
 	return propertyTypes;
@@ -47,10 +50,10 @@ function getValidatedSchema(schema, validated, prefix) {
 		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;
+		if (typeof value === "object" && value !== null && "$required" in value) required = typeof value["$required"] === "boolean" ? value[PROPERTY_REQUIRED] : true;
 		const prefixedKey = `${prefix}${key}`;
-		const types$1 = getTypes(value, validated, prefixedKey);
-		if (types$1.length > 0) addPropertyType(validated, prefixedKey, types$1, required);
+		const types = getTypes(value, validated, prefixedKey);
+		if (types.length > 0) addPropertyType(validated, prefixedKey, types, required);
 	}
 	if (noPrefix) validated.keys.array.sort();
 	return validated;
@@ -65,19 +68,4 @@ function validateSchema(schema) {
 	};
 	return typeof schema === "object" && schema !== null ? getValidatedSchema(schema, validated) : validated;
 }
-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,3 +1,4 @@
+import { TYPE_OBJECT, TYPE_UNDEFINED } from "../constants.js";
 import { isDateLike } from "../is.js";
 import { smush } from "@oscarpalmer/atoms/value";
 function validateType(type, value) {
@@ -7,9 +8,12 @@ function validateValue(validated, obj) {
 	if (typeof obj !== "object" || obj === null) 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("undefined")) return false;
@@ -18,11 +22,18 @@ function validateValue(validated, obj) {
 			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",

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.4",
-		"oxfmt": "^0.20",
-		"oxlint": "^1.35",
+		"oxfmt": "^0.21",
+		"oxlint": "^1.36",
 		"rolldown": "1.0.0-beta.57",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
@@ -45,5 +45,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.6.0"
+	"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,4 +1,4 @@
-
+import {SCHEMATIC_NAME} from './constants';
 import type {Schematic} from './schematic';
 
 export function isDateLike(value: unknown): value is Date {
@@ -17,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
 	);
 }

package/src/schematic.ts

@@ -1,5 +1,6 @@
-import type {PlainObject} from '@oscarpalmer/atoms';
-import type {Infer, Schema, TypedSchema, ValidatedSchema} from './model';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {SCHEMATIC_NAME} from './constants';
+import type {Infer, Schema, TypedSchema, ValidatedSchema} from './models';
 import {validateSchema} from './validation/schema.validation';
 import {validateValue} from './validation/value.validation';
 
@@ -17,11 +18,11 @@ export class Schematic<Model> {
 	}
 
 	constructor(schema: Model) {
-		Object.defineProperty(this, '$schematic', {
+		Object.defineProperty(this, SCHEMATIC_NAME, {
 			value: true,
 		});
 
-		this.#schema = validateSchema(schema as unknown as Schema);
+		this.#schema = validateSchema(schema);
 
 		this.#validatable = this.#schema.keys.array.length > 0;
 	}

package/src/validation/schema.validation.ts

@@ -1,7 +1,14 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {smush} from '@oscarpalmer/atoms/value';
+import {
+	PROPERTY_REQUIRED,
+	PROPERTY_TYPE,
+	TYPE_ALL,
+	TYPE_OBJECT,
+	TYPE_UNDEFINED,
+} from '../constants';
 import {isSchematic} from '../is';
-import type {Schema, ValidatedPropertyType, ValidatedSchema, Values} from '../model';
+import type {Schema, ValidatedPropertyType, ValidatedSchema} from '../models';
 
 function addPropertyType(
 	to: ValidatedSchema,
@@ -12,7 +19,11 @@ function addPropertyType(
 	if (to.keys.set.has(key)) {
 		const property = to.properties[key];
 
-		property.types.push(...values);
+		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);
@@ -23,8 +34,8 @@ function addPropertyType(
 		};
 	}
 
-	if (!required && !to.properties[key].types.includes('undefined')) {
-		to.properties[key].types.push('undefined');
+	if (!required && !to.properties[key].types.includes(TYPE_UNDEFINED)) {
+		to.properties[key].types.push(TYPE_UNDEFINED);
 	}
 }
 
@@ -41,7 +52,7 @@ function getTypes(
 	for (let index = 0; index < length; index += 1) {
 		const type = values[index];
 
-		if (isSchematic(type) || (typeof type === 'string' && types.has(type as never))) {
+		if (isSchematic(type) || (typeof type === 'string' && TYPE_ALL.has(type as never))) {
 			propertyTypes.push(type as never);
 
 			continue;
@@ -51,20 +62,15 @@ function getTypes(
 			continue;
 		}
 
-		if ('$type' in type) {
-			propertyTypes.push(...getTypes(type.$type, validated, prefix));
+		if (PROPERTY_TYPE in type) {
+			propertyTypes.push(...getTypes(type[PROPERTY_TYPE], validated, prefix));
 
 			continue;
 		}
 
-		addPropertyType(
-			validated,
-			prefix,
-			['object'],
-			typeof type.$required === 'boolean' ? type.$required : true,
-		);
+		addPropertyType(validated, prefix, [TYPE_OBJECT], type[PROPERTY_REQUIRED] !== false);
 
-		propertyTypes.push('object');
+		propertyTypes.push(TYPE_OBJECT);
 
 		getValidatedSchema(type as Schema, validated, prefix);
 	}
@@ -104,8 +110,8 @@ function getValidatedSchema(
 
 		let required = true;
 
-		if (typeof value === 'object' && value !== null && '$required' in value) {
-			required = typeof value.$required === 'boolean' ? value.$required : true;
+		if (typeof value === 'object' && value !== null && PROPERTY_REQUIRED in value) {
+			required = typeof value[PROPERTY_REQUIRED] === 'boolean' ? value[PROPERTY_REQUIRED] : true;
 		}
 
 		const prefixedKey = `${prefix}${key}`;
@@ -137,21 +143,3 @@ export function validateSchema(schema: unknown): ValidatedSchema {
 		? getValidatedSchema(schema as Schema, validated)
 		: validated;
 }
-
-//
-
-const types = new Set<keyof Values>([
-	'array',
-	'bigint',
-	'boolean',
-	'date',
-	'date-like',
-	'function',
-	'null',
-	'number',
-	'numerical',
-	'object',
-	'string',
-	'symbol',
-	'undefined',
-]);

package/src/validation/value.validation.ts

@@ -1,7 +1,8 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {smush} from '@oscarpalmer/atoms/value';
+import {TYPE_OBJECT, TYPE_UNDEFINED} from '../constants';
 import {isDateLike} from '../is';
-import type {ValidatedPropertyType, ValidatedSchema, Values} from '../model';
+import type {ValidatedPropertyType, ValidatedSchema, Values} from '../models';
 
 export function validateType(type: ValidatedPropertyType, value: unknown): boolean {
 	return typeof type === 'string' ? validators[type](value) : type.is(value);
@@ -15,14 +16,23 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 	const {keys, properties} = validated;
 	const keysLength = keys.array.length;
 
+	const ignore = new Set<string>();
+
 	const smushed = smush(obj as PlainObject);
 
 	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 === undefined && property.required && !property.types.includes('undefined')) {
+		if (value === undefined && property.required && !property.types.includes(TYPE_UNDEFINED)) {
 			return false;
 		}
 
@@ -37,7 +47,13 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 		}
 
 		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			if (validateType(property.types[typeIndex], value)) {
+			const type = property.types[typeIndex];
+
+			if (validateType(type, value)) {
+				if (type !== TYPE_OBJECT) {
+					ignore.add(key);
+				}
+
 				continue outer;
 			}
 		}
@@ -50,6 +66,10 @@ export function validateValue(validated: ValidatedSchema, obj: unknown): boolean
 
 //
 
+const EXPRESSION_SUFFIX = /\.\w+$/;
+
+//
+
 const validators: Record<keyof Values, (value: unknown) => boolean> = {
 	array: Array.isArray,
 	bigint: value => typeof value === 'bigint',

package/types/constants.d.ts

@@ -0,0 +1,7 @@
+import type { Values } from './models';
+export declare const PROPERTY_REQUIRED = "$required";
+export declare const PROPERTY_TYPE = "$type";
+export declare const SCHEMATIC_NAME = "$schematic";
+export declare const TYPE_OBJECT = "object";
+export declare const TYPE_UNDEFINED = "undefined";
+export declare const TYPE_ALL: Set<keyof Values>;

package/types/index.d.ts

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

package/types/schematic.d.ts

@@ -1,5 +1,5 @@
-import type { PlainObject } from '@oscarpalmer/atoms';
-import type { Infer, Schema, TypedSchema } from './model';
+import type { PlainObject } from '@oscarpalmer/atoms/models';
+import type { Infer, Schema, TypedSchema } from './models';
 /**
  * A schematic for validating objects
  */

package/types/validation/schema.validation.d.ts

@@ -1,2 +1,2 @@
-import type { ValidatedSchema } from '../model';
+import type { ValidatedSchema } from '../models';
 export declare function validateSchema(schema: unknown): ValidatedSchema;

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

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