@alauda-fe/common 1.4.27 → 1.4.28-beta.1

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,76 @@
+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;
+    /**
+     * 自动获取的 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;
+    /**
+     * 设置 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,93 @@
+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[];
+    /**
+     * 自动获取的 schema，当没有手动提供 schema 时使用
+     */
+    autoSchema$: Observable<OpenAPIV3SchemaObject>;
+    /**
+     * 最终使用的 schema，优先使用手动提供的，否则使用自动获取的
+     */
+    finalSchema$: Observable<OpenAPIV3SchemaObject>;
+    constructor(yamlUtil: YamlUtilService, schemaService: KubernetesSchemaService, monacoLanguageService: MonacoLanguageService);
+    ngAfterViewInit(): 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/directives/scroll-to-first-invalid.directive.d.ts

@@ -13,7 +13,7 @@ export declare class ScrollToFirstInvalidDirective {
     private readonly cdkScrollable;
     labelOffset: number;
     aclScrollToFirstInvalid: boolean | '';
-    get containerEl(): HTMLElement | (Window & typeof globalThis);
+    get containerEl(): (Window & typeof globalThis) | HTMLElement;
     onSubmit(): void;
     constructor(elRef: ElementRef<HTMLElement>, controlContainer: ControlContainer, cdkScrollable: CdkScrollable);
     scrollToFirstInvalid(): void;

package/core/services/feature-gate.service.d.ts

@@ -9,7 +9,7 @@ export declare class FeatureGateService {
     private readonly http;
     private readonly cacheStore;
     constructor(http: HttpClient);
-    loadState(cluster?: string): Observable<"loaded" | "loadFailed" | "loading">;
+    loadState(cluster?: string): Observable<"loading" | "loaded" | "loadFailed">;
     /**
      * check gate status
      * @param gate - specified feature gate

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

@@ -0,0 +1,43 @@
+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 readonly schemaCache;
+    private readonly schemaCache$$;
+    get definitions(): Record<string, OpenAPIV3SchemaObject>;
+    constructor();
+    /**
+     * 获取当前集群的 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/code/code-editor-configs.mjs

@@ -34,9 +34,9 @@ export const logsActions = {
 };
 export const commonOptions = {
     folding: true,
-    minimap: { enabled: false },
     wordWrap: 'on',
     tabSize: 2,
+    minimap: { enabled: false },
     scrollbar: {
         alwaysConsumeMouseWheel: false,
     },
@@ -53,6 +53,16 @@ export const yamlWriteOptions = {
     language: 'yaml',
     ...commonOptions,
 };
+export const yamlWriteMinimapOptions = {
+    language: 'yaml',
+    ...commonOptions,
+    minimap: { enabled: true },
+};
+export const yamlReadMinimapOptions = {
+    language: 'yaml',
+    ...readonlyOptions,
+    minimap: { enabled: true },
+};
 export const textWriteOptions = {
     language: 'text',
     ...commonOptions,
@@ -63,4 +73,4 @@ export const logsReadOptions = {
     readOnly: true,
     renderLineHighlight: 'none',
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/code/managed-fields-folder.util.mjs

@@ -0,0 +1,136 @@
+/**
+ * 自动折叠 managedFields 字段
+ * @param monacoEditor Monaco 编辑器实例
+ */
+export function foldManagedFields(monacoEditor) {
+    if (!monacoEditor) {
+        return;
+    }
+    const model = monacoEditor.getModel();
+    if (!model) {
+        return;
+    }
+    try {
+        // 查找所有 managedFields 字段（只在 metadata 下的）
+        const managedFieldsMatches = model.findMatches('^(\\s+)managedFields:', false, true, false, null, true);
+        if (managedFieldsMatches && managedFieldsMatches.length > 0) {
+            const foldingRanges = [];
+            for (const match of managedFieldsMatches) {
+                const startLine = match.range.startLineNumber;
+                const endLine = findManagedFieldsEndLine(model, startLine);
+                if (endLine > startLine) {
+                    foldingRanges.push({
+                        startLineNumber: startLine,
+                        startColumn: 1,
+                        endLineNumber: endLine,
+                        endColumn: model.getLineMaxColumn(endLine),
+                    });
+                }
+            }
+            if (foldingRanges.length > 0) {
+                setTimeout(() => {
+                    foldingRanges.forEach(range => {
+                        monacoEditor.setSelection(range);
+                        monacoEditor.getAction('editor.fold')?.run();
+                    });
+                }, 0);
+            }
+        }
+    }
+    catch (error) {
+        console.warn('Failed to fold managedFields:', error);
+    }
+}
+/**
+ * 查找 managedFields 字段的结束行
+ * @param model Monaco 编辑器模型
+ * @param startLine 起始行号
+ * @returns 结束行号
+ */
+function findManagedFieldsEndLine(model, startLine) {
+    const totalLines = model.getLineCount();
+    const startIndent = getLineIndentation(model, startLine);
+    // 从下一行开始查找
+    for (let line = startLine + 1; line <= totalLines; line++) {
+        const lineContent = model.getLineContent(line).trim();
+        // 跳过空行
+        if (!lineContent) {
+            continue;
+        }
+        const currentIndent = getLineIndentation(model, line);
+        // 如果缩进小于等于起始行，说明 managedFields 字段结束
+        if (currentIndent <= startIndent) {
+            return line - 1;
+        }
+    }
+    return totalLines;
+}
+/**
+ * 获取行的缩进级别
+ * @param model Monaco 编辑器模型
+ * @param lineNumber 行号
+ * @returns 缩进级别（空格数）
+ */
+function getLineIndentation(model, lineNumber) {
+    const lineContent = model.getLineContent(lineNumber);
+    const match = lineContent.match(/^(\s*)/);
+    return match ? match[1].length : 0;
+}
+/**
+ * ManagedFields 自动折叠器
+ * 用于在内容变化时自动折叠 managedFields 字段
+ */
+export class ManagedFieldsAutoFolder {
+    constructor() {
+        this.lastFoldedContent = '';
+    }
+    /**
+     * 开始监听内容变化并自动折叠
+     * @param editorProvider 编辑器实例提供者
+     * @param contentObservable 内容变化的 Observable
+     */
+    startAutoFold(editorProvider, contentObservable) {
+        this.stopAutoFold();
+        this.subscription = contentObservable.subscribe(() => {
+            setTimeout(() => {
+                const editor = editorProvider.getEditorInstance();
+                if (editor) {
+                    const model = editor.getModel();
+                    if (model) {
+                        const currentContent = model.getValue();
+                        // 只有当内容真正发生变化时才执行折叠
+                        if (currentContent.includes('managedFields:') &&
+                            currentContent !== this.lastFoldedContent) {
+                            foldManagedFields(editor);
+                            this.lastFoldedContent = currentContent;
+                        }
+                    }
+                }
+            }, 100);
+        });
+    }
+    /**
+     * 停止自动折叠
+     */
+    stopAutoFold() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+            this.subscription = undefined;
+        }
+    }
+    /**
+     * 手动执行一次折叠
+     * @param editorProvider 编辑器实例提供者
+     */
+    foldOnce(editorProvider) {
+        const editor = editorProvider.getEditorInstance();
+        if (editor) {
+            foldManagedFields(editor);
+            const model = editor.getModel();
+            if (model) {
+                this.lastFoldedContent = model.getValue();
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"managed-fields-folder.util.js","sourceRoot":"","sources":["../../../../../libs/common/src/code/managed-fields-folder.util.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAC/B,YAA0C;IAE1C,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,OAAO;IACT,CAAC;IAED,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAC;IACtC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO;IACT,CAAC;IAED,IAAI,CAAC;QACH,wCAAwC;QACxC,MAAM,oBAAoB,GAAG,KAAK,CAAC,WAAW,CAC5C,uBAAuB,EACvB,KAAK,EACL,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,IAAI,CACL,CAAC;QAEF,IAAI,oBAAoB,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5D,MAAM,aAAa,GAAU,EAAE,CAAC;YAEhC,KAAK,MAAM,KAAK,IAAI,oBAAoB,EAAE,CAAC;gBACzC,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC;gBAE9C,MAAM,OAAO,GAAG,wBAAwB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;gBAE3D,IAAI,OAAO,GAAG,SAAS,EAAE,CAAC;oBACxB,aAAa,CAAC,IAAI,CAAC;wBACjB,eAAe,EAAE,SAAS;wBAC1B,WAAW,EAAE,CAAC;wBACd,aAAa,EAAE,OAAO;wBACtB,SAAS,EAAE,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC;qBAC3C,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAED,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC7B,UAAU,CAAC,GAAG,EAAE;oBACd,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;wBAC5B,YAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;wBACjC,YAAY,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE,GAAG,EAAE,CAAC;oBAC/C,CAAC,CAAC,CAAC;gBACL,CAAC,EAAE,CAAC,CAAC,CAAC;YACR,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,IAAI,CAAC,+BAA+B,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,wBAAwB,CAC/B,KAAwB,EACxB,SAAiB;IAEjB,MAAM,UAAU,GAAG,KAAK,CAAC,YAAY,EAAE,CAAC;IACxC,MAAM,WAAW,GAAG,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAEzD,WAAW;IACX,KAAK,IAAI,IAAI,GAAG,SAAS,GAAG,CAAC,EAAE,IAAI,IAAI,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC;QAC1D,MAAM,WAAW,GAAG,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;QAEtD,OAAO;QACP,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,SAAS;QACX,CAAC;QAED,MAAM,aAAa,GAAG,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEtD,oCAAoC;QACpC,IAAI,aAAa,IAAI,WAAW,EAAE,CAAC;YACjC,OAAO,IAAI,GAAG,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;GAKG;AACH,SAAS,kBAAkB,CACzB,KAAwB,EACxB,UAAkB;IAElB,MAAM,WAAW,GAAG,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;IACrD,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAC1C,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AACrC,CAAC;AASD;;;GAGG;AACH,MAAM,OAAO,uBAAuB;IAApC;QAEU,sBAAiB,GAAG,EAAE,CAAC;IA0DjC,CAAC;IAxDC;;;;OAIG;IACH,aAAa,CACX,cAAsC,EACtC,iBAAsB;QAEtB,IAAI,CAAC,YAAY,EAAE,CAAC;QAEpB,IAAI,CAAC,YAAY,GAAG,iBAAiB,CAAC,SAAS,CAAC,GAAG,EAAE;YACnD,UAAU,CAAC,GAAG,EAAE;gBACd,MAAM,MAAM,GAAG,cAAc,CAAC,iBAAiB,EAAE,CAAC;gBAClD,IAAI,MAAM,EAAE,CAAC;oBACX,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;oBAChC,IAAI,KAAK,EAAE,CAAC;wBACV,MAAM,cAAc,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;wBACxC,oBAAoB;wBACpB,IACE,cAAc,CAAC,QAAQ,CAAC,gBAAgB,CAAC;4BACzC,cAAc,KAAK,IAAI,CAAC,iBAAiB,EACzC,CAAC;4BACD,iBAAiB,CAAC,MAAM,CAAC,CAAC;4BAC1B,IAAI,CAAC,iBAAiB,GAAG,cAAc,CAAC;wBAC1C,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC,EAAE,GAAG,CAAC,CAAC;QACV,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,YAAY;QACV,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAChC,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,cAAsC;QAC7C,MAAM,MAAM,GAAG,cAAc,CAAC,iBAAiB,EAAE,CAAC;QAClD,IAAI,MAAM,EAAE,CAAC;YACX,iBAAiB,CAAC,MAAM,CAAC,CAAC;YAC1B,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;YAChC,IAAI,KAAK,EAAE,CAAC;gBACV,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC5C,CAAC;QACH,CAAC;IACH,CAAC;CACF","sourcesContent":["import { editor } from 'monaco-editor/esm/vs/editor/editor.api';\nimport { Subscription } from 'rxjs';\n\n/**\n * 自动折叠 managedFields 字段\n * @param monacoEditor Monaco 编辑器实例\n */\nexport function foldManagedFields(\n  monacoEditor: editor.IStandaloneCodeEditor,\n): void {\n  if (!monacoEditor) {\n    return;\n  }\n\n  const model = monacoEditor.getModel();\n  if (!model) {\n    return;\n  }\n\n  try {\n    // 查找所有 managedFields 字段（只在 metadata 下的）\n    const managedFieldsMatches = model.findMatches(\n      '^(\\\\s+)managedFields:',\n      false,\n      true,\n      false,\n      null,\n      true,\n    );\n\n    if (managedFieldsMatches && managedFieldsMatches.length > 0) {\n      const foldingRanges: any[] = [];\n\n      for (const match of managedFieldsMatches) {\n        const startLine = match.range.startLineNumber;\n\n        const endLine = findManagedFieldsEndLine(model, startLine);\n\n        if (endLine > startLine) {\n          foldingRanges.push({\n            startLineNumber: startLine,\n            startColumn: 1,\n            endLineNumber: endLine,\n            endColumn: model.getLineMaxColumn(endLine),\n          });\n        }\n      }\n\n      if (foldingRanges.length > 0) {\n        setTimeout(() => {\n          foldingRanges.forEach(range => {\n            monacoEditor.setSelection(range);\n            monacoEditor.getAction('editor.fold')?.run();\n          });\n        }, 0);\n      }\n    }\n  } catch (error) {\n    console.warn('Failed to fold managedFields:', error);\n  }\n}\n\n/**\n * 查找 managedFields 字段的结束行\n * @param model Monaco 编辑器模型\n * @param startLine 起始行号\n * @returns 结束行号\n */\nfunction findManagedFieldsEndLine(\n  model: editor.ITextModel,\n  startLine: number,\n): number {\n  const totalLines = model.getLineCount();\n  const startIndent = getLineIndentation(model, startLine);\n\n  // 从下一行开始查找\n  for (let line = startLine + 1; line <= totalLines; line++) {\n    const lineContent = model.getLineContent(line).trim();\n\n    // 跳过空行\n    if (!lineContent) {\n      continue;\n    }\n\n    const currentIndent = getLineIndentation(model, line);\n\n    // 如果缩进小于等于起始行，说明 managedFields 字段结束\n    if (currentIndent <= startIndent) {\n      return line - 1;\n    }\n  }\n\n  return totalLines;\n}\n\n/**\n * 获取行的缩进级别\n * @param model Monaco 编辑器模型\n * @param lineNumber 行号\n * @returns 缩进级别（空格数）\n */\nfunction getLineIndentation(\n  model: editor.ITextModel,\n  lineNumber: number,\n): number {\n  const lineContent = model.getLineContent(lineNumber);\n  const match = lineContent.match(/^(\\s*)/);\n  return match ? match[1].length : 0;\n}\n\n/**\n * 编辑器实例获取器接口\n */\nexport interface EditorInstanceProvider {\n  getEditorInstance(): editor.IStandaloneCodeEditor | null;\n}\n\n/**\n * ManagedFields 自动折叠器\n * 用于在内容变化时自动折叠 managedFields 字段\n */\nexport class ManagedFieldsAutoFolder {\n  private subscription?: Subscription;\n  private lastFoldedContent = '';\n\n  /**\n   * 开始监听内容变化并自动折叠\n   * @param editorProvider 编辑器实例提供者\n   * @param contentObservable 内容变化的 Observable\n   */\n  startAutoFold(\n    editorProvider: EditorInstanceProvider,\n    contentObservable: any,\n  ): void {\n    this.stopAutoFold();\n\n    this.subscription = contentObservable.subscribe(() => {\n      setTimeout(() => {\n        const editor = editorProvider.getEditorInstance();\n        if (editor) {\n          const model = editor.getModel();\n          if (model) {\n            const currentContent = model.getValue();\n            // 只有当内容真正发生变化时才执行折叠\n            if (\n              currentContent.includes('managedFields:') &&\n              currentContent !== this.lastFoldedContent\n            ) {\n              foldManagedFields(editor);\n              this.lastFoldedContent = currentContent;\n            }\n          }\n        }\n      }, 100);\n    });\n  }\n\n  /**\n   * 停止自动折叠\n   */\n  stopAutoFold(): void {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n      this.subscription = undefined;\n    }\n  }\n\n  /**\n   * 手动执行一次折叠\n   * @param editorProvider 编辑器实例提供者\n   */\n  foldOnce(editorProvider: EditorInstanceProvider): void {\n    const editor = editorProvider.getEditorInstance();\n    if (editor) {\n      foldManagedFields(editor);\n      const model = editor.getModel();\n      if (model) {\n        this.lastFoldedContent = model.getValue();\n      }\n    }\n  }\n}\n"]}