is-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,355 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  and: () => and,
+  andAll: () => andAll,
+  arrayOf: () => arrayOf,
+  define: () => define,
+  equals: () => equals,
+  equalsBy: () => equalsBy,
+  equalsKey: () => equalsKey,
+  guardIn: () => guardIn,
+  isArray: () => isArray,
+  isArrayBuffer: () => isArrayBuffer,
+  isAsyncIterable: () => isAsyncIterable,
+  isBigInt: () => isBigInt,
+  isBlob: () => isBlob,
+  isBoolean: () => isBoolean,
+  isDataView: () => isDataView,
+  isDate: () => isDate,
+  isError: () => isError,
+  isFiniteNumber: () => isFiniteNumber,
+  isFunction: () => isFunction,
+  isIterable: () => isIterable,
+  isMap: () => isMap,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isNumberPrimitive: () => isNumberPrimitive,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  isPromiseLike: () => isPromiseLike,
+  isRegExp: () => isRegExp,
+  isSet: () => isSet,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  isTypedArray: () => isTypedArray,
+  isURL: () => isURL,
+  isUndefined: () => isUndefined,
+  nonNull: () => nonNull,
+  not: () => not,
+  nullable: () => nullable,
+  nullish: () => nullish,
+  oneOf: () => oneOf,
+  oneOfValues: () => oneOfValues,
+  optional: () => optional,
+  or: () => or,
+  predicateToRefine: () => predicateToRefine,
+  recordOf: () => recordOf,
+  required: () => required,
+  safeParse: () => safeParse,
+  safeParseWith: () => safeParseWith,
+  struct: () => struct,
+  toBooleanPredicates: () => toBooleanPredicates,
+  tupleOf: () => tupleOf
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/define.ts
+function define(fn) {
+  return (value) => !!fn(value);
+}
+
+// src/core/predicate.ts
+var predicateToRefine = (fn) => (value) => fn(value);
+
+// src/utils/util.ts
+var toBooleanPredicates = (guards) => guards;
+
+// src/core/logic.ts
+function and(precondition, condition) {
+  return function(input) {
+    if (precondition(input)) {
+      return condition(input);
+    }
+    return false;
+  };
+}
+function andAll(precondition, ...steps) {
+  const boolSteps = steps;
+  return function(input) {
+    return precondition(input) && boolSteps.every((step) => step(input));
+  };
+}
+function or(...guards) {
+  const predicates = toBooleanPredicates(guards);
+  return function(input) {
+    return predicates.some((guard) => guard(input));
+  };
+}
+function guardIn() {
+  return function(guard) {
+    return function(input) {
+      return guard(input);
+    };
+  };
+}
+function not(fn) {
+  return (input) => !fn(input);
+}
+
+// src/core/nullish.ts
+function nullable(fn) {
+  return (value) => value === null || fn(value);
+}
+function nonNull(fn) {
+  return (value) => value !== null && fn(value);
+}
+function nullish(fn) {
+  return (value) => value == null || fn(value);
+}
+function optional(fn) {
+  return (value) => value === void 0 || fn(value);
+}
+function required(fn) {
+  return (value) => value !== void 0 && fn(value);
+}
+
+// src/core/object.ts
+var getTag = (value) => Object.prototype.toString.call(value);
+var isFunction = define(
+  (value) => typeof value === "function"
+);
+var isObject = define(
+  (value) => typeof value === "object" && value !== null
+);
+var isPlainObject = define((value) => {
+  if (!isObject(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+});
+var isArray = define(Array.isArray);
+var isDate = define(
+  (value) => getTag(value) === "[object Date]" && !Number.isNaN(value.getTime())
+);
+var isRegExp = define(
+  (value) => getTag(value) === "[object RegExp]"
+);
+var isMap = define(
+  (value) => getTag(value) === "[object Map]"
+);
+var isSet = define(
+  (value) => getTag(value) === "[object Set]"
+);
+var isPromiseLike = define(
+  (value) => !!value && typeof value.then === "function"
+);
+var isIterable = define(
+  (value) => !!value && typeof value === "object" && typeof value[Symbol.iterator] === "function"
+);
+var isAsyncIterable = define(
+  (value) => !!value && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function"
+);
+var isArrayBuffer = define(
+  (value) => getTag(value) === "[object ArrayBuffer]"
+);
+var isDataView = define(
+  (value) => getTag(value) === "[object DataView]"
+);
+var isTypedArray = define(
+  (value) => ArrayBuffer.isView(value) && getTag(value) !== "[object DataView]"
+);
+var isError = define(
+  (value) => value instanceof Error || getTag(value) === "[object Error]"
+);
+var isURL = typeof URL !== "undefined" ? define((value) => value instanceof URL) : define((_value) => false);
+var isBlob = typeof Blob !== "undefined" ? define((value) => value instanceof Blob) : define((_value) => false);
+
+// src/core/equals.ts
+function equals(target) {
+  return function(input) {
+    return Object.is(input, target);
+  };
+}
+function equalsBy(guard, selector) {
+  const createComparator = (selectorFn) => (target) => (input) => {
+    if (!guard(input)) return false;
+    return Object.is(selectorFn(input), target);
+  };
+  if (selector) {
+    return createComparator(selector);
+  }
+  return (selector2) => createComparator(selector2);
+}
+function equalsKey(key, target) {
+  return function(input) {
+    return isObject(input) && Object.prototype.hasOwnProperty.call(input, key) && Object.is(input[key], target);
+  };
+}
+
+// src/core/parse.ts
+function safeParse(fn, value) {
+  const valid = fn(value);
+  return valid ? { valid: true, value } : { valid: false };
+}
+function safeParseWith(fn) {
+  return (value) => safeParse(fn, value);
+}
+
+// src/core/primitive.ts
+var isString = define((value) => typeof value === "string");
+var isNumberPrimitive = define(
+  (value) => typeof value === "number"
+);
+var isFiniteNumber = predicateToRefine(Number.isFinite);
+var isNumber = and(isNumberPrimitive, isFiniteNumber);
+var isBoolean = define((value) => typeof value === "boolean");
+var isBigInt = define((value) => typeof value === "bigint");
+var isSymbol = define((value) => typeof value === "symbol");
+var isUndefined = define((value) => value === void 0);
+var isNull = define((value) => value === null);
+
+// src/core/combinators/array.ts
+function arrayOf(elementGuard) {
+  return function(input) {
+    if (!Array.isArray(input)) return false;
+    for (const element of input) {
+      if (!elementGuard(element)) return false;
+    }
+    return true;
+  };
+}
+
+// src/core/combinators/tuple.ts
+function tupleOf(...guards) {
+  return function(input) {
+    return Array.isArray(input) && input.length === guards.length && guards.every(
+      (guard, index) => guard(input[index])
+    );
+  };
+}
+
+// src/core/combinators/one.ts
+function oneOf(...guards) {
+  return (input) => guards.some((guard) => guard(input));
+}
+
+// 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;
+  };
+}
+
+// src/core/combinators/struct.ts
+function struct(schema, options) {
+  return (input) => {
+    if (!isPlainObject(input)) return false;
+    const obj = input;
+    for (const key of Object.keys(schema)) {
+      const guard = schema[key];
+      if (!(key in obj)) return false;
+      if (!guard(obj[key])) return false;
+    }
+    if (options?.exact) {
+      const allowed = new Set(Object.keys(schema));
+      for (const key of Object.keys(obj)) {
+        if (!allowed.has(key)) return false;
+      }
+    }
+    return true;
+  };
+}
+
+// src/core/combinators/one-of-values.ts
+var ONE_OF_VALUES_LINEAR_SCAN_MAX = 8;
+function oneOfValues(...values) {
+  if (values.length <= ONE_OF_VALUES_LINEAR_SCAN_MAX) {
+    const items = values;
+    return function(input) {
+      return items.some((value) => Object.is(value, input));
+    };
+  }
+  const valueSet = new Set(values);
+  return function(input) {
+    return valueSet.has(input);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  and,
+  andAll,
+  arrayOf,
+  define,
+  equals,
+  equalsBy,
+  equalsKey,
+  guardIn,
+  isArray,
+  isArrayBuffer,
+  isAsyncIterable,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isDataView,
+  isDate,
+  isError,
+  isFiniteNumber,
+  isFunction,
+  isIterable,
+  isMap,
+  isNull,
+  isNumber,
+  isNumberPrimitive,
+  isObject,
+  isPlainObject,
+  isPromiseLike,
+  isRegExp,
+  isSet,
+  isString,
+  isSymbol,
+  isTypedArray,
+  isURL,
+  isUndefined,
+  nonNull,
+  not,
+  nullable,
+  nullish,
+  oneOf,
+  oneOfValues,
+  optional,
+  or,
+  predicateToRefine,
+  recordOf,
+  required,
+  safeParse,
+  safeParseWith,
+  struct,
+  toBooleanPredicates,
+  tupleOf
+});

