@jblib/is 0.0.5 → 0.0.7

package/dist/is-truthy.js

@@ -0,0 +1,30 @@
+//#region src/is-truthy.ts
+/**
+* isTruthy checks if a value is truthy. A value is considered truthy if it is not falsy.
+* Falsy values are false, 0, 0n, '', null, and undefined.
+* Useful for type narrowing in conditional statements.
+* See isFalsy for the opposite of isTruthy.
+*
+* @param v value to check.
+* @returns {v is Exclude<T, Falsy>} returns true if v is truthy or otherwise false.
+*
+* @example
+* ```ts
+* isTruthy(true) // true
+* isTruthy(1) // true
+* isTruthy('hello') // true
+* isTruthy([]) // true
+* isTruthy({}) // true
+* isTruthy(false) // false
+* isTruthy(0) // false
+* isTruthy(0n) // false
+* isTruthy('') // false
+* isTruthy(null) // false
+* isTruthy(undefined) // false
+* ```
+*/
+const isTruthy = (v) => !!v;
+
+//#endregion
+export { isTruthy };
+//# sourceMappingURL=is-truthy.js.map

package/dist/is-truthy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-truthy.js","names":[],"sources":["../src/is-truthy.ts"],"sourcesContent":["import { type Falsy } from './is-falsy.js'\n\n/**\n * isTruthy checks if a value is truthy. A value is considered truthy if it is not falsy.\n * Falsy values are false, 0, 0n, '', null, and undefined.\n * Useful for type narrowing in conditional statements.\n * See isFalsy for the opposite of isTruthy.\n *\n * @param v value to check.\n * @returns {v is Exclude<T, Falsy>} returns true if v is truthy or otherwise false.\n *\n * @example\n * ```ts\n * isTruthy(true) // true\n * isTruthy(1) // true\n * isTruthy('hello') // true\n * isTruthy([]) // true\n * isTruthy({}) // true\n * isTruthy(false) // false\n * isTruthy(0) // false\n * isTruthy(0n) // false\n * isTruthy('') // false\n * isTruthy(null) // false\n * isTruthy(undefined) // false\n * ```\n */\nconst isTruthy = <T>(v: T): v is Exclude<T, Falsy> => !!v\n\nexport { isTruthy }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAM,YAAe,MAAiC,CAAC,CAAC"}

package/dist/is-undefined.d.ts

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

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

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

package/dist/is-undefined.js

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

package/dist/is-undefined.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-undefined.js","names":[],"sources":["../src/is-undefined.ts"],"sourcesContent":["/**\n * isUndefined checks if a value is undefined.\n *\n * @param v value to check.\n * @returns {v is undefined} returns true if v is undefined or otherwise false.\n *\n * @example\n * ```ts\n * isUndefined(undefined) // true\n * isUndefined('hello') // false\n * isUndefined(123) // false\n * isUndefined({}) // false\n * isUndefined([]) // false\n * ```\n */\nconst isUndefined = (v: unknown): v is undefined => v === undefined\n\nexport { isUndefined }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,eAAe,MAA+B,MAAM"}

package/package.json

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

package/src/index.ts

@@ -2,13 +2,25 @@ 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 { isEmptyArray } from './is-empty-array.js'
 export { isEmptyObject } from './is-empty-object.js'
 export { isError } from './is-error.js'
+export { isFalsy } from './is-falsy.js'
 export { isFunction } from './is-function.js'
+export { isMap } from './is-map.js'
+export { isNegativeNumber } from './is-negative-number.js'
 export { isNil } from './is-nil.js'
 export { isNonEmptyArray } from './is-non-empty-array.js'
+export { isNull } from './is-null.js'
 export { isNumber } from './is-number.js'
 export { isObject } from './is-object.js'
 export { isPlainObject } from './is-plain-object.js'
+export { isPositiveNumber } from './is-positive-number.js'
 export { isPrimitive } from './is-primitive.js'
+export { isPromise } from './is-promise.js'
+export { isRegExp } from './is-reg-exp.js'
+export { isSet } from './is-set.js'
 export { isString } from './is-string.js'
