@gesslar/toolkit 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gesslar/toolkit",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Get in, bitches, we're going toolkitting.",
   "main": "./src/index.js",
   "type": "module",

package/src/lib/Data.js

@@ -273,9 +273,9 @@ export default class Data {
    * @returns {Promise<object>} The mapped object
    */
   static async mapObject(original, transformer, mutate = false) {
-    Valid.validType(original, "object", {allowEmpty: true})
-    Valid.validType(transformer, "function")
-    Valid.validType(mutate, "boolean")
+    Valid.type(original, "object", {allowEmpty: true})
+    Valid.type(transformer, "function")
+    Valid.type(mutate, "boolean")
 
     const result = mutate ? original : {}
 
@@ -565,4 +565,45 @@ export default class Data {
   static clamped(val, min, max) {
     return val >= min && val <= max
   }
+
+  /**
+   * Checks if a value is a plain object - created with object literals {},
+   * new Object(), or Object.create(null).
+   *
+   * Distinguishes plain objects from objects created by custom constructors, built-ins,
+   * or primitives. Plain objects only have Object.prototype or null in their prototype chain.
+   *
+   * @param {unknown} value - The value to check
+   * @returns {boolean} True if the value is a plain object, false otherwise
+   *
+   * @example
+   * isPlainObject({}) // true
+   * isPlainObject(new Object()) // true
+   * isPlainObject(Object.create(null)) // true
+   * isPlainObject([]) // false
+   * isPlainObject(new Date()) // false
+   * isPlainObject(null) // false
+   * isPlainObject("string") // false
+   * isPlainObject(class Person{}) // false
+   */
+  static isPlainObject(value) {
+    // First, check if it's an object and not null
+    if(typeof value !== "object" || value === null)
+      return false
+
+    // If it has no prototype, it's plain (created with Object.create(null))
+    const proto = Object.getPrototypeOf(value)
+
+    if(proto === null)
+      return true
+
+    // Check if the prototype chain ends at Object.prototype
+    // This handles objects created with {} or new Object()
+    let current = proto
+
+    while(Object.getPrototypeOf(current) !== null)
+      current = Object.getPrototypeOf(current)
+
+    return proto === current
+  }
 }

package/src/lib/Valid.js

@@ -5,14 +5,13 @@ import Data from "./Data.js"
 
 export default class Valid {
 /**
- * Validates a value against a type
+ * Validates a value against a type. Uses Data.isType.
  *
  * @param {unknown} value - The value to validate
- * @param {string} type - The expected type in the form of "object",
- *                        "object[]", "object|object[]"
+ * @param {string} type - The expected type in the form of "object", "object[]", "object|object[]"
  * @param {object} [options] - Additional options for validation.
  */
-  static validType(value, type, options) {
+  static type(value, type, options) {
     Valid.assert(
       Data.isType(value, type, options),
       `Invalid type. Expected ${type}, got ${JSON.stringify(value)}`,

package/src/types/Data.d.ts

@@ -248,4 +248,43 @@ export default class Data {
 
   /** Checks if a value is within a specified range (inclusive) */
   static clamped(val: number, min: number, max: number): boolean
+
+  /**
+   * Checks if a value is a plain object - created with object literals {}, 
+   * new Object(), or Object.create(null).
+   * 
+   * Distinguishes plain objects from objects created by custom constructors, built-ins, 
+   * or primitives. Plain objects only have Object.prototype or null in their prototype chain.
+   * Useful for validating configuration objects or data structures that should be plain objects.
+   *
+   * @param value - The value to check for plain object status
+   * @returns True if the value is a plain object, false otherwise
+   * 
+   * @example
+   * ```typescript
+   * import { Data } from '@gesslar/toolkit'
+   * 
+   * // Plain objects return true
+   * console.log(Data.isPlainObject({})) // true
+   * console.log(Data.isPlainObject(new Object())) // true 
+   * console.log(Data.isPlainObject(Object.create(null))) // true
+   * 
+   * // Non-plain objects return false
+   * console.log(Data.isPlainObject([])) // false
+   * console.log(Data.isPlainObject(new Date())) // false
+   * console.log(Data.isPlainObject(/regex/)) // false
+   * console.log(Data.isPlainObject(null)) // false
+   * console.log(Data.isPlainObject('string')) // false
+   * 
+   * // Useful for validating config objects
+   * function processConfig(config: unknown) {
+   *   if (!Data.isPlainObject(config)) {
+   *     throw new Error('Config must be a plain object')
+   *   }
+   *   // Safe to treat as object with string keys
+   *   return Object.entries(config)
+   * }
+   * ```
+   */
+  static isPlainObject(value: unknown): boolean
 }

package/src/types/Valid.d.ts

@@ -3,8 +3,8 @@
 
 export default class Valid {
   /** Validate a value against a type specification */
-  static validType(value: unknown, type: string, options?: { allowEmpty?: boolean }): void
+  static type(value: unknown, type: string, options?: { allowEmpty?: boolean }): void
 
   /** Assert a condition */
   static assert(condition: boolean, message: string, arg?: number | null): void
-}
+}