Smaller refactors to make code more readable

Author: CodeAndWeb

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

@@ -9,7 +9,7 @@ import {
   Translation,
   InterpolationParameters
 } from "./translate.service";
-import {equals, isDefined} from './util';
+import {equals, isDefinedAndNotNull} from './util';
 
 interface ExtendedNode extends Text {
   originalContent: string;
@@ -94,7 +94,7 @@ export class TranslateDirective implements AfterViewChecked, OnDestroy {
         if (forceUpdate) {
           node.lastKey = null;
         }
-        if(isDefined(node.lookupKey)) {
+        if(isDefinedAndNotNull(node.lookupKey)) {
           key = node.lookupKey;
         } else if (this.key) {
           key = this.key;
@@ -134,13 +134,13 @@ export class TranslateDirective implements AfterViewChecked, OnDestroy {
         if (!node.originalContent) {
           node.originalContent = this.getContent(node);
         }
-        node.currentValue = isDefined(res) ? res : (node.originalContent || key);
+        node.currentValue = isDefinedAndNotNull(res) ? res : (node.originalContent || key);
         // we replace in the original content to preserve spaces that we might have trimmed
         this.setContent(node, this.key ? node.currentValue : node.originalContent.replace(key, node.currentValue));
         this._ref.markForCheck();
       };
 
-      if (isDefined(translations)) {
+      if (isDefinedAndNotNull(translations)) {
         const res = this.translateService.getParsedResult(key, this.currentParams);
         if (isObservable(res)) {
           res.subscribe({next: onTranslation});
@@ -154,11 +154,11 @@ export class TranslateDirective implements AfterViewChecked, OnDestroy {
   }
 
   getContent(node: ExtendedNode): string {
-    return (isDefined(node.textContent) ? node.textContent : node.data) as string;
+    return (isDefinedAndNotNull(node.textContent) ? node.textContent : node.data) as string;
   }
 
   setContent(node: ExtendedNode, content: string): void {
-    if (isDefined(node.textContent)) {
+    if (isDefinedAndNotNull(node.textContent)) {
       node.textContent = content;
     } else {
       node.data = content;

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

@@ -8,7 +8,7 @@ import {
   Translation,
   InterpolationParameters
 } from "./translate.service";
-import {equals, isDefined, isDict, isString} from "./util";
+import {equals, isDefinedAndNotNull, isDict, isString} from "./util";
 
 @Injectable()
 @Pipe({
@@ -56,7 +56,7 @@ export class TranslatePipe implements PipeTransform, OnDestroy {
     }
 
     let interpolateParams: object | undefined = undefined;
-    if (isDefined(args[0]) && args.length) {
+    if (isDefinedAndNotNull(args[0]) && args.length) {
       if (isString(args[0]) && args[0].length) {
         // we accept objects written in the template such as {n:1}, {'n':1}, {n:'v'}
         // which is why we might need to change it to real JSON objects such as {"n":1} or {"n":"v"}

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

@@ -1,12 +1,12 @@
 import {Inject, Injectable, InjectionToken} from "@angular/core";
 import {concat, forkJoin, isObservable, Observable, of, defer} from "rxjs";
 import {concatMap, map, shareReplay, switchMap, take} from "rxjs/operators";
-import {MissingTranslationHandler, MissingTranslationHandlerParams} from "./missing-translation-handler";
+import {MissingTranslationHandler} from "./missing-translation-handler";
 import {TranslateCompiler} from "./translate.compiler";
 import {TranslateLoader} from "./translate.loader";
 import {InterpolateFunction, TranslateParser} from "./translate.parser";
 import {TranslateStore} from "./translate.store";
-import {isDefined, isArray, isString, isDict, insertValue} from "./util";
+import {isDefinedAndNotNull, isArray, isString, isDict, insertValue} from "./util";
 
 export const ISOLATE_TRANSLATE_SERVICE = new InjectionToken<string>('ISOLATE_TRANSLATE_SERVICE');
 export const USE_DEFAULT_LANG = new InjectionToken<string>('USE_DEFAULT_LANG');
@@ -189,7 +189,7 @@ export class TranslateService {
       // on init set the defaultLang immediately, but do not emit a change yet
       this.store.setDefaultLang(lang, false);
     }
-    
+
     const pending = this.loadOrExtendLanguage(lang);
     if (isObservable(pending))
     {
@@ -331,21 +331,17 @@ export class TranslateService {
   {
       const textToInterpolate = this.getTextToInterpolate(key);
 
-      let res: Translation | undefined;
-
-      if (textToInterpolate !== undefined)
+      if (isDefinedAndNotNull(textToInterpolate))
       {
-          res = this.runInterpolation(textToInterpolate, interpolateParams);
-      }
-      else
-      {
-          const params: MissingTranslationHandlerParams = {key, translateService: this};
-          if (typeof interpolateParams !== 'undefined') {
-              params.interpolateParams = interpolateParams;
-          }
-          res = this.missingTranslationHandler.handle(params);
+          return this.runInterpolation(textToInterpolate, interpolateParams);
       }
 
+      const res = this.missingTranslationHandler.handle({
+        key,
+        translateService: this,
+        ...(interpolateParams !== undefined && { interpolateParams })
+      });
+
       return res !== undefined ? res : key;
   }
 
@@ -358,66 +354,81 @@ export class TranslateService {
   {
     if(isArray(translations))
     {
-      return (translations as Translation[]).map((translation) => this.runInterpolation(translation, interpolateParams));
+      return this.runInterpolationOnArray(translations, interpolateParams);
     }
     else if (isDict(translations))
     {
-      const result: TranslationObject = {};
-      for (const key in translations) {
-        const res = this.runInterpolation(translations[key], interpolateParams);
-        if(res !== undefined)
-        {
-          result[key] = res;
-        }
-      }
-      return result;
+      return this.runInterpolationOnDict(translations, interpolateParams);
     }
     else
     {
       return this.parser.interpolate(translations, interpolateParams);
     }
   }
 
+  private runInterpolationOnArray(translations: InterpolatableTranslation, interpolateParams: InterpolationParameters | undefined)
+  {
+    return (translations as Translation[]).map((translation) => this.runInterpolation(translation, interpolateParams));
+  }
+
+  private runInterpolationOnDict(translations: InterpolatableTranslation, interpolateParams: InterpolationParameters | undefined)
+  {
+    const result: TranslationObject = {};
+    for (const key in translations)
+    {
+      const res = this.runInterpolation(translations[key], interpolateParams);
+      if (res !== undefined)
+      {
+        result[key] = res;
+      }
+    }
+    return result;
+  }
+
   /**
    * Returns the parsed result of the translations
    */
-  public getParsedResult(key: string | string[], interpolateParams?: InterpolationParameters): Translation|TranslationObject|Observable<Translation|TranslationObject> {
-
-    // handle a bunch of keys
-    if (key instanceof Array) {
-      const result: Record<string, Translation|Observable<Translation>> = {};
+  public getParsedResult(key: string | string[], interpolateParams?: InterpolationParameters): Translation|TranslationObject|Observable<Translation|TranslationObject>
+  {
+      return (key instanceof Array)  ? this.getParsedResultForArray(key, interpolateParams) :  this.getParsedResultForKey(key, interpolateParams);
+  }
 
-      let observables = false;
-      for (const k of key) {
-        result[k] = this.getParsedResultForKey(k, interpolateParams);
-        observables = observables || isObservable(result[k]);
-      }
+  private getParsedResultForArray(key: string[], interpolateParams: InterpolationParameters | undefined)
+  {
+    const result: Record<string, Translation | Observable<Translation>> = {};
 
-      if (!observables) {
-        return result as TranslationObject;
-      }
+    let observables = false;
+    for (const k of key)
+    {
+      result[k] = this.getParsedResultForKey(k, interpolateParams);
+      observables = observables || isObservable(result[k]);
+    }
 
-      const sources: Observable<Translation>[] = key.map(k => makeObservable(result[k]));
-      return forkJoin(sources).pipe(
-        map((arr: (Translation)[]) => {
-          const obj: TranslationObject = {};
-          arr.forEach((value:Translation, index: number) => {
-            obj[key[index]] = value;
-          });
-          return obj;
-        })
-      );
+    if (!observables)
+    {
+      return result as TranslationObject;
     }
 
-    return this.getParsedResultForKey(key, interpolateParams);
+    const sources: Observable<Translation>[] = key.map(k => makeObservable(result[k]));
+    return forkJoin(sources).pipe(
+      map((arr: (Translation)[]) =>
+      {
+        const obj: TranslationObject = {};
+        arr.forEach((value: Translation, index: number) =>
+        {
+          obj[key[index]] = value;
+        });
+        return obj;
+      })
+    );
   }
 
   /**
    * Gets the translated value of a key (or an array of keys)
    * @returns the translated key, or an object of translated keys
    */
   public get(key: string | string[], interpolateParams?: InterpolationParameters): Observable<Translation|TranslationObject> {
-    if (!isDefined(key) || !key.length) {
+    if (!isDefinedAndNotNull(key) || !key.length) {
       throw new Error(`Parameter "key" is required and cannot be empty`);
     }
     // check if we are loading a new translation to use
@@ -438,7 +449,7 @@ export class TranslateService {
    * @returns A stream of the translated key, or an object of translated keys
    */
   public getStreamOnTranslationChange(key: string | string[], interpolateParams?: InterpolationParameters): Observable<Translation|TranslationObject> {
-    if (!isDefined(key) || !key.length) {
+    if (!isDefinedAndNotNull(key) || !key.length) {
       throw new Error(`Parameter "key" is required and cannot be empty`);
     }
 
@@ -459,7 +470,7 @@ export class TranslateService {
    * @returns A stream of the translated key, or an object of translated keys
    */
   public stream(key: string | string[], interpolateParams?: InterpolationParameters): Observable<Translation|TranslationObject> {
-    if (!isDefined(key) || !key.length) {
+    if (!isDefinedAndNotNull(key) || !key.length) {
       throw new Error(`Parameter "key" required`);
     }
 
@@ -480,7 +491,7 @@ export class TranslateService {
    */
   public instant(key: string | string[], interpolateParams?: InterpolationParameters): Translation|TranslationObject
   {
-    if (!isDefined(key) || key.length === 0) {
+    if (!isDefinedAndNotNull(key) || key.length === 0) {
       throw new Error('Parameter "key" is required and cannot be empty');
     }
 

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

@@ -106,13 +106,6 @@ export class TranslateStore
         return this._onDefaultLangChange.asObservable();
     }
 
-    /**
-     * Update the list of available languages
-     */
-    public updateLanguages(): void {
-        this.addLanguages(Object.keys(this.translations));
-    }
-
     public addLanguages(languages: Language[]): void
     {
         this.languages = Array.from(new Set([...this.languages, ...languages]));

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

@@ -50,7 +50,7 @@ export function equals(o1: any, o2: any): boolean {
   return false;
 }
 
-export function isDefined(value: any): boolean {
+export function isDefinedAndNotNull(value: any): boolean {
   return typeof value !== 'undefined' && value !== null;
 }
 
@@ -142,8 +142,8 @@ export function getValue(target: any, key: string): any
   {
     key += keys.shift();
     if (
-      isDefined(target) &&
-      (isDefined(target[key]) || target[key] === null) &&
+      isDefinedAndNotNull(target) &&
+      (isDefinedAndNotNull(target[key]) || target[key] === null) &&
       (isDict(target[key]) || isArray(target[key]) || !keys.length)
     )
     {