@valkyriestudios/utils 12.37.0 → 12.38.0

package/array/groupBy.d.ts

@@ -1,4 +1,4 @@
-type Handler<T> = (val: T) => string | number | boolean;
+type Handler<T> = (val: T) => string | number | boolean | undefined;
 /**
  * Return a grouped object from an array.
  * Take Note: This function will automatically filter out any non/empty objects from the array
@@ -15,8 +15,8 @@ type Handler<T> = (val: T) => string | number | boolean;
  *      true: [{tally: 20, name: 'Peter'}, {tally: 40, name: 'Jake'}],
  *  }
  *
- * @param {T[]} arr - Array to group
+ * @param {T[]} val - Array or Set to group
  * @param {Handler<T>|keyof T} handler - String or a function, determines what to group by
  */
-declare function groupBy<T extends Record<string, any>>(arr: T[], handler: Handler<T> | keyof T): Record<string, T[]>;
+declare function groupBy<T extends Record<string, any>>(val: T[] | Set<T>, handler: Handler<T> | keyof T): Record<string, T[]>;
 export { groupBy, groupBy as default };

package/array/join.d.ts

@@ -39,8 +39,8 @@ interface joinOptions {
 /**
  * Join an array of values while autofiltering any non-string/non-number elements
  *
- * @param {unknown[]} val - Array of values to join
+ * @param {T[]|Set<T>} val - Array or Set of values to join
  * @param {joinOptions?} opts - Join options
  */
-declare function join(val: unknown[], opts?: joinOptions): string;
+declare function join<T>(val: T[] | Set<T>, opts?: joinOptions): string;
 export { join, join as default };

package/array/split.d.ts

@@ -2,16 +2,16 @@ type SplitOptions<T> = {
     filter_fn?: (el: T) => boolean;
 };
 /**
- * Splits the provided array in a set of batches according to the provided size
+ * Splits the provided array or set in a set of batches according to the provided size
  * For Example:
  *  split([1, 2, 3, 4, 5], 2) -> [[1,2],[3,4],[5]]
  *
  * For Example w/ filter
  *  split([1, false, 3, 4, 5], 2, {filter_fn: el => isInteger(el)}) -> [[1, 3], [4, 5]]
  *
- * @param {Array} val - Array to split
+ * @param {T[]|Set<T>} val - Array or Set to split
  * @param {number} size - Size of batches
  * @param {SplitOptions?} opts - Split options
  */
-declare function split<T>(arr: T[], size: number, opts?: SplitOptions<T>): T[][];
+declare function split<T>(arr: T[] | Set<T>, size: number, opts?: SplitOptions<T>): T[][];
 export { split, split as default };

package/caching/LRU.d.ts

@@ -8,7 +8,7 @@ export type LRUCacheOptions = {
 /**
  * Least-Recently-Used (LRU) Cache
  */
-declare class LRUCache<K, V> {
+declare class LRUCache<V> {
     #private;
     constructor(opts?: LRUCacheOptions);
     /**
@@ -24,32 +24,38 @@ declare class LRUCache<K, V> {
     /**
      * Returns whether or not a key exists in cache
      *
-     * @param {K} key - Key to retrieve
+     * @param {string} key - Key to retrieve
      */
-    has(key: K): boolean;
+    has(key: string): boolean;
     /**
      * Retrieves a value from the cache
      *
-     * @param {K} key - Key to retrieve
-     * @returns {V | undefined} Either the found value or undefined
+     * @param {string} key - Key to retrieve
      */
-    get(key: K): V | undefined;
+    get(key: string): V | undefined;
     /**
      * Sets a value on to the cache
      *
-     * @param {K} key - Key to set
+     * @param {string} key - Key to set
      * @param {V} value - Value to set for the key
      */
-    set(key: K, value: V): void;
+    set(key: string, value: V): void;
     /**
      * Removes a single value from the cache
      *
-     * @param {K} key - Key to remove
+     * @param {string} key - Key to remove
      */
-    del(key: K): void;
+    del(key: string): void;
     /**
      * Clears all contents of the cache
      */
     clear(): void;
+    /**
+     * MARK: Private
+     */
+    private addToFront;
+    private removeNode;
+    private moveToFront;
+    private evictTail;
 }
 export { LRUCache, LRUCache as default };

package/{array → cjs/array}/groupBy.js

@@ -5,9 +5,21 @@ exports.default = groupBy;
 const isNotEmpty_1 = require("../object/isNotEmpty");
 const FALLBACK = '_';
 const defaultHandler = () => FALLBACK;
-function groupBy(arr, handler) {
-    if (!Array.isArray(arr))
+function groupBy(val, handler) {
+    let normalized;
+    if (Array.isArray(val)) {
+        if (!val.length)
+            return {};
+        normalized = val;
+    }
+    else if (val instanceof Set) {
+        if (!val.size)
+            return {};
+        normalized = [...val];
+    }
+    else {
         return {};
+    }
     const acc = {};
     const n_handler = typeof handler === 'function'
         ? handler
@@ -16,8 +28,8 @@ function groupBy(arr, handler) {
             : defaultHandler;
     let key;
     let el;
-    for (let i = 0; i < arr.length; i++) {
-        el = arr[i];
+    for (let i = 0; i < normalized.length; i++) {
+        el = normalized[i];
         if (!(0, isNotEmpty_1.isNotEmptyObject)(el))
             continue;
         key = n_handler(el);

package/{array → cjs/array}/join.js

@@ -6,8 +6,20 @@ const round_1 = require("../number/round");
 const isIntegerAboveOrEqual_1 = require("../number/isIntegerAboveOrEqual");
 const SPACE_RGX = /(\s)+/g;
 function join(val, opts) {
-    if (!Array.isArray(val) || !val.length)
+    let normalized;
+    if (Array.isArray(val)) {
+        if (!val.length)
+            return '';
+        normalized = val;
+    }
+    else if (val instanceof Set) {
+        if (!val.size)
+            return '';
+        normalized = [...val];
+    }
+    else {
         return '';
+    }
     const DELIM = typeof opts?.delim === 'string' ? opts.delim : ' ';
     const DEDUPE = opts?.dedupe === true ? new Set() : null;
     const VALTRIM = opts?.valtrim ?? true;
@@ -15,8 +27,8 @@ function join(val, opts) {
     const VALROUND = (0, isIntegerAboveOrEqual_1.isIntegerAboveOrEqual)(opts?.valround, 0) ? opts.valround : false;
     let result = '';
     let has_val = false;
-    for (let i = 0; i < val.length; i++) {
-        const el = val[i];
+    for (let i = 0; i < normalized.length; i++) {
+        const el = normalized[i];
         let n_el;
         if (typeof el === 'string') {
             const trimmed = el.trim();

package/{array → cjs/array}/split.js

@@ -3,18 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.split = split;
 exports.default = split;
 function split(arr, size, opts) {
-    if (!Array.isArray(arr) ||
-        !Number.isInteger(size) ||
+    if (!Number.isInteger(size) ||
         size <= 0)
-        throw new Error('split requires an array and positive integer size');
+        throw new Error('split requires a positive integer size');
+    let normalized;
+    if (Array.isArray(arr)) {
+        normalized = arr;
+    }
+    else if (arr instanceof Set) {
+        normalized = [...arr];
+    }
+    else {
+        throw new Error('split requires an array or set');
+    }
     const FILTER_FN = typeof opts?.filter_fn === 'function' ? opts?.filter_fn : false;
     const result = [];
     let cursor = [];
     let ticker = 0;
-    const len = arr.length;
+    const len = normalized.length;
     if (FILTER_FN) {
         for (let i = 0; i < len; i++) {
-            const el = arr[i];
+            const el = normalized[i];
             if (FILTER_FN && !FILTER_FN(el))
                 continue;
             ticker++;
@@ -29,8 +38,8 @@ function split(arr, size, opts) {
             result.push(cursor);
     }
     else {
-        for (let i = 0; i < arr.length; i += size) {
-            result.push(arr.slice(i, i + size));
+        for (let i = 0; i < len; i += size) {
+            result.push(normalized.slice(i, i + size));
         }
     }
     return result;

package/cjs/caching/LRU.js

@@ -0,0 +1,123 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LRUCache_map, _LRUCache_head, _LRUCache_tail, _LRUCache_max_size, _LRUCache_size;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.LRUCache = void 0;
+const is_1 = __importDefault(require("../object/is"));
+const isIntegerAbove_1 = __importDefault(require("../number/isIntegerAbove"));
+class LRUCache {
+    constructor(opts = {}) {
+        _LRUCache_map.set(this, void 0);
+        _LRUCache_head.set(this, null);
+        _LRUCache_tail.set(this, null);
+        _LRUCache_max_size.set(this, void 0);
+        _LRUCache_size.set(this, 0);
+        const { max_size = 100 } = (0, is_1.default)(opts) ? opts : {};
+        __classPrivateFieldSet(this, _LRUCache_map, Object.create(null), "f");
+        __classPrivateFieldSet(this, _LRUCache_max_size, (0, isIntegerAbove_1.default)(max_size, 0) ? max_size : 100, "f");
+    }
+    get max_size() {
+        return __classPrivateFieldGet(this, _LRUCache_max_size, "f");
+    }
+    set max_size(max_size) {
+        if (!(0, isIntegerAbove_1.default)(max_size, 0))
+            throw new Error('max_size must be a positive integer');
+        __classPrivateFieldSet(this, _LRUCache_max_size, max_size, "f");
+        while (__classPrivateFieldGet(this, _LRUCache_size, "f") > max_size)
+            this.evictTail();
+    }
+    has(key) {
+        return key in __classPrivateFieldGet(this, _LRUCache_map, "f");
+    }
+    get(key) {
+        const node = __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        if (!node)
+            return undefined;
+        this.moveToFront(node);
+        return node.value;
+    }
+    set(key, value) {
+        var _a;
+        let node = __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        if (node !== undefined) {
+            node.value = value;
+            this.moveToFront(node);
+        }
+        else {
+            node = { key, value, prev: null, next: null };
+            __classPrivateFieldGet(this, _LRUCache_map, "f")[key] = node;
+            this.addToFront(node);
+            __classPrivateFieldSet(this, _LRUCache_size, (_a = __classPrivateFieldGet(this, _LRUCache_size, "f"), _a++, _a), "f");
+            if (__classPrivateFieldGet(this, _LRUCache_tail, "f") && __classPrivateFieldGet(this, _LRUCache_size, "f") > __classPrivateFieldGet(this, _LRUCache_max_size, "f")) {
+                this.evictTail();
+            }
+        }
+    }
+    del(key) {
+        var _a;
+        const node = __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        if (!node)
+            return;
+        this.removeNode(node);
+        delete __classPrivateFieldGet(this, _LRUCache_map, "f")[key];
+        __classPrivateFieldSet(this, _LRUCache_size, (_a = __classPrivateFieldGet(this, _LRUCache_size, "f"), _a--, _a), "f");
+    }
+    clear() {
+        __classPrivateFieldSet(this, _LRUCache_map, Object.create(null), "f");
+        __classPrivateFieldSet(this, _LRUCache_head, null, "f");
+        __classPrivateFieldSet(this, _LRUCache_tail, null, "f");
+        __classPrivateFieldSet(this, _LRUCache_size, 0, "f");
+    }
+    addToFront(node) {
+        node.next = __classPrivateFieldGet(this, _LRUCache_head, "f");
+        node.prev = null;
+        if (__classPrivateFieldGet(this, _LRUCache_head, "f")) {
+            __classPrivateFieldGet(this, _LRUCache_head, "f").prev = node;
+        }
+        __classPrivateFieldSet(this, _LRUCache_head, node, "f");
+        if (!__classPrivateFieldGet(this, _LRUCache_tail, "f")) {
+            __classPrivateFieldSet(this, _LRUCache_tail, node, "f");
+        }
+    }
+    removeNode(node) {
+        if (node.prev)
+            node.prev.next = node.next;
+        else
+            __classPrivateFieldSet(this, _LRUCache_head, node.next, "f");
+        if (node.next)
+            node.next.prev = node.prev;
+        else
+            __classPrivateFieldSet(this, _LRUCache_tail, node.prev, "f");
+        node.prev = null;
+        node.next = null;
+    }
+    moveToFront(node) {
+        if (__classPrivateFieldGet(this, _LRUCache_head, "f") === node)
+            return;
+        this.removeNode(node);
+        this.addToFront(node);
+    }
+    evictTail() {
+        var _a;
+        const old_tail = __classPrivateFieldGet(this, _LRUCache_tail, "f");
+        this.removeNode(old_tail);
+        delete __classPrivateFieldGet(this, _LRUCache_map, "f")[old_tail.key];
+        __classPrivateFieldSet(this, _LRUCache_size, (_a = __classPrivateFieldGet(this, _LRUCache_size, "f"), _a--, _a), "f");
+    }
+}
+exports.LRUCache = LRUCache;
+exports.default = LRUCache;
+_LRUCache_map = new WeakMap(), _LRUCache_head = new WeakMap(), _LRUCache_tail = new WeakMap(), _LRUCache_max_size = new WeakMap(), _LRUCache_size = new WeakMap();

package/{caching → cjs/caching}/memoize.js

@@ -1,17 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.memoize = memoize;
 exports.default = memoize;
-const isAsync_1 = require("../function/isAsync");
-const isIntegerAbove_1 = require("../number/isIntegerAbove");
-const LRU_1 = require("./LRU");
+const isAsync_1 = __importDefault(require("../function/isAsync"));
+const fnv1A_1 = __importDefault(require("../hash/fnv1A"));
+const isIntegerAbove_1 = __importDefault(require("../number/isIntegerAbove"));
+const LRU_1 = __importDefault(require("./LRU"));
 function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100) {
     const cache_duration = (0, isIntegerAbove_1.default)(cache_duration_ms, 0) ? cache_duration_ms : false;
     const cache = new LRU_1.default({ max_size: cache_max_size });
     const isResolverFn = typeof resolver === 'function';
     const memoized = (0, isAsync_1.default)(fn)
         ? async function (...args) {
-            const key = isResolverFn ? resolver(...args) : args[0];
+            let key = isResolverFn ? resolver(...args) : args[0];
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String((0, fnv1A_1.default)(key));
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
@@ -22,7 +27,8 @@ function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100)
             return result;
         }
         : function (...args) {
-            const key = isResolverFn ? resolver(...args) : args[0];
+            let key = isResolverFn ? resolver(...args) : args[0];
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String((0, fnv1A_1.default)(key));
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {

package/{date → cjs/date}/format.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
 exports.default = format;
 const convertToDate_1 = require("./convertToDate");
-const LRU_1 = require("../caching/LRU");
+const LRU_1 = __importDefault(require("../caching/LRU"));
 const WEEK_STARTS = {
     mon: 'mon',
     sun: 'sun',

package/{date → cjs/date}/isFormat.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateFormat = isDateFormat;
 exports.default = isDateFormat;
-const LRU_1 = require("../caching/LRU");
+const LRU_1 = __importDefault(require("../caching/LRU"));
 const SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
 const TOKENS = [
     ['YYYY', /\d{4}/.source, (raw, context) => {

package/esm/array/dedupe.js

@@ -0,0 +1,52 @@
+const REPL_NAN = 'nan';
+const REPL_TRUE = 'true';
+const REPL_FALSE = 'false';
+const REPL_UNDEF = 'undefined';
+const REPL_NULL = 'null';
+function getTypeString(el) {
+    switch (typeof el) {
+        case 'string':
+            return el;
+        case 'number':
+            return Number.isNaN(el) || !Number.isFinite(el) ? REPL_NAN : String(el);
+        case 'boolean':
+            return el ? REPL_TRUE : REPL_FALSE;
+        case 'undefined':
+            return REPL_UNDEF;
+        case 'object':
+            if (el === null) {
+                return REPL_NULL;
+            }
+            else if (Array.isArray(el) || el.toString() === '[object Object]') {
+                return JSON.stringify(el);
+            }
+            else if (el instanceof RegExp) {
+                return el.toString();
+            }
+            else if (el instanceof Date) {
+                return String(el.getTime());
+            }
+    }
+    return '';
+}
+function dedupe(val, opts) {
+    if (!Array.isArray(val))
+        return [];
+    const FILTER_FN = opts?.filter_fn;
+    const set = new Set();
+    const acc = [];
+    let hash;
+    const len = val.length;
+    for (let i = 0; i < len; i++) {
+        const el = val[i];
+        if (FILTER_FN && !FILTER_FN(el))
+            continue;
+        hash = getTypeString(el);
+        if (!set.has(hash)) {
+            set.add(hash);
+            acc.push(el);
+        }
+    }
+    return acc;
+}
+export { dedupe, dedupe as default };

package/esm/array/groupBy.js

@@ -0,0 +1,43 @@
+import { isNotEmptyObject } from '../object/isNotEmpty';
+const FALLBACK = '_';
+const defaultHandler = () => FALLBACK;
+function groupBy(val, handler) {
+    let normalized;
+    if (Array.isArray(val)) {
+        if (!val.length)
+            return {};
+        normalized = val;
+    }
+    else if (val instanceof Set) {
+        if (!val.size)
+            return {};
+        normalized = [...val];
+    }
+    else {
+        return {};
+    }
+    const acc = {};
+    const n_handler = typeof handler === 'function'
+        ? handler
+        : typeof handler === 'string'
+            ? ((el) => el[handler])
+            : defaultHandler;
+    let key;
+    let el;
+    for (let i = 0; i < normalized.length; i++) {
+        el = normalized[i];
+        if (!isNotEmptyObject(el))
+            continue;
+        key = n_handler(el);
+        if (key === undefined || (typeof key === 'string' && !key.length))
+            key = FALLBACK;
+        if (!acc[key]) {
+            acc[key] = [el];
+        }
+        else {
+            acc[key].push(el);
+        }
+    }
+    return acc;
+}
+export { groupBy, groupBy as default };

package/esm/array/index.js

@@ -0,0 +1,14 @@
+export { dedupe } from './dedupe';
+export { join } from './join';
+export { mapFn } from './mapFn';
+export { mapFnAsMap } from './mapFnAsMap';
+export { mapKey } from './mapKey';
+export { mapKeyAsMap } from './mapKeyAsMap';
+export { mapPrimitive } from './mapPrimitive';
+export { groupBy } from './groupBy';
+export { shuffle } from './shuffle';
+export { split } from './split';
+export { sort } from './sort';
+export { isArray } from './is';
+export { isNotEmptyArray } from './isNotEmpty';
+export { isNotEmptyArray as isNeArray } from './isNotEmpty';

package/esm/array/is.js

@@ -0,0 +1,4 @@
+function isArray(val) {
+    return Array.isArray(val);
+}
+export { isArray, isArray as default };

package/esm/array/isNotEmpty.js

@@ -0,0 +1,4 @@
+function isNotEmptyArray(val) {
+    return Array.isArray(val) && val.length !== 0;
+}
+export { isNotEmptyArray, isNotEmptyArray as default };

package/esm/array/join.js

@@ -0,0 +1,58 @@
+import { round } from '../number/round';
+import { isIntegerAboveOrEqual } from '../number/isIntegerAboveOrEqual';
+const SPACE_RGX = /(\s)+/g;
+function join(val, opts) {
+    let normalized;
+    if (Array.isArray(val)) {
+        if (!val.length)
+            return '';
+        normalized = val;
+    }
+    else if (val instanceof Set) {
+        if (!val.size)
+            return '';
+        normalized = [...val];
+    }
+    else {
+        return '';
+    }
+    const DELIM = typeof opts?.delim === 'string' ? opts.delim : ' ';
+    const DEDUPE = opts?.dedupe === true ? new Set() : null;
+    const VALTRIM = opts?.valtrim ?? true;
+    const INNERTRIM = opts?.innertrim ?? false;
+    const VALROUND = isIntegerAboveOrEqual(opts?.valround, 0) ? opts.valround : false;
+    let result = '';
+    let has_val = false;
+    for (let i = 0; i < normalized.length; i++) {
+        const el = normalized[i];
+        let n_el;
+        if (typeof el === 'string') {
+            const trimmed = el.trim();
+            if (!trimmed)
+                continue;
+            n_el = VALTRIM ? trimmed : el;
+            if (INNERTRIM)
+                n_el = n_el.replace(SPACE_RGX, ' ');
+        }
+        else if (Number.isFinite(el)) {
+            n_el = '' + (VALROUND !== false ? round(el, VALROUND) : el);
+        }
+        else {
+            continue;
+        }
+        if (DEDUPE) {
+            if (DEDUPE.has(n_el))
+                continue;
+            DEDUPE.add(n_el);
+        }
+        if (has_val) {
+            result = result + DELIM + n_el;
+        }
+        else {
+            result = n_el;
+            has_val = true;
+        }
+    }
+    return opts?.trim ?? true ? result.trim() : result;
+}
+export { join, join as default };

package/esm/array/mapFn.js

@@ -0,0 +1,22 @@
+import { merge } from '../object/merge';
+function mapFn(arr, fn, opts) {
+    if ((!Array.isArray(arr) || !arr.length) ||
+        typeof fn !== 'function')
+        return {};
+    const MERGE = opts?.merge === true;
+    const TRANSFORM_FN = opts?.transform_fn;
+    const map = {};
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        if (Object.prototype.toString.call(el) !== '[object Object]')
+            continue;
+        let hash = fn(el);
+        if (Number.isFinite(hash) || (typeof hash === 'string' && hash.length)) {
+            hash = hash + '';
+            const transformed = TRANSFORM_FN ? TRANSFORM_FN(el) : el;
+            map[hash] = MERGE && hash in map ? merge(map[hash], transformed, { union: true }) : transformed;
+        }
+    }
+    return map;
+}
+export { mapFn, mapFn as default };

package/esm/array/mapFnAsMap.js

@@ -0,0 +1,21 @@
+import { merge } from '../object/merge';
+function mapFnAsMap(arr, fn, opts) {
+    if ((!Array.isArray(arr) || !arr.length) ||
+        typeof fn !== 'function')
+        return new Map();
+    const MERGE = opts?.merge === true;
+    const TRANSFORM_FN = opts?.transform_fn;
+    const map = new Map();
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        if (Object.prototype.toString.call(el) !== '[object Object]')
+            continue;
+        const hash = fn(el);
+        if (Number.isFinite(hash) || (typeof hash === 'string' && hash.length > 0)) {
+            const transformed = TRANSFORM_FN ? TRANSFORM_FN(el) : el;
+            map.set(hash, MERGE && map.has(hash) ? merge(map.get(hash), transformed, { union: true }) : transformed);
+        }
+    }
+    return map;
+}
+export { mapFnAsMap, mapFnAsMap as default };

package/esm/array/mapKey.js

@@ -0,0 +1,22 @@
+import { merge } from '../object/merge';
+function mapKey(arr, key, opts) {
+    if (!Array.isArray(arr) ||
+        !arr.length ||
+        typeof key !== 'string' ||
+        !key.length)
+        return {};
+    const FILTER_FN = opts?.filter_fn;
+    const MERGE = opts?.merge === true;
+    const TRANSFORMER = opts?.transform_fn;
+    const map = {};
+    for (let i = 0; i < arr.length; i++) {
+        const el = arr[i];
+        const el_key = el?.[key];
+        if (el_key !== undefined && (!FILTER_FN || FILTER_FN(el))) {
+            const transformed = TRANSFORMER ? TRANSFORMER(el) : el;
+            map[el_key] = MERGE && el_key in map ? merge(map[el_key], transformed, { union: true }) : transformed;
+        }
+    }
+    return map;
+}
+export { mapKey, mapKey as default };