@nejs/basic-extensions 2.6.0 → 2.8.0

package/dist/mjs/map.extensions.js

@@ -0,0 +1,139 @@
+import { Patch } from '@nejs/extension';
+export const MapExtensions = new Patch(Map, {
+    [Patch.kMutablyHidden]: {
+        /**
+         * Determines if the supplied `value` is a `Map` object. This check
+         * is performed by first looking for the `Symbol.toStringTag` on the
+         * `value` and checking to see if it is equal to the string "Map".
+         * If that check fails, `instanceof` is used as a fallback to check
+         * the prototype chain.
+         *
+         * @param {any} value the value that needs to be checked to determine
+         * if it is a `Map` object or not
+         * @returns {boolean} `true` if the supplied `value` is a `Map`
+         * object, `false` otherwise
+         *
+         * @example
+         * const map = new Map()
+         * isMap(map) // true
+         * isMap(new Set()) // false
+         * isMap([]) // false
+         * isMap({}) // false
+         */
+        isMap(value) {
+            return value?.[Symbol.toStringTag] === Map.name && value instanceof Map;
+        },
+        /**
+         * Conditionally returns a value based on whether the supplied
+         * `value` is a `Map` object or not. If the `value` is a `Map`
+         * object, the `thenValue` will be returned. If it is not a `Map`
+         * object, the `elseValue` will be returned instead.
+         *
+         * @param {any} value the value to check to determine if it is a
+         * `Map` object
+         * @param {any} thenValue the value to return if the supplied
+         * `value` is a `Map` object
+         * @param {any} elseValue the value to return if the supplied
+         * `value` is not a `Map` object
+         * @returns {any} either the `thenValue` or `elseValue` depending
+         * on if the supplied `value` is a `Map` object
+         *
+         * @example
+         * const map = new Map()
+         * const set = new Set()
+         * ifMap(map, 'is a map', 'not a map') // 'is a map'
+         * ifMap(set, 'is a map', 'not a map') // 'not a map'
+         */
+        ifMap(value, thenValue, elseValue) {
+            return isThenElse(this.isMap(value), thenValue, elseValue);
+        },
+    }
+});
+const { isMap: pIsMap, ifMap: pIfMap } = MapExtensions.patches;
+export const MapPrototypeExtensions = new Patch(Map.prototype, {
+    [Patch.kMutablyHidden]: {
+        /**
+         * Determines if the current object is a `Map` object
+         *
+         * This is a getter that uses the `isMap` function from the
+         * `MapExtensions` patch to check if the current object (`this`) is
+         * a `Map` object
+         *
+         * @type {boolean}
+         * @readonly
+         *
+         * @example
+         * const map = new Map()
+         * console.log(map.isMap) // Output: true
+         *
+         * const notMap = {}
+         * console.log(notMap.isMap) // Output: false
+         */
+        get isMap() {
+            return pIsMap(this);
+        },
+        /**
+         * Conditionally returns a value based on whether the current
+         * object is a `Map` object or not
+         *
+         * If the current object is a `Map` object, the `thenValue` will
+         * be returned. If it is not a `Map` object, the `elseValue` will
+         * be returned instead.
+         *
+         * @param {any} thenValue the value to return if the current
+         * object is a `Map` object
+         * @param {any} elseValue the value to return if the current
+         * object is not a `Map` object
+         * @returns {any} either the `thenValue` or `elseValue` depending
+         * on if the current object is a `Map` object
+         *
+         * @example
+         * const map = new Map()
+         * map.ifMap('is a map', 'not a map') // 'is a map'
+         *
+         * const notMap = {}
+         * notMap.ifMap('is a map', 'not a map') // 'not a map'
+         */
+        ifMap(thenValue, elseValue) {
+            return pIfMap(this, thenValue, elseValue);
+        },
+        /**
+         * The function `getKey` returns the key associated with a given value
+         * in a map.
+         *
+         * @param {any} value - The value parameter is the value that you want to
+         * find the corresponding key for in the map.
+         * @param [strict=true] - The "strict" parameter is a boolean value that
+         * determines whether strict equality (===) or loose equality (==) should
+         * be used when comparing the "value" parameter with the values in the
+         * entries of the object. If "strict" is set to true, strict equality will
+         * be used.
+         * @returns the key associated with the given value. If a matching key is
+         * found, it is returned. If no matching key is found, null is returned.
+         */
+        getKey(value, strict = true) {
+            for (const [key, entryValue] of this) {
+                if ((strict && value === entryValue) &&
+                    (!strict && value == entryValue)) {
+                    return key;
+                }
+                return null;
+            }
+        },
+    },
+});
+// NOTE to self; this is repeated here otherwise a circular reference from
+// Object<->Function<->Global occurs. See original source in global.this.js
+// {@see globalThis.isThenElse}
+function isThenElse(bv, tv, ev) {
+    if (arguments.length > 1) {
+        var _then = isFunction(tv) ? tv(bv) : tv;
+        if (arguments.length > 2) {
+            var _else = isFunction(ev) ? tv(bv) : ev;
+            return bv ? _then : _else;
+        }
+        return bv || _then;
+    }
+    return bv;
+}
+//# sourceMappingURL=map.extensions.js.map

