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

@@ -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/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

@@ -50,5 +50,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.cts",
-	"version": "0.2.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',
+]);