@yelon/bis 17.2.0 → 17.2.2

package/esm2022/layout/layout.module.mjs

@@ -0,0 +1,54 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { I18nPipe } from '@yelon/theme';
+import { NzDropDownModule } from 'ng-zorro-antd/dropdown';
+import { NzFormModule } from 'ng-zorro-antd/form';
+import { NzGridModule } from 'ng-zorro-antd/grid';
+import { NzIconModule } from 'ng-zorro-antd/icon';
+import { NzInputModule } from 'ng-zorro-antd/input';
+import { NzTabsModule } from 'ng-zorro-antd/tabs';
+import { YunzaiLayoutBasicComponent } from './layout-basic.component';
+import { YunzaiLayoutNavGroupComponent } from './layout-nav-group.component';
+import { YunzaiLayoutNavTileComponent } from './layout-nav-tile.component';
+import * as i0 from "@angular/core";
+const COMPONENTS = [YunzaiLayoutNavTileComponent, YunzaiLayoutNavGroupComponent, YunzaiLayoutBasicComponent];
+export class YunzaiLayoutModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiLayoutModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.2.1", ngImport: i0, type: YunzaiLayoutModule, imports: [I18nPipe,
+            FormsModule,
+            NzFormModule,
+            NzInputModule,
+            CommonModule,
+            NzGridModule,
+            NzIconModule,
+            NzDropDownModule,
+            NzTabsModule, YunzaiLayoutNavTileComponent, YunzaiLayoutNavGroupComponent, YunzaiLayoutBasicComponent], exports: [YunzaiLayoutNavTileComponent, YunzaiLayoutNavGroupComponent, YunzaiLayoutBasicComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiLayoutModule, imports: [FormsModule,
+            NzFormModule,
+            NzInputModule,
+            CommonModule,
+            NzGridModule,
+            NzIconModule,
+            NzDropDownModule,
+            NzTabsModule, YunzaiLayoutNavGroupComponent, YunzaiLayoutBasicComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiLayoutModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        I18nPipe,
+                        FormsModule,
+                        NzFormModule,
+                        NzInputModule,
+                        CommonModule,
+                        NzGridModule,
+                        NzIconModule,
+                        NzDropDownModule,
+                        NzTabsModule,
+                        ...COMPONENTS
+                    ],
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF5b3V0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy9sYXlvdXQvbGF5b3V0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFN0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMxRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxELE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3RFLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzdFLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLDZCQUE2QixDQUFDOztBQUUzRSxNQUFNLFVBQVUsR0FBRyxDQUFDLDRCQUE0QixFQUFFLDZCQUE2QixFQUFFLDBCQUEwQixDQUFDLENBQUM7QUFpQjdHLE1BQU0sT0FBTyxrQkFBa0I7OEdBQWxCLGtCQUFrQjsrR0FBbEIsa0JBQWtCLFlBYjNCLFFBQVE7WUFDUixXQUFXO1lBQ1gsWUFBWTtZQUNaLGFBQWE7WUFDYixZQUFZO1lBQ1osWUFBWTtZQUNaLFlBQVk7WUFDWixnQkFBZ0I7WUFDaEIsWUFBWSxFQVpJLDRCQUE0QixFQUFFLDZCQUE2QixFQUFFLDBCQUEwQixhQUF2Riw0QkFBNEIsRUFBRSw2QkFBNkIsRUFBRSwwQkFBMEI7K0dBaUI5RixrQkFBa0IsWUFaM0IsV0FBVztZQUNYLFlBQVk7WUFDWixhQUFhO1lBQ2IsWUFBWTtZQUNaLFlBQVk7WUFDWixZQUFZO1lBQ1osZ0JBQWdCO1lBQ2hCLFlBQVksRUFaa0MsNkJBQTZCLEVBQUUsMEJBQTBCOzsyRkFpQjlGLGtCQUFrQjtrQkFmOUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUU7d0JBQ1AsUUFBUTt3QkFDUixXQUFXO3dCQUNYLFlBQVk7d0JBQ1osYUFBYTt3QkFDYixZQUFZO3dCQUNaLFlBQVk7d0JBQ1osWUFBWTt3QkFDWixnQkFBZ0I7d0JBQ2hCLFlBQVk7d0JBQ1osR0FBRyxVQUFVO3FCQUNkO29CQUNELE9BQU8sRUFBRSxVQUFVO2lCQUNwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbmltcG9ydCB7IEkxOG5QaXBlIH0gZnJvbSAnQHllbG9uL3RoZW1lJztcbmltcG9ydCB7IE56RHJvcERvd25Nb2R1bGUgfSBmcm9tICduZy16b3Jyby1hbnRkL2Ryb3Bkb3duJztcbmltcG9ydCB7IE56Rm9ybU1vZHVsZSB9IGZyb20gJ25nLXpvcnJvLWFudGQvZm9ybSc7XG5pbXBvcnQgeyBOekdyaWRNb2R1bGUgfSBmcm9tICduZy16b3Jyby1hbnRkL2dyaWQnO1xuaW1wb3J0IHsgTnpJY29uTW9kdWxlIH0gZnJvbSAnbmctem9ycm8tYW50ZC9pY29uJztcbmltcG9ydCB7IE56SW5wdXRNb2R1bGUgfSBmcm9tICduZy16b3Jyby1hbnRkL2lucHV0JztcbmltcG9ydCB7IE56VGFic01vZHVsZSB9IGZyb20gJ25nLXpvcnJvLWFudGQvdGFicyc7XG5cbmltcG9ydCB7IFl1bnphaUxheW91dEJhc2ljQ29tcG9uZW50IH0gZnJvbSAnLi9sYXlvdXQtYmFzaWMuY29tcG9uZW50JztcbmltcG9ydCB7IFl1bnphaUxheW91dE5hdkdyb3VwQ29tcG9uZW50IH0gZnJvbSAnLi9sYXlvdXQtbmF2LWdyb3VwLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBZdW56YWlMYXlvdXROYXZUaWxlQ29tcG9uZW50IH0gZnJvbSAnLi9sYXlvdXQtbmF2LXRpbGUuY29tcG9uZW50JztcblxuY29uc3QgQ09NUE9ORU5UUyA9IFtZdW56YWlMYXlvdXROYXZUaWxlQ29tcG9uZW50LCBZdW56YWlMYXlvdXROYXZHcm91cENvbXBvbmVudCwgWXVuemFpTGF5b3V0QmFzaWNDb21wb25lbnRdO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgSTE4blBpcGUsXG4gICAgRm9ybXNNb2R1bGUsXG4gICAgTnpGb3JtTW9kdWxlLFxuICAgIE56SW5wdXRNb2R1bGUsXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIE56R3JpZE1vZHVsZSxcbiAgICBOekljb25Nb2R1bGUsXG4gICAgTnpEcm9wRG93bk1vZHVsZSxcbiAgICBOelRhYnNNb2R1bGUsXG4gICAgLi4uQ09NUE9ORU5UU1xuICBdLFxuICBleHBvcnRzOiBDT01QT05FTlRTXG59KVxuZXhwb3J0IGNsYXNzIFl1bnphaUxheW91dE1vZHVsZSB7fVxuIl19

package/esm2022/layout/public_api.mjs

@@ -1,14 +1,6 @@
-export * from './layout-basic';
-export * from './layout-nav';
-export * from './widgets';
-export * from './bis.config';
-export * from './yunzai-act.guard';
-export * from './yunzai-auth.service';
-export * from './yunzai-default.interceptor';
-export * from './yunzai-i18n.service';
-export * from './yunzai-lang';
-export * from './yunzai-layout.module';
-export * from './yunzai-startup.service';
-export * from './html-names';
-export * from './yunzai-analysis-addon.guard';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy9sYXlvdXQvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xheW91dC1iYXNpYyc7XG5leHBvcnQgKiBmcm9tICcuL2xheW91dC1uYXYnO1xuZXhwb3J0ICogZnJvbSAnLi93aWRnZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vYmlzLmNvbmZpZyc7XG5leHBvcnQgKiBmcm9tICcuL3l1bnphaS1hY3QuZ3VhcmQnO1xuZXhwb3J0ICogZnJvbSAnLi95dW56YWktYXV0aC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4veXVuemFpLWRlZmF1bHQuaW50ZXJjZXB0b3InO1xuZXhwb3J0ICogZnJvbSAnLi95dW56YWktaTE4bi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4veXVuemFpLWxhbmcnO1xuZXhwb3J0ICogZnJvbSAnLi95dW56YWktbGF5b3V0Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3l1bnphaS1zdGFydHVwLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9odG1sLW5hbWVzJztcbmV4cG9ydCAqIGZyb20gJy4veXVuemFpLWFuYWx5c2lzLWFkZG9uLmd1YXJkJztcbiJdfQ==
+export * from './layout.module';
+export * from './layout-basic.component';
+export * from './layout-nav-application.component';
+export * from './layout-nav-group.component';
+export * from './layout-nav-tile.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy9sYXlvdXQvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xheW91dC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXlvdXQtYmFzaWMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGF5b3V0LW5hdi1hcHBsaWNhdGlvbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXlvdXQtbmF2LWdyb3VwLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xheW91dC1uYXYtdGlsZS5jb21wb25lbnQnO1xuIl19

package/esm2022/public_api.mjs

@@ -1,2 +1,9 @@
-export default void 0;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsS0FBSyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCB2b2lkIDA7XG4iXX0=
+export * from './src/provide';
+export * from './src/bis.module';
+export * from './src/helper';
+export * from './src/yunzai-default.interceptor';
+export * from './src/refresh-token';
+export * from './src/startup.service';
+export * from './src/yunzai-analysis-addon.guard';
+export * from './src/yunzai-act.guard';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zcmMvcHJvdmlkZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9iaXMubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL2hlbHBlcic7XG5leHBvcnQgKiBmcm9tICcuL3NyYy95dW56YWktZGVmYXVsdC5pbnRlcmNlcHRvcic7XG5leHBvcnQgKiBmcm9tICcuL3NyYy9yZWZyZXNoLXRva2VuJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3N0YXJ0dXAuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NyYy95dW56YWktYW5hbHlzaXMtYWRkb24uZ3VhcmQnO1xuZXhwb3J0ICogZnJvbSAnLi9zcmMveXVuemFpLWFjdC5ndWFyZCc7XG4iXX0=

package/esm2022/src/bis.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { YunzaiLayoutModule } from '@yelon/bis/layout';
+import { YunzaiWidgetsModule } from '@yelon/bis/yunzai-widgets';
+import * as i0 from "@angular/core";
+export class BisModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: BisModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.2.1", ngImport: i0, type: BisModule, imports: [YunzaiLayoutModule, YunzaiWidgetsModule], exports: [YunzaiLayoutModule, YunzaiWidgetsModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: BisModule, imports: [YunzaiLayoutModule, YunzaiWidgetsModule, YunzaiLayoutModule, YunzaiWidgetsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: BisModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [YunzaiLayoutModule, YunzaiWidgetsModule],
+                    exports: [YunzaiLayoutModule, YunzaiWidgetsModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmlzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy9zcmMvYmlzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQUtoRSxNQUFNLE9BQU8sU0FBUzs4R0FBVCxTQUFTOytHQUFULFNBQVMsWUFIVixrQkFBa0IsRUFBRSxtQkFBbUIsYUFDdkMsa0JBQWtCLEVBQUUsbUJBQW1COytHQUV0QyxTQUFTLFlBSFYsa0JBQWtCLEVBQUUsbUJBQW1CLEVBQ3ZDLGtCQUFrQixFQUFFLG1CQUFtQjs7MkZBRXRDLFNBQVM7a0JBSnJCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsa0JBQWtCLEVBQUUsbUJBQW1CLENBQUM7b0JBQ2xELE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLG1CQUFtQixDQUFDO2lCQUNuRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFl1bnphaUxheW91dE1vZHVsZSB9IGZyb20gJ0B5ZWxvbi9iaXMvbGF5b3V0JztcbmltcG9ydCB7IFl1bnphaVdpZGdldHNNb2R1bGUgfSBmcm9tICdAeWVsb24vYmlzL3l1bnphaS13aWRnZXRzJztcbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtZdW56YWlMYXlvdXRNb2R1bGUsIFl1bnphaVdpZGdldHNNb2R1bGVdLFxuICBleHBvcnRzOiBbWXVuemFpTGF5b3V0TW9kdWxlLCBZdW56YWlXaWRnZXRzTW9kdWxlXVxufSlcbmV4cG9ydCBjbGFzcyBCaXNNb2R1bGUge31cbiJdfQ==

package/esm2022/src/helper.mjs

@@ -0,0 +1,45 @@
+import { inject } from '@angular/core';
+import { Router } from 'express';
+import { YA_SERVICE_TOKEN } from '@yelon/auth';
+import { YUNZAI_I18N_TOKEN } from '@yelon/theme';
+import { NzNotificationService } from 'ng-zorro-antd/notification';
+export const CODEMESSAGE = {
+    200: '服务器成功返回请求的数据。',
+    201: '新建或修改数据成功。',
+    202: '一个请求已经进入后台排队（异步任务）。',
+    204: '删除数据成功。',
+    400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',
+    401: '用户没有权限（令牌、用户名、密码错误）。',
+    403: '用户得到授权，但是访问是被禁止的。',
+    404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',
+    406: '请求的格式不可得。',
+    410: '请求的资源被永久删除，且不会再得到的。',
+    422: '当创建一个对象时，发生一个验证错误。',
+    500: '服务器发生错误，请检查服务器。',
+    502: '网关错误。',
+    503: '服务不可用，服务器暂时过载或维护。',
+    504: '网关超时。'
+};
+export function getAdditionalHeaders(headers) {
+    const res = {};
+    const lang = inject(YUNZAI_I18N_TOKEN).currentLang;
+    if (!headers?.has('Accept-Language') && lang) {
+        res['Accept-Language'] = lang;
+    }
+    return res;
+}
+export function checkStatus(injector, ev) {
+    if ((ev.status >= 200 && ev.status < 300) || ev.status === 401) {
+        return;
+    }
+    const errortext = CODEMESSAGE[ev.status] || ev.statusText;
+    injector.get(NzNotificationService).error(`请求错误 ${ev.status}: ${ev.url}`, errortext);
+}
+export function goTo(injector, url) {
+    setTimeout(() => injector.get(Router).navigateByUrl(url));
+}
+export function toLogin(injector) {
+    injector.get(NzNotificationService).error(`未登录或登录已过期，请重新登录。`, ``);
+    goTo(injector, injector.get(YA_SERVICE_TOKEN).login_url);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/provide.mjs

@@ -0,0 +1,8 @@
+import { importProvidersFrom, makeEnvironmentProviders } from '@angular/core';
+import { BisModule } from './bis.module';
+export function provideYunzaiBis() {
+    const provides = [];
+    provides.push(importProvidersFrom(BisModule));
+    return makeEnvironmentProviders(provides);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2Jpcy9zcmMvcHJvdmlkZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQXdCLG1CQUFtQixFQUFFLHdCQUF3QixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXBHLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFekMsTUFBTSxVQUFVLGdCQUFnQjtJQUM5QixNQUFNLFFBQVEsR0FBMkIsRUFBRSxDQUFDO0lBQzVDLFFBQVEsQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQztJQUM5QyxPQUFPLHdCQUF3QixDQUFDLFFBQVEsQ0FBQyxDQUFDO0FBQzVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbnZpcm9ubWVudFByb3ZpZGVycywgaW1wb3J0UHJvdmlkZXJzRnJvbSwgbWFrZUVudmlyb25tZW50UHJvdmlkZXJzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IEJpc01vZHVsZSB9IGZyb20gJy4vYmlzLm1vZHVsZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlWXVuemFpQmlzKCk6IEVudmlyb25tZW50UHJvdmlkZXJzIHtcbiAgY29uc3QgcHJvdmlkZXM6IEVudmlyb25tZW50UHJvdmlkZXJzW10gPSBbXTtcbiAgcHJvdmlkZXMucHVzaChpbXBvcnRQcm92aWRlcnNGcm9tKEJpc01vZHVsZSkpO1xuICByZXR1cm4gbWFrZUVudmlyb25tZW50UHJvdmlkZXJzKHByb3ZpZGVzKTtcbn1cbiJdfQ==

package/esm2022/src/refresh-token.mjs

@@ -0,0 +1,79 @@
+import { HttpClient } from '@angular/common/http';
+import { APP_INITIALIZER, Injector } from '@angular/core';
+import { BehaviorSubject, catchError, filter, switchMap, take, throwError } from 'rxjs';
+import { YA_SERVICE_TOKEN } from '@yelon/auth';
+import { log } from '@yelon/util';
+import { toLogin } from './helper';
+let refreshToking = false;
+let refreshToken$ = new BehaviorSubject(null);
+export const tryRefreshToken = (injector, ev, req, next) => {
+    // 连刷新Token的请求都错了，那就是真错了
+    if (['/auth/oauth/getOrCreateToken/webapp'].some(url => req.url.includes(url))) {
+        toLogin(injector);
+        return throwError(() => ev);
+    }
+    // 2、如果 `refreshToking` 为 `true` 表示已经在请求刷新 Token 中，后续所有请求转入等待状态，直至结果返回后再重新发起请求
+    if (refreshToking) {
+        return refreshToken$.pipe(filter(v => !!v), take(1), switchMap(() => next(reAttachToken(injector, req))));
+    }
+    // 3、尝试调用刷新 Token
+    refreshToking = true;
+    refreshToken$.next(null);
+    return refreshTokenRequest(injector).pipe(switchMap(res => {
+        // 通知后续请求继续执行
+        refreshToking = false;
+        refreshToken$.next(res);
+        // 重新保存新 token
+        injector.get(YA_SERVICE_TOKEN).set(res);
+        // 重新发起请求
+        return next(reAttachToken(injector, req));
+    }), catchError(err => {
+        refreshToking = false;
+        toLogin(injector);
+        return throwError(() => err);
+    }));
+};
+function reAttachToken(injector, req) {
+    const token = injector.get(YA_SERVICE_TOKEN).get()?.access_token;
+    return req.clone({
+        setHeaders: {
+            Authorization: `Bearer ${token}`
+        }
+    });
+}
+function refreshTokenRequest(injector) {
+    const model = injector.get(YA_SERVICE_TOKEN).get();
+    const form = new FormData();
+    form.set('refresh_token', model?.refresh_token);
+    form.set('grant_type', 'refresh_token');
+    form.set('scope', 'webapp');
+    return injector.get(HttpClient).post(`/auth/oauth/getOrCreateToken/webapp`, form);
+}
+function buildAuthRefresh(injector) {
+    const tokenSrv = injector.get(YA_SERVICE_TOKEN);
+    tokenSrv.refresh
+        .pipe(filter(() => !refreshToking), switchMap(res => {
+        log(res);
+        refreshToking = true;
+        return refreshTokenRequest(injector);
+    }))
+        .subscribe({
+        next: res => {
+            res.expired = +new Date() + 1000 * 60 * 5;
+            refreshToking = false;
+            tokenSrv.set(res);
+        },
+        error: () => toLogin(injector)
+    });
+}
+export function provideYunzaiBindAuthRefresh() {
+    return [
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (injector) => () => buildAuthRefresh(injector),
+            deps: [Injector],
+            multi: true
+        }
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"refresh-token.js","sourceRoot":"","sources":["../../../../../packages/bis/src/refresh-token.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHandlerFn, HttpRequest, HttpResponseBase } from '@angular/common/http';\nimport { APP_INITIALIZER, Injector, Provider } from '@angular/core';\nimport { BehaviorSubject, catchError, filter, Observable, switchMap, take, throwError } from 'rxjs';\n\nimport { YA_SERVICE_TOKEN } from '@yelon/auth';\nimport { log } from '@yelon/util';\nimport { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport { toLogin } from './helper';\n\nlet refreshToking = false;\nlet refreshToken$: BehaviorSubject<NzSafeAny> = new BehaviorSubject<NzSafeAny>(null);\n\nexport const tryRefreshToken = (\n  injector: Injector,\n  ev: HttpResponseBase,\n  req: HttpRequest<NzSafeAny>,\n  next: HttpHandlerFn\n): Observable<NzSafeAny> => {\n  // 连刷新Token的请求都错了，那就是真错了\n  if (['/auth/oauth/getOrCreateToken/webapp'].some(url => req.url.includes(url))) {\n    toLogin(injector);\n    return throwError(() => ev);\n  }\n  // 2、如果 `refreshToking` 为 `true` 表示已经在请求刷新 Token 中，后续所有请求转入等待状态，直至结果返回后再重新发起请求\n  if (refreshToking) {\n    return refreshToken$.pipe(\n      filter(v => !!v),\n      take(1),\n      switchMap(() => next(reAttachToken(injector, req)))\n    );\n  }\n  // 3、尝试调用刷新 Token\n  refreshToking = true;\n  refreshToken$.next(null);\n\n  return refreshTokenRequest(injector).pipe(\n    switchMap(res => {\n      // 通知后续请求继续执行\n      refreshToking = false;\n      refreshToken$.next(res);\n      // 重新保存新 token\n      injector.get(YA_SERVICE_TOKEN).set(res);\n      // 重新发起请求\n      return next(reAttachToken(injector, req));\n    }),\n    catchError(err => {\n      refreshToking = false;\n      toLogin(injector);\n      return throwError(() => err);\n    })\n  );\n};\n\nfunction reAttachToken(injector: Injector, req: HttpRequest<NzSafeAny>): HttpRequest<NzSafeAny> {\n  const token = injector.get(YA_SERVICE_TOKEN).get()?.access_token;\n  return req.clone({\n    setHeaders: {\n      Authorization: `Bearer ${token}`\n    }\n  });\n}\n\nfunction refreshTokenRequest(injector: Injector): Observable<NzSafeAny> {\n  const model = injector.get(YA_SERVICE_TOKEN).get();\n  const form = new FormData();\n  form.set('refresh_token', model?.refresh_token!);\n  form.set('grant_type', 'refresh_token');\n  form.set('scope', 'webapp');\n  return injector.get(HttpClient).post(`/auth/oauth/getOrCreateToken/webapp`, form);\n}\n\nfunction buildAuthRefresh(injector: Injector): void {\n  const tokenSrv = injector.get(YA_SERVICE_TOKEN);\n  tokenSrv.refresh\n    .pipe(\n      filter(() => !refreshToking),\n      switchMap(res => {\n        log(res);\n        refreshToking = true;\n        return refreshTokenRequest(injector);\n      })\n    )\n    .subscribe({\n      next: res => {\n        res.expired = +new Date() + 1000 * 60 * 5;\n        refreshToking = false;\n        tokenSrv.set(res);\n      },\n      error: () => toLogin(injector)\n    });\n}\n\nexport function provideYunzaiBindAuthRefresh(): Provider[] {\n  return [\n    {\n      provide: APP_INITIALIZER,\n      useFactory: (injector: Injector) => () => buildAuthRefresh(injector),\n      deps: [Injector],\n      multi: true\n    }\n  ];\n}\n"]}

package/esm2022/src/startup.service.mjs

@@ -0,0 +1,182 @@
+import { HttpClient } from '@angular/common/http';
+import { APP_INITIALIZER, inject, Injectable } from '@angular/core';
+import { combineLatest, map, mergeMap, of } from 'rxjs';
+import { ACLService } from '@yelon/acl';
+import { TokenService } from '@yelon/auth';
+import { mergeBisConfig } from '@yelon/bis/config';
+import { MenuService, SettingsService, TitleService, YUNZAI_I18N_TOKEN } from '@yelon/theme';
+import { deepCopy, useLocalStorageCurrent, useLocalStorageDefaultRoute, useLocalStorageHeader, useLocalStorageProjectInfo, useLocalStorageTenant, useLocalStorageUser, WINDOW, YunzaiConfigService } from '@yelon/util';
+import * as i0 from "@angular/core";
+export function provideYunzaiStartup() {
+    return [
+        YunzaiStartupService,
+        {
+            provide: APP_INITIALIZER,
+            useFactory: (startupService) => () => startupService.load(),
+            deps: [YunzaiStartupService],
+            multi: true
+        }
+    ];
+}
+export class YunzaiStartupService {
+    constructor() {
+        this.config = mergeBisConfig(inject(YunzaiConfigService));
+        this.menuService = inject(MenuService);
+        this.aclService = inject(ACLService);
+        this.titleService = inject(TitleService);
+        this.tokenService = inject(TokenService);
+        this.httpClient = inject(HttpClient);
+        this.settingService = inject(SettingsService);
+        this.i18n = inject(YUNZAI_I18N_TOKEN);
+    }
+    load() {
+        let defaultLang = this.settingService.layout.lang || this.i18n.defaultLang;
+        const [setTenant] = useLocalStorageTenant();
+        const [setUser, getUser] = useLocalStorageUser();
+        const [setHeader] = useLocalStorageHeader();
+        const [setProject] = useLocalStorageProjectInfo();
+        const [setDefaultRoute] = useLocalStorageDefaultRoute();
+        const [setCurrent] = useLocalStorageCurrent();
+        return this.token().pipe(mergeMap((token) => {
+            inject(YunzaiConfigService).set('auth', {
+                token_send_key: 'Authorization',
+                token_send_template: `${token.token_type} \${access_token}`,
+                token_send_place: 'header'
+            });
+            this.tokenService.set(token);
+            return of(void 0);
+        }), mergeMap(() => {
+            return combineLatest([
+                this.httpClient.get(`/auth/user`),
+                this.httpClient.get(`/auth/allheader/v2`),
+                this.httpClient.get(`/app-manager/project/info`)
+            ]).pipe(map(([user, header, project]) => {
+                setUser(user.principal);
+                setTenant(user.tenantId);
+                setHeader(header.data);
+                setProject(project.data);
+                return void 0;
+            }));
+        }), mergeMap(() => {
+            return this.i18n.loadLangData(defaultLang).pipe(map((langData) => {
+                this.i18n.use(defaultLang, langData);
+                return void 0;
+            }));
+        }), mergeMap(() => {
+            const yunzaiUser = getUser();
+            const yunzaiMenus = deepCopy(yunzaiUser.menu).filter(m => m.systemCode && m.systemCode === this.config.systemCode);
+            const currentMenu = yunzaiMenus.pop();
+            if (currentMenu) {
+                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
+                });
+                this.titleService.default = currentMenu && currentMenu.text ? currentMenu.text : 'default application name';
+                this.titleService.setTitle(currentMenu && currentMenu.text ? currentMenu.text : 'no title');
+                const abilities = [];
+                generateAbility([currentMenu], abilities, '');
+                this.aclService.attachRole(yunzaiUser?.roles
+                    .map((role) => {
+                    return role.roleValue;
+                })
+                    .filter((a) => !!a) || []);
+                this.aclService.attachAbility(abilities);
+                this.menuService.add([currentMenu]);
+                setCurrent({
+                    name: currentMenu.text,
+                    intro: currentMenu.intro || '',
+                    icon: currentMenu.appIconUrl || './assets/tmp/img/avatar.jpg'
+                });
+                const attributes = currentMenu.attribute;
+                if (attributes) {
+                    const attr = JSON.parse(attributes);
+                    if (attr && attr.defaultRoute) {
+                        setDefaultRoute(attr.defaultRoute);
+                    }
+                    else {
+                        setDefaultRoute('/displayIndex');
+                    }
+                }
+                else {
+                    setDefaultRoute('/displayIndex');
+                }
+            }
+            return of(void 0);
+        }));
+    }
+    token() {
+        if (this.config.loginForm) {
+            return this.httpClient.post(`/auth/oauth/token?_allow_anonymous=true`, this.config.loginForm).pipe(map((response) => {
+                return response;
+            }));
+        }
+        else {
+            const uri = encodeURIComponent(inject(WINDOW).location.href);
+            return this.httpClient
+                .get(`/cas-proxy/app/validate_full?callback=${uri}&_allow_anonymous=true&timestamp=${new Date().getTime()}`)
+                .pipe(map((response) => {
+                switch (response.errcode) {
+                    case 2000:
+                        return response.data;
+                    case 2001:
+                        inject(WINDOW).location.href = response.msg;
+                        throw Error("Cookie Error: Can't find Cas Cookie,So jump to login!");
+                    default:
+                        if (response.data) {
+                            console.error(response.data);
+                            throw Error(response.data);
+                        }
+                        else if (response.msg) {
+                            console.error(response.msg);
+                            throw Error(response.msg);
+                        }
+                        else {
+                            console.error('cas unknown error');
+                            throw Error('Unknown Error: Cas auth exception!');
+                        }
+                }
+            }));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiStartupService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiStartupService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: YunzaiStartupService, decorators: [{
+            type: Injectable
+        }] });
+export function mapYzSideToYelonMenu(menus) {
+    menus.forEach(menu => {
+        if (menu.children && menu.hideChildren) {
+            menu.children.forEach(c => (c.hide = true));
+        }
+        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);
+        }
+    });
+}
+export 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);
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"startup.service.js","sourceRoot":"","sources":["../../../../../packages/bis/src/startup.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { APP_INITIALIZER, inject, Injectable, Provider } from '@angular/core';\nimport { combineLatest, map, mergeMap, Observable, of } from 'rxjs';\n\nimport { ACLService } from '@yelon/acl';\nimport { ITokenModel, TokenService } from '@yelon/auth';\nimport { mergeBisConfig } from '@yelon/bis/config';\nimport {\n  Menu,\n  MenuService,\n  SettingsService,\n  TitleService,\n  YUNZAI_I18N_TOKEN,\n  YunzaiHttpI18NService\n} from '@yelon/theme';\nimport {\n  deepCopy,\n  useLocalStorageCurrent,\n  useLocalStorageDefaultRoute,\n  useLocalStorageHeader,\n  useLocalStorageProjectInfo,\n  useLocalStorageTenant,\n  useLocalStorageUser,\n  WINDOW,\n  YunzaiConfigService,\n  YunzaiMenu,\n  YunzaiMenuAttribute\n} from '@yelon/util';\nimport { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nexport function provideYunzaiStartup(): Provider[] {\n  return [\n    YunzaiStartupService,\n    {\n      provide: APP_INITIALIZER,\n      useFactory: (startupService: YunzaiStartupService) => () => startupService.load(),\n      deps: [YunzaiStartupService],\n      multi: true\n    }\n  ];\n}\n@Injectable()\nexport class YunzaiStartupService {\n  private config = mergeBisConfig(inject(YunzaiConfigService));\n  private menuService = inject(MenuService);\n  private aclService = inject(ACLService);\n  private titleService = inject(TitleService);\n  private tokenService = inject(TokenService);\n  private httpClient = inject(HttpClient);\n  private settingService = inject(SettingsService);\n  private i18n = inject<YunzaiHttpI18NService>(YUNZAI_I18N_TOKEN);\n\n  load(): Observable<void> {\n    let defaultLang: string = this.settingService.layout.lang || this.i18n.defaultLang;\n    const [setTenant] = useLocalStorageTenant();\n    const [setUser, getUser] = useLocalStorageUser();\n    const [setHeader] = useLocalStorageHeader();\n    const [setProject] = useLocalStorageProjectInfo();\n    const [setDefaultRoute] = useLocalStorageDefaultRoute();\n    const [setCurrent] = useLocalStorageCurrent();\n    return this.token().pipe(\n      mergeMap((token: ITokenModel) => {\n        inject(YunzaiConfigService).set('auth', {\n          token_send_key: 'Authorization',\n          token_send_template: `${token.token_type} \\${access_token}`,\n          token_send_place: 'header'\n        });\n        this.tokenService.set(token);\n        return of(void 0);\n      }),\n      mergeMap(() => {\n        return combineLatest([\n          this.httpClient.get(`/auth/user`),\n          this.httpClient.get(`/auth/allheader/v2`),\n          this.httpClient.get(`/app-manager/project/info`)\n        ]).pipe(\n          map(([user, header, project]: NzSafeAny) => {\n            setUser(user.principal);\n            setTenant(user.tenantId);\n            setHeader(header.data);\n            setProject(project.data);\n            return void 0;\n          })\n        );\n      }),\n      mergeMap(() => {\n        return this.i18n.loadLangData(defaultLang).pipe(\n          map((langData: NzSafeAny) => {\n            this.i18n.use(defaultLang, langData);\n            return void 0;\n          })\n        );\n      }),\n      mergeMap(() => {\n        const yunzaiUser = getUser()!;\n        const yunzaiMenus: YunzaiMenu[] = deepCopy(yunzaiUser.menu).filter(\n          m => m.systemCode && m.systemCode === this.config.systemCode\n        );\n        const currentMenu = yunzaiMenus.pop();\n        if (currentMenu) {\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          this.titleService.default = currentMenu && currentMenu.text ? currentMenu.text : 'default application name';\n          this.titleService.setTitle(currentMenu && currentMenu.text ? currentMenu.text : 'no title');\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          this.menuService.add([currentMenu as Menu]);\n          setCurrent({\n            name: currentMenu.text,\n            intro: currentMenu.intro || '',\n            icon: currentMenu.appIconUrl || './assets/tmp/img/avatar.jpg'\n          });\n          const attributes = currentMenu.attribute;\n          if (attributes) {\n            const attr: YunzaiMenuAttribute = JSON.parse(attributes);\n            if (attr && attr.defaultRoute) {\n              setDefaultRoute(attr.defaultRoute);\n            } else {\n              setDefaultRoute('/displayIndex');\n            }\n          } else {\n            setDefaultRoute('/displayIndex');\n          }\n        }\n        return of(void 0);\n      })\n    );\n  }\n\n  token(): Observable<ITokenModel> {\n    if (this.config.loginForm) {\n      return this.httpClient.post(`/auth/oauth/token?_allow_anonymous=true`, this.config.loginForm).pipe(\n        map((response: NzSafeAny) => {\n          return response;\n        })\n      );\n    } else {\n      const uri = encodeURIComponent(inject(WINDOW).location.href);\n      return this.httpClient\n        .get(`/cas-proxy/app/validate_full?callback=${uri}&_allow_anonymous=true&timestamp=${new Date().getTime()}`)\n        .pipe(\n          map((response: NzSafeAny) => {\n            switch (response.errcode) {\n              case 2000:\n                return response.data;\n              case 2001:\n                inject(WINDOW).location.href = response.msg;\n                throw Error(\"Cookie Error: Can't find Cas Cookie,So jump to login!\");\n              default:\n                if (response.data) {\n                  console.error(response.data);\n                  throw Error(response.data);\n                } else if (response.msg) {\n                  console.error(response.msg);\n                  throw Error(response.msg);\n                } else {\n                  console.error('cas unknown error');\n                  throw Error('Unknown Error: Cas auth exception!');\n                }\n            }\n          })\n        );\n    }\n  }\n}\n\nexport function mapYzSideToYelonMenu(menus: YunzaiMenu[]): void {\n  menus.forEach(menu => {\n    if (menu.children && menu.hideChildren) {\n      menu.children.forEach(c => (c.hide = true));\n    }\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\nexport function 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"]}

