fix: reducing use of "any"

Author: CodeAndWeb

projects/ngx-translate/src/lib/util.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 import { InterpolatableTranslationObject } from './translate.service';
 
 /**
@@ -15,38 +13,43 @@ import { InterpolatableTranslationObject } from './translate.service';
  * @param o2 Object or value to compare.
  * @returns true if arguments are equal.
  */
-export function equals(o1: any, o2: any): boolean {
+export function equals(o1: unknown, o2: unknown): boolean {
   if (o1 === o2) return true;
   if (o1 === null || o2 === null) return false;
   if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
+
   const t1 = typeof o1, t2 = typeof o2;
-  let length: number, key: any, keySet: any;
+  let length: number;
+
   if (t1 == t2 && t1 == 'object') {
     if (Array.isArray(o1)) {
       if (!Array.isArray(o2)) return false;
       if ((length = o1.length) == o2.length) {
-        for (key = 0; key < length; key++) {
+        for (let key = 0; key < length; key++) {
           if (!equals(o1[key], o2[key])) return false;
         }
         return true;
       }
-    } else {
+    }
+    else {
       if (Array.isArray(o2)) {
         return false;
       }
-      keySet = Object.create(null);
-      for (key in o1) {
-        if (!equals(o1[key], o2[key])) {
-          return false;
+      if(isDict(o1) && isDict(o2)) {
+        const keySet = Object.create(null);
+        for (const key in o1) {
+          if (!equals(o1[key], o2[key])) {
+            return false;
+          }
+          keySet[key] = true;
         }
-        keySet[key] = true;
-      }
-      for (key in o2) {
-        if (!(key in keySet) && typeof o2[key] !== 'undefined') {
-          return false;
+        for (const key in o2) {
+          if (!(key in keySet) && typeof o2[key] !== 'undefined') {
+            return false;
+          }
         }
+        return true;
       }
-      return true;
     }
   }
   return false;
@@ -56,61 +59,59 @@ export function isDefinedAndNotNull<T>(value: T | null | undefined): value is T
   return typeof value !== 'undefined' && value !== null;
 }
 
+export function isDefined<T>(value: T | null | undefined): value is (T | null) {
+  return value !== undefined;
+}
 
-export function isDict(value: any): value is InterpolatableTranslationObject {
+export function isDict(value: unknown): value is InterpolatableTranslationObject {
   return isObject(value) && !isArray(value) && value !== null;
 }
 
-
-export function isObject(value: any): value is Record<string, any> {
+export function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
 
-export function isArray(value: any): value is any[] {
+export function isArray(value: unknown): value is unknown[] {
   return Array.isArray(value);
 }
 
-export function isString(value: any): value is string {
+export function isString(value: unknown): value is string {
   return typeof value === 'string';
 }
 
-export function isFunction(value: any): boolean {
+export function isFunction(value: unknown): boolean {
   return typeof value === "function"
 }
 
-export function cloneDeep<T>(obj: Readonly<T>): T
-{
-  if (obj === null || typeof obj !== "object")
-  {
-    return obj;
-  }
-
-  if (Array.isArray(obj)) {
-    return obj.map((item) => cloneDeep(item)) as unknown as T;
+function cloneDeep(value: unknown): unknown {
+  if (isArray(value)) {
+    return value.map(item => cloneDeep(item));
+  } else if (isDict(value)) {
+    const cloned: Record<string, unknown> = {};
+    Object.keys(value).forEach(key => {
+      cloned[key] = cloneDeep((value as Record<string, unknown>)[key]);
+    });
+    return cloned;
+  } else {
+    return value;
   }
-
-  const clonedObj: Record<string, any> = {};
-
-  Object.keys(obj).forEach((key) => {
-    clonedObj[key] = cloneDeep((obj as Record<string, any>)[key]);
-  });
-
-  return clonedObj as T;
 }
 
-export function mergeDeep(target: Readonly<any>, source: any): any {
-  const output = cloneDeep(target);
-
+/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+export function mergeDeep(target: Readonly<unknown>, source: Readonly<unknown>): any {
   if (!isObject(target))
   {
     return cloneDeep(source)
   }
 
-  if (isObject(target) && isObject(source)) {
+  const output = cloneDeep(target);
+
+  if (isObject(output) && isObject(source)) {
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
     Object.keys(source).forEach((key: any) => {
       if (isDict(source[key])) {
         if (key in target) {
-          output[key] = mergeDeep(target[key], source[key]);
+          output[key] = mergeDeep(target[key] as Readonly<unknown>, source[key]);
         } else {
           Object.assign(output, {[key]: source[key]});
         }
@@ -135,31 +136,51 @@ export function mergeDeep(target: Readonly<any>, source: any): any {
  * @param key Dot-separated key path specifying the value to retrieve.
  * @returns The value at the specified key path, or `undefined` if not found.
  */
-export function getValue(target: any, key: string): any
+export function getValue(target: unknown, key: string): unknown
 {
   const keys = key.split(".");
 
   key = "";
   do
   {
     key += keys.shift();
-    if (
-      isDefinedAndNotNull(target) &&
-      (isDefinedAndNotNull(target[key]) || target[key] === null) &&
-      (isDict(target[key]) || isArray(target[key]) || !keys.length)
-    )
+    const isLastKey = !keys.length;
+
+    if(isDefinedAndNotNull(target))
     {
-      target = target[key];
-      key = "";
+      if (
+        isDict(target) &&
+        isDefined(target[key]) &&
+        (isDict(target[key]) || isArray(target[key]) || isLastKey)
+      )
+      {
+        target = target[key];
+        key = "";
+        continue;
+      }
+
+      if(isArray(target))
+      {
+        const index = parseInt(key, 10);
+        if (
+          isDefined(target[index]) &&
+          (isDict(target[index]) || isArray(target[index]) || isLastKey)
+        )
+        {
+          target = target[index];
+          key = "";
+          continue;
+        }
+      }
     }
-    else if (!keys.length)
+
+    if (isLastKey)
     {
       target = undefined;
+      continue;
     }
-    else
-    {
-      key += ".";
-    }
+    key += ".";
+
   } while (keys.length);
 
   return target;
@@ -174,22 +195,17 @@ export function getValue(target: any, key: string): any
  * @param value to set
  * @deprecated use insertValue() instead
  */
-export function setValue(target: any, key: string, value: any): void {
-  const keys = key.split('.');
-  let current = target;
+export function setValue(target: Record<string, unknown>, key: string, value: unknown): void {
+  const keys:string[] = key.split('.');
+  let current:Record<string, unknown> = target;
 
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
 
-    // If we're at the last key, set the value
     if (i === keys.length - 1) {
       current[key] = value;
     } else {
-      // If the key doesn't exist or isn't an object, create an empty object
-      if (!current[key] || !isDict(current[key])) {
-        current[key] = {};
-      }
-      current = current[key];
+      current = (current[key] && isDict(current[key])) ? current[key] : {};
     }
   }
 }
@@ -204,12 +220,15 @@ export function setValue(target: any, key: string, value: any): void {
  * @param key E.g. "a.b.c"
  * @param value to set
  */
-export function insertValue(target: Readonly<any>, key: string, value: any): any {
-  return mergeDeep(target, createNestedObject(key, value));
+export function insertValue<T>(target: Readonly<T>, key: string, value: unknown): T {
+  return mergeDeep(target, createNestedObject(key, value) as Readonly<unknown>);
 }
 
 
 
-function createNestedObject(dotSeparatedKey: string, value: any): Record<string, any> {
-  return dotSeparatedKey.split('.').reduceRight((acc, key) => ({ [key]: acc }), value);
+function createNestedObject(dotSeparatedKey: string, value: unknown): Record<string, unknown>|unknown
+{
+  return dotSeparatedKey
+    .split('.')
+    .reduceRight<unknown>((acc, key) => ({ [key]: acc }), value);
 }

projects/ngx-translate/src/lib/utils.spec.ts

@@ -238,8 +238,6 @@ describe("Utils", () =>
       expect(getValue(['A', ['a', 'b', 'c'], 'C'], '1.2')).toEqual("c");
 
       expect(getValue("test", 'key')).not.toBeDefined();
-
-      expect(getValue("test", '1')).toEqual("e"); /// useless: substring
     })
 
   });