@oscarpalmer/atoms 0.212.0 → 0.214.0

package/dist/models/value/value.equal.model.d.mts

@@ -0,0 +1,76 @@
+import { Constructor } from "../index.mjs";
+//#region src/models/value/value.equal.model.d.ts
+/**
+ * Options for value equality comparison
+ */
+export type EqualOptions = {
+  /**
+   * When `true`, strings are compared case-insensitively
+   */
+  ignoreCase?: boolean;
+  /**
+   * Keys _(or key expressions)_ to ignore when comparing objects
+   */
+  ignoreKeys?: string | RegExp | Array<string | RegExp>;
+  /**
+   * Should `null` and `undefined` be considered equal?
+   */
+  relaxedNullish?: boolean;
+};
+/**
+ * An equalizer function for comparing values for equality, with predefined options
+ *
+ * Can be used to compare values, and register or deregister equality comparison handlers for specific classes
+ */
+export type Equalizer = {
+  /**
+   * Are two strings equal?
+   *
+   * @param first First string
+   * @param second Second string
+   * @param ignoreCase If `true`, comparison will be case-insensitive
+   * @returns `true` if the strings are equal, otherwise `false`
+   */
+  compare(first: string, second: string, ignoreCase?: boolean): boolean;
+  /**
+   * Are two values equal?
+   *
+   * @param first First value
+   * @param second Second value
+   * @returns `true` if the values are equal, otherwise `false`
+   */
+  compare(first: unknown, second: unknown): boolean;
+  /**
+   * Deregister a equality comparison handler for a specific class
+   *
+   * @param constructor Class constructor
+   */
+  deregister: <Instance>(constructor: Constructor<Instance>) => void;
+  /**
+   * Register a equality comparison function for a specific class
+   *
+   * @param constructor Class constructor
+   * @param handler Comparison function
+   */
+  register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
+};
+export type InternalEqualizer = {
+  [EQUAL_SYMBOL]: EqualizerOptions;
+} & Equalizer;
+export type EqualizerOptions = {
+  ignoreCase: boolean;
+  ignoreExpressions: EqualizerOptionsKeys<RegExp[]>;
+  ignoreKeys: EqualizerOptionsKeys<Set<string>>;
+  relaxedNullish: boolean;
+};
+type EqualizerOptionsKeys<Values> = {
+  enabled: boolean;
+  values: Values;
+};
+export declare const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
+export declare const EQUAL_ARRAY_THRESHOLD = 100;
+export declare const EQUAL_ERROR_PROPERTIES: string[];
+export declare const EQUAL_EXPRESSION_PROPERTIES: string[];
+export declare const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
+export declare const EQUAL_SYMBOL: unique symbol;
+//#endregion

package/dist/models/value/value.equal.model.mjs

@@ -0,0 +1,9 @@
+//#region src/models/value/value.equal.model.ts
+const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
+const EQUAL_ARRAY_THRESHOLD = 100;
+const EQUAL_ERROR_PROPERTIES = ["name", "message"];
+const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
+const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_SYMBOL = Symbol("equal");
+//#endregion
+export { EQUAL_ARRAY_PEEK_PERCENTAGE, EQUAL_ARRAY_THRESHOLD, EQUAL_ERROR_PROPERTIES, EQUAL_EXPRESSION_PROPERTIES, EQUAL_MINIMUM_LENGTH_FOR_SET, EQUAL_SYMBOL };

package/dist/models/value/value.handler.model.d.mts

@@ -0,0 +1,27 @@
+import { Constructor, GenericCallback } from "../index.mjs";
+//#region src/models/value/value.handler.model.d.ts
+export type BaseHandler = {
+  handlers: WeakMap<WeakKey, string | GenericCallback>;
+  options: BaseHandlerOptions;
+  owner: GenericCallback;
+  deregister(constructor: Constructor): void;
+  get(first: unknown, second: unknown): string | GenericCallback | undefined;
+  register(constructor: Constructor, handler?: string | GenericCallback): void;
+};
+export type BaseHandlerOptions = {
+  callback: GenericCallback;
+  method?: string;
+};
+export type CompareHandler<Value> = {
+  base: BaseHandler;
+  handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
+};
+export type Constructable = {
+  constructor: Constructor;
+};
+export type Handleable = Record<string, GenericCallback>;
+export type ValueHandler = {
+  base: BaseHandler;
+  handle(value: unknown, ...parameters: unknown[]): unknown;
+};
+//#endregion

