is-kit 1.6.3 → 1.7.0

package/README.md

@@ -166,7 +166,7 @@ Use `not(...)` when you want the complement of an existing guard or refinement.
 Use `struct` for plain-object payloads. Keys are required by default.
 
 ```ts
-import { isNumber, isString, optionalKey, struct } from 'is-kit';
+import { isNumber, isString, optional, optionalKey, struct } from 'is-kit';
 
 const isProfile = struct(
   {
@@ -176,14 +176,6 @@ const isProfile = struct(
   },
   { exact: true }
 );
-```
-
-`optionalKey(guard)` means the property may be missing.
-
-If the property must exist but the value may be `undefined`, use `optional(guard)` instead.
-
-```ts
-import { isString, optional, optionalKey, struct } from 'is-kit';
 
 const isConfig = struct({
   label: isString,
@@ -192,6 +184,12 @@ const isConfig = struct({
 });
 ```
 
+`optionalKey(guard)` means the property may be missing.
+
+Use `struct(schema, { exact: true })` when extra keys should be rejected.
+
+If the property must exist but the value may be `undefined`, use `optional(guard)` instead.
+
 ### 5. Validate arrays, tuples, maps, sets, and records
 
 Collection combinators keep your element guards reusable.
@@ -202,12 +200,14 @@ import {
   isNumber,
   isString,
   mapOf,
+  nonEmptyArrayOf,
   recordOf,
   setOf,
   tupleOf
 } from 'is-kit';
 
 const isStringArray = arrayOf(isString);
+const isNonEmptyTagList = nonEmptyArrayOf(isString);
 const isPoint = tupleOf(isNumber, isNumber);
 const isTagSet = setOf(isString);
 const isScoreMap = mapOf(isString, isNumber);
@@ -356,7 +356,7 @@ The library is organized around a few small building blocks:
 - **Primitives**: `isString`, `isNumber`, `isBoolean`, `isInteger`, ...
 - **Composition**: `define`, `and`, `andAll`, `or`, `not`, `oneOf`
 - **Object shapes**: `struct`, `optionalKey`, `hasKey`, `hasKeys`, `narrowKeyTo`
-- **Collections**: `arrayOf`, `tupleOf`, `setOf`, `mapOf`, `recordOf`
+- **Collections**: `arrayOf`, `nonEmptyArrayOf`, `tupleOf`, `setOf`, `mapOf`, `recordOf`
 - **Literals**: `oneOfValues`, `equals`, `equalsBy`, `equalsKey`
 - **Nullish handling**: `nullable`, `nonNull`, `nullish`, `optional`, `required`
 - **Result helpers**: `safeParse`, `safeParseWith`, `assert`

package/dist/index.d.mts

@@ -324,6 +324,13 @@ declare const isPrimitive: Guard<string | number | bigint | boolean | symbol | n
  * @returns Predicate narrowing to a readonly array of the guarded element type.
  */
 declare function arrayOf<F extends Predicate<unknown>>(elementGuard: F): Predicate<readonly GuardedOf<F>[]>;
+/**
+ * Validates a non-empty array where every element satisfies the provided guard.
+ *
+ * @param elementGuard Guard applied to each array element.
+ * @returns Predicate narrowing to a readonly non-empty array of the guarded element type.
+ */
+declare function nonEmptyArrayOf<F extends Predicate<unknown>>(elementGuard: F): Predicate<readonly [GuardedOf<F>, ...GuardedOf<F>[]]>;
 
 /**
  * Validates a set where every value satisfies the provided guard.
@@ -555,6 +562,49 @@ declare const hasKeys: <const KS extends readonly [PropertyKey, ...PropertyKey[]
  */
 declare function narrowKeyTo<A, K extends keyof A>(guard: Guard<A>, key: K): <const T extends A[K]>(target: T) => Predicate<A & Record<K, T>>;
 
