@univerjs/data-validation 0.2.4 → 0.2.6

package/lib/es/index.js

@@ -1,142 +1,142 @@
-var Z = Object.defineProperty;
-var k = (a, e, t) => e in a ? Z(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
-var u = (a, e, t) => k(a, typeof e != "symbol" ? e + "" : e, t);
-import { toDisposable as ee, Tools as G, DataValidationType as te, DataValidationOperator as s, Disposable as O, DataValidationStatus as ae, ILogService as y, CommandType as E, ICommandService as T, IUndoRedoService as M, UniverInstanceType as w, OnLifecycle as Q, LifecycleStages as j, IResourceManagerService as re, IUniverInstanceService as W, Plugin as ne, LocaleService as oe } from "@univerjs/core";
-import { Inject as v, Injector as F } from "@wendellhu/redi";
-import { BehaviorSubject as ie, Subject as C, debounceTime as b } from "rxjs";
-import { SheetsSelectionsService as se, RemoveSheetCommand as de, SheetInterceptorService as le } from "@univerjs/sheets";
-var ue = /* @__PURE__ */ ((a) => (a.SHEET = "sheet", a))(ue || {});
-class J {
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { toDisposable, Tools, DataValidationType, DataValidationOperator, Disposable, DataValidationStatus, ILogService, CommandType, ICommandService, IUndoRedoService, UniverInstanceType, OnLifecycle, LifecycleStages, Inject, IResourceManagerService, IUniverInstanceService, Plugin, Injector, LocaleService } from "@univerjs/core";
+import { BehaviorSubject, Subject, debounceTime } from "rxjs";
+import { SheetsSelectionsService, RemoveSheetCommand, SheetInterceptorService } from "@univerjs/sheets";
+var DataValidatorRegistryScope = /* @__PURE__ */ ((DataValidatorRegistryScope2) => (DataValidatorRegistryScope2.SHEET = "sheet", DataValidatorRegistryScope2))(DataValidatorRegistryScope || {});
+const _DataValidatorRegistryService = class _DataValidatorRegistryService {
   constructor() {
-    u(this, "_validatorByScopes", /* @__PURE__ */ new Map());
-    u(this, "_validatorMap", /* @__PURE__ */ new Map());
-    u(this, "_validatorsChange$", new ie(void 0));
-    u(this, "validatorsChange$", this._validatorsChange$.asObservable());
-  }
-  _addValidatorToScope(e, t) {
-    this._validatorByScopes.has(t) || this._validatorByScopes.set(t, []);
-    const r = this._validatorByScopes.get(t);
-    if (r.findIndex((n) => n.id === e.id) > -1)
-      throw new Error(`Validator item with the same id ${e.id} has already been added!`);
-    r.push(e);
-  }
-  _removeValidatorFromScope(e, t) {
-    const r = this._validatorByScopes.get(t);
-    if (!r)
+    __publicField(this, "_validatorByScopes", /* @__PURE__ */ new Map());
+    __publicField(this, "_validatorMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_validatorsChange$", new BehaviorSubject(void 0));
+    __publicField(this, "validatorsChange$", this._validatorsChange$.asObservable());
+  }
+  _addValidatorToScope(validator, scope) {
+    this._validatorByScopes.has(scope) || this._validatorByScopes.set(scope, []);
+    const validators = this._validatorByScopes.get(scope);
+    if (validators.findIndex((m) => m.id === validator.id) > -1)
+      throw new Error(`Validator item with the same id ${validator.id} has already been added!`);
+    validators.push(validator);
+  }
+  _removeValidatorFromScope(validator, scope) {
+    const validators = this._validatorByScopes.get(scope);
+    if (!validators)
       return;
-    const n = r.findIndex((o) => o.id === e.id);
-    n > -1 && r.splice(n, 1);
-  }
-  register(e) {
-    return this._validatorMap.set(e.id, e), Array.isArray(e.scopes) ? e.scopes.forEach((t) => {
-      this._addValidatorToScope(e, t);
-    }) : this._addValidatorToScope(e, e.scopes), this._validatorsChange$.next(), ee(() => {
-      this._validatorMap.delete(e.id), Array.isArray(e.scopes) ? e.scopes.forEach((t) => {
-        this._removeValidatorFromScope(e, t);
-      }) : this._removeValidatorFromScope(e, e.scopes), this._validatorsChange$.next();
+    const index = validators.findIndex((v) => v.id === validator.id);
+    index > -1 && validators.splice(index, 1);
+  }
+  register(validator) {
+    return this._validatorMap.set(validator.id, validator), Array.isArray(validator.scopes) ? validator.scopes.forEach((scope) => {
+      this._addValidatorToScope(validator, scope);
+    }) : this._addValidatorToScope(validator, validator.scopes), this._validatorsChange$.next(), toDisposable(() => {
+      this._validatorMap.delete(validator.id), Array.isArray(validator.scopes) ? validator.scopes.forEach((scope) => {
+        this._removeValidatorFromScope(validator, scope);
+      }) : this._removeValidatorFromScope(validator, validator.scopes), this._validatorsChange$.next();
     });
   }
-  getValidatorItem(e) {
-    return this._validatorMap.get(e);
+  getValidatorItem(id) {
+    return this._validatorMap.get(id);
   }
-  getValidatorsByScope(e) {
-    return this._validatorByScopes.get(e);
+  getValidatorsByScope(scope) {
+    return this._validatorByScopes.get(scope);
   }
-}
-var g = /* @__PURE__ */ ((a) => (a[a.SETTING = 0] = "SETTING", a[a.RANGE = 1] = "RANGE", a[a.OPTIONS = 2] = "OPTIONS", a))(g || {});
-function z(a) {
+};
+__name(_DataValidatorRegistryService, "DataValidatorRegistryService");
+let DataValidatorRegistryService = _DataValidatorRegistryService;
+var UpdateRuleType = /* @__PURE__ */ ((UpdateRuleType2) => (UpdateRuleType2[UpdateRuleType2.SETTING = 0] = "SETTING", UpdateRuleType2[UpdateRuleType2.RANGE = 1] = "RANGE", UpdateRuleType2[UpdateRuleType2.OPTIONS = 2] = "OPTIONS", UpdateRuleType2))(UpdateRuleType || {});
+function getRuleSetting(rule) {
   return {
-    type: a.type,
-    operator: a.operator,
-    formula1: a.formula1,
-    formula2: a.formula2,
-    allowBlank: a.allowBlank
+    type: rule.type,
+    operator: rule.operator,
+    formula1: rule.formula1,
+    formula2: rule.formula2,
+    allowBlank: rule.allowBlank
   };
 }
-function K(a) {
+__name(getRuleSetting, "getRuleSetting");
+function getRuleOptions(rule) {
   return {
-    error: a.error,
-    errorStyle: a.errorStyle,
-    errorTitle: a.errorTitle,
-    imeMode: a.imeMode,
-    prompt: a.prompt,
-    promptTitle: a.promptTitle,
-    showDropDown: a.showDropDown,
-    showErrorMessage: a.showErrorMessage,
-    showInputMessage: a.showInputMessage,
-    renderMode: a.renderMode,
-    bizInfo: a.bizInfo
+    error: rule.error,
+    errorStyle: rule.errorStyle,
+    errorTitle: rule.errorTitle,
+    imeMode: rule.imeMode,
+    prompt: rule.prompt,
+    promptTitle: rule.promptTitle,
+    showDropDown: rule.showDropDown,
+    showErrorMessage: rule.showErrorMessage,
+    showInputMessage: rule.showInputMessage,
+    renderMode: rule.renderMode,
+    bizInfo: rule.bizInfo
   };
 }
-function Qe(a) {
-  const t = a.get(se).getCurrentSelections().map((o) => o.range);
+__name(getRuleOptions, "getRuleOptions");
+function createDefaultNewRule(accessor) {
+  const currentRanges = accessor.get(SheetsSelectionsService).getCurrentSelections().map((s) => s.range);
   return {
-    uid: G.generateRandomId(6),
-    type: te.DECIMAL,
-    operator: s.EQUAL,
+    uid: Tools.generateRandomId(6),
+    type: DataValidationType.DECIMAL,
+    operator: DataValidationOperator.EQUAL,
     formula1: "100",
-    ranges: t != null ? t : [{ startColumn: 0, endColumn: 0, startRow: 0, endRow: 0 }]
+    ranges: currentRanges != null ? currentRanges : [{ startColumn: 0, endColumn: 0, startRow: 0, endRow: 0 }]
   };
 }
-class ce extends O {
-  constructor(t, r, n) {
+__name(createDefaultNewRule, "createDefaultNewRule");
+const _DataValidationManager = class _DataValidationManager extends Disposable {
+  constructor(unitId, subUnitId) {
     super();
-    u(this, "_dataValidations");
-    u(this, "_dataValidationMap", /* @__PURE__ */ new Map());
-    u(this, "_dataValidations$", new C());
-    u(this, "unitId");
-    u(this, "subUnitId");
-    u(this, "dataValidations$", this._dataValidations$.asObservable());
-    this.unitId = t, this.subUnitId = r, n && (this._insertRules(n), this._notice(), this.disposeWithMe({
-      dispose: () => {
+    __publicField(this, "_dataValidations", []);
+    __publicField(this, "_dataValidationMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_dataValidations$", new BehaviorSubject(this._dataValidations));
+    __publicField(this, "unitId");
+    __publicField(this, "subUnitId");
+    __publicField(this, "dataValidations$", this._dataValidations$.asObservable());
+    this.unitId = unitId, this.subUnitId = subUnitId, this._notice(), this.disposeWithMe({
+      dispose: /* @__PURE__ */ __name(() => {
         this._dataValidations$.complete();
-      }
-    }));
+      }, "dispose")
+    });
   }
   _notice() {
     this._dataValidations$.next(this._dataValidations);
   }
-  _insertRules(t) {
-    this._dataValidations = t, t.forEach((r) => {
-      this._dataValidationMap.set(r.uid, r);
-    });
+  getRuleById(id) {
+    return this._dataValidationMap.get(id);
   }
-  getRuleById(t) {
-    return this._dataValidationMap.get(t);
+  getRuleIndex(id) {
+    return this._dataValidations.findIndex((rule) => rule.uid === id);
   }
-  getRuleIndex(t) {
-    return this._dataValidations.findIndex((r) => r.uid === t);
-  }
-  addRule(t, r) {
-    const o = (Array.isArray(t) ? t : [t]).filter((i) => !this._dataValidationMap.has(i.uid));
-    typeof r == "number" && r < this._dataValidations.length ? this._dataValidations.splice(r, 0, ...o) : this._dataValidations.push(...o), o.forEach((i) => {
-      this._dataValidationMap.set(i.uid, i);
+  addRule(rule, index) {
+    const rules = (Array.isArray(rule) ? rule : [rule]).filter((item) => !this._dataValidationMap.has(item.uid));
+    typeof index == "number" && index < this._dataValidations.length ? this._dataValidations.splice(index, 0, ...rules) : this._dataValidations.push(...rules), rules.forEach((item) => {
+      this._dataValidationMap.set(item.uid, item);
     }), this._notice();
   }
-  removeRule(t) {
-    const r = this._dataValidations.findIndex((n) => n.uid === t);
-    r > -1 && (this._dataValidations.splice(r, 1), this._dataValidationMap.delete(t), this._notice());
-  }
-  updateRule(t, r) {
-    const n = this._dataValidationMap.get(t), o = this._dataValidations.findIndex((l) => t === l.uid);
-    if (!n)
-      throw new Error(`Data validation rule is not found, ruleId: ${t}.`);
-    const i = { ...n };
-    switch (r.type) {
-      case g.RANGE: {
-        i.ranges = r.payload;
+  removeRule(ruleId) {
+    const index = this._dataValidations.findIndex((item) => item.uid === ruleId);
+    index > -1 && (this._dataValidations.splice(index, 1), this._dataValidationMap.delete(ruleId), this._notice());
+  }
+  updateRule(ruleId, payload) {
+    const oldRule = this._dataValidationMap.get(ruleId), index = this._dataValidations.findIndex((rule2) => ruleId === rule2.uid);
+    if (!oldRule)
+      throw new Error(`Data validation rule is not found, ruleId: ${ruleId}.`);
+    const rule = { ...oldRule };
+    switch (payload.type) {
+      case UpdateRuleType.RANGE: {
+        rule.ranges = payload.payload;
         break;
       }
-      case g.SETTING: {
-        Object.assign(i, z(r.payload));
+      case UpdateRuleType.SETTING: {
+        Object.assign(rule, getRuleSetting(payload.payload));
         break;
       }
-      case g.OPTIONS: {
-        Object.assign(i, K(r.payload));
+      case UpdateRuleType.OPTIONS: {
+        Object.assign(rule, getRuleOptions(payload.payload));
         break;
       }
     }
-    return this._dataValidations[o] = i, this._dataValidationMap.set(t, i), this._notice(), i;
+    return this._dataValidations[index] = rule, this._dataValidationMap.set(ruleId, rule), this._notice(), rule;
   }
   getDataValidations() {
     return this._dataValidations;
@@ -144,660 +144,664 @@ class ce extends O {
   toJSON() {
     return this._dataValidations;
   }
-  validator(t, r, n, o) {
-    return ae.VALID;
+  validator(_content, _rule, _pos, _onComplete) {
+    return DataValidationStatus.VALID;
   }
-}
-var he = Object.defineProperty, pe = Object.getOwnPropertyDescriptor, _e = (a, e, t, r) => {
-  for (var n = r > 1 ? void 0 : r ? pe(e, t) : e, o = a.length - 1, i; o >= 0; o--)
-    (i = a[o]) && (n = (r ? i(e, t, n) : i(n)) || n);
-  return r && n && he(e, t, n), n;
-}, ge = (a, e) => (t, r) => e(t, r, a);
-let h = class extends O {
-  constructor(e) {
+};
+__name(_DataValidationManager, "DataValidationManager");
+let DataValidationManager = _DataValidationManager;
+var __defProp$4 = Object.defineProperty, __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor, __decorateClass$4 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$4(target, key, result), result;
+}, "__decorateClass$4"), __decorateParam$4 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$4"), _a;
+let DataValidationModel = (_a = class extends Disposable {
+  constructor(_logService) {
     super();
-    u(this, "_model", /* @__PURE__ */ new Map());
-    u(this, "_managerCreator", (e, t) => new ce(e, t, []));
-    u(this, "_ruleChange$", new C());
-    u(this, "_validStatusChange$", new C());
-    u(this, "ruleChange$", this._ruleChange$.asObservable());
-    u(this, "ruleChangeDebounce$", this.ruleChange$.pipe(b(20)));
-    u(this, "validStatusChange$", this._validStatusChange$.asObservable().pipe(b(20)));
-    this._logService = e, this.disposeWithMe({
-      dispose: () => {
+    __publicField(this, "_model", /* @__PURE__ */ new Map());
+    __publicField(this, "_managerCreator", /* @__PURE__ */ __name((unitId, subUnitId) => new DataValidationManager(unitId, subUnitId), "_managerCreator"));
+    __publicField(this, "_ruleChange$", new Subject());
+    __publicField(this, "_validStatusChange$", new Subject());
+    __publicField(this, "ruleChange$", this._ruleChange$.asObservable());
+    __publicField(this, "ruleChangeDebounce$", this.ruleChange$.pipe(debounceTime(20)));
+    __publicField(this, "validStatusChange$", this._validStatusChange$.asObservable().pipe(debounceTime(20)));
+    this._logService = _logService, this.disposeWithMe({
+      dispose: /* @__PURE__ */ __name(() => {
         this._ruleChange$.complete(), this._validStatusChange$.complete();
-      }
+      }, "dispose")
     });
   }
-  setManagerCreator(e) {
-    this._managerCreator = e;
+  setManagerCreator(creator) {
+    this._managerCreator = creator;
   }
-  ensureManager(e, t) {
-    this._model.has(e) || this._model.set(e, /* @__PURE__ */ new Map());
-    const r = this._model.get(e);
-    if (r.has(t))
-      return r.get(t);
-    const n = this._managerCreator(e, t);
-    return r.set(t, n), n;
+  ensureManager(unitId, subUnitId) {
+    this._model.has(unitId) || this._model.set(unitId, /* @__PURE__ */ new Map());
+    const unitMap = this._model.get(unitId);
+    if (unitMap.has(subUnitId))
+      return unitMap.get(subUnitId);
+    const manager = this._managerCreator(unitId, subUnitId);
+    return unitMap.set(subUnitId, manager), this.disposeWithMe(manager), manager;
   }
-  _addRuleSideEffect(e, t, r) {
-    this.ensureManager(e, t).getRuleById(r.uid) || this._ruleChange$.next({
-      rule: r,
+  _addRuleSideEffect(unitId, subUnitId, rule, source) {
+    this.ensureManager(unitId, subUnitId).getRuleById(rule.uid) || this._ruleChange$.next({
+      rule,
       type: "add",
-      unitId: e,
-      subUnitId: t
+      unitId,
+      subUnitId,
+      source
     });
   }
-  addRule(e, t, r, n) {
+  addRule(unitId, subUnitId, rule, source, index) {
     try {
-      const o = this.ensureManager(e, t);
-      (Array.isArray(r) ? r : [r]).forEach((l) => {
-        this._addRuleSideEffect(e, t, l);
-      }), o.addRule(r, n);
-    } catch (o) {
-      this._logService.error(o);
+      const manager = this.ensureManager(unitId, subUnitId);
+      (Array.isArray(rule) ? rule : [rule]).forEach((item) => {
+        this._addRuleSideEffect(unitId, subUnitId, item, source);
+      }), manager.addRule(rule, index);
+    } catch (error) {
+      this._logService.error(error);
     }
   }
-  updateRule(e, t, r, n) {
+  updateRule(unitId, subUnitId, ruleId, payload, source) {
     try {
-      const i = this.ensureManager(e, t).updateRule(r, n);
+      const rule = this.ensureManager(unitId, subUnitId).updateRule(ruleId, payload);
       this._ruleChange$.next({
-        rule: i,
+        rule,
         type: "update",
-        unitId: e,
-        subUnitId: t
+        unitId,
+        subUnitId,
+        source
       });
-    } catch (o) {
-      this._logService.error(o);
+    } catch (error) {
+      this._logService.error(error);
     }
   }
-  removeRule(e, t, r) {
+  removeRule(unitId, subUnitId, ruleId, source) {
     try {
-      const n = this.ensureManager(e, t), o = n.getRuleById(r);
-      o && (n.removeRule(r), this._ruleChange$.next({
-        rule: o,
+      const manager = this.ensureManager(unitId, subUnitId), oldRule = manager.getRuleById(ruleId);
+      oldRule && (manager.removeRule(ruleId), this._ruleChange$.next({
+        rule: oldRule,
         type: "remove",
-        unitId: e,
-        subUnitId: t
+        unitId,
+        subUnitId,
+        source
       }));
-    } catch (n) {
-      this._logService.error(n);
+    } catch (error) {
+      this._logService.error(error);
     }
   }
-  getRuleById(e, t, r) {
-    return this.ensureManager(e, t).getRuleById(r);
+  getRuleById(unitId, subUnitId, ruleId) {
+    return this.ensureManager(unitId, subUnitId).getRuleById(ruleId);
   }
-  getRuleIndex(e, t, r) {
-    return this.ensureManager(e, t).getRuleIndex(r);
+  getRuleIndex(unitId, subUnitId, ruleId) {
+    return this.ensureManager(unitId, subUnitId).getRuleIndex(ruleId);
   }
-  getRules(e, t) {
-    return this.ensureManager(e, t).getDataValidations();
+  getRules(unitId, subUnitId) {
+    return this.ensureManager(unitId, subUnitId).getDataValidations();
   }
-  validator(e, t, r) {
-    const { unitId: n, subUnitId: o } = r;
-    return this.ensureManager(n, o).validator(e, t, r, (l, d) => {
-      d && this._validStatusChange$.next({
-        unitId: n,
-        subUnitId: o,
-        ruleId: t.uid,
-        status: l
+  validator(content, rule, pos) {
+    const { unitId, subUnitId } = pos;
+    return this.ensureManager(unitId, subUnitId).validator(content, rule, pos, (status, changed) => {
+      changed && this._validStatusChange$.next({
+        unitId,
+        subUnitId,
+        ruleId: rule.uid,
+        status
       });
     });
   }
-  getUnitRules(e) {
-    const t = this._model.get(e);
-    if (!t)
+  getUnitRules(unitId) {
+    const unitMap = this._model.get(unitId);
+    if (!unitMap)
       return [];
-    const r = [];
-    return t.forEach((n) => {
-      r.push([n.subUnitId, n.getDataValidations()]);
-    }), r;
-  }
-  deleteUnitRules(e) {
-    this._model.delete(e);
-  }
-  getSubUnitIds(e) {
-    var t, r;
-    return Array.from((r = (t = this._model.get(e)) == null ? void 0 : t.keys()) != null ? r : []);
-  }
-};
-h = _e([
-  ge(0, y)
-], h);
-const m = {
-  type: E.MUTATION,
+    const res = [];
+    return unitMap.forEach((manager) => {
+      res.push([manager.subUnitId, manager.getDataValidations()]);
+    }), res;
+  }
+  deleteUnitRules(unitId) {
+    this._model.delete(unitId);
+  }
+  getSubUnitIds(unitId) {
+    var _a6, _b;
+    return Array.from((_b = (_a6 = this._model.get(unitId)) == null ? void 0 : _a6.keys()) != null ? _b : []);
+  }
+}, __name(_a, "DataValidationModel"), _a);
+DataValidationModel = __decorateClass$4([
+  __decorateParam$4(0, ILogService)
+], DataValidationModel);
+const AddDataValidationMutation = {
+  type: CommandType.MUTATION,
   id: "data-validation.mutation.addRule",
-  handler(a, e) {
-    if (!e)
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const { unitId: t, subUnitId: r, rule: n, index: o } = e;
-    return a.get(h).addRule(t, r, n, o), !0;
+    const { unitId, subUnitId, rule, index, source = "command" } = params;
+    return accessor.get(DataValidationModel).addRule(unitId, subUnitId, rule, source, index), !0;
   }
-}, S = {
-  type: E.MUTATION,
+}, RemoveDataValidationMutation = {
+  type: CommandType.MUTATION,
   id: "data-validation.mutation.removeRule",
-  handler(a, e) {
-    if (!e)
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const { unitId: t, subUnitId: r, ruleId: n } = e, o = a.get(h);
-    return Array.isArray(n) ? n.forEach((i) => {
-      o.removeRule(t, r, i);
-    }) : o.removeRule(t, r, n), !0;
+    const { unitId, subUnitId, ruleId, source = "command" } = params, dataValidationModel = accessor.get(DataValidationModel);
+    return Array.isArray(ruleId) ? ruleId.forEach((item) => {
+      dataValidationModel.removeRule(unitId, subUnitId, item, source);
+    }) : dataValidationModel.removeRule(unitId, subUnitId, ruleId, source), !0;
   }
-}, f = {
-  type: E.MUTATION,
+}, UpdateDataValidationMutation = {
+  type: CommandType.MUTATION,
   id: "data-validation.mutation.updateRule",
-  handler(a, e) {
-    if (!e)
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const { unitId: t, subUnitId: r, ruleId: n, payload: o } = e;
-    return a.get(h).updateRule(t, r, n, o), !0;
+    const { unitId, subUnitId, ruleId, payload, source = "command" } = params;
+    return accessor.get(DataValidationModel).updateRule(unitId, subUnitId, ruleId, payload, source), !0;
   }
-}, me = {
-  type: E.COMMAND,
+}, AddDataValidationCommand = {
+  type: CommandType.COMMAND,
   id: "data-validation.command.addRule",
-  async handler(a, e) {
-    if (a.get(y).warn("[Deprecated] AddDataValidationCommand is deprecated, please use AddSheetDataValidationCommand in @univerjs/sheets-data-validation instead!"), !e)
+  async handler(accessor, params) {
+    if (accessor.get(ILogService).warn("[Deprecated] AddDataValidationCommand is deprecated, please use AddSheetDataValidationCommand in @univerjs/sheets-data-validation instead!"), !params)
       return !1;
-    const { rule: r, unitId: n, subUnitId: o } = e, i = a.get(T), l = a.get(M), d = {
-      ...e,
+    const { rule, unitId, subUnitId } = params, commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), mutationParams = {
+      ...params,
       rule: {
-        ...e.rule,
-        ranges: [e.rule.range]
+        ...params.rule,
+        ranges: [params.rule.range]
       }
-    }, c = [{
-      id: m.id,
-      params: d
-    }], p = [{
-      id: S.id,
+    }, redoMutations = [{
+      id: AddDataValidationMutation.id,
+      params: mutationParams
+    }], undoMutations = [{
+      id: RemoveDataValidationMutation.id,
       params: {
-        unitId: n,
-        subUnitId: o,
-        ruleId: r.uid
+        unitId,
+        subUnitId,
+        ruleId: rule.uid
       }
     }];
-    return l.pushUndoRedo({
-      unitID: n,
-      redoMutations: c,
-      undoMutations: p
-    }), await i.executeCommand(m.id, d), !0;
-  }
-}, je = (a, e) => {
-  const t = a.get(h), { unitId: r, subUnitId: n, ruleId: o } = e;
-  if (Array.isArray(o)) {
-    const l = o.map((d) => t.getRuleById(r, n, d)).filter(Boolean);
+    return undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      redoMutations,
+      undoMutations
+    }), await commandService.executeCommand(AddDataValidationMutation.id, mutationParams), !0;
+  }
+}, removeDataValidationUndoFactory = /* @__PURE__ */ __name((accessor, redoParams) => {
+  const dataValidationModel = accessor.get(DataValidationModel), { unitId, subUnitId, ruleId, source } = redoParams;
+  if (Array.isArray(ruleId)) {
+    const rules = ruleId.map((id) => dataValidationModel.getRuleById(unitId, subUnitId, id)).filter(Boolean);
     return [{
-      id: m.id,
+      id: AddDataValidationMutation.id,
       params: {
-        unitId: r,
-        subUnitId: n,
-        rule: l
+        unitId,
+        subUnitId,
+        rule: rules,
+        source
       }
     }];
   }
   return [{
-    id: m.id,
+    id: AddDataValidationMutation.id,
     params: {
-      unitId: r,
-      subUnitId: n,
+      unitId,
+      subUnitId,
       rule: {
-        ...t.getRuleById(r, n, o)
+        ...dataValidationModel.getRuleById(unitId, subUnitId, ruleId)
       },
-      index: t.getRuleIndex(r, n, o)
+      index: dataValidationModel.getRuleIndex(unitId, subUnitId, ruleId)
     }
   }];
-}, Ee = {
-  type: E.COMMAND,
+}, "removeDataValidationUndoFactory"), RemoveDataValidationCommand = {
+  type: CommandType.COMMAND,
   id: "data-validation.command.removeRule",
-  handler(a, e) {
-    if (!e)
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const { unitId: t, subUnitId: r, ruleId: n } = e, o = a.get(T), i = a.get(M), l = a.get(h), d = [{
-      id: S.id,
-      params: e
-    }], c = [{
-      id: m.id,
+    const { unitId, subUnitId, ruleId } = params, commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), dataValidationModel = accessor.get(DataValidationModel), redoMutations = [{
+      id: RemoveDataValidationMutation.id,
+      params
+    }], undoMutations = [{
+      id: AddDataValidationMutation.id,
       params: {
-        unitId: t,
-        subUnitId: r,
+        unitId,
+        subUnitId,
         rule: {
-          ...l.getRuleById(t, r, n)
+          ...dataValidationModel.getRuleById(unitId, subUnitId, ruleId)
         },
-        index: l.getRuleIndex(t, r, n)
+        index: dataValidationModel.getRuleIndex(unitId, subUnitId, ruleId)
       }
     }];
-    return i.pushUndoRedo({
-      undoMutations: c,
-      redoMutations: d,
-      unitID: e.unitId
-    }), o.executeCommand(S.id, e), !0;
-  }
-}, ve = {
-  type: E.COMMAND,
+    return undoRedoService.pushUndoRedo({
+      undoMutations,
+      redoMutations,
+      unitID: params.unitId
+    }), commandService.executeCommand(RemoveDataValidationMutation.id, params), !0;
+  }
+}, UpdateDataValidationOptionsCommand = {
+  type: CommandType.COMMAND,
   id: "data-validation.command.updateDataValidationSetting",
-  handler(a, e) {
-    if (a.get(y).warn("[Deprecated] UpdateDataValidationOptionsCommand is deprecated, please use UpdateSheetDataValidationOptionsCommand in @univerjs/sheets-data-validation instead!"), !e)
+  handler(accessor, params) {
+    if (accessor.get(ILogService).warn("[Deprecated] UpdateDataValidationOptionsCommand is deprecated, please use UpdateSheetDataValidationOptionsCommand in @univerjs/sheets-data-validation instead!"), !params)
       return !1;
-    const r = a.get(T), n = a.get(M), o = a.get(h), { unitId: i, subUnitId: l, ruleId: d, options: c } = e, p = o.getRuleById(i, l, d);
-    if (!p)
+    const commandService = accessor.get(ICommandService), redoUndoService = accessor.get(IUndoRedoService), dataValidationModel = accessor.get(DataValidationModel), { unitId, subUnitId, ruleId, options } = params, rule = dataValidationModel.getRuleById(unitId, subUnitId, ruleId);
+    if (!rule)
       return !1;
-    const _ = {
-      unitId: i,
-      subUnitId: l,
-      ruleId: d,
+    const mutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
       payload: {
-        type: g.OPTIONS,
-        payload: c
+        type: UpdateRuleType.OPTIONS,
+        payload: options
       }
-    }, V = [{
-      id: f.id,
-      params: _
-    }], I = {
-      unitId: i,
-      subUnitId: l,
-      ruleId: d,
+    }, redoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: mutationParams
+    }], undoMutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
       payload: {
-        type: g.OPTIONS,
-        payload: K(p)
+        type: UpdateRuleType.OPTIONS,
+        payload: getRuleOptions(rule)
       }
-    }, U = [{
-      id: f.id,
-      params: I
+    }, undoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: undoMutationParams
     }];
-    return n.pushUndoRedo({
-      unitID: i,
-      redoMutations: V,
-      undoMutations: U
-    }), r.executeCommand(f.id, _), !0;
-  }
-}, fe = {
-  type: E.COMMAND,
+    return redoUndoService.pushUndoRedo({
+      unitID: unitId,
+      redoMutations,
+      undoMutations
+    }), commandService.executeCommand(UpdateDataValidationMutation.id, mutationParams), !0;
+  }
+}, UpdateDataValidationSettingCommand = {
+  type: CommandType.COMMAND,
   id: "data-validation.command.updateDataValidationOptions",
-  handler(a, e) {
-    if (a.get(y).warn("[Deprecated] UpdateDataValidationSettingCommand is deprecated, please use UpdateSheetDataValidationSettingCommand in @univerjs/sheets-data-validation instead!"), !e)
+  handler(accessor, params) {
+    if (accessor.get(ILogService).warn("[Deprecated] UpdateDataValidationSettingCommand is deprecated, please use UpdateSheetDataValidationSettingCommand in @univerjs/sheets-data-validation instead!"), !params)
       return !1;
-    const r = a.get(T), n = a.get(M), o = a.get(h), i = a.get(J), { unitId: l, subUnitId: d, ruleId: c, setting: p } = e, _ = i.getValidatorItem(p.type);
-    if (!_)
+    const commandService = accessor.get(ICommandService), redoUndoService = accessor.get(IUndoRedoService), dataValidationModel = accessor.get(DataValidationModel), dataValidatorRegistryService = accessor.get(DataValidatorRegistryService), { unitId, subUnitId, ruleId, setting } = params, validator = dataValidatorRegistryService.getValidatorItem(setting.type);
+    if (!validator)
       return !1;
-    const V = o.getRuleById(l, d, c);
-    if (!V || !_.validatorFormula({ ...V, ...p }, l, d).success)
+    const rule = dataValidationModel.getRuleById(unitId, subUnitId, ruleId);
+    if (!rule || !validator.validatorFormula({ ...rule, ...setting }, unitId, subUnitId).success)
       return !1;
-    const I = {
-      unitId: l,
-      subUnitId: d,
-      ruleId: c,
+    const mutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
       payload: {
-        type: g.SETTING,
-        payload: p
+        type: UpdateRuleType.SETTING,
+        payload: setting
       }
-    }, U = [{
-      id: f.id,
-      params: I
-    }], X = {
-      unitId: l,
-      subUnitId: d,
-      ruleId: c,
+    }, redoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: mutationParams
+    }], undoMutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
       payload: {
-        type: g.SETTING,
-        payload: z(V)
+        type: UpdateRuleType.SETTING,
+        payload: getRuleSetting(rule)
       }
-    }, Y = [{
-      id: f.id,
-      params: X
+    }, undoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: undoMutationParams
     }];
-    return n.pushUndoRedo({
-      unitID: l,
-      redoMutations: U,
-      undoMutations: Y
-    }), r.executeCommand(f.id, I), !0;
-  }
-}, Se = {
-  type: E.COMMAND,
+    return redoUndoService.pushUndoRedo({
+      unitID: unitId,
+      redoMutations,
+      undoMutations
+    }), commandService.executeCommand(UpdateDataValidationMutation.id, mutationParams), !0;
+  }
+}, RemoveAllDataValidationCommand = {
+  type: CommandType.COMMAND,
   id: "data-validation.command.removeAll",
-  handler(a, e) {
-    if (!e)
+  handler(accessor, params) {
+    if (!params)
       return !1;
-    const { unitId: t, subUnitId: r } = e, n = a.get(T), o = a.get(h), i = a.get(M), l = [...o.getRules(t, r)], d = {
-      unitId: t,
-      subUnitId: r,
-      ruleId: l.map((_) => _.uid)
-    }, c = [{
-      id: S.id,
-      params: d
-    }], p = [{
-      id: m.id,
+    const { unitId, subUnitId } = params, commandService = accessor.get(ICommandService), dataValidationModel = accessor.get(DataValidationModel), undoRedoService = accessor.get(IUndoRedoService), currentRules = [...dataValidationModel.getRules(unitId, subUnitId)], redoParams = {
+      unitId,
+      subUnitId,
+      ruleId: currentRules.map((rule) => rule.uid)
+    }, redoMutations = [{
+      id: RemoveDataValidationMutation.id,
+      params: redoParams
+    }], undoMutations = [{
+      id: AddDataValidationMutation.id,
       params: {
-        unitId: t,
-        subUnitId: r,
-        rule: l
+        unitId,
+        subUnitId,
+        rule: currentRules
       }
     }];
-    return i.pushUndoRedo({
-      redoMutations: c,
-      undoMutations: p,
-      unitID: t
-    }), n.executeCommand(S.id, d), !0;
+    return undoRedoService.pushUndoRedo({
+      redoMutations,
+      undoMutations,
+      unitID: unitId
+    }), commandService.executeCommand(RemoveDataValidationMutation.id, redoParams), !0;
   }
 };
-var Te = Object.defineProperty, Ve = Object.getOwnPropertyDescriptor, Me = (a, e, t, r) => {
-  for (var n = r > 1 ? void 0 : r ? Ve(e, t) : e, o = a.length - 1, i; o >= 0; o--)
-    (i = a[o]) && (n = (r ? i(e, t, n) : i(n)) || n);
-  return r && n && Te(e, t, n), n;
-}, D = (a, e) => (t, r) => e(t, r, a);
-const Ie = "SHEET_DATA_VALIDATION_PLUGIN";
-let A = class extends O {
-  constructor(a, e, t) {
-    super(), this._resourceManagerService = a, this._univerInstanceService = e, this._dataValidationModel = t, this._initSnapshot();
+var __defProp$3 = Object.defineProperty, __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor, __decorateClass$3 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$3(target, key, result), result;
+}, "__decorateClass$3"), __decorateParam$3 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$3");
+const DATA_VALIDATION_PLUGIN_NAME = "SHEET_DATA_VALIDATION_PLUGIN";
+var _a2;
+let DataValidationResourceController = (_a2 = class extends Disposable {
+  constructor(_resourceManagerService, _univerInstanceService, _dataValidationModel) {
+    super(), this._resourceManagerService = _resourceManagerService, this._univerInstanceService = _univerInstanceService, this._dataValidationModel = _dataValidationModel, this._initSnapshot();
   }
   _initSnapshot() {
-    const a = (t) => {
-      const r = this._dataValidationModel.getUnitRules(t), n = {};
-      return r ? (r.forEach(([o, i]) => {
-        n[o] = i;
-      }), JSON.stringify(n)) : "";
-    }, e = (t) => {
-      if (!t)
+    const toJson = /* @__PURE__ */ __name((unitID) => {
+      const map = this._dataValidationModel.getUnitRules(unitID), resultMap = {};
+      return map ? (map.forEach(([key, v]) => {
+        resultMap[key] = v;
+      }), JSON.stringify(resultMap)) : "";
+    }, "toJson"), parseJson = /* @__PURE__ */ __name((json) => {
+      if (!json)
         return {};
       try {
-        return JSON.parse(t);
+        return JSON.parse(json);
       } catch {
         return {};
       }
-    };
+    }, "parseJson");
     this.disposeWithMe(
       this._resourceManagerService.registerPluginResource({
-        pluginName: Ie,
-        businesses: [w.UNIVER_SHEET],
-        toJson: (t) => a(t),
-        parseJson: (t) => e(t),
-        onUnLoad: (t) => {
-          this._dataValidationModel.deleteUnitRules(t);
-        },
-        onLoad: (t, r) => {
-          Object.keys(r).forEach((n) => {
-            r[n].forEach((i) => {
-              this._dataValidationModel.addRule(t, n, i);
+        pluginName: DATA_VALIDATION_PLUGIN_NAME,
+        businesses: [UniverInstanceType.UNIVER_SHEET],
+        toJson: /* @__PURE__ */ __name((unitID) => toJson(unitID), "toJson"),
+        parseJson: /* @__PURE__ */ __name((json) => parseJson(json), "parseJson"),
+        onUnLoad: /* @__PURE__ */ __name((unitID) => {
+          this._dataValidationModel.deleteUnitRules(unitID);
+        }, "onUnLoad"),
+        onLoad: /* @__PURE__ */ __name((unitID, value) => {
+          Object.keys(value).forEach((subunitId) => {
+            value[subunitId].forEach((rule) => {
+              this._dataValidationModel.addRule(unitID, subunitId, rule, "patched");
             });
           });
-        }
+        }, "onLoad")
       })
     );
   }
-};
-A = Me([
-  Q(j.Ready, A),
-  D(0, re),
-  D(1, W),
-  D(2, v(h))
-], A);
-var Re = Object.defineProperty, Ae = Object.getOwnPropertyDescriptor, Ne = (a, e, t, r) => {
-  for (var n = r > 1 ? void 0 : r ? Ae(e, t) : e, o = a.length - 1, i; o >= 0; o--)
-    (i = a[o]) && (n = (r ? i(e, t, n) : i(n)) || n);
-  return r && n && Re(e, t, n), n;
-}, L = (a, e) => (t, r) => e(t, r, a);
-let N = class extends O {
-  constructor(a, e, t) {
-    super(), this._sheetInterceptorService = a, this._univerInstanceService = e, this._dataValidationModel = t, this._initSheetChange();
+}, __name(_a2, "DataValidationResourceController"), _a2);
+DataValidationResourceController = __decorateClass$3([
+  OnLifecycle(LifecycleStages.Ready, DataValidationResourceController),
+  __decorateParam$3(0, IResourceManagerService),
+  __decorateParam$3(1, IUniverInstanceService),
+  __decorateParam$3(2, Inject(DataValidationModel))
+], DataValidationResourceController);
+var __defProp$2 = Object.defineProperty, __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor, __decorateClass$2 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$2(target, key, result), result;
+}, "__decorateClass$2"), __decorateParam$2 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$2"), _a3;
+let DataValidationSheetController = (_a3 = class extends Disposable {
+  constructor(_sheetInterceptorService, _univerInstanceService, _dataValidationModel) {
+    super(), this._sheetInterceptorService = _sheetInterceptorService, this._univerInstanceService = _univerInstanceService, this._dataValidationModel = _dataValidationModel, this._initSheetChange();
   }
   _initSheetChange() {
     this.disposeWithMe(
       this._sheetInterceptorService.interceptCommand({
-        getMutations: (a) => {
-          var e;
-          if (a.id === de.id) {
-            const t = a.params, r = t.unitId || this._univerInstanceService.getCurrentUnitForType(w.UNIVER_SHEET).getUnitId(), n = this._univerInstanceService.getUniverSheetInstance(r);
-            if (!n)
+        getMutations: /* @__PURE__ */ __name((commandInfo) => {
+          var _a6;
+          if (commandInfo.id === RemoveSheetCommand.id) {
+            const params = commandInfo.params, unitId = params.unitId || this._univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET).getUnitId(), workbook = this._univerInstanceService.getUniverSheetInstance(unitId);
+            if (!workbook)
               return { redos: [], undos: [] };
-            const o = t.subUnitId || ((e = n.getActiveSheet()) == null ? void 0 : e.getSheetId());
-            if (!o)
+            const subUnitId = params.subUnitId || ((_a6 = workbook.getActiveSheet()) == null ? void 0 : _a6.getSheetId());
+            if (!subUnitId)
               return { redos: [], undos: [] };
-            const i = this._dataValidationModel.ensureManager(r, o);
-            if (!i)
+            const manager = this._dataValidationModel.ensureManager(unitId, subUnitId);
+            if (!manager)
               return { redos: [], undos: [] };
-            const l = i.getDataValidations(), d = l.map((_) => _.uid), c = {
-              unitId: r,
-              subUnitId: o,
-              ruleId: d
-            }, p = {
-              unitId: r,
-              subUnitId: o,
-              rule: l
+            const rules = manager.getDataValidations(), ids = rules.map((i) => i.uid), redoParams = {
+              unitId,
+              subUnitId,
+              ruleId: ids,
+              source: "patched"
+            }, undoParams = {
+              unitId,
+              subUnitId,
+              rule: rules,
+              source: "patched"
             };
             return {
               redos: [{
-                id: S.id,
-                params: c
+                id: RemoveDataValidationMutation.id,
+                params: redoParams
               }],
               undos: [{
-                id: m.id,
-                params: p
+                id: AddDataValidationMutation.id,
+                params: undoParams
               }]
             };
           }
           return { redos: [], undos: [] };
-        }
+        }, "getMutations")
       })
     );
   }
-};
-N = Ne([
-  Q(j.Ready, N),
-  L(0, v(le)),
-  L(1, v(W)),
-  L(2, v(h))
-], N);
-var Oe = Object.defineProperty, ye = Object.getOwnPropertyDescriptor, Ue = (a, e, t, r) => {
-  for (var n = r > 1 ? void 0 : r ? ye(e, t) : e, o = a.length - 1, i; o >= 0; o--)
-    (i = a[o]) && (n = (r ? i(e, t, n) : i(n)) || n);
-  return r && n && Oe(e, t, n), n;
-}, B = (a, e) => (t, r) => e(t, r, a);
-const De = "UNIVER_DATA_VALIDATION_PLUGIN";
-var R;
-let P = (R = class extends ne {
-  constructor(a, e, t) {
-    super(), this._injector = e, this._commandService = t;
-  }
-  onStarting(a) {
+}, __name(_a3, "DataValidationSheetController"), _a3);
+DataValidationSheetController = __decorateClass$2([
+  OnLifecycle(LifecycleStages.Ready, DataValidationSheetController),
+  __decorateParam$2(0, Inject(SheetInterceptorService)),
+  __decorateParam$2(1, Inject(IUniverInstanceService)),
+  __decorateParam$2(2, Inject(DataValidationModel))
+], DataValidationSheetController);
+var __defProp$1 = Object.defineProperty, __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor, __decorateClass$1 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$1(target, key, result), result;
+}, "__decorateClass$1"), __decorateParam$1 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$1");
+const PLUGIN_NAME = "UNIVER_DATA_VALIDATION_PLUGIN";
+var _a4;
+let UniverDataValidationPlugin = (_a4 = class extends Plugin {
+  constructor(_config, _injector, _commandService) {
+    super(), this._injector = _injector, this._commandService = _commandService;
+  }
+  onStarting() {
     [
-      // model
-      [h],
-      // service
-      [J],
-      [A],
-      [N]
-    ].forEach(
-      (e) => {
-        a.add(e);
-      }
-    ), [
+      [DataValidationModel],
+      [DataValidatorRegistryService],
+      [DataValidationResourceController],
+      [DataValidationSheetController]
+    ].forEach((d) => this._injector.add(d)), [
       // command
-      me,
-      Se,
-      ve,
-      fe,
-      Ee,
+      AddDataValidationCommand,
+      RemoveAllDataValidationCommand,
+      UpdateDataValidationOptionsCommand,
+      UpdateDataValidationSettingCommand,
+      RemoveDataValidationCommand,
       // mutation
-      m,
-      f,
-      S
-    ].forEach((e) => {
-      this._commandService.registerCommand(e);
+      AddDataValidationMutation,
+      UpdateDataValidationMutation,
+      RemoveDataValidationMutation
+    ].forEach((command) => {
+      this._commandService.registerCommand(command);
     });
   }
-}, u(R, "pluginName", De), u(R, "type", w.UNIVER_SHEET), R);
-P = Ue([
-  B(1, v(F)),
-  B(2, T)
-], P);
-s.BETWEEN + "", s.EQUAL + "", s.GREATER_THAN + "", s.GREATER_THAN_OR_EQUAL + "", s.LESS_THAN + "", s.LESS_THAN_OR_EQUAL + "", s.NOT_BETWEEN + "", s.NOT_EQUAL + "";
-const Le = {
-  [s.BETWEEN]: "dataValidation.ruleName.between",
-  [s.EQUAL]: "dataValidation.ruleName.equal",
-  [s.GREATER_THAN]: "dataValidation.ruleName.greaterThan",
-  [s.GREATER_THAN_OR_EQUAL]: "dataValidation.ruleName.greaterThanOrEqual",
-  [s.LESS_THAN]: "dataValidation.ruleName.lessThan",
-  [s.LESS_THAN_OR_EQUAL]: "dataValidation.ruleName.lessThanOrEqual",
-  [s.NOT_BETWEEN]: "dataValidation.ruleName.notBetween",
-  [s.NOT_EQUAL]: "dataValidation.ruleName.notEqual"
-}, Ce = {
-  [s.BETWEEN]: "dataValidation.errorMsg.between",
-  [s.EQUAL]: "dataValidation.errorMsg.equal",
-  [s.GREATER_THAN]: "dataValidation.errorMsg.greaterThan",
-  [s.GREATER_THAN_OR_EQUAL]: "dataValidation.errorMsg.greaterThanOrEqual",
-  [s.LESS_THAN]: "dataValidation.errorMsg.lessThan",
-  [s.LESS_THAN_OR_EQUAL]: "dataValidation.errorMsg.lessThanOrEqual",
-  [s.NOT_BETWEEN]: "dataValidation.errorMsg.notBetween",
-  [s.NOT_EQUAL]: "dataValidation.errorMsg.notEqual"
-}, We = {
-  [s.BETWEEN]: "dataValidation.textLength.errorMsg.between",
-  [s.EQUAL]: "dataValidation.textLength.errorMsg.equal",
-  [s.GREATER_THAN]: "dataValidation.textLength.errorMsg.greaterThan",
-  [s.GREATER_THAN_OR_EQUAL]: "dataValidation.textLength.errorMsg.greaterThanOrEqual",
-  [s.LESS_THAN]: "dataValidation.textLength.errorMsg.lessThan",
-  [s.LESS_THAN_OR_EQUAL]: "dataValidation.textLength.errorMsg.lessThanOrEqual",
-  [s.NOT_BETWEEN]: "dataValidation.textLength.errorMsg.notBetween",
-  [s.NOT_EQUAL]: "dataValidation.textLength.errorMsg.notEqual"
+}, __name(_a4, "UniverDataValidationPlugin"), __publicField(_a4, "pluginName", PLUGIN_NAME), __publicField(_a4, "type", UniverInstanceType.UNIVER_SHEET), _a4);
+UniverDataValidationPlugin = __decorateClass$1([
+  __decorateParam$1(1, Inject(Injector)),
+  __decorateParam$1(2, ICommandService)
+], UniverDataValidationPlugin);
+DataValidationOperator.BETWEEN + "", DataValidationOperator.EQUAL + "", DataValidationOperator.GREATER_THAN + "", DataValidationOperator.GREATER_THAN_OR_EQUAL + "", DataValidationOperator.LESS_THAN + "", DataValidationOperator.LESS_THAN_OR_EQUAL + "", DataValidationOperator.NOT_BETWEEN + "", DataValidationOperator.NOT_EQUAL + "";
+const OperatorTitleMap = {
+  [DataValidationOperator.BETWEEN]: "dataValidation.ruleName.between",
+  [DataValidationOperator.EQUAL]: "dataValidation.ruleName.equal",
+  [DataValidationOperator.GREATER_THAN]: "dataValidation.ruleName.greaterThan",
+  [DataValidationOperator.GREATER_THAN_OR_EQUAL]: "dataValidation.ruleName.greaterThanOrEqual",
+  [DataValidationOperator.LESS_THAN]: "dataValidation.ruleName.lessThan",
+  [DataValidationOperator.LESS_THAN_OR_EQUAL]: "dataValidation.ruleName.lessThanOrEqual",
+  [DataValidationOperator.NOT_BETWEEN]: "dataValidation.ruleName.notBetween",
+  [DataValidationOperator.NOT_EQUAL]: "dataValidation.ruleName.notEqual"
+}, OperatorErrorTitleMap = {
+  [DataValidationOperator.BETWEEN]: "dataValidation.errorMsg.between",
+  [DataValidationOperator.EQUAL]: "dataValidation.errorMsg.equal",
+  [DataValidationOperator.GREATER_THAN]: "dataValidation.errorMsg.greaterThan",
+  [DataValidationOperator.GREATER_THAN_OR_EQUAL]: "dataValidation.errorMsg.greaterThanOrEqual",
+  [DataValidationOperator.LESS_THAN]: "dataValidation.errorMsg.lessThan",
+  [DataValidationOperator.LESS_THAN_OR_EQUAL]: "dataValidation.errorMsg.lessThanOrEqual",
+  [DataValidationOperator.NOT_BETWEEN]: "dataValidation.errorMsg.notBetween",
+  [DataValidationOperator.NOT_EQUAL]: "dataValidation.errorMsg.notEqual"
+}, TextLengthErrorTitleMap = {
+  [DataValidationOperator.BETWEEN]: "dataValidation.textLength.errorMsg.between",
+  [DataValidationOperator.EQUAL]: "dataValidation.textLength.errorMsg.equal",
+  [DataValidationOperator.GREATER_THAN]: "dataValidation.textLength.errorMsg.greaterThan",
+  [DataValidationOperator.GREATER_THAN_OR_EQUAL]: "dataValidation.textLength.errorMsg.greaterThanOrEqual",
+  [DataValidationOperator.LESS_THAN]: "dataValidation.textLength.errorMsg.lessThan",
+  [DataValidationOperator.LESS_THAN_OR_EQUAL]: "dataValidation.textLength.errorMsg.lessThanOrEqual",
+  [DataValidationOperator.NOT_BETWEEN]: "dataValidation.textLength.errorMsg.notBetween",
+  [DataValidationOperator.NOT_EQUAL]: "dataValidation.textLength.errorMsg.notEqual"
 };
-var we = Object.defineProperty, be = Object.getOwnPropertyDescriptor, Be = (a, e, t, r) => {
-  for (var n = r > 1 ? void 0 : r ? be(e, t) : e, o = a.length - 1, i; o >= 0; o--)
-    (i = a[o]) && (n = (r ? i(e, t, n) : i(n)) || n);
-  return r && n && we(e, t, n), n;
-}, $ = (a, e) => (t, r) => e(t, r, a);
-const x = "{FORMULA1}", H = "{FORMULA2}", Pe = {
-  [s.BETWEEN]: "dataValidation.operators.between",
-  [s.EQUAL]: "dataValidation.operators.equal",
-  [s.GREATER_THAN]: "dataValidation.operators.greaterThan",
-  [s.GREATER_THAN_OR_EQUAL]: "dataValidation.operators.greaterThanOrEqual",
-  [s.LESS_THAN]: "dataValidation.operators.lessThan",
-  [s.LESS_THAN_OR_EQUAL]: "dataValidation.operators.lessThanOrEqual",
-  [s.NOT_BETWEEN]: "dataValidation.operators.notBetween",
-  [s.NOT_EQUAL]: "dataValidation.operators.notEqual"
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam");
+const FORMULA1 = "{FORMULA1}", FORMULA2 = "{FORMULA2}", operatorNameMap = {
+  [DataValidationOperator.BETWEEN]: "dataValidation.operators.between",
+  [DataValidationOperator.EQUAL]: "dataValidation.operators.equal",
+  [DataValidationOperator.GREATER_THAN]: "dataValidation.operators.greaterThan",
+  [DataValidationOperator.GREATER_THAN_OR_EQUAL]: "dataValidation.operators.greaterThanOrEqual",
+  [DataValidationOperator.LESS_THAN]: "dataValidation.operators.lessThan",
+  [DataValidationOperator.LESS_THAN_OR_EQUAL]: "dataValidation.operators.lessThanOrEqual",
+  [DataValidationOperator.NOT_BETWEEN]: "dataValidation.operators.notBetween",
+  [DataValidationOperator.NOT_EQUAL]: "dataValidation.operators.notEqual"
 };
-let q = class {
-  constructor(a, e) {
-    u(this, "canvasRender", null);
-    u(this, "dropdown");
-    u(this, "optionsInput");
-    this.localeService = a, this.injector = e;
+var _a5;
+let BaseDataValidator = (_a5 = class {
+  constructor(localeService, injector) {
+    __publicField(this, "canvasRender", null);
+    __publicField(this, "dropdown");
+    __publicField(this, "optionsInput");
+    this.localeService = localeService, this.injector = injector;
   }
   get operatorNames() {
-    return this.operators.map((a) => this.localeService.t(Pe[a]));
+    return this.operators.map((operator) => this.localeService.t(operatorNameMap[operator]));
   }
   get titleStr() {
     return this.localeService.t(this.title);
   }
-  skipDefaultFontRender(a, e, t) {
+  skipDefaultFontRender(rule, cellValue, pos) {
     return !1;
   }
-  generateRuleName(a) {
-    var t, r;
-    if (!a.operator)
+  generateRuleName(rule) {
+    var _a6, _b;
+    if (!rule.operator)
       return this.titleStr;
-    const e = this.localeService.t(Le[a.operator]).replace(x, (t = a.formula1) != null ? t : "").replace(H, (r = a.formula2) != null ? r : "");
-    return `${this.titleStr} ${e}`;
+    const ruleName = this.localeService.t(OperatorTitleMap[rule.operator]).replace(FORMULA1, (_a6 = rule.formula1) != null ? _a6 : "").replace(FORMULA2, (_b = rule.formula2) != null ? _b : "");
+    return `${this.titleStr} ${ruleName}`;
   }
-  generateRuleErrorMessage(a) {
-    var t, r;
-    return a.operator ? `${this.localeService.t(Ce[a.operator]).replace(x, (t = a.formula1) != null ? t : "").replace(H, (r = a.formula2) != null ? r : "")}` : this.titleStr;
+  generateRuleErrorMessage(rule) {
+    var _a6, _b;
+    return rule.operator ? `${this.localeService.t(OperatorErrorTitleMap[rule.operator]).replace(FORMULA1, (_a6 = rule.formula1) != null ? _a6 : "").replace(FORMULA2, (_b = rule.formula2) != null ? _b : "")}` : this.titleStr;
   }
-  getRuleFinalError(a) {
-    return a.showInputMessage && a.error ? a.error : this.generateRuleErrorMessage(a);
+  getRuleFinalError(rule) {
+    return rule.showInputMessage && rule.error ? rule.error : this.generateRuleErrorMessage(rule);
   }
-  isEmptyCellValue(a) {
-    return a === "" || a === void 0 || a === null;
+  isEmptyCellValue(cellValue) {
+    return cellValue === "" || cellValue === void 0 || cellValue === null;
   }
-  async isValidType(a, e, t) {
+  async isValidType(cellInfo, formula, rule) {
     return !0;
   }
-  transform(a, e, t) {
-    return a;
+  transform(cellInfo, formula, rule) {
+    return cellInfo;
   }
-  async validatorIsEqual(a, e, t) {
+  async validatorIsEqual(cellInfo, formula, rule) {
     return !0;
   }
-  async validatorIsNotEqual(a, e, t) {
+  async validatorIsNotEqual(cellInfo, formula, rule) {
     return !0;
   }
-  async validatorIsBetween(a, e, t) {
+  async validatorIsBetween(cellInfo, formula, rule) {
     return !0;
   }
-  async validatorIsNotBetween(a, e, t) {
+  async validatorIsNotBetween(cellInfo, formula, rule) {
     return !0;
   }
-  async validatorIsGreaterThan(a, e, t) {
+  async validatorIsGreaterThan(cellInfo, formula, rule) {
     return !0;
   }
-  async validatorIsGreaterThanOrEqual(a, e, t) {
+  async validatorIsGreaterThanOrEqual(cellInfo, formula, rule) {
     return !0;
   }
-  async validatorIsLessThan(a, e, t) {
+  async validatorIsLessThan(cellInfo, formula, rule) {
     return !0;
   }
-  async validatorIsLessThanOrEqual(a, e, t) {
+  async validatorIsLessThanOrEqual(cellInfo, formula, rule) {
     return !0;
   }
-  async validator(a, e) {
-    const { value: t, unitId: r, subUnitId: n } = a, o = this.isEmptyCellValue(t), { allowBlank: i = !0, operator: l } = e;
-    if (o)
-      return i;
-    const d = await this.parseFormula(e, r, n);
-    if (!await this.isValidType(a, d, e))
+  async validator(cellInfo, rule) {
+    const { value: cellValue, unitId, subUnitId } = cellInfo, isEmpty = this.isEmptyCellValue(cellValue), { allowBlank = !0, operator } = rule;
+    if (isEmpty)
+      return allowBlank;
+    const formulaInfo = await this.parseFormula(rule, unitId, subUnitId);
+    if (!await this.isValidType(cellInfo, formulaInfo, rule))
       return !1;
-    if (!G.isDefine(l))
+    if (!Tools.isDefine(operator))
       return !0;
-    const c = this.transform(a, d, e);
-    switch (l) {
-      case s.BETWEEN:
-        return this.validatorIsBetween(c, d, e);
-      case s.EQUAL:
-        return this.validatorIsEqual(c, d, e);
-      case s.GREATER_THAN:
-        return this.validatorIsGreaterThan(c, d, e);
-      case s.GREATER_THAN_OR_EQUAL:
-        return this.validatorIsGreaterThanOrEqual(c, d, e);
-      case s.LESS_THAN:
-        return this.validatorIsLessThan(c, d, e);
-      case s.LESS_THAN_OR_EQUAL:
-        return this.validatorIsLessThanOrEqual(c, d, e);
-      case s.NOT_BETWEEN:
-        return this.validatorIsNotBetween(c, d, e);
-      case s.NOT_EQUAL:
-        return this.validatorIsNotEqual(c, d, e);
+    const transformedCell = this.transform(cellInfo, formulaInfo, rule);
+    switch (operator) {
+      case DataValidationOperator.BETWEEN:
+        return this.validatorIsBetween(transformedCell, formulaInfo, rule);
+      case DataValidationOperator.EQUAL:
+        return this.validatorIsEqual(transformedCell, formulaInfo, rule);
+      case DataValidationOperator.GREATER_THAN:
+        return this.validatorIsGreaterThan(transformedCell, formulaInfo, rule);
+      case DataValidationOperator.GREATER_THAN_OR_EQUAL:
+        return this.validatorIsGreaterThanOrEqual(transformedCell, formulaInfo, rule);
+      case DataValidationOperator.LESS_THAN:
+        return this.validatorIsLessThan(transformedCell, formulaInfo, rule);
+      case DataValidationOperator.LESS_THAN_OR_EQUAL:
+        return this.validatorIsLessThanOrEqual(transformedCell, formulaInfo, rule);
+      case DataValidationOperator.NOT_BETWEEN:
+        return this.validatorIsNotBetween(transformedCell, formulaInfo, rule);
+      case DataValidationOperator.NOT_EQUAL:
+        return this.validatorIsNotEqual(transformedCell, formulaInfo, rule);
       default:
         throw new Error("Unknown operator.");
     }
   }
-};
-q = Be([
-  $(0, v(oe)),
-  $(1, v(F))
-], q);
-const Fe = [
-  s.BETWEEN,
-  s.NOT_BETWEEN
+}, __name(_a5, "BaseDataValidator"), _a5);
+BaseDataValidator = __decorateClass([
+  __decorateParam(0, Inject(LocaleService)),
+  __decorateParam(1, Inject(Injector))
+], BaseDataValidator);
+const TWO_FORMULA_OPERATOR_COUNT = [
+  DataValidationOperator.BETWEEN,
+  DataValidationOperator.NOT_BETWEEN
 ];
 export {
-  me as AddDataValidationCommand,
-  m as AddDataValidationMutation,
-  q as BaseDataValidator,
-  ce as DataValidationManager,
-  h as DataValidationModel,
-  A as DataValidationResourceController,
-  N as DataValidationSheetController,
-  ue as DataValidatorRegistryScope,
-  J as DataValidatorRegistryService,
-  Se as RemoveAllDataValidationCommand,
-  Ee as RemoveDataValidationCommand,
-  S as RemoveDataValidationMutation,
-  Fe as TWO_FORMULA_OPERATOR_COUNT,
-  We as TextLengthErrorTitleMap,
-  P as UniverDataValidationPlugin,
-  f as UpdateDataValidationMutation,
-  ve as UpdateDataValidationOptionsCommand,
-  fe as UpdateDataValidationSettingCommand,
-  g as UpdateRuleType,
-  Qe as createDefaultNewRule,
-  K as getRuleOptions,
-  z as getRuleSetting,
-  je as removeDataValidationUndoFactory
+  AddDataValidationCommand,
+  AddDataValidationMutation,
+  BaseDataValidator,
+  DataValidationManager,
+  DataValidationModel,
+  DataValidationResourceController,
+  DataValidationSheetController,
+  DataValidatorRegistryScope,
+  DataValidatorRegistryService,
+  RemoveAllDataValidationCommand,
+  RemoveDataValidationCommand,
+  RemoveDataValidationMutation,
+  TWO_FORMULA_OPERATOR_COUNT,
+  TextLengthErrorTitleMap,
+  UniverDataValidationPlugin,
+  UpdateDataValidationMutation,
+  UpdateDataValidationOptionsCommand,
+  UpdateDataValidationSettingCommand,
+  UpdateRuleType,
+  createDefaultNewRule,
+  getRuleOptions,
+  getRuleSetting,
+  removeDataValidationUndoFactory
 };