@nejs/basic-extensions 1.7.0 → 1.9.0

package/dist/cjs/newClasses/deferred.js

@@ -0,0 +1,306 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Deferred_promise, _Deferred_reject, _Deferred_resolve, _Deferred_settled;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeferredExtension = exports.Deferred = void 0;
+const extension_1 = require("@nejs/extension");
+/**
+ * Deferreds, which were first introduced by jQuery for browsers in the early
+ * 2000s, are a way to manage asynchronous operations. They have been widely
+ * used and replicated by engineers since then. Although the Promise class in
+ * modern JavaScript provides a static method called `withResolvers` that
+ * returns an object with similar properties to a Deferred, it is not directly
+ * supported by Node.js.
+ *
+ * ```
+ * const withResolvers = Promise.withResolvers()
+ * Reflect.has(withResolvers, 'promise') // true
+ * Reflect.has(withResolvers, 'resolve') // true
+ * Reflect.has(withResolvers, 'reject')  // true
+ * ```
+ *
+ * This Deferred class extends the Promise class, allowing it to capture the
+ * value or reason for easy access after resolution, akin to
+ * {@link Promise.withResolvers}. As it extends {@link Promise}, it is
+ * 'thenable' and works with `await` as if it were a native Promise. This
+ * allows seamless integration with code expecting Promise-like objects.
+ */
+class Deferred extends Promise {
+    /**
+     * The constructor for Deferred instances. By default, a new Deferred will
+     * have three important properties: `promise`, `resolve`, and `reject`.
+     *
+     * The constructor takes an object called `options`. It can have the
+     * following properties:
+     *
+     * ```
+     * interface BaseDeferredOptions {
+     *   // Deferreds store the value or reason. To turn this off, pass true
+     *   // to this option.
+     *   doNotTrackAnswers?: boolean;
+     * }
+     *
+     * interface ResolveDeferredOptions {
+     *   // Passing in an option object with a resolve value will auto resolve
+     *   // the Deferred with your value. An error will be raised if both
+     *   // resolve and reject are supplied at the same time.
+     *   resolve?: (value: any) => void;
+     * }
+     *
+     * interface RejectDeferredOptions {
+     *   // Passing in an option object with a reject reason will auto reject
+     *   // the Deferred with your reason. An error will be raised if both
+     *   // resolve and reject are supplied at the same time.
+     *   reject?: (reason: any) => void;
+     * }
+     *
+     * type DeferredOptions = BaseDeferredOptions &
+     *   (ResolveDeferredOptions | RejectDeferredOptions)
+     * ```
+     *
+     * @param {object} options see above for examples on supported options, but
+     * when supplied, the constructor can take instructions on how to auto
+     * resolve or reject the deferred created here.
+     */
+    constructor(options) {
+        // Check if options is an object, if not, assign an empty object to config
+        const config = (options && typeof (options) === 'object'
+            ? options
+            : {});
+        // Throw an error if both resolve and reject options are provided
+        if (config?.resolve && config?.reject) {
+            throw new TypeError('resolve and reject options cannot be simultaneously provided');
+        }
+        // Create an empty object to store the resolve and reject functions
+        let _resolve, _reject;
+        // Create a new promise and assign its resolve and reject functions to resolvers
+        super((resolve, reject) => {
+            _resolve = resolve;
+            _reject = reject;
+            if (config?.executor && typeof (config?.executor) === 'function') {
+                config?.executor(resolve, reject);
+            }
+        });
+        /**
+         * The promise backing this deferred object. Created when the constructor
+         * runs, this promise is what all `Promise.prototype` functions are routed
+         * to.
+         *
+         * @type {Promise}
+         */
+        _Deferred_promise.set(this, null
+        /**
+         * The reject() resolver that will be assigned when a new instance is
+         * created. Invoking this function with or without a `reason` will cause
+         * the deferred's promise to be settled.
+         *
+         * @type {function}
+         */
+        );
+        /**
+         * The reject() resolver that will be assigned when a new instance is
+         * created. Invoking this function with or without a `reason` will cause
+         * the deferred's promise to be settled.
+         *
+         * @type {function}
+         */
+        _Deferred_reject.set(this, null
+        /**
+         * The resolve() resolver that will be assigned when a new instance is
+         * created. Invoking this function with or without a `value` will cause
+         * the deferred's promise to be settled.
+         *
+         * @type {function}
+         */
+        );
+        /**
+         * The resolve() resolver that will be assigned when a new instance is
+         * created. Invoking this function with or without a `value` will cause
+         * the deferred's promise to be settled.
+         *
+         * @type {function}
+         */
+        _Deferred_resolve.set(this, null
+        /**
+         * When the Deferred is settled with {@link Deferred.resolve}, the `value`
+         * passed to that function will be set here as well.
+         *
+         * @type {*}
+         */
+        );
+        /**
+         * When the Deferred is settled with {@link Deferred.resolve}, the `value`
+         * passed to that function will be set here as well.
+         *
+         * @type {*}
+         */
+        this.value = null;
+        /**
+         * When the Deferred is settled with {@link Deferred.reject}, the `reason`
+         * passed to that rejection will also be stored here.
+         *
+         * @type {*}
+         */
+        this.reason = null;
+        /**
+         * When either {@link Deferred.resolve} or {@link Deferred.reject} are called,
+         * this property is set to `true`. Its current status at any time can be
+         * queried using the {@link Deferred.settled} getter.
+         *
+         * @type {boolean}
+         */
+        _Deferred_settled.set(this, false
+        /**
+         * The constructor for Deferred instances. By default, a new Deferred will
+         * have three important properties: `promise`, `resolve`, and `reject`.
+         *
+         * The constructor takes an object called `options`. It can have the
+         * following properties:
+         *
+         * ```
+         * interface BaseDeferredOptions {
+         *   // Deferreds store the value or reason. To turn this off, pass true
+         *   // to this option.
+         *   doNotTrackAnswers?: boolean;
+         * }
+         *
+         * interface ResolveDeferredOptions {
+         *   // Passing in an option object with a resolve value will auto resolve
+         *   // the Deferred with your value. An error will be raised if both
+         *   // resolve and reject are supplied at the same time.
+         *   resolve?: (value: any) => void;
+         * }
+         *
+         * interface RejectDeferredOptions {
+         *   // Passing in an option object with a reject reason will auto reject
+         *   // the Deferred with your reason. An error will be raised if both
+         *   // resolve and reject are supplied at the same time.
+         *   reject?: (reason: any) => void;
+         * }
+         *
+         * type DeferredOptions = BaseDeferredOptions &
+         *   (ResolveDeferredOptions | RejectDeferredOptions)
+         * ```
+         *
+         * @param {object} options see above for examples on supported options, but
+         * when supplied, the constructor can take instructions on how to auto
+         * resolve or reject the deferred created here.
+         */
+        );
+        // Define the resolve function for the Deferred instance
+        __classPrivateFieldSet(this, _Deferred_resolve, (value) => {
+            // If doNotTrackAnswers is not set to true, store the value
+            if (config?.doNotTrackAnswers !== true) {
+                this.value = value;
+            }
+            // Mark the Deferred instance as settled
+            __classPrivateFieldSet(this, _Deferred_settled, true, "f");
+            // Resolve the promise with the provided value
+            return _resolve(value);
+        }, "f");
+        // Define the reject function for the Deferred instance
+        __classPrivateFieldSet(this, _Deferred_reject, async (reason) => {
+            // If doNotTrackAnswers is not set to true, store the reason
+            if (config?.doNotTrackAnswers !== true) {
+                this.reason = reason;
+            }
+            // Mark the Deferred instance as settled
+            __classPrivateFieldSet(this, _Deferred_settled, true, "f");
+            // Reject the promise with the provided reason
+            return _reject(reason);
+        }, "f");
+        __classPrivateFieldSet(this, _Deferred_promise, this, "f");
+        // If a resolve option is provided, resolve the Deferred instance with it
+        if (config?.resolve) {
+            __classPrivateFieldGet(this, _Deferred_resolve, "f").call(this, config?.resolve);
+        }
+        // If a reject option is provided, reject the Deferred instance with it
+        else if (config?.reject) {
+            __classPrivateFieldGet(this, _Deferred_reject, "f").call(this, config?.reject);
+        }
+    }
+    /**
+     * Returns a boolean value that indicates whether or not this Deferred
+     * has been settled (either resolve or reject have been invoked).
+     *
+     * @returns {boolean} `true` if either {@link Deferred.resolve} or
+     * {@link Deferred.reject} have been invoked; `false` otherwise
+     */
+    get settled() {
+        return __classPrivateFieldGet(this, _Deferred_settled, "f");
+    }
+    /**
+     * Accessor for the promise managed by this Deferred instance.
+     *
+     * This getter provides access to the internal promise which is controlled
+     * by the Deferred's resolve and reject methods. It allows external code to
+     * attach callbacks for the resolution or rejection of the Deferred without
+     * the ability to directly resolve or reject it.
+     *
+     * @returns {Promise} The promise controlled by this Deferred instance.
+     */
+    get promise() {
+        return __classPrivateFieldGet(this, _Deferred_promise, "f");
+    }
+    /**
+     * Resolves the Deferred with the given value. If the value is a thenable
+     * (i.e., has a "then" method), the Deferred will "follow" that thenable,
+     * adopting its eventual state; otherwise, the Deferred will be fulfilled
+     * with the value. This function behaves the same as Promise.resolve.
+     *
+     * @param {*} value - The value to resolve the Deferred with.
+     * @returns {Promise} A Promise that is resolved with the given value.
+     */
+    resolve(value) {
+        return __classPrivateFieldGet(this, _Deferred_resolve, "f").call(this, value);
+    }
+    /**
+     * Rejects the Deferred with the given reason. This function behaves the
+     * same as Promise.reject. The Deferred will be rejected with the provided
+     * reason.
+     *
+     * @param {*} reason - The reason to reject the Deferred with.
+     * @returns {Promise} A Promise that is rejected with the given reason.
+     */
+    reject(reason) {
+        return __classPrivateFieldGet(this, _Deferred_reject, "f").call(this, reason);
+    }
+    /**
+     * A getter for the species symbol which returns a custom DeferredPromise
+     * class. This class extends from Deferred and is used to ensure that the
+     * constructor signature matches that of a Promise. The executor function
+     * passed to the constructor of this class is used to initialize the Deferred
+     * object with resolve and reject functions, similar to how a Promise would
+     * be initialized.
+     *
+     * @returns {DeferredPromise} A DeferredPromise class that extends Deferred.
+     */
+    static get [(_Deferred_promise = new WeakMap(), _Deferred_reject = new WeakMap(), _Deferred_resolve = new WeakMap(), _Deferred_settled = new WeakMap(), Symbol.species)]() {
+        return class DeferredPromise extends Deferred {
+            /**
+             * The constructor for the DeferredPromise class.
+             * It takes an executor function which is used to initialize the Deferred.
+             *
+             * @param {Function} executor - A function that is passed with the resolve
+             * and reject functions. The executor is expected to initialize the
+             * Deferred by calling resolve or reject at some point.
+             */
+            constructor(executor) {
+                super({ executor });
+            }
+        };
+    }
+}
+exports.Deferred = Deferred;
+exports.DeferredExtension = new extension_1.Extension(Deferred);
+//# sourceMappingURL=deferred.js.map

