@jblib/is 0.0.3 → 0.0.4

package/dist/index.d.ts

@@ -1,3 +1,15 @@
+import { isArray } from "./is-array.js";
+import { isBoolean } from "./is-boolean.js";
+import { isDate } from "./is-date.js";
+import { isDefined } from "./is-defined.js";
+import { isEmptyObject } from "./is-empty-object.js";
+import { isError } from "./is-error.js";
+import { isFunction } from "./is-function.js";
+import { isNil } from "./is-nil.js";
+import { isNonEmptyArray } from "./is-non-empty-array.js";
 import { isNumber } from "./is-number.js";
+import { isObject } from "./is-object.js";
+import { isPlainObject } from "./is-plain-object.js";
+import { isPrimitive } from "./is-primitive.js";
 import { isString } from "./is-string.js";
-export { isNumber, isString };
+export { isArray, isBoolean, isDate, isDefined, isEmptyObject, isError, isFunction, isNil, isNonEmptyArray, isNumber, isObject, isPlainObject, isPrimitive, isString };

package/dist/index.js

@@ -1,4 +1,16 @@
+import { isArray } from "./is-array.js";
+import { isBoolean } from "./is-boolean.js";
+import { isDate } from "./is-date.js";
+import { isDefined } from "./is-defined.js";
+import { isPlainObject } from "./is-plain-object.js";
+import { isEmptyObject } from "./is-empty-object.js";
+import { isError } from "./is-error.js";
+import { isFunction } from "./is-function.js";
+import { isNil } from "./is-nil.js";
+import { isNonEmptyArray } from "./is-non-empty-array.js";
 import { isNumber } from "./is-number.js";
+import { isObject } from "./is-object.js";
+import { isPrimitive } from "./is-primitive.js";
 import { isString } from "./is-string.js";
 
-export { isNumber, isString };
+export { isArray, isBoolean, isDate, isDefined, isEmptyObject, isError, isFunction, isNil, isNonEmptyArray, isNumber, isObject, isPlainObject, isPrimitive, isString };

package/dist/is-array.d.ts

@@ -0,0 +1,21 @@
+//#region src/is-array.d.ts
+/**
+ * isArray checks if the provided value is an array.
+ *
+ * @param v value to check.
+ * @returns {v is unknown[]} returns true if the value is an array or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isArray([]) // true
+ * isArray([1, 2, 3]) // true
+ * isArray('hello') // false
+ * isArray({}) // false
+ * isArray(123) // false
+ * isArray(undefined) // false
+ * ```
+ */
+declare const isArray: (v: unknown) => v is unknown[];
+//#endregion
+export { isArray };
+//# sourceMappingURL=is-array.d.ts.map

package/dist/is-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array.d.ts","names":[],"sources":["../src/is-array.ts"],"mappings":";;;;;;;;;;;;;;;;;cAgBM,OAAA,GAAW,CAAA,cAAa,CAAA"}

package/dist/is-array.js

@@ -0,0 +1,22 @@
+//#region src/is-array.ts
+/**
+* isArray checks if the provided value is an array.
+*
+* @param v value to check.
+* @returns {v is unknown[]} returns true if the value is an array or otherwise false.
+*
+* @example
+* ```ts
+* isArray([]) // true
+* isArray([1, 2, 3]) // true
+* isArray('hello') // false
+* isArray({}) // false
+* isArray(123) // false
+* isArray(undefined) // false
+* ```
+*/
+const isArray = (v) => Array.isArray(v);
+
+//#endregion
+export { isArray };
+//# sourceMappingURL=is-array.js.map

package/dist/is-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array.js","names":[],"sources":["../src/is-array.ts"],"sourcesContent":["/**\n * isArray checks if the provided value is an array.\n *\n * @param v value to check.\n * @returns {v is unknown[]} returns true if the value is an array or otherwise false.\n *\n * @example\n * ```ts\n * isArray([]) // true\n * isArray([1, 2, 3]) // true\n * isArray('hello') // false\n * isArray({}) // false\n * isArray(123) // false\n * isArray(undefined) // false\n * ```\n */\nconst isArray = (v: unknown): v is unknown[] => Array.isArray(v)\n\nexport { isArray }\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,WAAW,MAA+B,MAAM,QAAQ,EAAE"}

package/dist/is-boolean.d.ts

@@ -0,0 +1,21 @@
+//#region src/is-boolean.d.ts
+/**
+ * isBoolean checks if a value is a boolean.
+ *
+ * @param v value to check.
+ * @returns {v is boolean} returns true if the value is a boolean or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isBoolean(true) // true
+ * isBoolean(false) // true
+ * isBoolean('hello') // false
+ * isBoolean(42) // false
+ * isBoolean(null) // false
+ * isBoolean(undefined) // false
+ * ```
+ */
+declare const isBoolean: (v: unknown) => v is boolean;
+//#endregion
+export { isBoolean };
+//# sourceMappingURL=is-boolean.d.ts.map

package/dist/is-boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-boolean.d.ts","names":[],"sources":["../src/is-boolean.ts"],"mappings":";;;;;;;;;;;;;;;;;cAgBM,SAAA,GAAa,CAAA,cAAa,CAAA"}

package/dist/is-boolean.js

