@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/translate/tokens.mjs

@@ -0,0 +1,13 @@
+/**
+ * @packageDocumentation
+ * @module translate
+ */
+import { InjectionToken } from '@angular/core';
+export const TOKEN_LOCALE = new InjectionToken('initialize and runtime locale');
+export const TOKEN_DEFAULT_LOCALE = new InjectionToken('fallback locale if translation for current locale found');
+export const TOKEN_LOCALES = new InjectionToken('available locale list');
+export const TOKEN_TRANSLATIONS = new InjectionToken('multiple custom translations list, frozen, the later the higher privilege');
+export const TOKEN_REMOTE_TRANSLATIONS = new InjectionToken('custom loaded remote translations with highest privilege as `TOKEN_REMOTE_URL`');
+export const TOKEN_LOOSE = new InjectionToken('whether to use loose mode which represents treat `locale-*` as `locale`');
+export const TOKEN_REMOTE_URL = new InjectionToken('extra remote i18n translations url with highest privilege');
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/translate/translate.directive.mjs

@@ -0,0 +1,164 @@
+import { Directive, Host, Input, IterableDiffers, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { TEMPLATE_OPTIONS } from '../core/public-api';
+import { TranslateService } from './translate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./translate.service";
+const placeholder = (val) => ({
+    type: 'placeholder',
+    val: val.trim(),
+});
+const text = (val) => ({ type: 'text', val });
+export class TranslateView {
+    constructor(templateRef, match = '') {
+        this.templateRef = templateRef;
+        this.match = match;
+    }
+    isText() {
+        return !this.match;
+    }
+}
+export class TranslateDirective {
+    constructor(viewContainer, translate, differs) {
+        this.viewContainer = viewContainer;
+        this.translate = translate;
+        this.differs = differs;
+        this.dirty = false;
+        this.views = {};
+        this.differ = null;
+        this.viewIndexes = {};
+        this.inlineTracker = (index, item) => item.type === 'text'
+            ? `${item.val}_${index}`
+            : `${item.val}_${index}_${this.views[item.val] ? 'has_view' : 'no_view'}`;
+    }
+    set aclTranslate(key) {
+        this.translateKey = key;
+        this.dirty = true;
+    }
+    ngDoCheck() {
+        if (this.dirty || this.locale !== this.translate.locale) {
+            this.locale = this.translate.locale;
+            this.inlines = this.separateContent(this.translate.getRaw(this.translateKey));
+            if (!this.differ) {
+                try {
+                    this.differ = this.differs.find([]).create(this.inlineTracker);
+                }
+                catch {
+                    throw new Error(`Cannot find differ for translate directive inlines`);
+                }
+            }
+            this.update(this.inlines);
+        }
+    }
+    separateContent(content) {
+        if (content.length === 0) {
+            return [];
+        }
+        const matches = content.matchAll(TEMPLATE_OPTIONS.interpolate);
+        const result = [];
+        let prevIndex = 0;
+        for (const match of matches) {
+            if (match.index > prevIndex) {
+                result.push(text(content.slice(prevIndex, match.index)));
+            }
+            result.push(placeholder(match[1]));
+            prevIndex = match.index + match[0].length;
+        }
+        if (prevIndex < content.length) {
+            result.push(text(content.slice(prevIndex, content.length)));
+        }
+        return result;
+    }
+    update(inlines) {
+        if (!this.textView) {
+            throw new Error('translate directive need aclTranslateText to render text');
+        }
+        if (!this.differ) {
+            return;
+        }
+        const changes = this.differ.diff(inlines);
+        if (!changes) {
+            return;
+        }
+        this.applyChanges(changes);
+        this.dirty = false;
+    }
+    applyChanges(changes) {
+        changes.forEachOperation((change, adjustedPreviousIndex, currentIndex) => {
+            if (change.previousIndex === null) {
+                const item = change.item;
+                const index = currentIndex === null ? undefined : currentIndex;
+                if (item.type === 'text') {
+                    this.viewContainer.createEmbeddedView(this.textView.templateRef, { $implicit: item.val }, index);
+                }
+                else {
+                    const view = this.views[item.val];
+                    if (view) {
+                        this.viewContainer.createEmbeddedView(view.templateRef, null, index);
+                    }
+                    else {
+                        this.viewContainer.createEmbeddedView(this.textView.templateRef, { $implicit: item.val }, index);
+                    }
+                    this.viewIndexes[item.val] = this.viewIndexes[item.val] || [index];
+                }
+            }
+            else if (currentIndex === null) {
+                this.viewContainer.remove(adjustedPreviousIndex === null ? undefined : adjustedPreviousIndex);
+            }
+            else if (adjustedPreviousIndex !== null) {
+                const view = this.viewContainer.get(adjustedPreviousIndex);
+                this.viewContainer.move(view, currentIndex);
+            }
+        });
+    }
+    addView(view) {
+        if (view.isText()) {
+            this.textView = view;
+        }
+        else {
+            this.views[view.match] = view;
+            this.update(this.inlines);
+        }
+    }
+    static { this.ɵfac = function TranslateDirective_Factory(t) { return new (t || TranslateDirective)(i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject(i1.TranslateService), i0.ɵɵdirectiveInject(i0.IterableDiffers)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: TranslateDirective, selectors: [["", "aclTranslate", ""]], inputs: { aclTranslate: "aclTranslate" } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslateDirective, [{
+        type: Directive,
+        args: [{ selector: '[aclTranslate]' }]
+    }], function () { return [{ type: i0.ViewContainerRef }, { type: i1.TranslateService }, { type: i0.IterableDiffers }]; }, { aclTranslate: [{
+            type: Input
+        }] }); })();
+export class TranslateMatchDirective {
+    constructor(templateRef, aclTranslate) {
+        this.templateRef = templateRef;
+        this.aclTranslate = aclTranslate;
+    }
+    set aclTranslateMatch(val) {
+        this.aclTranslate.addView(new TranslateView(this.templateRef, val));
+    }
+    static { this.ɵfac = function TranslateMatchDirective_Factory(t) { return new (t || TranslateMatchDirective)(i0.ɵɵdirectiveInject(i0.TemplateRef), i0.ɵɵdirectiveInject(TranslateDirective, 1)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: TranslateMatchDirective, selectors: [["", "aclTranslateMatch", ""]], inputs: { aclTranslateMatch: "aclTranslateMatch" } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslateMatchDirective, [{
+        type: Directive,
+        args: [{ selector: '[aclTranslateMatch]' }]
+    }], function () { return [{ type: i0.TemplateRef }, { type: TranslateDirective, decorators: [{
+                type: Host
+            }] }]; }, { aclTranslateMatch: [{
+            type: Input
+        }] }); })();
+export class TranslateTextDirective {
+    constructor(templateRef, aclTranslate) {
+        this.aclTranslate = aclTranslate;
+        this.aclTranslate.addView(new TranslateView(templateRef));
+    }
+    static { this.ɵfac = function TranslateTextDirective_Factory(t) { return new (t || TranslateTextDirective)(i0.ɵɵdirectiveInject(i0.TemplateRef), i0.ɵɵdirectiveInject(TranslateDirective, 1)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: TranslateTextDirective, selectors: [["", "aclTranslateText", ""]] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslateTextDirective, [{
+        type: Directive,
+        args: [{ selector: '[aclTranslateText]' }]
+    }], function () { return [{ type: i0.TemplateRef }, { type: TranslateDirective, decorators: [{
+                type: Host
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.directive.js","sourceRoot":"","sources":["../../../../../libs/common/src/translate/translate.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  DoCheck,\n  Host,\n  Input,\n  IterableChanges,\n  IterableDiffer,\n  IterableDiffers,\n  TemplateRef,\n  ViewContainerRef,\n} from '@angular/core';\nimport { Dictionary } from 'ts-essentials';\n\nimport { TEMPLATE_OPTIONS } from '../core/public-api';\n\nimport { TranslateService } from './translate.service';\n\ninterface Inline {\n  type: 'placeholder' | 'text';\n  val: string;\n}\n\nconst placeholder = (val: string): Inline => ({\n  type: 'placeholder',\n  val: val.trim(),\n});\nconst text = (val: string): Inline => ({ type: 'text', val });\n\nexport class TranslateView {\n  constructor(\n    public readonly templateRef: TemplateRef<any>,\n    public readonly match = '',\n  ) {}\n\n  isText() {\n    return !this.match;\n  }\n}\n\n@Directive({ selector: '[aclTranslate]' })\nexport class TranslateDirective implements DoCheck {\n  constructor(\n    private readonly viewContainer: ViewContainerRef,\n    private readonly translate: TranslateService,\n    private readonly differs: IterableDiffers,\n  ) {}\n\n  @Input() set aclTranslate(key: string) {\n    this.translateKey = key;\n    this.dirty = true;\n  }\n\n  translateKey: string | Dictionary<string>;\n\n  private locale: string;\n\n  private dirty = false;\n\n  private textView: TranslateView;\n\n  private views: Dictionary<TranslateView> = {};\n\n  private differ: IterableDiffer<Inline> | null = null;\n\n  private viewIndexes: Dictionary<number[]> = {};\n\n  private inlines: Inline[];\n\n  inlineTracker = (index: number, item: Inline) =>\n    item.type === 'text'\n      ? `${item.val}_${index}`\n      : `${item.val}_${index}_${this.views[item.val] ? 'has_view' : 'no_view'}`;\n\n  ngDoCheck(): void {\n    if (this.dirty || this.locale !== this.translate.locale) {\n      this.locale = this.translate.locale;\n      this.inlines = this.separateContent(\n        this.translate.getRaw(this.translateKey),\n      );\n\n      if (!this.differ) {\n        try {\n          this.differ = this.differs.find([]).create(this.inlineTracker);\n        } catch {\n          throw new Error(`Cannot find differ for translate directive inlines`);\n        }\n      }\n\n      this.update(this.inlines);\n    }\n  }\n\n  separateContent(content: string) {\n    if (content.length === 0) {\n      return [];\n    }\n\n    const matches = content.matchAll(TEMPLATE_OPTIONS.interpolate);\n\n    const result: Inline[] = [];\n    let prevIndex = 0;\n\n    for (const match of matches) {\n      if (match.index > prevIndex) {\n        result.push(text(content.slice(prevIndex, match.index)));\n      }\n\n      result.push(placeholder(match[1]));\n\n      prevIndex = match.index + match[0].length;\n    }\n\n    if (prevIndex < content.length) {\n      result.push(text(content.slice(prevIndex, content.length)));\n    }\n\n    return result;\n  }\n\n  private update(inlines: Inline[]) {\n    if (!this.textView) {\n      throw new Error(\n        'translate directive need aclTranslateText to render text',\n      );\n    }\n\n    if (!this.differ) {\n      return;\n    }\n\n    const changes = this.differ.diff(inlines);\n\n    if (!changes) {\n      return;\n    }\n\n    this.applyChanges(changes);\n\n    this.dirty = false;\n  }\n\n  private applyChanges(changes: IterableChanges<Inline>) {\n    changes.forEachOperation((change, adjustedPreviousIndex, currentIndex) => {\n      if (change.previousIndex === null) {\n        const item = change.item;\n        const index = currentIndex === null ? undefined : currentIndex;\n        if (item.type === 'text') {\n          this.viewContainer.createEmbeddedView(\n            this.textView.templateRef,\n            { $implicit: item.val },\n            index,\n          );\n        } else {\n          const view = this.views[item.val];\n          if (view) {\n            this.viewContainer.createEmbeddedView(\n              view.templateRef,\n              null,\n              index,\n            );\n          } else {\n            this.viewContainer.createEmbeddedView(\n              this.textView.templateRef,\n              { $implicit: item.val },\n              index,\n            );\n          }\n\n          this.viewIndexes[item.val] = this.viewIndexes[item.val] || [index];\n        }\n      } else if (currentIndex === null) {\n        this.viewContainer.remove(\n          adjustedPreviousIndex === null ? undefined : adjustedPreviousIndex,\n        );\n      } else if (adjustedPreviousIndex !== null) {\n        const view = this.viewContainer.get(adjustedPreviousIndex)!;\n        this.viewContainer.move(view, currentIndex);\n      }\n    });\n  }\n\n  addView(view: TranslateView) {\n    if (view.isText()) {\n      this.textView = view;\n    } else {\n      this.views[view.match] = view;\n      this.update(this.inlines);\n    }\n  }\n}\n\n@Directive({ selector: '[aclTranslateMatch]' })\nexport class TranslateMatchDirective {\n  constructor(\n    private readonly templateRef: TemplateRef<any>,\n    @Host() private readonly aclTranslate: TranslateDirective,\n  ) {}\n\n  @Input() set aclTranslateMatch(val: string) {\n    this.aclTranslate.addView(new TranslateView(this.templateRef, val));\n  }\n}\n\n@Directive({ selector: '[aclTranslateText]' })\nexport class TranslateTextDirective {\n  constructor(\n    templateRef: TemplateRef<any>,\n    @Host() private readonly aclTranslate: TranslateDirective,\n  ) {\n    this.aclTranslate.addView(new TranslateView(templateRef));\n  }\n}\n"]}

package/esm2022/translate/translate.module.mjs

@@ -0,0 +1,91 @@
+/**
+ * @packageDocumentation
+ * @module translate
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { Locale } from './constants';
+import en from './en.json';
+import { getBrowserLang, getLang } from './helpers';
+import { PickLocalePipe } from './pick-locale.pipe';
+import { TOKEN_DEFAULT_LOCALE, TOKEN_LOCALE, TOKEN_LOCALES, TOKEN_LOOSE, TOKEN_REMOTE_TRANSLATIONS, TOKEN_REMOTE_URL, TOKEN_TRANSLATIONS, } from './tokens';
+import { TranslateDirective, TranslateMatchDirective, TranslateTextDirective, } from './translate.directive';
+import { TranslatePipe } from './translate.pipe';
+import zh from './zh.json';
+import * as i0 from "@angular/core";
+const EXPORTABLE = [
+    TranslateDirective,
+    TranslateMatchDirective,
+    TranslateTextDirective,
+    TranslatePipe,
+    PickLocalePipe,
+];
+export const DEFAULT_LOCALES = Object.values(Locale);
+export const DEFAULT_LOCALE = getLang();
+export const FALLBACK_LOCALE = getBrowserLang();
+export const CORE_TRANSLATIONS = Object.freeze({ zh, en });
+export class TranslateModule {
+    static forRoot(options = {}) {
+        return {
+            ngModule: TranslateModule,
+            providers: [
+                {
+                    provide: TOKEN_LOCALES,
+                    useValue: options.locales || DEFAULT_LOCALES,
+                },
+                {
+                    provide: TOKEN_LOCALE,
+                    useValue: options.locale || DEFAULT_LOCALE,
+                },
+                {
+                    provide: TOKEN_DEFAULT_LOCALE,
+                    useValue: options.defaultLocale || FALLBACK_LOCALE,
+                },
+                {
+                    provide: TOKEN_TRANSLATIONS,
+                    useValue: CORE_TRANSLATIONS,
+                    multi: true,
+                },
+                {
+                    provide: TOKEN_LOOSE,
+                    useValue: options.loose,
+                },
+                {
+                    provide: TOKEN_REMOTE_TRANSLATIONS,
+                    useValue: options.remoteTranslations,
+                    multi: true,
+                },
+                {
+                    provide: TOKEN_TRANSLATIONS,
+                    useValue: options.translations,
+                    multi: true,
+                },
+                {
+                    provide: TOKEN_REMOTE_URL,
+                    useValue: options.remoteUrl,
+                },
+            ],
+        };
+    }
+    static { this.ɵfac = function TranslateModule_Factory(t) { return new (t || TranslateModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: TranslateModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslateModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule],
+                declarations: EXPORTABLE,
+                exports: EXPORTABLE,
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(TranslateModule, { declarations: [TranslateDirective,
+        TranslateMatchDirective,
+        TranslateTextDirective,
+        TranslatePipe,
+        PickLocalePipe], imports: [CommonModule], exports: [TranslateDirective,
+        TranslateMatchDirective,
+        TranslateTextDirective,
+        TranslatePipe,
+        PickLocalePipe] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/translate/translate.pipe.mjs

@@ -0,0 +1,72 @@
+/**
+ * @packageDocumentation
+ * @module translate
+ */
+import { ChangeDetectorRef, Injector, Pipe, } from '@angular/core';
+import { isEqual } from 'lodash-es';
+import { Subject, merge, filter, takeUntil } from 'rxjs';
+import { TranslateService } from './translate.service';
+import * as i0 from "@angular/core";
+export class TranslatePipe {
+    constructor(injector) {
+        this.injector = injector;
+        this.cdr = this.injector.get(ChangeDetectorRef);
+        this.translate = this.injector.get(TranslateService);
+        this.lastRemoteLoaded = this.translate.remoteLoaded;
+        this.destroy$$ = new Subject();
+        this.translate.remoteLoaded$
+            .pipe(filter(_ => _), takeUntil(this.destroy$$))
+            .subscribe(() => this.cdr.markForCheck());
+    }
+    transform(key, data, ignoreNonExist = false) {
+        const { remoteLoaded, locale$, defaultLocale$ } = this.translate;
+        const isLoading = remoteLoaded === false;
+        if (isEqual(key, this.lastKey) &&
+            isEqual(data, this.lastData) &&
+            (isEqual(remoteLoaded, this.lastRemoteLoaded) || !remoteLoaded)) {
+            return this.value;
+        }
+        this.lastData = data;
+        this.lastRemoteLoaded = remoteLoaded;
+        this.updateValue(key, data, ignoreNonExist, isLoading);
+        this.dispose();
+        this.onChange = merge(locale$, defaultLocale$)
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(() => {
+            if (this.lastKey) {
+                this.lastKey = null;
+                this.updateValue(key, data, ignoreNonExist, isLoading);
+            }
+        });
+        return this.value;
+    }
+    updateValue(key, data, ignoreNonExist = false, isLoading = false) {
+        const value = this.translate.get(key, data, ignoreNonExist || isLoading);
+        // avoid text slashing on remote loading
+        if (!isLoading || key !== value) {
+            this.value = value;
+            this.lastKey = key;
+            this.cdr.markForCheck();
+        }
+    }
+    dispose() {
+        if (this.onChange) {
+            this.onChange.unsubscribe();
+            this.onChange = null;
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function TranslatePipe_Factory(t) { return new (t || TranslatePipe)(i0.ɵɵdirectiveInject(i0.Injector, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "translate", type: TranslatePipe, pure: false }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TranslatePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'translate',
+                pure: false,
+            }]
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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