refactor: strictly typed

src/parser/parse-stream.ts

@@ -1,37 +1,37 @@
 import Token from 'src/parser/token'
 import ITemplate from 'src/template/itemplate'
+import TagToken from './tag-token';
 
-type parseToken = (token: Token, remainTokens: Array<Token>) => ITemplate
-type eventHandler = ((arg?: Token | ITemplate) => void)
+type ParseToken = ((token: Token, remainTokens: Array<Token>) => ITemplate)
 
 export default class ParseStream {
   private tokens: Array<Token>
-  private handlers: {[key: string]: eventHandler} = {}
-  private stopRequested: boolean
-  private parseToken: parseToken
+  private handlers: {[key: string]: (arg: any) => void} = {}
+  private stopRequested: boolean = false
+  private parseToken: ParseToken
 
-  constructor (tokens: Array<Token>, parseToken: parseToken) {
+  constructor (tokens: Array<Token>, parseToken: ParseToken) {
     this.tokens = tokens
     this.parseToken = parseToken
   }
-  on (name: string, cb: eventHandler) {
+  on<T extends ITemplate | Token | undefined> (name: string, cb: (arg: T) => void): ParseStream {
     this.handlers[name] = cb
     return this
   }
-  trigger (event: string, arg?: Token | ITemplate) {
+  trigger <T extends Token | ITemplate>(event: string, arg?: T) {
     const h = this.handlers[event]
     if (typeof h === 'function') {
       h(arg)
       return true
     }
+    return false
   }
   start () {
     this.trigger('start')
-    let token
+    let token: Token | undefined
     while (!this.stopRequested && (token = this.tokens.shift())) {
       if (this.trigger('token', token)) continue
-      if (token.type === 'tag' &&
-          this.trigger(`tag:${token.name}`, token)) {
+      if (token.type === 'tag' && this.trigger(`tag:${(<TagToken>token).name}`, token)) {
         continue
       }
       const template = this.parseToken(token, this.tokens)