@@ -0,0 +1,22 @@
+//#region src/is-boolean.ts
+/**
+* isBoolean checks if a value is a boolean.
+*
+* @param v value to check.
+* @returns {v is boolean} returns true if the value is a boolean or otherwise false.
+*
+* @example
+* ```ts
+* isBoolean(true) // true
+* isBoolean(false) // true
+* isBoolean('hello') // false
+* isBoolean(42) // false
+* isBoolean(null) // false
+* isBoolean(undefined) // false
+* ```
+*/
+const isBoolean = (v) => typeof v === "boolean";
+
+//#endregion
+export { isBoolean };
+//# sourceMappingURL=is-boolean.js.map

package/dist/is-boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-boolean.js","names":[],"sources":["../src/is-boolean.ts"],"sourcesContent":["/**\n * isBoolean checks if a value is a boolean.\n *\n * @param v value to check.\n * @returns {v is boolean} returns true if the value is a boolean or otherwise false.\n *\n * @example\n * ```ts\n * isBoolean(true) // true\n * isBoolean(false) // true\n * isBoolean('hello') // false\n * isBoolean(42) // false\n * isBoolean(null) // false\n * isBoolean(undefined) // false\n * ```\n */\nconst isBoolean = (v: unknown): v is boolean => typeof v === 'boolean'\n\nexport { isBoolean }\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,aAAa,MAA6B,OAAO,MAAM"}

package/dist/is-date.d.ts

@@ -0,0 +1,21 @@
+//#region src/is-date.d.ts
+/**
+ * isDate checks if the value is an instance of Date and is a valid date.
+ *
+ * @param v value to check.
+ * @returns {v instanceof Date} returns true if the value is an instance of Date and is a valid date or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isDate(new Date()) // true
+ * isDate(new Date('invalid date')) // false
+ * isDate('2022-01-01') // false
+ * isDate(1640995200000) // false
+ * isDate(null) // false
+ * isDate(undefined) // false
+ * ```
+ */
+declare const isDate: (v: unknown) => v is Date;
+//#endregion
+export { isDate };
+//# sourceMappingURL=is-date.d.ts.map

package/dist/is-date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-date.d.ts","names":[],"sources":["../src/is-date.ts"],"mappings":";;;;;;;;;;;;;;;;;cAgBM,MAAA,GAAU,CAAA,cAAa,CAAA,IAAK,IAAA"}

package/dist/is-date.js

@@ -0,0 +1,22 @@
+//#region src/is-date.ts
+/**
+* isDate checks if the value is an instance of Date and is a valid date.
+*
+* @param v value to check.
+* @returns {v instanceof Date} returns true if the value is an instance of Date and is a valid date or otherwise false.
+*
+* @example
+* ```ts
+* isDate(new Date()) // true
+* isDate(new Date('invalid date')) // false
+* isDate('2022-01-01') // false
+* isDate(1640995200000) // false
+* isDate(null) // false
+* isDate(undefined) // false
+* ```
+*/
+const isDate = (v) => v instanceof Date && !isNaN(v.getTime());
+
+//#endregion
+export { isDate };
+//# sourceMappingURL=is-date.js.map

package/dist/is-date.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-date.js","names":[],"sources":["../src/is-date.ts"],"sourcesContent":["/**\n * isDate checks if the value is an instance of Date and is a valid date.\n *\n * @param v value to check.\n * @returns {v instanceof Date} returns true if the value is an instance of Date and is a valid date or otherwise false.\n *\n * @example\n * ```ts\n * isDate(new Date()) // true\n * isDate(new Date('invalid date')) // false\n * isDate('2022-01-01') // false\n * isDate(1640995200000) // false\n * isDate(null) // false\n * isDate(undefined) // false\n * ```\n */\nconst isDate = (v: unknown): v is Date => v instanceof Date && !isNaN(v.getTime())\n\nexport { isDate }\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,UAAU,MAA0B,aAAa,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC"}

package/dist/is-defined.d.ts

@@ -0,0 +1,19 @@
+//#region src/is-defined.d.ts
+/**
+ * isDefined checks if a value is not null or undefined.
+ *
+ * @param v value to check.
+ * @returns {v is T} returns true if the value is defined (not null or undefined) or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isDefined(42) // true
+ * isDefined('hello') // true
+ * isDefined(null) // false
+ * isDefined(undefined) // false
+ * ```
+ */
+declare const isDefined: <T>(v: T | null | undefined) => v is T;
+//#endregion
+export { isDefined };
+//# sourceMappingURL=is-defined.d.ts.map

package/dist/is-defined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-defined.d.ts","names":[],"sources":["../src/is-defined.ts"],"mappings":";;;;;;;;;;;;;;;cAcM,SAAA,MAAgB,CAAA,EAAG,CAAA,wBAAuB,CAAA,IAAK,CAAA"}

package/dist/is-defined.js

@@ -0,0 +1,20 @@
+//#region src/is-defined.ts
+/**
+* isDefined checks if a value is not null or undefined.
+*
+* @param v value to check.
+* @returns {v is T} returns true if the value is defined (not null or undefined) or otherwise false.
+*
+* @example
+* ```ts
+* isDefined(42) // true
+* isDefined('hello') // true
+* isDefined(null) // false
+* isDefined(undefined) // false
+* ```
+*/
+const isDefined = (v) => v !== null && v !== void 0;
+
+//#endregion
+export { isDefined };
+//# sourceMappingURL=is-defined.js.map

