@doeixd/machine 0.0.20 → 0.0.21

package/dist/esm/development/index.js

@@ -1683,6 +1683,176 @@ function forContext() {
   };
 }
 
+// src/actor.ts
+var _Actor = class _Actor {
+  constructor(initialMachine) {
+    this._observers = /* @__PURE__ */ new Set();
+    this._queue = [];
+    this._processing = false;
+    this._state = initialMachine;
+    this.ref = {
+      send: (event) => this.dispatch(event)
+    };
+    this.send = new Proxy({}, {
+      get: (_target, prop) => {
+        return (...args) => {
+          this.dispatch({ type: prop, args });
+        };
+      }
+    });
+  }
+  /**
+   * Registers a global inspector.
+   */
+  static inspect(inspector) {
+    _Actor._inspector = inspector;
+  }
+  /**
+   * Returns the current immutable snapshot of the machine.
+   */
+  getSnapshot() {
+    return this._state;
+  }
+  /**
+   * Subscribes to state changes.
+   * @param observer Callback function to be invoked on every state change.
+   * @returns Unsubscribe function.
+   */
+  subscribe(observer) {
+    this._observers.add(observer);
+    return () => {
+      this._observers.delete(observer);
+    };
+  }
+  /**
+   * Selects a slice of the state. 
+   */
+  select(selector) {
+    return selector(this._state);
+  }
+  /**
+   * Starts the actor.
+   */
+  start() {
+    return this;
+  }
+  /**
+   * Stops the actor.
+   */
+  stop() {
+    this._observers.clear();
+  }
+  /**
+   * Dispatches an event to the actor.
+   * Handles both sync and async transitions.
+   */
+  dispatch(event) {
+    if (_Actor._inspector) {
+      _Actor._inspector({
+        type: "@actor/send",
+        actor: this,
+        event,
+        snapshot: this._state
+      });
+    }
+    if (this._processing) {
+      this._queue.push(event);
+      return;
+    }
+    this._processing = true;
+    this._queue.push(event);
+    this._flush();
+  }
+  _flush() {
+    while (this._queue.length > 0) {
+      const event = this._queue[0];
+      this._queue.shift();
+      const transitions = this._state;
+      const fn = transitions[event.type];
+      if (typeof fn !== "function") {
+        console.warn(`[Actor] Transition '${String(event.type)}' not found.`);
+        continue;
+      }
+      let result;
+      try {
+        result = fn.apply(this._state.context, event.args);
+      } catch (error) {
+        console.error(`[Actor] Error in transition '${String(event.type)}':`, error);
+        continue;
+      }
+      if (result instanceof Promise) {
+        result.then((nextState) => {
+          this._state = nextState;
+          this._notify();
+          this._flush();
+        }).catch((error) => {
+          console.error(`[Actor] Async error in transition '${String(event.type)}':`, error);
+          this._flush();
+        });
+        return;
+      } else {
+        this._state = result;
+        this._notify();
+      }
+    }
+    this._processing = false;
+  }
+  _notify() {
+    const snapshot = this.getSnapshot();
+    this._observers.forEach((obs) => obs(snapshot));
+  }
+};
+// Global inspector
+_Actor._inspector = null;
+var Actor = _Actor;
+function createActor(machine) {
+  return new Actor(machine);
+}
+function spawn(machine) {
+  return createActor(machine);
+}
+function fromPromise(promiseFn) {
+  const initial = { status: "pending", data: void 0, error: void 0 };
+  const machine = createMachine(
+    initial,
+    (next2) => ({
+      resolve(data) {
+        return next2({ status: "resolved", data, error: void 0 });
+      },
+      reject(error) {
+        return next2({ status: "rejected", error, data: void 0 });
+      }
+    })
+  );
+  const actor = createActor(machine);
+  promiseFn().then((data) => actor.send.resolve(data)).catch((err) => actor.send.reject(err));
+  return actor;
+}
+function fromObservable(observable) {
+  const initial = { status: "active", value: void 0, error: void 0 };
+  const machine = createMachine(
+    initial,
+    (next2) => ({
+      next(value) {
+        return next2({ status: "active", value, error: void 0 });
+      },
+      error(error) {
+        return next2({ status: "error", error, value: void 0 });
+      },
+      complete() {
+        return next2({ status: "done", value: void 0, error: void 0 });
+      }
+    })
+  );
+  const actor = createActor(machine);
+  observable.subscribe(
+    (val) => actor.send.next(val),
+    (err) => actor.send.error(err),
+    () => actor.send.complete()
+  );
+  return actor;
+}
+
 // src/index.ts
 function createMachine(context, fnsOrFactory) {
   if (typeof fnsOrFactory === "function") {
@@ -1861,6 +2031,7 @@ function next(m, update) {
   return createMachine(update(context), transitions);
 }
 export {
+  Actor,
   BoundMachine,
   CANCEL,
   META_KEY,
@@ -1877,6 +2048,7 @@ export {
   combineFactories,
   compose,
   composeTyped,
+  createActor,
   createAsyncMachine,
   createContext,
   createCustomMiddleware,
@@ -1907,6 +2079,8 @@ export {
   discriminantCase,
   extendTransitions,
   forContext,
+  fromObservable,
+  fromPromise,
   guard,
   guardAsync,
   guarded,
@@ -1939,6 +2113,7 @@ export {
   runWithEnsemble,
   runWithRunner,
   setContext,
+  spawn,
   state,
   step,
   stepAsync,