@dereekb/util 10.0.19 → 10.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/util",
-  "version": "10.0.19",
+  "version": "10.0.21",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",

package/src/lib/array/array.d.ts

@@ -111,6 +111,13 @@ export declare function takeLast<T>(values: T[], maxToTake: number, keepFromFron
  * @returns
  */
 export declare function forEachWithArray<T>(array: Maybe<ArrayOrValue<T>>, forEach: (value: T) => void): T[];
+/**
+ * Counts all the values in a nested array.
+ *
+ * @param array
+ * @returns
+ */
+export declare function countAllInNestedArray<T>(array: T[][]): number;
 /**
  * @deprecated Use mergeArraysIntoArray() instead. Will be removed in v10.1.
  */

package/src/lib/array/array.factory.d.ts

@@ -30,3 +30,19 @@ export declare function arrayFactory<T>(factory: Factory<T> | FactoryWithIndex<T
  * @returns
  */
 export declare function arrayInputFactory<O, I>(factory: FactoryWithRequiredInput<O, I>): ArrayInputFactory<I, O>;
+/**
+ * Creates a factory that returns the items from the input array and returns null after the factory function has exhausted all array values.
+ *
+ * The factory can only be used once.
+ *
+ * @param array
+ */
+export declare function terminatingFactoryFromArray<T>(array: T[]): Factory<T | null>;
+/**
+ *
+ * Creates a factory that returns the items from the input array and returns the terminating value if the input array is empty.
+ *
+ * @param array
+ * @param terminatingValue
+ */
+export declare function terminatingFactoryFromArray<T, E>(array: T[], terminatingValue: E): Factory<T | E>;

package/src/lib/page/page.calculator.d.ts

@@ -1,4 +1,4 @@
-import { type Page } from './page';
+import { type PageNumber, type Page } from './page';
 export interface PageCalculatorConfig {
     pageSize: number;
     limitKey?: string;
@@ -16,9 +16,9 @@ export declare class PageCalculator {
     calcWithPage(page?: Page): {
         [x: string]: number;
     };
-    calc(page?: number): {
+    calc(page?: PageNumber): {
         [x: string]: number;
     };
     calcSkipWithPage(page?: Page): number;
-    calcSkip(page?: number): number;
+    calcSkip(page?: PageNumber): number;
 }

package/src/lib/page/page.d.ts

@@ -19,7 +19,7 @@ export interface Page {
     /**
      * Current page number.
      *
-     * // TODO: Rename to pageNumber
+     * // TODO (COMPAT): Rename to pageNumber
      */
     page: PageNumber;
 }

package/src/lib/page/page.filter.d.ts

@@ -1,5 +1,5 @@
 import { type Filter, type OptionalFilter } from '../filter';
-import { type Page } from '../page';
+import { type PageNumber, type Page } from '../page';
 import { type IterateFn, type IteratePageFn } from '../iterate';
 /**
  * Represents a page number with a filter.
@@ -29,7 +29,7 @@ export interface FilteredPageIterateFn<T> {
  * @param request
  * @returns
  */
-export declare function filteredPage<F = unknown>(page: number, request?: Filter<F>): FilteredPage<F>;
+export declare function filteredPage<F = unknown>(page: PageNumber, request?: Filter<F>): FilteredPage<F>;
 /**
  * Iterates using a delegate function sequentially.
  *

package/src/lib/promise/promise.d.ts

@@ -1,7 +1,9 @@
+import { type ArrayOrValue } from '../array/array';
 import { type Milliseconds } from '../date/date';
 import { type PrimativeKey, type ReadOneOrMoreKeysFunction } from '../key';
 import { type IndexNumber } from '../value';
 import { type Maybe } from '../value/maybe.type';
+import { type PromiseOrValue } from './promise.type';
 export type RunAsyncTaskForValueConfig<T = unknown> = Omit<PerformAsyncTaskConfig<T>, 'throwError'>;
 export type RunAsyncTasksForValuesConfig<T = unknown> = Omit<PerformAsyncTasksConfig<T>, 'throwError'>;
 /**
@@ -61,7 +63,28 @@ export declare function performAsyncTask<O>(taskFn: () => Promise<O>, config?: P
  * Used as a key to identify the "group" that a task belongs to to prevent other concurrent tasks from that group from running in parallel when parallel execution is desired.
  */
 export type PerformTasksInParallelTaskUniqueKey = string;
-export interface PerformTasksInParallelFunctionConfig<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey> {
+export type PerformTasksInParallelFunctionConfig<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey> = Omit<PerformTasksFromFactoryInParallelFunctionConfig<I, K>, 'waitBetweenTaskInputRequests'>;
+/**
+ * Function that awaits a promise generated from each of the input values.
+ *
+ * Will throw an error if any error is encountered as soon as it is encountered. No further tasks will be dispatched, but tasks that have already been dispatched will continue to run.
+ */
+export type PerformTasksInParallelFunction<I> = (input: I[]) => Promise<void>;
+/**
+ * Convenience function for calling performTasksInParallelFunction() with the given input.
+ *
+ * @param input
+ * @param config
+ * @returns
+ */
+export declare function performTasksInParallel<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey>(input: I[], config: PerformTasksInParallelFunctionConfig<I, K>): Promise<void>;
+/**
+ * Creates a function that performs tasks in parallel.
+ *
+ * @param config
+ */
+export declare function performTasksInParallelFunction<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey>(config: PerformTasksInParallelFunctionConfig<I, K>): PerformTasksInParallelFunction<I>;
+export interface PerformTasksFromFactoryInParallelFunctionConfig<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey> {
     /**
      * Creates a promise from the input.
      */
@@ -86,24 +109,23 @@ export interface PerformTasksInParallelFunctionConfig<I, K extends PrimativeKey
      * Optional amount of time to wait between each task.
      */
     readonly waitBetweenTasks?: Milliseconds;
+    /**
+     * Optional amount of time to wait between each task input request.
+     */
+    readonly waitBetweenTaskInputRequests?: Milliseconds;
 }
+export type PerformTaskFactoryTasksInParallelFunctionTaskInputFactory<I> = () => PromiseOrValue<ArrayOrValue<I> | null>;
 /**
- * Function that awaits a promise generate from each of the input values.
+ * Function that awaits all promises generated from the task factory until the factory returns null.
  *
- * Will throw an error if any error is encountered as soon as it is encountered. No further tasks will be dispatched, but tasks that have already been dispatched will continue to run.
- */
-export type PerformTasksInParallelFunction<I> = (input: I[]) => Promise<void>;
-/**
- * Convenience function for calling performTasksInParallelFunction() with the given input.
+ * If an array is pushed then the task factory will begin (but not necessarily complete) all those tasks before pulling the next set of tasks.
  *
- * @param input
- * @param config
- * @returns
+ * Will throw an error if any error is encountered as soon as it is encountered. No further tasks will be dispatched, but tasks that have already been dispatched will continue to run.
  */
-export declare function performTasksInParallel<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey>(input: I[], config: PerformTasksInParallelFunctionConfig<I, K>): Promise<void>;
+export type PerformTaskFactoryTasksInParallelFunction<I> = (taskInputFactory: PerformTaskFactoryTasksInParallelFunctionTaskInputFactory<I>) => Promise<void>;
 /**
- * Creates a function that performs tasks in parallel.
+ * Creates a function that performs tasks from the task factory in parallel.
  *
  * @param config
  */
-export declare function performTasksInParallelFunction<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey>(config: PerformTasksInParallelFunctionConfig<I, K>): PerformTasksInParallelFunction<I>;
+export declare function performTasksFromFactoryInParallelFunction<I, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey>(config: PerformTasksFromFactoryInParallelFunctionConfig<I, K>): PerformTaskFactoryTasksInParallelFunction<I>;

package/src/lib/promise/promise.loop.d.ts

@@ -1,13 +1,14 @@
 import { type BatchCount } from '../grouping';
 import { type Maybe } from '../value/maybe.type';
+import { type PromiseOrValue } from './promise.type';
 export interface PerformTaskLoopConfig<O> {
     next: (i: number, prev: Maybe<O>) => Promise<O>;
-    checkContinue: (prev: Maybe<O>, i: number) => boolean;
+    checkContinue: (prev: Maybe<O>, i: number) => PromiseOrValue<boolean>;
 }
 export interface PerformTaskLoopWithInitConfig<O> {
     initValue: O;
     next: (i: number, prev: O) => Promise<O>;
-    checkContinue: (prev: O, i: number) => boolean;
+    checkContinue: (prev: O, i: number) => PromiseOrValue<boolean>;
 }
 export declare function performTaskLoop<O>(config: PerformTaskLoopWithInitConfig<O>): Promise<O>;
 export declare function performTaskLoop<O>(config: PerformTaskLoopConfig<O>): Promise<O>;

package/test/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [10.0.21](https://github.com/dereekb/dbx-components/compare/v10.0.20-dev...v10.0.21) (2024-02-17)
+
+
+
+## [10.0.20](https://github.com/dereekb/dbx-components/compare/v10.0.19-dev...v10.0.20) (2024-02-15)
+
+
+
 ## [10.0.19](https://github.com/dereekb/dbx-components/compare/v10.0.18-dev...v10.0.19) (2024-02-13)
 
 

package/test/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/util/test",
-  "version": "10.0.19",
+  "version": "10.0.21",
   "type": "commonjs",
   "peerDependencies": {
     "@dereekb/util": "*"