@oscarpalmer/atoms 0.206.0 → 0.208.0

package/dist/index.d.mts

@@ -3667,7 +3667,7 @@ export type MemoizedOptions<Callback extends GenericCallback> = {
  */
 export declare function memoize<Callback extends GenericCallback>(callback: Callback, options?: MemoizedOptions<Callback>): Memoized<Callback>;
 //#endregion
-//#region src/internal/result/models.d.ts
+//#region src/internal/models/result.model.d.ts
 /**
  * An unknown result
  */
@@ -4587,6 +4587,108 @@ export declare function setValue<Data extends PlainObject, Path extends NestedKe
  */
 export declare function setValue<Data extends PlainObject>(data: Data, path: string, value: unknown, ignoreCase?: boolean): Data;
 //#endregion
+//#region src/internal/models/plan.model.d.ts
+/**
+ * An asynchronous plan of execution that can yield intermediate results and eventually return a result
+ */
+type AsyncPlan<Value, Error = unknown> = {
+  /**
+   * Run the plan to completion
+   *
+   * @returns Result
+   */
+  run: () => Promise<Result<Value, Error>>;
+};
+/**
+ * A plan of execution that can yield intermediate results and eventually return a result
+ */
+type Plan<Value, Error = unknown> = {
+  /**
+   * Run the plan to completion
+   *
+   * @returns Result
+   */
+  run: () => Result<Value, Error>;
+};
+//#endregion
+//#region src/plan/index.d.ts
+/**
+ * Create a plan for an asynchronous generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function asyncPlan<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): AsyncPlan<Value, Error>;
+/**
+ * Run an asynchronous generator to completion
+ *
+ * @param generator Generator to run
+ * @returns Result
+ */
+export declare function asyncRun<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): Promise<Result<Value, Error>>;
+/**
+ * Run an asynchronous plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Result
+ */
+export declare function asyncRun<Value = unknown, Error = unknown>(plan: AsyncPlan<Value, Error>): Promise<Result<Value, Error>>;
+/**
+ * Is the value an asynchronous plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous plan, otherwise `false`
+ */
+export declare function isAsyncPlan<Value = unknown, Error = unknown>(value: unknown): value is AsyncPlan<Value, Error>;
+/**
+ * Is the value an asynchronous generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous generator function, otherwise `false`
+ */
+export declare function isAsyncGenerator(value: unknown): value is () => AsyncGenerator;
+/**
+ * Is the value a generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a generator function, otherwise `false`
+ */
+export declare function isGenerator(value: unknown): value is () => Generator;
+/**
+ * Is the value a plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a plan, otherwise `false`
+ */
+export declare function isPlan<Value = unknown, Error = unknown>(value: unknown): value is Plan<Value, Error>;
+/**
+ * Create a plan for a generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function plan<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, Error>): Plan<Value, Error>;
+/**
+ * Run a generator to completion
+ *
+ * @param generator Generator to run
+ * @returns Result
+ */
+export declare function run<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, unknown>): Result<Value, Error>;
+/**
+ * Run a plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Result
+ */
+export declare function run<Value = unknown, Error = unknown>(plan: Plan<Value, Error>): Result<Value, Error>;
+export declare namespace plan {
+  export var async: typeof asyncPlan;
+}
+export declare namespace run {
+  export var async: typeof asyncRun;
+}
+//#endregion
 //#region src/internal/aborter.d.ts
 type Aborter = {
   callback: GenericCallback;
@@ -8317,4 +8419,4 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { type AsyncLimiter, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, type Limiter, Logger, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimeLogger, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };
+export { type AsyncLimiter, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, type Limiter, Logger, type Plan, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimeLogger, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };

package/dist/index.mjs

@@ -2746,6 +2746,134 @@ function setValue(data, path, value, ignoreCase) {
 	return data;
 }
 const SET_EXPRESSION_INDEX = /^\d+$/;
+const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
+const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+const PLAN_SYMBOL = Symbol("plan");
+const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
+const PLAN_TYPE_PLAN_SYNC = "plan";
+//#endregion
+//#region src/plan/index.ts
+function AsyncPlan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_ASYNC
+	};
+}
+AsyncPlan.prototype.run = runAsyncPlan;
+function Plan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
+}
+Plan.prototype.run = runPlan;
+function asyncExecute(callback) {
+	return asyncAttempt(async () => {
+		const generator = callback();
+		let lastValue;
+		while (true) {
+			const next = await generator.next();
+			const { done } = next;
+			let value = next.value;
+			if (value instanceof Error) throw value;
+			lastValue = value;
+			if (done === true) break;
+		}
+		return lastValue;
+	});
+}
+/**
+* Create a plan for an asynchronous generator function
+*
+* @param generator Generator to plan for
+* @returns Generator plan
+*/
+function asyncPlan(generator) {
+	if (!isAsyncGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+	return new AsyncPlan(generator);
+}
+async function asyncRun(input) {
+	if (isAsyncPlan(input)) return input.run();
+	if (!isAsyncGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return asyncExecute(input);
+}
+function execute(callback) {
+	return attempt(() => {
+		const generator = callback();
+		let lastValue;
+		while (true) {
+			const next = generator.next();
+			const { done } = next;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			lastValue = value;
+			if (done === true) break;
+		}
+		return lastValue;
+	});
+}
+/**
+* Is the value an asynchronous plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
+*/
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+}
+/**
+* Is the value an asynchronous generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator function, otherwise `false`
+*/
+function isAsyncGenerator(value) {
+	return typeof value === "function" && value.constructor.name === "AsyncGeneratorFunction" && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+}
+/**
+* Is the value a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGenerator(value) {
+	return typeof value === "function" && value.constructor.name === "GeneratorFunction" && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+}
+/**
+* Is the value a plan?
+*
+* @param value Value to check
+* @returns `true` if the value is a plan, otherwise `false`
+*/
+function isPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
+}
+function isPlanInstance(type, value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+}
+/**
+* Create a plan for a generator function
+*
+* @param generator Generator to plan for
+* @returns Generator plan
+*/
+function plan(generator) {
+	if (!isGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+	return new Plan(generator);
+}
+function run(input) {
+	if (isPlan(input)) return input.run();
+	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return execute(input);
+}
+function runAsyncPlan() {
+	return asyncExecute(this[PLAN_SYMBOL].generator);
+}
+function runPlan() {
+	return execute(this[PLAN_SYMBOL].generator);
+}
+plan.async = asyncPlan;
+run.async = asyncRun;
 //#endregion
 //#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
@@ -6493,7 +6621,7 @@ function addToQueue(parameters, signal) {
 		reject: rejector,
 		resolve: resolver
 	});