+export { isSymbol } from './is-symbol.js'
+export { isTruthy } from './is-truthy.js'
+export { isUndefined } from './is-undefined.js'

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

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { isEmptyArray } from './is-empty-array.js'
+
+describe('is empty array', () => {
+  it('should return true for empty arrays', () => {
+    expect(isEmptyArray([])).toBe(true)
+  })
+
+  it('should return false for non-empty arrays', () => {
+    expect(isEmptyArray([1, 2, 3])).toBe(false)
+  })
+
+  it('should return false for non-arrays', () => {
+    expect(isEmptyArray('hello')).toBe(false)
+    expect(isEmptyArray({})).toBe(false)
+    expect(isEmptyArray(123)).toBe(false)
+    expect(isEmptyArray(null)).toBe(false)
+    expect(isEmptyArray(undefined)).toBe(false)
+  })
+})

package/src/is-empty-array.ts

@@ -0,0 +1,17 @@
+/**
+ * isEmptyArray checks if the value is an empty array.
+ *
+ * @param v value to check.
+ * @returns {v is unknown[]} returns true if v is an empty array or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isEmptyArray([]) // true
+ * isEmptyArray([1, 2, 3]) // false
+ * isEmptyArray('hello') // false
+ * isEmptyArray({}) // false
+ * ```
+ */
+const isEmptyArray = (v: unknown): v is unknown[] => Array.isArray(v) && v.length === 0
+
+export { isEmptyArray }

package/src/is-falsy.spec.ts

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

package/src/is-falsy.ts

@@ -0,0 +1,31 @@
+type Falsy = false | 0 | 0n | '' | null | undefined
+
+/**
+ * isFalsy checks if a value is falsy.
+ * A value is considered falsy if it is false, 0, 0n, '', null, or undefined.
+ * Useful for type narrowing in conditional statements.
+ * See isTruthy for the opposite of isFalsy.
+ *
+ * @param v value to check.
+ * @returns {v is Extract<T, Falsy>} returns true if v is falsy or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isFalsy(false) // true
+ * isFalsy(0) // true
+ * isFalsy(0n) // true
+ * isFalsy('') // true
+ * isFalsy(null) // true
+ * isFalsy(undefined) // true
+ * isFalsy(true) // false
+ * isFalsy(1) // false
+ * isFalsy('hello') // false
+ * isFalsy([]) // false
+ * isFalsy({}) // false
+ * ```
+ */
+const isFalsy = <T>(v: T): v is Extract<T, Falsy> => !v
+
+export type { Falsy }
+
+export { isFalsy }

package/src/is-map.spec.ts

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

package/src/is-map.ts

@@ -0,0 +1,18 @@
+/**
+ * isMap checks if a value is a Map.
+ *
+ * @param v value to check.
+ * @returns {v is Map<unknown, unknown>} returns true if v is a Map or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isMap(new Map()) // true
+ * isMap(new Set()) // false
+ * isMap([]) // false
+ * isMap({}) // false
+ * isMap('hello') // false
+ * ```
+ */
+const isMap = (v: unknown): v is Map<unknown, unknown> => v instanceof Map
+
+export { isMap }

package/src/is-negative-number.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+
+import { isNegativeNumber } from './is-negative-number.js'
+
+describe('is negative number', () => {
+  it('should return true for negative numbers', () => {
+    expect(isNegativeNumber(-5)).toBe(true)
+  })
+
+  it('should return false for non-negative numbers', () => {
+    expect(isNegativeNumber(5)).toBe(false)
+    expect(isNegativeNumber(0)).toBe(false)
+    expect(isNegativeNumber('hello')).toBe(false)
+  })
+})

package/src/is-negative-number.ts

@@ -0,0 +1,20 @@
+/**
+ * isNegativeNumber checks if a value is a negative number.
+ * Note that zero is not considered a negative number.
+ *
+ * @param v value to check.
+ * @returns {v is number} returns true if v is a negative number or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNegativeNumber(-5) // true
+ * isNegativeNumber(5) // false
+ * isNegativeNumber(0) // false
+ * isNegativeNumber('hello') // false
+ * ```
+ */
+const isNegativeNumber = (v: unknown): v is number => {
+  return typeof v === 'number' && v < 0
+}
+
+export { isNegativeNumber }

