typingfreaks/src/state.ts

/**
 * This module is a simple state machine implementation. We model states as a
 * graph, and the state machine simply keeps track of the current and final
 * state. The state also has a display field as metadata. This serves as the
 * state name and is also used to represent the remaining text to be input at
 * that particular state.
 */

export enum TransitionResult {
  FAILED,
  SUCCESS,
  SKIPPED,
}

interface StateMap {
  [index: string]: State;
}

interface StateTransitionList {
  [index: string]: [State, boolean];
}

export interface Observer {
  (result: TransitionResult, boundary: boolean): void;
}

export class State {
  display: string;
  transitions: StateTransitionList;

  constructor(display: string) {
    this.display = display;
    this.transitions = {};
  }

  addTransition(input: string, state: State, boundary: boolean = false): void {
    this.transitions[input] = [state, boundary];
  }

  transition(input: string): [State, boolean] | undefined {
    return this.transitions[input];
  }

  clone(): State {
    let state = new State(this.display);
    state.transitions = { ...this.transitions };
    return state;
  }
}

export class StateMachine {
  initialState: State;
  finalState: State;
  currentState: State;
  observers: Set<Observer>;
  nextMachine: StateMachine | null;

  constructor(initialState: State, finalState: State) {
    this.initialState = initialState;
    this.currentState = initialState;
    this.finalState = finalState;
    this.observers = new Set();
    this.nextMachine = null;
  }

  transition(input: string) {
    let result = this.currentState.transition(input);
    if (result == null) {
      this.skipTransition(input);
    } else {
      let [newState, boundary] = result;
      this.currentState = newState;
      this.notifyResult(TransitionResult.SUCCESS, boundary);
    }
  }

  private skipTransition(input: string): boolean {
    let potentialNextStates: Array<[State, boolean]> = Object.keys(
      this.currentState.transitions
    ).map((k) => this.currentState.transitions[k]);
    for (let i = 0; i < potentialNextStates.length; ++i) {
      let [state, skippedBoundary] = potentialNextStates[i];
      if (state === this.finalState) {
        if (this.nextMachine != null) {
          let result = this.nextMachine.initialState.transition(input);
          if (result != null) {
            const [newState, boundary] = result;
            this.currentState = state;
            this.nextMachine.currentState = newState;
            this.notifyResult(TransitionResult.SKIPPED, skippedBoundary);
            this.nextMachine.notifyResult(TransitionResult.SUCCESS, boundary);
            return true;
          }
        }
      } else {
        let result = state.transition(input);
        if (result != null) {
          let [newState, boundary] = result;
          this.currentState = newState;
          this.notifyResult(TransitionResult.SKIPPED, skippedBoundary);
          this.notifyResult(TransitionResult.SUCCESS, boundary);
          return true;
        }
      }
    }
    this.notifyResult(TransitionResult.FAILED, false);
    return false;
  }

  isNew(): boolean {
    return this.currentState === this.initialState;
  }

  isFinished(): boolean {
    return this.currentState === this.finalState;
  }

  reset(): void {
    this.currentState = this.initialState;
  }

  clone(): StateMachine {
    return new StateMachine(this.initialState, this.finalState);
  }

  getWord(): string {
    return this.initialState.display;
  }

  getDisplay(): string {
    return this.currentState.display;
  }

  addObserver(observer: Observer): void {
    this.observers.add(observer);
  }

  removeObserver(observer: Observer): void {
    this.observers.delete(observer);
  }

  notifyResult(result: TransitionResult, boundary: boolean): void {
    this.observers.forEach((o) => o(result, boundary));
  }
}

export interface Transition {
  from: string;
  input: string;
  to: string;
  boundary: boolean;
}

export function buildFromTransitions(
  initial: string,
  transitions: Transition[]
): StateMachine {
  let states: StateMap = {};
  function getState(name: string): State {
    if (states[name] === undefined) {
      states[name] = new State(name);
    }
    return states[name];
  }
  transitions.forEach((t) => {
    let fromState = getState(t.from);
    let toState = getState(t.to);
    fromState.addTransition(t.input, toState, t.boundary);
  });
  let initialState = getState(initial);
  let finalState = getState('');
  return new StateMachine(initialState, finalState);
}

export function makeTransition(
  from: string,
  input: string,
  to: string,
  boundary: boolean = false
): Transition {
  return { from, input, to, boundary };
}