@axi-engine/states 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,132 @@
+let _axi_engine_utils = require("@axi-engine/utils");
+
+//#region src/state-machine.ts
+/**
+* A minimal, type-safe finite state machine.
+* It manages states, transitions, and associated lifecycle hooks (`onEnter`, `onExit`).
+*
+* @template T The type used for state identifiers (e.g., a string or an enum).
+* @template P The default payload type for state handlers. Can be overridden per state.
+* @example
+* enum PlayerState { Idle, Walk, Run }
+*
+* const playerFsm = new StateMachine<PlayerState>();
+*
+* playerFsm.register(PlayerState.Idle, () => console.log('Player is now idle.'));
+* playerFsm.register(PlayerState.Walk, () => console.log('Player is walking.'));
+*
+* async function start() {
+*   await playerFsm.call(PlayerState.Idle);
+*   await playerFsm.call(PlayerState.Walk);
+* }
+*/
+var StateMachine = class {
+	/**
+	* @protected
+	* The internal representation of the current state.
+	*/
+	_state;
+	/**
+	* @protected
+	* A map storing all registered state configurations.
+	*/
+	states = /* @__PURE__ */ new Map();
+	/**
+	* Public emitter that fires an event whenever the state changes.
+	* The event provides the old state, the new state, and the payload.
+	* @see Emitter
+	* @example
+	* fsm.onChange.subscribe((from, to, payload) => {
+	*   console.log(`State transitioned from ${from} to ${to}`);
+	* });
+	*/
+	onChange = new _axi_engine_utils.Emitter();
+	/**
+	* Gets the current state of the machine.
+	* @returns The current state identifier, or `undefined` if the machine has not been started.
+	*/
+	get state() {
+		return this._state;
+	}
+	/**
+	* Registers a state and its associated handler or configuration.
+	* If a handler is already registered for the given state, it will be overwritten.
+	*
+	* @param state The identifier for the state to register.
+	* @param handler A handler function (`onEnter`) or a full configuration object.
+	* @example
+	* // Simple registration
+	* fsm.register(MyState.Idle, () => console.log('Entering Idle'));
+	*
+	* // Advanced registration
+	* fsm.register(MyState.Walking, {
+	*   onEnter: () => console.log('Start walking animation'),
+	*   onExit: () => console.log('Stop walking animation'),
+	*   allowedFrom: [MyState.Idle]
+	* });
+	*/
+	register(state, handler) {
+		if ((0, _axi_engine_utils.isUndefined)(handler) || typeof handler === "function") this.states.set(state, { onEnter: handler });
+		else this.states.set(state, handler);
+	}
+	/**
+	* Transitions the machine to a new state.
+	* This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
+	* It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
+	*
+	* @param newState The identifier of the state to transition to.
+	* @param payload An optional payload to pass to the new state's `onEnter` handler.
+	* @returns A promise that resolves when the transition is complete.
+	* @throws {Error} if the `newState` has not been registered.
+	* @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
+	* @example
+	* try {
+	*   await fsm.call(PlayerState.Run, { speed: 10 });
+	* } catch (e) {
+	*   console.error('State transition failed:', e.message);
+	* }
+	*/
+	async call(newState, payload) {
+		const oldState = this._state;
+		const oldStateConfig = this._state ? this.states.get(this._state) : void 0;
+		const newStateConfig = this.states.get(newState);
+		(0, _axi_engine_utils.throwIfEmpty)(newStateConfig, `State ${String(newState)} is not registered.`);
+		(0, _axi_engine_utils.throwIf)(!(0, _axi_engine_utils.isNullOrUndefined)(newStateConfig.allowedFrom) && !(0, _axi_engine_utils.isNullOrUndefined)(oldState) && !newStateConfig.allowedFrom.includes(oldState), `Transition from ${String(oldState)} to ${String(newState)} is not allowed.`);
+		await oldStateConfig?.onExit?.();
+		this._state = newState;
+		await newStateConfig.onEnter?.(payload);
+		this.onChange.emit(oldState, newState, payload);
+	}
+	/**
+	* Removes a single state configuration from the machine.
+	* If the removed state is the currently active one, the machine's state will be reset to `undefined`.
+	*
+	* @param state The identifier of the state to remove.
+	* @returns `true` if the state was found and removed, otherwise `false`.
+	* @example
+	* fsm.register(MyState.Temp, () => {});
+	* // ...
+	* const wasRemoved = fsm.unregister(MyState.Temp);
+	* console.log('Temporary state removed:', wasRemoved);
+	*/
+	unregister(state) {
+		if (this._state === state) this._state = void 0;
+		return this.states.delete(state);
+	}
+	/**
+	* Removes all registered states and resets the machine to its initial, undefined state.
+	* This does not clear `onChange` subscribers.
+	* @example
+	* fsm.register(MyState.One);
+	* fsm.register(MyState.Two);
+	* // ...
+	* fsm.clear(); // The machine is now empty.
+	*/
+	clear() {
+		this.states.clear();
+		this._state = void 0;
+	}
+};
+
+//#endregion
+exports.StateMachine = StateMachine;

package/dist/index.d.cts

