is-kit 1.3.0 → 1.4.1

package/README.md

@@ -181,15 +181,24 @@ 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` …
-- **Stay ergonomic**: helpers like `nullable`, `optional`, `equals`, `safeParse`, `assert`, `hasKey`, `narrowKeyTo`.
+- **Stay ergonomic**: helpers like `nullable`, `optional`, `equals`, `safeParse`, `assert`, `hasKey`, `hasKeys`, `narrowKeyTo`.
 
 ### Key Helpers
 
-Use `hasKey` to check for a required own property before refining, and
+Use `hasKey`/`hasKeys` to check required own properties before refining, and
 `narrowKeyTo` when you need to narrow a property to a specific literal value.
 
 ```ts
-import { hasKey, isString, isNumber, narrowKeyTo, or, struct } from 'is-kit';
+import {
+  hasKey,
+  hasKeys,
+  isString,
+  isNumber,
+  narrowKeyTo,
+  oneOfValues,
+  or,
+  struct
+} from 'is-kit';
 
 // Base guard (e.g., via struct)
 type User = { id: string; age: number; role: 'admin' | 'guest' | 'trial' };
@@ -200,6 +209,7 @@ const isUser = struct({
 });
 
 const hasRole = hasKey('role');
+const hasRoleAndId = hasKeys('role', 'id');
 const byRole = narrowKeyTo(isUser, 'role');
 const isGuest = byRole('guest'); // Readonly<User> & { role: 'guest' }
 const isTrial = byRole('trial'); // Readonly<User> & { role: 'trial' }
@@ -210,6 +220,11 @@ if (hasRole(value)) {
   value.role;
 }
 
+if (hasRoleAndId(value)) {
+  value.role;
+  value.id;
+}
+
 if (isGuestOrTrial(value)) {
   // value.role is 'guest' | 'trial'
 }

package/dist/index.d.mts

@@ -476,6 +476,13 @@ declare const isInstanceOf: <C extends abstract new (...args: unknown[]) => unkn
  * @returns Predicate narrowing to an object with the key present.
  */
 declare const hasKey: <K extends PropertyKey>(key: K) => Predicate<Record<K, unknown>>;
+/**
+ * Checks whether a value has all specified own keys.
+ *
+ * @param keys Property keys to check.
+ * @returns Predicate narrowing to an object with all keys present.
+ */
+declare const hasKeys: <const KS extends readonly [PropertyKey, ...PropertyKey[]]>(...keys: KS) => Predicate<Record<KS[number], unknown>>;
 /**
  * Builds a guard that narrows a specific key to the provided literal value.
  *
@@ -498,4 +505,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, 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 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 };

package/dist/index.d.ts

@@ -476,6 +476,13 @@ declare const isInstanceOf: <C extends abstract new (...args: unknown[]) => unkn
  * @returns Predicate narrowing to an object with the key present.
  */
 declare const hasKey: <K extends PropertyKey>(key: K) => Predicate<Record<K, unknown>>;
