@nestia/e2e 7.3.3 → 8.0.0-dev.20250829

package/lib/ArrayUtil.js

@@ -53,15 +53,15 @@ exports.ArrayUtil = void 0;
  *
  * This namespace contains utility functions for array operations including
  * asynchronous processing, filtering, mapping, and repetition tasks implemented
- * in functional programming style. All functions are implemented using currying
- * to enhance reusability and composability.
+ * in functional programming style. Functions use direct parameter passing for
+ * simplicity while maintaining functional programming principles.
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @example
  *   ```typescript
  *   // Asynchronous filtering example
  *   const numbers = [1, 2, 3, 4, 5];
- *   const evenNumbers = await ArrayUtil.asyncFilter(numbers)(
+ *   const evenNumbers = await ArrayUtil.asyncFilter(numbers,
  *     async (num) => num % 2 === 0
  *   );
  *   console.log(evenNumbers); // [2, 4]
@@ -74,9 +74,9 @@ var ArrayUtil;
      * Filters an array by applying an asynchronous predicate function to each
      * element.
      *
-     * This function is implemented in curried form, first taking an array and
-     * then a predicate function. Elements are processed sequentially, ensuring
-     * order is maintained.
+     * Elements are processed sequentially, ensuring order is maintained. The
+     * predicate function receives the element, index, and the full array as
+     * parameters.
      *
      * @example
      *   ```typescript
@@ -86,7 +86,7 @@ var ArrayUtil;
      *     { id: 3, name: 'Charlie', active: true }
      *   ];
      *
-     *   const activeUsers = await ArrayUtil.asyncFilter(users)(
+     *   const activeUsers = await ArrayUtil.asyncFilter(users,
      *     async (user) => {
      *       // Async validation logic (e.g., API call)
      *       await new Promise(resolve => setTimeout(resolve, 100));
@@ -98,37 +98,35 @@ var ArrayUtil;
      *
      * @template Input - The type of elements in the input array
      * @param elements - The readonly array to filter
-     * @returns A function that takes a predicate and returns a Promise resolving
-     *   to the filtered array
+     * @param pred - The asynchronous predicate function to test each element
+     * @returns A Promise resolving to the filtered array
      */
-    ArrayUtil.asyncFilter = function (elements) {
-        return function (pred) { return __awaiter(_this, void 0, void 0, function () {
-            var ret;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        ret = [];
-                        return [4 /*yield*/, ArrayUtil.asyncForEach(elements)(function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
-                                var flag;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, pred(elem, index, array)];
-                                        case 1:
-                                            flag = _a.sent();
-                                            if (flag === true)
-                                                ret.push(elem);
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, ret];
-                }
-            });
-        }); };
-    };
+    ArrayUtil.asyncFilter = function (elements, pred) { return __awaiter(_this, void 0, void 0, function () {
+        var ret;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ret = [];
+                    return [4 /*yield*/, ArrayUtil.asyncForEach(elements, function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
+                            var flag;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, pred(elem, index, array)];
+                                    case 1:
+                                        flag = _a.sent();
+                                        if (flag === true)
+                                            ret.push(elem);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, ret];
+            }
+        });
+    }); };
     /**
      * Executes an asynchronous function for each element in an array
      * sequentially.
@@ -142,57 +140,56 @@ var ArrayUtil;
      *   ```typescript
      *   const urls = ['url1', 'url2', 'url3'];
      *
-     *   await ArrayUtil.asyncForEach(urls)(async (url, index) => {
-     *   console.log(`Processing ${index}: ${url}`);
-     *   const data = await fetch(url);
-     *   await processData(data);
-     *   console.log(`Completed ${index}: ${url}`);
+     *   await ArrayUtil.asyncForEach(urls, async (url, index) => {
+     *     console.log(`Processing ${index}: ${url}`);
+     *     const data = await fetch(url);
+     *     await processData(data);
+     *     console.log(`Completed ${index}: ${url}`);
      *   });
      *   console.log('All URLs processed sequentially');
      *   ```
      *
      * @template Input - The type of elements in the input array
      * @param elements - The readonly array to process
-     * @returns A function that takes an async closure and returns a Promise<void>
+     * @param closure - The asynchronous function to execute for each element
+     * @returns A Promise<void> that resolves when all operations complete
      */