package/dist/cjs/newClasses/deferred.js.map

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

package/dist/cjs/setextensions.d.ts

@@ -0,0 +1,2 @@
+export const SetPrototypeExtensions: Patch;
+import { Patch } from '@nejs/extension';

package/dist/cjs/setextensions.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetPrototypeExtensions = void 0;
+const extension_1 = require("@nejs/extension");
+exports.SetPrototypeExtensions = new extension_1.Patch(Set.prototype, {
+    /**
+     * Merges multiple iterables into the set. Each element from the iterables
+     * is added to the set, ensuring uniqueness of all elements. This method
+     * mutates the original set.
+     *
+     * @param {...Iterable} iterables - One or more iterable objects (like Set
+     * or Array) whose elements will be added to the set.
+     */
+    concat(...iterables) {
+        for (const iterable of iterables) {
+            if (typeof iterable === 'string' ||
+                !Reflect.has(iterable, Symbol.iterator)) {
+                this.add(iterable);
+                continue;
+            }
+            for (const element of iterable) {
+                this.add(element);
+            }
+        }
+    },
+    /**
+     * Checks to see if any value within the `Set` loosely equals the supplied
+     * value.
+     *
+     * @param {*} value any value that might be loosely equal to an item in the
+     * set, as opposed to {@link Set.has} which is the equivalent of a strict or
+     * triple equals (`===`) check
+     * @returns {boolean} `true` if any value within the set is loosely equal to
+     * the supplied value, `false` otherwise
+     */
+    contains(value) {
+        for (const element of this) {
+            if (value == element) {
+                return true;
+            }
+        }
+        return false;
+    },
+    /**
+     * Checks if every element in the set passes the test implemented by the
+     * provided function. The function is called with each element of the set.
+     * Note: Since sets do not have indices, the index parameter is always NaN.
+     *
+     * @param {Function} everyFn - The function to test each element. Receives
+     * the element, index (always NaN), and the set itself.
+     * @param {Object} [thisArg] - Optional. Value to use as `this` when executing
+     * `everyFn`.
+     * @throws {TypeError} If `everyFn` is not a function.
+     * @returns {boolean} True if every element passes the test, false otherwise.
+     */
+    every(everyFn, thisArg) {
+        if (typeof everyFn !== 'function') {
+            throw new TypeError(`everyFn must be a function! Received ${String(everyFn)}`);
+        }
+        let found = 0;
+        for (const element of this) {
+            if (everyFn.call(thisArg, element, NaN, this)) {
+                found++;
+            }
+        }
+        return (found === this.size);
+    },
+    /**
+     * Finds the first element in the set satisfying the provided testing
+     * function. If no elements satisfy the testing function, undefined is
+     * returned. The function is called with each element of the set.
+     * Note: Since sets do not have indices, the index parameter is always NaN.
+     *
+     * @param {Function} findFn - The function to execute on each element. It
+     * receives the element, index (always NaN), and the set itself.
+     * @param {Object} [thisArg] - Optional. Value to use as `this` when executing
+     * `findFn`.
+     * @throws {TypeError} If `findFn` is not a function.
+     * @returns {*} The first element that satisfies `findFn`, or undefined.
+     */
+    find(findFn, thisArg) {
+        if (typeof findFn !== 'function') {
+            throw new TypeError(`findFn must be a function! Received ${String(findFn)}`);
+        }
+        for (const element of this) {
+            const match = findFn.call(thisArg, element, NaN, this);
+            if (match) {
+                return element;
+            }
+        }
+        return undefined;
+    },
+    /**
+     * Finds the last element in the set satisfying the provided testing function.
+     * If no elements satisfy the testing function, undefined is returned. The
+     * function is called with each element of the set in reverse order.
+     * Note: Since sets do not have indices, the index parameter is always NaN.
+     *
+     * @param {Function} findFn - The function to execute on each element. It
+     * receives the element, index (always NaN), and the set itself.
+     * @param {Object} [thisArg] - Optional. Value to use as `this` when executing
+     * `findFn`.
+     * @throws {TypeError} If `findFn` is not a function.
+     * @returns {*} The last element that satisfies `findFn`, or undefined.
+     */
+    findLast(findFn, thisArg) {
+        if (typeof findFn !== 'function') {
+            throw new TypeError(`findFn must be a function! Received ${String(findFn)}`);
+        }
+        const found = [];
+        for (const element of this) {
+            const match = findFn.call(thisArg, element, NaN, this);
+            if (match) {
+                found.push(element);
+            }
+        }
+        if (found.length) {
+            return found[found.length - 1];
+        }
+        return undefined;
+    },
+    /**
+     * A getter property that returns the number of elements in the set.
+     * This is an alias for the `size` property of the set.
+     *
+     * @returns {number} The number of elements in the set.
+     */
+    get length() {
+        return this.size;
+    },
+    /**
+     * Creates a new array populated with the results of calling the provided
+     * function on every element in the set. The function is called with each
+     * element of the set. Note: Since sets do not have indices, the index
+     * parameter is always NaN.
+     *
+     * @param {Function} mapFn - The function to execute on each element. It
+     * receives the element, index (always NaN), and the set itself.
+     * @param {Object} [thisArg] - Optional. Value to use as `this` when executing
+     * `mapFn`.
+     * @throws {TypeError} If `mapFn` is not a function.
+     * @returns {Array} A new array with each element being the result of the
+     * `mapFn`.
+     */
+    map(mapFn, thisArg) {
+        if (typeof mapFn !== 'function') {
+            throw new TypeError(`mapFn must be a function! Received ${String(mapFn)}`);
+        }
+        const transformed = [];
+        for (const element of this) {
+            transformed.push(mapFn.call(thisArg, element, NaN, this));
+        }
+        return transformed;
+    },
+    /**
+     * Applies a function against an accumulator and each element in the set to
+     * reduce it to a single value. The function is called with each element of
+     * the set. Note: Since sets do not have indices, the index parameter is
+     * always NaN.
+     *
+     * @param {Function} reduceFn - The function to execute on each element. It
+     * receives the accumulator, element, index (always NaN), and the set itself.
+     * @param {*} initialValue - The initial value to start reducing from.
+     * @param {Object} [thisArg] - Optional. Value to use as `this` when executing
+     * `reduceFn`.
+     * @throws {TypeError} If `reduceFn` is not a function.
+     * @returns {*} The reduced value.
+     */
+    reduce(reduceFn, initialValue, thisArg) {
+        if (typeof reduceFn !== 'function') {
+            throw new TypeError(`reduceFn must be a Function! Received ${String(reduceFn)}`);
+        }
+        let accumulator = initialValue;
+        for (const element of this) {
+            accumulator = reduceFn.call(thisArg, accumulator, element, NaN, this);
+        }
+        return accumulator;
+    },
+    /**
+     * Tests whether at least one element in the set passes the test implemented
+     * by the provided function. The function is called with each element of the
+     * set. Note: Since sets do not have indices, the index parameter is always NaN.
+     *
+     * @param {Function} someFn - The function to test each element. It receives
+     * the element, index (always NaN), and the set itself.
+     * @param {Object} [thisArg] - Optional. Value to use as `this` when executing
+     * `someFn`.
+     * @throws {TypeError} If `someFn` is not a function.
+     * @returns {boolean} True if at least one element passes the test, false
+     * otherwise.
+     */
+    some(someFn, thisArg) {
+        if (typeof someFn !== 'function') {
+            throw new TypeError(`someFn must be a function! Received ${String(someFn)}`);
+        }
+        for (const element of this) {
+            if (someFn.call(thisArg, element, NaN, this)) {
+                return true;
+            }
+        }
+        return false;
+    },
+});
+//# sourceMappingURL=setextensions.js.map

package/dist/cjs/setextensions.js.map

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

package/dist/mjs/functionextensions.d.ts

@@ -8,4 +8,5 @@
  * capabilities of function handling and introspection in JavaScript.
  */
 export const FunctionExtensions: Patch;
+export const FunctionPrototypeExtensions: Patch;
 import { Patch } from '@nejs/extension';