@thi.ng/validate 0.2.0 → 0.3.0

package/api.d.ts

@@ -6,7 +6,7 @@ export interface Validator {
     coerce?: Fn<any, any>;
     /**
      * Validation predicate. If the function returns false, the
-     * {@link volidator} wrapper will throw an error.
+     * {@link validator} wrapper will throw an error.
      */
     valid: Predicate<any>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thi.ng/validate",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "Functional, composable, fully extensible, predicate-based value validation with customizable error messages",
 	"type": "module",
 	"module": "./index.js",
@@ -85,5 +85,5 @@
 		"status": "alpha",
 		"year": 2026
 	},
-	"gitHead": "c0d6e8f2517c5edc745774266f3cbca586b03d5e"
+	"gitHead": "7e7cd1f3214bf256630f87efaa1f2f5f53454133"
 }

package/validators.d.ts

@@ -55,6 +55,14 @@ export declare const ValidationError: {
  * @param validators
  */
 export declare const validator: (...validators: Validator[]) => (x: any) => boolean;
+/**
+ * Utility validator which always passes.
+ */
+export declare const ALWAYS: Validator;
+/**
+ * Utility validator which always fails.
+ */
+export declare const NEVER: Validator;
 /**
  * Higher order validator. Takes existing validator(s) and returns an augmented
  * version which also allows values to be nullish. If more than one validator is
@@ -108,11 +116,19 @@ export declare const isUndefined: (msg?: Validator["msg"]) => Validator;
  * @param msg
  */
 export declare const isNullish: (msg?: Validator["msg"]) => Validator;
+export declare const isArray: (msg?: Validator["msg"]) => Validator;
+export declare const isArrayOf: (validators: Validator | Validator[], msg?: Validator["msg"]) => Validator;
 export declare const isBoolean: (msg?: Validator["msg"]) => Validator;
 export declare const isNumber: (msg?: Validator["msg"]) => Validator;
 export declare const isString: (msg?: Validator["msg"]) => Validator;
 export declare const isDate: (msg?: Validator["msg"]) => Validator;
+export declare const isFunction: (msg?: Validator["msg"]) => Validator;
 export declare const isRegExp: (msg?: Validator["msg"]) => Validator;
+/**
+ * Returns validator which checks that given value is a plain object (not class).
+ *
+ * @param msg
+ */
 export declare const isObject: (msg?: Validator["msg"]) => Validator;
 /**
  * Returns validator to check if value is a plain object and the values of all
@@ -122,8 +138,6 @@ export declare const isObject: (msg?: Validator["msg"]) => Validator;
  * @param msg
  */
 export declare const isObjectOf: (validators: Validator | Validator[], msg?: Validator["msg"]) => Validator;
-export declare const isArray: (msg?: Validator["msg"]) => Validator;
-export declare const isArrayOf: (validators: Validator | Validator[], msg?: Validator["msg"]) => Validator;
 export declare const isTypedArray: (msg?: Validator["msg"]) => Validator;
 /**
  * Returns validator to check if value is a `Uint8Array`.
@@ -152,8 +166,11 @@ export declare const hasRequiredKeys: (keys: string[], nonNullish?: boolean, onl
  * @param onlyKeys
  */
 export declare const hasKeysOf: (validators: Record<PropertyKey, Validator | Validator[]>, onlyKeys?: boolean) => Validator;
+export declare const hasRequiredPatternKeys: (pattern: RegExp, nonNullish?: boolean, onlyKeys?: boolean, msg?: Validator["msg"]) => Validator;
+export declare const hasPatternKeysOf: (pattern: RegExp, validators: Validator | Validator[], onlyKeys?: boolean) => Validator;
 /**
- * Returns validator to check if value is one of the given options.
+ * Returns validator to check if value is one of the given options. Values are
+ * checked via `opts.includes(x)`.
  *
  * @param opts
  * @param msg

package/validators.js

@@ -2,7 +2,7 @@ import { isArray as $isArray } from "@thi.ng/checks/is-array";
 import { isArrayOf as $isArrayOf } from "@thi.ng/checks/is-array-of";
 import { isBoolean as $isBoolean } from "@thi.ng/checks/is-boolean";
 import { isDate as $isDate } from "@thi.ng/checks/is-date";
-import { isFunction } from "@thi.ng/checks/is-function";
+import { isFunction as $isFunction } from "@thi.ng/checks/is-function";
 import { isNumber as $isNumber } from "@thi.ng/checks/is-number";
 import { isObjectOf as $isObjectOf } from "@thi.ng/checks/is-object-of";
 import { isPlainObject } from "@thi.ng/checks/is-plain-object";
@@ -15,13 +15,15 @@ const validator = (...validators) => (x) => {
   for (let { coerce, valid, msg } of validators) {
     if (coerce) x = coerce(x);
     if (!valid(x)) {
-      if (isFunction(msg)) msg = msg(x);
+      if ($isFunction(msg)) msg = msg(x);
       throw new ValidationError(msg ?? "failed validation");
     }
   }
   return true;
 };
 const __asArray = (v) => $isArray(v) ? v : [v];
+const ALWAYS = { valid: () => true };
+const NEVER = { valid: () => false };
 const optional = (first, ...rest) => {
   const { coerce, valid, msg } = rest.length ? every(first, ...rest) : first;
   return {
@@ -69,6 +71,14 @@ const isNullish = (msg) => ({
   valid: (x) => x === null,
   msg: msg ?? `expected nullish value`
 });
+const isArray = (msg) => ({
+  valid: $isArray,
+  msg: msg ?? `required array value`
+});
+const isArrayOf = (validators, msg) => ({
+  valid: $isArrayOf(validator(...__asArray(validators))),
+  msg: msg ?? `required array value`
+});
 const isBoolean = (msg) => ({
   valid: $isBoolean,
   msg: msg ?? `required boolean value`
@@ -85,26 +95,22 @@ const isDate = (msg) => ({
   valid: $isDate,
   msg: msg ?? `required date value`
 });
+const isFunction = (msg) => ({
+  valid: $isFunction,
+  msg: msg ?? `required function value`
+});
 const isRegExp = (msg) => ({
   valid: $isRegExp,
   msg: msg ?? `required regexp value`
 });
 const isObject = (msg) => ({
   valid: isPlainObject,
-  msg: msg ?? `required object value`
+  msg: msg ?? `required plain object value`
 });
 const isObjectOf = (validators, msg) => ({
   valid: $isObjectOf(validator(...__asArray(validators))),
   msg: msg ?? `required object value`
 });
-const isArray = (msg) => ({
-  valid: $isArray,
-  msg: msg ?? `required array value`
-});
-const isArrayOf = (validators, msg) => ({
-  valid: $isArrayOf(validator(...__asArray(validators))),
-  msg: msg ?? `required array value`
-});
 const isTypedArray = (msg) => ({
   valid: $isTypedArray,
   msg: msg ?? `required typed array value`
@@ -118,30 +124,67 @@ const hasRequiredKeys = (keys, nonNullish = false, onlyKeys = false, msg) => ({
     if (onlyKeys) __onlyKeys(keys, x);
     return keys.every((k) => k in x && (nonNullish ? x[k] != null : true));
   },
-  msg: msg ?? `required keys: ${keys.join(", ")}${nonNullish ? " (must be non-nullish)" : ""}`
+  msg: msg ?? `required keys: ${keys.join(", ")}${nonNullish ? " (values must be non-nullish)" : ""}`
 });
 const hasKeysOf = (validators, onlyKeys = false) => ({
   valid: (x) => {
-    if (x == null) return false;
     if (onlyKeys) __onlyKeys(Object.keys(validators), x);
-    for (let [key, v] of Object.entries(validators)) {
+    for (let k in validators) {
       try {
-        validator(...__asArray(v))(x[key]);
+        validator(...__asArray(validators[k]))(x[k]);
       } catch (e) {
         throw new ValidationError(
-          (e.origMessage ?? e.message) + ` (key: ${key})`
+          (e.origMessage ?? e.message) + ` (key: ${k})`
         );
       }
     }
     return true;
   }
 });
+const hasRequiredPatternKeys = (pattern, nonNullish = false, onlyKeys = false, msg) => ({
+  valid: (x) => {
+    let found = false;
+    for (let k in x) {
+      if (pattern.test(k)) {
+        if (nonNullish && x[k] == null) return false;
+        found = true;
+      } else if (onlyKeys) {
+        __disallowedKey(k);
+      }
+    }
+    return found;
+  },
+  msg: msg ?? `required pattern keys: ${pattern}${nonNullish ? " (values must be non-nullish)" : ""}`
+});
+const hasPatternKeysOf = (pattern, validators, onlyKeys = false) => {
+  const fn = validator(...__asArray(validators));
+  return {
+    valid: (x) => {
+      for (let k in x) {
+        if (pattern.test(k)) {
+          try {
+            fn(x[k]);
+          } catch (e) {
+            throw new ValidationError(
+              (e.origMessage ?? e.message) + ` (key: ${k})`
+            );
+          }
+        } else if (onlyKeys) {
+          __disallowedKey(k);
+        }
+      }
+      return true;
+    }
+  };
+};
 const __onlyKeys = (keys, x) => {
   for (let k in x) {
-    if (!keys.includes(k))
-      throw new ValidationError(`key: ${k} not allowed`);
+    if (!keys.includes(k)) __disallowedKey(k);
   }
 };
+const __disallowedKey = (key) => {
+  throw new ValidationError(`key: ${key} not allowed`);
+};
 const isEnum = (opts, msg) => ({
   valid: (x) => opts.includes(x),
   msg: msg ?? `required value to be one of: ${opts.join(", ")}`
@@ -187,15 +230,20 @@ const matchesRegexp = (re, msg) => ({
   msg: msg ?? `doesn't match pattern`
 });
 export {
+  ALWAYS,
+  NEVER,
   ValidationError,
   every,
   hasKeysOf,
+  hasPatternKeysOf,
   hasRequiredKeys,
+  hasRequiredPatternKeys,
   isArray,
   isArrayOf,
   isBoolean,
   isDate,
   isEnum,
+  isFunction,
   isInRange,
   isLength,
   isMaxLength,