@camcima/finita 2.0.0 → 2.1.0

package/dist/index.cjs

@@ -0,0 +1,1422 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbstractNamedProcessDetector: () => AbstractNamedProcessDetector,
+  ActiveTransitionFilter: () => ActiveTransitionFilter,
+  AndComposite: () => AndComposite,
+  CallbackCondition: () => CallbackCondition,
+  CallbackObserver: () => CallbackObserver,
+  Contradiction: () => Contradiction,
+  Dispatcher: () => Dispatcher,
+  DuplicateStateError: () => DuplicateStateError,
+  Event: () => Event,
+  Factory: () => Factory,
+  FilterStateByEvent: () => FilterStateByEvent,
+  FilterStateByFinalState: () => FilterStateByFinalState,
+  FilterStateByTransition: () => FilterStateByTransition,
+  FilterTransitionByEvent: () => FilterTransitionByEvent,
+  GraphBuilder: () => GraphBuilder,
+  LockAdapterMutex: () => LockAdapterMutex,
+  LockCanNotBeAcquiredError: () => LockCanNotBeAcquiredError,
+  MutexFactory: () => MutexFactory,
+  Not: () => Not,
+  NullMutex: () => NullMutex,
+  OnEnterObserver: () => OnEnterObserver,
+  OneOrNoneActiveTransition: () => OneOrNoneActiveTransition,
+  OrComposite: () => OrComposite,
+  Process: () => Process,
+  ScoreTransition: () => ScoreTransition,
+  SetupHelper: () => SetupHelper,
+  SingleProcessDetector: () => SingleProcessDetector,
+  State: () => State,
+  StateCollection: () => StateCollection,
+  StateCollectionMerger: () => StateCollectionMerger,
+  StatefulStateNameDetector: () => StatefulStateNameDetector,
+  StatefulStatusChanger: () => StatefulStatusChanger,
+  Statemachine: () => Statemachine,
+  Tautology: () => Tautology,
+  Timeout: () => Timeout,
+  Transition: () => Transition,
+  TransitionLogger: () => TransitionLogger,
+  WeightTransition: () => WeightTransition,
+  WrongEventForStateError: () => WrongEventForStateError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Event.ts
+var Event = class {
+  name;
+  observers = /* @__PURE__ */ new Set();
+  metadata = /* @__PURE__ */ new Map();
+  invokeArgs = [];
+  constructor(name) {
+    this.name = name;
+  }
+  getName() {
+    return this.name;
+  }
+  getInvokeArgs() {
+    return this.invokeArgs;
+  }
+  async invoke(...args) {
+    this.invokeArgs = args;
+    try {
+      await this.notify();
+    } finally {
+      this.invokeArgs = [];
+    }
+  }
+  attach(observer) {
+    this.observers.add(observer);
+  }
+  detach(observer) {
+    this.observers.delete(observer);
+  }
+  async notify() {
+    for (const observer of this.observers) {
+      await observer.update(this);
+    }
+  }
+  getObservers() {
+    return this.observers;
+  }
+  getMetadata() {
+    return Object.fromEntries(this.metadata);
+  }
+  getMetadataValue(key) {
+    return this.metadata.get(key);
+  }
+  setMetadataValue(key, value) {
+    this.metadata.set(key, value);
+  }
+  hasMetadataValue(key) {
+    return this.metadata.has(key);
+  }
+  deleteMetadataValue(key) {
+    this.metadata.delete(key);
+  }
+};
+
+// src/State.ts
+var State = class {
+  name;
+  transitions = /* @__PURE__ */ new Set();
+  events = /* @__PURE__ */ new Map();
+  metadata = /* @__PURE__ */ new Map();
+  constructor(name) {
+    this.name = name;
+  }
+  getName() {
+    return this.name;
+  }
+  getTransitions() {
+    return this.transitions;
+  }
+  addTransition(transition) {
+    if (this.transitions.has(transition)) {
+      return;
+    }
+    const targetName = transition.getTargetState().getName();
+    const eventName = transition.getEventName();
+    const conditionName = transition.getConditionName();
+    for (const existing of this.transitions) {
+      if (existing.getTargetState().getName() === targetName && existing.getEventName() === eventName && existing.getConditionName() === conditionName) {
+        return;
+      }
+    }
+    this.transitions.add(transition);
+    if (eventName) {
+      this.getEvent(eventName);
+    }
+  }
+  getEventNames() {
+    return Array.from(this.events.keys());
+  }
+  hasEvent(name) {
+    return this.events.has(name);
+  }
+  getEvent(name) {
+    let event = this.events.get(name);
+    if (!event) {
+      event = new Event(name);
+      this.events.set(name, event);
+    }
+    return event;
+  }
+  getMetadata() {
+    return Object.fromEntries(this.metadata);
+  }
+  getMetadataValue(key) {
+    return this.metadata.get(key);
+  }
+  setMetadataValue(key, value) {
+    this.metadata.set(key, value);
+  }
+  hasMetadataValue(key) {
+    return this.metadata.has(key);
+  }
+  deleteMetadataValue(key) {
+    this.metadata.delete(key);
+  }
+};
+
+// src/Transition.ts
+var Transition = class {
+  targetState;
+  eventName;
+  condition;
+  weight = 1;
+  constructor(targetState, eventName = null, condition = null) {
+    this.targetState = targetState;
+    this.eventName = eventName;
+    this.condition = condition;
+  }
+  getTargetState() {
+    return this.targetState;
+  }
+  getEventName() {
+    return this.eventName;
+  }
+  getConditionName() {
+    if (this.condition) {
+      return this.condition.getName();
+    }
+    return null;
+  }
+  getCondition() {
+    return this.condition;
+  }
+  async isActive(subject, context, event) {
+    let result;
+    if (event) {
+      result = event.getName() === this.eventName;
+    } else {
+      result = this.eventName === null;
+    }
+    if (this.condition && result) {
+      result = await this.condition.checkCondition(subject, context);
+    }
+    return result;
+  }
+  getWeight() {
+    return this.weight;
+  }
+  setWeight(weight) {
+    this.weight = weight;
+  }
+};
+
+// src/util/StateCollectionMerger.ts
+var StateCollectionMerger = class {
+  targetCollection;
+  stateNamePrefix = "";
+  constructor(targetCollection) {
+    this.targetCollection = targetCollection;
+  }
+  getStateNamePrefix() {
+    return this.stateNamePrefix;
+  }
+  setStateNamePrefix(prefix) {
+    this.stateNamePrefix = prefix;
+  }
+  getTargetCollection() {
+    return this.targetCollection;
+  }
+  createState(name) {
+    return new State(name);
+  }
+  findOrCreateState(name) {
+    const prefixedName = this.stateNamePrefix + name;
+    if (this.targetCollection.hasState(prefixedName)) {
+      return this.targetCollection.getState(prefixedName);
+    }
+    const state = this.createState(prefixedName);
+    this.targetCollection.addState(state);
+    return state;
+  }
+  createCondition(sourceTransition) {
+    return sourceTransition.getCondition();
+  }
+  createTransition(sourceTransition) {
+    const targetStateName = sourceTransition.getTargetState().getName();
+    const targetState = this.findOrCreateState(targetStateName);
+    this.mergeMetadata(sourceTransition.getTargetState(), targetState);
+    const eventName = sourceTransition.getEventName();
+    const condition = this.createCondition(sourceTransition);
+    const transition = new Transition(targetState, eventName, condition);
+    transition.setWeight(sourceTransition.getWeight());
+    return transition;
+  }
+  mergeMetadata(source, target) {
+    const metadata = source.getMetadata();
+    for (const [key, value] of Object.entries(metadata)) {
+      target.setMetadataValue(key, value);
+    }
+  }
+  mergeEvent(source, target, eventName) {
+    const sourceEvent = source.getEvent(eventName);
+    const targetEvent = target.getEvent(eventName);
+    const sourceMetadata = sourceEvent.getMetadata();
+    for (const [key, value] of Object.entries(sourceMetadata)) {
+      targetEvent.setMetadataValue(key, value);
+    }
+    for (const observer of sourceEvent.getObservers()) {
+      targetEvent.attach(observer);
+    }
+  }
+  mergeState(sourceState) {
+    const targetState = this.findOrCreateState(sourceState.getName());
+    this.mergeMetadata(sourceState, targetState);
+    for (const sourceTransition of sourceState.getTransitions()) {
+      const targetTransition = this.createTransition(sourceTransition);
+      targetState.addTransition(targetTransition);
+    }
+    for (const eventName of sourceState.getEventNames()) {
+      this.mergeEvent(sourceState, targetState, eventName);
+    }
+  }
+  merge(source) {
+    if ("getStates" in source && typeof source.getStates === "function") {
+      const collection = source;
+      for (const state of collection.getStates()) {
+        this.mergeState(state);
+      }
+    } else {
+      this.mergeState(source);
+    }
+  }
+};
+
+// src/error/DuplicateStateError.ts
+var DuplicateStateError = class extends Error {
+  stateName;
+  constructor(stateName) {
+    super(
+      `There is already a different state with name "${stateName}" in this collection`
+    );
+    this.name = "DuplicateStateError";
+    this.stateName = stateName;
+  }
+};
+
+// src/StateCollection.ts
+var StateCollection = class {
+  states = /* @__PURE__ */ new Map();
+  stateCollectionMerger = null;
+  getState(name) {
+    const state = this.states.get(name);
+    if (!state) {
+      throw new Error(`State "${name}" not found`);
+    }
+    return state;
+  }
+  getStates() {
+    return this.states.values();
+  }
+  hasState(name) {
+    return this.states.has(name);
+  }
+  addState(state) {
+    const existing = this.states.get(state.getName());
+    if (existing && existing !== state) {
+      throw new DuplicateStateError(state.getName());
+    }
+    this.states.set(state.getName(), state);
+  }
+  getStateCollectionMerger() {
+    if (!this.stateCollectionMerger) {
+      this.stateCollectionMerger = new StateCollectionMerger(this);
+    }
+    return this.stateCollectionMerger;
+  }
+  merge(source) {
+    const merger = this.getStateCollectionMerger();
+    merger.merge(source);
+  }
+};
+
+// src/Process.ts
+var Process = class {
+  name;
+  initialState;
+  states;
+  constructor(name, initialState) {
+    this.name = name;
+    this.initialState = initialState;
+    this.states = new StateCollection();
+    this.registerState(initialState);
+  }
+  registerState(state) {
+    const name = state.getName();
+    if (this.states.hasState(name)) {
+      if (this.states.getState(name) !== state) {
+        throw new DuplicateStateError(name);
+      }
+      return;
+    }
+    this.states.addState(state);
+    for (const transition of state.getTransitions()) {
+      const targetState = transition.getTargetState();
+      this.registerState(targetState);
+    }
+  }
+  getName() {
+    return this.name;
+  }
+  getInitialState() {
+    return this.initialState;
+  }
+  getStates() {
+    return this.states.getStates();
+  }
+  getState(name) {
+    return this.states.getState(name);
+  }
+  hasState(name) {
+    return this.states.hasState(name);
+  }
+};
+
+// src/selector/OneOrNoneActiveTransition.ts
+var OneOrNoneActiveTransition = class {
+  selectTransition(transitions) {
+    const arr = Array.from(transitions);
+    switch (arr.length) {
+      case 0:
+        return null;
+      case 1:
+        return arr[0];
+      default:
+        throw new Error("More than one transition is active!");
+    }
+  }
+};
+
+// src/mutex/NullMutex.ts
+var NullMutex = class {
+  acquired = false;
+  acquireLock() {
+    this.acquired = true;
+    return true;
+  }
+  releaseLock() {
+    this.acquired = false;
+    return true;
+  }
+  isAcquired() {
+    return this.acquired;
+  }
+  isLocked() {
+    return false;
+  }
+};
+
+// src/Dispatcher.ts
+var Dispatcher = class {
+  commands = [];
+  onReadyCallbacks = [];
+  ready = false;
+  dispatch(event, args = [], onReadyCallback) {
+    if (this.ready) {
+      throw new Error("Was already invoked!");
+    }
+    this.commands.push({ event, args });
+    if (onReadyCallback) {
+      this.onReadyCallbacks.push(onReadyCallback);
+    }
+  }
+  async invoke() {
+    if (this.ready) {
+      throw new Error("Was already invoked!");
+    }
+    for (const { event, args } of this.commands) {
+      await event.invoke(...args);
+    }
+    this.ready = true;
+    for (const callback of this.onReadyCallbacks) {
+      await callback.invoke();
+    }
+  }
+  isReady() {
+    return this.ready;
+  }
+};
+
+// src/filter/ActiveTransitionFilter.ts
+var ActiveTransitionFilter = class {
+  static async filter(transitions, subject, context, event) {
+    const active = [];
+    for (const transition of transitions) {
+      if (await transition.isActive(subject, context, event)) {
+        active.push(transition);
+      }
+    }
+    return active;
+  }
+};
+
+// src/error/WrongEventForStateError.ts
+var WrongEventForStateError = class extends Error {
+  stateName;
+  eventName;
+  constructor(stateName, eventName) {
+    super(`Current state "${stateName}" doesn't have event "${eventName}"`);
+    this.name = "WrongEventForStateError";
+    this.stateName = stateName;
+    this.eventName = eventName;
+  }
+};
+
+// src/error/LockCanNotBeAcquiredError.ts
+var LockCanNotBeAcquiredError = class extends Error {
+  constructor(message = "Lock can not be acquired!") {
+    super(message);
+    this.name = "LockCanNotBeAcquiredError";
+  }
+};
+
+// src/Statemachine.ts
+var Statemachine = class {
+  subject;
+  currentState;
+  lastState = null;
+  transitionSelector;
+  selectedTransition = null;
+  process;
+  mutex;
+  autoreleaseLock = true;
+  dispatcher = null;
+  currentEvent = null;
+  currentContext = null;
+  observers = /* @__PURE__ */ new Set();
+  constructor(subject, process, stateName, transitionSelector, mutex) {
+    this.subject = subject;
+    if (stateName) {
+      this.currentState = process.getState(stateName);
+    } else {
+      this.currentState = process.getInitialState();
+    }
+    this.transitionSelector = transitionSelector ?? new OneOrNoneActiveTransition();
+    this.process = process;
+    this.mutex = mutex ?? new NullMutex();
+  }
+  getProcess() {
+    return this.process;
+  }
+  getCurrentState() {
+    return this.currentState;
+  }
+  getLastState() {
+    return this.lastState;
+  }
+  getSubject() {
+    return this.subject;
+  }
+  getSelectedTransition() {
+    return this.selectedTransition;
+  }
+  getCurrentContext() {
+    return this.currentContext;
+  }
+  async doCheckTransitions(context, event, automaticVisited) {
+    try {
+      const transitions = this.currentState.getTransitions();
+      const activeTransitions = await ActiveTransitionFilter.filter(
+        transitions,
+        this.subject,
+        context,
+        event
+      );
+      this.selectedTransition = this.transitionSelector.selectTransition(activeTransitions);
+      if (this.selectedTransition) {
+        const targetState = this.selectedTransition.getTargetState();
+        if (this.selectedTransition.getEventName() === null) {
+          if (!automaticVisited) {
+            automaticVisited = /* @__PURE__ */ new Set();
+          }
+          automaticVisited.add(this.currentState);
+          if (automaticVisited.has(targetState)) {
+            throw new Error(
+              `Automatic transition cycle detected: state "${targetState.getName()}" was already visited \u2014 this would cause infinite recursion`
+            );
+          }
+        }
+        if (this.currentState !== targetState) {
+          this.lastState = this.currentState;
+          this.currentState = targetState;
+          this.currentContext = context;
+          this.currentEvent = event ?? null;
+          try {
+            await this.notify();
+          } finally {
+            this.currentContext = null;
+            this.currentEvent = null;
+            this.selectedTransition = null;
+            this.lastState = null;
+          }
+        }
+        await this.doCheckTransitions(context, void 0, automaticVisited);
+      }
+    } catch (error) {
+      let message = `Exception was thrown when doing a transition from current state "${this.currentState.getName()}"`;
+      if (this.currentEvent) {
+        message += ` with event "${this.currentEvent.getName()}"`;
+      }
+      const named = this.subject;
+      if (named && typeof named.getName === "function") {
+        message += ` for "${named.getName()}"`;
+      }
+      throw new Error(message, { cause: error });
+    }
+  }
+  async onDispatcherReady() {
+    if (this.dispatcher && this.dispatcher.isReady()) {
+      const context = this.currentContext;
+      const event = this.currentEvent ?? void 0;
+      this.dispatcher = null;
+      this.currentContext = null;
+      this.currentEvent = null;
+      try {
+        await this.doCheckTransitions(context, event);
+      } finally {
+        if (this.autoreleaseLock && this.isLockAcquired()) {
+          await this.releaseLock();
+        }
+      }
+    }
+  }
+  async dispatchEvent(dispatcher, name, context) {
+    if (this.dispatcher) {
+      throw new Error("Event dispatching is still running!");
+    }
+    if (this.currentState.hasEvent(name)) {
+      await this.acquireLockOrThrowException();
+      try {
+        this.dispatcher = dispatcher;
+        this.currentContext = context ?? /* @__PURE__ */ new Map();
+        this.currentEvent = this.currentState.getEvent(name);
+        dispatcher.dispatch(
+          this.currentEvent,
+          [this.subject, this.currentContext],
+          { invoke: () => this.onDispatcherReady() }
+        );
+      } catch (error) {
+        this.dispatcher = null;
+        this.currentContext = null;
+        this.currentEvent = null;
+        if (this.autoreleaseLock) {
+          await this.releaseLock();
+        }
+        throw error;
+      }
+    } else {
+      throw new WrongEventForStateError(this.currentState.getName(), name);
+    }
+  }
+  async triggerEvent(name, context) {
+    const dispatcher = new Dispatcher();
+    try {
+      await this.dispatchEvent(dispatcher, name, context);
+      await dispatcher.invoke();
+    } finally {
+      this.dispatcher = null;
+      this.currentContext = null;
+      this.currentEvent = null;
+      if (this.autoreleaseLock && this.isLockAcquired()) {
+        await this.releaseLock();
+      }
+    }
+  }
+  async checkTransitions(context) {
+    await this.acquireLockOrThrowException();
+    const ctx = context ?? /* @__PURE__ */ new Map();
+    try {
+      await this.doCheckTransitions(ctx);
+    } finally {
+      if (this.autoreleaseLock && this.isLockAcquired()) {
+        await this.releaseLock();
+      }
+    }
+  }
+  async acquireLockOrThrowException() {
+    if (!await this.acquireLock()) {
+      throw new LockCanNotBeAcquiredError("Lock can not be acquired!");
+    }
+  }
+  isAutoreleaseLock() {
+    return this.autoreleaseLock;
+  }
+  setAutoreleaseLock(autorelease) {
+    this.autoreleaseLock = autorelease;
+  }
+  async acquireLock() {
+    if (this.mutex.isAcquired()) {
+      return true;
+    }
+    return this.mutex.acquireLock();
+  }
+  async releaseLock() {
+    await this.mutex.releaseLock();
+  }
+  isLockAcquired() {
+    return this.mutex.isAcquired();
+  }
+  attach(observer) {
+    this.observers.add(observer);
+  }
+  detach(observer) {
+    this.observers.delete(observer);
+  }
+  async notify() {
+    for (const observer of this.observers) {
+      await observer.update(this);
+    }
+  }
+  getObservers() {
+    return this.observers;
+  }
+};
+
+// src/condition/Tautology.ts
+var Tautology = class {
+  name;
+  constructor(name = "Tautology") {
+    this.name = name;
+  }
+  getName() {
+    return this.name;
+  }
+  checkCondition(_subject, _context) {
+    return true;
+  }
+};
+
+// src/condition/Contradiction.ts
+var Contradiction = class {
+  name;
+  constructor(name = "Contradiction") {
+    this.name = name;
+  }
+  getName() {
+    return this.name;
+  }
+  checkCondition(_subject, _context) {
+    return false;
+  }
+};
+
+// src/condition/CallbackCondition.ts
+var CallbackCondition = class {
+  name;
+  callable;
+  constructor(name, callable) {
+    this.name = name;
+    this.callable = callable;
+  }
+  getName() {
+    return this.name;
+  }
+  checkCondition(subject, context) {
+    return this.callable(subject, context);
+  }
+};
+
+// src/condition/Timeout.ts
+function isLastStateHasChangedDate(obj) {
+  return typeof obj === "object" && obj !== null && "getLastStateHasChangedDate" in obj && typeof obj.getLastStateHasChangedDate === "function";
+}
+var Timeout = class {
+  timeoutMs;
+  label;
+  constructor(timeoutMs, label) {
+    this.timeoutMs = timeoutMs;
+    this.label = label ?? `${timeoutMs}ms`;
+  }
+  getName() {
+    return `Timeout: ${this.label}`;
+  }
+  getLastStateHasChangedDate(subject, _context) {
+    if (isLastStateHasChangedDate(subject)) {
+      return subject.getLastStateHasChangedDate();
+    }
+    throw new Error("Subject must implement LastStateHasChangedDateInterface");
+  }
+  checkCondition(subject, context) {
+    const date = new Date(
+      this.getLastStateHasChangedDate(subject, context).getTime()
+    );
+    date.setTime(date.getTime() + this.timeoutMs);
+    return date <= /* @__PURE__ */ new Date();
+  }
+};
+
+// src/condition/AndComposite.ts
+var AndComposite = class {
+  conditions = [];
+  constructor(condition) {
+    this.conditions.push(condition);
+  }
+  addAnd(condition) {
+    this.conditions.push(condition);
+    return this;
+  }
+  getName() {
+    const names = this.conditions.map((c) => c.getName());
+    return `(${names.join(" and ")})`;
+  }
+  async checkCondition(subject, context) {
+    for (const condition of this.conditions) {
+      if (!await condition.checkCondition(subject, context)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/condition/OrComposite.ts
+var OrComposite = class {
+  conditions = [];
+  constructor(condition) {
+    this.conditions.push(condition);
+  }
+  addOr(condition) {
+    this.conditions.push(condition);
+    return this;
+  }
+  getName() {
+    const names = this.conditions.map((c) => c.getName());
+    return `(${names.join(" or ")})`;
+  }
+  async checkCondition(subject, context) {
+    for (const condition of this.conditions) {
+      if (await condition.checkCondition(subject, context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/condition/Not.ts
+var Not = class {
+  condition;
+  constructor(condition) {
+    this.condition = condition;
+  }
+  getName() {
+    return `not ( ${this.condition.getName()} )`;
+  }
+  async checkCondition(subject, context) {
+    return !await this.condition.checkCondition(subject, context);
+  }
+};
+
+// src/observer/CallbackObserver.ts
+var CallbackObserver = class {
+  callback;
+  constructor(callback) {
+    this.callback = callback;
+  }
+  update(subject) {
+    const event = subject;
+    if (typeof event.getInvokeArgs === "function") {
+      return this.callback(...event.getInvokeArgs());
+    }
+    return this.callback(subject);
+  }
+};
+
+// src/observer/StatefulStatusChanger.ts
+function isStatemachine(obj) {
+  return typeof obj === "object" && obj !== null && "getCurrentState" in obj && "getSubject" in obj;
+}
+function isStateful(obj) {
+  return typeof obj === "object" && obj !== null && "setCurrentStateName" in obj && typeof obj.setCurrentStateName === "function";
+}
+var StatefulStatusChanger = class {
+  update(subject) {
+    if (isStatemachine(subject)) {
+      const subjectObj = subject.getSubject();
+      if (isStateful(subjectObj)) {
+        const stateName = subject.getCurrentState().getName();
+        subjectObj.setCurrentStateName(stateName);
+      }
+    }
+  }
+};
+
+// src/observer/OnEnterObserver.ts
+function isStatemachine2(obj) {
+  return typeof obj === "object" && obj !== null && "getCurrentState" in obj && "triggerEvent" in obj;
+}
+var OnEnterObserver = class _OnEnterObserver {
+  static DEFAULT_EVENT_NAME = "onEnter";
+  eventName;
+  constructor(eventName = _OnEnterObserver.DEFAULT_EVENT_NAME) {
+    this.eventName = eventName;
+  }
+  async update(subject) {
+    if (isStatemachine2(subject) && subject.getCurrentState().hasEvent(this.eventName)) {
+      const sm = subject;
+      const autorelease = sm.isAutoreleaseLock();
+      sm.setAutoreleaseLock(false);
+      try {
+        await sm.triggerEvent(
+          this.eventName,
+          sm.getCurrentContext() ?? void 0
+        );
+      } finally {
+        sm.setAutoreleaseLock(autorelease);
+      }
+    }
+  }
+};
+
+// src/observer/TransitionLogger.ts
+function isStatemachine3(obj) {
+  return typeof obj === "object" && obj !== null && "getCurrentState" in obj && "getSubject" in obj;
+}
+function isNamed(obj) {
+  return typeof obj === "object" && obj !== null && "getName" in obj && typeof obj.getName === "function";
+}
+function convertToString(obj) {
+  if (isNamed(obj)) {
+    return obj.getName();
+  }
+  return String(obj);
+}
+var TransitionLogger = class {
+  logger;
+  loggerLevel;
+  constructor(logger, loggerLevel = "info") {
+    this.logger = logger;
+    this.loggerLevel = loggerLevel;
+  }
+  update(subject) {
+    if (!isStatemachine3(subject)) {
+      return;
+    }
+    const context = {};
+    context["subject"] = subject.getSubject();
+    context["currentState"] = subject.getCurrentState();
+    context["lastState"] = subject.getLastState();
+    context["transition"] = subject.getSelectedTransition();
+    let message = "Transition";
+    if (context["subject"] != null) {
+      message += ` for "${convertToString(context["subject"])}"`;
+    }
+    if (context["lastState"] != null) {
+      message += ` from "${convertToString(context["lastState"])}"`;
+    }
+    if (context["currentState"] != null) {
+      message += ` to "${convertToString(context["currentState"])}"`;
+    }
+    const transition = context["transition"];
+    if (transition && typeof transition.getEventName === "function") {
+      const eventName = transition.getEventName();
+      const condition = transition.getConditionName?.();
+      if (eventName || condition) {
+        message += " with";
+        if (eventName) {
+          message += ` event "${eventName}"`;
+        }
+        if (condition) {
+          message += ` condition "${condition}"`;
+        }
+      }
+    }
+    this.logger.log(this.loggerLevel, message, context);
+  }
+};
+
+// src/filter/FilterStateByEvent.ts
+var FilterStateByEvent = class {
+  static *filter(states, eventName) {
+    for (const state of states) {
+      if (state.hasEvent(eventName)) {
+        yield state;
+      }
+    }
+  }
+};
+
+// src/filter/FilterStateByTransition.ts
+var FilterStateByTransition = class {
+  static *filter(states) {
+    for (const state of states) {
+      for (const transition of state.getTransitions()) {
+        if (!transition.getEventName()) {
+          yield state;
+          break;
+        }
+      }
+    }
+  }
+};
+
+// src/filter/FilterStateByFinalState.ts
+var FilterStateByFinalState = class {
+  static *filter(states) {
+    for (const state of states) {
+      let count = 0;
+      for (const _transition of state.getTransitions()) {
+        count++;
+        break;
+      }
+      if (count === 0) {
+        yield state;
+      }
+    }
+  }
+};
+
+// src/filter/FilterTransitionByEvent.ts
+var FilterTransitionByEvent = class {
+  static *filter(transitions, eventName) {
+    for (const transition of transitions) {
+      if (transition.getEventName() === eventName) {
+        yield transition;
+      }
+    }
+  }
+};
+
+// src/selector/ScoreTransition.ts
+var ScoreTransition = class {
+  innerSelector;
+  constructor(innerSelector) {
+    this.innerSelector = innerSelector ?? new OneOrNoneActiveTransition();
+  }
+  calculateScore(transition) {
+    let score = 0;
+    if (transition.getEventName()) {
+      score += 2;
+    }
+    if (transition.getConditionName()) {
+      score += 1;
+    }
+    return score;
+  }
+  selectTransition(transitions) {
+    let bestTransitions = [];
+    let bestScore = -1;
+    for (const transition of transitions) {
+      const score = this.calculateScore(transition);
+      if (score > bestScore) {
+        bestScore = score;
+        bestTransitions = [transition];
+      } else if (score === bestScore) {
+        bestTransitions.push(transition);
+      }
+    }
+    return this.innerSelector.selectTransition(bestTransitions);
+  }
+};
+
+// src/selector/WeightTransition.ts
+var WeightTransition = class {
+  innerSelector;
+  epsilon;
+  constructor(innerSelector, epsilon = 1e-3) {
+    this.innerSelector = innerSelector ?? new OneOrNoneActiveTransition();
+    this.epsilon = epsilon;
+  }
+  selectTransition(transitions) {
+    let bestTransitions = [];
+    let bestWeight = null;
+    for (const transition of transitions) {
+      const weight = transition.getWeight();
+      const diff = weight - (bestWeight ?? 0);
+      if (bestWeight === null || diff >= this.epsilon) {
+        bestWeight = weight;
+        bestTransitions = [transition];
+      } else if (Math.abs(diff) < this.epsilon) {
+        bestTransitions.push(transition);
+      }
+    }
+    return this.innerSelector.selectTransition(bestTransitions);
+  }
+};
+
+// src/mutex/LockAdapterMutex.ts
+var LockAdapterMutex = class {
+  lockAdapter;
+  resourceName;
+  acquired = false;
+  constructor(lockAdapter, resourceName) {
+    this.lockAdapter = lockAdapter;
+    this.resourceName = resourceName;
+  }
+  async acquireLock() {
+    if (!this.acquired) {
+      this.acquired = await this.lockAdapter.acquireLock(this.resourceName);
+    }
+    return this.acquired;
+  }
+  async releaseLock() {
+    if (this.acquired) {
+      const result = await this.lockAdapter.releaseLock(this.resourceName);
+      if (result) {
+        this.acquired = false;
+      }
+      return result;
+    }
+    return false;
+  }
+  isAcquired() {
+    return this.acquired;
+  }
+  async isLocked() {
+    return this.lockAdapter.isLocked(this.resourceName);
+  }
+};
+
+// src/mutex/MutexFactory.ts
+var MutexFactory = class {
+  lockAdapter;
+  stringConverter;
+  constructor(lockAdapter, stringConverter) {
+    this.lockAdapter = lockAdapter;
+    this.stringConverter = stringConverter;
+  }
+  createMutex(subject) {
+    return new LockAdapterMutex(
+      this.lockAdapter,
+      this.stringConverter(subject)
+    );
+  }
+};
+
+// src/factory/Factory.ts
+var Factory = class {
+  processDetector;
+  stateNameDetector;
+  statemachineObservers = /* @__PURE__ */ new Set();
+  transitionSelector = null;
+  mutexFactory = null;
+  constructor(processDetector, stateNameDetector) {
+    this.processDetector = processDetector;
+    this.stateNameDetector = stateNameDetector ?? null;
+  }
+  setMutexFactory(factory) {
+    this.mutexFactory = factory;
+  }
+  setTransitionSelector(selector) {
+    this.transitionSelector = selector;
+  }
+  attachStatemachineObserver(observer) {
+    this.statemachineObservers.add(observer);
+  }
+  detachStatemachineObserver(observer) {
+    this.statemachineObservers.delete(observer);
+  }
+  getStatemachineObservers() {
+    return this.statemachineObservers;
+  }
+  async createStatemachine(subject) {
+    const process = this.processDetector.detectProcess(subject);
+    const stateName = this.stateNameDetector ? this.stateNameDetector.detectCurrentStateName(subject) : null;
+    const mutex = this.mutexFactory ? await this.mutexFactory.createMutex(subject) : null;
+    const statemachine = new Statemachine(
+      subject,
+      process,
+      stateName,
+      this.transitionSelector,
+      mutex
+    );
+    for (const observer of this.statemachineObservers) {
+      statemachine.attach(observer);
+    }
+    return statemachine;
+  }
+};
+
+// src/factory/SingleProcessDetector.ts
+var SingleProcessDetector = class {
+  process;
+  constructor(process) {
+    this.process = process;
+  }
+  detectProcess(_subject) {
+    return this.process;
+  }
+};
+
+// src/factory/AbstractNamedProcessDetector.ts
+var AbstractNamedProcessDetector = class {
+  processes = /* @__PURE__ */ new Map();
+  addProcess(process) {
+    this.processes.set(process.getName(), process);
+  }
+  hasProcess(name) {
+    return this.processes.has(name);
+  }
+  detectProcess(subject) {
+    const name = this.detectProcessName(subject);
+    const process = this.processes.get(name);
+    if (!process) {
+      throw new Error(`Process "${name}" not found`);
+    }
+    return process;
+  }
+};
+
+// src/factory/StatefulStateNameDetector.ts
+function isStateful2(obj) {
+  return typeof obj === "object" && obj !== null && "getCurrentStateName" in obj && typeof obj.getCurrentStateName === "function";
+}
+var StatefulStateNameDetector = class {
+  detectCurrentStateName(subject) {
+    if (isStateful2(subject)) {
+      return subject.getCurrentStateName();
+    }
+    throw new Error("Subject has to implement the StatefulInterface!");
+  }
+};
+
+// src/util/SetupHelper.ts
+var SetupHelper = class {
+  stateCollection;
+  constructor(stateCollection) {
+    this.stateCollection = stateCollection;
+  }
+  findOrCreateState(name) {
+    if (!this.stateCollection.hasState(name)) {
+      this.stateCollection.addState(new State(name));
+    }
+    return this.stateCollection.getState(name);
+  }
+  findTransition(sourceState, targetState, eventName = null, condition = null) {
+    const conditionName = condition ? condition.getName() : null;
+    for (const transition of sourceState.getTransitions()) {
+      const hasSameTargetState = transition.getTargetState() === targetState;
+      const hasSameCondition = transition.getConditionName() === conditionName;
+      const hasSameEvent = transition.getEventName() === eventName;
+      if (hasSameTargetState && hasSameCondition && hasSameEvent) {
+        return transition;
+      }
+    }
+    return null;
+  }
+  findOrCreateTransition(sourceStateName, targetStateName, eventName = null, condition = null) {
+    const sourceState = this.findOrCreateState(sourceStateName);
+    const targetState = this.findOrCreateState(targetStateName);
+    let transition = this.findTransition(
+      sourceState,
+      targetState,
+      eventName,
+      condition
+    );
+    if (!transition) {
+      transition = new Transition(targetState, eventName, condition);
+      sourceState.addTransition(transition);
+    }
+    return transition;
+  }
+  findOrCreateEvent(sourceStateName, eventName) {
+    const sourceState = this.findOrCreateState(sourceStateName);
+    return sourceState.getEvent(eventName);
+  }
+  addCommand(sourceStateName, eventName, command) {
+    this.findOrCreateEvent(sourceStateName, eventName).attach(command);
+  }
+  addCommandAndSelfTransition(sourceStateName, eventName, command) {
+    this.addCommand(sourceStateName, eventName, command);
+    this.findOrCreateTransition(sourceStateName, sourceStateName, eventName);
+  }
+};
+
+// src/graph/GraphBuilder.ts
+function isNamed2(obj) {
+  return typeof obj === "object" && obj !== null && "getName" in obj && typeof obj.getName === "function";
+}
+function escapeDoubleQuotes(str) {
+  return str.replace(/"/g, '\\"');
+}
+function toMermaidId(name) {
+  return "s_" + name.replace(
+    /[^a-zA-Z0-9]/g,
+    (ch) => `_${ch.charCodeAt(0).toString(16).padStart(4, "0")}`
+  );
+}
+function escapeMermaidLabel(str) {
+  return str.replace(/"/g, "#quot;");
+}
+function convertToString2(obj) {
+  if (isNamed2(obj)) {
+    return obj.getName();
+  }
+  return String(obj);
+}
+var GraphBuilder = class {
+  nodes = /* @__PURE__ */ new Map();
+  edges = [];
+  getOrCreateNode(state) {
+    const name = state.getName();
+    let node = this.nodes.get(name);
+    if (!node) {
+      node = { id: name, label: name, metadata: state.getMetadata() };
+      this.nodes.set(name, node);
+    }
+    return node;
+  }
+  getTransitionLabel(state, transition) {
+    const parts = [];
+    const eventName = transition.getEventName();
+    if (eventName) {
+      parts.push(`E: ${eventName}`);
+      const event = state.getEvent(eventName);
+      const observerNames = [];
+      for (const observer of event.getObservers()) {
+        observerNames.push(convertToString2(observer));
+      }
+      if (observerNames.length > 0) {
+        parts.push(`C: ${observerNames.join(", ")}`);
+      }
+    }
+    const conditionName = transition.getConditionName();
+    if (conditionName) {
+      parts.push(`IF: ${conditionName}`);
+    }
+    parts.push(`W: ${transition.getWeight()}`);
+    return parts.join("\n");
+  }
+  addState(state) {
+    this.getOrCreateNode(state);
+    for (const transition of state.getTransitions()) {
+      const sourceNode = this.getOrCreateNode(state);
+      const targetNode = this.getOrCreateNode(transition.getTargetState());
+      const label = this.getTransitionLabel(state, transition);
+      const metadata = {};
+      const eventName = transition.getEventName();
+      if (eventName && state.hasEvent(eventName)) {
+        Object.assign(metadata, state.getEvent(eventName).getMetadata());
+      }
+      this.edges.push({
+        source: sourceNode.id,
+        target: targetNode.id,
+        label,
+        metadata
+      });
+    }
+  }
+  addStates(states) {
+    for (const state of states) {
+      this.addState(state);
+    }
+  }
+  addStateCollection(stateCollection) {
+    this.addStates(stateCollection.getStates());
+  }
+  getGraph() {
+    return {
+      nodes: Array.from(this.nodes.values()),
+      edges: [...this.edges]
+    };
+  }
+  toDot(options) {
+    const graph = this.getGraph();
+    const rankdir = options?.rankdir ?? "LR";
+    const lines = [];
+    lines.push("digraph {");
+    lines.push(`  rankdir=${rankdir};`);
+    for (const node of graph.nodes) {
+      const label = escapeDoubleQuotes(node.label);
+      lines.push(`  "${label}" [label="${label}"];`);
+    }
+    for (const edge of graph.edges) {
+      const source = escapeDoubleQuotes(edge.source);
+      const target = escapeDoubleQuotes(edge.target);
+      const label = escapeDoubleQuotes(edge.label);
+      lines.push(`  "${source}" -> "${target}" [label="${label}"];`);
+    }
+    lines.push("}");
+    return lines.join("\n");
+  }
+  toMermaid(options) {
+    const graph = this.getGraph();
+    const direction = options?.direction ?? "LR";
+    const lines = [];
+    lines.push(`stateDiagram-v2`);
+    lines.push(`  direction ${direction}`);
+    const declared = /* @__PURE__ */ new Set();
+    for (const node of graph.nodes) {
+      const id = toMermaidId(node.id);
+      if (!declared.has(id)) {
+        declared.add(id);
+        const label = escapeMermaidLabel(node.label);
+        lines.push(`  ${id} : "${label}"`);
+      }
+    }
+    for (const edge of graph.edges) {
+      const source = toMermaidId(edge.source);
+      const target = toMermaidId(edge.target);
+      const label = escapeMermaidLabel(edge.label.replace(/\n/g, " / "));
+      lines.push(`  ${source} --> ${target} : ${label}`);
+    }
+    return lines.join("\n");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractNamedProcessDetector,
+  ActiveTransitionFilter,
+  AndComposite,
+  CallbackCondition,
+  CallbackObserver,
+  Contradiction,
+  Dispatcher,
+  DuplicateStateError,
+  Event,
+  Factory,
+  FilterStateByEvent,
+  FilterStateByFinalState,
+  FilterStateByTransition,
+  FilterTransitionByEvent,
+  GraphBuilder,
+  LockAdapterMutex,
+  LockCanNotBeAcquiredError,
+  MutexFactory,
+  Not,
+  NullMutex,
+  OnEnterObserver,
+  OneOrNoneActiveTransition,
+  OrComposite,
+  Process,
+  ScoreTransition,
+  SetupHelper,
+  SingleProcessDetector,
+  State,
+  StateCollection,
+  StateCollectionMerger,
+  StatefulStateNameDetector,
+  StatefulStatusChanger,
+  Statemachine,
+  Tautology,
+  Timeout,
+  Transition,
+  TransitionLogger,
+  WeightTransition,
+  WrongEventForStateError
+});
+//# sourceMappingURL=index.cjs.map