-	if (state.options.autostart) run(state);
+	if (state.options.autostart) run$1(state);
 	return {
 		id,
 		promise
@@ -6681,12 +6809,12 @@ function resumeQueue() {
 	}
 	state.paused = false;
 	const length = min([state.options.concurrency, state.items.length]);
-	for (let index = 0; index < length; index += 1) run(state);
+	for (let index = 0; index < length; index += 1) run$1(state);
 }
 function resumeQueues(key) {
 	handleQueues(this, QUEUE_HANDLE_RESUME, key);
 }
-async function run(state) {
+async function run$1(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
 	let item = state.items.shift();
@@ -6847,4 +6975,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncOnce, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncPlan, asyncRun, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/internal/function/work.d.mts

@@ -1,5 +1,5 @@
 import { GenericCallback } from "../../models.mjs";
-import { UnwrapValue } from "../result/models.mjs";
+import { UnwrapValue } from "../models/result.model.mjs";
 //#region src/internal/function/work.d.ts
 /**
  * A synchronous _Flow_, a function that pipe a value through a series of functions

package/dist/internal/models/plan.model.d.mts

@@ -0,0 +1,48 @@
+import { Result } from "./result.model.mjs";
+//#region src/internal/models/plan.model.d.ts
+/**
+ * An asynchronous plan of execution that can yield intermediate results and eventually return a result
+ */
+export type AsyncPlan<Value, Error = unknown> = {
+  /**
+   * Run the plan to completion
+   *
+   * @returns Result
+   */
+  run: () => Promise<Result<Value, Error>>;
+};
+type AsyncPlanState = {
+  generator: () => AsyncGenerator;
+} & BaseState<typeof PLAN_TYPE_PLAN_ASYNC>;
+type BaseState<Type extends PlanType> = {
+  type: Type;
+};
+export type InternalAsyncPlan = {
+  [PLAN_SYMBOL]: AsyncPlanState;
+} & AsyncPlan<never, never>;
+export type InternalPlan = {
+  [PLAN_SYMBOL]: PlanState;
+} & Plan<never, never>;
+/**
+ * A plan of execution that can yield intermediate results and eventually return a result
+ */
+export type Plan<Value, Error = unknown> = {
+  /**
+   * Run the plan to completion
+   *
+   * @returns Result
+   */
+  run: () => Result<Value, Error>;
+};
+type PlanState = {
+  generator: () => Generator;
+} & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
+export type PlanType = "asyncPlan" | "plan";
+export declare const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
+export declare const GENERATOR_NAME_SYNC = "GeneratorFunction";
+export declare const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
+export declare const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+export declare const PLAN_SYMBOL: symbol;
+export declare const PLAN_TYPE_PLAN_ASYNC: PlanType;
+export declare const PLAN_TYPE_PLAN_SYNC: PlanType;
+//#endregion

package/dist/internal/models/plan.model.mjs

@@ -0,0 +1,10 @@
+//#region src/internal/models/plan.model.ts
+const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
+const GENERATOR_NAME_SYNC = "GeneratorFunction";
+const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
+const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+const PLAN_SYMBOL = Symbol("plan");
+const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
+const PLAN_TYPE_PLAN_SYNC = "plan";
+//#endregion
+export { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC };

package/dist/internal/{result/models.d.mts → models/result.model.d.mts}

@@ -1,5 +1,5 @@
 import { GenericCallback } from "../../models.mjs";
-//#region src/internal/result/models.d.ts
+//#region src/internal/models/result.model.d.ts
 /**
  * An unknown result
  */

package/dist/internal/result/attempt.d.mts

@@ -1,4 +1,4 @@
-import { ExtendedResult, Result } from "./models.mjs";
+import { ExtendedResult, Result } from "../models/result.model.mjs";
 //#region src/internal/result/attempt.d.ts
 /**
  * Executes a _Promise_, catching any errors, and returns a result

package/dist/internal/result/misc.d.mts

@@ -1,4 +1,4 @@
-import { Err, ExtendedErr, Ok, Result } from "./models.mjs";
+import { Err, ExtendedErr, Ok, Result } from "../models/result.model.mjs";
 //#region src/internal/result/misc.d.ts
 /**
  * Creates an extended error result

package/dist/internal/value/has.d.mts

@@ -1,5 +1,5 @@
 import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs";
-import { Result } from "../result/models.mjs";
+import { Result } from "../models/result.model.mjs";
 //#region src/internal/value/has.d.ts
 /**
  * Check if a property is defined in an object

package/dist/internal/value/misc.d.mts

@@ -1,4 +1,4 @@
-import { Result } from "../result/models.mjs";
+import { Result } from "../models/result.model.mjs";
 //#region src/internal/value/misc.d.ts
 export declare function findKey(needle: string, haystack: object): string;
 export declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;

package/dist/plan/index.d.mts

@@ -0,0 +1,80 @@
+import { Result } from "../internal/models/result.model.mjs";
+import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+//#region src/plan/index.d.ts
+/**
+ * Create a plan for an asynchronous generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function asyncPlan<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): AsyncPlan<Value, Error>;
+/**
+ * Run an asynchronous generator to completion
+ *
+ * @param generator Generator to run
+ * @returns Result
+ */
+export declare function asyncRun<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): Promise<Result<Value, Error>>;
+/**
+ * Run an asynchronous plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Result
+ */
+export declare function asyncRun<Value = unknown, Error = unknown>(plan: AsyncPlan<Value, Error>): Promise<Result<Value, Error>>;
+/**
+ * Is the value an asynchronous plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous plan, otherwise `false`
+ */
+export declare function isAsyncPlan<Value = unknown, Error = unknown>(value: unknown): value is AsyncPlan<Value, Error>;
+/**
+ * Is the value an asynchronous generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous generator function, otherwise `false`
+ */
+export declare function isAsyncGenerator(value: unknown): value is () => AsyncGenerator;
+/**
+ * Is the value a generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a generator function, otherwise `false`
+ */
+export declare function isGenerator(value: unknown): value is () => Generator;
+/**
+ * Is the value a plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a plan, otherwise `false`
+ */
+export declare function isPlan<Value = unknown, Error = unknown>(value: unknown): value is Plan<Value, Error>;
+/**
+ * Create a plan for a generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function plan<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, Error>): Plan<Value, Error>;
+/**
+ * Run a generator to completion
+ *
+ * @param generator Generator to run
+ * @returns Result
+ */
+export declare function run<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, unknown>): Result<Value, Error>;
+/**
+ * Run a plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Result
+ */
+export declare function run<Value = unknown, Error = unknown>(plan: Plan<Value, Error>): Result<Value, Error>;
+export declare namespace plan {
+  export var async: typeof asyncPlan;
+}
+export declare namespace run {
+  export var async: typeof asyncRun;
+}
+//#endregion

