@sumaris-net/ngx-components 0.28.3 → 0.28.4

package/bundles/sumaris-net.ngx-components.umd.js

@@ -2854,23 +2854,42 @@
         TranslateContextService.prototype.get = function (key, context, interpolateParams) {
             var _this = this;
             // No context: do a normal translate
-            if (!isNil(context))
+            if (!key || !isNil(context))
                 return this.translate.get(key, interpolateParams);
             // Compute a contextual i18n key, using the context as suffix
-            var contextKey = this.contextualKey(key, context);
+            var contextualKeys = this.contextualKeys(key, context);
             // Return the contextual translation, or default of not exists
-            return this.translate.get(contextKey, interpolateParams)
-                .pipe(operators.mergeMap(function (translation) { return (translation !== contextKey) ? rxjs.of(translation) : _this.translate.get(key); }));
+            return this.translate.get(contextualKeys, interpolateParams)
+                .pipe(operators.map(function (translations) { return _this.findFirstValid(contextualKeys, translations) || key; }));
         };
         TranslateContextService.prototype.instant = function (key, context, interpolateParams) {
             // No context: do a normal translate
-            if (isNilOrBlank(context))
+            if (!key || isNilOrBlank(context))
                 return this.translate.instant(key, interpolateParams);
             // Compute a contextual i18n key, using the context as suffix
-            var contextualKey = this.contextualKey(key, context);
-            // Return the contextual translation, or default of not exists
-            var translation = this.translate.instant(contextualKey, interpolateParams);
-            return (translation !== contextualKey) ? translation : this.translate.instant(key, interpolateParams);
+            var contextualKeys = this.contextualKeys(key, context);
+            var translations = this.translate.instant(contextualKeys, interpolateParams);
+            return this.findFirstValid(contextualKeys, translations) || key;
+        };
+        /**
+         * Compute contextual i18n keys, using the context as suffix.<br>
+         * Suffix can be simple name (like 'aaa' - will return ['<key>.aaa']) or complexe (like 'aaa.bbb' - will return ['<key>.aaa.bbb', '<key>.aaa']
+         *
+         * @param key
+         * @param context
+         * @private
+         */
+        TranslateContextService.prototype.contextualKeys = function (key, context) {
+            var _this = this;
+            return context.split('.')
+                .filter(isNotNilOrBlank)
+                .reduce(function (res, item) {
+                var inheritedContext = res.length > 0 ? (res[res.length - 1] + '.') : '';
+                return res.concat(inheritedContext + item);
+            }, [])
+                .reverse() // Start with children, ends with parent key
+                .map(function (contextItem) { return _this.contextualKey(key, contextItem); })
+                .concat(key);
         };
         /**
          * Compute a contextual i18n key, using the context as suffix
@@ -2890,6 +2909,25 @@
                 ? "" + context + key
                 : parts.slice(0, parts.length - 1).concat(context + parts[parts.length - 1]).join('.');
         };
+        TranslateContextService.prototype.findFirstValid = function (keys, translations) {
+            var e_1, _a;
+            try {
+                // For eac contextual key: try to find translation, then use the first valid
+                for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+                    var key = keys_1_1.value;
+                    if (translations[key] !== key)
+                        return translations[key];
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return undefined;
+        };
         return TranslateContextService;
     }());
     TranslateContextService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function TranslateContextService_Factory() { return new TranslateContextService(i0__namespace.ɵɵinject(i1__namespace$1.TranslateService)); }, token: TranslateContextService, providedIn: "root" });