package/dist/index.mjs

@@ -0,0 +1,279 @@
+// src/core/define.ts
+function define(fn) {
+  return (value) => !!fn(value);
+}
+
+// src/core/predicate.ts
+var predicateToRefine = (fn) => (value) => fn(value);
+
+// src/utils/util.ts
+var toBooleanPredicates = (guards) => guards;
+
+// src/core/logic.ts
+function and(precondition, condition) {
+  return function(input) {
+    if (precondition(input)) {
+      return condition(input);
+    }
+    return false;
+  };
+}
+function andAll(precondition, ...steps) {
+  const boolSteps = steps;
+  return function(input) {
+    return precondition(input) && boolSteps.every((step) => step(input));
+  };
+}
+function or(...guards) {
+  const predicates = toBooleanPredicates(guards);
+  return function(input) {
+    return predicates.some((guard) => guard(input));
+  };
+}
+function guardIn() {
+  return function(guard) {
+    return function(input) {
+      return guard(input);
+    };
+  };
+}
+function not(fn) {
+  return (input) => !fn(input);
+}
+
+// src/core/nullish.ts
+function nullable(fn) {
+  return (value) => value === null || fn(value);
+}
+function nonNull(fn) {
+  return (value) => value !== null && fn(value);
+}
+function nullish(fn) {
+  return (value) => value == null || fn(value);
+}
+function optional(fn) {
+  return (value) => value === void 0 || fn(value);
+}
+function required(fn) {
+  return (value) => value !== void 0 && fn(value);
+}
+
+// src/core/object.ts
+var getTag = (value) => Object.prototype.toString.call(value);
+var isFunction = define(
+  (value) => typeof value === "function"
+);
+var isObject = define(
+  (value) => typeof value === "object" && value !== null
+);
+var isPlainObject = define((value) => {
+  if (!isObject(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+});
+var isArray = define(Array.isArray);
+var isDate = define(
+  (value) => getTag(value) === "[object Date]" && !Number.isNaN(value.getTime())
+);
+var isRegExp = define(
+  (value) => getTag(value) === "[object RegExp]"
+);
+var isMap = define(
+  (value) => getTag(value) === "[object Map]"
+);
+var isSet = define(
+  (value) => getTag(value) === "[object Set]"
+);
+var isPromiseLike = define(
+  (value) => !!value && typeof value.then === "function"
+);
+var isIterable = define(
+  (value) => !!value && typeof value === "object" && typeof value[Symbol.iterator] === "function"
+);
+var isAsyncIterable = define(
+  (value) => !!value && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function"
+);
+var isArrayBuffer = define(
+  (value) => getTag(value) === "[object ArrayBuffer]"
+);
+var isDataView = define(
+  (value) => getTag(value) === "[object DataView]"
+);
+var isTypedArray = define(
+  (value) => ArrayBuffer.isView(value) && getTag(value) !== "[object DataView]"
+);
+var isError = define(
+  (value) => value instanceof Error || getTag(value) === "[object Error]"
+);
+var isURL = typeof URL !== "undefined" ? define((value) => value instanceof URL) : define((_value) => false);
+var isBlob = typeof Blob !== "undefined" ? define((value) => value instanceof Blob) : define((_value) => false);
+
+// src/core/equals.ts
+function equals(target) {
+  return function(input) {
+    return Object.is(input, target);
+  };
+}
+function equalsBy(guard, selector) {
+  const createComparator = (selectorFn) => (target) => (input) => {
+    if (!guard(input)) return false;
+    return Object.is(selectorFn(input), target);
+  };
+  if (selector) {
+    return createComparator(selector);
+  }
+  return (selector2) => createComparator(selector2);
+}
+function equalsKey(key, target) {
+  return function(input) {
+    return isObject(input) && Object.prototype.hasOwnProperty.call(input, key) && Object.is(input[key], target);
+  };
+}
+
+// src/core/parse.ts
+function safeParse(fn, value) {
+  const valid = fn(value);
+  return valid ? { valid: true, value } : { valid: false };
+}
+function safeParseWith(fn) {
+  return (value) => safeParse(fn, value);
+}
+
+// src/core/primitive.ts
+var isString = define((value) => typeof value === "string");
+var isNumberPrimitive = define(
+  (value) => typeof value === "number"
+);
+var isFiniteNumber = predicateToRefine(Number.isFinite);
+var isNumber = and(isNumberPrimitive, isFiniteNumber);
+var isBoolean = define((value) => typeof value === "boolean");
+var isBigInt = define((value) => typeof value === "bigint");
+var isSymbol = define((value) => typeof value === "symbol");
+var isUndefined = define((value) => value === void 0);
+var isNull = define((value) => value === null);
+
+// src/core/combinators/array.ts
+function arrayOf(elementGuard) {
+  return function(input) {
+    if (!Array.isArray(input)) return false;
+    for (const element of input) {
+      if (!elementGuard(element)) return false;
+    }
+    return true;
+  };
+}
+
+// src/core/combinators/tuple.ts
+function tupleOf(...guards) {
+  return function(input) {
+    return Array.isArray(input) && input.length === guards.length && guards.every(
+      (guard, index) => guard(input[index])
+    );
+  };
+}
+
+// src/core/combinators/one.ts
+function oneOf(...guards) {
+  return (input) => guards.some((guard) => guard(input));
+}
+
+// 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;
+  };
+}
+
+// src/core/combinators/struct.ts
+function struct(schema, options) {
+  return (input) => {
+    if (!isPlainObject(input)) return false;
+    const obj = input;
+    for (const key of Object.keys(schema)) {
+      const guard = schema[key];
+      if (!(key in obj)) return false;
+      if (!guard(obj[key])) return false;
+    }
+    if (options?.exact) {
+      const allowed = new Set(Object.keys(schema));
+      for (const key of Object.keys(obj)) {
+        if (!allowed.has(key)) return false;
+      }
+    }
+    return true;
+  };
+}
+
+// src/core/combinators/one-of-values.ts
+var ONE_OF_VALUES_LINEAR_SCAN_MAX = 8;
+function oneOfValues(...values) {
+  if (values.length <= ONE_OF_VALUES_LINEAR_SCAN_MAX) {
+    const items = values;
+    return function(input) {
+      return items.some((value) => Object.is(value, input));
+    };
+  }
+  const valueSet = new Set(values);
+  return function(input) {
+    return valueSet.has(input);
+  };
+}
+export {
+  and,
+  andAll,
+  arrayOf,
+  define,
+  equals,
+  equalsBy,
+  equalsKey,
+  guardIn,
+  isArray,
+  isArrayBuffer,
+  isAsyncIterable,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isDataView,
+  isDate,
+  isError,
+  isFiniteNumber,
+  isFunction,
+  isIterable,
+  isMap,
+  isNull,
+  isNumber,
+  isNumberPrimitive,
+  isObject,
+  isPlainObject,
+  isPromiseLike,
+  isRegExp,
+  isSet,
+  isString,
+  isSymbol,
+  isTypedArray,
+  isURL,
+  isUndefined,
+  nonNull,
+  not,
+  nullable,
+  nullish,
+  oneOf,
+  oneOfValues,
+  optional,
+  or,
+  predicateToRefine,
+  recordOf,
+  required,
+  safeParse,
+  safeParseWith,
+  struct,
+  toBooleanPredicates,
+  tupleOf
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "is-kit",
+  "version": "1.0.0",
+  "description": "Make 'isXXX' easier. Let's make your code type safe and more readable!",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "is",
+    "isXXX",
+    "isKit",
+    "type guards",
+    "type safe",
+    "type checking"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nyaomaru/is-kit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nyaomaru/is-kit/issues"
+  },
+  "homepage": "https://github.com/nyaomaru/is-kit#readme",
+  "author": "nyaomaru",
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9.33.0",
+    "@types/jest": "^30.0.0",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^30.0.5",
+    "prettier": "^3.6.2",
+    "ts-jest": "^29.4.1",
+    "tsd": "^0.33.0",
+    "tsup": "^8.5.0",
+    "typedoc": "^0.28.12",
+    "typescript": "^5.9.2"
+  },
+  "tsd": {
+    "directory": "tests-d",
+    "compilerOptions": {
+      "baseUrl": "."
+    }
+  },
+  "scripts": {
+    "test": "jest",
+    "test:types": "tsd",
+    "lint": "eslint .",
+    "build": "tsup",
+    "typedoc": "typedoc --out docs/public/api"
+  }
+}