-    ArrayUtil.asyncForEach = function (elements) {
-        return function (closure) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, ArrayUtil.asyncRepeat(elements.length)(function (index) {
-                            return closure(elements[index], index, elements);
-                        })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-    };
+    ArrayUtil.asyncForEach = function (elements, closure) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ArrayUtil.asyncRepeat(elements.length, function (index) {
+                        return closure(elements[index], index, elements);
+                    })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
     /**
      * Transforms each element of an array using an asynchronous function to
      * create a new array.
      *
      * Similar to JavaScript's native map but processes asynchronous functions
      * sequentially. Each element's transformation is completed before proceeding
-     * to the next element, ensuring order is maintained.
+     * to the next element, ensuring order is maintained. This function still
+     * maintains the currying pattern for composition.
      *
      * @example
      *   ```typescript
      *   const userIds = [1, 2, 3, 4, 5];
      *
      *   const userDetails = await ArrayUtil.asyncMap(userIds)(
-     *   async (id, index) => {
-     *   console.log(`Fetching user ${id} (${index + 1}/${userIds.length})`);
-     *   const response = await fetch(`/api/users/${id}`);
-     *   return await response.json();
-     *   }
+     *     async (id, index) => {
+     *       console.log(`Fetching user ${id} (${index + 1}/${userIds.length})`);
+     *       const response = await fetch(`/api/users/${id}`);
+     *       return await response.json();
+     *     }
      *   );
      *   console.log('All users fetched:', userDetails);
      *   ```
      *
      * @template Input - The type of elements in the input array
-     * @template Output - The type of elements in the output array
      * @param elements - The readonly array to transform
      * @returns A function that takes a transformation function and returns a
      *   Promise resolving to the transformed array
@@ -205,7 +202,7 @@ var ArrayUtil;
                 switch (_a.label) {
                     case 0:
                         ret = [];
-                        return [4 /*yield*/, ArrayUtil.asyncForEach(elements)(function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
+                        return [4 /*yield*/, ArrayUtil.asyncForEach(elements, function (elem, index, array) { return __awaiter(_this, void 0, void 0, function () {
                                 var output;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
@@ -234,7 +231,7 @@ var ArrayUtil;
      * @example
      *   ```typescript
      *   // Generate random data 5 times
-     *   const randomData = await ArrayUtil.asyncRepeat(5)(async (index) => {
+     *   const randomData = await ArrayUtil.asyncRepeat(5, async (index) => {
      *     await new Promise(resolve => setTimeout(resolve, 100)); // Wait 0.1 seconds
      *     return {
      *       id: index,
@@ -245,59 +242,55 @@ var ArrayUtil;
      *   console.log('Generated data:', randomData);
      *   ```;
      *
+     * @template T - The type of the result from each execution
      * @param count - The number of times to repeat (non-negative integer)
-     * @returns A function that takes an async closure and returns a Promise
-     *   resolving to an array of results
+     * @param closure - The asynchronous function to execute repeatedly
+     * @returns A Promise resolving to an array of results
      */
-    ArrayUtil.asyncRepeat = function (count) {
-        return function (closure) { return __awaiter(_this, void 0, void 0, function () {
-            var indexes, output, indexes_1, indexes_1_1, index, _a, _b, e_1_1;
-            var e_1, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        indexes = new Array(count)
-                            .fill(1)
-                            .map(function (_, index) { return index; });
-                        output = [];
-                        _d.label = 1;
-                    case 1:
-                        _d.trys.push([1, 6, 7, 8]);
-                        indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next();
-                        _d.label = 2;
-                    case 2:
-                        if (!!indexes_1_1.done) return [3 /*break*/, 5];
-                        index = indexes_1_1.value;
-                        _b = (_a = output).push;
-                        return [4 /*yield*/, closure(index)];
-                    case 3:
-                        _b.apply(_a, [_d.sent()]);
-                        _d.label = 4;
-                    case 4:
-                        indexes_1_1 = indexes_1.next();
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 8];
-                    case 6:
-                        e_1_1 = _d.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 8];
-                    case 7:
-                        try {
-                            if (indexes_1_1 && !indexes_1_1.done && (_c = indexes_1.return)) _c.call(indexes_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/, output];
-                }
-            });
-        }); };
-    };
+    ArrayUtil.asyncRepeat = function (count, closure) { return __awaiter(_this, void 0, void 0, function () {
+        var indexes, output, indexes_1, indexes_1_1, index, _a, _b, e_1_1;
+        var e_1, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    indexes = new Array(count).fill(1).map(function (_, index) { return index; });
+                    output = [];
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 6, 7, 8]);
+                    indexes_1 = __values(indexes), indexes_1_1 = indexes_1.next();
+                    _d.label = 2;
+                case 2:
+                    if (!!indexes_1_1.done) return [3 /*break*/, 5];
+                    index = indexes_1_1.value;
+                    _b = (_a = output).push;
+                    return [4 /*yield*/, closure(index)];
+                case 3:
+                    _b.apply(_a, [_d.sent()]);
+                    _d.label = 4;
+                case 4:
+                    indexes_1_1 = indexes_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_1_1 = _d.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (indexes_1_1 && !indexes_1_1.done && (_c = indexes_1.return)) _c.call(indexes_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/, output];
+            }
+        });
+    }); };
     /**
      * Checks if at least one element in the array satisfies the given condition.
      *
-     * Similar to JavaScript's native some() method but implemented in curried
-     * form for better compatibility with functional programming style. Returns
-     * true immediately when the first element satisfying the condition is found.
+     * Similar to JavaScript's native some() method. Returns true immediately
+     * when the first element satisfying the condition is found.
      *
      * @example
      *   ```typescript
@@ -308,25 +301,22 @@ var ArrayUtil;
      *     { name: 'Orange', price: 80, inStock: true }
      *   ];
      *
-     *   const hasEvenNumber = ArrayUtil.has(numbers)(num => num % 2 === 0);
+     *   const hasEvenNumber = ArrayUtil.has(numbers, num => num % 2 === 0);
      *   console.log(hasEvenNumber); // true (8 exists)
      *
-     *   const hasExpensiveItem = ArrayUtil.has(products)(product => product.price > 90);
+     *   const hasExpensiveItem = ArrayUtil.has(products, product => product.price > 90);
      *   console.log(hasExpensiveItem); // true (Apple costs 100)
      *
-     *   const hasOutOfStock = ArrayUtil.has(products)(product => !product.inStock);
+     *   const hasOutOfStock = ArrayUtil.has(products, product => !product.inStock);
      *   console.log(hasOutOfStock); // true (Banana is out of stock)
      *   ```;
      *
      * @template T - The type of elements in the array
      * @param elements - The readonly array to check
-     * @returns A function that takes a predicate and returns a boolean
+     * @param pred - The predicate function to test elements
+     * @returns Boolean indicating if any element satisfies the condition
      */
