@oscarpalmer/jhunal 0.15.0 → 0.17.0

package/dist/schematic.d.mts

@@ -0,0 +1,36 @@
+import { Infer, Schema, TypedSchema, ValidatedProperty } from "./models.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/schematic.d.ts
+/**
+ * A schematic for validating objects
+ */
+declare class Schematic<Model> {
+  #private;
+  private readonly $schematic;
+  constructor(properties: ValidatedProperty[]);
+  /**
+   * Does the value match the schema?
+   * @param value Value to validate
+   * @returns `true` if the value matches the schema, otherwise `false`
+   */
+  is(value: unknown): value is Model;
+}
+/**
+ * Create a schematic from a schema
+ * @template Model Schema type
+ * @param schema Schema to create the schematic from
+ * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
+ * @returns A schematic for the given schema
+ */
+declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer<Model>>;
+/**
+ * Create a schematic from a typed schema
+ * @template Model Existing type
+ * @param schema Typed schema to create the schematic from
+ * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
+ * @returns A schematic for the given typed schema
+ */
+declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;
+//#endregion
+export { Schematic, schematic };

package/dist/{schematic.js → schematic.mjs}

@@ -1,9 +1,10 @@
-import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.js";
-import { isSchematic } from "./helpers.js";
-import { SchematicError } from "./models.js";
-import { getProperties } from "./validation/property.validation.js";
-import { validateObject } from "./validation/value.validation.js";
+import { MESSAGE_SCHEMA_INVALID_TYPE, SCHEMATIC_NAME } from "./constants.mjs";
+import { isSchematic } from "./helpers.mjs";
+import { SchematicError } from "./models.mjs";
+import { getProperties } from "./validation/property.validation.mjs";
+import { validateObject } from "./validation/value.validation.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/schematic.ts
 /**
 * A schematic for validating objects
 */
