@alauda-fe/common 1.0.0-next.0

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

@@ -0,0 +1,280 @@
+import { Injectable, IterableDiffers, } from '@angular/core';
+import { cloneDeep, isEqual, set, unset } from 'lodash-es';
+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();
+    }
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    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 = function ValidateRowDuplicateService_Factory(t) { return new (t || ValidateRowDuplicateService)(i0.ɵɵinject(i0.IterableDiffers)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ValidateRowDuplicateService, factory: ValidateRowDuplicateService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ValidateRowDuplicateService, [{
+        type: Injectable
+    }], function () { return [{ type: i0.IterableDiffers }]; }, null); })();
+// 仅返回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/common/src/core/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, isEqual, set, unset } from 'lodash-es';\nimport { Subscription } from 'rxjs';\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  // eslint-disable-next-line sonarjs/cognitive-complexity\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/core/services/index.mjs

@@ -0,0 +1,15 @@
+export * from './aui-paginator-intl.service';
+export * from './aui-tooltip-copy-intl.service';
+export * from './custom-code-editor-intl.service';
+export * from './feature-gate.service';
+export * from './intercept-deactivate.service';
+export * from './k8s-util.service';
+export * from './silently-navigate.service';
+export * from './time.service';
+export * from './ui-state.service';
+export * from './workspace-helper.service';
+export * from './on-resize.service';
+export * from './yaml-util.service';
+export * from './form-row-duplicate/form-row-duplicate.service';
+export * from './context.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlEQUFpRCxDQUFDO0FBQ2hFLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F1aS1wYWdpbmF0b3ItaW50bC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vYXVpLXRvb2x0aXAtY29weS1pbnRsLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jdXN0b20tY29kZS1lZGl0b3ItaW50bC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmVhdHVyZS1nYXRlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmNlcHQtZGVhY3RpdmF0ZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vazhzLXV0aWwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NpbGVudGx5LW5hdmlnYXRlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90aW1lLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi91aS1zdGF0ZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vd29ya3NwYWNlLWhlbHBlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vb24tcmVzaXplLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi95YW1sLXV0aWwuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm0tcm93LWR1cGxpY2F0ZS9mb3JtLXJvdy1kdXBsaWNhdGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRleHQuc2VydmljZSc7XG4iXX0=

package/esm2022/core/services/intercept-deactivate.service.mjs

@@ -0,0 +1,78 @@
+import { DialogService } from '@alauda/ui';
+import { Location } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { Subject, filter, takeUntil, from, map } from 'rxjs';
+import { TranslateService } from '../../translate/translate.service';
+import { CURR_ESCAPE_DEACTIVATE_GUARD, ESCAPE_DEACTIVATE_GUARD, } from '../guards/intercept-deactivate.guard';
+import { skipError } from '../utils/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/router";
+import * as i3 from "@alauda/ui";
+import * as i4 from "../../translate/translate.service";
+export class InterceptDeactivateService {
+    constructor(location, router, dialog, translate) {
+        this.location = location;
+        this.router = router;
+        this.dialog = dialog;
+        this.translate = translate;
+        this.destroy$$ = new Subject();
+        this.router.events
+            .pipe(filter(ev => ev instanceof NavigationEnd), takeUntil(this.destroy$$))
+            .subscribe(() => {
+            const url = new URL(this.location.path(true), window.location.href);
+            if (url.hash === '#' + ESCAPE_DEACTIVATE_GUARD ||
+                url.hash === '#' + CURR_ESCAPE_DEACTIVATE_GUARD) {
+                this.location.replaceState(url.pathname, url.search.slice(1));
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    intercept({ title, content, context, errorFallback, } = {}) {
+        return from(this.dialog.confirm({
+            title: this.translate.get(title || 'intercept_deactivate_title', context),
+            content: this.translate.get(content || 'intercept_deactivate_content', context),
+            confirmText: this.translate.get('confirm'),
+            cancelText: this.translate.get('cancel'),
+        })).pipe(map(() => true), skipError(errorFallback));
+    }
+    async back(escape) {
+        if (escape) {
+            await this.escape();
+        }
+        this.location.back();
+    }
+    async forward(escape) {
+        if (escape) {
+            await this.escape();
+        }
+        this.location.forward();
+    }
+    searchParamsToQueryParams(searchParams) {
+        const queryParams = {};
+        searchParams.forEach((_value, key) => {
+            const values = searchParams.getAll(key);
+            queryParams[key] = values.length <= 1 ? values[0] : values;
+        });
+        return queryParams;
+    }
+    async escape() {
+        const url = new URL(this.location.path(), location.href);
+        await this.router.navigate([url.pathname], {
+            replaceUrl: true,
+            fragment: CURR_ESCAPE_DEACTIVATE_GUARD,
+            queryParams: this.searchParamsToQueryParams(url.searchParams),
+        });
+    }
+    static { this.ɵfac = function InterceptDeactivateService_Factory(t) { return new (t || InterceptDeactivateService)(i0.ɵɵinject(i1.Location), i0.ɵɵinject(i2.Router), i0.ɵɵinject(i3.DialogService), i0.ɵɵinject(i4.TranslateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: InterceptDeactivateService, factory: InterceptDeactivateService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(InterceptDeactivateService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.Location }, { type: i2.Router }, { type: i3.DialogService }, { type: i4.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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