-    ArrayUtil.has = function (elements) {
-        return function (pred) {
-            return elements.find(pred) !== undefined;
-        };
-    };
+    ArrayUtil.has = function (elements, pred) { return elements.find(pred) !== undefined; };
     /**
      * Executes a function a specified number of times and collects the results
      * into an array.
@@ -337,14 +327,14 @@ var ArrayUtil;
      * @example
      *   ```typescript
      *   // Generate an array of squares from 1 to 5
-     *   const squares = ArrayUtil.repeat(5)(index => (index + 1) ** 2);
+     *   const squares = ArrayUtil.repeat(5, index => (index + 1) ** 2);
      *   console.log(squares); // [1, 4, 9, 16, 25]
      *
      *   // Generate an array of default user objects
-     *   const users = ArrayUtil.repeat(3)(index => ({
-     *   id: index + 1,
-     *   name: `User${index + 1}`,
-     *   email: `user${index + 1}@example.com`
+     *   const users = ArrayUtil.repeat(3, index => ({
+     *     id: index + 1,
+     *     name: `User${index + 1}`,
+     *     email: `user${index + 1}@example.com`
      *   }));
      *   console.log(users);
      *   // [
@@ -354,14 +344,12 @@ var ArrayUtil;
      *   // ]
      *   ```
      *
+     * @template T - The type of the result from each execution
      * @param count - The number of times to repeat (non-negative integer)
-     * @returns A function that takes a closure and returns an array of results
+     * @param closure - The function to execute repeatedly
+     * @returns An array of results
      */
