is-kit 1.4.2 → 1.6.0

package/README.md

@@ -69,9 +69,11 @@ import {
   and,
   or,
   not,
+  mapOf,
+  optionalKey,
+  setOf,
   struct,
   oneOfValues,
-  optional,
   isNumber,
   isString,
   predicateToRefine
@@ -90,11 +92,13 @@ const isOther = not(isShortOrPositive);
 
 // Define object shapes
 const isRole = oneOfValues(['admin', 'member'] as const);
+const isTags = setOf(isString);
+const isScores = mapOf(isString, isNumber);
 const isUser = struct({
   id: isPositive, // number > 0
   name: isString, // string
   role: isRole, // 'admin' | 'member'
-  nickname: optional(isShortString) // string <= 3 | undefined
+  nickname: optionalKey(isShortString) // key may be absent; when present, string <= 3
 });
 
 // Use them
@@ -102,6 +106,8 @@ isPositive(3); // true
 isShortOrPositive('foo'); // true
 isShortOrPositive(false); // false
 isOther('x'); // true
+isTags(new Set(['new', 'vip'])); // true
+isScores(new Map([['math', 98]])); // true
 
 const maybeUser: unknown = { id: 7, name: 'Rin', role: 'admin' };
 if (isUser(maybeUser)) {
@@ -111,10 +117,41 @@ if (isUser(maybeUser)) {
 }
 ```
 
+Use `optionalKey(...)` for key-level optional properties in `struct`.
+Use `optional(...)` when the key exists but the value itself may be `undefined`.
+Combine them as `optionalKey(optional(guard))` when both are allowed.
+
 Composed guards stay reusable:
 `isPositive` can be used standalone or as part of a `struct` definition.
 
-When validating complex shapes, reach for `struct` — and friends like `arrayOf`, `recordOf`, or `oneOf`.
+When validating complex shapes, reach for `struct` and collection
+combinators like `arrayOf`, `setOf`, `mapOf`, `recordOf`, or `oneOf`.
+
+### Collection combinators
+
+Use `arrayOf`, `setOf`, `mapOf`, and `recordOf` to validate homogeneous
+collections while preserving precise readonly types.
+
+```ts
+import {
+  arrayOf,
+  mapOf,
+  recordOf,
+  setOf,
+  isNumber,
+  isString
+} from 'is-kit';
+
+const isStringArray = arrayOf(isString);
+const isStringSet = setOf(isString);
+const isScoreMap = mapOf(isString, isNumber);
+const isStringRecord = recordOf(isString, isString);
+
+isStringArray(['a', 'b']); // true
+isStringSet(new Set(['a', 'b'])); // true
+isScoreMap(new Map([['math', 98]])); // true
+isStringRecord({ a: 'x', b: 'y' }); // true
+```
 
 ### Primitive guards
 
@@ -161,6 +198,8 @@ isInfiniteNumber(1); // false
 
 Object/built-in guards cover arrays, dates, maps/sets, and more. Use
 `isInstanceOf` when you want a reusable guard from a class constructor.
+For content-aware map/set validation, pair `isMap` / `isSet` with `mapOf`
+and `setOf`.
 
 ```ts
 import { isArray, isDate, isInstanceOf } from 'is-kit';
@@ -180,7 +219,7 @@ isAnimal({}); // false
 
 - **Define once**: `define<T>(fn)` turns a plain function into a type guard.
 - **Upgrade predicates**: `predicateToRefine(fn)` adds narrowing.
-- **Compose freely**: `and`, `or`, `not`, `oneOf`, `arrayOf`, `struct` …
+- **Compose freely**: `and`, `or`, `not`, `oneOf`, `arrayOf`, `setOf`, `mapOf`, `struct` …
 - **Stay ergonomic**: helpers like `nullable`, `optional`, `equals`, `safeParse`, `assert`, `hasKey`, `hasKeys`, `narrowKeyTo`.
 
 ### Key Helpers

package/dist/index.d.mts

@@ -13,13 +13,43 @@ type ParseResult<T> = {
 };
 type GuardedOf<F> = F extends (value: unknown) => value is infer G ? G : never;
 type GuardedWithin<Fs, A> = Extract<Fs extends readonly unknown[] ? GuardedOf<Fs[number]> : never, A>;
-type Schema = Readonly<Record<string, Predicate<unknown>>>;
-type InferSchema<S extends Schema> = {
-    readonly [K in keyof S]: GuardedOf<S[K]>;
-};
 
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
+/**
+ * Marks a `struct` schema field as optional at the key level.
+ */
+type OptionalSchemaField<G extends Predicate<unknown>> = Readonly<{
+    optional: true;
+    guard: G;
+}>;
+/**
+ * Field accepted by `struct` schemas.
+ */
+type SchemaField = Predicate<unknown> | OptionalSchemaField<Predicate<unknown>>;
+/**
+ * Object schema consumed by `struct`.
+ */
+type Schema = Readonly<Record<string, SchemaField>>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+type InferSchemaField<F> = F extends Predicate<unknown> ? GuardedOf<F> : F extends OptionalSchemaField<infer G> ? GuardedOf<G> : never;
+type RequiredSchemaKeys<S extends Schema> = {
+    [K in keyof S]-?: S[K] extends OptionalSchemaField<Predicate<unknown>> ? never : K;
+}[keyof S];
+type OptionalSchemaKeys<S extends Schema> = {
+    [K in keyof S]-?: S[K] extends OptionalSchemaField<Predicate<unknown>> ? K : never;
+}[keyof S];
+/**
+ * Infers the readonly object type produced by a `struct` schema.
+ */
+type InferSchema<S extends Schema> = Simplify<{
+    readonly [K in RequiredSchemaKeys<S>]: InferSchemaField<S[K]>;
+} & {
+    readonly [K in OptionalSchemaKeys<S>]?: InferSchemaField<S[K]>;
+}>;
+
 /**
  * Wraps a user function as a typed predicate.
  *
@@ -295,6 +325,23 @@ declare const isPrimitive: Guard<string | number | bigint | boolean | symbol | n
  */
 declare function arrayOf<F extends Predicate<unknown>>(elementGuard: F): Predicate<readonly GuardedOf<F>[]>;
 
+/**
+ * Validates a set where every value satisfies the provided guard.
+ *
+ * @param valueGuard Guard applied to each set value.
+ * @returns Predicate narrowing to a readonly set of the guarded value type.
+ */
+declare function setOf<VF extends Predicate<unknown>>(valueGuard: VF): Predicate<ReadonlySet<GuardedOf<VF>>>;
+
+/**
+ * Validates a map where every key and value satisfies the provided guards.
+ *
+ * @param keyGuard Guard applied to each map key.
+ * @param valueGuard Guard applied to each map value.
+ * @returns Predicate narrowing to a readonly map with guarded key/value types.
+ */
+declare function mapOf<KF extends Predicate<unknown>, VF extends Predicate<unknown>>(keyGuard: KF, valueGuard: VF): Predicate<ReadonlyMap<GuardedOf<KF>, GuardedOf<VF>>>;
+
 /**
  * Validates a fixed-length tuple by applying element-wise guards.
  *
@@ -323,9 +370,20 @@ declare function oneOf<A, Fs extends readonly Predicate<A>[]>(...guards: Fs): (i
  */
 declare function recordOf<KF extends Predicate<string>, VF extends Predicate<unknown>>(keyFunction: KF, valueFunction: VF): Predicate<Readonly<Record<GuardedOf<KF>, GuardedOf<VF>>>>;
 
+/**
+ * Marks a struct schema field as optional at the key level.
+ *
+ * When used inside `struct`, the property may be absent. If the property exists,
+ * its value must satisfy the wrapped guard.
+ *
+ * @param guard Guard used to validate the property value when the key exists.
+ * @returns Schema field marker understood by `struct`.
+ */
+declare function optionalKey<G extends Predicate<unknown>>(guard: G): OptionalSchemaField<G>;
 /**
  * Validates an object against a field-to-guard schema.
- * Keys in the schema are required; optionally rejects extra keys when `exact: true`.
+ * Keys in the schema are required unless wrapped with `optionalKey`; optionally
+ * rejects extra keys when `exact: true`.
  *
  * @param schema Record of property guards.
  * @param options When `{ exact: true }`, disallows properties not in `schema`.
@@ -505,4 +563,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 OutOfGuards, type ParseResult, type Predicate, type Primitive, type Refine, type RefineChain, type Refinement, type Schema, 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, narrowKeyTo, nonNull, not, nullable, nullish, oneOf, oneOfValues, optional, or, predicateToRefine, recordOf, required, safeParse, safeParseWith, 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, 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 };

package/dist/index.d.ts

@@ -13,13 +13,43 @@ type ParseResult<T> = {
 };
 type GuardedOf<F> = F extends (value: unknown) => value is infer G ? G : never;
 type GuardedWithin<Fs, A> = Extract<Fs extends readonly unknown[] ? GuardedOf<Fs[number]> : never, A>;
-type Schema = Readonly<Record<string, Predicate<unknown>>>;
-type InferSchema<S extends Schema> = {
-    readonly [K in keyof S]: GuardedOf<S[K]>;
-};
 
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
+/**
+ * Marks a `struct` schema field as optional at the key level.
+ */
+type OptionalSchemaField<G extends Predicate<unknown>> = Readonly<{
+    optional: true;
+    guard: G;
+}>;
+/**
+ * Field accepted by `struct` schemas.
+ */
+type SchemaField = Predicate<unknown> | OptionalSchemaField<Predicate<unknown>>;
+/**
+ * Object schema consumed by `struct`.
+ */
+type Schema = Readonly<Record<string, SchemaField>>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+type InferSchemaField<F> = F extends Predicate<unknown> ? GuardedOf<F> : F extends OptionalSchemaField<infer G> ? GuardedOf<G> : never;
+type RequiredSchemaKeys<S extends Schema> = {
+    [K in keyof S]-?: S[K] extends OptionalSchemaField<Predicate<unknown>> ? never : K;
+}[keyof S];
+type OptionalSchemaKeys<S extends Schema> = {
+    [K in keyof S]-?: S[K] extends OptionalSchemaField<Predicate<unknown>> ? K : never;
+}[keyof S];
+/**
+ * Infers the readonly object type produced by a `struct` schema.
+ */
+type InferSchema<S extends Schema> = Simplify<{
+    readonly [K in RequiredSchemaKeys<S>]: InferSchemaField<S[K]>;
+} & {
+    readonly [K in OptionalSchemaKeys<S>]?: InferSchemaField<S[K]>;
+}>;
+
 /**
  * Wraps a user function as a typed predicate.
  *
@@ -295,6 +325,23 @@ declare const isPrimitive: Guard<string | number | bigint | boolean | symbol | n
  */
 declare function arrayOf<F extends Predicate<unknown>>(elementGuard: F): Predicate<readonly GuardedOf<F>[]>;
 
+/**
+ * Validates a set where every value satisfies the provided guard.
+ *
+ * @param valueGuard Guard applied to each set value.
+ * @returns Predicate narrowing to a readonly set of the guarded value type.
+ */
+declare function setOf<VF extends Predicate<unknown>>(valueGuard: VF): Predicate<ReadonlySet<GuardedOf<VF>>>;
+
+/**
+ * Validates a map where every key and value satisfies the provided guards.
+ *
+ * @param keyGuard Guard applied to each map key.
+ * @param valueGuard Guard applied to each map value.
+ * @returns Predicate narrowing to a readonly map with guarded key/value types.
+ */
+declare function mapOf<KF extends Predicate<unknown>, VF extends Predicate<unknown>>(keyGuard: KF, valueGuard: VF): Predicate<ReadonlyMap<GuardedOf<KF>, GuardedOf<VF>>>;
+
 /**
  * Validates a fixed-length tuple by applying element-wise guards.
  *
@@ -323,9 +370,20 @@ declare function oneOf<A, Fs extends readonly Predicate<A>[]>(...guards: Fs): (i
  */
 declare function recordOf<KF extends Predicate<string>, VF extends Predicate<unknown>>(keyFunction: KF, valueFunction: VF): Predicate<Readonly<Record<GuardedOf<KF>, GuardedOf<VF>>>>;
 
+/**
+ * Marks a struct schema field as optional at the key level.
+ *
+ * When used inside `struct`, the property may be absent. If the property exists,
+ * its value must satisfy the wrapped guard.
+ *
+ * @param guard Guard used to validate the property value when the key exists.
+ * @returns Schema field marker understood by `struct`.
+ */
+declare function optionalKey<G extends Predicate<unknown>>(guard: G): OptionalSchemaField<G>;
 /**
  * Validates an object against a field-to-guard schema.
- * Keys in the schema are required; optionally rejects extra keys when `exact: true`.
+ * Keys in the schema are required unless wrapped with `optionalKey`; optionally
+ * rejects extra keys when `exact: true`.
  *
  * @param schema Record of property guards.
  * @param options When `{ exact: true }`, disallows properties not in `schema`.
@@ -505,4 +563,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 OutOfGuards, type ParseResult, type Predicate, type Primitive, type Refine, type RefineChain, type Refinement, type Schema, 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, narrowKeyTo, nonNull, not, nullable, nullish, oneOf, oneOfValues, optional, or, predicateToRefine, recordOf, required, safeParse, safeParseWith, 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, 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 };

package/dist/index.js

@@ -68,6 +68,7 @@ __export(index_exports, {
   isWeakMap: () => isWeakMap,
   isWeakSet: () => isWeakSet,
   isZero: () => isZero,
+  mapOf: () => mapOf,
   narrowKeyTo: () => narrowKeyTo,
   nonNull: () => nonNull,
   not: () => not,
@@ -76,12 +77,14 @@ __export(index_exports, {
   oneOf: () => oneOf,
   oneOfValues: () => oneOfValues,
   optional: () => optional,
+  optionalKey: () => optionalKey,
   or: () => or,
   predicateToRefine: () => predicateToRefine,
   recordOf: () => recordOf,
   required: () => required,
   safeParse: () => safeParse,
   safeParseWith: () => safeParseWith,
+  setOf: () => setOf,
   struct: () => struct,
   toBooleanPredicates: () => toBooleanPredicates,
   tupleOf: () => tupleOf
@@ -302,6 +305,29 @@ function arrayOf(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;
+  });
+}
+
+// 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;
+  });
+}
+
 // src/core/combinators/tuple.ts
 function tupleOf(...guards) {
   return (input) => {
@@ -332,15 +358,44 @@ function recordOf(keyFunction, valueFunction) {
 }
 
 // src/core/combinators/struct.ts
-var hasRequiredKeys = (obj, schema, keys) => keys.every((key) => key in obj && schema[key](obj[key]));
+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.
+  (field) => isObject(field) && field.optional === true && typeof field.guard === "function"
+);
+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]))
+);
+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]))
+);
 var hasOnlyAllowedKeys = (obj, allowed) => Object.keys(obj).every((key) => allowed.has(key));
+function optionalKey(guard) {
+  return { optional: true, guard };
+}
 function struct(schema, options) {
-  const schemaKeys = Object.keys(schema);
+  const requiredEntries = [];
+  const optionalEntries = [];
+  const schemaKeys = [];
+  for (const [key, field] of Object.entries(schema)) {
+    schemaKeys.push(key);
+    if (isOptionalSchemaField(field)) {
+      optionalEntries.push([key, field.guard]);
+      continue;
+    }
+    requiredEntries.push([key, field]);
+  }
   const allowed = options?.exact ? new Set(schemaKeys) : null;
   return (input) => {
     if (!isPlainObject(input)) return false;
     const obj = input;
-    if (!hasRequiredKeys(obj, schema, schemaKeys)) return false;
+    if (!hasRequiredKeys(obj, requiredEntries)) return false;
+    if (!hasValidOptionalKeys(obj, optionalEntries)) return false;
     if (!allowed) return true;
     return hasOnlyAllowedKeys(obj, allowed);
   };
@@ -455,6 +510,7 @@ function narrowKeyTo(guard, key) {
   isWeakMap,
   isWeakSet,
   isZero,
+  mapOf,
   narrowKeyTo,
   nonNull,
   not,
@@ -463,12 +519,14 @@ function narrowKeyTo(guard, key) {
   oneOf,
   oneOfValues,
   optional,
+  optionalKey,
   or,
   predicateToRefine,
   recordOf,
   required,
   safeParse,
   safeParseWith,
+  setOf,
   struct,
   toBooleanPredicates,
   tupleOf

package/dist/index.mjs

@@ -212,6 +212,29 @@ function arrayOf(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;
+  });
+}
+
+// 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;
+  });
+}
+
 // src/core/combinators/tuple.ts
 function tupleOf(...guards) {
   return (input) => {
@@ -242,15 +265,44 @@ function recordOf(keyFunction, valueFunction) {
 }
 
 // src/core/combinators/struct.ts
-var hasRequiredKeys = (obj, schema, keys) => keys.every((key) => key in obj && schema[key](obj[key]));
+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.
+  (field) => isObject(field) && field.optional === true && typeof field.guard === "function"
+);
+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]))
+);
+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]))
+);
 var hasOnlyAllowedKeys = (obj, allowed) => Object.keys(obj).every((key) => allowed.has(key));
+function optionalKey(guard) {
+  return { optional: true, guard };
+}
 function struct(schema, options) {
-  const schemaKeys = Object.keys(schema);
+  const requiredEntries = [];
+  const optionalEntries = [];
+  const schemaKeys = [];
+  for (const [key, field] of Object.entries(schema)) {
+    schemaKeys.push(key);
+    if (isOptionalSchemaField(field)) {
+      optionalEntries.push([key, field.guard]);
+      continue;
+    }
+    requiredEntries.push([key, field]);
+  }
   const allowed = options?.exact ? new Set(schemaKeys) : null;
   return (input) => {
     if (!isPlainObject(input)) return false;
     const obj = input;
-    if (!hasRequiredKeys(obj, schema, schemaKeys)) return false;
+    if (!hasRequiredKeys(obj, requiredEntries)) return false;
+    if (!hasValidOptionalKeys(obj, optionalEntries)) return false;
     if (!allowed) return true;
     return hasOnlyAllowedKeys(obj, allowed);
   };
@@ -364,6 +416,7 @@ export {
   isWeakMap,
   isWeakSet,
   isZero,
+  mapOf,
   narrowKeyTo,
   nonNull,
   not,
@@ -372,12 +425,14 @@ export {
   oneOf,
   oneOfValues,
   optional,
+  optionalKey,
   or,
   predicateToRefine,
   recordOf,
   required,
   safeParse,
   safeParseWith,
+  setOf,
   struct,
   toBooleanPredicates,
   tupleOf

package/package.json

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