@dereekb/util 12.4.5 → 12.5.1

package/package.json

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

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

@@ -95,6 +95,31 @@ export declare function pushArrayItemsIntoArray<T>(target: T[], array: T[]): T[]
  * @returns
  */
 export declare function takeFront<T>(values: T[], maxToTake: number): T[];
+/**
+ * splitFront() result
+ */
+export interface SplitFrontResult<T> {
+    /**
+     * The input max to take value.
+     */
+    readonly maxToTake: number;
+    /**
+     * The front of the array up to the maxToTake.
+     */
+    readonly front: T[];
+    /**
+     * The remaining values after the front.
+     */
+    readonly remaining: T[];
+}
+/**
+ * Splits the array into two arrays, the first being the front of the array up to the maxToTake, and the second being the remaining values.
+ *
+ * @param values The array to split.
+ * @param maxToTake The maximum number of values to take from the front of the array.
+ * @returns The front and remaining values.
+ */
+export declare function splitFront<T>(values: T[], maxToTake: number): SplitFrontResult<T>;
 /**
  * Copies/takes as many elements as possible from the end.
  *

package/src/lib/auth/auth.role.claims.d.ts

@@ -1,5 +1,6 @@
 import { type AuthRole, type AuthRoleSet } from './auth.role';
 import { type ArrayOrValue } from '../array/array';
+import { SetIncludesMode } from '../set';
 import { type Maybe } from '../value/maybe.type';
 /**
  * Key in the claims.
@@ -50,6 +51,20 @@ export interface AuthRoleClaimsFactoryConfigEntrySimpleOptions<V extends SimpleA
      * The roles to add when this claims is encountered.
      */
     roles: ArrayOrValue<AuthRole>;
+    /**
+     * Describes when to add the value when encoding the roles.
+     *
+     * During encoding back to roles, the value will be set in the claims if ["any"/"all"] roles are not present.
+     *
+     * For "all", set the inverse if "all of the roles are present"/"any of the roles are NOT present"
+     * For "any", set the inverse if "any of the roles are present"/"all of the roles are NOT present"
+     *
+     * True defaults to "any".
+     *
+     * For example, if there is a role that disables/disallowed the "uploads" role, and "uploads" is present during encoding,
+     * then the value will not be set on the inverse claim.
+     */
+    inverse?: true | SetIncludesMode;
     /**
      * (Optional) claim value. Overrides the default claim value.
      */

package/src/lib/date/date.unix.d.ts

@@ -25,8 +25,10 @@ export declare function unixTimeNumberFromDate(date: MaybeNot): MaybeNot;
  * Converts a Date object or unix timestamp number to a Date object.
  *
  * @param input - Date object or unix timestamp number to convert
- * @returns Date object if input is valid, null/undefined if input is null/undefined
+ * @returns Date object if input is valid. Returns null/undefined if input is null/undefined
  */
+export declare function dateFromDateOrTimeNumber(input: DateOrUnixDateTimeNumber): Date;
+export declare function dateFromDateOrTimeNumber(input: MaybeNot): MaybeNot;
 export declare function dateFromDateOrTimeNumber(input: Maybe<DateOrUnixDateTimeNumber>): Maybe<Date>;
 /**
  * Converts a unix timestamp number to a Date object.

package/src/lib/getter/getter.d.ts

@@ -11,6 +11,10 @@ export type Getter<T> = () => T;
  * Getter with the design of returning a new value each time.
  */
 export type Factory<T> = Getter<T>;
+/**
+ * Getter that returns a promise.
+ */
+export type AsyncFactory<T> = Factory<Promise<T>>;
 /**
  * Function that returns a value with an optional single argument.
  */

package/src/lib/number/number.d.ts

@@ -8,9 +8,15 @@ export type NumberString = string;
 /**
  * Number that represents a percent.
  *
- *  e.g. 5 = 0.05 = 5%
+ *  e.g. PercentNumber of 5 = 0.05 = 5%
  */
 export type PercentNumber = number;