+/**
+ * Checks whether every array element satisfies the provided predicate.
+ *
+ * @param values Array values to validate.
+ * @param predicate Predicate applied to each element.
+ * @returns Whether all elements satisfy `predicate`.
+ */
+declare const everyArrayValue: (values: readonly unknown[], predicate: (value: unknown) => boolean) => boolean;
+/**
+ * Checks whether a tuple matches the provided element predicates in order.
+ *
+ * @param values Tuple candidate values.
+ * @param predicates Predicates aligned to each tuple index.
+ * @returns Whether lengths match and each index passes.
+ */
+declare const everyTupleValue: (values: readonly unknown[], predicates: readonly ((value: unknown) => boolean)[]) => boolean;
+/**
+ * Checks whether every set value satisfies the provided predicate.
+ *
+ * @param values Set values to validate.
+ * @param predicate Predicate applied to each value.
+ * @returns Whether all set values satisfy `predicate`.
+ */
+declare const everySetValue: (values: ReadonlySet<unknown>, predicate: (value: unknown) => boolean) => boolean;
+/**
+ * Checks whether every map entry satisfies the provided key and value predicates.
+ *
+ * @param values Map values to validate.
+ * @param keyPredicate Predicate applied to each key.
+ * @param valuePredicate Predicate applied to each value.
+ * @returns Whether all keys and values satisfy their predicates.
+ */
+declare const everyMapEntry: (values: ReadonlyMap<unknown, unknown>, keyPredicate: (key: unknown) => boolean, valuePredicate: (value: unknown) => boolean) => boolean;
+/**
+ * Checks whether every own enumerable string key/value pair satisfies the provided predicates.
+ *
+ * @param values Plain object values to validate.
+ * @param keyPredicate Predicate applied to each enumerable own string key.
+ * @param valuePredicate Predicate applied to each corresponding value.
+ * @returns Whether all enumerable entries satisfy their predicates.
+ */
+declare const everyOwnEnumerableEntry: (values: Record<string, unknown>, keyPredicate: (key: string) => boolean, valuePredicate: (value: unknown) => boolean) => boolean;
+
 /**
  * Converts predicates to plain boolean predicates for iteration helpers.
  *
@@ -563,4 +613,4 @@ declare function narrowKeyTo<A, K extends keyof A>(guard: Guard<A>, key: K): <co
  */
 declare const toBooleanPredicates: <A>(predicates: readonly ((value: A) => boolean)[]) => ReadonlyArray<(value: A) => boolean>;
 
-export { type ChainResult, type Guard, type GuardedOf, type GuardedWithin, type InferSchema, type OptionalSchemaField, type OutOfGuards, type ParseResult, type Predicate, type Primitive, type Refine, type RefineChain, type Refinement, type Schema, type SchemaField, and, andAll, arrayOf, assert, define, equals, equalsBy, equalsKey, guardIn, hasKey, hasKeys, isArray, isArrayBuffer, isAsyncIterable, isBigInt, isBlob, isBoolean, isDataView, isDate, isError, isFiniteNumber, isFunction, isInfiniteNumber, isInstanceOf, isInteger, isIterable, isMap, isNaN, isNegative, isNull, isNumber, isNumberPrimitive, isObject, isPlainObject, isPositive, isPrimitive, isPromiseLike, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isURL, isUndefined, isWeakMap, isWeakSet, isZero, mapOf, narrowKeyTo, nonNull, not, nullable, nullish, oneOf, oneOfValues, optional, optionalKey, or, predicateToRefine, recordOf, required, safeParse, safeParseWith, setOf, struct, toBooleanPredicates, tupleOf };
+export { type ChainResult, type Guard, type GuardedOf, type GuardedWithin, type InferSchema, type OptionalSchemaField, type OutOfGuards, type ParseResult, type Predicate, type Primitive, type Refine, type RefineChain, type Refinement, type Schema, type SchemaField, and, andAll, arrayOf, assert, define, equals, equalsBy, equalsKey, everyArrayValue, everyMapEntry, everyOwnEnumerableEntry, everySetValue, everyTupleValue, guardIn, hasKey, hasKeys, isArray, isArrayBuffer, isAsyncIterable, isBigInt, isBlob, isBoolean, isDataView, isDate, isError, isFiniteNumber, isFunction, isInfiniteNumber, isInstanceOf, isInteger, isIterable, isMap, isNaN, isNegative, isNull, isNumber, isNumberPrimitive, isObject, isPlainObject, isPositive, isPrimitive, isPromiseLike, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isURL, isUndefined, isWeakMap, isWeakSet, isZero, mapOf, narrowKeyTo, nonEmptyArrayOf, nonNull, not, nullable, nullish, oneOf, oneOfValues, optional, optionalKey, or, predicateToRefine, recordOf, required, safeParse, safeParseWith, setOf, struct, toBooleanPredicates, tupleOf };

