@oscarpalmer/atoms 0.209.0 → 0.211.0

package/dist/plan/index.d.mts

@@ -1,5 +1,6 @@
-import { Result } from "../internal/models/result.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
@@ -7,74 +8,13 @@ import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
  * @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>;
+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<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
+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,7 +1,7 @@
-import { isError, isOk } from "../internal/result/misc.mjs";
-import "../result/misc.mjs";
-import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
-import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, 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 { 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] = {
@@ -12,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] = {
@@ -22,120 +23,12 @@ function Plan(generator) {
 Plan.prototype[Symbol.iterator] = function() {
 	return this[PLAN_SYMBOL].generator();
 };
+Plan.prototype.attempt = attemptRunPlan;
 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;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.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;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.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 isGeneratorInstance(GENERATOR_NAME_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;
-}
-/**
-* 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);
+	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
+	if (isGenerator(generator)) return new Plan(generator);
+	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
-plan.async = asyncPlan;
-run.async = asyncRun;
 //#endregion
-export { asyncPlan, asyncRun, isAsyncGenerator, isAsyncPlan, isGenerator, isPlan, plan, run };
+export { asyncAttemptRun, asyncRun, attemptRun, plan, run };

package/dist/plan/is.d.mts

@@ -0,0 +1,2 @@
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };

package/dist/plan/is.mjs

@@ -0,0 +1,2 @@
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };

package/dist/plan/misc.d.mts

@@ -0,0 +1,2 @@
+import { fail, succeed } from "../internal/plan.mjs";
+export { fail, succeed };

package/dist/plan/misc.mjs

@@ -0,0 +1,2 @@
+import { fail, succeed } from "../internal/plan.mjs";
+export { fail, succeed };

package/dist/plan/models.d.mts

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

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.209.0",
+	"version": "0.211.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -153,6 +153,14 @@
 			"types": "./dist/plan/index.d.mts",
 			"default": "./dist/plan/index.mjs"
 		},
+		"./plan/is": {
+			"types": "./dist/plan/is.d.mts",
+			"default": "./dist/plan/is.mjs"
+		},
+		"./plan/misc": {
+			"types": "./dist/plan/misc.d.mts",
+			"default": "./dist/plan/misc.mjs"
+		},
 		"./plan/models": {
 			"default": "./dist/plan/models.mjs"
 		},
@@ -297,7 +305,7 @@
 	"devDependencies": {
 		"@types/node": "^26.6",
 		"@vitest/coverage-istanbul": "5.0.1",
-		"eslint": "^10.11",
+		"eslint": "^10.12",
 		"jsdom": "^30.1",
 		"tsdown": "^0.23",
 		"typescript": "^7",