package/src/is-null.spec.ts

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

package/src/is-null.ts

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

package/src/is-positive-number.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+
+import { isPositiveNumber } from './is-positive-number.js'
+
+describe('is positive number', () => {
+  it('should return true for positive numbers', () => {
+    expect(isPositiveNumber(5)).toBe(true)
+  })
+
+  it('should return false for non-positive numbers', () => {
+    expect(isPositiveNumber(-5)).toBe(false)
+    expect(isPositiveNumber(0)).toBe(false)
+    expect(isPositiveNumber('hello')).toBe(false)
+  })
+})

package/src/is-positive-number.ts

@@ -0,0 +1,20 @@
+/**
+ * isPositiveNumber checks if a value is a positive number.
+ * Note that zero is not considered a positive number.
+ *
+ * @param value value to check.
+ * @returns {value is number} returns true if value is a positive number or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPositiveNumber(5) // true
+ * isPositiveNumber(-5) // false
+ * isPositiveNumber(0) // false
+ * isPositiveNumber('hello') // false
+ * ```
+ */
+const isPositiveNumber = (value: unknown): value is number => {
+  return typeof value === 'number' && value > 0
+}
+
+export { isPositiveNumber }

package/src/is-promise.spec.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import { isPromise } from './is-promise.js'
+
+describe('is promise', () => {
+  it('should return true for promises', () => {
+    expect(
+      isPromise({
+        then: () => {
+          void 0
+        },
+        catch: () => {
+          void 0
+        },
+      }),
+    ).toBe(true)
+    expect(isPromise(Promise.resolve())).toBe(true)
+  })
+
+  it('should return false for non-promises', () => {
+    expect(isPromise(123)).toBe(false)
+    expect(isPromise({})).toBe(false)
+    expect(isPromise([])).toBe(false)
+    expect(isPromise(null)).toBe(false)
+    expect(isPromise(undefined)).toBe(false)
+  })
+})

package/src/is-promise.ts

@@ -0,0 +1,22 @@
+/**
+ * isPromise checks if a value is a Promise.
+ *
+ * @param v value to check.
+ * @returns {v is Promise<unknown>} returns true if v is a Promise or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPromise(Promise.resolve()) // true
+ * isPromise(new Set()) // false
+ * isPromise([]) // false
+ * isPromise({}) // false
+ * isPromise('hello') // false
+ * ```
+ */
+const isPromise = (v: unknown): v is Promise<unknown> =>
+  typeof v === 'object' &&
+  v !== null &&
+  typeof (v as Promise<unknown>).then === 'function' &&
+  typeof (v as Promise<unknown>).catch === 'function'
+
+export { isPromise }

package/src/is-reg-exp.spec.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+
+import { isRegExp } from './is-reg-exp.js'
+
+describe('is reg exp', () => {
+  it('should return true for regexp values', () => {
+    expect(isRegExp(/abc/)).toBe(true)
+    expect(isRegExp(new RegExp('abc'))).toBe(true)
+  })
+
+  it('should return false for non-regexp values', () => {
+    expect(isRegExp('abc')).toBe(false)
+    expect(isRegExp(123)).toBe(false)
+    expect(isRegExp({})).toBe(false)
+    expect(isRegExp([])).toBe(false)
+    expect(isRegExp(null)).toBe(false)
+    expect(isRegExp(undefined)).toBe(false)
+  })
+})

package/src/is-reg-exp.ts

@@ -0,0 +1,21 @@
+/**
+ * isRegExp checks if a value is a regular expression.
+ *
+ * @param v value to check.
+ * @returns {v is RegExp} returns true if v is a RegExp or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isRegExp(/abc/) // true
+ * isRegExp(new RegExp('abc')) // true
+ * isRegExp('abc') // false
+ * isRegExp(123) // false
+ * isRegExp({}) // false
+ * isRegExp([]) // false
+ * isRegExp(null) // false
+ * isRegExp(undefined) // false
+ * ```
+ */
+const isRegExp = (v: unknown): v is RegExp => v instanceof RegExp
+
+export { isRegExp }

