@klyper/utils 0.2.2 → 0.2.3

package/dist/index.cjs

@@ -1,21 +1,77 @@
 /*!
- * @klyper/utils v0.2.2
+ * @klyper/utils v0.2.3
  * Utility helpers for the Klyper ecosystem.
  * (c) 2026 Andrew Caires
  * @license: MIT
  */
 'use strict';
 
-function isNil(value) {
-  return value === null || value === undefined;
-}
+const types$1 = {};
 
-function noop() {}
+const type = (test) => test == null ? "null" : types$1[types$1.toString.call(test)] || "object";
 
-function identity(value) {
-  return value;
-}
+["Array", "AsyncFunction", "Boolean", "Date", "Function", "Map", "Number", "Object", "RegExp", "Set", "String"].forEach((type) => types$1["[object " + type + "]"] = type.toLowerCase());
 
-exports.identity = identity;
+const isArray = (test) => type(test) == "array";
+
+const isBoolean = (test) => type(test) == "boolean";
+
+const isFunction = (test) => typeof test == "function";
+
+const isConstructor = (test) => isFunction(test) && !!test.prototype && test.prototype.constructor === test;
+
+const isDate = (test) => type(test) == "date";
+
+const isDef = (test) => type(test) != "null";
+
+const isNumber = (test) => type(test) == "number";
+
+const isFloat = (test) => isNumber(test) && !!(test % 1);
+
+const isInteger = (test) => isNumber(test) && !(test % 1);
+
+const isMap = (test) => type(test) == "map";
+
+const isNil = (test) => test === null || test === undefined;
+
+const isNull = (test) => test === null;
+
+const isObject = (test) => type(test) == "object";
+
+const isPlainObject = (test) => isObject(test) && test.constructor === Object;
+
+const isRegExp = (test) => type(test) == "regexp";
+
+const types = ["boolean", "number", "string"];
+
+const isScalar = (test) => types.indexOf(type(test)) != -1;
+
+const isSet = (test) => type(test) == "set";
+
+const isString = (test) => typeof test == "string";
+
+const isSymbol = (test) => typeof test == "symbol";
+
+const isUndefined = (test) => test === undefined;
+
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isConstructor = isConstructor;
+exports.isDate = isDate;
+exports.isDef = isDef;
+exports.isFloat = isFloat;
+exports.isFunction = isFunction;
+exports.isInteger = isInteger;
+exports.isMap = isMap;
 exports.isNil = isNil;
-exports.noop = noop;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isRegExp = isRegExp;
+exports.isScalar = isScalar;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isUndefined = isUndefined;
+exports.type = type;

package/dist/index.d.ts

@@ -1,9 +1,88 @@
 /*!
- * @klyper/utils v0.2.2
+ * @klyper/utils v0.2.3
  * Utility helpers for the Klyper ecosystem.
  * (c) 2026 Andrew Caires
  * @license: MIT
  */