package/esm2022/src/yunzai-act.guard.mjs

@@ -0,0 +1,88 @@
+import { Injectable, inject } from '@angular/core';
+import { BUSINESS_DEFAULT_CONFIG, mergeBisConfig } from '@yelon/bis/config';
+import { deepCopy, log, useLocalStorageUser } from '@yelon/util';
+import * as i0 from "@angular/core";
+import * as i1 from "@yelon/util";
+import * as i2 from "@angular/router";
+export class ActGuardService {
+    constructor(configService, pathToRegexp, router) {
+        this.configService = configService;
+        this.pathToRegexp = pathToRegexp;
+        this.router = router;
+        this.bis = BUSINESS_DEFAULT_CONFIG;
+        this.menus = [];
+        this.links = [];
+        log('act: ');
+        this.bis = mergeBisConfig(this.configService);
+        log('act: config ', this.bis);
+        const [, getUser] = useLocalStorageUser();
+        const user = getUser();
+        log('act: user ', user);
+        // @ts-ignore
+        this.menus = deepCopy(user.menu || []).filter((m) => m.systemCode && m.systemCode === this.bis.systemCode);
+        log('act: menus ', this.menus);
+        this.getAllLinks(this.menus, this.links);
+        log('act: links ', this.links);
+    }
+    process(url) {
+        log('act: can activate ', url);
+        if (this.preHandle(url)) {
+            return true;
+        }
+        log('act: can activate child prehandle success');
+        let canactivate = false;
+        this.links.forEach((link) => {
+            // path = /xxx
+            if (link === url.split('?')[0]) {
+                canactivate = true;
+                log(`act: link value ${link} equals url value ${url}`);
+                return;
+            }
+            // paht = /xxx/:xx
+            const regexp = this.pathToRegexp.stringToRegexp(link, null, null);
+            log(`act: ${link} test ${url.split('?')[0]}`);
+            if (regexp.test(url.split('?')[0])) {
+                canactivate = true;
+                log(`act: test value ${canactivate}`);
+                return;
+            }
+        });
+        if (canactivate) {
+            log(`act: test sucess`);
+            return true;
+        }
+        else {
+            log(`act: test error`);
+            this.router.navigate(['displayIndex']);
+            return false;
+        }
+    }
+    preHandle(url) {
+        return (url.includes('error') ||
+            url.includes('exception') ||
+            url.includes('displayIndex') ||
+            url === '' ||
+            url === null ||
+            url === '/' ||
+            url.includes('iframePage'));
+    }
+    getAllLinks(menu, links) {
+        menu.forEach((sider) => {
+            if (sider.link) {
+                links.push(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: ActGuardService, deps: [{ token: i1.YunzaiConfigService }, { token: i1.PathToRegexpService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: ActGuardService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: ActGuardService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.YunzaiConfigService }, { type: i1.PathToRegexpService }, { type: i2.Router }] });
+export const actGuardCanActive = (_, state) => inject(ActGuardService).process(state.url);
+export const actGuardCanActiveChild = (_, state) => inject(ActGuardService).process(state.url);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yunzai-act.guard.js","sourceRoot":"","sources":["../../../../../packages/bis/src/yunzai-act.guard.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { CanActivateChildFn, CanActivateFn, Router } from '@angular/router';\n\nimport { BUSINESS_DEFAULT_CONFIG, mergeBisConfig } from '@yelon/bis/config';\nimport { Menu } from '@yelon/theme';\nimport {\n  deepCopy,\n  log,\n  YunzaiBusinessConfig,\n  YunzaiConfigService,\n  PathToRegexpService,\n  useLocalStorageUser,\n  YunzaiUser\n} from '@yelon/util';\nimport { NzSafeAny } from 'ng-zorro-antd/core/types';\n\n@Injectable({ providedIn: 'root' })\nexport class ActGuardService {\n  private bis: YunzaiBusinessConfig = BUSINESS_DEFAULT_CONFIG;\n  private menus: NzSafeAny[] = [];\n  private links: string[] = [];\n\n  constructor(\n    private configService: YunzaiConfigService,\n    private pathToRegexp: PathToRegexpService,\n    private router: Router\n  ) {\n    log('act: ');\n    this.bis = mergeBisConfig(this.configService);\n    log('act: config ', this.bis);\n    const [, getUser] = useLocalStorageUser();\n    const user: YunzaiUser = getUser()!;\n    log('act: user ', user);\n    // @ts-ignore\n    this.menus = deepCopy((user.menu as NzSafeAny) || []).filter(\n      (m: Menu) => m.systemCode && m.systemCode === this.bis.systemCode\n    ) as Menu[];\n    log('act: menus ', this.menus);\n    this.getAllLinks(this.menus, this.links);\n    log('act: links ', this.links);\n  }\n\n  process(url: string): boolean {\n    log('act: can activate ', url);\n    if (this.preHandle(url)) {\n      return true;\n    }\n    log('act: can activate child prehandle success');\n    let canactivate = false;\n    this.links.forEach((link: string) => {\n      // path = /xxx\n      if (link === url.split('?')[0]) {\n        canactivate = true;\n        log(`act: link value ${link} equals url value ${url}`);\n        return;\n      }\n      // paht = /xxx/:xx\n      const regexp: RegExp = this.pathToRegexp.stringToRegexp(link, null, null);\n      log(`act: ${link} test ${url.split('?')[0]}`);\n      if (regexp.test(url.split('?')[0])) {\n        canactivate = true;\n        log(`act: test value ${canactivate}`);\n        return;\n      }\n    });\n    if (canactivate) {\n      log(`act: test sucess`);\n      return true;\n    } else {\n      log(`act: test error`);\n      this.router.navigate(['displayIndex']);\n      return false;\n    }\n  }\n\n  preHandle(url: string): boolean {\n    return (\n      url.includes('error') ||\n      url.includes('exception') ||\n      url.includes('displayIndex') ||\n      url === '' ||\n      url === null ||\n      url === '/' ||\n      url.includes('iframePage')\n    );\n  }\n\n  getAllLinks(menu: Menu[], links: string[]): void {\n    menu.forEach((sider: Menu) => {\n      if (sider.link) {\n        links.push(sider.link);\n      }\n      if (sider.children && sider.children.length > 0) {\n        this.getAllLinks(sider.children, links);\n      }\n    });\n  }\n}\n\nexport const actGuardCanActive: CanActivateFn = (_, state) => inject(ActGuardService).process(state.url);\nexport const actGuardCanActiveChild: CanActivateChildFn = (_, state) => inject(ActGuardService).process(state.url);\n"]}