@oscarpalmer/jhunal 0.2.0 → 0.4.0

package/src/index.ts

@@ -1,282 +1,2 @@
-import type {
-	OptionalKeysOf,
-	RequiredKeysOf,
-	Simplify,
-	UnionToTuple,
-} from 'type-fest';
-import type {PlainObject} from '@oscarpalmer/atoms/models';
-
-type GetKey<Value> = {
-	[Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
-
-type GetTypes<Value extends unknown[]> = Value extends [infer Single]
-	? Single
-	: Value;
-
-type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
-
-type InferProperty<Value> = Value extends Property
-	? Value['type'] extends keyof Values
-		? Values[Value['type']]
-		: Value['type'] extends (keyof Values)[]
-			? Values[Value['type'][number]]
-			: never
-	: never;
-
-type InferValue<Value> = Value extends keyof Values
-	? Values[Value]
-	: Value extends (keyof Values)[]
-		? Values[Value[number]]
-		: never;
-
-type Inferred<Model extends Schema> = {
-	[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property
-		? InferProperty<Model[Key]>
-		: InferValue<Model[Key]>;
-} & {
-	[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property
-		? InferProperty<Model[Key]>
-		: never;
-};
-
-type InferredOptionalProperties<Model extends Schema> = {
-	[Key in keyof Model]: Model[Key] extends Property
-		? Model[Key]['required'] extends false
-			? Key
-			: never
-		: never;
-}[keyof Model];
-
-type InferredRequiredProperties<Model extends Schema> = {
-	[Key in keyof Model]: Model[Key] extends Property
-		? Model[Key]['required'] extends false
-			? never
-			: Key
-		: Key;
-}[keyof Model];
-
-type OptionalProperty<Type> = {
-	required: false;
-	type: GetType<Type>;
-};
-
-type Property = {
-	required?: boolean;
-	type: keyof Values | (keyof Values)[];
-};
-
-type RequiredProperty<Type> = {
-	required: true;
-	type: GetType<Type>;
-};
-
-/**
- * A schema for validating objects
- */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
-
-/**
- * A schematic for validating objects
- */
-export type Schematic<Model> = {
-	/**
-	 * Does the value match the schema?
-	 */
-	is(value: unknown): value is Model;
-};
-
-type Typed = Record<string, unknown>;
-
-/**
- * A typed schema for validating objects
- */
-export type TypedSchema<Model extends Typed> = Simplify<
-	{
-		[Key in RequiredKeysOf<Model>]:
-			| GetType<Model[Key]>
-			| RequiredProperty<Model[Key]>;
-	} & {
-		[Key in OptionalKeysOf<Model>]: OptionalProperty<Model[Key]>;
-	}
->;
-
-type ValidatedProperty = {
-	required: boolean;
-	types: (keyof Values)[];
-};
-
-type ValidatedSchema = {
-	keys: string[];
-	length: number;
-	properties: Record<string, ValidatedProperty>;
-};
-
-type Values = {
-	array: unknown[];
-	bigint: bigint;
-	boolean: boolean;
-	date: Date;
-	// biome-ignore lint/complexity/noBannedTypes: it's the most basic value type, so I think it's ok
-	function: Function;
-	null: null;
-	number: number;
-	object: object;
-	string: string;
-	symbol: symbol;
-	undefined: undefined;
-};
-
-//
-
-const types = new Set<keyof Values>([
-	'array',
-	'bigint',
-	'boolean',
-	'date',
-	'function',
-	'null',
-	'number',
-	'object',
-	'string',
-	'symbol',
-	'undefined',
-]);
-
-const validators: Record<keyof Values, (value: unknown) => boolean> = {
-	array: Array.isArray,
-	bigint: value => typeof value === 'bigint',
-	boolean: value => typeof value === 'boolean',
-	date: value => value instanceof Date,
-	function: value => typeof value === 'function',
-	null: value => value === null,
-	number: value => typeof value === 'number',
-	object: value => typeof value === 'object' && value !== null,
-	string: value => typeof value === 'string',
-	symbol: value => typeof value === 'symbol',
-	undefined: value => value === undefined,
-};
-
-//
-
-function getTypes(value: unknown): (keyof Values)[] {
-	return (Array.isArray(value) ? value : [value]).filter(item =>
-		types.has(item),
-	);
-}
-
-function getValidatedSchema(schema: unknown): ValidatedSchema {
-	const validated: ValidatedSchema = {
-		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 as Schema)[key];
-
-		let required = true;
-		let valueTypes: (keyof Values)[];
-
-		if (Array.isArray(value)) {
-			valueTypes = getTypes(value);
-		} else if (typeof value === 'object' && value !== null) {
-			if (typeof (value as PlainObject).required === 'boolean') {
-				required = (value as PlainObject).required as boolean;
-			}
-
-			valueTypes = getTypes((value as PlainObject).type);
-		} else {
-			valueTypes = getTypes(value);
-		}
-
-		if (valueTypes.length > 0) {
-			if (!required && !valueTypes.includes('undefined')) {
-				valueTypes.push('undefined');
-			}
-
-			validated.keys.push(key);
-
-			validated.properties[key] = {
-				required,
-				types: valueTypes,
-			};
-
-			validated.length += 1;
-		}
-	}
-
-	return validated;
-}
-
-/**
- * Create a schematic from a typed schema
- */
-export function schematic<Model extends Typed>(
-		schema: TypedSchema<Model>,
-	): Schematic<Model>;
-
-/**
- * Create a schematic from a schema
- */
-export function schematic<Model extends Schema>(
-		schema: Model,
-	): Schematic<Inferred<Model>>;
-
-export function schematic<Model extends Schema>(schema: Model) {
-	const validated = getValidatedSchema(schema);
-
-	const canValidate = validated.length > 0;
-
-	return Object.freeze({
-		is: (value: unknown) => canValidate && validate(validated, value),
-	});
-}
-
-function validate(validated: ValidatedSchema, obj: unknown): boolean {
-	if (typeof obj !== 'object' || obj === null) {
-		return false;
-	}
-
-	outer: for (let index = 0; index < validated.length; index += 1) {
-		const key = validated.keys[index];
-		const property = validated.properties[key];
-		const value = (obj as PlainObject)[key];
-
-		if (
-			value === undefined &&
-			property.required &&
-			!property.types.includes('undefined')
-		) {
-			return false;
-		}
-
-		const typesLength = property.types.length;
-
-		if (typesLength === 1) {
-			if (!validators[property.types[0]](value)) {
-				return false;
-			}
-
-			continue;
-		}
-
-		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
-			if (validators[property.types[typeIndex]](value)) {
-				continue outer;
-			}
-		}
-
-		return false;
-	}
-
-	return true;
-}
+export type {Schema, Schematic, TypedSchema} from './model';
+export * from './schematic';

package/src/is.ts

@@ -0,0 +1,22 @@
+import type {Schematic} from './model';
+
+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
+	);
+}