@@ -0,0 +1,120 @@
+import { Emitter } from "@axi-engine/utils";
+
+//#region src/state-handler.d.ts
+type StateHandler<P = void> = P extends void ? () => void | Promise<void> : (payload: P) => void | Promise<void>;
+interface StateHandlerConfig<T, P = void> {
+  onEnter?: StateHandler<P>;
+  onExit?: () => void | Promise<void>;
+  allowedFrom?: T[];
+}
+type StateHandlerRegistration<T, P = void> = StateHandler<P> | StateHandlerConfig<T, P>;
+//#endregion
+//#region src/state-machine.d.ts
+/**
+ * A minimal, type-safe finite state machine.
+ * It manages states, transitions, and associated lifecycle hooks (`onEnter`, `onExit`).
+ *
+ * @template T The type used for state identifiers (e.g., a string or an enum).
+ * @template P The default payload type for state handlers. Can be overridden per state.
+ * @example
+ * enum PlayerState { Idle, Walk, Run }
+ *
+ * const playerFsm = new StateMachine<PlayerState>();
+ *
+ * playerFsm.register(PlayerState.Idle, () => console.log('Player is now idle.'));
+ * playerFsm.register(PlayerState.Walk, () => console.log('Player is walking.'));
+ *
+ * async function start() {
+ *   await playerFsm.call(PlayerState.Idle);
+ *   await playerFsm.call(PlayerState.Walk);
+ * }
+ */
+declare class StateMachine<T, P = void> {
+  /**
+       * @protected
+       * The internal representation of the current state.
+       */
+  protected _state?: T;
+  /**
+       * @protected
+       * A map storing all registered state configurations.
+       */
+  protected states: Map<T, StateHandlerConfig<T, P> | undefined>;
+  /**
+       * Public emitter that fires an event whenever the state changes.
+       * The event provides the old state, the new state, and the payload.
+       * @see Emitter
+       * @example
+       * fsm.onChange.subscribe((from, to, payload) => {
+       *   console.log(`State transitioned from ${from} to ${to}`);
+       * });
+       */
+  readonly onChange: Emitter<[from?: T | undefined, to?: T | undefined, payload?: P | undefined]>;
+  /**
+       * Gets the current state of the machine.
+       * @returns The current state identifier, or `undefined` if the machine has not been started.
+       */
+  get state(): T | undefined;
+  /**
+       * Registers a state and its associated handler or configuration.
+       * If a handler is already registered for the given state, it will be overwritten.
+       *
+       * @param state The identifier for the state to register.
+       * @param handler A handler function (`onEnter`) or a full configuration object.
+       * @example
+       * // Simple registration
+       * fsm.register(MyState.Idle, () => console.log('Entering Idle'));
+       *
+       * // Advanced registration
+       * fsm.register(MyState.Walking, {
+       *   onEnter: () => console.log('Start walking animation'),
+       *   onExit: () => console.log('Stop walking animation'),
+       *   allowedFrom: [MyState.Idle]
+       * });
+       */
+  register(state: T, handler?: StateHandlerRegistration<T, P>): void;
+  /**
+       * Transitions the machine to a new state.
+       * This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
+       * It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
+       *
+       * @param newState The identifier of the state to transition to.
+       * @param payload An optional payload to pass to the new state's `onEnter` handler.
+       * @returns A promise that resolves when the transition is complete.
+       * @throws {Error} if the `newState` has not been registered.
+       * @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
+       * @example
+       * try {
+       *   await fsm.call(PlayerState.Run, { speed: 10 });
+       * } catch (e) {
+       *   console.error('State transition failed:', e.message);
+       * }
+       */
+  call(newState: T, payload?: P): Promise<void>;
+  /**
+       * Removes a single state configuration from the machine.
+       * If the removed state is the currently active one, the machine's state will be reset to `undefined`.
+       *
+       * @param state The identifier of the state to remove.
+       * @returns `true` if the state was found and removed, otherwise `false`.
+       * @example
+       * fsm.register(MyState.Temp, () => {});
+       * // ...
+       * const wasRemoved = fsm.unregister(MyState.Temp);
+       * console.log('Temporary state removed:', wasRemoved);
+       */
+  unregister(state: T): boolean;
+  /**
+       * Removes all registered states and resets the machine to its initial, undefined state.
+       * This does not clear `onChange` subscribers.
+       * @example
+       * fsm.register(MyState.One);
+       * fsm.register(MyState.Two);
+       * // ...
+       * fsm.clear(); // The machine is now empty.
+       */
+  clear(): void;
+}
+//#endregion
+export { StateHandler, StateHandlerConfig, StateHandlerRegistration, StateMachine };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/state-handler.ts","../src/state-machine.ts"],"mappings":";;;KAAY,YAAA,aACV,CAAA,6BACe,OAAA,UAAA,OAAA,EACD,CAAA,YAAa,OAAA;AAAA,UAGZ,kBAAA;EAAA,OAAA,GACL,YAAA,CAAa,CAAA;EAAA,MAAA,gBACD,OAAA;EAAA,WAAA,GACR,CAAA;AAAA;AAAA,KAGJ,wBAAA,gBAAwC,YAAA,CAAa,CAAA,IAAK,kBAAA,CAAmB,CAAA,EAAG,CAAA;;;;ACW5F;;;;;;;;;;;;;;;;;;cAAa,YAAA;EAAA;;;;EAAA,UAAA,MAAA,GAKQ,CAAA;EAAA;;;;EAAA,UAAA,MAAA,EAMD,GAAA,CAAI,CAAA,EAAG,kBAAA,CAAmB,CAAA,EAAG,CAAA;EAAA;;;;;;;;;EAAA,SAAA,QAAA,EAW9B,OAAA,EAAA,IAAA,GAAA,CAAA,cAAA,EAAA,GAAA,CAAA,cAAA,OAAA,GAAA,CAAA;EAAA;;;;EAAA,IAAA,MAAA,GAMJ,CAAA;EAAA;;;;;;;;;;;;;;;;;EAAA,SAAA,KAAA,EAqBG,CAAA,EAAA,OAAA,GAAa,wBAAA,CAAyB,CAAA,EAAG,CAAA;EAAA;;;;;;;;;;;;;;;;;EAAA,KAAA,QAAA,EAyBpC,CAAA,EAAA,OAAA,GAAa,CAAA,GAAI,OAAA;EAAA;;;;;;;;;;;;EAAA,WAAA,KAAA,EAmCpB,CAAA;EAAA;;;;;;;;;EAAA,MAAA;AAAA"}

package/dist/index.d.mts

@@ -1,13 +1,15 @@
-import { Emitter } from '@axi-engine/utils';
+import { Emitter } from "@axi-engine/utils";
 
+//#region src/state-handler.d.ts
 type StateHandler<P = void> = P extends void ? () => void | Promise<void> : (payload: P) => void | Promise<void>;
 interface StateHandlerConfig<T, P = void> {
-    onEnter?: StateHandler<P>;
-    onExit?: () => void | Promise<void>;
-    allowedFrom?: T[];
+  onEnter?: StateHandler<P>;
+  onExit?: () => void | Promise<void>;
+  allowedFrom?: T[];
 }
 type StateHandlerRegistration<T, P = void> = StateHandler<P> | StateHandlerConfig<T, P>;