package/dist/models/value/value.handler.model.mjs

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

package/dist/models/value/value.merge.model.d.mts

@@ -0,0 +1,82 @@
+import { ArrayOrPlainObject, NestedPartial, PlainObject, UnionToIntersection } from "../index.mjs";
+//#region src/models/value/value.merge.model.d.ts
+/**
+ * Options for assigning values
+ */
+export type AssignOptions = BaseOptions;
+type BaseOptions = {
+  /**
+   * Key _(or key epxressions)_ for values that should be replaced
+   *
+   * ```ts
+   * merge([{items: [1, 2, 3]}, {items: [99]}]); // => {items: [99]}
+   * ```
+   */
+  replaceableObjects?: string | RegExp | Array<string | RegExp>;
+  /**
+   * Skip nullable values when merging objects?
+   *
+   * ```ts
+   * merge({a: 1, b: 2}, {b: null, c: 3}, {d: null}); // => {a: 1, b: 2, c: 3}
+   * ```
+   */
+  skipNullableAny?: boolean;
+  /**
+   * Skip nullable values when merging arrays?
+   *
+   * ```ts
+   * merge([1, 2, 3], [null, null, 99]); // => [1, 2, 99]
+   * ```
+   */
+  skipNullableInArrays?: boolean;
+};
+/**
+ * An assigner function for assigning values from one or more objects to the first one
+ */
+export type Assigner = {
+  /**
+   * Assign values from one or more objects to the first one
+   *
+   * @param to Value to assign to
+   * @param from Values to assign
+   * @returns Assigned value
+   */
+  assign<To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From]): To & UnionToIntersection<From[number]>;
+};
+export type InternalAssigner = {
+  [MERGE_SYMBOL_ASSIGN]: MergingOptions;
+} & Assigner;
+export type InternalMerger = {
+  [MERGE_SYMBOL_MERGE]: MergingOptions;
+} & Merger;
+/**
+ * Options for merging values
+ */
+export type MergeOptions = {
+  /**
+   * Assign values to the first array or object instead of creating a new one?
+   */
+  assignValues?: boolean;
+};
+/**
+ * A merger function for merging multiple arrays or objects into a single one
+ */
+export type Merger = {
+  /**
+   * Merge multiple arrays or objects into a single one
+   *
+   * @param values Values to merge
+   * @returns Merged value
+   */
+  merge<Values extends ArrayOrPlainObject[]>(values: Array<NestedPartial<Values[number]>>): UnionToIntersection<Values[number]>;
+};
+export type MergeReplaceableObjectsCallback = (name: string) => boolean;
+export type MergingOptions = {
+  assignValues: boolean;
+  replaceableObjects: MergeReplaceableObjectsCallback | undefined;
+  skipNullableAny: boolean;
+  skipNullableInArrays: boolean;
+};
+export declare const MERGE_SYMBOL_ASSIGN: unique symbol;
+export declare const MERGE_SYMBOL_MERGE: unique symbol;
+//#endregion

package/dist/models/value/value.merge.model.mjs

@@ -0,0 +1,5 @@
+//#region src/models/value/value.merge.model.ts
+const MERGE_SYMBOL_ASSIGN = Symbol("assign");
+const MERGE_SYMBOL_MERGE = Symbol("merge");
+//#endregion
+export { MERGE_SYMBOL_ASSIGN, MERGE_SYMBOL_MERGE };

package/dist/models/value/value.misc.model.d.mts