package/src/model.ts

@@ -0,0 +1,168 @@
+import type {
+	OptionalKeysOf,
+	RequiredKeysOf,
+	Simplify,
+	UnionToTuple,
+} from 'type-fest';
+
+export type AutoInferExclude = 'date-like' | 'numerical';
+
+export type GetKey<Value> = {
+		[Key in Exclude<ValueKey, AutoInferExclude>]: Value extends Values[Key]
+			? Key
+			: never;
+	}[Exclude<ValueKey, AutoInferExclude>] extends infer SpecificKey
+		? SpecificKey extends never
+			? {
+					[Key in AutoInferExclude]: Value extends Values[Key] ? Key : never;
+				}[AutoInferExclude]
+			: SpecificKey
+		: never;
+
+export type GetTypes<Value extends unknown[]> = Value extends [infer Type]
+	? Type
+	: Value;
+
+export type GetType<Value> = GetTypes<UnionToTuple<GetKey<Value>>>;
+
+export type InferProperty<Value> = Value extends Property
+	? InferPropertyType<Value['type']>
+	: never;
+
+type InferPropertyType<Value> = Value extends (infer Type)[]
+	? InferPropertyTypeValue<Type>[]
+	: InferPropertyTypeValue<Value>;
+
+type InferPropertyTypeValue<Value> = Value extends PropertyType
+	? Value extends Schema
+		? Inferred<Value>
+		: Value extends Schematic<infer Model>
+			? Model
+			: Value extends ValueKey
+				? Values[Value]
+				: Value extends (infer NestedElementType)[]
+					? InferPropertyTypeValue<NestedElementType>[]
+					: Value
+	: never;
+
+export type InferValue<Value> = Value extends ValueKey
+	? Values[Value]
+	: Value extends ValueKey[]
+		? Values[Value[number]]
+		: never;
+
+export type Inferred<Model extends Schema> = Simplify<
+	{
+		[Key in InferredRequiredProperties<Model>]: Model[Key] extends Property
+			? InferProperty<Model[Key]>
+			: InferValue<Model[Key]>;
+	} & {
+		[Key in InferredOptionalProperties<Model>]?: Model[Key] extends Property
+			? InferProperty<Model[Key]>
+			: never;
+	}
+>;
+
+export type InferredOptionalProperties<Model extends Schema> = {
+	[Key in keyof Model]: Model[Key] extends Property
+		? Model[Key]['required'] extends false
+			? Key
+			: never
+		: never;
+}[keyof Model];
+
+export type InferredRequiredProperties<Model extends Schema> = {
+	[Key in keyof Model]: Model[Key] extends Property
+		? Model[Key]['required'] extends false
+			? never
+			: Key
+		: Key;
+}[keyof Model];
+
+export type OptionalProperty<Type> = {
+	required: false;
+	type: GetType<Type>;
+};
+
+export type Property = {
+		required?: boolean;
+		type: PropertyType | PropertyType[];
+	};
+
+type PropertyType = Schema | Schematic<unknown> | ValueKey;
+
+export type RequiredProperty<Type> = {
+	required: true;
+	type: GetType<Type>;
+};
+
+/**
+ * A schema for validating objects
+ */
+export type Schema = {
+	[key: string]: Property | ValueKey | ValueKey[];
+};
+
+/**
+ * A schematic for validating objects
+ */
+export type Schematic<Model> = {
+	/**
+	 * Does the value match the schema?
+	 */
+	is(value: unknown): value is Model;
+};
+
+export type Typed = Record<string, unknown>;
+
+/**
+ * A typed schema for validating objects
+ */
+export type TypedSchema<Model extends Typed> = Simplify<
+	{
+		[Key in RequiredKeysOf<Model>]:
+			| GetType<Model[Key]>
+			| RequiredProperty<Model[Key]>;
+	} & {
+		[Key in OptionalKeysOf<Model>]: OptionalProperty<Model[Key]>;
+	}
+>;
+
+export type ValidatedProperty = {
+		required: boolean;
+		types: ValidatedPropertyType[];
+	};
+
+export type ValidatedPropertyType =
+	| Schematic<unknown>
+	| ValidatedSchema
+	| ValueKey;
+
+export type ValidatedSchema = {
+		keys: string[];
+		length: number;
+		properties: ValidatedSchemaProperties;
+	};
+
+type ValidatedSchemaProperties = {
+	[key: string]: ValidatedProperty;
+};
+
+export type ValueKey = keyof Values;
+
+export type Values = {
+		array: unknown[];
+		bigint: bigint;
+		boolean: boolean;
+		date: Date;
+		'date-like': number | string | Date;
+		// biome-ignore lint/complexity/noBannedTypes: it's the most basic value type, so I think it's ok
+		function: Function;
+		null: null;
+		number: number;
+		numerical: bigint | number;
+		object: object;
+		string: string;
+		symbol: symbol;
+		undefined: undefined;
+	};

