@axi-engine/states 0.1.1 → 0.1.3

package/dist/index.d.ts

@@ -1,117 +1,3 @@
-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 };
+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

@@ -1,147 +1,3 @@
-"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 {
-  /**
-   * @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 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
-});
+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/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,8 +1,13 @@
 {
   "name": "@axi-engine/states",
-  "version": "0.1.1",
+  "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",