+/**
+ * Checks whether a value has all specified own keys.
+ *
+ * @param keys Property keys to check.
+ * @returns Predicate narrowing to an object with all keys present.
+ */
+declare const hasKeys: <const KS extends readonly [PropertyKey, ...PropertyKey[]]>(...keys: KS) => Predicate<Record<KS[number], unknown>>;
 /**
  * Builds a guard that narrows a specific key to the provided literal value.
  *
@@ -498,4 +505,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, 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 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 };

package/dist/index.js

@@ -30,6 +30,7 @@ __export(index_exports, {
   equalsKey: () => equalsKey,
   guardIn: () => guardIn,
   hasKey: () => hasKey,
+  hasKeys: () => hasKeys,
   isArray: () => isArray,
   isArrayBuffer: () => isArrayBuffer,
   isAsyncIterable: () => isAsyncIterable,
@@ -107,7 +108,7 @@ var toBooleanPredicates = (predicates) => predicates;
 
 // src/core/logic.ts
 function and(precondition, condition) {
-  return function(input) {
+  return (input) => {
     if (precondition(input)) {
       return condition(input);
     }
@@ -115,23 +116,19 @@ function and(precondition, condition) {
   };
 }
 function andAll(precondition, ...steps) {
-  return function(input) {
+  return (input) => {
     if (!precondition(input)) return false;
     return applyRefinements(input, steps);
   };
 }
 function or(...guards) {
   const predicates = toBooleanPredicates(guards);
-  return function(input) {
+  return (input) => {
     return predicates.some((guard) => guard(input));
   };
 }
 function guardIn() {
-  return function(guard) {
-    return function(input) {
-      return guard(input);
-    };
-  };
+  return (guard) => (input) => guard(input);
 }
 function not(fn) {
   return (input) => !fn(input);
@@ -223,7 +220,7 @@ var isInstanceOf = (constructor) => define((value) => value instanceof construct
 
 // src/core/equals.ts
 function equals(target) {
-  return function(input) {
+  return (input) => {
     return Object.is(input, target);
   };
 }
@@ -238,7 +235,7 @@ function equalsBy(guard, selector) {
   return (selector2) => createComparator(selector2);
 }
 function equalsKey(key, target) {
-  return function(input) {
+  return (input) => {
     return isObject(input) && Object.prototype.hasOwnProperty.call(input, key) && Object.is(input[key], target);
   };
 }
@@ -295,7 +292,7 @@ var isPrimitive = or(
 
 // src/core/combinators/array.ts
 function arrayOf(elementGuard) {
-  return function(input) {
+  return (input) => {
     if (!Array.isArray(input)) return false;
     for (const element of input) {
       if (!elementGuard(element)) return false;
@@ -306,7 +303,7 @@ function arrayOf(elementGuard) {
 
 // src/core/combinators/tuple.ts
 function tupleOf(...guards) {
-  return function(input) {
+  return (input) => {
     return Array.isArray(input) && input.length === guards.length && guards.every(
       (guard, index) => guard(input[index])
     );
@@ -359,7 +356,7 @@ var isZeroNumber = and(
 );
 var normalizeValues = (args) => isSingleArrayArg(args) ? args[0] : args;
 var createLinearPredicate = (items) => {
-  return function(input) {
+  return (input) => {
     return items.some((value) => Object.is(value, input));
   };
 };
@@ -375,7 +372,7 @@ var createSetPredicate = (items) => {
       valueSet.add(literalValue);
     }
   }
-  return function(input) {
+  return (input) => {
     if (isZeroNumber(input)) {
       return Object.is(input, -0) ? hasNegativeZero : hasPositiveZero;
     }
@@ -391,12 +388,20 @@ function oneOfValues(...args) {
 var hasKey = (key) => define(
   (input) => isObject(input) && Object.prototype.hasOwnProperty.call(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))
+  );
+};
 function narrowKeyTo(guard, key) {
-  return function(target) {
+  return (target) => {
     const keyEquals = equalsKey(key, target);
-    return define(function(input) {
-      return guard(input) && keyEquals(input);
-    });
+    return define(
+      (input) => guard(input) && keyEquals(input)
+    );
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -411,6 +416,7 @@ function narrowKeyTo(guard, key) {
   equalsKey,
   guardIn,
   hasKey,
+  hasKeys,
   isArray,
   isArrayBuffer,
   isAsyncIterable,

package/dist/index.mjs

@@ -18,7 +18,7 @@ var toBooleanPredicates = (predicates) => predicates;
 
 // src/core/logic.ts
 function and(precondition, condition) {
-  return function(input) {
+  return (input) => {
     if (precondition(input)) {
       return condition(input);
     }
@@ -26,23 +26,19 @@ function and(precondition, condition) {
   };
 }
 function andAll(precondition, ...steps) {
-  return function(input) {
+  return (input) => {
     if (!precondition(input)) return false;
     return applyRefinements(input, steps);
   };
 }
 function or(...guards) {
   const predicates = toBooleanPredicates(guards);
-  return function(input) {
+  return (input) => {
     return predicates.some((guard) => guard(input));
   };
 }
 function guardIn() {
-  return function(guard) {
-    return function(input) {
-      return guard(input);
-    };
-  };
+  return (guard) => (input) => guard(input);
 }
 function not(fn) {
   return (input) => !fn(input);
@@ -134,7 +130,7 @@ var isInstanceOf = (constructor) => define((value) => value instanceof construct
 
 // src/core/equals.ts
 function equals(target) {
-  return function(input) {
+  return (input) => {
     return Object.is(input, target);
   };
 }
@@ -149,7 +145,7 @@ function equalsBy(guard, selector) {
   return (selector2) => createComparator(selector2);
 }
 function equalsKey(key, target) {
-  return function(input) {
+  return (input) => {
     return isObject(input) && Object.prototype.hasOwnProperty.call(input, key) && Object.is(input[key], target);
   };
 }
@@ -206,7 +202,7 @@ var isPrimitive = or(
 
 // src/core/combinators/array.ts
 function arrayOf(elementGuard) {
-  return function(input) {
+  return (input) => {
     if (!Array.isArray(input)) return false;
     for (const element of input) {
       if (!elementGuard(element)) return false;
@@ -217,7 +213,7 @@ function arrayOf(elementGuard) {
 
 // src/core/combinators/tuple.ts
 function tupleOf(...guards) {
-  return function(input) {
+  return (input) => {
     return Array.isArray(input) && input.length === guards.length && guards.every(
       (guard, index) => guard(input[index])
     );
@@ -270,7 +266,7 @@ var isZeroNumber = and(
 );
 var normalizeValues = (args) => isSingleArrayArg(args) ? args[0] : args;
 var createLinearPredicate = (items) => {
-  return function(input) {
+  return (input) => {
     return items.some((value) => Object.is(value, input));
   };
 };
@@ -286,7 +282,7 @@ var createSetPredicate = (items) => {
       valueSet.add(literalValue);
     }
   }
-  return function(input) {
+  return (input) => {
     if (isZeroNumber(input)) {
       return Object.is(input, -0) ? hasNegativeZero : hasPositiveZero;
     }
@@ -302,12 +298,20 @@ function oneOfValues(...args) {
 var hasKey = (key) => define(
   (input) => isObject(input) && Object.prototype.hasOwnProperty.call(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))
+  );
+};
 function narrowKeyTo(guard, key) {
-  return function(target) {
+  return (target) => {
     const keyEquals = equalsKey(key, target);
-    return define(function(input) {
-      return guard(input) && keyEquals(input);
-    });
+    return define(
+      (input) => guard(input) && keyEquals(input)
+    );
   };
 }
 export {
@@ -321,6 +325,7 @@ export {
   equalsKey,
   guardIn,
   hasKey,
+  hasKeys,
   isArray,
   isArrayBuffer,
   isAsyncIterable,

package/package.json

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