@yelon/bis 17.2.0 → 17.2.2

package/esm2022/src/yunzai-analysis-addon.guard.mjs

@@ -0,0 +1,99 @@
+import { Inject, inject, Injectable } from '@angular/core';
+import { YA_SERVICE_TOKEN } from '@yelon/auth';
+import { BUSINESS_DEFAULT_CONFIG, mergeBisConfig } from '@yelon/bis/config';
+import { deepCopy, useLocalStorageUser, WINDOW } from '@yelon/util';
+import * as i0 from "@angular/core";
+import * as i1 from "@yelon/util";
+export class YunzaiAnalysisAddonGuardService {
+    constructor(configService, pathToRegexp, win, tokenService) {
+        this.configService = configService;
+        this.pathToRegexp = pathToRegexp;
+        this.win = win;
+        this.tokenService = tokenService;
+        this.bis = BUSINESS_DEFAULT_CONFIG;
+        this.menus = [];
+        this.links = [];
+        this.value = {};
+        this.bis = mergeBisConfig(this.configService);
+        const [, getUser] = useLocalStorageUser();
+        const user = getUser();
+        this.menus = deepCopy(user.menu || []).filter((m) => m.systemCode && m.systemCode === this.bis.systemCode);
+        if (user) {
+            this.value = {
+                systemCode: this.bis.systemCode,
+                userid: user.id,
+                realname: user.realname,
+                usertype: user.userType,
+                usercode: user.userCode,
+                username: user.username,
+                account: user.username,
+                deptid: user.deptId,
+                deptname: user.deptName,
+                token: this.tokenService.get()?.access_token
+            };
+        }
+        if (this.menus && this.menus.length > 0) {
+            this.value['system'] = this.menus[0].text;
+        }
+        this.getAllLinks(this.menus, this.links);
+    }
+    process(url) {
+        let flag = false;
+        this.links.forEach(link => {
+            if (link.link === url.split('?')[0]) {
+                flag = true;
+                this.value['routename'] = link.title;
+                this.value['routeurl'] = link.link;
+                if (this.win['yunzai']) {
+                    this.win['yunzai'].setExtra(this.value);
+                }
+                return;
+            }
+            const regexp = this.pathToRegexp.stringToRegexp(link, null, null);
+            if (regexp.test(url.split('?')[0])) {
+                flag = true;
+                this.value['routename'] = link.title;
+                this.value['routeurl'] = link.link;
+                if (this.win['yunzai']) {
+                    this.win['yunzai'].setExtra(this.value);
+                }
+                return;
+            }
+        });
+        if (!flag) {
+            this.value['routename'] = url;
+            this.value['routeurl'] = url;
+            if (this.win['yunzai']) {
+                this.win['yunzai'].setExtra(this.value);
+            }
+        }
+        return true;
+    }
+    getAllLinks(menu, links) {
+        menu.forEach((sider) => {
+            if (sider.link) {
+                links.push({ title: sider.text ? sider.text : sider.link, link: sider.link });
+            }
+            if (sider.children && sider.children.length > 0) {
+                this.getAllLinks(sider.children, links);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiAnalysisAddonGuardService, deps: [{ token: i1.YunzaiConfigService }, { token: i1.PathToRegexpService }, { token: WINDOW }, { token: YA_SERVICE_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiAnalysisAddonGuardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiAnalysisAddonGuardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.YunzaiConfigService }, { type: i1.PathToRegexpService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [YA_SERVICE_TOKEN]
+                }] }] });
+export const analysisAddonCanActive = (_, state) => inject(YunzaiAnalysisAddonGuardService).process(state.url);
+export const analysisAddonCanActiveChild = (_, state) => inject(YunzaiAnalysisAddonGuardService).process(state.url);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yunzai-analysis-addon.guard.js","sourceRoot":"","sources":["../../../../../packages/bis/src/yunzai-analysis-addon.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, inject, Injectable } from '@angular/core';\nimport { CanActivateChildFn, CanActivateFn } from '@angular/router';\n\nimport { ITokenService, YA_SERVICE_TOKEN } from '@yelon/auth';\nimport { BUSINESS_DEFAULT_CONFIG, mergeBisConfig } from '@yelon/bis/config';\nimport { Menu } from '@yelon/theme';\nimport {\n  deepCopy,\n  PathToRegexpService,\n  useLocalStorageUser,\n  WINDOW,\n  YunzaiBusinessConfig,\n  YunzaiConfigService,\n  YunzaiUser\n} from '@yelon/util';\nimport { NzSafeAny } from 'ng-zorro-antd/core/types';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class YunzaiAnalysisAddonGuardService {\n  private bis: YunzaiBusinessConfig = BUSINESS_DEFAULT_CONFIG;\n  private menus: NzSafeAny[] = [];\n  private links: Array<{ title: string; link: string }> = [];\n  private value: NzSafeAny = {};\n\n  constructor(\n    private configService: YunzaiConfigService,\n    private pathToRegexp: PathToRegexpService,\n    @Inject(WINDOW) private win: NzSafeAny,\n    @Inject(YA_SERVICE_TOKEN) private tokenService: ITokenService\n  ) {\n    this.bis = mergeBisConfig(this.configService);\n    const [, getUser] = useLocalStorageUser();\n    const user: YunzaiUser = getUser()!;\n    this.menus = deepCopy((user.menu as NzSafeAny) || []).filter(\n      (m: Menu) => m.systemCode && m.systemCode === this.bis.systemCode\n    ) as Menu[];\n    if (user) {\n      this.value = {\n        systemCode: this.bis.systemCode,\n        userid: user.id,\n        realname: user.realname,\n        usertype: user.userType,\n        usercode: user.userCode,\n        username: user.username,\n        account: user.username,\n        deptid: user.deptId,\n        deptname: user.deptName,\n        token: this.tokenService.get()?.access_token\n      };\n    }\n    if (this.menus && this.menus.length > 0) {\n      this.value['system'] = (this.menus[0] as Menu).text;\n    }\n    this.getAllLinks(this.menus, this.links);\n  }\n\n  process(url: string): boolean {\n    let flag = false;\n    this.links.forEach(link => {\n      if (link.link === url.split('?')[0]) {\n        flag = true;\n        this.value['routename'] = link.title;\n        this.value['routeurl'] = link.link;\n        if (this.win['yunzai']) {\n          this.win['yunzai'].setExtra(this.value);\n        }\n        return;\n      }\n      const regexp: RegExp = this.pathToRegexp.stringToRegexp(link, null, null);\n      if (regexp.test(url.split('?')[0])) {\n        flag = true;\n        this.value['routename'] = link.title;\n        this.value['routeurl'] = link.link;\n        if (this.win['yunzai']) {\n          this.win['yunzai'].setExtra(this.value);\n        }\n        return;\n      }\n    });\n    if (!flag) {\n      this.value['routename'] = url;\n      this.value['routeurl'] = url;\n      if (this.win['yunzai']) {\n        this.win['yunzai'].setExtra(this.value);\n      }\n    }\n    return true;\n  }\n\n  getAllLinks(menu: Menu[], links: Array<{ title: string; link: string }>): void {\n    menu.forEach((sider: Menu) => {\n      if (sider.link) {\n        links.push({ title: sider.text ? sider.text : sider.link, link: sider.link });\n      }\n      if (sider.children && sider.children.length > 0) {\n        this.getAllLinks(sider.children, links);\n      }\n    });\n  }\n}\n\nexport const analysisAddonCanActive: CanActivateFn = (_, state) =>\n  inject(YunzaiAnalysisAddonGuardService).process(state.url);\nexport const analysisAddonCanActiveChild: CanActivateChildFn = (_, state) =>\n  inject(YunzaiAnalysisAddonGuardService).process(state.url);\n"]}

