@oscarpalmer/jhunal 0.2.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

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const is = require('./is.cjs');
+const validation_schema_validation = require('./validation/schema.validation.cjs');
+
+function getTypes(value) {
+  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",
+  "undefined"
+]);
+
+exports.getTypes = getTypes;

package/dist/helpers.js

@@ -0,0 +1,41 @@
+import { isSchematic } from './is.js';
+import { validateSchema } from './validation/schema.validation.js';
+
+function getTypes(value) {
+  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",
+  "undefined"
+]);
+
+export { getTypes };

package/dist/index.cjs

@@ -2,110 +2,8 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const types = /* @__PURE__ */ new Set([
-  "array",
-  "bigint",
-  "boolean",
-  "date",
-  "function",
-  "null",
-  "number",
-  "object",
-  "string",
-  "symbol",
-  "undefined"
-]);
-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
-};
-function getTypes(value) {
-  return (Array.isArray(value) ? value : [value]).filter(
-    (item) => types.has(item)
-  );
-}
-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 schematic(schema) {
-  const validated = getValidatedSchema(schema);
-  const canValidate = validated.length > 0;
-  return Object.freeze({
-    is: (value) => canValidate && validate(validated, value)
-  });
-}
-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 schematic = require('./schematic.cjs');
 
-exports.schematic = schematic;
+
+
+exports.schematic = schematic.schematic;

package/dist/index.js

@@ -1,107 +1 @@
-const types = /* @__PURE__ */ new Set([
-  "array",
-  "bigint",
-  "boolean",
-  "date",
-  "function",
-  "null",
-  "number",
-  "object",
-  "string",
-  "symbol",
-  "undefined"
-]);
-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
-};
-function getTypes(value) {
-  return (Array.isArray(value) ? value : [value]).filter(
-    (item) => types.has(item)
-  );
-}
-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 schematic(schema) {
-  const validated = getValidatedSchema(schema);
-  const canValidate = validated.length > 0;
-  return Object.freeze({
-    is: (value) => canValidate && validate(validated, value)
-  });
-}
-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;
-}
-
-export { schematic };
+export { schematic } from './schematic.js';

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/model.cjs

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

package/dist/model.js

@@ -0,0 +1 @@
+

package/dist/schematic.cjs

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

package/dist/schematic.js

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

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.2.0"
+	"version": "0.4.0"
 }

package/src/helpers.ts

@@ -0,0 +1,49 @@
+import {isSchematic} from './is';
+import type {ValidatedPropertyType, Values} from './model';
+import {validateSchema} from './validation/schema.validation';
+
+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>([
+	'array',
+	'bigint',
+	'boolean',
+	'date',
+	'date-like',
+	'function',
+	'null',
+	'number',
+	'numerical',
+	'object',
+	'string',
+	'symbol',
+	'undefined',
+]);