package/dist/plan/index.mjs

@@ -0,0 +1,126 @@
+import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
+import { PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
+//#region src/plan/index.ts
+function AsyncPlan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_ASYNC
+	};
+}
+AsyncPlan.prototype.run = runAsyncPlan;
+function Plan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
+}
+Plan.prototype.run = runPlan;
+function asyncExecute(callback) {
+	return asyncAttempt(async () => {
+		const generator = callback();
+		let lastValue;
+		while (true) {
+			const next = await generator.next();
+			const { done } = next;
+			let value = next.value;
+			if (value instanceof Error) throw value;
+			lastValue = value;
+			if (done === true) break;
+		}
+		return lastValue;
+	});
+}
+/**
+* Create a plan for an asynchronous generator function
+*
+* @param generator Generator to plan for
+* @returns Generator plan
+*/
+function asyncPlan(generator) {
+	if (!isAsyncGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+	return new AsyncPlan(generator);
+}
+async function asyncRun(input) {
+	if (isAsyncPlan(input)) return input.run();
+	if (!isAsyncGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return asyncExecute(input);
+}
+function execute(callback) {
+	return attempt(() => {
+		const generator = callback();
+		let lastValue;
+		while (true) {
+			const next = generator.next();
+			const { done } = next;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			lastValue = value;
+			if (done === true) break;
+		}
+		return lastValue;
+	});
+}
+/**
+* Is the value an asynchronous plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
+*/
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+}
+/**
+* Is the value an asynchronous generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator function, otherwise `false`
+*/
+function isAsyncGenerator(value) {
+	return typeof value === "function" && value.constructor.name === "AsyncGeneratorFunction" && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+}
+/**
+* Is the value a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGenerator(value) {
+	return typeof value === "function" && value.constructor.name === "GeneratorFunction" && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+}
+/**
+* Is the value a plan?
+*
+* @param value Value to check
+* @returns `true` if the value is a plan, otherwise `false`
+*/
+function isPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
+}
+function isPlanInstance(type, value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+}
+/**
+* Create a plan for a generator function
+*
+* @param generator Generator to plan for
+* @returns Generator plan
+*/
+function plan(generator) {
+	if (!isGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+	return new Plan(generator);
+}
+function run(input) {
+	if (isPlan(input)) return input.run();
+	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return execute(input);
+}
+function runAsyncPlan() {
+	return asyncExecute(this[PLAN_SYMBOL].generator);
+}
+function runPlan() {
+	return execute(this[PLAN_SYMBOL].generator);
+}
+plan.async = asyncPlan;
+run.async = asyncRun;
+//#endregion
+export { asyncPlan, asyncRun, isAsyncGenerator, isAsyncPlan, isGenerator, isPlan, plan, run };

package/dist/plan/models.d.mts

@@ -0,0 +1,2 @@
+import { Plan } from "../internal/models/plan.model.mjs";
+export type { Plan };

package/dist/plan/models.mjs

@@ -0,0 +1 @@
+export {};

package/dist/promise/misc.d.mts

@@ -1,4 +1,4 @@
-import { Result } from "../internal/result/models.mjs";
+import { Result } from "../internal/models/result.model.mjs";
 import { Aborter } from "../internal/aborter.mjs";
 import { CancelablePromise, PromiseParameters } from "./models.mjs";
 import { toPromise } from "../result/misc.mjs";

package/dist/promise/models.d.mts

@@ -1,5 +1,5 @@
 import { ArrayOrPlainObject, GenericCallback, Key } from "../models.mjs";
-import { Result } from "../internal/result/models.mjs";
+import { Result } from "../internal/models/result.model.mjs";
 import { Aborter } from "../internal/aborter.mjs";
 import { PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 //#region src/promise/models.d.ts

package/dist/result/match.d.mts

@@ -1,4 +1,4 @@
-import { AnyResult, ResultMatch } from "../internal/result/models.mjs";
+import { AnyResult, ResultMatch } from "../internal/models/result.model.mjs";
 //#region src/result/match.d.ts
 /**
  * Handles a _Result_ with match callbacks

package/dist/result/misc.d.mts

@@ -1,4 +1,4 @@
-import { AnyResult } from "../internal/result/models.mjs";
+import { AnyResult } from "../internal/models/result.model.mjs";
 import { error, isError, isOk, isResult, ok, unwrap } from "../internal/result/misc.mjs";
 //#region src/result/misc.d.ts
 /**

package/dist/result/work/flow.d.mts

@@ -1,5 +1,5 @@
 import { GenericCallback } from "../../models.mjs";
-import { Result, UnwrapValue } from "../../internal/result/models.mjs";
+import { Result, UnwrapValue } from "../../internal/models/result.model.mjs";
 //#region src/result/work/flow.d.ts
 /**
  * A synchronous _Flow_, a function that attempts to pipe values through a series of functions

package/dist/result/work/pipe.d.mts

@@ -1,5 +1,5 @@
 import { GenericCallback } from "../../models.mjs";
-import { Result, UnwrapValue } from "../../internal/result/models.mjs";
+import { Result, UnwrapValue } from "../../internal/models/result.model.mjs";
 //#region src/result/work/pipe.d.ts
 type WrapValue<Value> = Result<UnwrapValue<Value>>;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.206.0",
+	"version": "0.208.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -149,6 +149,13 @@
 			"types": "./dist/number.d.mts",
 			"default": "./dist/number.mjs"
 		},
+		"./plan": {
+			"types": "./dist/plan/index.d.mts",
+			"default": "./dist/plan/index.mjs"
+		},
+		"./plan/models": {
+			"default": "./dist/plan/models.mjs"
+		},
 		"./promise": {
 			"types": "./dist/promise/index.d.mts",
 			"default": "./dist/promise/index.mjs"
@@ -162,7 +169,6 @@
 			"default": "./dist/promise/misc.mjs"
 		},
 		"./promise/models": {
-			"types": "./dist/promise/models.d.mts",
 			"default": "./dist/promise/models.mjs"
 		},
 		"./promise/timed": {
@@ -198,8 +204,7 @@
 			"default": "./dist/result/misc.mjs"
 		},
 		"./result/models": {
-			"types": "./dist/internal/result/models.d.mts",
-			"default": "./dist/internal/result/models.mjs"
+			"default": "./dist/internal/models/result.model.mjs"
 		},
 		"./result/pipe": {
 			"types": "./dist/result/work/pipe.d.mts",