-
+//#endregion
+//#region src/state-machine.d.ts
 /**
  * A minimal, type-safe finite state machine.
  * It manages states, transitions, and associated lifecycle hooks (`onEnter`, `onExit`).
@@ -28,90 +30,91 @@ type StateHandlerRegistration<T, P = void> = StateHandler<P> | StateHandlerConfi
  * }
  */
 declare class StateMachine<T, P = void> {
-    /**
-     * @protected
-     * The internal representation of the current state.
-     */
-    protected _state?: T;
-    /**
-     * @protected
-     * A map storing all registered state configurations.
-     */
-    protected states: Map<T, StateHandlerConfig<T, P> | undefined>;
-    /**
-     * Public emitter that fires an event whenever the state changes.
-     * The event provides the old state, the new state, and the payload.
-     * @see Emitter
-     * @example
-     * fsm.onChange.subscribe((from, to, payload) => {
-     *   console.log(`State transitioned from ${from} to ${to}`);
-     * });
-     */
-    readonly onChange: Emitter<[from?: T | undefined, to?: T | undefined, payload?: P | undefined]>;
-    /**
-     * Gets the current state of the machine.
-     * @returns The current state identifier, or `undefined` if the machine has not been started.
-     */
-    get state(): T | undefined;
-    /**
-     * Registers a state and its associated handler or configuration.
-     * If a handler is already registered for the given state, it will be overwritten.
-     *
-     * @param state The identifier for the state to register.
-     * @param handler A handler function (`onEnter`) or a full configuration object.
-     * @example
-     * // Simple registration
-     * fsm.register(MyState.Idle, () => console.log('Entering Idle'));
-     *
-     * // Advanced registration
-     * fsm.register(MyState.Walking, {
-     *   onEnter: () => console.log('Start walking animation'),
-     *   onExit: () => console.log('Stop walking animation'),
-     *   allowedFrom: [MyState.Idle]
-     * });
-     */
-    register(state: T, handler?: StateHandlerRegistration<T, P>): void;
-    /**
-     * Transitions the machine to a new state.
-     * This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
-     * It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
-     *
-     * @param newState The identifier of the state to transition to.
-     * @param payload An optional payload to pass to the new state's `onEnter` handler.
-     * @returns A promise that resolves when the transition is complete.
-     * @throws {Error} if the `newState` has not been registered.
-     * @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
-     * @example
-     * try {
-     *   await fsm.call(PlayerState.Run, { speed: 10 });
-     * } catch (e) {
-     *   console.error('State transition failed:', e.message);
-     * }
-     */
-    call(newState: T, payload?: P): Promise<void>;
-    /**
-     * Removes a single state configuration from the machine.
-     * If the removed state is the currently active one, the machine's state will be reset to `undefined`.
-     *
-     * @param state The identifier of the state to remove.
-     * @returns `true` if the state was found and removed, otherwise `false`.
-     * @example
-     * fsm.register(MyState.Temp, () => {});
-     * // ...
-     * const wasRemoved = fsm.unregister(MyState.Temp);
-     * console.log('Temporary state removed:', wasRemoved);
-     */
-    unregister(state: T): boolean;
-    /**
-     * Removes all registered states and resets the machine to its initial, undefined state.
-     * This does not clear `onChange` subscribers.
-     * @example
-     * fsm.register(MyState.One);
-     * fsm.register(MyState.Two);
-     * // ...
-     * fsm.clear(); // The machine is now empty.
-     */
-    clear(): void;
+  /**
+       * @protected
+       * The internal representation of the current state.
+       */
+  protected _state?: T;
+  /**
+       * @protected
+       * A map storing all registered state configurations.
+       */
+  protected states: Map<T, StateHandlerConfig<T, P> | undefined>;
+  /**
+       * Public emitter that fires an event whenever the state changes.
+       * The event provides the old state, the new state, and the payload.
+       * @see Emitter
+       * @example
+       * fsm.onChange.subscribe((from, to, payload) => {
+       *   console.log(`State transitioned from ${from} to ${to}`);
+       * });
+       */
+  readonly onChange: Emitter<[from?: T | undefined, to?: T | undefined, payload?: P | undefined]>;
+  /**
+       * Gets the current state of the machine.
+       * @returns The current state identifier, or `undefined` if the machine has not been started.
+       */
+  get state(): T | undefined;
+  /**
+       * Registers a state and its associated handler or configuration.
+       * If a handler is already registered for the given state, it will be overwritten.
+       *
+       * @param state The identifier for the state to register.
+       * @param handler A handler function (`onEnter`) or a full configuration object.
+       * @example
+       * // Simple registration
+       * fsm.register(MyState.Idle, () => console.log('Entering Idle'));
+       *
+       * // Advanced registration
+       * fsm.register(MyState.Walking, {
+       *   onEnter: () => console.log('Start walking animation'),
+       *   onExit: () => console.log('Stop walking animation'),
+       *   allowedFrom: [MyState.Idle]
+       * });
+       */
+  register(state: T, handler?: StateHandlerRegistration<T, P>): void;
+  /**
+       * Transitions the machine to a new state.
+       * This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
+       * It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
+       *
+       * @param newState The identifier of the state to transition to.
+       * @param payload An optional payload to pass to the new state's `onEnter` handler.
+       * @returns A promise that resolves when the transition is complete.
+       * @throws {Error} if the `newState` has not been registered.
+       * @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
+       * @example
+       * try {
+       *   await fsm.call(PlayerState.Run, { speed: 10 });
+       * } catch (e) {
+       *   console.error('State transition failed:', e.message);
+       * }
+       */
+  call(newState: T, payload?: P): Promise<void>;
+  /**
+       * Removes a single state configuration from the machine.
+       * If the removed state is the currently active one, the machine's state will be reset to `undefined`.
+       *
+       * @param state The identifier of the state to remove.
+       * @returns `true` if the state was found and removed, otherwise `false`.
+       * @example
+       * fsm.register(MyState.Temp, () => {});
+       * // ...
+       * const wasRemoved = fsm.unregister(MyState.Temp);
+       * console.log('Temporary state removed:', wasRemoved);
+       */
+  unregister(state: T): boolean;
+  /**
+       * Removes all registered states and resets the machine to its initial, undefined state.
+       * This does not clear `onChange` subscribers.
+       * @example
+       * fsm.register(MyState.One);
+       * fsm.register(MyState.Two);
+       * // ...
+       * fsm.clear(); // The machine is now empty.
+       */
+  clear(): void;
 }