@@ -0,0 +1,33 @@
+import { NestedKeys, NestedValue, PlainObject, Simplify, ToString, UnionToIntersection } from "../index.mjs";
+//#region src/models/value/value.misc.model.d.ts
+export type ComparisonHandler<Value = any> = (first: Value, second: Value) => number;
+/**
+ * Thanks, type-fest!
+ */
+type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+/**
+ * A shaken object, without any `undefined` values
+ */
+export type Shaken<Value extends PlainObject> = Simplify<{ [Key in keyof Value as undefined extends Value[Key] ? never : Key]: Value[Key]; } & { [Key in keyof Value as undefined extends Value[Key] ? [Value[Key]] extends [undefined] ? never : Key : never]?: Exclude<Value[Key], undefined>; }>;
+/**
+ * A smushed object, with all nested objects flattened into a single level, using dot notation keys
+ */
+export type Smushed<Value extends PlainObject> = Simplify<{ [NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>>; }>;
+/**
+ * An unsmushed object, with all dot notation keys turned into nested keys
+ */
+export type Unsmushed<Value extends PlainObject> = Simplify<Omit<{ [UnionKey in KeysOfUnion<Value>]: Value[UnionKey]; }, `${string}.${string}`>>;
+export type UnsmushedKey = {
+  order: number;
+  value: string;
+};
+export declare const COMPARE_NAME: string;
+export declare const VALUE_MISC_EXPRESSION_BRACKET: RegExp;
+export declare const VALUE_MISC_EXPRESSION_DOTS: RegExp;
+export declare const VALUE_MISC_EXPRESSION_NESTED: RegExp;
+export declare const VALUE_MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
+export declare const VALUE_MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+export declare const VALUE_MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
+export declare const VALUE_MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+export declare const SMUSH_MAX_DEPTH = 100;
+//#endregion

package/dist/models/value/value.misc.model.mjs

@@ -0,0 +1,12 @@
+//#region src/models/value/value.misc.model.ts
+const COMPARE_NAME = "compare";
+const VALUE_MISC_EXPRESSION_BRACKET = /\[(\w+)\]/g;
+const VALUE_MISC_EXPRESSION_DOTS = /^\.|\.$/g;
+const VALUE_MISC_EXPRESSION_NESTED = /\.|\[\w+\]/;
+const VALUE_MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const VALUE_MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const VALUE_MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
+const VALUE_MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+const SMUSH_MAX_DEPTH = 100;
+//#endregion
+export { COMPARE_NAME, SMUSH_MAX_DEPTH, VALUE_MISC_EXPRESSION_BRACKET, VALUE_MISC_EXPRESSION_DOTS, VALUE_MISC_EXPRESSION_NESTED, VALUE_MISC_NESTED_MESSAGE_INPUT, VALUE_MISC_NESTED_MESSAGE_MISSING, VALUE_MISC_NESTED_MESSAGE_PATH, VALUE_MISC_NESTED_MESSAGE_UNSAFE };

package/dist/models/value/value.transform.model.d.mts

@@ -0,0 +1,28 @@
+import { PlainObject } from "../index.mjs";
+//#region src/models/value/value.transform.model.d.ts
+export type InternalTransformer<Value extends PlainObject> = {
+  [TRANSFORM_SYMBOL]: TransformHandler<Value>;
+} & Transformer<Value>;
+/**
+ * A callback transform an object's properties
+ */
+export type TransformCallback<Value extends PlainObject, Key extends keyof Value> = (key: Key, value: Value[Key]) => Value[Key];
+/**
+ * A collection of keyed callbacks to transform an object's properties
+ */
+export type TransformCallbacks<Value extends PlainObject> = Partial<{ [Key in keyof Value]: (value: Value[Key]) => Value[Key]; }>;
+export type TransformHandler<Value extends PlainObject> = TransformCallback<Value, keyof Value> | TransformCallbacks<Value>;
+/**
+ * A transformer for an object, with predefined callbacks for transforming its properties
+ */
+export type Transformer<Value extends PlainObject> = {
+  /**
+   * Transform an object's properties
+   *
+   * @param value Object to transform
+   * @returns Transformed object
+   */
+  transform(value: Value): Value;
+};
+export declare const TRANSFORM_SYMBOL: unique symbol;
+//#endregion

package/dist/models/value/value.transform.model.mjs

@@ -0,0 +1,4 @@
+//#region src/models/value/value.transform.model.ts
+const TRANSFORM_SYMBOL = Symbol("transform");
+//#endregion
+export { TRANSFORM_SYMBOL };

package/dist/plan/generate.d.mts

@@ -1,4 +1,5 @@
+import { AsyncPlanState, PlanState } from "../models/plan.model.mjs";
 //#region src/plan/generate.d.ts
-export declare function asyncGenerate(callback: (...parameters: unknown[]) => AsyncGenerator, parameters: unknown[]): Promise<unknown>;
-export declare function generate(callback: (...parameters: unknown[]) => Generator, parameters: unknown[]): unknown;
+export declare function asyncGenerate(input: AsyncPlanState | ((...parameters: unknown[]) => AsyncGenerator), parameters: unknown[], unwrap: boolean): Promise<unknown>;
+export declare function generate(input: PlanState | ((...parameters: unknown[]) => Generator), parameters: unknown[], unwrap: boolean): unknown;
 //#endregion

package/dist/plan/generate.mjs

@@ -1,14 +1,16 @@
-import { isError } from "../internal/result/misc.mjs";
+import { isError, isOk } from "../internal/result/misc.mjs";
 //#region src/plan/generate.ts
-async function asyncGenerate(callback, parameters) {
-	const generator = callback(...parameters);
+async function asyncGenerate(input, parameters, unwrap) {
+	let generator;
+	if (typeof input === "function") generator = input(...parameters);
+	else generator = input.generator(...parameters);
 	let success = true;
 	let lastValue;
 	try {
 		while (true) {
 			const next = await generator.next(lastValue);
-			const { done } = next;
-			let { value } = next;
+			const done = next.done === true;
+			const { value } = next;
 			if (value instanceof Error) throw value;
 			if (isError(value)) throw value.error;
 			lastValue = value;
@@ -18,13 +20,15 @@ async function asyncGenerate(callback, parameters) {
 		lastValue = error;
 		success = false;
 	} finally {
-		await generator?.return(lastValue);
+		await generator.return(lastValue);
 	}
-	if (success) return lastValue;
+	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
-function generate(callback, parameters) {
-	const generator = callback(...parameters);
+function generate(input, parameters, unwrap) {
+	let generator;
+	if (typeof input === "function") generator = input(...parameters);
+	else generator = input.generator(...parameters);
 	let success = true;
 	let lastValue;
 	try {
@@ -43,7 +47,7 @@ function generate(callback, parameters) {
 	} finally {
 		generator.return(lastValue);
 	}
-	if (success) return lastValue;
+	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
 //#endregion

package/dist/plan/index.d.mts

@@ -1,4 +1,4 @@
-import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, Plan } from "../models/plan.model.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 import { asyncRun, run } from "./run.mjs";
 //#region src/plan/index.d.ts

package/dist/plan/index.mjs

@@ -1,5 +1,5 @@
-import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
-import { isAsyncGenerator, isGenerator } from "../internal/plan.mjs";
+import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../models/plan.model.mjs";
+import { isAsyncGenerator, isGenerator } from "./is.mjs";
 import { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan } from "./result.mjs";
 import { asyncRun, run, runAsyncPlan, runPlan } from "./run.mjs";
 //#region src/plan/index.ts

package/dist/plan/is.d.mts

@@ -1,2 +1,31 @@
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
-export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };
+import { AsyncPlan, Plan } from "../models/plan.model.mjs";
+//#region src/plan/is.d.ts
+/**
+ * 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 an asynchronous plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous plan, otherwise `false`
+ */
+export declare function isAsyncPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is AsyncPlan<Yielded, Returned, Parameters>;
+/**
+ * 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<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is Plan<Yielded, Returned, Parameters>;
+//#endregion

package/dist/plan/is.mjs

@@ -1,2 +1,46 @@
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../models/plan.model.mjs";
+//#region src/plan/is.ts
+/**
+* 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 isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
+}
+/**
+* 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 a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGenerator(value) {
+	return isGeneratorInstance(GENERATOR_NAME_SYNC, value);
+}
+function isGeneratorInstance(name, value) {
+	return typeof value === "function" && value !== null && value.constructor.name === name && 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;
+}
+//#endregion
 export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };

package/dist/plan/misc.d.mts

@@ -1,2 +1,21 @@
-import { fail, succeed } from "../internal/plan.mjs";
-export { fail, succeed };
+import { Ok } from "../models/result.model.mjs";
+//#region src/plan/misc.d.ts
+/**
+ * Create an immediately failing plan
+ *
+ * @param reason Failure reason
+ * @returns Plan failure
+ */
+export declare function fail<Reason>(reason: Reason): Generator<Reason, void>;
+/**
+ * Create an immediately succeeding plan
+ *
+ * @param value Success value
+ * @returns Plan success
+ */
+export declare function succeed<Value>(value: Value): Generator<never, Value>;
+export declare function succeedResult<Returned>(value: Returned): Generator<never, Ok<Returned>>;
+export declare namespace succeed {
+  export var result: typeof succeedResult;
+}
+//#endregion

package/dist/plan/misc.mjs

@@ -1,2 +1,32 @@
-import { fail, succeed } from "../internal/plan.mjs";
-export { fail, succeed };
+import { ok } from "../internal/result/misc.mjs";
+//#region src/plan/misc.ts
+/**
+* Create an immediately failing plan
+*
+* @param reason Failure reason
+* @returns Plan failure
+*/
+function fail(reason) {
+	return (function* () {
+		throw reason;
+	})();
+}
+/**
+* Create an immediately succeeding plan
+*
+* @param value Success value
+* @returns Plan success
+*/
+function succeed(value) {
+	return (function* () {
+		return value;
+	})();
+}
+function succeedResult(value) {
+	return (function* () {
+		return ok(value);
+	})();
+}
+succeed.result = succeedResult;
+//#endregion
+export { fail, succeed, succeedResult };

package/dist/plan/models.d.mts

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

package/dist/plan/result.d.mts

@@ -1,5 +1,5 @@
-import { Result } from "../internal/models/result.model.mjs";
-import { AsyncPlan, InternalPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+import { Result } from "../models/result.model.mjs";
+import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanOk } from "../models/plan.model.mjs";
 //#region src/plan/result.d.ts
 /**
  * Attempt to run the generator to completion
@@ -8,7 +8,7 @@ import { AsyncPlan, InternalPlan, Plan, PlanError, PlanResult } from "../interna
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -16,7 +16,7 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the generator to completion
  *
@@ -24,7 +24,7 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * @returns Result
  */
-export declare function attemptRun<Yielded, Returned>(generator: () => Generator<Yielded, Returned, unknown>, ...parameters: Parameters<typeof generator>): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -32,8 +32,8 @@ export declare function attemptRun<Yielded, Returned>(generator: () => Generator
  *
  * @returns Result
  */
-export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
-export declare function attemptRunAsyncPlan(this: InternalPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRunAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
 export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace attemptRun {
   export var async: typeof asyncAttemptRun;

package/dist/plan/result.mjs

@@ -1,23 +1,23 @@
 import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
-import { PLAN_MESSAGE_RUN_INPUT } from "../internal/models/plan.model.mjs";
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.mjs";
 import { asyncGenerate, generate } from "./generate.mjs";
 //#region src/plan/result.ts
 function asyncAttemptRun(input, ...parameters) {
 	if (isAsyncPlan(input)) return input.attempt(...parameters);
-	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters));
+	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters, true));
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function attemptRun(input, ...parameters) {
 	if (isPlan(input)) return input.attempt(...parameters);
-	if (isGenerator(input)) return attempt(() => generate(input, parameters));
+	if (isGenerator(input)) return attempt(() => generate(input, parameters, true));
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function attemptRunAsyncPlan(...parameters) {
-	return asyncAttempt(() => this.run(...parameters));
+	return asyncAttempt(() => asyncGenerate(this[PLAN_SYMBOL], parameters, true));
 }
 function attemptRunPlan(...parameters) {
-	return attempt(() => this.run(...parameters));
+	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
 }
 attemptRun.async = asyncAttemptRun;
 //#endregion

package/dist/plan/run.d.mts

@@ -1,4 +1,4 @@
-import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanReturned } from "../models/plan.model.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 //#region src/plan/run.d.ts
 /**
@@ -7,28 +7,28 @@ import { asyncAttemptRun, attemptRun } from "./result.mjs";
  * @param generator Generator to run
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
 /**
  * Run a generator to completion
  *
  * @param generator Generator to run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned, unknown>, ...parameters: Parameters): PlanResult<Returned> | PlanError<Yielded, Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlanReturned<Returned>;
 /**
  * Run a plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanResult<Returned> | PlanError<Yielded, Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
 export declare function runAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
 export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace asyncRun {