@oscarpalmer/atoms 0.210.0 → 0.212.0

package/dist/plan/generate.mjs

@@ -0,0 +1,50 @@
+import { isError } from "../internal/result/misc.mjs";
+//#region src/plan/generate.ts
+async function asyncGenerate(callback, parameters) {
+	const generator = callback(...parameters);
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = await generator.next(lastValue);
+			const { done } = next;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done === true) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		await generator?.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+function generate(callback, parameters) {
+	const generator = callback(...parameters);
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = generator.next(lastValue);
+			const done = next.done === true;
+			const { value } = next;
+			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+//#endregion
+export { asyncGenerate, generate };

package/dist/plan/index.d.mts

@@ -1,4 +1,6 @@
-import { AsyncPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+import { asyncAttemptRun, attemptRun } from "./result.mjs";
+import { asyncRun, run } from "./run.mjs";
 //#region src/plan/index.d.ts
 /**
  * Create a plan for an asynchronous generator function
@@ -6,40 +8,13 @@ import { AsyncPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.
  * @param generator Generator to plan for
  * @returns Generator plan
  */
-export declare function plan<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned>;
+export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned, Parameters>;
 /**
  * Create a plan for a generator function
  *
  * @param generator Generator to plan for
  * @returns Generator plan
  */
-export declare function plan<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): Plan<Yielded, Returned>;
-/**
- * Run an asynchronous generator to completion
- *
- * @param generator Generator to run
- * @returns Result
- */
-export declare function run<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
-/**
- * Run an asynchronous plan to completion
- *
- * @param plan Plan to run
- * @returns Result
- */
-export declare function run<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
-/**
- * Run a generator to completion
- *
- * @param generator Generator to run
- * @returns Result
- */
-export declare function run<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): PlanResult<Returned> | PlanError<Yielded, Returned>;
-/**
- * Run a plan to completion
- *
- * @param plan Plan to run
- * @returns Result
- */
-export declare function run<Yielded, Returned>(plan: Plan<Yielded, Returned>): PlanResult<Returned> | PlanError<Yielded, Returned>;
-//#endregion
+export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>): Plan<Yielded, Returned, Parameters>;
+//#endregion
+export { asyncAttemptRun, asyncRun, attemptRun, run };

package/dist/plan/index.mjs

