@alauda-fe/common 1.4.28-beta.6 → 1.4.28

package/array-form-table/form/component.d.ts

@@ -83,7 +83,7 @@ export declare class ArrayFormTableComponent implements OnDestroy {
     addDisabled: boolean | '';
     actionColumnDivider: boolean | '';
     showZeroState: boolean;
-    get formDirective(): FormGroupDirective | NgForm;
+    get formDirective(): NgForm | FormGroupDirective;
     /**
      * 自定义是否展示错误内容
      * 例如 control 是 FormGroup，只有在内部子 control 错误时才需要展示错误内容

package/code/code-editor-configs.d.ts

@@ -15,5 +15,7 @@ export declare const commonOptions: IEditorConstructionOptions;
 export declare const readonlyOptions: IEditorConstructionOptions;
 export declare const yamlReadOptions: IEditorConstructionOptions;
 export declare const yamlWriteOptions: IEditorConstructionOptions;
+export declare const yamlWriteMinimapOptions: IEditorConstructionOptions;
+export declare const yamlReadMinimapOptions: IEditorConstructionOptions;
 export declare const textWriteOptions: IEditorConstructionOptions;
 export declare const logsReadOptions: IEditorConstructionOptions;

package/code/managed-fields-folder.util.d.ts

@@ -0,0 +1,35 @@
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api';
+/**
+ * 自动折叠 managedFields 字段
+ * @param monacoEditor Monaco 编辑器实例
+ */
+export declare function foldManagedFields(monacoEditor: editor.IStandaloneCodeEditor): void;
+/**
+ * 编辑器实例获取器接口
+ */
+export interface EditorInstanceProvider {
+    getEditorInstance(): editor.IStandaloneCodeEditor | null;
+}
+/**
+ * ManagedFields 自动折叠器
+ * 用于在内容变化时自动折叠 managedFields 字段
+ */
+export declare class ManagedFieldsAutoFolder {
+    private subscription?;
+    private lastFoldedContent;
+    /**
+     * 开始监听内容变化并自动折叠
+     * @param editorProvider 编辑器实例提供者
+     * @param contentObservable 内容变化的 Observable
+     */
+    startAutoFold(editorProvider: EditorInstanceProvider, contentObservable: any): void;
+    /**
+     * 停止自动折叠
+     */
+    stopAutoFold(): void;
+    /**
+     * 手动执行一次折叠
+     * @param editorProvider 编辑器实例提供者
+     */
+    foldOnce(editorProvider: EditorInstanceProvider): void;
+}

package/code/public-api.d.ts

@@ -9,3 +9,7 @@ export * from './code-display-dialog/component';
 export * from './code-editor-configs';
 export * from './k8s-yaml-display-dialog/component';
 export * from './resource-yaml-display/component';
+export * from './resource-yaml-editor/component';
+export * from './yaml-sidebar/component';
+export * from './yaml-sidebar/types';
+export * from './yaml-examples';

package/code/resource-yaml-display/component.d.ts

@@ -1,20 +1,78 @@
+import { MonacoLanguageService } from '@alauda/code-editor';
+import { OnDestroy, AfterViewInit } from '@angular/core';
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api';
 import { BehaviorSubject, Observable } from 'rxjs';
-import { KubernetesResource, YamlUtilService, Arrayable } from '../../core/public-api';
+import { KubernetesSchemaService } from '../../core/services/kubernetes-schema.service';
+import { YamlUtilService } from '../../core/services/yaml-util.service';
+import { Arrayable } from '../../core/types/helpers';
+import { KubernetesResource } from '../../core/types/k8s/core';
+import { OpenAPIV3SchemaObject } from '../../core/types/schema';
+import { EditorInstanceProvider } from '../managed-fields-folder.util';
 import * as i0 from "@angular/core";
-export declare class ResourceYamlDisplayComponent<T extends KubernetesResource> {
-    private readonly yamlUtil;
+export declare class ResourceYamlDisplayComponent<T extends KubernetesResource> implements OnDestroy, AfterViewInit, EditorInstanceProvider {
+    readonly yamlUtil: YamlUtilService;
+    readonly schemaService: KubernetesSchemaService;
+    private readonly monacoLanguageService;
+    private destroy$;
     concise$$: BehaviorSubject<boolean>;
     reduce$$: BehaviorSubject<boolean>;
+    showSidebar$$: BehaviorSubject<boolean>;
+    showDebugPanel$$: BehaviorSubject<boolean>;
+    modelUri: string;
+    private yamlSchemaService;
+    private monacoEditor;
+    private registeredSchemas;
+    codeEditorRef: {
+        editor: editor.IStandaloneCodeEditor;
+    };
     hasWrapper: boolean;
+    showDebugInfo: boolean;
     conciseEnable: boolean;
     manageFieldActionEnable: boolean;
+    sidebarEnable: boolean;
+    schemaEnable: boolean;
+    exampleEnable: boolean;
+    autoFoldManagedFields: boolean;
+    schema: OpenAPIV3SchemaObject;
     resource: Arrayable<T>;
     readonly resource$: Observable<Arrayable<T>>;
-    constructor(yamlUtil: YamlUtilService);
+    readonly schema$: Observable<OpenAPIV3SchemaObject>;
+    minimap: boolean;
+    yamlReadMinimapOptions: import("../code-editor-configs").IEditorConstructionOptions;
+    yamlReadOptions: import("../code-editor-configs").IEditorConstructionOptions;
+    hasFolded: boolean;
+    /**
+     * 自动获取的 schema，当没有手动提供 schema 时使用
+     */
+    autoSchema$: Observable<OpenAPIV3SchemaObject>;
+    /**
+     * 最终使用的 schema，优先使用手动提供的，否则使用自动获取的
+     */
+    finalSchema$: Observable<OpenAPIV3SchemaObject>;
+    constructor(yamlUtil: YamlUtilService, schemaService: KubernetesSchemaService, monacoLanguageService: MonacoLanguageService);
     yaml$: Observable<string>;
-    editorOptions: import("../code-editor-configs").IEditorConstructionOptions;
+    get editorOptions(): import("../code-editor-configs").IEditorConstructionOptions;
     viewActions: import("@alauda/code-editor").CodeEditorActionsConfig;
     conciseChange(value: boolean): void;
+    toggleSidebar(): void;
+    toggleDebugInfo(): void;
+    getCurrentResource(): T | null;
+    getCurrentSchema(): OpenAPIV3SchemaObject | null;
+    selfFoldManagedFields(): void;
+    /**
+     * 设置 YAML schema 以提供 hover 提示和自动完成
+     */
+    setYamlSchema(resource: T, schema: OpenAPIV3SchemaObject): void;
+    ngAfterViewInit(): void;
+    /**
+     * 获取 Monaco Editor 实例
+     */
+    getEditorInstance(): editor.IStandaloneCodeEditor | null;
+    /**
+     * 自动折叠 managedFields 字段
+     */
+    foldManagedFields(): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ResourceYamlDisplayComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceYamlDisplayComponent<any>, "acl-resource-yaml-display", never, { "hasWrapper": { "alias": "hasWrapper"; "required": false; }; "conciseEnable": { "alias": "conciseEnable"; "required": false; }; "manageFieldActionEnable": { "alias": "manageFieldActionEnable"; "required": false; }; "resource": { "alias": "resource"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceYamlDisplayComponent<any>, "acl-resource-yaml-display", never, { "hasWrapper": { "alias": "hasWrapper"; "required": false; }; "showDebugInfo": { "alias": "showDebugInfo"; "required": false; }; "conciseEnable": { "alias": "conciseEnable"; "required": false; }; "manageFieldActionEnable": { "alias": "manageFieldActionEnable"; "required": false; }; "sidebarEnable": { "alias": "sidebarEnable"; "required": false; }; "schemaEnable": { "alias": "schemaEnable"; "required": false; }; "exampleEnable": { "alias": "exampleEnable"; "required": false; }; "autoFoldManagedFields": { "alias": "autoFoldManagedFields"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "resource": { "alias": "resource"; "required": false; }; "minimap": { "alias": "minimap"; "required": false; }; }, {}, never, never, true, never>;
 }

package/code/resource-yaml-editor/component.d.ts

@@ -0,0 +1,95 @@
+import { MonacoLanguageService } from '@alauda/code-editor';
+import { EventEmitter, OnDestroy, AfterViewInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { KubernetesSchemaService } from '../../core/services/kubernetes-schema.service';
+import { YamlUtilService } from '../../core/services/yaml-util.service';
+import { Arrayable } from '../../core/types/helpers';
+import { KubernetesResource } from '../../core/types/k8s/core';
+import { OpenAPIV3SchemaObject } from '../../core/types/schema';
+import { EditorInstanceProvider } from '../managed-fields-folder.util';
+import { YamlExample } from '../yaml-sidebar/types';
+import * as i0 from "@angular/core";
+export declare class ResourceYamlEditorComponent<T extends KubernetesResource> implements ControlValueAccessor, OnDestroy, EditorInstanceProvider, AfterViewInit {
+    readonly yamlUtil: YamlUtilService;
+    readonly schemaService: KubernetesSchemaService;
+    private readonly monacoLanguageService;
+    private destroy$;
+    private _value;
+    private _originalValue;
+    private onChange;
+    private onTouched;
+    showSidebar$$: BehaviorSubject<boolean>;
+    showDebugPanel$$: BehaviorSubject<boolean>;
+    modelUri: string;
+    private yamlSchemaService;
+    private monacoEditor;
+    private registeredSchemas;
+    private codeEditorRef;
+    hasWrapper: boolean;
+    showDebugInfo: boolean;
+    sidebarEnable: boolean;
+    schema: OpenAPIV3SchemaObject;
+    schemaEnable: boolean;
+    exampleEnable: boolean;
+    resource: Arrayable<T>;
+    autoFoldManagedFields: boolean;
+    set originalValue(value: string);
+    get originalValue(): string;
+    options: import("../code-editor-configs").IEditorConstructionOptions;
+    actionsConfig: import("@alauda/code-editor").CodeEditorActionsConfig;
+    tryYaml: EventEmitter<string>;
+    readonly resource$: Observable<Arrayable<T>>;
+    readonly schema$: Observable<OpenAPIV3SchemaObject>;
+    autoFillNamespace: boolean;
+    extraExamples: YamlExample[];
+    hasFolded: boolean;
+    /**
+     * 自动获取的 schema，当没有手动提供 schema 时使用
+     */
+    autoSchema$: Observable<OpenAPIV3SchemaObject>;
+    /**
+     * 最终使用的 schema，优先使用手动提供的，否则使用自动获取的
+     */
+    finalSchema$: Observable<OpenAPIV3SchemaObject>;
+    constructor(yamlUtil: YamlUtilService, schemaService: KubernetesSchemaService, monacoLanguageService: MonacoLanguageService);
+    ngAfterViewInit(): void;
+    selfFoldManagedFields(): void;
+    get value(): string;
+    set value(val: string);
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    toggleSidebar(): void;
+    toggleDebugInfo(): void;
+    getCurrentResource(): T | null;
+    getCurrentSchema(): OpenAPIV3SchemaObject | null;
+    getDebugInfo(): {
+        hasResource: boolean;
+        resourceApiVersion: string;
+        resourceKind: string;
+        hasManualSchema: boolean;
+        workspaceHelperAvailable: boolean;
+        currentWorkspace: Readonly<{
+            project: string;
+            cluster: string;
+            namespace: string;
+        }>;
+    };
+    onTryYaml(yamlContent: string): void;
+    /**
+     * 设置 YAML schema 以提供 hover 提示和自动完成
+     */
+    setYamlSchema(resource: T, schema: OpenAPIV3SchemaObject): void;
+    /**
+     * 获取 Monaco 编辑器实例
+     */
+    getEditorInstance(): import('monaco-editor').editor.IStandaloneCodeEditor | null;
+    /**
+     * 手动折叠 managedFields
+     */
+    foldManagedFields(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceYamlEditorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceYamlEditorComponent<any>, "acl-resource-yaml-editor", never, { "hasWrapper": { "alias": "hasWrapper"; "required": false; }; "showDebugInfo": { "alias": "showDebugInfo"; "required": false; }; "sidebarEnable": { "alias": "sidebarEnable"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "schemaEnable": { "alias": "schemaEnable"; "required": false; }; "exampleEnable": { "alias": "exampleEnable"; "required": false; }; "resource": { "alias": "resource"; "required": false; }; "autoFoldManagedFields": { "alias": "autoFoldManagedFields"; "required": false; }; "originalValue": { "alias": "originalValue"; "required": false; }; "options": { "alias": "options"; "required": false; }; "actionsConfig": { "alias": "actionsConfig"; "required": false; }; "autoFillNamespace": { "alias": "autoFillNamespace"; "required": false; }; "extraExamples": { "alias": "extraExamples"; "required": false; }; }, { "tryYaml": "tryYaml"; }, never, never, true, never>;
+}

package/code/yaml-examples.d.ts

@@ -0,0 +1,8 @@
+import { YamlExample } from './yaml-sidebar/types';
+/**
+ * Kubernetes 资源的内置 YAML 示例
+ * 按照 apiVersion.kind 的格式组织
+ */
+export declare const BUILT_IN_YAML_EXAMPLES: {
+    [key: string]: YamlExample[];
+};

package/code/yaml-sidebar/component.d.ts

@@ -0,0 +1,57 @@
+import { HttpClient } from '@angular/common/http';
+import { OnInit, OnChanges, SimpleChanges, EventEmitter, ChangeDetectorRef } from '@angular/core';
+import { KubernetesSchemaService } from '../../core/services/kubernetes-schema.service';
+import { KubernetesResource } from '../../core/types/k8s/core';
+import { OpenAPIV3SchemaObject } from '../../core/types/schema';
+import { YamlExample } from './types';
+import * as i0 from "@angular/core";
+export declare class ResourceYamlSidebarComponent implements OnInit, OnChanges {
+    private schemaService;
+    private http;
+    private cdr;
+    resource: KubernetesResource;
+    schema: OpenAPIV3SchemaObject;
+    close: EventEmitter<void>;
+    tryYaml: EventEmitter<string>;
+    schemaEnable: boolean;
+    exampleEnable: boolean;
+    extraExamples: YamlExample[];
+    private readonly DEFINITIONS_PREFIX;
+    currentSchema: OpenAPIV3SchemaObject;
+    properties: {
+        [key: string]: OpenAPIV3SchemaObject;
+    };
+    path: string[];
+    resourceKind: string;
+    examples: YamlExample[];
+    hasSchema: boolean;
+    hasExamples: boolean;
+    constructor(schemaService: KubernetesSchemaService, http: HttpClient, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    refresh(): void;
+    private loadExamples;
+    private loadConsoleYAMLSamples;
+    drillDownToProperty(name: string): void;
+    navigateToPath(index: number): void;
+    hasNestedProperties(property: OpenAPIV3SchemaObject): boolean;
+    getPropertyType(property: OpenAPIV3SchemaObject): string;
+    isRequired(propertyName: string): boolean;
+    /**
+     * 检查属性是否有 $ref 引用或嵌套属性
+     */
+    hasViewableContent(property: OpenAPIV3SchemaObject): boolean;
+    /**
+     * 检查属性是否有 $ref 引用
+     */
+    hasRefProperty(property: OpenAPIV3SchemaObject): boolean;
+    /**
+     * 获取 $ref 引用的定义名称
+     */
+    getRefDefinitionName(property: OpenAPIV3SchemaObject): string;
+    tryExample(example: YamlExample): void;
+    downloadYaml(example: YamlExample): void;
+    processDescription(description: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceYamlSidebarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ResourceYamlSidebarComponent, "acl-resource-yaml-sidebar", never, { "resource": { "alias": "resource"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "schemaEnable": { "alias": "schemaEnable"; "required": false; }; "exampleEnable": { "alias": "exampleEnable"; "required": false; }; "extraExamples": { "alias": "extraExamples"; "required": false; }; }, { "close": "close"; "tryYaml": "tryYaml"; }, never, never, true, never>;
+}

package/code/yaml-sidebar/types.d.ts

@@ -0,0 +1,21 @@
+export interface YamlExample {
+    title: string;
+    description: string;
+    yaml: string;
+    snippet?: boolean;
+}
+export interface ConsoleYAMLSample {
+    metadata: {
+        name: string;
+    };
+    spec: {
+        title: string;
+        description: string;
+        yaml: string;
+        snippet?: boolean;
+        targetResource: {
+            apiVersion: string;
+            kind: string;
+        };
+    };
+}

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

@@ -21,7 +21,7 @@ export declare class BaseNestedFormControl<V, M = V> implements AfterViewInit, O
     protected asyncValidator: boolean;
     protected cdr: ChangeDetectorRef;
     protected destroy$$: Subject<void>;
-    protected hostForm: FormGroupDirective | NgForm;
+    protected hostForm: NgForm | FormGroupDirective;
     constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;

package/core/services/kubernetes-schema.service.d.ts

@@ -0,0 +1,44 @@
+import { Observable } from 'rxjs';
+import { OpenAPIV2Document } from '../types/openapi';
+import { OpenAPIV3SchemaObject } from '../types/schema';
+import { WorkspaceHelperService } from './workspace-helper.service';
+import * as i0 from "@angular/core";
+export declare class KubernetesSchemaService {
+    private readonly http;
+    readonly workspaceHelper: WorkspaceHelperService;
+    private initialized;
+    private readonly schemaCache;
+    private readonly schemaCache$$;
+    get definitions(): Record<string, OpenAPIV3SchemaObject>;
+    private ensureInitialized;
+    /**
+     * 获取当前集群的 OpenAPI schema
+     */
+    getOpenAPISchema(): Observable<OpenAPIV2Document | null>;
+    /**
+     * 根据 Kubernetes 资源类型获取对应的 schema
+     */
+    getResourceSchema(apiVersion: string, kind: string): Observable<OpenAPIV3SchemaObject | null>;
+    /**
+     * 获取所有可用的资源定义
+     */
+    getAllResourceDefinitions(): Observable<Record<string, OpenAPIV3SchemaObject> | null>;
+    /**
+     * 清理缓存
+     */
+    clearCache(): void;
+    /**
+     * 获取缓存状态
+     */
+    getCacheStatus(): Observable<Map<string, OpenAPIV2Document>>;
+    /**
+     * 检查 WorkspaceHelperService 是否可用
+     */
+    isWorkspaceHelperAvailable(): boolean;
+    /**
+     * 从 Kubernetes API 获取 OpenAPI schema
+     */
+    private fetchOpenAPISchema;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KubernetesSchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KubernetesSchemaService>;
+}

package/core/services/public-api.d.ts

@@ -4,6 +4,7 @@ export * from './custom-code-editor-intl.service';
 export * from './feature-gate.service';
 export * from './intercept-deactivate.service';
 export * from './k8s-util.service';
+export * from './kubernetes-schema.service';
 export * from './silently-navigate.service';
 export * from './time.service';
 export * from './ui-state.service';

package/core/types/openapi.d.ts

@@ -0,0 +1,37 @@
+import { OpenAPIV3SchemaObject } from './schema';
+export interface OpenAPIV2Document {
+    swagger: string;
+    info: {
+        title: string;
+        version: string;
+        description?: string;
+    };
+    host?: string;
+    basePath?: string;
+    schemes?: string[];
+    consumes?: string[];
+    produces?: string[];
+    paths: Record<string, any>;
+    definitions: Record<string, OpenAPIV3SchemaObject>;
+    parameters?: Record<string, any>;
+    responses?: Record<string, any>;
+    securityDefinitions?: Record<string, any>;
+    security?: any[];
+    tags?: any[];
+    externalDocs?: any;
+}
+export interface SchemaProperty {
+    name: string;
+    type: string;
+    description?: string;
+    required: boolean;
+    properties?: {
+        [key: string]: OpenAPIV3SchemaObject;
+    };
+    items?: OpenAPIV3SchemaObject;
+}
+export interface SchemaBreadcrumb {
+    name: string;
+    path: string[];
+    schema: OpenAPIV3SchemaObject;
+}

package/core/types/public-api.d.ts

@@ -5,6 +5,7 @@
  */
 export * from './commons';
 export * from './helpers';
+export * from './openapi';
 export * from './schema';
 export * from './resource-definitions';
 export * from './k8s/public-api';

package/esm2022/abnormal-page/abnormal-page.component.mjs

@@ -63,5 +63,5 @@ export class AbnormalPageComponent {
     </acl-page-guard>
   `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".description{color:rgb(var(--aui-color-secondary-text))}\n"] }]
     }], null, null); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(AbnormalPageComponent, { className: "AbnormalPageComponent" }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(AbnormalPageComponent, { className: "AbnormalPageComponent", filePath: "abnormal-page/abnormal-page.component.ts", lineNumber: 33 }); })();
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/array-form-table/form/component.mjs

@@ -531,5 +531,5 @@ export class ArrayFormTableComponent {
         }], rowDrop: [{
             type: Output
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ArrayFormTableComponent, { className: "ArrayFormTableComponent" }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(ArrayFormTableComponent, { className: "ArrayFormTableComponent", filePath: "array-form-table/form/component.ts", lineNumber: 130 }); })();
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/array-form-table/form/component.ts","../../../../../../libs/common/src/array-form-table/form/template.html"],"names":[],"mappings":"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","sourcesContent":["import { ButtonModule, IconModule, rgbColor, TooltipModule } from '@alauda/ui';\nimport { CdkDragDrop, DragDropModule } from '@angular/cdk/drag-drop';\nimport { AsyncPipe, NgForOf, NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  EventEmitter,\n  Injector,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  TemplateRef,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  FormArray,\n  FormGroup,\n  FormGroupDirective,\n  NgForm,\n} from '@angular/forms';\nimport { debounceTime, EMPTY, map, merge, startWith, Subject } from 'rxjs';\n\nimport { PurePipe } from '../../core/pipes/pure.pipe';\nimport { EFFECT_DIRECTIVE_MODULE } from '../../effect-directive/module';\nimport { TranslateModule } from '../../translate/public-api';\nimport { ZeroStateComponent } from '../../widget/zero-state/zero-state.component';\n\nexport const ARRAY_TABLE_FORM_ERROR_BG = rgbColor('r-6');\n\nexport const rowBackgroundColorFn = <T extends AbstractControl>({\n  invalid,\n}: T): string => (invalid ? ARRAY_TABLE_FORM_ERROR_BG : '');\n\nexport const noShowRowError = () => false;\n\n@Directive({\n  selector: '[aclArrayFormTableHeader]',\n  standalone: true,\n})\nexport class ArrayFormTableHeaderDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclArrayFormTableRowError]',\n  standalone: true,\n})\nexport class ArrayFormTableRowErrorDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclArrayFormTableRow]',\n  standalone: true,\n})\nexport class ArrayFormTableRowDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclArrayFormTableZeroState]',\n  standalone: true,\n})\nexport class ArrayFormTableZeroStateDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclArrayFormTableRowControl]',\n  standalone: true,\n})\nexport class ArrayFormTableRowControlDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclArrayFormTableRowSeparator]',\n  standalone: true,\n})\nexport class ArrayFormTableRowSeparatorDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n@Directive({\n  selector: '[aclArrayFormTableFooter]',\n  standalone: true,\n})\nexport class ArrayFormTableFooterDirective {\n  constructor(public templateRef: TemplateRef<any>) {}\n}\n\n// 递归验证 control 是否有问题，group 内部可能会有嵌套的情况\nfunction _isFormControlInvalid(control: AbstractControl) {\n  if (control instanceof FormGroup || control instanceof FormArray) {\n    return (\n      (control.dirty && !!control.errors) ||\n      Object.values(control.controls).some(_isFormControlInvalid)\n    );\n  }\n  return control.dirty && control.invalid;\n}\n\n@Component({\n  selector: 'acl-array-form-table',\n  templateUrl: './template.html',\n  // Since rows maybe updated without changing reference, we use Default here:\n  // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection\n  changeDetection: ChangeDetectionStrategy.Default,\n  imports: [\n    NgTemplateOutlet,\n    TooltipModule,\n    ZeroStateComponent,\n    ButtonModule,\n    IconModule,\n    NgIf,\n    NgForOf,\n    PurePipe,\n    AsyncPipe,\n    TranslateModule,\n    DragDropModule,\n    ...EFFECT_DIRECTIVE_MODULE,\n  ],\n  standalone: true,\n})\nexport class ArrayFormTableComponent implements OnDestroy {\n  @ContentChild(ArrayFormTableHeaderDirective, {\n    read: TemplateRef,\n    static: true,\n  })\n  headerTemplate: TemplateRef<any>;\n\n  // 用户可以提供多行模板, 但只有第一行有控制按键.\n  @ContentChildren(ArrayFormTableRowDirective, { read: TemplateRef })\n  rowTemplates: QueryList<TemplateRef<any>>;\n\n  @ContentChild(ArrayFormTableRowErrorDirective, { read: TemplateRef })\n  rowErrorTemplate: TemplateRef<any>;\n\n  /**\n   * 表单默认提供删除按键; 假如用户提供模板, 将使用用户的模板\n   */\n  @ContentChild(ArrayFormTableRowControlDirective, {\n    read: TemplateRef,\n    static: true,\n  })\n  rowControlTemplate: TemplateRef<any>;\n\n  /**\n   * 表单默认提供添加按键; 假如用户提供模板, 将使用用户的模板\n   */\n  @ContentChild(ArrayFormTableFooterDirective, {\n    read: TemplateRef,\n    static: true,\n  })\n  footerTemplate: TemplateRef<any>;\n\n  /**\n   * 表单默认为空数据提供无xxx的模板; 假如用户提供模板, 将使用用户的模板\n   */\n  @ContentChild(ArrayFormTableZeroStateDirective, {\n    read: TemplateRef,\n    static: false,\n  })\n  zeroStateTemplate: TemplateRef<any>;\n\n  /**\n   * 行之间的分隔区域自定义模板\n   */\n  @ContentChild(ArrayFormTableRowSeparatorDirective, {\n    read: TemplateRef,\n    static: false,\n  })\n  separatorTemplate: TemplateRef<any>;\n\n  /**\n   * 行之间的分隔区域，默认关闭\n   */\n  @Input()\n  rowSeparator = false;\n\n  @ContentChild(FormGroupDirective, { static: false })\n  ngFormGroupDirective: FormGroupDirective;\n\n  // Data context for rows.\n  @Input()\n  rows: any[];\n\n  @Input()\n  resourceName = null as string;\n\n  @Input()\n  resourceNameTranslated: string;\n\n  @Output()\n  add = new EventEmitter<void>();\n\n  @Output()\n  remove = new EventEmitter<number>(); // Returns the index to be removed\n\n  @Input()\n  readonly: boolean | '' = false;\n\n  @Input()\n  addDisabled: boolean | '' = false;\n\n  @Input()\n  actionColumnDivider: boolean | '' = false;\n\n  @Input()\n  showZeroState = true;\n\n  get formDirective() {\n    return (\n      this.injector.get(FormGroupDirective, null) ||\n      this.injector.get(NgForm, null)\n    );\n  }\n\n  /**\n   * 自定义是否展示错误内容\n   * 例如 control 是 FormGroup，只有在内部子 control 错误时才需要展示错误内容\n   */\n  @Input()\n  showRowError<T extends AbstractControl>(\n    control: T,\n    formDirective?: NgForm | FormGroupDirective,\n  ): boolean {\n    if (formDirective) {\n      return (\n        control.invalid &&\n        (formDirective.submitted || _isFormControlInvalid(control))\n      );\n    }\n\n    return false;\n  }\n\n  /**\n   * @deprecated use {@link showRowError} instead\n   */\n  @Input()\n  rowBackgroundColorFn<T extends AbstractControl>(\n    control: T,\n    formDirective?: NgForm | FormGroupDirective,\n  ): string {\n    return this.showRowError(control, formDirective)\n      ? ARRAY_TABLE_FORM_ERROR_BG\n      : null;\n  }\n\n  @Input()\n  minRow = 0;\n\n  @Input()\n  minRowTooltip = '';\n\n  @Input()\n  maxRow = Infinity;\n\n  @Input()\n  maxRowTooltip = '';\n\n  @Input() enableDrop = false;\n\n  @Output() rowDrop = new EventEmitter<CdkDragDrop<FormGroup[]>>();\n\n  destroy$$ = new Subject<void>();\n\n  cdr = this.injector.get(ChangeDetectorRef);\n\n  constructor(public injector: Injector) {}\n\n  ngOnDestroy(): void {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  drop(event: CdkDragDrop<FormGroup[]>) {\n    this.rowDrop.emit(event);\n  }\n\n  shouldShowRowError = (control: AbstractControl) => {\n    const { statusChanges = EMPTY, status } = control;\n\n    return (\n      this.formDirective\n        ? merge(statusChanges, this.formDirective.ngSubmit)\n        : statusChanges\n    ).pipe(\n      startWith(status),\n      debounceTime(0),\n      map(() => this.showRowError(control, this.formDirective)),\n    );\n  };\n}\n","<table\n  class=\"acl-array-form-table\"\n  [class.acl-array-form-table__readonly-mode]=\"readonly\"\n>\n  <thead *ngIf=\"headerTemplate\">\n    <tr>\n      <ng-container *ngTemplateOutlet=\"headerTemplate\"></ng-container>\n      <th\n        *ngIf=\"!readonly && minRow !== maxRow\"\n        class=\"acl-array-form-table__action-col\"\n      ></th>\n    </tr>\n  </thead>\n  <tbody\n    cdkDropList\n    (cdkDropListDropped)=\"drop($event)\"\n  >\n    <ng-container *ngFor=\"let row of rows; let index = index\">\n      <tr\n        *ngFor=\"let rowTemplate of rowTemplates; let templateIndex = index\"\n        cdkDrag\n        [class.acl-array-form-table__row-error]=\"\n          row | pure: shouldShowRowError | async\n        \"\n        [attr.rowtemplateindex]=\"templateIndex\"\n      >\n        <td [hidden]=\"!enableDrop\">\n          <aui-icon\n            class=\"tw-ml-8\"\n            icon=\"move\"\n            cdkDragHandle\n          ></aui-icon>\n        </td>\n        <ng-container\n          *ngTemplateOutlet=\"\n            rowTemplate;\n            context: { $implicit: row, index: index }\n          \"\n        ></ng-container>\n        <td\n          *ngIf=\"templateIndex === 0 && !readonly && minRow !== maxRow\"\n          class=\"acl-array-form-table__action-col\"\n          [class.acl-array-form-table__action-col-divider]=\"actionColumnDivider\"\n        >\n          <ng-container *ngIf=\"rowControlTemplate\">\n            <ng-container\n              *ngTemplateOutlet=\"\n                rowControlTemplate;\n                context: { $implicit: row, index: index }\n              \"\n            ></ng-container>\n          </ng-container>\n          <div\n            [auiTooltip]=\"minRowTooltip\"\n            [auiTooltipDisabled]=\"rows?.length > minRow || !minRowTooltip\"\n          >\n            <button\n              *ngIf=\"!rowControlTemplate\"\n              aui-button=\"text\"\n              type=\"button\"\n              [disabled]=\"rows?.length <= minRow\"\n              [square]=\"true\"\n              [plain]=\"true\"\n              (click)=\"remove.emit(index)\"\n            >\n              <aui-icon icon=\"minus_circle\"></aui-icon>\n            </button>\n          </div>\n        </td>\n      </tr>\n\n      <tr\n        *ngIf=\"rowErrorTemplate && !readonly\"\n        [class.acl-array-form-table__row-error]=\"\n          row | pure: shouldShowRowError | async\n        \"\n        [hidden]=\"!(row | pure: shouldShowRowError | async)\"\n      >\n        <ng-container\n          *ngTemplateOutlet=\"\n            rowErrorTemplate;\n            context: { $implicit: row, index: index }\n          \"\n        ></ng-container>\n      </tr>\n      <ng-container\n        *ngIf=\"\n          (rowSeparator || separatorTemplate) &&\n          rows?.length > 1 &&\n          index !== rows?.length - 1\n        \"\n      >\n        <tr class=\"acl-array-form-table__separator\">\n          <td colspan=\"100\">\n            @if (separatorTemplate) {\n              <ng-container\n                *ngTemplateOutlet=\"separatorTemplate\"\n              ></ng-container>\n            } @else {\n              <div class=\"tw-h-[8px]\"></div>\n            }\n          </td>\n        </tr>\n      </ng-container>\n    </ng-container>\n\n    <tr *ngIf=\"(!rows || rows.length === 0) && showZeroState\">\n      <td\n        colspan=\"100\"\n        style=\"padding: unset\"\n      >\n        <acl-zero-state\n          *ngIf=\"!zeroStateTemplate\"\n          [showEmptyIcon]=\"false\"\n          [zeroState]=\"true\"\n          [resourceName]=\"resourceName\"\n          [resourceNameTranslated]=\"resourceNameTranslated\"\n          [minHeight]=\"48\"\n        ></acl-zero-state>\n\n        <ng-container *ngIf=\"zeroStateTemplate\">\n          <ng-container *ngTemplateOutlet=\"zeroStateTemplate\"></ng-container>\n        </ng-container>\n      </td>\n    </tr>\n\n    <tr\n      *ngIf=\"!readonly && minRow !== maxRow\"\n      class=\"acl-array-form-table--row-action\"\n    >\n      <td colspan=\"100\">\n        <div class=\"acl-array-form-table__bottom-control-buttons\">\n          <ng-container *ngIf=\"footerTemplate\">\n            <ng-container *ngTemplateOutlet=\"footerTemplate\"></ng-container>\n          </ng-container>\n          <div\n            *ngIf=\"!footerTemplate\"\n            class=\"tw-flex tw-w-full\"\n            [auiTooltip]=\"maxRowTooltip\"\n            [auiTooltipDisabled]=\"rows?.length < maxRow || !maxRowTooltip\"\n          >\n            <button\n              aui-button=\"primary\"\n              type=\"button\"\n              [plain]=\"true\"\n              size=\"mini\"\n              (click)=\"add.emit()\"\n              [disabled]=\"rows?.length >= maxRow || addDisabled\"\n            >\n              <aui-icon icon=\"plus_circle\"></aui-icon>\n              {{ 'add' | translate }}\n            </button>\n          </div>\n        </div>\n      </td>\n    </tr>\n  </tbody>\n</table>\n"]}

package/esm2022/array-form-table/key-value-form/component.mjs

@@ -293,5 +293,5 @@ __decorate([
         }], zeroStateTemplate: [{
             type: Input
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(KeyValueFormTableComponent, { className: "KeyValueFormTableComponent" }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(KeyValueFormTableComponent, { className: "KeyValueFormTableComponent", filePath: "array-form-table/key-value-form/component.ts", lineNumber: 44 }); })();
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/common/src/array-form-table/key-value-form/component.ts","../../../../../../libs/common/src/array-form-table/key-value-form/template.html"],"names":[],"mappings":"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","sourcesContent":["import { ButtonModule, FormModule, IconModule, InputModule } from '@alauda/ui';\nimport { NgIf, NgTemplateOutlet } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  Input,\n  OnInit,\n  TemplateRef,\n} from '@angular/core';\nimport { FormArray, ReactiveFormsModule, ValidatorFn } from '@angular/forms';\nimport { sortBy } from 'lodash-es';\n\nimport { StringMap, ValueHook } from '../../core/public-api';\nimport { ValidateRowDuplicateService } from '../../core/services/form-row-duplicate/form-row-duplicate.service';\nimport { EffectDirectiveModule } from '../../effect-directive/module';\nimport { ErrorsMapperModule } from '../../form/public-api';\nimport { TranslateModule } from '../../translate/public-api';\nimport { BaseStringMapFormComponent } from '../base-string-map-form.component';\nimport { ArrayFormTableComponent } from '../form/component';\nimport { ArrayFormTableModule } from '../form/module';\n\n@Component({\n  selector: 'acl-key-value-form-table',\n  templateUrl: 'template.html',\n  styleUrls: ['styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [\n    ArrayFormTableModule,\n    ReactiveFormsModule,\n    ArrayFormTableComponent,\n    InputModule,\n    NgIf,\n    NgTemplateOutlet,\n    TranslateModule,\n    ErrorsMapperModule,\n    ButtonModule,\n    IconModule,\n    FormModule,\n    EffectDirectiveModule,\n  ],\n  standalone: true,\n  providers: [ValidateRowDuplicateService],\n})\nexport class KeyValueFormTableComponent\n  extends BaseStringMapFormComponent\n  implements OnInit\n{\n  @Input()\n  resourceName: string;\n\n  @Input()\n  resourceNameTranslated: string;\n\n  @Input()\n  multiLineValue: boolean;\n\n  @ValueHook(null, null, function (this: KeyValueFormTableComponent) {\n    this.form?.controls.forEach((formArray: FormArray) => {\n      const [key, value] = formArray.controls;\n      key.setValidators(this.getKeyValidators());\n      value.setValidators(this.getValueValidators());\n    });\n  })\n  @Input()\n  validator: {\n    key?: ValidatorFn | ValidatorFn[];\n    value?: ValidatorFn | ValidatorFn[];\n  } = {\n    key: [],\n    value: [],\n  };\n\n  @Input()\n  errorMapper: {\n    key?: StringMap;\n    value?: StringMap;\n  } = {\n    key: {},\n    value: {},\n  };\n\n  @Input()\n  placeholder: {\n    key?: string;\n    value?: string;\n  };\n\n  @Input()\n  readonly: boolean;\n\n  @Input()\n  textKey: boolean;\n\n  @Input()\n  maxRow = Infinity;\n\n  @Input()\n  minRow = 0;\n\n  @ValueHook<KeyValueFormTableComponent, 'readonlyKeys'>(Boolean)\n  @Input()\n  readonlyKeys: Array<string | RegExp> = [];\n\n  @Input()\n  zeroStateTemplate: TemplateRef<any>;\n\n  isReadonly(key: string) {\n    return this.readonlyKeys.some(toCheckKey => {\n      if (!toCheckKey) {\n        return false;\n      }\n      if (typeof toCheckKey === 'string') {\n        return toCheckKey === key;\n      }\n\n      return toCheckKey.test(key);\n    });\n  }\n\n  getDataValueByIndex(index: number) {\n    return (this.form.at(index) as FormArray).at(1).value;\n  }\n\n  override adaptResourceModel(resource: { [key: string]: string }) {\n    let newFormModel = Object.entries(resource || {});\n    // 排序，先按字母排序，再把 readonly 的放前面\n    newFormModel = sortBy(newFormModel, (arr: [string, string]) => arr[0]);\n    newFormModel.sort((arr1: [string, string], arr2: [string, string]) => {\n      const flag1 = this.isReadonly(arr1[0]);\n      const flag2 = this.isReadonly(arr2[0]);\n      if ((flag1 && flag2) || (!flag1 && !flag2)) {\n        return 0;\n      }\n      return flag1 ? -1 : 1;\n    });\n    if (newFormModel.length === 0) {\n      newFormModel = this.getDefaultFormModel();\n    }\n\n    return newFormModel;\n  }\n\n  override getKeyValidators() {\n    return this.validator?.key;\n  }\n\n  override getValueValidators() {\n    return this.validator?.value;\n  }\n\n  isLabelReadonly(index: number) {\n    const formArray = this.form.controls[index] as FormArray;\n    return formArray.valid && this.isReadonly(formArray.controls[0].value);\n  }\n}\n","<acl-array-form-table\n  [resourceName]=\"resourceName\"\n  [resourceNameTranslated]=\"resourceNameTranslated\"\n  (add)=\"add(form.length)\"\n  (remove)=\"remove($event)\"\n  [rows]=\"form.controls\"\n  [formGroup]=\"$any(form)\"\n  [readonly]=\"readonly\"\n  [maxRow]=\"maxRow\"\n  [minRow]=\"minRow\"\n>\n  <ng-container *aclArrayFormTableHeader>\n    <th style=\"width: 33%\">{{ 'key' | translate }}</th>\n    <th style=\"width: 66%\">{{ 'value' | translate }}</th>\n  </ng-container>\n\n  <!-- Input row -->\n  <ng-container\n    *aclArrayFormTableRow=\"let control; let index = index\"\n    [formGroupName]=\"index\"\n  >\n    <td>\n      <input\n        [hidden]=\"textKey\"\n        (blur)=\"onBlur()\"\n        aui-input\n        [readonly]=\"readonly || isLabelReadonly(index)\"\n        formControlName=\"0\"\n        [placeholder]=\"placeholder?.key || ('key' | translate)\"\n      />\n      <ng-container *ngIf=\"textKey\">\n        {{ control.get('0').value }}\n      </ng-container>\n    </td>\n\n    <td>\n      <input\n        *ngIf=\"!multiLineValue\"\n        (blur)=\"onBlur()\"\n        aui-input\n        [readonly]=\"readonly || isLabelReadonly(index)\"\n        formControlName=\"1\"\n        [placeholder]=\"placeholder?.value || ('value' | translate)\"\n      />\n      <div\n        *ngIf=\"multiLineValue\"\n        class=\"textarea-wrapper\"\n        [attr.data-value]=\"getDataValueByIndex(index)\"\n      >\n        <textarea\n          (blur)=\"onBlur()\"\n          [readonly]=\"readonly || isLabelReadonly(index)\"\n          aui-input\n          formControlName=\"1\"\n          rows=\"1\"\n          [placeholder]=\"placeholder?.value || ('value' | translate)\"\n        ></textarea>\n      </div>\n    </td>\n  </ng-container>\n\n  <!-- Input error row -->\n  <ng-container *aclArrayFormTableRowError=\"let control\">\n    <td\n      *ngIf=\"control.invalid\"\n      colspan=\"3\"\n      class=\"acl-table-form-error-hint\"\n    >\n      <ng-container *ngIf=\"control.errors?.keyIsMissing\">\n        {{ 'k8s_resource_label_key_required' | translate }}\n      </ng-container>\n\n      <ng-container *ngIf=\"control.errors?.duplicateError\">\n        {{ 'k8s_resource_label_key_duplicated' | translate }}\n      </ng-container>\n\n      <acl-errors-mapper\n        auiFormItemError\n        [errors]=\"control.errors?.key\"\n        [errorsMapper]=\"errorMapper?.key\"\n      ></acl-errors-mapper>\n      <acl-errors-mapper\n        auiFormItemError\n        [errors]=\"control.errors?.value\"\n        [errorsMapper]=\"errorMapper?.value\"\n      ></acl-errors-mapper>\n    </td>\n  </ng-container>\n\n  <ng-container *aclArrayFormTableRowControl=\"let item; let index = index\">\n    <button\n      [hidden]=\"readonly || isLabelReadonly(index)\"\n      aui-button=\"text\"\n      type=\"button\"\n      [square]=\"true\"\n      [plain]=\"true\"\n      (click)=\"remove(index)\"\n    >\n      <aui-icon icon=\"minus_circle\"></aui-icon>\n    </button>\n  </ng-container>\n\n  <ng-container *ngIf=\"zeroStateTemplate\">\n    <ng-container *aclArrayFormTableZeroState>\n      <ng-template [ngTemplateOutlet]=\"zeroStateTemplate\"></ng-template>\n    </ng-container>\n  </ng-container>\n</acl-array-form-table>\n"]}

package/esm2022/array-form-table/key-value-table/component.mjs

@@ -70,5 +70,5 @@ export class KeyValueTableComponent {
         }], resourceNameTranslated: [{
             type: Input
         }] }); })();
-(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(KeyValueTableComponent, { className: "KeyValueTableComponent" }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(KeyValueTableComponent, { className: "KeyValueTableComponent", filePath: "array-form-table/key-value-table/component.ts", lineNumber: 27 }); })();
 //# sourceMappingURL=data:application/json;base64,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