@alauda-fe/common 1.0.0-next.0

package/exec/terminal/component.d.ts

@@ -0,0 +1,95 @@
+import { NotificationService, SearchComponent } from '@alauda/ui';
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges, TemplateRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Terminal } from 'xterm';
+import { CanvasAddon } from 'xterm-addon-canvas';
+import { WebglAddon } from 'xterm-addon-webgl';
+import { ApiGatewayService } from '../../api/public-api';
+import { AuthorizationStateService } from '../../authorization/public-api';
+import { K8sPermissionService } from '../../permission/k8s-permission.service';
+import { TranslateService } from '../../translate/public-api';
+import { ConnectionStatus } from '../constants';
+import { TerminalOption } from '../types';
+import * as i0 from "@angular/core";
+export declare const BIN_SH = "/bin/sh";
+export declare const AUTO_SCRIPT_COMMENT = "# !!auto-script!!";
+export declare const EXEC_FAILED_MESSAGE_CONTAINERD = "Internal error occurred: error executing command in container";
+export declare const EXEC_FAILED_MESSAGE_DOCKER = "OCI runtime exec failed: exec failed: unable to start container process";
+export declare const NO_PERMISSION_CODE = 40001;
+export declare function initRendererAddon(): WebglAddon | CanvasAddon;
+/**
+ * For dispatching keyboard events automatically to xterm,
+ * please view https://www.physics.udel.edu/~watson/scen103/ascii.html for reference.
+ *
+ * For instance, if you want to dispatch `Ctrl+C` to xterm, you should dispatch `\x03`(aka `\u0003`) to the socket.
+ *
+ * ```ts
+ * socket.send('0' + encode('\u0003'))
+ * ```
+ */
+export declare class TerminalComponent implements OnChanges, OnDestroy, OnInit {
+    private readonly apiGateway;
+    private readonly authState;
+    private readonly notification;
+    private readonly translate;
+    private readonly cdr;
+    private readonly k8sPermission;
+    private readonly globalNamespace;
+    ConnectionStatus: typeof ConnectionStatus;
+    option: TerminalOption;
+    index: number;
+    extraButton: TemplateRef<unknown>;
+    extraContent: TemplateRef<unknown>;
+    readonly connectionStatusChange: EventEmitter<ConnectionStatus>;
+    readonly sendData: EventEmitter<string>;
+    readonly socketReady: EventEmitter<WebSocket>;
+    readonly fallbackShell: EventEmitter<string>;
+    anchorRef: ElementRef<HTMLDivElement>;
+    searchInputRef: SearchComponent;
+    beforeUnload(event: BeforeUnloadEvent): void;
+    unload(_event: BeforeUnloadEvent): void;
+    theme: 'light' | 'dark';
+    fontSize: number;
+    searching: boolean;
+    searchKeyword: string;
+    coding: string;
+    connectionStatus: ConnectionStatus;
+    commandHasRun: boolean;
+    needClear: boolean;
+    xterm: Terminal;
+    private searchAddon;
+    private socket;
+    private ping;
+    socket$$: Subject<WebSocket>;
+    shouldFallBackOnClose: boolean;
+    get themeClass(): string;
+    get showLoading(): boolean;
+    constructor(apiGateway: ApiGatewayService, authState: AuthorizationStateService, notification: NotificationService, translate: TranslateService, cdr: ChangeDetectorRef, k8sPermission: K8sPermissionService, globalNamespace: string);
+    ngOnInit(): void;
+    ngOnChanges({ option }: SimpleChanges): void;
+    ngOnDestroy(): void;
+    focus(): void;
+    reconnect(): void;
+    killProcess(): void;
+    switchTheme(): void;
+    fontSizeChange(size: number): void;
+    openSearching(): void;
+    closeSearching(): void;
+    onShellKeyDown(event: KeyboardEvent): void;
+    onSearchInputKeyDown(event: KeyboardEvent): void;
+    private getSearchOptions;
+    findNext(): void;
+    findPrevious(): void;
+    private initXterm;
+    private initFitAddon;
+    private initSearchAddon;
+    private initSocket;
+    private readonly initSocketListeners;
+    private readonly initSocketConnection;
+    private fallBackOnClose;
+    private closeSocket;
+    private resizeRemoteTerminal;
+    private updateConnectionStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminalComponent, "acl-terminal", never, { "option": { "alias": "option"; "required": false; }; "index": { "alias": "index"; "required": false; }; "extraButton": { "alias": "extraButton"; "required": false; }; "extraContent": { "alias": "extraContent"; "required": false; }; }, { "connectionStatusChange": "connectionStatusChange"; "sendData": "sendData"; "socketReady": "socketReady"; "fallbackShell": "fallbackShell"; }, never, never, false, never>;
+}

