@oscarpalmer/jhunal 0.3.0 → 0.4.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.cjs

@@ -2,19 +2,40 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+const is = require('./is.cjs');
+const validation_schema_validation = require('./validation/schema.validation.cjs');
+
 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 is.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(validation_schema_validation.validateSchema(type));
+        break;
+      }
+    }
+  }
+  return returned;
 }
 const types = /* @__PURE__ */ new Set([
   "array",
   "bigint",
   "boolean",
   "date",
+  "date-like",
   "function",
   "null",
   "number",
+  "numerical",
   "object",
   "string",
   "symbol",

package/dist/helpers.js

@@ -1,16 +1,37 @@
+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;
+      }
+    }
+  }
+  return returned;
 }
 const types = /* @__PURE__ */ new Set([
   "array",
   "bigint",
   "boolean",
   "date",
+  "date-like",
   "function",
   "null",
   "number",
+  "numerical",
   "object",
   "string",
   "symbol",

package/dist/is.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+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;
+}
+
+exports.isDateLike = isDateLike;
+exports.isSchematic = isSchematic;

package/dist/is.js

@@ -0,0 +1,14 @@
+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/schematic.cjs

@@ -2,13 +2,15 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const validation = require('./validation.cjs');
+const validation_schema_validation = require('./validation/schema.validation.cjs');
+const validation_value_validation = require('./validation/value.validation.cjs');
 
 function schematic(schema) {
-  const validated = validation.getValidatedSchema(schema);
+  const validated = validation_schema_validation.validateSchema(schema);
   const canValidate = validated.length > 0;
   return Object.freeze({
-    is: (value) => canValidate && validation.validate(validated, value)
+    $schematic: true,
+    is: (value) => canValidate && validation_value_validation.validateValue(validated, value)
   });
 }
 

package/dist/schematic.js

@@ -1,10 +1,12 @@
-import { getValidatedSchema, validate } from './validation.js';
+import { validateSchema } from './validation/schema.validation.js';
+import { validateValue } from './validation/value.validation.js';
 
 function schematic(schema) {
-  const validated = getValidatedSchema(schema);
+  const validated = validateSchema(schema);
   const canValidate = validated.length > 0;
   return Object.freeze({
-    is: (value) => canValidate && validate(validated, value)
+    $schematic: true,
+    is: (value) => canValidate && validateValue(validated, value)
   });
 }
 

package/dist/validation/schema.validation.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const helpers = require('../helpers.cjs');
+
+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 = helpers.getTypes(value);
+    } else if (typeof value === "object" && value !== null) {
+      if (typeof value.required === "boolean") {
+        required = value.required;
+      }
+      types = helpers.getTypes(value.type);
+    } else {
+      types = helpers.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();
+
+exports.validateSchema = validateSchema;
+exports.validatedSchemas = validatedSchemas;

package/dist/validation/schema.validation.js

@@ -0,0 +1,49 @@
+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/type.validation.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const is = require('../is.cjs');
+const validation_value_validation = require('./value.validation.cjs');
+
+function validateType(type, value) {
+  if (typeof type === "string") {
+    return validators[type](value);
+  }
+  if (is.isSchematic(type)) {
+    return type.is(value);
+  }
+  return validation_value_validation.validateValue(type, value);
+}
+const validators = {
+  array: Array.isArray,
+  bigint: (value) => typeof value === "bigint",
+  boolean: (value) => typeof value === "boolean",
+  date: (value) => value instanceof Date,
+  "date-like": is.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
+};
+
+exports.validateType = validateType;

package/dist/validation/type.validation.js

@@ -0,0 +1,29 @@
+import { isDateLike, isSchematic } from '../is.js';
+import { validateValue } from './value.validation.js';
+
+function validateType(type, value) {
+  if (typeof type === "string") {
+    return validators[type](value);
+  }
+  if (isSchematic(type)) {
+    return type.is(value);
+  }
+  return validateValue(type, value);
+}
+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
+};
+
+export { validateType };

package/dist/validation/value.validation.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const validation_type_validation = require('./type.validation.cjs');
+
+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 (!validation_type_validation.validateType(property.types[0], value)) {
+        return false;
+      }
+      continue;
+    }
+    for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+      if (validation_type_validation.validateType(property.types[typeIndex], value)) {
+        continue outer;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+
+exports.validateValue = validateValue;

package/dist/validation/value.validation.js

@@ -0,0 +1,31 @@
+import { validateType } from './type.validation.js';
+
+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;
+}
+
+export { validateValue };

package/package.json

@@ -50,5 +50,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.cts",
-	"version": "0.3.0"
+	"version": "0.4.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 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

@@ -5,39 +5,63 @@ import type {
 	UnionToTuple,
 } from 'type-fest';
 
+export type AutoInferExclude = 'date-like' | 'numerical';
+
 export type GetKey<Value> = {
-	[Key in keyof Values]: Value extends Values[Key] ? Key : never;
-}[keyof Values];
+		[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 Single]
-	? Single
+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
-	? Value['type'] extends keyof Values
-		? Values[Value['type']]
-		: Value['type'] extends (keyof Values)[]
-			? Values[Value['type'][number]]
-			: never
+	? 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 keyof Values
+export type InferValue<Value> = Value extends ValueKey
 	? Values[Value]
-	: Value extends (keyof Values)[]
+	: Value extends ValueKey[]
 		? Values[Value[number]]
 		: never;
 
-export 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;
-};
+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
@@ -61,9 +85,11 @@ export type OptionalProperty<Type> = {
 };
 
 export type Property = {
-	required?: boolean;
-	type: keyof Values | (keyof Values)[];
-};
+		required?: boolean;
+		type: PropertyType | PropertyType[];
+	};
+
+type PropertyType = Schema | Schematic<unknown> | ValueKey;
 
 export type RequiredProperty<Type> = {
 	required: true;
@@ -73,7 +99,9 @@ export type RequiredProperty<Type> = {
 /**
  * A schema for validating objects
  */
-export type Schema = Record<string, keyof Values | (keyof Values)[] | Property>;
+export type Schema = {
+	[key: string]: Property | ValueKey | ValueKey[];
+};
 
 /**
  * A schematic for validating objects
@@ -101,27 +129,40 @@ export type TypedSchema<Model extends Typed> = Simplify<
 >;
 
 export type ValidatedProperty = {
-	required: boolean;
-	types: (keyof Values)[];
-};
+		required: boolean;
+		types: ValidatedPropertyType[];
+	};
+
+export type ValidatedPropertyType =
+	| Schematic<unknown>
+	| ValidatedSchema
+	| ValueKey;
 
 export type ValidatedSchema = {
-	keys: string[];
-	length: number;
-	properties: Record<string, ValidatedProperty>;
+		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;
-	// 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;
-};
+		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;
+	};