@oscarpalmer/atoms 0.85.0 → 0.86.0

package/dist/index.cjs

@@ -12,6 +12,7 @@ const number = require("./number.cjs");
 const query = require("./query.cjs");
 const queue = require("./queue.cjs");
 const random = require("./random.cjs");
+const schema = require("./schema.cjs");
 const sized = require("./sized.cjs");
 const string_index = require("./string/index.cjs");
 require("./touch.cjs");
@@ -87,6 +88,7 @@ exports.getRandomHex = random.getRandomHex;
 exports.getRandomInteger = random.getRandomInteger;
 exports.getRandomItem = random.getRandomItem;
 exports.getRandomItems = random.getRandomItems;
+exports.schematic = schema.schematic;
 exports.SizedMap = sized.SizedMap;
 exports.SizedSet = sized.SizedSet;
 exports.createUuid = string_index.createUuid;

package/dist/index.js

@@ -10,6 +10,7 @@ import { between, clamp, getNumber } from "./number.js";
 import { fromQuery, toQuery } from "./query.js";
 import { queue } from "./queue.js";
 import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems } from "./random.js";
+import { schematic } from "./schema.js";
 import { SizedMap, SizedSet } from "./sized.js";
 import { createUuid, getString, join, parse, truncate, words } from "./string/index.js";
 import "./touch.js";
@@ -122,6 +123,7 @@ export {
   rgbToHex,
   rgbToHsl,
   round,
+  schematic,
   setValue,
   shuffle,
   smush,

package/dist/schema.cjs

@@ -1,25 +1,78 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-function getKeys(value) {
-  return value && typeof value === "object" ? Object.keys(value) : [];
+const valueTypes = /* @__PURE__ */ new Set([
+  "array",
+  "bigint",
+  "boolean",
+  "date",
+  "function",
+  "number",
+  "object",
+  "string",
+  "symbol"
+]);
+function getValidatedSchema(schema) {
+  const validated = {
+    keys: [],
+    length: 0,
+    schema: {}
+  };
+  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];
+    const types = [];
+    if (valueTypes.has(value)) {
+      types.push(value);
+    } else if (Array.isArray(value)) {
+      const typesLength = value.length;
+      for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+        const type = value[typeIndex];
+        if (valueTypes.has(type)) {
+          types.push(type);
+        }
+      }
+    }
+    if (types.length > 0) {
+      validated.keys.push(key);
+      validated.schema[key] = types;
+      validated.length += 1;
+    }
+  }
+  return validated;
 }
 function schematic(schema) {
-  const keys = getKeys(schema);
-  const { length } = keys;
-  const canValidate = length > 0;
+  const validated = getValidatedSchema(schema);
+  const canValidate = validated.length > 0;
   return Object.freeze({
-    is: (value) => canValidate && validate(schema, keys, length, value)
+    is: (value) => canValidate && validate(validated, value)
   });
 }