package/dist/is-defined.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-defined.js","names":[],"sources":["../src/is-defined.ts"],"sourcesContent":["/**\n * isDefined checks if a value is not null or undefined.\n *\n * @param v value to check.\n * @returns {v is T} returns true if the value is defined (not null or undefined) or otherwise false.\n *\n * @example\n * ```ts\n * isDefined(42) // true\n * isDefined('hello') // true\n * isDefined(null) // false\n * isDefined(undefined) // false\n * ```\n */\nconst isDefined = <T>(v: T | null | undefined): v is T => v !== null && v !== undefined\n\nexport { isDefined }\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAM,aAAgB,MAAoC,MAAM,QAAQ,MAAM"}

package/dist/is-empty-object.d.ts

@@ -0,0 +1,23 @@
+//#region src/is-empty-object.d.ts
+/**
+ * isEmptyObject checks if a value is an empty object, that is,
+ * a plain object with no own properties.
+ *
+ * @param v value to check.
+ * @returns {v is Record<PropertyKey, never>} returns true if the value is an empty object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isEmptyObject({}) // true
+ * isEmptyObject(Object.create(null)) // true
+ * isEmptyObject({ a: 1 }) // false
+ * isEmptyObject([]) // false
+ * isEmptyObject(null) // false
+ * isEmptyObject('hello') // false
+ * isEmptyObject(42) // false
+ * ```
+ */
+declare const isEmptyObject: (v: unknown) => v is Record<PropertyKey, never>;
+//#endregion
+export { isEmptyObject };
+//# sourceMappingURL=is-empty-object.d.ts.map

package/dist/is-empty-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-object.d.ts","names":[],"sources":["../src/is-empty-object.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAoBM,aAAA,GAAiB,CAAA,cAAa,CAAA,IAAK,MAAA,CAAO,WAAA"}

package/dist/is-empty-object.js

@@ -0,0 +1,26 @@
+import { isPlainObject } from "./is-plain-object.js";
+
+//#region src/is-empty-object.ts
+/**
+* isEmptyObject checks if a value is an empty object, that is,
+* a plain object with no own properties.
+*
+* @param v value to check.
+* @returns {v is Record<PropertyKey, never>} returns true if the value is an empty object or otherwise false.
+*
+* @example
+* ```ts
+* isEmptyObject({}) // true
+* isEmptyObject(Object.create(null)) // true
+* isEmptyObject({ a: 1 }) // false
+* isEmptyObject([]) // false
+* isEmptyObject(null) // false
+* isEmptyObject('hello') // false
+* isEmptyObject(42) // false
+* ```
+*/
+const isEmptyObject = (v) => isPlainObject(v) && Reflect.ownKeys(v).length === 0;
+
+//#endregion
+export { isEmptyObject };
+//# sourceMappingURL=is-empty-object.js.map

package/dist/is-empty-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-object.js","names":[],"sources":["../src/is-empty-object.ts"],"sourcesContent":["import { isPlainObject } from './is-plain-object.js'\n\n/**\n * isEmptyObject checks if a value is an empty object, that is,\n * a plain object with no own properties.\n *\n * @param v value to check.\n * @returns {v is Record<PropertyKey, never>} returns true if the value is an empty object or otherwise false.\n *\n * @example\n * ```ts\n * isEmptyObject({}) // true\n * isEmptyObject(Object.create(null)) // true\n * isEmptyObject({ a: 1 }) // false\n * isEmptyObject([]) // false\n * isEmptyObject(null) // false\n * isEmptyObject('hello') // false\n * isEmptyObject(42) // false\n * ```\n */\nconst isEmptyObject = (v: unknown): v is Record<PropertyKey, never> =>\n  isPlainObject(v) && Reflect.ownKeys(v).length === 0\n\nexport { isEmptyObject }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,MAAM,iBAAiB,MACrB,cAAc,EAAE,IAAI,QAAQ,QAAQ,EAAE,CAAC,WAAW"}

package/dist/is-error.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-error.d.ts
+/**
+ * isError checks if the value is an instance of Error.
+ *
+ * @param v value to check.
+ * @returns {v is Error} returns true if the value is an instance of Error or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isError(new Error()) // true
+ * isError('hello') // false
+ * isError({}) // false
+ * isError(123) // false
+ * isError(null) // false
+ * ```
+ */
+declare const isError: (v: unknown) => v is Error;
+//#endregion
+export { isError };
+//# sourceMappingURL=is-error.d.ts.map

package/dist/is-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-error.d.ts","names":[],"sources":["../src/is-error.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,OAAA,GAAW,CAAA,cAAa,CAAA,IAAK,KAAA"}

package/dist/is-error.js

@@ -0,0 +1,21 @@
+//#region src/is-error.ts
+/**
+* isError checks if the value is an instance of Error.
+*
+* @param v value to check.
+* @returns {v is Error} returns true if the value is an instance of Error or otherwise false.
+*
+* @example
+* ```ts
+* isError(new Error()) // true
+* isError('hello') // false
+* isError({}) // false
+* isError(123) // false
+* isError(null) // false
+* ```
+*/
+const isError = (v) => v instanceof Error;
+
+//#endregion
+export { isError };
+//# sourceMappingURL=is-error.js.map

package/dist/is-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-error.js","names":[],"sources":["../src/is-error.ts"],"sourcesContent":["/**\n * isError checks if the value is an instance of Error.\n *\n * @param v value to check.\n * @returns {v is Error} returns true if the value is an instance of Error or otherwise false.\n *\n * @example\n * ```ts\n * isError(new Error()) // true\n * isError('hello') // false\n * isError({}) // false\n * isError(123) // false\n * isError(null) // false\n * ```\n */\nconst isError = (v: unknown): v is Error => v instanceof Error\n\nexport { isError }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,WAAW,MAA2B,aAAa"}

