@rcompat/is 0.3.0 → 0.3.1

package/lib/private/index.d.ts

@@ -3,24 +3,36 @@ import newable from "#newable";
 import numeric from "#numeric";
 import object from "#object";
 import primitive from "#primitive";
-import type { Dict, Nullish } from "@rcompat/type";
+import type { Dict, Nullish, UnknownFunction } from "@rcompat/type";
 declare function isArray(x: unknown): x is unknown[];
+declare function isBigint(x: unknown): x is bigint;
+declare function isBoolean(x: unknown): x is boolean;
 declare function isDate(x: unknown): x is Date;
 declare function isDefined(x: unknown): x is {} | null;
 declare function isDict(x: unknown): x is Dict;
 declare function isError(x: unknown): x is Error;
 declare function isFalsy(x: unknown): boolean;
+declare function isFunction(x: unknown): x is UnknownFunction;
+declare function isIterable(x: unknown): x is Iterable<unknown>;
+declare function isMap(x: unknown): x is Map<unknown, unknown>;
+declare function isNull(x: unknown): x is null;
 declare function isNullish(x: unknown): x is Nullish;
+declare function isNumber(x: unknown): x is number;
 declare function isPromise(x: unknown): x is Promise<unknown>;
 declare function isRegExp(x: unknown): x is RegExp;
+declare function isSet(x: unknown): x is Set<unknown>;
+declare function isString(x: unknown): x is string;
+declare function isSymbol(x: unknown): x is symbol;
 declare function isTruthy(x: unknown): boolean;
+declare function isTypedArray(x: unknown): x is ArrayBufferView;
+declare function isUndefined(x: unknown): x is undefined;
 declare function isURL(x: unknown): x is URL;
-declare function isMap(x: unknown): x is Map<unknown, unknown>;
-declare function isSet(x: unknown): x is Set<unknown>;
 declare const _default: {
     array: typeof isArray;
+    bigint: typeof isBigint;
     blank: (x: unknown) => x is string;
     boolish: (x: unknown) => x is import("@rcompat/type").Boolish;
+    boolean: typeof isBoolean;
     date: typeof isDate;
     defined: typeof isDefined;
     dict: typeof isDict;
@@ -28,12 +40,16 @@ declare const _default: {
     error: typeof isError;
     falsy: typeof isFalsy;
     finite: (x: unknown) => x is bigint | number;
+    function: typeof isFunction;
     int: (x: unknown) => x is bigint | number;
+    iterable: typeof isIterable;
     map: typeof isMap;
     nan: (x: unknown) => x is number;
-    nonempty: (x: unknown) => boolean;
     newable: typeof newable;
+    nonempty: (x: unknown) => boolean;
+    null: typeof isNull;
     nullish: typeof isNullish;
+    number: typeof isNumber;
     numeric: typeof numeric;
     object: typeof object;
     primitive: typeof primitive;
@@ -41,8 +57,12 @@ declare const _default: {
     regexp: typeof isRegExp;
     safeint: (x: unknown) => x is number;
     set: typeof isSet;
+    string: typeof isString;
+    symbol: typeof isSymbol;
     truthy: typeof isTruthy;
+    typedarray: typeof isTypedArray;
     uint: (x: unknown) => x is bigint | number;
+    undefined: typeof isUndefined;
     url: typeof isURL;
 };
 export default _default;

package/lib/private/index.js

@@ -8,6 +8,12 @@ import strings from "#strings";
 function isArray(x) {
     return Array.isArray(x);
 }
+function isBigint(x) {
+    return typeof x === "bigint";
+}
+function isBoolean(x) {
+    return typeof x === "boolean";
+}
 function isDate(x) {
     return x instanceof Date;
 }
@@ -26,31 +32,57 @@ function isError(x) {
 function isFalsy(x) {
     return !x;
 }
+function isFunction(x) {
+    return typeof x === "function";
+}
+function isIterable(x) {
+    return typeof x?.[Symbol.iterator] === "function";
+}
+function isMap(x) {
+    return x instanceof Map;
+}
+function isNull(x) {
+    return x === null;
+}
 function isNullish(x) {
     return x === null || x === undefined;
 }
+function isNumber(x) {
+    return typeof x === "number";
+}
 function isPromise(x) {
     return x instanceof Promise;
 }
 function isRegExp(x) {
     return x instanceof RegExp;
 }
+function isSet(x) {
+    return x instanceof Set;
+}
+function isString(x) {
+    return typeof x === "string";
+}
+function isSymbol(x) {
+    return typeof x === "symbol";
+}
 function isTruthy(x) {
     return !!x;
 }
-function isURL(x) {
-    return x instanceof URL;
+function isTypedArray(x) {
+    return ArrayBuffer.isView(x);
 }
-function isMap(x) {
-    return x instanceof Map;
+function isUndefined(x) {
+    return x === undefined;
 }
-function isSet(x) {
-    return x instanceof Set;
+function isURL(x) {
+    return x instanceof URL;
 }
 export default {
     array: isArray,
+    bigint: isBigint,
     blank: strings.isBlank,
     boolish: strings.isBoolish,
+    boolean: isBoolean,
     date: isDate,
     defined: isDefined,
     dict: isDict,
@@ -58,12 +90,16 @@ export default {
     error: isError,
     falsy: isFalsy,
     finite: numbers.isFinite,
+    function: isFunction,
     int: numbers.isInt,
+    iterable: isIterable,
     map: isMap,
     nan: numbers.isNaN,
-    nonempty: (x) => !empty(x),
     newable,
+    nonempty: (x) => !empty(x),
+    null: isNull,
     nullish: isNullish,
+    number: isNumber,
     numeric,
     object,
     primitive,
@@ -71,8 +107,12 @@ export default {
     regexp: isRegExp,
     safeint: numbers.isSafeint,
     set: isSet,
+    string: isString,
+    symbol: isSymbol,
     truthy: isTruthy,
+    typedarray: isTypedArray,
     uint: numbers.isUint,
+    undefined: isUndefined,
     url: isURL,
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcompat/is",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Standard library identity checks",
   "bugs": "https://github.com/rcompat/rcompat/issues",
   "license": "MIT",