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

package/esm2022/errors-mapper/errors-mapper.directive.mjs

@@ -0,0 +1,115 @@
+import { __decorate, __metadata } from "tslib";
+import { ComponentPortal, DomPortalOutlet } from '@angular/cdk/portal';
+import { ApplicationRef, ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentFactoryResolver, Directive, Injector, Input, Optional, Self, } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { Observable, Subject, merge, of, debounceTime, map, switchMap, takeUntil, } from 'rxjs';
+import { ObservableInput } from '../core/public-api';
+import { BaseErrorsMapper } from './base-errors-mapper';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class ErrorsMapperDirective extends BaseErrorsMapper {
+    constructor(injector, cdr, 
+    // eslint-disable-next-line sonar/deprecation
+    cfr, appRef, control, ngForm, formGroup) {
+        super(injector);
+        this.injector = injector;
+        this.cdr = cdr;
+        this.cfr = cfr;
+        this.appRef = appRef;
+        this.control = control;
+        this.ngForm = ngForm;
+        this.formGroup = formGroup;
+        this.destroy$ = new Subject();
+    }
+    ngAfterViewInit() {
+        if (!this.control) {
+            throw new Error('Errors mapper is not properly configured. No valid control is found.');
+        }
+        this.initPortal();
+        const statusChange = [this.control.statusChanges];
+        if (this.ngForm) {
+            statusChange.push(this.ngForm.ngSubmit);
+        }
+        if (this.formGroup) {
+            statusChange.push(this.formGroup.ngSubmit);
+        }
+        this.aclErrorsMapperDisabled$
+            .pipe(switchMap(isDisable => isDisable
+            ? of(null)
+            : merge(...statusChange, this.translate.locale$).pipe(debounceTime(50), map(() => this.getErrorMessage(this.control.errors, this.aclErrorsMapper || {}, this.aclErrorsMapperFn, this.aclErrorsMapperControlName)))), takeUntil(this.destroy$))
+            .subscribe(content => {
+            this.updateContent(content);
+            this.cdr.markForCheck();
+        });
+    }
+    updateContent(content) {
+        if (!content) {
+            if (this.portalHost.hasAttached()) {
+                this.portalHost.detach();
+            }
+            return;
+        }
+        if (!this.portalHost.hasAttached()) {
+            this.portalAttach = this.portalHost.attach(this.portal).instance;
+        }
+        this.portalAttach.data = content;
+        this.portalAttach.cdr.markForCheck();
+    }
+    initPortal() {
+        this.portalHost = new DomPortalOutlet(this.aclErrorsMapperOutlet, this.cfr, this.appRef, this.injector);
+        this.portal = new ComponentPortal(TextComponent);
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.portalHost.dispose();
+    }
+    static { this.ɵfac = function ErrorsMapperDirective_Factory(t) { return new (t || ErrorsMapperDirective)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ComponentFactoryResolver), i0.ɵɵdirectiveInject(i0.ApplicationRef), i0.ɵɵdirectiveInject(i1.NgControl, 2), i0.ɵɵdirectiveInject(i1.NgForm, 8), i0.ɵɵdirectiveInject(i1.FormGroupDirective, 8)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ErrorsMapperDirective, selectors: [["", "aclErrorsMapper", ""]], inputs: { aclErrorsMapper: "aclErrorsMapper", aclErrorsMapperFn: "aclErrorsMapperFn", aclErrorsMapperDisabled: "aclErrorsMapperDisabled", aclErrorsMapperOutlet: "aclErrorsMapperOutlet", aclErrorsMapperControlName: "aclErrorsMapperControlName" }, standalone: true, features: [i0.ɵɵInheritDefinitionFeature] }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperDirective.prototype, "aclErrorsMapperDisabled$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorsMapperDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclErrorsMapper]',
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.Injector }, { type: i0.ChangeDetectorRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i1.NgControl, decorators: [{
+                type: Self
+            }] }, { type: i1.NgForm, decorators: [{
+                type: Optional
+            }] }, { type: i1.FormGroupDirective, decorators: [{
+                type: Optional
+            }] }]; }, { aclErrorsMapper: [{
+            type: Input
+        }], aclErrorsMapperFn: [{
+            type: Input
+        }], aclErrorsMapperDisabled: [{
+            type: Input
+        }], aclErrorsMapperDisabled$: [], aclErrorsMapperOutlet: [{
+            type: Input
+        }], aclErrorsMapperControlName: [{
+            type: Input
+        }] }); })();
+class TextComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    static { this.ɵfac = function TextComponent_Factory(t) { return new (t || TextComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: TextComponent, selectors: [["ng-component"]], standalone: true, features: [i0.ɵɵStandaloneFeature], decls: 1, vars: 1, template: function TextComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtext(0);
+        } if (rf & 2) {
+            i0.ɵɵtextInterpolate1(" ", ctx.data, " ");
+        } }, encapsulation: 2, changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TextComponent, [{
+        type: Component,
+        args: [{
+                template: ` {{ data }} `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                standalone: true,
+            }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors-mapper.directive.js","sourceRoot":"","sources":["../../../../../libs/common/src/errors-mapper/errors-mapper.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentPortal, DomPortalOutlet, Portal } from '@angular/cdk/portal';\nimport {\n  AfterViewInit,\n  ApplicationRef,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentFactoryResolver,\n  Directive,\n  Injector,\n  Input,\n  OnDestroy,\n  Optional,\n  Self,\n} from '@angular/core';\nimport { FormGroupDirective, NgControl, NgForm } from '@angular/forms';\nimport {\n  Observable,\n  Subject,\n  merge,\n  of,\n  debounceTime,\n  map,\n  switchMap,\n  takeUntil,\n} from 'rxjs';\n\nimport { StringMap, ObservableInput } from '../core/public-api';\n\nimport { BaseErrorsMapper } from './base-errors-mapper';\nimport { ErrorsMapperFn } from './types';\n\n@Directive({\n  selector: '[aclErrorsMapper]',\n  standalone: true,\n})\nexport class ErrorsMapperDirective\n  extends BaseErrorsMapper\n  implements AfterViewInit, OnDestroy\n{\n  @Input()\n  aclErrorsMapper: StringMap | '';\n\n  @Input()\n  aclErrorsMapperFn: ErrorsMapperFn;\n\n  @Input()\n  aclErrorsMapperDisabled: boolean;\n\n  /**\n   * disable errors mapper\n   */\n  @ObservableInput()\n  aclErrorsMapperDisabled$: Observable<boolean>;\n\n  /**\n   * specify outlet, consider this other than specific control entity to make sure di can always get ngForm\n   */\n  @Input()\n  aclErrorsMapperOutlet: Element;\n\n  @Input()\n  aclErrorsMapperControlName: string;\n\n  private portal: Portal<any>;\n  private portalHost: DomPortalOutlet;\n  private portalAttach: TextComponent;\n  private readonly destroy$ = new Subject<void>();\n\n  constructor(\n    public injector: Injector,\n    private readonly cdr: ChangeDetectorRef,\n    // eslint-disable-next-line sonar/deprecation\n    private readonly cfr: ComponentFactoryResolver,\n    private readonly appRef: ApplicationRef,\n    @Self() private readonly control: NgControl,\n    @Optional() private readonly ngForm: NgForm,\n    @Optional()\n    private readonly formGroup: FormGroupDirective,\n  ) {\n    super(injector);\n  }\n\n  ngAfterViewInit() {\n    if (!this.control) {\n      throw new Error(\n        'Errors mapper is not properly configured. No valid control is found.',\n      );\n    }\n    this.initPortal();\n    const statusChange = [this.control.statusChanges];\n\n    if (this.ngForm) {\n      statusChange.push(this.ngForm.ngSubmit);\n    }\n    if (this.formGroup) {\n      statusChange.push(this.formGroup.ngSubmit);\n    }\n\n    this.aclErrorsMapperDisabled$\n      .pipe(\n        switchMap(isDisable =>\n          isDisable\n            ? of(null)\n            : merge(...statusChange, this.translate.locale$).pipe(\n                debounceTime(50),\n                map(() =>\n                  this.getErrorMessage(\n                    this.control.errors,\n                    this.aclErrorsMapper || {},\n                    this.aclErrorsMapperFn,\n                    this.aclErrorsMapperControlName,\n                  ),\n                ),\n              ),\n        ),\n        takeUntil(this.destroy$),\n      )\n      .subscribe(content => {\n        this.updateContent(content);\n        this.cdr.markForCheck();\n      });\n  }\n\n  updateContent(content: string) {\n    if (!content) {\n      if (this.portalHost.hasAttached()) {\n        this.portalHost.detach();\n      }\n      return;\n    }\n    if (!this.portalHost.hasAttached()) {\n      this.portalAttach = this.portalHost.attach(this.portal).instance;\n    }\n    this.portalAttach.data = content;\n    this.portalAttach.cdr.markForCheck();\n  }\n\n  initPortal() {\n    this.portalHost = new DomPortalOutlet(\n      this.aclErrorsMapperOutlet,\n      this.cfr,\n      this.appRef,\n      this.injector,\n    );\n    this.portal = new ComponentPortal(TextComponent);\n  }\n\n  ngOnDestroy() {\n    this.destroy$.next();\n    this.portalHost.dispose();\n  }\n}\n\n@Component({\n  template: ` {{ data }} `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n})\nclass TextComponent {\n  data: string;\n  constructor(public cdr: ChangeDetectorRef) {}\n}\n"]}

package/esm2022/errors-mapper/errors-mapper.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { ErrorsMapperComponent } from './errors-mapper-component/component';
+import { ErrorsMapperDirective } from './errors-mapper.directive';
+import * as i0 from "@angular/core";
+export class ErrorsMapperModule {
+    static { this.ɵfac = function ErrorsMapperModule_Factory(t) { return new (t || ErrorsMapperModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: ErrorsMapperModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({}); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ErrorsMapperModule, [{
+        type: NgModule,
+        args: [{
+                imports: [ErrorsMapperComponent, ErrorsMapperDirective],
+                exports: [ErrorsMapperComponent, ErrorsMapperDirective],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(ErrorsMapperModule, { imports: [ErrorsMapperComponent, ErrorsMapperDirective], exports: [ErrorsMapperComponent, ErrorsMapperDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLW1hcHBlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvZXJyb3JzLW1hcHBlci9lcnJvcnMtbWFwcGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDOztBQU1sRSxNQUFNLE9BQU8sa0JBQWtCO21GQUFsQixrQkFBa0I7bUVBQWxCLGtCQUFrQjs7O3VGQUFsQixrQkFBa0I7Y0FKOUIsUUFBUTtlQUFDO2dCQUNSLE9BQU8sRUFBRSxDQUFDLHFCQUFxQixFQUFFLHFCQUFxQixDQUFDO2dCQUN2RCxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsRUFBRSxxQkFBcUIsQ0FBQzthQUN4RDs7d0ZBQ1ksa0JBQWtCLGNBSG5CLHFCQUFxQixFQUFFLHFCQUFxQixhQUM1QyxxQkFBcUIsRUFBRSxxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBFcnJvcnNNYXBwZXJDb21wb25lbnQgfSBmcm9tICcuL2Vycm9ycy1tYXBwZXItY29tcG9uZW50L2NvbXBvbmVudCc7XG5pbXBvcnQgeyBFcnJvcnNNYXBwZXJEaXJlY3RpdmUgfSBmcm9tICcuL2Vycm9ycy1tYXBwZXIuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0Vycm9yc01hcHBlckNvbXBvbmVudCwgRXJyb3JzTWFwcGVyRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW0Vycm9yc01hcHBlckNvbXBvbmVudCwgRXJyb3JzTWFwcGVyRGlyZWN0aXZlXSxcbn0pXG5leHBvcnQgY2xhc3MgRXJyb3JzTWFwcGVyTW9kdWxlIHt9XG4iXX0=

package/esm2022/errors-mapper/public-api.mjs

@@ -0,0 +1,5 @@
+export * from './errors-mapper-component/component';
+export * from './errors-mapper.directive';
+export * from './errors-mapper.module';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9lcnJvcnMtbWFwcGVyL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Vycm9ycy1tYXBwZXItY29tcG9uZW50L2NvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Vycm9ycy1tYXBwZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzLW1hcHBlci5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/esm2022/errors-mapper/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvZXJyb3JzLW1hcHBlci90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3RyaW5nTWFwIH0gZnJvbSAnLi4vY29yZS9wdWJsaWMtYXBpJztcblxuLyoqXG4gKiBEZWZpbmVzIGhvdyBhIGVycm9yIG9iamVjdCAodmFsaWRhdG9yIGtleSwgZXJyb3Igb2JqZWN0LCB0aGUgY29udHJvbCBvYmplY3QpIHNob3VsZCBiZSBtYXBwZWQgdG8gc3RyaW5nLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEVycm9yTWFwcGVySW50ZXJmYWNlIHtcbiAgLyoqXG4gICAqIE1hcHMgYW4gZXJyb3IgdG8gYSBzdHJpbmcuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBrZXkgdGhlIGVycm9yIGtleS4gaS5lLiwgcmVxdWlyZWQsIGV0Y1xuICAgKiBAcGFyYW0gZXJyb3IgdGhlIGVycm9yIG9iamVjdFxuICAgKiBAcGFyYW0gY29udHJvbCBjb250cm9sIE9iamVjdCAoQWJzdHJhY3RDb250cm9sIGZvciBBbmd1bGFyLCBOZ01vZGVsIGZvciBBbmd1bGFySlMpXG4gICAqIEByZXR1cm5zIHtzdHJpbmd9XG4gICAqL1xuICBtYXAoa2V5OiBzdHJpbmcsIGVycm9yPzogdW5rbm93biwgY29udHJvbD86IHVua25vd24pOiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIEVycm9yc01hcHBlckZuID0gKGVycm9yOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPikgPT4gc3RyaW5nO1xuXG5leHBvcnQgdHlwZSBFcnJvck1hcHBlciA9IEVycm9yTWFwcGVySW50ZXJmYWNlIHwgU3RyaW5nTWFwO1xuIl19

package/esm2022/exec/constants.mjs

@@ -0,0 +1,64 @@
+export const TERMINAL_THEME_LOCAL_STORAGE_KEY = 'acl-terminal-theme';
+export const TERMINAL_FONT_LOCAL_STORAGE_KEY = 'acl-terminal-font';
+export var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus["Connecting"] = "connecting";
+    ConnectionStatus["Connected"] = "connected";
+    ConnectionStatus["Disconnected"] = "disconnected";
+    ConnectionStatus["NoPermission"] = "noPermission";
+    ConnectionStatus["ReConnecting"] = "reConnecting";
+})(ConnectionStatus || (ConnectionStatus = {}));
+export const XTERM_DEFAULT_OPTIONS = {
+    fontSize: 12,
+    fontFamily: 'Monaco, Consolas, "Courier New", monospace',
+    cursorBlink: true,
+};
+export const XTERM_LIGHT_THEME = {
+    background: '#ffffff',
+    foreground: '#323437',
+    cursor: '#323437',
+    cursorAccent: '#ffffff',
+    selectionBackground: '#007af5',
+    selectionInactiveBackground: '#f5a300',
+    black: '#000000',
+    red: '#c91b00',
+    green: '#00c200',
+    yellow: '#c7c400',
+    blue: '#0225c7',
+    magenta: '#c930c7',
+    cyan: '#00c5c7',
+    white: '#c7c7c7',
+    brightBlack: '#676767',
+    brightRed: '#ff6d67',
+    brightGreen: '#5ff967',
+    brightYellow: '#fefb67',
+    brightBlue: '#6871ff',
+    brightMagenta: '#ff76ff',
+    brightCyan: '#5ffdff',
+    brightWhite: '#fffefe',
+};
+export const XTERM_DARK_THEME = {
+    background: '#242733',
+    foreground: '#eeeff3',
+    cursor: '#eeeff3',
+    cursorAccent: '#242733',
+    selectionBackground: '#3d8eff',
+    selectionInactiveBackground: '#edac2c',
+    black: '#000000',
+    red: '#c91b00',
+    green: '#00c200',
+    yellow: '#c7c400',
+    blue: '#0225c7',
+    magenta: '#c930c7',
+    cyan: '#00c5c7',
+    white: '#c7c7c7',
+    brightBlack: '#676767',
+    brightRed: '#ff6d67',
+    brightGreen: '#5ff967',
+    brightYellow: '#fefb67',
+    brightBlue: '#6871ff',
+    brightMagenta: '#ff76ff',
+    brightCyan: '#5ffdff',
+    brightWhite: '#fffefe',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/exec/module.mjs

@@ -0,0 +1,82 @@
+import { ButtonModule, DropdownModule, IconModule, InlineAlertModule, InputModule, TabsModule, ThemeModule, TooltipModule, } from '@alauda/ui';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TextEllipsisComponent } from '../scm/text-ellipsis/component';
+import { TranslateModule } from '../translate/public-api';
+import { LoadingMaskComponent } from '../widget/loading-mask/loading-mask.component';
+import { TerminalPlaceholderComponent } from './placeholder/component';
+import { TerminalComponent } from './terminal/component';
+import { TerminalExtraButtonDirective, TerminalExtraContentDirective, TerminalGroupComponent, } from './terminal-group/component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@alauda/ui";
+import * as i3 from "../scm/text-ellipsis/component";
+import * as i4 from "../translate/translate.pipe";
+import * as i5 from "../widget/loading-mask/loading-mask.component";
+export const EXPORTS = [
+    TerminalGroupComponent,
+    TerminalComponent,
+    TerminalPlaceholderComponent,
+    TerminalExtraButtonDirective,
+    TerminalExtraContentDirective,
+];
+export class EXECModule {
+    static { this.ɵfac = function EXECModule_Factory(t) { return new (t || EXECModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: EXECModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+            TranslateModule,
+            ButtonModule,
+            DropdownModule,
+            IconModule,
+            InlineAlertModule,
+            InputModule,
+            TabsModule,
+            TooltipModule,
+            ThemeModule,
+            LoadingMaskComponent] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EXECModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    TranslateModule,
+                    ButtonModule,
+                    DropdownModule,
+                    IconModule,
+                    InlineAlertModule,
+                    InputModule,
+                    TabsModule,
+                    TooltipModule,
+                    ThemeModule,
+                    TextEllipsisComponent,
+                    LoadingMaskComponent,
+                ],
+                declarations: EXPORTS,
+                exports: EXPORTS,
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(EXECModule, { declarations: [TerminalGroupComponent,
+        TerminalComponent,
+        TerminalPlaceholderComponent,
+        TerminalExtraButtonDirective,
+        TerminalExtraContentDirective], imports: [CommonModule,
+        TranslateModule,
+        ButtonModule,
+        DropdownModule,
+        IconModule,
+        InlineAlertModule,
+        InputModule,
+        TabsModule,
+        TooltipModule,
+        ThemeModule,
+        TextEllipsisComponent,
+        LoadingMaskComponent], exports: [TerminalGroupComponent,
+        TerminalComponent,
+        TerminalPlaceholderComponent,
+        TerminalExtraButtonDirective,
+        TerminalExtraContentDirective] }); })();
+i0.ɵɵsetComponentScope(TerminalGroupComponent, [i1.NgForOf, i1.NgIf, i2.ButtonComponent, i2.IconComponent, i2.TabGroupComponent, i2.TabComponent, i2.TabLabelDirective, i2.TooltipDirective, i3.TextEllipsisComponent, TerminalComponent], [i4.TranslatePipe]);
+i0.ɵɵsetComponentScope(TerminalComponent, [i1.NgClass, i1.NgIf, i1.NgTemplateOutlet, i2.ButtonComponent, i2.DropdownDirective, i2.MenuComponent, i2.MenuItemComponent, i2.IconComponent, i2.InlineAlertComponent, i2.InputAddonAfterDirective, i2.SearchComponent, i2.NumberInputComponent, i2.TooltipDirective, i5.LoadingMaskComponent, TerminalPlaceholderComponent], [i1.AsyncPipe, i4.TranslatePipe]);
+i0.ɵɵsetComponentScope(TerminalPlaceholderComponent, [], [i4.TranslatePipe, i2.ThemePickerPipe]);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/exec/placeholder/component.mjs

@@ -0,0 +1,42 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export const TYPES = {
+    placeholder: {
+        img: ['images/light/no-data.svg', 'images/dark/no-data.svg'],
+        text: 'no_remote_terminal_connected',
+    },
+    permission: {
+        img: ['images/light/no-permission.svg', 'images/dark/no-permission.svg'],
+        text: 'no_permission_description',
+    },
+};
+export class TerminalPlaceholderComponent {
+    constructor() {
+        this.type = 'placeholder';
+    }
+    get config() {
+        return TYPES[this.type];
+    }
+    static { this.ɵfac = function TerminalPlaceholderComponent_Factory(t) { return new (t || TerminalPlaceholderComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: TerminalPlaceholderComponent, selectors: [["acl-terminal-placeholder"]], inputs: { type: "type" }, decls: 6, vars: 6, consts: [[1, "tw-flex", "tw-flex-col", "tw-justify-center", "tw-items-center", "tw-w-[100%]", "tw-h-[100%]", "tw-min-h-[360px]"], [1, "tw-w-[200px]", "tw-h-[200px]", "tw-mb-20", 3, "src"], [1, "tw-leading-text-xl", "tw-text-main-text", "tw-font-bolder"]], template: function TerminalPlaceholderComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "div", 0);
+            i0.ɵɵelement(1, "img", 1);
+            i0.ɵɵpipe(2, "auiThemePicker");
+            i0.ɵɵelementStart(3, "div", 2);
+            i0.ɵɵtext(4);
+            i0.ɵɵpipe(5, "translate");
+            i0.ɵɵelementEnd()();
+        } if (rf & 2) {
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("src", i0.ɵɵpipeBind1(2, 2, ctx.config.img), i0.ɵɵsanitizeUrl);
+            i0.ɵɵadvance(3);
+            i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(5, 4, ctx.config.text), " ");
+        } }, styles: ["[_nghost-%COMP%]{display:block;width:100%;height:100%;border:1px solid rgb(var(--aui-color-border));border-radius:var(--aui-border-radius-l);overflow:auto}"], changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TerminalPlaceholderComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-terminal-placeholder', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n  class=\"tw-flex tw-flex-col tw-justify-center tw-items-center tw-w-[100%] tw-h-[100%] tw-min-h-[360px]\"\n>\n  <img\n    class=\"tw-w-[200px] tw-h-[200px] tw-mb-20\"\n    [src]=\"config.img | auiThemePicker\"\n  />\n  <div class=\"tw-leading-text-xl tw-text-main-text tw-font-bolder\">\n    {{ config.text | translate }}\n  </div>\n</div>\n", styles: [":host{display:block;width:100%;height:100%;border:1px solid rgb(var(--aui-color-border));border-radius:var(--aui-border-radius-l);overflow:auto}\n"] }]
+    }], null, { type: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/exec/public-api.mjs

@@ -0,0 +1,8 @@
+export * from './module';
+export * from './constants';
+export * from './types';
+export * from './service';
+export * from './terminal-group/component';
+export * from './terminal/component';
+export * from './placeholder/component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9leGVjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0YW50cyc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Rlcm1pbmFsLWdyb3VwL2NvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3Rlcm1pbmFsL2NvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BsYWNlaG9sZGVyL2NvbXBvbmVudCc7XG4iXX0=

package/esm2022/exec/service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { map, startWith } from 'rxjs';
+import { K8sResourceAction, publishRef } from '../core/public-api';
+import { K8sPermissionService } from '../permission/public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "../permission/public-api";
+export class ExecService {
+    constructor(k8sPermission) {
+        this.k8sPermission = k8sPermission;
+    }
+    execPermission({ cluster, namespace }) {
+        return this.k8sPermission
+            .isAllowed({
+            type: { type: 'pods/exec' },
+            cluster,
+            namespace,
+            action: [K8sResourceAction.CREATE],
+        })
+            .pipe(map(({ create }) => create), startWith(false), publishRef());
+    }
+    openTerminal(href) {
+        const width = 800;
+        const height = 600;
+        const screenWith = window.screen.width;
+        const screenHeight = window.screen.height;
+        const top = screenHeight / 2 - height / 2;
+        const left = screenWith / 2 - width / 2;
+        window.open(href, '_blank', `width=${width},height=${height},top=${top},left=${left},resizable=yes`);
+    }
+    static { this.ɵfac = function ExecService_Factory(t) { return new (t || ExecService)(i0.ɵɵinject(i1.K8sPermissionService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ExecService, factory: ExecService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ExecService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.K8sPermissionService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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