package/dist/is-function.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-function.d.ts
+/**
+ * isFunction checks if the provided value is a function.
+ *
+ * @param v value to check.
+ * @returns {v is (...args: unknown[]) => unknown} returns true if v is a function or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isFunction(() => {}) // true
+ * isFunction(function() {}) // true
+ * isFunction(async function() {}) // true
+ * isFunction('hello') // false
+ * isFunction({}) // false
+ * ```
+ */
+declare const isFunction: (v: unknown) => v is (...args: unknown[]) => unknown;
+//#endregion
+export { isFunction };
+//# sourceMappingURL=is-function.d.ts.map

package/dist/is-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-function.d.ts","names":[],"sources":["../src/is-function.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,UAAA,GAAc,CAAA,cAAa,CAAA,QAAS,IAAA"}

package/dist/is-function.js

@@ -0,0 +1,21 @@
+//#region src/is-function.ts
+/**
+* isFunction checks if the provided value is a function.
+*
+* @param v value to check.
+* @returns {v is (...args: unknown[]) => unknown} returns true if v is a function or otherwise false.
+*
+* @example
+* ```ts
+* isFunction(() => {}) // true
+* isFunction(function() {}) // true
+* isFunction(async function() {}) // true
+* isFunction('hello') // false
+* isFunction({}) // false
+* ```
+*/
+const isFunction = (v) => typeof v === "function";
+
+//#endregion
+export { isFunction };
+//# sourceMappingURL=is-function.js.map

package/dist/is-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-function.js","names":[],"sources":["../src/is-function.ts"],"sourcesContent":["/**\n * isFunction checks if the provided value is a function.\n *\n * @param v value to check.\n * @returns {v is (...args: unknown[]) => unknown} returns true if v is a function or otherwise false.\n *\n * @example\n * ```ts\n * isFunction(() => {}) // true\n * isFunction(function() {}) // true\n * isFunction(async function() {}) // true\n * isFunction('hello') // false\n * isFunction({}) // false\n * ```\n */\nconst isFunction = (v: unknown): v is (...args: unknown[]) => unknown => typeof v === 'function'\n\nexport { isFunction }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,cAAc,MAAqD,OAAO,MAAM"}

package/dist/is-nil.d.ts

@@ -0,0 +1,21 @@
+//#region src/is-nil.d.ts
+/**
+ * isNil checks if a value is null or undefined.
+ *
+ * @param v value to check.
+ * @returns {v is null | undefined} returns true if the value is null or undefined or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNil(null) // true
+ * isNil(undefined) // true
+ * isNil(42) // false
+ * isNil('hello') // false
+ * isNil({}) // false
+ * isNil([]) // false
+ * ```
+ */
+declare const isNil: (v: unknown) => v is null | undefined;
+//#endregion
+export { isNil };
+//# sourceMappingURL=is-nil.d.ts.map

package/dist/is-nil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-nil.d.ts","names":[],"sources":["../src/is-nil.ts"],"mappings":";;;;;;;;;;;;;;;;;cAgBM,KAAA,GAAS,CAAA,cAAa,CAAA"}

package/dist/is-nil.js

@@ -0,0 +1,22 @@
+//#region src/is-nil.ts
+/**
+* isNil checks if a value is null or undefined.
+*
+* @param v value to check.
+* @returns {v is null | undefined} returns true if the value is null or undefined or otherwise false.
+*
+* @example
+* ```ts
+* isNil(null) // true
+* isNil(undefined) // true
+* isNil(42) // false
+* isNil('hello') // false
+* isNil({}) // false
+* isNil([]) // false
+* ```
+*/
+const isNil = (v) => v === null || v === void 0;
+
+//#endregion
+export { isNil };
+//# sourceMappingURL=is-nil.js.map

package/dist/is-nil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-nil.js","names":[],"sources":["../src/is-nil.ts"],"sourcesContent":["/**\n * isNil checks if a value is null or undefined.\n *\n * @param v value to check.\n * @returns {v is null | undefined} returns true if the value is null or undefined or otherwise false.\n *\n * @example\n * ```ts\n * isNil(null) // true\n * isNil(undefined) // true\n * isNil(42) // false\n * isNil('hello') // false\n * isNil({}) // false\n * isNil([]) // false\n * ```\n */\nconst isNil = (v: unknown): v is null | undefined => v === null || v === undefined\n\nexport { isNil }\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,MAAM,SAAS,MAAsC,MAAM,QAAQ,MAAM"}

package/dist/is-non-empty-array.d.ts

@@ -0,0 +1,19 @@
+//#region src/is-non-empty-array.d.ts
+/**
+ * isNonEmptyArray checks if the provided value is an array and contains at least one element.
+ *
+ * @param v value to check.
+ * @returns {v is unknown[]} returns true if v is a non-empty array or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNonEmptyArray([1, 2, 3]) // true
+ * isNonEmptyArray([]) // false
+ * isNonEmptyArray('hello') // false
+ * isNonEmptyArray({}) // false
+ * ```
+ */
+declare const isNonEmptyArray: (v: unknown) => v is unknown[];
+//#endregion
+export { isNonEmptyArray };
+//# sourceMappingURL=is-non-empty-array.d.ts.map

package/dist/is-non-empty-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-non-empty-array.d.ts","names":[],"sources":["../src/is-non-empty-array.ts"],"mappings":";;;;;;;;;;;;;;;cAcM,eAAA,GAAmB,CAAA,cAAa,CAAA"}