package/esm2022/src/yunzai-default.interceptor.mjs

@@ -0,0 +1,63 @@
+import { HttpErrorResponse, HttpResponseBase } from '@angular/common/http';
+import { Injector, inject } from '@angular/core';
+import { of, throwError, mergeMap, catchError } from 'rxjs';
+import { mergeBisConfig } from '@yelon/bis/config';
+import { IGNORE_BASE_URL } from '@yelon/theme';
+import { YUNZAI_CONFIG, YunzaiConfigService } from '@yelon/util';
+import { checkStatus, getAdditionalHeaders, goTo, toLogin } from './helper';
+import { tryRefreshToken } from './refresh-token';
+function handleData(injector, ev, req, next) {
+    checkStatus(injector, ev);
+    const config = injector.get(YUNZAI_CONFIG).bis;
+    switch (ev.status) {
+        case 200:
+            return of(ev);
+        case 401:
+            if (config.refreshTokenEnabled && config.refreshTokenType === 're-request') {
+                const unAuthorizationReq = req.clone();
+                unAuthorizationReq.headers.delete('Authorization');
+                return tryRefreshToken(injector, ev, unAuthorizationReq, next);
+            }
+            toLogin(injector);
+            break;
+        case 403:
+        case 404:
+        case 500:
+            goTo(injector, `/exception/${ev.status}?url=${req.urlWithParams}`);
+            break;
+        default:
+            if (ev instanceof HttpErrorResponse) {
+                console.warn('未可知错误，大部分是由于后端不支持跨域CORS或无效配置引起，请参考 https://ng.yunzainfo.com/docs/server 解决跨域问题', ev);
+            }
+            break;
+    }
+    if (ev instanceof HttpErrorResponse) {
+        return throwError(() => ev);
+    }
+    else if (ev._throw) {
+        return throwError(() => ev.body);
+    }
+    else {
+        return of(ev);
+    }
+}
+export const yunzaiDefaultInterceptor = (req, next) => {
+    const config = mergeBisConfig(inject(YunzaiConfigService));
+    const { baseUrl } = config;
+    let url = req.url;
+    if (!req.context.get(IGNORE_BASE_URL) && !url.startsWith('https://') && !url.startsWith('http://')) {
+        url = baseUrl + (baseUrl.endsWith('/') && url.startsWith('/') ? url.substring(1) : url);
+    }
+    if (url.includes('.json') && url.includes('assets')) {
+        url = req.url;
+    }
+    const newReq = req.clone({ url, setHeaders: getAdditionalHeaders(req.headers) });
+    const injector = inject(Injector);
+    return next(newReq).pipe(mergeMap(ev => {
+        if (ev instanceof HttpResponseBase) {
+            return handleData(injector, ev, newReq, next);
+        }
+        return of(ev);
+    }), catchError((err) => handleData(injector, err, newReq, next)));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/yunzai-widgets/public_api.mjs

@@ -0,0 +1,7 @@
+export * from './yunzai-clear-storage.component';
+export * from './yunzai-fullscreen.component';
+export * from './yunzai-notify.component';
+export * from './yunzai-i18n.component';
+export * from './yunzai-user.component';
+export * from './yunzai-widget.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy95dW56YWktd2lkZ2V0cy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi95dW56YWktY2xlYXItc3RvcmFnZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi95dW56YWktZnVsbHNjcmVlbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi95dW56YWktbm90aWZ5LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3l1bnphaS1pMThuLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3l1bnphaS11c2VyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3l1bnphaS13aWRnZXQubW9kdWxlJztcbiJdfQ==

package/esm2022/yunzai-widgets/yunzai-clear-storage.component.mjs

@@ -0,0 +1,47 @@
+import { ChangeDetectionStrategy, Component, HostListener, inject } from '@angular/core';
+import { I18nPipe } from '@yelon/theme';
+import { NzIconModule } from 'ng-zorro-antd/icon';
+import { NzMessageService } from 'ng-zorro-antd/message';
+import { NzModalService } from 'ng-zorro-antd/modal';
+import * as i0 from "@angular/core";
+import * as i1 from "ng-zorro-antd/icon";
+export class YunzaiHeaderClearStorageComponent {
+    constructor() {
+        this.modalSrv = inject(NzModalService);
+        this.messageSrv = inject(NzMessageService);
+    }
+    _click() {
+        this.modalSrv.confirm({
+            nzTitle: 'Make sure clear all local storage?',
+            nzOnOk: () => {
+                localStorage.clear();
+                this.messageSrv.success('Clear Finished!');
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiHeaderClearStorageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: YunzaiHeaderClearStorageComponent, isStandalone: true, selector: "yunzai-header-clear-storage", host: { listeners: { "click": "_click()" }, properties: { "class.flex-1": "true" } }, ngImport: i0, template: `
+    <i nz-icon nzType="tool"></i>
+    {{ 'menu.clear.local.storage' | i18n }}
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: NzIconModule }, { kind: "directive", type: i1.NzIconDirective, selector: "[nz-icon]", inputs: ["nzSpin", "nzRotate", "nzType", "nzTheme", "nzTwotoneColor", "nzIconfont"], exportAs: ["nzIcon"] }, { kind: "pipe", type: I18nPipe, name: "i18n" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiHeaderClearStorageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'yunzai-header-clear-storage',
+                    template: `
+    <i nz-icon nzType="tool"></i>
+    {{ 'menu.clear.local.storage' | i18n }}
+  `,
+                    host: {
+                        '[class.flex-1]': 'true'
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    imports: [NzIconModule, I18nPipe]
+                }]
+        }], propDecorators: { _click: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/yunzai-widgets/yunzai-fullscreen.component.mjs

@@ -0,0 +1,47 @@
+import { ChangeDetectionStrategy, Component, HostListener } from '@angular/core';
+import screenfull from 'screenfull';
+import { I18nPipe } from '@yelon/theme';
+import { NzIconModule } from 'ng-zorro-antd/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "ng-zorro-antd/icon";
+export class YunzaiHeaderFullScreenComponent {
+    constructor() {
+        this.status = false;
+    }
+    _resize() {
+        this.status = screenfull.isFullscreen;
+    }
+    _click() {
+        if (screenfull.isEnabled) {
+            screenfull.toggle();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiHeaderFullScreenComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.1", type: YunzaiHeaderFullScreenComponent, isStandalone: true, selector: "yunzai-header-fullscreen", host: { listeners: { "window:resize": "_resize()", "click": "_click()" }, properties: { "class.flex-1": "true" } }, ngImport: i0, template: `
+    <i nz-icon [nzType]="status ? 'fullscreen-exit' : 'fullscreen'"></i>
+    {{ (status ? 'menu.fullscreen.exit' : 'menu.fullscreen') | i18n }}
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: NzIconModule }, { kind: "directive", type: i1.NzIconDirective, selector: "[nz-icon]", inputs: ["nzSpin", "nzRotate", "nzType", "nzTheme", "nzTwotoneColor", "nzIconfont"], exportAs: ["nzIcon"] }, { kind: "pipe", type: I18nPipe, name: "i18n" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiHeaderFullScreenComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'yunzai-header-fullscreen',
+                    template: `
+    <i nz-icon [nzType]="status ? 'fullscreen-exit' : 'fullscreen'"></i>
+    {{ (status ? 'menu.fullscreen.exit' : 'menu.fullscreen') | i18n }}
+  `,
+                    host: {
+                        '[class.flex-1]': 'true'
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    standalone: true,
+                    imports: [NzIconModule, I18nPipe]
+                }]
+        }], propDecorators: { _resize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }], _click: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/yunzai-widgets/yunzai-i18n.component.mjs

@@ -0,0 +1,139 @@
+import { CommonModule, DOCUMENT } from '@angular/common';
+import { booleanAttribute, ChangeDetectionStrategy, Component, inject, Input } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { I18nPipe, SettingsService, YUNZAI_I18N_TOKEN } from '@yelon/theme';
+import { NzDropDownModule } from 'ng-zorro-antd/dropdown';
+import { NzIconModule } from 'ng-zorro-antd/icon';
+import * as i0 from "@angular/core";
+import * as i1 from "ng-zorro-antd/menu";
+import * as i2 from "ng-zorro-antd/dropdown";
+import * as i3 from "ng-zorro-antd/icon";
+export class YunzaiHeaderI18nComponent {
+    constructor() {
+        this.settings = inject(SettingsService);
+        this.i18n = inject(YUNZAI_I18N_TOKEN);
+        this.doc = inject(DOCUMENT);
+        this.langs = [];
+        this.destroy$ = new Subject();
+        /** Whether to display language text */
+        this.showLangText = true;
+    }
+    get curLangCode() {
+        return this.settings.layout.lang;
+    }
+    ngOnInit() {
+        this.i18n
+            .getLangs()
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(langs => {
+            this.langs = langs;
+        });
+    }
+    change(lang) {
+        const spinEl = this.doc.createElement('div');
+        spinEl.setAttribute('class', `page-loading ant-spin ant-spin-lg ant-spin-spinning`);
+        spinEl.innerHTML = `<span class="ant-spin-dot ant-spin-dot-spin"><i></i><i></i><i></i><i></i></span>`;
+        this.doc.body.appendChild(spinEl);
+        this.i18n.loadLangData(lang).subscribe(res => {
+            this.i18n.use(lang, res);
+            this.settings.setLayout('lang', lang);
+            setTimeout(() => this.doc.location.reload());
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiHeaderI18nComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.2.1", type: YunzaiHeaderI18nComponent, isStandalone: true, selector: "yunzai-header-i18n", inputs: { showLangText: ["showLangText", "showLangText", booleanAttribute] }, host: { properties: { "class.flex-1": "true" } }, ngImport: i0, template: `
+    @if (showLangText) {
+      <div nz-dropdown [nzDropdownMenu]="langMenu" nzPlacement="bottomRight">
+        <i nz-icon nzType="global"></i>
+        {{ 'lang.nav' | i18n }}
+        <i nz-icon nzType="down"></i>
+      </div>
+    } @else {
+      <i nz-dropdown [nzDropdownMenu]="langMenu" nzPlacement="bottomRight" nz-icon nzType="global"></i>
+    }
+    <nz-dropdown-menu data-event-id="_nav_lang" #langMenu="nzDropdownMenu">
+      <ul nz-menu>
+        @for (item of langs; track item) {
+          <li
+            data-event-id="_nav_lang"
+            [attr.data-text]="item.text"
+            nz-menu-item
+            [nzSelected]="item.code === curLangCode"
+            (click)="change(item.code)"
+          >
+            @if (!item.icon) {
+              <span role="img" [attr.aria-label]="item.text" class="pr-xs">{{ item.abbr }}</span>
+            } @else {
+              <img
+                style="margin-right:4px"
+                width="50px"
+                height="30px"
+                [src]="'data:image/png;base64,' + item.icon"
+                [alt]="item.abbr"
+                class="pr-xs"
+              />
+            }
+            {{ item.text }}
+          </li>
+        }
+      </ul>
+    </nz-dropdown-menu>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: NzDropDownModule }, { kind: "directive", type: i1.NzMenuDirective, selector: "[nz-menu]", inputs: ["nzInlineIndent", "nzTheme", "nzMode", "nzInlineCollapsed", "nzSelectable"], outputs: ["nzClick"], exportAs: ["nzMenu"] }, { kind: "component", type: i1.NzMenuItemComponent, selector: "[nz-menu-item]", inputs: ["nzPaddingLeft", "nzDisabled", "nzSelected", "nzDanger", "nzMatchRouterExact", "nzMatchRouter"], exportAs: ["nzMenuItem"] }, { kind: "directive", type: i2.NzDropDownDirective, selector: "[nz-dropdown]", inputs: ["nzDropdownMenu", "nzTrigger", "nzMatchWidthElement", "nzBackdrop", "nzClickHide", "nzDisabled", "nzVisible", "nzOverlayClassName", "nzOverlayStyle", "nzPlacement"], outputs: ["nzVisibleChange"], exportAs: ["nzDropdown"] }, { kind: "component", type: i2.NzDropdownMenuComponent, selector: "nz-dropdown-menu", exportAs: ["nzDropdownMenu"] }, { kind: "ngmodule", type: NzIconModule }, { kind: "directive", type: i3.NzIconDirective, selector: "[nz-icon]", inputs: ["nzSpin", "nzRotate", "nzType", "nzTheme", "nzTwotoneColor", "nzIconfont"], exportAs: ["nzIcon"] }, { kind: "pipe", type: I18nPipe, name: "i18n" }, { kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiHeaderI18nComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: `yunzai-header-i18n`,
+                    template: `
+    @if (showLangText) {
+      <div nz-dropdown [nzDropdownMenu]="langMenu" nzPlacement="bottomRight">
+        <i nz-icon nzType="global"></i>
+        {{ 'lang.nav' | i18n }}
+        <i nz-icon nzType="down"></i>
+      </div>
+    } @else {
+      <i nz-dropdown [nzDropdownMenu]="langMenu" nzPlacement="bottomRight" nz-icon nzType="global"></i>
+    }
+    <nz-dropdown-menu data-event-id="_nav_lang" #langMenu="nzDropdownMenu">
+      <ul nz-menu>
+        @for (item of langs; track item) {
+          <li
+            data-event-id="_nav_lang"
+            [attr.data-text]="item.text"
+            nz-menu-item
+            [nzSelected]="item.code === curLangCode"
+            (click)="change(item.code)"
+          >
+            @if (!item.icon) {
+              <span role="img" [attr.aria-label]="item.text" class="pr-xs">{{ item.abbr }}</span>
+            } @else {
+              <img
+                style="margin-right:4px"
+                width="50px"
+                height="30px"
+                [src]="'data:image/png;base64,' + item.icon"
+                [alt]="item.abbr"
+                class="pr-xs"
+              />
+            }
+            {{ item.text }}
+          </li>
+        }
+      </ul>
+    </nz-dropdown-menu>
+  `,
+                    host: {
+                        '[class.flex-1]': 'true'
+                    },
+                    standalone: true,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NzDropDownModule, NzIconModule, I18nPipe, CommonModule]
+                }]
+        }], propDecorators: { showLangText: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieXVuemFpLWkxOG4uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYmlzL3l1bnphaS13aWRnZXRzL3l1bnphaS1pMThuLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBcUIsTUFBTSxlQUFlLENBQUM7QUFDdkgsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFMUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxlQUFlLEVBQUUsaUJBQWlCLEVBQXlDLE1BQU0sY0FBYyxDQUFDO0FBRW5ILE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzFELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7Ozs7QUFpRGxELE1BQU0sT0FBTyx5QkFBeUI7SUEvQ3RDO1FBZ0RtQixhQUFRLEdBQUcsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQ25DLFNBQUksR0FBRyxNQUFNLENBQXdCLGlCQUFpQixDQUFDLENBQUM7UUFDeEQsUUFBRyxHQUFHLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUN4QyxVQUFLLEdBQXFCLEVBQUUsQ0FBQztRQUNyQixhQUFRLEdBQXVCLElBQUksT0FBTyxFQUFhLENBQUM7UUFDaEUsdUNBQXVDO1FBQ0MsaUJBQVksR0FBRyxJQUFJLENBQUM7S0E2QjdEO0lBM0JDLElBQUksV0FBVztRQUNiLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDO0lBQ25DLENBQUM7SUFDRCxRQUFRO1FBQ04sSUFBSSxDQUFDLElBQUk7YUFDTixRQUFRLEVBQUU7YUFDVixJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQzthQUM5QixTQUFTLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDakIsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUM7UUFDckIsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQsTUFBTSxDQUFDLElBQVk7UUFDakIsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDN0MsTUFBTSxDQUFDLFlBQVksQ0FBQyxPQUFPLEVBQUUscURBQXFELENBQUMsQ0FBQztRQUNwRixNQUFNLENBQUMsU0FBUyxHQUFHLGtGQUFrRixDQUFDO1FBQ3RHLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUVsQyxJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDM0MsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQ3pCLElBQUksQ0FBQyxRQUFRLENBQUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQztZQUN0QyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztRQUMvQyxDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFDRCxXQUFXO1FBQ1QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUMzQixDQUFDOzhHQW5DVSx5QkFBeUI7a0dBQXpCLHlCQUF5QiwrR0FPaEIsZ0JBQWdCLCtFQXBEMUI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FxQ1QsMkRBTVMsZ0JBQWdCLHkyQkFBRSxZQUFZLDZNQUFFLFFBQVEsNENBQUUsWUFBWTs7MkZBRXJELHlCQUF5QjtrQkEvQ3JDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG9CQUFvQjtvQkFDOUIsUUFBUSxFQUFFOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUNUO29CQUNELElBQUksRUFBRTt3QkFDSixnQkFBZ0IsRUFBRSxNQUFNO3FCQUN6QjtvQkFDRCxVQUFVLEVBQUUsSUFBSTtvQkFDaEIsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLE9BQU8sRUFBRSxDQUFDLGdCQUFnQixFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsWUFBWSxDQUFDO2lCQUNsRTs4QkFReUMsWUFBWTtzQkFBbkQsS0FBSzt1QkFBQyxFQUFFLFNBQVMsRUFBRSxnQkFBZ0IsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSwgRE9DVU1FTlQgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgYm9vbGVhbkF0dHJpYnV0ZSwgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgaW5qZWN0LCBJbnB1dCwgT25EZXN0cm95LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFN1YmplY3QsIHRha2VVbnRpbCB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyBJMThuUGlwZSwgU2V0dGluZ3NTZXJ2aWNlLCBZVU5aQUlfSTE4Tl9UT0tFTiwgWXVuemFpSHR0cEkxOE5TZXJ2aWNlLCBZdW56YWlJMThOVHlwZSB9IGZyb20gJ0B5ZWxvbi90aGVtZSc7XG5pbXBvcnQgeyBOelNhZmVBbnkgfSBmcm9tICduZy16b3Jyby1hbnRkL2NvcmUvdHlwZXMnO1xuaW1wb3J0IHsgTnpEcm9wRG93bk1vZHVsZSB9IGZyb20gJ25nLXpvcnJvLWFudGQvZHJvcGRvd24nO1xuaW1wb3J0IHsgTnpJY29uTW9kdWxlIH0gZnJvbSAnbmctem9ycm8tYW50ZC9pY29uJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiBgeXVuemFpLWhlYWRlci1pMThuYCxcbiAgdGVtcGxhdGU6IGBcbiAgICBAaWYgKHNob3dMYW5nVGV4dCkge1xuICAgICAgPGRpdiBuei1kcm9wZG93biBbbnpEcm9wZG93bk1lbnVdPVwibGFuZ01lbnVcIiBuelBsYWNlbWVudD1cImJvdHRvbVJpZ2h0XCI+XG4gICAgICAgIDxpIG56LWljb24gbnpUeXBlPVwiZ2xvYmFsXCI+PC9pPlxuICAgICAgICB7eyAnbGFuZy5uYXYnIHwgaTE4biB9fVxuICAgICAgICA8aSBuei1pY29uIG56VHlwZT1cImRvd25cIj48L2k+XG4gICAgICA8L2Rpdj5cbiAgICB9IEBlbHNlIHtcbiAgICAgIDxpIG56LWRyb3Bkb3duIFtuekRyb3Bkb3duTWVudV09XCJsYW5nTWVudVwiIG56UGxhY2VtZW50PVwiYm90dG9tUmlnaHRcIiBuei1pY29uIG56VHlwZT1cImdsb2JhbFwiPjwvaT5cbiAgICB9XG4gICAgPG56LWRyb3Bkb3duLW1lbnUgZGF0YS1ldmVudC1pZD1cIl9uYXZfbGFuZ1wiICNsYW5nTWVudT1cIm56RHJvcGRvd25NZW51XCI+XG4gICAgICA8dWwgbnotbWVudT5cbiAgICAgICAgQGZvciAoaXRlbSBvZiBsYW5nczsgdHJhY2sgaXRlbSkge1xuICAgICAgICAgIDxsaVxuICAgICAgICAgICAgZGF0YS1ldmVudC1pZD1cIl9uYXZfbGFuZ1wiXG4gICAgICAgICAgICBbYXR0ci5kYXRhLXRleHRdPVwiaXRlbS50ZXh0XCJcbiAgICAgICAgICAgIG56LW1lbnUtaXRlbVxuICAgICAgICAgICAgW256U2VsZWN0ZWRdPVwiaXRlbS5jb2RlID09PSBjdXJMYW5nQ29kZVwiXG4gICAgICAgICAgICAoY2xpY2spPVwiY2hhbmdlKGl0ZW0uY29kZSlcIlxuICAgICAgICAgID5cbiAgICAgICAgICAgIEBpZiAoIWl0ZW0uaWNvbikge1xuICAgICAgICAgICAgICA8c3BhbiByb2xlPVwiaW1nXCIgW2F0dHIuYXJpYS1sYWJlbF09XCJpdGVtLnRleHRcIiBjbGFzcz1cInByLXhzXCI+e3sgaXRlbS5hYmJyIH19PC9zcGFuPlxuICAgICAgICAgICAgfSBAZWxzZSB7XG4gICAgICAgICAgICAgIDxpbWdcbiAgICAgICAgICAgICAgICBzdHlsZT1cIm1hcmdpbi1yaWdodDo0cHhcIlxuICAgICAgICAgICAgICAgIHdpZHRoPVwiNTBweFwiXG4gICAgICAgICAgICAgICAgaGVpZ2h0PVwiMzBweFwiXG4gICAgICAgICAgICAgICAgW3NyY109XCInZGF0YTppbWFnZS9wbmc7YmFzZTY0LCcgKyBpdGVtLmljb25cIlxuICAgICAgICAgICAgICAgIFthbHRdPVwiaXRlbS5hYmJyXCJcbiAgICAgICAgICAgICAgICBjbGFzcz1cInByLXhzXCJcbiAgICAgICAgICAgICAgLz5cbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIHt7IGl0ZW0udGV4dCB9fVxuICAgICAgICAgIDwvbGk+XG4gICAgICAgIH1cbiAgICAgIDwvdWw+XG4gICAgPC9uei1kcm9wZG93bi1tZW51PlxuICBgLFxuICBob3N0OiB7XG4gICAgJ1tjbGFzcy5mbGV4LTFdJzogJ3RydWUnXG4gIH0sXG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBpbXBvcnRzOiBbTnpEcm9wRG93bk1vZHVsZSwgTnpJY29uTW9kdWxlLCBJMThuUGlwZSwgQ29tbW9uTW9kdWxlXVxufSlcbmV4cG9ydCBjbGFzcyBZdW56YWlIZWFkZXJJMThuQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0LCBPbkRlc3Ryb3kge1xuICBwcml2YXRlIHJlYWRvbmx5IHNldHRpbmdzID0gaW5qZWN0KFNldHRpbmdzU2VydmljZSk7XG4gIHByaXZhdGUgcmVhZG9ubHkgaTE4biA9IGluamVjdDxZdW56YWlIdHRwSTE4TlNlcnZpY2U+KFlVTlpBSV9JMThOX1RPS0VOKTtcbiAgcHJpdmF0ZSByZWFkb25seSBkb2MgPSBpbmplY3QoRE9DVU1FTlQpO1xuICBsYW5nczogWXVuemFpSTE4TlR5cGVbXSA9IFtdO1xuICBwcml2YXRlIGRlc3Ryb3kkOiBTdWJqZWN0PE56U2FmZUFueT4gPSBuZXcgU3ViamVjdDxOelNhZmVBbnk+KCk7XG4gIC8qKiBXaGV0aGVyIHRvIGRpc3BsYXkgbGFuZ3VhZ2UgdGV4dCAqL1xuICBASW5wdXQoeyB0cmFuc2Zvcm06IGJvb2xlYW5BdHRyaWJ1dGUgfSkgc2hvd0xhbmdUZXh0ID0gdHJ1ZTtcblxuICBnZXQgY3VyTGFuZ0NvZGUoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy5zZXR0aW5ncy5sYXlvdXQubGFuZztcbiAgfVxuICBuZ09uSW5pdCgpOiB2b2lkIHtcbiAgICB0aGlzLmkxOG5cbiAgICAgIC5nZXRMYW5ncygpXG4gICAgICAucGlwZSh0YWtlVW50aWwodGhpcy5kZXN0cm95JCkpXG4gICAgICAuc3Vic2NyaWJlKGxhbmdzID0+IHtcbiAgICAgICAgdGhpcy5sYW5ncyA9IGxhbmdzO1xuICAgICAgfSk7XG4gIH1cblxuICBjaGFuZ2UobGFuZzogc3RyaW5nKTogdm9pZCB7XG4gICAgY29uc3Qgc3BpbkVsID0gdGhpcy5kb2MuY3JlYXRlRWxlbWVudCgnZGl2Jyk7XG4gICAgc3BpbkVsLnNldEF0dHJpYnV0ZSgnY2xhc3MnLCBgcGFnZS1sb2FkaW5nIGFudC1zcGluIGFudC1zcGluLWxnIGFudC1zcGluLXNwaW5uaW5nYCk7XG4gICAgc3BpbkVsLmlubmVySFRNTCA9IGA8c3BhbiBjbGFzcz1cImFudC1zcGluLWRvdCBhbnQtc3Bpbi1kb3Qtc3BpblwiPjxpPjwvaT48aT48L2k+PGk+PC9pPjxpPjwvaT48L3NwYW4+YDtcbiAgICB0aGlzLmRvYy5ib2R5LmFwcGVuZENoaWxkKHNwaW5FbCk7XG5cbiAgICB0aGlzLmkxOG4ubG9hZExhbmdEYXRhKGxhbmcpLnN1YnNjcmliZShyZXMgPT4ge1xuICAgICAgdGhpcy5pMThuLnVzZShsYW5nLCByZXMpO1xuICAgICAgdGhpcy5zZXR0aW5ncy5zZXRMYXlvdXQoJ2xhbmcnLCBsYW5nKTtcbiAgICAgIHNldFRpbWVvdXQoKCkgPT4gdGhpcy5kb2MubG9jYXRpb24ucmVsb2FkKCkpO1xuICAgIH0pO1xuICB9XG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIHRoaXMuZGVzdHJveSQuY29tcGxldGUoKTtcbiAgfVxufVxuIl19