package/dist/mjs/map.extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.extensions.js","sourceRoot":"","sources":["../../src/map.extensions.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAEvC,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,KAAK,CAAC,GAAG,EAAE;IAC1C,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE;QACtB;;;;;;;;;;;;;;;;;;WAkBG;QACH,KAAK,CAAC,KAAK;YACT,OAAO,KAAK,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,IAAI,IAAI,KAAK,YAAY,GAAG,CAAA;QACzE,CAAC;QAED;;;;;;;;;;;;;;;;;;;;WAoBG;QACH,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS;YAC/B,OAAO,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;QAC5D,CAAC;KACF;CACF,CAAC,CAAA;AAEF,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC,OAAO,CAAA;AAE9D,MAAM,CAAC,MAAM,sBAAsB,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE;IAC7D,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE;QACtB;;;;;;;;;;;;;;;;WAgBG;QACH,IAAI,KAAK;YACP,OAAO,MAAM,CAAC,IAAI,CAAC,CAAA;QACrB,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,KAAK,CAAC,SAAS,EAAE,SAAS;YACxB,OAAO,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;QAC3C,CAAC;QAED;;;;;;;;;;;;;WAaG;QACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;YACzB,KAAK,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC,IAAI,IAAI,EAAE,CAAC;gBACrC,IACE,CAAC,MAAM,IAAI,KAAK,KAAK,UAAU,CAAC;oBAChC,CAAC,CAAC,MAAM,IAAI,KAAK,IAAI,UAAU,CAAC,EAChC,CAAC;oBACD,OAAO,GAAG,CAAA;gBACZ,CAAC;gBAED,OAAO,IAAI,CAAA;YACb,CAAC;QACH,CAAC;KACF;CACF,CAAC,CAAA;AAEF,0EAA0E;AAC1E,2EAA2E;AAC3E,+BAA+B;AAC/B,SAAS,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;IAC5B,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,IAAI,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnE,IAAI,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAA;QACrE,CAAC;QAAC,OAAO,EAAE,IAAI,KAAK,CAAC;IACvB,CAAC;IAAC,OAAO,EAAE,CAAA;AACb,CAAC"}

package/dist/mjs/number.extension.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A patch for the JavaScript built-in `Number` class that adds utility
+ * methods without modifying the global namespace directly
+ *
+ * This patch includes methods for checking if a value is a number and
+ * conditionally returning a value based on whether the supplied value is
+ * a number or not.
+ *
+ * @type {Patch}
+ * @property {Object} [Patch.kMutablyHidden] An object containing methods
+ * that are hidden from enumeration and mutation
+ *
+ * @example
+ * import { NumberExtensions } from 'number.extension.js'
+ *
+ * NumberExtensions.apply()
+ * // Now the `Number` class has additional methods available
+ */
+export const NumberExtensions: Patch;
+/**
+ * `NumberPrototypeExtensions` provides a set of utility methods that
+ * are added to the `Number` prototype. This allows all number instances
+ * to access new functionality directly, enhancing their capabilities
+ * beyond the standard `Number` class methods.
+ *
+ * These extensions are applied using the `Patch` class from
+ * '@nejs/extension', ensuring that they do not interfere with the
+ * global namespace or existing properties.
+ *
+ * The extensions include methods for checking if a value is a number,
+ * conditionally returning values based on whether a value is a number,
+ * and more, making number-related tasks more convenient and expressive.
+ *
+ * @example
+ * const num = 42
+ * console.log(num.isNumber) // Output: true
+ *
+ * const notNum = "123"
+ * console.log(notNum.isNumber) // Output: false
+ *
+ * @type {Patch}
+ */
+export const NumberPrototypeExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/mjs/number.extension.js