package/dist/is-non-empty-array.js

@@ -0,0 +1,20 @@
+//#region src/is-non-empty-array.ts
+/**
+* isNonEmptyArray checks if the provided value is an array and contains at least one element.
+*
+* @param v value to check.
+* @returns {v is unknown[]} returns true if v is a non-empty array or otherwise false.
+*
+* @example
+* ```ts
+* isNonEmptyArray([1, 2, 3]) // true
+* isNonEmptyArray([]) // false
+* isNonEmptyArray('hello') // false
+* isNonEmptyArray({}) // false
+* ```
+*/
+const isNonEmptyArray = (v) => Array.isArray(v) && v.length > 0;
+
+//#endregion
+export { isNonEmptyArray };
+//# sourceMappingURL=is-non-empty-array.js.map

package/dist/is-non-empty-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-non-empty-array.js","names":[],"sources":["../src/is-non-empty-array.ts"],"sourcesContent":["/**\n * isNonEmptyArray checks if the provided value is an array and contains at least one element.\n *\n * @param v value to check.\n * @returns {v is unknown[]} returns true if v is a non-empty array or otherwise false.\n *\n * @example\n * ```ts\n * isNonEmptyArray([1, 2, 3]) // true\n * isNonEmptyArray([]) // false\n * isNonEmptyArray('hello') // false\n * isNonEmptyArray({}) // false\n * ```\n */\nconst isNonEmptyArray = (v: unknown): v is unknown[] => Array.isArray(v) && v.length > 0\n\nexport { isNonEmptyArray }\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAM,mBAAmB,MAA+B,MAAM,QAAQ,EAAE,IAAI,EAAE,SAAS"}

package/dist/is-object.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-object.d.ts
+/**
+ * isObject checks if the value is an object.
+ *
+ * @param v value to check.
+ * @returns {v is object} returns true if the value is an object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isObject({}) // true
+ * isObject([]) // true
+ * isObject(null) // false
+ * isObject('hello') // false
+ * isObject(42) // false
+ * ```
+ */
+declare const isObject: (v: unknown) => v is object;
+//#endregion
+export { isObject };
+//# sourceMappingURL=is-object.d.ts.map

package/dist/is-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-object.d.ts","names":[],"sources":["../src/is-object.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,QAAA,GAAY,CAAA,cAAa,CAAA"}

package/dist/is-object.js

@@ -0,0 +1,21 @@
+//#region src/is-object.ts
+/**
+* isObject checks if the value is an object.
+*
+* @param v value to check.
+* @returns {v is object} returns true if the value is an object or otherwise false.
+*
+* @example
+* ```ts
+* isObject({}) // true
+* isObject([]) // true
+* isObject(null) // false
+* isObject('hello') // false
+* isObject(42) // false
+* ```
+*/
+const isObject = (v) => typeof v === "object" && v !== null;
+
+//#endregion
+export { isObject };
+//# sourceMappingURL=is-object.js.map

package/dist/is-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-object.js","names":[],"sources":["../src/is-object.ts"],"sourcesContent":["/**\n * isObject checks if the value is an object.\n *\n * @param v value to check.\n * @returns {v is object} returns true if the value is an object or otherwise false.\n *\n * @example\n * ```ts\n * isObject({}) // true\n * isObject([]) // true\n * isObject(null) // false\n * isObject('hello') // false\n * isObject(42) // false\n * ```\n */\nconst isObject = (v: unknown): v is object => typeof v === 'object' && v !== null\n\nexport { isObject }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,YAAY,MAA4B,OAAO,MAAM,YAAY,MAAM"}

package/dist/is-plain-object.d.ts

@@ -0,0 +1,22 @@
+//#region src/is-plain-object.d.ts
+/**
+ * isPlainObject checks if a value is a plain object, that is,
+ * an object created by the Object constructor or with a null prototype.
+ *
+ * @param v value to check.
+ * @returns {v is Record<PropertyKey, unknown>} returns true if the value is a plain object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject(Object.create(null)) // true
+ * isPlainObject([]) // false
+ * isPlainObject(null) // false
+ * isPlainObject('hello') // false
+ * isPlainObject(42) // false
+ * ```
+ */
+declare const isPlainObject: (v: unknown) => v is Record<PropertyKey, unknown>;
+//#endregion
+export { isPlainObject };
+//# sourceMappingURL=is-plain-object.d.ts.map

package/dist/is-plain-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.d.ts","names":[],"sources":["../src/is-plain-object.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAiBM,aAAA,GAAiB,CAAA,cAAa,CAAA,IAAK,MAAA,CAAO,WAAA"}

package/dist/is-plain-object.js

@@ -0,0 +1,27 @@
+//#region src/is-plain-object.ts
+/**
+* isPlainObject checks if a value is a plain object, that is,
+* an object created by the Object constructor or with a null prototype.
+*
+* @param v value to check.
+* @returns {v is Record<PropertyKey, unknown>} returns true if the value is a plain object or otherwise false.
+*
+* @example
+* ```ts
+* isPlainObject({}) // true
+* isPlainObject(Object.create(null)) // true
+* isPlainObject([]) // false
+* isPlainObject(null) // false
+* isPlainObject('hello') // false
+* isPlainObject(42) // false
+* ```
+*/
+const isPlainObject = (v) => {
+	if (typeof v !== "object" || v === null) return false;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+};
+
+//#endregion
+export { isPlainObject };
+//# sourceMappingURL=is-plain-object.js.map