-function validate(schema, keys, length, value) {
-  if (getKeys(value).length !== length) {
+function validate(validated, value) {
+  if (typeof value !== "object" || value === null) {
     return false;
   }
-  for (let index = 0; index < length; index += 1) {
-    const key = keys[index];
-    if (!validators[schema[key]](value[key])) {
-      return false;
+  outer: for (let index = 0; index < validated.length; index += 1) {
+    const key = validated.keys[index];
+    const types = validated.schema[key];
+    const val = value[key];
+    const typesLength = types.length;
+    if (typesLength === 1) {
+      if (!validators[types[0]](val)) {
+        return false;
+      }
+      continue;
+    }
+    for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+      if (validators[types[typeIndex]](val)) {
+        continue outer;
+      }
     }
+    return false;
   }
   return true;
 }

package/dist/schema.js

@@ -1,23 +1,76 @@
-function getKeys(value) {
-  return value && typeof value === "object" ? Object.keys(value) : [];
+const valueTypes = /* @__PURE__ */ new Set([
+  "array",
+  "bigint",
+  "boolean",
+  "date",
+  "function",
+  "number",
+  "object",
+  "string",
+  "symbol"
+]);
+function getValidatedSchema(schema) {
+  const validated = {
+    keys: [],
+    length: 0,
+    schema: {}
+  };
+  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];
+    const types = [];
+    if (valueTypes.has(value)) {
+      types.push(value);
+    } else if (Array.isArray(value)) {
+      const typesLength = value.length;
+      for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+        const type = value[typeIndex];
+        if (valueTypes.has(type)) {
+          types.push(type);
+        }
+      }
+    }
+    if (types.length > 0) {
+      validated.keys.push(key);
+      validated.schema[key] = types;
+      validated.length += 1;
+    }
+  }
+  return validated;
 }
 function schematic(schema) {
-  const keys = getKeys(schema);
-  const { length } = keys;
-  const canValidate = length > 0;
+  const validated = getValidatedSchema(schema);
+  const canValidate = validated.length > 0;
   return Object.freeze({
-    is: (value) => canValidate && validate(schema, keys, length, value)
+    is: (value) => canValidate && validate(validated, value)
   });
 }
-function validate(schema, keys, length, value) {
-  if (getKeys(value).length !== length) {
+function validate(validated, value) {
+  if (typeof value !== "object" || value === null) {
     return false;
   }
-  for (let index = 0; index < length; index += 1) {
-    const key = keys[index];
-    if (!validators[schema[key]](value[key])) {
-      return false;
+  outer: for (let index = 0; index < validated.length; index += 1) {
+    const key = validated.keys[index];
+    const types = validated.schema[key];
+    const val = value[key];
+    const typesLength = types.length;
+    if (typesLength === 1) {
+      if (!validators[types[0]](val)) {
+        return false;
+      }
+      continue;
+    }
+    for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+      if (validators[types[typeIndex]](val)) {
+        continue outer;
+      }
     }
+    return false;
   }
   return true;
 }

package/package.json

@@ -4,7 +4,7 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"type-fest": "^4.33"
+		"type-fest": "^4.34"
 	},
 	"description": "Atomic utilities for making your JavaScript better.",
 	"devDependencies": {
@@ -218,5 +218,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.cts",
-	"version": "0.85.0"
+	"version": "0.86.0"
 }

package/src/index.ts

@@ -11,6 +11,7 @@ export * from './number';
 export * from './query';
 export * from './queue';
 export * from './random';
+export * from './schema';
 export * from './sized';
 export * from './string/index';
 export * from './touch';

package/src/schema.ts

@@ -17,7 +17,7 @@ type ReverseInferred<Model extends Typed> = {
 		: never;
 };
 
-export type Schema = Record<string, keyof Values>;
+export type Schema = Record<string, keyof Values | (keyof Values)[]>;
 
 export type Schematic<Model> = {
 	/**
@@ -28,6 +28,12 @@ export type Schematic<Model> = {
 
 type Typed = Record<string, unknown>;
 
+type ValidatedSchema = {
+	keys: string[];
+	length: number;
+	schema: Record<string, (keyof Values)[]>;
+};
+
 type Values = {
 	array: unknown[];
 	bigint: bigint;
@@ -41,8 +47,62 @@ type Values = {
 	symbol: symbol;
 };
 
-function getKeys(value: unknown): string[] {
-	return value && typeof value === 'object' ? Object.keys(value) : [];
+const valueTypes = new Set<keyof Values>([
+	'array',
+	'bigint',
+	'boolean',
+	'date',
+	'function',
+	'number',
+	'object',
+	'string',
+	'symbol',
+]);
+
+function getValidatedSchema(schema: unknown): ValidatedSchema {
+	const validated: ValidatedSchema = {
+		keys: [],
+		length: 0,
+		schema: {},
+	};
+
+	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];
+
+		const types: (keyof Values)[] = [];
+
+		if (valueTypes.has(value as never)) {
+			types.push(value as never);
+		} else if (Array.isArray(value)) {
+			const typesLength = value.length;
+
+			for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+				const type = value[typeIndex];
+
+				if (valueTypes.has(type)) {
+					types.push(type);
+				}
+			}
+		}
+
+		if (types.length > 0) {
+			validated.keys.push(key);
+
+			validated.schema[key] = types;
+
+			validated.length += 1;
+		}
+	}
+
+	return validated;
 }
 
 /**
@@ -60,33 +120,42 @@ export function schematic<Model extends Schema>(
 ): Schematic<Simplify<Inferred<Model>>>;
 
 export function schematic<Model extends Schema>(schema: Model) {
-	const keys = getKeys(schema);
-	const {length} = keys;
+	const validated = getValidatedSchema(schema);
 
-	const canValidate = length > 0;
+	const canValidate = validated.length > 0;
 
 	return Object.freeze({
-		is: (value: unknown) =>
-			canValidate && validate(schema, keys, length, value),
+		is: (value: unknown) => canValidate && validate(validated, value),
 	});
 }
 
-function validate(
-	schema: Schema,
-	keys: string[],
-	length: number,
-	value: unknown,
-): boolean {
-	if (getKeys(value).length !== length) {
+function validate(validated: ValidatedSchema, value: unknown): boolean {
+	if (typeof value !== 'object' || value === null) {
 		return false;
 	}
 
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
+	outer: for (let index = 0; index < validated.length; index += 1) {
+		const key = validated.keys[index];
+		const types = validated.schema[key];
+		const val = (value as PlainObject)[key];
+
+		const typesLength = types.length;
 
-		if (!validators[schema[key]]((value as PlainObject)[key])) {
-			return false;
+		if (typesLength === 1) {
+			if (!validators[types[0]](val)) {
+				return false;
+			}
+
+			continue;
 		}
+
+		for (let typeIndex = 0; typeIndex < typesLength; typeIndex += 1) {
+			if (validators[types[typeIndex]](val)) {
+				continue outer;
+			}
+		}
+
+		return false;
 	}
 
 	return true;

package/types/index.d.cts

@@ -1321,6 +1321,42 @@ export type Get<BaseType, Path extends readonly string[] | LiteralStringUnion<To
 	bracketNotation: true;
 	maxRecursionDepth: 2;
 }>>>, Options extends GetOptions = {}> = GetWithPath<BaseType, Path extends string ? ToPath<Path> : Path, Options>;
+export type FindKey<Model, Value> = {
+	[Key in keyof Model]: Model[Key] extends Value ? Key : never;
+}[keyof Model];
+export type Inferred<Model extends Schema> = {
+	[Key in keyof Model]: Model[Key] extends keyof Values ? Values[Model[Key]] : never;
+};
+export type ReverseInferred<Model extends Typed> = {
+	[Key in keyof Model]: Model[Key] extends Values[keyof Values] ? FindKey<Values, Model[Key]> : never;
+};
+export type Schema = Record<string, keyof Values | (keyof Values)[]>;
+export type Schematic<Model> = {
+	/**
+	 * Does the value match the schema?
+	 */
+	is(value: unknown): value is Model;
+};
+export type Typed = Record<string, unknown>;
+export type Values = {
+	array: unknown[];
+	bigint: bigint;
+	boolean: boolean;
+	date: Date;
+	function: Function;
+	number: number;
+	object: object;
+	string: string;
+	symbol: symbol;
+};
+/**
+ * Create a schematic from a typed schema
+ */
+export declare function schematic<Model extends Typed>(schema: ReverseInferred<Model>): Schematic<Model>;
+/**
+ * Create a schematic from a schema
+ */
+export declare function schematic<Model extends Schema>(schema: Model): Schematic<Simplify<Inferred<Model>>>;
 /**
  * Get a random boolean
  */

package/types/index.d.ts

@@ -11,6 +11,7 @@ export * from './number';
 export * from './query';
 export * from './queue';
 export * from './random';
+export * from './schema';
 export * from './sized';
 export * from './string/index';
 export * from './touch';

package/types/schema.d.cts

@@ -69,7 +69,7 @@ export type Inferred<Model extends Schema> = {
 export type ReverseInferred<Model extends Typed> = {
 	[Key in keyof Model]: Model[Key] extends Values[keyof Values] ? FindKey<Values, Model[Key]> : never;
 };
-export type Schema = Record<string, keyof Values>;
+export type Schema = Record<string, keyof Values | (keyof Values)[]>;
 export type Schematic<Model> = {
 	/**
 	 * Does the value match the schema?

package/types/schema.d.ts

@@ -8,7 +8,7 @@ type Inferred<Model extends Schema> = {
 type ReverseInferred<Model extends Typed> = {
     [Key in keyof Model]: Model[Key] extends Values[keyof Values] ? FindKey<Values, Model[Key]> : never;
 };
-export type Schema = Record<string, keyof Values>;
+export type Schema = Record<string, keyof Values | (keyof Values)[]>;
 export type Schematic<Model> = {
     /**
      * Does the value match the schema?