@thi.ng/validate 0.1.0 → 0.3.0

package/README.md

@@ -90,13 +90,17 @@ try {
 - [`isPositive()`](https://docs.thi.ng/umbrella/validate/functions/isPositive.html)
 - [`isRegExp()`](https://docs.thi.ng/umbrella/validate/functions/isRegExp.html)
 - [`isString()`](https://docs.thi.ng/umbrella/validate/functions/isString.html)
+- [`isTypedArray()`](https://docs.thi.ng/umbrella/validate/functions/isTypedArray.html)
+- [`isU8Array()`](https://docs.thi.ng/umbrella/validate/functions/isU8Array.html)
 - [`isUndefined()`](https://docs.thi.ng/umbrella/validate/functions/isUndefined.html)
 - [`matchesRegexp()`](https://docs.thi.ng/umbrella/validate/functions/matchesRegexp.html)
 
 ### Combinators
 
-- [`oneOf()`](https://docs.thi.ng/umbrella/validate/functions/oneOf.html)
+- [`every()`](https://docs.thi.ng/umbrella/validate/functions/every.html)
+- [`not()`](https://docs.thi.ng/umbrella/validate/functions/not.html)
 - [`optional()`](https://docs.thi.ng/umbrella/validate/functions/optional.html)
+- [`some()`](https://docs.thi.ng/umbrella/validate/functions/some.html)
 
 ## Status
 
@@ -130,7 +134,7 @@ For Node.js REPL:
 const val = await import("@thi.ng/validate");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1021 bytes
+Package sizes (brotli'd, pre-treeshake): ESM: 1.19 KB
 
 ## Dependencies
 

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.1.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": "92be63f24030506f09d6d156804da2798c381dc4"
+	"gitHead": "7e7cd1f3214bf256630f87efaa1f2f5f53454133"
 }

package/validators.d.ts

@@ -56,20 +56,54 @@ export declare const ValidationError: {
  */
 export declare const validator: (...validators: Validator[]) => (x: any) => boolean;
 /**
- * Higher order validator. Takes an existing validator and returns an augmented
- * version which also allows value to be nullish.
+ * 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
+ * given, they're first combined via {@link every}.
+ *
+ * @param first
+ * @param rest
+ */
+export declare const optional: (first: Validator, ...rest: Validator[]) => Validator;
+/**
+ * Higher order validator. Takes existing validator and optional error message.
+ * Returns an augmented validator which applies logical negation of the original
+ * validator.
  *
  * @param validator
+ * @param msg
  */
-export declare const optional: ({ coerce, valid, msg }: Validator) => Validator;
+export declare const not: ({ coerce, valid, msg: $msg }: Validator, msg?: Validator["msg"]) => Validator;
 /**
- * Higher order validator. Takes a numer of validators and returns a new one
- * which will apply the validators in given order, but return when the first one
- * succeeds and only fails if all of the validators failed.
+ * Higher order validator. Takes one or more validators and returns a new one
+ * which will apply the validators in given order, and return successfully with
+ * the first one passed and only fails if **none** of the validators passed.
  *
- * @param validators
+ * @param first
+ * @param rest
  */
-export declare const oneOf: (validators: (Validator | Validator[])[]) => Validator;
+export declare const some: (first: Validator | Validator[], ...rest: (Validator | Validator[])[]) => Validator;
+/**
+ * Higher order validator. Takes a number of validators and returns a new one
+ * which will apply the validators in given order, and only returns success if
+ * **all** of the validators passed.
+ *
+ * @remarks
+ * Essentially the same as {@link validator}, but returns a {@link Validator}
+ * object (presumably for further composition) instead of a predicate function
+ * to apply directly.
+ *
+ * @param first
+ * @param rest
+ */
+export declare const every: (first: Validator, ...rest: Validator[]) => Validator;
 /**
  * Returns validator to check if value is undefined.
  *
@@ -82,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
@@ -96,12 +138,39 @@ 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 hasRequiredKeys: (keys: string[], msg?: Validator["msg"]) => Validator;
-export declare const hasKeysOf: (validators: Record<PropertyKey, Validator | Validator[]>) => Validator;
+export declare const isTypedArray: (msg?: Validator["msg"]) => Validator;
+/**
+ * Returns validator to check if value is a `Uint8Array`.
+ *
+ * @param msg
+ */
+export declare const isU8Array: (msg?: Validator["msg"]) => Validator;
+/**
+ * Returns validator to ensure given `keys` are present in an object, optionally
+ * also checks their values are `nonNullish` (default: false). If `onlyKeys` is
+ * true (default: false), the validator also checks that no other keys are
+ * defined in the object.
+ *
+ * @param keys
+ * @param nonNullish
+ * @param onlyKeys
+ * @param msg
+ */
+export declare const hasRequiredKeys: (keys: string[], nonNullish?: boolean, onlyKeys?: boolean, msg?: Validator["msg"]) => Validator;
+/**
+ * Takes object of validators to check values of different keys in an object.
+ * Returns validator which applies all checks, optionally also ensures no other
+ * keys are defined (if `onlyKeys` is true, default: false).
+ *
+ * @param validators
+ * @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,38 +2,55 @@ 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";
 import { isRegExp as $isRegExp } from "@thi.ng/checks/is-regexp";
 import { isString as $isString } from "@thi.ng/checks/is-string";
+import { isTypedArray as $isTypedArray } from "@thi.ng/checks/is-typedarray";
 import { defError } from "@thi.ng/errors/deferror";
 const ValidationError = defError(() => `validation error`);
 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 optional = ({ coerce, valid, msg }) => ({
+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 {
+    coerce,
+    valid: (x) => x == null || valid(x),
+    msg
+  };
+};
+const not = ({ coerce, valid, msg: $msg }, msg) => ({
   coerce,
-  valid: (x) => x == null || valid(x),
-  msg
+  valid: (x) => {
+    try {
+      return !valid(x);
+    } catch (e) {
+      return true;
+    }
+  },
+  msg: msg ?? $msg
 });
-const __asArray = (v) => $isArray(v) ? v : [v];
-const oneOf = (validators) => {
+const some = (first, ...rest) => {
   let lastMsg;
   return {
     valid: (x) => {
       lastMsg = void 0;
-      for (let v of validators) {
+      for (let $v of [first, ...rest]) {
         try {
-          return validator(...__asArray(v))(x);
+          return validator(...__asArray($v))(x);
         } catch (e) {
           lastMsg = e.origMessage ?? e.message;
         }
@@ -43,6 +60,9 @@ const oneOf = (validators) => {
     msg: () => lastMsg ?? "invalid value"
   };
 };
+const every = (first, ...rest) => ({
+  valid: (x) => validator(first, ...rest)(x)
+});
 const isUndefined = (msg) => ({
   valid: (x) => x === void 0,
   msg: msg ?? `expected undefined value`
@@ -51,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`
@@ -67,48 +95,96 @@ 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 isTypedArray = (msg) => ({
+  valid: $isTypedArray,
+  msg: msg ?? `required typed array value`
 });
-const isArrayOf = (validators, msg) => ({
-  valid: $isArrayOf(validator(...__asArray(validators))),
-  msg: msg ?? `required array value`
+const isU8Array = (msg) => ({
+  valid: (x) => x instanceof Uint8Array,
+  msg: msg ?? `required byte array value`
 });
-const hasRequiredKeys = (keys, msg) => ({
+const hasRequiredKeys = (keys, nonNullish = false, onlyKeys = false, msg) => ({
   valid: (x) => {
-    const $keys = new Set(Object.keys(x));
-    return keys.every((k) => $keys.has(k));
+    if (onlyKeys) __onlyKeys(keys, x);
+    return keys.every((k) => k in x && (nonNullish ? x[k] != null : true));
   },
-  msg: msg ?? `required keys: ${keys.join(", ")}`
+  msg: msg ?? `required keys: ${keys.join(", ")}${nonNullish ? " (values must be non-nullish)" : ""}`
 });
-const hasKeysOf = (validators) => ({
+const hasKeysOf = (validators, onlyKeys = false) => ({
   valid: (x) => {
-    if (x == null) return false;
-    for (let [key, v] of Object.entries(validators)) {
+    if (onlyKeys) __onlyKeys(Object.keys(validators), x);
+    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)) __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(", ")}`
@@ -154,14 +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,
@@ -177,9 +259,12 @@ export {
   isPositive,
   isRegExp,
   isString,
+  isTypedArray,
+  isU8Array,
   isUndefined,
   matchesRegexp,
-  oneOf,
+  not,
   optional,
+  some,
   validator
 };