@@ -0,0 +1,257 @@
+import { Patch } from '@nejs/extension';
+/**
+ * A patch for the JavaScript built-in `Number` class that adds utility
+ * methods without modifying the global namespace directly
+ *
+ * This patch includes methods for checking if a value is a number and
+ * conditionally returning a value based on whether the supplied value is
+ * a number or not.
+ *
+ * @type {Patch}
+ * @property {Object} [Patch.kMutablyHidden] An object containing methods
+ * that are hidden from enumeration and mutation
+ *
+ * @example
+ * import { NumberExtensions } from 'number.extension.js'
+ *
+ * NumberExtensions.apply()
+ * // Now the `Number` class has additional methods available
+ */
+export const NumberExtensions = new Patch(Number, {
+    [Patch.kMutablyHidden]: {
+        /**
+         * Determines if the supplied `value` is a `Number`. This check is
+         * performed by first converting the `value` to a `Number` using the
+         * `Number()` constructor and checking to see if the result is not
+         * `NaN`. If that check passes, `typeof` is used to ensure that the
+         * original `value` is of type "number".
+         *
+         * @param {*} value The value that needs to be checked to determine if it
+         * is a `Number` or not
+         * @returns {boolean} `true` if the supplied `value` is a `Number`,
+         * `false` otherwise
+         *
+         * @example
+         * const num = 42
+         * isNumber(num) // true
+         * isNumber('42') // false
+         * isNumber(NaN) // false
+         * isNumber(Infinity) // true
+         */
+        isNumber(value) {
+            return !isNaN(value) && typeof value === 'number';
+        },
+        /**
+         * Checks if all or some of the supplied values are numbers.
+         *
+         * This method uses the `Array.prototype.every` or `Array.prototype.some`
+         * method to check if all or some of the supplied values are numbers,
+         * respectively. The method to use is determined by the `which` parameter.
+         *
+         * @param {string} [which='every'] - Determines the method to use for the
+         * check. Can be either 'every' or 'some'. Defaults to 'every'.
+         * @param {...*} values - The values to check.
+         * @returns {boolean} - Returns `true` if all or some of the values are
+         * numbers (based on the `which` parameter), `false` otherwise.
+         *
+         * @example
+         * areNumbers('every', 1, 2, 3) // true
+         * areNumbers('some', 1, '2', 3) // true
+         * areNumbers('every', 1, '2', 3) // false
+         */
+        areNumbers(which = ['every', 'some'][0], ...values) {
+            if (which !== 'every' && which !== 'some') {
+                return false;
+            }
+            return values[which](num => this.isNumber(num));
+        },
+        /**
+         * Conditionally returns a value based on whether the supplied `value` is
+         * a `Number` or not. If the `value` is a `Number`, the `thenValue` will
+         * be returned. If it is not a `Number`, the `elseValue` will be
+         * returned instead.
+         *
+         * @param {*} value The value to check to determine if it is a `Number`
+         * @param {*} thenValue The value to return if the supplied `value` is
+         * a `Number`
+         * @param {*} elseValue The value to return if the supplied `value` is
+         * not a `Number`
+         * @returns {*} Either the `thenValue` or `elseValue` depending on if the
+         * supplied `value` is a `Number`
+         *
+         * @example
+         * const num = 42
+         * const str = 'hello'
+         * ifNumber(num, 'is a number', 'not a number') // 'is a number'
+         * ifNumber(str, 'is a number', 'not a number') // 'not a number'
+         */
+        ifNumber(value, thenValue, elseValue) {
+            return isThenElse(this.isNumber(value), thenValue, elseValue);
+        },
+        /**
+         * Conditionally returns a value based on whether all or some of the
+         * supplied values are numbers.
+         *
+         * This method uses the `areNumbers` method to check if all or some of
+         * the supplied values are numbers, based on the `which` parameter.
+         * If the condition is met, the `thenValue` is returned, otherwise
+         * the `elseValue` is returned.
+         *
+         * @param {*} thenValue - The value to return if the condition is met.
+         * @param {*} elseValue - The value to return if the condition is not met.
+         * @param {string} [which='every'] - Determines the method to use for the
+         * check. Can be either 'every' or 'some'. Defaults to 'every'.
+         * @param {...*} numbers - The values to check.
+         * @returns {*} Either the `thenValue` or `elseValue` depending on if all
+         * or some of the supplied values are numbers.
+         *
+         * @example
+         * ifNumbers('All are numbers', 'Not all are numbers', 'every', 1, 2, 3)
+         * // returns 'All are numbers'
+         * ifNumbers('At least one is a number', 'None are numbers', 'some', 1, '2', 3)
+         * // returns 'At least one is a number'
+         * ifNumbers('All are numbers', 'Not all are numbers', 'every', 1, '2', 3)
+         * // returns 'Not all are numbers'
+         */
+        ifNumbers(thenValue, elseValue, which = ['every', 'some'][0], ...numbers) {
+            return isThenElse(this.areNumbers(which, ...numbers), thenValue, elseValue);
+        },
+        /**
+         * Clamps a value between a minimum and maximum value.
+         *
+         * This method checks if the provided value and the min and max bounds are
+         * numbers. If they are not, it returns the original value. If they are,
+         * it ensures that the value does not go below the minimum value or above
+         * the maximum value.
+         *
+         * @param {*} value - The value to clamp.
+         * @param {number} [minValue=-Infinity] - The minimum value. Defaults
+         * to -Infinity.
+         * @param {number} [maxValue=Infinity] - The maximum value. Defaults
+         * to Infinity.
+         * @returns {*} - Returns the clamped value if all parameters are numbers,
+         * otherwise returns the original value.
+         *
+         * @example
+         * clamp(10, 1, 5) // returns 5
+         * clamp(-10, 1, 5) // returns 1
+         * clamp(3, 1, 5) // returns 3
+         * clamp('10', 1, 5) // returns '10'
+         */
+        clamp(value, minValue = -Infinity, maxValue = Infinity) {
+            if (!this.areNumbers('every', value, minValue, maxValue)) {
+                return value;
+            }
+            return Math.max(minValue, Math.min(maxValue, value));
+        },
+    }
+});
+const { isNumber: pIsNumber, ifNumber: pIfNumber } = NumberExtensions.patches;
+/**
+ * `NumberPrototypeExtensions` provides a set of utility methods that
+ * are added to the `Number` prototype. This allows all number instances
+ * to access new functionality directly, enhancing their capabilities
+ * beyond the standard `Number` class methods.
+ *
+ * These extensions are applied using the `Patch` class from
+ * '@nejs/extension', ensuring that they do not interfere with the
+ * global namespace or existing properties.
+ *
+ * The extensions include methods for checking if a value is a number,
+ * conditionally returning values based on whether a value is a number,
+ * and more, making number-related tasks more convenient and expressive.
+ *
+ * @example
+ * const num = 42
+ * console.log(num.isNumber) // Output: true
+ *
+ * const notNum = "123"
+ * console.log(notNum.isNumber) // Output: false
+ *
+ * @type {Patch}
+ */
+export const NumberPrototypeExtensions = new Patch(Number.prototype, {
+    [Patch.kMutablyHidden]: {
+        /**
+         * Returns an object representation of the number instance.
+         *
+         * This getter method creates and returns an object that wraps the number
+         * instance, allowing it to be treated as an object. The returned object
+         * is created using the `Object()` constructor, which takes the number
+         * instance as its argument.
+         *
+         * @type {Object}
+         * @readonly
+         *
+         * @example
+         * const num = 42
+         * console.log(typeof num)           // 'number'
+         * console.log(typeof num.instance)  // 'object'
+         */
+        get instance() {
+            return Object(this);
+        },
+        /**
+         * Determines if the current object is a number
+         *
+         * This getter uses the `pIsNumber` function from the `NumberExtensions`
+         * patch to check if the current object (`this`) is a number.
+         *
+         * @type {boolean}
+         * @readonly
+         *
+         * @example
+         * const num = 42
+         * console.log(num.isNumber) // Output: true
+         *
+         * const notNum = "123"
+         * console.log(notNum.isNumber) // Output: false
+         */
+        get isNumber() {
+            return pIsNumber(this);
+        },
+        /**
+         * Checks if the current object is a number and returns the corresponding
+         * value based on the result.
+         *
+         * This method uses the `pIfNumber` function from the `NumberExtensions`
+         * patch to determine if the current object (`this`) is a number. If it is
+         * a number, the `thenValue` is returned. Otherwise, the `elseValue` is
+         * returned.
+         *
+         * @param {any} thenValue The value to return if the current object is
+         * a number
+         * @param {any} elseValue The value to return if the current object is not
+         * a number
+         * @returns {any} The `thenValue` if the current object is a number, or
+         * the `elseValue` if it is not a number
+         *
+         * @example
+         * const num = 42
+         * console.log(num.ifNumber('Is a number', 'Not a number'))
+         * // Output: 'Is a number'
+         *
+         * const notNum = '123'
+         * console.log(notNum.ifNumber('Is a number', 'Not a number'))
+         * // Output: 'Not a number'
+         */
+        ifNumber(thenValue, elseValue) {
+            return pIfNumber(this, thenValue, elseValue);
+        },
+    }
+});
+// NOTE to self; this is repeated here otherwise a circular reference from
+// Object<->Function<->Global occurs. See original source in global.this.js
+// {@see globalThis.isThenElse}
+function isThenElse(bv, tv, ev) {
+    if (arguments.length > 1) {
+        var _then = isFunction(tv) ? tv(bv) : tv;
+        if (arguments.length > 2) {
+            var _else = isFunction(ev) ? tv(bv) : ev;
+            return bv ? _then : _else;
+        }
+        return bv || _then;
+    }
+    return bv;
+}
+//# sourceMappingURL=number.extension.js.map