-
-export { type StateHandler, type StateHandlerConfig, type StateHandlerRegistration, StateMachine };
+//#endregion
+export { StateHandler, StateHandlerConfig, StateHandlerRegistration, StateMachine };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/state-handler.ts","../src/state-machine.ts"],"mappings":";;;KAAY,YAAA,aACV,CAAA,6BACe,OAAA,UAAA,OAAA,EACD,CAAA,YAAa,OAAA;AAAA,UAGZ,kBAAA;EAAA,OAAA,GACL,YAAA,CAAa,CAAA;EAAA,MAAA,gBACD,OAAA;EAAA,WAAA,GACR,CAAA;AAAA;AAAA,KAGJ,wBAAA,gBAAwC,YAAA,CAAa,CAAA,IAAK,kBAAA,CAAmB,CAAA,EAAG,CAAA;;;;ACW5F;;;;;;;;;;;;;;;;;;cAAa,YAAA;EAAA;;;;EAAA,UAAA,MAAA,GAKQ,CAAA;EAAA;;;;EAAA,UAAA,MAAA,EAMD,GAAA,CAAI,CAAA,EAAG,kBAAA,CAAmB,CAAA,EAAG,CAAA;EAAA;;;;;;;;;EAAA,SAAA,QAAA,EAW9B,OAAA,EAAA,IAAA,GAAA,CAAA,cAAA,EAAA,GAAA,CAAA,cAAA,OAAA,GAAA,CAAA;EAAA;;;;EAAA,IAAA,MAAA,GAMJ,CAAA;EAAA;;;;;;;;;;;;;;;;;EAAA,SAAA,KAAA,EAqBG,CAAA,EAAA,OAAA,GAAa,wBAAA,CAAyB,CAAA,EAAG,CAAA;EAAA;;;;;;;;;;;;;;;;;EAAA,KAAA,QAAA,EAyBpC,CAAA,EAAA,OAAA,GAAa,CAAA,GAAI,OAAA;EAAA;;;;;;;;;;;;EAAA,WAAA,KAAA,EAmCpB,CAAA;EAAA;;;;;;;;;EAAA,MAAA;AAAA"}

package/dist/index.mjs

@@ -1,117 +1,133 @@
-// src/state-machine.ts
 import { Emitter, isNullOrUndefined, isUndefined, throwIf, throwIfEmpty } from "@axi-engine/utils";
