Address comments

Author: mmermerkaya

packages/database/src/core/PersistentConnection.ts

@@ -948,8 +948,8 @@ 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_, (_, queries) => {
-      forEach(queries, (_, listenSpec) => {
+    forEach(this.listens_, (_pathString, queries) => {
+      forEach(queries, (_key, listenSpec) => {
         this.sendListen_(listenSpec);
       });
     });

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): any;
 

packages/database/src/core/view/ChildChangeAccumulator.ts

@@ -15,22 +15,15 @@
  * limitations under the License.
  */
 
-import { getValues, safeGet } from '@firebase/util';
 import { Change } from './Change';
 import { assert, assertionError } from '@firebase/util';
 
-/**
- * @constructor
- */
 export class ChildChangeAccumulator {
-  private changeMap_: { [k: string]: Change } = {};
+  private readonly changeMap: Map<string, Change> = new Map();
 
-  /**
-   * @param {!Change} change
-   */
   trackChildChange(change: Change) {
     const type = change.type;
-    const childKey /** @type {!string} */ = change.childName;
+    const childKey = change.childName!;
     assert(
       type == Change.CHILD_ADDED ||
         type == Change.CHILD_CHANGED ||
@@ -41,44 +34,50 @@ export class ChildChangeAccumulator {
       childKey !== '.priority',
       'Only non-priority child changes can be tracked.'
     );
-    const oldChange = safeGet(this.changeMap_, childKey) as Change;
+    const oldChange = this.changeMap.get(childKey);
     if (oldChange) {
       const oldType = oldChange.type;
       if (type == Change.CHILD_ADDED && oldType == Change.CHILD_REMOVED) {
-        this.changeMap_[childKey] = Change.childChangedChange(
+        this.changeMap.set(
           childKey,
-          change.snapshotNode,
-          oldChange.snapshotNode
+          Change.childChangedChange(
+            childKey,
+            change.snapshotNode,
+            oldChange.snapshotNode
+          )
         );
       } else if (
         type == Change.CHILD_REMOVED &&
         oldType == Change.CHILD_ADDED
       ) {
-        delete this.changeMap_[childKey];
+        this.changeMap.delete(childKey);
       } else if (
         type == Change.CHILD_REMOVED &&
         oldType == Change.CHILD_CHANGED
       ) {
-        this.changeMap_[childKey] = Change.childRemovedChange(
+        this.changeMap.set(
           childKey,
-          oldChange.oldSnap
+          Change.childRemovedChange(childKey, oldChange.oldSnap)
         );
       } else if (
         type == Change.CHILD_CHANGED &&
         oldType == Change.CHILD_ADDED
       ) {
-        this.changeMap_[childKey] = Change.childAddedChange(
+        this.changeMap.set(
           childKey,
-          change.snapshotNode
+          Change.childAddedChange(childKey, change.snapshotNode)
         );
       } else if (
         type == Change.CHILD_CHANGED &&
         oldType == Change.CHILD_CHANGED
       ) {
-        this.changeMap_[childKey] = Change.childChangedChange(
+        this.changeMap.set(
           childKey,
-          change.snapshotNode,
-          oldChange.oldSnap
+          Change.childChangedChange(
+            childKey,
+            change.snapshotNode,
+            oldChange.oldSnap
+          )
         );
       } else {
         throw assertionError(
@@ -89,14 +88,11 @@ export class ChildChangeAccumulator {
         );
       }
     } else {
-      this.changeMap_[childKey] = change;
+      this.changeMap.set(childKey, change);
     }
   }
 
-  /**
-   * @return {!Array.<!Change>}
-   */
   getChanges(): Change[] {
-    return getValues(this.changeMap_);
+    return Array.from(this.changeMap.values());
   }
 }

packages/polyfill/index.ts

@@ -21,11 +21,16 @@ import 'whatwg-fetch';
 // Promise
 import 'promise-polyfill/lib/polyfill';
 
-// ES6
+// ES Stable
 import 'core-js/features/array/find';
 import 'core-js/features/array/find-index';
+import 'core-js/features/array/from';
 import 'core-js/features/object/assign';
+import 'core-js/features/object/entries';
+import 'core-js/features/object/values';
 import 'core-js/features/string/starts-with';
 import 'core-js/features/string/repeat';
 import 'core-js/features/symbol';
 import 'core-js/features/symbol/iterator';
+import 'core-js/features/map';
+import 'core-js/features/set';

packages/util/src/obj.ts

@@ -43,7 +43,7 @@ export function forEach<T extends object>(
   obj: T,
   fn: (key: Keys<T>, value: Values<T>) => void
 ) {
-  for (var key of Object.keys(obj)) {
+  for (const key of Object.keys(obj)) {
     // Object.keys() doesn't return an Array<keyof T>
     // https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208
     fn(key as Keys<T>, obj[key]);
@@ -77,7 +77,12 @@ export function isNonNullObject(obj: unknown): obj is object {
 }
 
 export function isEmpty(obj: object): obj is {} {
-  return Object.keys(obj).length === 0;
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      return false;
+    }
+  }
+  return true;
 }
 
 export function getCount(obj: object): number {
@@ -89,8 +94,8 @@ export function map<T extends object, V, U extends { [key in keyof T]: V }>(
   fn: (value: Values<T>, key: Keys<T>, obj: T) => V,
   opt_obj?: unknown
 ): U {
-  var res: Partial<U> = {};
-  for (var [key, value] of Object.entries(obj)) {
+  const res: Partial<U> = {};
+  for (const [key, value] of Object.entries(obj)) {
     res[key] = fn.call(opt_obj, value, key, obj);
   }
   return res as U;
@@ -101,7 +106,7 @@ export function findKey<T extends object>(
   fn: <K extends Keys<T>>(value: T[K], key: K, obj: T) => boolean,
   opt_this?: unknown
 ): keyof T | undefined {
-  for (var [key, value] of Object.entries(obj)) {
+  for (const [key, value] of Object.entries(obj)) {
     if (fn.call(opt_this, value, key, obj)) {
       return key as keyof T;
     }
@@ -114,21 +119,17 @@ export function findValue<T extends object>(
   fn: (value: Values<T>, key: Keys<T>, obj: T) => boolean,
   opt_this?: unknown
 ): Values<T> | undefined {
-  var key = findKey(obj, fn, opt_this);
+  const key = findKey(obj, fn, opt_this);
   return key && obj[key];
 }
 
 export function getAnyKey<T extends object>(obj: T): keyof T | undefined {
-  const keys = Object.keys(obj);
-  if (keys.length > 0) {
-    return keys[0] as keyof T;
-  } else {
-    return undefined;
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      return key;
+    }
   }
-}
-
-export function getValues<T extends object>(obj: T): Array<Values<T>> {
-  return Object.values(obj);
+  return undefined;
 }
 
 /**
@@ -142,7 +143,7 @@ export function every<T extends object>(
   obj: T,
   fn: (key: Keys<T>, value: Values<T>) => boolean
 ): boolean {
-  for (var [key, value] of Object.entries(obj)) {
+  for (const [key, value] of Object.entries(obj)) {
     if (!fn(key as Keys<T>, value)) {
       return false;
     }