@nestia/e2e 10.0.2 → 11.0.0-dev.20260305

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as e2e from "./module";
-
-export default e2e;
-export * from "./module";
+import * as e2e from "./module";
+
+export default e2e;
+export * from "./module";

package/src/internal/json_equal_to.ts

@@ -1,35 +1,35 @@
-export const json_equal_to =
-  (exception: (key: string) => boolean) =>
-  <T>(x: T) =>
-  (y: T | null | undefined): string[] => {
-    const container: string[] = [];
-    const iterate =
-      (accessor: string) =>
-      (x: any) =>
-      (y: any): void => {
-        if (typeof x === "function" || typeof y === "function") return;
-        else if (typeof x !== typeof y) container.push(accessor);
-        else if (x instanceof Array)
-          if (!(y instanceof Array)) container.push(accessor);
-          else array(accessor)(x)(y);
-        else if (x instanceof Object) object(accessor)(x)(y);
-        else if (x !== y) container.push(accessor);
-      };
-    const array =
-      (accessor: string) =>
-      (x: any[]) =>
-      (y: any[]): void => {
-        if (x.length !== y.length) container.push(`${accessor}.length`);
-        x.forEach((xItem, i) => iterate(`${accessor}[${i}]`)(xItem)(y[i]));
-      };
-    const object =
-      (accessor: string) =>
-      (x: any) =>
-      (y: any): void =>
-        Object.keys(x)
-          .filter((key) => x[key] !== undefined && !exception(key))
-          .forEach((key) => iterate(`${accessor}.${key}`)(x[key])(y[key]));
-
-    iterate("")(x)(y);
-    return container;
-  };
+export const json_equal_to =
+  (exception: (key: string) => boolean) =>
+  <T>(x: T) =>
+  (y: T | null | undefined): string[] => {
+    const container: string[] = [];
+    const iterate =
+      (accessor: string) =>
+      (x: any) =>
+      (y: any): void => {
+        if (typeof x === "function" || typeof y === "function") return;
+        else if (typeof x !== typeof y) container.push(accessor);
+        else if (x instanceof Array)
+          if (!(y instanceof Array)) container.push(accessor);
+          else array(accessor)(x)(y);
+        else if (x instanceof Object) object(accessor)(x)(y);
+        else if (x !== y) container.push(accessor);
+      };
+    const array =
+      (accessor: string) =>
+      (x: any[]) =>
+      (y: any[]): void => {
+        if (x.length !== y.length) container.push(`${accessor}.length`);
+        x.forEach((xItem, i) => iterate(`${accessor}[${i}]`)(xItem)(y[i]));
+      };
+    const object =
+      (accessor: string) =>
+      (x: any) =>
+      (y: any): void =>
+        Object.keys(x)
+          .filter((key) => x[key] !== undefined && !exception(key))
+          .forEach((key) => iterate(`${accessor}.${key}`)(x[key])(y[key]));
+
+    iterate("")(x)(y);
+    return container;
+  };

package/src/module.ts

@@ -1,7 +1,7 @@
-export * from "./ArrayUtil";
-export * from "./MapUtil";
-export * from "./RandomGenerator";
-
-export * from "./DynamicExecutor";
-export * from "./GaffComparator";
-export * from "./TestValidator";
+export * from "./ArrayUtil";
+export * from "./MapUtil";
+export * from "./RandomGenerator";
+
+export * from "./DynamicExecutor";
+export * from "./GaffComparator";
+export * from "./TestValidator";

package/lib/ArrayUtil.d.ts

