[web] Update packages, use TS 2.4

web/inc/logdog-stream-view/model.ts

 /*
   Copyright 2016 The LUCI Authors. All rights reserved.
   Use of this source code is governed under the Apache License, Version 2.0
   that can be found in the LICENSE file.
 */
 
 ///<reference path="../logdog-stream/logdog.ts" />
 ///<reference path="../luci-operation/operation.ts" />
 ///<reference path="../luci-sleep-promise/promise.ts" />
 ///<reference path="../rpc/client.ts" />
@@ skipping 522 matching lines @@
       // Post-fetch cleanup.
       this.clearCurrentOperation(op);
     }
 
     private async fetchLocationRound(l: Location, op: luci.Operation) {
       let buf = await this.provider.fetch(op, l);
 
       // Clear our fetching status.
       this.rendering = true;
       this.loadingState = LoadingState.RENDERING;
-      let hasLogs = !!(buf && buf.peek());
+      let hasLogs = !!(buf.peek());
 
       // Resolve any previous rendering Promise that we have. This
       // makes sure our rendering and fetching don't get more than
       // one round out of sync.
       if (this.renderPromise) {
         await this.renderPromise;
       }
 
       // Clear our loading state (updates controls automatically).
       this.loadingState = LoadingState.RENDERING;
@@ skipping 398 matching lines @@
       }
       return opts;
     }
 
     private async getHead(op: luci.Operation) {
       this.updateIndexes();
 
       if (this.finished) {
         // Our HEAD region has met/surpassed our TAIL region, so there are no
         // HEAD logs to return. Only bottom.
-        return null;
+        return [];
       }
 
       // If we have a tail pointer, only fetch HEAD up to that point.
       let opts = this.nextFetcherOptions();
       if (this.firstTailIndex >= 0) {
         opts.logCount = (this.firstTailIndex - this.nextHeadIndex);
       }
 
       let f =
           this.setActiveFetch(this.fetcher.get(op, this.nextHeadIndex, opts));
@@ skipping 242 matching lines @@
       // length of our active array.
       this.active = this.active.filter((entry) => {
         return (
             (!entry.buffer) || entry.buffer.peek() ||
             (!entry.ls.fetchedEndOfStream()));
       });
 
       if (!this.active.length) {
         // No active streams, so we're finished. Permanently set our promise to
         // the finished state.
-        return;
+        return new BufferedLogs(null);
       }
 
       let buffers: BufferedLogs[];
       this.currentNextPromise = this.ensureActiveBuffers(op);
       try {
         buffers = await this.currentNextPromise;
       } finally {
         this.currentNextPromise = null;
       }
       return this._aggregateBuffers(buffers);
     }
 
-    private async ensureActiveBuffers(op: luci.Operation):
-        Promise<BufferedLogs[]|null> {
+    private async ensureActiveBuffers(op: luci.Operation) {
       // Fill all buffers for all active streams. This may result in an RPC to
       // load new buffer content for streams whose buffers are empty.
       await Promise.all(this.active.map((entry) => entry.ensure(op)));
 
       // Examine the error status of each stream.
       //
       // The error is interesting, since we must present a common error view to
       // our caller. If all returned errors are "NOT_AUTHENTICATED", we will
       // return a NOT_AUTHENTICATED. Otherwise, we will return a generic
       // "streams failed" error.
@@ skipping 195 matching lines @@
 
       // Get the next log and increment our index.
       let log = this.logs[this.index++];
       if (this.index >= this.logs.length) {
         this.logs = null;
       }
       return log;
     }
   }
 }