+/**
+ * A percent decimal value.
+ *
+ * e.g. PercentDecimal of 0.05 = 5%
+ */
+export type PercentDecimal = number;
 /**
  * Converts the percent number to a decimal value.
  *

package/src/lib/path/path.d.ts

@@ -1,7 +1,10 @@
 import { type MapSameFunction } from '../value/map';
+import { DecisionFunction } from '../value/decision';
 import { type ArrayOrValue } from '../array/array';
-import { type IndexRangeInput, type Maybe } from '../value';
 import { type FactoryWithRequiredInput } from '../getter/getter';
+import { type PrimativeValue } from '../type';
+import { Maybe } from '../value/maybe.type';
+import { IndexRangeInput } from '../value/indexed';
 export declare const SLASH_PATH_SEPARATOR = "/";
 export declare const SLASH_PATH_FILE_TYPE_SEPARATOR = ".";
 export type SlashPathSeparatorString = typeof SLASH_PATH_SEPARATOR;
@@ -11,22 +14,60 @@ export declare const DEFAULT_SLASH_PATH_ILLEGAL_CHARACTERS: string[];
  * Default replacement character for illegal characters.
  */
 export declare const DEFAULT_SLASH_PATH_ILLEGAL_CHARACTER_REPLACEMENT = "_";
+/**
+ * A relative folder path that does not start with a slash.
+ */
+export type RelativeSlashPathFolder = `${string}${SlashPathSeparatorString}`;
+/**
+ * An absolute folder path that starts with a slash.
+ */
+export type AbsoluteSlashPathFolder = `${SlashPathSeparatorString}${string}${SlashPathSeparatorString}`;
 /**
  * A forward-slash path string.
  */
-export type SlashPathFolder = `${SlashPathSeparatorString}${string}${SlashPathSeparatorString}` | `${string}${SlashPathSeparatorString}`;
+export type SlashPathFolder = AbsoluteSlashPathFolder | RelativeSlashPathFolder | `${SlashPathSeparatorString}`;
+/**
+ * A relative folder path that is just an empty string.
+ */
+export type EmptyRelativeSlashPathFolder = '';
+/**
+ * This type includes the empty relative folder path possibility.
+ */
+export type InferredSlashPathFolder = SlashPathFolder | EmptyRelativeSlashPathFolder;
+/**
+ * The file extension of a SlashPathTypedFile.
+ *
+ * e.g. 'png' in 'image.png'
+ */
+export type SlashPathTypedFileExtension = string;
 /**
- * A file name without a type.
+ * The suffix of a typed file.
+ *
+ * e.g. '.png' in 'image.png'
  */
-export type SlashPathFile = string;
+export type SlashPathTypedFileSuffix = `${SlashFileTypeSeparatorString}${SlashPathTypedFileExtension}`;
 /**
- * A file name
+ * A SlashPath file name without a file type identifier (e.g. 'image', and not 'image.png')
+ */
+export type SlashPathUntypedFile = string;
+/**
+ * A file name that contains a file type identifier (e.g. 'image.png')
  */
 export type SlashPathTypedFile = `${string}${SlashFileTypeSeparatorString}${string}`;
+/**
+ * A SlashPath file name
+ */
+export type SlashPathFile = SlashPathUntypedFile | SlashPathTypedFile;
 /**
  * A simple path made up of UTF-8 characters and slashes
  */
 export type SlashPath = SlashPathFolder | SlashPathFile | SlashPathTypedFile;
+/**
+ * A part of a slash path.
+ *
+ * Does not contain any slashes.
+ */
+export type SlashPathPart = string | SlashPathTypedFile;
 /**
  * Function that modifies the input SlashPath
  */
@@ -55,14 +96,14 @@ export declare function isValidSlashPath(input: string): input is SlashPath;
  *
  * @param slashPath
  */
-export declare function slashPathName(slashPath: SlashPath): string;
+export declare function slashPathName(slashPath: SlashPath): SlashPathPart;
 /**
  * Returns each section of a SlashPath
  *
  * @param slashPath
  * @returns
  */
