@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/xstate-actors.esm-CtI5S0f4.esm.js

@@ -0,0 +1,310 @@
+import { i as XSTATE_STOP } from "./xstate.esm-Cf4e0Cfd.esm.js";
+const instanceStates = /* #__PURE__ */ new WeakMap();
+/**
+* Represents an actor created by `fromCallback`.
+*
+* The type of `self` within the actor's logic.
+*
+* @example
+*
+* ```ts
+* import { fromCallback, createActor } from 'xstate';
+*
+* // The events the actor receives.
+* type Event = { type: 'someEvent' };
+* // The actor's input.
+* type Input = { name: string };
+*
+* // Actor logic that logs whenever it receives an event of type `someEvent`.
+* const logic = fromCallback<Event, Input>(({ self, input, receive }) => {
+*   self;
+*   // ^? CallbackActorRef<Event, Input>
+*
+*   receive((event) => {
+*     if (event.type === 'someEvent') {
+*       console.log(`${input.name}: received "someEvent" event`);
+*       // logs 'myActor: received "someEvent" event'
+*     }
+*   });
+* });
+*
+* const actor = createActor(logic, { input: { name: 'myActor' } });
+* //    ^? CallbackActorRef<Event, Input>
+* ```
+*
+* @see {@link fromCallback}
+*/
+/**
+* An actor logic creator which returns callback logic as defined by a callback
+* function.
+*
+* @remarks
+* Useful for subscription-based or other free-form logic that can send events
+* back to the parent actor.
+*
+* Actors created from callback logic (“callback actors”) can:
+*
+* - Receive events via the `receive` function
+* - Send events to the parent actor via the `sendBack` function
+*
+* Callback actors are a bit different from other actors in that they:
+*
+* - Do not work with `onDone`
+* - Do not produce a snapshot using `.getSnapshot()`
+* - Do not emit values when used with `.subscribe()`
+* - Can not be stopped with `.stop()`
+*
+* @example
+*
+* ```typescript
+* const callbackLogic = fromCallback(({ sendBack, receive }) => {
+*   let lockStatus = 'unlocked';
+*
+*   const handler = (event) => {
+*     if (lockStatus === 'locked') {
+*       return;
+*     }
+*     sendBack(event);
+*   };
+*
+*   receive((event) => {
+*     if (event.type === 'lock') {
+*       lockStatus = 'locked';
+*     } else if (event.type === 'unlock') {
+*       lockStatus = 'unlocked';
+*     }
+*   });
+*
+*   document.body.addEventListener('click', handler);
+*
+*   return () => {
+*     document.body.removeEventListener('click', handler);
+*   };
+* });
+* ```
+*
+* @param callback - The callback function used to describe the callback logic
+*   The callback function is passed an object with the following properties:
+*
+*   - `receive` - A function that can send events back to the parent actor; the
+*       listener is then called whenever events are received by the callback
+*       actor
+*   - `sendBack` - A function that can send events back to the parent actor
+*   - `input` - Data that was provided to the callback actor
+*   - `self` - The parent actor of the callback actor
+*   - `system` - The actor system to which the callback actor belongs The callback
+*       function can (optionally) return a cleanup function, which is called
+*       when the actor is stopped.
+*
+* @returns Callback logic
+* @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
+* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+*/
+function fromCallback(callback) {
+	return {
+		config: callback,
+		start: (state, actorScope) => {
+			const { self, system, emit } = actorScope;
+			const callbackState = {
+				receivers: void 0,
+				dispose: void 0
+			};
+			instanceStates.set(self, callbackState);
+			callbackState.dispose = callback({
+				input: state.input,
+				system,
+				self,
+				sendBack: (event) => {
+					if (self.getSnapshot().status === "stopped") return;
+					if (self._parent) system._relay(self, self._parent, event);
+				},
+				receive: (listener) => {
+					callbackState.receivers ??= /* @__PURE__ */ new Set();
+					callbackState.receivers.add(listener);
+				},
+				emit
+			});
+		},
+		transition: (state, event, actorScope) => {
+			const callbackState = instanceStates.get(actorScope.self);
+			if (event.type === "xstate.stop") {
+				state = {
+					...state,
+					status: "stopped",
+					error: void 0
+				};
+				callbackState.dispose?.();
+				return state;
+			}
+			callbackState.receivers?.forEach((receiver) => receiver(event));
+			return state;
+		},
+		getInitialSnapshot: (_, input) => {
+			return {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				input
+			};
+		},
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
+	};
+}
+const XSTATE_PROMISE_RESOLVE = "xstate.promise.resolve";
+const XSTATE_PROMISE_REJECT = "xstate.promise.reject";
+/**
+* Represents an actor created by `fromPromise`.
+*
+* The type of `self` within the actor's logic.
+*
+* @example
+*
+* ```ts
+* import { fromPromise, createActor } from 'xstate';
+*
+* // The actor's resolved output
+* type Output = string;
+* // The actor's input.
+* type Input = { message: string };
+*
+* // Actor logic that fetches the url of an image of a cat saying `input.message`.
+* const logic = fromPromise<Output, Input>(async ({ input, self }) => {
+*   self;
+*   // ^? PromiseActorRef<Output, Input>
+*
+*   const data = await fetch(
+*     `https://cataas.com/cat/says/${input.message}`
+*   );
+*   const url = await data.json();
+*   return url;
+* });
+*
+* const actor = createActor(logic, { input: { message: 'hello world' } });
+* //    ^? PromiseActorRef<Output, Input>
+* ```
+*
+* @see {@link fromPromise}
+*/
+const controllerMap = /* @__PURE__ */ new WeakMap();
+/**
+* An actor logic creator which returns promise logic as defined by an async
+* process that resolves or rejects after some time.
+*
+* Actors created from promise actor logic (“promise actors”) can:
+*
+* - Emit the resolved value of the promise
+* - Output the resolved value of the promise
+*
+* Sending events to promise actors will have no effect.
+*
+* @example
+*
+* ```ts
+* const promiseLogic = fromPromise(async () => {
+*   const result = await fetch('https://example.com/...').then((data) =>
+*     data.json()
+*   );
+*
+*   return result;
+* });
+*
+* const promiseActor = createActor(promiseLogic);
+* promiseActor.subscribe((snapshot) => {
+*   console.log(snapshot);
+* });
+* promiseActor.start();
+* // => {
+* //   output: undefined,
+* //   status: 'active'
+* //   ...
+* // }
+*
+* // After promise resolves
+* // => {
+* //   output: { ... },
+* //   status: 'done',
+* //   ...
+* // }
+* ```
+*
+* @param promiseCreator A function which returns a Promise, and accepts an
+*   object with the following properties:
+*
+*   - `input` - Data that was provided to the promise actor
+*   - `self` - The parent actor of the promise actor
+*   - `system` - The actor system to which the promise actor belongs
+*
+* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+*/
+function fromPromise(promiseCreator) {
+	return {
+		config: promiseCreator,
+		transition: (state, event, scope) => {
+			if (state.status !== "active") return state;
+			switch (event.type) {
+				case XSTATE_PROMISE_RESOLVE: {
+					const resolvedValue = event.data;
+					return {
+						...state,
+						status: "done",
+						output: resolvedValue,
+						input: void 0
+					};
+				}
+				case XSTATE_PROMISE_REJECT: return {
+					...state,
+					status: "error",
+					error: event.data,
+					input: void 0
+				};
+				case XSTATE_STOP:
+					controllerMap.get(scope.self)?.abort();
+					return {
+						...state,
+						status: "stopped",
+						input: void 0
+					};
+				default: return state;
+			}
+		},
+		start: (state, { self, system, emit }) => {
+			if (state.status !== "active") return;
+			const controller = new AbortController();
+			controllerMap.set(self, controller);
+			Promise.resolve(promiseCreator({
+				input: state.input,
+				system,
+				self,
+				signal: controller.signal,
+				emit
+			})).then((response) => {
+				if (self.getSnapshot().status !== "active") return;
+				controllerMap.delete(self);
+				system._relay(self, self, {
+					type: XSTATE_PROMISE_RESOLVE,
+					data: response
+				});
+			}, (errorData) => {
+				if (self.getSnapshot().status !== "active") return;
+				controllerMap.delete(self);
+				system._relay(self, self, {
+					type: XSTATE_PROMISE_REJECT,
+					data: errorData
+				});
+			});
+		},
+		getInitialSnapshot: (_, input) => {
+			return {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				input
+			};
+		},
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
+	};
+}
+//#endregion
+export { fromPromise as n, fromCallback as t };