@axi-engine/states 0.1.2 → 0.1.3

package/dist/index.d.mts

@@ -1,15 +1,13 @@
-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`).
@@ -30,91 +28,90 @@ 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;
 }
-//#endregion
-export { StateHandler, StateHandlerConfig, StateHandlerRegistration, StateMachine };
-//# sourceMappingURL=index.d.mts.map
+
+export { type StateHandler, type StateHandlerConfig, type StateHandlerRegistration, StateMachine };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './state-handler';
+export * from './state-machine';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './state-handler';
+export * from './state-machine';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA"}

package/dist/index.mjs

@@ -1,133 +1,120 @@
+// 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 {
-	/**
-	* @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;
-	}
+  /**
+   * @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;
+  }
+};
+export {
+  StateMachine
 };
-
-//#endregion
-export { StateMachine };
-//# sourceMappingURL=index.mjs.map

package/dist/state-handler.d.ts

@@ -0,0 +1,8 @@
+export type StateHandler<P = void> = P extends void ? () => void | Promise<void> : (payload: P) => void | Promise<void>;
+export interface StateHandlerConfig<T, P = void> {
+    onEnter?: StateHandler<P>;
+    onExit?: () => void | Promise<void>;
+    allowedFrom?: T[];
+}
+export type StateHandlerRegistration<T, P = void> = StateHandler<P> | StateHandlerConfig<T, P>;
+//# sourceMappingURL=state-handler.d.ts.map

package/dist/state-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-handler.d.ts","sourceRoot":"","sources":["../src/state-handler.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,CAAC,CAAC,GAAG,IAAI,IAC/B,CAAC,SAAS,IAAI,GACZ,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAG3C,MAAM,WAAW,kBAAkB,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI;IAC7C,OAAO,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,WAAW,CAAC,EAAE,CAAC,EAAE,CAAC;CACnB;AAED,MAAM,MAAM,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/dist/state-handler.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state-handler.js.map

package/dist/state-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-handler.js","sourceRoot":"","sources":["../src/state-handler.ts"],"names":[],"mappings":""}

package/dist/state-machine.d.ts

@@ -0,0 +1,108 @@
+import { StateHandlerConfig, StateHandlerRegistration } from "./state-handler";
+import { Emitter } from '@axi-engine/utils';
+/**
+ * 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);
+ * }
+ */
+export 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;
+}
+//# sourceMappingURL=state-machine.d.ts.map

package/dist/state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.d.ts","sourceRoot":"","sources":["../src/state-machine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAE,wBAAwB,EAAC,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EAAC,OAAO,EAAwD,MAAM,mBAAmB,CAAC;AAGjG;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI;IACnC;;;OAGG;IACH,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAErB;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,CAAa;IAE3E;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAAQ,+EAAkD;IAEnE;;;OAGG;IACH,IAAI,KAAK,IAAI,CAAC,GAAG,SAAS,CAEzB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI;IAQlE;;;;;;;;;;;;;;;;OAgBG;IACG,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBnD;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAO7B;;;;;;;;OAQG;IACH,KAAK,IAAI,IAAI;CAId"}

package/dist/state-machine.js

@@ -0,0 +1,136 @@
+import { Emitter, isNullOrUndefined, isUndefined, throwIf, throwIfEmpty } from '@axi-engine/utils';
+/**
+ * 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);
+ * }
+ */
+export class StateMachine {
+    /**
+     * @protected
+     * The internal representation of the current state.
+     */
+    _state;
+    /**
+     * @protected
+     * A map storing all registered state configurations.
+     */
+    states = 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) : undefined;
+        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 = undefined;
+        }
+        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 = undefined;
+    }
+}
+//# sourceMappingURL=state-machine.js.map

package/dist/state-machine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-machine.js","sourceRoot":"","sources":["../src/state-machine.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,OAAO,EAAE,YAAY,EAAC,MAAM,mBAAmB,CAAC;AAGjG;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,YAAY;IACvB;;;OAGG;IACO,MAAM,CAAK;IAErB;;;OAGG;IACO,MAAM,GAAiD,IAAI,GAAG,EAAE,CAAC;IAE3E;;;;;;;;OAQG;IACM,QAAQ,GAAG,IAAI,OAAO,EAAmC,CAAC;IAEnE;;;OAGG;IACH,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,KAAQ,EAAE,OAAwC;QACzD,IAAI,WAAW,CAAC,OAAO,CAAC,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;YAC1D,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,EAAC,OAAO,EAAE,OAAO,EAAC,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,IAAI,CAAC,QAAW,EAAE,OAAW;QACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC;QAC7B,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9E,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAEjD,YAAY,CAAC,cAAc,EAAE,SAAS,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAC,CAAC;QAE7E,OAAO,CACL,CAAC,iBAAiB,CAAC,cAAc,CAAC,WAAW,CAAC;YAC9C,CAAC,iBAAiB,CAAC,QAAQ,CAAC;YAC5B,CAAC,cAAc,CAAC,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAC9C,mBAAmB,MAAM,CAAC,QAAQ,CAAC,OAAO,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAC7E,CAAC;QAEF,MAAM,cAAc,EAAE,MAAM,EAAE,EAAE,CAAC;QAEjC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;QAEvB,MAAO,cAAc,CAAC,OAAiD,EAAE,CAAC,OAAO,CAAC,CAAC;QAEnF,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,KAAQ;QACjB,IAAI,IAAI,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC1B,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QAC1B,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC1B,CAAC;CACF"}

package/package.json

@@ -1,47 +1,47 @@
-{
-  "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"
-  }
-}
+{
+  "name": "@axi-engine/states",
+  "version": "0.1.3",
+  "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": "tsup",
+    "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.cjs

@@ -1,132 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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"}