WIP: Convert several ES5 classes to TS classes

Author: jsayol

src/database/core/operation/AckUserWrite.ts

@@ -1,51 +1,42 @@
 import { assert } from "../../../utils/assert";
 import { Path } from "../util/Path";
-import { OperationSource, OperationType } from "./Operation";
+import { Operation, OperationSource, OperationType } from './Operation';
+import { ImmutableTree } from '../util/ImmutableTree';
 
-/**
- *
- * @param {!Path} path
- * @param {!ImmutableTree<!boolean>} affectedTree
- * @param {!boolean} revert
- * @constructor
- * @implements {fb.core.Operation}
- */
-export const AckUserWrite = function(path, affectedTree, revert) {
+export class AckUserWrite implements Operation {
   /** @inheritDoc */
-  this.type = OperationType.ACK_USER_WRITE;
+  type = OperationType.ACK_USER_WRITE;
 
   /** @inheritDoc */
-  this.source = OperationSource.User;
-
-  /** @inheritDoc */
-  this.path = path;
+  source = OperationSource.User;
 
   /**
-   * A tree containing true for each affected path.  Affected paths can't overlap.
-   * @type {!util.ImmutableTree.<!boolean>}
+   *
+   * @param {!Path} path
+   * @param {!ImmutableTree<!boolean>} affectedTree A tree containing true for each affected path. Affected paths can't overlap.
+   * @param {!boolean} revert
    */
-  this.affectedTree = affectedTree;
+  constructor(/**@inheritDoc */ public path: Path,
+              /**@inheritDoc */ public affectedTree: ImmutableTree,
+              /**@inheritDoc */ public revert: boolean) {
+
+  }
 
   /**
-   * @type {boolean}
+   * @inheritDoc
    */
-  this.revert = revert;
-};
-
-/**
- * @inheritDoc
- */
-AckUserWrite.prototype.operationForChild = function(childName) {
-  if (!this.path.isEmpty()) {
-    assert(this.path.getFront() === childName, 'operationForChild called for unrelated child.');
-    return new AckUserWrite(this.path.popFront(), this.affectedTree, this.revert);
-  } else if (this.affectedTree.value != null) {
-    assert(this.affectedTree.children.isEmpty(),
+  operationForChild(childName: string) {
+    if (!this.path.isEmpty()) {
+      assert(this.path.getFront() === childName, 'operationForChild called for unrelated child.');
+      return new AckUserWrite(this.path.popFront(), this.affectedTree, this.revert);
+    } else if (this.affectedTree.value != null) {
+      assert(this.affectedTree.children.isEmpty(),
         'affectedTree should not have overlapping affected paths.');
-    // All child locations are affected as well; just return same operation.
-    return this;
-  } else {
-    var childTree = this.affectedTree.subtree(new Path(childName));
-    return new AckUserWrite(Path.Empty, childTree, this.revert);
+      // All child locations are affected as well; just return same operation.
+      return this;
+    } else {
+      const childTree = this.affectedTree.subtree(new Path(childName));
+      return new AckUserWrite(Path.Empty, childTree, this.revert);
+    }
   }
-};
+}

src/database/core/operation/Merge.ts

@@ -1,7 +1,8 @@
-import { OperationType } from "./Operation";
+import { Operation, OperationSource, OperationType } from './Operation';
 import { Overwrite } from "./Overwrite";
 import { Path } from "../util/Path";
 import { assert } from "../../../utils/assert";
+import { ImmutableTree } from '../util/ImmutableTree';
 
 /**
  * @param {!fb.core.OperationSource} source
@@ -10,48 +11,42 @@ import { assert } from "../../../utils/assert";
  * @constructor
  * @implements {fb.core.Operation}
  */
-export const Merge = function(source, path, children) {
+export class Merge implements Operation {
   /** @inheritDoc */
-  this.type = OperationType.MERGE;
+  type = OperationType.MERGE;
 
-  /** @inheritDoc */
-  this.source = source;
-
-  /** @inheritDoc */
-  this.path = path;
+  constructor(/**@inheritDoc */ public source: OperationSource,
+              /**@inheritDoc */ public path: Path,
+              /**@inheritDoc */ public children: ImmutableTree) {
+  }
 
   /**
-   * @type {!fb.core.util.ImmutableTree.<!fb.core.snap.Node>}
+   * @inheritDoc
    */
-  this.children = children;
-};
-
-/**
- * @inheritDoc
- */
-Merge.prototype.operationForChild = function(childName) {
-  if (this.path.isEmpty()) {
-    var childTree = this.children.subtree(new Path(childName));
-    if (childTree.isEmpty()) {
-      // This child is unaffected
-      return null;
-    } else if (childTree.value) {
-      // We have a snapshot for the child in question.  This becomes an overwrite of the child.
-      return new Overwrite(this.source, Path.Empty, childTree.value);
+  operationForChild(childName: string): Operation {
+    if (this.path.isEmpty()) {
+      const childTree = this.children.subtree(new Path(childName));
+      if (childTree.isEmpty()) {
+        // This child is unaffected
+        return null;
+      } else if (childTree.value) {
+        // We have a snapshot for the child in question.  This becomes an overwrite of the child.
+        return new Overwrite(this.source, Path.Empty, childTree.value);
+      } else {
+        // This is a merge at a deeper level
+        return new Merge(this.source, Path.Empty, childTree);
+      }
     } else {
-      // This is a merge at a deeper level
-      return new Merge(this.source, Path.Empty, childTree);
+      assert(this.path.getFront() === childName,
+        'Can\'t get a merge for a child not on the path of the operation');
+      return new Merge(this.source, this.path.popFront(), this.children);
     }
-  } else {
-    assert(this.path.getFront() === childName,
-                        'Can\'t get a merge for a child not on the path of the operation');
-    return new Merge(this.source, this.path.popFront(), this.children);
   }
-};
 
-/**
- * @inheritDoc
- */
-Merge.prototype.toString = function() {
-  return 'Operation(' + this.path + ': ' + this.source.toString() + ' merge: ' + this.children.toString() + ')';
-};
+  /**
+   * @inheritDoc
+   */
+  toString() {
+    return 'Operation(' + this.path + ': ' + this.source.toString() + ' merge: ' + this.children.toString() + ')';
+  }
+}

src/database/core/operation/Operation.ts

@@ -1,42 +1,42 @@
 import { assert } from "../../../utils/assert";
+import { Path } from '../util/Path';
 
 /**
  *
  * @enum
  */
-export const OperationType = {
-  OVERWRITE: 0,
-  MERGE: 1,
-  ACK_USER_WRITE: 2,
-  LISTEN_COMPLETE: 3
-};
+export enum OperationType {
+  OVERWRITE,
+  MERGE,
+  ACK_USER_WRITE,
+  LISTEN_COMPLETE
+}
 
 /**
  * @interface
  */
-export const Operation = function() { };
-
-/**
- * @type {!OperationSource}
- */
-Operation.prototype.source;
-
-/**
- * @type {!OperationType}
- */
-Operation.prototype.type;
+export interface Operation {
+  /**
+   * @type {!OperationSource}
+   */
+  source: OperationSource;
 
-/**
- * @type {!Path}
- */
-Operation.prototype.path;
+  /**
+   * @type {!OperationType}
+   */
+  type: OperationType;
 
-/**
- * @param {string} childName
- * @return {?Operation}
- */
-Operation.prototype.operationForChild = () => {};
+  /**
+   * @type {!Path}
+   */
+  path: Path;
 
+  /**
+   * @param {string} childName
+   * @return {?Operation}
+   */
+  operationForChild(childName: string): Operation | null;
+}
 
 /**
  * @param {boolean} fromUser
@@ -46,16 +46,10 @@ Operation.prototype.operationForChild = () => {};
  * @constructor
  */
 export class OperationSource {
-  fromUser;
-  fromServer;
-  queryId;
-  tagged;
-  
-  constructor(fromUser, fromServer, queryId, tagged) {
-    this.fromUser = fromUser;
-    this.fromServer = fromServer;
-    this.queryId = queryId;
-    this.tagged = tagged;
+  constructor(public fromUser: boolean,
+              public fromServer: boolean,
+              public queryId: string | null,
+              public tagged: boolean) {
     assert(!tagged || fromServer, 'Tagged queries must be from server.');
   }
   /**

src/database/core/operation/Overwrite.ts

@@ -1,4 +1,4 @@
-import { OperationType } from "./Operation";
+import { Operation, OperationType } from './Operation';
 import { Path } from "../util/Path";
 
 /**
@@ -8,7 +8,7 @@ import { Path } from "../util/Path";
  * @constructor
  * @implements {Operation}
  */
-export class Overwrite {
+export class Overwrite implements Operation {
   /** @inheritDoc */
   type;
 

src/database/core/stats/StatsListener.ts

@@ -3,23 +3,21 @@ import { clone } from "../../../utils/obj";
 /**
  * Returns the delta from the previous call to get stats.
  *
- * @param collection The collection to "listen" to.
+ * @param collection_ The collection to "listen" to.
  * @constructor
  */
 export class StatsListener {
-  collection_;
-  last_;
+  private last_ = null;
 
-  constructor(collection) {
-    this.collection_ = collection;
-    this.last_ = null;
+  constructor(private collection_) {
   }
+
   get() {
-    var newStats = this.collection_.get();
+    const newStats = this.collection_.get();
 
-    var delta = clone(newStats);
+    const delta = clone(newStats);
     if (this.last_) {
-      for (var stat in this.last_) {
+      for (let stat in this.last_) {
         delta[stat] = delta[stat] - this.last_[stat];
       }
     }

src/database/core/stats/StatsReporter.ts

@@ -5,46 +5,49 @@ import { StatsListener } from "./StatsListener";
 // Assuming some apps may have a short amount of time on page, and a bulk of firebase operations probably
 // happen on page load, we try to report our first set of stats pretty quickly, but we wait at least 10
 // seconds to try to ensure the Firebase connection is established / settled.
-var FIRST_STATS_MIN_TIME = 10 * 1000;
-var FIRST_STATS_MAX_TIME = 30 * 1000;
+const FIRST_STATS_MIN_TIME = 10 * 1000;
+const FIRST_STATS_MAX_TIME = 30 * 1000;
 
 // We'll continue to report stats on average every 5 minutes.
-var REPORT_STATS_INTERVAL = 5 * 60 * 1000;
+const REPORT_STATS_INTERVAL = 5 * 60 * 1000;
 
 /**
  *
  * @param collection
- * @param connection
+ * @param server_
  * @constructor
  */
-export const StatsReporter = function(collection, connection) {
-  this.statsToReport_ = {};
-  this.statsListener_ = new StatsListener(collection);
-  this.server_ = connection;
-
-  var timeout = FIRST_STATS_MIN_TIME + (FIRST_STATS_MAX_TIME - FIRST_STATS_MIN_TIME) * Math.random();
-  setTimeoutNonBlocking(this.reportStats_.bind(this), Math.floor(timeout));
-};
-
-StatsReporter.prototype.includeStat = function(stat) {
-  this.statsToReport_[stat] = true;
-};
-
-StatsReporter.prototype.reportStats_ = function() {
-  var stats = this.statsListener_.get();
-  var reportedStats = { };
-  var haveStatsToReport = false;
-  for (var stat in stats) {
-    if (stats[stat] > 0 && contains(this.statsToReport_, stat)) {
-      reportedStats[stat] = stats[stat];
-      haveStatsToReport = true;
-    }
+export class StatsReporter {
+  private statsListener_;
+  private statsToReport_ = {};
+
+  constructor(collection, private server_: any) {
+    this.statsListener_ = new StatsListener(collection);
+
+    const timeout = FIRST_STATS_MIN_TIME + (FIRST_STATS_MAX_TIME - FIRST_STATS_MIN_TIME) * Math.random();
+    setTimeoutNonBlocking(this.reportStats_.bind(this), Math.floor(timeout));
   }
 
-  if (haveStatsToReport) {
-    this.server_.reportStats(reportedStats);
+  includeStat(stat) {
+    this.statsToReport_[stat] = true;
   }
 
-  // queue our next run.
-  setTimeoutNonBlocking(this.reportStats_.bind(this), Math.floor(Math.random() * 2 * REPORT_STATS_INTERVAL));
-};
+  private reportStats_() {
+    const stats = this.statsListener_.get();
+    const reportedStats = {};
+    let haveStatsToReport = false;
+    for (let stat in stats) {
+      if (stats[stat] > 0 && contains(this.statsToReport_, stat)) {
+        reportedStats[stat] = stats[stat];
+        haveStatsToReport = true;
+      }
+    }
+
+    if (haveStatsToReport) {
+      this.server_.reportStats(reportedStats);
+    }
+
+    // queue our next run.
+    setTimeoutNonBlocking(this.reportStats_.bind(this), Math.floor(Math.random() * 2 * REPORT_STATS_INTERVAL));
+  }
+}