@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.0

package/form/base-form-container.d.ts

@@ -0,0 +1,41 @@
+import { NotificationService } from '@alauda/ui';
+import { Location } from '@angular/common';
+import { Injector, OnInit } from '@angular/core';
+import { FormBuilder, FormGroup } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { InterceptDeactivateService } from '../page-deactivate';
+import * as i0 from "@angular/core";
+/**
+ * http://confluence.alauda.cn/display/FRON/Issue-Angular+related
+ * 由于formControl存在内存泄漏问题，内部 form 展示-隐藏切换应当采用 hidden 进行控制
+ */
+export declare abstract class BaseFormContainer<T = any> implements OnInit {
+    isUpdate: boolean;
+    initResource: T;
+    initResource$: Observable<T>;
+    private readonly ngForm;
+    codeEditorOptions: import("../code-editor/code-editor-configs").IEditorConstructionOptions;
+    actionsConfig: import("@alauda/code-editor").CodeEditorActionsConfig;
+    formView: 'UI' | 'YAML';
+    submitting: boolean;
+    resource: T;
+    yaml: string;
+    originalYaml: string;
+    fb: FormBuilder;
+    interceptDeactivate: InterceptDeactivateService;
+    form: FormGroup;
+    protected notification: NotificationService;
+    protected location: Location;
+    protected fillResource: (resource: T) => T;
+    abstract submit(params?: unknown): void;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    switchFormView(view: 'YAML' | 'UI'): void;
+    cancel(escape?: boolean): void;
+    protected checkForm(): boolean;
+    protected yamlToResource(yaml: string): T;
+    protected resourceToYaml(resource: T): string;
+    protected updateResource(resource: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormContainer<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFormContainer<any>, never, never, { "isUpdate": { "alias": "isUpdate"; "required": false; }; "initResource": { "alias": "initResource"; "required": false; }; }, {}, never, never, false, never>;
+}

package/form/base-nested-form-control.d.ts

@@ -0,0 +1,58 @@
+import { AfterViewInit, ChangeDetectorRef, OnDestroy, QueryList } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, FormGroupDirective, NgControl, NgForm, ValidationErrors } from '@angular/forms';
+import { ReplaySubject, Subject, Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare function createNestedFormControl<V, M = V>({ autoEmitChange, asyncValidator, }?: {
+    autoEmitChange?: boolean;
+    asyncValidator?: boolean;
+}): new () => BaseNestedFormControl<V, M>;
+export declare class BaseNestedFormControl<V, M = V> implements AfterViewInit, OnDestroy, ControlValueAccessor {
+    protected controls: QueryList<NgControl>;
+    get disabled(): boolean | '';
+    set disabled(val: boolean | '');
+    private _disabled;
+    onValidatorChange: () => void;
+    onChange: (_: V) => void;
+    onTouched: () => void;
+    onSubmitted: () => void;
+    model: M;
+    submitted: boolean;
+    protected autoEmitChange: boolean;
+    protected asyncValidator: boolean;
+    protected cdr: ChangeDetectorRef;
+    protected destroy$$: Subject<void>;
+    protected hostForm: NgForm | FormGroupDirective;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    registerOnValidatorChange(fn: () => void): void;
+    registerOnChange(fn: (_: V) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: V): void;
+    validate(_control?: AbstractControl): ValidationErrors | null | Observable<ValidationErrors | null>;
+    emitModel(model?: M): void;
+    emitValue(value: V): void;
+    protected valueIn(value: V): M;
+    protected modelOut(model: M): V;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseNestedFormControl<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseNestedFormControl<any, any>, never, never, { "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, false, never>;
+}
+/**
+ * @deprecated use {@link BaseNestedFormControl} instead.
+ */
+export declare class BaseNestedFormControlPure<V, M = V> extends BaseNestedFormControl<V, M> {
+    model$: ReplaySubject<M>;
+    constructor();
+    writeValue(value: V): void;
+    emitValue(value: V): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseNestedFormControlPure<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseNestedFormControlPure<any, any>, never, never, {}, {}, never, never, false, never>;
+}
+type Path = string | Array<string | number>;
+interface Mapper {
+    [x: string]: Mapper | Path;
+}
+export declare function dataTransfer<S extends object, T extends object, M extends Record<keyof T, Path | Mapper> = Record<keyof T, Path | Mapper>>(mapper: M): [(source: S) => T, (target: T) => S];
+export declare function copyValue<T extends object>(from: Path, to: Path, mapper?: (v: any) => any): (object: T) => T;
+export {};

package/form/errors-mapper/base-errors-mapper.d.ts

@@ -0,0 +1,13 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { Injector } from '@angular/core';
+import { StringMap } from '../../types';
+import { ErrorMapperInterface, ErrorsMapperFn } from './types';
+import * as i0 from "@angular/core";
+export declare abstract class BaseErrorsMapper {
+    translate: TranslateService;
+    mapperService: ErrorMapperInterface;
+    protected getErrorMessage(errors: Record<string, any>, errorsMapper?: StringMap, errorsMapperFn?: ErrorsMapperFn, namePrefix?: string, ignoreUnknownError?: boolean): string;
+    constructor(injector: Injector);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseErrorsMapper, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseErrorsMapper, never, never, {}, {}, never, never, false, never>;
+}

package/form/errors-mapper/default-errors-mapper.service.d.ts

@@ -0,0 +1,10 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { ErrorMapperInterface } from './types';
+import * as i0 from "@angular/core";
+export declare class DefaultErrorsMapperService implements ErrorMapperInterface {
+    private readonly translate;
+    constructor(translate: TranslateService);
+    map(key: string, error: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultErrorsMapperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultErrorsMapperService>;
+}

package/form/errors-mapper/errors-mapper-component/component.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { StringMap } from '../../../types';
+import { BaseErrorsMapper } from '../base-errors-mapper';
+import { ErrorsMapperFn } from '../types';
+import * as i0 from "@angular/core";
+export declare class ErrorsMapperComponent extends BaseErrorsMapper {
+    errors: Record<string, boolean>;
+    readonly errors$: Observable<Record<string, boolean>>;
+    errorsMapper: StringMap;
+    readonly errorsMapper$: Observable<StringMap>;
+    errorsMapperFn: ErrorsMapperFn;
+    readonly errorsMapperFn$: Observable<ErrorsMapperFn>;
+    controlName: string;
+    readonly controlName$: Observable<string>;
+    ignoreUnknownError: boolean;
+    readonly errorMessage$: Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorsMapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorsMapperComponent, "acl-errors-mapper", never, { "errors": { "alias": "errors"; "required": false; }; "errorsMapper": { "alias": "errorsMapper"; "required": false; }; "errorsMapperFn": { "alias": "errorsMapperFn"; "required": false; }; "controlName": { "alias": "controlName"; "required": false; }; "ignoreUnknownError": { "alias": "ignoreUnknownError"; "required": false; }; }, {}, never, ["*"], true, never>;
+}

package/form/errors-mapper/errors-mapper.directive.d.ts

@@ -0,0 +1,39 @@
+import { AfterViewInit, ApplicationRef, ChangeDetectorRef, ComponentFactoryResolver, Injector, OnDestroy } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { StringMap } from '../../types';
+import { BaseErrorsMapper } from './base-errors-mapper';
+import { ErrorsMapperFn } from './types';
+import * as i0 from "@angular/core";
+export declare class ErrorsMapperDirective extends BaseErrorsMapper implements AfterViewInit, OnDestroy {
+    injector: Injector;
+    private readonly cdr;
+    private readonly cfr;
+    private readonly appRef;
+    private readonly control;
+    private readonly ngForm;
+    private readonly formGroup;
+    aclErrorsMapper: StringMap | '';
+    aclErrorsMapperFn: ErrorsMapperFn;
+    aclErrorsMapperDisabled: boolean;
+    /**
+     * disable errors mapper
+     */
+    aclErrorsMapperDisabled$: Observable<boolean>;
+    /**
+     * specify outlet, consider this other than specific control entity to make sure di can always get ngForm
+     */
+    aclErrorsMapperOutlet: Element;
+    aclErrorsMapperControlName: string;
+    private portal;
+    private portalHost;
+    private portalAttach;
+    private readonly destroy$;
+    constructor(injector: Injector, cdr: ChangeDetectorRef, cfr: ComponentFactoryResolver, appRef: ApplicationRef, control: NgControl, ngForm: NgForm, formGroup: FormGroupDirective);
+    ngAfterViewInit(): void;
+    updateContent(content: string): void;
+    initPortal(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorsMapperDirective, [null, null, null, null, { self: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ErrorsMapperDirective, "[aclErrorsMapper]", never, { "aclErrorsMapper": { "alias": "aclErrorsMapper"; "required": false; }; "aclErrorsMapperFn": { "alias": "aclErrorsMapperFn"; "required": false; }; "aclErrorsMapperDisabled": { "alias": "aclErrorsMapperDisabled"; "required": false; }; "aclErrorsMapperOutlet": { "alias": "aclErrorsMapperOutlet"; "required": false; }; "aclErrorsMapperControlName": { "alias": "aclErrorsMapperControlName"; "required": false; }; }, {}, never, never, true, never>;
+}

package/form/errors-mapper/index.d.ts

@@ -0,0 +1,6 @@
+import { ErrorsMapperComponent } from './errors-mapper-component/component';
+import { ErrorsMapperDirective } from './errors-mapper.directive';
+export * from './errors-mapper-component/component';
+export * from './errors-mapper.directive';
+export * from './types';
+export declare const ERRORS_MAPPER_MODULE: readonly [typeof ErrorsMapperComponent, typeof ErrorsMapperDirective];

package/form/errors-mapper/types.d.ts

@@ -0,0 +1,16 @@
+import { StringMap } from '../../types';
+/**
+ * Defines how a error object (validator key, error object, the control object) should be mapped to string.
+ */
+export interface ErrorMapperInterface {
+    /**
+     * Maps an error to a string.
+     * @param {string} key the error key. i.e., required, etc
+     * @param error the error object
+     * @param control control Object (AbstractControl for Angular, NgModel for AngularJS)
+     * @returns {string}
+     */
+    map(key: string, error?: unknown, control?: unknown): string;
+}
+export type ErrorsMapperFn = (error: Record<string, unknown>) => string;
+export type ErrorMapper = ErrorMapperInterface | StringMap;

package/form/index.d.ts

@@ -0,0 +1,5 @@
+export * from './validators';
+export * from './errors-mapper';
+export { genControlDepsMap } from './utils';
+export * from './base-form-container';
+export * from './base-nested-form-control';

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, true, 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, true, never>;
+}

package/form/validators/index.d.ts

@@ -0,0 +1,9 @@
+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/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, true, 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, true, never>;
+}

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, true, 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, true, never>;
+}

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

@@ -0,0 +1,17 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { AbstractControl, AsyncValidatorFn, ValidatorFn } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { LimitRange, LimitRangeItem } from '../../types';
+import { RESOURCE_MAC_TYPES } from '../../utils';
+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/component';
+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-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 aclStrongPassword(enabled: boolean | '');
+    get aclStrongPassword(): 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, { "aclStrongPassword": { "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 "@alauda-fe/dynamic-plugin-sdk";
+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.TranslatePipe], [typeof i1.StrongPasswordTooltipComponent, typeof i2.StrongPasswordDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<StrongPasswordValidatorModule>;
+}

package/form/validators/utils.d.ts

@@ -0,0 +1,67 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+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;
+    };
+}>;
+export declare const CRON_FORMAT_ERROR = "cronFormatError";
+export declare const CRON_MIN_INTERVAL_ERROR = "cronMinIntervalError";
+export declare function cronValidator(minInterval?: number): (control: AbstractControl) => ValidationErrors | null;
+export declare function cronValidatorBasic(value: string, minInterval?: number): {
+    cronFormatError: boolean;
+    cronMinIntervalError?: undefined;
+} | {
+    cronMinIntervalError: boolean;
+    cronFormatError?: undefined;
+};

package/index.d.ts

@@ -0,0 +1,14 @@
+export * from './types';
+export * from './constants';
+export * from './utils';
+export * from './services';
+export * from './pipes';
+export * from './directives';
+export * from './components';
+export * from './k8s-resource-list';
+export * from './k8s-shared';
+export * from './code-editor';
+export * from './form';
+export * from './array-form-table';
+export * from './async-data';
+export * from './page-deactivate';

package/k8s-resource-list/footer/component.d.ts

@@ -0,0 +1,42 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { OnDestroy, OnInit, TemplateRef, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ScrollBorderObserverDirective } from '../../directives';
+import { KubernetesResource, KubernetesResourceList } from '../../types';
+import { StreamListLoader } from '../types';
+import * as i0 from "@angular/core";
+export declare class K8sListFooterNoDataDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sListFooterNoDataDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<K8sListFooterNoDataDirective, "[aclK8sListFooterNoData]", never, {}, {}, never, never, true, never>;
+}
+export declare class K8sListFooterLoadingErrorDirective {
+    templateRef: TemplateRef<any>;
+    constructor(templateRef: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8sListFooterLoadingErrorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<K8sListFooterLoadingErrorDirective, "[aclK8sListFooterLoadingError]", never, {}, {}, never, never, true, never>;
+}
+export declare class K8SResourceListFooterComponent extends ScrollBorderObserverDirective implements OnInit, OnDestroy {
+    private readonly translate;
+    list: StreamListLoader<KubernetesResourceList, KubernetesResource>;
+    autoLoad: boolean;
+    backTop: boolean;
+    bottomDistance: number;
+    resourceNameTranslated: string;
+    firstScrollLoad: number;
+    resourceNameTranslated$: Observable<string>;
+    resourceName: string;
+    resourceName$: Observable<string>;
+    noDataTemplate: TemplateRef<any>;
+    loadingErrorTemplate: TemplateRef<any>;
+    isEmptyList$: Observable<boolean>;
+    noDataHint$: Observable<string>;
+    loadingErrorCode$: Observable<number>;
+    window: Window & typeof globalThis;
+    constructor(injector: Injector, translate: TranslateService);
+    ngOnInit(): void;
+    retry(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<K8SResourceListFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<K8SResourceListFooterComponent, "acl-k8s-resource-list-footer", never, { "list": { "alias": "list"; "required": false; }; "autoLoad": { "alias": "autoLoad"; "required": false; }; "backTop": { "alias": "backTop"; "required": false; }; "bottomDistance": { "alias": "bottomDistance"; "required": false; }; "resourceNameTranslated": { "alias": "resourceNameTranslated"; "required": false; }; "firstScrollLoad": { "alias": "firstScrollLoad"; "required": false; }; "resourceName": { "alias": "resourceName"; "required": false; }; }, {}, ["noDataTemplate", "loadingErrorTemplate"], never, true, never>;
+}

package/k8s-resource-list/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * [[include:k8s-resource-list/README.md]]
+ * @module k8s-resource-list
+ * @preferred
+ */
+/** imports */
+import { K8SResourceListFooterComponent, K8sListFooterNoDataDirective, K8sListFooterLoadingErrorDirective } from './footer/component';
+export * from './footer/component';
+export * from './k8s-resource-list';
+export * from './types';
+export * from './utils';
+export * from './k8s-resource-paged-list';
+export declare const K8S_RESOURCE_LIST_MODULE: readonly [typeof K8SResourceListFooterComponent, typeof K8sListFooterNoDataDirective, typeof K8sListFooterLoadingErrorDirective];