@@ -15,7 +16,7 @@ var Schematic = class {
 	}
 	/**
 	* Does the value match the schema?
-	* @param value - Value to validate
+	* @param value Value to validate
 	* @returns `true` if the value matches the schema, otherwise `false`
 	*/
 	is(value) {
@@ -27,4 +28,5 @@ function schematic(schema) {
 	if (!isPlainObject(schema)) throw new SchematicError(MESSAGE_SCHEMA_INVALID_TYPE);
 	return new Schematic(getProperties(schema));
 }
+//#endregion
 export { Schematic, schematic };

package/dist/validation/property.validation.d.mts

@@ -0,0 +1,7 @@
+import { ValidatedProperty } from "../models.mjs";
+import { PlainObject } from "@oscarpalmer/atoms/models";
+
+//#region src/validation/property.validation.d.ts
+declare function getProperties(original: PlainObject, prefix?: string, fromType?: boolean): ValidatedProperty[];
+//#endregion
+export { getProperties };

package/dist/validation/{property.validation.js → property.validation.mjs}

@@ -1,8 +1,9 @@
-import { EXPRESSION_PROPERTY, MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TEMPLATE_PATTERN_KEY, TEMPLATE_PATTERN_PROPERTY, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.js";
-import { instanceOf, isSchematic } from "../helpers.js";
-import { SchematicError } from "../models.js";
+import { MESSAGE_SCHEMA_INVALID_EMPTY, MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED, MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE, MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED, MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE, MESSAGE_VALIDATOR_INVALID_KEY, MESSAGE_VALIDATOR_INVALID_TYPE, MESSAGE_VALIDATOR_INVALID_VALUE, PROPERTY_REQUIRED, PROPERTY_TYPE, PROPERTY_VALIDATORS, TEMPLATE_PATTERN_KEY, TEMPLATE_PATTERN_PROPERTY, TYPE_ALL, TYPE_OBJECT, TYPE_UNDEFINED, VALIDATABLE_TYPES } from "../constants.mjs";
+import { instanceOf, isSchematic } from "../helpers.mjs";
+import { SchematicError } from "../models.mjs";
 import { isConstructor, isPlainObject } from "@oscarpalmer/atoms/is";
-import { join } from "@oscarpalmer/atoms/string/misc";
+import { join } from "@oscarpalmer/atoms/string";
+//#region src/validation/property.validation.ts
 function getDisallowedProperty(obj) {
 	if ("$required" in obj) return PROPERTY_REQUIRED;
 	if ("$type" in obj) return PROPERTY_TYPE;
@@ -19,8 +20,8 @@ function getProperties(original, prefix, fromType) {
 	const properties = [];
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
-		if (EXPRESSION_PROPERTY.test(key)) continue;
 		const value = original[key];
+		if (value == null) throw new SchematicError(MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace("<>", join([prefix, key], ".")));
 		const types = [];
 		let required = true;
 		let validators = {};
@@ -87,4 +88,5 @@ function getValidators(original) {
 	}
 	return validators;
 }
+//#endregion
 export { getProperties };

package/dist/validation/value.validation.d.mts

@@ -0,0 +1,6 @@
+import { ValidatedProperty } from "../models.mjs";
+
+//#region src/validation/value.validation.d.ts
+declare function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean;
+//#endregion
+export { validateObject };

package/dist/validation/{value.validation.js → value.validation.mjs}

@@ -1,5 +1,6 @@
-import { isSchematic } from "../helpers.js";
+import { isSchematic } from "../helpers.mjs";
 import { isPlainObject } from "@oscarpalmer/atoms/is";
+//#region src/validation/value.validation.ts
 function validateObject(obj, properties) {
 	if (!isPlainObject(obj)) return false;
 	const propertiesLength = properties.length;
@@ -25,7 +26,7 @@ function validateValue(type, property, value) {
 		default: return validators[type](value) && (property.validators[type]?.every((validator) => validator(value)) ?? true);
 	}
 }
-var validators = {
+const validators = {
 	array: Array.isArray,
 	bigint: (value) => typeof value === "bigint",
 	boolean: (value) => typeof value === "boolean",
@@ -38,4 +39,5 @@ var validators = {
 	symbol: (value) => typeof value === "symbol",
 	undefined: (value) => value === void 0
 };
+//#endregion
 export { validateObject };

package/package.json

@@ -1,49 +1,54 @@
 {
-	"author": {
-		"name": "Oscar Palmér",
-		"url": "https://oscarpalmer.se"
-	},
-	"dependencies": {
-		"@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.35",
-		"oxlint": "^1.50",
-		"rolldown": "1.0.0-rc.5",
-		"tslib": "^2.8",
-		"typescript": "^5.9",
-		"vite": "8.0.0-beta.15",
-		"vitest": "^4"
-	},
-	"exports": {
-		"./package.json": "./package.json",
-		".": {
-			"types": "./types/index.d.ts",
-			"default": "./dist/index.js"
-		}
-	},
-	"files": ["dist", "src", "types"],
-	"keywords": ["schema", "validation"],
-	"license": "MIT",
-	"module": "./dist/index.js",
-	"name": "@oscarpalmer/jhunal",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/oscarpalmer/jhunal.git"
-	},
-	"scripts": {
-		"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",
-		"watch": "npx vite build --watch"
-	},
-	"type": "module",
-	"types": "./types/index.d.ts",
-	"version": "0.15.0"
+  "name": "@oscarpalmer/jhunal",
+  "version": "0.17.0",
+  "description": "Flies free beneath the glistening moons…",
+  "keywords": [
+    "schema",
+    "validation"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Oscar Palmér",
+    "url": "https://oscarpalmer.se"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oscarpalmer/jhunal.git"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "npx vp pack && npm run tsdown:build",
+    "tsdown:build": "npx tsdown -c ./tsdown.config.ts",
+    "tsdown:watch": "npx tsdown -c ./tsdown.config.ts --watch",
+    "test": "npx vp test run --coverage",
+    "test:leak": "npx vp test run --detect-async-leaks --coverage",
+    "watch": "npx vite build --watch"
+  },
+  "dependencies": {
+    "@oscarpalmer/atoms": "^0.168"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5",
+    "@vitest/coverage-istanbul": "^4.1",
+    "jsdom": "^29.0",
+    "tsdown": "^0.21",
+    "typescript": "^5.9",
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vite-plus": "latest",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+  },
+  "packageManager": "npm@11.11.1"
 }

package/src/constants.ts

@@ -2,8 +2,6 @@ import type {ValueName} from './models';
 
 export const ERROR_NAME = 'SchematicError';
 
-export const EXPRESSION_PROPERTY = /(^|\.)\$(required|type|validators)(\.|$)/;
-
 export const MESSAGE_CONSTRUCTOR = 'Expected a constructor function';
 
 export const MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one property';
@@ -11,8 +9,10 @@ export const MESSAGE_SCHEMA_INVALID_EMPTY = 'Schema must have at least one prope
 export const MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED =
 	"'<key>.<property>' property is not allowed for schemas in $type";
 
-export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED =
-	"'<>.$required' property must be a boolean";
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE =
+	"'<>' property must not be 'null' or 'undefined'";
+
+export const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
 
 export const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
 

package/src/models.ts

@@ -135,8 +135,8 @@ type InferSchemaEntryValue<Value> =
 			? Model
 			: Value extends SchemaProperty
 				? InferPropertyType<Value['$type']>
-				: Value extends NestedSchema
-					? Infer<Omit<Value, '$required'>>
+				: Value extends PlainSchema
+					? Infer<Value & Schema>
 					: Value extends ValueName
 						? Values[Value & ValueName]
 						: Value extends Schema
@@ -154,11 +154,7 @@ type IsOptionalProperty<Value> = Value extends SchemaProperty
 	? Value['$required'] extends false
 		? true
 		: false
-	: Value extends {$required?: boolean}
-		? Value extends {$required: false}
-			? true
-			: false
-		: false;
+	: false;
 
 /**
  * Extracts the last member from a union type by leveraging intersection of function return types
@@ -188,25 +184,6 @@ type MapToSchemaPropertyTypes<Value extends unknown[]> = Value extends [infer He
 	? [ToSchemaPropertyTypeEach<Head>, ...MapToSchemaPropertyTypes<Tail>]
 	: [];
 
-/**
- * A nested schema definition that may include a `$required` flag alongside arbitrary string-keyed properties
- *
- * @example
- * ```ts
- * const address: NestedSchema = {
- *   $required: false,
- *   street: 'string',
- *   city: 'string',
- * };
- * ```
- */
-export type NestedSchema = {
-	/**
-	 * Whether the nested schema is required (defaults to `true`)
-	 */
-	$required?: boolean;
-} & Schema;
-
 /**
  * Extracts keys from an object type that are optional
  *
@@ -220,7 +197,11 @@ type OptionalKeys<Value> = {
  * A generic schema allowing {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry} as values
  */
 type PlainSchema = {
-	[key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
+	[key: string]: PlainSchema | SchemaEntry | SchemaEntry[] | undefined;
+} & {
+	$required?: never;
+	$type?: never;
+	$validators?: never;
 };
 
 /**
@@ -271,7 +252,7 @@ export type Schema = SchemaIndex;
  */
 type SchemaEntry =
 	| Constructor
-	| Schema
+	| PlainSchema
 	| SchemaProperty
 	| Schematic<unknown>
 	| ValueName
@@ -281,7 +262,7 @@ type SchemaEntry =
  * Index signature interface backing {@link Schema}, allowing string-keyed entries of {@link NestedSchema}, {@link SchemaEntry}, or arrays of {@link SchemaEntry}
  */
 interface SchemaIndex {
-	[key: string]: NestedSchema | SchemaEntry | SchemaEntry[];
+	[key: string]: PlainSchema | SchemaEntry | SchemaEntry[];
 }
 
 /**
@@ -327,12 +308,7 @@ type SchemaPropertyType =
 	| ((value: unknown) => boolean);
 
 /**
- * A custom error class for schema validation failures, with its `name` set to {@link ERROR_NAME}
- *
- * @example
- * ```ts
- * throw new SchematicError('Expected a string, received a number');
- * ```
+ * A custom error class for schematic validation failures
  */
 export class SchematicError extends Error {
 	constructor(message: string) {
@@ -360,11 +336,9 @@ type ToSchemaPropertyType<Value> = UnwrapSingle<
  *
  * @template Value - type to convert
  */
-type ToSchemaPropertyTypeEach<Value> = Value extends NestedSchema
-	? Omit<Value, '$required'>
-	: Value extends PlainObject
-		? TypedSchema<Value>
-		: ToValueType<Value>;
+type ToSchemaPropertyTypeEach<Value> = Value extends PlainObject
+	? TypedSchema<Value>
+	: ToValueType<Value>;
 
 /**
  * Converts a type into its corresponding {@link ValueName}-representation

package/src/schematic.ts

@@ -30,7 +30,7 @@ export class Schematic<Model> {
 
 	/**
 	 * Does the value match the schema?
-	 * @param value - Value to validate
+	 * @param value Value to validate
 	 * @returns `true` if the value matches the schema, otherwise `false`
 	 */
 	is(value: unknown): value is Model {
@@ -40,8 +40,8 @@ export class Schematic<Model> {
 
 /**
  * Create a schematic from a schema
- * @template Model - Schema type
- * @param schema - Schema to create the schematic from
+ * @template Model Schema type
+ * @param schema Schema to create the schematic from
  * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
  * @returns A schematic for the given schema
  */
@@ -49,8 +49,8 @@ export function schematic<Model extends Schema>(schema: Model): Schematic<Infer<
 
 /**
  * Create a schematic from a typed schema
- * @template Model - Existing type
- * @param schema - Typed schema to create the schematic from
+ * @template Model Existing type
+ * @param schema Typed schema to create the schematic from
  * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
  * @returns A schematic for the given typed schema
  */

package/src/validation/property.validation.ts

@@ -1,10 +1,10 @@
 import {isConstructor, isPlainObject} from '@oscarpalmer/atoms/is';
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {join} from '@oscarpalmer/atoms/string/misc';
+import {join} from '@oscarpalmer/atoms/string';
 import {
-	EXPRESSION_PROPERTY,
 	MESSAGE_SCHEMA_INVALID_EMPTY,
 	MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED,
+	MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE,
 	MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED,
 	MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE,
 	MESSAGE_VALIDATOR_INVALID_KEY,
@@ -74,12 +74,17 @@ export function getProperties(
 	for (let keyIndex = 0; keyIndex < keysLength; keyIndex += 1) {
 		const key = keys[keyIndex];
 
-		if (EXPRESSION_PROPERTY.test(key)) {
-			continue;
-		}
-
 		const value = original[key];
 
+		if (value == null) {
+			throw new SchematicError(
+				MESSAGE_SCHEMA_INVALID_PROPERTY_NULLABLE.replace(
+					TEMPLATE_PATTERN,
+					join([prefix, key], '.'),
+				),
+			);
+		}
+
 		const types: ValidatedPropertyType[] = [];
 
 		let required = true;

package/dist/index.js

@@ -1,4 +0,0 @@
-import { instanceOf, isSchematic } from "./helpers.js";
-import { SchematicError } from "./models.js";
-import { schematic } from "./schematic.js";
-export { SchematicError, instanceOf, isSchematic, schematic };

package/dist/models.js

@@ -1,16 +0,0 @@
-import { ERROR_NAME } from "./constants.js";
-/**
-* A custom error class for schema validation failures, with its `name` set to {@link ERROR_NAME}
-*
-* @example
-* ```ts
-* throw new SchematicError('Expected a string, received a number');
-* ```
-*/
-var SchematicError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = ERROR_NAME;
-	}
-};
-export { SchematicError };

package/types/constants.d.ts

@@ -1,22 +0,0 @@
-export declare const ERROR_NAME = "SchematicError";
-export declare const EXPRESSION_PROPERTY: RegExp;
-export declare const MESSAGE_CONSTRUCTOR = "Expected a constructor function";
-export declare const MESSAGE_SCHEMA_INVALID_EMPTY = "Schema must have at least one property";
-export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_DISALLOWED = "'<key>.<property>' property is not allowed for schemas in $type";
-export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_REQUIRED = "'<>.$required' property must be a boolean";
-export declare const MESSAGE_SCHEMA_INVALID_PROPERTY_TYPE = "'<>' property must be of a valid type";
-export declare const MESSAGE_SCHEMA_INVALID_TYPE = "Schema must be an object";
-export declare const MESSAGE_VALIDATOR_INVALID_KEY = "Validator '<>' does not exist";
-export declare const MESSAGE_VALIDATOR_INVALID_TYPE = "Validators must be an object";
-export declare const MESSAGE_VALIDATOR_INVALID_VALUE = "Validator '<>' must be a function or an array of functions";
-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 TEMPLATE_PATTERN = "<>";
-export declare const TEMPLATE_PATTERN_KEY = "<key>";
-export declare const TEMPLATE_PATTERN_PROPERTY = "<property>";
-export declare const TYPE_OBJECT = "object";
-export declare const TYPE_UNDEFINED = "undefined";
-export declare const VALIDATABLE_TYPES: Set<keyof import("./models").Values>;
-export declare const TYPE_ALL: Set<keyof import("./models").Values>;

package/types/index.d.ts

@@ -1,3 +0,0 @@
-export { instanceOf, isSchematic } from './helpers';
-export { SchematicError, type Schema, type TypedSchema } from './models';
-export { schematic, type Schematic } from './schematic';

package/types/schematic.d.ts

@@ -1,32 +0,0 @@
-import type { PlainObject } from '@oscarpalmer/atoms/models';
-import { type Infer, type Schema, type TypedSchema, type ValidatedProperty } from './models';
-/**
- * A schematic for validating objects
- */
-export declare class Schematic<Model> {
-    #private;
-    private readonly $schematic;
-    constructor(properties: ValidatedProperty[]);
-    /**
-     * Does the value match the schema?
-     * @param value - Value to validate
-     * @returns `true` if the value matches the schema, otherwise `false`
-     */
-    is(value: unknown): value is Model;
-}
-/**
- * Create a schematic from a schema
- * @template Model - Schema type
- * @param schema - Schema to create the schematic from
- * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
- * @returns A schematic for the given schema
- */
-export declare function schematic<Model extends Schema>(schema: Model): Schematic<Infer<Model>>;
-/**
- * Create a schematic from a typed schema
- * @template Model - Existing type
- * @param schema - Typed schema to create the schematic from
- * @throws Throws {@link SchematicError} if the schema can not be converted into a schematic
- * @returns A schematic for the given typed schema
- */
-export declare function schematic<Model extends PlainObject>(schema: TypedSchema<Model>): Schematic<Model>;

package/types/validation/property.validation.d.ts

@@ -1,3 +0,0 @@
-import type { PlainObject } from '@oscarpalmer/atoms/models';
-import { type ValidatedProperty } from '../models';
-export declare function getProperties(original: PlainObject, prefix?: string, fromType?: boolean): ValidatedProperty[];

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

@@ -1,2 +0,0 @@
-import type { ValidatedProperty } from '../models';
-export declare function validateObject(obj: unknown, properties: ValidatedProperty[]): boolean;