-export declare function slashPathParts(slashPath: SlashPath): string[];
+export declare function slashPathParts(slashPath: SlashPath): SlashPathPart[];
 /**
  * Slash path type to enforce.
  * - relative: path that does not start with a slash
@@ -82,6 +123,49 @@ export declare const ALL_SLASHES_REGEX: RegExp;
 export declare const ALL_DOUBLE_SLASHES_REGEX: RegExp;
 export declare const ALL_SLASH_PATH_FILE_TYPE_SEPARATORS_REGEX: RegExp;
 export declare function toRelativeSlashPathStartType(input: SlashPath): SlashPath;
+/**
+ * Factory function that creates a SlashPathFolder from a string.
+ */
+export type SlashPathFolderFactory = (input: string) => InferredSlashPathFolder;
+export interface SlashPathFolderFactoryConfig {
+    /**
+     * Optional start type for the slash path. Defaults to 'any'.
+     */
+    readonly startType?: SlashPathStartType;
+    /**
+     * Whether to treat untyped files as folders.
+     *
+     * Defaults to false.
+     */
+    readonly treatUntypedFilesAsFolders?: boolean;
+    /**
+     * Optional validation configuration.
+     */
+    readonly validationConfig?: SlashPathValidationFactoryConfig;
+    /**
+     * The path value to return if the input is considered invalid after the validation step.
+     *
+     * You can also configure the `throwError` option in `validationConfig` to throw an error, in which case this option will be ignored.
+     *
+     * Defaults to ''.
+     */
+    readonly invalidPathValue?: Maybe<InferredSlashPathFolder>;
+}
+/**
+ * Creates a SlashPathFolderFactory.
+ *
+ * @param config Configuration options for the factory.
+ * @returns A SlashPathFolderFactory.
+ */
+export declare function slashPathFolderFactory(config?: SlashPathFolderFactoryConfig): SlashPathFolderFactory;
+/**
+ * Converts the input string to a valid slash path folder based on the configuration.
+ *
+ * If the input is a file, the folder of the file is returned instead.
+ *
+ * @param input
+ */
+export declare function slashPathFolder(input: string, config?: SlashPathFolderFactoryConfig): InferredSlashPathFolder;
 /**
  *
  * @param input
@@ -92,6 +176,13 @@ export declare function fixMultiSlashesInSlashPath(input: SlashPath): SlashPath;
 export declare function replaceMultipleFilePathsInSlashPath(input: SlashPath): SlashPath;
 export declare function removeTrailingSlashes(input: SlashPath): SlashPath;
 export declare function removeTrailingFileTypeSeparators(input: SlashPath): SlashPath;
+/**
+ * Adds a trailing slash to the input if it does not already have one.
+ *
+ * @param input A slash path.
+ * @returns A slash path folder.
+ */
+export declare function addTrailingSlash(input: SlashPath): SlashPathFolder;
 /**
  * Replaces all extra and invalidate FilePathTypeSeparator values from the SlashPath, returning a valid SlashPath.
  *
@@ -116,25 +207,25 @@ export interface SlashPathValidationFactoryConfig {
     /**
      * Set of illegal characters to find/replace. If not provided, used the DEFAULT_SLASH_PATH_ILLEGAL_CHARACTERS
      */
-    illegalStrings?: ArrayOrValue<string>;
+    readonly illegalStrings?: ArrayOrValue<string>;
     /**
      * String used to replace all encountered illegal characters.
      *
      * Is true by default.
      */
-    replaceIllegalCharacters?: string | boolean;
+    readonly replaceIllegalCharacters?: string | boolean;
     /**
      * Whether or not to replace extra dots by treating them as illegal characters.
      *
      * Will replace extra dots with the input value, or if true, will replace them with the value for replaceIllegalCharacters.
      */
-    replaceIllegalDots?: string | boolean;
+    readonly replaceIllegalDots?: string | boolean;
     /**
      * Whether or not to validate a final time after replacing elements and throw an error if it is still not valid.
      *
      * Disabled by default unless replaceIllegalCharacters and replaceIllegalDots are false.
      */
-    throwError?: boolean;
+    readonly throwError?: boolean;
 }
 export declare function slashPathValidationFactory(config?: SlashPathValidationFactoryConfig): SlashPathValidationFactory;
 /**
@@ -145,15 +236,15 @@ export interface SlashPathFactoryConfig {
     /**
      * SlashPath start type to enforce
      */
