Refactor object utility functions

Author: mmermerkaya

config/tsconfig.base.json

@@ -5,16 +5,11 @@
     "importHelpers": true,
     "strictNullChecks": true,
     "noImplicitAny": true,
-    "lib": [
-      "es2015",
-      "dom"
-    ],
+    "lib": ["es2017", "dom"],
     "module": "ES2015",
     "moduleResolution": "node",
     "sourceMap": true,
     "target": "es5",
-    "typeRoots": [
-      "../node_modules/@types"
-    ]
+    "typeRoots": ["../node_modules/@types"]
   }
 }

packages/database/src/core/PersistentConnection.ts

@@ -948,14 +948,11 @@ export class PersistentConnection extends ServerActions {
 
     // Puts depend on having received the corresponding data update from the server before they complete, so we must
     // make sure to send listens before puts.
-    forEach(
-      this.listens_,
-      (pathString: string, queries: { [key: string]: ListenSpec }) => {
-        forEach(queries, (key: string, listenSpec: ListenSpec) => {
-          this.sendListen_(listenSpec);
-        });
-      }
-    );
+    forEach(this.listens_, (_pathString, queries) => {
+      forEach(queries, (_key, listenSpec) => {
+        this.sendListen_(listenSpec);
+      });
+    });
 
     for (let i = 0; i < this.outstandingPuts_.length; i++) {
       if (this.outstandingPuts_[i]) this.sendPut_(i);

packages/database/src/core/SparseSnapshotTree.ts

@@ -17,41 +17,30 @@
 
 import { Path } from './util/Path';
 import { PRIORITY_INDEX } from './snap/indexes/PriorityIndex';
-import { CountedSet } from './util/CountedSet';
 import { Node } from './snap/Node';
 
 /**
  * Helper class to store a sparse set of snapshots.
- *
- * @constructor
  */
 export class SparseSnapshotTree {
-  /**
-   * @private
-   * @type {Node}
-   */
-  private value_: Node | null = null;
+  private value: Node | null = null;
 
-  /**
-   * @private
-   * @type {CountedSet}
-   */
-  private children_: CountedSet<string, SparseSnapshotTree> | null = null;
+  private readonly children: Map<string, SparseSnapshotTree> = new Map();
 
   /**
    * Gets the node stored at the given path if one exists.
    *
-   * @param {!Path} path Path to look up snapshot for.
-   * @return {?Node} The retrieved node, or null.
+   * @param path Path to look up snapshot for.
+   * @return The retrieved node, or null.
    */
   find(path: Path): Node | null {
-    if (this.value_ != null) {
-      return this.value_.getChild(path);
-    } else if (!path.isEmpty() && this.children_ != null) {
+    if (this.value != null) {
+      return this.value.getChild(path);
+    } else if (!path.isEmpty() && this.children.size > 0) {
       const childKey = path.getFront();
       path = path.popFront();
-      if (this.children_.contains(childKey)) {
-        const childTree = this.children_.get(childKey) as SparseSnapshotTree;
+      if (this.children.has(childKey)) {
+        const childTree = this.children.get(childKey);
         return childTree.find(path);
       } else {
         return null;
@@ -65,26 +54,22 @@ export class SparseSnapshotTree {
    * Stores the given node at the specified path. If there is already a node
    * at a shallower path, it merges the new data into that snapshot node.
    *
-   * @param {!Path} path Path to look up snapshot for.
-   * @param {!Node} data The new data, or null.
+   * @param path Path to look up snapshot for.
+   * @param data The new data, or null.
    */
   remember(path: Path, data: Node) {
     if (path.isEmpty()) {
-      this.value_ = data;
-      this.children_ = null;
-    } else if (this.value_ !== null) {
-      this.value_ = this.value_.updateChild(path, data);
+      this.value = data;
+      this.children.clear();
+    } else if (this.value !== null) {
+      this.value = this.value.updateChild(path, data);
     } else {
-      if (this.children_ == null) {
-        this.children_ = new CountedSet<string, SparseSnapshotTree>();
-      }
-
       const childKey = path.getFront();
-      if (!this.children_.contains(childKey)) {
-        this.children_.add(childKey, new SparseSnapshotTree());
+      if (!this.children.has(childKey)) {
+        this.children.set(childKey, new SparseSnapshotTree());
       }
 
-      const child = this.children_.get(childKey) as SparseSnapshotTree;
+      const child = this.children.get(childKey);
       path = path.popFront();
       child.remember(path, data);
     }
@@ -93,22 +78,22 @@ export class SparseSnapshotTree {
   /**
    * Purge the data at path from the cache.
    *
-   * @param {!Path} path Path to look up snapshot for.
-   * @return {boolean} True if this node should now be removed.
+   * @param path Path to look up snapshot for.
+   * @return True if this node should now be removed.
    */
   forget(path: Path): boolean {
     if (path.isEmpty()) {
-      this.value_ = null;
-      this.children_ = null;
+      this.value = null;
+      this.children.clear();
       return true;
     } else {
-      if (this.value_ !== null) {
-        if (this.value_.isLeafNode()) {
+      if (this.value !== null) {
+        if (this.value.isLeafNode()) {
           // We're trying to forget a node that doesn't exist
           return false;
         } else {
-          const value = this.value_;
-          this.value_ = null;
+          const value = this.value;
+          this.value = null;
 
           const self = this;
           value.forEachChild(PRIORITY_INDEX, function(key, tree) {
@@ -117,24 +102,17 @@ export class SparseSnapshotTree {
 
           return this.forget(path);
         }
-      } else if (this.children_ !== null) {
+      } else if (this.children.size > 0) {
         const childKey = path.getFront();
         path = path.popFront();
-        if (this.children_.contains(childKey)) {
-          const safeToRemove = (this.children_.get(
-            childKey
-          ) as SparseSnapshotTree).forget(path);
+        if (this.children.has(childKey)) {
+          const safeToRemove = this.children.get(childKey).forget(path);
           if (safeToRemove) {
-            this.children_.remove(childKey);
+            this.children.delete(childKey);
           }
         }
 
-        if (this.children_.isEmpty()) {
-          this.children_ = null;
-          return true;
-        } else {
-          return false;
-        }
+        return this.children.size === 0;
       } else {
         return true;
       }
@@ -145,12 +123,12 @@ export class SparseSnapshotTree {
    * Recursively iterates through all of the stored tree and calls the
    * callback on each one.
    *
-   * @param {!Path} prefixPath Path to look up node for.
-   * @param {!Function} func The function to invoke for each tree.
+   * @param prefixPath Path to look up node for.
+   * @param func The function to invoke for each tree.
    */
   forEachTree(prefixPath: Path, func: (a: Path, b: Node) => any) {
-    if (this.value_ !== null) {
-      func(prefixPath, this.value_);
+    if (this.value !== null) {
+      func(prefixPath, this.value);
     } else {
       this.forEachChild((key, tree) => {
         const path = new Path(prefixPath.toString() + '/' + key);
@@ -162,13 +140,11 @@ export class SparseSnapshotTree {
   /**
    * Iterates through each immediate child and triggers the callback.
    *
-   * @param {!Function} func The function to invoke for each child.
+   * @param func The function to invoke for each child.
    */
   forEachChild(func: (a: string, b: SparseSnapshotTree) => void) {
-    if (this.children_ !== null) {
-      this.children_.each((key, tree) => {
-        func(key, tree);
-      });
-    }
+    this.children.forEach((tree, key) => {
+      func(key, tree);
+    });
   }
 }

packages/database/src/core/snap/IndexMap.ts

@@ -70,12 +70,12 @@ export class IndexMap {
     const sortedMap = safeGet(this.indexes_, indexKey);
     if (!sortedMap) throw new Error('No index defined for ' + indexKey);
 
-    if (sortedMap === fallbackObject) {
+    if (sortedMap instanceof SortedMap) {
+      return sortedMap;
+    } else {
       // The index exists, but it falls back to just name comparison. Return null so that the calling code uses the
       // regular child map
       return null;
-    } else {
-      return sortedMap as SortedMap<NamedNode, Node>;
     }
   }
 

packages/database/src/core/snap/Node.ts

@@ -116,8 +116,8 @@ export interface Node {
   forEachChild(index: Index, action: (a: string, b: Node) => void): any;
 
   /**
-   * @param {boolean=} exportFormat True for export format (also wire protocol format).
-   * @return {*} Value of this node as JSON.
+   * @param exportFormat True for export format (also wire protocol format).
+   * @return Value of this node as JSON.
    */
   val(exportFormat?: boolean): unknown;
 

packages/database/src/core/snap/nodeFromJSON.ts

@@ -113,9 +113,8 @@ export function nodeFromJSON(
     }
   } else {
     let node: Node = ChildrenNode.EMPTY_NODE;
-    const jsonObj = json as { [key: string]: unknown };
-    forEach(jsonObj, (key: string, childData: any) => {
-      if (contains(jsonObj, key)) {
+    forEach(json, (key, childData) => {
+      if (contains(json, key)) {
         if (key.substring(0, 1) !== '.') {
           // ignore metadata nodes.
           const childNode = nodeFromJSON(childData);