@nejs/basic-extensions 2.21.5 → 2.22.6

package/dist/cjs/classes/refmap.js

@@ -1,421 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RefMapExtensions = exports.RefMap = void 0;
-const extension_1 = require("@nejs/extension");
-const object_extensions_js_1 = require("../object.extensions.js");
-const symbol_extensions_js_1 = require("../symbol.extensions.js");
-const weakref_extensions_js_1 = require("../weakref.extensions.js");
-const iterable_js_1 = require("./iterable.js");
-const { isObject, isNullDefined, isValidKey } = object_extensions_js_1.ObjectExtensions.patches;
-const { isRegistered } = symbol_extensions_js_1.SymbolExtensions.patches;
-const { isValidReference } = weakref_extensions_js_1.WeakRefExtensions.patches;
-/**
- * RefMap class extends the standard Map object to manage a collection of
- * WeakRef values mapped to strong keys. It provides additional functionality
- * such as objectification of values and various utility methods.
- *
- * Unlike standard Maps or Objects, RefMap stores weak references to objects,
- * allowing them to be garbage-collected if there are no other references to
- * them. This behavior is different from Maps and standard Objects, which
- * maintain strong references to their elements.
- *
- * @extends Map
- */
-class RefMap extends Map {
-    /**
-     * Private field to track whether the RefMap should objectify primitive
-     * values.
-     *
-     * @private
-     */
-    #objectifyValues = false;
-    constructor(...args) {
-        super(...args);
-    }
-    /**
-     * Method to control whether the RefMap should objectify its values. When
-     * objectifying, primitive values (number, string, boolean, bigint) are
-     * converted to their respective object types, which allows them to be used as
-     * WeakRef targets.
-     *
-     * @param {boolean} setObjectification - Flag to enable or disable
-     * objectification.
-     * @returns {RefMap} - The current RefMap instance to allow method chaining.
-     */
-    objectifying(setObjectification = true) {
-        this.objectifyValues = setObjectification;
-        return this;
-    }
-    /**
-     * The function converts a JavaScript Map object into a regular JavaScript
-     * object, handling invalid keys by converting them to strings.
-     *
-     * @returns {object} an object; keys that are not either a `String` or a
-     * `Symbol` will be converted to a string.
-     */
-    asObject() {
-        const object = {};
-        for (const [key, value] of this) {
-            const useKey = isValidKey(key) ? key : String(key);
-            const useValue = value?.valueOf() || value;
-            object[useKey] = useValue;
-        }
-        return object;
-    }
-    /**
-     * Returns the state indicating whether or not `RefMap` will attempt to
-     * convert non-valid primitives into targets that are valid input for
-     * new `WeakRef` object instances. If this value is `false` then no
-     * *objectification* will occur.
-     *
-     * @returns {boolean} The current state of objectifyValues.
-     */
-    get objectifyValues() {
-        return this.#objectifyValues;
-    }
-    /**
-     * The `get` function retrieves a value from a map and returns it, or returns a
-     * default value if the value is null or undefined. The actual retrieved value
-     * is a dereferenced `WeakRef`. If the result is `undefined` and this is not the
-     * expected response, it is likely the value has been garbage collected.
-     *
-     * @param {any} key - The key parameter is the key of the value you want to
-     * retrieve from the data structure.
-     * @param {any} defaultValue - The `defaultValue` parameter is the value that
-     * will be returned if the key does not exist in the map or if the value
-     * associated with the key has been garbage collected (i.e., it no longer
-     * exists).
-     * @returns The method is returning the value associated with the given key.
-     * If the value is not found or if it has been garbage collected (deref()
-     * returns null), then the defaultValue is returned.
-     */
-    get(key, defaultValue) {
-        const value = super.get(key);
-        if (!value || !value?.deref()) {
-            return defaultValue;
-        }
-        return value?.deref();
-    }
-    /**
-     * Setting this value to true, will cause all set values to the Map to
-     * be analyzed for validity as a candidate to be wrapped in a `WeakRef`
-     * object. If true, and if possible, the object will be turned into an
-     * `Object` variant first.
-     *
-     * @param {boolean} value - The new state to set for objectifyValues.
-     */
-    set objectifyValues(value) {
-        this.#objectifyValues = !!value;
-    }
-    /**
-     * Overrides the set method of `Map`. Adds a value to the `RefMap`,
-     * converting it to a `WeakRef`. Throws an error if the value is not a
-     * valid `WeakRef` target (e.g., `null`, `undefined`, or a registered
-     * `symbol`). If {@link objectifyValues} is enabled, an attempt to convert
-     * primitives to their object variants will be made. These are `numbers`,
-     * `strings`, `boolean` values and `bigint`s.
-     *
-     * @param {*} key - The `key` to be set on the `RefMap`
-     * @param {*} value - The value to be associated with the `key`
-     * @throws {TypeError} If the value is not a valid WeakRef target.
-     */
-    set(key, value) {
-        let useValue = value;
-        // Objectify the value if needed
-        if (this.#objectifyValues && (typeof useValue === 'number' ||
-            typeof useValue === 'string' ||
-            typeof useValue === 'boolean' ||
-            typeof useValue === 'bigint')) {
-            useValue = Object(useValue);
-        }
-        // Check if the value is an object, and if it's a symbol, ensure it's not registered
-        if (typeof useValue === 'symbol' && Symbol.keyFor(useValue) !== undefined) {
-            throw new TypeError('RefMap cannot accept registered symbols as values');
-        }
-        if (typeof useValue !== 'object' && typeof useValue !== 'symbol') {
-            throw new TypeError('RefMap values must be objects, non-registered symbols, or objectified primitives');
-        }
-        // If the value is null or undefined, throw an error
-        if (useValue === null || useValue === undefined) {
-            throw new TypeError('RefMap values cannot be null or undefined');
-        }
-        const ref = new WeakRef(useValue);
-        super.set(key, ref);
-    }
-    /**
-     * Sets multiple values at a single time. The format is an array of array
-     * or rather an array of {@link Object.entries} (for example,
-     * `[[key1,value1], [key2,value2]]`). For each entry pair, if the length
-     * is not 2, either missing a key or value, it will be skipped.
-     *
-     * @param {Iterable} values - An iterable of values to add to the RefMap.
-     * @throws {TypeError} If the supplied values are falsey or non-iterable.
-     * @returns {RepMap} returns `this` to allow for chaining
-     */
-    setAll(entries) {
-        if (!iterable_js_1.Iterable.isIterable(entries)) {
-            throw new TypeError('The supplied list of entries must be an array of arrays in the ' +
-                'format [[key1, value1], [key2, value2], ...].');
-        }
-        const forEach = entry => {
-            const [key, value] = entry;
-            if (!key || !isObject(value) || !isRegistered(value)) {
-                return;
-            }
-            this.set(key, value);
-        };
-        for (const entry of entries) {
-            forEach(entry);
-        }
-        return this;
-    }
-    /**
-     * Removes all elements from the RefMap that have been garbage collected
-     * (i.e., their WeakRef no longer points to an object).
-     *
-     * @returns {RefMap} - The current RefMap instance to allow method chaining.
-     */
-    clean() {
-        for (const [key, dereferenced] of this) {
-            if (!dereferenced) {
-                this.delete(key);
-            }
-        }
-        return this;
-    }
-    /**
-     * Executes a provided function once for each value in the RefMap. The callback
-     * function receives the dereferenced value, the value again (as RefMap doesn't
-     * use keys), and the RefMap itself. This method provides a way to iterate over
-     * and apply operations to the values stored in the RefMap, taking into account
-     * that they are weak references and may have been garbage-collected.
-     *
-     * @param {Function} forEachFn - Function to execute for each element. It
-     * takes three arguments: element, element (again, as RefMap has no key), and
-     * the RefMap itself.
-     * @param {*} thisArg - Value to use as `this` when executing `forEachFn`.
-     */
-    entries() {
-        const entriesIterator = super.entries();
-        const refIterator = new iterable_js_1.Iterator(entriesIterator, (entry) => {
-            if (entry) {
-                const [key, ref] = entry;
-                const value = ref?.deref();
-                return [key, value];
-            }
-            return entry;
-        });
-        return refIterator;
-    }
-    /**
-     * Iterate over the items in the map and pass them to the supplied
-     * function ala `Map.prototype.forEach`. Note however, there are no
-     * indexes on Maps and as such, the index parameter of the callback
-     * will always be the value's key. Subsequently the `array` or third
-     * parameter will receive the map instance rather than an array.
-     *
-     * @param {function} forEachFn the function to use for each element in
-     * the set.
-     * @param {object} thisArg the `this` argument to be applied to each
-     * invocation of the `forEachFn` callback. Note, this value is unable
-     * to be applied if the `forEachFn` is a big arrow function
-     */
-    forEach(forEachFn, thisArg) {
-        for (const [key, ref] of super.entries()) {
-            const value = ref?.deref();
-            if (!value) {
-                continue;
-            }
-            forEachFn.call(thisArg, value, key, this);
-        }
-    }
-    /**
-     * Returns an iterator for the values in the RefMap. Each value is
-     * dereferenced from its WeakRef before being returned. This method allows
-     * iterating over he set's values, similar to how one would iterate over
-     * values in a standard Map or Array, but with the understanding that the
-     * values are weakly referenced and may no longer exist (in which case
-     * they are skipped).
-     *
-     * @returns {Iterator} An iterator for the values.
-     */
-    values() {
-        return new iterable_js_1.Iterator(super.values(), function perItem(value) {
-            const dereferenced = value?.deref();
-            return dereferenced || value;
-        });
-    }
-    /**
-     * Determines whether an element with the specified value exists in the
-     * `RefMap`. For non-objectified sets, this method checks if the dereferenced
-     * values of the map include the specified value.
-     *
-     * For objectified sets, strict is set to false which uses loose
-     * equality to allow for things like `Object(5)` to equal `5`. This is important
-     * because otherwise primitives could not be weakly referenced. In the grand
-     * scheme of things, this is only useful if the objectified value is the
-     * one being referenced.
-     *
-     * @param {*} value - The value to check for presence in the RefMap.
-     * @param {boolean} strict - if `true`, the default, then the supplied value
-     * is hard compared to the dereferenced value (`===`). If `false`, then a
-     * loose comparison is used (`==`)
-     * @returns {boolean} - True if an element with the specified value exists
-     * in the RefMap, false otherwise.
-     */
-    hasValue(value, strict = true) {
-        if (isNullDefined(value)) {
-            return false;
-        }
-        if (this.#objectifyValues) {
-            strict = false;
-        }
-        for (const [_, dereferenced] of this) {
-            if ((strict && value === dereferenced) ||
-                (!strict && value == dereferenced)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * The `filter` function filters the entries of a `RefMap` object based on
-     * a given filter function. The dereferenced entries of the values of the map
-     * will be passed to the function rather than a `WeakRef` itself.
-     *
-     * A new resulting entry set will be generated and a new `RefMap` will be made
-     * from these entries and returned. Note that this function never returns
-     * `null`
-     *
-     * @param {function} filterFn - The `filterFn` parameter is a function that
-     * will be used to filter the entries in the `RefMap`. It will be called with
-     * three arguments: the value of the current entry, the key of the current
-     * entry, and the `RefMap` itself. The function should return `true`
-     * @param {object} thisArg - The `thisArg` parameter is an optional argument
-     * that specifies the value to be used as `this` when executing the
-     * `filterFn` function. It allows you to explicitly set the context in which
-     * the `filterFn` function is called. If `thisArg` is not provided, `this
-     * @returns {array} The `filter` method is returning an array of filtered map
-     * entries
-     */
-    filter(filterFn, thisArg) {
-        const resultingEntries = [];
-        for (const [key, dereferenced] of this) {
-            if (filterFn.call(thisArg, dereferenced, key, this)) {
-                resultingEntries.push([key, dereferenced]);
-            }
-        }
-        return resultingEntries;
-    }
-    /**
-     * The `find` function iterates over a map and calls a given function on
-     * each value, returning the first value for which the function returns
-     * a truthy value.
-     *
-     * The function signature of `findFn` is
-     * ```
-     * function findFn(value, key, map)
-     * ```
-     * 'value' is passed to findFn up to two times; first with the `WeakRef`
-     * value, second with the result of {@link WeakRef.deref}. If `findFn`
-     * returns true for either of these the dereferenced value will be
-     * returned from the call to {@link RefMap.find}.
-     * `key` represents the key object that the value is mapped to.
-     * `map` is simply a reference to `this` map.
-     *
-     * @param findFn - `findFn` is a function that will be called for each
-     * element in the map. It takes three arguments: `ref`, `key`, and `map`;
-     * where `ref` is the value of the current element in the map, `key` is
-     * the key of the current element, and `map` is a reference to the instance
-     * being searched.
-     * @param thisArg - The `thisArg` parameter is the value to be used as
-     * the `this` value when executing the `findFn` function. It allows you
-     * to specify the context in which the `findFn` function should be called.
-     * @returns the first dereferenced value that satisfies the condition
-     * specified by the `findFn` function. If no value satisfies the condition,
-     * it returns `null`.
-     */
-    find(findFn, thisArg) {
-        for (const [key, dereferenced] of this) {
-            const ref = super.get(key);
-            let result = findFn.call(thisArg, ref, key, map);
-            if (!result) {
-                result = findFn.call(thisArg, dereferenced, key, map);
-            }
-            if (result) {
-                return dereferenced;
-            }
-        }
-        return null;
-    }
-    /**
-     * Creates a new array or `RefMap` with the results of calling a provided
-     * function on every element in the calling `RefMap`. This method dereferences
-     * each value, applies the `mapFn`, and collects the results. If `toRefMap` is
-     * `true`, a new `RefMap` is returned; otherwise, an array. This method
-     * differs from `Array.map` in handling weak references and the potential to
-     * return a new `RefMap` instead of an array.
-     *
-     * @param {Function} mapFn - Function that produces an element of the new
-     * array or `RefMap`, taking three arguments.
-     * @param {*} thisArg - Value to use as this when executing mapFn.
-     * @param {boolean} toRefMap - Determines if the output should be a new
-     * `RefMap` (`true`) or an array (`false`).
-     * @param {boolean} mirrorObjectification - If `true` and `toRefMap` is
-     * `true`, the new `RefMap` mirrors the objectification setting of the
-     * original.
-     * @returns {Array|RefMap} - A new array or `RefMap` with each element being
-     * the result of the `mapFn`.
-     */
-    map(mapFn, thisArg, toRefMap, mirrorObjectification) {
-        if (typeof mapFn !== 'function') {
-            throw new TypeError('mapFn must be a function! Received', mapFn);
-        }
-        const entries = [];
-        const errors = [];
-        let needsObjectification = mirrorObjectification && this.objectifyValues;
-        let detectNeed = mirrorObjectification === undefined;
-        let objectify = needsObjectification;
-        for (const [key, dereferenced] of this) {
-            const [, VALUE] = [0, 1];
-            const transformed = mapFn.call(thisArg, [key, dereferenced], key, this);
-            if (!isValidReference(transformed[VALUE])) {
-                if (isValidReference(Object(transformed[VALUE]))) {
-                    needsObjectification = true;
-                    if (detectNeed && !objectify) {
-                        objectify = true;
-                        transformed[VALUE] = Object(transformed[VALUE]);
-                    }
-                }
-            }
-            entries.push(transformed);
-        }
-        if (toRefMap) {
-            return new RefMap(entries).objectifying(objectify);
-        }
-        return entries;
-    }
-    /**
-     * The function returns an iterator that iterates over the entries of an object,
-     * dereferencing any weak references.
-     *
-     * @returns {Iterator} A new iterator object is being returned.
-     */
-    *[Symbol.iterator]() {
-        for (const [key, ref] of this.entries()) {
-            yield [key, ref];
-        }
-    }
-    /**
-     * Ensures that the constructor of this object instance's name
-     * is returned if the string tag for this instance is queried
-     *
-     * @returns {string} the name of the class
-     */
-    get [Symbol.toStringTag]() {
-        return this.constructor.name;
-    }
-}
-exports.RefMap = RefMap;
-exports.RefMapExtensions = new extension_1.Extension(RefMap);
-//# sourceMappingURL=refmap.js.map

package/dist/cjs/classes/refmap.js.map

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

package/dist/cjs/classes/refset.d.ts

@@ -1,186 +0,0 @@
-/**
- * RefSet class extends the standard Set object to manage a collection of
- * WeakRef objects. It provides additional functionality such as objectification
- * of values and various utility methods.
- *
- * Unlike standard Sets or Arrays, RefSet stores weak references to objects,
- * allowing them to be garbage-collected if there are no other references to
- * them. This behavior is different from Arrays and standard Sets, which
- * maintain strong references to their elements.
- *
- * @extends Set
- */
-export class RefSet extends Set<any> {
-    constructor(values?: readonly any[] | null | undefined);
-    constructor(iterable?: Iterable<any> | null | undefined);
-    /**
-     * Method to control whether the RefSet should objectify its values. When
-     * objectifying, primitive values (number, string, boolean, bigint) are
-     * converted to their respective object types, which allows them to be used as
-     * WeakRef targets.
-     *
-     * @param {boolean} setObjectification - Flag to enable or disable
-     * objectification.
-     * @returns {RefSet} - The current RefSet instance to allow method chaining.
-     */
-    objectifying(setObjectification?: boolean): RefSet;
-    /**
-     * Setting this value to true, will cause all added values to the Set to
-     * be analyzed for validity as a candidate to be wrapped in a `WeakRef`
-     * object. If true, and if possible, the object will be turned into an
-     * `Object` variant first. This will also enable less rigid variable
-     * comparison in the `.has()` method (i.e. `==` instead of `===`).
-     *
-     * @param {boolean} value - The new state to set for objectifyValues.
-     */
-    set objectifyValues(value: boolean);
-    /**
-     * Returns the state indicating whether or not `RefSet` will attempt to
-     * convert non-valid primitives into targets that are valid input for
-     * new `WeakRef` object instances. If this value is `false` then no
-     * *objectification* will occur.
-     *
-     * @returns {boolean} The current state of objectifyValues.
-     */
-    get objectifyValues(): boolean;
-    /**
-     * Overrides the add method of Set. Adds a value to the RefSet, converting it
-     * to a WeakRef. Throws an error if the value is not a valid WeakRef target
-     * (e.g., null, undefined, or a registered symbol). If `objectifyValues` is
-     * enabled, an attempt to convert primitives to their object variants will be
-     * made. These are numbers, strings, boolean values and big integers.
-     *
-     * @param {*} value - The value to be added to the RefSet.
-     * @throws {TypeError} If the value is not a valid WeakRef target.
-     */
-    add(value: any): void;
-    /**
-     * Adds multiple values to the RefSet. The supplied `values` should be
-     * iterable and truthy. This function defers to `.add()` for its logic so
-     * each value from the supplied collection of values will also be subject
-     * to the criteria of that function.
-     *
-     * @param {Iterable} values - An iterable of values to add to the RefSet.
-     * @throws {TypeError} If the supplied values are falsey or non-iterable.
-     */
-    addAll(values: Iterable<any>): void;
-    /**
-     * Removes all elements from the RefSet that have been garbage collected
-     * (i.e., their WeakRef no longer points to an object).
-     *
-     * @returns {RefSet} - The current RefSet instance to allow method chaining.
-     */
-    clean(): RefSet;
-    /**
-     * Executes a provided function once for each value in the RefSet. The callback
-     * function receives the dereferenced value, the value again (as RefSet doesn't
-     * use keys), and the RefSet itself. This method provides a way to iterate over
-     * and apply operations to the values stored in the RefSet, taking into account
-     * that they are weak references and may have been garbage-collected.
-     *
-     * @param {Function} forEachFn - Function to execute for each element. It
-     * takes three arguments: element, element (again, as RefSet has no key), and
-     * the RefSet itself.
-     * @param {*} thisArg - Value to use as `this` when executing `forEachFn`.
-     */
-    entries(): any[][];
-    /**
-     * Iterate over the items in the set and pass them to the supplied
-     * function ala `Array.prototype.forEach`. Note however, there are no
-     * indexes on Sets and as such, the index parameter of the callback
-     * will always be `NaN`. Subsequently the `array` or third parameter
-     * will receive the set instance rather than an array.
-     *
-     * @param {function} forEachFn the function to use for each element in
-     * the set.
-     * @param {object} thisArg the `this` argument to be applied to each
-     * invocation of the `forEachFn` callback. Note, this value is unable
-     * to be applied if the `forEachFn` is a big arrow function
-     */
-    forEach(forEachFn: Function, thisArg: object): void;
-    /**
-     * Returns an iterator for the values in the RefSet. Each value is
-     * dereferenced from its WeakRef before being returned. This method allows
-     * iterating over he set's values, similar to how one would iterate over
-     * values in a standard Set or Array, but with the understanding that the
-     * values are weakly referenced and may no longer exist (in which case
-     * they are skipped).
-     *
-     * @returns {Iterator} An iterator for the values.
-     */
-    values(): Iterator<any, any, any>;
-    /**
-     * Returns an iterator for the keys of the RefSet. In RefSet, keys and
-     * values are identical, so this method behaves the same as `values()`. It
-     * provides compatibility with the standard Set interface and allows use in
-     * contexts where keys are expected, despite RefSet not differentiating
-     * between keys and values.
-     *
-     * @returns {Iterator} An iterator for the keys.
-     */
-    keys(): Iterator<any, any, any>;
-    /**
-     * Checks if the RefSet contains a value that is equal to the specified
-     * value. This method is used primarily in objectified RefSets to determine
-     * the presence of a value, taking into account objectification. It differs
-     * from the `has` method in that it's tailored for sets that have
-     * transformed their primitive values into objects, whereas `has` is more
-     * general-purpose.
-     *
-     * @param {*} value - The value to search for in the RefSet.
-     * @returns {boolean} - True if the RefSet contains the value, false otherwise.
-     */
-    contains(value: any): boolean;
-    /**
-     * Creates a new array with all elements that pass the test implemented by
-     * the provided function. This method iterates over each element,
-     * dereferences it, and applies the filter function. Unlike Array `filter`,
-     * the callback receives the dereferenced value and not an index or array,
-     * reflecting the non-indexed nature of RefSet. Useful for selectively
-     * creating arrays from the set based on certain conditions, especially when
-     * dealing with weak references.
-     *
-     * @param {Function} filterFn - Function to test each element of the RefSet.
-     * The function receives the dereferenced value.
-     * @param {*} thisArg - Value to use as `this` when executing `filterFn`.
-     * @returns {Array} - A new array with the elements that pass the test.
-     */
-    filter(filterFn: Function, thisArg: any): any[];
-    /**
-     * Returns the value of the first element in the RefSet that satisfies the
-     * provided testing function. Similar to Array `find`, this method iterates
-     * over the RefSet, dereferencing each value and applying the testing
-     * function. The non-indexed nature of RefSet is considered, as the
-     * callback does not receive an index. This method is useful for finding a
-     * specific element based on a condition.
-     *
-     * @param {*} thisArg - Value to use as this when executing findFn.
-     * @returns {*} - The value of the first element in the RefSet that satisfies
-     * the testing function, or undefined if none found.
-     * @returns {any} the dereferenced value if found, or undefined otherwise
-     */
-    find(findFn: any, thisArg: any): any;
-    /**
-     * Creates a new array or `RefSet` with the results of calling a provided
-     * function on every element in the calling `RefSet`. This method dereferences
-     * each value, applies the `mapFn`, and collects the results. If `toRefSet` is
-     * `true`, a new `RefSet` is returned; otherwise, an array. This method
-     * differs from `Array.map` in handling weak references and the potential to
-     * return a new `RefSet` instead of an array.
-     *
-     * @param {Function} mapFn - Function that produces an element of the new
-     * array or `RefSet`, taking three arguments.
-     * @param {*} thisArg - Value to use as this when executing mapFn.
-     * @param {boolean} toRefSet - Determines if the output should be a new
-     * `RefSet` (`true`) or an array (`false`).
-     * @param {boolean} mirrorObjectification - If `true` and `toRefSet` is
-     * `true`, the new `RefSet` mirrors the objectification setting of the
-     * original.
-     * @returns {Array|RefSet} - A new array or `RefSet` with each element being
-     * the result of the `mapFn`.
-     */
-    map(mapFn: Function, thisArg: any, toRefSet: boolean, mirrorObjectification: boolean): any[] | RefSet;
-    #private;
-}
-export const RefSetExtensions: Extension;
-import { Extension } from '@nejs/extension';