+
+//#region src/state-machine.ts
+/**
+* A minimal, type-safe finite state machine.
+* It manages states, transitions, and associated lifecycle hooks (`onEnter`, `onExit`).
+*
+* @template T The type used for state identifiers (e.g., a string or an enum).
+* @template P The default payload type for state handlers. Can be overridden per state.
+* @example
+* enum PlayerState { Idle, Walk, Run }
+*
+* const playerFsm = new StateMachine<PlayerState>();
+*
+* playerFsm.register(PlayerState.Idle, () => console.log('Player is now idle.'));
+* playerFsm.register(PlayerState.Walk, () => console.log('Player is walking.'));
+*
+* async function start() {
+*   await playerFsm.call(PlayerState.Idle);
+*   await playerFsm.call(PlayerState.Walk);
+* }
+*/
 var StateMachine = class {
-  constructor() {
-    /**
-     * @protected
-     * A map storing all registered state configurations.
-     */
-    this.states = /* @__PURE__ */ new Map();
-    /**
-     * Public emitter that fires an event whenever the state changes.
-     * The event provides the old state, the new state, and the payload.
-     * @see Emitter
-     * @example
-     * fsm.onChange.subscribe((from, to, payload) => {
-     *   console.log(`State transitioned from ${from} to ${to}`);
-     * });
-     */
-    this.onChange = new Emitter();
-  }
-  /**
-   * Gets the current state of the machine.
-   * @returns The current state identifier, or `undefined` if the machine has not been started.
-   */
-  get state() {
-    return this._state;
-  }
-  /**
-   * Registers a state and its associated handler or configuration.
-   * If a handler is already registered for the given state, it will be overwritten.
-   *
-   * @param state The identifier for the state to register.
-   * @param handler A handler function (`onEnter`) or a full configuration object.
-   * @example
-   * // Simple registration
-   * fsm.register(MyState.Idle, () => console.log('Entering Idle'));
-   *
-   * // Advanced registration
-   * fsm.register(MyState.Walking, {
-   *   onEnter: () => console.log('Start walking animation'),
-   *   onExit: () => console.log('Stop walking animation'),
-   *   allowedFrom: [MyState.Idle]
-   * });
-   */
-  register(state, handler) {
-    if (isUndefined(handler) || typeof handler === "function") {
-      this.states.set(state, { onEnter: handler });
-    } else {
-      this.states.set(state, handler);
-    }
-  }
-  /**
-   * Transitions the machine to a new state.
-   * This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
-   * It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
-   *
-   * @param newState The identifier of the state to transition to.
-   * @param payload An optional payload to pass to the new state's `onEnter` handler.
-   * @returns A promise that resolves when the transition is complete.
-   * @throws {Error} if the `newState` has not been registered.
-   * @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
-   * @example
-   * try {
-   *   await fsm.call(PlayerState.Run, { speed: 10 });
-   * } catch (e) {
-   *   console.error('State transition failed:', e.message);
-   * }
-   */
-  async call(newState, payload) {
-    const oldState = this._state;
-    const oldStateConfig = this._state ? this.states.get(this._state) : void 0;
-    const newStateConfig = this.states.get(newState);
-    throwIfEmpty(newStateConfig, `State ${String(newState)} is not registered.`);
-    throwIf(
-      !isNullOrUndefined(newStateConfig.allowedFrom) && !isNullOrUndefined(oldState) && !newStateConfig.allowedFrom.includes(oldState),
-      `Transition from ${String(oldState)} to ${String(newState)} is not allowed.`
-    );
-    await oldStateConfig?.onExit?.();
-    this._state = newState;
-    await newStateConfig.onEnter?.(payload);
-    this.onChange.emit(oldState, newState, payload);
-  }
-  /**
-   * Removes a single state configuration from the machine.
-   * If the removed state is the currently active one, the machine's state will be reset to `undefined`.
-   *
-   * @param state The identifier of the state to remove.
-   * @returns `true` if the state was found and removed, otherwise `false`.
-   * @example
-   * fsm.register(MyState.Temp, () => {});
-   * // ...
-   * const wasRemoved = fsm.unregister(MyState.Temp);
-   * console.log('Temporary state removed:', wasRemoved);
-   */
-  unregister(state) {
-    if (this._state === state) {
-      this._state = void 0;
-    }
-    return this.states.delete(state);
-  }
-  /**
-   * Removes all registered states and resets the machine to its initial, undefined state.
-   * This does not clear `onChange` subscribers.
-   * @example
-   * fsm.register(MyState.One);
-   * fsm.register(MyState.Two);
-   * // ...
-   * fsm.clear(); // The machine is now empty.
-   */
-  clear() {
-    this.states.clear();
-    this._state = void 0;
-  }
-};
-export {
-  StateMachine
+	/**
+	* @protected
+	* The internal representation of the current state.
+	*/
+	_state;
+	/**
+	* @protected
+	* A map storing all registered state configurations.
+	*/
+	states = /* @__PURE__ */ new Map();
+	/**
+	* Public emitter that fires an event whenever the state changes.
+	* The event provides the old state, the new state, and the payload.
+	* @see Emitter
+	* @example
+	* fsm.onChange.subscribe((from, to, payload) => {
+	*   console.log(`State transitioned from ${from} to ${to}`);
+	* });
+	*/
+	onChange = new Emitter();
+	/**
+	* Gets the current state of the machine.
+	* @returns The current state identifier, or `undefined` if the machine has not been started.
+	*/
+	get state() {
+		return this._state;
+	}
+	/**
+	* Registers a state and its associated handler or configuration.
+	* If a handler is already registered for the given state, it will be overwritten.
+	*
+	* @param state The identifier for the state to register.
+	* @param handler A handler function (`onEnter`) or a full configuration object.
+	* @example
+	* // Simple registration
+	* fsm.register(MyState.Idle, () => console.log('Entering Idle'));
+	*
+	* // Advanced registration
+	* fsm.register(MyState.Walking, {
+	*   onEnter: () => console.log('Start walking animation'),
+	*   onExit: () => console.log('Stop walking animation'),
+	*   allowedFrom: [MyState.Idle]
+	* });
+	*/
+	register(state, handler) {
+		if (isUndefined(handler) || typeof handler === "function") this.states.set(state, { onEnter: handler });
+		else this.states.set(state, handler);
+	}
+	/**
+	* Transitions the machine to a new state.
+	* This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
+	* It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
+	*
+	* @param newState The identifier of the state to transition to.
+	* @param payload An optional payload to pass to the new state's `onEnter` handler.
+	* @returns A promise that resolves when the transition is complete.
+	* @throws {Error} if the `newState` has not been registered.
+	* @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
+	* @example
+	* try {
+	*   await fsm.call(PlayerState.Run, { speed: 10 });
+	* } catch (e) {
+	*   console.error('State transition failed:', e.message);
+	* }
+	*/
+	async call(newState, payload) {
+		const oldState = this._state;
+		const oldStateConfig = this._state ? this.states.get(this._state) : void 0;
+		const newStateConfig = this.states.get(newState);
+		throwIfEmpty(newStateConfig, `State ${String(newState)} is not registered.`);
+		throwIf(!isNullOrUndefined(newStateConfig.allowedFrom) && !isNullOrUndefined(oldState) && !newStateConfig.allowedFrom.includes(oldState), `Transition from ${String(oldState)} to ${String(newState)} is not allowed.`);
+		await oldStateConfig?.onExit?.();
+		this._state = newState;
+		await newStateConfig.onEnter?.(payload);
+		this.onChange.emit(oldState, newState, payload);
+	}
+	/**
+	* Removes a single state configuration from the machine.
+	* If the removed state is the currently active one, the machine's state will be reset to `undefined`.
+	*
+	* @param state The identifier of the state to remove.
+	* @returns `true` if the state was found and removed, otherwise `false`.
+	* @example
+	* fsm.register(MyState.Temp, () => {});
+	* // ...
+	* const wasRemoved = fsm.unregister(MyState.Temp);
+	* console.log('Temporary state removed:', wasRemoved);
+	*/
+	unregister(state) {
+		if (this._state === state) this._state = void 0;
+		return this.states.delete(state);
+	}
+	/**
+	* Removes all registered states and resets the machine to its initial, undefined state.
+	* This does not clear `onChange` subscribers.
+	* @example
+	* fsm.register(MyState.One);
+	* fsm.register(MyState.Two);
+	* // ...
+	* fsm.clear(); // The machine is now empty.
+	*/
+	clear() {
+		this.states.clear();
+		this._state = void 0;
+	}
 };