-    startType?: SlashPathStartType;
+    readonly startType?: SlashPathStartType;
     /**
      * Prefix paths to append
      */
-    basePath?: ArrayOrValue<SlashPathFolder>;
+    readonly basePath?: ArrayOrValue<SlashPathFolder>;
     /**
      * SlashPathValidationFactoryConfig to use for validation.
      */
-    validate?: boolean | SlashPathValidationFactoryConfig;
+    readonly validate?: boolean | SlashPathValidationFactoryConfig;
 }
 export declare function slashPathFactory(config?: SlashPathFactoryConfig): SlashPathFactory;
 export declare function mergeSlashPaths(paths: Maybe<SlashPath>[]): SlashPath;
@@ -171,15 +262,15 @@ export interface IsolateSlashPathFunctionConfig {
     /**
      * Range to isolate
      */
-    range: IndexRangeInput;
+    readonly range: IndexRangeInput;
     /**
      * Start type to force the result to be.
      */
-    startType?: SlashPathStartType;
+    readonly startType?: SlashPathStartType;
     /**
      * Whether or not to isolate the path to a file path. If true, the result string will not end with a slash.
      */
-    asFile?: boolean;
+    readonly asFile?: boolean;
 }
 /**
  * Isolates a configured index range of path elements.
@@ -194,3 +285,236 @@ export type IsolateSlashPathFunction = (path: SlashPath) => SlashPath;
  * @returns
  */
 export declare function isolateSlashPathFunction(config: IsolateSlashPathFunctionConfig): IsolateSlashPathFunction;
