@nejs/basic-extensions 1.5.0 → 1.5.1

package/dist/cjs/functionextensions.js

@@ -3,43 +3,49 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionExtensions = void 0;
 const extension_1 = require("@nejs/extension");
 /**
- * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
- * constructor. It extends `Function` with additional utility methods for determining the
- * specific type or nature of function-like objects. These methods allow developers to
- * distinguish between classes, regular functions, async functions, and arrow functions
- * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
- * library and enhances the capabilities of function handling and introspection in JavaScript.
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript
+ * `Function` constructor. It extends `Function` with additional utility methods
+ * for determining the specific type or nature of function-like objects. These
+ * methods allow developers to distinguish between classes, regular functions,
+ * async functions, and arrow functions in a more intuitive and straightforward
+ * manner. This class is part of the `@nejs/extension` library and enhances the
+ * capabilities of function handling and introspection in JavaScript.
  */
 exports.FunctionExtensions = new extension_1.Patch(Function, {
     /**
-     * Determines if a given value is a class. It checks if the value is an instance of
-     * `Function` and if its string representation includes the keyword 'class'. This method
-     * is useful for distinguishing classes from other function types in JavaScript.
+     * Determines if a given value is a class. It checks if the value is an
+     * instance of `Function` and if its string representation includes the
+     * keyword 'class'. This method is useful for distinguishing classes from
+     * other function types in JavaScript.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is a class, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is a class, otherwise
+     * `false`.
      */
     isClass(value) {
         return value instanceof Function && !!/^class\s/.exec(String(value));
     },
     /**
-     * Checks if a given value is a regular function. This method verifies if the value is
-     * an instance of `Function`, which includes regular functions, classes, and async
-     * functions but excludes arrow functions.
+     * Checks if a given value is a regular function. This method verifies if
+     * the value is an instance of `Function`, which includes regular functions,
+     * classes, and async functions but excludes arrow functions.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is a regular function, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is a regular function,
+     * otherwise `false`.
      */
     isFunction(value) {
         return value instanceof Function;
     },
     /**
-     * Determines if a given value is an asynchronous function. It checks if the value is an
-     * instance of `Function` and if its string representation includes the keyword 'Async'.
-     * This method is particularly useful for identifying async functions.
+     * Determines if a given value is an asynchronous function. It checks if the
+     * value is an instance of `Function` and if its string representation
+     * includes the keyword 'Async'. This method is particularly useful for
+     * identifying async functions.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is an async function, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is an async function,
+     * otherwise `false`.
      */
     isAsync(value) {
         const stringTag = /(\w+)]/g.exec(Object.prototype.toString.call(value))[1];
@@ -47,12 +53,14 @@ exports.FunctionExtensions = new extension_1.Patch(Function, {
             stringTag.includes('Async'));
     },
     /**
-     * Checks if a given value is an arrow function. It verifies if the value is an instance
-     * of `Function`, if its string representation includes the '=>' symbol, and if it lacks
-     * a prototype, which is a characteristic of arrow functions in JavaScript.
+     * Checks if a given value is an arrow function. It verifies if the value is
+     * an instance of `Function`, if its string representation includes the '=>'
+     * symbol, and if it lacks a prototype, which is a characteristic of arrow
+     * functions in JavaScript.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is an arrow function, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is an arrow function,
+     * otherwise `false`.
      */
     isBigArrow(value) {
         return (value instanceof Function &&
@@ -61,16 +69,17 @@ exports.FunctionExtensions = new extension_1.Patch(Function, {
             !Reflect.has(value, 'prototype'));
     },
     /**
-     * Determines if a given value is a bound function. Bound functions are created using
-     * the `Function.prototype.bind` method, which allows setting the `this` value at the
-     * time of binding. This method checks if the value is an instance of `Function`, if
-     * its string representation starts with 'bound', and if it lacks a `prototype`
-     * property. These characteristics are indicative of bound functions in JavaScript.
+     * Determines if a given value is a bound function. Bound functions are
+     * created using the `Function.prototype.bind` method, which allows setting
+     * the `this` value at the time of binding. This method checks if the value
+     * is an instance of `Function`, if its string representation starts with
+     * 'bound', and if it lacks a `prototype` property. These characteristics
+     * are indicative of bound functions in JavaScript.
      *
      * @param {*} value - The value to be checked, typically a function.
-     * @returns {boolean} Returns `true` if the value is a bound function, otherwise
-     * `false`. Bound functions have a specific format in their string representation
-     * and do not have their own `prototype` property.
+     * @returns {boolean} Returns `true` if the value is a bound function,
+     * otherwise `false`. Bound functions have a specific format in their
+     * string representation and do not have their own `prototype` property.
      */
     isBound(value) {
         return (value instanceof Function &&

package/dist/cjs/objectextensions.js

@@ -11,6 +11,14 @@ const extension_1 = require("@nejs/extension");
  * utility functions.
  */
 exports.ObjectExtensions = new extension_1.Patch(Object, {
+    /**
+     * Checks to see if the supplied `value` is both an object, and has the
+     * appropriate symbol defined.
+     *
+     * @param {any} value the value to determine if it contains a defined
+     * `Symbol.toStringTag` defined.
+     * @returns true if the symbol is defined, false otherwise
+     */
     hasStringTag(value) {
         return Object.isObject(value) && Reflect.has(value, Symbol.toStringTag);
     },

package/dist/mjs/descriptor.js

@@ -242,16 +242,16 @@ class Descriptor {
         return this.constructor.name;
     }
     /**
-     * The function `getData` retrieves the value of a property from an object if it
-     * exists and is a data property.
+     * The function `getData` retrieves the value of a property from an object
+     * if it exists and is a data property.
      *
      * @param object - The "object" parameter is the object from which we want to
      * retrieve data.
      * @param property - The `property` parameter is the name of the property that
      * you want to retrieve the data from.
-     * @returns either the value of the specified property if it exists and is a data
-     * property, or undefined if the property does not exist or is not a data
-     * property.
+     * @returns either the value of the specified property if it exists and is
+     * a data property, or undefined if the property does not exist or is not
+     * a data property.
      */
     static getData(object, property) {
         if (!isObject(object) || !isString(property)) {
@@ -276,10 +276,10 @@ class Descriptor {
      * which we want to get the accessor.
      * @returns an object that contains the getter and setter functions for the
      * specified property of the given object. If the property is an accessor
-     * property (defined with a getter and/or setter), the returned object will also
-     * have additional properties such as "accessor" and "descriptor". If the
-     * property is not found or is not an accessor property, the function returns
-     * undefined.
+     * property (defined with a getter and/or setter), the returned object will
+     * also have additional properties such as "accessor" and "descriptor". If
+     * the property is not found or is not an accessor property, the function
+     * returns undefined.
      */
     static getAccessor(object, property) {
         if (!isObject(object))
@@ -318,14 +318,14 @@ class Descriptor {
      *
      * @param [enumerable=false] - A boolean value indicating whether the property
      * can be enumerated (listed) when iterating over the object's properties.
-     * @param [configurable=false] - The `configurable` parameter determines whether
-     * the property can be deleted or its attributes can be modified. If
-     * `configurable` is set to `true`, the property can be deleted and its
-     * attributes can be changed. If `configurable` is set to `false`, the property
-     * cannot be deleted and
+     * @param [configurable=false] - The `configurable` parameter determines
+     * whether the property can be deleted or its attributes can be modified.
+     * If `configurable` is set to `true`, the property can be deleted and its
+     * attributes can be changed. If `configurable` is set to `false`, the
+     * property cannot be deleted and
      * @returns An object with the properties `enumerable` and `configurable` is
-     * being returned. The values of these properties are determined by the arguments
-     * passed to the `base` function.
+     * being returned. The values of these properties are determined by the
+     * arguments passed to the `base` function.
      */
     static base(enumerable = false, configurable = false) {
         return {
@@ -340,9 +340,9 @@ class Descriptor {
      *
      * @param getter - The getter parameter is a function that will be used as the
      * getter for the property. It will be called when the property is accessed.
-     * @param setter - The `setter` parameter is a function that will be used as the
-     * setter for the property. It will be called whenever the property is assigned a
-     * new value.
+     * @param setter - The `setter` parameter is a function that will be used as
+     * the setter for the property. It will be called whenever the property is
+     * assigned a new value.
      * @param [] - - `getter`: A function that will be used as the getter for the
      * property.
      * @returns an object with properties "get", "set", "enumerable", and
@@ -357,13 +357,15 @@ class Descriptor {
         };
     }
     /**
-     * The function "newData" creates a new data object with customizable properties.
+     * The function "newData" creates a new data object with customizable
+     * properties.
      *
-     * @param value - The value parameter represents the value that will be assigned
-     * to the property.
-     * @param [writable=true] - The `writable` parameter determines whether the value
-     * of the property can be changed. If `writable` is set to `true`, the value can
-     * be changed. If `writable` is set to `false`, the value cannot be changed.
+     * @param value - The value parameter represents the value that will be
+     * assigned to the property.
+     * @param [writable=true] - The `writable` parameter determines whether the
+     * value of the property can be changed. If `writable` is set to `true`, the
+     * value can be changed. If `writable` is set to `false`, the value cannot be
+     * changed.
      * @param [] - - `value`: The value to be assigned to the property.
      * @returns an object with properties `value`, `enumerable`, `writable`, and
      * `configurable`.
@@ -377,10 +379,11 @@ class Descriptor {
         };
     }
     /**
-     * The function checks if an object is a valid object descriptor in JavaScript.
+     * The function checks if an object is a valid object descriptor in
+     * JavaScript.
      *
-     * @param object - The `object` parameter is the object that we want to check if
-     * it is a descriptor.
+     * @param object - The `object` parameter is the object that we want to
+     * check if it is a descriptor.
      * @returns a boolean value.
      */
     static isDescriptor(object) {
@@ -394,12 +397,13 @@ class Descriptor {
     /**
      * The function checks if a given property or descriptor is a data property.
      *
-     * @param descriptor_orProp - The `descriptor_orProp` parameter can be either a
-     * descriptor or a property name.
-     * @param object - The `object` parameter is the object that you want to check
-     * for data properties.
-     * @returns a boolean value. It returns `true` if the `descriptor` object has any
-     * keys that match the `DATA_KEYS` array, otherwise it returns `false`.
+     * @param descriptor_orProp - The `descriptor_orProp` parameter can be
+     * either a descriptor or a property name.
+     * @param object - The `object` parameter is the object that you want to
+     * check for data properties.
+     * @returns a boolean value. It returns `true` if the `descriptor` object
+     * has any keys that match the `DATA_KEYS` array, otherwise it returns
+     * `false`.
      */
     static isData(object_orProp, property) {
         const needsDescriptor = (((typeof object_orProp === 'object') || object_orProp instanceof Object) &&
@@ -418,15 +422,15 @@ class Descriptor {
         return validData;
     }
     /**
-     * The function checks if a given property descriptor or property of an object is
-     * an accessor.
+     * The function checks if a given property descriptor or property of an
+     * object is an accessor.
      *
      * @param object_orProp - The `descriptor_orProp` parameter can be either a
      * descriptor object or a property name.
-     * @param property - The `object` parameter is the object that you want to check
-     * for accessor properties.
-     * @returns a boolean value. It returns true if the descriptor or property passed
-     * as an argument is an accessor descriptor, and false otherwise.
+     * @param property - The `object` parameter is the object that you want to
+     * check for accessor properties.
+     * @returns a boolean value. It returns true if the descriptor or property
+     * passed as an argument is an accessor descriptor, and false otherwise.
      */
     static isAccessor(object_orProp, property) {
         const needsDescriptor = ((object_orProp && property) &&
@@ -446,25 +450,28 @@ class Descriptor {
         return validAccessor;
     }
     /**
-     * A base descriptor (new for each read) that is both enumerable and configurable
+     * A base descriptor (new for each read) that is both enumerable and
+     * configurable
      *
-     * @returns The method `flexible` is returning the result of calling the `base`
-     * method with the arguments `true` and `true`.
+     * @returns The method `flexible` is returning the result of calling the
+     * `base` method with the arguments `true` and `true`.
      */
     static get flexible() {
         return this.base(true, true);
     }
     /**
-     * A base descriptor (new for each read) that is not enumerable but is configurable
+     * A base descriptor (new for each read) that is not enumerable but is
+     * configurable
      *
-     * @returns The method `enigmatic` is returning the result of calling the `base`
-     * method with the arguments `false` and `true`.
+     * @returns The method `enigmatic` is returning the result of calling
+     * the `base` method with the arguments `false` and `true`.
      */
     static get enigmatic() {
         return this.base(false, true);
     }
     /**
-     * A base descriptor (new for each read) that is neither enumerable nor configurable
+     * A base descriptor (new for each read) that is neither enumerable
+     * nor configurable
      *
      * @returns The code is returning the result of calling the `base` method with
      * the arguments `false` and `false`.
@@ -475,8 +482,8 @@ class Descriptor {
     /**
      * A base descriptor (new for each read) that enumerable but not configurable
      *
-     * @returns The method is returning the result of calling the `base` method with
-     * the arguments `true` and `false`.
+     * @returns The method is returning the result of calling the `base`
+     * method with the arguments `true` and `false`.
      */
     static get transparent() {
         return this.base(true, false);

package/dist/mjs/functionextensions.d.ts

@@ -1,10 +1,11 @@
 /**
- * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
- * constructor. It extends `Function` with additional utility methods for determining the
- * specific type or nature of function-like objects. These methods allow developers to
- * distinguish between classes, regular functions, async functions, and arrow functions
- * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
- * library and enhances the capabilities of function handling and introspection in JavaScript.
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript
+ * `Function` constructor. It extends `Function` with additional utility methods
+ * for determining the specific type or nature of function-like objects. These
+ * methods allow developers to distinguish between classes, regular functions,
+ * async functions, and arrow functions in a more intuitive and straightforward
+ * manner. This class is part of the `@nejs/extension` library and enhances the
+ * capabilities of function handling and introspection in JavaScript.
  */
 export const FunctionExtensions: Patch;
 import { Patch } from '@nejs/extension';

package/dist/mjs/functionextensions.js

@@ -1,42 +1,48 @@
 import { Patch } from '@nejs/extension';
 /**
- * The `FunctionExtensions` class is a patch applied to the built-in JavaScript `Function`
- * constructor. It extends `Function` with additional utility methods for determining the
- * specific type or nature of function-like objects. These methods allow developers to
- * distinguish between classes, regular functions, async functions, and arrow functions
- * in a more intuitive and straightforward manner. This class is part of the `@nejs/extension`
- * library and enhances the capabilities of function handling and introspection in JavaScript.
+ * The `FunctionExtensions` class is a patch applied to the built-in JavaScript
+ * `Function` constructor. It extends `Function` with additional utility methods
+ * for determining the specific type or nature of function-like objects. These
+ * methods allow developers to distinguish between classes, regular functions,
+ * async functions, and arrow functions in a more intuitive and straightforward
+ * manner. This class is part of the `@nejs/extension` library and enhances the
+ * capabilities of function handling and introspection in JavaScript.
  */
 export const FunctionExtensions = new Patch(Function, {
     /**
-     * Determines if a given value is a class. It checks if the value is an instance of
-     * `Function` and if its string representation includes the keyword 'class'. This method
-     * is useful for distinguishing classes from other function types in JavaScript.
+     * Determines if a given value is a class. It checks if the value is an
+     * instance of `Function` and if its string representation includes the
+     * keyword 'class'. This method is useful for distinguishing classes from
+     * other function types in JavaScript.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is a class, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is a class, otherwise
+     * `false`.
      */
     isClass(value) {
         return value instanceof Function && !!/^class\s/.exec(String(value));
     },
     /**
-     * Checks if a given value is a regular function. This method verifies if the value is
-     * an instance of `Function`, which includes regular functions, classes, and async
-     * functions but excludes arrow functions.
+     * Checks if a given value is a regular function. This method verifies if
+     * the value is an instance of `Function`, which includes regular functions,
+     * classes, and async functions but excludes arrow functions.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is a regular function, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is a regular function,
+     * otherwise `false`.
      */
     isFunction(value) {
         return value instanceof Function;
     },
     /**
-     * Determines if a given value is an asynchronous function. It checks if the value is an
-     * instance of `Function` and if its string representation includes the keyword 'Async'.
-     * This method is particularly useful for identifying async functions.
+     * Determines if a given value is an asynchronous function. It checks if the
+     * value is an instance of `Function` and if its string representation
+     * includes the keyword 'Async'. This method is particularly useful for
+     * identifying async functions.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is an async function, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is an async function,
+     * otherwise `false`.
      */
     isAsync(value) {
         const stringTag = /(\w+)]/g.exec(Object.prototype.toString.call(value))[1];
@@ -44,12 +50,14 @@ export const FunctionExtensions = new Patch(Function, {
             stringTag.includes('Async'));
     },
     /**
-     * Checks if a given value is an arrow function. It verifies if the value is an instance
-     * of `Function`, if its string representation includes the '=>' symbol, and if it lacks
-     * a prototype, which is a characteristic of arrow functions in JavaScript.
+     * Checks if a given value is an arrow function. It verifies if the value is
+     * an instance of `Function`, if its string representation includes the '=>'
+     * symbol, and if it lacks a prototype, which is a characteristic of arrow
+     * functions in JavaScript.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} Returns `true` if the value is an arrow function, otherwise `false`.
+     * @returns {boolean} Returns `true` if the value is an arrow function,
+     * otherwise `false`.
      */
     isBigArrow(value) {
         return (value instanceof Function &&
@@ -58,16 +66,17 @@ export const FunctionExtensions = new Patch(Function, {
             !Reflect.has(value, 'prototype'));
     },
     /**
-     * Determines if a given value is a bound function. Bound functions are created using
-     * the `Function.prototype.bind` method, which allows setting the `this` value at the
-     * time of binding. This method checks if the value is an instance of `Function`, if
-     * its string representation starts with 'bound', and if it lacks a `prototype`
-     * property. These characteristics are indicative of bound functions in JavaScript.
+     * Determines if a given value is a bound function. Bound functions are
+     * created using the `Function.prototype.bind` method, which allows setting
+     * the `this` value at the time of binding. This method checks if the value
+     * is an instance of `Function`, if its string representation starts with
+     * 'bound', and if it lacks a `prototype` property. These characteristics
+     * are indicative of bound functions in JavaScript.
      *
      * @param {*} value - The value to be checked, typically a function.
-     * @returns {boolean} Returns `true` if the value is a bound function, otherwise
-     * `false`. Bound functions have a specific format in their string representation
-     * and do not have their own `prototype` property.
+     * @returns {boolean} Returns `true` if the value is a bound function,
+     * otherwise `false`. Bound functions have a specific format in their
+     * string representation and do not have their own `prototype` property.
      */
     isBound(value) {
         return (value instanceof Function &&

package/dist/mjs/objectextensions.js

@@ -8,6 +8,14 @@ import { Patch } from '@nejs/extension';
  * utility functions.
  */
 export const ObjectExtensions = new Patch(Object, {
+    /**
+     * Checks to see if the supplied `value` is both an object, and has the
+     * appropriate symbol defined.
+     *
+     * @param {any} value the value to determine if it contains a defined
+     * `Symbol.toStringTag` defined.
+     * @returns true if the symbol is defined, false otherwise
+     */
     hasStringTag(value) {
         return Object.isObject(value) && Reflect.has(value, Symbol.toStringTag);
     },

package/package.json

@@ -46,9 +46,9 @@
     "test": "jest"
   },
   "type": "module",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "dependencies": {
     "@nejs/extension": "^1.2.1"
   },
-  "browser": "dist/@nejs/basic-extensions.bundle.1.4.1.js"
+  "browser": "dist/@nejs/basic-extensions.bundle.1.5.0.js"
 }