+
+//#endregion
+export { StateMachine };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/state-machine.ts"],"sourcesContent":["import {StateHandlerConfig, StateHandlerRegistration} from \"./state-handler\";\r\nimport {Emitter, isNullOrUndefined, isUndefined, throwIf, throwIfEmpty} from '@axi-engine/utils';\r\n\r\n\r\n/**\r\n * A minimal, type-safe finite state machine.\r\n * It manages states, transitions, and associated lifecycle hooks (`onEnter`, `onExit`).\r\n *\r\n * @template T The type used for state identifiers (e.g., a string or an enum).\r\n * @template P The default payload type for state handlers. Can be overridden per state.\r\n * @example\r\n * enum PlayerState { Idle, Walk, Run }\r\n *\r\n * const playerFsm = new StateMachine<PlayerState>();\r\n *\r\n * playerFsm.register(PlayerState.Idle, () => console.log('Player is now idle.'));\r\n * playerFsm.register(PlayerState.Walk, () => console.log('Player is walking.'));\r\n *\r\n * async function start() {\r\n *   await playerFsm.call(PlayerState.Idle);\r\n *   await playerFsm.call(PlayerState.Walk);\r\n * }\r\n */\r\nexport class StateMachine<T, P = void> {\r\n  /**\r\n   * @protected\r\n   * The internal representation of the current state.\r\n   */\r\n  protected _state?: T;\r\n\r\n  /**\r\n   * @protected\r\n   * A map storing all registered state configurations.\r\n   */\r\n  protected states: Map<T, StateHandlerConfig<T, P> | undefined> = new Map();\r\n\r\n  /**\r\n   * Public emitter that fires an event whenever the state changes.\r\n   * The event provides the old state, the new state, and the payload.\r\n   * @see Emitter\r\n   * @example\r\n   * fsm.onChange.subscribe((from, to, payload) => {\r\n   *   console.log(`State transitioned from ${from} to ${to}`);\r\n   * });\r\n   */\r\n  readonly onChange = new Emitter<[from?: T, to?: T, payload?: P]>();\r\n\r\n  /**\r\n   * Gets the current state of the machine.\r\n   * @returns The current state identifier, or `undefined` if the machine has not been started.\r\n   */\r\n  get state(): T | undefined {\r\n    return this._state;\r\n  }\r\n\r\n  /**\r\n   * Registers a state and its associated handler or configuration.\r\n   * If a handler is already registered for the given state, it will be overwritten.\r\n   *\r\n   * @param state The identifier for the state to register.\r\n   * @param handler A handler function (`onEnter`) or a full configuration object.\r\n   * @example\r\n   * // Simple registration\r\n   * fsm.register(MyState.Idle, () => console.log('Entering Idle'));\r\n   *\r\n   * // Advanced registration\r\n   * fsm.register(MyState.Walking, {\r\n   *   onEnter: () => console.log('Start walking animation'),\r\n   *   onExit: () => console.log('Stop walking animation'),\r\n   *   allowedFrom: [MyState.Idle]\r\n   * });\r\n   */\r\n  register(state: T, handler?: StateHandlerRegistration<T, P>): void {\r\n    if (isUndefined(handler) || typeof handler === 'function') {\r\n      this.states.set(state, {onEnter: handler});\r\n    } else {\r\n      this.states.set(state, handler);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Transitions the machine to a new state.\r\n   * This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.\r\n   * It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.\r\n   *\r\n   * @param newState The identifier of the state to transition to.\r\n   * @param payload An optional payload to pass to the new state's `onEnter` handler.\r\n   * @returns A promise that resolves when the transition is complete.\r\n   * @throws {Error} if the `newState` has not been registered.\r\n   * @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.\r\n   * @example\r\n   * try {\r\n   *   await fsm.call(PlayerState.Run, { speed: 10 });\r\n   * } catch (e) {\r\n   *   console.error('State transition failed:', e.message);\r\n   * }\r\n   */\r\n  async call(newState: T, payload?: P): Promise<void> {\r\n    const oldState = this._state;\r\n    const oldStateConfig = this._state ? this.states.get(this._state) : undefined;\r\n    const newStateConfig = this.states.get(newState);\r\n\r\n    throwIfEmpty(newStateConfig, `State ${String(newState)} is not registered.`);\r\n\r\n    throwIf(\r\n      !isNullOrUndefined(newStateConfig.allowedFrom) &&\r\n      !isNullOrUndefined(oldState) &&\r\n      !newStateConfig.allowedFrom.includes(oldState),\r\n      `Transition from ${String(oldState)} to ${String(newState)} is not allowed.`\r\n    );\r\n\r\n    await oldStateConfig?.onExit?.();\r\n\r\n    this._state = newState;\r\n\r\n    await (newStateConfig.onEnter as (payload?: P) => void | Promise<void>)?.(payload);\r\n\r\n    this.onChange.emit(oldState, newState, payload);\r\n  }\r\n\r\n  /**\r\n   * Removes a single state configuration from the machine.\r\n   * If the removed state is the currently active one, the machine's state will be reset to `undefined`.\r\n   *\r\n   * @param state The identifier of the state to remove.\r\n   * @returns `true` if the state was found and removed, otherwise `false`.\r\n   * @example\r\n   * fsm.register(MyState.Temp, () => {});\r\n   * // ...\r\n   * const wasRemoved = fsm.unregister(MyState.Temp);\r\n   * console.log('Temporary state removed:', wasRemoved);\r\n   */\r\n  unregister(state: T): boolean {\r\n    if (this._state === state) {\r\n      this._state = undefined;\r\n    }\r\n    return this.states.delete(state);\r\n  }\r\n\r\n  /**\r\n   * Removes all registered states and resets the machine to its initial, undefined state.\r\n   * This does not clear `onChange` subscribers.\r\n   * @example\r\n   * fsm.register(MyState.One);\r\n   * fsm.register(MyState.Two);\r\n   * // ...\r\n   * fsm.clear(); // The machine is now empty.\r\n   */\r\n  clear(): void {\r\n    this.states.clear();\r\n    this._state = undefined;\r\n  }\r\n}\r\n\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,eAAb,MAAuC;;;;;CAKrC,AAAU;;;;;CAMV,AAAU,yBAAuD,IAAI,KAAK;;;;;;;;;;CAW1E,AAAS,WAAW,IAAI,SAA0C;;;;;CAMlE,IAAI,QAAuB;AACzB,SAAO,KAAK;;;;;;;;;;;;;;;;;;;CAoBd,SAAS,OAAU,SAAgD;AACjE,MAAI,YAAY,QAAQ,IAAI,OAAO,YAAY,WAC7C,MAAK,OAAO,IAAI,OAAO,EAAC,SAAS,SAAQ,CAAC;MAE1C,MAAK,OAAO,IAAI,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;CAqBnC,MAAM,KAAK,UAAa,SAA4B;EAClD,MAAM,WAAW,KAAK;EACtB,MAAM,iBAAiB,KAAK,SAAS,KAAK,OAAO,IAAI,KAAK,OAAO,GAAG;EACpE,MAAM,iBAAiB,KAAK,OAAO,IAAI,SAAS;AAEhD,eAAa,gBAAgB,SAAS,OAAO,SAAS,CAAC,qBAAqB;AAE5E,UACE,CAAC,kBAAkB,eAAe,YAAY,IAC9C,CAAC,kBAAkB,SAAS,IAC5B,CAAC,eAAe,YAAY,SAAS,SAAS,EAC9C,mBAAmB,OAAO,SAAS,CAAC,MAAM,OAAO,SAAS,CAAC,kBAC5D;AAED,QAAM,gBAAgB,UAAU;AAEhC,OAAK,SAAS;AAEd,QAAO,eAAe,UAAoD,QAAQ;AAElF,OAAK,SAAS,KAAK,UAAU,UAAU,QAAQ;;;;;;;;;;;;;;CAejD,WAAW,OAAmB;AAC5B,MAAI,KAAK,WAAW,MAClB,MAAK,SAAS;AAEhB,SAAO,KAAK,OAAO,OAAO,MAAM;;;;;;;;;;;CAYlC,QAAc;AACZ,OAAK,OAAO,OAAO;AACnB,OAAK,SAAS"}

