@xstate/effect 0.1.0-alpha.2

package/dist/xstate-effect-atom.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/atom.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHN0YXRlLWVmZmVjdC1hdG9tLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuL2RlY2xhcmF0aW9ucy9zcmMvYXRvbS5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBIn0=

package/dist/xstate-effect-atom.js

@@ -0,0 +1,88 @@
+import { Cause } from 'effect';
+import { Atom, AsyncResult } from 'effect/unstable/reactivity';
+import { c as createEffectActor, N as NotReadyError, t as taggedState } from './state-9a718be3.js';
+export { N as NotReadyError } from './state-9a718be3.js';
+import 'xstate';
+import 'xstate/durable';
+
+/**
+ * Atoms that expose one actor to a reactive UI through
+ * `effect/unstable/reactivity`. Read them with the atom bindings for your
+ * framework, such as `@effect/atom-react`.
+ */
+
+/**
+ * Creates atoms for an actor that runs in an `Atom.runtime`. The runtime's
+ * Layer must provide every service the logic requires; a missing service is
+ * a type error on the `runtime` argument.
+ *
+ * The actor is created with `createEffectActor` inside the `actor` atom's
+ * scope, so its lifetime follows the atom: it starts on first read and stops
+ * when the atom is released. Wrap the atoms with `Atom.keepAlive` to pin the
+ * actor for the registry's lifetime, or with `Atom.family` to create one
+ * actor per input.
+ */
+function createActorAtoms(runtime, logic, options) {
+  const host = runtime;
+  const actor = host.atom(createEffectActor(logic, options));
+  const snapshot = Atom.make(get => {
+    const result = get(actor);
+    if (!AsyncResult.isSuccess(result)) {
+      return AsyncResult.map(result, running => running.getSnapshot());
+    }
+    const running = result.value;
+    const publish = () => {
+      get.setSelf(AsyncResult.success(running.getSnapshot()));
+    };
+    // The atom is the consumer of the actor's error: `result` reports it,
+    // so the observer handles `error` and XState does not report it as
+    // unhandled.
+    const subscription = running.subscribe({
+      next: publish,
+      error: publish,
+      complete: publish
+    });
+    get.addFinalizer(() => {
+      subscription.unsubscribe();
+    });
+    return AsyncResult.success(running.getSnapshot());
+  });
+  const result = Atom.make(get => {
+    const current = get(snapshot);
+    if (!AsyncResult.isSuccess(current)) {
+      return current;
+    }
+    const value = current.value;
+    if (value.status === 'error') {
+      return AsyncResult.failureWithPrevious(Cause.fail(value.error), {
+        previous: get.self()
+      });
+    }
+    return current;
+  });
+  const sendAtom = Atom.writable(get => AsyncResult.map(get(actor), () => undefined), (ctx, event) => {
+    const current = ctx.get(actor);
+    if (AsyncResult.isInitial(current)) {
+      ctx.setSelf(AsyncResult.failure(Cause.fail(new NotReadyError())));
+    } else if (AsyncResult.isFailure(current)) {
+      ctx.setSelf(AsyncResult.map(current, () => undefined));
+    } else {
+      current.value.send(event);
+      ctx.setSelf(AsyncResult.success(undefined));
+    }
+  });
+  function select(selector) {
+    return Atom.map(snapshot, result => AsyncResult.map(result, selector));
+  }
+  const state = select(current => taggedState(current));
+  return {
+    actor,
+    snapshot,
+    result,
+    send: sendAtom,
+    select,
+    state
+  };
+}
+
+export { createActorAtoms };

package/dist/xstate-effect.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieHN0YXRlLWVmZmVjdC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi9kZWNsYXJhdGlvbnMvc3JjL2luZGV4LmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==