@yelon/bis 14.2.0 → 15.0.0-beta.0

package/esm2020/src/yunzai-i18n.service.mjs

@@ -0,0 +1,94 @@
+import { registerLocaleData } from '@angular/common';
+import ngEn from '@angular/common/locales/en';
+import ngZh from '@angular/common/locales/zh';
+import ngZhTw from '@angular/common/locales/zh-Hant';
+import { Injectable } from '@angular/core';
+import { enUS as dfEn, zhCN as dfZhCn, zhTW as dfZhTw } from 'date-fns/locale';
+import { en_US as yelonEnUS, zh_CN as yelonZhCn, zh_TW as yelonZhTw, YunzaiI18nBaseService } from '@yelon/theme';
+import { en_US as zorroEnUS, zh_CN as zorroZhCN, zh_TW as zorroZhTW } from 'ng-zorro-antd/i18n';
+import * as i0 from "@angular/core";
+import * as i1 from "@yelon/theme";
+import * as i2 from "ng-zorro-antd/i18n";
+import * as i3 from "@angular/cdk/platform";
+import * as i4 from "@yelon/util/config";
+const DEFAULT = 'zh-CN';
+const LANGS = {
+    'zh-CN': {
+        text: '简体中文',
+        ng: ngZh,
+        zorro: zorroZhCN,
+        date: dfZhCn,
+        yelon: yelonZhCn,
+        abbr: '🇨🇳'
+    },
+    'zh-TW': {
+        text: '繁体中文',
+        ng: ngZhTw,
+        zorro: zorroZhTW,
+        date: dfZhTw,
+        yelon: yelonZhTw,
+        abbr: '🇭🇰'
+    },
+    'en-US': {
+        text: 'English',
+        ng: ngEn,
+        zorro: zorroEnUS,
+        date: dfEn,
+        yelon: yelonEnUS,
+        abbr: '🇬🇧'
+    }
+};
+class YunzaiI18NService extends YunzaiI18nBaseService {
+    constructor(http, settings, nzI18nService, yelonLocaleService, platform, cogSrv) {
+        super(cogSrv);
+        this.http = http;
+        this.settings = settings;
+        this.nzI18nService = nzI18nService;
+        this.yelonLocaleService = yelonLocaleService;
+        this.platform = platform;
+        this._defaultLang = DEFAULT;
+        this._langs = Object.keys(LANGS).map(code => {
+            const item = LANGS[code];
+            return { code, text: item.text, abbr: item.abbr };
+        });
+        const defaultLang = this.getDefaultLang();
+        this._defaultLang = this._langs.findIndex(w => w.code === defaultLang) === -1 ? DEFAULT : defaultLang;
+    }
+    getDefaultLang() {
+        if (!this.platform.isBrowser) {
+            return DEFAULT;
+        }
+        if (this.settings.layout.lang) {
+            return this.settings.layout.lang;
+        }
+        let res = (navigator.languages ? navigator.languages[0] : null) || navigator.language;
+        const arr = res.split('-');
+        return arr.length <= 1 ? res : `${arr[0]}-${arr[1].toUpperCase()}`;
+    }
+    loadLangData(lang) {
+        return this.http.get(`assets/tmp/i18n/${lang}.json`);
+    }
+    use(lang, data) {
+        if (this._currentLang === lang)
+            return;
+        this._data = this.flatData(data, []);
+        const item = LANGS[lang];
+        registerLocaleData(item.ng);
+        this.nzI18nService.setLocale(item.zorro);
+        this.nzI18nService.setDateLocale(item.date);
+        this.yelonLocaleService.setLocale(item.yelon);
+        this._currentLang = lang;
+        this._change$.next(lang);
+    }
+    getLangs() {
+        return this._langs;
+    }
+}
+YunzaiI18NService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiI18NService, deps: [{ token: i1._HttpClient }, { token: i1.SettingsService }, { token: i2.NzI18nService }, { token: i1.YelonLocaleService }, { token: i3.Platform }, { token: i4.YunzaiConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+YunzaiI18NService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiI18NService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiI18NService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1._HttpClient }, { type: i1.SettingsService }, { type: i2.NzI18nService }, { type: i1.YelonLocaleService }, { type: i3.Platform }, { type: i4.YunzaiConfigService }]; } });
+export { YunzaiI18NService as YzI18nService, YunzaiI18NService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yunzai-i18n.service.js","sourceRoot":"","sources":["../../../../../packages/bis/src/yunzai-i18n.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Platform } from '@angular/cdk/platform';\nimport { registerLocaleData } from '@angular/common';\nimport ngEn from '@angular/common/locales/en';\nimport ngZh from '@angular/common/locales/zh';\nimport ngZhTw from '@angular/common/locales/zh-Hant';\nimport { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { enUS as dfEn, zhCN as dfZhCn, zhTW as dfZhTw } from 'date-fns/locale';\n\nimport {\n  YelonLocaleService,\n  en_US as yelonEnUS,\n  SettingsService,\n  zh_CN as yelonZhCn,\n  zh_TW as yelonZhTw,\n  _HttpClient,\n  YunzaiI18nBaseService\n} from '@yelon/theme';\nimport { YunzaiConfigService } from '@yelon/util/config';\nimport { NzSafeAny } from 'ng-zorro-antd/core/types';\nimport { en_US as zorroEnUS, NzI18nService, zh_CN as zorroZhCN, zh_TW as zorroZhTW } from 'ng-zorro-antd/i18n';\n\ninterface LangConfigData {\n  abbr: string;\n  text: string;\n  ng: NzSafeAny;\n  zorro: NzSafeAny;\n  date: NzSafeAny;\n  yelon: NzSafeAny;\n}\n\nconst DEFAULT = 'zh-CN';\nconst LANGS: { [key: string]: LangConfigData } = {\n  'zh-CN': {\n    text: '简体中文',\n    ng: ngZh,\n    zorro: zorroZhCN,\n    date: dfZhCn,\n    yelon: yelonZhCn,\n    abbr: '🇨🇳'\n  },\n  'zh-TW': {\n    text: '繁体中文',\n    ng: ngZhTw,\n    zorro: zorroZhTW,\n    date: dfZhTw,\n    yelon: yelonZhTw,\n    abbr: '🇭🇰'\n  },\n  'en-US': {\n    text: 'English',\n    ng: ngEn,\n    zorro: zorroEnUS,\n    date: dfEn,\n    yelon: yelonEnUS,\n    abbr: '🇬🇧'\n  }\n};\n\n@Injectable({ providedIn: 'root' })\nclass YunzaiI18NService extends YunzaiI18nBaseService {\n  protected override _defaultLang = DEFAULT;\n  private _langs = Object.keys(LANGS).map(code => {\n    const item = LANGS[code];\n    return { code, text: item.text, abbr: item.abbr };\n  });\n\n  constructor(\n    private http: _HttpClient,\n    private settings: SettingsService,\n    private nzI18nService: NzI18nService,\n    private yelonLocaleService: YelonLocaleService,\n    private platform: Platform,\n    cogSrv: YunzaiConfigService\n  ) {\n    super(cogSrv);\n\n    const defaultLang = this.getDefaultLang();\n    this._defaultLang = this._langs.findIndex(w => w.code === defaultLang) === -1 ? DEFAULT : defaultLang;\n  }\n\n  private getDefaultLang(): string {\n    if (!this.platform.isBrowser) {\n      return DEFAULT;\n    }\n    if (this.settings.layout.lang) {\n      return this.settings.layout.lang;\n    }\n    let res = (navigator.languages ? navigator.languages[0] : null) || navigator.language;\n    const arr = res.split('-');\n    return arr.length <= 1 ? res : `${arr[0]}-${arr[1].toUpperCase()}`;\n  }\n\n  loadLangData(lang: string): Observable<NzSafeAny> {\n    return this.http.get(`assets/tmp/i18n/${lang}.json`);\n  }\n\n  use(lang: string, data: Record<string, unknown>): void {\n    if (this._currentLang === lang) return;\n\n    this._data = this.flatData(data, []);\n\n    const item = LANGS[lang];\n    registerLocaleData(item.ng);\n    this.nzI18nService.setLocale(item.zorro);\n    this.nzI18nService.setDateLocale(item.date);\n    this.yelonLocaleService.setLocale(item.yelon);\n    this._currentLang = lang;\n\n    this._change$.next(lang);\n  }\n\n  getLangs(): Array<{ code: string; text: string; abbr: string }> {\n    return this._langs;\n  }\n}\n\nexport { YunzaiI18NService as YzI18nService, YunzaiI18NService };\n"]}

package/esm2020/src/yunzai-layout.module.mjs

@@ -0,0 +1,76 @@
+import { CommonModule } from '@angular/common';
+import { HttpClientModule } from '@angular/common/http';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { YunzaiSharedYelonModule, YunzaiSharedZorroModule } from '@yelon/bcs';
+import { YUNZAI_THEME_BTN_KEYS } from '@yelon/theme/theme-btn';
+import { YzLayoutBasicComponent } from './layout-basic/layout-basic.component';
+import { LayoutNavApplicationComponent, LayoutNavGroupComponent, LayoutNavTileComponent } from './layout-nav';
+import { YunzaiClearStorageComponent, YunzaiFullScreenComponent, YunzaiI18NComponent, YunzaiNotifyComponent, YunzaiThemBtnComponent, YunzaiUserComponent } from './widgets';
+import * as i0 from "@angular/core";
+const WIDGETS = [
+    YunzaiClearStorageComponent,
+    YunzaiFullScreenComponent,
+    YunzaiI18NComponent,
+    YunzaiNotifyComponent,
+    YunzaiThemBtnComponent,
+    YunzaiUserComponent
+];
+const LAYOUT_NAV_COMPONENTS = [LayoutNavApplicationComponent, LayoutNavGroupComponent, LayoutNavTileComponent];
+const COMPONENTS = [YzLayoutBasicComponent];
+export class YunzaiLayoutModule {
+}
+YunzaiLayoutModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiLayoutModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+YunzaiLayoutModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.4", ngImport: i0, type: YunzaiLayoutModule, declarations: [YzLayoutBasicComponent, YunzaiClearStorageComponent,
+        YunzaiFullScreenComponent,
+        YunzaiI18NComponent,
+        YunzaiNotifyComponent,
+        YunzaiThemBtnComponent,
+        YunzaiUserComponent, LayoutNavApplicationComponent, LayoutNavGroupComponent, LayoutNavTileComponent], imports: [HttpClientModule,
+        CommonModule,
+        FormsModule,
+        RouterModule,
+        ReactiveFormsModule,
+        YunzaiSharedYelonModule,
+        YunzaiSharedZorroModule], exports: [YzLayoutBasicComponent, YunzaiClearStorageComponent,
+        YunzaiFullScreenComponent,
+        YunzaiI18NComponent,
+        YunzaiNotifyComponent,
+        YunzaiThemBtnComponent,
+        YunzaiUserComponent, LayoutNavApplicationComponent, LayoutNavGroupComponent, LayoutNavTileComponent] });
+YunzaiLayoutModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiLayoutModule, providers: [
+        {
+            provide: YUNZAI_THEME_BTN_KEYS,
+            useValue: 'site-theme'
+        }
+    ], imports: [HttpClientModule,
+        CommonModule,
+        FormsModule,
+        RouterModule,
+        ReactiveFormsModule,
+        YunzaiSharedYelonModule,
+        YunzaiSharedZorroModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiLayoutModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        HttpClientModule,
+                        CommonModule,
+                        FormsModule,
+                        RouterModule,
+                        ReactiveFormsModule,
+                        YunzaiSharedYelonModule,
+                        YunzaiSharedZorroModule
+                    ],
+                    providers: [
+                        {
+                            provide: YUNZAI_THEME_BTN_KEYS,
+                            useValue: 'site-theme'
+                        }
+                    ],
+                    declarations: [...COMPONENTS, ...WIDGETS, ...LAYOUT_NAV_COMPONENTS],
+                    exports: [...COMPONENTS, ...WIDGETS, ...LAYOUT_NAV_COMPONENTS]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/yunzai-startup.service.mjs