+export interface SlashPathDetails {
+    /**
+     * The full path
+     */
+    readonly path: SlashPath;
+    /**
+     * The path type
+     */
+    readonly type: SlashPathType;
+    /**
+     * The last part of the path.
+     *
+     * If the input path ended with a slash, indicating it is a file, then this will include the slash.
+     */
+    readonly end: SlashPathPart;
+    /**
+     * Returns true if the input is a typed or untyped file.
+     */
+    readonly isFile: boolean;
+    /**
+     * The last part of the path, if the path is not a folder.
+     *
+     * If it is a folder, this is undefined.
+     */
+    readonly file?: Maybe<SlashPathFile | SlashPathTypedFile>;
+    /**
+     * The file name, if file is defined.
+     */
+    readonly fileName?: Maybe<string>;
+    /**
+     * The typed file part, if the file is a typed file.
+     */
+    readonly typedFile: Maybe<SlashPathTypedFile>;
+    /**
+     * The file extension of the typed file, if the file is a typed file.
+     */
+    readonly typedFileExtension?: Maybe<SlashPathTypedFileExtension>;
+    /**
+     * Contains the name of the folder the file is in, if applicable.
+     *
+     * Unset if there is no file.
+     */
+    readonly fileFolder: Maybe<SlashPathPart>;
+    /**
+     * Contains all parts of the path, minus the file part.
+     *
+     * If a folder is input, this is the entire folder path.
+     *
+     * If there is only one path part and the path is a relative path, this will be an empty string.
+     */
+    readonly folderPath: InferredSlashPathFolder;
+    /**
+     * The start type of the path.
+     */
+    readonly startType: SlashPathStartType;
+    /**
+     * All parts of the path
+     */
+    readonly parts: SlashPathPart[];
+}
+/**
+ * Returns the details of a path.
+ *
+ * @param path The path to get details for.
+ * @returns The details of the path.
+ */
+export declare function slashPathDetails(path: SlashPath): SlashPathDetails;
+/**
+ * Numbers that are translated into pre-configured function codes.
+ */
+export declare enum SlashPathPathMatcherPartCode {
+    /**
+     * Treat as a wildcard
+     */
+    WILDCARD = 0
+}
+export type SlashPathPathMatcherFunction = DecisionFunction<SlashPathPart>;
+/**
+ * A part of a path to match against.
+ *
+ * SlashPathFolders are expanded into multiple SlashPathPart values automatically.
+ * SlashPathPathMatcherPartCode values are translated into pre-configured functions.
+ * A boolean value will be translated into a decision function. NOTE: Putting false will cause all matches to fail.
+ * Finally, any function that is provided will be used as-is when matching against a path part.
+ */
+export type SlashPathPathMatcherPart = SlashPathPart | SlashPathFolder | SlashPathPathMatcherPartCode | SlashPathPathMatcherFunction | boolean;
+/**
+ * Matcher path composed of parts to match against.
+ */
+export type SlashPathPathMatcherPath = ArrayOrValue<SlashPathPathMatcherPart>;
+/**
+ * Expands the input matcher path into decision functions.
+ *
+ * @param path The path to expand.
+ * @returns An array of decision functions.
+ */
+export declare function expandSlashPathPathMatcherPartToDecisionFunctions(path: SlashPathPathMatcherPath): SlashPathPathMatcherFunction[];
+/**
+ * The default value to use when filling non-matching parts.
+ */
+export declare const DEFAULT_SLASH_PATH_PATH_MATCHER_NON_MATCHING_FILL_VALUE = false;
+export interface SlashPathPathMatcherConfig<N extends PrimativeValue = typeof DEFAULT_SLASH_PATH_PATH_MATCHER_NON_MATCHING_FILL_VALUE> {
+    /**
+     * The base path or parts to match against.
+     */
+    readonly targetPath: SlashPathPathMatcherPath;
+    /**
+     * A decision function to use when matching against the remaining parts of the input path that go past the target path.
+     *
+     * Defaults to a decision function that returns false.
+     */
+    readonly matchRemaining?: boolean | DecisionFunction<SlashPathPart>;
+    /**
+     * The maximum number of parts to compare/match.
+     */
+    readonly maxPartsToCompare?: number;
+    /**
+     * A value to use when filling non-matching parts.
+     *
+     * Defaults to false.
+     */
+    readonly nonMatchingFillValue?: N;
+}
+export type SlashPathPathMatcher<N extends PrimativeValue = typeof DEFAULT_SLASH_PATH_PATH_MATCHER_NON_MATCHING_FILL_VALUE> = (inputPath: SlashPath) => SlashPathPathMatcherResult<N>;
+export interface SlashPathPathMatcherResult<N extends PrimativeValue = typeof DEFAULT_SLASH_PATH_PATH_MATCHER_NON_MATCHING_FILL_VALUE> {
+    /**
+     * The input path that was matched.
+     */
+    readonly inputPath: SlashPath;
+    /**
+     * True if the input path has the same configured base path.
+     */
+    readonly matchesTargetPath: boolean;
+    /**
+     * All parts of the input path.
+     */
+    readonly inputPathParts: SlashPathPart[];
+    /**
+     * Result of the comparison between the parts of the input path against the base path.
+     *
+     * The array element is null on parts that do not match.
+     */
+    readonly matchingParts: (SlashPathPart | null)[];
+    /**
+     * The value to use when filling non-matching parts.
+     */
+    readonly nonMatchingFillValue: N;
+    /**
+     * Result of the comparison between the parts of the input path against the base path.
+     *
+     * The array element is null on parts that match.
+     *
+     * If the input path is shorter than the target path, the remaining parts will be filled with the nonMatchingFillValue.
+     */
+    readonly nonMatchingParts: (SlashPathPart | null | N)[];
+    /**
+     * The total number of parts that did not match.
+     */
+    readonly nonMatchingPartsCount: number;
+}
+export type SlashPathPathMatcherConfigInput<N extends PrimativeValue = PrimativeValue> = SlashPathPathMatcherConfig<N> | SlashPathPathMatcherConfig<N>['targetPath'];
+/**
+ * Creates a SlashPathPathMatcherConfig from the input.
+ *
+ * @param input The configuration input.
+ * @returns The configuration.
+ */
+export declare function slashPathPathMatcherConfig<N extends PrimativeValue = PrimativeValue>(input: SlashPathPathMatcherConfigInput<N>): SlashPathPathMatcherConfig<N>;
+/**
+ * Creates a SlashPathPathMatcher.
+ *
+ * @param config The configuration for the matcher.
+ * @returns The matcher.
+ */
+export declare function slashPathPathMatcher<N extends PrimativeValue = PrimativeValue>(input: SlashPathPathMatcherConfigInput<N>): SlashPathPathMatcher<N>;
+export interface SlashPathSubPathMatcherConfig {
+    /**
+     * The base path or parts to match against.
+     */
+    readonly basePath: SlashPathPathMatcherPath;
+}
+export type SlashPathSubPathMatcherResult = SlashPathSubPathMatcherNonMatchResult | SlashPathSubPathMatcherMatchResult;
+export interface SlashPathSubPathMatcherBaseResult {
+    /**
+     * The input path that was matched.
+     */
+    readonly inputPath: SlashPath;
+    /**
+     * True if the input path has the same configured base path.
+     */
+    readonly matchesBasePath: boolean;
+    /**
+     * All parts of the input path.
+     */
+    readonly inputPathParts: SlashPathPart[];
+    /**
+     * Result of the comparison between the parts of the input path against the base path.
+     *
+     * The array element is null on parts that match.
+     */
+    readonly nonMatchingParts: (SlashPathPart | null)[];
+    /**
+     * All remaining parts of the path, relative to the base path.
+     *
+     * Only non-null if matchesBasePath is true.
+     */
+    readonly subPathParts: SlashPathPart[] | null;
+}
+export interface SlashPathSubPathMatcherMatchResult extends SlashPathSubPathMatcherBaseResult {
+    readonly matchesBasePath: true;
+    /**
+     * All parts of the sub path, relative to the base path.
+     */
+    readonly subPathParts: SlashPathPart[];
+}
+export interface SlashPathSubPathMatcherNonMatchResult extends SlashPathSubPathMatcherBaseResult {
+    readonly matchesBasePath: false;
+    /**
+     * Unset when the input path does not match the base path.
+     */
+    readonly subPathParts: null;
+}
+/**
+ * Used to match sub paths of a specific configured path.
+ */
+export type SlashPathSubPathMatcher = (path: SlashPath) => SlashPathSubPathMatcherResult;
+/**
+ * Creates a SlashPathSubPathMatcher.
+ *
+ * @param config The configuration for the matcher.
+ * @returns The matcher.
+ */
+export declare function slashPathSubPathMatcher(config: SlashPathSubPathMatcherConfig): SlashPathSubPathMatcher;

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