package/dist/index.d.ts

@@ -324,6 +324,13 @@ declare const isPrimitive: Guard<string | number | bigint | boolean | symbol | n
  * @returns Predicate narrowing to a readonly array of the guarded element type.
  */
 declare function arrayOf<F extends Predicate<unknown>>(elementGuard: F): Predicate<readonly GuardedOf<F>[]>;
+/**
+ * Validates a non-empty array where every element satisfies the provided guard.
+ *
+ * @param elementGuard Guard applied to each array element.
+ * @returns Predicate narrowing to a readonly non-empty array of the guarded element type.
+ */
+declare function nonEmptyArrayOf<F extends Predicate<unknown>>(elementGuard: F): Predicate<readonly [GuardedOf<F>, ...GuardedOf<F>[]]>;
 
 /**
  * Validates a set where every value satisfies the provided guard.
@@ -555,6 +562,49 @@ declare const hasKeys: <const KS extends readonly [PropertyKey, ...PropertyKey[]
  */
 declare function narrowKeyTo<A, K extends keyof A>(guard: Guard<A>, key: K): <const T extends A[K]>(target: T) => Predicate<A & Record<K, T>>;
 
+/**
+ * Checks whether every array element satisfies the provided predicate.
+ *
+ * @param values Array values to validate.
+ * @param predicate Predicate applied to each element.
+ * @returns Whether all elements satisfy `predicate`.
+ */
+declare const everyArrayValue: (values: readonly unknown[], predicate: (value: unknown) => boolean) => boolean;
+/**
+ * Checks whether a tuple matches the provided element predicates in order.
+ *
+ * @param values Tuple candidate values.
+ * @param predicates Predicates aligned to each tuple index.
+ * @returns Whether lengths match and each index passes.
+ */
+declare const everyTupleValue: (values: readonly unknown[], predicates: readonly ((value: unknown) => boolean)[]) => boolean;
+/**
+ * Checks whether every set value satisfies the provided predicate.
+ *
+ * @param values Set values to validate.
+ * @param predicate Predicate applied to each value.
+ * @returns Whether all set values satisfy `predicate`.
+ */
+declare const everySetValue: (values: ReadonlySet<unknown>, predicate: (value: unknown) => boolean) => boolean;
+/**
+ * Checks whether every map entry satisfies the provided key and value predicates.
+ *
+ * @param values Map values to validate.
+ * @param keyPredicate Predicate applied to each key.
+ * @param valuePredicate Predicate applied to each value.
+ * @returns Whether all keys and values satisfy their predicates.
+ */
+declare const everyMapEntry: (values: ReadonlyMap<unknown, unknown>, keyPredicate: (key: unknown) => boolean, valuePredicate: (value: unknown) => boolean) => boolean;
+/**
+ * Checks whether every own enumerable string key/value pair satisfies the provided predicates.
+ *
+ * @param values Plain object values to validate.
+ * @param keyPredicate Predicate applied to each enumerable own string key.
+ * @param valuePredicate Predicate applied to each corresponding value.
+ * @returns Whether all enumerable entries satisfy their predicates.
+ */
+declare const everyOwnEnumerableEntry: (values: Record<string, unknown>, keyPredicate: (key: string) => boolean, valuePredicate: (value: unknown) => boolean) => boolean;
+
 /**
  * Converts predicates to plain boolean predicates for iteration helpers.
  *
@@ -563,4 +613,4 @@ declare function narrowKeyTo<A, K extends keyof A>(guard: Guard<A>, key: K): <co
  */
 declare const toBooleanPredicates: <A>(predicates: readonly ((value: A) => boolean)[]) => ReadonlyArray<(value: A) => boolean>;
 
