is-kit 1.7.0 → 1.7.1

package/dist/index.mjs

@@ -1,11 +1,3 @@
-// src/core/define.ts
-function define(fn) {
-  return (value) => !!fn(value);
-}
-
-// src/core/predicate.ts
-var predicateToRefine = (fn) => (value) => fn(value);
-
 // src/core/assert.ts
 var DEFAULT_ASSERT_MESSAGE = "Assertion failed";
 function assert(fn, value, message) {
@@ -13,94 +5,9 @@ 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;
-
-// src/core/logic.ts
-function and(precondition, condition) {
-  return define((input) => {
-    if (precondition(input)) {
-      return condition(input);
-    }
-    return false;
-  });
-}
-function andAll(precondition, ...steps) {
-  return define((input) => {
-    if (!precondition(input)) return false;
-    return applyRefinements(input, steps);
-  });
-}
-function or(...guards) {
-  const predicates = toBooleanPredicates(guards);
-  return define(
-    (input) => predicates.some((guard) => guard(input))
-  );
-}
-function guardIn() {
-  return (guard) => (input) => guard(input);
-}
-function not(fn) {
-  return (input) => !fn(input);
-}
-function applyRefinements(value, steps) {
-  if (!steps || steps.length === 0) return true;
-  for (const step of steps) {
-    if (!step(value)) return false;
-  }
-  return true;
-}
-
-// 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 allowWhen((value) => value === null, fn);
-}
-function nonNull(fn) {
-  return requireWhen((value) => value === null, fn);
-}
-function nullish(fn) {
-  return allowWhen((value) => value == null, fn);
-}
-function optional(fn) {
-  return allowWhen((value) => value === void 0, fn);
-}
-function required(fn) {
-  return requireWhen((value) => value === void 0, fn);
+// src/core/define.ts
+function define(fn) {
+  return (value) => !!fn(value);
 }
 
 // src/utils/object-tags.ts
@@ -198,6 +105,117 @@ function equalsKey(key, target) {
   return (input) => hasMatchingKey(input);
 }
 
+// src/core/key.ts
+var hasKey = (key) => define(
+  (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.hasOwn(input, key))
+  );
+};
+function narrowKeyTo(guard, key) {
+  return (target) => {
+    const keyEquals = equalsKey(key, target);
+    return define(
+      (input) => guard(input) && keyEquals(input)
+    );
+  };
+}
+
+// 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;
+
+// src/core/logic.ts
+function and(precondition, condition) {
+  return define((input) => {
+    if (precondition(input)) {
+      return condition(input);
+    }
+    return false;
+  });
+}
+function andAll(precondition, ...steps) {
+  return define((input) => {
+    if (!precondition(input)) return false;
+    return applyRefinements(input, steps);
+  });
+}
+function or(...guards) {
+  const predicates = toBooleanPredicates(guards);
+  return define(
+    (input) => predicates.some((guard) => guard(input))
+  );
+}
+function guardIn() {
+  return (guard) => (input) => guard(input);
+}
+function not(fn) {
+  return (input) => !fn(input);
+}
+function applyRefinements(value, steps) {
+  if (!steps || steps.length === 0) return true;
+  for (const step of steps) {
+    if (!step(value)) return false;
+  }
+  return true;
+}
+
+// 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 allowWhen((value) => value === null, fn);
+}
+function nonNull(fn) {
+  return requireWhen((value) => value === null, fn);
+}
+function nullish(fn) {
+  return allowWhen((value) => value == null, fn);
+}
+function optional(fn) {
+  return allowWhen((value) => value === void 0, fn);
+}
+function required(fn) {
+  return requireWhen((value) => value === void 0, fn);
+}
+
 // src/core/parse.ts
 function safeParse(fn, value) {
   const valid = fn(value);
@@ -207,6 +225,9 @@ function safeParseWith(fn) {
   return (value) => safeParse(fn, value);
 }
 
+// src/core/predicate.ts
+var predicateToRefine = (fn) => (value) => fn(value);
+
 // src/core/primitive.ts
 var isString = define((value) => typeof value === "string");
 var isNumberPrimitive = define(
@@ -260,13 +281,6 @@ function nonEmptyArrayOf(elementGuard) {
   );
 }
 
-// src/core/combinators/set.ts
-function setOf(valueGuard) {
-  return define(
-    (input) => isSet(input) && everySetValue(input, valueGuard)
-  );
-}
-
 // src/core/combinators/map.ts
 function mapOf(keyGuard, valueGuard) {
   return define(
@@ -274,18 +288,46 @@ function mapOf(keyGuard, valueGuard) {
   );
 }
 
-// src/core/combinators/tuple.ts
-function tupleOf(...guards) {
-  return define(
-    (input) => Array.isArray(input) && everyTupleValue(input, guards)
-  );
-}
-
 // src/core/combinators/one-of.ts
 function oneOf(...guards) {
   return or(...guards);
 }
 
+// src/core/combinators/one-of-values.ts
+var ONE_OF_VALUES_LINEAR_SCAN_MAX = 8;
+var isSingleArrayArg = define(
+  (value) => Array.isArray(value) && value.length === 1 && Array.isArray(value[0])
+);
+var normalizeValues = (args) => isSingleArrayArg(args) ? args[0] : args;
+var createLinearPredicate = (items) => {
+  return define((input) => {
+    return items.some((value) => Object.is(value, input));
+  });
+};
+var createSetPredicate = (items) => {
+  let hasPositiveZero = false;
+  let hasNegativeZero = false;
+  const valueSet = /* @__PURE__ */ new Set();
+  for (const literalValue of items) {
+    if (isZero(literalValue)) {
+      if (Object.is(literalValue, -0)) hasNegativeZero = true;
+      else hasPositiveZero = true;
+    } else {
+      valueSet.add(literalValue);
+    }
+  }
+  return define((input) => {
+    if (isZero(input)) {
+      return Object.is(input, -0) ? hasNegativeZero : hasPositiveZero;
+    }
+    return valueSet.has(input);
+  });
+};
+function oneOfValues(...args) {
+  const items = normalizeValues(args);
+  return items.length <= ONE_OF_VALUES_LINEAR_SCAN_MAX ? createLinearPredicate(items) : createSetPredicate(items);
+}
+
 // src/core/combinators/record.ts
 function recordOf(keyFunction, valueFunction) {
   return define(
@@ -293,6 +335,13 @@ function recordOf(keyFunction, valueFunction) {
   );
 }
 
+// src/core/combinators/set.ts
+function setOf(valueGuard) {
+  return define(
+    (input) => isSet(input) && everySetValue(input, valueGuard)
+  );
+}
+
 // src/core/combinators/struct.ts
 var isOptionalSchemaField = define(
   // WHY: Optional fields are represented as a small tagged object so `struct`
@@ -336,60 +385,11 @@ function struct(schema, options) {
   });
 }
 
-// src/core/combinators/one-of-values.ts
-var ONE_OF_VALUES_LINEAR_SCAN_MAX = 8;
-var isSingleArrayArg = define(
-  (value) => Array.isArray(value) && value.length === 1 && Array.isArray(value[0])
-);
-var normalizeValues = (args) => isSingleArrayArg(args) ? args[0] : args;
-var createLinearPredicate = (items) => {
-  return define((input) => {
-    return items.some((value) => Object.is(value, input));
-  });
-};
-var createSetPredicate = (items) => {
-  let hasPositiveZero = false;
-  let hasNegativeZero = false;
-  const valueSet = /* @__PURE__ */ new Set();
-  for (const literalValue of items) {
-    if (isZero(literalValue)) {
-      if (Object.is(literalValue, -0)) hasNegativeZero = true;
-      else hasPositiveZero = true;
-    } else {
-      valueSet.add(literalValue);
-    }
-  }
-  return define((input) => {
-    if (isZero(input)) {
-      return Object.is(input, -0) ? hasNegativeZero : hasPositiveZero;
-    }
-    return valueSet.has(input);
-  });
-};
-function oneOfValues(...args) {
-  const items = normalizeValues(args);
-  return items.length <= ONE_OF_VALUES_LINEAR_SCAN_MAX ? createLinearPredicate(items) : createSetPredicate(items);
-}
-
-// src/core/key.ts
-var hasKey = (key) => define(
-  (input) => isObject(input) && Object.hasOwn(input, key)
-);
-var hasKeys = (...keys) => {
-  if (keys.length === 0) {
-    return define(() => false);
-  }
+// src/core/combinators/tuple.ts
+function tupleOf(...guards) {
   return define(
-    (input) => isObject(input) && keys.every((key) => Object.hasOwn(input, key))
+    (input) => Array.isArray(input) && everyTupleValue(input, guards)
   );
-};
-function narrowKeyTo(guard, key) {
-  return (target) => {
-    const keyEquals = equalsKey(key, target);
-    return define(
-      (input) => guard(input) && keyEquals(input)
-    );
-  };
 }
 export {
   and,

package/package.json

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