@doeixd/machine 0.0.20 → 0.0.22

package/dist/esm/development/index.js

@@ -1434,6 +1434,104 @@ function withDebugging(machine) {
   return withTimeTravel(withSnapshot(withHistory(machine)));
 }
 
+// src/mixins.ts
+function getAllPropertyDescriptors(obj) {
+  const descriptors = {};
+  let current = obj;
+  while (current && current !== Object.prototype) {
+    const props = Object.getOwnPropertyDescriptors(current);
+    for (const [key, desc] of Object.entries(props)) {
+      if (key === "constructor") continue;
+      if (!(key in descriptors)) {
+        descriptors[key] = desc;
+      }
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return descriptors;
+}
+function MachineUnion(...machines) {
+  const Base = machines[0];
+  class CombinedMachine extends Base {
+    constructor(context) {
+      super(context);
+    }
+  }
+  const wrapMethod = (fn) => {
+    return function(...args) {
+      const result = fn.apply(this, args);
+      if (result && typeof result === "object" && "context" in result) {
+        const newContext = { ...this.context, ...result.context };
+        return new CombinedMachine(newContext);
+      }
+      return result;
+    };
+  };
+  for (const machine of machines) {
+    const descriptors = getAllPropertyDescriptors(machine.prototype);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (key === "constructor") continue;
+      if (typeof descriptor.value === "function") {
+        const originalFn = descriptor.value;
+        const wrappedFn = wrapMethod(originalFn);
+        Object.defineProperty(CombinedMachine.prototype, key, {
+          ...descriptor,
+          value: wrappedFn
+        });
+      } else {
+        Object.defineProperty(CombinedMachine.prototype, key, descriptor);
+      }
+    }
+  }
+  return CombinedMachine;
+}
+function MachineExclude(Source, ...Excluded) {
+  class ExcludedMachine extends MachineBase {
+    constructor(context) {
+      super(context);
+    }
+  }
+  const sourceDescriptors = getAllPropertyDescriptors(Source.prototype);
+  for (const [key, descriptor] of Object.entries(sourceDescriptors)) {
+    if (key === "constructor") continue;
+    if (typeof descriptor.value === "function") {
+      const originalFn = descriptor.value;
+      const wrappedFn = function(...args) {
+        const result = originalFn.apply(this, args);
+        if (result && typeof result === "object" && "context" in result) {
+          return new ExcludedMachine({ ...this.context, ...result.context });
+        }
+        return result;
+      };
+      Object.defineProperty(ExcludedMachine.prototype, key, { ...descriptor, value: wrappedFn });
+    } else {
+      Object.defineProperty(ExcludedMachine.prototype, key, descriptor);
+    }
+  }
+  for (const Excl of Excluded) {
+    const excludedDescriptors = getAllPropertyDescriptors(Excl.prototype);
+    for (const key of Object.keys(excludedDescriptors)) {
+      if (Object.prototype.hasOwnProperty.call(ExcludedMachine.prototype, key)) {
+        delete ExcludedMachine.prototype[key];
+      }
+    }
+  }
+  return ExcludedMachine;
+}
+function machineUnion(...instances) {
+  const constructors = instances.map((i) => i.constructor);
+  const contexts = instances.map((i) => i.context);
+  const mergedContext = Object.assign({}, ...contexts);
+  const CombinedClass = MachineUnion(...constructors);
+  return new CombinedClass(mergedContext);
+}
+function machineExclude(source, ...excluded) {
+  const sourceCtor = source.constructor;
+  const excludedCtors = excluded.map((e) => e.constructor);
+  const ExcludedClass = MachineExclude(sourceCtor, ...excludedCtors);
+  return new ExcludedClass(source.context);
+}
+
 // src/utils.ts
 function isState(machine, machineClass) {
   return machine instanceof machineClass;
@@ -1683,6 +1781,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,10 +2129,13 @@ function next(m, update) {
   return createMachine(update(context), transitions);
 }
 export {
+  Actor,
   BoundMachine,
   CANCEL,
   META_KEY,
   MachineBase,
+  MachineExclude,
+  MachineUnion,
   MiddlewareBuilder,
   MultiMachineBase,
   action,
@@ -1877,6 +2148,7 @@ export {
   combineFactories,
   compose,
   composeTyped,
+  createActor,
   createAsyncMachine,
   createContext,
   createCustomMiddleware,
@@ -1907,6 +2179,8 @@ export {
   discriminantCase,
   extendTransitions,
   forContext,
+  fromObservable,
+  fromPromise,
   guard,
   guardAsync,
   guarded,
@@ -1924,6 +2198,8 @@ export {
   isPipelineConfig,
   isState,
   logState,
+  machineExclude,
+  machineUnion,
   matchMachine,
   mergeContext,
   metadata,
@@ -1939,6 +2215,7 @@ export {
   runWithEnsemble,
   runWithRunner,
   setContext,
+  spawn,
   state,
   step,
   stepAsync,