-export { type ChainResult, type Guard, type GuardedOf, type GuardedWithin, type InferSchema, type OptionalSchemaField, type OutOfGuards, type ParseResult, type Predicate, type Primitive, type Refine, type RefineChain, type Refinement, type Schema, type SchemaField, and, andAll, arrayOf, assert, define, equals, equalsBy, equalsKey, guardIn, hasKey, hasKeys, isArray, isArrayBuffer, isAsyncIterable, isBigInt, isBlob, isBoolean, isDataView, isDate, isError, isFiniteNumber, isFunction, isInfiniteNumber, isInstanceOf, isInteger, isIterable, isMap, isNaN, isNegative, isNull, isNumber, isNumberPrimitive, isObject, isPlainObject, isPositive, isPrimitive, isPromiseLike, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isURL, isUndefined, isWeakMap, isWeakSet, isZero, mapOf, narrowKeyTo, nonNull, not, nullable, nullish, oneOf, oneOfValues, optional, optionalKey, or, predicateToRefine, recordOf, required, safeParse, safeParseWith, setOf, struct, toBooleanPredicates, tupleOf };
+export { type ChainResult, type Guard, type GuardedOf, type GuardedWithin, type InferSchema, type OptionalSchemaField, type OutOfGuards, type ParseResult, type Predicate, type Primitive, type Refine, type RefineChain, type Refinement, type Schema, type SchemaField, and, andAll, arrayOf, assert, define, equals, equalsBy, equalsKey, everyArrayValue, everyMapEntry, everyOwnEnumerableEntry, everySetValue, everyTupleValue, guardIn, hasKey, hasKeys, isArray, isArrayBuffer, isAsyncIterable, isBigInt, isBlob, isBoolean, isDataView, isDate, isError, isFiniteNumber, isFunction, isInfiniteNumber, isInstanceOf, isInteger, isIterable, isMap, isNaN, isNegative, isNull, isNumber, isNumberPrimitive, isObject, isPlainObject, isPositive, isPrimitive, isPromiseLike, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isURL, isUndefined, isWeakMap, isWeakSet, isZero, mapOf, narrowKeyTo, nonEmptyArrayOf, nonNull, not, nullable, nullish, oneOf, oneOfValues, optional, optionalKey, or, predicateToRefine, recordOf, required, safeParse, safeParseWith, setOf, struct, toBooleanPredicates, tupleOf };

package/dist/index.js

