@alauda-fe/crd-form 0.0.1

package/esm2022/alauda-fe-crd-form.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxhdWRhLWZlLWNyZC1mb3JtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbGlicy9jcmQtZm9ybS9zcmMvYWxhdWRhLWZlLWNyZC1mb3JtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/lib/abstract/base-array.mjs

@@ -0,0 +1,117 @@
+import { Directive, EventEmitter, Input, Output, } from '@angular/core';
+import { last } from 'lodash-es';
+import { CrdFormComponent } from '../crd-form/component';
+import { Validations, } from '../types';
+import { getFieldDisplayName, getFormData, modifyArrayFieldPathIndex, } from '../utils';
+import { isFolded, repairFieldChildPathByCorrectIndex } from '../utils/helper';
+import * as i0 from "@angular/core";
+import * as i1 from "../crd-form/component";
+export class BaseOperandFiledArrayComponent {
+    get expanded() {
+        return this._expanded ?? !isFolded(this.arrayFieldGroup);
+    }
+    set expanded(expanded) {
+        this._expanded = expanded;
+    }
+    constructor(crdForm) {
+        this.crdForm = crdForm;
+        this.readonly = false;
+        this.valueChange = new EventEmitter();
+        this.itemRemove = new EventEmitter();
+        this.getFieldDisplayName = getFieldDisplayName;
+    }
+    ngOnChanges({ arrayFieldGroup, formDataState }) {
+        if (!this.basicArrayFieldTemplate &&
+            arrayFieldGroup.currentValue?.fieldLists?.length > 0) {
+            this.basicArrayFieldTemplate = last(arrayFieldGroup.currentValue.fieldLists);
+        }
+        if (formDataState?.currentValue && formDataState?.previousValue) {
+            const currValue = getFormData(formDataState.currentValue, this.arrayFieldGroup.path);
+            const arrayFieldLength = this.arrayFieldGroup.fieldLists?.length;
+            if (currValue?.size > arrayFieldLength) {
+                Array.from({ length: currValue.size - arrayFieldLength }).forEach(() => {
+                    this.addItem();
+                });
+            }
+        }
+    }
+    fieldValueChange(e) {
+        this.valueChange.emit(e);
+    }
+    addItem() {
+        const newFields = this.basicArrayFieldTemplate.map(field => {
+            const toPath = modifyArrayFieldPathIndex(field.path, () => this.arrayFieldGroup.fieldLists.length);
+            return {
+                ...repairFieldChildPathByCorrectIndex(field, field.path, toPath),
+            };
+        });
+        this.arrayFieldGroup.fieldLists = [
+            ...this.arrayFieldGroup.fieldLists,
+            newFields,
+        ];
+    }
+    removeItem(index) {
+        const groupToRemove = this.arrayFieldGroup.fieldLists[index];
+        const groupUntouched = this.arrayFieldGroup.fieldLists.filter((_, idx) => idx < index);
+        const groupToLeftShift = this.arrayFieldGroup.fieldLists.filter((_, idx) => idx > index);
+        const leftShiftedGroups = groupToLeftShift.map(group => group.map(field => {
+            const toPath = modifyArrayFieldPathIndex(field.path, idx => idx - 1);
+            return {
+                ...repairFieldChildPathByCorrectIndex(field, field.path, toPath),
+            };
+        }));
+        this.arrayFieldGroup.fieldLists = [...groupUntouched, ...leftShiftedGroups];
+        const [match, formDataPathToRemove] = 
+        // eslint-disable-next-line regexp/strict
+        /^(.*\[\d+]).*$/.exec(groupToRemove?.[0].path) || [];
+        if (match) {
+            this.itemRemove.next(formDataPathToRemove);
+        }
+        this.crdForm.controlMap.forEach((_, key) => {
+            if (key.startsWith(`${this.arrayFieldGroup.path}[${this.arrayFieldGroup.fieldLists.length}]`)) {
+                this.crdForm.controlMap.delete(key);
+            }
+        });
+        this.crdForm.refreshValidation();
+        this.deleteFormData(`${this.arrayFieldGroup.path}[${index}]`);
+    }
+    deleteFormData(path) {
+        this.valueChange.next({
+            field: {
+                ...this.arrayFieldGroup,
+                path,
+            },
+            data: null,
+        });
+    }
+    fieldIsRequired(field) {
+        return (field?.required ||
+            Object.keys(field?.validations || {})?.includes(Validations.required));
+    }
+    get columnFields() {
+        return this.basicArrayFieldTemplate;
+    }
+    trackByFn(index) {
+        return index;
+    }
+    static { this.ɵfac = function BaseOperandFiledArrayComponent_Factory(t) { return new (t || BaseOperandFiledArrayComponent)(i0.ɵɵdirectiveInject(i1.CrdFormComponent)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: BaseOperandFiledArrayComponent, inputs: { arrayFieldGroup: "arrayFieldGroup", formDataState: "formDataState", formErrors: "formErrors", isArrayTable: "isArrayTable", readonly: "readonly" }, outputs: { valueChange: "valueChange", itemRemove: "itemRemove" }, features: [i0.ɵɵNgOnChangesFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BaseOperandFiledArrayComponent, [{
+        type: Directive
+    }], () => [{ type: i1.CrdFormComponent }], { arrayFieldGroup: [{
+            type: Input
+        }], formDataState: [{
+            type: Input
+        }], formErrors: [{
+            type: Input
+        }], isArrayTable: [{
+            type: Input
+        }], readonly: [{
+            type: Input
+        }], valueChange: [{
+            type: Output
+        }], itemRemove: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-array.js","sourceRoot":"","sources":["../../../../../../libs/crd-form/src/lib/abstract/base-array.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,YAAY,EACZ,KAAK,EAEL,MAAM,GAEP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAML,WAAW,GACZ,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,yBAAyB,GAC1B,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,QAAQ,EAAE,kCAAkC,EAAE,MAAM,iBAAiB,CAAC;;;AAG/E,MAAM,OAAO,8BAA8B;IAYzC,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC3D,CAAC;IAED,IAAI,QAAQ,CAAC,QAAiB;QAC5B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;IAMD,YAA4B,OAAyB;QAAzB,YAAO,GAAP,OAAO,CAAkB;QAnB5C,aAAQ,GAAG,KAAK,CAAC;QAEhB,gBAAW,GAAG,IAAI,YAAY,EAAE,CAAC;QACjC,eAAU,GAAG,IAAI,YAAY,EAAE,CAAC;QAc1C,wBAAmB,GAAG,mBAAmB,CAAC;IAEc,CAAC;IAEzD,WAAW,CAAC,EAAE,eAAe,EAAE,aAAa,EAAiB;QAC3D,IACE,CAAC,IAAI,CAAC,uBAAuB;YAC7B,eAAe,CAAC,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,CAAC,EACpD,CAAC;YACD,IAAI,CAAC,uBAAuB,GAAG,IAAI,CACjC,eAAe,CAAC,YAAY,CAAC,UAAU,CACxC,CAAC;QACJ,CAAC;QACD,IAAI,aAAa,EAAE,YAAY,IAAI,aAAa,EAAE,aAAa,EAAE,CAAC;YAChE,MAAM,SAAS,GAAG,WAAW,CAC3B,aAAa,CAAC,YAAY,EAC1B,IAAI,CAAC,eAAe,CAAC,IAAI,CAC1B,CAAC;YACF,MAAM,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC;YACjE,IAAI,SAAS,EAAE,IAAI,GAAG,gBAAgB,EAAE,CAAC;gBACvC,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,IAAI,GAAG,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAC/D,GAAG,EAAE;oBACH,IAAI,CAAC,OAAO,EAAE,CAAC;gBACjB,CAAC,CACF,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED,gBAAgB,CAAC,CAAwB;QACvC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IAED,OAAO;QACL,MAAM,SAAS,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACzD,MAAM,MAAM,GAAG,yBAAyB,CACtC,KAAK,CAAC,IAAI,EACV,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAC7C,CAAC;YACF,OAAO;gBACL,GAAG,kCAAkC,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC;aACjD,CAAC;QACpB,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,UAAU,GAAG;YAChC,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU;YAClC,SAAS;SACV,CAAC;IACJ,CAAC;IAED,UAAU,CAAC,KAAa;QACtB,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QAC7D,MAAM,cAAc,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAC3D,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,KAAK,CACxB,CAAC;QACF,MAAM,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAC7D,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,KAAK,CACxB,CAAC;QAEF,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CACrD,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YAChB,MAAM,MAAM,GAAG,yBAAyB,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;YACrE,OAAO;gBACL,GAAG,kCAAkC,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC;aACjD,CAAC;QACpB,CAAC,CAAC,CACH,CAAC;QAEF,IAAI,CAAC,eAAe,CAAC,UAAU,GAAG,CAAC,GAAG,cAAc,EAAE,GAAG,iBAAiB,CAAC,CAAC;QAE5E,MAAM,CAAC,KAAK,EAAE,oBAAoB,CAAC;QACjC,yCAAyC;QACzC,gBAAgB,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACvD,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE;YACzC,IACE,GAAG,CAAC,UAAU,CACZ,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,GAAG,CAC1E,EACD,CAAC;gBACD,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACtC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;QAEjC,IAAI,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,IAAI,KAAK,GAAG,CAAC,CAAC;IAChE,CAAC;IAEO,cAAc,CAAC,IAAY;QACjC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACpB,KAAK,EAAE;gBACL,GAAG,IAAI,CAAC,eAAe;gBACvB,IAAI;aACL;YACD,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED,eAAe,CAAC,KAAmB;QACjC,OAAO,CACL,KAAK,EAAE,QAAQ;YACf,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,QAAQ,CAAC,CACtE,CAAC;IACJ,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,uBAAuB,CAAC;IACtC,CAAC;IAED,SAAS,CAAC,KAAa;QACrB,OAAO,KAAK,CAAC;IACf,CAAC;+FAvIU,8BAA8B;oEAA9B,8BAA8B;;iFAA9B,8BAA8B;cAD1C,SAAS;iDAEC,eAAe;kBAAvB,KAAK;YACG,aAAa;kBAArB,KAAK;YACG,UAAU;kBAAlB,KAAK;YACG,YAAY;kBAApB,KAAK;YACG,QAAQ;kBAAhB,KAAK;YAEI,WAAW;kBAApB,MAAM;YACG,UAAU;kBAAnB,MAAM","sourcesContent":["import {\n  Directive,\n  EventEmitter,\n  Input,\n  OnChanges,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport { last } from 'lodash-es';\n\nimport { CrdFormComponent } from '../crd-form/component';\nimport {\n  FieldValueChangeEvent,\n  FormDataState,\n  FormErrors,\n  OperandArrayFieldGroup,\n  OperandField,\n  Validations,\n} from '../types';\nimport {\n  getFieldDisplayName,\n  getFormData,\n  modifyArrayFieldPathIndex,\n} from '../utils';\nimport { isFolded, repairFieldChildPathByCorrectIndex } from '../utils/helper';\n\n@Directive()\nexport class BaseOperandFiledArrayComponent implements OnChanges {\n  @Input() arrayFieldGroup: OperandArrayFieldGroup;\n  @Input() formDataState: FormDataState;\n  @Input() formErrors: FormErrors;\n  @Input() isArrayTable: boolean;\n  @Input() readonly = false;\n\n  @Output() valueChange = new EventEmitter();\n  @Output() itemRemove = new EventEmitter();\n\n  private _expanded: boolean;\n\n  get expanded() {\n    return this._expanded ?? !isFolded(this.arrayFieldGroup);\n  }\n\n  set expanded(expanded: boolean) {\n    this._expanded = expanded;\n  }\n\n  basicArrayFieldTemplate: OperandField[];\n\n  getFieldDisplayName = getFieldDisplayName;\n\n  constructor(public readonly crdForm: CrdFormComponent) {}\n\n  ngOnChanges({ arrayFieldGroup, formDataState }: SimpleChanges) {\n    if (\n      !this.basicArrayFieldTemplate &&\n      arrayFieldGroup.currentValue?.fieldLists?.length > 0\n    ) {\n      this.basicArrayFieldTemplate = last(\n        arrayFieldGroup.currentValue.fieldLists,\n      );\n    }\n    if (formDataState?.currentValue && formDataState?.previousValue) {\n      const currValue = getFormData(\n        formDataState.currentValue,\n        this.arrayFieldGroup.path,\n      );\n      const arrayFieldLength = this.arrayFieldGroup.fieldLists?.length;\n      if (currValue?.size > arrayFieldLength) {\n        Array.from({ length: currValue.size - arrayFieldLength }).forEach(\n          () => {\n            this.addItem();\n          },\n        );\n      }\n    }\n  }\n\n  fieldValueChange(e: FieldValueChangeEvent) {\n    this.valueChange.emit(e);\n  }\n\n  addItem() {\n    const newFields = this.basicArrayFieldTemplate.map(field => {\n      const toPath = modifyArrayFieldPathIndex(\n        field.path,\n        () => this.arrayFieldGroup.fieldLists.length,\n      );\n      return {\n        ...repairFieldChildPathByCorrectIndex(field, field.path, toPath),\n      } as OperandField;\n    });\n    this.arrayFieldGroup.fieldLists = [\n      ...this.arrayFieldGroup.fieldLists,\n      newFields,\n    ];\n  }\n\n  removeItem(index: number) {\n    const groupToRemove = this.arrayFieldGroup.fieldLists[index];\n    const groupUntouched = this.arrayFieldGroup.fieldLists.filter(\n      (_, idx) => idx < index,\n    );\n    const groupToLeftShift = this.arrayFieldGroup.fieldLists.filter(\n      (_, idx) => idx > index,\n    );\n\n    const leftShiftedGroups = groupToLeftShift.map(group =>\n      group.map(field => {\n        const toPath = modifyArrayFieldPathIndex(field.path, idx => idx - 1);\n        return {\n          ...repairFieldChildPathByCorrectIndex(field, field.path, toPath),\n        } as OperandField;\n      }),\n    );\n\n    this.arrayFieldGroup.fieldLists = [...groupUntouched, ...leftShiftedGroups];\n\n    const [match, formDataPathToRemove] =\n      // eslint-disable-next-line regexp/strict\n      /^(.*\\[\\d+]).*$/.exec(groupToRemove?.[0].path) || [];\n    if (match) {\n      this.itemRemove.next(formDataPathToRemove);\n    }\n\n    this.crdForm.controlMap.forEach((_, key) => {\n      if (\n        key.startsWith(\n          `${this.arrayFieldGroup.path}[${this.arrayFieldGroup.fieldLists.length}]`,\n        )\n      ) {\n        this.crdForm.controlMap.delete(key);\n      }\n    });\n    this.crdForm.refreshValidation();\n\n    this.deleteFormData(`${this.arrayFieldGroup.path}[${index}]`);\n  }\n\n  private deleteFormData(path: string) {\n    this.valueChange.next({\n      field: {\n        ...this.arrayFieldGroup,\n        path,\n      },\n      data: null,\n    });\n  }\n\n  fieldIsRequired(field: OperandField) {\n    return (\n      field?.required ||\n      Object.keys(field?.validations || {})?.includes(Validations.required)\n    );\n  }\n\n  get columnFields() {\n    return this.basicArrayFieldTemplate;\n  }\n\n  trackByFn(index: number) {\n    return index;\n  }\n}\n"]}

package/esm2022/lib/crd-form/component.mjs

@@ -0,0 +1,334 @@
+import { __decorate, __metadata } from "tslib";
+import { LabelPosition } from '@alauda/ui';
+import { ObservableInput, } from '@alauda-fe/common';
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Output, QueryList, ViewChild, } from '@angular/core';
+import { NgForm } from '@angular/forms';
+import { List, Map as $Map, fromJS } from 'immutable';
+import { flattenDeep, fromPairs, isEmpty, uniq } from 'lodash-es';
+import { Observable } from 'rxjs';
+import { RemoteWidgetsService } from '../remote-widgets';
+import { SpecCapability, } from '../types';
+import { CrdFormCustomDescriptionDirective, parseArrayPath, SCHEMA_PATH, createCapabilityField, normalizePath, pathToArray, getCustomDescription, getOperandPath, getPathFromTagPath, getFieldsByPath, fieldShouldReveal, getDefaultValue, } from '../utils';
+import { differPathsTag, getAllOtherTagPath, matchValueAgainstOneOf, } from './helper';
+import * as i0 from "@angular/core";
+import * as i1 from "../remote-widgets";
+const _c0 = ["form"];
+function CrdFormComponent_ng_container_2_Template(rf, ctx) { if (rf & 1) {
+    const _r1 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "acl-operand-field", 4);
+    i0.ɵɵpipe(2, "pure");
+    i0.ɵɵpipe(3, "async");
+    i0.ɵɵlistener("valueChange", function CrdFormComponent_ng_container_2_Template_acl_operand_field_valueChange_1_listener($event) { i0.ɵɵrestoreView(_r1); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.fieldValueChange($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const field_r3 = ctx.$implicit;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("fields", ctx_r1.fields)("field", field_r3)("formDataState", ctx_r1.formDataState)("readonly", ctx_r1.readonly)("customDescription", i0.ɵɵpipeBind3(2, 6, ctx_r1.customDescriptions, ctx_r1.getCustomDescription, field_r3))("remoteModuleDefinition", i0.ɵɵpipeBind1(3, 10, ctx_r1.remoteModuleDefinition$));
+} }
+function CrdFormComponent_ng_container_3_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "acl-operand-field-group", 5);
+    i0.ɵɵlistener("valueChange", function CrdFormComponent_ng_container_3_Template_acl_operand_field_group_valueChange_1_listener($event) { i0.ɵɵrestoreView(_r4); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.fieldValueChange($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const group_r5 = ctx.$implicit;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("fields", ctx_r1.fields)("fieldGroup", group_r5)("formDataState", ctx_r1.formDataState)("formErrors", ctx_r1.formErrors)("readonly", ctx_r1.readonly)("customDescriptions", ctx_r1.customDescriptions);
+} }
+function CrdFormComponent_ng_container_4_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "acl-operand-array-field-group", 6);
+    i0.ɵɵlistener("valueChange", function CrdFormComponent_ng_container_4_Template_acl_operand_array_field_group_valueChange_1_listener($event) { i0.ɵɵrestoreView(_r6); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.fieldValueChange($event)); })("itemRemove", function CrdFormComponent_ng_container_4_Template_acl_operand_array_field_group_itemRemove_1_listener($event) { i0.ɵɵrestoreView(_r6); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.deleteFormData($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const group_r7 = ctx.$implicit;
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("arrayFieldGroup", group_r7)("formDataState", ctx_r1.formDataState)("readonly", ctx_r1.readonly);
+} }
+function CrdFormComponent_ng_container_5_Template(rf, ctx) { if (rf & 1) {
+    const _r8 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementContainerStart(0);
+    i0.ɵɵelementStart(1, "acl-operand-advanced-field-group", 7);
+    i0.ɵɵlistener("valueChange", function CrdFormComponent_ng_container_5_Template_acl_operand_advanced_field_group_valueChange_1_listener($event) { i0.ɵɵrestoreView(_r8); const ctx_r1 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r1.fieldValueChange($event)); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementContainerEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("fields", ctx_r1.fields)("fieldList", ctx_r1.advancedFields)("formDataState", ctx_r1.formDataState)("readonly", ctx_r1.readonly);
+} }
+export class CrdFormComponent {
+    constructor(rws) {
+        this.rws = rws;
+        this.debug = false;
+        this.openApiSchemaPath = SCHEMA_PATH;
+        this.readonly = false;
+        this.labelPosition = LabelPosition.Right;
+        this.formStateChange = new EventEmitter();
+        this.formSchemaChange = new EventEmitter();
+        this.formErrors = {};
+        // 一个全局的 controlMap，方便控制 field 主动校验。
+        // 该 controlMap 以及所有 field 里的 control 实例，都是为了数据追踪与错误同步（control.error -> crdForm error），本身不影响提交，由 crd-form 的 error 去阻塞提交。
+        this.controlMap = new Map();
+        this.remoteModuleDefinition$ = this.rws.remoteModule$;
+        this.getCustomDescription = getCustomDescription;
+        // 被隐藏起来的表单的路径集合
+        this.dirtyPathsSet = new Set();
+    }
+    ngOnChanges({ openApiSchema, descriptors, data }) {
+        if (openApiSchema?.currentValue || descriptors?.currentValue) {
+            this.setUpForm();
+        }
+        else if (data?.currentValue) {
+            this.formDataState = fromJS(data.currentValue);
+        }
+    }
+    setUpForm() {
+        this.formDataState = fromJS(this.data || {});
+        const { normalFields, fieldGroups, arrayFieldGroups, advancedFields, descriptorFields, openApiFields, basicFields, } = createCapabilityField(this.descriptors || [], this.openApiSchema || {}, this.data, this.openApiSchemaPath);
+        this.fields = basicFields.filter(fieldShouldReveal);
+        if (this.debug) {
+            /* eslint-disable  no-console */
+            console.info('openApiFields:', openApiFields);
+            console.info('descriptorFields:', descriptorFields);
+            console.info('basicFields:', basicFields);
+            console.info('normalFields', normalFields);
+            console.info('fieldGroups:', fieldGroups);
+            console.info('arrayFieldGroups:', arrayFieldGroups);
+            console.info('advancedFields:', advancedFields);
+            /* eslint-enable no-console */
+        }
+        this.normalFields = normalFields;
+        this.fieldGroups = fieldGroups;
+        this.arrayFieldGroups = arrayFieldGroups;
+        this.advancedFields = advancedFields;
+        this.formSchemaChange.emit({
+            openApiFields,
+            descriptorFields,
+        });
+    }
+    fieldValueChange(event) {
+        let onceDirtyPathsSet = new Set();
+        // TODO: 待review确认后移除该开关
+        if (this.formContext?.gates?.includes('onceDirtyPathsSet')) {
+            const operandPath = getOperandPath(event.field);
+            // 如果表单被隐藏且这次change是因为直接改变了包含该路径的父路径的值（例如编辑yaml）
+            // 那就阻止此子路径值的change逻辑
+            if (this.dirtyPathsSet.has(operandPath) &&
+                this._lastUpdateField?.path &&
+                operandPath.startsWith(`${this._lastUpdateField.path}.`)) {
+                return;
+            }
+        }
+        else {
+            onceDirtyPathsSet = this.dirtyPathsSet;
+        }
+        const eventData = event.data;
+        if (event.field.capabilities.some(c => c.startsWith(SpecCapability.oneOf))) {
+            const { dirtyPaths, validPaths } = this.resolveExpiredPath(event.field, eventData);
+            dirtyPaths.forEach(path => {
+                this.dirtyPathsSet.add(normalizePath(path));
+                onceDirtyPathsSet.add(normalizePath(path));
+            });
+            validPaths.forEach(path => {
+                this.updateValidPathValue(path);
+            });
+        }
+        const allOtherPaths = getAllOtherTagPath(this.fields, Array.from(onceDirtyPathsSet));
+        const removedPaths = uniq(
+        // 同一 path 可能有多个 tag，假设某个 tagged path 有效，则其对应 path 数据不应该删除
+        differPathsTag(Array.from(onceDirtyPathsSet), allOtherPaths).map(path => getPathFromTagPath(path))).filter(
+        // 只清空叶子结点，以适配 yaml 情况
+        path => !this.fields.some(field => {
+            const isParentPath = field.path.startsWith(`${path}.`);
+            if (isParentPath) {
+                // 该 field 亦为 dirty，不以为依据
+                return !onceDirtyPathsSet.has(field.path);
+            }
+            return false;
+        }));
+        if (eventData == null && !this.keepEmptyPath) {
+            if (!onceDirtyPathsSet.has(getOperandPath(event.field))) {
+                this.deleteFormData(event.field.path);
+            }
+        }
+        else {
+            this.updateFormData(event.field, eventData);
+        }
+        removedPaths.forEach(path => {
+            this.deleteFormData(path);
+        });
+        this.refreshValidation();
+        this.formStateChange.emit({
+            data: this.formDataState.toJS(),
+            errors: this.formErrors,
+        });
+    }
+    deleteFormData(path) {
+        this.formDataState = this.formDataState.deleteIn(pathToArray(path));
+        this.controlMap.get(path)?.setValue(null);
+        this.formStateChange.emit({
+            data: this.formDataState.toJS(),
+            errors: this.formErrors,
+        });
+    }
+    updateValidPathValue(path) {
+        // 如果有效路径是上一次的无效路径，则意味着该路径的值在上次被重置了，所以当该路径又需要显示给用户时应该使用默认值
+        const useDefault = this.dirtyPathsSet.has(normalizePath(path));
+        this.dirtyPathsSet.delete(normalizePath(path));
+        // 如果对一组表单都有依赖，那路径可能是这组表单的父路径，所以需要把所有子孙都找出来
+        const fields = getFieldsByPath(path, [
+            ...this.normalFields,
+            ...flattenDeep(this.fieldGroups.map(group => group.fieldList)),
+            ...flattenDeep(this.arrayFieldGroups.map(arrayGroup => arrayGroup.fieldLists)),
+            ...this.advancedFields,
+        ]);
+        fields.forEach(field => {
+            // 理论上 oneof 只影响视图，但实际还会影响 formDataState，所以需要同步更新 formDataState
+            let value = this.controlMap.get(getOperandPath(field)).value;
+            if (!value && useDefault) {
+                value = getDefaultValue(field);
+            }
+            this.updateFormData(field, value);
+        });
+    }
+    updateFormData(field, data) {
+        if (!field)
+            return;
+        const { match, index, pathBeforeIndex, pathAfterIndex } = parseArrayPath(field.path);
+        if (match && index === 0) {
+            this.formDataState = this.initializeFormDataArrayProperty(this.formDataState, pathBeforeIndex, pathAfterIndex, data);
+        }
+        this.formDataState = this.formDataState.setIn(pathToArray(field.path), data);
+        this._lastUpdateField = field;
+    }
+    refreshValidation() {
+        const errors = Array.from(this.controlMap).reduce((acc, [pathWithTag, control]) => {
+            if (this.dirtyPathsSet.has(pathWithTag)) {
+                return acc;
+            }
+            const path = getPathFromTagPath(pathWithTag);
+            acc[path] = isEmpty(control.errors) ? null : control.errors;
+            return acc;
+        }, {});
+        const result = fromPairs(Object.entries(errors ?? {}).filter(([_k, v]) => !!v));
+        this.formErrors = isEmpty(result) ? null : result;
+    }
+    // 当某个 field 发生数据变化，返回其相关 oneOf path 是否应该移除
+    // 仅当当前 field 中 oneOf 条件与当前数据不匹配，
+    resolveExpiredPath(field, currentValue) {
+        const { dirtyPaths, validPaths } = matchValueAgainstOneOf(field, currentValue);
+        const otherFieldStatus = this.fields
+            .filter(i => getOperandPath(i) !== getOperandPath(field))
+            .map(field => ({
+            path: getOperandPath(field),
+            result: matchValueAgainstOneOf(field, this.controlMap.get(getOperandPath(field))?.value),
+        }));
+        const newDirtyPaths = validPaths.filter(path => {
+            // 当前 valid path 在其他 field 中为 dirty，若该 field 本身也为 dirty 则忽略该影响，仍然判定为 valid，否则（该 field 有效）认定为 dirty
+            const fieldCandidates = otherFieldStatus.filter(status => status.result.dirtyPaths.includes(path));
+            return fieldCandidates.some(({ path }) => !otherFieldStatus.some(status => status.result.dirtyPaths.includes(path)));
+        });
+        return {
+            dirtyPaths: [...dirtyPaths, ...newDirtyPaths],
+            validPaths: validPaths.filter(path => !newDirtyPaths.includes(path)),
+        };
+    }
+    initializeFormDataArrayProperty(state, pathBeforeIndex, pathAfterIndex, value) {
+        if (state.getIn([...pathToArray(pathBeforeIndex), 0])) {
+            return state;
+        }
+        const item = $Map({}).setIn(pathToArray(pathAfterIndex), value);
+        const list = List([item]);
+        return state.setIn(pathToArray(pathBeforeIndex), list);
+    }
+    submit() {
+        this.refreshValidation();
+        this.form.onSubmit(null);
+    }
+    static { this.ɵfac = function CrdFormComponent_Factory(t) { return new (t || CrdFormComponent)(i0.ɵɵdirectiveInject(i1.RemoteWidgetsService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: CrdFormComponent, selectors: [["acl-crd-form"]], contentQueries: function CrdFormComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, CrdFormCustomDescriptionDirective, 4);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.customDescriptions = _t);
+        } }, viewQuery: function CrdFormComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 7);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.form = _t.first);
+        } }, inputs: { openApiSchema: "openApiSchema", descriptors: "descriptors", data: "data", debug: "debug", openApiSchemaPath: "openApiSchemaPath", readonly: "readonly", labelWidth: "labelWidth", labelPosition: "labelPosition", cluster: "cluster", namespace: "namespace", formContext: "formContext", keepEmptyPath: "keepEmptyPath", effectControlDefaultValue: "effectControlDefaultValue", uiContext: "uiContext", widgets: "widgets" }, outputs: { formStateChange: "formStateChange", formSchemaChange: "formSchemaChange" }, features: [i0.ɵɵNgOnChangesFeature], decls: 6, vars: 7, consts: [["form", "ngForm"], ["auiForm", "", 3, "aclScrollToFirstInvalid", "auiFormLabelPosition", "auiFormLabelWidth"], [4, "ngFor", "ngForOf"], [4, "ngIf"], [3, "valueChange", "fields", "field", "formDataState", "readonly", "customDescription", "remoteModuleDefinition"], [3, "valueChange", "fields", "fieldGroup", "formDataState", "formErrors", "readonly", "customDescriptions"], [3, "valueChange", "itemRemove", "arrayFieldGroup", "formDataState", "readonly"], [3, "valueChange", "fields", "fieldList", "formDataState", "readonly"]], template: function CrdFormComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "form", 1, 0);
+            i0.ɵɵtemplate(2, CrdFormComponent_ng_container_2_Template, 4, 12, "ng-container", 2)(3, CrdFormComponent_ng_container_3_Template, 2, 6, "ng-container", 2)(4, CrdFormComponent_ng_container_4_Template, 2, 3, "ng-container", 2)(5, CrdFormComponent_ng_container_5_Template, 2, 4, "ng-container", 3);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("aclScrollToFirstInvalid", !!ctx.formErrors)("auiFormLabelPosition", ctx.labelPosition)("auiFormLabelWidth", ctx.labelWidth);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngForOf", ctx.normalFields);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngForOf", ctx.fieldGroups);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngForOf", ctx.arrayFieldGroups);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", ctx.advancedFields == null ? null : ctx.advancedFields.length);
+        } }, styles: ["[_nghost-%COMP%]{width:100%}"], changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], CrdFormComponent.prototype, "formContext$", void 0);
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CrdFormComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-crd-form', changeDetection: ChangeDetectionStrategy.OnPush, template: "<form\n  auiForm\n  [aclScrollToFirstInvalid]=\"!!formErrors\"\n  #form=\"ngForm\"\n  [auiFormLabelPosition]=\"labelPosition\"\n  [auiFormLabelWidth]=\"labelWidth\"\n>\n  <!-- normal fields -->\n  <ng-container *ngFor=\"let field of normalFields\">\n    <acl-operand-field\n      [fields]=\"fields\"\n      [field]=\"field\"\n      [formDataState]=\"formDataState\"\n      [readonly]=\"readonly\"\n      [customDescription]=\"\n        customDescriptions | pure: getCustomDescription:field\n      \"\n      (valueChange)=\"fieldValueChange($event)\"\n      [remoteModuleDefinition]=\"remoteModuleDefinition$ | async\"\n    >\n    </acl-operand-field>\n  </ng-container>\n\n  <!-- field groups \u517C\u5BB9\uFF0C\u9700\u8981\u4FDD\u7559-->\n  <ng-container *ngFor=\"let group of fieldGroups\">\n    <acl-operand-field-group\n      [fields]=\"fields\"\n      [fieldGroup]=\"group\"\n      [formDataState]=\"formDataState\"\n      [formErrors]=\"formErrors\"\n      [readonly]=\"readonly\"\n      (valueChange)=\"fieldValueChange($event)\"\n      [customDescriptions]=\"customDescriptions\"\n    >\n    </acl-operand-field-group>\n  </ng-container>\n\n  <!-- array field groups \u517C\u5BB9\uFF0C\u9700\u8981\u4FDD\u7559 -->\n  <ng-container *ngFor=\"let group of arrayFieldGroups\">\n    <acl-operand-array-field-group\n      [arrayFieldGroup]=\"group\"\n      [formDataState]=\"formDataState\"\n      [readonly]=\"readonly\"\n      (valueChange)=\"fieldValueChange($event)\"\n      (itemRemove)=\"deleteFormData($event)\"\n    >\n    </acl-operand-array-field-group>\n  </ng-container>\n\n  <!-- advanced fields -->\n  <ng-container *ngIf=\"advancedFields?.length\">\n    <acl-operand-advanced-field-group\n      [fields]=\"fields\"\n      [fieldList]=\"advancedFields\"\n      [formDataState]=\"formDataState\"\n      [readonly]=\"readonly\"\n      (valueChange)=\"fieldValueChange($event)\"\n    ></acl-operand-advanced-field-group>\n  </ng-container>\n</form>\n", styles: [":host{width:100%}\n"] }]
+    }], () => [{ type: i1.RemoteWidgetsService }], { openApiSchema: [{
+            type: Input
+        }], descriptors: [{
+            type: Input
+        }], data: [{
+            type: Input
+        }], debug: [{
+            type: Input
+        }], openApiSchemaPath: [{
+            type: Input
+        }], readonly: [{
+            type: Input
+        }], labelWidth: [{
+            type: Input
+        }], labelPosition: [{
+            type: Input
+        }], cluster: [{
+            type: Input
+        }], namespace: [{
+            type: Input
+        }], formContext: [{
+            type: Input
+        }], formContext$: [], keepEmptyPath: [{
+            type: Input
+        }], effectControlDefaultValue: [{
+            type: Input
+        }], uiContext: [{
+            type: Input
+        }], formStateChange: [{
+            type: Output
+        }], formSchemaChange: [{
+            type: Output
+        }], form: [{
+            type: ViewChild,
+            args: ['form', { static: true }]
+        }], customDescriptions: [{
+            type: ContentChildren,
+            args: [CrdFormCustomDescriptionDirective]
+        }], widgets: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(CrdFormComponent, { className: "CrdFormComponent", filePath: "lib/crd-form/component.ts", lineNumber: 64 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../libs/crd-form/src/lib/crd-form/component.ts","../../../../../../libs/crd-form/src/lib/crd-form/template.html"],"names":[],"mappings":"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","sourcesContent":["import { LabelPosition } from '@alauda/ui';\nimport {\n  Dictionary,\n  ObservableInput,\n  OpenAPIV3SchemaObject,\n} from '@alauda-fe/common';\nimport { ComponentType } from '@angular/cdk/portal';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  ContentChildren,\n  EventEmitter,\n  Input,\n  OnChanges,\n  Output,\n  QueryList,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { AbstractControl, NgForm } from '@angular/forms';\nimport { List, Map as $Map, fromJS } from 'immutable';\nimport { flattenDeep, fromPairs, isEmpty, uniq } from 'lodash-es';\nimport { Observable } from 'rxjs';\n\nimport { RemoteWidgetsService } from '../remote-widgets';\nimport {\n  Descriptor,\n  FieldValueChangeEvent,\n  FormDataState,\n  FormErrors,\n  FormState,\n  OperandArrayFieldGroup,\n  OperandField,\n  OperandFieldGroup,\n  SpecCapability,\n} from '../types';\nimport {\n  CrdFormCustomDescriptionDirective,\n  parseArrayPath,\n  SCHEMA_PATH,\n  createCapabilityField,\n  normalizePath,\n  pathToArray,\n  getCustomDescription,\n  getOperandPath,\n  getPathFromTagPath,\n  getFieldsByPath,\n  fieldShouldReveal,\n  getDefaultValue,\n} from '../utils';\n\nimport {\n  differPathsTag,\n  getAllOtherTagPath,\n  matchValueAgainstOneOf,\n} from './helper';\n\n@Component({\n  selector: 'acl-crd-form',\n  templateUrl: 'template.html',\n  styleUrls: ['styles.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CrdFormComponent implements OnChanges {\n  @Input() openApiSchema: OpenAPIV3SchemaObject;\n  @Input() descriptors: Descriptor[];\n  @Input() data: unknown;\n  @Input() debug = false;\n  @Input() openApiSchemaPath: string | string[] = SCHEMA_PATH;\n  @Input() readonly = false;\n  @Input() labelWidth: string;\n  @Input() labelPosition: LabelPosition = LabelPosition.Right;\n\n  @Input() cluster?: string;\n  @Input() namespace?: string;\n\n  @Input() formContext: any;\n  @ObservableInput() formContext$: Observable<any>;\n\n  @Input() keepEmptyPath: boolean;\n\n  @Input() effectControlDefaultValue: boolean;\n\n  @Input() uiContext?: Record<string, any>;\n\n  @Output() formStateChange = new EventEmitter<FormState>();\n\n  @Output() formSchemaChange = new EventEmitter<any>();\n\n  @ViewChild('form', { static: true })\n  form: NgForm;\n\n  @ContentChildren(CrdFormCustomDescriptionDirective)\n  customDescriptions: QueryList<CrdFormCustomDescriptionDirective>;\n\n  @Input()\n  widgets: Array<{\n    descriptor: string;\n    component: ComponentType<any>;\n  }>;\n\n  formDataState: FormDataState;\n  formErrors: FormErrors = {};\n\n  fields: OperandField[];\n  normalFields: OperandField[];\n  fieldGroups: OperandFieldGroup[];\n  arrayFieldGroups: OperandArrayFieldGroup[];\n  advancedFields: OperandField[];\n  private _lastUpdateField: OperandField;\n\n  // 一个全局的 controlMap，方便控制 field 主动校验。\n  // 该 controlMap 以及所有 field 里的 control 实例，都是为了数据追踪与错误同步（control.error -> crdForm error），本身不影响提交，由 crd-form 的 error 去阻塞提交。\n  controlMap = new Map<string, AbstractControl>();\n\n  constructor(private readonly rws: RemoteWidgetsService) {}\n\n  remoteModuleDefinition$ = this.rws.remoteModule$;\n\n  ngOnChanges({ openApiSchema, descriptors, data }: SimpleChanges) {\n    if (openApiSchema?.currentValue || descriptors?.currentValue) {\n      this.setUpForm();\n    } else if (data?.currentValue) {\n      this.formDataState = fromJS(data.currentValue) as FormDataState;\n    }\n  }\n\n  getCustomDescription = getCustomDescription;\n\n  private setUpForm() {\n    this.formDataState = fromJS(this.data || {}) as FormDataState;\n\n    const {\n      normalFields,\n      fieldGroups,\n      arrayFieldGroups,\n      advancedFields,\n      descriptorFields,\n      openApiFields,\n      basicFields,\n    } = createCapabilityField(\n      this.descriptors || [],\n      this.openApiSchema || ({} as OpenAPIV3SchemaObject),\n      this.data,\n      this.openApiSchemaPath,\n    );\n\n    this.fields = basicFields.filter(fieldShouldReveal);\n    if (this.debug) {\n      /* eslint-disable  no-console */\n      console.info('openApiFields:', openApiFields);\n      console.info('descriptorFields:', descriptorFields);\n      console.info('basicFields:', basicFields);\n\n      console.info('normalFields', normalFields);\n\n      console.info('fieldGroups:', fieldGroups);\n      console.info('arrayFieldGroups:', arrayFieldGroups);\n      console.info('advancedFields:', advancedFields);\n      /* eslint-enable no-console */\n    }\n\n    this.normalFields = normalFields;\n    this.fieldGroups = fieldGroups;\n    this.arrayFieldGroups = arrayFieldGroups;\n    this.advancedFields = advancedFields;\n\n    this.formSchemaChange.emit({\n      openApiFields,\n      descriptorFields,\n    });\n  }\n\n  // 被隐藏起来的表单的路径集合\n  dirtyPathsSet = new Set<string>();\n\n  fieldValueChange(event: FieldValueChangeEvent) {\n    let onceDirtyPathsSet = new Set<string>();\n\n    // TODO: 待review确认后移除该开关\n    if ((this.formContext?.gates as string[])?.includes('onceDirtyPathsSet')) {\n      const operandPath = getOperandPath(event.field);\n      // 如果表单被隐藏且这次change是因为直接改变了包含该路径的父路径的值（例如编辑yaml）\n      // 那就阻止此子路径值的change逻辑\n      if (\n        this.dirtyPathsSet.has(operandPath) &&\n        this._lastUpdateField?.path &&\n        operandPath.startsWith(`${this._lastUpdateField.path}.`)\n      ) {\n        return;\n      }\n    } else {\n      onceDirtyPathsSet = this.dirtyPathsSet;\n    }\n\n    const eventData = event.data;\n    if (\n      event.field.capabilities.some(c => c.startsWith(SpecCapability.oneOf))\n    ) {\n      const { dirtyPaths, validPaths } = this.resolveExpiredPath(\n        event.field,\n        eventData,\n      );\n\n      dirtyPaths.forEach(path => {\n        this.dirtyPathsSet.add(normalizePath(path));\n        onceDirtyPathsSet.add(normalizePath(path));\n      });\n\n      validPaths.forEach(path => {\n        this.updateValidPathValue(path);\n      });\n    }\n    const allOtherPaths = getAllOtherTagPath(\n      this.fields,\n      Array.from(onceDirtyPathsSet),\n    );\n    const removedPaths = uniq(\n      // 同一 path 可能有多个 tag，假设某个 tagged path 有效，则其对应 path 数据不应该删除\n      differPathsTag(Array.from(onceDirtyPathsSet), allOtherPaths).map(path =>\n        getPathFromTagPath(path),\n      ),\n    ).filter(\n      // 只清空叶子结点，以适配 yaml 情况\n      path =>\n        !this.fields.some(field => {\n          const isParentPath = field.path.startsWith(`${path}.`);\n          if (isParentPath) {\n            // 该 field 亦为 dirty，不以为依据\n            return !onceDirtyPathsSet.has(field.path);\n          }\n          return false;\n        }),\n    );\n    if (eventData == null && !this.keepEmptyPath) {\n      if (!onceDirtyPathsSet.has(getOperandPath(event.field))) {\n        this.deleteFormData(event.field.path);\n      }\n    } else {\n      this.updateFormData(event.field, eventData);\n    }\n\n    removedPaths.forEach(path => {\n      this.deleteFormData(path);\n    });\n    this.refreshValidation();\n    this.formStateChange.emit({\n      data: this.formDataState.toJS(),\n      errors: this.formErrors,\n    });\n  }\n\n  deleteFormData(path: string) {\n    this.formDataState = this.formDataState.deleteIn(pathToArray(path));\n    this.controlMap.get(path)?.setValue(null);\n\n    this.formStateChange.emit({\n      data: this.formDataState.toJS(),\n      errors: this.formErrors,\n    });\n  }\n\n  private updateValidPathValue(path: string) {\n    // 如果有效路径是上一次的无效路径，则意味着该路径的值在上次被重置了，所以当该路径又需要显示给用户时应该使用默认值\n    const useDefault = this.dirtyPathsSet.has(normalizePath(path));\n    this.dirtyPathsSet.delete(normalizePath(path));\n    // 如果对一组表单都有依赖，那路径可能是这组表单的父路径，所以需要把所有子孙都找出来\n    const fields = getFieldsByPath(path, [\n      ...this.normalFields,\n      ...flattenDeep(this.fieldGroups.map(group => group.fieldList)),\n      ...flattenDeep(\n        this.arrayFieldGroups.map(arrayGroup => arrayGroup.fieldLists),\n      ),\n      ...this.advancedFields,\n    ]);\n    fields.forEach(field => {\n      // 理论上 oneof 只影响视图，但实际还会影响 formDataState，所以需要同步更新 formDataState\n      let value = this.controlMap.get(getOperandPath(field)).value;\n      if (!value && useDefault) {\n        value = getDefaultValue(field);\n      }\n      this.updateFormData(field, value);\n    });\n  }\n\n  private updateFormData(field: OperandField, data: unknown) {\n    if (!field) return;\n    const { match, index, pathBeforeIndex, pathAfterIndex } = parseArrayPath(\n      field.path,\n    );\n    if (match && index === 0) {\n      this.formDataState = this.initializeFormDataArrayProperty(\n        this.formDataState,\n        pathBeforeIndex,\n        pathAfterIndex,\n        data,\n      );\n    }\n    this.formDataState = this.formDataState.setIn(\n      pathToArray(field.path),\n      data,\n    );\n    this._lastUpdateField = field;\n  }\n\n  refreshValidation() {\n    const errors = Array.from(this.controlMap).reduce(\n      (acc, [pathWithTag, control]) => {\n        if (this.dirtyPathsSet.has(pathWithTag)) {\n          return acc;\n        }\n        const path = getPathFromTagPath(pathWithTag);\n        acc[path] = isEmpty(control.errors) ? null : control.errors;\n        return acc;\n      },\n      {} as Dictionary<FormErrors>,\n    );\n    const result = fromPairs(\n      Object.entries(errors ?? {}).filter(([_k, v]) => !!v),\n    );\n\n    this.formErrors = isEmpty(result) ? null : result;\n  }\n\n  // 当某个 field 发生数据变化，返回其相关 oneOf path 是否应该移除\n  // 仅当当前 field 中 oneOf 条件与当前数据不匹配，\n  private resolveExpiredPath(field: OperandField, currentValue: any) {\n    const { dirtyPaths, validPaths } = matchValueAgainstOneOf(\n      field,\n      currentValue,\n    );\n    const otherFieldStatus = this.fields\n      .filter(i => getOperandPath(i) !== getOperandPath(field))\n      .map(field => ({\n        path: getOperandPath(field),\n        result: matchValueAgainstOneOf(\n          field,\n          this.controlMap.get(getOperandPath(field))?.value,\n        ),\n      }));\n\n    const newDirtyPaths = validPaths.filter(path => {\n      // 当前 valid path 在其他 field 中为 dirty，若该 field 本身也为 dirty 则忽略该影响，仍然判定为 valid，否则（该 field 有效）认定为 dirty\n      const fieldCandidates = otherFieldStatus.filter(status =>\n        status.result.dirtyPaths.includes(path),\n      );\n      return fieldCandidates.some(\n        ({ path }) =>\n          !otherFieldStatus.some(status =>\n            status.result.dirtyPaths.includes(path),\n          ),\n      );\n    });\n    return {\n      dirtyPaths: [...dirtyPaths, ...newDirtyPaths],\n      validPaths: validPaths.filter(path => !newDirtyPaths.includes(path)),\n    };\n  }\n\n  private initializeFormDataArrayProperty(\n    state: FormDataState,\n    pathBeforeIndex: string,\n    pathAfterIndex: string,\n    value: any,\n  ) {\n    if (state.getIn([...pathToArray(pathBeforeIndex), 0])) {\n      return state;\n    }\n    const item = $Map({}).setIn(pathToArray(pathAfterIndex), value);\n    const list = List([item]);\n    return state.setIn(pathToArray(pathBeforeIndex), list);\n  }\n\n  submit() {\n    this.refreshValidation();\n    this.form.onSubmit(null);\n  }\n}\n","<form\n  auiForm\n  [aclScrollToFirstInvalid]=\"!!formErrors\"\n  #form=\"ngForm\"\n  [auiFormLabelPosition]=\"labelPosition\"\n  [auiFormLabelWidth]=\"labelWidth\"\n>\n  <!-- normal fields -->\n  <ng-container *ngFor=\"let field of normalFields\">\n    <acl-operand-field\n      [fields]=\"fields\"\n      [field]=\"field\"\n      [formDataState]=\"formDataState\"\n      [readonly]=\"readonly\"\n      [customDescription]=\"\n        customDescriptions | pure: getCustomDescription:field\n      \"\n      (valueChange)=\"fieldValueChange($event)\"\n      [remoteModuleDefinition]=\"remoteModuleDefinition$ | async\"\n    >\n    </acl-operand-field>\n  </ng-container>\n\n  <!-- field groups 兼容，需要保留-->\n  <ng-container *ngFor=\"let group of fieldGroups\">\n    <acl-operand-field-group\n      [fields]=\"fields\"\n      [fieldGroup]=\"group\"\n      [formDataState]=\"formDataState\"\n      [formErrors]=\"formErrors\"\n      [readonly]=\"readonly\"\n      (valueChange)=\"fieldValueChange($event)\"\n      [customDescriptions]=\"customDescriptions\"\n    >\n    </acl-operand-field-group>\n  </ng-container>\n\n  <!-- array field groups 兼容，需要保留 -->\n  <ng-container *ngFor=\"let group of arrayFieldGroups\">\n    <acl-operand-array-field-group\n      [arrayFieldGroup]=\"group\"\n      [formDataState]=\"formDataState\"\n      [readonly]=\"readonly\"\n      (valueChange)=\"fieldValueChange($event)\"\n      (itemRemove)=\"deleteFormData($event)\"\n    >\n    </acl-operand-array-field-group>\n  </ng-container>\n\n  <!-- advanced fields -->\n  <ng-container *ngIf=\"advancedFields?.length\">\n    <acl-operand-advanced-field-group\n      [fields]=\"fields\"\n      [fieldList]=\"advancedFields\"\n      [formDataState]=\"formDataState\"\n      [readonly]=\"readonly\"\n      (valueChange)=\"fieldValueChange($event)\"\n    ></acl-operand-advanced-field-group>\n  </ng-container>\n</form>\n"]}

package/esm2022/lib/crd-form/helper.mjs

@@ -0,0 +1,32 @@
+import { differenceBy } from 'lodash-es';
+import { convertValue, getOneOfMap, getOperandPath, getPathFromTagPath, normalizePath, } from '../utils';
+// 去除 others 和 paths 中主 path 相同的部分
+export function differPathsTag(paths, others) {
+    return differenceBy(paths, others, pathWithTag => getPathFromTagPath(pathWithTag));
+}
+export function getAllOtherTagPath(fields, paths) {
+    return fields
+        .map(path => getOperandPath(path))
+        .filter(path => !paths.includes(path));
+}
+export function matchValueAgainstOneOf(field, currentValue) {
+    // oneOfMap 里应当为 tagged path
+    const oneOfMap = getOneOfMap(field);
+    // 使用两个 set 处理多条 OneOf 中存在公共 path 的情形
+    const dirtyPathSet = new Set();
+    const validPathSet = new Set();
+    Object.entries(oneOfMap).forEach(([value, paths]) => {
+        paths.forEach(path => {
+            (convertValue(value, field.type) === currentValue
+                ? validPathSet
+                : dirtyPathSet).add(path);
+        });
+    });
+    return {
+        dirtyPaths: Array.from(dirtyPathSet)
+            .filter(i => !validPathSet.has(i))
+            .map(path => normalizePath(path)),
+        validPaths: Array.from(validPathSet).map(path => normalizePath(path)),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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