@jblib/is 0.0.2 → 0.0.4

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 }

package/src/is-string.ts

@@ -1,8 +1,15 @@
 /**
- * Checks if a value is a string.
+ * isString checks if the provided value is a string.
  *
- * @param v value to check
- * @returns boolean indicating if the value is a string
+ * @param v value to check.
+ * @returns {v is string} returns true if v is a string or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isString('hello') // true
+ * isString(123) // false
+ * isString({}) // false
+ * ```
  */
 const isString = (v: unknown): v is string => typeof v === 'string'