package/dist/is-plain-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["/**\n * isPlainObject checks if a value is a plain object, that is,\n * an object created by the Object constructor or with a null prototype.\n *\n * @param v value to check.\n * @returns {v is Record<PropertyKey, unknown>} returns true if the value is a plain object or otherwise false.\n *\n * @example\n * ```ts\n * isPlainObject({}) // true\n * isPlainObject(Object.create(null)) // true\n * isPlainObject([]) // false\n * isPlainObject(null) // false\n * isPlainObject('hello') // false\n * isPlainObject(42) // false\n * ```\n */\nconst isPlainObject = (v: unknown): v is Record<PropertyKey, unknown> => {\n  if (typeof v !== 'object' || v === null) {\n    return false\n  }\n\n  const proto = Object.getPrototypeOf(v) as unknown\n\n  return proto === Object.prototype || proto === null\n}\n\nexport { isPlainObject }\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,MAAM,iBAAiB,MAAkD;AACvE,KAAI,OAAO,MAAM,YAAY,MAAM,KACjC,QAAO;CAGT,MAAM,QAAQ,OAAO,eAAe,EAAE;AAEtC,QAAO,UAAU,OAAO,aAAa,UAAU"}

package/dist/is-primitive.d.ts

@@ -0,0 +1,27 @@
+//#region src/is-primitive.d.ts
+/**
+ * Primitive type represents the primitive values.
+ */
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * isPrimitive checks if a value is a primitive.
+ *
+ * @param v value to check.
+ * @returns {v is Primitive} returns true if the value is a primitive or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPrimitive(42) // true
+ * isPrimitive('hello') // true
+ * isPrimitive(true) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive({}) // false
+ * isPrimitive([]) // false
+ * isPrimitive(() => {}) // false
+ * ```
+ */
+declare const isPrimitive: (v: unknown) => v is Primitive;
+//#endregion
+export { isPrimitive };
+//# sourceMappingURL=is-primitive.d.ts.map

package/dist/is-primitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-primitive.d.ts","names":[],"sources":["../src/is-primitive.ts"],"mappings":";;;;KAGK,SAAA;;;AAAS;;;;;;;;;;;;;;;;cAoBR,WAAA,GAAe,CAAA,cAAa,CAAA,IAAK,SAAA"}

package/dist/is-primitive.js

@@ -0,0 +1,24 @@
+//#region src/is-primitive.ts
+/**
+* isPrimitive checks if a value is a primitive.
+*
+* @param v value to check.
+* @returns {v is Primitive} returns true if the value is a primitive or otherwise false.
+*
+* @example
+* ```ts
+* isPrimitive(42) // true
+* isPrimitive('hello') // true
+* isPrimitive(true) // true
+* isPrimitive(null) // true
+* isPrimitive(undefined) // true
+* isPrimitive({}) // false
+* isPrimitive([]) // false
+* isPrimitive(() => {}) // false
+* ```
+*/
+const isPrimitive = (v) => v === null || typeof v !== "object" && typeof v !== "function";
+
+//#endregion
+export { isPrimitive };
+//# sourceMappingURL=is-primitive.js.map

package/dist/is-primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-primitive.js","names":[],"sources":["../src/is-primitive.ts"],"sourcesContent":["/**\n * Primitive type represents the primitive values.\n */\ntype Primitive = string | number | boolean | bigint | symbol | null | undefined\n\n/**\n * isPrimitive checks if a value is a primitive.\n *\n * @param v value to check.\n * @returns {v is Primitive} returns true if the value is a primitive or otherwise false.\n *\n * @example\n * ```ts\n * isPrimitive(42) // true\n * isPrimitive('hello') // true\n * isPrimitive(true) // true\n * isPrimitive(null) // true\n * isPrimitive(undefined) // true\n * isPrimitive({}) // false\n * isPrimitive([]) // false\n * isPrimitive(() => {}) // false\n * ```\n */\nconst isPrimitive = (v: unknown): v is Primitive => v === null || (typeof v !== 'object' && typeof v !== 'function')\n\nexport { isPrimitive }\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuBA,MAAM,eAAe,MAA+B,MAAM,QAAS,OAAO,MAAM,YAAY,OAAO,MAAM"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jblib/is",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "is, condition checks",
   "type": "module",
   "devDependencies": {

package/src/index.ts

@@ -1,4 +1,14 @@
-import { isNumber } from './is-number.js'
-import { isString } from './is-string.js'
-
-export { isNumber, isString }
+export { isArray } from './is-array.js'
+export { isBoolean } from './is-boolean.js'
+export { isDate } from './is-date.js'
+export { isDefined } from './is-defined.js'
+export { isEmptyObject } from './is-empty-object.js'
+export { isError } from './is-error.js'
+export { isFunction } from './is-function.js'
+export { isNil } from './is-nil.js'
+export { isNonEmptyArray } from './is-non-empty-array.js'
+export { isNumber } from './is-number.js'
+export { isObject } from './is-object.js'
+export { isPlainObject } from './is-plain-object.js'
+export { isPrimitive } from './is-primitive.js'
+export { isString } from './is-string.js'

package/src/is-boolean.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { isBoolean } from './is-boolean.js'
+
+describe('is boolean', () => {
+  it('should return true for booleans', () => {
+    expect(isBoolean(true)).toBe(true)
+    expect(isBoolean(false)).toBe(true)
+  })
+
+  it('should return false for non-booleans', () => {
+    expect(isBoolean('hello')).toBe(false)
+    expect(isBoolean({})).toBe(false)
+    expect(isBoolean(123)).toBe(false)
+    expect(isBoolean(null)).toBe(false)
+    expect(isBoolean(undefined)).toBe(false)
+  })
+})

package/src/is-boolean.ts

@@ -0,0 +1,19 @@
+/**
+ * isBoolean checks if a value is a boolean.
+ *
+ * @param v value to check.
+ * @returns {v is boolean} returns true if the value is a boolean or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isBoolean(true) // true
+ * isBoolean(false) // true
+ * isBoolean('hello') // false
+ * isBoolean(42) // false
+ * isBoolean(null) // false
+ * isBoolean(undefined) // false
+ * ```
+ */
+const isBoolean = (v: unknown): v is boolean => typeof v === 'boolean'
+
+export { isBoolean }

package/src/is-date.spec.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { isDate } from './is-date.js'
+
+describe('is date', () => {
+  it('should return true for valid dates', () => {
+    expect(isDate(new Date())).toBe(true)
+  })
+
+  it('should return false for invalid dates', () => {
+    expect(isDate(new Date('invalid date'))).toBe(false)
+  })
+
+  it('should return false for non-date values', () => {
+    expect(isDate('2022-01-01')).toBe(false)
+    expect(isDate(1640995200000)).toBe(false)
+    expect(isDate({})).toBe(false)
+    expect(isDate(null)).toBe(false)
+    expect(isDate(undefined)).toBe(false)
+  })
+})

package/src/is-date.ts

@@ -0,0 +1,19 @@
+/**
+ * isDate checks if the value is an instance of Date and is a valid date.
+ *
+ * @param v value to check.
+ * @returns {v instanceof Date} returns true if the value is an instance of Date and is a valid date or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isDate(new Date()) // true
+ * isDate(new Date('invalid date')) // false
+ * isDate('2022-01-01') // false
+ * isDate(1640995200000) // false
+ * isDate(null) // false
+ * isDate(undefined) // false
+ * ```
+ */
+const isDate = (v: unknown): v is Date => v instanceof Date && !isNaN(v.getTime())
+
+export { isDate }

package/src/is-defined.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+
+import { isDefined } from './is-defined.js'
+
+describe('is defined', () => {
+  it('should return true for defined values', () => {
+    expect(isDefined(42)).toBe(true)
+    expect(isDefined('hello')).toBe(true)
+  })
+
+  it('should return false for null or undefined', () => {
+    expect(isDefined(null)).toBe(false)
+    expect(isDefined(undefined)).toBe(false)
+  })
+})

package/src/is-defined.ts

@@ -0,0 +1,17 @@
+/**
+ * isDefined checks if a value is not null or undefined.
+ *
+ * @param v value to check.
+ * @returns {v is T} returns true if the value is defined (not null or undefined) or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isDefined(42) // true
+ * isDefined('hello') // true
+ * isDefined(null) // false
+ * isDefined(undefined) // false
+ * ```
+ */
+const isDefined = <T>(v: T | null | undefined): v is T => v !== null && v !== undefined
+
+export { isDefined }

package/src/is-empty-object.spec.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest'
+
+import { isEmptyObject } from './is-empty-object.js'
+
+describe('is empty object', () => {
+  it('should return true for empty objects', () => {
+    expect(isEmptyObject({})).toBe(true)
+    expect(isEmptyObject(Object.create(null))).toBe(true)
+  })
+
+  it('should return false for non-empty objects', () => {
+    expect(
+      isEmptyObject({
+        a: 1,
+      }),
+    ).toBe(false)
+  })
+
+  it('should return false for non-object values', () => {
+    expect(isEmptyObject([])).toBe(false)
+    expect(isEmptyObject(null)).toBe(false)
+    expect(isEmptyObject('hello')).toBe(false)
+    expect(isEmptyObject(42)).toBe(false)
+  })
+})

package/src/is-empty-object.ts

@@ -0,0 +1,24 @@
+import { isPlainObject } from './is-plain-object.js'
+
+/**
+ * isEmptyObject checks if a value is an empty object, that is,
+ * a plain object with no own properties.
+ *
+ * @param v value to check.
+ * @returns {v is Record<PropertyKey, never>} returns true if the value is an empty object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isEmptyObject({}) // true
+ * isEmptyObject(Object.create(null)) // true
+ * isEmptyObject({ a: 1 }) // false
+ * isEmptyObject([]) // false
+ * isEmptyObject(null) // false
+ * isEmptyObject('hello') // false
+ * isEmptyObject(42) // false
+ * ```
+ */
+const isEmptyObject = (v: unknown): v is Record<PropertyKey, never> =>
+  isPlainObject(v) && Reflect.ownKeys(v).length === 0
+
+export { isEmptyObject }

package/src/is-error.spec.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+
+import { isError } from './is-error.js'
+
+describe('is error', () => {
+  it('should return true for errors', () => {
+    expect(isError(new Error())).toBe(true)
+    expect(isError(new Error('error message'))).toBe(true)
+  })
+
+  it('should return false for non-errors', () => {
+    expect(isError('hello')).toBe(false)
+    expect(isError({})).toBe(false)
+    expect(isError(123)).toBe(false)
+    expect(isError(null)).toBe(false)
+    expect(isError(undefined)).toBe(false)
+    expect(isError([])).toBe(false)
+  })
+})

package/src/is-error.ts

@@ -0,0 +1,18 @@
+/**
+ * isError checks if the value is an instance of Error.
+ *
+ * @param v value to check.
+ * @returns {v is Error} returns true if the value is an instance of Error or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isError(new Error()) // true
+ * isError('hello') // false
+ * isError({}) // false
+ * isError(123) // false
+ * isError(null) // false
+ * ```
+ */
+const isError = (v: unknown): v is Error => v instanceof Error
+
+export { isError }

package/src/is-nil.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { isNil } from './is-nil.js'
+
+describe('is nil', () => {
+  it('should return true for null and undefined', () => {
+    expect(isNil(null)).toBe(true)
+    expect(isNil(undefined)).toBe(true)
+  })
+
+  it('should return false for non-nil values', () => {
+    expect(isNil(42)).toBe(false)
+    expect(isNil('hello')).toBe(false)
+    expect(isNil({})).toBe(false)
+    expect(isNil([])).toBe(false)
+  })
+})

package/src/is-nil.ts

@@ -0,0 +1,19 @@
+/**
+ * isNil checks if a value is null or undefined.
+ *
+ * @param v value to check.
+ * @returns {v is null | undefined} returns true if the value is null or undefined or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNil(null) // true
+ * isNil(undefined) // true
+ * isNil(42) // false
+ * isNil('hello') // false
+ * isNil({}) // false
+ * isNil([]) // false
+ * ```
+ */
+const isNil = (v: unknown): v is null | undefined => v === null || v === undefined
+
+export { isNil }

package/src/is-object.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { isObject } from './is-object.js'
+
+describe('is object', () => {
+  it('should return true for objects', () => {
+    expect(isObject({})).toBe(true)
+    expect(isObject([])).toBe(true)
+  })
+
+  it('should return false for non-objects', () => {
+    expect(isObject('hello')).toBe(false)
+    expect(isObject(123)).toBe(false)
+    expect(isObject(null)).toBe(false)
+    expect(isObject(undefined)).toBe(false)
+  })
+})

package/src/is-object.ts

@@ -0,0 +1,18 @@
+/**
+ * isObject checks if the value is an object.
+ *
+ * @param v value to check.
+ * @returns {v is object} returns true if the value is an object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isObject({}) // true
+ * isObject([]) // true
+ * isObject(null) // false
+ * isObject('hello') // false
+ * isObject(42) // false
+ * ```
+ */
+const isObject = (v: unknown): v is object => typeof v === 'object' && v !== null
+
+export { isObject }

package/src/is-plain-object.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { isPlainObject } from './is-plain-object.js'
+
+describe('is plain object', () => {
+  it('should return true for plain objects', () => {
+    expect(isPlainObject({})).toBe(true)
+    expect(isPlainObject(Object.create(null))).toBe(true)
+  })
+
+  it('should return false for non-plain objects', () => {
+    expect(isPlainObject([])).toBe(false)
+    expect(isPlainObject(null)).toBe(false)
+    expect(isPlainObject(undefined)).toBe(false)
+    expect(isPlainObject('hello')).toBe(false)
+    expect(isPlainObject(42)).toBe(false)
+  })
+})

package/src/is-plain-object.ts

@@ -0,0 +1,28 @@
+/**
+ * isPlainObject checks if a value is a plain object, that is,
+ * an object created by the Object constructor or with a null prototype.
+ *
+ * @param v value to check.
+ * @returns {v is Record<PropertyKey, unknown>} returns true if the value is a plain object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPlainObject({}) // true
+ * isPlainObject(Object.create(null)) // true
+ * isPlainObject([]) // false
+ * isPlainObject(null) // false
+ * isPlainObject('hello') // false
+ * isPlainObject(42) // false
+ * ```
+ */
+const isPlainObject = (v: unknown): v is Record<PropertyKey, unknown> => {
+  if (typeof v !== 'object' || v === null) {
+    return false
+  }
+
+  const proto = Object.getPrototypeOf(v) as unknown
+
+  return proto === Object.prototype || proto === null
+}
+
+export { isPlainObject }

package/src/is-primitive.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { isPrimitive } from './is-primitive.js'
+
+describe('is primitive', () => {
+  it('should return true for primitives', () => {
+    expect(isPrimitive(42)).toBe(true)
+    expect(isPrimitive('hello')).toBe(true)
+    expect(isPrimitive(true)).toBe(true)
+    expect(isPrimitive(null)).toBe(true)
+    expect(isPrimitive(undefined)).toBe(true)
+  })
+
+  it('should return false for non-primitives', () => {
+    expect(isPrimitive({})).toBe(false)
+    expect(isPrimitive([])).toBe(false)
+    expect(
+      isPrimitive(() => {
+        void 0
+      }),
+    ).toBe(false)
+  })
+})

package/src/is-primitive.ts

@@ -0,0 +1,26 @@
+/**
+ * Primitive type represents the primitive values.
+ */
+type Primitive = string | number | boolean | bigint | symbol | null | undefined
+
+/**
+ * isPrimitive checks if a value is a primitive.
+ *
+ * @param v value to check.
+ * @returns {v is Primitive} returns true if the value is a primitive or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPrimitive(42) // true
+ * isPrimitive('hello') // true
+ * isPrimitive(true) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive({}) // false
+ * isPrimitive([]) // false
+ * isPrimitive(() => {}) // false
+ * ```
+ */
+const isPrimitive = (v: unknown): v is Primitive => v === null || (typeof v !== 'object' && typeof v !== 'function')
+
+export { isPrimitive }