@univerjs/data-validation 0.1.6

package/lib/es/index.js

@@ -0,0 +1,667 @@
+var P = Object.defineProperty;
+var q = (e, a, t) => a in e ? P(e, a, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[a] = t;
+var c = (e, a, t) => (q(e, typeof a != "symbol" ? a + "" : a, t), t);
+import { toDisposable as G, Disposable as U, ILogService as H, CommandType as m, Tools as L, DataValidationType as Q, DataValidationOperator as s, ICommandService as T, IUndoRedoService as M, Plugin as W, LocaleService as j, DataValidationStatus as F } from "@univerjs/core";
+import { Inject as I, Injector as B } from "@wendellhu/redi";
+import { BehaviorSubject as J, Subject as S, debounceTime as A } from "rxjs";
+import { SelectionManagerService as z } from "@univerjs/sheets";
+var K = /* @__PURE__ */ ((e) => (e.SHEET = "sheet", e))(K || {});
+class b {
+  constructor() {
+    c(this, "_validatorByScopes", /* @__PURE__ */ new Map());
+    c(this, "_validatorMap", /* @__PURE__ */ new Map());
+    c(this, "_validatorsChange$", new J(void 0));
+    c(this, "validatorsChange$", this._validatorsChange$.asObservable());
+  }
+  _addValidatorToScope(a, t) {
+    this._validatorByScopes.has(t) || this._validatorByScopes.set(t, []);
+    const r = this._validatorByScopes.get(t);
+    if (r.findIndex((o) => o.id === a.id) > -1)
+      throw new Error(`Validator item with the same id ${a.id} has already been added!`);
+    r.push(a);
+  }
+  _removeValidatorFromScope(a, t) {
+    const r = this._validatorByScopes.get(t);
+    if (!r)
+      return;
+    const o = r.findIndex((n) => n.id === a.id);
+    o > -1 && r.splice(o, 1);
+  }
+  register(a) {
+    return this._validatorMap.set(a.id, a), Array.isArray(a.scopes) ? a.scopes.forEach((t) => {
+      this._addValidatorToScope(a, t);
+    }) : this._addValidatorToScope(a, a.scopes), this._validatorsChange$.next(), G(() => {
+      this._validatorMap.delete(a.id), Array.isArray(a.scopes) ? a.scopes.forEach((t) => {
+        this._removeValidatorFromScope(a, t);
+      }) : this._removeValidatorFromScope(a, a.scopes), this._validatorsChange$.next();
+    });
+  }
+  getValidatorItem(a) {
+    return this._validatorMap.get(a);
+  }
+  getValidatorsByScope(a) {
+    return this._validatorByScopes.get(a);
+  }
+}
+var X = Object.defineProperty, Y = Object.getOwnPropertyDescriptor, Z = (e, a, t, r) => {
+  for (var o = r > 1 ? void 0 : r ? Y(a, t) : a, n = e.length - 1, i; n >= 0; n--)
+    (i = e[n]) && (o = (r ? i(a, t, o) : i(o)) || o);
+  return r && o && X(a, t, o), o;
+}, k = (e, a) => (t, r) => a(t, r, e);
+let h = class extends U {
+  constructor(a) {
+    super();
+    c(this, "_model", /* @__PURE__ */ new Map());
+    c(this, "_managerCreator");
+    c(this, "_ruleChange$", new S());
+    c(this, "_validStatusChange$", new S());
+    c(this, "ruleChange$", this._ruleChange$.asObservable());
+    c(this, "ruleChangeDebounce$", this.ruleChange$.pipe(A(20)));
+    c(this, "validStatusChange$", this._validStatusChange$.asObservable().pipe(A(20)));
+    this._logService = a, this.disposeWithMe({
+      dispose: () => {
+        this._ruleChange$.complete(), this._validStatusChange$.complete();
+      }
+    });
+  }
+  setManagerCreator(a) {
+    this._managerCreator = a;
+  }
+  ensureManager(a, t) {
+    this._model.has(a) || this._model.set(a, /* @__PURE__ */ new Map());
+    const r = this._model.get(a);
+    if (r.has(t))
+      return r.get(t);
+    const o = this._managerCreator(a, t);
+    return r.set(t, o), o;
+  }
+  addRule(a, t, r, o) {
+    try {
+      this.ensureManager(a, t).addRule(r, o), this._ruleChange$.next({
+        rule: r,
+        type: "add",
+        unitId: a,
+        subUnitId: t
+      });
+    } catch (n) {
+      this._logService.error(n);
+    }
+  }
+  updateRule(a, t, r, o) {
+    try {
+      const i = this.ensureManager(a, t).updateRule(r, o);
+      this._ruleChange$.next({
+        rule: i,
+        type: "update",
+        unitId: a,
+        subUnitId: t
+      });
+    } catch (n) {
+      this._logService.error(n);
+    }
+  }
+  removeRule(a, t, r) {
+    try {
+      const o = this.ensureManager(a, t), n = o.getRuleById(r);
+      o.removeRule(r), this._ruleChange$.next({
+        rule: n,
+        type: "remove",
+        unitId: a,
+        subUnitId: t
+      });
+    } catch (o) {
+      this._logService.error(o);
+    }
+  }
+  getRuleById(a, t, r) {
+    return this.ensureManager(a, t).getRuleById(r);
+  }
+  getRuleIndex(a, t, r) {
+    return this.ensureManager(a, t).getRuleIndex(r);
+  }
+  getRules(a, t) {
+    return this.ensureManager(a, t).getDataValidations();
+  }
+  validator(a, t, r) {
+    const { unitId: o, subUnitId: n } = r;
+    return this.ensureManager(o, n).validator(a, t, r, (d) => {
+      this._validStatusChange$.next({
+        unitId: o,
+        subUnitId: n,
+        ruleId: t.uid,
+        status: d
+      });
+    });
+  }
+  getUnitRules(a) {
+    const t = this._model.get(a);
+    if (!t)
+      return [];
+    const r = [];
+    return t.forEach((o) => {
+      r.push([o.subUnitId, o.getDataValidations()]);
+    }), r;
+  }
+};
+h = Z([
+  k(0, H)
+], h);
+const E = {
+  type: m.MUTATION,
+  id: "data-validation.mutation.addRule",
+  handler(e, a) {
+    if (!a)
+      return !1;
+    const { unitId: t, subUnitId: r, rule: o, index: n } = a, i = e.get(h);
+    return Array.isArray(o) ? o.forEach((d) => {
+      i.addRule(t, r, d, n);
+    }) : i.addRule(t, r, o, n), !0;
+  }
+}, v = {
+  type: m.MUTATION,
+  id: "data-validation.mutation.removeRule",
+  handler(e, a) {
+    if (!a)
+      return !1;
+    const { unitId: t, subUnitId: r, ruleId: o } = a, n = e.get(h);
+    return Array.isArray(o) ? o.forEach((i) => {
+      n.removeRule(t, r, i);
+    }) : n.removeRule(t, r, o), !0;
+  }
+}, g = {
+  type: m.MUTATION,
+  id: "data-validation.mutation.updateRule",
+  handler(e, a) {
+    if (!a)
+      return !1;
+    const { unitId: t, subUnitId: r, ruleId: o, payload: n } = a;
+    return e.get(h).updateRule(t, r, o, n), !0;
+  }
+};
+function aa(e) {
+  return {
+    type: e.type,
+    operator: e.operator,
+    formula1: e.formula1,
+    formula2: e.formula2,
+    allowBlank: e.allowBlank
+  };
+}
+function ta(e) {
+  return {
+    error: e.error,
+    errorStyle: e.errorStyle,
+    errorTitle: e.errorTitle,
+    imeMode: e.imeMode,
+    prompt: e.prompt,
+    promptTitle: e.promptTitle,
+    showDropDown: e.showDropDown,
+    showErrorMessage: e.showErrorMessage,
+    showInputMessage: e.showInputMessage,
+    renderMode: e.renderMode
+  };
+}
+function Ra(e) {
+  const t = e.get(z).getSelectionRanges();
+  return {
+    uid: L.generateRandomId(6),
+    type: Q.DECIMAL,
+    operator: s.EQUAL,
+    formula1: "100",
+    ranges: t != null ? t : [{ startColumn: 0, endColumn: 0, startRow: 0, endRow: 0 }]
+  };
+}
+var p = /* @__PURE__ */ ((e) => (e[e.SETTING = 0] = "SETTING", e[e.RANGE = 1] = "RANGE", e[e.OPTIONS = 2] = "OPTIONS", e))(p || {});
+const ea = {
+  type: m.COMMAND,
+  id: "data-validation.command.addRule",
+  async handler(e, a) {
+    if (!a)
+      return !1;
+    const { rule: t, unitId: r, subUnitId: o } = a, n = e.get(T), i = e.get(M), d = {
+      ...a,
+      rule: {
+        ...a.rule,
+        ranges: [a.rule.range]
+      }
+    }, l = [{
+      id: E.id,
+      params: d
+    }], u = [{
+      id: v.id,
+      params: {
+        unitId: r,
+        subUnitId: o,
+        ruleId: t.uid
+      }
+    }];
+    return i.pushUndoRedo({
+      unitID: r,
+      redoMutations: l,
+      undoMutations: u
+    }), await n.executeCommand(E.id, d), !0;
+  }
+}, Va = (e, a) => {
+  const t = e.get(h), { unitId: r, subUnitId: o, ruleId: n } = a;
+  if (Array.isArray(n)) {
+    const d = n.map((l) => t.getRuleById(r, o, l)).filter(Boolean);
+    return [{
+      id: E.id,
+      params: {
+        unitId: r,
+        subUnitId: o,
+        rule: d
+      }
+    }];
+  }
+  return [{
+    id: E.id,
+    params: {
+      unitId: r,
+      subUnitId: o,
+      rule: {
+        ...t.getRuleById(r, o, n)
+      },
+      index: t.getRuleIndex(r, o, n)
+    }
+  }];
+}, ra = {
+  type: m.COMMAND,
+  id: "data-validation.command.removeRule",
+  handler(e, a) {
+    if (!a)
+      return !1;
+    const { unitId: t, subUnitId: r, ruleId: o } = a, n = e.get(T), i = e.get(M), d = e.get(h), l = [{
+      id: v.id,
+      params: a
+    }], u = [{
+      id: E.id,
+      params: {
+        unitId: t,
+        subUnitId: r,
+        rule: {
+          ...d.getRuleById(t, r, o)
+        },
+        index: d.getRuleIndex(t, r, o)
+      }
+    }];
+    return i.pushUndoRedo({
+      undoMutations: u,
+      redoMutations: l,
+      unitID: a.unitId
+    }), n.executeCommand(v.id, a), !0;
+  }
+}, oa = {
+  type: m.COMMAND,
+  id: "data-validation.command.updateDataValidationSetting",
+  handler(e, a) {
+    if (!a)
+      return !1;
+    const t = e.get(T), r = e.get(M), o = e.get(h), { unitId: n, subUnitId: i, ruleId: d, options: l } = a, u = o.getRuleById(n, i, d);
+    if (!u)
+      return !1;
+    const _ = {
+      unitId: n,
+      subUnitId: i,
+      ruleId: d,
+      payload: {
+        type: p.OPTIONS,
+        payload: l
+      }
+    }, f = [{
+      id: g.id,
+      params: _
+    }], R = {
+      unitId: n,
+      subUnitId: i,
+      ruleId: d,
+      payload: {
+        type: p.OPTIONS,
+        payload: ta(u)
+      }
+    }, V = [{
+      id: g.id,
+      params: R
+    }];
+    return r.pushUndoRedo({
+      unitID: n,
+      redoMutations: f,
+      undoMutations: V
+    }), t.executeCommand(g.id, _), !0;
+  }
+}, na = {
+  type: m.COMMAND,
+  id: "data-validation.command.updateDataValidationOptions",
+  handler(e, a) {
+    if (!a)
+      return !1;
+    const t = e.get(T), r = e.get(M), o = e.get(h), n = e.get(b), { unitId: i, subUnitId: d, ruleId: l, setting: u } = a, _ = n.getValidatorItem(u.type);
+    if (!_ || !_.validatorFormula(u).success)
+      return !1;
+    const f = o.getRuleById(i, d, l);
+    if (!f)
+      return !1;
+    const R = {
+      unitId: i,
+      subUnitId: d,
+      ruleId: l,
+      payload: {
+        type: p.SETTING,
+        payload: u
+      }
+    }, V = [{
+      id: g.id,
+      params: R
+    }], $ = {
+      unitId: i,
+      subUnitId: d,
+      ruleId: l,
+      payload: {
+        type: p.SETTING,
+        payload: aa(f)
+      }
+    }, x = [{
+      id: g.id,
+      params: $
+    }];
+    return r.pushUndoRedo({
+      unitID: i,
+      redoMutations: V,
+      undoMutations: x
+    }), t.executeCommand(g.id, R), !0;
+  }
+}, ia = {
+  type: m.COMMAND,
+  id: "data-validation.command.removeAll",
+  handler(e, a) {
+    if (!a)
+      return !1;
+    const { unitId: t, subUnitId: r } = a, o = e.get(T), n = e.get(h), i = e.get(M), d = [...n.getRules(t, r)], l = {
+      unitId: t,
+      subUnitId: r,
+      ruleId: d.map((f) => f.uid)
+    }, u = [{
+      id: v.id,
+      params: l
+    }], _ = [{
+      id: E.id,
+      params: {
+        unitId: t,
+        subUnitId: r,
+        rule: d
+      }
+    }];
+    return i.pushUndoRedo({
+      redoMutations: u,
+      undoMutations: _,
+      unitID: t
+    }), o.executeCommand(v.id, l), !0;
+  }
+};
+var sa = Object.defineProperty, da = Object.getOwnPropertyDescriptor, la = (e, a, t, r) => {
+  for (var o = r > 1 ? void 0 : r ? da(a, t) : a, n = e.length - 1, i; n >= 0; n--)
+    (i = e[n]) && (o = (r ? i(a, t, o) : i(o)) || o);
+  return r && o && sa(a, t, o), o;
+}, N = (e, a) => (t, r) => a(t, r, e);
+const ua = "data-validation";
+let O = class extends W {
+  constructor(e, a) {
+    super(ua), this._injector = e, this._commandService = a;
+  }
+  onStarting(e) {
+    [
+      // model
+      [h],
+      // service
+      [b]
+    ].forEach(
+      (a) => {
+        e.add(a);
+      }
+    ), [
+      // command
+      ea,
+      ia,
+      oa,
+      na,
+      ra,
+      // mutation
+      E,
+      g,
+      v
+    ].forEach((a) => {
+      this._commandService.registerCommand(a);
+    });
+  }
+};
+O = la([
+  N(0, I(B)),
+  N(1, T)
+], O);
+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 ca = {
+  [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"
+}, ha = {
+  [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"
+};
+var pa = Object.defineProperty, ma = Object.getOwnPropertyDescriptor, _a = (e, a, t, r) => {
+  for (var o = r > 1 ? void 0 : r ? ma(a, t) : a, n = e.length - 1, i; n >= 0; n--)
+    (i = e[n]) && (o = (r ? i(a, t, o) : i(o)) || o);
+  return r && o && pa(a, t, o), o;
+}, y = (e, a) => (t, r) => a(t, r, e);
+const w = "{FORMULA1}", C = "{FORMULA2}", ga = {
+  [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"
+};
+let D = class {
+  constructor(e, a) {
+    c(this, "canvasRender", null);
+    c(this, "dropdown");
+    c(this, "optionsInput");
+    this.localeService = e, this.injector = a;
+  }
+  get operatorNames() {
+    return this.operators.map((e) => this.localeService.t(ga[e]));
+  }
+  get titleStr() {
+    return this.localeService.t(this.title);
+  }
+  skipDefaultFontRender(e, a, t) {
+    return !1;
+  }
+  generateRuleName(e) {
+    var t, r;
+    if (!e.operator)
+      return this.titleStr;
+    const a = this.localeService.t(ca[e.operator]).replace(w, (t = e.formula1) != null ? t : "").replace(C, (r = e.formula2) != null ? r : "");
+    return `${this.titleStr} ${a}`;
+  }
+  generateRuleErrorMessage(e) {
+    var t, r;
+    return e.operator ? `${this.localeService.t(ha[e.operator]).replace(w, (t = e.formula1) != null ? t : "").replace(C, (r = e.formula2) != null ? r : "")}` : this.titleStr;
+  }
+  getRuleFinalError(e) {
+    return e.showInputMessage && e.error ? e.error : this.generateRuleErrorMessage(e);
+  }
+  isEmptyCellValue(e) {
+    return e === "" || e === void 0 || e === null;
+  }
+  async isValidType(e, a, t) {
+    return !0;
+  }
+  transform(e, a, t) {
+    return e;
+  }
+  async validatorIsEqual(e, a, t) {
+    return !0;
+  }
+  async validatorIsNotEqual(e, a, t) {
+    return !0;
+  }
+  async validatorIsBetween(e, a, t) {
+    return !0;
+  }
+  async validatorIsNotBetween(e, a, t) {
+    return !0;
+  }
+  async validatorIsGreaterThan(e, a, t) {
+    return !0;
+  }
+  async validatorIsGreaterThanOrEqual(e, a, t) {
+    return !0;
+  }
+  async validatorIsLessThan(e, a, t) {
+    return !0;
+  }
+  async validatorIsLessThanOrEqual(e, a, t) {
+    return !0;
+  }
+  async validator(e, a) {
+    const { value: t, unitId: r, subUnitId: o } = e, n = this.isEmptyCellValue(t), { allowBlank: i = !0, operator: d } = a;
+    if (n)
+      return i;
+    const l = await this.parseFormula(a, r, o);
+    if (!await this.isValidType(e, l, a))
+      return !1;
+    if (!L.isDefine(d))
+      return !0;
+    const u = this.transform(e, l, a);
+    switch (d) {
+      case s.BETWEEN:
+        return this.validatorIsBetween(u, l, a);
+      case s.EQUAL:
+        return this.validatorIsEqual(u, l, a);
+      case s.GREATER_THAN:
+        return this.validatorIsGreaterThan(u, l, a);
+      case s.GREATER_THAN_OR_EQUAL:
+        return this.validatorIsGreaterThanOrEqual(u, l, a);
+      case s.LESS_THAN:
+        return this.validatorIsLessThan(u, l, a);
+      case s.LESS_THAN_OR_EQUAL:
+        return this.validatorIsLessThanOrEqual(u, l, a);
+      case s.NOT_BETWEEN:
+        return this.validatorIsNotBetween(u, l, a);
+      case s.NOT_EQUAL:
+        return this.validatorIsNotEqual(u, l, a);
+      default:
+        throw new Error("Unknown operator.");
+    }
+  }
+};
+D = _a([
+  y(0, I(j)),
+  y(1, I(B))
+], D);
+class Ia extends U {
+  constructor(t, r, o) {
+    super();
+    c(this, "_dataValidations");
+    c(this, "_dataValidationMap", /* @__PURE__ */ new Map());
+    c(this, "_dataValidations$", new S());
+    c(this, "unitId");
+    c(this, "subUnitId");
+    c(this, "dataValidations$", this._dataValidations$.asObservable());
+    this.unitId = t, this.subUnitId = r, o && (this._insertRules(o), this._notice(), this.disposeWithMe({
+      dispose: () => {
+        this._dataValidations$.complete();
+      }
+    }));
+  }
+  _notice() {
+    this._dataValidations$.next(this._dataValidations);
+  }
+  _insertRules(t) {
+    this._dataValidations = t, t.forEach((r) => {
+      this._dataValidationMap.set(r.uid, r);
+    });
+  }
+  getRuleById(t) {
+    return this._dataValidationMap.get(t);
+  }
+  getRuleIndex(t) {
+    return this._dataValidations.findIndex((r) => r.uid === t);
+  }
+  addRule(t, r) {
+    typeof r == "number" && r < this._dataValidations.length ? this._dataValidations.splice(r, 0, t) : this._dataValidations.push(t), this._dataValidationMap.set(t.uid, t), this._notice();
+  }
+  removeRule(t) {
+    const r = this._dataValidations.findIndex((o) => o.uid === t);
+    this._dataValidations.splice(r, 1), this._dataValidationMap.delete(t), this._notice();
+  }
+  updateRule(t, r) {
+    const o = this._dataValidationMap.get(t), n = this._dataValidations.findIndex((d) => t === d.uid);
+    if (!o)
+      throw new Error(`Data validation rule is not found, ruleId: ${t}.`);
+    const i = { ...o };
+    switch (r.type) {
+      case p.RANGE: {
+        i.ranges = r.payload;
+        break;
+      }
+      case p.SETTING: {
+        Object.assign(i, r.payload);
+        break;
+      }
+      case p.OPTIONS: {
+        Object.assign(i, r.payload);
+        break;
+      }
+    }
+    return this._dataValidations[n] = i, this._dataValidationMap.set(t, i), this._notice(), i;
+  }
+  getDataValidations() {
+    return this._dataValidations;
+  }
+  toJSON() {
+    return this._dataValidations;
+  }
+  validator(t, r, o, n) {
+    return F.VALID;
+  }
+}
+const Sa = [
+  s.BETWEEN,
+  s.NOT_BETWEEN
+];
+export {
+  ea as AddDataValidationCommand,
+  E as AddDataValidationMutation,
+  D as BaseDataValidator,
+  Ia as DataValidationManager,
+  h as DataValidationModel,
+  K as DataValidatorRegistryScope,
+  b as DataValidatorRegistryService,
+  ia as RemoveAllDataValidationCommand,
+  ra as RemoveDataValidationCommand,
+  v as RemoveDataValidationMutation,
+  Sa as TWO_FORMULA_OPERATOR_COUNT,
+  O as UniverDataValidationPlugin,
+  g as UpdateDataValidationMutation,
+  oa as UpdateDataValidationOptionsCommand,
+  na as UpdateDataValidationSettingCommand,
+  p as UpdateRuleType,
+  Ra as createDefaultNewRule,
+  ta as getRuleOptions,
+  aa as getRuleSetting,
+  Va as removeDataValidationUndoFactory
+};

package/lib/types/commands/commands/data-validation.command.d.ts

@@ -0,0 +1,30 @@
+import { IRemoveDataValidationMutationParams } from '../mutations/data-validation.mutation';
+import { ISheetCommandSharedParams } from '@univerjs/sheets';
+import { Injector } from '@wendellhu/redi';
+import { ICommand, IDataValidationRule, IDataValidationRuleBase, IDataValidationRuleOptions, IMutationInfo, IRange } from '@univerjs/core';
+
+export interface IAddDataValidationCommandParams extends ISheetCommandSharedParams {
+    rule: Omit<IDataValidationRule, 'ranges'> & {
+        range: IRange;
+    };
+    index?: number;
+}
+export declare const AddDataValidationCommand: ICommand<IAddDataValidationCommandParams>;
+export interface IRemoveDataValidationCommandParams extends ISheetCommandSharedParams {
+    ruleId: string;
+}
+export declare const removeDataValidationUndoFactory: (accessor: Injector, redoParams: IRemoveDataValidationMutationParams) => IMutationInfo<object>[];
+export declare const RemoveDataValidationCommand: ICommand<IRemoveDataValidationCommandParams>;
+export interface IUpdateDataValidationOptionsCommandParams extends ISheetCommandSharedParams {
+    ruleId: string;
+    options: IDataValidationRuleOptions;
+}
+export declare const UpdateDataValidationOptionsCommand: ICommand<IUpdateDataValidationOptionsCommandParams>;
+export interface IUpdateDataValidationSettingCommandParams extends ISheetCommandSharedParams {
+    ruleId: string;
+    setting: IDataValidationRuleBase;
+}
+export declare const UpdateDataValidationSettingCommand: ICommand<IUpdateDataValidationSettingCommandParams>;
+export interface IRemoveAllDataValidationCommandParams extends ISheetCommandSharedParams {
+}
+export declare const RemoveAllDataValidationCommand: ICommand<IRemoveAllDataValidationCommandParams>;

package/lib/types/commands/mutations/data-validation.mutation.d.ts

@@ -0,0 +1,18 @@
+import { IUpdateRulePayload } from '../../types/interfaces/i-update-rule-payload';
+import { ISheetCommandSharedParams } from '@univerjs/sheets';
+import { ICommand, IDataValidationRule } from '@univerjs/core';
+
+export interface IAddDataValidationMutationParams extends ISheetCommandSharedParams {
+    rule: IDataValidationRule | IDataValidationRule[];
+    index?: number;
+}
+export declare const AddDataValidationMutation: ICommand<IAddDataValidationMutationParams>;
+export interface IRemoveDataValidationMutationParams extends ISheetCommandSharedParams {
+    ruleId: string | string[];
+}
+export declare const RemoveDataValidationMutation: ICommand<IRemoveDataValidationMutationParams>;
+export interface IUpdateDataValidationMutationParams extends ISheetCommandSharedParams {
+    payload: IUpdateRulePayload;
+    ruleId: string;
+}
+export declare const UpdateDataValidationMutation: ICommand<IUpdateDataValidationMutationParams>;