@@ -1,244 +0,0 @@
-/**
- * A namespace providing utility functions for array manipulation.
- *
- * This namespace contains utility functions for array operations including
- * asynchronous processing, filtering, mapping, and repetition tasks implemented
- * 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,
- *     async (num) => num % 2 === 0
- *   );
- *   console.log(evenNumbers); // [2, 4]
- *   ```;
- */
-export declare namespace ArrayUtil {
-    /**
-     * Filters an array by applying an asynchronous predicate function to each
-     * element.
-     *
-     * Elements are processed sequentially, ensuring order is maintained. The
-     * predicate function receives the element, index, and the full array as
-     * parameters.
-     *
-     * @example
-     *   ```typescript
-     *   const users = [
-     *     { id: 1, name: 'Alice', active: true },
-     *     { id: 2, name: 'Bob', active: false },
-     *     { id: 3, name: 'Charlie', active: true }
-     *   ];
-     *
-     *   const activeUsers = await ArrayUtil.asyncFilter(users,
-     *     async (user) => {
-     *       // Async validation logic (e.g., API call)
-     *       await new Promise(resolve => setTimeout(resolve, 100));
-     *       return user.active;
-     *     }
-     *   );
-     *   console.log(activeUsers); // [{ id: 1, name: 'Alice', active: true }, { id: 3, name: 'Charlie', active: true }]
-     *   ```;
-     *
-     * @template Input - The type of elements in the input array
-     * @param elements - The readonly array to filter
-     * @param pred - The asynchronous predicate function to test each element
-     * @returns A Promise resolving to the filtered array
-     */
-    const asyncFilter: <Input>(elements: readonly Input[], pred: (elem: Input, index: number, array: readonly Input[]) => Promise<boolean>) => Promise<Input[]>;
-    /**
-     * Executes an asynchronous function for each element in an array
-     * sequentially.
-     *
-     * Unlike JavaScript's native forEach, this function processes asynchronous
-     * functions sequentially and waits for all operations to complete. It
-     * performs sequential processing rather than parallel processing, making it
-     * suitable for operations where order matters.
-     *
-     * @example
-     *   ```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}`);
-     *   });
-     *   console.log('All URLs processed sequentially');
-     *   ```
-     *
-     * @template Input - The type of elements in the input array
-     * @param elements - The readonly array to process
-     * @param closure - The asynchronous function to execute for each element
-     * @returns A Promise<void> that resolves when all operations complete
-     */
-    const asyncForEach: <Input>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<any>) => Promise<void>;
-    /**
-     * 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. 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();
-     *   }
-     *   );
-     *   console.log('All users fetched:', userDetails);
-     *   ```
-     *
-     * @template Input - The type of elements in the input 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
-     */
-    const asyncMap: <Input, Output>(elements: readonly Input[], closure: (elem: Input, index: number, array: readonly Input[]) => Promise<Output>) => Promise<Output[]>;
-    /**
-     * Executes an asynchronous function a specified number of times sequentially.
-     *
-     * Executes the function with indices from 0 to count-1 incrementally. Each
-     * execution is performed sequentially, and all results are collected into an
-     * array.
-     *
-     * @example
-     *   ```typescript
-     *   // Generate random data 5 times
-     *   const randomData = await ArrayUtil.asyncRepeat(5, async (index) => {
-     *     await new Promise(resolve => setTimeout(resolve, 100)); // Wait 0.1 seconds
-     *     return {
-     *       id: index,
-     *       value: Math.random(),
-     *       timestamp: new Date().toISOString()
-     *     };
-     *   });
-     *   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)
-     * @param closure - The asynchronous function to execute repeatedly
-     * @returns A Promise resolving to an array of results
-     */
-    const asyncRepeat: <T>(count: number, closure: (index: number) => Promise<T>) => Promise<T[]>;
-    /**
-     * Checks if at least one element in the array satisfies the given condition.
-     *
-     * Similar to JavaScript's native some() method. Returns true immediately when
-     * the first element satisfying the condition is found.
-     *
-     * @example
-     *   ```typescript
-     *   const numbers = [1, 3, 5, 7, 8, 9];
-     *   const products = [
-     *     { name: 'Apple', price: 100, inStock: true },
-     *     { name: 'Banana', price: 50, inStock: false },
-     *     { name: 'Orange', price: 80, inStock: true }
-     *   ];
-     *
-     *   const hasEvenNumber = ArrayUtil.has(numbers, num => num % 2 === 0);
-     *   console.log(hasEvenNumber); // true (8 exists)
-     *
-     *   const hasExpensiveItem = ArrayUtil.has(products, product => product.price > 90);
-     *   console.log(hasExpensiveItem); // true (Apple costs 100)
-     *
-     *   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
-     * @param pred - The predicate function to test elements
-     * @returns Boolean indicating if any element satisfies the condition
-     */
-    const has: <T>(elements: readonly T[], pred: (elem: T) => boolean) => boolean;
-    /**
-     * Executes a function a specified number of times and collects the results
-     * into an array.
-     *
-     * A synchronous repetition function that executes the given function for each
-     * index (from 0 to count-1) and collects the results into an array.
-     *
-     * @example
-     *   ```typescript
-     *   // Generate an array of squares from 1 to 5
-     *   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`
-     *   }));
-     *   console.log(users);
-     *   // [
-     *   //   { id: 1, name: 'User1', email: 'user1@example.com' },
-     *   //   { id: 2, name: 'User2', email: 'user2@example.com' },
-     *   //   { id: 3, name: 'User3', email: 'user3@example.com' }
-     *   // ]
-     *   ```
-     *
-     * @template T - The type of the result from each execution
-     * @param count - The number of times to repeat (non-negative integer)
-     * @param closure - The function to execute repeatedly
-     * @returns An array of results
-     */
-    const repeat: <T>(count: number, closure: (index: number) => T) => T[];
-    /**
-     * Generates all possible subsets of a given array.
-     *
-     * Implements the mathematical concept of power set, generating 2^n subsets
-     * from an array of n elements. Uses depth-first search (DFS) algorithm to
-     * calculate all possible combinations of including or excluding each
-     * element.
-     *
-     * @example
-     *   ```typescript
-     *   const numbers = [1, 2, 3];
-     *   const allSubsets = ArrayUtil.subsets(numbers);
-     *   console.log(allSubsets);
-     *   // [
-     *   //   [],           // empty set
-     *   //   [3],          // {3}
-     *   //   [2],          // {2}
-     *   //   [2, 3],       // {2, 3}
-     *   //   [1],          // {1}
-     *   //   [1, 3],       // {1, 3}
-     *   //   [1, 2],       // {1, 2}
-     *   //   [1, 2, 3]     // {1, 2, 3}
-     *   // ]
-     *
-     *   const colors = ['red', 'blue'];
-     *   const colorSubsets = ArrayUtil.subsets(colors);
-     *   console.log(colorSubsets);
-     *   // [
-     *   //   [],
-     *   //   ['blue'],
-     *   //   ['red'],
-     *   //   ['red', 'blue']
-     *   // ]
-     *
-     *   // Warning: Result size grows exponentially with array size
-     *   // Example: 10 elements → 1,024 subsets, 20 elements → 1,048,576 subsets
-     *   ```;
-     *
-     * @template T - The type of elements in the array
-     * @param array - The array to generate subsets from
-     * @returns An array containing all possible subsets
-     */
-    const subsets: <T>(array: T[]) => T[][];
-}