@nestia/e2e 7.4.0 → 8.0.0-dev.20250829
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -21
- package/README.md +93 -93
- package/lib/ArrayUtil.d.ts +47 -43
- package/lib/ArrayUtil.js +122 -134
- package/lib/ArrayUtil.js.map +1 -1
- package/lib/GaffComparator.d.ts +19 -12
- package/lib/GaffComparator.js +19 -12
- package/lib/GaffComparator.js.map +1 -1
- package/lib/MapUtil.d.ts +79 -0
- package/lib/MapUtil.js +92 -0
- package/lib/MapUtil.js.map +1 -0
- package/lib/RandomGenerator.d.ts +107 -71
- package/lib/RandomGenerator.js +124 -109
- package/lib/RandomGenerator.js.map +1 -1
- package/lib/TestValidator.d.ts +107 -145
- package/lib/TestValidator.js +308 -351
- package/lib/TestValidator.js.map +1 -1
- package/lib/module.d.ts +2 -1
- package/lib/module.js +2 -1
- package/lib/module.js.map +1 -1
- package/package.json +1 -1
- package/src/ArrayUtil.ts +87 -88
- package/src/GaffComparator.ts +19 -12
- package/src/MapUtil.ts +86 -0
- package/src/RandomGenerator.ts +138 -101
- package/src/TestValidator.ts +251 -294
- package/src/module.ts +3 -1
package/lib/TestValidator.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"TestValidator.js","sourceRoot":"","sources":["../src/TestValidator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAAoD;AACpD,0DAAyD;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,IAAiB,aAAa,
|
|
1
|
+
{"version":3,"file":"TestValidator.js","sourceRoot":"","sources":["../src/TestValidator.ts"],"names":[],"mappings":"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"}
|
package/lib/module.d.ts
CHANGED
package/lib/module.js
CHANGED
|
@@ -15,8 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
|
15
15
|
};
|
|
16
16
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
17
17
|
__exportStar(require("./ArrayUtil"), exports);
|
|
18
|
+
__exportStar(require("./MapUtil"), exports);
|
|
19
|
+
__exportStar(require("./RandomGenerator"), exports);
|
|
18
20
|
__exportStar(require("./DynamicExecutor"), exports);
|
|
19
21
|
__exportStar(require("./GaffComparator"), exports);
|
|
20
|
-
__exportStar(require("./RandomGenerator"), exports);
|
|
21
22
|
__exportStar(require("./TestValidator"), exports);
|
|
22
23
|
//# sourceMappingURL=module.js.map
|
package/lib/module.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,oDAAkC;AAClC,mDAAiC;AACjC,
|
|
1
|
+
{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,4CAA0B;AAC1B,oDAAkC;AAElC,oDAAkC;AAClC,mDAAiC;AACjC,kDAAgC"}
|
package/package.json
CHANGED
package/src/ArrayUtil.ts
CHANGED
|
@@ -3,15 +3,15 @@
|
|
|
3
3
|
*
|
|
4
4
|
* This namespace contains utility functions for array operations including
|
|
5
5
|
* asynchronous processing, filtering, mapping, and repetition tasks implemented
|
|
6
|
-
* in functional programming style.
|
|
7
|
-
*
|
|
6
|
+
* in functional programming style. Functions use direct parameter passing for
|
|
7
|
+
* simplicity while maintaining functional programming principles.
|
|
8
8
|
*
|
|
9
9
|
* @author Jeongho Nam - https://github.com/samchon
|
|
10
10
|
* @example
|
|
11
11
|
* ```typescript
|
|
12
12
|
* // Asynchronous filtering example
|
|
13
13
|
* const numbers = [1, 2, 3, 4, 5];
|
|
14
|
-
* const evenNumbers = await ArrayUtil.asyncFilter(numbers
|
|
14
|
+
* const evenNumbers = await ArrayUtil.asyncFilter(numbers,
|
|
15
15
|
* async (num) => num % 2 === 0
|
|
16
16
|
* );
|
|
17
17
|
* console.log(evenNumbers); // [2, 4]
|
|
@@ -22,9 +22,9 @@ export namespace ArrayUtil {
|
|
|
22
22
|
* Filters an array by applying an asynchronous predicate function to each
|
|
23
23
|
* element.
|
|
24
24
|
*
|
|
25
|
-
*
|
|
26
|
-
*
|
|
27
|
-
*
|
|
25
|
+
* Elements are processed sequentially, ensuring order is maintained. The
|
|
26
|
+
* predicate function receives the element, index, and the full array as
|
|
27
|
+
* parameters.
|
|
28
28
|
*
|
|
29
29
|
* @example
|
|
30
30
|
* ```typescript
|
|
@@ -34,7 +34,7 @@ export namespace ArrayUtil {
|
|
|
34
34
|
* { id: 3, name: 'Charlie', active: true }
|
|
35
35
|
* ];
|
|
36
36
|
*
|
|
37
|
-
* const activeUsers = await ArrayUtil.asyncFilter(users
|
|
37
|
+
* const activeUsers = await ArrayUtil.asyncFilter(users,
|
|
38
38
|
* async (user) => {
|
|
39
39
|
* // Async validation logic (e.g., API call)
|
|
40
40
|
* await new Promise(resolve => setTimeout(resolve, 100));
|
|
@@ -46,25 +46,24 @@ export namespace ArrayUtil {
|
|
|
46
46
|
*
|
|
47
47
|
* @template Input - The type of elements in the input array
|
|
48
48
|
* @param elements - The readonly array to filter
|
|
49
|
-
* @
|
|
50
|
-
*
|
|
49
|
+
* @param pred - The asynchronous predicate function to test each element
|
|
50
|
+
* @returns A Promise resolving to the filtered array
|
|
51
51
|
*/
|
|
52
|
-
export const asyncFilter =
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
61
|
-
|
|
62
|
-
await
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
};
|
|
52
|
+
export const asyncFilter = async <Input>(
|
|
53
|
+
elements: readonly Input[],
|
|
54
|
+
pred: (
|
|
55
|
+
elem: Input,
|
|
56
|
+
index: number,
|
|
57
|
+
array: readonly Input[],
|
|
58
|
+
) => Promise<boolean>,
|
|
59
|
+
): Promise<Input[]> => {
|
|
60
|
+
const ret: Input[] = [];
|
|
61
|
+
await asyncForEach(elements, async (elem, index, array) => {
|
|
62
|
+
const flag: boolean = await pred(elem, index, array);
|
|
63
|
+
if (flag === true) ret.push(elem);
|
|
64
|
+
});
|
|
65
|
+
return ret;
|
|
66
|
+
};
|
|
68
67
|
|
|
69
68
|
/**
|
|
70
69
|
* Executes an asynchronous function for each element in an array
|
|
@@ -79,32 +78,32 @@ export namespace ArrayUtil {
|
|
|
79
78
|
* ```typescript
|
|
80
79
|
* const urls = ['url1', 'url2', 'url3'];
|
|
81
80
|
*
|
|
82
|
-
* await ArrayUtil.asyncForEach(urls
|
|
83
|
-
*
|
|
84
|
-
*
|
|
85
|
-
*
|
|
86
|
-
*
|
|
81
|
+
* await ArrayUtil.asyncForEach(urls, async (url, index) => {
|
|
82
|
+
* console.log(`Processing ${index}: ${url}`);
|
|
83
|
+
* const data = await fetch(url);
|
|
84
|
+
* await processData(data);
|
|
85
|
+
* console.log(`Completed ${index}: ${url}`);
|
|
87
86
|
* });
|
|
88
87
|
* console.log('All URLs processed sequentially');
|
|
89
88
|
* ```
|
|
90
89
|
*
|
|
91
90
|
* @template Input - The type of elements in the input array
|
|
92
91
|
* @param elements - The readonly array to process
|
|
93
|
-
* @
|
|
92
|
+
* @param closure - The asynchronous function to execute for each element
|
|
93
|
+
* @returns A Promise<void> that resolves when all operations complete
|
|
94
94
|
*/
|
|
95
|
-
export const asyncForEach =
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
)
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
};
|
|
95
|
+
export const asyncForEach = async <Input>(
|
|
96
|
+
elements: readonly Input[],
|
|
97
|
+
closure: (
|
|
98
|
+
elem: Input,
|
|
99
|
+
index: number,
|
|
100
|
+
array: readonly Input[],
|
|
101
|
+
) => Promise<any>,
|
|
102
|
+
): Promise<void> => {
|
|
103
|
+
await asyncRepeat(elements.length, (index) =>
|
|
104
|
+
closure(elements[index], index, elements),
|
|
105
|
+
);
|
|
106
|
+
};
|
|
108
107
|
|
|
109
108
|
/**
|
|
110
109
|
* Transforms each element of an array using an asynchronous function to
|
|
@@ -112,24 +111,24 @@ export namespace ArrayUtil {
|
|
|
112
111
|
*
|
|
113
112
|
* Similar to JavaScript's native map but processes asynchronous functions
|
|
114
113
|
* sequentially. Each element's transformation is completed before proceeding
|
|
115
|
-
* to the next element, ensuring order is maintained.
|
|
114
|
+
* to the next element, ensuring order is maintained. This function still
|
|
115
|
+
* maintains the currying pattern for composition.
|
|
116
116
|
*
|
|
117
117
|
* @example
|
|
118
118
|
* ```typescript
|
|
119
119
|
* const userIds = [1, 2, 3, 4, 5];
|
|
120
120
|
*
|
|
121
121
|
* const userDetails = await ArrayUtil.asyncMap(userIds)(
|
|
122
|
-
*
|
|
123
|
-
*
|
|
124
|
-
*
|
|
125
|
-
*
|
|
126
|
-
*
|
|
122
|
+
* async (id, index) => {
|
|
123
|
+
* console.log(`Fetching user ${id} (${index + 1}/${userIds.length})`);
|
|
124
|
+
* const response = await fetch(`/api/users/${id}`);
|
|
125
|
+
* return await response.json();
|
|
126
|
+
* }
|
|
127
127
|
* );
|
|
128
128
|
* console.log('All users fetched:', userDetails);
|
|
129
129
|
* ```
|
|
130
130
|
*
|
|
131
131
|
* @template Input - The type of elements in the input array
|
|
132
|
-
* @template Output - The type of elements in the output array
|
|
133
132
|
* @param elements - The readonly array to transform
|
|
134
133
|
* @returns A function that takes a transformation function and returns a
|
|
135
134
|
* Promise resolving to the transformed array
|
|
@@ -144,7 +143,7 @@ export namespace ArrayUtil {
|
|
|
144
143
|
) => Promise<Output>,
|
|
145
144
|
): Promise<Output[]> => {
|
|
146
145
|
const ret: Output[] = [];
|
|
147
|
-
await asyncForEach(elements
|
|
146
|
+
await asyncForEach(elements, async (elem, index, array) => {
|
|
148
147
|
const output: Output = await closure(elem, index, array);
|
|
149
148
|
ret.push(output);
|
|
150
149
|
});
|
|
@@ -161,7 +160,7 @@ export namespace ArrayUtil {
|
|
|
161
160
|
* @example
|
|
162
161
|
* ```typescript
|
|
163
162
|
* // Generate random data 5 times
|
|
164
|
-
* const randomData = await ArrayUtil.asyncRepeat(5
|
|
163
|
+
* const randomData = await ArrayUtil.asyncRepeat(5, async (index) => {
|
|
165
164
|
* await new Promise(resolve => setTimeout(resolve, 100)); // Wait 0.1 seconds
|
|
166
165
|
* return {
|
|
167
166
|
* id: index,
|
|
@@ -172,29 +171,26 @@ export namespace ArrayUtil {
|
|
|
172
171
|
* console.log('Generated data:', randomData);
|
|
173
172
|
* ```;
|
|
174
173
|
*
|
|
174
|
+
* @template T - The type of the result from each execution
|
|
175
175
|
* @param count - The number of times to repeat (non-negative integer)
|
|
176
|
-
* @
|
|
177
|
-
*
|
|
176
|
+
* @param closure - The asynchronous function to execute repeatedly
|
|
177
|
+
* @returns A Promise resolving to an array of results
|
|
178
178
|
*/
|
|
179
|
-
export const asyncRepeat =
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
return output;
|
|
190
|
-
};
|
|
179
|
+
export const asyncRepeat = async <T>(
|
|
180
|
+
count: number,
|
|
181
|
+
closure: (index: number) => Promise<T>,
|
|
182
|
+
): Promise<T[]> => {
|
|
183
|
+
const indexes: number[] = new Array(count).fill(1).map((_, index) => index);
|
|
184
|
+
const output: T[] = [];
|
|
185
|
+
for (const index of indexes) output.push(await closure(index));
|
|
186
|
+
return output;
|
|
187
|
+
};
|
|
191
188
|
|
|
192
189
|
/**
|
|
193
190
|
* Checks if at least one element in the array satisfies the given condition.
|
|
194
191
|
*
|
|
195
|
-
* Similar to JavaScript's native some() method
|
|
196
|
-
*
|
|
197
|
-
* true immediately when the first element satisfying the condition is found.
|
|
192
|
+
* Similar to JavaScript's native some() method. Returns true immediately
|
|
193
|
+
* when the first element satisfying the condition is found.
|
|
198
194
|
*
|
|
199
195
|
* @example
|
|
200
196
|
* ```typescript
|
|
@@ -205,24 +201,25 @@ export namespace ArrayUtil {
|
|
|
205
201
|
* { name: 'Orange', price: 80, inStock: true }
|
|
206
202
|
* ];
|
|
207
203
|
*
|
|
208
|
-
* const hasEvenNumber = ArrayUtil.has(numbers
|
|
204
|
+
* const hasEvenNumber = ArrayUtil.has(numbers, num => num % 2 === 0);
|
|
209
205
|
* console.log(hasEvenNumber); // true (8 exists)
|
|
210
206
|
*
|
|
211
|
-
* const hasExpensiveItem = ArrayUtil.has(products
|
|
207
|
+
* const hasExpensiveItem = ArrayUtil.has(products, product => product.price > 90);
|
|
212
208
|
* console.log(hasExpensiveItem); // true (Apple costs 100)
|
|
213
209
|
*
|
|
214
|
-
* const hasOutOfStock = ArrayUtil.has(products
|
|
210
|
+
* const hasOutOfStock = ArrayUtil.has(products, product => !product.inStock);
|
|
215
211
|
* console.log(hasOutOfStock); // true (Banana is out of stock)
|
|
216
212
|
* ```;
|
|
217
213
|
*
|
|
218
214
|
* @template T - The type of elements in the array
|
|
219
215
|
* @param elements - The readonly array to check
|
|
220
|
-
* @
|
|
216
|
+
* @param pred - The predicate function to test elements
|
|
217
|
+
* @returns Boolean indicating if any element satisfies the condition
|
|
221
218
|
*/
|
|
222
|
-
export const has =
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
219
|
+
export const has = <T>(
|
|
220
|
+
elements: readonly T[],
|
|
221
|
+
pred: (elem: T) => boolean,
|
|
222
|
+
): boolean => elements.find(pred) !== undefined;
|
|
226
223
|
|
|
227
224
|
/**
|
|
228
225
|
* Executes a function a specified number of times and collects the results
|
|
@@ -234,14 +231,14 @@ export namespace ArrayUtil {
|
|
|
234
231
|
* @example
|
|
235
232
|
* ```typescript
|
|
236
233
|
* // Generate an array of squares from 1 to 5
|
|
237
|
-
* const squares = ArrayUtil.repeat(5
|
|
234
|
+
* const squares = ArrayUtil.repeat(5, index => (index + 1) ** 2);
|
|
238
235
|
* console.log(squares); // [1, 4, 9, 16, 25]
|
|
239
236
|
*
|
|
240
237
|
* // Generate an array of default user objects
|
|
241
|
-
* const users = ArrayUtil.repeat(3
|
|
242
|
-
*
|
|
243
|
-
*
|
|
244
|
-
*
|
|
238
|
+
* const users = ArrayUtil.repeat(3, index => ({
|
|
239
|
+
* id: index + 1,
|
|
240
|
+
* name: `User${index + 1}`,
|
|
241
|
+
* email: `user${index + 1}@example.com`
|
|
245
242
|
* }));
|
|
246
243
|
* console.log(users);
|
|
247
244
|
* // [
|
|
@@ -251,13 +248,15 @@ export namespace ArrayUtil {
|
|
|
251
248
|
* // ]
|
|
252
249
|
* ```
|
|
253
250
|
*
|
|
251
|
+
* @template T - The type of the result from each execution
|
|
254
252
|
* @param count - The number of times to repeat (non-negative integer)
|
|
255
|
-
* @
|
|
253
|
+
* @param closure - The function to execute repeatedly
|
|
254
|
+
* @returns An array of results
|
|
256
255
|
*/
|
|
257
|
-
export const repeat =
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
256
|
+
export const repeat = <T>(
|
|
257
|
+
count: number,
|
|
258
|
+
closure: (index: number) => T,
|
|
259
|
+
): T[] => new Array(count).fill("").map((_, index) => closure(index));
|
|
261
260
|
|
|
262
261
|
/**
|
|
263
262
|
* Generates all possible subsets of a given array.
|
package/src/GaffComparator.ts
CHANGED
|
@@ -34,12 +34,14 @@
|
|
|
34
34
|
* users.sort(GaffComparator.strings(user => [user.lastName, user.firstName]));
|
|
35
35
|
* events.sort(GaffComparator.dates(event => [event.startDate, event.endDate]));
|
|
36
36
|
*
|
|
37
|
-
* // Integration with TestValidator
|
|
38
|
-
*
|
|
37
|
+
* // Integration with TestValidator's currying pattern
|
|
38
|
+
* const validator = TestValidator.sort("user sorting",
|
|
39
39
|
* (sortable) => api.getUsers({ sort: sortable })
|
|
40
40
|
* )("name", "email")(
|
|
41
41
|
* GaffComparator.strings(user => [user.name, user.email])
|
|
42
|
-
* )
|
|
42
|
+
* );
|
|
43
|
+
* await validator("+"); // ascending
|
|
44
|
+
* await validator("-"); // descending
|
|
43
45
|
* ```;
|
|
44
46
|
*/
|
|
45
47
|
export namespace GaffComparator {
|
|
@@ -87,12 +89,14 @@ export namespace GaffComparator {
|
|
|
87
89
|
* // Complex multi-field: status, then last name, then first name
|
|
88
90
|
* users.sort(GaffComparator.strings(user => [user.status, user.lastName, user.firstName]));
|
|
89
91
|
*
|
|
90
|
-
* // Integration with
|
|
91
|
-
*
|
|
92
|
+
* // Integration with TestValidator sorting validation
|
|
93
|
+
* const sortValidator = TestValidator.sort("user name sorting",
|
|
92
94
|
* (sortFields) => userApi.getUsers({ sort: sortFields })
|
|
93
95
|
* )("lastName", "firstName")(
|
|
94
96
|
* GaffComparator.strings(user => [user.lastName, user.firstName])
|
|
95
|
-
* )
|
|
97
|
+
* );
|
|
98
|
+
* await sortValidator("+"); // test ascending order
|
|
99
|
+
* await sortValidator("-"); // test descending order
|
|
96
100
|
* ```;
|
|
97
101
|
*
|
|
98
102
|
* @template T - The type of objects being compared
|
|
@@ -165,12 +169,13 @@ export namespace GaffComparator {
|
|
|
165
169
|
* // Sort by modification history: created date, then updated date
|
|
166
170
|
* events.sort(GaffComparator.dates(event => [event.createdAt, event.updatedAt]));
|
|
167
171
|
*
|
|
168
|
-
* // Validate API date sorting
|
|
169
|
-
*
|
|
172
|
+
* // Validate API date sorting with TestValidator
|
|
173
|
+
* const dateValidator = TestValidator.sort("event chronological sorting",
|
|
170
174
|
* (sortFields) => eventApi.getEvents({ sort: sortFields })
|
|
171
175
|
* )("startDate")(
|
|
172
176
|
* GaffComparator.dates(event => event.startDate)
|
|
173
|
-
* )
|
|
177
|
+
* );
|
|
178
|
+
* await dateValidator("+", true); // ascending with trace logging
|
|
174
179
|
*
|
|
175
180
|
* // Test complex date-based sorting
|
|
176
181
|
* const sortByEventSchedule = GaffComparator.dates(event => [
|
|
@@ -245,12 +250,14 @@ export namespace GaffComparator {
|
|
|
245
250
|
* // Sort by inventory priority: low stock first, then by sales
|
|
246
251
|
* products.sort(GaffComparator.numbers(product => [product.stock, -product.salesCount]));
|
|
247
252
|
*
|
|
248
|
-
* // Validate API numerical sorting
|
|
249
|
-
*
|
|
253
|
+
* // Validate API numerical sorting with TestValidator
|
|
254
|
+
* const priceValidator = TestValidator.sort("product price sorting",
|
|
250
255
|
* (sortFields) => productApi.getProducts({ sort: sortFields })
|
|
251
256
|
* )("price")(
|
|
252
257
|
* GaffComparator.numbers(product => product.price)
|
|
253
|
-
* )
|
|
258
|
+
* );
|
|
259
|
+
* await priceValidator("+"); // test ascending order
|
|
260
|
+
* await priceValidator("-"); // test descending order
|
|
254
261
|
*
|
|
255
262
|
* // Test multi-criteria sorting
|
|
256
263
|
* const sortByBusinessValue = GaffComparator.numbers(product => [
|
package/src/MapUtil.ts
ADDED
|
@@ -0,0 +1,86 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* A namespace providing utility functions for Map manipulation.
|
|
3
|
+
*
|
|
4
|
+
* This namespace contains helper functions for working with JavaScript Map
|
|
5
|
+
* objects, providing convenient methods for common Map operations like
|
|
6
|
+
* retrieving values with lazy initialization.
|
|
7
|
+
*
|
|
8
|
+
* @author Jeongho Nam - https://github.com/samchon
|
|
9
|
+
* @example
|
|
10
|
+
* ```typescript
|
|
11
|
+
* // Create a cache with lazy initialization
|
|
12
|
+
* const cache = new Map<string, ExpensiveObject>();
|
|
13
|
+
*
|
|
14
|
+
* const obj = MapUtil.take(cache, "key1", () => {
|
|
15
|
+
* console.log("Creating expensive object...");
|
|
16
|
+
* return new ExpensiveObject();
|
|
17
|
+
* });
|
|
18
|
+
*
|
|
19
|
+
* // Subsequent calls return cached value without re-creating
|
|
20
|
+
* const sameObj = MapUtil.take(cache, "key1", () => new ExpensiveObject());
|
|
21
|
+
* console.log(obj === sameObj); // true
|
|
22
|
+
* ```;
|
|
23
|
+
*/
|
|
24
|
+
export namespace MapUtil {
|
|
25
|
+
/**
|
|
26
|
+
* Retrieves a value from a Map or creates it using a lazy initialization
|
|
27
|
+
* function.
|
|
28
|
+
*
|
|
29
|
+
* This function implements the "get or create" pattern for Maps. If the key
|
|
30
|
+
* exists in the Map, it returns the existing value. Otherwise, it calls the
|
|
31
|
+
* provided factory function to create a new value, stores it in the Map, and
|
|
32
|
+
* returns it. The factory function is only called when the key doesn't exist,
|
|
33
|
+
* enabling lazy initialization and caching patterns.
|
|
34
|
+
*
|
|
35
|
+
* @example
|
|
36
|
+
* ```typescript
|
|
37
|
+
* // Simple caching example
|
|
38
|
+
* const userCache = new Map<number, User>();
|
|
39
|
+
*
|
|
40
|
+
* const user = MapUtil.take(userCache, userId, () => {
|
|
41
|
+
* // This expensive operation only runs if userId is not cached
|
|
42
|
+
* return fetchUserFromDatabase(userId);
|
|
43
|
+
* });
|
|
44
|
+
*
|
|
45
|
+
* // Configuration object caching
|
|
46
|
+
* const configs = new Map<string, Config>();
|
|
47
|
+
*
|
|
48
|
+
* const dbConfig = MapUtil.take(configs, "database", () => ({
|
|
49
|
+
* host: "localhost",
|
|
50
|
+
* port: 5432,
|
|
51
|
+
* database: "myapp"
|
|
52
|
+
* }));
|
|
53
|
+
*
|
|
54
|
+
* // Lazy computation results
|
|
55
|
+
* const computationCache = new Map<string, number>();
|
|
56
|
+
*
|
|
57
|
+
* const result = MapUtil.take(computationCache, "fibonacci-40", () => {
|
|
58
|
+
* console.log("Computing fibonacci(40)...");
|
|
59
|
+
* return fibonacci(40); // Only computed once
|
|
60
|
+
* });
|
|
61
|
+
*
|
|
62
|
+
* // Using with complex keys
|
|
63
|
+
* const cache = new Map<[number, number], Matrix>();
|
|
64
|
+
* const key: [number, number] = [rows, cols];
|
|
65
|
+
*
|
|
66
|
+
* const matrix = MapUtil.take(cache, key, () =>
|
|
67
|
+
* generateIdentityMatrix(rows, cols)
|
|
68
|
+
* );
|
|
69
|
+
* ```;
|
|
70
|
+
*
|
|
71
|
+
* @template K - The type of keys in the Map
|
|
72
|
+
* @template V - The type of values in the Map
|
|
73
|
+
* @param map - The Map to retrieve from or update
|
|
74
|
+
* @param key - The key to look up in the Map
|
|
75
|
+
* @param value - A factory function that creates the value if key doesn't exist
|
|
76
|
+
* @returns The existing value if found, or the newly created value
|
|
77
|
+
*/
|
|
78
|
+
export function take<K, V>(map: Map<K, V>, key: K, value: () => V): V {
|
|
79
|
+
if (map.has(key)) {
|
|
80
|
+
return map.get(key) as V;
|
|
81
|
+
}
|
|
82
|
+
const newValue = value();
|
|
83
|
+
map.set(key, newValue);
|
|
84
|
+
return newValue;
|
|
85
|
+
}
|
|
86
|
+
}
|