@oscarpalmer/atoms 0.216.0 → 0.217.0

package/dist/plan/misc.mjs

@@ -1,39 +1,56 @@
 import { error } from "../internal/result/misc.mjs";
-import { PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { getGenerator } from "../internal/plan/index.mjs";
 //#region src/plan/misc.ts
-function PlanFailure(generator) {
-	this[PLAN_SYMBOL] = { generator };
-}
-PlanFailure.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-function PlanSuccess(generator) {
-	this[PLAN_SYMBOL] = { generator };
-}
-PlanSuccess.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-/**
-* Create an immediately failing plan
-*
-* @param value Failure value
-* @returns Plan failure
-*/
+function AsyncFailure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_ASYNC
+	};
+}
+AsyncFailure.prototype[Symbol.asyncIterator] = getGenerator;
+function AsyncSuccess(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_ASYNC
+	};
+}
+AsyncSuccess.prototype[Symbol.asyncIterator] = getGenerator;
+function Failure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_SYNC
+	};
+}
+Failure.prototype[Symbol.iterator] = getGenerator;
+function Success(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_SYNC
+	};
+}
+Success.prototype[Symbol.iterator] = getGenerator;
+function asyncFail(value) {
+	return new AsyncFailure(async function* () {
+		yield error(await (typeof value === "function" ? value() : value));
+	});
+}
+function asyncSucceed(value) {
+	return new AsyncSuccess(async function* () {
+		return typeof value === "function" ? value() : value;
+	});
+}
 function fail(value) {
-	return new PlanFailure(function* () {
-		yield error(value);
+	return new Failure(function* () {
+		yield error(typeof value === "function" ? value() : value);
 	});
 }
-/**
-* Create an immediately succeeding plan
-*
-* @param value Success value
-* @returns Plan success
-*/
 function succeed(value) {
-	return new PlanSuccess(function* () {
-		return value;
+	return new Success(function* () {
+		return typeof value === "function" ? value() : value;
 	});
 }
+fail.async = asyncFail;
+succeed.async = asyncSucceed;
 //#endregion
-export { fail, succeed };
+export { asyncFail, asyncSucceed, fail, succeed };

package/dist/plan/models.d.mts

@@ -1,2 +1,2 @@
-import { AsyncPlan, Plan, PlanFailure, PlanResult, PlanSuccess } from "../models/plan.model.mjs";
-export type { AsyncPlan, Plan, PlanFailure, PlanResult, PlanSuccess };
+import { AsyncFailure, AsyncPlan, AsyncPlanned, AsyncStep, AsyncSuccess, Failure, Plan, PlanError, PlanOk, PlanReturned, Planned, Step, Success } from "../models/plan.model.mjs";
+export type { AsyncFailure, AsyncPlan, AsyncPlanned, AsyncStep, AsyncSuccess, Failure, Plan, PlanError, PlanOk, PlanReturned, Planned, Step, Success };

package/dist/plan/result.d.mts

@@ -1,11 +1,14 @@
 import { Result } from "../models/result.model.mjs";
-import { AsyncPlan, InternalPlan, Plan, PlanError, PlanOk } from "../models/plan.model.mjs";
+import { AsyncPlan, Plan, PlanError, PlanOk } from "../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_
  *
+ * @param generator Generator to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -14,6 +17,8 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * _Returns a promised {@link Result} instead of a raw value or throwing an error_
  *
+ * @param generator Generator to run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -22,6 +27,9 @@ export declare function asyncAttemptRun<Yielded, Returned>(generator: () => Asyn
  *
  * _Returns a promised {@link Result} instead of a raw value or throwing an error_
  *
+ * @param plan Plan to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -30,6 +38,8 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * _Returns a promised {@link Result} instead of a raw value or throwing an error_
  *
+ * @param plan Plan to run
+ * @param signal Optional abort signal
  * @returns Promised result
  */
 export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
@@ -38,6 +48,8 @@ export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yield
  *
  * _Returns a {@link Result} instead of a raw value or throwing an error_
  *
+ * @param generator Generator to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
@@ -46,11 +58,11 @@ export declare function attemptRun<Yielded, Returned, Parameters extends unknown
  *
  * _Returns a {@link Result} instead of a raw value or throwing an error_
  *
+ * @param plan Plan to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 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: never, first: never, second: never): 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,28 +1,22 @@
 import { asyncAttempt, attempt } from "../internal/result/attempt.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";
+import { asyncGenerate, generate } from "../internal/plan/plan.generate.mjs";
+import { isAsyncGeneratorFunction, isAsyncPlan, isGeneratorFunction, isPlan } from "./is.mjs";
 //#region src/plan/result.ts
 function asyncAttemptRun(input, first, second) {
 	let generator;
 	if (isAsyncPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isAsyncGenerator(input)) generator = input;
+	else if (isAsyncGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return asyncAttempt(() => asyncGenerate(generator, true, first, second));
 }
 function attemptRun(input, ...parameters) {
 	let generator;
 	if (isPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isGenerator(input)) generator = input;
+	else if (isGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return attempt(() => generate(generator, parameters, true));
 }
-function attemptRunAsyncPlan(first, second) {
-	return asyncAttemptRun(this, first, second);
-}
-function attemptRunPlan(...parameters) {
-	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
-}
 attemptRun.async = asyncAttemptRun;
 //#endregion
-export { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan };
+export { asyncAttemptRun, attemptRun };

package/dist/plan/run.d.mts

@@ -1,4 +1,4 @@
-import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanReturned } from "../models/plan.model.mjs";
+import { AsyncPlan, Plan, PlanReturned } from "../models/plan.model.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 //#region src/plan/run.d.ts
 /**
@@ -51,8 +51,6 @@ export declare function run<Yielded, Returned, Parameters extends unknown[]>(gen
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
-export declare function runAsyncPlan(this: InternalAsyncPlan, first: never, second: never): Promise<unknown>;
-export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;
 }

package/dist/plan/run.mjs

@@ -1,26 +1,20 @@
 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";
+import { asyncGenerate, generate } from "../internal/plan/plan.generate.mjs";
+import { isAsyncGeneratorFunction, isAsyncPlan, isGeneratorFunction, isPlan } from "./is.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 //#region src/plan/run.ts
 function asyncRun(input, first, second) {
 	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
-	if (isAsyncGenerator(input)) return asyncGenerate(input, false, first, second);
+	if (isAsyncGeneratorFunction(input)) return asyncGenerate(input, false, first, second);
 	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, false);
+	if (isGeneratorFunction(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runAsyncPlan(first, second) {
-	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
-}
-function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL], parameters, false);
-}
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;
 run.attempt = attemptRun;
 //#endregion
-export { asyncRun, run, runAsyncPlan, runPlan };
+export { asyncRun, run };

package/dist/plan/use.d.mts

@@ -0,0 +1,36 @@
+import { AsyncStep, AsyncStepValue, Step, StepValue } from "../models/plan.model.mjs";
+//#region src/plan/use.d.ts
+/**
+ * Create an asynchronous step from a callback
+ *
+ * @param callback Callback
+ * @returns An asynchronous step
+ */
+export declare function asyncUse<Value>(callback: () => Value & AsyncStepValue<Value>): AsyncStep<Value>;
+/**
+ * Create an asynchronous step from a value
+ *
+ * @param value Value
+ * @returns An asynchronous step
+ */
+export declare function asyncUse<Value>(value: Value & AsyncStepValue<Value>): AsyncStep<Value>;
+/**
+ * Create a step from a callback
+ *
+ * @param callback Callback
+ * @returns A step
+ * @throws Error If the input is invalid
+ */
+export declare function use<Value>(callback: () => Value & StepValue<Value>): Step<Value>;
+/**
+ * Create a step from a value
+ *
+ * @param value Value
+ * @returns A step
+ * @throws Error If the input is invalid
+ */
+export declare function use<Value>(value: Value & StepValue<Value>): Step<Value>;
+export declare namespace use {
+  export var async: typeof asyncUse;
+}
+//#endregion

package/dist/plan/use.mjs

@@ -0,0 +1,69 @@
+import { isError, isOk } from "../internal/result/misc.mjs";
+import { PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { getGenerator } from "../internal/plan/index.mjs";
+import { isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncPlan, isAsyncStep, isAsyncSuccess, isGenerator } from "./is.mjs";
+import { fail } from "./misc.mjs";
+//#region src/plan/use.ts
+function AsyncStep(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_ASYNC
+	};
+}
+AsyncStep.prototype[Symbol.asyncIterator] = getGenerator;
+function Step(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_SYNC
+	};
+}
+Step.prototype[Symbol.iterator] = getGenerator;
+function asyncUse(value) {
+	return new AsyncStep(async function* () {
+		let actual = value;
+		if (typeof actual === "function") actual = actual();
+		actual = await actual;
+		if (typeof actual === "function") throw new Error();
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isAsyncGenerator(actual) || isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
+	});
+}
+function use(value) {
+	validateUseInput(value, false);
+	return new Step(function* () {
+		let actual = value;
+		if (typeof actual === "function") {
+			actual = actual();
+			validateUseInput(actual, true);
+		}
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
+	});
+}
+function validateUseInput(value, resolved) {
+	if (value instanceof Promise || isAsyncFailure(value) || isAsyncGenerator(value) || isAsyncGeneratorFunction(value) || isAsyncPlan(value) || isAsyncStep(value) || isAsyncSuccess(value)) throw new Error();
+	if (resolved && typeof value === "function") throw new Error();
+}
+use.async = asyncUse;
+//#endregion
+export { asyncUse, use };

package/dist/promise/models.mjs

@@ -1,2 +1 @@
-import { CancelablePromise, PromiseTimeoutError } from "../models/promise.model.mjs";
-export { CancelablePromise, PromiseTimeoutError };
+export { CancelablePromise, PromiseTimeoutError } from "../models/promise.model.mjs";

package/dist/result/index.mjs

@@ -1,2 +1 @@
-import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
-export { asyncAttempt, attempt };
+export { asyncAttempt, attempt } from "../internal/result/attempt.mjs";

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

@@ -181,4 +181,5 @@ export declare function attemptPipe<Initial>(initial: GenericCallback | Initial
 export declare namespace attemptPipe {
   export var async: typeof attemptAsyncPipe;
 }
-//#endregion
+//#endregion
+export {};

package/dist/subscription.mjs

@@ -1,2 +1 @@
-import { isSubscription, isSubscriptions, subscriptions } from "./internal/subscription.mjs";
-export { isSubscription, isSubscriptions, subscriptions };
+export { isSubscription, isSubscriptions, subscriptions } from "./internal/subscription.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.216.0",
+	"version": "0.217.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -173,6 +173,10 @@
 			"types": "./dist/plan/run.d.mts",
 			"default": "./dist/plan/run.mjs"
 		},
+		"./plan/use": {
+			"types": "./dist/plan/use.d.mts",
+			"default": "./dist/plan/use.mjs"
+		},
 		"./promise": {
 			"types": "./dist/promise/index.d.mts",
 			"default": "./dist/promise/index.mjs"
@@ -313,18 +317,12 @@
 	},
 	"devDependencies": {
 		"@types/node": "^26.6",
-		"@vitest/coverage-istanbul": "5.0.1",
-		"eslint": "^10.12",
+		"@vitest/coverage-istanbul": "^5",
+		"eslint": "^10.13",
 		"jsdom": "^30.1",
 		"tsdown": "^0.23",
 		"typescript": "^7",
-		"vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
-		"vite-plus": "1.0.0",
-		"vitest": "5.0.1"
-	},
-	"overrides": {
-		"vite": "npm:@voidzero-dev/vite-plus-core@1.0.0",
-		"vitest": "5.0.1"
+		"vite-plus": "^1.2"
 	},
 	"packageManager": "npm@11.11.1"
 }