@@ -28,6 +28,11 @@ __export(index_exports, {
   equals: () => equals,
   equalsBy: () => equalsBy,
   equalsKey: () => equalsKey,
+  everyArrayValue: () => everyArrayValue,
+  everyMapEntry: () => everyMapEntry,
+  everyOwnEnumerableEntry: () => everyOwnEnumerableEntry,
+  everySetValue: () => everySetValue,
+  everyTupleValue: () => everyTupleValue,
   guardIn: () => guardIn,
   hasKey: () => hasKey,
   hasKeys: () => hasKeys,
@@ -70,6 +75,7 @@ __export(index_exports, {
   isZero: () => isZero,
   mapOf: () => mapOf,
   narrowKeyTo: () => narrowKeyTo,
+  nonEmptyArrayOf: () => nonEmptyArrayOf,
   nonNull: () => nonNull,
   not: () => not,
   nullable: () => nullable,
@@ -106,6 +112,39 @@ function assert(fn, value, message) {
   throw new Error(message ?? DEFAULT_ASSERT_MESSAGE);
 }
 
+// src/utils/guard-collections.ts
+var everyArrayValue = (values, predicate) => {
+  for (const value of values) {
+    if (!predicate(value)) return false;
+  }
+  return true;
+};
+var everyTupleValue = (values, predicates) => {
+  if (values.length !== predicates.length) return false;
+  for (const [index, predicate] of predicates.entries()) {
+    if (!predicate(values[index])) return false;
+  }
+  return true;
+};
+var everySetValue = (values, predicate) => {
+  for (const value of values) {
+    if (!predicate(value)) return false;
+  }
+  return true;
+};
+var everyMapEntry = (values, keyPredicate, valuePredicate) => {
+  for (const [key, value] of values) {
+    if (!keyPredicate(key) || !valuePredicate(value)) return false;
+  }
+  return true;
+};
+var everyOwnEnumerableEntry = (values, keyPredicate, valuePredicate) => {
+  for (const key of Object.keys(values)) {
+    if (!keyPredicate(key) || !valuePredicate(values[key])) return false;
+  }
+  return true;
+};
+
 // src/utils/to-boolean-predicates.ts
 var toBooleanPredicates = (predicates) => predicates;
 
@@ -145,20 +184,22 @@ function applyRefinements(value, steps) {
 }
 
 // src/core/nullish.ts
+var allowWhen = (acceptedValue, predicate) => (value) => acceptedValue(value) || predicate(value);
+var requireWhen = (rejectedValue, predicate) => (value) => !rejectedValue(value) && predicate(value);
 function nullable(fn) {
-  return (value) => value === null || fn(value);
+  return allowWhen((value) => value === null, fn);
 }
 function nonNull(fn) {
-  return (value) => value !== null && fn(value);
+  return requireWhen((value) => value === null, fn);
 }
 function nullish(fn) {
-  return (value) => value == null || fn(value);
+  return allowWhen((value) => value == null, fn);
 }
 function optional(fn) {
-  return (value) => value === void 0 || fn(value);
+  return allowWhen((value) => value === void 0, fn);
 }
 function required(fn) {
-  return (value) => value !== void 0 && fn(value);
+  return requireWhen((value) => value === void 0, fn);
 }
 
 // src/utils/object-tags.ts
@@ -251,7 +292,7 @@ function equalsBy(guard, selector) {
 }
 function equalsKey(key, target) {
   const hasMatchingKey = define((input) => {
-    return isObject(input) && Object.prototype.hasOwnProperty.call(input, key) && Object.is(input[key], target);
+    return isObject(input) && Object.hasOwn(input, key) && Object.is(input[key], target);
   });
   return (input) => hasMatchingKey(input);
 }
@@ -308,69 +349,50 @@ var isPrimitive = or(
 
 // src/core/combinators/array.ts
 function arrayOf(elementGuard) {
-  return define((input) => {
-    if (!Array.isArray(input)) return false;
-    for (const element of input) {
-      if (!elementGuard(element)) return false;
-    }
-    return true;
-  });
+  return define(
+    (input) => Array.isArray(input) && everyArrayValue(input, elementGuard)
+  );
+}
+function nonEmptyArrayOf(elementGuard) {
+  return define(
+    (input) => Array.isArray(input) && input.length > 0 && everyArrayValue(input, elementGuard)
+  );
 }
 
 // src/core/combinators/set.ts
 function setOf(valueGuard) {
-  return define((input) => {
-    if (!isSet(input)) return false;
-    for (const value of input.values()) {
-      if (!valueGuard(value)) return false;
-    }
-    return true;
-  });
+  return define(
+    (input) => isSet(input) && everySetValue(input, valueGuard)
+  );
 }
 
 // src/core/combinators/map.ts
 function mapOf(keyGuard, valueGuard) {
-  return define((input) => {
-    if (!isMap(input)) return false;
-    for (const [key, value] of input.entries()) {
-      if (!keyGuard(key)) return false;
-      if (!valueGuard(value)) return false;
-    }
-    return true;
-  });
+  return define(
+    (input) => isMap(input) && everyMapEntry(input, keyGuard, valueGuard)
+  );
 }
 
 // src/core/combinators/tuple.ts
 function tupleOf(...guards) {
-  return define((input) => {
-    return Array.isArray(input) && input.length === guards.length && guards.every(
-      (guard, index) => guard(input[index])
-    );
-  });
+  return define(
+    (input) => Array.isArray(input) && everyTupleValue(input, guards)
+  );
 }
 
 // src/core/combinators/one-of.ts
 function oneOf(...guards) {
-  const predicates = toBooleanPredicates(guards);
-  return (input) => predicates.some((guard) => guard(input));
+  return or(...guards);
 }
 
 // src/core/combinators/record.ts
 function recordOf(keyFunction, valueFunction) {
-  return (input) => {
-    if (!isPlainObject(input)) return false;
-    const obj = input;
-    for (const key of Object.keys(obj)) {
-      if (!keyFunction(key)) return false;
-      const value = obj[key];
-      if (!valueFunction(value)) return false;
-    }
-    return true;
-  };
+  return define(
+    (input) => isPlainObject(input) && everyOwnEnumerableEntry(input, keyFunction, valueFunction)
+  );
 }
 
 // src/core/combinators/struct.ts
-var hasOwnKey = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
 var isOptionalSchemaField = define(
   // WHY: Optional fields are represented as a small tagged object so `struct`
   // can distinguish schema metadata from plain predicate functions up front.
@@ -379,12 +401,12 @@ var isOptionalSchemaField = define(
 var hasRequiredKeys = (obj, entries) => (
   // WHY: Required fields must be own properties; inherited values should not
   // satisfy a schema because `struct` models object payload shape, not prototype chains.
-  entries.every(([key, guard]) => hasOwnKey(obj, key) && guard(obj[key]))
+  entries.every(([key, guard]) => Object.hasOwn(obj, key) && guard(obj[key]))
 );
 var hasValidOptionalKeys = (obj, entries) => (
   // WHY: Optional keys are validated only when present. Missing keys stay valid
   // without forcing callers to encode `undefined` into the value guard.
-  entries.every(([key, guard]) => !hasOwnKey(obj, key) || guard(obj[key]))
+  entries.every(([key, guard]) => !Object.hasOwn(obj, key) || guard(obj[key]))
 );
 var hasOnlyAllowedKeys = (obj, allowed) => Object.keys(obj).every((key) => allowed.has(key));
 function optionalKey(guard) {
@@ -450,14 +472,14 @@ function oneOfValues(...args) {
 
 // src/core/key.ts
 var hasKey = (key) => define(
-  (input) => isObject(input) && Object.prototype.hasOwnProperty.call(input, key)
+  (input) => isObject(input) && Object.hasOwn(input, key)
 );
 var hasKeys = (...keys) => {
   if (keys.length === 0) {
     return define(() => false);
   }
   return define(
-    (input) => isObject(input) && keys.every((key) => Object.prototype.hasOwnProperty.call(input, key))
+    (input) => isObject(input) && keys.every((key) => Object.hasOwn(input, key))
   );
 };
 function narrowKeyTo(guard, key) {
@@ -478,6 +500,11 @@ function narrowKeyTo(guard, key) {
   equals,
   equalsBy,
   equalsKey,
+  everyArrayValue,
+  everyMapEntry,
+  everyOwnEnumerableEntry,
+  everySetValue,
+  everyTupleValue,
   guardIn,
   hasKey,
   hasKeys,
@@ -520,6 +547,7 @@ function narrowKeyTo(guard, key) {
   isZero,
   mapOf,
   narrowKeyTo,
+  nonEmptyArrayOf,
   nonNull,
   not,
   nullable,

package/dist/index.mjs

@@ -13,6 +13,39 @@ function assert(fn, value, message) {
   throw new Error(message ?? DEFAULT_ASSERT_MESSAGE);
 }
 
+// src/utils/guard-collections.ts
+var everyArrayValue = (values, predicate) => {
+  for (const value of values) {
+    if (!predicate(value)) return false;
+  }
+  return true;
+};
+var everyTupleValue = (values, predicates) => {
+  if (values.length !== predicates.length) return false;
+  for (const [index, predicate] of predicates.entries()) {
+    if (!predicate(values[index])) return false;
+  }
+  return true;
+};
+var everySetValue = (values, predicate) => {
+  for (const value of values) {
+    if (!predicate(value)) return false;
+  }
+  return true;
+};
+var everyMapEntry = (values, keyPredicate, valuePredicate) => {
+  for (const [key, value] of values) {
+    if (!keyPredicate(key) || !valuePredicate(value)) return false;
+  }
+  return true;
+};
+var everyOwnEnumerableEntry = (values, keyPredicate, valuePredicate) => {
+  for (const key of Object.keys(values)) {
+    if (!keyPredicate(key) || !valuePredicate(values[key])) return false;
+  }
+  return true;
+};
+
 // src/utils/to-boolean-predicates.ts
 var toBooleanPredicates = (predicates) => predicates;
 
@@ -52,20 +85,22 @@ function applyRefinements(value, steps) {
 }
 
 // src/core/nullish.ts
+var allowWhen = (acceptedValue, predicate) => (value) => acceptedValue(value) || predicate(value);
+var requireWhen = (rejectedValue, predicate) => (value) => !rejectedValue(value) && predicate(value);
 function nullable(fn) {
-  return (value) => value === null || fn(value);
+  return allowWhen((value) => value === null, fn);
 }
 function nonNull(fn) {
-  return (value) => value !== null && fn(value);
+  return requireWhen((value) => value === null, fn);
 }
 function nullish(fn) {
-  return (value) => value == null || fn(value);
+  return allowWhen((value) => value == null, fn);
 }
 function optional(fn) {
-  return (value) => value === void 0 || fn(value);
+  return allowWhen((value) => value === void 0, fn);
 }
 function required(fn) {
-  return (value) => value !== void 0 && fn(value);
+  return requireWhen((value) => value === void 0, fn);
 }
 
 // src/utils/object-tags.ts
@@ -158,7 +193,7 @@ function equalsBy(guard, selector) {
 }
 function equalsKey(key, target) {
   const hasMatchingKey = define((input) => {
-    return isObject(input) && Object.prototype.hasOwnProperty.call(input, key) && Object.is(input[key], target);
+    return isObject(input) && Object.hasOwn(input, key) && Object.is(input[key], target);
   });
   return (input) => hasMatchingKey(input);
 }
@@ -215,69 +250,50 @@ var isPrimitive = or(
 
 // src/core/combinators/array.ts
 function arrayOf(elementGuard) {
-  return define((input) => {
-    if (!Array.isArray(input)) return false;
-    for (const element of input) {
-      if (!elementGuard(element)) return false;
-    }
-    return true;
-  });
+  return define(
+    (input) => Array.isArray(input) && everyArrayValue(input, elementGuard)
+  );
+}
+function nonEmptyArrayOf(elementGuard) {
+  return define(
+    (input) => Array.isArray(input) && input.length > 0 && everyArrayValue(input, elementGuard)
+  );
 }
 
 // src/core/combinators/set.ts
 function setOf(valueGuard) {
-  return define((input) => {
-    if (!isSet(input)) return false;
-    for (const value of input.values()) {
-      if (!valueGuard(value)) return false;
-    }
-    return true;
-  });
+  return define(
+    (input) => isSet(input) && everySetValue(input, valueGuard)
+  );
 }
 
 // src/core/combinators/map.ts
 function mapOf(keyGuard, valueGuard) {
-  return define((input) => {
-    if (!isMap(input)) return false;
-    for (const [key, value] of input.entries()) {
-      if (!keyGuard(key)) return false;
-      if (!valueGuard(value)) return false;
-    }
-    return true;
-  });
+  return define(
+    (input) => isMap(input) && everyMapEntry(input, keyGuard, valueGuard)
+  );
 }
 
 // src/core/combinators/tuple.ts
 function tupleOf(...guards) {
-  return define((input) => {
-    return Array.isArray(input) && input.length === guards.length && guards.every(
-      (guard, index) => guard(input[index])
-    );
-  });
+  return define(
+    (input) => Array.isArray(input) && everyTupleValue(input, guards)
+  );
 }
 
 // src/core/combinators/one-of.ts
 function oneOf(...guards) {
-  const predicates = toBooleanPredicates(guards);
-  return (input) => predicates.some((guard) => guard(input));
+  return or(...guards);
 }
 
 // src/core/combinators/record.ts
 function recordOf(keyFunction, valueFunction) {
-  return (input) => {
-    if (!isPlainObject(input)) return false;
-    const obj = input;
-    for (const key of Object.keys(obj)) {
-      if (!keyFunction(key)) return false;
-      const value = obj[key];
-      if (!valueFunction(value)) return false;
-    }
-    return true;
-  };
+  return define(
+    (input) => isPlainObject(input) && everyOwnEnumerableEntry(input, keyFunction, valueFunction)
+  );
 }
 
 // src/core/combinators/struct.ts
-var hasOwnKey = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
 var isOptionalSchemaField = define(
   // WHY: Optional fields are represented as a small tagged object so `struct`
   // can distinguish schema metadata from plain predicate functions up front.
@@ -286,12 +302,12 @@ var isOptionalSchemaField = define(
 var hasRequiredKeys = (obj, entries) => (
   // WHY: Required fields must be own properties; inherited values should not
   // satisfy a schema because `struct` models object payload shape, not prototype chains.
-  entries.every(([key, guard]) => hasOwnKey(obj, key) && guard(obj[key]))
+  entries.every(([key, guard]) => Object.hasOwn(obj, key) && guard(obj[key]))
 );
 var hasValidOptionalKeys = (obj, entries) => (
   // WHY: Optional keys are validated only when present. Missing keys stay valid
   // without forcing callers to encode `undefined` into the value guard.
-  entries.every(([key, guard]) => !hasOwnKey(obj, key) || guard(obj[key]))
+  entries.every(([key, guard]) => !Object.hasOwn(obj, key) || guard(obj[key]))
 );
 var hasOnlyAllowedKeys = (obj, allowed) => Object.keys(obj).every((key) => allowed.has(key));
 function optionalKey(guard) {
@@ -357,14 +373,14 @@ function oneOfValues(...args) {
 
 // src/core/key.ts
 var hasKey = (key) => define(
-  (input) => isObject(input) && Object.prototype.hasOwnProperty.call(input, key)
+  (input) => isObject(input) && Object.hasOwn(input, key)
 );
 var hasKeys = (...keys) => {
   if (keys.length === 0) {
     return define(() => false);
   }
   return define(
-    (input) => isObject(input) && keys.every((key) => Object.prototype.hasOwnProperty.call(input, key))
+    (input) => isObject(input) && keys.every((key) => Object.hasOwn(input, key))
   );
 };
 function narrowKeyTo(guard, key) {
@@ -384,6 +400,11 @@ export {
   equals,
   equalsBy,
   equalsKey,
+  everyArrayValue,
+  everyMapEntry,
+  everyOwnEnumerableEntry,
+  everySetValue,
+  everyTupleValue,
   guardIn,
   hasKey,
   hasKeys,
@@ -426,6 +447,7 @@ export {
   isZero,
   mapOf,
   narrowKeyTo,
+  nonEmptyArrayOf,
   nonNull,
   not,
   nullable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "is-kit",
-  "version": "1.6.3",
+  "version": "1.7.0",
   "description": "Make 'isXXX' easier. Let's make your code type safe and more readable!",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",