package/src/is-set.spec.ts

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

package/src/is-set.ts

@@ -0,0 +1,18 @@
+/**
+ * isSet checks if a value is a Set.
+ *
+ * @param v value to check.
+ * @returns {v is Set<unknown>} returns true if v is a Set or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isSet(new Set()) // true
+ * isSet(new Map()) // false
+ * isSet([]) // false
+ * isSet({}) // false
+ * isSet('hello') // false
+ * ```
+ */
+const isSet = (v: unknown): v is Set<unknown> => v instanceof Set
+
+export { isSet }

package/src/is-symbol.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { isSymbol } from './is-symbol.js'
+
+describe('is symbol', () => {
+  it('should return true for symbols', () => {
+    expect(isSymbol(Symbol('foo'))).toBe(true)
+  })
+
+  it('should return false for non-symbols', () => {
+    expect(isSymbol(123)).toBe(false)
+    expect(isSymbol('hello')).toBe(false)
+    expect(isSymbol({})).toBe(false)
+    expect(isSymbol([])).toBe(false)
+    expect(isSymbol(null)).toBe(false)
+    expect(isSymbol(undefined)).toBe(false)
+  })
+})

package/src/is-symbol.ts

@@ -0,0 +1,18 @@
+/**
+ * isSymbol checks if a value is a symbol.
+ *
+ * @param v value to check.
+ * @returns {v is symbol} returns true if v is a symbol or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isSymbol(Symbol('foo')) // true
+ * isSymbol('hello') // false
+ * isSymbol(123) // false
+ * isSymbol({}) // false
+ * isSymbol([]) // false
+ * ```
+ */
+const isSymbol = (v: unknown): v is symbol => typeof v === 'symbol'
+
+export { isSymbol }

package/src/is-truthy.spec.ts

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

package/src/is-truthy.ts

@@ -0,0 +1,29 @@
+import { type Falsy } from './is-falsy.js'
+
+/**
+ * isTruthy checks if a value is truthy. A value is considered truthy if it is not falsy.
+ * Falsy values are false, 0, 0n, '', null, and undefined.
+ * Useful for type narrowing in conditional statements.
+ * See isFalsy for the opposite of isTruthy.
+ *
+ * @param v value to check.
+ * @returns {v is Exclude<T, Falsy>} returns true if v is truthy or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isTruthy(true) // true
+ * isTruthy(1) // true
+ * isTruthy('hello') // true
+ * isTruthy([]) // true
+ * isTruthy({}) // true
+ * isTruthy(false) // false
+ * isTruthy(0) // false
+ * isTruthy(0n) // false
+ * isTruthy('') // false
+ * isTruthy(null) // false
+ * isTruthy(undefined) // false
+ * ```
+ */
+const isTruthy = <T>(v: T): v is Exclude<T, Falsy> => !!v
+
+export { isTruthy }

package/src/is-undefined.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+
+import { isUndefined } from './is-undefined.js'
+
+describe('is undefined', () => {
+  it('should return true for undefined', () => {
+    expect(isUndefined(undefined)).toBe(true)
+  })
+
+  it('should return true for a type that could be undefined and is undefined', () => {
+    const v: string | undefined = undefined
+
+    expect(isUndefined(v)).toBe(true)
+  })
+
+  it('should return false for non-undefined values', () => {
+    expect(isUndefined(null)).toBe(false)
+    expect(isUndefined('hello')).toBe(false)
+    expect(isUndefined(123)).toBe(false)
+    expect(isUndefined({})).toBe(false)
+    expect(isUndefined([])).toBe(false)
+  })
+
+  it('should return false for a type that could be undefined and is not undefined', () => {
+    const v: string | undefined = 'hello'
+
+    expect(isUndefined(v)).toBe(false)
+  })
+})

package/src/is-undefined.ts

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