package/src/schematic.ts

@@ -0,0 +1,30 @@
+import type {Inferred, Schema, Schematic, Typed, TypedSchema} from './model';
+import {validateSchema} from './validation/schema.validation';
+import {validateValue} from './validation/value.validation';
+
+/**
+ * Create a schematic from a schema
+ */
+export function schematic<Model extends Schema>(
+	schema: Model,
+): Schematic<Inferred<Model>>;
+
+/**
+ * Create a schematic from a typed schema
+ */
+export function schematic<Model extends Typed>(
+	schema: TypedSchema<Model>,
+): Schematic<Model>;
+
+export function schematic<Model extends Schema>(
+	schema: Model,
+): Schematic<Model> {
+	const validated = validateSchema(schema);
+
+	const canValidate = validated.length > 0;
+
+	return Object.freeze({
+		$schematic: true,
+		is: (value: unknown) => canValidate && validateValue(validated, value),
+	}) as never;
+}

package/src/validation/schema.validation.ts

@@ -0,0 +1,63 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {getTypes} from '../helpers';
+import type {Schema, ValidatedPropertyType, ValidatedSchema} from '../model';
+
+export function validateSchema(schema: unknown): ValidatedSchema {
+	if (validatedSchemas.has(schema as never)) {
+		return validatedSchemas.get(schema as never) as ValidatedSchema;
+	}
+
+	const validated: ValidatedSchema = {
+		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 as Schema)[key];
+
+		let required = true;
+		let types: ValidatedPropertyType[];
+
+		if (Array.isArray(value)) {
+			types = getTypes(value);
+		} else if (typeof value === 'object' && value !== null) {
+			if (typeof (value as PlainObject).required === 'boolean') {
+				required = (value as PlainObject).required as boolean;
+			}
+
+			types = getTypes((value as PlainObject).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 as never, validated);
+
+	return validated;
+}
+
+export const validatedSchemas = new WeakMap<Schema, ValidatedSchema>();

package/src/validation/type.validation.ts

@@ -0,0 +1,34 @@
+import {isDateLike, isSchematic} from '../is';
+import type {ValidatedPropertyType, ValidatedSchema, Values} from '../model';
+import {validateValue} from './value.validation';
+
+export function validateType(
+	type: ValidatedPropertyType,
+	value: unknown,
+): boolean {
+	if (typeof type === 'string') {
+		return validators[type](value);
+	}
+
+	if (isSchematic(type)) {
+		return type.is(value);
+	}
+
+	return validateValue(type as ValidatedSchema, value);
+}
+
+const validators: Record<keyof Values, (value: unknown) => boolean> = {
+	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 === undefined,
+};

package/src/validation/value.validation.ts

@@ -0,0 +1,46 @@
+import type {PlainObject} from '@oscarpalmer/atoms/models';
+import type {ValidatedSchema} from '../model';
+import {validateType} from './type.validation';
+
+export function validateValue(
+	validated: ValidatedSchema,
+	obj: unknown,
+): boolean {
+	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 as PlainObject)[key];
+
+		if (
+			value === undefined &&
+			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;
+}

package/types/helpers.d.cts

@@ -0,0 +1,43 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * A schematic for validating objects
+ */
+export type Schematic<Model> = {
+	/**
+	 * Does the value match the schema?
+	 */
+	is(value: unknown): value is Model;
+};
+export type ValidatedProperty = {
+	required: boolean;
+	types: ValidatedPropertyType[];
+};
+export type ValidatedPropertyType = Schematic<unknown> | ValidatedSchema | ValueKey;
+export type ValidatedSchema = {
+	keys: string[];
+	length: number;
+	properties: ValidatedSchemaProperties;
+};
+export type ValidatedSchemaProperties = {
+	[key: string]: ValidatedProperty;
+};
+export type ValueKey = keyof Values;
+export type Values = {
+	array: unknown[];
+	bigint: bigint;
+	boolean: boolean;
+	date: Date;
+	"date-like": number | string | Date;
+	function: Function;
+	null: null;
+	number: number;
+	numerical: bigint | number;
+	object: object;
+	string: string;
+	symbol: symbol;
+	undefined: undefined;
+};
+export declare function getTypes(value: unknown): ValidatedPropertyType[];
+
+export {};

package/types/helpers.d.ts

@@ -0,0 +1,2 @@
+import type { ValidatedPropertyType } from './model';
+export declare function getTypes(value: unknown): ValidatedPropertyType[];