@thi.ng/validate 0.1.0 → 0.2.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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thi.ng/validate",
-	"version": "0.1.0",
+	"version": "0.2.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": "c0d6e8f2517c5edc745774266f3cbca586b03d5e"
 }

package/validators.d.ts

@@ -56,20 +56,46 @@ 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.
+ * 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.
  *
@@ -98,8 +124,34 @@ export declare const isObject: (msg?: Validator["msg"]) => Validator;
 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;
 /**
  * Returns validator to check if value is one of the given options.
  *

package/validators.js

@@ -8,6 +8,7 @@ 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) => {
@@ -20,20 +21,34 @@ const validator = (...validators) => (x) => {
   }
   return true;
 };
-const optional = ({ coerce, valid, msg }) => ({
+const __asArray = (v) => $isArray(v) ? v : [v];
+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 +58,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`
@@ -87,16 +105,25 @@ const isArrayOf = (validators, msg) => ({
   valid: $isArrayOf(validator(...__asArray(validators))),
   msg: msg ?? `required array value`
 });
-const hasRequiredKeys = (keys, msg) => ({
+const isTypedArray = (msg) => ({
+  valid: $isTypedArray,
+  msg: msg ?? `required typed array value`
+});
+const isU8Array = (msg) => ({
+  valid: (x) => x instanceof Uint8Array,
+  msg: msg ?? `required byte array value`
+});
+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 ? " (must be non-nullish)" : ""}`
 });
-const hasKeysOf = (validators) => ({
+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)) {
       try {
         validator(...__asArray(v))(x[key]);
@@ -109,6 +136,12 @@ const hasKeysOf = (validators) => ({
     return true;
   }
 });
+const __onlyKeys = (keys, x) => {
+  for (let k in x) {
+    if (!keys.includes(k))
+      throw new ValidationError(`key: ${k} not allowed`);
+  }
+};
 const isEnum = (opts, msg) => ({
   valid: (x) => opts.includes(x),
   msg: msg ?? `required value to be one of: ${opts.join(", ")}`
@@ -155,6 +188,7 @@ const matchesRegexp = (re, msg) => ({
 });
 export {
   ValidationError,
+  every,
   hasKeysOf,
   hasRequiredKeys,
   isArray,
@@ -177,9 +211,12 @@ export {
   isPositive,
   isRegExp,
   isString,
+  isTypedArray,
+  isU8Array,
   isUndefined,
   matchesRegexp,
-  oneOf,
+  not,
   optional,
+  some,
   validator
 };