@nejs/basic-extensions 1.0.0 → 1.2.0

package/src/objectextensions.js

@@ -45,7 +45,47 @@ export const ObjectExtensions = new Patch(Object, {
    * @returns {string} - The string tag of the object, indicating its type.
    */
   getStringTag(value) {
-    return /(\w+)]/.exec(Object.prototype.toString.call(value))[1];
+    return /\s(.+)]/.exec(Object.prototype.toString.call(value))[1];
+  },
+
+  /**
+   * Strips an object down to only the keys specified. Optionally, any
+   * accessors can be made to retain their context on the source object.
+   *
+   * @param {object} object the object to pare down
+   * @param {Array<string|symbol>} keys the keys that should appear in the
+   * final reduced object
+   * @param {boolean} [bindAccessors = true] if this value is true
+   * then any accessors from the source object will continue to have their
+   * `this` value bound to the source. If the getter or setter on that object
+   * is defined using an arrow function, this will not work as intended.
+   * @returns {object} an object containing only the keys and symbols specified
+   * in the `keys` parameter.
+   */
+  stripTo(object, keys, bindAccessors = true) {
+    const result = {}
+
+    if (!Array.isArray(keys)) {
+      return result
+    }
+
+    for (let key of keys) {
+      if (Reflect.has(object, key)) {
+        const descriptor = Object.getOwnPropertyDescriptor(object, key)
+        if (Reflect.has(descriptor, 'get') || Reflect.has(descriptor, 'set')) {
+          if (bindAccessors) {
+            descriptor.get = descriptor?.get?.bind(object)
+            descriptor.set = descriptor?.set?.bind(object)
+          }
+          Object.defineProperty(result, descriptor)
+        }
+        else {
+          Object.defineProperty(result, descriptor)
+        }
+      }
+    }
+
+    return result
   },
 
   /**

package/src/reflectextensions.js

@@ -1,4 +1,5 @@
 import { Patch } from '@nejs/extension'
+import { ObjectExtensions } from './objectextensions.js'
 
 /**
  * The `ReflectExtensions` class is a patch applied to the built-in JavaScript
@@ -30,6 +31,32 @@ export const ReflectExtensions = new Patch(Reflect, {
     )
   },
 
+  ownDescriptors(object) {
+    const result = {}
+    const revertOnDone = () => revertOnDone.doIt ? ObjectExtensions.revert() : ''
+    revertOnDone.doIt = false
+
+    if (!Object.isObject) {
+      revertOnDone.doIt = true
+      ObjectExtensions.apply()
+    }
+
+    if (!Object.isObject(object)) {
+      revertOnDone()
+      return {}
+    }
+
+    const keys = Reflect.ownKeys(object)
+
+    for (const key of keys) {
+      result[key] = Object.getOwnPropertyDescriptor(key)
+    }
+
+    revertOnDone()
+
+    return result
+  },
+
   /**
    * The function checks if an object has at least one of the specified keys.
    *
@@ -86,4 +113,4 @@ export const ReflectExtensions = new Patch(Reflect, {
   values(object) {
     return Reflect.entries.map(([,value]) => value)
   }
-})
+})

package/src/stringextensions.js

@@ -0,0 +1,25 @@
+import { Patch } from '@nejs/extension';
+
+/**
+ * `StringExtensions` is a patch for the JavaScript built-in `String` class. It
+ * adds utility methods to the `String` class without modifying the global namespace
+ * directly. This patch includes methods for key validation, object type checking,
+ * and retrieving the string tag of an object. These methods are useful for
+ * enhancing the capabilities of the standard `String` class with additional
+ * utility functions.
+ */
+export const StringExtensions = new Patch(String, {
+  /**
+   * The `isString` method does exactly what one would it expect. It returns
+   * true if the string matches typeof or instanceof as a string.
+   *
+   * @param {*} value checks to see if the `value` is a string
+   * @returns {boolean} `true` if it is a `String`, `false` otherwise
+   */
+  isString(value) {
+    if (value && (typeof value === 'string' || value instanceof String)) {
+      return value.length > 0
+    }
+    return false
+  },
+});

package/src/symbolextensions.js

@@ -0,0 +1,25 @@
+import { Patch } from '@nejs/extension';
+
+/**
+ * `SymbolExtensions` is a patch for the JavaScript built-in `Symbol` class. It
+ * adds utility methods to the `Symbol` class without modifying the global namespace
+ * directly. This patch includes methods for key validation, object type checking,
+ * and retrieving the string tag of an object. These methods are useful for
+ * enhancing the capabilities of the standard `Symbol` class with additional
+ * utility functions.
+ */
+export const SymbolExtensions = new Patch(Symbol, {
+  /**
+   * The `isSymbol` method does exactly what one would it expect. It returns
+   * true if the string matches typeof or instanceof as a symbol.
+   *
+   * @param {*} value checks to see if the `value` is a string
+   * @returns {boolean} `true` if it is a `Symbol`, `false` otherwise
+   */
+  isSymbol(value) {
+    if (value && (typeof value === 'symbol')) {
+      return true
+    }
+    return false
+  },
+});