package/exec/terminal-group/component.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter, QueryList, TemplateRef } from '@angular/core';
+import { ConnectionStatus } from '../constants';
+import { TerminalComponent } from '../terminal/component';
+import { TerminalOption } from '../types';
+import * as i0 from "@angular/core";
+export declare class TerminalExtraButtonDirective {
+    enable: boolean | '';
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalExtraButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TerminalExtraButtonDirective, "[aclTerminalExtraButton]", never, { "enable": { "alias": "aclTerminalExtraButton"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare class TerminalExtraContentDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalExtraContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TerminalExtraContentDirective, "[aclTerminalExtraContent]", never, {}, {}, never, never, false, never>;
+}
+export declare class TerminalGroupComponent {
+    ConnectionStatus: typeof ConnectionStatus;
+    selectedIndex: number;
+    terminalOptions: TerminalOption[];
+    terminalExtraButton: TerminalExtraButtonDirective;
+    terminalExtraButtonRef: TemplateRef<unknown>;
+    terminalExtraContentRef: TemplateRef<unknown>;
+    readonly selectedIndexChange: EventEmitter<number>;
+    readonly terminalOptionsChange: EventEmitter<TerminalOption[]>;
+    readonly socketReady: EventEmitter<{
+        option: TerminalOption;
+        socket: WebSocket;
+        index: number;
+    }>;
+    readonly fallbackShell: EventEmitter<{
+        option: TerminalOption;
+        shell: string;
+    }>;
+    terminals: QueryList<TerminalComponent>;
+    statusMap: Map<TerminalOption, ConnectionStatus>;
+    removeTerminal(index: number): void;
+    trackByOption(_: number, option: TerminalOption): TerminalOption;
+    handleConnectionStatusChange(option: TerminalOption, status: ConnectionStatus): void;
+    reconnect(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TerminalGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TerminalGroupComponent, "acl-terminal-group", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "terminalOptions": { "alias": "terminalOptions"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "terminalOptionsChange": "terminalOptionsChange"; "socketReady": "socketReady"; "fallbackShell": "fallbackShell"; }, ["terminalExtraButton", "terminalExtraButtonRef", "terminalExtraContentRef"], never, false, never>;
+}

package/exec/types.d.ts

@@ -0,0 +1,14 @@
+export interface TerminalOption {
+    cluster: string;
+    namespace: string;
+    pod: string;
+    container: string;
+    user?: string;
+    command?: string;
+    label?: string;
+    advanceApi?: boolean;
+    cmd?: string;
+    icon?: string;
+    notClearWhenReconnect?: boolean;
+    checkPermissionType?: 'cluster' | 'node';
+}

package/feature-gate-forbidden/component/component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class FeatureGateForbiddenComponent {
+    featureName: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureGateForbiddenComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureGateForbiddenComponent, "acl-feature-gate-forbidden", never, { "featureName": { "alias": "featureName"; "required": false; }; }, {}, never, never, false, never>;
+}

package/feature-gate-forbidden/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+export * from './component/component';

package/feature-gate-forbidden/module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component/component";
+import * as i2 from "@angular/router";
+import * as i3 from "../translate/translate.module";
+import * as i4 from "../page-guard/module";
+import * as i5 from "@alauda/ui";
+export declare class FeatureGateForbiddenModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureGateForbiddenModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FeatureGateForbiddenModule, [typeof i1.FeatureGateForbiddenComponent], [typeof i2.RouterModule, typeof i3.TranslateModule, typeof i4.PageGuardModule, typeof i5.ButtonModule], [typeof i1.FeatureGateForbiddenComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FeatureGateForbiddenModule>;
+}

package/form/index.d.ts

@@ -0,0 +1,4 @@
+export * from './labels-editor/component';
+export * from './taints-editor/component';
+export * from './validators/public-api';
+export { genControlDepsMap } from './utils';

package/form/labels-editor/component.d.ts

@@ -0,0 +1,31 @@
+import { AbstractControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+declare const LabelsEditorComponent_base: new () => import("../../core").BaseNestedFormControl<Record<string, string>, Pair[]>;
+export declare class LabelsEditorComponent extends LabelsEditorComponent_base {
+    K8S_RESOURCE_LABEL_VALUE_PATTERN: {
+        pattern: RegExp;
+        tip: string;
+    };
+    duplicatedRows: Record<number, boolean>;
+    addLabel(): void;
+    editLabel(index: number, key: keyof Pair, value: string): void;
+    removeLabel(index: number): void;
+    validateLabelKey: (duplicatedRows: Record<number, boolean>, index: number) => (control: AbstractControl) => {
+        duplicated: any;
+        pattern: boolean;
+    };
+    writeValue(value: Record<string, string>): void;
+    emitValue(value: Record<string, string>): void;
+    protected valueIn(value: Record<string, string>): Pair[];
+    protected modelOut(model: Pair[]): Record<string, string>;
+    private checkDuplicatedRows;
+    private keyPattern;
+    private keyDuplicated;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LabelsEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LabelsEditorComponent, "acl-labels-editor", never, {}, {}, never, never, true, never>;
+}
+interface Pair {
+    key: string;
+    value: string;
+}
+export {};

package/form/taints-editor/component.d.ts

@@ -0,0 +1,22 @@
+import { AbstractControl } from '@angular/forms';
+import { TaintEffect } from '../../core';
+import * as i0 from "@angular/core";
+declare const TaintsEditorComponent_base: new () => import("../../core").BaseNestedFormControl<Taint[], Taint[]>;
+export declare class TaintsEditorComponent extends TaintsEditorComponent_base {
+    effects: TaintEffect[];
+    addTaint(): void;
+    editTaint(index: number, key: keyof Omit<Taint, 'effect'>, value: string): void;
+    editTaint(index: number, key: 'effect', value: TaintEffect): void;
+    removeTaint(index: number): void;
+    keyPattern(control: AbstractControl<string>): {
+        pattern: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaintsEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaintsEditorComponent, "acl-taints-editor", never, {}, {}, never, never, true, never>;
+}
+interface Taint {
+    key: string;
+    value: string;
+    effect: TaintEffect;
+}
+export {};

package/form/utils.d.ts

@@ -0,0 +1,40 @@
+import { FormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+interface Rule<T> {
+    source: T;
+    deps: string[];
+    isEnable: (...deps: unknown[]) => boolean;
+}
+/**
+ * @description
+ * 创建集群中存在大量的 control 依赖的情形，同时，由于业务特殊性，在 ipv4,ipv6 时要对表单控件进行不同外观的展示，因此控件的 disabled 变得很复杂
+ * 如果是在 ts 里通过 valueChanges 写：每个影响源都要写自己的 subscription，且某个 control 可能会收到多个其他 control 影响，届时逻辑组织会复杂很多,
+ * 如果是在模板里通过 aluControlDisabled 去写，可能会存在多个 control 要重复同一套逻辑，这点在创建集群中很常见，因此提供了如下方案，可以以声明式写法去描述依赖关系
+ *
+ * @usageNotes
+ * For example, for the following `FormGroup`:
+ * ```
+ * [
+ {
+ source: 'joinCIDR',
+ deps: ['networkType'],
+ isEnable: networkType => networkType === 'kube-ovn',
+ },
+ {
+ source: 'gatewayIPv6',
+ deps: ['networkType', 'transmitType', 'ipv6DualStack'],
+ isEnable: (networkType, transmitType, ipv6DualStack: boolean) =>
+ networkType === 'kube-ovn' &&
+ transmitType === 'underlay' &&
+ ipv6DualStack,
+ },
+ {
+ source: ['clusterCIDRIPv6', 'serviceCIDRIPv6'],
+ deps: ['ipv6DualStack'],
+ isEnable: (ipv6DualStack: boolean) => ipv6DualStack,
+ },
+ ]
+ * ```
+ */
+export declare function genControlDepsMap(context: FormGroup, rules: Array<Rule<string | string[]>>, destroy$: Observable<unknown>): void;
+export {};

package/form/validators/async-function-validator.directive.d.ts

@@ -0,0 +1,11 @@
+import { AbstractControl, AsyncValidator, AsyncValidatorFn } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class AsyncFunctionValidatorDirective implements AsyncValidator {
+    aclAsyncValidateFn: AsyncValidatorFn | AsyncValidatorFn[];
+    get asyncValidateFn(): AsyncValidatorFn;
+    onValidatorChange: () => void;
+    validate(control: AbstractControl): Promise<import("@angular/forms").ValidationErrors> | import("rxjs").Observable<import("@angular/forms").ValidationErrors>;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsyncFunctionValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AsyncFunctionValidatorDirective, "[aclAsyncValidateFn][ngModel],[aclAsyncValidateFn][formControl],[aclAsyncValidateFn][formControlName]", never, { "aclAsyncValidateFn": { "alias": "aclAsyncValidateFn"; "required": false; }; }, {}, never, never, false, never>;
+}

package/form/validators/dns1123-subdomain.d.ts

@@ -0,0 +1,28 @@
+import { AbstractControl } from '@angular/forms';
+/**
+ * https://kubernetes.io/zh/docs/concepts/overview/working-with-objects/names/
+  const dns1123LabelFmt string = "[a-z0-9]([-a-z0-9]*[a-z0-9])?"
+  const dns1123SubdomainFmt string = dns1123LabelFmt + "(\\." + dns1123LabelFmt + ")*"
+  const dns1123SubdomainErrorMsg string = "a lowercase RFC 1123 subdomain must consist of lower case alphanumeric characters, '-' or '.', and must start and end with an alphanumeric character"
+
+  // DNS1123SubdomainMaxLength is a subdomain's max length in DNS (RFC 1123)
+  const DNS1123SubdomainMaxLength int = 253
+
+  var dns1123SubdomainRegexp = regexp.MustCompile("^" + dns1123SubdomainFmt + "$")
+
+  // IsDNS1123Subdomain tests for a string that conforms to the definition of a
+  // subdomain in DNS (RFC 1123).
+  func IsDNS1123Subdomain(value string) []string {
+    var errs []string
+    if len(value) > DNS1123SubdomainMaxLength {
+      errs = append(errs, MaxLenError(DNS1123SubdomainMaxLength))
+    }
+    if !dns1123SubdomainRegexp.MatchString(value) {
+      errs = append(errs, RegexError(dns1123SubdomainErrorMsg, dns1123SubdomainFmt, "example.com"))
+    }
+    return errs
+  }
+ */
+export declare function DNS1123SubdomainValidator(ctrl: AbstractControl): {
+    domain: boolean;
+};

package/form/validators/function-validator.directive.d.ts

@@ -0,0 +1,11 @@
+import { AbstractControl, Validator, ValidatorFn } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class FunctionValidatorDirective implements Validator {
+    aclValidateFn: ValidatorFn | ValidatorFn[];
+    get validateFn(): ValidatorFn;
+    onValidatorChange: () => void;
+    validate(control: AbstractControl): import("@angular/forms").ValidationErrors;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FunctionValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FunctionValidatorDirective, "[aclValidateFn][ngModel],[aclValidateFn][formControl],[aclValidateFn][formControlName]", never, { "aclValidateFn": { "alias": "aclValidateFn"; "required": false; }; }, {}, never, never, false, never>;
+}

package/form/validators/maxlength-minlength-validator.directive.d.ts

@@ -0,0 +1,20 @@
+import { MaxLengthValidator, MinLengthValidator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * 功能和 MaxLengthValidator 完全一样，唯一的区别就是不设置 host maxlength attribute
+ * 使用场景：ngModel 的表单希望设置 maxlength validator 但不相限制输入框输入的字符。
+ * 比如产品希望最长 20 个字符，超过 20 个字符红色提醒
+ * https://github.com/angular/angular/blob/main/packages/forms/src/directives/validators.ts#L591
+ */
+export declare class MaxLengthValidatorDirective extends MaxLengthValidator {
+    aclMaxlength: string | number;
+    inputName: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaxLengthValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MaxLengthValidatorDirective, "[aclMaxlength][formControlName],[aclMaxlength][formControl],[aclMaxlength][ngModel]", never, { "aclMaxlength": { "alias": "aclMaxlength"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare class MinLengthValidatorDirective extends MinLengthValidator {
+    aclMinlength: string | number;
+    inputName: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinLengthValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MinLengthValidatorDirective, "[aclMinlength][formControlName],[aclMinlength][formControl],[aclMinlength][ngModel]", never, { "aclMinlength": { "alias": "aclMinlength"; "required": false; }; }, {}, never, never, false, never>;
+}

package/form/validators/module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./function-validator.directive";
+import * as i2 from "./async-function-validator.directive";
+import * as i3 from "./not-be-validator.directive";
+import * as i4 from "./one-of-validator.directive";
+import * as i5 from "./maxlength-minlength-validator.directive";
+import * as i6 from "@angular/common";
+import * as i7 from "./strong-password/strong-password-validator.module";
+export declare class ValidatorsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ValidatorsModule, [typeof i1.FunctionValidatorDirective, typeof i2.AsyncFunctionValidatorDirective, typeof i3.NotBeValidatorDirective, typeof i4.OneOfValidatorDirective, typeof i5.MaxLengthValidatorDirective, typeof i5.MinLengthValidatorDirective], [typeof i6.CommonModule, typeof i7.StrongPasswordValidatorModule], [typeof i1.FunctionValidatorDirective, typeof i2.AsyncFunctionValidatorDirective, typeof i3.NotBeValidatorDirective, typeof i4.OneOfValidatorDirective, typeof i5.MaxLengthValidatorDirective, typeof i5.MinLengthValidatorDirective, typeof i7.StrongPasswordValidatorModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ValidatorsModule>;
+}

package/form/validators/not-be-validator.directive.d.ts

@@ -0,0 +1,12 @@
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import * as i0 from "@angular/core";
+export type NotBeValue = string | RegExp;
+export declare class NotBeValidatorDirective implements Validator {
+    aclNotBe: NotBeValue | NotBeValue[];
+    notBeValues: NotBeValue[];
+    onValidatorChange: () => void;
+    validate(control: AbstractControl): ValidationErrors;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotBeValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NotBeValidatorDirective, "[aclNotBe][ngModel],[aclNotBe][formControl],[aclNotBe][formControlName]", never, { "aclNotBe": { "alias": "aclNotBe"; "required": false; }; }, {}, never, never, false, never>;
+}

package/form/validators/one-of-validator.directive.d.ts

@@ -0,0 +1,12 @@
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import * as i0 from "@angular/core";
+export type OneOfValue = string | RegExp;
+export declare class OneOfValidatorDirective implements Validator {
+    aclOneOf: OneOfValue | OneOfValue[];
+    oneOfValues: OneOfValue[];
+    onValidatorChange: () => void;
+    validate(control: AbstractControl): ValidationErrors;
+    registerOnValidatorChange(fn: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OneOfValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<OneOfValidatorDirective, "[aclOneOf][ngModel],[aclOneOf][formControl],[aclOneOf][formControlName]", never, { "aclOneOf": { "alias": "aclOneOf"; "required": false; }; }, {}, never, never, false, never>;
+}

package/form/validators/public-api.d.ts

@@ -0,0 +1,10 @@
+export * from './module';
+export * from './utils';
+export * from './dns1123-subdomain';
+export * from './resource-limit';
+export * from './strong-password';
+export * from './not-be-validator.directive';
+export * from './one-of-validator.directive';
+export * from './function-validator.directive';
+export * from './async-function-validator.directive';
+export * from './maxlength-minlength-validator.directive';

package/form/validators/resource-limit.d.ts

@@ -0,0 +1,16 @@
+import { AbstractControl, AsyncValidatorFn, ValidatorFn } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { LimitRange, LimitRangeItem, RESOURCE_MAC_TYPES } from '../../core';
+import { TranslateService } from '../../translate/public-api';
+export type AvailableResourceType = (typeof RESOURCE_MAC_TYPES)[number];
+export interface ResourceControl {
+    value: string;
+    unit: string;
+}
+export declare function setupErrorMapper(resource: LimitRange, translate: TranslateService): {
+    cpu_max: string;
+    memory_max: string;
+};
+export declare const getResourceLimitValidatorFn: (type: AvailableResourceType, limitRange: Omit<LimitRangeItem, 'type'>, unit?: string) => ValidatorFn;
+export declare function getResourceLimitAsyncValidatorFn(type: AvailableResourceType, limitRange$: Observable<LimitRange>, unit?: string): AsyncValidatorFn;
+export declare const initGreaterValidator: (type: AvailableResourceType, control: AbstractControl) => import("rxjs").Subscription;

package/form/validators/strong-password/index.d.ts

@@ -0,0 +1,3 @@
+export * from './strong-password-tooltip';
+export * from './strong-password-validator.directive';
+export * from './strong-password-validator.module';

package/form/validators/strong-password/strong-password-tooltip/component.d.ts

@@ -0,0 +1,6 @@
+import { TooltipComponent } from '@alauda/ui';
+import * as i0 from "@angular/core";
+export declare class StrongPasswordTooltipComponent extends TooltipComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StrongPasswordTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StrongPasswordTooltipComponent, "ng-component", never, {}, {}, never, never, false, never>;
+}

package/form/validators/strong-password/strong-password-tooltip/index.d.ts

@@ -0,0 +1 @@
+export * from './component';

package/form/validators/strong-password/strong-password-validator.directive.d.ts

@@ -0,0 +1,34 @@
+import { BaseTooltip } from '@alauda/ui';
+import { Overlay } from '@angular/cdk/overlay';
+import { ChangeDetectorRef, ElementRef, NgZone, Renderer2, ViewContainerRef, OnChanges } from '@angular/core';
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import { StrongPasswordTooltipComponent } from './strong-password-tooltip/component';
+import * as i0 from "@angular/core";
+export declare class StrongPasswordDirective extends BaseTooltip implements Validator, OnChanges {
+    private _enabled;
+    set enabled(enabled: boolean | '');
+    get enabled(): boolean;
+    private _required;
+    set required(required: boolean | '');
+    get required(): boolean;
+    specialChars: string;
+    minlength: number;
+    maxlength: number;
+    notStartsWith: string;
+    protected componentClass: typeof StrongPasswordTooltipComponent;
+    registerOnValidatorChange(fn: () => void): void;
+    ngOnChanges(): void;
+    onValidatorChange: () => void;
+    constructor(overlay: Overlay, viewContainerRef: ViewContainerRef, elRef: ElementRef<HTMLInputElement>, renderer: Renderer2, cdr: ChangeDetectorRef, ngZone: NgZone);
+    protected onFocus(): void;
+    validate: (control: AbstractControl) => ValidationErrors;
+    private resetContext;
+    private readonly validatePattern;
+    private readonly validateLength;
+    private readonly validateEnglishChar;
+    private readonly validateNumber;
+    private readonly validateSpecialChar;
+    private readonly validateNotStartsWith;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StrongPasswordDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StrongPasswordDirective, "input[aclStrongPassword][ngModel],input[aclStrongPassword][formControl],input[aclStrongPassword][formControlName]", never, { "enabled": { "alias": "aclStrongPassword"; "required": false; }; "required": { "alias": "required"; "required": false; }; "specialChars": { "alias": "specialChars"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "notStartsWith": { "alias": "notStartsWith"; "required": false; }; }, {}, never, never, false, never>;
+}

package/form/validators/strong-password/strong-password-validator.module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./strong-password-tooltip/component";
+import * as i2 from "./strong-password-validator.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/forms";
+import * as i5 from "@alauda/ui";
+import * as i6 from "../../../translate/translate.module";
+export declare class StrongPasswordValidatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<StrongPasswordValidatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<StrongPasswordValidatorModule, [typeof i1.StrongPasswordTooltipComponent, typeof i2.StrongPasswordDirective], [typeof i3.CommonModule, typeof i4.FormsModule, typeof i4.ReactiveFormsModule, typeof i5.IconModule, typeof i6.TranslateModule], [typeof i1.StrongPasswordTooltipComponent, typeof i2.StrongPasswordDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StrongPasswordValidatorModule>;
+}

package/form/validators/utils.d.ts

@@ -0,0 +1,57 @@
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import { TranslateService } from '../../translate/translate.service';
+export declare const STRONG_PASSWORD_SPECIAL_CHARS = "~!@#$%^&*()-_=+?";
+export declare function randomPassword({ length, symbols, }?: {
+    length?: number;
+    symbols?: string;
+}): string;
+export declare function k8sResourceLabelKeyValidator(control: AbstractControl): ValidationErrors | null;
+export declare const k8sResourceAnnotationKeyValidator: typeof k8sResourceLabelKeyValidator;
+export declare const k8sResourceLabelValueValidator: import("@angular/forms").ValidatorFn;
+export declare const k8sResourceLabelValidator: {
+    key: typeof k8sResourceLabelKeyValidator;
+    value: import("@angular/forms").ValidatorFn;
+};
+export declare const k8sResourceAnnotationValidator: {
+    key: typeof k8sResourceLabelKeyValidator;
+};
+export declare const getK8sResourceLabelErrorMapper: (translate: TranslateService) => {
+    key: {
+        namePattern: string;
+        prefixPattern: string;
+        nameTooLong: string;
+        prefixTooLong: string;
+    };
+    value: {
+        pattern: string;
+        maxlength: string;
+    };
+};
+export declare const getK8sResourceLabelErrorMapper$: (translate: TranslateService) => import("rxjs").Observable<{
+    key: {
+        namePattern: string;
+        prefixPattern: string;
+        nameTooLong: string;
+        prefixTooLong: string;
+    };
+    value: {
+        pattern: string;
+        maxlength: string;
+    };
+}>;
+export declare const getK8sResourceAnnotationErrorMapper: (translate: TranslateService) => {
+    key: {
+        namePattern: string;
+        prefixPattern: string;
+        nameTooLong: string;
+        prefixTooLong: string;
+    };
+};
+export declare const getK8sResourceAnnotationErrorMapper$: (translate: TranslateService) => import("rxjs").Observable<{
+    key: {
+        namePattern: string;
+        prefixPattern: string;
+        nameTooLong: string;
+        prefixTooLong: string;
+    };
+}>;

package/graph-canvas/components/graph-actions.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class GraphActionsComponent {
+    position: string;
+    get positionClass(): Record<string, boolean>;
+    handleMouseDown(e: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraphActionsComponent, "acl-graph-actions", never, { "position": { "alias": "position"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/graph-canvas/components/graph-canvas.component.d.ts

@@ -0,0 +1,47 @@
+import { AfterViewInit, EventEmitter, OnInit } from '@angular/core';
+import { GraphStoreService } from '../graph-store.service';
+import { OriginX, OriginY, TransformAction, TransformState } from '../types';
+import * as i0 from "@angular/core";
+export declare class GraphCanvasComponent implements OnInit, AfterViewInit {
+    private readonly graphStore;
+    minScale: number;
+    maxScale: number;
+    originX: OriginX;
+    originY: OriginY;
+    boundary: number;
+    loading: boolean;
+    loadFailed: boolean;
+    retry: EventEmitter<void>;
+    private readonly canvasRef;
+    private readonly surfaceRef;
+    private readonly getCanvasRect;
+    private readonly getSurfaceRect;
+    private dragStartPoint;
+    transformState: TransformState;
+    get dragging(): boolean;
+    get canvasStyle(): {
+        padding: string;
+        justifyContent: string;
+        alignItems: string;
+        cursor: string;
+    };
+    get surfaceStyle(): {
+        transformOrigin: string;
+        transform: string;
+    };
+    constructor(graphStore: GraphStoreService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    handleWheelEvent(e: WheelEvent): void;
+    handleMouseDown(e: MouseEvent): void;
+    handleMouseMove(e: MouseEvent): void;
+    handleMouseUp(): void;
+    zoomByWheel(v: number, pointerPosition: [number, number]): void;
+    zoomByDefaultStep(direction: 'in' | 'out'): void;
+    zoomOriginal(): void;
+    zoomOverview(): void;
+    move(x: number, y: number): void;
+    dispatchTransform(action: TransformAction): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphCanvasComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraphCanvasComponent, "acl-graph-canvas", never, { "minScale": { "alias": "minScale"; "required": false; }; "maxScale": { "alias": "maxScale"; "required": false; }; "originX": { "alias": "originX"; "required": false; }; "originY": { "alias": "originY"; "required": false; }; "boundary": { "alias": "boundary"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "loadFailed": { "alias": "loadFailed"; "required": false; }; }, { "retry": "retry"; }, never, ["*", "acl-graph-links", "acl-graph-actions"], false, never>;
+}

package/graph-canvas/components/graph-link.component.d.ts

@@ -0,0 +1,26 @@
+import { ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { GraphStoreService } from '../graph-store.service';
+import { Points, NodeID } from '../types';
+import * as i0 from "@angular/core";
+export declare class GraphLinkComponent implements OnDestroy {
+    private readonly store;
+    private readonly cdr;
+    from: NodeID;
+    to: NodeID;
+    direction: 'h' | 'v';
+    radius: number;
+    arrow: boolean;
+    color: string;
+    path: (points: Points) => string;
+    parallelDirection: (a: number, b: number, al: number, bl: number) => [number, number];
+    verticalDirection: (a: number, b: number, al: number, bl: number) => [number, number];
+    private readonly onDestroy$$;
+    points: Points;
+    get arrowTransform(): string;
+    constructor(store: GraphStoreService, cdr: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    private findPoints;
+    unScale(points: Points): Points;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GraphLinkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GraphLinkComponent, "g[aclGraphLink]", never, { "from": { "alias": "from"; "required": false; }; "to": { "alias": "to"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "radius": { "alias": "radius"; "required": false; }; "arrow": { "alias": "arrow"; "required": false; }; "color": { "alias": "color"; "required": false; }; "path": { "alias": "path"; "required": false; }; "parallelDirection": { "alias": "parallelDirection"; "required": false; }; "verticalDirection": { "alias": "verticalDirection"; "required": false; }; }, {}, never, never, false, never>;
+}