@rb-games/core 0.1.0

package/dist/state-machine/index.js

@@ -0,0 +1,954 @@
+import { EventEmitter } from 'pixi.js';
+import merge from 'lodash/merge';
+
+// state-machine/StateMachine.ts
+var StateMachine = class extends EventEmitter {
+  config;
+  context;
+  isTransitioning = false;
+  resolvedStateCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super();
+    this.config = config;
+    if (!this.config.modes[this.config.initialMode]) {
+      throw new Error(`Initial mode "${this.config.initialMode}" not found in config`);
+    }
+    const initialMode = this.config.modes[this.config.initialMode];
+    if (!initialMode.states[this.config.initialState]) {
+      throw new Error(
+        `Initial state "${this.config.initialState}" not found in mode "${this.config.initialMode}"`
+      );
+    }
+    this.context = {
+      currentState: this.config.initialState,
+      previousState: null,
+      currentMode: this.config.initialMode,
+      previousMode: null,
+      timestamp: Date.now(),
+      data: this.config.initialData ?? {},
+      metadata: {}
+    };
+  }
+  /**
+   * Current state key (e.g., 'IDLE', 'SPIN', 'MATCH')
+   */
+  get state() {
+    return this.context.currentState;
+  }
+  /**
+   * Current mode key (e.g., 'NORMAL', 'FREESPIN', 'BONUS')
+   */
+  get mode() {
+    return this.context.currentMode;
+  }
+  /**
+   * Current state data (mutable)
+   */
+  get data() {
+    return this.context.data;
+  }
+  /**
+   * Get a readonly copy of the current state context
+   *
+   * @returns Readonly state context with current state, mode, data, and metadata
+   */
+  getContext() {
+    return { ...this.context };
+  }
+  /**
+   * Update state data using an updater function
+   *
+   * @param updater - Function that receives current data and optionally returns new data
+   *
+   * @example
+   * ```typescript
+   * machine.updateData(data => {
+   *   data.balance = 1000;
+   *   data.bet = 10;
+   * });
+   * ```
+   */
+  updateData(updater) {
+    const result = updater(this.context.data);
+    if (result !== void 0) {
+      this.context.data = result;
+    }
+  }
+  resolveStateDefinition(state, mode) {
+    const modeKey = mode ?? this.context.currentMode;
+    const cacheKey = `${modeKey}:${state}`;
+    if (this.resolvedStateCache.has(cacheKey)) {
+      return this.resolvedStateCache.get(cacheKey);
+    }
+    const currentMode = this.config.modes[modeKey];
+    const stateDef = currentMode.states[state];
+    if (!stateDef) {
+      throw new Error(`State "${state}" not found in mode "${modeKey}"`);
+    }
+    if (!stateDef.extends) {
+      this.resolvedStateCache.set(cacheKey, stateDef);
+      return stateDef;
+    }
+    const chain = [];
+    const visited = /* @__PURE__ */ new Set();
+    let current = stateDef;
+    let currentKey = state;
+    while (current) {
+      if (visited.has(currentKey)) {
+        throw new Error(`Circular extends detected in state "${state}"`);
+      }
+      visited.add(currentKey);
+      chain.unshift(current);
+      if (current.extends) {
+        const parentKey = current.extends;
+        const parent = currentMode.states[parentKey];
+        if (!parent) {
+          throw new Error(`Parent state "${parentKey}" not found for state "${state}"`);
+        }
+        current = parent;
+        currentKey = parentKey;
+      } else {
+        break;
+      }
+    }
+    const resolved = merge({}, ...chain);
+    delete resolved.extends;
+    resolved.guards = stateDef.guards;
+    resolved.onEnter = stateDef.onEnter;
+    resolved.onExit = stateDef.onExit;
+    this.resolvedStateCache.set(cacheKey, resolved);
+    return resolved;
+  }
+  resolveScopeData(scopeConfig) {
+    if (!scopeConfig) return {};
+    const resolved = {};
+    for (const [scopeName, scopeData] of Object.entries(scopeConfig)) {
+      resolved[scopeName] = {};
+      for (const [componentName, componentData] of Object.entries(scopeData)) {
+        resolved[scopeName][componentName] = {};
+        for (const [propName, propValue] of Object.entries(componentData)) {
+          resolved[scopeName][componentName][propName] = this.resolveValue(propValue);
+        }
+      }
+    }
+    return resolved;
+  }
+  resolveValue(value) {
+    if (typeof value === "function") {
+      return value(this.context);
+    }
+    return value;
+  }
+  /**
+   * Get resolved scope data for a specific scope
+   *
+   * @param scopeName - Name of the scope (e.g., 'ui', 'scene', 'audio')
+   * @returns Resolved scope data with all resolver functions evaluated
+   *
+   * @example
+   * ```typescript
+   * const uiState = machine.getScope('ui');
+   * console.log(uiState.spinButton.enabled); // true
+   * ```
+   */
+  getScope(scopeName) {
+    const resolvedState = this.resolveStateDefinition(this.context.currentState);
+    const scopeData = this.resolveScopeData(resolvedState.scopes);
+    return scopeData[scopeName] ?? {};
+  }
+  /**
+   * Get all resolved scope data for the current state
+   *
+   * @returns Object containing all scopes with resolved data
+   *
+   * @example
+   * ```typescript
+   * const scopes = machine.getAllScopes();
+   * console.log(scopes.ui);    // UI scope data
+   * console.log(scopes.scene); // Scene scope data
+   * ```
+   */
+  getAllScopes() {
+    const resolvedState = this.resolveStateDefinition(this.context.currentState);
+    return this.resolveScopeData(resolvedState.scopes);
+  }
+  /**
+   * Transition to a new state within the current mode
+   *
+   * This is an async operation that:
+   * 1. Checks guards (canExit, canEnter)
+   * 2. Calls onExit hook of current state
+   * 3. Changes the state
+   * 4. Calls onEnter hook of target state
+   * 5. Emits events (state:exit, state:enter, state:change, scope:update)
+   *
+   * @param targetState - Target state key to transition to
+   * @param options - Transition options
+   * @param options.force - Skip guard checks and force transition
+   * @param options.silent - Skip event emissions
+   * @returns Promise that resolves to true if transition succeeded, false otherwise
+   *
+   * @example
+   * ```typescript
+   * // Normal transition
+   * await machine.transition('SPIN');
+   *
+   * // Force transition (skip guards)
+   * await machine.transition('SPIN', { force: true });
+   *
+   * // Silent transition (no events)
+   * await machine.transition('SPIN', { silent: true });
+   * ```
+   *
+   * @fires state:exit - When exiting current state
+   * @fires state:enter - When entering target state
+   * @fires state:change - After state change completes
+   * @fires scope:update - For each scope after state change
+   * @fires transition:blocked - If guard check fails
+   * @fires error - If an error occurs during transition
+   */
+  async transition(targetState, options = {}) {
+    if (this.isTransitioning && !options.force) {
+      console.warn("Transition already in progress");
+      return false;
+    }
+    const fromState = this.context.currentState;
+    if (fromState === targetState) {
+      return true;
+    }
+    const currentMode = this.config.modes[this.context.currentMode];
+    if (!currentMode.states[targetState]) {
+      const error = new Error(
+        `State "${targetState}" not found in mode "${this.context.currentMode}"`
+      );
+      if (this.config.strict) {
+        throw error;
+      }
+      this.emit("error", error, this.context);
+      return false;
+    }
+    if (!options.force) {
+      const canTransition = await this.checkGuards(fromState, targetState);
+      if (!canTransition.allowed) {
+        this.emit(
+          "transition:blocked",
+          fromState,
+          targetState,
+          canTransition.reason || "Guard check failed",
+          this.context
+        );
+        return false;
+      }
+    }
+    this.isTransitioning = true;
+    try {
+      if (!options.silent) {
+        this.emit("transition:start", fromState, targetState, this.context);
+      }
+      const fromStateDef = this.resolveStateDefinition(fromState);
+      if (fromStateDef.onExit) {
+        await fromStateDef.onExit(this.context);
+      }
+      if (!options.silent) {
+        this.emit("state:exit", fromState, this.context);
+      }
+      const previousState = this.context.currentState;
+      this.context = {
+        ...this.context,
+        currentState: targetState,
+        previousState,
+        timestamp: Date.now()
+      };
+      const toStateDef = this.resolveStateDefinition(targetState);
+      if (toStateDef.onEnter) {
+        await toStateDef.onEnter(this.context);
+      }
+      if (!options.silent) {
+        this.emit("state:enter", targetState, this.context);
+        this.emit("state:change", fromState, targetState, this.context);
+        const scopes = this.getAllScopes();
+        for (const [scopeName, scopeData] of Object.entries(scopes)) {
+          this.emit("scope:update", scopeName, scopeData, this.context);
+          this.emit(`scope:update:${scopeName}`, scopeData, this.context);
+        }
+        this.emit("transition:complete", fromState, targetState, this.context);
+      }
+      return true;
+    } catch (error) {
+      this.emit("error", error, this.context);
+      return false;
+    } finally {
+      this.isTransitioning = false;
+    }
+  }
+  /**
+   * Change to a different mode with an optional initial state
+   *
+   * This will:
+   * 1. Call onExit hook of current mode
+   * 2. Clear state resolution cache
+   * 3. Change mode and state
+   * 4. Call onEnter hook of target mode
+   * 5. Call onEnter hook of initial state
+   * 6. Emit events
+   *
+   * @param targetMode - Target mode key to switch to
+   * @param initialState - Optional initial state in the target mode (defaults to config.initialState)
+   * @returns Promise that resolves to true if mode change succeeded, false otherwise
+   *
+   * @example
+   * ```typescript
+   * // Switch to freespin mode
+   * await machine.changeMode('FREESPIN', 'IDLE');
+   *
+   * // Return to normal mode
+   * await machine.changeMode('NORMAL', 'IDLE');
+   * ```
+   *
+   * @fires mode:exit - When exiting current mode
+   * @fires mode:enter - When entering target mode
+   * @fires mode:change - After mode change completes
+   * @fires state:enter - When entering initial state
+   * @fires scope:update - For each scope after mode change
+   */
+  async changeMode(targetMode, initialState) {
+    if (this.context.currentMode === targetMode) {
+      return true;
+    }
+    const targetModeDef = this.config.modes[targetMode];
+    if (!targetModeDef) {
+      const error = new Error(`Mode "${targetMode}" not found`);
+      if (this.config.strict) {
+        throw error;
+      }
+      this.emit("error", error, this.context);
+      return false;
+    }
+    const targetState = initialState ?? this.config.initialState;
+    if (!targetModeDef.states[targetState]) {
+      const error = new Error(`State "${targetState}" not found in mode "${targetMode}"`);
+      if (this.config.strict) {
+        throw error;
+      }
+      this.emit("error", error, this.context);
+      return false;
+    }
+    const fromMode = this.context.currentMode;
+    const currentModeDef = this.config.modes[fromMode];
+    try {
+      if (currentModeDef.onExit) {
+        await currentModeDef.onExit(this.context);
+      }
+      this.emit("mode:exit", fromMode, this.context);
+      this.resolvedStateCache.clear();
+      const previousMode = this.context.currentMode;
+      this.context = {
+        ...this.context,
+        currentMode: targetMode,
+        previousMode,
+        currentState: targetState,
+        previousState: this.context.currentState,
+        timestamp: Date.now()
+      };
+      if (targetModeDef.onEnter) {
+        await targetModeDef.onEnter(this.context);
+      }
+      this.emit("mode:enter", targetMode, this.context);
+      this.emit("mode:change", fromMode, targetMode, this.context);
+      const toStateDef = this.resolveStateDefinition(targetState);
+      if (toStateDef.onEnter) {
+        await toStateDef.onEnter(this.context);
+      }
+      this.emit("state:enter", targetState, this.context);
+      const scopes = this.getAllScopes();
+      for (const [scopeName, scopeData] of Object.entries(scopes)) {
+        this.emit("scope:update", scopeName, scopeData, this.context);
+        this.emit(`scope:update:${scopeName}`, scopeData, this.context);
+      }
+      return true;
+    } catch (error) {
+      this.emit("error", error, this.context);
+      return false;
+    }
+  }
+  /**
+   * Check if a state exists in the current mode (synchronous, no guard check)
+   *
+   * @param targetState - State key to check
+   * @returns True if state exists in current mode, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (machine.can('SPIN')) {
+   *   console.log('SPIN state exists');
+   * }
+   * ```
+   */
+  can(targetState) {
+    const currentMode = this.config.modes[this.context.currentMode];
+    return !!(currentMode == null ? void 0 : currentMode.states[targetState]);
+  }
+  /**
+   * Check if transition to a state is allowed (async, includes guard check)
+   *
+   * @param targetState - State key to check
+   * @returns Promise that resolves to true if transition is allowed, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (await machine.canAsync('SPIN')) {
+   *   await machine.transition('SPIN');
+   * } else {
+   *   console.log('Cannot transition to SPIN');
+   * }
+   * ```
+   */
+  async canAsync(targetState) {
+    const result = await this.checkGuards(this.context.currentState, targetState);
+    return result.allowed;
+  }
+  async checkGuards(fromState, toState) {
+    var _a, _b;
+    const fromStateDef = this.resolveStateDefinition(fromState);
+    const toStateDef = this.resolveStateDefinition(toState);
+    if ((_a = fromStateDef.guards) == null ? void 0 : _a.canExit) {
+      const canExit = await fromStateDef.guards.canExit(this.context);
+      if (!canExit) {
+        return { allowed: false, reason: `Cannot exit state "${fromState}"` };
+      }
+    }
+    if ((_b = toStateDef.guards) == null ? void 0 : _b.canEnter) {
+      const canEnter = await toStateDef.guards.canEnter(this.context);
+      if (!canEnter) {
+        return { allowed: false, reason: `Cannot enter state "${toState}"` };
+      }
+    }
+    return { allowed: true };
+  }
+  /**
+   * Check if current state matches the given state key
+   *
+   * @param state - State key to compare
+   * @returns True if current state matches, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (machine.is('SPIN')) {
+   *   console.log('Currently spinning');
+   * }
+   * ```
+   */
+  is(state) {
+    return this.context.currentState === state;
+  }
+  /**
+   * Check if current mode matches the given mode key
+   *
+   * @param mode - Mode key to compare
+   * @returns True if current mode matches, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (machine.isMode('FREESPIN')) {
+   *   console.log('In freespin mode');
+   * }
+   * ```
+   */
+  isMode(mode) {
+    return this.context.currentMode === mode;
+  }
+  /**
+   * Reset state machine to initial state and mode
+   *
+   * Clears cache and resets context to initial configuration
+   *
+   * @example
+   * ```typescript
+   * machine.reset();
+   * console.log(machine.state); // Initial state
+   * console.log(machine.mode);  // Initial mode
+   * ```
+   */
+  reset() {
+    this.resolvedStateCache.clear();
+    this.context = {
+      currentState: this.config.initialState,
+      previousState: null,
+      currentMode: this.config.initialMode,
+      previousMode: null,
+      timestamp: Date.now(),
+      data: this.config.initialData ?? {},
+      metadata: {}
+    };
+  }
+  /**
+   * Destroy state machine and clean up resources
+   *
+   * Clears cache and removes all event listeners
+   *
+   * @example
+   * ```typescript
+   * machine.destroy();
+   * ```
+   */
+  destroy() {
+    this.resolvedStateCache.clear();
+    this.removeAllListeners();
+  }
+};
+
+// state-machine/ConfigBuilder.ts
+var ConfigBuilder = class {
+  constructor(initialData) {
+    this.config.initialData = initialData;
+  }
+  config = {
+    modes: {}
+  };
+  currentMode = null;
+  currentState = null;
+  /**
+   * Define a new mode or switch to an existing mode
+   *
+   * @param name - Mode key (e.g., 'NORMAL', 'FREESPIN', 'BONUS')
+   * @returns This builder for chaining
+   */
+  mode(name) {
+    this.currentMode = name;
+    if (!this.config.modes[name]) {
+      this.config.modes[name] = { states: {} };
+    }
+    return this;
+  }
+  /**
+   * Define a new state in the current mode
+   *
+   * @param name - State key (e.g., 'IDLE', 'SPIN', 'MATCH')
+   * @returns This builder for chaining
+   * @throws Error if mode() hasn't been called first
+   */
+  state(name) {
+    if (!this.currentMode) {
+      throw new Error("Must call mode() before state()");
+    }
+    this.currentState = name;
+    const mode = this.config.modes[this.currentMode];
+    if (!mode.states[name]) {
+      mode.states[name] = {};
+    }
+    return this;
+  }
+  /**
+   * Make current state extend from a parent state (inheritance)
+   *
+   * Child state will inherit all properties from parent state using lodash merge.
+   * Child properties override parent properties.
+   *
+   * @param parentState - Parent state key to extend from
+   * @returns This builder for chaining
+   * @throws Error if mode() and state() haven't been called first
+   *
+   * @example
+   * ```typescript
+   * .state('IDLE')
+   * .scope('ui', { spinButton: { enabled: true, icon: 'spin' } })
+   *
+   * .state('SPIN')
+   * .extends('IDLE')  // Inherits from IDLE
+   * .scope('ui', { spinButton: { icon: 'stop' } })  // Only override icon
+   * ```
+   */
+  extends(parentState) {
+    if (!this.currentMode || !this.currentState) {
+      throw new Error("Must call mode() and state() before extends()");
+    }
+    const state = this.config.modes[this.currentMode].states[this.currentState];
+    state.extends = parentState;
+    return this;
+  }
+  /**
+   * Define scope configuration for current state
+   *
+   * Scopes organize related configuration (ui, scene, audio, etc.).
+   * Values can be static or resolver functions.
+   *
+   * @param scopeName - Scope key (e.g., 'ui', 'scene', 'audio')
+   * @param scopeData - Scope configuration object
+   * @returns This builder for chaining
+   * @throws Error if mode() and state() haven't been called first
+   *
+   * @example
+   * ```typescript
+   * .scope('ui', {
+   *   spinButton: {
+   *     enabled: true,
+   *     icon: (ctx) => ctx.data.isQuickSpin ? 'quick_spin' : 'spin',
+   *   },
+   *   betButtons: { enabled: false },
+   * })
+   * .scope('scene', {
+   *   reels: { spinning: true },
+   * })
+   * ```
+   */
+  scope(scopeName, scopeData) {
+    if (!this.currentMode || !this.currentState) {
+      throw new Error("Must call mode() and state() before scope()");
+    }
+    const state = this.config.modes[this.currentMode].states[this.currentState];
+    if (!state.scopes) {
+      state.scopes = {};
+    }
+    state.scopes[scopeName] = scopeData;
+    return this;
+  }
+  /**
+   * Add onEnter lifecycle hook to current state
+   *
+   * Called when entering this state. Can be async.
+   * Transition waits for this hook to complete.
+   *
+   * @param hook - Lifecycle hook function
+   * @returns This builder for chaining
+   * @throws Error if mode() and state() haven't been called first
+   *
+   * @example
+   * ```typescript
+   * .onEnter(async (ctx) => {
+   *   ctx.data.balance -= ctx.data.bet;
+   *   await scene.playAnimation();
+   * })
+   * ```
+   */
+  onEnter(hook) {
+    if (!this.currentMode || !this.currentState) {
+      throw new Error("Must call mode() and state() before onEnter()");
+    }
+    const state = this.config.modes[this.currentMode].states[this.currentState];
+    state.onEnter = hook;
+    return this;
+  }
+  /**
+   * Add onExit lifecycle hook to current state
+   *
+   * Called when exiting this state. Can be async.
+   * Transition waits for this hook to complete.
+   *
+   * @param hook - Lifecycle hook function
+   * @returns This builder for chaining
+   * @throws Error if mode() and state() haven't been called first
+   *
+   * @example
+   * ```typescript
+   * .onExit(async (ctx) => {
+   *   await scene.cleanup();
+   * })
+   * ```
+   */
+  onExit(hook) {
+    if (!this.currentMode || !this.currentState) {
+      throw new Error("Must call mode() and state() before onExit()");
+    }
+    const state = this.config.modes[this.currentMode].states[this.currentState];
+    state.onExit = hook;
+    return this;
+  }
+  /**
+   * Add transition guard to current state
+   *
+   * Guards control whether transitions are allowed.
+   * Return false to block transition.
+   *
+   * @param type - Guard type ('canEnter' or 'canExit')
+   * @param guard - Guard function
+   * @returns This builder for chaining
+   * @throws Error if mode() and state() haven't been called first
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', (ctx) => ctx.data.balance >= ctx.data.bet)
+   * .guard('canExit', (ctx) => !ctx.data.isLocked)
+   * ```
+   */
+  guard(type, guard) {
+    if (!this.currentMode || !this.currentState) {
+      throw new Error("Must call mode() and state() before guard()");
+    }
+    const state = this.config.modes[this.currentMode].states[this.currentState];
+    if (!state.guards) {
+      state.guards = {};
+    }
+    state.guards[type] = guard;
+    return this;
+  }
+  /**
+   * Add metadata to current state
+   *
+   * @param data - Metadata object
+   * @returns This builder for chaining
+   * @throws Error if mode() and state() haven't been called first
+   */
+  metadata(data) {
+    if (!this.currentMode || !this.currentState) {
+      throw new Error("Must call mode() and state() before metadata()");
+    }
+    const state = this.config.modes[this.currentMode].states[this.currentState];
+    state.metadata = { ...state.metadata, ...data };
+    return this;
+  }
+  /**
+   * Add lifecycle hook to current mode
+   *
+   * @param type - Hook type ('onEnter' or 'onExit')
+   * @param hook - Lifecycle hook function
+   * @returns This builder for chaining
+   * @throws Error if mode() hasn't been called first
+   *
+   * @example
+   * ```typescript
+   * .mode('FREESPIN')
+   * .modeHook('onEnter', (ctx) => {
+   *   ctx.data.freeSpinsRemaining = 10;
+   * })
+   * ```
+   */
+  modeHook(type, hook) {
+    if (!this.currentMode) {
+      throw new Error("Must call mode() before modeHook()");
+    }
+    const mode = this.config.modes[this.currentMode];
+    mode[type] = hook;
+    return this;
+  }
+  /**
+   * Set initial state and mode
+   *
+   * @param state - Initial state key
+   * @param mode - Initial mode key
+   * @returns This builder for chaining
+   *
+   * @example
+   * ```typescript
+   * .initial('IDLE', 'NORMAL')
+   * ```
+   */
+  initial(state, mode) {
+    this.config.initialState = state;
+    this.config.initialMode = mode;
+    return this;
+  }
+  /**
+   * Set initial data for state context
+   *
+   * @param data - Initial data object
+   * @returns This builder for chaining
+   *
+   * @example
+   * ```typescript
+   * .initialData({ balance: 1000, bet: 10 })
+   * ```
+   */
+  initialData(data) {
+    this.config.initialData = data;
+    return this;
+  }
+  /**
+   * Enable strict mode (throws errors instead of emitting error events)
+   *
+   * @param value - Enable strict mode (default: true)
+   * @returns This builder for chaining
+   */
+  strict(value = true) {
+    this.config.strict = value;
+    return this;
+  }
+  /**
+   * Build and return the final state machine configuration
+   *
+   * @returns Complete state machine configuration
+   * @throws Error if initial state and mode haven't been set
+   *
+   * @example
+   * ```typescript
+   * const config = createConfig()
+   *   .initial('IDLE', 'NORMAL')
+   *   .mode('NORMAL')
+   *   .state('IDLE')
+   *   .build();
+   * ```
+   */
+  build() {
+    if (!this.config.initialState || !this.config.initialMode) {
+      throw new Error("Must set initial state and mode");
+    }
+    return this.config;
+  }
+};
+function createConfig(initialData) {
+  return new ConfigBuilder(initialData);
+}
+
+// state-machine/guards.ts
+var guards = {
+  /**
+   * Always allow transition
+   *
+   * @returns Guard that always returns true
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.always())
+   * ```
+   */
+  always: () => () => true,
+  /**
+   * Never allow transition
+   *
+   * @returns Guard that always returns false
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.never())
+   * ```
+   */
+  never: () => () => false,
+  /**
+   * Check if data key exists and is not null/undefined
+   *
+   * @template TData - Type of state data
+   * @param key - Data key to check
+   * @returns Guard that checks if key exists
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.hasData('balance'))
+   * ```
+   */
+  hasData: (key) => {
+    return (context) => context.data[key] !== void 0 && context.data[key] !== null;
+  },
+  /**
+   * Check if data key equals a specific value
+   *
+   * @template TData - Type of state data
+   * @param key - Data key to check
+   * @param value - Value to compare against
+   * @returns Guard that checks equality
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.dataEquals('gameMode', 'normal'))
+   * ```
+   */
+  dataEquals: (key, value) => {
+    return (context) => context.data[key] === value;
+  },
+  /**
+   * Check if data key is greater than a value
+   *
+   * @template TData - Type of state data
+   * @param key - Data key to check (must be number)
+   * @param value - Value to compare against
+   * @returns Guard that checks if key > value
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.dataGreaterThan('balance', 0))
+   * ```
+   */
+  dataGreaterThan: (key, value) => {
+    return (context) => context.data[key] > value;
+  },
+  /**
+   * Check if data key is less than a value
+   *
+   * @template TData - Type of state data
+   * @param key - Data key to check (must be number)
+   * @param value - Value to compare against
+   * @returns Guard that checks if key < value
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.dataLessThan('lives', 3))
+   * ```
+   */
+  dataLessThan: (key, value) => {
+    return (context) => context.data[key] < value;
+  },
+  /**
+   * Combine multiple guards with AND logic
+   *
+   * All guards must return true for transition to be allowed.
+   *
+   * @template TData - Type of state data
+   * @param guards - Guards to combine
+   * @returns Guard that checks all guards
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.and(
+   *   guards.hasData('balance'),
+   *   guards.dataGreaterThan('balance', 10),
+   *   (ctx) => ctx.data.isActive
+   * ))
+   * ```
+   */
+  and: (...guards2) => {
+    return async (context) => {
+      for (const guard of guards2) {
+        const result = await guard(context);
+        if (!result) return false;
+      }
+      return true;
+    };
+  },
+  /**
+   * Combine multiple guards with OR logic
+   *
+   * At least one guard must return true for transition to be allowed.
+   *
+   * @template TData - Type of state data
+   * @param guards - Guards to combine
+   * @returns Guard that checks any guard
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.or(
+   *   guards.dataEquals('mode', 'demo'),
+   *   guards.dataGreaterThan('balance', 0)
+   * ))
+   * ```
+   */
+  or: (...guards2) => {
+    return async (context) => {
+      for (const guard of guards2) {
+        const result = await guard(context);
+        if (result) return true;
+      }
+      return false;
+    };
+  },
+  /**
+   * Negate a guard (NOT logic)
+   *
+   * Returns opposite of the guard's result.
+   *
+   * @template TData - Type of state data
+   * @param guard - Guard to negate
+   * @returns Guard that returns opposite result
+   *
+   * @example
+   * ```typescript
+   * .guard('canEnter', guards.not(
+   *   guards.dataEquals('isLocked', true)
+   * ))
+   * ```
+   */
+  not: (guard) => {
+    return async (context) => !await guard(context);
+  }
+};
+
+export { ConfigBuilder, StateMachine, createConfig, guards };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map