xstate 6.0.0-alpha.48 → 6.0.0-alpha.49

package/dist/xstate-fsm.development.esm.js

@@ -0,0 +1,403 @@
+export { c as createFSM } from './fsm-e18a7cb4.development.esm.js';
+import './createActor-88709f74.development.esm.js';
+
+var FSMActorStatus = /*#__PURE__*/function (FSMActorStatus) {
+  FSMActorStatus[FSMActorStatus["NotStarted"] = 0] = "NotStarted";
+  FSMActorStatus[FSMActorStatus["Running"] = 1] = "Running";
+  FSMActorStatus[FSMActorStatus["Stopped"] = 2] = "Stopped";
+  return FSMActorStatus;
+}(FSMActorStatus || {});
+let nextSessionId = 0;
+function addressSegment(id) {
+  return id.replaceAll('%', '%25').replaceAll('/', '%2F');
+}
+const timerMaps = new WeakMap();
+const registryMaps = new WeakMap();
+class FSMSystem {
+  constructor(_clock) {
+    this._clock = _clock;
+  }
+  createActorRef(logic, options) {
+    return new FSMActor(logic, options);
+  }
+  spawnActor() {}
+  startActor(actor) {
+    actor.start();
+  }
+  stopActor(actor) {
+    actor._stop();
+  }
+  terminateActor(actor, termination) {
+    actor._terminate(termination);
+  }
+  emitEvent(source, event) {
+    source._emit(event);
+  }
+  sendEvent(_, target, event) {
+    target._send(event);
+  }
+  _relay(source, target, event) {
+    this.sendEvent(source, target, event);
+  }
+  scheduleTimer(source, id, delay) {
+    let actorTimers = timerMaps.get(source);
+    if (!actorTimers) {
+      actorTimers = new Map();
+      timerMaps.set(source, actorTimers);
+    }
+    actorTimers.set(id, this._clock.setTimeout(() => {
+      actorTimers.delete(id);
+      source._send({
+        type: 'xstate.timer',
+        id
+      });
+    }, delay));
+  }
+  cancelTimer(source, id) {
+    const actorTimers = timerMaps.get(source);
+    const timeout = actorTimers?.get(id);
+    if (timeout !== undefined) {
+      this._clock.clearTimeout(timeout);
+      actorTimers.delete(id);
+    }
+  }
+  cancelAllTimers(source) {
+    const actorTimers = timerMaps.get(source);
+    for (const timeout of actorTimers?.values() ?? []) {
+      this._clock.clearTimeout(timeout);
+    }
+    actorTimers?.clear();
+  }
+  _set(key, actor) {
+    let registry = registryMaps.get(this);
+    if (!registry) {
+      registry = new Map();
+      registryMaps.set(this, registry);
+    }
+    registry.set(key, actor);
+  }
+  get(key) {
+    return registryMaps.get(this)?.get(key);
+  }
+  getAll() {
+    return Object.fromEntries(registryMaps.get(this) ?? []);
+  }
+  _unregister(actor) {
+    const registry = registryMaps.get(this);
+    for (const [key, value] of registry ?? []) {
+      if (value === actor) {
+        registry.delete(key);
+      }
+    }
+  }
+}
+
+/** A compact actor runtime for logic returned by `createFSM(...)`. */
+class FSMActor {
+  constructor(logic, options = {}) {
+    this.logic = logic;
+    this.options = options;
+    this._snapshot = void 0;
+    this._effects = void 0;
+    this._queue = void 0;
+    this._processing = false;
+    this._observers = void 0;
+    this._listeners = void 0;
+    this._trigger = void 0;
+    this._restored = false;
+    this._processingStatus = FSMActorStatus.NotStarted;
+    this.id = void 0;
+    this.sessionId = void 0;
+    this.address = void 0;
+    this.ref = this;
+    this.src = void 0;
+    this.system = void 0;
+    this._parent = void 0;
+    this.id = options.id ?? logic.id ?? '(fsm)';
+    this.sessionId = options._sessionId ?? `fsm:${nextSessionId++}`;
+    this.src = options.src ?? logic;
+    this._parent = options.parent;
+    this.address = this._parent ? `${this._parent.address}/${addressSegment(this.id)}` : addressSegment(this.id);
+    this.system = this._parent?.system ?? new FSMSystem(options.clock ?? {
+      setTimeout,
+      clearTimeout
+    });
+    if (options.registryKey) {
+      this.system._set(options.registryKey, this);
+    }
+    const persisted = options.snapshot ?? options.state;
+    try {
+      if (persisted !== undefined) {
+        this._restored = true;
+        this._snapshot = logic.restoreSnapshot?.(persisted, this) ?? persisted;
+        this._effects = [];
+      } else {
+        [this._snapshot, this._effects] = logic.initialTransition(options.input, this);
+      }
+    } catch (error) {
+      this._snapshot = {
+        status: 'error',
+        output: undefined,
+        error
+      };
+      this._effects = [];
+    }
+  }
+  get self() {
+    return this;
+  }
+  get logger() {
+    return this.options.logger ?? console.log;
+  }
+  defer(fn) {
+    fn();
+  }
+  get emit() {
+    const emit = event => this.system.emitEvent(this, event);
+    Object.defineProperty(this, 'emit', {
+      value: emit
+    });
+    return emit;
+  }
+  stopChild(child) {
+    child._stop();
+  }
+  actionExecutor(effect) {
+    effect.exec();
+  }
+  start() {
+    if (this._processingStatus !== FSMActorStatus.NotStarted) {
+      return this;
+    }
+    this._processingStatus = FSMActorStatus.Running;
+    try {
+      this.runEffects(this._effects);
+    } catch (error) {
+      this.fail(error);
+      return this;
+    }
+    if (this._snapshot.status === 'error') {
+      this.fail(this._snapshot.error);
+      return this;
+    }
+    this._effects = [];
+    if (this._processingStatus === FSMActorStatus.Stopped) {
+      return this;
+    }
+    try {
+      this.logic.start?.(this._snapshot, this, {
+        restored: this._restored
+      });
+    } catch (error) {
+      this.fail(error);
+      return this;
+    }
+    if (this._restored) {
+      const timers = this._snapshot.timers ?? {};
+      for (const timer of Object.values(timers)) {
+        const delay = !this.system._clock.now && timer.startedAt !== undefined ? Math.min(timer.delay, Math.max(0, timer.startedAt + timer.delay - Date.now())) : timer.delay;
+        this.system.scheduleTimer(this, timer.id, delay);
+      }
+      this._restored = false;
+    }
+    this.notify();
+    this.flush();
+    return this;
+  }
+  send(event) {
+    if (this._processingStatus === FSMActorStatus.Stopped) {
+      return;
+    }
+    (this._queue ??= []).push(event);
+    this.flush();
+  }
+  _send(event) {
+    this.send(event);
+  }
+  flush() {
+    if (this._processing || this._processingStatus !== FSMActorStatus.Running || !this._queue?.length) {
+      return;
+    }
+    this._processing = true;
+    let event;
+    while (this._processingStatus === FSMActorStatus.Running && (event = this._queue?.shift())) {
+      try {
+        const [snapshot, effects] = this.logic.transition(this._snapshot, event, this);
+        this._snapshot = snapshot;
+        this.runEffects(effects);
+        if (this._snapshot.status === 'active') {
+          this.notify();
+        }
+      } catch (error) {
+        this.fail(error);
+        break;
+      }
+    }
+    this._processing = false;
+  }
+  runEffects(effects) {
+    for (const effect of effects) {
+      effect.exec();
+    }
+  }
+  getSnapshot() {
+    return this._snapshot;
+  }
+  getPersistedSnapshot(options) {
+    return this.logic.getPersistedSnapshot(this._snapshot, options);
+  }
+  toJSON() {
+    return {
+      xstate$type: 'actorRef',
+      id: this.id,
+      address: this.address,
+      src: typeof this.src === 'string' ? this.src : undefined
+    };
+  }
+  _stop() {
+    if (this._processingStatus === FSMActorStatus.Stopped) {
+      return this;
+    }
+    if (this._processingStatus === FSMActorStatus.Running) {
+      const [snapshot, effects] = this.logic.transition(this._snapshot, {
+        type: '@xstate.stop'
+      }, this);
+      this._snapshot = snapshot;
+      this.runEffects(effects);
+    }
+    this._processingStatus = FSMActorStatus.Stopped;
+    this.system.cancelAllTimers(this);
+    this.system._unregister(this);
+    this._queue = undefined;
+    for (const observer of this._observers ?? []) {
+      observer.complete?.();
+    }
+    this._observers?.clear();
+    return this;
+  }
+  stop() {
+    if (this._parent) {
+      throw new Error('A non-root actor cannot be stopped directly.');
+    }
+    return this._stop();
+  }
+  subscribe(observerOrNext, error, complete) {
+    const observer = typeof observerOrNext === 'function' ? {
+      next: observerOrNext,
+      error,
+      complete
+    } : observerOrNext ?? {};
+    if (this._processingStatus === FSMActorStatus.Stopped) {
+      const snapshot = this._snapshot;
+      if (snapshot.status === 'done') {
+        observer.complete?.();
+      } else if (snapshot.status === 'error') {
+        observer.error?.(snapshot.error);
+      }
+      return {
+        unsubscribe() {}
+      };
+    }
+    (this._observers ??= new Set()).add(observer);
+    return {
+      unsubscribe: () => this._observers?.delete(observer)
+    };
+  }
+  on(type, handler) {
+    let listeners = this._listeners?.get(type);
+    if (!listeners) {
+      listeners = new Set();
+      (this._listeners ??= new Map()).set(type, listeners);
+    }
+    listeners.add(handler);
+    return {
+      unsubscribe: () => listeners.delete(handler)
+    };
+  }
+  _emit(event) {
+    for (const listeners of [this._listeners?.get(event.type), this._listeners?.get('*')]) {
+      for (const listener of listeners ?? []) {
+        listener(event);
+      }
+    }
+  }
+  _terminate(termination) {
+    this.notify();
+    this._processingStatus = FSMActorStatus.Stopped;
+    this.system.cancelAllTimers(this);
+    this.system._unregister(this);
+    for (const observer of this._observers ?? []) {
+      if (termination.status === 'error') {
+        observer.error?.(termination.error);
+      } else {
+        observer.complete?.();
+      }
+    }
+    this._observers?.clear();
+    this._listeners?.clear();
+  }
+  fail(error) {
+    this._snapshot = {
+      ...this._snapshot,
+      status: 'error',
+      output: undefined,
+      error
+    };
+    this._processingStatus = FSMActorStatus.Stopped;
+    this.system.cancelAllTimers(this);
+    this.system._unregister(this);
+    this._queue = undefined;
+    for (const observer of this._observers ?? []) {
+      observer.error?.(error);
+    }
+    this._observers?.clear();
+    this._listeners?.clear();
+  }
+  notify() {
+    for (const observer of this._observers ?? []) {
+      observer.next?.(this._snapshot);
+    }
+  }
+  _isRunning() {
+    return this._processingStatus === FSMActorStatus.Running;
+  }
+  _inspectTransition() {}
+  get trigger() {
+    return this._trigger ??= new Proxy({}, {
+      get: (_, type) => payload => this.send({
+        ...payload,
+        type
+      })
+    });
+  }
+  select(selector, equal = Object.is) {
+    return {
+      get: () => selector(this._snapshot),
+      subscribe: observerOrNext => {
+        const observer = typeof observerOrNext === 'function' ? {
+          next: observerOrNext
+        } : observerOrNext;
+        let selected = selector(this._snapshot);
+        return this.subscribe({
+          next: snapshot => {
+            const next = selector(snapshot);
+            if (!equal(selected, next)) {
+              selected = next;
+              observer.next?.(next);
+            }
+          },
+          error: observer.error,
+          complete: observer.complete
+        });
+      }
+    };
+  }
+  [Symbol.observable]() {
+    return this;
+  }
+}
+function createFSMActor(logic, options) {
+  return new FSMActor(logic, options);
+}
+
+export { FSMActor, createFSMActor };