Merge pull request #1 from bameyrick/default-value

Add ability to provide default value

Author: bameyrick

packages/ng-lazy-translate/README.md

@@ -214,3 +214,31 @@ The translation service uses [messageformat](https://messageformat.github.io/) t
   ```typescript
   this.translateService.translate('common.greetings.hello_world', { name: 'John', time: '10:00' });
   ```
+
+## Default value
+
+If you want to provide a default value for when a translation is not found in any language, you can do so by passing it as the last parameter to the translate pipe or function:
+
+- Template:
+
+  ```html
+  {{ 'common.greetings.hello_world' | translate: { name: 'John', time: '10:00' }: 'Hello, this is my default string' }}
+  ```
+
+  or without values:
+
+  ```html
+  {{ 'common.greetings.hello_world' | translate: 'Hello, this is my default string' }}
+  ```
+
+- Component/Service:
+
+  ```typescript
+  this.translateService.translate('common.greetings.hello_world', { name: 'John', time: '10:00' }, 'Hello, this is my default string');
+  ```
+
+  or without values:
+
+  ```typescript
+  this.translateService.translate('common.greetings.hello_world', undefined, 'Hello, this is my default string');
+  ```

packages/ng-lazy-translate/src/lib/pipe/translate.pipe.spec.ts

@@ -48,8 +48,20 @@ describe(`LazyTranslatePipe`, () => {
       expect(paramsSpy).toHaveBeenCalledWith({ key: 'test', interpolateParams: { test: 'test' } });
     });
 
-    it(`should throw a syntax error if the interpolateParams are not valid`, () => {
-      expect(() => pipe.transform('test', `{ test: 'test'`)).toThrowError(SyntaxError);
+    it(`should pass the defaultValue when interpolateParams are provided`, () => {
+      const paramsSpy = jest.spyOn((pipe as any).params$, 'next');
+
+      pipe.transform('no-value-test', `{ test: 'test' }`, 'default');
+
+      expect(paramsSpy).toHaveBeenCalledWith({ key: 'no-value-test', interpolateParams: { test: 'test' }, defaultValue: 'default' });
+    });
+
+    it(`should pass the defaultValue when interpolateParams are not provided`, () => {
+      const paramsSpy = jest.spyOn((pipe as any).params$, 'next');
+
+      pipe.transform('no-value-test', 'default');
+
+      expect(paramsSpy).toHaveBeenCalledWith({ key: 'no-value-test', defaultValue: 'default' });
     });
   });
 });

packages/ng-lazy-translate/src/lib/pipe/translate.pipe.ts

@@ -18,7 +18,7 @@ export class LazyTranslatePipe implements PipeTransform, OnDestroy {
   /**
    * An observable of the params provided from the transform
    */
-  private readonly params$ = new Subject<{ key?: string | null; interpolateParams?: Dictionary<unknown> }>();
+  private readonly params$ = new Subject<{ key?: string | null; interpolateParams?: Dictionary<unknown>; defaultValue?: string }>();
 
   /**
    * Handle the params being updated
@@ -45,25 +45,32 @@ export class LazyTranslatePipe implements PipeTransform, OnDestroy {
 
   public transform(key?: string | null, ...args: Array<Dictionary<unknown> | string>): string | undefined {
     let interpolateParams: Dictionary<unknown> | undefined;
+    let defaultValue: string | undefined;
+
+    if (args.length > 1) {
+      defaultValue = args[1] as string;
+    }
 
     if (!isNullOrUndefined(args[0])) {
-      if (isString(args[0])) {
+      const params = args[0];
+
+      if (isString(params)) {
         /** 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"}
          */
-        const validArgs: string = args[0].replace(/(')?([a-zA-Z0-9_]+)(')?(\s)?:/g, '"$2":').replace(/:(\s)?(')(.*?)(')/g, ':"$3"');
+        const validArgs: string = params.replace(/(')?([a-zA-Z0-9_]+)(')?(\s)?:/g, '"$2":').replace(/:(\s)?(')(.*?)(')/g, ':"$3"');
 
         try {
           interpolateParams = JSON.parse(validArgs);
         } catch (error) {
-          throw new SyntaxError(`Incorrect parameter in TranslatePipe. Expected a valid Object, received: ${args[0]}`);
+          defaultValue = params;
         }
       } else if (isObject(args[0]) && !Array.isArray(args[0])) {
         interpolateParams = args[0] as Dictionary<unknown>;
       }
     }
 
-    this.params$.next({ key, interpolateParams });
+    this.params$.next({ key, interpolateParams, defaultValue });
 
     return this.value;
   }

packages/ng-lazy-translate/src/lib/translate.service.spec.ts

@@ -133,6 +133,16 @@ describe(`LazyTranslateService`, () => {
         expect(await result).toBe('common.test');
       });
 
+      it(`should return the default value if no translation is found and a default value is provided`, async () => {
+        const result = firstValueFrom(service.translate('common.no-value', undefined, 'default'));
+
+        await delay();
+
+        httpMock.expectOne(TEST_ASSET_PATHS[`en.common`]).flush({});
+
+        expect(await result).toBe('default');
+      });
+
       it(`the value should update when the language changes`, async () => {
         let result = '';
 

packages/ng-lazy-translate/src/lib/translate.service.ts

@@ -75,12 +75,12 @@ export class LazyTranslateService {
     this.language$.next(this.getValidLanguageCode(language));
   }
 
-  public translate(key?: string | null, params?: Record<string, unknown>): Observable<string> {
+  public translate(key?: string | null, params?: Record<string, unknown>, defaultValue?: string): Observable<string> {
     return combineLatest([this.language$, this.defaultLanguage$]).pipe(
       distinctUntilChanged((previous, next) => isEqual(previous, next)),
       concatMap(() => (isString(key) ? of(key) : NEVER)),
       mergeMap(k => from(this.getKey(k))),
-      map(result => (isNullOrUndefined(result) ? key || '' : result(this.flattenParams(params))))
+      map(result => (isNullOrUndefined(result) ? defaultValue || key || '' : result(this.flattenParams(params))))
     );
   }