@@ -0,0 +1,157 @@
+import { APP_INITIALIZER, Inject, Injectable } from '@angular/core';
+import { mergeMap, of } from 'rxjs';
+import { YUNZAI_I18N_TOKEN } from '@yelon/theme';
+import { WINDOW, deepCopy, log } from '@yelon/util';
+import { BUSINESS_DEFAULT_CONFIG, mergeBisConfig } from './bis.config';
+import { ICONS } from './icon/style-icons';
+import * as i0 from "@angular/core";
+import * as i1 from "ng-zorro-antd/icon";
+import * as i2 from "@yelon/theme";
+import * as i3 from "@yelon/acl";
+import * as i4 from "./yunzai-auth.service";
+import * as i5 from "@yelon/cache";
+import * as i6 from "@yelon/util";
+import * as i7 from "./yunzai-i18n.service";
+class YunzaiStartupService {
+    constructor(iconSrv, menuService, i18n, win, settingService, aclService, titleService, yzAuthService, cacheService, configService) {
+        this.menuService = menuService;
+        this.i18n = i18n;
+        this.win = win;
+        this.settingService = settingService;
+        this.aclService = aclService;
+        this.titleService = titleService;
+        this.yzAuthService = yzAuthService;
+        this.cacheService = cacheService;
+        this.configService = configService;
+        this.config = BUSINESS_DEFAULT_CONFIG;
+        this.config = mergeBisConfig(this.configService);
+        iconSrv.addIcon(...ICONS);
+    }
+    load() {
+        log('startup.service: ', 'load');
+        const defaultLang = this.i18n.defaultLang;
+        return this.i18n.loadLangData(defaultLang).pipe(mergeMap(langData => {
+            log('startup.service: ', 'set i18n, defaultLang->', defaultLang, ' langData->', langData);
+            this.i18n.use(defaultLang, langData);
+            return of(null);
+        }), mergeMap(() => {
+            return this.yzAuthService.login();
+        }), mergeMap(v => {
+            // preloader finish
+            this.systemInit();
+            log('startup.service: preloader finish');
+            if (this.win && this.win.appBootstrap) {
+                this.win.appBootstrap();
+            }
+            return of(v);
+        }));
+    }
+    systemInit() {
+        log('startup.service: system init');
+        // user
+        const yunzaiUser = this.cacheService.get('_yz_user', { mode: 'none' });
+        // menu
+        const yunzaiMenus = deepCopy(yunzaiUser.menu).filter(m => m.systemCode && m.systemCode === this.config.systemCode);
+        mapYzSideToYelonMenu(yunzaiMenus);
+        const currentMenu = yunzaiMenus.pop();
+        if (currentMenu) {
+            // logo app
+            this.settingService.setApp({ name: currentMenu.text, description: currentMenu.intro });
+            this.settingService.setUser({
+                name: yunzaiUser.realname,
+                avatar: `${this.config.baseUrl}/filecenter/file/${yunzaiUser.avatarId}` || '',
+                email: yunzaiUser.email
+            });
+            // title
+            this.titleService.default = currentMenu && currentMenu.text ? currentMenu.text : 'default application name';
+            this.titleService.setTitle(currentMenu && currentMenu.text ? currentMenu.text : 'no title');
+            // acl
+            const abilities = [];
+            generateAbility([currentMenu], abilities, '');
+            this.aclService.attachRole(yunzaiUser?.roles
+                .map((role) => {
+                return role.roleValue;
+            })
+                .filter((a) => !!a) || []);
+            this.aclService.attachAbility(abilities);
+            // aside menu
+            this.menuService.add([currentMenu]);
+            // cache current
+            this.cacheService.set('_yz_current', {
+                name: currentMenu.text,
+                intro: currentMenu.intro,
+                icon: currentMenu.appIconUrl
+            });
+            // cache displayIndex
+            const attributes = currentMenu.attribute;
+            if (attributes) {
+                const attr = JSON.parse(attributes);
+                if (attr && attr.defaultRoute) {
+                    this.cacheService.set('_yz_defaultRoute', attr.defaultRoute);
+                }
+                else {
+                    this.cacheService.set('_yz_defaultRoute', '/displayIndex');
+                }
+            }
+            else {
+                this.cacheService.set('_yz_defaultRoute', '/displayIndex');
+            }
+        }
+    }
+}
+YunzaiStartupService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiStartupService, deps: [{ token: i1.NzIconService }, { token: i2.MenuService }, { token: YUNZAI_I18N_TOKEN }, { token: WINDOW }, { token: i2.SettingsService }, { token: i3.ACLService }, { token: i2.TitleService }, { token: i4.YunzaiAuthService }, { token: i5.CacheService }, { token: i6.YunzaiConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+YunzaiStartupService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiStartupService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.4", ngImport: i0, type: YunzaiStartupService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.NzIconService }, { type: i2.MenuService }, { type: i7.YunzaiI18NService, decorators: [{
+                    type: Inject,
+                    args: [YUNZAI_I18N_TOKEN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: i2.SettingsService }, { type: i3.ACLService }, { type: i2.TitleService }, { type: i4.YunzaiAuthService }, { type: i5.CacheService }, { type: i6.YunzaiConfigService }]; } });
+function mapYzSideToYelonMenu(menus) {
+    menus.forEach(menu => {
+        menu.badgeDot = menu.badge_dot || null;
+        menu.badgeStatus = menu.badge_status || null;
+        menu.shortcutRoot = menu.shortcut_root || null;
+        menu.reuse = true;
+        if (menu.children) {
+            mapYzSideToYelonMenu(menu.children);
+        }
+    });
+}
+function generateAbility(menus, abilities, prefix) {
+    menus.forEach(menu => {
+        if (menu.link) {
+            prefix += menu.link;
+        }
+        else {
+            prefix += '';
+        }
+        if (menu.menuAuths) {
+            menu.menuAuths.forEach((a) => {
+                abilities.push(`${prefix}:${a}`);
+                abilities.push(a);
+            });
+        }
+        if (menu.children) {
+            generateAbility(menu.children, abilities, prefix);
+        }
+    });
+}
+function YunzaiStartupServiceFactory(startupService) {
+    return () => startupService.load();
+}
+//@ts-ignore
+const YUNZAI_APPINIT_PROVIDES = [
+    YunzaiStartupService,
+    {
+        provide: APP_INITIALIZER,
+        useFactory: YunzaiStartupServiceFactory,
+        deps: [YunzaiStartupService],
+        multi: true
+    }
+];
+export { YunzaiStartupService as YzStartupService, YunzaiStartupService, YunzaiStartupServiceFactory as YzStartupServiceFactory, YunzaiStartupServiceFactory, YUNZAI_APPINIT_PROVIDES as YZ_APPINIT_PROVIDES, YUNZAI_APPINIT_PROVIDES, mapYzSideToYelonMenu, generateAbility };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yunzai-startup.service.js","sourceRoot":"","sources":["../../../../../packages/bis/src/yunzai-startup.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { APP_INITIALIZER, Inject, Injectable } from '@angular/core';\nimport { Observable, mergeMap, of } from 'rxjs';\n\nimport { ACLService } from '@yelon/acl';\nimport { CacheService, YunzaiMenu, YunzaiMenuAttribute, YunzaiUser } from '@yelon/cache';\nimport { Menu, MenuService, SettingsService, TitleService, YUNZAI_I18N_TOKEN } from '@yelon/theme';\nimport { WINDOW, YunzaiBusinessConfig, YunzaiConfigService, deepCopy, log } from '@yelon/util';\nimport { NzSafeAny } from 'ng-zorro-antd/core/types';\nimport { NzIconService } from 'ng-zorro-antd/icon';\n\nimport { BUSINESS_DEFAULT_CONFIG, mergeBisConfig } from './bis.config';\nimport { ICONS } from './icon/style-icons';\nimport { YunzaiAuthService } from './yunzai-auth.service';\nimport { YunzaiI18NService } from './yunzai-i18n.service';\n\n@Injectable()\nclass YunzaiStartupService {\n  private config: YunzaiBusinessConfig = BUSINESS_DEFAULT_CONFIG;\n\n  constructor(\n    iconSrv: NzIconService,\n    private menuService: MenuService,\n    @Inject(YUNZAI_I18N_TOKEN) private i18n: YunzaiI18NService,\n    @Inject(WINDOW) private win: NzSafeAny,\n    private settingService: SettingsService,\n    private aclService: ACLService,\n    private titleService: TitleService,\n    private yzAuthService: YunzaiAuthService,\n    private cacheService: CacheService,\n    private configService: YunzaiConfigService\n  ) {\n    this.config = mergeBisConfig(this.configService);\n    iconSrv.addIcon(...ICONS);\n  }\n\n  load(): Observable<void> {\n    log('startup.service: ', 'load');\n    const defaultLang = this.i18n.defaultLang;\n    return this.i18n.loadLangData(defaultLang).pipe(\n      mergeMap(langData => {\n        log('startup.service: ', 'set i18n, defaultLang->', defaultLang, ' langData->', langData);\n        this.i18n.use(defaultLang, langData);\n        return of(null);\n      }),\n      mergeMap(() => {\n        return this.yzAuthService.login();\n      }),\n      mergeMap(v => {\n        // preloader finish\n        this.systemInit();\n        log('startup.service: preloader finish');\n        if (this.win && this.win.appBootstrap) {\n          this.win.appBootstrap();\n        }\n        return of(v);\n      })\n    );\n  }\n\n  systemInit(): void {\n    log('startup.service: system init');\n    // user\n    const yunzaiUser: YunzaiUser = this.cacheService.get('_yz_user', { mode: 'none' });\n    // menu\n    const yunzaiMenus: YunzaiMenu[] = deepCopy(yunzaiUser.menu).filter(\n      m => m.systemCode && m.systemCode === this.config.systemCode\n    );\n    mapYzSideToYelonMenu(yunzaiMenus);\n    const currentMenu = yunzaiMenus.pop();\n    if (currentMenu) {\n      // logo app\n      this.settingService.setApp({ name: currentMenu.text, description: currentMenu.intro });\n      this.settingService.setUser({\n        name: yunzaiUser.realname,\n        avatar: `${this.config.baseUrl}/filecenter/file/${yunzaiUser.avatarId}` || '',\n        email: yunzaiUser.email\n      });\n      // title\n      this.titleService.default = currentMenu && currentMenu.text ? currentMenu.text : 'default application name';\n      this.titleService.setTitle(currentMenu && currentMenu.text ? currentMenu.text : 'no title');\n      // acl\n      const abilities: string[] = [];\n      generateAbility([currentMenu], abilities, '');\n      this.aclService.attachRole(\n        yunzaiUser?.roles\n          .map((role: NzSafeAny) => {\n            return role.roleValue;\n          })\n          .filter((a: NzSafeAny) => !!a) || []\n      );\n      this.aclService.attachAbility(abilities);\n      // aside menu\n      this.menuService.add([currentMenu as Menu]);\n      // cache current\n      this.cacheService.set('_yz_current', {\n        name: currentMenu.text,\n        intro: currentMenu.intro,\n        icon: currentMenu.appIconUrl\n      });\n      // cache displayIndex\n      const attributes = currentMenu.attribute;\n      if (attributes) {\n        const attr: YunzaiMenuAttribute = JSON.parse(attributes);\n        if (attr && attr.defaultRoute) {\n          this.cacheService.set('_yz_defaultRoute', attr.defaultRoute);\n        } else {\n          this.cacheService.set('_yz_defaultRoute', '/displayIndex');\n        }\n      } else {\n        this.cacheService.set('_yz_defaultRoute', '/displayIndex');\n      }\n    }\n  }\n}\n\nfunction mapYzSideToYelonMenu(menus: YunzaiMenu[]): void {\n  menus.forEach(menu => {\n    menu.badgeDot = menu.badge_dot || null;\n    menu.badgeStatus = menu.badge_status || null;\n    menu.shortcutRoot = menu.shortcut_root || null;\n    menu.reuse = true;\n    if (menu.children) {\n      mapYzSideToYelonMenu(menu.children);\n    }\n  });\n}\n\nfunction generateAbility(menus: YunzaiMenu[], abilities: string[], prefix: string): void {\n  menus.forEach(menu => {\n    if (menu.link) {\n      prefix += menu.link;\n    } else {\n      prefix += '';\n    }\n    if (menu.menuAuths) {\n      menu.menuAuths.forEach((a: string) => {\n        abilities.push(`${prefix}:${a}`);\n        abilities.push(a);\n      });\n    }\n\n    if (menu.children) {\n      generateAbility(menu.children, abilities, prefix);\n    }\n  });\n}\n\nfunction YunzaiStartupServiceFactory(startupService: YunzaiStartupService): () => Observable<void> {\n  return () => startupService.load();\n}\n\n//@ts-ignore\nconst YUNZAI_APPINIT_PROVIDES = [\n  YunzaiStartupService,\n  {\n    provide: APP_INITIALIZER,\n    useFactory: YunzaiStartupServiceFactory,\n    deps: [YunzaiStartupService],\n    multi: true\n  }\n];\n\nexport {\n  YunzaiStartupService as YzStartupService,\n  YunzaiStartupService,\n  YunzaiStartupServiceFactory as YzStartupServiceFactory,\n  YunzaiStartupServiceFactory,\n  YUNZAI_APPINIT_PROVIDES as YZ_APPINIT_PROVIDES,\n  YUNZAI_APPINIT_PROVIDES,\n  mapYzSideToYelonMenu,\n  generateAbility\n};\n"]}