@@ -1,5 +1,7 @@
-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";
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+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 { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan } from "./result.mjs";
+import { asyncRun, run, runAsyncPlan, runPlan } from "./run.mjs";
 //#region src/plan/index.ts
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
@@ -10,6 +12,7 @@ function AsyncPlan(generator) {
 AsyncPlan.prototype[Symbol.asyncIterator] = function() {
 	return this[PLAN_SYMBOL].generator();
 };
+AsyncPlan.prototype.attempt = attemptRunAsyncPlan;
 AsyncPlan.prototype.run = runAsyncPlan;
 function Plan(generator) {
 	this[PLAN_SYMBOL] = {
@@ -20,67 +23,12 @@ function Plan(generator) {
 Plan.prototype[Symbol.iterator] = function() {
 	return this[PLAN_SYMBOL].generator();
 };
+Plan.prototype.attempt = attemptRunPlan;
 Plan.prototype.run = runPlan;
-async function asyncExecute(callback) {
-	const generator = callback();
-	let success = true;
-	let lastValue;
-	try {
-		while (true) {
-			const next = await generator.next(lastValue);
-			const { done } = next;
-			let { value } = next;
-			if (value instanceof Error) throw value;
-			lastValue = value;
-			if (done === true) break;
-		}
-	} catch (error) {
-		lastValue = error;
-		success = false;
-	} finally {
-		generator?.return(lastValue);
-	}
-	if (success) return lastValue;
-	throw lastValue;
-}
-function execute(callback) {
-	const generator = callback();
-	let success = true;
-	let lastValue;
-	try {
-		while (true) {
-			const next = generator.next(lastValue);
-			const done = next.done === true;
-			let { value } = next;
-			if (value instanceof Error) throw value;
-			lastValue = value;
-			if (done) break;
-		}
-	} catch (error) {
-		lastValue = error;
-		success = false;
-	} finally {
-		generator.return(lastValue);
-	}
-	if (success) return lastValue;
-	throw lastValue;
-}
 function plan(generator) {
 	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
 	if (isGenerator(generator)) return new Plan(generator);
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
-function run(input) {
-	if (isAsyncPlan(input) || isPlan(input)) return input.run();
-	if (isAsyncGenerator(input)) return asyncExecute(input);
-	if (isGenerator(input)) return execute(input);
-	throw new Error(PLAN_MESSAGE_RUN_INPUT);
-}
-function runAsyncPlan() {
-	return asyncExecute(this[PLAN_SYMBOL].generator);
-}
-function runPlan() {
-	return execute(this[PLAN_SYMBOL].generator);
-}
 //#endregion
-export { plan, run };
+export { asyncAttemptRun, asyncRun, attemptRun, plan, run };

package/dist/plan/result.d.mts

@@ -0,0 +1,41 @@
+import { Result } from "../internal/models/result.model.mjs";
+import { AsyncPlan, InternalPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+//#region src/plan/result.d.ts
+/**
+ * Attempt to run the generator to completion
+ *
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @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>>>;
+/**
+ * Attempt to run the plan to completion
+ *
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @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>>>;
+/**
+ * Attempt to run the generator to completion
+ *
+ * _Returns a {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Result
+ */
+export declare function attemptRun<Yielded, Returned>(generator: () => Generator<Yielded, Returned, unknown>, ...parameters: Parameters<typeof generator>): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+/**
+ * Attempt to run the plan to completion
+ *
+ * _Returns a {@link Result} instead of a raw value or throwing an error_
+ *
+ * @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 attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+export declare namespace attemptRun {
+  export var async: typeof asyncAttemptRun;
+}
+//#endregion

package/dist/plan/result.mjs

@@ -0,0 +1,24 @@
+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 { 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));
+	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));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function attemptRunAsyncPlan(...parameters) {
+	return asyncAttempt(() => this.run(...parameters));
+}
+function attemptRunPlan(...parameters) {
+	return attempt(() => this.run(...parameters));
+}
+attemptRun.async = asyncAttemptRun;
+//#endregion
+export { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan };

package/dist/plan/run.d.mts

@@ -0,0 +1,41 @@
+import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+import { asyncAttemptRun, attemptRun } from "./result.mjs";
+//#region src/plan/run.d.ts
+/**
+ * Run an asynchronous generator to completion
+ *
+ * @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>>;
+/**
+ * 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>>;
+/**
+ * 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>;
+/**
+ * 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 runAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+export declare namespace asyncRun {
+  export var attempt: typeof asyncAttemptRun;
+}
+export declare namespace run {
+  export var async: typeof asyncRun;
+  export var attempt: typeof attemptRun;
+}
+//#endregion

package/dist/plan/run.mjs

@@ -0,0 +1,26 @@
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { asyncGenerate, generate } from "./generate.mjs";
+import { asyncAttemptRun, attemptRun } from "./result.mjs";
+//#region src/plan/run.ts
+function asyncRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.run(...parameters);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function run(input, ...parameters) {
+	if (isPlan(input)) return input.run(...parameters);
+	if (isGenerator(input)) return generate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function runAsyncPlan(...parameters) {
+	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL].generator, parameters);
+}
+asyncRun.attempt = asyncAttemptRun;
+run.async = asyncRun;
+run.attempt = attemptRun;
+//#endregion
+export { asyncRun, run, runAsyncPlan, runPlan };

package/dist/promise/models.d.mts

@@ -34,8 +34,8 @@ export type PromiseData = {
   result: ArrayOrPlainObject;
 };
 export type PromiseHandlers = {
-  resolve: (value: unknown[]) => void;
-  reject: (reason: unknown) => void;
+  resolve(value: unknown[]): void;
+  reject(reason: unknown): void;
 };
 /**
  * Options for a _Promise_-handling function

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.210.0",
+	"version": "0.212.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",