@oscarpalmer/jhunal 0.1.0 → 0.3.0

package/dist/helpers.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function getTypes(value) {
+  return (Array.isArray(value) ? value : [value]).filter(
+    (item) => types.has(item)
+  );
+}
+const types = /* @__PURE__ */ new Set([
+  "array",
+  "bigint",
+  "boolean",
+  "date",
+  "function",
+  "null",
+  "number",
+  "object",
+  "string",
+  "symbol",
+  "undefined"
+]);
+
+exports.getTypes = getTypes;

package/dist/helpers.js

@@ -0,0 +1,20 @@
+function getTypes(value) {
+  return (Array.isArray(value) ? value : [value]).filter(
+    (item) => types.has(item)
+  );
+}
+const types = /* @__PURE__ */ new Set([
+  "array",
+  "bigint",
+  "boolean",
+  "date",
+  "function",
+  "null",
+  "number",
+  "object",
+  "string",
+  "symbol",
+  "undefined"
+]);
+
+export { getTypes };

package/dist/index.cjs

@@ -1,2 +1,9 @@
 'use strict';
 
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const schematic = require('./schematic.cjs');
+
+
+
+exports.schematic = schematic.schematic;

package/dist/index.js

@@ -1 +1 @@
-
+export { schematic } from './schematic.js';

package/dist/model.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/model.js

@@ -0,0 +1 @@
+

package/dist/schematic.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const validation = require('./validation.cjs');
+
+function schematic(schema) {
+  const validated = validation.getValidatedSchema(schema);
+  const canValidate = validated.length > 0;
+  return Object.freeze({
+    is: (value) => canValidate && validation.validate(validated, value)
+  });
+}
+
+exports.schematic = schematic;

package/dist/schematic.js

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

package/dist/validation.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const helpers = require('./helpers.cjs');
+
+function getValidatedSchema(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 valueTypes;
+    if (Array.isArray(value)) {
+      valueTypes = helpers.getTypes(value);
+    } else if (typeof value === "object" && value !== null) {
+      if (typeof value.required === "boolean") {
+        required = value.required;
+      }
+      valueTypes = helpers.getTypes(value.type);
+    } else {
+      valueTypes = helpers.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;
+}
+function validate(validated, obj) {
+  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[key];
+    if (value === void 0 && 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;
+}
+const validators = {
+  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 === void 0
+};
+
+exports.getValidatedSchema = getValidatedSchema;
+exports.validate = validate;

package/dist/validation.js

@@ -0,0 +1,84 @@
+import { getTypes } from './helpers.js';
+
+function getValidatedSchema(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 valueTypes;
+    if (Array.isArray(value)) {
+      valueTypes = getTypes(value);
+    } else if (typeof value === "object" && value !== null) {
+      if (typeof value.required === "boolean") {
+        required = value.required;
+      }
+      valueTypes = getTypes(value.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;
+}
+function validate(validated, obj) {
+  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[key];
+    if (value === void 0 && 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;
+}
+const validators = {
+  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 === void 0
+};
+
+export { getValidatedSchema, validate };

package/package.json

@@ -3,6 +3,10 @@
 		"name": "Oscar Palmér",
 		"url": "https://oscarpalmer.se"
 	},
+	"dependencies": {
+		"@oscarpalmer/atoms": "^0.94",
+		"type-fest": "^4.39"
+	},
 	"description": "Flies free beneath the glistening moons…",
 	"devDependencies": {
 		"@biomejs/biome": "^1.9",
@@ -46,5 +50,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.cts",
-	"version": "0.1.0"
+	"version": "0.3.0"
 }

package/src/helpers.ts

@@ -0,0 +1,21 @@
+import type {Values} from './model';
+
+export function getTypes(value: unknown): (keyof Values)[] {
+	return (Array.isArray(value) ? value : [value]).filter(item =>
+		types.has(item),
+	);
+}
+
+const types = new Set<keyof Values>([
+	'array',
+	'bigint',
+	'boolean',
+	'date',
+	'function',
+	'null',
+	'number',
+	'object',
+	'string',
+	'symbol',
+	'undefined',
+]);

package/src/index.ts

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

package/src/model.ts

@@ -0,0 +1,127 @@
+import type {
+	OptionalKeysOf,
+	RequiredKeysOf,
+	Simplify,
+	UnionToTuple,
+} from 'type-fest';
+
+export type GetKey<Value> = {
+	[Key in keyof Values]: Value extends Values[Key] ? Key : never;
+}[keyof Values];
+
+export type GetTypes<Value extends unknown[]> = Value extends [infer Single]
+	? Single
+	: 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
+	: never;
+
+export type InferValue<Value> = Value extends keyof Values
+	? Values[Value]
+	: Value extends (keyof Values)[]
+		? 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 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: keyof Values | (keyof Values)[];
+};
+
+export 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;
+};
+
+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: (keyof Values)[];
+};
+
+export type ValidatedSchema = {
+	keys: string[];
+	length: number;
+	properties: Record<string, ValidatedProperty>;
+};
+
+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;
+};

package/src/schematic.ts

@@ -0,0 +1,26 @@
+import type {Inferred, Schema, Schematic, Typed, TypedSchema} from './model';
+import {getValidatedSchema, validate} from './validation';
+
+/**
+ * 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),
+	});
+}

package/src/validation.ts

@@ -0,0 +1,109 @@
+import type {PlainObject} from '@oscarpalmer/atoms';
+import {getTypes} from './helpers';
+import type {Schema, ValidatedSchema, Values} from './model';
+
+export 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;
+}
+
+export 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;
+}
+
+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,
+};

package/types/helpers.d.cts

@@ -0,0 +1,18 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type Values = {
+	array: unknown[];
+	bigint: bigint;
+	boolean: boolean;
+	date: Date;
+	function: Function;
+	null: null;
+	number: number;
+	object: object;
+	string: string;
+	symbol: symbol;
+	undefined: undefined;
+};
+export declare function getTypes(value: unknown): (keyof Values)[];
+
+export {};

package/types/helpers.d.ts

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