package/dist/mjs/number.extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.extension.js","sourceRoot":"","sources":["../../src/number.extension.js"],"names":[],"mappings":"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"}

package/dist/mjs/object.extensions.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Creates a deep or shallow copy of the provided source objects and merges
+ * them into the destination object. The function uses a Set to keep track
+ * of visited objects to avoid circular references.
+ *
+ * @function
+ * @name copyObject
+ * @param {boolean} deep - If true, performs a deep copy, otherwise performs
+ * a shallow copy.
+ * @param {object} destination - The object to which properties will be copied.
+ * @param {...object} sources - The source object(s) from which properties
+ * will be copied.
+ * @returns {object} The destination object with the copied properties.
+ *
+ * @example
+ * // Shallow copy
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { b: { d: 3 }, e: 4 };
+ * const result = copyObject(false, obj1, obj2);
+ * console.log(result); // Output: { a: 1, b: { d: 3 }, e: 4 }
+ *
+ * @example
+ * // Deep copy
+ * const obj1 = { a: 1, b: { c: 2 } };
+ * const obj2 = { b: { d: 3 }, e: 4 };
+ * const result = copyObject(true, obj1, obj2);
+ * console.log(result); // Output: { a: 1, b: { c: 2, d: 3 }, e: 4 }
+ */
+export function copyObject(deep: boolean, destination: object, ...sources: object[]): object;
+/**
+ * `ObjectExtensions` is a constant that applies a patch to the global
+ * `Object` constructor. This patch extends the `Object` with additional
+ * methods and properties, enhancing its functionality.
+ *
+ * The `Patch` function takes two arguments: the target object to be patched
+ * (in this case, `Object`), and an object containing the methods and
+ * properties to be added to the target object.
+ *
+ * @type {Patch}
+ * @memberof module:object.extensions
+ */
+export const ObjectExtensions: Patch;
+/**
+ * `ObjectPrototypeExtensions` is a constant that applies a patch to the
+ * Object prototype. This patch extends the Object prototype with additional
+ * methods and properties, enhancing its functionality.
+ *
+ * The `Patch` function takes two arguments: the target object to be patched
+ * (in this case, `Object.prototype`), and an object containing the methods
+ * and properties to be added to the target object.
+ *
+ * @example
+ * // Using a method added by ObjectPrototypeExtensions
+ * const obj = {};
+ * console.log(obj.isObject()); // Output: true
+ *
+ * @const
+ * @type {Patch}
+ * @memberof module:object.extensions
+ */
+export const ObjectPrototypeExtensions: Patch;
+import { Patch } from '@nejs/extension';