-    ArrayUtil.repeat = function (count) {
-        return function (closure) {
-            return new Array(count).fill("").map(function (_, index) { return closure(index); });
-        };
-    };
+    ArrayUtil.repeat = function (count, closure) { return new Array(count).fill("").map(function (_, index) { return closure(index); }); };
     /**
      * Generates all possible subsets of a given array.
      *

package/lib/ArrayUtil.js.map

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

package/lib/GaffComparator.d.ts

@@ -34,12 +34,14 @@
  *   users.sort(GaffComparator.strings(user => [user.lastName, user.firstName]));
  *   events.sort(GaffComparator.dates(event => [event.startDate, event.endDate]));
  *
- *   // Integration with TestValidator
- *   await TestValidator.sort("user sorting")(
+ *   // Integration with TestValidator's currying pattern
+ *   const validator = TestValidator.sort("user sorting",
  *     (sortable) => api.getUsers({ sort: sortable })
  *   )("name", "email")(
  *     GaffComparator.strings(user => [user.name, user.email])
- *   )("+");
+ *   );
+ *   await validator("+"); // ascending
+ *   await validator("-"); // descending
  *   ```;
  */
 export declare namespace GaffComparator {
@@ -87,12 +89,14 @@ export declare namespace GaffComparator {
      *   // Complex multi-field: status, then last name, then first name
      *   users.sort(GaffComparator.strings(user => [user.status, user.lastName, user.firstName]));
      *
-     *   // Integration with API sorting validation
-     *   await TestValidator.sort("user name sorting")(
+     *   // Integration with TestValidator sorting validation
+     *   const sortValidator = TestValidator.sort("user name sorting",
      *     (sortFields) => userApi.getUsers({ sort: sortFields })
      *   )("lastName", "firstName")(
      *     GaffComparator.strings(user => [user.lastName, user.firstName])
-     *   )("+");
+     *   );
+     *   await sortValidator("+"); // test ascending order
+     *   await sortValidator("-"); // test descending order
      *   ```;
      *
      * @template T - The type of objects being compared
@@ -156,12 +160,13 @@ export declare namespace GaffComparator {
      *   // Sort by modification history: created date, then updated date
      *   events.sort(GaffComparator.dates(event => [event.createdAt, event.updatedAt]));
      *
-     *   // Validate API date sorting
-     *   await TestValidator.sort("event chronological sorting")(
+     *   // Validate API date sorting with TestValidator
+     *   const dateValidator = TestValidator.sort("event chronological sorting",
      *     (sortFields) => eventApi.getEvents({ sort: sortFields })
      *   )("startDate")(
      *     GaffComparator.dates(event => event.startDate)
-     *   )("+");
+     *   );
+     *   await dateValidator("+", true); // ascending with trace logging
      *
      *   // Test complex date-based sorting
      *   const sortByEventSchedule = GaffComparator.dates(event => [
@@ -225,12 +230,14 @@ export declare namespace GaffComparator {
      *   // Sort by inventory priority: low stock first, then by sales
      *   products.sort(GaffComparator.numbers(product => [product.stock, -product.salesCount]));
      *
-     *   // Validate API numerical sorting
-     *   await TestValidator.sort("product price sorting")(
+     *   // Validate API numerical sorting with TestValidator
+     *   const priceValidator = TestValidator.sort("product price sorting",
      *     (sortFields) => productApi.getProducts({ sort: sortFields })
      *   )("price")(
      *     GaffComparator.numbers(product => product.price)
-     *   )("+");
+     *   );
+     *   await priceValidator("+"); // test ascending order
+     *   await priceValidator("-"); // test descending order
      *
      *   // Test multi-criteria sorting
      *   const sortByBusinessValue = GaffComparator.numbers(product => [

package/lib/GaffComparator.js

@@ -37,12 +37,14 @@ exports.GaffComparator = void 0;
  *   users.sort(GaffComparator.strings(user => [user.lastName, user.firstName]));
  *   events.sort(GaffComparator.dates(event => [event.startDate, event.endDate]));
  *
- *   // Integration with TestValidator
- *   await TestValidator.sort("user sorting")(
+ *   // Integration with TestValidator's currying pattern
+ *   const validator = TestValidator.sort("user sorting",
  *     (sortable) => api.getUsers({ sort: sortable })
  *   )("name", "email")(
  *     GaffComparator.strings(user => [user.name, user.email])
- *   )("+");
+ *   );
+ *   await validator("+"); // ascending
+ *   await validator("-"); // descending
  *   ```;
  */
 var GaffComparator;
@@ -91,12 +93,14 @@ var GaffComparator;
      *   // Complex multi-field: status, then last name, then first name
      *   users.sort(GaffComparator.strings(user => [user.status, user.lastName, user.firstName]));
      *
-     *   // Integration with API sorting validation
-     *   await TestValidator.sort("user name sorting")(
+     *   // Integration with TestValidator sorting validation
+     *   const sortValidator = TestValidator.sort("user name sorting",
      *     (sortFields) => userApi.getUsers({ sort: sortFields })
      *   )("lastName", "firstName")(
      *     GaffComparator.strings(user => [user.lastName, user.firstName])
-     *   )("+");
+     *   );
+     *   await sortValidator("+"); // test ascending order
+     *   await sortValidator("-"); // test descending order
      *   ```;
      *
      * @template T - The type of objects being compared
@@ -167,12 +171,13 @@ var GaffComparator;
      *   // Sort by modification history: created date, then updated date
      *   events.sort(GaffComparator.dates(event => [event.createdAt, event.updatedAt]));
      *
-     *   // Validate API date sorting
-     *   await TestValidator.sort("event chronological sorting")(
+     *   // Validate API date sorting with TestValidator
+     *   const dateValidator = TestValidator.sort("event chronological sorting",
      *     (sortFields) => eventApi.getEvents({ sort: sortFields })
      *   )("startDate")(
      *     GaffComparator.dates(event => event.startDate)
-     *   )("+");
+     *   );
+     *   await dateValidator("+", true); // ascending with trace logging
      *
      *   // Test complex date-based sorting
      *   const sortByEventSchedule = GaffComparator.dates(event => [
@@ -246,12 +251,14 @@ var GaffComparator;
      *   // Sort by inventory priority: low stock first, then by sales
      *   products.sort(GaffComparator.numbers(product => [product.stock, -product.salesCount]));
      *
-     *   // Validate API numerical sorting
-     *   await TestValidator.sort("product price sorting")(
+     *   // Validate API numerical sorting with TestValidator
+     *   const priceValidator = TestValidator.sort("product price sorting",
      *     (sortFields) => productApi.getProducts({ sort: sortFields })
      *   )("price")(
      *     GaffComparator.numbers(product => product.price)
-     *   )("+");
+     *   );
+     *   await priceValidator("+"); // test ascending order
+     *   await priceValidator("-"); // test descending order
      *
      *   // Test multi-criteria sorting
      *   const sortByBusinessValue = GaffComparator.numbers(product => [

package/lib/GaffComparator.js.map

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

package/lib/MapUtil.d.ts

@@ -0,0 +1,79 @@
+/**
+ * A namespace providing utility functions for Map manipulation.
+ *
+ * This namespace contains helper functions for working with JavaScript Map
+ * objects, providing convenient methods for common Map operations like
+ * retrieving values with lazy initialization.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   // Create a cache with lazy initialization
+ *   const cache = new Map<string, ExpensiveObject>();
+ *
+ *   const obj = MapUtil.take(cache, "key1", () => {
+ *     console.log("Creating expensive object...");
+ *     return new ExpensiveObject();
+ *   });
+ *
+ *   // Subsequent calls return cached value without re-creating
+ *   const sameObj = MapUtil.take(cache, "key1", () => new ExpensiveObject());
+ *   console.log(obj === sameObj); // true
+ *   ```;
+ */
+export declare namespace MapUtil {
+    /**
+     * Retrieves a value from a Map or creates it using a lazy initialization
+     * function.
+     *
+     * This function implements the "get or create" pattern for Maps. If the key
+     * exists in the Map, it returns the existing value. Otherwise, it calls the
+     * provided factory function to create a new value, stores it in the Map, and
+     * returns it. The factory function is only called when the key doesn't exist,
+     * enabling lazy initialization and caching patterns.
+     *
+     * @example
+     *   ```typescript
+     *   // Simple caching example
+     *   const userCache = new Map<number, User>();
+     *
+     *   const user = MapUtil.take(userCache, userId, () => {
+     *     // This expensive operation only runs if userId is not cached
+     *     return fetchUserFromDatabase(userId);
+     *   });
+     *
+     *   // Configuration object caching
+     *   const configs = new Map<string, Config>();
+     *
+     *   const dbConfig = MapUtil.take(configs, "database", () => ({
+     *     host: "localhost",
+     *     port: 5432,
+     *     database: "myapp"
+     *   }));
+     *
+     *   // Lazy computation results
+     *   const computationCache = new Map<string, number>();
+     *
+     *   const result = MapUtil.take(computationCache, "fibonacci-40", () => {
+     *     console.log("Computing fibonacci(40)...");
+     *     return fibonacci(40); // Only computed once
+     *   });
+     *
+     *   // Using with complex keys
+     *   const cache = new Map<[number, number], Matrix>();
+     *   const key: [number, number] = [rows, cols];
+     *
+     *   const matrix = MapUtil.take(cache, key, () =>
+     *     generateIdentityMatrix(rows, cols)
+     *   );
+     *   ```;
+     *
+     * @template K - The type of keys in the Map
+     * @template V - The type of values in the Map
+     * @param map - The Map to retrieve from or update
+     * @param key - The key to look up in the Map
+     * @param value - A factory function that creates the value if key doesn't exist
+     * @returns The existing value if found, or the newly created value
+     */
+    function take<K, V>(map: Map<K, V>, key: K, value: () => V): V;
+}