-export declare function isNil(value: unknown): value is null | undefined;
-export declare function noop(): void;
-export declare function identity<T>(value: T): T;
+declare const isArray: (test: unknown) => test is Array<any>;
+
+declare const isBoolean: (test: unknown) => test is boolean;
+
+type TypeAnyConstructor<T = any> = new (...args: Array<any>) => T;
+type TypeAnyFunction<T = any> = (...args: Array<any>) => T;
+type TypeArray<T> = Array<T>;
+type TypeAnyArray = TypeArray<any>;
+type TypeStringArray = TypeArray<string>;
+type TypeNumberArray = TypeArray<number>;
+type TypeFunctionArray = TypeArray<TypeAnyFunction>;
+type TypeKey = number | string | symbol;
+type TypeOptional<T> = T | null | undefined;
+type TypeScalar = boolean | number | string;
+type Nullable<T> = T | null;
+type Maybe<T> = TypeOptional<T>;
+type EntityId = string;
+type TypeObject<T, K extends keyof any = string> = Record<K, T>;
+type TypeAnyObject = TypeObject<any>;
+type TypeBooleanObject = TypeObject<boolean>;
+type TypeFunctionObject = TypeObject<TypeAnyFunction>;
+type TypeNumberObject = TypeObject<number>;
+type TypeStringObject = TypeObject<string>;
+type TypeObjectOptional<T, K extends keyof T = keyof T> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+} & {
+    [P in keyof T as P extends K ? P : never]?: T[P];
+};
+type TypeObjectRequired<T, K extends keyof T> = {
+    [P in K]-?: T[P];
+} & {
+    [P in Exclude<keyof T, K>]: T[P];
+};
+type TypeObjectKeys<T, F = any> = {
+    [K in keyof T]: T[K] extends F ? K : never;
+}[keyof T];
+type TypeObjectKeysFunction<T> = TypeObjectKeys<T, TypeAnyFunction>;
+type TypeCallback<T, K, O, R> = (value: T, key: K, object: O) => R;
+type TypeCallbackArray<T> = TypeCallback<T, number, TypeArray<T>, any>;
+type TypeCallbackMap<T> = TypeCallback<T, number, TypeArray<T>, T>;
+type TypeCallbackObject<T> = TypeCallback<T, string, TypeObject<T>, any>;
+
+declare const isConstructor: (test: unknown) => test is TypeAnyConstructor;
+
+declare const isDate: (test: unknown) => test is Date;
+
+declare const isDef: <T = any>(test: unknown) => test is T;
+
+declare const isFloat: (test: unknown) => test is number;
+
+declare const isFunction: (test: unknown) => test is TypeAnyFunction;
+
+declare const isInteger: (test: unknown) => test is number;
+
+declare const isMap: <K = any, V = any>(test: unknown) => test is Map<K, V>;
+
+declare const isNil: (test: unknown) => test is null | undefined;
+
+declare const isNull: (test: unknown) => test is null;
+
+declare const isNumber: (test: unknown) => test is number;
+
+declare const isObject: (test: unknown) => test is TypeAnyObject;
+
+declare const isPlainObject: (test: unknown) => test is TypeAnyObject;
+
+declare const isRegExp: (test: unknown) => test is RegExp;
+
+declare const isScalar: (test: unknown) => test is TypeScalar;
+
+declare const isSet: <T = any>(test: unknown) => test is Set<T>;
+
+declare const isString: (test: unknown) => test is string;
+
+declare const isSymbol: (test: unknown) => test is symbol;
+
+declare const isUndefined: (test: unknown) => test is undefined;
+
+declare const type: (test: unknown) => string;
+
+export { isArray, isBoolean, isConstructor, isDate, isDef, isFloat, isFunction, isInteger, isMap, isNil, isNull, isNumber, isObject, isPlainObject, isRegExp, isScalar, isSet, isString, isSymbol, isUndefined, type };
+export type { EntityId, Maybe, Nullable, TypeAnyArray, TypeAnyConstructor, TypeAnyFunction, TypeAnyObject, TypeArray, TypeBooleanObject, TypeCallback, TypeCallbackArray, TypeCallbackMap, TypeCallbackObject, TypeFunctionArray, TypeFunctionObject, TypeKey, TypeNumberArray, TypeNumberObject, TypeObject, TypeObjectKeys, TypeObjectKeysFunction, TypeObjectOptional, TypeObjectRequired, TypeOptional, TypeScalar, TypeStringArray, TypeStringObject };

package/dist/index.js

@@ -1,17 +1,55 @@
 /*!
- * @klyper/utils v0.2.2
+ * @klyper/utils v0.2.3
  * Utility helpers for the Klyper ecosystem.
  * (c) 2026 Andrew Caires
  * @license: MIT
  */
-function isNil(value) {
-  return value === null || value === undefined;
-}
+const types$1 = {};
 
-function noop() {}
+const type = (test) => test == null ? "null" : types$1[types$1.toString.call(test)] || "object";
 
-function identity(value) {
-  return value;
-}
+["Array", "AsyncFunction", "Boolean", "Date", "Function", "Map", "Number", "Object", "RegExp", "Set", "String"].forEach((type) => types$1["[object " + type + "]"] = type.toLowerCase());
 
-export { identity, isNil, noop };
+const isArray = (test) => type(test) == "array";
+
+const isBoolean = (test) => type(test) == "boolean";
+
+const isFunction = (test) => typeof test == "function";
+
+const isConstructor = (test) => isFunction(test) && !!test.prototype && test.prototype.constructor === test;
+
+const isDate = (test) => type(test) == "date";
+
+const isDef = (test) => type(test) != "null";
+
+const isNumber = (test) => type(test) == "number";
+
+const isFloat = (test) => isNumber(test) && !!(test % 1);
+
+const isInteger = (test) => isNumber(test) && !(test % 1);
+
+const isMap = (test) => type(test) == "map";
+
+const isNil = (test) => test === null || test === undefined;
+
+const isNull = (test) => test === null;
+
+const isObject = (test) => type(test) == "object";
+
+const isPlainObject = (test) => isObject(test) && test.constructor === Object;
+
+const isRegExp = (test) => type(test) == "regexp";
+
+const types = ["boolean", "number", "string"];
+
+const isScalar = (test) => types.indexOf(type(test)) != -1;
+
+const isSet = (test) => type(test) == "set";
+
+const isString = (test) => typeof test == "string";
+
+const isSymbol = (test) => typeof test == "symbol";
+
+const isUndefined = (test) => test === undefined;
+
+export { isArray, isBoolean, isConstructor, isDate, isDef, isFloat, isFunction, isInteger, isMap, isNil, isNull, isNumber, isObject, isPlainObject, isRegExp, isScalar, isSet, isString, isSymbol, isUndefined, type };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@klyper/utils",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Utility helpers for the Klyper ecosystem.",
   "author": "Andrew Caires",
   "license": "MIT",