Allow skipping characters

src/display.ts

@@ -35,14 +35,13 @@ namespace display {
     }
 
     rerender(result: TransitionResult): void {
-      switch (result) {
-        case TransitionResult.SUCCESS:
-          this.element.classList.add('half');
-          break;
-        case TransitionResult.FINISHED:
+      if (result != TransitionResult.FAILED) {
+        if (this.state.isFinished()) {
           this.element.classList.remove('half');
           this.element.classList.add('full');
-          break;
+        } else {
+          this.element.classList.add('half');
+        }
       }
     }
 

src/kana.ts

@@ -450,7 +450,12 @@ namespace kana {
           let machine = mappings[i - 1][segment];
           if (machine != undefined) {
             kana.push(original);
-            machines.push(machine.clone());
+            let nextMachine = machine.clone();
+            if (machines.length > 0) {
+              let prevMachine = machines[machines.length - 1];
+              prevMachine.nextMachine = nextMachine;
+            }
+            machines.push(nextMachine);
             position += i - 1;
             break;
           }
@@ -478,8 +483,12 @@ namespace kana {
 
       let currentMachine = this.stateMachines[this.currentIndex];
       let result = currentMachine.transition(input);
-      if (result === TransitionResult.FINISHED) {
+      while (currentMachine.isFinished()) {
         this.currentIndex += 1;
+        currentMachine = this.stateMachines[this.currentIndex];
+        if (currentMachine == null) {
+          return true;
+        }
       }
       return this.currentIndex >= this.stateMachines.length;
     }

src/state.ts

@@ -6,7 +6,7 @@
  * that particular state.
  */
 namespace state {
-  export enum TransitionResult { FAILED, SUCCESS, FINISHED }
+  export enum TransitionResult { FAILED, SUCCESS, SKIPPED }
 
   interface StateMap {
     [index: string]: State
@@ -49,12 +49,14 @@ namespace 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): TransitionResult {
@@ -66,15 +68,40 @@ namespace state {
     private _transition(input: string): TransitionResult {
       let newState = this.currentState.transition(input);
       if (newState == null) {
-        return TransitionResult.FAILED;
+        if (this.skipTransition(input)) {
+          return TransitionResult.SKIPPED;
+        } else {
+          return TransitionResult.FAILED;
+        }
       } else {
         this.currentState = newState;
-        if (this.finalState === newState) {
-          return TransitionResult.FINISHED;
+        return TransitionResult.SUCCESS;
+      }
+    }
+
+    private skipTransition(input: string): boolean {
+      let potentialNextStates: State[] = Object.keys(this.currentState.transitions).map(k => this.currentState.transitions[k]);
+      for (let i = 0; i < potentialNextStates.length; ++i) {
+        let state = potentialNextStates[i];
+        if (state === this.finalState) {
+          if (this.nextMachine != null) {
+            let result = this.nextMachine.initialState.transition(input);
+            if (result != null) {
+              this.currentState = state;
+              this.nextMachine.currentState = result;
+              this.nextMachine.notify(TransitionResult.SUCCESS);
+              return true;
+            }
+          }
         } else {
-          return TransitionResult.SUCCESS;
+          let result = state.transition(input);
+          if (result != null) {
+            this.currentState = result;
+            return true;
+          }
         }
       }
+      return false;
     }
 
     isNew(): boolean {