fix: the type Translation not contains any again

Translation now extends StrictTranslation (without any that we use internally)
with any. This makes the change more compatible with the previous release -
and allows us to use the strict types internally.

Author: CodeAndWeb

projects/ngx-translate/src/lib/missing-translation-handler.spec.ts

@@ -4,8 +4,8 @@ import {
   MissingTranslationHandler,
   MissingTranslationHandlerParams, provideTranslateService,
   TranslateLoader,
-  TranslateService, Translation,
-  TranslationObject
+  TranslateService, StrictTranslation,
+  TranslationObject, Translation
 } from "../public-api";
 import {Injectable, Type} from "@angular/core";
 
@@ -37,7 +37,7 @@ describe('MissingTranslationHandler', () => {
 
   @Injectable()
   class MissingObs implements MissingTranslationHandler {
-    handle(params: MissingTranslationHandlerParams): Observable<Translation> {
+    handle(params: MissingTranslationHandlerParams): Observable<StrictTranslation> {
       return of(`handled: ${params.key}`);
     }
   }
@@ -68,7 +68,7 @@ describe('MissingTranslationHandler', () => {
     translate.get('nonExistingKey').subscribe((res: Translation) => {
       expect(missingTranslationHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining({key: 'nonExistingKey'}));
       //test that the instance of the last called argument is string
-      expect(res as string).toEqual('handled');
+      expect(res).toEqual('handled');
     });
   });
 
@@ -81,7 +81,7 @@ describe('MissingTranslationHandler', () => {
     translate.get('nonExistingKey', interpolateParams).subscribe((res: Translation) => {
       expect(missingTranslationHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining({interpolateParams: interpolateParams}));
       //test that the instance of the last called argument is string
-      expect(res as string).toEqual('handled');
+      expect(res).toEqual('handled');
     });
   });
 
@@ -95,13 +95,13 @@ describe('MissingTranslationHandler', () => {
              .subscribe((res: Translation) => {
       expect(missingTranslationHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining({translateService: translate}));
       //test that the instance of the last called argument is string
-      expect(res as string).toEqual('handled');
+      expect(res).toEqual('handled');
     });
   });
 
   it('should return the key when using MissingTranslationHandler & the handler returns nothing', () => {
     class MissingUndef implements MissingTranslationHandler {
-      handle(params: MissingTranslationHandlerParams):Translation|Observable<Translation> {
+      handle(params: MissingTranslationHandlerParams):StrictTranslation|Observable<StrictTranslation> {
         void params;
         const data:TranslationObject = {};
         return data['test'];
@@ -114,7 +114,7 @@ describe('MissingTranslationHandler', () => {
 
     translate.get('nonExistingKey').subscribe((res: Translation) => {
       expect(missingTranslationHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining({key: 'nonExistingKey'}));
-      expect(res as string).toEqual('nonExistingKey');
+      expect(res).toEqual('nonExistingKey');
     });
   });
 
@@ -133,7 +133,7 @@ describe('MissingTranslationHandler', () => {
     translate.use('en');
     spyOn(missingTranslationHandler, 'handle').and.callThrough();
 
-    expect(translate.instant('nonExistingKey') as string).toEqual('handled');
+    expect(translate.instant('nonExistingKey')).toEqual('handled');
     expect(missingTranslationHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining({key: 'nonExistingKey'}));
   });
 
@@ -144,7 +144,7 @@ describe('MissingTranslationHandler', () => {
 
     translate.get('nonExistingKey').subscribe((res: Translation) => {
       expect(missingTranslationHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining({key: 'nonExistingKey'}));
-      expect(res as string).toEqual('handled: nonExistingKey');
+      expect(res).toEqual('handled: nonExistingKey');
     });
   });
 
@@ -170,7 +170,7 @@ describe('MissingTranslationHandler', () => {
     translate.use('en');
     spyOn(missingTranslationHandler, 'handle').and.callThrough();
 
-    expect(translate.instant('nonExistingKey') as string).toEqual('nonExistingKey');
+    expect(translate.instant('nonExistingKey')).toEqual('nonExistingKey');
   });
 
   it('should not wait for the MissingTranslationHandler when it returns an observable & we use instant with an array', () => {
@@ -200,7 +200,7 @@ describe('MissingTranslationHandler', () => {
     translate.get('TEST').subscribe((res: Translation) => {
       expect(missingTranslationHandler.handle).toHaveBeenCalledWith(jasmine.objectContaining({key: 'TEST'}));
       //test that the instance of the last called argument is string
-      expect(res as string).toEqual('handled');
+      expect(res).toEqual('handled');
     });
   });
 
@@ -211,7 +211,7 @@ describe('MissingTranslationHandler', () => {
 
     spyOn(missingTranslationHandler, 'handle').and.callThrough();
     translate.get('TEST').subscribe((res: Translation) => {
-      expect(res as string).toEqual('This is a test');
+      expect(res).toEqual('This is a test');
     });
   });
 });

projects/ngx-translate/src/lib/missing-translation-handler.ts

@@ -1,6 +1,6 @@
 import {Injectable} from "@angular/core";
 import {Observable} from "rxjs";
-import {TranslateService, Translation} from "./translate.service";
+import {TranslateService, StrictTranslation} from "./translate.service";
 
 export interface MissingTranslationHandlerParams {
   /**
@@ -30,7 +30,7 @@ export abstract class MissingTranslationHandler {
    * If it returns an observable, the value returned by this observable will be used (except if the method was "instant").
    * If it returns undefined, the key will be used as a value
    */
-  abstract handle(params: MissingTranslationHandlerParams): Translation|Observable<Translation>;
+  abstract handle(params: MissingTranslationHandlerParams): StrictTranslation|Observable<StrictTranslation>;
 }
 
 /**

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

@@ -48,18 +48,18 @@ describe('TranslateCompiler', () => {
 
     it('should use the compiler on loading translations', () => {
       translate.get('LOAD').subscribe((res: Translation) => {
-        expect(res as string).toBe('This is a test');
+        expect(res).toBe('This is a test');
       });
     });
 
     it('should use the compiler on manually adding a translation object', () => {
       translate.setTranslation('en', {'SET-TRANSLATION': 'A manually added translation'});
-      expect(translate.instant('SET-TRANSLATION') as string).toBe('A manually added translation');
+      expect(translate.instant('SET-TRANSLATION')).toBe('A manually added translation');
     });
 
     it('should use the compiler on manually adding a single translation', () => {
       translate.set('SET', 'Another manually added translation', 'en');
-      expect(translate.instant('SET') as string).toBe('Another manually added translation');
+      expect(translate.instant('SET')).toBe('Another manually added translation');
     });
   });
 
@@ -101,18 +101,18 @@ describe('TranslateCompiler', () => {
 
     it('should use the compiler on loading translations', () => {
       translate.get('LOAD').subscribe((res: Translation) => {
-        expect(res as string).toBe('This is a test|compiled');
+        expect(res).toBe('This is a test|compiled');
       });
     });
 
     it('should use the compiler on manually adding a translation object', () => {
       translate.setTranslation('en', {'SET-TRANSLATION': 'A manually added translation'});
-      expect(translate.instant('SET-TRANSLATION') as string).toBe('A manually added translation|compiled');
+      expect(translate.instant('SET-TRANSLATION')).toBe('A manually added translation|compiled');
     });
 
     it('should use the compiler on manually adding a single translation', () => {
       translate.set('SET', 'Another manually added translation', 'en');
-      expect(translate.instant('SET') as string).toBe('Another manually added translation|compiled');
+      expect(translate.instant('SET')).toBe('Another manually added translation|compiled');
     });
   });
 });

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

@@ -6,7 +6,7 @@ import {
   LangChangeEvent,
   TranslateService,
   TranslationChangeEvent,
-  Translation,
+  StrictTranslation,
   InterpolationParameters
 } from "./translate.service";
 import {equals, isDefinedAndNotNull, isString} from "./util";
@@ -127,7 +127,7 @@ export class TranslateDirective implements AfterViewChecked, OnDestroy {
 
       this.lastParams = this.currentParams;
 
-      const onTranslation = (res: Translation) => {
+      const onTranslation = (res: StrictTranslation) => {
         if (res !== key || !node.lastKey) {
           node.lastKey = key;
         }

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

@@ -41,7 +41,7 @@ describe('TranslateLoader', () => {
 
     // this will request the translation from the backend because we use a static files loader for TranslateService
     translate.get('TEST').subscribe((res: Translation) => {
-      expect(res as string).toEqual('This is a test');
+      expect(res).toEqual('This is a test');
     });
   });
 
@@ -70,7 +70,7 @@ describe('TranslateLoader', () => {
 
     // this will request the translation from the CustomLoader
     translate.get('TEST').subscribe((res: Translation) => {
-      expect(res as string).toEqual('This is also a test');
+      expect(res).toEqual('This is also a test');
     });
   });
 

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

@@ -92,7 +92,7 @@ describe('TranslatePipe (modules)', () => {
     translate.setTranslation('en', {"TEST": "This is a test"});
     translate.use('en');
 
-    expect(translatePipe.transform('TEST') as string).toEqual("This is a test");
+    expect(translatePipe.transform('TEST')).toEqual("This is a test");
   });
 
   it('should call markForChanges when it translates a string', () => {
@@ -108,44 +108,44 @@ describe('TranslatePipe (modules)', () => {
     translate.setTranslation('en', {"TEST": "This is a test {{param}}"});
     translate.use('en');
 
-    expect(translatePipe.transform('TEST', {param: "with param"}) as string).toEqual("This is a test with param");
+    expect(translatePipe.transform('TEST', {param: "with param"})).toEqual("This is a test with param");
   });
 
   it('should translate a string with object as string parameters', () => {
     translate.setTranslation('en', {"TEST": "This is a test {{param}}"});
     translate.use('en');
 
-    expect(translatePipe.transform('TEST', '{param: "with param"}') as string).toEqual("This is a test with param");
-    expect(translatePipe.transform('TEST', '{"param": "with param"}') as string).toEqual("This is a test with param");
-    expect(translatePipe.transform('TEST', "{param: 'with param'}") as string).toEqual("This is a test with param");
-    expect(translatePipe.transform('TEST', "{'param' : 'with param'}") as string).toEqual("This is a test with param");
+    expect(translatePipe.transform('TEST', '{param: "with param"}')).toEqual("This is a test with param");
+    expect(translatePipe.transform('TEST', '{"param": "with param"}')).toEqual("This is a test with param");
+    expect(translatePipe.transform('TEST', "{param: 'with param'}")).toEqual("This is a test with param");
+    expect(translatePipe.transform('TEST', "{'param' : 'with param'}")).toEqual("This is a test with param");
   });
 
   it('should translate a string with object as multiple string parameters', () => {
     translate.setTranslation('en', {"TEST": "This is a test {{param1}} {{param2}}"});
     translate.use('en');
 
-    expect(translatePipe.transform('TEST', '{param1: "with param-1", param2: "and param-2"}') as string)
+    expect(translatePipe.transform('TEST', '{param1: "with param-1", param2: "and param-2"}'))
       .toEqual("This is a test with param-1 and param-2");
-    expect(translatePipe.transform('TEST', '{"param1": "with param-1", "param2": "and param-2"}') as string)
+    expect(translatePipe.transform('TEST', '{"param1": "with param-1", "param2": "and param-2"}'))
       .toEqual("This is a test with param-1 and param-2");
-    expect(translatePipe.transform('TEST', "{param1: 'with param-1', param2: 'and param-2'}") as string)
+    expect(translatePipe.transform('TEST', "{param1: 'with param-1', param2: 'and param-2'}"))
       .toEqual("This is a test with param-1 and param-2");
-    expect(translatePipe.transform('TEST', "{'param1' : 'with param-1', 'param2': 'and param-2'}") as string)
+    expect(translatePipe.transform('TEST', "{'param1' : 'with param-1', 'param2': 'and param-2'}"))
       .toEqual("This is a test with param-1 and param-2");
   });
 
   it('should translate a string with object as nested string parameters', () => {
     translate.setTranslation('en', {"TEST": "This is a test {{param.one}} {{param.two}}"});
     translate.use('en');
 
-    expect(translatePipe.transform('TEST', '{param: {one: "with param-1", two: "and param-2"}}') as string)
+    expect(translatePipe.transform('TEST', '{param: {one: "with param-1", two: "and param-2"}}'))
       .toEqual("This is a test with param-1 and param-2");
-    expect(translatePipe.transform('TEST', '{"param": {"one": "with param-1", "two": "and param-2"}}') as string)
+    expect(translatePipe.transform('TEST', '{"param": {"one": "with param-1", "two": "and param-2"}}'))
       .toEqual("This is a test with param-1 and param-2");
-    expect(translatePipe.transform('TEST', "{param: {one: 'with param-1', two: 'and param-2'}}") as string)
+    expect(translatePipe.transform('TEST', "{param: {one: 'with param-1', two: 'and param-2'}}"))
       .toEqual("This is a test with param-1 and param-2");
-    expect(translatePipe.transform('TEST', "{'param' : {'one': 'with param-1', 'two': 'and param-2'}}") as string)
+    expect(translatePipe.transform('TEST', "{'param' : {'one': 'with param-1', 'two': 'and param-2'}}"))
       .toEqual("This is a test with param-1 and param-2");
   });
 
@@ -156,15 +156,15 @@ describe('TranslatePipe (modules)', () => {
     spyOn(translatePipe, 'updateValue').and.callThrough();
     spyOn(ref, 'markForCheck').and.callThrough();
 
-    expect(translatePipe.transform('TEST', {param: "with param"}) as string).toEqual("This is a test with param");
+    expect(translatePipe.transform('TEST', {param: "with param"})).toEqual("This is a test with param");
     expect(translatePipe.updateValue).toHaveBeenCalledTimes(1);
 
     // same value, shouldn't call 'updateValue' again
-    expect(translatePipe.transform('TEST', {param: "with param"}) as string).toEqual("This is a test with param");
+    expect(translatePipe.transform('TEST', {param: "with param"})).toEqual("This is a test with param");
     expect(translatePipe.updateValue).toHaveBeenCalledTimes(1);
 
     // different param, should call 'updateValue'
-    expect(translatePipe.transform('TEST', {param: "with param2"}) as string).toEqual("This is a test with param2");
+    expect(translatePipe.transform('TEST', {param: "with param2"})).toEqual("This is a test with param2");
     expect(translatePipe.updateValue).toHaveBeenCalledTimes(2);
 
     expect(ref.markForCheck).toHaveBeenCalledTimes(2);
@@ -194,12 +194,12 @@ describe('TranslatePipe (modules)', () => {
       translate.setTranslation('fr', {"TEST": "C'est un test"});
       translate.use('en');
 
-      expect(translatePipe.transform('TEST') as string).toEqual("This is a test");
+      expect(translatePipe.transform('TEST')).toEqual("This is a test");
 
       // this will be resolved at the next lang change
       const subscription = translate.onLangChange.subscribe((res: LangChangeEvent) => {
         expect(res.lang).toEqual('fr');
-        expect(translatePipe.transform('TEST') as string).toEqual("C'est un test");
+        expect(translatePipe.transform('TEST')).toEqual("C'est un test");
         subscription.unsubscribe();
         done();
       });
@@ -209,14 +209,14 @@ describe('TranslatePipe (modules)', () => {
 
     it('with file loader', (done) => {
       translate.use('en');
-      expect(translatePipe.transform('TEST') as string).toEqual("This is a test");
+      expect(translatePipe.transform('TEST')).toEqual("This is a test");
 
       // this will be resolved at the next lang change
       const subscription = translate.onLangChange.subscribe((res: LangChangeEvent) => {
         // let it update the translations
         setTimeout(() => {
           expect(res.lang).toEqual('fr');
-          expect(translatePipe.transform('TEST') as string).toEqual("C'est un test");
+          expect(translatePipe.transform('TEST')).toEqual("C'est un test");
           subscription.unsubscribe();
           done();
         });
@@ -242,12 +242,12 @@ describe('TranslatePipe (modules)', () => {
       translate.setTranslation('fr', {"TEST": "C'est un test"});
       translate.setDefaultLang('en');
 
-      expect(translatePipe.transform('TEST') as string).toEqual("This is a test");
+      expect(translatePipe.transform('TEST')).toEqual("This is a test");
 
       // this will be resolved at the next lang change
       const subscription = translate.onDefaultLangChange.subscribe((res: DefaultLangChangeEvent) => {
         expect(res.lang).toEqual('fr');
-        expect(translatePipe.transform('TEST') as string).toEqual("C'est un test");
+        expect(translatePipe.transform('TEST')).toEqual("C'est un test");
         subscription.unsubscribe();
         done();
       });
@@ -257,14 +257,14 @@ describe('TranslatePipe (modules)', () => {
 
     it('with file loader', (done) => {
       translate.setDefaultLang('en');
-      expect(translatePipe.transform('TEST') as string).toEqual("This is a test");
+      expect(translatePipe.transform('TEST')).toEqual("This is a test");
 
       // this will be resolved at the next lang change
       const subscription = translate.onDefaultLangChange.subscribe((res: DefaultLangChangeEvent) => {
         // let it update the translations
         setTimeout(() => {
           expect(res.lang).toEqual('fr');
-          expect(translatePipe.transform('TEST') as string).toEqual("C'est un test");
+          expect(translatePipe.transform('TEST')).toEqual("C'est un test");
           subscription.unsubscribe();
           done();
         });