@systemfsoftware/xstate-effect 0.0.0-bootstrap.0 → 0.1.0-beta.8

package/dist/index.mjs

@@ -0,0 +1,429 @@
+import { a as startHostedEffect, c as withActorScope, d as EffectInterruptedError, i as runHostedEffect, l as ActorFailedError, n as createEffectActor, o as EffectActor, r as relayToParent, s as ActorScope, t as taggedState, u as ActorStoppedError } from "./state-CNrCEIpU.mjs";
+import { Cause, Effect, Exit, Queue, Schema, Stream } from "effect";
+import { dual } from "effect/Function";
+import { createLogic, setup } from "@systemfsoftware/xstate";
+// src/actor.ts
+const noopSubscription = { unsubscribe: () => {} };
+function actorId(actor) {
+	return actor.id ?? "(unknown)";
+}
+/**
+* Marks an already-errored actor's error as observed, so XState does not
+* report it as unhandled: the caller consumes it as a typed failure.
+*/
+function observeError(actor) {
+	actor.subscribe({ error: () => {} }).unsubscribe();
+}
+function stoppedError(actor) {
+	return new ActorStoppedError({
+		actorId: actorId(actor),
+		snapshot: actor.getSnapshot()
+	});
+}
+function isActorRef(value) {
+	return typeof value === "object" && value !== null && typeof value.send === "function" && typeof value.getSnapshot === "function";
+}
+/**
+* Sends an event to an actor. The returned Effect always succeeds: the event
+* is enqueued, like `actor.send(event)`, and processed on the actor's own
+* fiber. An event that cannot be delivered (for example to a stopped actor)
+* is reported as a dead letter, observable with {@link deadLetters}.
+*/
+const send = dual(2, (actor, event) => Effect.sync(() => {
+	actor.send(event);
+}));
+/**
+* Streams an actor's snapshots, starting with the current one. The stream ends
+* when the actor completes or stops, and emits the error snapshot before
+* ending when the actor errors. Interrupting the stream unsubscribes from the
+* actor.
+*/
+function snapshots(actor) {
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const current = actor.getSnapshot();
+		Queue.offerUnsafe(queue, current);
+		if (current.status !== "active") {
+			observeError(actor);
+			Queue.endUnsafe(queue);
+			return noopSubscription;
+		}
+		return actor.subscribe({
+			next: (snapshot) => {
+				Queue.offerUnsafe(queue, snapshot);
+			},
+			error: () => {
+				Queue.offerUnsafe(queue, actor.getSnapshot());
+				Queue.endUnsafe(queue);
+			},
+			complete: () => {
+				Queue.endUnsafe(queue);
+			}
+		});
+	}), (subscription) => Effect.sync(() => {
+		subscription.unsubscribe();
+	})));
+}
+/**
+* Streams every event an actor emits, as delivered to `actor.on('*', …)`. The
+* stream ends when the actor completes, errors or stops. Interrupting the
+* stream removes the listener.
+*/
+function emitted(actor) {
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const listener = actor.on("*", (event) => {
+			Queue.offerUnsafe(queue, event);
+		});
+		if (actor.getSnapshot().status !== "active") {
+			Queue.endUnsafe(queue);
+			return [listener, noopSubscription];
+		}
+		return [listener, actor.subscribe({
+			error: () => {
+				Queue.endUnsafe(queue);
+			},
+			complete: () => {
+				Queue.endUnsafe(queue);
+			}
+		})];
+	}), ([listener, subscription]) => Effect.sync(() => {
+		listener.unsubscribe();
+		subscription.unsubscribe();
+	})));
+}
+/**
+* Waits for the first actor snapshot that satisfies `predicate`, succeeding
+* immediately when the current snapshot already does. Fails with
+* `ActorStoppedError` if the actor stops or errors first, and with
+* `Cause.TimeoutError` when `options.timeout` elapses. Interrupting the Effect
+* unsubscribes from the actor.
+*/
+const waitFor = dual((args) => isActorRef(args[0]), (actor, predicate, options) => {
+	const waiting = Effect.callback((resume) => {
+		const current = actor.getSnapshot();
+		if (predicate(current)) {
+			resume(Effect.succeed(current));
+			return;
+		}
+		if (current.status !== "active") {
+			observeError(actor);
+			resume(Effect.fail(stoppedError(actor)));
+			return;
+		}
+		let settled = false;
+		let subscription;
+		const dispose = () => {
+			settled = true;
+			subscription?.unsubscribe();
+		};
+		subscription = actor.subscribe({
+			next: (snapshot) => {
+				if (settled || !predicate(snapshot)) return;
+				dispose();
+				resume(Effect.succeed(snapshot));
+			},
+			error: () => {
+				if (settled) return;
+				dispose();
+				resume(Effect.fail(stoppedError(actor)));
+			},
+			complete: () => {
+				if (settled) return;
+				dispose();
+				resume(Effect.fail(stoppedError(actor)));
+			}
+		});
+		if (settled) subscription.unsubscribe();
+		return Effect.sync(dispose);
+	});
+	return options === void 0 ? waiting : Effect.timeout(waiting, options.timeout);
+});
+/**
+* Joins an actor's final result, like `Fiber.join`: succeeds with its `output`
+* when it is done, fails with `ActorFailedError` carrying `snapshot.error` when
+* it errors, and fails with `ActorStoppedError` when it stops without output.
+* Waits for a still-active actor to settle.
+*/
+function join(actor) {
+	return Effect.callback((resume) => {
+		const settle = () => {
+			const snapshot = actor.getSnapshot();
+			if (snapshot.status === "done") resume(Effect.succeed(snapshot.output));
+			else if (snapshot.status === "error") resume(Effect.fail(new ActorFailedError({ cause: snapshot.error })));
+			else resume(Effect.fail(stoppedError(actor)));
+		};
+		if (actor.getSnapshot().status !== "active") {
+			observeError(actor);
+			settle();
+			return;
+		}
+		let settled = false;
+		let subscription;
+		const dispose = () => {
+			settled = true;
+			subscription?.unsubscribe();
+		};
+		const onSettled = () => {
+			if (settled) return;
+			dispose();
+			settle();
+		};
+		subscription = actor.subscribe({
+			error: onSettled,
+			complete: onSettled
+		});
+		if (settled) subscription.unsubscribe();
+		return Effect.sync(dispose);
+	});
+}
+/**
+* Streams the inspection events of the actor's system, as delivered to
+* `system.inspect(…)`. The stream runs until it is interrupted or its scope
+* closes.
+*/
+function inspect(actor) {
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+		const observer = (inspectionEvent) => {
+			Queue.offerUnsafe(queue, inspectionEvent);
+		};
+		const inspectable = actor;
+		return inspectable.inspect !== void 0 ? inspectable.inspect(observer) : actor.system.inspect(observer);
+	}), (subscription) => Effect.sync(() => {
+		subscription.unsubscribe();
+	})));
+}
+/**
+* Streams the events the actor's system could not deliver, as reported by
+* `system.onRejectedEvent`: sends to a stopped actor, invalid external
+* events and internal events sent from outside their owner. A dead letter is
+* not an actor error. The stream runs until it is interrupted or its scope
+* closes.
+*/
+function deadLetters(actor) {
+	return Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => actor.system.onRejectedEvent((rejection) => {
+		Queue.offerUnsafe(queue, rejection);
+	})), (subscription) => Effect.sync(() => {
+		subscription.unsubscribe();
+	})));
+}
+// src/schema.ts
+function isStandardSchema(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && "~standard" in value;
+}
+function toStandardSchema(schema) {
+	if (Schema.isSchema(schema)) return Schema.toStandardSchemaV1(schema);
+	return schema;
+}
+function mapSchemaRecord(value) {
+	return Object.fromEntries(Object.keys(value).map((key) => {
+		const entry = value[key];
+		if (Schema.isSchema(entry) || isStandardSchema(entry)) return [key, toStandardSchema(entry)];
+		if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) return [key, mapSchemaRecord(entry)];
+		return [key, entry];
+	}));
+}
+function toStandardSetupSchemas(schemas) {
+	return schemas !== void 0 ? mapSchemaRecord(schemas) : void 0;
+}
+function toStandardSetupStates(states) {
+	if (states === void 0) return;
+	return Object.fromEntries(Object.entries(states).map(([key, state]) => [key, {
+		...state,
+		...state.schemas !== void 0 ? { schemas: mapSchemaRecord(state.schemas) } : void 0,
+		...state.states !== void 0 ? { states: toStandardSetupStates(state.states) } : void 0
+	}]));
+}
+// src/fromEffect.ts
+const EFFECT_INIT = "@xstate.init";
+const EFFECT_RESOLVE = "xstate.effect.resolve";
+const EFFECT_REJECT = "xstate.effect.reject";
+const EFFECT_NEXT = "xstate.effect.next";
+const EFFECT_COMPLETE = "xstate.effect.complete";
+const effectLogicBrand = Symbol.for("@xstate/effect/logic");
+function toError(exit) {
+	if (Exit.isSuccess(exit)) return;
+	if (Cause.hasInterruptsOnly(exit.cause)) return new EffectInterruptedError({ cause: exit.cause });
+	return Cause.squash(exit.cause);
+}
+function createSourceArgs(input, self, system) {
+	return {
+		input,
+		self,
+		system,
+		emit: (event) => {
+			system.emitEvent(self, event);
+		}
+	};
+}
+function brandLogic(logic, error, requirements) {
+	Object.defineProperty(logic, effectLogicBrand, {
+		configurable: false,
+		enumerable: false,
+		value: {
+			error,
+			requirements
+		}
+	});
+	return logic;
+}
+function fromEffect(sourceOrConfig) {
+	const config = typeof sourceOrConfig === "function" || Effect.isEffect(sourceOrConfig) ? { effect: sourceOrConfig } : sourceOrConfig;
+	const source = config.effect;
+	const schemas = config.schemas !== void 0 ? {
+		...config.schemas.input !== void 0 ? { input: toStandardSchema(config.schemas.input) } : {},
+		...config.schemas.output !== void 0 ? { output: toStandardSchema(config.schemas.output) } : {}
+	} : void 0;
+	return brandLogic(createLogic({
+		id: config.id,
+		validator: config.validator,
+		schemas,
+		context: void 0,
+		run: ({ event, input, self, system }, enq) => {
+			if (event.type === EFFECT_RESOLVE) return {
+				status: "done",
+				output: event.output,
+				input: void 0
+			};
+			if (event.type === EFFECT_REJECT) return {
+				status: "error",
+				error: event.error,
+				input: void 0
+			};
+			if (event.type !== EFFECT_INIT) return;
+			const effect = typeof source === "function" ? source(createSourceArgs(input, self, system)) : source;
+			enq.effect(() => startHostedEffect(self, Effect.scoped(effect), "fromEffect", (exit) => {
+				if (self.getSnapshot().status !== "active") return;
+				if (Exit.isSuccess(exit)) self.send({
+					type: EFFECT_RESOLVE,
+					output: exit.value
+				});
+				else self.send({
+					type: EFFECT_REJECT,
+					error: toError(exit)
+				});
+			}));
+		}
+	}), void 0, void 0);
+}
+function resolveStreamConfig(sourceOrConfig) {
+	return typeof sourceOrConfig === "function" || Stream.isStream(sourceOrConfig) ? { stream: sourceOrConfig } : sourceOrConfig;
+}
+function toLogicSchemas(schemas) {
+	return schemas?.input !== void 0 ? { input: toStandardSchema(schemas.input) } : void 0;
+}
+function fromEffectStream(sourceOrConfig) {
+	const config = resolveStreamConfig(sourceOrConfig);
+	const stream = config.stream;
+	return brandLogic(createLogic({
+		id: config.id,
+		validator: config.validator,
+		schemas: toLogicSchemas(config.schemas),
+		context: void 0,
+		run: ({ event, input, self, system }, enq) => {
+			if (event.type === EFFECT_NEXT) return { context: event.value };
+			if (event.type === EFFECT_COMPLETE) return {
+				status: "done",
+				input: void 0
+			};
+			if (event.type === EFFECT_REJECT) return {
+				status: "error",
+				error: event.error,
+				input: void 0
+			};
+			if (event.type !== EFFECT_INIT) return;
+			const streamValue = typeof stream === "function" ? stream(createSourceArgs(input, self, system)) : stream;
+			const consume = Stream.runForEach(streamValue, (value) => Effect.sync(() => {
+				if (self.getSnapshot().status === "active") self.send({
+					type: EFFECT_NEXT,
+					value
+				});
+			}));
+			enq.effect(() => startHostedEffect(self, Effect.scoped(consume), "fromEffectStream", (exit) => {
+				if (self.getSnapshot().status !== "active") return;
+				if (Exit.isSuccess(exit)) self.send({ type: EFFECT_COMPLETE });
+				else self.send({
+					type: EFFECT_REJECT,
+					error: toError(exit)
+				});
+			}));
+		}
+	}), void 0, void 0);
+}
+function fromEffectEventStream(sourceOrConfig) {
+	const config = resolveStreamConfig(sourceOrConfig);
+	const stream = config.stream;
+	return brandLogic(createLogic({
+		id: config.id,
+		validator: config.validator,
+		schemas: toLogicSchemas(config.schemas),
+		context: void 0,
+		run: ({ event, input, self, system }, enq) => {
+			if (event.type === EFFECT_COMPLETE) return {
+				status: "done",
+				input: void 0
+			};
+			if (event.type === EFFECT_REJECT) return {
+				status: "error",
+				error: event.error,
+				input: void 0
+			};
+			if (event.type !== EFFECT_INIT) return;
+			const streamValue = typeof stream === "function" ? stream(createSourceArgs(input, self, system)) : stream;
+			const consume = Stream.runForEach(streamValue, (value) => Effect.sync(() => relayToParent(self, value)));
+			enq.effect(() => startHostedEffect(self, Effect.scoped(consume), "fromEffectEventStream", (exit) => {
+				if (self.getSnapshot().status !== "active") return;
+				if (Exit.isSuccess(exit)) self.send({ type: EFFECT_COMPLETE });
+				else self.send({
+					type: EFFECT_REJECT,
+					error: toError(exit)
+				});
+			}));
+		}
+	}), void 0, void 0);
+}
+// src/setupEffect.ts
+function wrapActions(actions) {
+	if (actions === void 0) return;
+	const wrapped = {};
+	for (const [key, action] of Object.entries(actions)) {
+		const invoke = action;
+		wrapped[key] = (args) => {
+			const result = invoke(args);
+			const returned = result;
+			return Effect.isEffect(returned) ? runHostedEffect(args.self, result, `action.${key}`) : returned;
+		};
+	}
+	return wrapped;
+}
+/**
+* Makes `machine.provide` host Effect-returning action overrides the same way
+* `setupEffect` hosts declared actions.
+*/
+function decorateMachine(machine) {
+	const provide = machine.provide.bind(machine);
+	machine.provide = ((sources) => decorateMachine(provide({
+		...sources,
+		actions: wrapActions(sources["actions"])
+	})));
+	return machine;
+}
+function decorateEffectSetup(effectSetup) {
+	const createMachine = effectSetup.createMachine.bind(effectSetup);
+	effectSetup.createMachine = ((config) => decorateMachine(createMachine(config)));
+	const extendAny = effectSetup.extend;
+	effectSetup.extend = ((extension) => decorateEffectSetup(extendAny({
+		...extension,
+		schemas: toStandardSetupSchemas(extension.schemas),
+		states: toStandardSetupStates(extension.states),
+		actions: wrapActions(extension.actions)
+	})));
+	return effectSetup;
+}
+function setupEffect(config = {}) {
+	return decorateEffectSetup(setup({
+		...config,
+		schemas: toStandardSetupSchemas(config.schemas),
+		states: toStandardSetupStates(config.states),
+		actions: wrapActions(config.actions)
+	}));
+}
+export { ActorFailedError, ActorScope, ActorStoppedError, EffectActor, EffectInterruptedError, createEffectActor, deadLetters, emitted, fromEffect, fromEffectEventStream, fromEffectStream, inspect, join, send, setupEffect, snapshots, taggedState, waitFor, withActorScope };