@gesslar/toolkit 0.1.2 → 0.1.4

package/README.md

@@ -1,4 +1,4 @@
-# npm i @gesslar/toolkit
+# `npm i @gesslar/toolkit`
 
 This package is intended to be a collection of useful utilities for any
 project's consumption. Not the kind that gives you bleeding, hacking coughs,

package/package.json

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

package/src/lib/Data.js

@@ -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/DirectoryObject.js

@@ -209,18 +209,17 @@ export default class DirectoryObject extends FS {
   /**
    * Lists the contents of a directory.
    *
-   * @param {DirectoryObject} directory - The directory to list.
    * @returns {Promise<{files: Array<FileObject>, directories: Array<DirectoryObject>}>} The files and directories in the directory.
    */
-  async read(directory) {
+  async read() {
     const found = await fs.readdir(
-      new URL(directory.uri),
+      new URL(this.uri),
       {withFileTypes: true}
     )
 
     const results = await Promise.all(
       found.map(async dirent => {
-        const fullPath = path.join(directory.path, dirent.name)
+        const fullPath = path.join(this.path, dirent.name)
         const stat = await fs.stat(fullPath)
 
         return {dirent, stat, fullPath}

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
 }