style(eslint): apply specified code style changes

src/index.ts

@@ -31,12 +31,14 @@ const _hasOwn = Object.prototype.hasOwnProperty;
  * @returns {T}
  * @template T
  */
-export function map<T>(opt_initial: T | undefined) {
-  const obj = Object.create(null);
+export const map = <T>(opt_initial: T | undefined) {
+  const object = Object.create(null);
   if (opt_initial) {
-    Object.assign(obj, opt_initial);
+    Object.assign(object, opt_initial);
   }
-  return obj;
+
+  // FIXME(@DerekNonGeneric): Should we be creating objects w/ null protos?
+  return { ...opt_initial };
 }
 
 /**
@@ -46,8 +48,8 @@ export function map<T>(opt_initial: T | undefined) {
  * @returns {boolean}
  * @template T
  */
-export function hasOwn<T>(obj: T, key: string) {
-  return _hasOwn.call(obj, key);
+export const hasOwn = <T>(object: T, key: string): boolean {
+  return _hasOwn.call(object, key);
 }
 
 /**
@@ -57,12 +59,11 @@ export function hasOwn<T>(obj: T, key: string) {
  * @param {string} key
  * @returns {unknown}
  */
-export function ownProperty(obj: Record<string, number | RegExp>, key: string) {
-  if (hasOwn(obj, key)) {
-    return obj[key];
-  } else {
-    return undefined;
-  }
+export const ownProperty = (
+  object: Record<string, number | RegExp>,
+  key: string,
+): unknown => {
+  return hasOwn(object, key) ? Reflect.get(object, key) : undefined;
 }
 
 interface ITargetSourceDepth {
@@ -82,12 +83,12 @@ interface ITargetSourceDepth {
  * @throws {Error} If source contains a circular reference.
  * Note: Only nested objects are deep-merged, primitives and arrays are not.
  */
-export function deepMerge(target: Object, source: Object, depth = 10): Object {
+export const deepMerge = (target: object, source: object, depth = 10): object {
   // Keep track of seen objects to detect recursive references.
-  const seen: Array<Object> = [];
+  const seen: object[] = [];
 
   /** @type {!Array<ITargetSourceDepth>} */
-  const queue: Array<ITargetSourceDepth> = [];
+  const queue: ITargetSourceDepth[] = [];
   queue.push({ t: target, s: source, d: 0 });
 
   // BFS to ensure objects don't have recursive references at shallower depths.
@@ -104,19 +105,19 @@ export function deepMerge(target: Object, source: Object, depth = 10): Object {
       Object.assign(t, s);
       continue;
     }
-    Object.keys(s).forEach((key) => {
-      const newValue = s[key];
+    for (const key of Object.keys(s)) {
+      const newValue = Reflect.get(s, key);
       // Perform a deep merge IFF both target and source have the same key
       // whose corresponding values are objects.
       if (hasOwn(t, key)) {
-        const oldValue = t[key];
+        const oldValue = Reflect.get(t, key);
         if (isObject(newValue) && isObject(oldValue)) {
           queue.push({ t: oldValue, s: newValue, d: d + 1 });
-          return;
+          continue;
         }
       }
-      t[key] = newValue;
-    });
+      Reflect.set(t, key, newValue);
+    }
   }
   return target;
 }
@@ -130,7 +131,7 @@ export function objectsEqualShallow(
   o1: Record<string, number | RegExp> | null | undefined,
   o2: Record<string, number | RegExp> | null | undefined
 ): boolean {
-  if (o1 == null || o2 == null) {
+  if (o1 == undefined || o2 == undefined) {
     // Null is only equal to null, and undefined to undefined.
     return o1 === o2;
   }
@@ -159,15 +160,15 @@ export function objectsEqualShallow(
  * @returns {R}
  * @template T,R
  */
-export function memo<T, P extends keyof T>(
-  obj: T,
-  prop: P,
-  factory: (arg0: T, arg1: P) => T[P]
+export const memo = <T, P extends keyof T>(
+  object: T,
+  property: P,
+  factory: (argument0: T, argument1: P) => T[P],
 ): T[P] {
-  let result = obj[prop];
+  let result = Reflect.get(object, property);
   if (result === undefined) {
-    result = factory(obj, prop);
-    obj[prop] = result;
+    result = factory(object, property);
+    Reflect.set(object, property, result);
   }
   return result;
 }