package/package.json

@@ -1,39 +1,47 @@
-{
-  "name": "@axi-engine/states",
-  "version": "0.1.0",
-  "description": "A minimal, type-safe state machine for the Axi Engine, designed for managing game logic and component states with a simple API.",
-  "license": "MIT",
-  "keywords": [
-    "axi-engine",
-    "typescript",
-    "gamedev",
-    "game-development",
-    "game-engine",
-    "state-machine",
-    "finite-state-machine",
-    "fsm",
-    "state-management",
-    "events"
-  ],
-  "types": "./dist/index.d.ts",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "build": "tsup",
-    "docs": "typedoc src/index.ts --out docs/api --options ../../typedoc.json",
-    "test": "echo 'No tests yet for @axi-engine/states'"
-  },
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "@axi-engine/utils": "^0.1.5"
-  }
-}
+{
+  "name": "@axi-engine/states",
+  "version": "0.1.2",
+  "description": "A minimal, type-safe state machine for the Axi Engine, designed for managing game logic and component states with a simple API.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/axijs/engine.git",
+    "directory": "packages/states"
+  },
+  "keywords": [
+    "axi-engine",
+    "typescript",
+    "gamedev",
+    "game-development",
+    "game-engine",
+    "state-machine",
+    "finite-state-machine",
+    "fsm",
+    "state-management",
+    "events"
+  ],
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "docs": "typedoc src/index.ts --out docs/api --options ../../typedoc.json",
+    "test": "echo 'No tests yet for @axi-engine/states'"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@axi-engine/utils": "^0.1.6"
+  },
+  "peerDependencies": {
+    "@axi-engine/utils": "^0.1.6"
+  }
+}

package/dist/index.d.ts

@@ -1,117 +0,0 @@
-import { Emitter } from '@axi-engine/utils';
-
-type StateHandler<P = void> = P extends void ? () => void | Promise<void> : (payload: P) => void | Promise<void>;
-interface StateHandlerConfig<T, P = void> {
-    onEnter?: StateHandler<P>;
-    onExit?: () => void | Promise<void>;
-    allowedFrom?: T[];
-}
-type StateHandlerRegistration<T, P = void> = StateHandler<P> | StateHandlerConfig<T, P>;
-
-/**
- * A minimal, type-safe finite state machine.
- * It manages states, transitions, and associated lifecycle hooks (`onEnter`, `onExit`).
- *
- * @template T The type used for state identifiers (e.g., a string or an enum).
- * @template P The default payload type for state handlers. Can be overridden per state.
- * @example
- * enum PlayerState { Idle, Walk, Run }
- *
- * const playerFsm = new StateMachine<PlayerState>();
- *
- * playerFsm.register(PlayerState.Idle, () => console.log('Player is now idle.'));
- * playerFsm.register(PlayerState.Walk, () => console.log('Player is walking.'));
- *
- * async function start() {
- *   await playerFsm.call(PlayerState.Idle);
- *   await playerFsm.call(PlayerState.Walk);
- * }
- */
-declare class StateMachine<T, P = void> {
-    /**
-     * @protected
-     * The internal representation of the current state.
-     */
-    protected _state?: T;
-    /**
-     * @protected
-     * A map storing all registered state configurations.
-     */
-    protected states: Map<T, StateHandlerConfig<T, P> | undefined>;
-    /**
-     * Public emitter that fires an event whenever the state changes.
-     * The event provides the old state, the new state, and the payload.
-     * @see Emitter
-     * @example
-     * fsm.onChange.subscribe((from, to, payload) => {
-     *   console.log(`State transitioned from ${from} to ${to}`);
-     * });
-     */
-    readonly onChange: Emitter<[from?: T | undefined, to?: T | undefined, payload?: P | undefined]>;
-    /**
-     * Gets the current state of the machine.
-     * @returns The current state identifier, or `undefined` if the machine has not been started.
-     */
-    get state(): T | undefined;
-    /**
-     * Registers a state and its associated handler or configuration.
-     * If a handler is already registered for the given state, it will be overwritten.
-     *
-     * @param state The identifier for the state to register.
-     * @param handler A handler function (`onEnter`) or a full configuration object.
-     * @example
-     * // Simple registration
-     * fsm.register(MyState.Idle, () => console.log('Entering Idle'));
-     *
-     * // Advanced registration
-     * fsm.register(MyState.Walking, {
-     *   onEnter: () => console.log('Start walking animation'),
-     *   onExit: () => console.log('Stop walking animation'),
-     *   allowedFrom: [MyState.Idle]
-     * });
-     */
-    register(state: T, handler?: StateHandlerRegistration<T, P>): void;
-    /**
-     * Transitions the machine to a new state.
-     * This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
-     * It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
-     *
-     * @param newState The identifier of the state to transition to.
-     * @param payload An optional payload to pass to the new state's `onEnter` handler.
-     * @returns A promise that resolves when the transition is complete.
-     * @throws {Error} if the `newState` has not been registered.
-     * @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
-     * @example
-     * try {
-     *   await fsm.call(PlayerState.Run, { speed: 10 });
-     * } catch (e) {
-     *   console.error('State transition failed:', e.message);
-     * }
-     */
-    call(newState: T, payload?: P): Promise<void>;
-    /**
-     * Removes a single state configuration from the machine.
-     * If the removed state is the currently active one, the machine's state will be reset to `undefined`.
-     *
-     * @param state The identifier of the state to remove.
-     * @returns `true` if the state was found and removed, otherwise `false`.
-     * @example
-     * fsm.register(MyState.Temp, () => {});
-     * // ...
-     * const wasRemoved = fsm.unregister(MyState.Temp);
-     * console.log('Temporary state removed:', wasRemoved);
-     */
-    unregister(state: T): boolean;
-    /**
-     * Removes all registered states and resets the machine to its initial, undefined state.
-     * This does not clear `onChange` subscribers.
-     * @example
-     * fsm.register(MyState.One);
-     * fsm.register(MyState.Two);
-     * // ...
-     * fsm.clear(); // The machine is now empty.
-     */
-    clear(): void;
-}
-
-export { type StateHandler, type StateHandlerConfig, type StateHandlerRegistration, StateMachine };

