@jsverse/transloco 7.0.0

package/esm2022/lib/transloco-testing.module.mjs

@@ -0,0 +1,76 @@
+import { APP_INITIALIZER, Inject, Injectable, InjectionToken, NgModule, } from '@angular/core';
+import { of } from 'rxjs';
+import { TranslocoModule } from './transloco.module';
+import { provideTransloco } from './transloco.providers';
+import { TranslocoService } from './transloco.service';
+import * as i0 from "@angular/core";
+const TRANSLOCO_TEST_LANGS = new InjectionToken('TRANSLOCO_TEST_LANGS - Available testing languages');
+const TRANSLOCO_TEST_OPTIONS = new InjectionToken('TRANSLOCO_TEST_OPTIONS - Testing options');
+export class TestingLoader {
+    langs;
+    constructor(langs) {
+        this.langs = langs;
+    }
+    getTranslation(lang) {
+        return of(this.langs[lang]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TestingLoader, deps: [{ token: TRANSLOCO_TEST_LANGS }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TestingLoader });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TestingLoader, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLOCO_TEST_LANGS]
+                }] }] });
+export function initTranslocoService(service, langs = {}, options) {
+    const preloadAllLangs = () => options.preloadLangs
+        ? Promise.all(Object.keys(langs).map((lang) => service.load(lang).toPromise()))
+        : Promise.resolve();
+    return preloadAllLangs;
+}
+export class TranslocoTestingModule {
+    static forRoot(options) {
+        return {
+            ngModule: TranslocoTestingModule,
+            providers: [
+                provideTransloco({
+                    loader: TestingLoader,
+                    config: {
+                        prodMode: true,
+                        missingHandler: { logMissingKey: false },
+                        ...options.translocoConfig,
+                    },
+                }),
+                {
+                    provide: TRANSLOCO_TEST_LANGS,
+                    useValue: options.langs,
+                },
+                {
+                    provide: TRANSLOCO_TEST_OPTIONS,
+                    useValue: options,
+                },
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: initTranslocoService,
+                    deps: [
+                        TranslocoService,
+                        TRANSLOCO_TEST_LANGS,
+                        TRANSLOCO_TEST_OPTIONS,
+                    ],
+                    multi: true,
+                },
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.9", ngImport: i0, type: TranslocoTestingModule, exports: [TranslocoModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoTestingModule, imports: [TranslocoModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoTestingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [TranslocoModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/transloco.config.mjs

@@ -0,0 +1,37 @@
+import { InjectionToken } from '@angular/core';
+export const TRANSLOCO_CONFIG = new InjectionToken('TRANSLOCO_CONFIG', {
+    providedIn: 'root',
+    factory: () => defaultConfig,
+});
+export const defaultConfig = {
+    defaultLang: 'en',
+    reRenderOnLangChange: false,
+    prodMode: false,
+    failedRetries: 2,
+    fallbackLang: [],
+    availableLangs: [],
+    missingHandler: {
+        logMissingKey: true,
+        useFallbackTranslation: false,
+        allowEmpty: false,
+    },
+    flatten: {
+        aot: false,
+    },
+    interpolation: ['{{', '}}'],
+};
+export function translocoConfig(config = {}) {
+    return {
+        ...defaultConfig,
+        ...config,
+        missingHandler: {
+            ...defaultConfig.missingHandler,
+            ...config.missingHandler,
+        },
+        flatten: {
+            ...defaultConfig.flatten,
+            ...config.flatten,
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/transloco.directive.mjs

@@ -0,0 +1,169 @@
+import { ChangeDetectorRef, Directive, ElementRef, inject, Input, Renderer2, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { forkJoin, switchMap } from 'rxjs';
+import { TemplateHandler } from './template-handler';
+import { TRANSLOCO_LANG } from './transloco-lang';
+import { TRANSLOCO_LOADING_TEMPLATE } from './transloco-loading-template';
+import { TRANSLOCO_SCOPE } from './transloco-scope';
+import { TranslocoService } from './transloco.service';
+import { listenOrNotOperator, resolveInlineLoader, shouldListenToLangChanges, } from './shared';
+import { LangResolver } from './lang-resolver';
+import { ScopeResolver } from './scope-resolver';
+import * as i0 from "@angular/core";
+export class TranslocoDirective {
+    service = inject(TranslocoService);
+    tpl = inject(TemplateRef, {
+        optional: true,
+    });
+    providerLang = inject(TRANSLOCO_LANG, { optional: true });
+    providerScope = inject(TRANSLOCO_SCOPE, { optional: true });
+    providedLoadingTpl = inject(TRANSLOCO_LOADING_TEMPLATE, {
+        optional: true,
+    });
+    cdr = inject(ChangeDetectorRef);
+    host = inject(ElementRef);
+    vcr = inject(ViewContainerRef);
+    renderer = inject(Renderer2);
+    subscription = null;
+    view;
+    translationMemo = {};
+    key;
+    params = {};
+    inlineScope;
+    inlineRead;
+    inlineLang;
+    inlineTpl;
+    currentLang;
+    loaderTplHandler;
+    // Whether we already rendered the view once
+    initialized = false;
+    path;
+    langResolver = new LangResolver();
+    scopeResolver = new ScopeResolver(this.service);
+    strategy = this.tpl === null ? 'attribute' : 'structural';
+    static ngTemplateContextGuard(dir, ctx) {
+        return true;
+    }
+    ngOnInit() {
+        const listenToLangChange = shouldListenToLangChanges(this.service, this.providerLang || this.inlineLang);
+        this.subscription = this.service.langChanges$
+            .pipe(switchMap((activeLang) => {
+            const lang = this.langResolver.resolve({
+                inline: this.inlineLang,
+                provider: this.providerLang,
+                active: activeLang,
+            });
+            return Array.isArray(this.providerScope)
+                ? forkJoin(this.providerScope.map((providerScope) => this.resolveScope(lang, providerScope)))
+                : this.resolveScope(lang, this.providerScope);
+        }), listenOrNotOperator(listenToLangChange))
+            .subscribe(() => {
+            this.currentLang = this.langResolver.resolveLangBasedOnScope(this.path);
+            this.strategy === 'attribute'
+                ? this.attributeStrategy()
+                : this.structuralStrategy(this.currentLang, this.inlineRead);
+            this.cdr.markForCheck();
+            this.initialized = true;
+        });
+        if (!this.initialized) {
+            const loadingContent = this.resolveLoadingContent();
+            if (loadingContent) {
+                this.loaderTplHandler = new TemplateHandler(loadingContent, this.vcr);
+                this.loaderTplHandler.attachView();
+            }
+        }
+    }
+    ngOnChanges(changes) {
+        // We need to support dynamic keys/params, so if this is not the first change CD cycle
+        // we need to run the function again in order to update the value
+        if (this.strategy === 'attribute') {
+            const notInit = Object.keys(changes).some((v) => !changes[v].firstChange);
+            notInit && this.attributeStrategy();
+        }
+    }
+    attributeStrategy() {
+        this.detachLoader();
+        this.renderer.setProperty(this.host.nativeElement, 'innerText', this.service.translate(this.key, this.params, this.currentLang));
+    }
+    structuralStrategy(lang, read) {
+        this.translationMemo = {};
+        if (this.view) {
+            // when the lang changes we need to change the reference so Angular will update the view
+            this.view.context['$implicit'] = this.getTranslateFn(lang, read);
+            this.view.context['currentLang'] = this.currentLang;
+        }
+        else {
+            this.detachLoader();
+            this.view = this.vcr.createEmbeddedView(this.tpl, {
+                $implicit: this.getTranslateFn(lang, read),
+                currentLang: this.currentLang,
+            });
+        }
+    }
+    getTranslateFn(lang, read) {
+        return (key, params) => {
+            const withRead = read ? `${read}.${key}` : key;
+            const withParams = params
+                ? `${withRead}${JSON.stringify(params)}`
+                : withRead;
+            if (Object.prototype.hasOwnProperty.call(this.translationMemo, withParams)) {
+                return this.translationMemo[withParams].value;
+            }
+            this.translationMemo[withParams] = {
+                params,
+                value: this.service.translate(withRead, params, lang),
+            };
+            return this.translationMemo[withParams].value;
+        };
+    }
+    resolveLoadingContent() {
+        return this.inlineTpl || this.providedLoadingTpl;
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            // Caretaker note: it's important to clean up references to subscriptions since they save the `next`
+            // callback within its `destination` property, preventing classes from being GC'd.
+            this.subscription = null;
+        }
+    }
+    detachLoader() {
+        this.loaderTplHandler?.detachView();
+    }
+    resolveScope(lang, providerScope) {
+        const resolvedScope = this.scopeResolver.resolve({
+            inline: this.inlineScope,
+            provider: providerScope,
+        });
+        this.path = this.langResolver.resolveLangPath(lang, resolvedScope);
+        const inlineLoader = resolveInlineLoader(providerScope, resolvedScope);
+        return this.service._loadDependencies(this.path, inlineLoader);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.9", type: TranslocoDirective, isStandalone: true, selector: "[transloco]", inputs: { key: ["transloco", "key"], params: ["translocoParams", "params"], inlineScope: ["translocoScope", "inlineScope"], inlineRead: ["translocoRead", "inlineRead"], inlineLang: ["translocoLang", "inlineLang"], inlineTpl: ["translocoLoadingTpl", "inlineTpl"] }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[transloco]',
+                    standalone: true,
+                }]
+        }], propDecorators: { key: [{
+                type: Input,
+                args: ['transloco']
+            }], params: [{
+                type: Input,
+                args: ['translocoParams']
+            }], inlineScope: [{
+                type: Input,
+                args: ['translocoScope']
+            }], inlineRead: [{
+                type: Input,
+                args: ['translocoRead']
+            }], inlineLang: [{
+                type: Input,
+                args: ['translocoLang']
+            }], inlineTpl: [{
+                type: Input,
+                args: ['translocoLoadingTpl']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transloco.directive.js","sourceRoot":"","sources":["../../../../../libs/transloco/src/lib/transloco.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Renderer2,\n  SimpleChanges,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport { forkJoin, Observable, Subscription, switchMap } from 'rxjs';\n\nimport { Content, TemplateHandler } from './template-handler';\nimport { TRANSLOCO_LANG } from './transloco-lang';\nimport { TRANSLOCO_LOADING_TEMPLATE } from './transloco-loading-template';\nimport { TRANSLOCO_SCOPE } from './transloco-scope';\nimport { TranslocoService } from './transloco.service';\nimport { HashMap, OrArray, Translation, TranslocoScope } from './types';\nimport {\n  listenOrNotOperator,\n  resolveInlineLoader,\n  shouldListenToLangChanges,\n} from './shared';\nimport { LangResolver } from './lang-resolver';\nimport { ScopeResolver } from './scope-resolver';\n\ntype TranslateFn = (key: string, params?: HashMap) => any;\ninterface ViewContext {\n  $implicit: TranslateFn;\n  currentLang: string;\n}\n\n@Directive({\n  selector: '[transloco]',\n  standalone: true,\n})\nexport class TranslocoDirective implements OnInit, OnDestroy, OnChanges {\n  private service = inject(TranslocoService);\n  private tpl = inject<TemplateRef<ViewContext>>(TemplateRef, {\n    optional: true,\n  });\n  private providerLang = inject(TRANSLOCO_LANG, { optional: true });\n  private providerScope: OrArray<TranslocoScope> | null = inject(\n    TRANSLOCO_SCOPE,\n    { optional: true }\n  );\n  private providedLoadingTpl = inject(TRANSLOCO_LOADING_TEMPLATE, {\n    optional: true,\n  });\n  private cdr = inject(ChangeDetectorRef);\n  private host = inject(ElementRef);\n  private vcr = inject(ViewContainerRef);\n  private renderer = inject(Renderer2);\n\n  subscription: Subscription | null = null;\n  view: EmbeddedViewRef<ViewContext> | undefined;\n\n  private translationMemo: Record<string, { value: any; params?: HashMap }> =\n    {};\n\n  @Input('transloco') key: string | undefined;\n  @Input('translocoParams') params: HashMap = {};\n  @Input('translocoScope') inlineScope: string | undefined;\n  @Input('translocoRead') inlineRead: string | undefined;\n  @Input('translocoLang') inlineLang: string | undefined;\n  @Input('translocoLoadingTpl') inlineTpl: Content | undefined;\n\n  private currentLang: string | undefined;\n  private loaderTplHandler: TemplateHandler | undefined;\n  // Whether we already rendered the view once\n  private initialized = false;\n  private path: string | undefined;\n  private langResolver = new LangResolver();\n  private scopeResolver = new ScopeResolver(this.service);\n  private readonly strategy = this.tpl === null ? 'attribute' : 'structural';\n\n  static ngTemplateContextGuard(\n    dir: TranslocoDirective,\n    ctx: unknown\n  ): ctx is ViewContext {\n    return true;\n  }\n\n  ngOnInit() {\n    const listenToLangChange = shouldListenToLangChanges(\n      this.service,\n      this.providerLang || this.inlineLang\n    );\n\n    this.subscription = this.service.langChanges$\n      .pipe(\n        switchMap((activeLang) => {\n          const lang = this.langResolver.resolve({\n            inline: this.inlineLang,\n            provider: this.providerLang,\n            active: activeLang,\n          });\n\n          return Array.isArray(this.providerScope)\n            ? forkJoin(\n                this.providerScope.map((providerScope) =>\n                  this.resolveScope(lang, providerScope)\n                )\n              )\n            : this.resolveScope(lang, this.providerScope);\n        }),\n        listenOrNotOperator(listenToLangChange)\n      )\n      .subscribe(() => {\n        this.currentLang = this.langResolver.resolveLangBasedOnScope(\n          this.path!\n        );\n        this.strategy === 'attribute'\n          ? this.attributeStrategy()\n          : this.structuralStrategy(this.currentLang, this.inlineRead);\n        this.cdr.markForCheck();\n        this.initialized = true;\n      });\n\n    if (!this.initialized) {\n      const loadingContent = this.resolveLoadingContent();\n      if (loadingContent) {\n        this.loaderTplHandler = new TemplateHandler(loadingContent, this.vcr);\n        this.loaderTplHandler.attachView();\n      }\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    // We need to support dynamic keys/params, so if this is not the first change CD cycle\n    // we need to run the function again in order to update the value\n    if (this.strategy === 'attribute') {\n      const notInit = Object.keys(changes).some((v) => !changes[v].firstChange);\n      notInit && this.attributeStrategy();\n    }\n  }\n\n  private attributeStrategy() {\n    this.detachLoader();\n    this.renderer.setProperty(\n      this.host.nativeElement,\n      'innerText',\n      this.service.translate(this.key!, this.params, this.currentLang)\n    );\n  }\n\n  private structuralStrategy(lang: string, read?: string) {\n    this.translationMemo = {};\n\n    if (this.view) {\n      // when the lang changes we need to change the reference so Angular will update the view\n      this.view.context['$implicit'] = this.getTranslateFn(lang, read);\n      this.view.context['currentLang'] = this.currentLang!;\n    } else {\n      this.detachLoader();\n      this.view = this.vcr.createEmbeddedView(this.tpl!, {\n        $implicit: this.getTranslateFn(lang, read),\n        currentLang: this.currentLang!,\n      });\n    }\n  }\n\n  protected getTranslateFn(\n    lang: string,\n    read: string | undefined\n  ): TranslateFn {\n    return (key: string, params?: HashMap) => {\n      const withRead = read ? `${read}.${key}` : key;\n      const withParams = params\n        ? `${withRead}${JSON.stringify(params)}`\n        : withRead;\n\n      if (\n        Object.prototype.hasOwnProperty.call(this.translationMemo, withParams)\n      ) {\n        return this.translationMemo[withParams].value;\n      }\n\n      this.translationMemo[withParams] = {\n        params,\n        value: this.service.translate(withRead, params, lang),\n      };\n\n      return this.translationMemo[withParams].value;\n    };\n  }\n\n  private resolveLoadingContent() {\n    return this.inlineTpl || this.providedLoadingTpl;\n  }\n\n  ngOnDestroy() {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n      // Caretaker note: it's important to clean up references to subscriptions since they save the `next`\n      // callback within its `destination` property, preventing classes from being GC'd.\n      this.subscription = null;\n    }\n  }\n\n  private detachLoader() {\n    this.loaderTplHandler?.detachView();\n  }\n\n  private resolveScope(\n    lang: string,\n    providerScope: TranslocoScope | null\n  ): Observable<Translation | Translation[]> {\n    const resolvedScope = this.scopeResolver.resolve({\n      inline: this.inlineScope,\n      provider: providerScope,\n    });\n    this.path = this.langResolver.resolveLangPath(lang, resolvedScope);\n    const inlineLoader = resolveInlineLoader(providerScope, resolvedScope);\n\n    return this.service._loadDependencies(this.path, inlineLoader);\n  }\n}\n"]}

package/esm2022/lib/transloco.interceptor.mjs

@@ -0,0 +1,17 @@
+import { InjectionToken, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export const TRANSLOCO_INTERCEPTOR = new InjectionToken('TRANSLOCO_INTERCEPTOR');
+export class DefaultInterceptor {
+    preSaveTranslation(translation) {
+        return translation;
+    }
+    preSaveTranslationKey(_, value) {
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: DefaultInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: DefaultInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: DefaultInterceptor, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsb2NvLmludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy90cmFuc2xvY28vc3JjL2xpYi90cmFuc2xvY28uaW50ZXJjZXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSTNELE1BQU0sQ0FBQyxNQUFNLHFCQUFxQixHQUFHLElBQUksY0FBYyxDQUNyRCx1QkFBdUIsQ0FDeEIsQ0FBQztBQVNGLE1BQU0sT0FBTyxrQkFBa0I7SUFDN0Isa0JBQWtCLENBQUMsV0FBd0I7UUFDekMsT0FBTyxXQUFXLENBQUM7SUFDckIsQ0FBQztJQUVELHFCQUFxQixDQUFDLENBQVMsRUFBRSxLQUFhO1FBQzVDLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQzt1R0FQVSxrQkFBa0I7MkdBQWxCLGtCQUFrQjs7MkZBQWxCLGtCQUFrQjtrQkFEOUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFRyYW5zbGF0aW9uIH0gZnJvbSAnLi90eXBlcyc7XG5cbmV4cG9ydCBjb25zdCBUUkFOU0xPQ09fSU5URVJDRVBUT1IgPSBuZXcgSW5qZWN0aW9uVG9rZW48VHJhbnNsb2NvSW50ZXJjZXB0b3I+KFxuICAnVFJBTlNMT0NPX0lOVEVSQ0VQVE9SJ1xuKTtcblxuZXhwb3J0IGludGVyZmFjZSBUcmFuc2xvY29JbnRlcmNlcHRvciB7XG4gIHByZVNhdmVUcmFuc2xhdGlvbih0cmFuc2xhdGlvbjogVHJhbnNsYXRpb24sIGxhbmc6IHN0cmluZyk6IFRyYW5zbGF0aW9uO1xuXG4gIHByZVNhdmVUcmFuc2xhdGlvbktleShrZXk6IHN0cmluZywgdmFsdWU6IHN0cmluZywgbGFuZzogc3RyaW5nKTogc3RyaW5nO1xufVxuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgRGVmYXVsdEludGVyY2VwdG9yIGltcGxlbWVudHMgVHJhbnNsb2NvSW50ZXJjZXB0b3Ige1xuICBwcmVTYXZlVHJhbnNsYXRpb24odHJhbnNsYXRpb246IFRyYW5zbGF0aW9uKTogVHJhbnNsYXRpb24ge1xuICAgIHJldHVybiB0cmFuc2xhdGlvbjtcbiAgfVxuXG4gIHByZVNhdmVUcmFuc2xhdGlvbktleShfOiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiB2YWx1ZTtcbiAgfVxufVxuIl19

package/esm2022/lib/transloco.loader.mjs

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+import { of } from 'rxjs';
+export class DefaultLoader {
+    translations;
+    constructor(translations) {
+        this.translations = translations;
+    }
+    getTranslation(lang) {
+        return of(this.translations.get(lang) || {});
+    }
+}
+export const TRANSLOCO_LOADER = new InjectionToken('TRANSLOCO_LOADER');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsb2NvLmxvYWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvdHJhbnNsb2NvL3NyYy9saWIvdHJhbnNsb2NvLmxvYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQy9DLE9BQU8sRUFBYyxFQUFFLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFldEMsTUFBTSxPQUFPLGFBQWE7SUFDSjtJQUFwQixZQUFvQixZQUFzQztRQUF0QyxpQkFBWSxHQUFaLFlBQVksQ0FBMEI7SUFBRyxDQUFDO0lBRTlELGNBQWMsQ0FBQyxJQUFZO1FBQ3pCLE9BQU8sRUFBRSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQy9DLENBQUM7Q0FDRjtBQUVELE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLElBQUksY0FBYyxDQUNoRCxrQkFBa0IsQ0FDbkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlLCBvZiB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyBUcmFuc2xhdGlvbiB9IGZyb20gJy4vdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRyYW5zbG9jb0xvYWRlciB7XG4gIGdldFRyYW5zbGF0aW9uKFxuICAgIGxhbmc6IHN0cmluZyxcbiAgICBkYXRhPzogVHJhbnNsb2NvTG9hZGVyRGF0YVxuICApOiBPYnNlcnZhYmxlPFRyYW5zbGF0aW9uPiB8IFByb21pc2U8VHJhbnNsYXRpb24+O1xufVxuXG5leHBvcnQgdHlwZSBUcmFuc2xvY29Mb2FkZXJEYXRhID0ge1xuICBzY29wZTogc3RyaW5nO1xufTtcblxuZXhwb3J0IGNsYXNzIERlZmF1bHRMb2FkZXIgaW1wbGVtZW50cyBUcmFuc2xvY29Mb2FkZXIge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHRyYW5zbGF0aW9uczogTWFwPHN0cmluZywgVHJhbnNsYXRpb24+KSB7fVxuXG4gIGdldFRyYW5zbGF0aW9uKGxhbmc6IHN0cmluZyk6IE9ic2VydmFibGU8VHJhbnNsYXRpb24+IHtcbiAgICByZXR1cm4gb2YodGhpcy50cmFuc2xhdGlvbnMuZ2V0KGxhbmcpIHx8IHt9KTtcbiAgfVxufVxuXG5leHBvcnQgY29uc3QgVFJBTlNMT0NPX0xPQURFUiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxUcmFuc2xvY29Mb2FkZXI+KFxuICAnVFJBTlNMT0NPX0xPQURFUidcbik7XG4iXX0=

package/esm2022/lib/transloco.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { TranslocoDirective } from './transloco.directive';
+import { TranslocoPipe } from './transloco.pipe';
+import * as i0 from "@angular/core";
+const decl = [TranslocoDirective, TranslocoPipe];
+export class TranslocoModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.9", ngImport: i0, type: TranslocoModule, imports: [TranslocoDirective, TranslocoPipe], exports: [TranslocoDirective, TranslocoPipe] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: decl,
+                    exports: decl,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsb2NvLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvdHJhbnNsb2NvL3NyYy9saWIvdHJhbnNsb2NvLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzNELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQzs7QUFFakQsTUFBTSxJQUFJLEdBQUcsQ0FBQyxrQkFBa0IsRUFBRSxhQUFhLENBQUMsQ0FBQztBQU1qRCxNQUFNLE9BQU8sZUFBZTt1R0FBZixlQUFlO3dHQUFmLGVBQWUsWUFOZCxrQkFBa0IsRUFBRSxhQUFhLGFBQWpDLGtCQUFrQixFQUFFLGFBQWE7d0dBTWxDLGVBQWU7OzJGQUFmLGVBQWU7a0JBSjNCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLElBQUk7b0JBQ2IsT0FBTyxFQUFFLElBQUk7aUJBQ2QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBUcmFuc2xvY29EaXJlY3RpdmUgfSBmcm9tICcuL3RyYW5zbG9jby5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgVHJhbnNsb2NvUGlwZSB9IGZyb20gJy4vdHJhbnNsb2NvLnBpcGUnO1xuXG5jb25zdCBkZWNsID0gW1RyYW5zbG9jb0RpcmVjdGl2ZSwgVHJhbnNsb2NvUGlwZV07XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IGRlY2wsXG4gIGV4cG9ydHM6IGRlY2wsXG59KVxuZXhwb3J0IGNsYXNzIFRyYW5zbG9jb01vZHVsZSB7fVxuIl19

package/esm2022/lib/transloco.pipe.mjs

@@ -0,0 +1,97 @@
+import { ChangeDetectorRef, Inject, Optional, Pipe, } from '@angular/core';
+import { switchMap, forkJoin } from 'rxjs';
+import { TranslocoService } from './transloco.service';
+import { TRANSLOCO_SCOPE } from './transloco-scope';
+import { TRANSLOCO_LANG } from './transloco-lang';
+import { listenOrNotOperator, resolveInlineLoader, shouldListenToLangChanges, } from './shared';
+import { LangResolver } from './lang-resolver';
+import { ScopeResolver } from './scope-resolver';
+import * as i0 from "@angular/core";
+import * as i1 from "./transloco.service";
+export class TranslocoPipe {
+    service;
+    providerScope;
+    providerLang;
+    cdr;
+    subscription = null;
+    lastValue = '';
+    lastKey;
+    path;
+    langResolver = new LangResolver();
+    scopeResolver;
+    constructor(service, providerScope, providerLang, cdr) {
+        this.service = service;
+        this.providerScope = providerScope;
+        this.providerLang = providerLang;
+        this.cdr = cdr;
+        this.scopeResolver = new ScopeResolver(this.service);
+    }
+    // null is for handling strict mode + async pipe types https://github.com/jsverse/transloco/issues/311
+    // null is for handling strict mode + optional chaining types https://github.com/jsverse/transloco/issues/488
+    transform(key, params, inlineLang) {
+        if (!key) {
+            return key;
+        }
+        const keyName = params ? `${key}${JSON.stringify(params)}` : key;
+        if (keyName === this.lastKey) {
+            return this.lastValue;
+        }
+        this.lastKey = keyName;
+        this.subscription?.unsubscribe();
+        const listenToLangChange = shouldListenToLangChanges(this.service, this.providerLang || inlineLang);
+        this.subscription = this.service.langChanges$
+            .pipe(switchMap((activeLang) => {
+            const lang = this.langResolver.resolve({
+                inline: inlineLang,
+                provider: this.providerLang,
+                active: activeLang,
+            });
+            return Array.isArray(this.providerScope)
+                ? forkJoin(this.providerScope.map((providerScope) => this.resolveScope(lang, providerScope)))
+                : this.resolveScope(lang, this.providerScope);
+        }), listenOrNotOperator(listenToLangChange))
+            .subscribe(() => this.updateValue(key, params));
+        return this.lastValue;
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+        // Caretaker note: it's important to clean up references to subscriptions since they save the `next`
+        // callback within its `destination` property, preventing classes from being GC'd.
+        this.subscription = null;
+    }
+    updateValue(key, params) {
+        const lang = this.langResolver.resolveLangBasedOnScope(this.path);
+        this.lastValue = this.service.translate(key, params, lang);
+        this.cdr.markForCheck();
+    }
+    resolveScope(lang, providerScope) {
+        const resolvedScope = this.scopeResolver.resolve({
+            inline: undefined,
+            provider: providerScope,
+        });
+        this.path = this.langResolver.resolveLangPath(lang, resolvedScope);
+        const inlineLoader = resolveInlineLoader(providerScope, resolvedScope);
+        return this.service._loadDependencies(this.path, inlineLoader);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoPipe, deps: [{ token: i1.TranslocoService }, { token: TRANSLOCO_SCOPE, optional: true }, { token: TRANSLOCO_LANG, optional: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.0.9", ngImport: i0, type: TranslocoPipe, isStandalone: true, name: "transloco", pure: false });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.9", ngImport: i0, type: TranslocoPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'transloco',
+                    pure: false,
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslocoService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TRANSLOCO_SCOPE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TRANSLOCO_LANG]
+                }] }, { type: i0.ChangeDetectorRef }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transloco.pipe.js","sourceRoot":"","sources":["../../../../../libs/transloco/src/lib/transloco.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Inject,\n  OnDestroy,\n  Optional,\n  Pipe,\n  PipeTransform,\n} from '@angular/core';\nimport { switchMap, forkJoin, Observable, Subscription } from 'rxjs';\n\nimport { TranslocoService } from './transloco.service';\nimport { HashMap, OrArray, Translation, TranslocoScope } from './types';\nimport { TRANSLOCO_SCOPE } from './transloco-scope';\nimport { TRANSLOCO_LANG } from './transloco-lang';\nimport {\n  listenOrNotOperator,\n  resolveInlineLoader,\n  shouldListenToLangChanges,\n} from './shared';\nimport { LangResolver } from './lang-resolver';\nimport { ScopeResolver } from './scope-resolver';\n\n@Pipe({\n  name: 'transloco',\n  pure: false,\n  standalone: true,\n})\nexport class TranslocoPipe implements PipeTransform, OnDestroy {\n  private subscription: Subscription | null = null;\n  private lastValue = '';\n  private lastKey: string | undefined;\n  private path: string | undefined;\n  private langResolver = new LangResolver();\n  private scopeResolver!: ScopeResolver;\n\n  constructor(\n    private service: TranslocoService,\n    @Optional()\n    @Inject(TRANSLOCO_SCOPE)\n    private providerScope: OrArray<TranslocoScope> | undefined,\n    @Optional()\n    @Inject(TRANSLOCO_LANG)\n    private providerLang: string | undefined,\n    private cdr: ChangeDetectorRef\n  ) {\n    this.scopeResolver = new ScopeResolver(this.service);\n  }\n\n  // null is for handling strict mode + async pipe types https://github.com/jsverse/transloco/issues/311\n  // null is for handling strict mode + optional chaining types https://github.com/jsverse/transloco/issues/488\n  transform(\n    key?: string | null,\n    params?: HashMap,\n    inlineLang?: string\n  ): string {\n    if (!key) {\n      return key as any;\n    }\n\n    const keyName = params ? `${key}${JSON.stringify(params)}` : key;\n\n    if (keyName === this.lastKey) {\n      return this.lastValue;\n    }\n\n    this.lastKey = keyName;\n    this.subscription?.unsubscribe();\n\n    const listenToLangChange = shouldListenToLangChanges(\n      this.service,\n      this.providerLang || inlineLang\n    );\n\n    this.subscription = this.service.langChanges$\n      .pipe(\n        switchMap((activeLang) => {\n          const lang = this.langResolver.resolve({\n            inline: inlineLang,\n            provider: this.providerLang,\n            active: activeLang,\n          });\n\n          return Array.isArray(this.providerScope)\n            ? forkJoin(\n                this.providerScope.map((providerScope) =>\n                  this.resolveScope(lang, providerScope)\n                )\n              )\n            : this.resolveScope(lang, this.providerScope);\n        }),\n        listenOrNotOperator(listenToLangChange)\n      )\n      .subscribe(() => this.updateValue(key, params));\n\n    return this.lastValue;\n  }\n\n  ngOnDestroy() {\n    this.subscription?.unsubscribe();\n    // Caretaker note: it's important to clean up references to subscriptions since they save the `next`\n    // callback within its `destination` property, preventing classes from being GC'd.\n    this.subscription = null;\n  }\n\n  private updateValue(key: string, params?: HashMap | undefined) {\n    const lang = this.langResolver.resolveLangBasedOnScope(this.path!);\n    this.lastValue = this.service.translate(key, params, lang);\n    this.cdr.markForCheck();\n  }\n\n  private resolveScope(\n    lang: string,\n    providerScope: TranslocoScope | null\n  ): Observable<Translation | Translation[]> {\n    const resolvedScope = this.scopeResolver.resolve({\n      inline: undefined,\n      provider: providerScope,\n    });\n    this.path = this.langResolver.resolveLangPath(lang, resolvedScope);\n    const inlineLoader = resolveInlineLoader(providerScope, resolvedScope);\n\n    return this.service._loadDependencies(this.path, inlineLoader);\n  }\n}\n"]}

package/esm2022/lib/transloco.providers.mjs

@@ -0,0 +1,92 @@
+import { makeEnvironmentProviders, } from '@angular/core';
+import { TRANSLOCO_LOADER } from './transloco.loader';
+import { TRANSLOCO_CONFIG, translocoConfig, } from './transloco.config';
+import { TRANSLOCO_SCOPE } from './transloco-scope';
+import { DefaultTranspiler, TRANSLOCO_TRANSPILER, } from './transloco.transpiler';
+import { DefaultHandler, TRANSLOCO_MISSING_HANDLER, } from './transloco-missing-handler';
+import { DefaultInterceptor, TRANSLOCO_INTERCEPTOR, } from './transloco.interceptor';
+import { DefaultFallbackStrategy, TRANSLOCO_FALLBACK_STRATEGY, } from './transloco-fallback-strategy';
+import { TRANSLOCO_LOADING_TEMPLATE } from './transloco-loading-template';
+import { TRANSLOCO_LANG } from './transloco-lang';
+export function provideTransloco(options) {
+    const providers = [
+        provideTranslocoTranspiler(DefaultTranspiler),
+        provideTranslocoMissingHandler(DefaultHandler),
+        provideTranslocoInterceptor(DefaultInterceptor),
+        provideTranslocoFallbackStrategy(DefaultFallbackStrategy),
+    ];
+    if (options.config) {
+        providers.push(provideTranslocoConfig(options.config));
+    }
+    if (options.loader) {
+        providers.push(provideTranslocoLoader(options.loader));
+    }
+    return providers;
+}
+export function provideTranslocoConfig(config) {
+    return makeEnvironmentProviders([
+        {
+            provide: TRANSLOCO_CONFIG,
+            useValue: translocoConfig(config),
+        },
+    ]);
+}
+export function provideTranslocoLoader(loader) {
+    return makeEnvironmentProviders([
+        { provide: TRANSLOCO_LOADER, useClass: loader },
+    ]);
+}
+export function provideTranslocoScope(scope) {
+    return {
+        provide: TRANSLOCO_SCOPE,
+        useValue: scope,
+        multi: true,
+    };
+}
+export function provideTranslocoLoadingTpl(content) {
+    return {
+        provide: TRANSLOCO_LOADING_TEMPLATE,
+        useValue: content,
+    };
+}
+export function provideTranslocoTranspiler(transpiler) {
+    return makeEnvironmentProviders([
+        {
+            provide: TRANSLOCO_TRANSPILER,
+            useClass: transpiler,
+            deps: [TRANSLOCO_CONFIG],
+        },
+    ]);
+}
+export function provideTranslocoFallbackStrategy(strategy) {
+    return makeEnvironmentProviders([
+        {
+            provide: TRANSLOCO_FALLBACK_STRATEGY,
+            useClass: strategy,
+            deps: [TRANSLOCO_CONFIG],
+        },
+    ]);
+}
+export function provideTranslocoMissingHandler(handler) {
+    return makeEnvironmentProviders([
+        {
+            provide: TRANSLOCO_MISSING_HANDLER,
+            useClass: handler,
+        },
+    ]);
+}
+export function provideTranslocoInterceptor(interceptor) {
+    return makeEnvironmentProviders([
+        {
+            provide: TRANSLOCO_INTERCEPTOR,
+            useClass: interceptor,
+        },
+    ]);
+}
+export function provideTranslocoLang(lang) {
+    return {
+        provide: TRANSLOCO_LANG,
+        useValue: lang,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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