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

package/esm2022/services/form-row-duplicate/form-row-duplicate.service.mjs

@@ -0,0 +1,280 @@
+import { Injectable, IterableDiffers, } from '@angular/core';
+import { cloneDeep, set, unset } from 'lodash-es';
+import { isEqual } from '../../utils';
+import * as i0 from "@angular/core";
+export const DUPLICATE_ERROR_KEY = 'duplicateError';
+// IDENTICAL: 检测具有互反性，传递性。a与b重复，b与c重复，a必然与c重复，此程度上可进行优化
+// FULL: 不要求检测具有互反性，传递性。a与b判别重复，b与c判别重复，a未必与c判别重复
+// 主要是针对一些复杂的自定义匹配重复的使用场景，FULL模式采用全检查
+export var DUPLICATION_JUSTIFY_STRATEGY;
+(function (DUPLICATION_JUSTIFY_STRATEGY) {
+    DUPLICATION_JUSTIFY_STRATEGY["IDENTICAL"] = "identical";
+    DUPLICATION_JUSTIFY_STRATEGY["FULL"] = "full";
+})(DUPLICATION_JUSTIFY_STRATEGY || (DUPLICATION_JUSTIFY_STRATEGY = {}));
+export const STRATEGY_JUDGE_MAPPER = {
+    [DUPLICATION_JUSTIFY_STRATEGY.IDENTICAL]: identicalStrategyCheck,
+    [DUPLICATION_JUSTIFY_STRATEGY.FULL]: fullStrategyCheck,
+};
+// use in component lifecycle
+export class ValidateRowDuplicateService {
+    /**
+     * @param differFactory: used to create support differ, which can be provided by user
+     */
+    constructor(arrayDiffers) {
+        this.arrayDiffers = arrayDiffers;
+        // used to save last value, to check whether if control changed
+        this.controlValueMap = new WeakMap();
+        // used to save errors，to solve validators concurrently work(second validator can't get error from previous validator in one turn)
+        this.errorMap = new WeakMap();
+    }
+    createFormArrayValidator({ rowKeys, formArray, valueMapFn = defaultValueMapFn, initData = [], matchesFn = matchValue, strategy = DUPLICATION_JUSTIFY_STRATEGY.IDENTICAL, }) {
+        const keys = formatKeys(rowKeys);
+        if (!this.rowsDiffer) {
+            this.rowsDiffer = this.arrayDiffers.find([]).create();
+        }
+        this.initFormArraySizeChange(formArray, this.rowsDiffer, keys, valueMapFn, matchesFn, strategy, initData);
+        return (control) => {
+            const { controls } = formArray;
+            const lastValue = this.controlValueMap.get(control);
+            if (control.pristine) {
+                return null;
+            }
+            // nothing change
+            const currentValue = getValueInKeys(control.value, keys, valueMapFn);
+            this.controlValueMap.set(control, currentValue);
+            if (lastValue) {
+                let identical = true;
+                Object.entries(keys).forEach(([key, props]) => {
+                    if (!equalsValue(props, currentValue[key], lastValue[key])) {
+                        identical = false;
+                    }
+                });
+                if (identical) {
+                    return this.errorMap.get(control);
+                }
+            }
+            const diffKeys = lastValue
+                ? diffKeysByValue(keys, currentValue, lastValue)
+                : keys;
+            // 和上次值存在差异，可将老数据作为删除行处理
+            if (lastValue) {
+                this.handleRemoveRowValue(diffKeys, controls, lastValue, valueMapFn, control, matchesFn, strategy, initData);
+            }
+            // 更新后的状态，可能导致其他行出现新的重复
+            const otherControls = controls.filter(ctrl => ctrl !== control);
+            const ctrlError = {};
+            otherControls.forEach(ctrl => {
+                const otherValue = getValueInKeys(ctrl.value, diffKeys, valueMapFn);
+                const othersError = {};
+                // keys 中分别比较 如果 otherValue 与 currentValue 在某个key下，数据相同，则说明此 key 存在重复错误
+                Object.entries(diffKeys).forEach(([key, props]) => {
+                    if (matchesFn(props, otherValue[key], currentValue[key])) {
+                        set(othersError, [key], currentValue[key]);
+                        set(ctrlError, key, currentValue[key]);
+                    }
+                });
+                this.addDuplicateError(othersError, ctrl, true);
+            });
+            (initData || []).forEach(initRow => {
+                Object.entries(diffKeys).forEach(([key, props]) => {
+                    if (matchesFn(props, initRow[key], currentValue[key])) {
+                        set(ctrlError, key, currentValue[key]);
+                    }
+                });
+            });
+            this.addDuplicateError(ctrlError, control);
+            return this.errorMap.get(control);
+        };
+    }
+    handleRemoveRowValue(keys, controls, staleValue, mapFn, selfControl, matchesFn, strategy, initData) {
+        if (selfControl) {
+            this.removeDuplicateError(Object.keys(keys), selfControl);
+        }
+        const toRemoveError = STRATEGY_JUDGE_MAPPER[strategy](keys, controls, staleValue, mapFn, matchesFn, initData);
+        (toRemoveError || []).forEach(({ key, control }) => this.removeDuplicateError([key], control, true));
+    }
+    initFormArraySizeChange(formArray, rowsDiffer, keys, mapFn, matchesFn, strategy, initData) {
+        if (!this.formArraySizeSub) {
+            this.formArraySizeSub = formArray.valueChanges.subscribe(_ => {
+                const { controls } = formArray;
+                const rowsDiff = rowsDiffer.diff(controls);
+                if (rowsDiff) {
+                    // on deleting row
+                    rowsDiff.forEachRemovedItem(record => {
+                        const rawValue = getValueInKeys(record.item.value, keys, mapFn);
+                        this.handleRemoveRowValue(keys, controls, rawValue, mapFn, undefined, matchesFn, strategy, initData);
+                    });
+                }
+            });
+        }
+    }
+    addDuplicateError(errorInfo, control, setControl = false) {
+        const errors = cloneDeep(this.errorMap.get(control)) || {};
+        // already has error,no need to add
+        if (!Object.keys(errorInfo).some(key => errors?.[DUPLICATE_ERROR_KEY]?.[key] == null)) {
+            return;
+        }
+        Object.keys(errorInfo).forEach(key => {
+            set(errors, [DUPLICATE_ERROR_KEY, key], errorInfo[key]);
+        });
+        this.errorMap.set(control, errors);
+        if (setControl) {
+            // 当设置重复报错时,需要注意保留原来的报错
+            const controlError = cloneDeep(control.errors);
+            unset(controlError, [DUPLICATE_ERROR_KEY]);
+            const error = { ...controlError, ...this.errorMap.get(control) };
+            control.setErrors(Object.keys(error).length === 0 ? null : error, {
+                emitEvent: false,
+            });
+            // control's error should be shown,it's not pristine any more
+            control.markAsDirty();
+        }
+    }
+    removeDuplicateError(errorInfo, control, setControl = false) {
+        const errors = cloneDeep(this.errorMap.get(control));
+        // no need to remove error
+        if (!errorInfo.some(key => errors?.[DUPLICATE_ERROR_KEY]?.[key] != null)) {
+            return;
+        }
+        errorInfo.forEach(key => {
+            unset(errors, [DUPLICATE_ERROR_KEY, key]);
+        });
+        this.errorMap.set(control, Object.keys(errors?.[DUPLICATE_ERROR_KEY] || {}).length ? errors : null);
+        if (setControl) {
+            const controlError = cloneDeep(control.errors) || {};
+            unset(controlError, [DUPLICATE_ERROR_KEY]);
+            const error = { ...controlError, ...this.errorMap.get(control) };
+            control.setErrors(Object.keys(error).length === 0 ? null : error, {
+                emitEvent: false,
+            });
+        }
+    }
+    ngOnDestroy() {
+        if (this.formArraySizeSub) {
+            this.formArraySizeSub.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ValidateRowDuplicateService, deps: [{ token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ValidateRowDuplicateService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ValidateRowDuplicateService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.IterableDiffers }] });
+// 仅返回keys规则下，currentValue与lastValue存在不同的部分key
+function diffKeysByValue(keys, currentValue, lastValue) {
+    const obj = {};
+    Object.entries(keys).forEach(([key, props]) => {
+        if (!equalsValue(props, currentValue[key], lastValue[key])) {
+            obj[key] = props;
+        }
+    });
+    return obj;
+}
+// 指定属性下，value1 和 value2 对于所有的属性存在有效值，并且相同，此时可判定重复
+function matchValue(props, value1, value2) {
+    return !props.some(prop => unCheckedValue(value1, prop) || value1[prop] !== value2[prop]);
+}
+// 指定属性下，value1 和 value2 对于所有的属性相同，此时可判定 value1 , value2 相等
+function equalsValue(props, value1, value2) {
+    return !props.some(prop => !isEqual(value1[prop], value2[prop]));
+}
+/**
+ * @param keys ['protocol',{complex: ['containerPort','hostPort']}]
+ * @returns [{protocol: ['protocol']}, {complex: ['containerPort','hostPort']}]
+ */
+function formatKeys(keys = []) {
+    const obj = {};
+    keys.forEach(keyObj => {
+        if (typeof keyObj === 'string') {
+            obj[keyObj] = [keyObj];
+            return;
+        }
+        Object.keys(keyObj).forEach(key => {
+            obj[key] = keyObj[key];
+        });
+    });
+    return obj;
+}
+function unCheckedValue(value, key) {
+    return value?.[key] == null || value[key] === '';
+}
+function defaultValueMapFn(data, prop) {
+    return data?.[prop];
+}
+/**
+ * @param value input value,which should include all key behind keys
+ * @param keys formatted keys, key is error key, like [{'containerPort':['containerPort']},{'complexError':['containerPort','hostPort']}]
+ * @returns
+ */
+function getValueInKeys(value, keys, mapFn) {
+    const obj = {};
+    Object.entries(keys).forEach(([key, props]) => {
+        props.forEach(prop => {
+            set(obj, [key, prop], mapFn(value, prop));
+        });
+    });
+    return obj;
+}
+// 互反性检查
+function identicalStrategyCheck(keys, controls, staleValue, mapFn, matchesFn, initData) {
+    const errorsCounter = {};
+    Object.entries(keys).forEach(([key, props]) => {
+        errorsCounter[key] = { controls: new Set(), count: 0 };
+        initData.forEach(initRow => {
+            if (matchValue(props, initRow[key], staleValue[key])) {
+                errorsCounter[key].count++;
+            }
+        });
+        controls.forEach(ctrl => {
+            const controlValue = getValueInKeys(ctrl.value, keys, mapFn);
+            // 互反性策略，要求和老数据相比，因此只有和老数据相同，但和任意当前其他数据不同的，才需要去掉之前的错误
+            if (matchesFn(props, controlValue[key], staleValue[key])) {
+                errorsCounter[key].count++;
+                errorsCounter[key].controls.add(ctrl);
+            }
+        });
+    });
+    const toRemoveError = [];
+    Object.entries(errorsCounter).forEach(([key, item]) => {
+        if (item.count === 1) {
+            item.controls.forEach(control => {
+                toRemoveError.push({ key, control });
+            });
+        }
+    });
+    return toRemoveError;
+}
+// 全检查
+function fullStrategyCheck(keys, controls, _, mapFn, matchesFn, initData) {
+    const controlError = new Map();
+    Object.entries(keys).forEach(([key, props]) => {
+        controls.forEach(ctrl => {
+            const controlValue = getValueInKeys(ctrl.value, keys, mapFn);
+            // 全检查策略，最终错误 key 对应 count 为 0 的ctrl会去掉相应错误
+            controlError.set(ctrl, { key, count: 0 });
+            initData.forEach(initRow => {
+                if (matchValue(props, initRow[key], controlValue)) {
+                    const rawCount = controlError.get(ctrl).count;
+                    controlError.set(ctrl, { key, count: rawCount + 1 });
+                }
+            });
+            controls
+                .filter(otherControl => otherControl !== ctrl)
+                .forEach(otherControl => {
+                const otherValue = getValueInKeys(otherControl.value, keys, mapFn);
+                if (matchesFn(props, controlValue[key], otherValue[key])) {
+                    const rawCount = controlError.get(ctrl).count;
+                    controlError.set(ctrl, { key, count: rawCount + 1 });
+                }
+            });
+        });
+    });
+    const toRemoveError = [];
+    controlError.forEach(({ count, key }, control) => {
+        if (count === 0) {
+            toRemoveError.push({ key, control });
+        }
+    });
+    return toRemoveError;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-row-duplicate.service.js","sourceRoot":"","sources":["../../../../../../libs/dynamic-plugin-shared/src/services/form-row-duplicate/form-row-duplicate.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Injectable,\n  IterableDiffer,\n  IterableDiffers,\n  OnDestroy,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  FormArray,\n  FormGroup,\n  ValidationErrors,\n  ValidatorFn,\n} from '@angular/forms';\nimport { cloneDeep, set, unset } from 'lodash-es';\nimport { Subscription } from 'rxjs';\n\nimport { isEqual } from '../../utils';\n\nexport const DUPLICATE_ERROR_KEY = 'duplicateError';\n\ntype RowKeys = Array<string | Record<string, string[]>>;\ntype FormatKeys = Record<string, string[]>;\nexport type FormatValue = Record<string, any>;\n\nexport type MatchValueFn = (\n  props: string[],\n  value1: FormatValue,\n  value2: FormatValue,\n) => boolean;\n\nexport type StrategyFn = (\n  keys: FormatKeys,\n  controls: AbstractControl[],\n  staleValue: FormatValue,\n  mapFn: ValueMapFn,\n  matchesFn: MatchValueFn,\n  initData: any[],\n) => Array<{ key: string; control: AbstractControl }>;\n\n// IDENTICAL: 检测具有互反性，传递性。a与b重复，b与c重复，a必然与c重复，此程度上可进行优化\n// FULL: 不要求检测具有互反性，传递性。a与b判别重复，b与c判别重复，a未必与c判别重复\n// 主要是针对一些复杂的自定义匹配重复的使用场景，FULL模式采用全检查\nexport enum DUPLICATION_JUSTIFY_STRATEGY {\n  IDENTICAL = 'identical',\n  FULL = 'full',\n}\n\nexport const STRATEGY_JUDGE_MAPPER: Record<\n  DUPLICATION_JUSTIFY_STRATEGY,\n  StrategyFn\n> = {\n  [DUPLICATION_JUSTIFY_STRATEGY.IDENTICAL]: identicalStrategyCheck,\n  [DUPLICATION_JUSTIFY_STRATEGY.FULL]: fullStrategyCheck,\n};\n\n// use in component lifecycle\n@Injectable()\nexport class ValidateRowDuplicateService implements OnDestroy {\n  // used to detect all controls data change\n  private rowsDiffer: IterableDiffer<AbstractControl>;\n\n  /**\n   * @param differFactory: used to create support differ, which can be provided by user\n   */\n  constructor(private readonly arrayDiffers: IterableDiffers) {}\n\n  // used to save last value, to check whether if control changed\n  private readonly controlValueMap = new WeakMap<\n    AbstractControl,\n    FormatValue\n  >();\n\n  // used to save errors，to solve validators concurrently work(second validator can't get error from previous validator in one turn)\n  private readonly errorMap = new WeakMap<AbstractControl, ValidationErrors>();\n\n  private formArraySizeSub: Subscription;\n\n  createFormArrayValidator({\n    rowKeys,\n    formArray,\n    valueMapFn = defaultValueMapFn,\n    initData = [],\n    matchesFn = matchValue,\n    strategy = DUPLICATION_JUSTIFY_STRATEGY.IDENTICAL,\n  }: {\n    rowKeys: RowKeys;\n    formArray: FormArray;\n    valueMapFn?: any;\n    initData?: any[];\n    matchesFn?: MatchValueFn;\n    strategy?: DUPLICATION_JUSTIFY_STRATEGY;\n  }): ValidatorFn {\n    const keys = formatKeys(rowKeys);\n    if (!this.rowsDiffer) {\n      this.rowsDiffer = this.arrayDiffers.find([]).create();\n    }\n\n    this.initFormArraySizeChange(\n      formArray,\n      this.rowsDiffer,\n      keys,\n      valueMapFn,\n      matchesFn,\n      strategy,\n      initData,\n    );\n\n    return (control: FormGroup) => {\n      const { controls } = formArray;\n      const lastValue = this.controlValueMap.get(control);\n      if (control.pristine) {\n        return null;\n      }\n      // nothing change\n      const currentValue = getValueInKeys(control.value, keys, valueMapFn);\n      this.controlValueMap.set(control, currentValue);\n      if (lastValue) {\n        let identical = true;\n        Object.entries(keys).forEach(([key, props]) => {\n          if (!equalsValue(props, currentValue[key], lastValue[key])) {\n            identical = false;\n          }\n        });\n        if (identical) {\n          return this.errorMap.get(control);\n        }\n      }\n      const diffKeys = lastValue\n        ? diffKeysByValue(keys, currentValue, lastValue)\n        : keys;\n      // 和上次值存在差异，可将老数据作为删除行处理\n      if (lastValue) {\n        this.handleRemoveRowValue(\n          diffKeys,\n          controls,\n          lastValue,\n          valueMapFn,\n          control,\n          matchesFn,\n          strategy,\n          initData,\n        );\n      }\n      // 更新后的状态，可能导致其他行出现新的重复\n      const otherControls = controls.filter(ctrl => ctrl !== control);\n      const ctrlError: Record<string, any> = {};\n      otherControls.forEach(ctrl => {\n        const otherValue = getValueInKeys(ctrl.value, diffKeys, valueMapFn);\n        const othersError: Record<string, any> = {};\n        // keys 中分别比较 如果 otherValue 与 currentValue 在某个key下，数据相同，则说明此 key 存在重复错误\n        Object.entries(diffKeys).forEach(([key, props]) => {\n          if (matchesFn(props, otherValue[key], currentValue[key])) {\n            set(othersError, [key], currentValue[key]);\n            set(ctrlError, key, currentValue[key]);\n          }\n        });\n        this.addDuplicateError(othersError, ctrl, true);\n      });\n      (initData || []).forEach(initRow => {\n        Object.entries(diffKeys).forEach(([key, props]) => {\n          if (matchesFn(props, initRow[key], currentValue[key])) {\n            set(ctrlError, key, currentValue[key]);\n          }\n        });\n      });\n      this.addDuplicateError(ctrlError, control);\n      return this.errorMap.get(control);\n    };\n  }\n\n  private handleRemoveRowValue(\n    keys: FormatKeys,\n    controls: AbstractControl[],\n    staleValue: FormatValue,\n    mapFn: ValueMapFn,\n    selfControl?: AbstractControl,\n    matchesFn?: MatchValueFn,\n    strategy?: DUPLICATION_JUSTIFY_STRATEGY,\n    initData?: any[],\n  ) {\n    if (selfControl) {\n      this.removeDuplicateError(Object.keys(keys), selfControl);\n    }\n    const toRemoveError = STRATEGY_JUDGE_MAPPER[strategy](\n      keys,\n      controls,\n      staleValue,\n      mapFn,\n      matchesFn,\n      initData,\n    );\n    (toRemoveError || []).forEach(({ key, control }) =>\n      this.removeDuplicateError([key], control, true),\n    );\n  }\n\n  private initFormArraySizeChange(\n    formArray: FormArray,\n    rowsDiffer: IterableDiffer<AbstractControl>,\n    keys: FormatKeys,\n    mapFn: ValueMapFn,\n    matchesFn: MatchValueFn,\n    strategy: DUPLICATION_JUSTIFY_STRATEGY,\n    initData?: any[],\n  ) {\n    if (!this.formArraySizeSub) {\n      this.formArraySizeSub = formArray.valueChanges.subscribe(_ => {\n        const { controls } = formArray;\n        const rowsDiff = rowsDiffer.diff(controls);\n        if (rowsDiff) {\n          // on deleting row\n          rowsDiff.forEachRemovedItem(record => {\n            const rawValue = getValueInKeys(record.item.value, keys, mapFn);\n            this.handleRemoveRowValue(\n              keys,\n              controls,\n              rawValue,\n              mapFn,\n              undefined,\n              matchesFn,\n              strategy,\n              initData,\n            );\n          });\n        }\n      });\n    }\n  }\n\n  private addDuplicateError(\n    errorInfo: Record<string, any>,\n    control: AbstractControl,\n    setControl = false,\n  ) {\n    const errors = cloneDeep(this.errorMap.get(control)) || {};\n    // already has error,no need to add\n    if (\n      !Object.keys(errorInfo).some(\n        key => errors?.[DUPLICATE_ERROR_KEY]?.[key] == null,\n      )\n    ) {\n      return;\n    }\n\n    Object.keys(errorInfo).forEach(key => {\n      set(errors, [DUPLICATE_ERROR_KEY, key], errorInfo[key]);\n    });\n    this.errorMap.set(control, errors);\n    if (setControl) {\n      // 当设置重复报错时,需要注意保留原来的报错\n      const controlError = cloneDeep(control.errors);\n      unset(controlError, [DUPLICATE_ERROR_KEY]);\n      const error = { ...controlError, ...this.errorMap.get(control) };\n      control.setErrors(Object.keys(error).length === 0 ? null : error, {\n        emitEvent: false,\n      });\n\n      // control's error should be shown,it's not pristine any more\n      control.markAsDirty();\n    }\n  }\n\n  private removeDuplicateError(\n    errorInfo: string[],\n    control: AbstractControl,\n    setControl = false,\n  ) {\n    const errors = cloneDeep(this.errorMap.get(control));\n    // no need to remove error\n    if (!errorInfo.some(key => errors?.[DUPLICATE_ERROR_KEY]?.[key] != null)) {\n      return;\n    }\n    errorInfo.forEach(key => {\n      unset(errors, [DUPLICATE_ERROR_KEY, key]);\n    });\n    this.errorMap.set(\n      control,\n      Object.keys(errors?.[DUPLICATE_ERROR_KEY] || {}).length ? errors : null,\n    );\n    if (setControl) {\n      const controlError: Record<string, any> = cloneDeep(control.errors) || {};\n      unset(controlError, [DUPLICATE_ERROR_KEY]);\n\n      const error = { ...controlError, ...this.errorMap.get(control) };\n      control.setErrors(Object.keys(error).length === 0 ? null : error, {\n        emitEvent: false,\n      });\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.formArraySizeSub) {\n      this.formArraySizeSub.unsubscribe();\n    }\n  }\n}\n\n// 仅返回keys规则下，currentValue与lastValue存在不同的部分key\nfunction diffKeysByValue(\n  keys: FormatKeys,\n  currentValue: FormatValue,\n  lastValue: FormatValue,\n) {\n  const obj: FormatKeys = {};\n  Object.entries(keys).forEach(([key, props]) => {\n    if (!equalsValue(props, currentValue[key], lastValue[key])) {\n      obj[key] = props;\n    }\n  });\n  return obj;\n}\n\n// 指定属性下，value1 和 value2 对于所有的属性存在有效值，并且相同，此时可判定重复\nfunction matchValue(props: string[], value1: FormatValue, value2: FormatValue) {\n  return !props.some(\n    prop => unCheckedValue(value1, prop) || value1[prop] !== value2[prop],\n  );\n}\n\n// 指定属性下，value1 和 value2 对于所有的属性相同，此时可判定 value1 , value2 相等\nfunction equalsValue(\n  props: string[],\n  value1: FormatValue,\n  value2: FormatValue,\n) {\n  return !props.some(prop => !isEqual(value1[prop], value2[prop]));\n}\n\n/**\n * @param keys ['protocol',{complex: ['containerPort','hostPort']}]\n * @returns [{protocol: ['protocol']}, {complex: ['containerPort','hostPort']}]\n */\nfunction formatKeys(keys: RowKeys = []): FormatKeys {\n  const obj: FormatKeys = {};\n  keys.forEach(keyObj => {\n    if (typeof keyObj === 'string') {\n      obj[keyObj] = [keyObj];\n      return;\n    }\n    Object.keys(keyObj).forEach(key => {\n      obj[key] = keyObj[key];\n    });\n  });\n  return obj;\n}\n\nfunction unCheckedValue(value: FormatValue, key: string) {\n  return value?.[key] == null || value[key] === '';\n}\n\nfunction defaultValueMapFn(data: any, prop: string) {\n  return data?.[prop];\n}\n\ntype ValueMapFn = (data: any, prop?: string) => any;\n\n/**\n * @param value input value,which should include all key behind keys\n * @param keys formatted keys, key is error key, like [{'containerPort':['containerPort']},{'complexError':['containerPort','hostPort']}]\n * @returns\n */\nfunction getValueInKeys(\n  value: any,\n  keys: FormatKeys,\n  mapFn: ValueMapFn,\n): FormatValue {\n  const obj = {};\n  Object.entries(keys).forEach(([key, props]) => {\n    props.forEach(prop => {\n      set(obj, [key, prop], mapFn(value, prop));\n    });\n  });\n  return obj;\n}\n\n// 互反性检查\nfunction identicalStrategyCheck(\n  keys: FormatKeys,\n  controls: AbstractControl[],\n  staleValue: FormatValue,\n  mapFn: ValueMapFn,\n  matchesFn: MatchValueFn,\n  initData: any[],\n) {\n  const errorsCounter: Record<\n    string,\n    { controls: Set<AbstractControl>; count: number }\n  > = {};\n\n  Object.entries(keys).forEach(([key, props]) => {\n    errorsCounter[key] = { controls: new Set(), count: 0 };\n    initData.forEach(initRow => {\n      if (matchValue(props, initRow[key], staleValue[key])) {\n        errorsCounter[key].count++;\n      }\n    });\n    controls.forEach(ctrl => {\n      const controlValue = getValueInKeys(ctrl.value, keys, mapFn);\n      // 互反性策略，要求和老数据相比，因此只有和老数据相同，但和任意当前其他数据不同的，才需要去掉之前的错误\n      if (matchesFn(props, controlValue[key], staleValue[key])) {\n        errorsCounter[key].count++;\n        errorsCounter[key].controls.add(ctrl);\n      }\n    });\n  });\n  const toRemoveError: Array<{ key: string; control: AbstractControl }> = [];\n  Object.entries(errorsCounter).forEach(([key, item]) => {\n    if (item.count === 1) {\n      item.controls.forEach(control => {\n        toRemoveError.push({ key, control });\n      });\n    }\n  });\n  return toRemoveError;\n}\n\n// 全检查\nfunction fullStrategyCheck(\n  keys: FormatKeys,\n  controls: AbstractControl[],\n  _: FormatValue,\n  mapFn: ValueMapFn,\n  matchesFn: MatchValueFn,\n  initData: any[],\n) {\n  const controlError: Map<AbstractControl, { key: string; count: number }> =\n    new Map();\n\n  Object.entries(keys).forEach(([key, props]) => {\n    controls.forEach(ctrl => {\n      const controlValue = getValueInKeys(ctrl.value, keys, mapFn);\n      // 全检查策略，最终错误 key 对应 count 为 0 的ctrl会去掉相应错误\n      controlError.set(ctrl, { key, count: 0 });\n      initData.forEach(initRow => {\n        if (matchValue(props, initRow[key], controlValue)) {\n          const rawCount = controlError.get(ctrl).count;\n          controlError.set(ctrl, { key, count: rawCount + 1 });\n        }\n      });\n      controls\n        .filter(otherControl => otherControl !== ctrl)\n        .forEach(otherControl => {\n          const otherValue = getValueInKeys(otherControl.value, keys, mapFn);\n          if (matchesFn(props, controlValue[key], otherValue[key])) {\n            const rawCount = controlError.get(ctrl).count;\n            controlError.set(ctrl, { key, count: rawCount + 1 });\n          }\n        });\n    });\n  });\n  const toRemoveError: Array<{ key: string; control: AbstractControl }> = [];\n  controlError.forEach(({ count, key }, control) => {\n    if (count === 0) {\n      toRemoveError.push({ key, control });\n    }\n  });\n  return toRemoveError;\n}\n"]}

package/esm2022/services/index.mjs

@@ -0,0 +1,4 @@
+export * from './on-resize.service';
+export * from './yaml-util.service';
+export * from './form-row-duplicate/form-row-duplicate.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsaURBQWlELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29uLXJlc2l6ZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4veWFtbC11dGlsLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtLXJvdy1kdXBsaWNhdGUvZm9ybS1yb3ctZHVwbGljYXRlLnNlcnZpY2UnO1xuIl19

package/esm2022/services/on-resize.service.mjs

@@ -0,0 +1,52 @@
+import { Directive, Injectable, Injector, NgZone, } from '@angular/core';
+import { animationFrameScheduler, fromEvent, auditTime } from 'rxjs';
+import * as i0 from "@angular/core";
+const RESIZE_SCHEDULER = animationFrameScheduler;
+// 提供全局的监听事件
+export class ListenResizeDirective {
+    constructor(injector) {
+        this._resizeService = injector.get(OnResizeChangeService);
+    }
+    ngAfterViewInit() {
+        this._resizeService.subscribe(this);
+    }
+    ngOnDestroy() {
+        this._resizeService.unsubscribe(this);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ListenResizeDirective, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ListenResizeDirective, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ListenResizeDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+export class OnResizeChangeService {
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        this._resizeListeners = new Set();
+        this.ngZone.runOutsideAngular(() => Promise.resolve().then(() => {
+            fromEvent(window, 'resize')
+                .pipe(
+            // 收集多个resize
+            auditTime(0, RESIZE_SCHEDULER))
+                .subscribe(_ => {
+                this._resizeListeners.forEach(i => i.onResize());
+            });
+        }));
+    }
+    subscribe(item) {
+        this._resizeListeners.add(item);
+        item.onResize();
+    }
+    unsubscribe(item) {
+        this._resizeListeners.delete(item);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: OnResizeChangeService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: OnResizeChangeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: OnResizeChangeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/yaml-util.service.mjs

@@ -0,0 +1,99 @@
+import { TOKEN_BASE_DOMAIN } from '@alauda-fe/dynamic-plugin-sdk';
+import { Inject, Injectable } from '@angular/core';
+import { get, sortBy } from 'lodash-es';
+import { ANNOTATIONS, LABELS, METADATA } from '../constants';
+import { emptyObjectRemoveRuleFactory, prefixFilterRuleFactory, stringify, yamlFilterField, } from '../utils';
+import * as i0 from "@angular/core";
+export class YamlUtilService {
+    constructor(baseDomain) {
+        this.baseDomain = baseDomain;
+    }
+    // https://confluence.alauda.cn/pages/viewpage.action?pageId=112060211
+    // 所有资源规则全平台通用
+    getConciseResource(r) {
+        const commonFilters = [
+            'metadata.namespace',
+            'metadata.managedFields',
+            'metadata.creationTimestamp',
+            'metadata.generation',
+            'metadata.resourceVersion',
+            'metadata.uid',
+            'metadata.ownerReferences',
+            'metadata.finalizers',
+            'metadata.selfLink',
+            `metadata.labels.['app.${this.baseDomain}/uuid']`,
+            prefixFilterRuleFactory(this.baseDomain, [METADATA, ANNOTATIONS]),
+            prefixFilterRuleFactory('kubernetes.io', [METADATA, ANNOTATIONS], 'includes'),
+            'status',
+        ];
+        const specificFilters = [];
+        switch (r.kind) {
+            case 'Application': {
+                specificFilters.push('metadata.labels.sync-from-helmrequest');
+                break;
+            }
+            case 'Deployment':
+            case 'StatefulSet':
+            case 'DaemonSet': {
+                specificFilters.push('spec.template.annotations.updateTimestamp');
+                break;
+            }
+            case 'Job': {
+                specificFilters.push('spec.selector.matchLabels', 'spec.template.metadata.labels.controller-uid', `${METADATA}.${LABELS}.controller-uid`, prefixFilterRuleFactory('batch.kubernetes.io/controller-uid', ['spec', 'template', METADATA, LABELS], 'includes'));
+                break;
+            }
+            case 'PersistentVolumeClaim': {
+                specificFilters.push(prefixFilterRuleFactory('pv.kubernetes.io', [METADATA, ANNOTATIONS], 'startsWith'), prefixFilterRuleFactory('volume.beta.kubernetes.io', [METADATA, ANNOTATIONS], 'startsWith'), 'spec.volumeName');
+                break;
+            }
+            case 'Service': {
+                specificFilters.push(resource => {
+                    // ExternalName 类型的 Service 没有 ports
+                    const ports = get(resource, ['spec', 'ports']) ?? [];
+                    return ports.map((_, i) => ['spec', 'ports', `[${i}]`, 'nodePort'].join('.'));
+                }, 'spec.clusterIPs', 'spec.clusterIP', 'spec.ipFamilies', 'spec.ipFamilyPolicy');
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        specificFilters.push(emptyObjectRemoveRuleFactory([METADATA, ANNOTATIONS]), emptyObjectRemoveRuleFactory([METADATA, LABELS]));
+        return yamlFilterField(r, [...commonFilters, ...specificFilters]);
+    }
+    /**
+     *
+     *
+     * @template T
+     * @param {T} resource
+     * @param {boolean} [concise=false] 精简 Yaml
+     * @param {boolean} [reduce=false] 隐藏 managedFields
+     * @returns
+     * @memberof YamlUtilService
+     */
+    generateFilteredYamlResource(resource, concise = false, reduce = false) {
+        return sortBy(Array.isArray(resource) ? resource : [resource], 'kind')
+            .map((resource) => concise
+            ? this.getConciseResource(resource)
+            : reduce
+                ? yamlFilterField(resource, ['metadata.managedFields'])
+                : resource)
+            .map(res => stringify(res, {
+            strict: false,
+            sortMapEntries: true,
+        }))
+            .join('\n---\r\n\n');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: YamlUtilService, deps: [{ token: TOKEN_BASE_DOMAIN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: YamlUtilService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: YamlUtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TOKEN_BASE_DOMAIN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yaml-util.service.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/services/yaml-util.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { TOKEN_BASE_DOMAIN } from '@alauda-fe/dynamic-plugin-sdk';\nimport { Inject, Injectable } from '@angular/core';\nimport { get, sortBy } from 'lodash-es';\n\nimport { ANNOTATIONS, LABELS, METADATA } from '../constants';\nimport { Arrayable, KubernetesResource, ServicePort } from '../types';\nimport {\n  emptyObjectRemoveRuleFactory,\n  prefixFilterRuleFactory,\n  stringify,\n  yamlFilterField,\n  YamlFilterItem,\n} from '../utils';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class YamlUtilService {\n  constructor(@Inject(TOKEN_BASE_DOMAIN) private readonly baseDomain: string) {}\n\n  // https://confluence.alauda.cn/pages/viewpage.action?pageId=112060211\n  // 所有资源规则全平台通用\n  getConciseResource(r: KubernetesResource) {\n    const commonFilters: YamlFilterItem[] = [\n      'metadata.namespace',\n      'metadata.managedFields',\n      'metadata.creationTimestamp',\n      'metadata.generation',\n      'metadata.resourceVersion',\n      'metadata.uid',\n      'metadata.ownerReferences',\n      'metadata.finalizers',\n      'metadata.selfLink',\n      `metadata.labels.['app.${this.baseDomain}/uuid']`,\n      prefixFilterRuleFactory(this.baseDomain, [METADATA, ANNOTATIONS]),\n      prefixFilterRuleFactory(\n        'kubernetes.io',\n        [METADATA, ANNOTATIONS],\n        'includes',\n      ),\n      'status',\n    ];\n    const specificFilters: YamlFilterItem[] = [];\n    switch (r.kind) {\n      case 'Application': {\n        specificFilters.push('metadata.labels.sync-from-helmrequest');\n        break;\n      }\n      case 'Deployment':\n      case 'StatefulSet':\n      case 'DaemonSet': {\n        specificFilters.push('spec.template.annotations.updateTimestamp');\n        break;\n      }\n      case 'Job': {\n        specificFilters.push(\n          'spec.selector.matchLabels',\n          'spec.template.metadata.labels.controller-uid',\n          `${METADATA}.${LABELS}.controller-uid`,\n          prefixFilterRuleFactory(\n            'batch.kubernetes.io/controller-uid',\n            ['spec', 'template', METADATA, LABELS],\n            'includes',\n          ),\n        );\n        break;\n      }\n      case 'PersistentVolumeClaim': {\n        specificFilters.push(\n          prefixFilterRuleFactory(\n            'pv.kubernetes.io',\n            [METADATA, ANNOTATIONS],\n            'startsWith',\n          ),\n          prefixFilterRuleFactory(\n            'volume.beta.kubernetes.io',\n            [METADATA, ANNOTATIONS],\n            'startsWith',\n          ),\n          'spec.volumeName',\n        );\n        break;\n      }\n      case 'Service': {\n        specificFilters.push(\n          resource => {\n            // ExternalName 类型的 Service 没有 ports\n            const ports =\n              (get(resource, ['spec', 'ports']) as ServicePort[]) ?? [];\n            return ports.map((_, i) =>\n              ['spec', 'ports', `[${i}]`, 'nodePort'].join('.'),\n            );\n          },\n          'spec.clusterIPs',\n          'spec.clusterIP',\n          'spec.ipFamilies',\n          'spec.ipFamilyPolicy',\n        );\n        break;\n      }\n      default: {\n        break;\n      }\n    }\n    specificFilters.push(\n      emptyObjectRemoveRuleFactory([METADATA, ANNOTATIONS]),\n      emptyObjectRemoveRuleFactory([METADATA, LABELS]),\n    );\n    return yamlFilterField(r, [...commonFilters, ...specificFilters]);\n  }\n\n  /**\n   *\n   *\n   * @template T\n   * @param {T} resource\n   * @param {boolean} [concise=false] 精简 Yaml\n   * @param {boolean} [reduce=false] 隐藏 managedFields\n   * @returns\n   * @memberof YamlUtilService\n   */\n  generateFilteredYamlResource<T extends KubernetesResource>(\n    resource: Arrayable<T>,\n    concise = false,\n    reduce = false,\n  ) {\n    return sortBy(Array.isArray(resource) ? resource : [resource], 'kind')\n      .map((resource: T) =>\n        concise\n          ? this.getConciseResource(resource)\n          : reduce\n            ? yamlFilterField(resource, ['metadata.managedFields'])\n            : resource,\n      )\n      .map(res =>\n        stringify(res, {\n          strict: false,\n          sortMapEntries: true,\n        }),\n      )\n      .join('\\n---\\r\\n\\n');\n  }\n}\n"]}

package/esm2022/types/common.mjs

@@ -0,0 +1,6 @@
+/**
+ * @packageDocumentation
+ * @module types
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL3R5cGVzL2NvbW1vbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSB0eXBlc1xuICovXG5cbmV4cG9ydCB0eXBlIFN0cmluZ01hcCA9IFJlY29yZDxzdHJpbmcsIHN0cmluZz47XG5cbmV4cG9ydCBpbnRlcmZhY2UgRW52aXJvbm1lbnRzIHtcbiAgR0xPQkFMX05BTUVTUEFDRT86IHN0cmluZztcbiAgTEFCRUxfQkFTRV9ET01BSU4/OiBzdHJpbmc7XG4gIExPR09fVVJMPzogc3RyaW5nO1xuICBJTk5FUl9QUk9KRUNUX05TX1BSRUZJWD86IHN0cmluZztcbiAgQ1BBQVNfU0VTU0lPTl9TV0lUQ0g/OiAnb24nIHwgJ29mZic7XG4gIENMT1NFX0JST1dTRVJfRU5EX1NFU1NJT04/OiBzdHJpbmc7XG4gIENVUlJFTlRfU1RBVEU/OiAnQWN0aXZlJyB8ICdTdGFuZGJ5Jztcbn1cblxuZXhwb3J0IHR5cGUgS2V5VmFsdWU8ViA9IHN0cmluZywgVCBleHRlbmRzIG9iamVjdCA9IG9iamVjdD4gPSBUICYge1xuICBrZXk6IHN0cmluZztcbiAgdmFsdWU6IFY7XG59O1xuXG5leHBvcnQgaW50ZXJmYWNlIFJlc291cmNlTGlzdFBhcmFtcyBleHRlbmRzIFN0cmluZ01hcCB7XG4gIGxpbWl0Pzogc3RyaW5nO1xuICBjb250aW51ZT86IHN0cmluZztcbiAgbGFiZWxTZWxlY3Rvcj86IHN0cmluZztcbiAgZmllbGRTZWxlY3Rvcj86IHN0cmluZztcbiAgZmllbGQ/OiBzdHJpbmc7XG4gIGtleXdvcmQ/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgV29ya3NwYWNlUGFyYW1zIHtcbiAgcHJvamVjdD86IHN0cmluZztcbiAgY2x1c3Rlcj86IHN0cmluZztcbiAgbmFtZXNwYWNlPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFdvcmtzcGFjZUxpc3RQYXJhbXNcbiAgZXh0ZW5kcyBXb3Jrc3BhY2VQYXJhbXMsXG4gICAgUmVzb3VyY2VMaXN0UGFyYW1zIHt9XG5cbmV4cG9ydCBpbnRlcmZhY2UgV29ya3NwYWNlRGV0YWlsUGFyYW1zIGV4dGVuZHMgV29ya3NwYWNlTGlzdFBhcmFtcyB7XG4gIG5hbWU/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCB0eXBlIFBhZ2luYXRpb248VCwgTyA9IHsgW2tleTogc3RyaW5nXTogdW5rbm93biB9PiA9IHtcbiAgdG90YWw6IG51bWJlcjtcbiAgaXRlbXM6IFRbXTtcbn0gJiBPO1xuIl19

package/esm2022/types/helpers.mjs

@@ -0,0 +1,12 @@
+/**
+ * @packageDocumentation
+ * @module types
+ */
+export function isErrorMessage(error) {
+    return 'message' in error && typeof error.message === 'string';
+}
+export const DataSource = {
+    Platform: 'Platform',
+    Business: 'Business',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/types/index.mjs

@@ -0,0 +1,9 @@
+/**
+ * @packageDocumentation
+ * @module types
+ * @preferred
+ */
+export * from './common';
+export * from './helpers';
+export * from './k8s';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqIEBtb2R1bGUgdHlwZXNcbiAqIEBwcmVmZXJyZWRcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbic7XG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9rOHMnO1xuIl19

package/esm2022/types/k8s/core.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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