@tolgee/ngx 4.9.2 → 4.10.0-rc.4a0f1a6.0

package/esm2020/lib/NgxPlugin.mjs

@@ -0,0 +1,5 @@
+import { DevTools } from '@tolgee/web';
+export const NgxPlugin = () => (tolgee) => {
+    return tolgee.use(DevTools());
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmd4UGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRvbGdlZS9zcmMvbGliL05neFBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWdCLFFBQVEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUVyRCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsR0FBaUIsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLEVBQUU7SUFDdEQsT0FBTyxNQUFNLENBQUMsR0FBRyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7QUFDaEMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVG9sZ2VlUGx1Z2luLCBEZXZUb29scyB9IGZyb20gJ0B0b2xnZWUvd2ViJztcblxuZXhwb3J0IGNvbnN0IE5neFBsdWdpbiA9ICgpOiBUb2xnZWVQbHVnaW4gPT4gKHRvbGdlZSkgPT4ge1xuICByZXR1cm4gdG9sZ2VlLnVzZShEZXZUb29scygpKTtcbn07XG4iXX0=

package/esm2020/lib/loader.component.mjs

@@ -0,0 +1,21 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LoaderComponent {
+}
+LoaderComponent.ɵfac = function LoaderComponent_Factory(t) { return new (t || LoaderComponent)(); };
+LoaderComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LoaderComponent, selectors: [["ng-component"]], inputs: { html: "html" }, decls: 1, vars: 1, consts: [[1, "loader-template", 3, "innerHTML"]], template: function LoaderComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelement(0, "div", 0);
+    } if (rf & 2) {
+        i0.ɵɵproperty("innerHTML", ctx.html, i0.ɵɵsanitizeHtml);
+    } }, encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoaderComponent, [{
+        type: Component,
+        args: [{
+                template: `
+    <div class="loader-template" [innerHTML]="html"></div>
+  `,
+            }]
+    }], null, { html: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC10b2xnZWUvc3JjL2xpYi9sb2FkZXIuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU9qRCxNQUFNLE9BQU8sZUFBZTs7OEVBQWYsZUFBZTtrRUFBZixlQUFlO1FBSHhCLHlCQUFzRDs7UUFBekIsdURBQWtCOzt1RkFHdEMsZUFBZTtjQUwzQixTQUFTO2VBQUM7Z0JBQ1QsUUFBUSxFQUFFOztHQUVUO2FBQ0Y7Z0JBRVUsSUFBSTtrQkFBWixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgdGVtcGxhdGU6IGBcbiAgICA8ZGl2IGNsYXNzPVwibG9hZGVyLXRlbXBsYXRlXCIgW2lubmVySFRNTF09XCJodG1sXCI+PC9kaXY+XG4gIGAsXG59KVxuZXhwb3J0IGNsYXNzIExvYWRlckNvbXBvbmVudCB7XG4gIEBJbnB1dCgpIGh0bWw6IHN0cmluZyB8IHVuZGVmaW5lZDtcbn1cbiJdfQ==

package/esm2020/lib/loading-template.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const TOLGEE_LOADING_TEMPLATE = new InjectionToken('tolgee.loading-template');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZGluZy10ZW1wbGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25neC10b2xnZWUvc3JjL2xpYi9sb2FkaW5nLXRlbXBsYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQWdCLE1BQU0sZUFBZSxDQUFDO0FBRTdELE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLElBQUksY0FBYyxDQUV0RCx5QkFBeUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIENvbXBvbmVudFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY29uc3QgVE9MR0VFX0xPQURJTkdfVEVNUExBVEUgPSBuZXcgSW5qZWN0aW9uVG9rZW48e1xuICBjb21wb25lbnQ6IENvbXBvbmVudFJlZjx1bmtub3duPiB8IHN0cmluZztcbn0+KCd0b2xnZWUubG9hZGluZy10ZW1wbGF0ZScpO1xuIl19

package/esm2020/lib/ngx-tolgee.module.mjs

@@ -1,43 +1,39 @@
 import { APP_INITIALIZER, NgModule } from '@angular/core';
 import { TranslatePipe } from './translate.pipe';
-import { TranslationsProvider } from './translations-provider';
-import { TranslateService } from './translate.service';
-import { STranslatePipe } from './stranslate.pipe';
-import { TolgeeConfig } from './tolgeeConfig';
 import { TComponent } from './t.component';
+import { TranslateService } from './translate.service';
+import { LoaderComponent } from "./loader.component";
 import * as i0 from "@angular/core";
 export class NgxTolgeeModule {
-    // @dynamic
-    static forRoot(options) {
-        options = { filesUrlPrefix: '/assets/i18n/', ...options };
-        return {
-            ngModule: NgxTolgeeModule,
-            providers: [
-                TranslateService,
-                TranslationsProvider,
-                {
-                    provide: APP_INITIALIZER,
-                    useFactory: (provider) => {
-                        return async () => await provider.load(options);
-                    },
-                    deps: [TranslationsProvider, TranslateService],
-                    multi: true,
-                },
-                { provide: TolgeeConfig, useValue: options },
-            ],
-        };
-    }
 }
 NgxTolgeeModule.ɵfac = function NgxTolgeeModule_Factory(t) { return new (t || NgxTolgeeModule)(); };
 NgxTolgeeModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: NgxTolgeeModule });
-NgxTolgeeModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [] });
+NgxTolgeeModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ providers: [
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (service) => {
+                return async () => await service.start();
+            },
+            deps: [TranslateService],
+            multi: true,
+        },
+    ] });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NgxTolgeeModule, [{
         type: NgModule,
         args: [{
-                declarations: [TranslatePipe, STranslatePipe, TComponent],
-                exports: [TranslatePipe, STranslatePipe, TComponent],
-                providers: [],
+                declarations: [TranslatePipe, TComponent, LoaderComponent],
+                exports: [TranslatePipe, TComponent],
+                providers: [
+                    {
+                        provide: APP_INITIALIZER,
+                        useFactory: (service) => {
+                            return async () => await service.start();
+                        },
+                        deps: [TranslateService],
+                        multi: true,
+                    },
+                ],
             }]
     }], null, null); })();
-(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(NgxTolgeeModule, { declarations: [TranslatePipe, STranslatePipe, TComponent], exports: [TranslatePipe, STranslatePipe, TComponent] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(NgxTolgeeModule, { declarations: [TranslatePipe, TComponent, LoaderComponent], exports: [TranslatePipe, TComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/t.component.mjs

@@ -1,44 +1,94 @@
-import { Component, Input } from '@angular/core';
-import { TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE } from '@tolgee/core';
+import { Component, Inject, Input, Optional, } from '@angular/core';
+import { TOLGEE_LOADING_TEMPLATE } from './loading-template';
+import { TemplateHandler } from './template-handler';
 import * as i0 from "@angular/core";
 import * as i1 from "./translate.service";
 const _c0 = ["t", ""];
 export class TComponent {
-    constructor(ref, translateService) {
+    constructor(ref, translateService, loadingTemplate, vcr) {
         this.ref = ref;
         this.translateService = translateService;
+        this.loadingTemplate = loadingTemplate;
+        this.vcr = vcr;
     }
     ngOnInit() {
-        const element = this.ref.nativeElement;
-        element.setAttribute(TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE, this.key);
-        // set safe at first
-        element.textContent = this.translateService.instantSafe(this.key, this.params, this.default);
-        // then do the async translation
-        this.subscription = this.translateService
-            .getSafe(this.key, this.params, this.default)
-            .subscribe((translated) => {
-            return (element.textContent = translated);
-        });
+        // noinspection JSIgnoredPromiseFromCall
+        this.subscribe();
+        if (this.shouldRenderLoading()) {
+            this.renderLoading();
+            return;
+        }
+        this.renderInstantValue();
+    }
+    ngOnChanges() {
+        // noinspection JSIgnoredPromiseFromCall
+        this.subscribe();
     }
     ngOnDestroy() {
         if (this.subscription) {
             this.subscription.unsubscribe();
         }
     }
+    renderInstantValue() {
+        // set safe at first
+        this.getElement().textContent = this.translateService.instant(this.getTranslateParams());
+    }
+    getTranslateParams() {
+        return {
+            key: this.key,
+            ns: this.ns,
+            params: this.params,
+            defaultValue: this.default,
+            noWrap: this.noWrap,
+        };
+    }
+    renderLoading() {
+        this.loaderTplHandler = new TemplateHandler(this.loadingTemplate, this.vcr);
+        this.loaderTplHandler.attachView();
+    }
+    shouldRenderLoading() {
+        return !this.isNamespaceLoaded() && this.loadingTemplate;
+    }
+    isNamespaceLoaded() {
+        return this.translateService.tolgee.isLoaded(this.ns);
+    }
+    async subscribe() {
+        this.subscription?.unsubscribe();
+        await this.translateService.tolgee.addActiveNs(this.ns);
+        this.subscription = this.translateService
+            .translate(this.getTranslateParams())
+            .subscribe((translated) => {
+            this.loaderTplHandler?.detachView();
+            this.getElement().textContent = translated;
+            this.initialized = true;
+        });
+    }
+    getElement() {
+        return this.ref.nativeElement;
+    }
 }
-TComponent.ɵfac = function TComponent_Factory(t) { return new (t || TComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.TranslateService)); };
-TComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: TComponent, selectors: [["", "t", ""]], inputs: { params: "params", key: "key", default: "default" }, attrs: _c0, decls: 0, vars: 0, template: function TComponent_Template(rf, ctx) { }, encapsulation: 2 });
+TComponent.ɵfac = function TComponent_Factory(t) { return new (t || TComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.TranslateService), i0.ɵɵdirectiveInject(TOLGEE_LOADING_TEMPLATE, 8), i0.ɵɵdirectiveInject(i0.ViewContainerRef)); };
+TComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: TComponent, selectors: [["", "t", ""]], inputs: { params: "params", key: "key", ns: "ns", default: "default", noWrap: "noWrap" }, features: [i0.ɵɵNgOnChangesFeature], attrs: _c0, decls: 0, vars: 0, template: function TComponent_Template(rf, ctx) { }, encapsulation: 2 });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TComponent, [{
         type: Component,
         args: [{
                 selector: '[t]',
                 template: ``,
             }]
-    }], function () { return [{ type: i0.ElementRef }, { type: i1.TranslateService }]; }, { params: [{
+    }], function () { return [{ type: i0.ElementRef }, { type: i1.TranslateService }, { type: undefined, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [TOLGEE_LOADING_TEMPLATE]
+            }] }, { type: i0.ViewContainerRef }]; }, { params: [{
             type: Input
         }], key: [{
             type: Input
+        }], ns: [{
+            type: Input
         }], default: [{
             type: Input
+        }], noWrap: [{
+            type: Input
         }] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/template-handler.mjs

@@ -0,0 +1,31 @@
+import { TemplateRef, ComponentFactoryResolver, } from '@angular/core';
+import { LoaderComponent } from "./loader.component";
+export class TemplateHandler {
+    constructor(view, vcr) {
+        this.view = view;
+        this.vcr = vcr;
+        this.injector = this.vcr.injector;
+    }
+    attachView() {
+        if (this.view instanceof TemplateRef) {
+            this.vcr.createEmbeddedView(this.view);
+        }
+        else if (typeof this.view === 'string') {
+            const componentRef = this.createComponent(LoaderComponent);
+            componentRef.instance.html = this.view;
+            componentRef.hostView.detectChanges();
+        }
+        else {
+            this.createComponent(this.view);
+        }
+    }
+    detachView() {
+        this.vcr.clear();
+    }
+    createComponent(cmp) {
+        const cfr = this.injector.get(ComponentFactoryResolver);
+        const factory = cfr.resolveComponentFactory(cmp);
+        return this.vcr.createComponent(factory);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/tolgee-instance-token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const TOLGEE_INSTANCE = new InjectionToken('tolgee.instance');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9sZ2VlLWluc3RhbmNlLXRva2VuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRvbGdlZS9zcmMvbGliL3RvbGdlZS1pbnN0YW5jZS10b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRy9DLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxJQUFJLGNBQWMsQ0FDL0MsaUJBQWlCLENBQ2xCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVG9sZ2VlSW5zdGFuY2UgfSBmcm9tICdAdG9sZ2VlL2NvcmUnO1xuXG5leHBvcnQgY29uc3QgVE9MR0VFX0lOU1RBTkNFID0gbmV3IEluamVjdGlvblRva2VuPFRvbGdlZUluc3RhbmNlPihcbiAgJ3RvbGdlZS5pbnN0YW5jZSdcbik7XG4iXX0=

package/esm2020/lib/translate.pipe.mjs

@@ -1,48 +1,39 @@
 import { Pipe } from '@angular/core';
+import { getTranslateParams } from '@tolgee/web';
 import * as i0 from "@angular/core";
 import * as i1 from "./translate.service";
 export class TranslatePipe {
     constructor(translateService) {
         this.translateService = translateService;
         this.value = '';
-    }
-    get resultProvider() {
-        return (key, params, defaultValue) => this.translateService.get(key, params, defaultValue);
+        this.transform = (...args) => {
+            // @ts-ignore
+            const params = getTranslateParams(...args);
+            const { key } = params;
+            if (!key || key.length === 0) {
+                return key;
+            }
+            if (JSON.stringify(this.params) === JSON.stringify(params)) {
+                return this.value;
+            }
+            this.params = params;
+            // unsubscribe first
+            this.unsubscribe();
+            // asynchronously translate and assign subscription
+            this.subscription = this.translate(params);
+            return this.value;
+        };
     }
     ngOnDestroy() {
         this.unsubscribe();
     }
-    transform(key, paramsOrDefaultValue, params) {
-        if (!key || key.length === 0) {
-            return key;
-        }
-        const defaultValue = typeof paramsOrDefaultValue !== 'object'
-            ? paramsOrDefaultValue
-            : undefined;
-        if (typeof paramsOrDefaultValue === 'object') {
-            params = paramsOrDefaultValue;
-        }
-        if (this.key === key &&
-            JSON.stringify(this.params) === JSON.stringify(params) &&
-            this.defaultValue === defaultValue) {
-            return this.value;
-        }
-        this.key = key;
-        this.params = params;
-        this.defaultValue = defaultValue;
-        // unsubscribe first
-        this.unsubscribe();
-        // asynchronously translate and assign subscription
-        this.subscription = this.translate(key, params, defaultValue);
-        return this.value;
-    }
     unsubscribe() {
         if (this.subscription) {
             this.subscription.unsubscribe();
         }
     }
-    translate(key, params, defaultValue) {
-        return this.resultProvider(key, params, defaultValue).subscribe((r) => {
+    translate(props) {
+        return this.translateService.translate(props).subscribe((r) => {
             this.value = r;
         });
     }
@@ -56,4 +47,4 @@ TranslatePipe.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "translate", type
                 pure: false,
             }]
     }], function () { return [{ type: i1.TranslateService }]; }, null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/translate.service.mjs

@@ -1,13 +1,41 @@
-import { EventEmitter, Injectable } from '@angular/core';
+import { Inject, Injectable } from '@angular/core';
 import { Observable } from 'rxjs';
-import { IcuFormatter, Tolgee } from '@tolgee/core';
+import { getTranslateParams, } from '@tolgee/web';
+import { TOLGEE_INSTANCE } from './tolgee-instance-token';
 import * as i0 from "@angular/core";
-import * as i1 from "./tolgeeConfig";
 export class TranslateService {
-    constructor(config) {
-        this.config = config;
-        this.onLangChange = new EventEmitter();
-        this.onTranslationChange = new EventEmitter();
+    constructor(_tolgee) {
+        this._tolgee = _tolgee;
+        this.language = new Observable((subscriber) => {
+            subscriber.next(this.tolgee.getLanguage());
+            const subscription = this.on('language').subscribe((value) => {
+                subscriber.next(value.value);
+            });
+            return () => subscription.unsubscribe();
+        });
+        this.instant = (...args) => {
+            // @ts-ignore
+            const params = getTranslateParams(...args);
+            return this.tolgee.t(params);
+        };
+        this.translate = (...args) => {
+            // @ts-ignore
+            const params = getTranslateParams(...args);
+            return new Observable((subscriber) => {
+                const translate = async () => {
+                    const translated = this.tolgee.t(params);
+                    subscriber.next(translated);
+                };
+                // noinspection JSIgnoredPromiseFromCall
+                translate();
+                const subscription = this.tolgee
+                    .onKeyUpdate(translate)
+                    .subscribeKey({ key: params.key, ns: params.ns });
+                return () => {
+                    subscription.unsubscribe();
+                };
+            });
+        };
     }
     get tolgee() {
         return this._tolgee;
@@ -15,30 +43,25 @@ export class TranslateService {
     /**
      * Starts Tolgee if not started and subscribes for languageChange and translationChange events
      */
-    async start(config) {
+    async start() {
         if (!this.runPromise) {
-            this._tolgee = Tolgee.use(IcuFormatter).init({
-                wrapperMode: 'invisible',
-                ...config,
-            });
             this.runPromise = this.tolgee.run();
-            // unsubscribe first, if it is subscribed for some reason
-            this.unsubscribeCoreListeners();
-            this.onTranslationChangeCoreSubscription =
-                this._tolgee.onTranslationChange.subscribe((data) => {
-                    this.onTranslationChange.emit(data);
-                });
-            this.onLangChangeCoreSubscription = this._tolgee.onLangChange.subscribe(() => {
-                this.onLangChange.emit();
-            });
         }
         await this.runPromise;
     }
     ngOnDestroy() {
         // stop it!
         this.tolgee.stop();
-        // unsubscribe listeners
-        this.unsubscribeCoreListeners();
+    }
+    on(event) {
+        return new Observable((subscriber) => {
+            const subscription = this.tolgee.on(event, (value) => {
+                subscriber.next(value);
+            });
+            return () => {
+                subscription.unsubscribe;
+            };
+        });
     }
     /**
      * Changes the current language
@@ -49,107 +72,14 @@ export class TranslateService {
     setLang(lang) {
         return this.tolgee.changeLanguage(lang);
     }
-    /**
-     * Returns the current language
-     */
-    getCurrentLang() {
-        return this.tolgee.lang;
-    }
-    /**
-     * Returns Observable providing current translated value
-     * Tne observable is subscribed to translation change and language change events of Tolgee
-     *
-     * In development mode, it returns string wrapped with configured
-     * prefix and suffix to be handled in browser by MutationObserver.
-     *
-     * You should use unsubscribe method when you are done!
-     *
-     * in onInit: this.subscription = translateService.get('aa')
-     * in onDestroy: this.subscription.unsubscribe()
-     *
-     * @param key The key to translate (e.g. what-a-key)
-     * @param params The parameters to interpolate (e.g. {name: "John"})
-     * @param defaultValue Value, which will be rendered, when no translated value is provided
-     */
-    get(key, params = {}, defaultValue) {
-        return this.translate(key, params, false, defaultValue);
-    }
-    /**
-     * Returns Observable providing current translated value
-     * Tne observable is subscribed to translation change and language change events of Tolgee
-     *
-     * In development mode, it returns the translated string,
-     * so in-context localization is not going to work.
-     *
-     * You should use unsubscribe method when you are done!
-     *
-     * in onInit: this.subscription = translateService.get('aa')
-     * in onDestroy: this.subscription.unsubscribe()
-     *
-     * @param key The key to translate (e.g. what-a-key)
-     * @param params The parameters to interpolate (e.g. {name: "John"})
-     * @param defaultValue Value, which will be rendered, when no translated value is provided
-     */
-    getSafe(key, params = {}, defaultValue) {
-        return this.translate(key, params, true, defaultValue);
-    }
-    /**
-     * Returns the translation value synchronously
-     *
-     * In development mode, it returns string wrapped with configured
-     * prefix and suffix to be handled in browser by MutationObserver.
-     *
-     * @param key The key to translate (e.g. what-a-key)
-     * @param params The parameters to interpolate (e.g. {name: "John"})
-     * @param defaultValue Value, which will be rendered, when no translated value is provided
-     */
-    instant(key, params = {}, defaultValue) {
-        return this.tolgee.instant(key, params, undefined, undefined, defaultValue);
-    }
-    /**
-     * Returns the translation value synchronously
-     *
-     * In development mode, it returns the translated string,
-     * so in-context localization is not going to work.
-     *
-     * @param key The key to translate (e.g. what-a-key)
-     * @param params The parameters to interpolate (e.g. {name: "John"})
-     * @param defaultValue Value, which will be rendered, when no translated value is provided
-     */
-    instantSafe(input, params = {}, defaultValue) {
-        return this.tolgee.instant(input, params, true, undefined, defaultValue);
-    }
-    unsubscribeCoreListeners() {
-        this.onTranslationChangeCoreSubscription?.unsubscribe();
-        this.onLangChangeCoreSubscription?.unsubscribe();
-    }
-    translate(key, params = {}, noWrap = false, defaultValue) {
-        return new Observable((subscriber) => {
-            const translate = async () => {
-                // start if not started
-                await this.start(this.config);
-                const translated = await this.tolgee.translate(key, params, noWrap, defaultValue);
-                subscriber.next(translated);
-            };
-            translate();
-            const onTranslationChangeSubscription = this.tolgee.onTranslationChange.subscribe((data) => {
-                if (data.key === key) {
-                    translate();
-                }
-            });
-            const onLanguageChangeSubscription = this.tolgee.onLangChange.subscribe(() => {
-                translate();
-            });
-            return () => {
-                onTranslationChangeSubscription.unsubscribe();
-                onLanguageChangeSubscription.unsubscribe();
-            };
-        });
-    }
 }
-TranslateService.ɵfac = function TranslateService_Factory(t) { return new (t || TranslateService)(i0.ɵɵinject(i1.TolgeeConfig)); };
-TranslateService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TranslateService, factory: TranslateService.ɵfac });
+TranslateService.ɵfac = function TranslateService_Factory(t) { return new (t || TranslateService)(i0.ɵɵinject(TOLGEE_INSTANCE)); };
+TranslateService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TranslateService, factory: TranslateService.ɵfac, providedIn: 'root' });
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslateService, [{
-        type: Injectable
-    }], function () { return [{ type: i1.TolgeeConfig }]; }, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.service.js","sourceRoot":"","sources":["../../../../projects/ngx-tolgee/src/lib/translate.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Injectable, OnDestroy } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { IcuFormatter, Tolgee, TranslationData } from '@tolgee/core';\nimport { TolgeeConfig } from './tolgeeConfig';\n\n@Injectable()\nexport class TranslateService implements OnDestroy {\n  public readonly onLangChange: EventEmitter<never> = new EventEmitter<never>();\n  public readonly onTranslationChange: EventEmitter<TranslationData> =\n    new EventEmitter<TranslationData>();\n\n  private runPromise: Promise<void>;\n  private onTranslationChangeCoreSubscription: any;\n  private onLangChangeCoreSubscription: any;\n\n  constructor(private config: TolgeeConfig) {}\n\n  private _tolgee: Tolgee;\n\n  public get tolgee(): Tolgee {\n    return this._tolgee;\n  }\n\n  /**\n   * Starts Tolgee if not started and subscribes for languageChange and translationChange events\n   */\n  public async start(config: TolgeeConfig): Promise<void> {\n    if (!this.runPromise) {\n      this._tolgee = Tolgee.use(IcuFormatter).init({\n        wrapperMode: 'invisible',\n        ...config,\n      });\n      this.runPromise = this.tolgee.run();\n      // unsubscribe first, if it is subscribed for some reason\n      this.unsubscribeCoreListeners();\n      this.onTranslationChangeCoreSubscription =\n        this._tolgee.onTranslationChange.subscribe((data) => {\n          this.onTranslationChange.emit(data);\n        });\n      this.onLangChangeCoreSubscription = this._tolgee.onLangChange.subscribe(\n        () => {\n          this.onLangChange.emit();\n        }\n      );\n    }\n    await this.runPromise;\n  }\n\n  ngOnDestroy(): void {\n    // stop it!\n    this.tolgee.stop();\n    // unsubscribe listeners\n    this.unsubscribeCoreListeners();\n  }\n\n  /**\n   * Changes the current language\n   * @param lang The new current language (e.g. en, en-US)\n   * @return Promise<void> Resolves when translations\n   * for given language are loaded\n   */\n  public setLang(lang: string) {\n    return this.tolgee.changeLanguage(lang);\n  }\n\n  /**\n   * Returns the current language\n   */\n  public getCurrentLang(): string {\n    return this.tolgee.lang;\n  }\n\n  /**\n   * Returns Observable providing current translated value\n   * Tne observable is subscribed to translation change and language change events of Tolgee\n   *\n   * In development mode, it returns string wrapped with configured\n   * prefix and suffix to be handled in browser by MutationObserver.\n   *\n   * You should use unsubscribe method when you are done!\n   *\n   * in onInit: this.subscription = translateService.get('aa')\n   * in onDestroy: this.subscription.unsubscribe()\n   *\n   * @param key The key to translate (e.g. what-a-key)\n   * @param params The parameters to interpolate (e.g. {name: \"John\"})\n   * @param defaultValue Value, which will be rendered, when no translated value is provided\n   */\n  public get(\n    key: string,\n    params = {},\n    defaultValue?: string\n  ): Observable<string> {\n    return this.translate(key, params, false, defaultValue);\n  }\n\n  /**\n   * Returns Observable providing current translated value\n   * Tne observable is subscribed to translation change and language change events of Tolgee\n   *\n   * In development mode, it returns the translated string,\n   * so in-context localization is not going to work.\n   *\n   * You should use unsubscribe method when you are done!\n   *\n   * in onInit: this.subscription = translateService.get('aa')\n   * in onDestroy: this.subscription.unsubscribe()\n   *\n   * @param key The key to translate (e.g. what-a-key)\n   * @param params The parameters to interpolate (e.g. {name: \"John\"})\n   * @param defaultValue Value, which will be rendered, when no translated value is provided\n   */\n  public getSafe(\n    key: string,\n    params = {},\n    defaultValue?: string\n  ): Observable<string> {\n    return this.translate(key, params, true, defaultValue);\n  }\n\n  /**\n   * Returns the translation value synchronously\n   *\n   * In development mode, it returns string wrapped with configured\n   * prefix and suffix to be handled in browser by MutationObserver.\n   *\n   * @param key The key to translate (e.g. what-a-key)\n   * @param params The parameters to interpolate (e.g. {name: \"John\"})\n   * @param defaultValue Value, which will be rendered, when no translated value is provided\n   */\n  public instant(key: string, params = {}, defaultValue?: string): string {\n    return this.tolgee.instant(key, params, undefined, undefined, defaultValue);\n  }\n\n  /**\n   * Returns the translation value synchronously\n   *\n   * In development mode, it returns the translated string,\n   * so in-context localization is not going to work.\n   *\n   * @param key The key to translate (e.g. what-a-key)\n   * @param params The parameters to interpolate (e.g. {name: \"John\"})\n   * @param defaultValue Value, which will be rendered, when no translated value is provided\n   */\n  public instantSafe(\n    input: string,\n    params = {},\n    defaultValue?: string\n  ): string {\n    return this.tolgee.instant(input, params, true, undefined, defaultValue);\n  }\n\n  private unsubscribeCoreListeners() {\n    this.onTranslationChangeCoreSubscription?.unsubscribe();\n    this.onLangChangeCoreSubscription?.unsubscribe();\n  }\n\n  private translate(\n    key: string,\n    params = {},\n    noWrap = false,\n    defaultValue: string\n  ): Observable<string> {\n    return new Observable((subscriber) => {\n      const translate = async () => {\n        // start if not started\n        await this.start(this.config);\n        const translated = await this.tolgee.translate(\n          key,\n          params,\n          noWrap,\n          defaultValue\n        );\n\n        subscriber.next(translated);\n      };\n\n      translate();\n\n      const onTranslationChangeSubscription =\n        this.tolgee.onTranslationChange.subscribe((data) => {\n          if (data.key === key) {\n            translate();\n          }\n        });\n\n      const onLanguageChangeSubscription = this.tolgee.onLangChange.subscribe(\n        () => {\n          translate();\n        }\n      );\n\n      return () => {\n        onTranslationChangeSubscription.unsubscribe();\n        onLanguageChangeSubscription.unsubscribe();\n      };\n    });\n  }\n}\n"]}
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [TOLGEE_INSTANCE]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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