package/dist/index.js

@@ -1,144 +0,0 @@
-"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, {
-  StateMachine: () => StateMachine
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/state-machine.ts
-var import_utils = require("@axi-engine/utils");
-var StateMachine = class {
-  constructor() {
-    /**
-     * @protected
-     * A map storing all registered state configurations.
-     */
-    this.states = /* @__PURE__ */ new Map();
-    /**
-     * Public emitter that fires an event whenever the state changes.
-     * The event provides the old state, the new state, and the payload.
-     * @see Emitter
-     * @example
-     * fsm.onChange.subscribe((from, to, payload) => {
-     *   console.log(`State transitioned from ${from} to ${to}`);
-     * });
-     */
-    this.onChange = new import_utils.Emitter();
-  }
-  /**
-   * Gets the current state of the machine.
-   * @returns The current state identifier, or `undefined` if the machine has not been started.
-   */
-  get state() {
-    return this._state;
-  }
-  /**
-   * Registers a state and its associated handler or configuration.
-   * If a handler is already registered for the given state, it will be overwritten.
-   *
-   * @param state The identifier for the state to register.
-   * @param handler A handler function (`onEnter`) or a full configuration object.
-   * @example
-   * // Simple registration
-   * fsm.register(MyState.Idle, () => console.log('Entering Idle'));
-   *
-   * // Advanced registration
-   * fsm.register(MyState.Walking, {
-   *   onEnter: () => console.log('Start walking animation'),
-   *   onExit: () => console.log('Stop walking animation'),
-   *   allowedFrom: [MyState.Idle]
-   * });
-   */
-  register(state, handler) {
-    if ((0, import_utils.isUndefined)(handler) || typeof handler === "function") {
-      this.states.set(state, { onEnter: handler });
-    } else {
-      this.states.set(state, handler);
-    }
-  }
-  /**
-   * Transitions the machine to a new state.
-   * This method is asynchronous to accommodate async `onEnter` and `onExit` handlers.
-   * It will execute the `onExit` handler of the old state, then the `onEnter` handler of the new state.
-   *
-   * @param newState The identifier of the state to transition to.
-   * @param payload An optional payload to pass to the new state's `onEnter` handler.
-   * @returns A promise that resolves when the transition is complete.
-   * @throws {Error} if the `newState` has not been registered.
-   * @throws {Error} if the transition from the current state to the `newState` is not allowed by the `allowedFrom` rule.
-   * @example
-   * try {
-   *   await fsm.call(PlayerState.Run, { speed: 10 });
-   * } catch (e) {
-   *   console.error('State transition failed:', e.message);
-   * }
-   */
-  async call(newState, payload) {
-    const oldState = this._state;
-    const oldStateConfig = this._state ? this.states.get(this._state) : void 0;
-    const newStateConfig = this.states.get(newState);
-    (0, import_utils.throwIfEmpty)(newStateConfig, `State ${String(newState)} is not registered.`);
-    (0, import_utils.throwIf)(
-      !(0, import_utils.isNullOrUndefined)(newStateConfig.allowedFrom) && !(0, import_utils.isNullOrUndefined)(oldState) && !newStateConfig.allowedFrom.includes(oldState),
-      `Transition from ${String(oldState)} to ${String(newState)} is not allowed.`
-    );
-    await oldStateConfig?.onExit?.();
-    this._state = newState;
-    await newStateConfig.onEnter?.(payload);
-    this.onChange.emit(oldState, newState, payload);
-  }
-  /**
-   * Removes a single state configuration from the machine.
-   * If the removed state is the currently active one, the machine's state will be reset to `undefined`.
-   *
-   * @param state The identifier of the state to remove.
-   * @returns `true` if the state was found and removed, otherwise `false`.
-   * @example
-   * fsm.register(MyState.Temp, () => {});
-   * // ...
-   * const wasRemoved = fsm.unregister(MyState.Temp);
-   * console.log('Temporary state removed:', wasRemoved);
-   */
-  unregister(state) {
-    if (this._state === state) {
-      this._state = void 0;
-    }
-    return this.states.delete(state);
-  }
-  /**
-   * Removes all registered states and resets the machine to its initial, undefined state.
-   * This does not clear `onChange` subscribers.
-   * @example
-   * fsm.register(MyState.One);
-   * fsm.register(MyState.Two);
-   * // ...
-   * fsm.clear(); // The machine is now empty.
-   */
-  clear() {
-    this.states.clear();
-    this._state = void 0;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  StateMachine
-});