@@ -8,5 +8,6 @@ export * from './promise.loop';
 export * from './promise.ref';
 export * from './promise.factory';
 export * from './promise.type';
+export * from './promise.task';
 export * from './wait';
 export * from './use';

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

@@ -19,8 +19,8 @@ export declare function runAsyncTaskForValue<O>(taskFn: () => Promise<O>, config
  * @param config
  * @returns
  */
-export declare function runAsyncTasksForValues<T, K = unknown>(input: T[], taskFn: PromiseAsyncTaskFn<T, K>, config?: RunAsyncTasksForValuesConfig<T>): Promise<K[]>;
-export type PromiseAsyncTaskFn<T, K = unknown> = (value: T, tryNumber?: number) => Promise<K>;
+export declare function runAsyncTasksForValues<T, K = unknown>(input: T[], taskFn: PerformAsyncTaskFn<T, K>, config?: RunAsyncTasksForValuesConfig<T>): Promise<K[]>;
+export type PerformAsyncTaskFn<T, K = unknown> = (value: T, tryNumber?: number) => Promise<K>;
 export interface PerformAsyncTaskResult<O> {
     readonly value: Maybe<O>;
     readonly success: boolean;
@@ -58,7 +58,7 @@ export interface PerformAsyncTasksConfig<I = unknown, K extends PrimativeKey = P
  *
  * This is useful for retrying sections that may experience optimistic concurrency collisions.
  */
-export declare function performAsyncTasks<I, O = unknown, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey>(input: I[], taskFn: PromiseAsyncTaskFn<I, O>, config?: PerformAsyncTasksConfig<I, K>): Promise<PerformAsyncTasksResult<I, O>>;
+export declare function performAsyncTasks<I, O = unknown, K extends PrimativeKey = PerformTasksInParallelTaskUniqueKey>(input: I[], taskFn: PerformAsyncTaskFn<I, O>, config?: PerformAsyncTasksConfig<I, K>): Promise<PerformAsyncTasksResult<I, O>>;
 export declare function performAsyncTask<O>(taskFn: () => Promise<O>, config?: PerformAsyncTaskConfig<0>): Promise<PerformAsyncTaskResult<O>>;
 /**
  * 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.
@@ -136,3 +136,4 @@ export declare function performTasksFromFactoryInParallelFunction<I, K extends P
  * @returns A string factory that generates unique keys for non-concurrent tasks.
  */
 export declare function makeDefaultNonConcurrentTaskKeyFactory(): StringFactory<any>;
+export type PromiseAsyncTaskFn<T, K = unknown> = PerformAsyncTaskFn<T, K>;

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

@@ -0,0 +1,63 @@
+import { AsyncFactory } from '../getter/getter';
+import { Maybe } from '../value';
+import { RunAsyncTasksForValuesConfig } from './promise';
+/**
+ * A function that returns a Promise, typically returning void/no value.
+ */
+export type AsyncTask<T = void> = AsyncFactory<T>;
+/**
+ * An AsyncTask that has a name and a run function.
+ */
+export type NamedAsyncTask<T = void> = {
+    readonly name: string;
+    readonly run: AsyncTask<T>;
+};
+export type NamedAsyncTaskRecord<T = void> = Record<string, AsyncTask<T>>;
+/**
+ * A function that runs an array of named async tasks.
+ */
+export type RunNamedAsyncTasksFunction<T = void> = (inputTasks: RunNamedAsyncTasksInput<T>, options?: Maybe<RunNamedAsyncTasksFunctionOptions<T>>) => Promise<RunNamedAsyncTasksResult<T>>;
+/**
+ * Options for a RunNamedAsyncTasksFunction.
+ */
+export type RunNamedAsyncTasksFunctionOptions<T = void> = Maybe<Omit<RunAsyncTasksForValuesConfig<T>, 'nonConcurrentTaskKeyFactory' | 'retriesAllowed' | 'retryWait' | 'beforeRetry'>>;
+/**
+ * Config for runNamedAsyncTasksFunction().
+ */
+export interface RunNamedAsyncTasksFunctionConfig<T = void> {
+    readonly onTaskSuccess?: (task: NamedAsyncTask<T>, value: T) => void;
+    readonly onTaskFailure?: (task: NamedAsyncTask<T>, error: unknown) => void;
+    readonly defaultOptions?: RunNamedAsyncTasksFunctionOptions<T>;
+}
+/**
+ * The input for runNamedAsyncTasks(). Either an array of NamedAsyncTasks or a NamedAsyncTaskRecord.
+ */
+export type RunNamedAsyncTasksInput<T = void> = NamedAsyncTaskRecord<T> | NamedAsyncTask<T>[];
+/**
+ * The result of runNamedAsyncTasks().
+ */
+export interface RunNamedAsyncTasksResult<T = void> {
+    /**
+     * The tasks that were run successfully.
+     */
+    readonly successfulTasks: NamedAsyncTask<T>[];
+    /**
+     * The tasks that failed.
+     */
+    readonly failedTasks: NamedAsyncTask<T>[];
+}
+/**
+ * Creates a new RunNamedAsyncTasksFunction.
+ *
+ * @param config Optional configuration.
+ * @returns A new RunNamedAsyncTasksFunction.
+ */
+export declare function runNamedAsyncTasksFunction<T = void>(config?: RunNamedAsyncTasksFunctionConfig<T>): RunNamedAsyncTasksFunction<T>;
+/**
+ * Runs the input named tasks and returns the results.
+ *
+ * @param inputTasks
+ * @param options
+ * @returns
+ */
+export declare function runNamedAsyncTasks<T = void>(inputTasks: RunNamedAsyncTasksInput<T>, config?: RunNamedAsyncTasksFunctionConfig<T>): Promise<RunNamedAsyncTasksResult<T>>;