@univerjs/sheets-filter 0.5.4 → 0.5.5-experimental.20250123-34738ff

package/lib/es/index.js

@@ -1,94 +1,101 @@
-var Fe = Object.defineProperty;
-var we = (i, r, e) => r in i ? Fe(i, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[r] = e;
-var w = (i, r, e) => we(i, typeof r != "symbol" ? r + "" : r, e);
-import { isNumeric as Se, Disposable as V, Rectangle as Y, mergeSets as Q, Tools as k, extractPureTextFromCell as ve, CellValueType as K, UniverInstanceType as U, fromCallback as Me, CommandType as E, IResourceManagerService as Ee, IUniverInstanceService as x, ICommandService as T, Inject as z, DisposableCollection as Oe, moveMatrixArray as ee, Plugin as ye, merge as Ae, Injector as Te, IConfigService as Ne, IUndoRedoService as j, ErrorService as xe, LocaleService as Ie, sequenceExecute as $e } from "@univerjs/core";
-import { SheetInterceptorService as Pe, RefRangeService as Ue, SetWorksheetActiveOperation as be, CopySheetCommand as Le, RemoveSheetCommand as Be, INTERCEPTOR_POINT as ze, RemoveRowMutation as He, InsertRowMutation as De, SetRangeValuesMutation as We, expandToContinuousRange as ae, getSheetCommandTarget as L, MoveRowsCommand as Ve, MoveRangeCommand as je, EffectRefRangId as te, RemoveRowCommand as qe, RemoveColCommand as Qe, InsertColCommand as Ge, InsertRowCommand as Je, SheetsSelectionsService as Ye, isSingleCellSelection as Ke } from "@univerjs/sheets";
-import { BehaviorSubject as b, merge as Xe, filter as Ze, switchMap as ke, of as et } from "rxjs";
-const tt = "sheets-filter.config", re = {}, ce = "sheet.mutation.set-filter-range", de = "sheet.mutation.set-filter-criteria", ue = "sheet.mutation.remove-filter", he = "sheet.mutation.re-calc-filter", rt = /* @__PURE__ */ new Set([
-  ce,
-  de,
-  ue,
-  he
+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 { isNumeric, Disposable, Rectangle, mergeSets, Tools, extractPureTextFromCell, CellValueType, UniverInstanceType, fromCallback, CommandType, IResourceManagerService, IUniverInstanceService, ICommandService, Inject, DisposableCollection, moveMatrixArray, Plugin, merge as merge$1, Injector, IConfigService, IUndoRedoService, ErrorService, LocaleService, sequenceExecute } from "@univerjs/core";
+import { SheetInterceptorService, RefRangeService, SetWorksheetActiveOperation, CopySheetCommand, RemoveSheetCommand, INTERCEPTOR_POINT, RemoveRowMutation, InsertRowMutation, SetRangeValuesMutation, expandToContinuousRange, getSheetCommandTarget, MoveRowsCommand, MoveRangeCommand, EffectRefRangId, RemoveRowCommand, RemoveColCommand, InsertColCommand, InsertRowCommand, SheetsSelectionsService, isSingleCellSelection } from "@univerjs/sheets";
+import { BehaviorSubject, merge, filter, switchMap, of } from "rxjs";
+const SHEETS_FILTER_PLUGIN_CONFIG_KEY = "sheets-filter.config", defaultPluginConfig = {}, SetSheetsFilterRangeMutationId = "sheet.mutation.set-filter-range", SetSheetsFilterCriteriaMutationId = "sheet.mutation.set-filter-criteria", RemoveSheetsFilterMutationId = "sheet.mutation.remove-filter", ReCalcSheetsFilterMutationId = "sheet.mutation.re-calc-filter", FILTER_MUTATIONS = /* @__PURE__ */ new Set([
+  SetSheetsFilterRangeMutationId,
+  SetSheetsFilterCriteriaMutationId,
+  RemoveSheetsFilterMutationId,
+  ReCalcSheetsFilterMutationId
 ]);
-var N = /* @__PURE__ */ ((i) => (i.EQUAL = "equal", i.GREATER_THAN = "greaterThan", i.GREATER_THAN_OR_EQUAL = "greaterThanOrEqual", i.LESS_THAN = "lessThan", i.LESS_THAN_OR_EQUAL = "lessThanOrEqual", i.NOT_EQUALS = "notEqual", i))(N || {});
-const nt = {
-  operator: N.GREATER_THAN,
-  fn: (i, r) => $(i) ? i > r : !1
-}, it = {
-  operator: N.GREATER_THAN_OR_EQUAL,
-  fn: (i, r) => $(i) ? i >= r : !1
-}, st = {
-  operator: N.LESS_THAN,
-  fn: (i, r) => $(i) ? i < r : !1
-}, ot = {
-  operator: N.LESS_THAN_OR_EQUAL,
-  fn: (i, r) => $(i) ? i <= r : !1
-}, lt = {
-  operator: N.EQUAL,
-  fn: (i, r) => $(i) ? i === r : !1
-}, fe = {
-  operator: N.NOT_EQUALS,
-  fn: (i, r) => {
-    if (typeof r == "string") {
-      if (r === " ")
-        return i != null;
-      const e = ge(i);
-      return e && ut(r) ? !_e(r).test(e) : e !== r;
+var CustomFilterOperator = /* @__PURE__ */ ((CustomFilterOperator2) => (CustomFilterOperator2.EQUAL = "equal", CustomFilterOperator2.GREATER_THAN = "greaterThan", CustomFilterOperator2.GREATER_THAN_OR_EQUAL = "greaterThanOrEqual", CustomFilterOperator2.LESS_THAN = "lessThan", CustomFilterOperator2.LESS_THAN_OR_EQUAL = "lessThanOrEqual", CustomFilterOperator2.NOT_EQUALS = "notEqual", CustomFilterOperator2))(CustomFilterOperator || {});
+const greaterThan = {
+  operator: CustomFilterOperator.GREATER_THAN,
+  fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value > compare : !1, "fn")
+}, greaterThanOrEqualTo = {
+  operator: CustomFilterOperator.GREATER_THAN_OR_EQUAL,
+  fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value >= compare : !1, "fn")
+}, lessThan = {
+  operator: CustomFilterOperator.LESS_THAN,
+  fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value < compare : !1, "fn")
+}, lessThanOrEqualTo = {
+  operator: CustomFilterOperator.LESS_THAN_OR_EQUAL,
+  fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value <= compare : !1, "fn")
+}, equals = {
+  operator: CustomFilterOperator.EQUAL,
+  fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value === compare : !1, "fn")
+}, notEquals = {
+  operator: CustomFilterOperator.NOT_EQUALS,
+  fn: /* @__PURE__ */ __name((value, compare) => {
+    if (typeof compare == "string") {
+      if (compare === " ")
+        return value != null;
+      const ensuredString = ensureString(value);
+      return ensuredString && isWildCardString(compare) ? !createREGEXFromWildChar(compare).test(ensuredString) : ensuredString !== compare;
     }
-    return $(i) ? i !== r : !0;
-  }
-}, me = /* @__PURE__ */ new Map([]), at = [nt, it, st, ot, lt, fe];
-at.forEach((i) => {
-  me.set(i.operator, i);
+    return ensureNumber(value) ? value !== compare : !0;
+  }, "fn")
+}, CustomFilterFnRegistry = /* @__PURE__ */ new Map([]), ALL_CUSTOM_FILTER_FUNCTIONS = [greaterThan, greaterThanOrEqualTo, lessThan, lessThanOrEqualTo, equals, notEquals];
+ALL_CUSTOM_FILTER_FUNCTIONS.forEach((fn) => {
+  CustomFilterFnRegistry.set(fn.operator, fn);
 });
-function ct(i) {
-  return !!i;
+function isNumericFilterFn(operator) {
+  return !!operator;
 }
-const dt = {
-  fn: (i, r) => {
-    const e = ge(i);
-    return e === null ? r === "" : _e(r).test(e);
-  }
+__name(isNumericFilterFn, "isNumericFilterFn");
+const textMatch = {
+  fn: /* @__PURE__ */ __name((value, compare) => {
+    const ensured = ensureString(value);
+    return ensured === null ? compare === "" : createREGEXFromWildChar(compare).test(ensured);
+  }, "fn")
 };
-function ne(i) {
-  return i ? me.get(i) : dt;
+function getCustomFilterFn(operator) {
+  return operator ? CustomFilterFnRegistry.get(operator) : textMatch;
 }
-function $(i) {
-  return typeof i == "number";
+__name(getCustomFilterFn, "getCustomFilterFn");
+function ensureNumber(value) {
+  return typeof value == "number";
 }
-function ie(i) {
-  return !!(typeof i == "number" || typeof i == "string" && Se(i));
+__name(ensureNumber, "ensureNumber");
+function ensureNumeric(value) {
+  return !!(typeof value == "number" || typeof value == "string" && isNumeric(value));
 }
-function ge(i) {
-  return typeof i == "boolean" || i == null ? null : typeof i == "string" ? i : i.toString();
+__name(ensureNumeric, "ensureNumeric");
+function ensureString(value) {
+  return typeof value == "boolean" || value == null ? null : typeof value == "string" ? value : value.toString();
 }
-function ut(i) {
-  return typeof i == "number" ? !1 : i.indexOf("*") !== -1 || i.indexOf("?") !== -1;
+__name(ensureString, "ensureString");
+function isWildCardString(str) {
+  return typeof str == "number" ? !1 : str.indexOf("*") !== -1 || str.indexOf("?") !== -1;
 }
-function _e(i) {
-  const r = i.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("?", ".").replace(/[*]/g, ".$&");
-  return new RegExp(`^${r}$`);
+__name(isWildCardString, "isWildCardString");
+function createREGEXFromWildChar(wildChar) {
+  const regexpStr = wildChar.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("?", ".").replace(/[*]/g, ".$&");
+  return new RegExp(`^${regexpStr}$`);
 }
-const G = () => /* @__PURE__ */ new Set();
-class D extends V {
-  constructor(e, t, n) {
+__name(createREGEXFromWildChar, "createREGEXFromWildChar");
+const EMPTY = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Set(), "EMPTY"), _FilterModel = class _FilterModel extends Disposable {
+  constructor(unitId, subUnitId, _worksheet) {
     super();
-    w(this, "_filteredOutRows$", new b(G()));
+    __publicField(this, "_filteredOutRows$", new BehaviorSubject(EMPTY()));
     /** An observable value. A set of filtered out rows. */
-    w(this, "filteredOutRows$", this._filteredOutRows$.asObservable());
+    __publicField(this, "filteredOutRows$", this._filteredOutRows$.asObservable());
     // TODO: we may need to update which cols have criteria rather than simple boolean
-    w(this, "_hasCriteria$", new b(!1));
-    w(this, "hasCriteria$", this._hasCriteria$.asObservable());
-    w(this, "_filterColumnByIndex", /* @__PURE__ */ new Map());
-    w(this, "_alreadyFilteredOutRows", G());
-    w(this, "_range");
-    this.unitId = e, this.subUnitId = t, this._worksheet = n;
+    __publicField(this, "_hasCriteria$", new BehaviorSubject(!1));
+    __publicField(this, "hasCriteria$", this._hasCriteria$.asObservable());
+    __publicField(this, "_filterColumnByIndex", /* @__PURE__ */ new Map());
+    __publicField(this, "_alreadyFilteredOutRows", EMPTY());
+    __publicField(this, "_range");
+    this.unitId = unitId, this.subUnitId = subUnitId, this._worksheet = _worksheet;
   }
   get filteredOutRows() {
     return this._filteredOutRows$.getValue();
   }
-  set filteredOutRows(e) {
-    this._alreadyFilteredOutRows = e, this._filteredOutRows$.next(e);
+  set filteredOutRows(rows) {
+    this._alreadyFilteredOutRows = rows, this._filteredOutRows$.next(rows);
   }
   dispose() {
     super.dispose(), this._filteredOutRows$.complete(), this._hasCriteria$.complete();
@@ -97,11 +104,11 @@ class D extends V {
    * Serialize this filter model to the JSON format representation.
    */
   serialize() {
-    const e = {
-      ref: Y.clone(this._range),
-      filterColumns: this._getAllFilterColumns(!0).sort(([t], [n]) => t - n).map(([t, n]) => n.serialize())
+    const result = {
+      ref: Rectangle.clone(this._range),
+      filterColumns: this._getAllFilterColumns(!0).sort(([offset1], [offset2]) => offset1 - offset2).map(([_, filterColumn]) => filterColumn.serialize())
     };
-    return this._alreadyFilteredOutRows && (e.cachedFilteredOut = Array.from(this._alreadyFilteredOutRows).sort()), e;
+    return this._alreadyFilteredOutRows && (result.cachedFilteredOut = Array.from(this._alreadyFilteredOutRows).sort()), result;
   }
   /**
    * Deserialize auto filter info to construct a `FilterModel` object.
@@ -110,16 +117,16 @@ class D extends V {
    * @param worksheet the Worksheet object
    * @param autoFilter auto filter data
    */
-  static deserialize(e, t, n, s) {
-    const o = new D(e, t, n);
-    return o._dump(s), o;
+  static deserialize(unitId, subUnitId, worksheet, autoFilter) {
+    const filterModel = new _FilterModel(unitId, subUnitId, worksheet);
+    return filterModel._dump(autoFilter), filterModel;
   }
-  _dump(e) {
-    var t;
-    this.setRange(e.ref), (t = e.filterColumns) == null || t.forEach((n) => this._setCriteriaWithoutReCalc(n.colId, n)), e.cachedFilteredOut && (this._alreadyFilteredOutRows = new Set(e.cachedFilteredOut), this._emit()), this._emitHasCriteria();
+  _dump(autoFilter) {
+    var _a4;
+    this.setRange(autoFilter.ref), (_a4 = autoFilter.filterColumns) == null || _a4.forEach((filterColumn) => this._setCriteriaWithoutReCalc(filterColumn.colId, filterColumn)), autoFilter.cachedFilteredOut && (this._alreadyFilteredOutRows = new Set(autoFilter.cachedFilteredOut), this._emit()), this._emitHasCriteria();
   }
-  isRowFiltered(e) {
-    return this._alreadyFilteredOutRows.has(e);
+  isRowFiltered(row) {
+    return this._alreadyFilteredOutRows.has(row);
   }
   getRange() {
     if (!this._range)
@@ -131,74 +138,74 @@ class D extends V {
    * another word it would not change `filteredOutRows` on `FilterModel` nor `FilterColumn`.
    * @param col
    */
-  getFilteredOutRowsExceptCol(e) {
-    return this._getAllFilterColumns(!0).filter(([t]) => t !== e).reduce((t, [, n]) => {
-      const s = n.calc({ getAlreadyFilteredOutRows: () => t });
-      return s ? Q(t, s) : t;
+  getFilteredOutRowsExceptCol(col) {
+    return this._getAllFilterColumns(!0).filter(([colOffset]) => colOffset !== col).reduce((acc, [, filterColumn]) => {
+      const newResult = filterColumn.calc({ getAlreadyFilteredOutRows: /* @__PURE__ */ __name(() => acc, "getAlreadyFilteredOutRows") });
+      return newResult ? mergeSets(acc, newResult) : acc;
     }, /* @__PURE__ */ new Set());
   }
   /**
    * Set range of the filter model, this would remove some `IFilterColumn`
    * if the new range not overlaps the old range.
    */
-  setRange(e) {
-    this._range = e, this._getAllFilterColumns(!0).forEach(([t, n]) => {
-      n.setRangeAndColumn({
-        startRow: e.startRow,
-        endRow: e.endRow,
-        startColumn: t,
-        endColumn: t
-      }, t);
+  setRange(range) {
+    this._range = range, this._getAllFilterColumns(!0).forEach(([col, filterColumn]) => {
+      filterColumn.setRangeAndColumn({
+        startRow: range.startRow,
+        endRow: range.endRow,
+        startColumn: col,
+        endColumn: col
+      }, col);
     });
   }
   /**
    * Set or remove filter criteria on a specific row.
    */
-  setCriteria(e, t, n = !1) {
+  setCriteria(col, criteria, reCalc = !1) {
     if (!this._range)
       throw new Error("[FilterModel] could not set criteria before a range is set!");
-    if (!t) {
-      this._removeCriteria(e), this._rebuildAlreadyFilteredOutRowsWithCache(), n && this._reCalcAllColumns(), this._emit(), this._emitHasCriteria();
+    if (!criteria) {
+      this._removeCriteria(col), this._rebuildAlreadyFilteredOutRowsWithCache(), reCalc && this._reCalcAllColumns(), this._emit(), this._emitHasCriteria();
       return;
     }
-    this._setCriteriaWithoutReCalc(e, t), n && (this._rebuildAlreadyFilteredOutRowsWithCache(), this._reCalcWithNoCacheColumns(), this._emit(), this._emitHasCriteria());
+    this._setCriteriaWithoutReCalc(col, criteria), reCalc && (this._rebuildAlreadyFilteredOutRowsWithCache(), this._reCalcWithNoCacheColumns(), this._emit(), this._emitHasCriteria());
   }
   getAllFilterColumns() {
     return this._getAllFilterColumns(!0);
   }
-  getFilterColumn(e) {
-    var t;
-    return (t = this._filterColumnByIndex.get(e)) != null ? t : null;
+  getFilterColumn(index) {
+    var _a4;
+    return (_a4 = this._filterColumnByIndex.get(index)) != null ? _a4 : null;
   }
   reCalc() {
     this._reCalcAllColumns(), this._emit();
   }
-  _getAllFilterColumns(e = !1) {
-    const t = Array.from(this._filterColumnByIndex.entries());
-    return e ? t : t.map(([n, s]) => s);
+  _getAllFilterColumns(withCol = !1) {
+    const columns = Array.from(this._filterColumnByIndex.entries());
+    return withCol ? columns : columns.map(([_, filterColumn]) => filterColumn);
   }
   _reCalcAllColumns() {
-    this._alreadyFilteredOutRows = G(), this._getAllFilterColumns().forEach((e) => e.__clearCache()), this._reCalcWithNoCacheColumns();
+    this._alreadyFilteredOutRows = EMPTY(), this._getAllFilterColumns().forEach((filterColumn) => filterColumn.__clearCache()), this._reCalcWithNoCacheColumns();
   }
-  _setCriteriaWithoutReCalc(e, t) {
-    const n = this._range;
-    if (!n)
+  _setCriteriaWithoutReCalc(col, criteria) {
+    const range = this._range;
+    if (!range)
       throw new Error("[FilterModel] could not set criteria before a range is set!");
-    const { startColumn: s, endColumn: o } = n;
-    if (e > o || e < s)
-      throw new Error(`[FilterModel] could not set criteria on column ${e} which is out of range!`);
-    let l;
-    this._filterColumnByIndex.has(e) ? l = this._filterColumnByIndex.get(e) : (l = new ht(
+    const { startColumn, endColumn } = range;
+    if (col > endColumn || col < startColumn)
+      throw new Error(`[FilterModel] could not set criteria on column ${col} which is out of range!`);
+    let filterColumn;
+    this._filterColumnByIndex.has(col) ? filterColumn = this._filterColumnByIndex.get(col) : (filterColumn = new FilterColumn(
       this.unitId,
       this.subUnitId,
       this._worksheet,
-      t,
-      { getAlreadyFilteredOutRows: () => this._alreadyFilteredOutRows }
-    ), l.setRangeAndColumn(n, e), this._filterColumnByIndex.set(e, l)), l.setCriteria(t);
+      criteria,
+      { getAlreadyFilteredOutRows: /* @__PURE__ */ __name(() => this._alreadyFilteredOutRows, "getAlreadyFilteredOutRows") }
+    ), filterColumn.setRangeAndColumn(range, col), this._filterColumnByIndex.set(col, filterColumn)), filterColumn.setCriteria(criteria);
   }
-  _removeCriteria(e) {
-    const t = this._filterColumnByIndex.get(e);
-    t && (t.dispose(), this._filterColumnByIndex.delete(e));
+  _removeCriteria(col) {
+    const filterColumn = this._filterColumnByIndex.get(col);
+    filterColumn && (filterColumn.dispose(), this._filterColumnByIndex.delete(col));
   }
   _emit() {
     this._filteredOutRows$.next(this._alreadyFilteredOutRows);
@@ -207,27 +214,29 @@ class D extends V {
     this._hasCriteria$.next(this._filterColumnByIndex.size > 0);
   }
   _rebuildAlreadyFilteredOutRowsWithCache() {
-    const e = this._getAllFilterColumns().filter((t) => t.hasCache()).reduce((t, n) => Q(t, n.filteredOutRows), /* @__PURE__ */ new Set());
-    this._alreadyFilteredOutRows = e;
+    const newFilteredOutRows = this._getAllFilterColumns().filter((filterColumn) => filterColumn.hasCache()).reduce((acc, filterColumn) => mergeSets(acc, filterColumn.filteredOutRows), /* @__PURE__ */ new Set());
+    this._alreadyFilteredOutRows = newFilteredOutRows;
   }
   _reCalcWithNoCacheColumns() {
-    const e = this._getAllFilterColumns().filter((t) => !t.hasCache());
-    for (const t of e) {
-      const n = t.reCalc();
-      n && (this._alreadyFilteredOutRows = Q(this._alreadyFilteredOutRows, n));
+    const noCacheFilteredOutRows = this._getAllFilterColumns().filter((filterColumn) => !filterColumn.hasCache());
+    for (const filterColumn of noCacheFilteredOutRows) {
+      const filteredRows = filterColumn.reCalc();
+      filteredRows && (this._alreadyFilteredOutRows = mergeSets(this._alreadyFilteredOutRows, filteredRows));
     }
   }
-}
-class ht extends V {
-  constructor(e, t, n, s, o) {
+};
+__name(_FilterModel, "FilterModel");
+let FilterModel = _FilterModel;
+const _FilterColumn = class _FilterColumn extends Disposable {
+  constructor(unitId, subUnitId, _worksheet, _criteria, _filterColumnContext) {
     super();
-    w(this, "_filteredOutRows", null);
+    __publicField(this, "_filteredOutRows", null);
     /** Cache the filter function.  */
-    w(this, "_filterFn", null);
-    w(this, "_range", null);
-    w(this, "_column", 0);
-    w(this, "_filterByValues", !1);
-    this.unitId = e, this.subUnitId = t, this._worksheet = n, this._criteria = s, this._filterColumnContext = o;
+    __publicField(this, "_filterFn", null);
+    __publicField(this, "_range", null);
+    __publicField(this, "_column", 0);
+    __publicField(this, "_filterByValues", !1);
+    this.unitId = unitId, this.subUnitId = subUnitId, this._worksheet = _worksheet, this._criteria = _criteria, this._filterColumnContext = _filterColumnContext;
   }
   get filteredOutRows() {
     return this._filteredOutRows;
@@ -244,7 +253,7 @@ class ht extends V {
   serialize() {
     if (!this._criteria)
       throw new Error("[FilterColumn]: could not serialize without a filter column!");
-    return k.deepClone({
+    return Tools.deepClone({
       ...this._criteria,
       colId: this._column
     });
@@ -253,14 +262,14 @@ class ht extends V {
     return this._filteredOutRows !== null;
   }
   // The first row should be omitted!
-  setRangeAndColumn(e, t) {
-    this._range = e, this._column = t;
+  setRangeAndColumn(range, column) {
+    this._range = range, this._column = column;
   }
-  setCriteria(e) {
-    this._criteria = e, this._generateFilterFn(), this._filteredOutRows = null;
+  setCriteria(criteria) {
+    this._criteria = criteria, this._generateFilterFn(), this._filteredOutRows = null;
   }
   getColumnData() {
-    return k.deepClone(this._criteria);
+    return Tools.deepClone(this._criteria);
   }
   /**
    * Trigger new calculation on this `FilterModel` instance.
@@ -271,98 +280,110 @@ class ht extends V {
   reCalc() {
     return this._filteredOutRows = this.calc(this._filterColumnContext), this._filteredOutRows;
   }
-  calc(e) {
+  calc(context) {
     if (!this._filterFn)
       throw new Error("[FilterColumn] cannot calculate without a filter fn!");
     if (!this._range)
       throw new Error("[FilterColumn] cannot calculate without a range!");
     if (typeof this._column != "number")
       throw new TypeError("[FilterColumn] cannot calculate without a column offset!");
-    const t = this._column, n = { startColumn: t, endColumn: t, startRow: this._range.startRow + 1, endRow: this._range.endRow }, s = /* @__PURE__ */ new Set(), o = e.getAlreadyFilteredOutRows();
-    for (const l of this._worksheet.iterateByColumn(n, !1, !1)) {
-      const { row: a, rowSpan: c, col: h } = l;
-      if (o.has(a) && (!c || c === 1))
+    const column = this._column, iterateRange = { startColumn: column, endColumn: column, startRow: this._range.startRow + 1, endRow: this._range.endRow }, filteredOutRows = /* @__PURE__ */ new Set(), filteredOutByOthers = context.getAlreadyFilteredOutRows();
+    for (const range of this._worksheet.iterateByColumn(iterateRange, !1, !1)) {
+      const { row, rowSpan, col } = range;
+      if (filteredOutByOthers.has(row) && (!rowSpan || rowSpan === 1))
         continue;
-      const d = this._filterByValues ? ve(this._worksheet.getCell(a, h)) : Ft(this._worksheet, a, h);
-      if (!this._filterFn(d) && (s.add(a), c))
-        for (let u = 1; u < c; u++)
-          s.add(a + u);
+      const value = this._filterByValues ? extractPureTextFromCell(this._worksheet.getCell(row, col)) : getFilterValueForConditionalFiltering(this._worksheet, row, col);
+      if (!this._filterFn(value) && (filteredOutRows.add(row), rowSpan))
+        for (let i = 1; i < rowSpan; i++)
+          filteredOutRows.add(row + i);
     }
-    return s;
+    return filteredOutRows;
   }
   _generateFilterFn() {
-    this._criteria && (this._filterFn = ft(this._criteria), this._filterByValues = !!this._criteria.filters);
+    this._criteria && (this._filterFn = generateFilterFn(this._criteria), this._filterByValues = !!this._criteria.filters);
   }
-}
-function ft(i) {
-  if (i.filters)
-    return mt(i.filters);
-  if (i.customFilters)
-    return gt(i.customFilters);
+};
+__name(_FilterColumn, "FilterColumn");
+let FilterColumn = _FilterColumn;
+function generateFilterFn(column) {
+  if (column.filters)
+    return filterByValuesFnFactory(column.filters);
+  if (column.customFilters)
+    return customFilterFnFactory(column.customFilters);
   throw new Error("[FilterModel]: other types of filters are not supported yet.");
 }
-function mt(i) {
-  const r = !!i.blank, e = new Set(i.filters);
-  return (t) => t === void 0 || t === "" ? r : e.has(typeof t == "string" ? t : `${t}`);
+__name(generateFilterFn, "generateFilterFn");
+function filterByValuesFnFactory(values) {
+  const includeBlank = !!values.blank, valuesSet = new Set(values.filters);
+  return (value) => value === void 0 || value === "" ? includeBlank : valuesSet.has(typeof value == "string" ? value : `${value}`);
 }
-function gt(i) {
-  const r = i.customFilters.map((e) => pt(e));
-  return Ct(r) ? i.and ? _t(r) : Rt(r) : r[0];
+__name(filterByValuesFnFactory, "filterByValuesFnFactory");
+function customFilterFnFactory(customFilters) {
+  const customFilterFns = customFilters.customFilters.map((filter2) => generateCustomFilterFn(filter2));
+  return isCompoundCustomFilter(customFilterFns) ? customFilters.and ? AND(customFilterFns) : OR(customFilterFns) : customFilterFns[0];
 }
-function _t(i) {
-  const [r, e] = i;
-  return (t) => r(t) && e(t);
+__name(customFilterFnFactory, "customFilterFnFactory");
+function AND(filterFns) {
+  const [fn1, fn2] = filterFns;
+  return (value) => fn1(value) && fn2(value);
 }
-function Rt(i) {
-  const [r, e] = i;
-  return (t) => r(t) || e(t);
+__name(AND, "AND");
+function OR(filterFns) {
+  const [fn1, fn2] = filterFns;
+  return (value) => fn1(value) || fn2(value);
 }
-function Ct(i) {
-  return i.length === 2;
+__name(OR, "OR");
+function isCompoundCustomFilter(filter2) {
+  return filter2.length === 2;
 }
-function pt(i) {
-  const r = i.val;
-  if (i.operator === N.NOT_EQUALS && !ie(r))
-    return (n) => fe.fn(n, r);
-  if (ct(i.operator)) {
-    if (!ie(r)) return () => !1;
-    const n = ne(i.operator), s = Number(r);
-    return (o) => n.fn(o, s);
-  }
-  const e = ne(i.operator);
-  return (t) => e.fn(t, r);
+__name(isCompoundCustomFilter, "isCompoundCustomFilter");
+function generateCustomFilterFn(filter2) {
+  const compare = filter2.val;
+  if (filter2.operator === CustomFilterOperator.NOT_EQUALS && !ensureNumeric(compare))
+    return (value) => notEquals.fn(value, compare);
+  if (isNumericFilterFn(filter2.operator)) {
+    if (!ensureNumeric(compare)) return () => !1;
+    const customFilterFn2 = getCustomFilterFn(filter2.operator), ensuredNumber = Number(compare);
+    return (value) => customFilterFn2.fn(value, ensuredNumber);
+  }
+  const customFilterFn = getCustomFilterFn(filter2.operator);
+  return (value) => customFilterFn.fn(value, compare);
 }
-function Ft(i, r, e) {
-  const t = i.getCell(r, e);
-  if (!t) return null;
-  const n = i.getCellRaw(r, e);
-  return t && !n ? se(t) : n ? t.t === K.NUMBER && typeof t.v == "string" ? n.v : se(n) : null;
+__name(generateCustomFilterFn, "generateCustomFilterFn");
+function getFilterValueForConditionalFiltering(worksheet, row, col) {
+  const interceptedCell = worksheet.getCell(row, col);
+  if (!interceptedCell) return null;
+  const rawCell = worksheet.getCellRaw(row, col);
+  return interceptedCell && !rawCell ? extractFilterValueFromCell(interceptedCell) : rawCell ? interceptedCell.t === CellValueType.NUMBER && typeof interceptedCell.v == "string" ? rawCell.v : extractFilterValueFromCell(rawCell) : null;
 }
-function se(i) {
-  var t, n;
-  const r = (n = (t = i.p) == null ? void 0 : t.body) == null ? void 0 : n.dataStream;
-  if (r) return r.trimEnd();
-  const e = i.v;
-  return typeof e == "string" ? i.t === K.BOOLEAN ? e.toUpperCase() : e : typeof e == "number" ? i.t === K.BOOLEAN ? e ? "TRUE" : "FALSE" : e : typeof e == "boolean" ? e ? "TRUE" : "FALSE" : "";
+__name(getFilterValueForConditionalFiltering, "getFilterValueForConditionalFiltering");
+function extractFilterValueFromCell(cell) {
+  var _a4, _b;
+  const richTextValue = (_b = (_a4 = cell.p) == null ? void 0 : _a4.body) == null ? void 0 : _b.dataStream;
+  if (richTextValue) return richTextValue.trimEnd();
+  const rawValue = cell.v;
+  return typeof rawValue == "string" ? cell.t === CellValueType.BOOLEAN ? rawValue.toUpperCase() : rawValue : typeof rawValue == "number" ? cell.t === CellValueType.BOOLEAN ? rawValue ? "TRUE" : "FALSE" : rawValue : typeof rawValue == "boolean" ? rawValue ? "TRUE" : "FALSE" : "";
 }
-var wt = Object.defineProperty, St = Object.getOwnPropertyDescriptor, vt = (i, r, e, t) => {
-  for (var n = t > 1 ? void 0 : t ? St(r, e) : r, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (n = (t ? o(r, e, n) : o(n)) || n);
-  return t && n && wt(r, e, n), n;
-}, J = (i, r) => (e, t) => r(e, t, i);
-const Re = "SHEET_FILTER_PLUGIN";
-let M = class extends V {
-  constructor(r, e, t) {
+__name(extractFilterValueFromCell, "extractFilterValueFromCell");
+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");
+const SHEET_FILTER_SNAPSHOT_ID = "SHEET_FILTER_PLUGIN";
+var _a;
+let SheetsFilterService = (_a = class extends Disposable {
+  constructor(_resourcesManagerService, _univerInstanceService, _commandService) {
     super();
-    w(this, "_filterModels", /* @__PURE__ */ new Map());
-    w(this, "_loadedUnitId$", new b(null));
-    w(this, "loadedUnitId$", this._loadedUnitId$.asObservable());
-    w(this, "_errorMsg$", new b(null));
-    w(this, "errorMsg$", this._errorMsg$.asObservable());
-    w(this, "_activeFilterModel$", new b(null));
+    __publicField(this, "_filterModels", /* @__PURE__ */ new Map());
+    __publicField(this, "_loadedUnitId$", new BehaviorSubject(null));
+    __publicField(this, "loadedUnitId$", this._loadedUnitId$.asObservable());
+    __publicField(this, "_errorMsg$", new BehaviorSubject(null));
+    __publicField(this, "errorMsg$", this._errorMsg$.asObservable());
+    __publicField(this, "_activeFilterModel$", new BehaviorSubject(null));
     /** An observable value emitting the current Workbook's active Worksheet's filter model (if there is one). */
-    w(this, "activeFilterModel$", this._activeFilterModel$.asObservable());
-    this._resourcesManagerService = r, this._univerInstanceService = e, this._commandService = t, this._initModel(), this._initActiveFilterModel();
+    __publicField(this, "activeFilterModel$", this._activeFilterModel$.asObservable());
+    this._resourcesManagerService = _resourcesManagerService, this._univerInstanceService = _univerInstanceService, this._commandService = _commandService, this._initModel(), this._initActiveFilterModel();
   }
   /** The current Workbook's active Worksheet's filter model (if there is one). */
   get activeFilterModel() {
@@ -373,235 +394,237 @@ let M = class extends V {
    * @param unitId
    * @param subUnitId
    */
-  ensureFilterModel(r, e) {
-    const t = this.getFilterModel(r, e);
-    if (t)
-      return t;
-    const n = this._univerInstanceService.getUniverSheetInstance(r);
-    if (!n)
-      throw new Error(`[SheetsFilterService]: could not create "FilterModel" on a non-existing workbook ${r}!`);
-    const s = n.getSheetBySheetId(e);
-    if (!s)
-      throw new Error(`[SheetsFilterService]: could not create "FilterModel" on a non-existing worksheet ${e}!`);
-    const o = new D(r, e, s);
-    return this._cacheFilterModel(r, e, o), o;
-  }
-  getFilterModel(r, e) {
-    var t, n;
-    return (n = (t = this._filterModels.get(r)) == null ? void 0 : t.get(e)) != null ? n : null;
-  }
-  removeFilterModel(r, e) {
-    const t = this.getFilterModel(r, e);
-    return t ? (t.dispose(), this._filterModels.get(r).delete(e), !0) : !1;
-  }
-  setFilterErrorMsg(r) {
-    this._errorMsg$.next(r);
+  ensureFilterModel(unitId, subUnitId) {
+    const already = this.getFilterModel(unitId, subUnitId);
+    if (already)
+      return already;
+    const workbook = this._univerInstanceService.getUniverSheetInstance(unitId);
+    if (!workbook)
+      throw new Error(`[SheetsFilterService]: could not create "FilterModel" on a non-existing workbook ${unitId}!`);
+    const worksheet = workbook.getSheetBySheetId(subUnitId);
+    if (!worksheet)
+      throw new Error(`[SheetsFilterService]: could not create "FilterModel" on a non-existing worksheet ${subUnitId}!`);
+    const filterModel = new FilterModel(unitId, subUnitId, worksheet);
+    return this._cacheFilterModel(unitId, subUnitId, filterModel), filterModel;
+  }
+  getFilterModel(unitId, subUnitId) {
+    var _a4, _b;
+    return (_b = (_a4 = this._filterModels.get(unitId)) == null ? void 0 : _a4.get(subUnitId)) != null ? _b : null;
+  }
+  removeFilterModel(unitId, subUnitId) {
+    const already = this.getFilterModel(unitId, subUnitId);
+    return already ? (already.dispose(), this._filterModels.get(unitId).delete(subUnitId), !0) : !1;
+  }
+  setFilterErrorMsg(content) {
+    this._errorMsg$.next(content);
   }
   _updateActiveFilterModel() {
-    let r;
+    let workbook;
     try {
-      if (r = this._univerInstanceService.getCurrentUnitForType(U.UNIVER_SHEET), !r) {
+      if (workbook = this._univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET), !workbook) {
         this._activeFilterModel$.next(null);
         return;
       }
-    } catch (o) {
-      console.error("[SheetsFilterService]: could not get active workbook!", o);
+    } catch (err) {
+      console.error("[SheetsFilterService]: could not get active workbook!", err);
       return;
     }
-    const e = r.getActiveSheet(!0);
-    if (!e) {
+    const activeSheet = workbook.getActiveSheet(!0);
+    if (!activeSheet) {
       this._activeFilterModel$.next(null);
       return;
     }
-    const t = e.getUnitId(), n = e.getSheetId(), s = this.getFilterModel(t, n);
-    this._activeFilterModel$.next(s);
+    const unitId = activeSheet.getUnitId(), subUnitId = activeSheet.getSheetId(), filterModel = this.getFilterModel(unitId, subUnitId);
+    this._activeFilterModel$.next(filterModel);
   }
   _initActiveFilterModel() {
     this.disposeWithMe(
-      Xe(
+      merge(
         // source1: executing filter related mutations
-        Me(this._commandService.onCommandExecuted.bind(this._commandService)).pipe(Ze(([r]) => r.type === E.MUTATION && rt.has(r.id))),
+        fromCallback(this._commandService.onCommandExecuted.bind(this._commandService)).pipe(filter(([command]) => command.type === CommandType.MUTATION && FILTER_MUTATIONS.has(command.id))),
         // source2: activate sheet changes
-        this._univerInstanceService.getCurrentTypeOfUnit$(U.UNIVER_SHEET).pipe(ke((r) => {
-          var e;
-          return (e = r == null ? void 0 : r.activeSheet$) != null ? e : et(null);
+        this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET).pipe(switchMap((workbook) => {
+          var _a4;
+          return (_a4 = workbook == null ? void 0 : workbook.activeSheet$) != null ? _a4 : of(null);
         }))
       ).subscribe(() => this._updateActiveFilterModel())
     );
   }
-  _serializeAutoFiltersForUnit(r) {
-    const e = this._filterModels.get(r);
-    if (!e)
+  _serializeAutoFiltersForUnit(unitId) {
+    const allFilterModels = this._filterModels.get(unitId);
+    if (!allFilterModels)
       return "{}";
-    const t = {};
-    return e.forEach((n, s) => {
-      t[s] = n.serialize();
-    }), JSON.stringify(t);
-  }
-  _deserializeAutoFiltersForUnit(r, e) {
-    const t = this._univerInstanceService.getUniverSheetInstance(r);
-    Object.keys(e).forEach((n) => {
-      const s = e[n], o = D.deserialize(r, n, t.getSheetBySheetId(n), s);
-      this._cacheFilterModel(r, n, o);
+    const json = {};
+    return allFilterModels.forEach((model, worksheetId) => {
+      json[worksheetId] = model.serialize();
+    }), JSON.stringify(json);
+  }
+  _deserializeAutoFiltersForUnit(unitId, json) {
+    const workbook = this._univerInstanceService.getUniverSheetInstance(unitId);
+    Object.keys(json).forEach((worksheetId) => {
+      const autoFilter = json[worksheetId], filterModel = FilterModel.deserialize(unitId, worksheetId, workbook.getSheetBySheetId(worksheetId), autoFilter);
+      this._cacheFilterModel(unitId, worksheetId, filterModel);
     });
   }
   _initModel() {
     this._resourcesManagerService.registerPluginResource({
-      pluginName: Re,
-      businesses: [U.UNIVER_SHEET],
-      toJson: (r) => this._serializeAutoFiltersForUnit(r),
-      parseJson: (r) => JSON.parse(r),
-      onLoad: (r, e) => {
-        this._deserializeAutoFiltersForUnit(r, e), this._loadedUnitId$.next(r), this._updateActiveFilterModel();
-      },
-      onUnLoad: (r) => {
-        const e = this._filterModels.get(r);
-        e && (e.forEach((t) => t.dispose()), this._filterModels.delete(r));
-      }
+      pluginName: SHEET_FILTER_SNAPSHOT_ID,
+      businesses: [UniverInstanceType.UNIVER_SHEET],
+      toJson: /* @__PURE__ */ __name((id) => this._serializeAutoFiltersForUnit(id), "toJson"),
+      parseJson: /* @__PURE__ */ __name((json) => JSON.parse(json), "parseJson"),
+      onLoad: /* @__PURE__ */ __name((unitId, value) => {
+        this._deserializeAutoFiltersForUnit(unitId, value), this._loadedUnitId$.next(unitId), this._updateActiveFilterModel();
+      }, "onLoad"),
+      onUnLoad: /* @__PURE__ */ __name((unitId) => {
+        const allFilterModels = this._filterModels.get(unitId);
+        allFilterModels && (allFilterModels.forEach((model) => model.dispose()), this._filterModels.delete(unitId));
+      }, "onUnLoad")
     });
   }
-  _cacheFilterModel(r, e, t) {
-    this._filterModels.has(r) || this._filterModels.set(r, /* @__PURE__ */ new Map()), this._filterModels.get(r).set(e, t);
-  }
+  _cacheFilterModel(unitId, subUnitId, filterModel) {
+    this._filterModels.has(unitId) || this._filterModels.set(unitId, /* @__PURE__ */ new Map()), this._filterModels.get(unitId).set(subUnitId, filterModel);
+  }
+}, __name(_a, "SheetsFilterService"), _a);
+SheetsFilterService = __decorateClass$2([
+  __decorateParam$2(0, IResourceManagerService),
+  __decorateParam$2(1, IUniverInstanceService),
+  __decorateParam$2(2, ICommandService)
+], SheetsFilterService);
+const SetSheetsFilterRangeMutation = {
+  id: SetSheetsFilterRangeMutationId,
+  type: CommandType.MUTATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const { subUnitId, unitId, range } = params;
+    return accessor.get(SheetsFilterService).ensureFilterModel(unitId, subUnitId).setRange(range), !0;
+  }, "handler")
+}, SetSheetsFilterCriteriaMutation = {
+  id: SetSheetsFilterCriteriaMutationId,
+  type: CommandType.MUTATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const { subUnitId, unitId, criteria, col, reCalc = !0 } = params, filterModel = accessor.get(SheetsFilterService).getFilterModel(unitId, subUnitId);
+    return filterModel ? (filterModel.setCriteria(col, criteria, reCalc), !0) : !1;
+  }, "handler")
+}, RemoveSheetsFilterMutation = {
+  id: RemoveSheetsFilterMutationId,
+  type: CommandType.MUTATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const { unitId, subUnitId } = params;
+    return accessor.get(SheetsFilterService).removeFilterModel(unitId, subUnitId);
+  }, "handler")
+}, ReCalcSheetsFilterMutation = {
+  id: ReCalcSheetsFilterMutationId,
+  type: CommandType.MUTATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const { unitId, subUnitId } = params, filterModel = accessor.get(SheetsFilterService).getFilterModel(unitId, subUnitId);
+    return filterModel ? (filterModel.reCalc(), !0) : !1;
+  }, "handler")
 };
-M = vt([
-  J(0, Ee),
-  J(1, x),
-  J(2, T)
-], M);
-const R = {
-  id: ce,
-  type: E.MUTATION,
-  handler: (i, r) => {
-    const { subUnitId: e, unitId: t, range: n } = r;
-    return i.get(M).ensureFilterModel(t, e).setRange(n), !0;
-  }
-}, p = {
-  id: de,
-  type: E.MUTATION,
-  handler: (i, r) => {
-    const { subUnitId: e, unitId: t, criteria: n, col: s, reCalc: o = !0 } = r, a = i.get(M).getFilterModel(t, e);
-    return a ? (a.setCriteria(s, n, o), !0) : !1;
-  }
-}, O = {
-  id: ue,
-  type: E.MUTATION,
-  handler: (i, r) => {
-    const { unitId: e, subUnitId: t } = r;
-    return i.get(M).removeFilterModel(e, t);
-  }
-}, H = {
-  id: he,
-  type: E.MUTATION,
-  handler: (i, r) => {
-    const { unitId: e, subUnitId: t } = r, s = i.get(M).getFilterModel(e, t);
-    return s ? (s.reCalc(), !0) : !1;
-  }
-};
-function Mt(i, r) {
-  for (let e = 0; e < i.length; e++) {
-    let t = e;
-    if (i[e])
-      for (let n = e + 1; n < i.length; n++)
-        i[t] && i[n] && r(i[t], i[n]) && (i[t] = null, t = n);
-  }
-  return i.filter((e) => e !== null);
+function objectsShaker(target, isEqual) {
+  for (let i = 0; i < target.length; i++) {
+    let cur = i;
+    if (target[i])
+      for (let j = i + 1; j < target.length; j++)
+        target[cur] && target[j] && isEqual(target[cur], target[j]) && (target[cur] = null, cur = j);
+  }
+  return target.filter((o) => o !== null);
 }
-function I(i) {
-  return Mt(i, (r, e) => r.id === p.id && e.id === p.id && r.params.unitId === e.params.unitId && r.params.subUnitId === e.params.subUnitId && r.params.col === e.params.col);
+__name(objectsShaker, "objectsShaker");
+function mergeSetFilterCriteria(mutations) {
+  return objectsShaker(mutations, (o1, o2) => o1.id === SetSheetsFilterCriteriaMutation.id && o2.id === SetSheetsFilterCriteriaMutation.id && o1.params.unitId === o2.params.unitId && o1.params.subUnitId === o2.params.subUnitId && o1.params.col === o2.params.col);
 }
-var Et = Object.defineProperty, Ot = Object.getOwnPropertyDescriptor, yt = (i, r, e, t) => {
-  for (var n = t > 1 ? void 0 : t ? Ot(r, e) : r, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (n = (t ? o(r, e, n) : o(n)) || n);
-  return t && n && Et(r, e, n), n;
-}, P = (i, r) => (e, t) => r(e, t, i);
-let W = class extends V {
-  constructor(r, e, t, n, s) {
+__name(mergeSetFilterCriteria, "mergeSetFilterCriteria");
+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"), _a2;
+let SheetsFilterController = (_a2 = class extends Disposable {
+  constructor(_commandService, _sheetInterceptorService, _sheetsFilterService, _univerInstanceService, _refRangeService) {
     super();
-    w(this, "_disposableCollection", new Oe());
-    this._commandService = r, this._sheetInterceptorService = e, this._sheetsFilterService = t, this._univerInstanceService = n, this._refRangeService = s, this._initCommands(), this._initRowFilteredInterceptor(), this._initInterceptors(), this._commandExecutedListener(), this._initErrorHandling();
+    __publicField(this, "_disposableCollection", new DisposableCollection());
+    this._commandService = _commandService, this._sheetInterceptorService = _sheetInterceptorService, this._sheetsFilterService = _sheetsFilterService, this._univerInstanceService = _univerInstanceService, this._refRangeService = _refRangeService, this._initCommands(), this._initRowFilteredInterceptor(), this._initInterceptors(), this._commandExecutedListener(), this._initErrorHandling();
   }
   _initCommands() {
     [
-      p,
-      R,
-      H,
-      O
-    ].forEach((r) => this.disposeWithMe(this._commandService.registerCommand(r)));
+      SetSheetsFilterCriteriaMutation,
+      SetSheetsFilterRangeMutation,
+      ReCalcSheetsFilterMutation,
+      RemoveSheetsFilterMutation
+    ].forEach((command) => this.disposeWithMe(this._commandService.registerCommand(command)));
   }
   _initInterceptors() {
     this.disposeWithMe(this._sheetInterceptorService.interceptCommand({
-      getMutations: (r) => this._getUpdateFilter(r)
-    })), this.disposeWithMe(this._commandService.onCommandExecuted((r) => {
-      if (r.id === be.id) {
-        const e = r.params, t = e.subUnitId, n = e.unitId;
-        if (!t || !n)
+      getMutations: /* @__PURE__ */ __name((command) => this._getUpdateFilter(command), "getMutations")
+    })), this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo) => {
+      if (commandInfo.id === SetWorksheetActiveOperation.id) {
+        const params = commandInfo.params, sheetId = params.subUnitId, unitId = params.unitId;
+        if (!sheetId || !unitId)
           return;
-        this._registerRefRange(n, t);
+        this._registerRefRange(unitId, sheetId);
       }
-      if (r.id === R.id) {
-        const e = r.params, t = e.subUnitId, n = e.unitId;
-        if (!t || !n)
+      if (commandInfo.id === SetSheetsFilterRangeMutation.id) {
+        const params = commandInfo.params, sheetId = params.subUnitId, unitId = params.unitId;
+        if (!sheetId || !unitId)
           return;
-        this._registerRefRange(e.unitId, e.subUnitId);
+        this._registerRefRange(params.unitId, params.subUnitId);
       }
-    })), this.disposeWithMe(this._sheetsFilterService.loadedUnitId$.subscribe((r) => {
-      if (r) {
-        const e = this._univerInstanceService.getUniverSheetInstance(r), t = e == null ? void 0 : e.getActiveSheet();
-        t && this._registerRefRange(r, t.getSheetId());
+    })), this.disposeWithMe(this._sheetsFilterService.loadedUnitId$.subscribe((unitId) => {
+      if (unitId) {
+        const workbook = this._univerInstanceService.getUniverSheetInstance(unitId), sheet = workbook == null ? void 0 : workbook.getActiveSheet();
+        sheet && this._registerRefRange(unitId, sheet.getSheetId());
       }
     }));
   }
-  _registerRefRange(r, e) {
-    var l;
+  _registerRefRange(unitId, subUnitId) {
+    var _a4;
     this._disposableCollection.dispose();
-    const t = this._univerInstanceService.getUniverSheetInstance(r), n = t == null ? void 0 : t.getSheetBySheetId(e);
-    if (!t || !n) return;
-    const s = (l = this._sheetsFilterService.getFilterModel(r, e)) == null ? void 0 : l.getRange(), o = (a) => {
-      switch (a.id) {
-        case Je.id: {
-          const c = a.params, h = c.unitId || r, d = c.subUnitId || e;
-          return this._handleInsertRowCommand(c, h, d);
+    const workbook = this._univerInstanceService.getUniverSheetInstance(unitId), workSheet = workbook == null ? void 0 : workbook.getSheetBySheetId(subUnitId);
+    if (!workbook || !workSheet) return;
+    const range = (_a4 = this._sheetsFilterService.getFilterModel(unitId, subUnitId)) == null ? void 0 : _a4.getRange(), handler = /* @__PURE__ */ __name((config) => {
+      switch (config.id) {
+        case InsertRowCommand.id: {
+          const params = config.params, _unitId = params.unitId || unitId, _subUnitId = params.subUnitId || subUnitId;
+          return this._handleInsertRowCommand(params, _unitId, _subUnitId);
         }
-        case Ge.id: {
-          const c = a.params, h = c.unitId || r, d = c.subUnitId || e;
-          return this._handleInsertColCommand(c, h, d);
+        case InsertColCommand.id: {
+          const params = config.params, _unitId = params.unitId || unitId, _subUnitId = params.subUnitId || subUnitId;
+          return this._handleInsertColCommand(params, _unitId, _subUnitId);
         }
-        case Qe.id: {
-          const c = a.params;
-          return this._handleRemoveColCommand(c, r, e);
+        case RemoveColCommand.id: {
+          const params = config.params;
+          return this._handleRemoveColCommand(params, unitId, subUnitId);
         }
-        case qe.id: {
-          const c = a.params;
-          return this._handleRemoveRowCommand(c, r, e);
+        case RemoveRowCommand.id: {
+          const params = config.params;
+          return this._handleRemoveRowCommand(params, unitId, subUnitId);
         }
-        case te.MoveColsCommandId: {
-          const c = a.params;
-          return this._handleMoveColsCommand(c, r, e);
+        case EffectRefRangId.MoveColsCommandId: {
+          const params = config.params;
+          return this._handleMoveColsCommand(params, unitId, subUnitId);
         }
-        case te.MoveRowsCommandId: {
-          const c = a.params;
-          return this._handleMoveRowsCommand(c, r, e);
+        case EffectRefRangId.MoveRowsCommandId: {
+          const params = config.params;
+          return this._handleMoveRowsCommand(params, unitId, subUnitId);
         }
-        case je.id: {
-          const c = a.params;
-          return this._handleMoveRangeCommand(c, r, e);
+        case MoveRangeCommand.id: {
+          const params = config.params;
+          return this._handleMoveRangeCommand(params, unitId, subUnitId);
         }
       }
       return { redos: [], undos: [] };
-    };
-    s && this._disposableCollection.add(this._refRangeService.registerRefRange(s, o, r, e));
-  }
-  _getUpdateFilter(r) {
-    const { id: e } = r;
-    switch (e) {
-      case Be.id: {
-        const t = r.params;
-        return this._handleRemoveSheetCommand(t, t.unitId, t.subUnitId);
+    }, "handler");
+    range && this._disposableCollection.add(this._refRangeService.registerRefRange(range, handler, unitId, subUnitId));
+  }
+  _getUpdateFilter(command) {
+    const { id } = command;
+    switch (id) {
+      case RemoveSheetCommand.id: {
+        const params = command.params;
+        return this._handleRemoveSheetCommand(params, params.unitId, params.subUnitId);
       }
-      case Le.id: {
-        const t = r.params, { targetSubUnitId: n, unitId: s, subUnitId: o } = t;
-        return !s || !o || !n ? this._handleNull() : this._handleCopySheetCommand(s, o, n);
+      case CopySheetCommand.id: {
+        const params = command.params, { targetSubUnitId, unitId, subUnitId } = params;
+        return !unitId || !subUnitId || !targetSubUnitId ? this._handleNull() : this._handleCopySheetCommand(unitId, subUnitId, targetSubUnitId);
       }
     }
     return {
@@ -609,441 +632,441 @@ let W = class extends V {
       undos: []
     };
   }
-  _handleInsertColCommand(r, e, t) {
-    var _;
-    const n = this._sheetsFilterService.getFilterModel(e, t), s = (_ = n == null ? void 0 : n.getRange()) != null ? _ : null;
-    if (!n || !s)
+  _handleInsertColCommand(config, unitId, subUnitId) {
+    var _a4;
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId), filterRange = (_a4 = filterModel == null ? void 0 : filterModel.getRange()) != null ? _a4 : null;
+    if (!filterModel || !filterRange)
       return this._handleNull();
-    const { startColumn: o, endColumn: l } = s, { startColumn: a, endColumn: c } = r.range, h = c - a + 1;
-    if (c > l)
+    const { startColumn, endColumn } = filterRange, { startColumn: insertStartColumn, endColumn: insertEndColumn } = config.range, count = insertEndColumn - insertStartColumn + 1;
+    if (insertEndColumn > endColumn)
       return this._handleNull();
-    const d = [], u = [], m = a, g = {
-      unitId: e,
-      subUnitId: t,
+    const redos = [], undos = [], anchor = insertStartColumn, setFilterRangeMutationParams = {
+      unitId,
+      subUnitId,
       range: {
-        ...s,
-        startColumn: a <= o ? o + h : o,
-        endColumn: l + h
+        ...filterRange,
+        startColumn: insertStartColumn <= startColumn ? startColumn + count : startColumn,
+        endColumn: endColumn + count
       }
-    }, C = {
-      unitId: e,
-      subUnitId: t,
-      range: s
+    }, undoSetFilterRangeMutationParams = {
+      unitId,
+      subUnitId,
+      range: filterRange
     };
-    d.push({ id: R.id, params: g }), u.push({ id: R.id, params: C });
-    const F = n.getAllFilterColumns().filter((f) => f[0] >= m);
-    if (F.length !== 0) {
-      const { newRange: f, oldRange: v } = this.moveCriteria(e, t, F, h);
-      d.push(...f.redos, ...v.redos), u.push(...f.undos, ...v.undos);
+    redos.push({ id: SetSheetsFilterRangeMutation.id, params: setFilterRangeMutationParams }), undos.push({ id: SetSheetsFilterRangeMutation.id, params: undoSetFilterRangeMutationParams });
+    const effected = filterModel.getAllFilterColumns().filter((column) => column[0] >= anchor);
+    if (effected.length !== 0) {
+      const { newRange, oldRange } = this.moveCriteria(unitId, subUnitId, effected, count);
+      redos.push(...newRange.redos, ...oldRange.redos), undos.push(...newRange.undos, ...oldRange.undos);
     }
-    return { redos: I(d), undos: I(u) };
+    return { redos: mergeSetFilterCriteria(redos), undos: mergeSetFilterCriteria(undos) };
   }
-  _handleInsertRowCommand(r, e, t) {
-    var C;
-    const n = this._sheetsFilterService.getFilterModel(e, t), s = (C = n == null ? void 0 : n.getRange()) != null ? C : null;
-    if (!n || !s)
+  _handleInsertRowCommand(config, unitId, subUnitId) {
+    var _a4;
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId), filterRange = (_a4 = filterModel == null ? void 0 : filterModel.getRange()) != null ? _a4 : null;
+    if (!filterModel || !filterRange)
       return this._handleNull();
-    const { startRow: o, endRow: l } = s, { startRow: a, endRow: c } = r.range, h = c - a + 1;
-    if (c > l)
+    const { startRow, endRow } = filterRange, { startRow: insertStartRow, endRow: insertEndRow } = config.range, rowCount = insertEndRow - insertStartRow + 1;
+    if (insertEndRow > endRow)
       return this._handleNull();
-    const d = [], u = [], m = {
-      unitId: e,
-      subUnitId: t,
+    const redos = [], undos = [], setFilterRangeParams = {
+      unitId,
+      subUnitId,
       range: {
-        ...s,
-        startRow: a <= o ? o + h : o,
-        endRow: l + h
+        ...filterRange,
+        startRow: insertStartRow <= startRow ? startRow + rowCount : startRow,
+        endRow: endRow + rowCount
       }
-    }, g = {
-      unitId: e,
-      subUnitId: t,
-      range: s
+    }, undoSetFilterRangeMutationParams = {
+      unitId,
+      subUnitId,
+      range: filterRange
     };
-    return d.push({ id: R.id, params: m }), u.push({ id: R.id, params: g }), {
-      redos: I(d),
-      undos: I(u)
+    return redos.push({ id: SetSheetsFilterRangeMutation.id, params: setFilterRangeParams }), undos.push({ id: SetSheetsFilterRangeMutation.id, params: undoSetFilterRangeMutationParams }), {
+      redos: mergeSetFilterCriteria(redos),
+      undos: mergeSetFilterCriteria(undos)
     };
   }
-  _handleRemoveColCommand(r, e, t) {
-    var F;
-    const n = this._sheetsFilterService.getFilterModel(e, t), s = (F = n == null ? void 0 : n.getRange()) != null ? F : null;
-    if (!n || !s)
+  _handleRemoveColCommand(config, unitId, subUnitId) {
+    var _a4;
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId), filterRange = (_a4 = filterModel == null ? void 0 : filterModel.getRange()) != null ? _a4 : null;
+    if (!filterModel || !filterRange)
       return this._handleNull();
-    const { startColumn: o, endColumn: l } = s, { startColumn: a, endColumn: c } = r.range;
-    if (a > l)
+    const { startColumn, endColumn } = filterRange, { startColumn: removeStartColumn, endColumn: removeEndColumn } = config.range;
+    if (removeStartColumn > endColumn)
       return this._handleNull();
-    const h = [], d = [], u = c < o ? 0 : Math.min(c, l) - Math.max(a, o) + 1, m = c - a + 1, g = n.getAllFilterColumns();
-    g.forEach((_) => {
-      const [f, v] = _;
-      f <= c && f >= a && (h.push({ id: p.id, params: { unitId: e, subUnitId: t, col: f, criteria: null } }), d.push({ id: p.id, params: { unitId: e, subUnitId: t, col: f, criteria: { ...v.serialize(), colId: f } } }));
+    const redos = [], undos = [], rangeRemoveCount = removeEndColumn < startColumn ? 0 : Math.min(removeEndColumn, endColumn) - Math.max(removeStartColumn, startColumn) + 1, removeCount = removeEndColumn - removeStartColumn + 1, filterColumn = filterModel.getAllFilterColumns();
+    filterColumn.forEach((column) => {
+      const [col, filter2] = column;
+      col <= removeEndColumn && col >= removeStartColumn && (redos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId, col, criteria: null } }), undos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId, col, criteria: { ...filter2.serialize(), colId: col } } }));
     });
-    const C = g.filter((_) => {
-      const [f, v] = _;
-      return f > c;
+    const shifted = filterColumn.filter((column) => {
+      const [col, _] = column;
+      return col > removeEndColumn;
     });
-    let S = { undos: [], redos: [] };
-    if (C.length > 0) {
-      const { oldRange: _, newRange: f } = this.moveCriteria(e, t, C, -m);
-      S = f, h.push(..._.redos), d.unshift(..._.undos);
+    let newRangeCriteria = { undos: [], redos: [] };
+    if (shifted.length > 0) {
+      const { oldRange, newRange } = this.moveCriteria(unitId, subUnitId, shifted, -removeCount);
+      newRangeCriteria = newRange, redos.push(...oldRange.redos), undos.unshift(...oldRange.undos);
     }
-    if (u === l - o + 1) {
-      const _ = {
-        unitId: e,
-        subUnitId: t
+    if (rangeRemoveCount === endColumn - startColumn + 1) {
+      const removeFilterRangeMutationParams = {
+        unitId,
+        subUnitId
       };
-      h.push({ id: O.id, params: _ }), d.unshift({ id: R.id, params: { range: s, unitId: e, subUnitId: t } });
+      redos.push({ id: RemoveSheetsFilterMutation.id, params: removeFilterRangeMutationParams }), undos.unshift({ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId } });
     } else {
-      const _ = o <= a ? o : u === 0 ? o - m : a, f = o <= a ? l - u : l - m, v = {
-        unitId: e,
-        subUnitId: t,
-        range: { ...s, startColumn: _, endColumn: f }
+      const newStartColumn = startColumn <= removeStartColumn ? startColumn : rangeRemoveCount === 0 ? startColumn - removeCount : removeStartColumn, newEndColumn = startColumn <= removeStartColumn ? endColumn - rangeRemoveCount : endColumn - removeCount, setFilterRangeMutationParams = {
+        unitId,
+        subUnitId,
+        range: { ...filterRange, startColumn: newStartColumn, endColumn: newEndColumn }
       };
-      h.push({ id: R.id, params: v }), d.unshift({ id: R.id, params: { range: s, unitId: e, subUnitId: t } }), h.push(...S.redos), d.unshift(...S.undos);
+      redos.push({ id: SetSheetsFilterRangeMutation.id, params: setFilterRangeMutationParams }), undos.unshift({ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId } }), redos.push(...newRangeCriteria.redos), undos.unshift(...newRangeCriteria.undos);
     }
     return {
-      undos: d,
-      redos: h
+      undos,
+      redos
     };
   }
-  _handleRemoveRowCommand(r, e, t) {
-    var C;
-    const n = this._sheetsFilterService.getFilterModel(e, t);
-    if (!n)
+  _handleRemoveRowCommand(config, unitId, subUnitId) {
+    var _a4;
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId);
+    if (!filterModel)
       return this._handleNull();
-    const s = n.getRange(), { startRow: o, endRow: l } = s, { startRow: a, endRow: c } = r.range;
-    if (a > l)
+    const filterRange = filterModel.getRange(), { startRow, endRow } = filterRange, { startRow: removeStartRow, endRow: removeEndRow } = config.range;
+    if (removeStartRow > endRow)
       return this._handleNull();
-    if (c < o)
+    if (removeEndRow < startRow)
       return {
-        undos: [{ id: R.id, params: { range: s, unitId: e, subUnitId: t } }],
+        undos: [{ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId } }],
         redos: [{
-          id: R.id,
+          id: SetSheetsFilterRangeMutation.id,
           params: {
             range: {
-              ...s,
-              startRow: o - (c - a + 1),
-              endRow: l - (c - a + 1)
+              ...filterRange,
+              startRow: startRow - (removeEndRow - removeStartRow + 1),
+              endRow: endRow - (removeEndRow - removeStartRow + 1)
             },
-            unitId: e,
-            subUnitId: t
+            unitId,
+            subUnitId
           }
         }]
       };
-    const h = [], d = [], u = n.getAllFilterColumns(), m = o <= c && o >= a;
-    d.push({ id: R.id, params: { range: s, unitId: e, subUnitId: t } });
-    const g = Math.min(c, l) - Math.max(a, o) + 1;
-    if (g === l - o + 1 || m) {
-      const S = {
-        unitId: e,
-        subUnitId: t
+    const redos = [], undos = [], filterColumn = filterModel.getAllFilterColumns(), filterHeaderIsRemoved = startRow <= removeEndRow && startRow >= removeStartRow;
+    undos.push({ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId } });
+    const count = Math.min(removeEndRow, endRow) - Math.max(removeStartRow, startRow) + 1;
+    if (count === endRow - startRow + 1 || filterHeaderIsRemoved) {
+      const removeFilterRangeMutationParams = {
+        unitId,
+        subUnitId
       };
-      h.push({ id: O.id, params: S }), u.forEach((F) => {
-        const [_, f] = F, v = {
-          unitId: e,
-          subUnitId: t,
-          col: _,
-          criteria: { ...f.serialize(), colId: _ }
+      redos.push({ id: RemoveSheetsFilterMutation.id, params: removeFilterRangeMutationParams }), filterColumn.forEach((column) => {
+        const [offset, filter2] = column, setCriteriaMutationParams = {
+          unitId,
+          subUnitId,
+          col: offset,
+          criteria: { ...filter2.serialize(), colId: offset }
         };
-        d.push({ id: p.id, params: v });
+        undos.push({ id: SetSheetsFilterCriteriaMutation.id, params: setCriteriaMutationParams });
       });
     } else {
-      const S = (C = this._univerInstanceService.getUniverSheetInstance(e)) == null ? void 0 : C.getSheetBySheetId(t);
-      if (!S)
+      const worksheet = (_a4 = this._univerInstanceService.getUniverSheetInstance(unitId)) == null ? void 0 : _a4.getSheetBySheetId(subUnitId);
+      if (!worksheet)
         return this._handleNull();
-      const F = [];
-      for (let y = a; y <= c; y++)
-        S.getRowFiltered(y) && F.push(y);
-      const _ = Math.min(o, a), f = _ + (l - o) - g + F.length, v = {
-        unitId: e,
-        subUnitId: t,
+      const hiddenRows = [];
+      for (let r = removeStartRow; r <= removeEndRow; r++)
+        worksheet.getRowFiltered(r) && hiddenRows.push(r);
+      const afterStartRow = Math.min(startRow, removeStartRow), afterEndRow = afterStartRow + (endRow - startRow) - count + hiddenRows.length, setFilterRangeMutationParams = {
+        unitId,
+        subUnitId,
         range: {
-          ...s,
-          startRow: _,
-          endRow: f
+          ...filterRange,
+          startRow: afterStartRow,
+          endRow: afterEndRow
         }
       };
-      h.push({ id: R.id, params: v });
+      redos.push({ id: SetSheetsFilterRangeMutation.id, params: setFilterRangeMutationParams });
     }
     return {
-      undos: I(d),
-      redos: I(h)
+      undos: mergeSetFilterCriteria(undos),
+      redos: mergeSetFilterCriteria(redos)
     };
   }
   // eslint-disable-next-line max-lines-per-function
-  _handleMoveColsCommand(r, e, t) {
-    var _;
-    const n = this._sheetsFilterService.getFilterModel(e, t), s = (_ = n == null ? void 0 : n.getRange()) != null ? _ : null;
-    if (!n || !s)
+  _handleMoveColsCommand(config, unitId, subUnitId) {
+    var _a4;
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId), filterRange = (_a4 = filterModel == null ? void 0 : filterModel.getRange()) != null ? _a4 : null;
+    if (!filterModel || !filterRange)
       return this._handleNull();
-    const { startColumn: o, endColumn: l } = s, { fromRange: a, toRange: c } = r;
-    if (a.endColumn < o && c.startColumn <= o || a.startColumn > l && c.endColumn > l)
+    const { startColumn, endColumn } = filterRange, { fromRange, toRange } = config;
+    if (fromRange.endColumn < startColumn && toRange.startColumn <= startColumn || fromRange.startColumn > endColumn && toRange.endColumn > endColumn)
       return this._handleNull();
-    const h = [], d = [], u = {};
-    for (let f = o; f <= l; f++)
-      u[f] = {
-        colIndex: f,
-        filter: n.getFilterColumn(f)
+    const redos = [], undos = [], filterCol = {};
+    for (let col = startColumn; col <= endColumn; col++)
+      filterCol[col] = {
+        colIndex: col,
+        filter: filterModel.getFilterColumn(col)
       };
-    ee(a.startColumn, a.endColumn - a.startColumn + 1, c.startColumn, u);
-    let m = s.startColumn, g = s.endColumn;
-    o >= a.startColumn && o <= a.endColumn && c.startColumn > a.startColumn && a.endColumn < l && (m = a.endColumn + 1), l >= a.startColumn && l <= a.endColumn && c.startColumn < a.startColumn && a.startColumn > o && (g = a.startColumn - 1);
-    const C = Object.keys(u).map((f) => Number(f)), S = C.find((f) => u[f].colIndex === g), F = C.find((f) => u[f].colIndex === m);
-    if (C.forEach((f) => {
-      var X, Z;
-      const { colIndex: v, filter: y } = u[f], A = f;
-      if (y) {
-        if (A >= F && A <= S) {
-          const q = {
-            unitId: e,
-            subUnitId: t,
-            col: A,
-            criteria: { ...y.serialize(), colId: A }
-          }, pe = {
-            unitId: e,
-            subUnitId: t,
-            col: A,
-            criteria: n.getFilterColumn(A) ? { ...(X = n.getFilterColumn(A)) == null ? void 0 : X.serialize(), colId: A } : null
+    moveMatrixArray(fromRange.startColumn, fromRange.endColumn - fromRange.startColumn + 1, toRange.startColumn, filterCol);
+    let startBorder = filterRange.startColumn, endBorder = filterRange.endColumn;
+    startColumn >= fromRange.startColumn && startColumn <= fromRange.endColumn && toRange.startColumn > fromRange.startColumn && fromRange.endColumn < endColumn && (startBorder = fromRange.endColumn + 1), endColumn >= fromRange.startColumn && endColumn <= fromRange.endColumn && toRange.startColumn < fromRange.startColumn && fromRange.startColumn > startColumn && (endBorder = fromRange.startColumn - 1);
+    const numberCols = Object.keys(filterCol).map((col) => Number(col)), newEnd = numberCols.find((col) => filterCol[col].colIndex === endBorder), newStart = numberCols.find((col) => filterCol[col].colIndex === startBorder);
+    if (numberCols.forEach((col) => {
+      var _a5, _b;
+      const { colIndex: oldColIndex, filter: filter2 } = filterCol[col], newColIndex = col;
+      if (filter2) {
+        if (newColIndex >= newStart && newColIndex <= newEnd) {
+          const setCriteriaMutationParams = {
+            unitId,
+            subUnitId,
+            col: newColIndex,
+            criteria: { ...filter2.serialize(), colId: newColIndex }
+          }, undoSetCriteriaMutationParams = {
+            unitId,
+            subUnitId,
+            col: newColIndex,
+            criteria: filterModel.getFilterColumn(newColIndex) ? { ...(_a5 = filterModel.getFilterColumn(newColIndex)) == null ? void 0 : _a5.serialize(), colId: newColIndex } : null
           };
-          h.push({ id: p.id, params: q }), d.push({ id: p.id, params: pe });
+          redos.push({ id: SetSheetsFilterCriteriaMutation.id, params: setCriteriaMutationParams }), undos.push({ id: SetSheetsFilterCriteriaMutation.id, params: undoSetCriteriaMutationParams });
         }
-        if (!((Z = u[v]) != null && Z.filter)) {
-          const q = {
-            unitId: e,
-            subUnitId: t,
-            col: v,
+        if (!((_b = filterCol[oldColIndex]) != null && _b.filter)) {
+          const setCriteriaMutationParams = {
+            unitId,
+            subUnitId,
+            col: oldColIndex,
             criteria: null
           };
-          h.push({ id: p.id, params: q }), d.push({ id: p.id, params: { unitId: e, subUnitId: t, col: v, criteria: { ...y.serialize(), colId: v } } });
+          redos.push({ id: SetSheetsFilterCriteriaMutation.id, params: setCriteriaMutationParams }), undos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId, col: oldColIndex, criteria: { ...filter2.serialize(), colId: oldColIndex } } });
         }
       }
-    }), o !== F || l !== S) {
-      const f = {
-        unitId: e,
-        subUnitId: t,
+    }), startColumn !== newStart || endColumn !== newEnd) {
+      const setFilterRangeMutationParams = {
+        unitId,
+        subUnitId,
         range: {
-          ...s,
-          startColumn: F,
-          endColumn: S
+          ...filterRange,
+          startColumn: newStart,
+          endColumn: newEnd
         }
       };
-      h.unshift({ id: R.id, params: f }), d.unshift({ id: R.id, params: { range: s, unitId: e, subUnitId: t } });
+      redos.unshift({ id: SetSheetsFilterRangeMutation.id, params: setFilterRangeMutationParams }), undos.unshift({ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId } });
     }
     return {
-      undos: d,
-      redos: h
+      undos,
+      redos
     };
   }
-  _handleMoveRowsCommand(r, e, t) {
-    var _;
-    const n = this._sheetsFilterService.getFilterModel(e, t), s = (_ = n == null ? void 0 : n.getRange()) != null ? _ : null;
-    if (!n || !s)
+  _handleMoveRowsCommand(config, unitId, subUnitId) {
+    var _a4;
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId), filterRange = (_a4 = filterModel == null ? void 0 : filterModel.getRange()) != null ? _a4 : null;
+    if (!filterModel || !filterRange)
       return this._handleNull();
-    const { startRow: o, endRow: l } = s, { fromRange: a, toRange: c } = r;
-    if (a.endRow < o && c.startRow <= o || a.startRow > l && c.endRow > l)
+    const { startRow, endRow } = filterRange, { fromRange, toRange } = config;
+    if (fromRange.endRow < startRow && toRange.startRow <= startRow || fromRange.startRow > endRow && toRange.endRow > endRow)
       return this._handleNull();
-    const h = [], d = [], u = {};
-    for (let f = o; f <= l; f++)
-      u[f] = {
-        oldIndex: f
+    const redos = [], undos = [], filterRow = {};
+    for (let row = startRow; row <= endRow; row++)
+      filterRow[row] = {
+        oldIndex: row
       };
-    const m = o;
-    let g = l;
-    l >= a.startRow && l <= a.endRow && c.startRow < a.startRow && a.startRow > o && (g = a.startRow - 1), ee(a.startRow, a.endRow - a.startRow + 1, c.startRow, u);
-    const C = Object.keys(u).map((f) => Number(f)), S = C.find((f) => u[f].oldIndex === g), F = C.find((f) => u[f].oldIndex === m);
-    if (o !== F || l !== S) {
-      const f = {
-        unitId: e,
-        subUnitId: t,
+    const startBorder = startRow;
+    let endBorder = endRow;
+    endRow >= fromRange.startRow && endRow <= fromRange.endRow && toRange.startRow < fromRange.startRow && fromRange.startRow > startRow && (endBorder = fromRange.startRow - 1), moveMatrixArray(fromRange.startRow, fromRange.endRow - fromRange.startRow + 1, toRange.startRow, filterRow);
+    const numberRows = Object.keys(filterRow).map((row) => Number(row)), newEnd = numberRows.find((row) => filterRow[row].oldIndex === endBorder), newStart = numberRows.find((row) => filterRow[row].oldIndex === startBorder);
+    if (startRow !== newStart || endRow !== newEnd) {
+      const setFilterRangeMutationParams = {
+        unitId,
+        subUnitId,
         range: {
-          ...s,
-          startRow: F,
-          endRow: S
+          ...filterRange,
+          startRow: newStart,
+          endRow: newEnd
         }
       };
-      h.push({ id: R.id, params: f }, { id: H.id, params: { unitId: e, subUnitId: t } }), d.push({ id: R.id, params: { range: s, unitId: e, subUnitId: t } }, { id: H.id, params: { unitId: e, subUnitId: t } });
+      redos.push({ id: SetSheetsFilterRangeMutation.id, params: setFilterRangeMutationParams }, { id: ReCalcSheetsFilterMutation.id, params: { unitId, subUnitId } }), undos.push({ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId } }, { id: ReCalcSheetsFilterMutation.id, params: { unitId, subUnitId } });
     }
     return {
-      redos: h,
-      undos: d
+      redos,
+      undos
     };
   }
-  _handleMoveRangeCommand(r, e, t) {
-    const { fromRange: n, toRange: s } = r, o = this._sheetsFilterService.getFilterModel(e, t);
-    if (!o)
+  _handleMoveRangeCommand(config, unitId, subUnitId) {
+    const { fromRange, toRange } = config, filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId);
+    if (!filterModel)
       return this._handleNull();
-    const l = o.getRange();
-    if (!l)
+    const filterRange = filterModel.getRange();
+    if (!filterRange)
       return this._handleNull();
-    const a = [], c = [];
-    if (Y.contains(n, l)) {
-      const h = l.startRow - n.startRow, d = l.startColumn - n.startColumn, u = {
-        startRow: s.startRow + h,
-        startColumn: s.startColumn + d,
-        endRow: s.startRow + h + (l.endRow - l.startRow),
-        endColumn: s.startColumn + d + (l.endColumn - l.startColumn)
-      }, m = {
-        id: O.id,
+    const redos = [], undos = [];
+    if (Rectangle.contains(fromRange, filterRange)) {
+      const rowOffset = filterRange.startRow - fromRange.startRow, colOffset = filterRange.startColumn - fromRange.startColumn, newFilterRange = {
+        startRow: toRange.startRow + rowOffset,
+        startColumn: toRange.startColumn + colOffset,
+        endRow: toRange.startRow + rowOffset + (filterRange.endRow - filterRange.startRow),
+        endColumn: toRange.startColumn + colOffset + (filterRange.endColumn - filterRange.startColumn)
+      }, removeFilter = {
+        id: RemoveSheetsFilterMutation.id,
         params: {
-          unitId: e,
-          subUnitId: t
+          unitId,
+          subUnitId
         }
-      }, g = { id: R.id, params: { unitId: e, subUnitId: t, range: u } }, C = { id: R.id, params: { unitId: e, subUnitId: t, range: l } };
-      a.push(m, g), c.push(m, C);
-      const S = o.getAllFilterColumns(), F = s.startColumn - n.startColumn;
-      S.forEach((_) => {
-        const [f, v] = _;
-        v && (a.push({ id: p.id, params: { unitId: e, subUnitId: t, col: f + F, criteria: { ...v.serialize(), colId: f + F } } }), c.push({ id: p.id, params: { unitId: e, subUnitId: t, col: f, criteria: { ...v.serialize(), colId: f } } }));
+      }, setNewFilterRange = { id: SetSheetsFilterRangeMutation.id, params: { unitId, subUnitId, range: newFilterRange } }, setOldFilterRange = { id: SetSheetsFilterRangeMutation.id, params: { unitId, subUnitId, range: filterRange } };
+      redos.push(removeFilter, setNewFilterRange), undos.push(removeFilter, setOldFilterRange);
+      const filterColumn = filterModel.getAllFilterColumns(), moveColDelta = toRange.startColumn - fromRange.startColumn;
+      filterColumn.forEach((column) => {
+        const [col, criteria] = column;
+        criteria && (redos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId, col: col + moveColDelta, criteria: { ...criteria.serialize(), colId: col + moveColDelta } } }), undos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId, col, criteria: { ...criteria.serialize(), colId: col } } }));
       });
-    } else if (Y.intersects(s, l)) {
-      const h = {
-        ...l,
-        endRow: Math.max(l.endRow, s.endRow)
+    } else if (Rectangle.intersects(toRange, filterRange)) {
+      const newFilterRange = {
+        ...filterRange,
+        endRow: Math.max(filterRange.endRow, toRange.endRow)
       };
-      a.push({ id: R.id, params: { unitId: e, subUnitId: t, range: h } }), c.push({ id: R.id, params: { unitId: e, subUnitId: t, range: l } });
+      redos.push({ id: SetSheetsFilterRangeMutation.id, params: { unitId, subUnitId, range: newFilterRange } }), undos.push({ id: SetSheetsFilterRangeMutation.id, params: { unitId, subUnitId, range: filterRange } });
     }
     return {
-      redos: a,
-      undos: c
+      redos,
+      undos
     };
   }
-  _handleRemoveSheetCommand(r, e, t) {
-    const n = this._sheetsFilterService.getFilterModel(e, t);
-    if (!n)
+  _handleRemoveSheetCommand(config, unitId, subUnitId) {
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId);
+    if (!filterModel)
       return this._handleNull();
-    const s = n.getRange();
-    if (!s)
+    const filterRange = filterModel.getRange();
+    if (!filterRange)
       return this._handleNull();
-    const o = [], l = [];
-    return n.getAllFilterColumns().forEach(([c, h]) => {
-      l.push({ id: p.id, params: { unitId: e, subUnitId: t, col: c, criteria: { ...h.serialize(), colId: c } } });
-    }), o.push({ id: O.id, params: { unitId: e, subUnitId: t, range: s } }), l.unshift({ id: R.id, params: { range: s, unitId: e, subUnitId: t } }), {
-      undos: l,
-      redos: o
+    const redos = [], undos = [];
+    return filterModel.getAllFilterColumns().forEach(([col, filter2]) => {
+      undos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId, col, criteria: { ...filter2.serialize(), colId: col } } });
+    }), redos.push({ id: RemoveSheetsFilterMutation.id, params: { unitId, subUnitId, range: filterRange } }), undos.unshift({ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId } }), {
+      undos,
+      redos
     };
   }
-  _handleCopySheetCommand(r, e, t) {
-    const n = this._sheetsFilterService.getFilterModel(r, e);
-    if (!n)
+  _handleCopySheetCommand(unitId, subUnitId, targetSubUnitId) {
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId);
+    if (!filterModel)
       return this._handleNull();
-    const s = n.getRange();
-    if (!s)
+    const filterRange = filterModel.getRange();
+    if (!filterRange)
       return this._handleNull();
-    const o = [], l = [], a = [], c = [];
-    return n.getAllFilterColumns().forEach(([d, u]) => {
-      o.push({ id: p.id, params: { unitId: r, subUnitId: t, col: d, criteria: { ...u.serialize(), colId: d } } }), a.push({ id: p.id, params: { unitId: r, subUnitId: t, col: d, criteria: null } });
-    }), a.push({ id: O.id, params: { unitId: r, subUnitId: t, range: s } }), o.unshift({ id: R.id, params: { range: s, unitId: r, subUnitId: t } }), {
-      undos: l,
-      redos: o,
-      preUndos: a,
-      preRedos: c
+    const redos = [], undos = [], preUndos = [], preRedos = [];
+    return filterModel.getAllFilterColumns().forEach(([col, filter2]) => {
+      redos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId: targetSubUnitId, col, criteria: { ...filter2.serialize(), colId: col } } }), preUndos.push({ id: SetSheetsFilterCriteriaMutation.id, params: { unitId, subUnitId: targetSubUnitId, col, criteria: null } });
+    }), preUndos.push({ id: RemoveSheetsFilterMutation.id, params: { unitId, subUnitId: targetSubUnitId, range: filterRange } }), redos.unshift({ id: SetSheetsFilterRangeMutation.id, params: { range: filterRange, unitId, subUnitId: targetSubUnitId } }), {
+      undos,
+      redos,
+      preUndos,
+      preRedos
     };
   }
   _handleNull() {
     return { redos: [], undos: [] };
   }
   _initRowFilteredInterceptor() {
-    this.disposeWithMe(this._sheetInterceptorService.intercept(ze.ROW_FILTERED, {
+    this.disposeWithMe(this._sheetInterceptorService.intercept(INTERCEPTOR_POINT.ROW_FILTERED, {
       // sheet-interceptor.service.ts
-      handler: (r, e) => {
-        var t, n;
-        return r ? !0 : (n = (t = this._sheetsFilterService.getFilterModel(
-          e.unitId,
-          e.subUnitId
-        )) == null ? void 0 : t.isRowFiltered(e.row)) != null ? n : !1;
-      }
+      handler: /* @__PURE__ */ __name((filtered, rowLocation) => {
+        var _a4, _b;
+        return filtered ? !0 : (_b = (_a4 = this._sheetsFilterService.getFilterModel(
+          rowLocation.unitId,
+          rowLocation.subUnitId
+        )) == null ? void 0 : _a4.isRowFiltered(rowLocation.row)) != null ? _b : !1;
+      }, "handler")
     }));
   }
-  moveCriteria(r, e, t, n) {
-    const s = {
-      unitId: r,
-      subUnitId: e,
+  moveCriteria(unitId, subUnitId, target, step) {
+    const defaultSetCriteriaMutationParams = {
+      unitId,
+      subUnitId,
       criteria: null,
       col: -1
-    }, o = [], l = [], a = [], c = [];
-    return t.forEach((h) => {
-      const [d, u] = h;
-      l.push({
-        id: p.id,
+    }, oldUndos = [], oldRedos = [], newUndos = [], newRedos = [];
+    return target.forEach((column) => {
+      const [offset, filter2] = column;
+      oldRedos.push({
+        id: SetSheetsFilterCriteriaMutation.id,
         params: {
-          ...s,
-          col: d
+          ...defaultSetCriteriaMutationParams,
+          col: offset
         }
-      }), o.push({
-        id: p.id,
+      }), oldUndos.push({
+        id: SetSheetsFilterCriteriaMutation.id,
         params: {
-          ...s,
-          col: d,
-          criteria: { ...u.serialize(), colId: d }
+          ...defaultSetCriteriaMutationParams,
+          col: offset,
+          criteria: { ...filter2.serialize(), colId: offset }
         }
       });
-    }), t.forEach((h) => {
-      const [d, u] = h;
-      c.push({
-        id: p.id,
+    }), target.forEach((column) => {
+      const [offset, filter2] = column;
+      newRedos.push({
+        id: SetSheetsFilterCriteriaMutation.id,
         params: {
-          ...s,
-          col: d + n,
-          criteria: { ...u.serialize(), colId: d + n }
+          ...defaultSetCriteriaMutationParams,
+          col: offset + step,
+          criteria: { ...filter2.serialize(), colId: offset + step }
         }
-      }), a.push({
-        id: p.id,
+      }), newUndos.push({
+        id: SetSheetsFilterCriteriaMutation.id,
         params: {
-          ...s,
-          col: d + n,
+          ...defaultSetCriteriaMutationParams,
+          col: offset + step,
           criteria: null
         }
       });
     }), {
       newRange: {
-        redos: c,
-        undos: a
+        redos: newRedos,
+        undos: newUndos
       },
       oldRange: {
-        redos: l,
-        undos: o
+        redos: oldRedos,
+        undos: oldUndos
       }
     };
   }
   _commandExecutedListener() {
-    this.disposeWithMe(this._commandService.onCommandExecuted((r, e) => {
-      var c, h;
-      const { unitId: t, subUnitId: n } = r.params || {}, s = this._sheetsFilterService.getFilterModel(t, n);
-      if (!s) return;
-      const o = Array.from(s.filteredOutRows).sort((d, u) => d - u), l = [];
-      let a = !1;
-      if (r.id === He.id) {
-        const { startRow: d, endRow: u } = r.params.range, m = o.filter((g) => g >= d && g <= u);
-        o.forEach((g) => {
-          if (g < d)
-            l.push(g);
-          else if (a = !0, g <= u) {
-            const C = Math.max(d, l.length ? l[l.length - 1] + 1 : d);
-            l.push(C);
+    this.disposeWithMe(this._commandService.onCommandExecuted((command, options) => {
+      var _a4, _b;
+      const { unitId, subUnitId } = command.params || {}, filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId);
+      if (!filterModel) return;
+      const filteredOutRows = Array.from(filterModel.filteredOutRows).sort((a, b) => a - b), newFilteredOutRows = [];
+      let changed = !1;
+      if (command.id === RemoveRowMutation.id) {
+        const { startRow, endRow } = command.params.range, filterOutInRemove = filteredOutRows.filter((row) => row >= startRow && row <= endRow);
+        filteredOutRows.forEach((row) => {
+          if (row < startRow)
+            newFilteredOutRows.push(row);
+          else if (changed = !0, row <= endRow) {
+            const newIndex = Math.max(startRow, newFilteredOutRows.length ? newFilteredOutRows[newFilteredOutRows.length - 1] + 1 : startRow);
+            newFilteredOutRows.push(newIndex);
           } else
-            l.push(g - (u - d + 1 - m.length));
+            newFilteredOutRows.push(row - (endRow - startRow + 1 - filterOutInRemove.length));
         });
       }
-      if (r.id === De.id) {
-        const { startRow: d, endRow: u } = r.params.range;
-        o.forEach((m) => {
-          m >= d ? (a = !0, l.push(m + (u - d + 1))) : l.push(m);
+      if (command.id === InsertRowMutation.id) {
+        const { startRow, endRow } = command.params.range;
+        filteredOutRows.forEach((row) => {
+          row >= startRow ? (changed = !0, newFilteredOutRows.push(row + (endRow - startRow + 1))) : newFilteredOutRows.push(row);
         });
       }
-      if (a && (s.filteredOutRows = new Set(l)), r.id === We.id && !(e != null && e.onlyLocal)) {
-        const d = this._getExtendRegion(t, n);
-        if (d) {
-          const u = r.params.cellValue;
-          if (u)
-            for (let m = d.startColumn; m <= d.endColumn; m++) {
-              const g = (c = u == null ? void 0 : u[d.startRow]) == null ? void 0 : c[m];
-              if (g && this._cellHasValue(g)) {
-                const C = (h = this._univerInstanceService.getUnit(t)) == null ? void 0 : h.getSheetBySheetId(n);
-                if (C) {
-                  const S = ae(d, { down: !0 }, C), F = this._sheetsFilterService.getFilterModel(t, n), _ = F.getRange();
-                  F.setRange({
-                    ..._,
-                    endRow: S.endRow
-                  }), this._registerRefRange(t, n);
+      if (changed && (filterModel.filteredOutRows = new Set(newFilteredOutRows)), command.id === SetRangeValuesMutation.id && !(options != null && options.onlyLocal)) {
+        const extendRegion = this._getExtendRegion(unitId, subUnitId);
+        if (extendRegion) {
+          const cellValue = command.params.cellValue;
+          if (cellValue)
+            for (let col = extendRegion.startColumn; col <= extendRegion.endColumn; col++) {
+              const cell = (_a4 = cellValue == null ? void 0 : cellValue[extendRegion.startRow]) == null ? void 0 : _a4[col];
+              if (cell && this._cellHasValue(cell)) {
+                const worksheet = (_b = this._univerInstanceService.getUnit(unitId)) == null ? void 0 : _b.getSheetBySheetId(subUnitId);
+                if (worksheet) {
+                  const extendedRange = expandToContinuousRange(extendRegion, { down: !0 }, worksheet), filterModel2 = this._sheetsFilterService.getFilterModel(unitId, subUnitId), filterRange = filterModel2.getRange();
+                  filterModel2.setRange({
+                    ...filterRange,
+                    endRow: extendedRange.endRow
+                  }), this._registerRefRange(unitId, subUnitId);
                 }
               }
             }
@@ -1051,266 +1074,270 @@ let W = class extends V {
       }
     }));
   }
-  _getExtendRegion(r, e) {
-    var a;
-    const t = this._sheetsFilterService.getFilterModel(r, e);
-    if (!t)
+  _getExtendRegion(unitId, subUnitId) {
+    var _a4;
+    const filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId);
+    if (!filterModel)
       return null;
-    const n = (a = this._univerInstanceService.getUnit(r)) == null ? void 0 : a.getSheetBySheetId(e);
-    if (!n)
+    const worksheet = (_a4 = this._univerInstanceService.getUnit(unitId)) == null ? void 0 : _a4.getSheetBySheetId(subUnitId);
+    if (!worksheet)
       return null;
-    const s = t.getRange();
-    if (!s)
+    const filterRange = filterModel.getRange();
+    if (!filterRange)
       return null;
-    const o = n.getRowCount() - 1, l = n.getRowManager();
-    for (let c = s.endRow + 1; c <= o; c++)
-      if (l.getRowRawVisible(c))
+    const maxRowIndex = worksheet.getRowCount() - 1, rowManager = worksheet.getRowManager();
+    for (let row = filterRange.endRow + 1; row <= maxRowIndex; row++)
+      if (rowManager.getRowRawVisible(row))
         return {
-          startRow: c,
-          endRow: c,
-          startColumn: s.startColumn,
-          endColumn: s.endColumn
+          startRow: row,
+          endRow: row,
+          startColumn: filterRange.startColumn,
+          endColumn: filterRange.endColumn
         };
     return null;
   }
   _initErrorHandling() {
-    this.disposeWithMe(this._commandService.beforeCommandExecuted((r) => {
-      const e = r.params, t = L(this._univerInstanceService);
-      if (!t) return;
-      const { subUnitId: n, unitId: s } = t, o = this._sheetsFilterService.getFilterModel(s, n);
-      if (!o) return;
-      const l = o.getRange();
-      if (r.id === Ve.id && e.fromRange.startRow <= l.startRow && e.fromRange.endRow < l.endRow && e.fromRange.endRow >= l.startRow)
+    this.disposeWithMe(this._commandService.beforeCommandExecuted((command) => {
+      const params = command.params, target = getSheetCommandTarget(this._univerInstanceService);
+      if (!target) return;
+      const { subUnitId, unitId } = target, filterModel = this._sheetsFilterService.getFilterModel(unitId, subUnitId);
+      if (!filterModel) return;
+      const filterRange = filterModel.getRange();
+      if (command.id === MoveRowsCommand.id && params.fromRange.startRow <= filterRange.startRow && params.fromRange.endRow < filterRange.endRow && params.fromRange.endRow >= filterRange.startRow)
         throw this._sheetsFilterService.setFilterErrorMsg("sheets-filter.msg.filter-header-forbidden"), new Error("[SheetsFilterController]: Cannot move header row of filter");
     }));
   }
-  _cellHasValue(r) {
-    const e = Object.values(r);
-    return !(e.length === 0 || e.every((t) => t == null));
-  }
-};
-W = yt([
-  P(0, T),
-  P(1, z(Pe)),
-  P(2, z(M)),
-  P(3, x),
-  P(4, z(Ue))
-], W);
-var At = Object.defineProperty, Tt = Object.getOwnPropertyDescriptor, Nt = (i, r, e, t) => {
-  for (var n = t > 1 ? void 0 : t ? Tt(r, e) : r, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (n = (t ? o(r, e, n) : o(n)) || n);
-  return t && n && At(r, e, n), n;
-}, oe = (i, r) => (e, t) => r(e, t, i), B;
-let le = (B = class extends ye {
-  constructor(i = re, r, e) {
-    super(), this._config = i, this._injector = r, this._configService = e;
-    const { ...t } = Ae(
+  _cellHasValue(cell) {
+    const values = Object.values(cell);
+    return !(values.length === 0 || values.every((v) => v == null));
+  }
+}, __name(_a2, "SheetsFilterController"), _a2);
+SheetsFilterController = __decorateClass$1([
+  __decorateParam$1(0, ICommandService),
+  __decorateParam$1(1, Inject(SheetInterceptorService)),
+  __decorateParam$1(2, Inject(SheetsFilterService)),
+  __decorateParam$1(3, IUniverInstanceService),
+  __decorateParam$1(4, Inject(RefRangeService))
+], SheetsFilterController);
+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"), _a3;
+let UniverSheetsFilterPlugin = (_a3 = class extends Plugin {
+  constructor(_config = defaultPluginConfig, _injector, _configService) {
+    super(), this._config = _config, this._injector = _injector, this._configService = _configService;
+    const { ...rest } = merge$1(
       {},
-      re,
+      defaultPluginConfig,
       this._config
     );
-    this._configService.setConfig(tt, t);
+    this._configService.setConfig(SHEETS_FILTER_PLUGIN_CONFIG_KEY, rest);
   }
   onStarting() {
     [
-      [M],
-      [W]
-    ].forEach((i) => this._injector.add(i));
+      [SheetsFilterService],
+      [SheetsFilterController]
+    ].forEach((d) => this._injector.add(d));
   }
   onReady() {
-    this._injector.get(W);
-  }
-}, w(B, "type", U.UNIVER_SHEET), w(B, "pluginName", Re), B);
-le = Nt([
-  oe(1, z(Te)),
-  oe(2, Ne)
-], le);
-const xt = {
+    this._injector.get(SheetsFilterController);
+  }
+}, __name(_a3, "UniverSheetsFilterPlugin"), __publicField(_a3, "type", UniverInstanceType.UNIVER_SHEET), __publicField(_a3, "pluginName", SHEET_FILTER_SNAPSHOT_ID), _a3);
+UniverSheetsFilterPlugin = __decorateClass([
+  __decorateParam(1, Inject(Injector)),
+  __decorateParam(2, IConfigService)
+], UniverSheetsFilterPlugin);
+const SetSheetFilterRangeCommand = {
   id: "sheet.command.set-filter-range",
-  type: E.COMMAND,
-  handler: (i, r) => {
-    const e = i.get(M), t = i.get(T), n = i.get(j), s = i.get(x), { unitId: o, subUnitId: l, range: a } = r;
-    if (!L(s, r) || e.getFilterModel(o, l)) return !1;
-    if (a.endRow === a.startRow) {
-      const m = i.get(xe), g = i.get(Ie);
-      return m.emit(g.t("sheets-filter.command.not-valid-filter-range")), !1;
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const sheetsFilterService = accessor.get(SheetsFilterService), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), instanceSrv = accessor.get(IUniverInstanceService), { unitId, subUnitId, range } = params;
+    if (!getSheetCommandTarget(instanceSrv, params) || sheetsFilterService.getFilterModel(unitId, subUnitId)) return !1;
+    if (range.endRow === range.startRow) {
+      const errorService = accessor.get(ErrorService), localeService = accessor.get(LocaleService);
+      return errorService.emit(localeService.t("sheets-filter.command.not-valid-filter-range")), !1;
     }
-    const d = { id: R.id, params: { unitId: o, subUnitId: l, range: a } }, u = t.syncExecuteCommand(d.id, d.params);
-    return u && n.pushUndoRedo({
-      unitID: o,
-      undoMutations: [{ id: O.id, params: { unitId: o, subUnitId: l } }],
-      redoMutations: [d]
-    }), u;
-  }
-}, It = {
+    const redoMutation = { id: SetSheetsFilterRangeMutation.id, params: { unitId, subUnitId, range } }, result = commandService.syncExecuteCommand(redoMutation.id, redoMutation.params);
+    return result && undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      undoMutations: [{ id: RemoveSheetsFilterMutation.id, params: { unitId, subUnitId } }],
+      redoMutations: [redoMutation]
+    }), result;
+  }, "handler")
+}, RemoveSheetFilterCommand = {
   id: "sheet.command.remove-sheet-filter",
-  type: E.COMMAND,
-  handler: (i, r) => {
-    const e = i.get(x), t = i.get(M), n = i.get(T), s = i.get(j), o = L(e, r);
-    if (!o) return !1;
-    const { unitId: l, subUnitId: a } = o, c = t.getFilterModel(l, a);
-    if (!c) return !1;
-    const h = c == null ? void 0 : c.serialize(), d = $t(l, a, h), u = n.syncExecuteCommand(O.id, { unitId: l, subUnitId: a });
-    return u && s.pushUndoRedo({
-      unitID: l,
-      undoMutations: d,
-      redoMutations: [{ id: O.id, params: { unitId: l, subUnitId: a } }]
-    }), u;
-  }
-}, Ht = {
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const univerInstanceService = accessor.get(IUniverInstanceService), sheetsFilterService = accessor.get(SheetsFilterService), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), commandTarget = getSheetCommandTarget(univerInstanceService, params);
+    if (!commandTarget) return !1;
+    const { unitId, subUnitId } = commandTarget, filterModel = sheetsFilterService.getFilterModel(unitId, subUnitId);
+    if (!filterModel) return !1;
+    const autoFilter = filterModel == null ? void 0 : filterModel.serialize(), undoMutations = destructFilterModel(unitId, subUnitId, autoFilter), result = commandService.syncExecuteCommand(RemoveSheetsFilterMutation.id, { unitId, subUnitId });
+    return result && undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      undoMutations,
+      redoMutations: [{ id: RemoveSheetsFilterMutation.id, params: { unitId, subUnitId } }]
+    }), result;
+  }, "handler")
+}, SmartToggleSheetsFilterCommand = {
   id: "sheet.command.smart-toggle-filter",
-  type: E.COMMAND,
-  handler: async (i) => {
-    const r = i.get(x), e = i.get(M), t = i.get(T), n = r.getCurrentUnitForType(U.UNIVER_SHEET), s = n == null ? void 0 : n.getActiveSheet();
-    if (!s || !n) return !1;
-    const o = n.getUnitId(), l = s.getSheetId();
-    if (e.getFilterModel(o, l))
-      return t.executeCommand(It.id, { unitId: o, subUnitId: l });
-    const h = i.get(Ye).getCurrentLastSelection();
-    if (!h) return !1;
-    const d = h.range, u = Ke(h) ? ae(d, { left: !0, right: !0, up: !0, down: !0 }, s) : d;
-    return t.executeCommand(xt.id, {
-      unitId: o,
-      subUnitId: l,
-      range: u
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name(async (accessor) => {
+    const univerInstanceService = accessor.get(IUniverInstanceService), sheetsFilterService = accessor.get(SheetsFilterService), commandService = accessor.get(ICommandService), currentWorkbook = univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET), currentWorksheet = currentWorkbook == null ? void 0 : currentWorkbook.getActiveSheet();
+    if (!currentWorksheet || !currentWorkbook) return !1;
+    const unitId = currentWorkbook.getUnitId(), subUnitId = currentWorksheet.getSheetId();
+    if (sheetsFilterService.getFilterModel(unitId, subUnitId))
+      return commandService.executeCommand(RemoveSheetFilterCommand.id, { unitId, subUnitId });
+    const lastSelection = accessor.get(SheetsSelectionsService).getCurrentLastSelection();
+    if (!lastSelection) return !1;
+    const startRange = lastSelection.range, targetFilterRange = isSingleCellSelection(lastSelection) ? expandToContinuousRange(startRange, { left: !0, right: !0, up: !0, down: !0 }, currentWorksheet) : startRange;
+    return commandService.executeCommand(SetSheetFilterRangeCommand.id, {
+      unitId,
+      subUnitId,
+      range: targetFilterRange
     });
-  }
-}, Dt = {
+  }, "handler")
+}, SetSheetsFilterCriteriaCommand = {
   id: "sheet.command.set-filter-criteria",
-  type: E.COMMAND,
-  handler: (i, r) => {
-    const e = i.get(M), t = i.get(T), n = i.get(j), { unitId: s, subUnitId: o, col: l, criteria: a } = r, c = e.getFilterModel(s, o);
-    if (!c) return !1;
-    const h = c.getRange();
-    if (!h || l < h.startColumn || l > h.endColumn) return !1;
-    const d = c.getFilterColumn(l), u = Ut(s, o, l, d), m = {
-      id: p.id,
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const sheetsFilterService = accessor.get(SheetsFilterService), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), { unitId, subUnitId, col, criteria } = params, filterModel = sheetsFilterService.getFilterModel(unitId, subUnitId);
+    if (!filterModel) return !1;
+    const range = filterModel.getRange();
+    if (!range || col < range.startColumn || col > range.endColumn) return !1;
+    const filterColumn = filterModel.getFilterColumn(col), undoMutation = destructFilterColumn(unitId, subUnitId, col, filterColumn), redoMutation = {
+      id: SetSheetsFilterCriteriaMutation.id,
       params: {
-        unitId: s,
-        subUnitId: o,
-        col: l,
-        criteria: a
+        unitId,
+        subUnitId,
+        col,
+        criteria
       }
-    }, g = t.syncExecuteCommand(m.id, m.params);
-    return g && n.pushUndoRedo({
-      unitID: s,
-      undoMutations: [u],
-      redoMutations: [m]
-    }), g;
-  }
-}, Wt = {
+    }, result = commandService.syncExecuteCommand(redoMutation.id, redoMutation.params);
+    return result && undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      undoMutations: [undoMutation],
+      redoMutations: [redoMutation]
+    }), result;
+  }, "handler")
+}, ClearSheetsFilterCriteriaCommand = {
   id: "sheet.command.clear-filter-criteria",
-  type: E.COMMAND,
-  handler: (i, r) => {
-    const e = i.get(M), t = i.get(j), n = i.get(T), s = i.get(x), o = L(s, r);
-    if (!o) return !1;
-    const { unitId: l, subUnitId: a } = o, c = e.getFilterModel(o.unitId, o.subUnitId);
-    if (!c) return !1;
-    const h = c.serialize(), d = Ce(l, a, h), u = Pt(l, a, h);
-    return $e(u, n).result ? (t.pushUndoRedo({
-      unitID: l,
-      undoMutations: d,
-      redoMutations: u
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const sheetsFilterService = accessor.get(SheetsFilterService), undoRedoService = accessor.get(IUndoRedoService), commandService = accessor.get(ICommandService), instanceSrv = accessor.get(IUniverInstanceService), commandTarget = getSheetCommandTarget(instanceSrv, params);
+    if (!commandTarget) return !1;
+    const { unitId, subUnitId } = commandTarget, filterModel = sheetsFilterService.getFilterModel(commandTarget.unitId, commandTarget.subUnitId);
+    if (!filterModel) return !1;
+    const autoFilter = filterModel.serialize(), undoMutations = destructFilterCriteria(unitId, subUnitId, autoFilter), redoMutations = generateRemoveCriteriaMutations(unitId, subUnitId, autoFilter);
+    return sequenceExecute(redoMutations, commandService).result ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      undoMutations,
+      redoMutations
     }), !0) : !1;
-  }
-}, Vt = {
+  }, "handler")
+}, ReCalcSheetsFilterCommand = {
   id: "sheet.command.re-calc-filter",
-  type: E.COMMAND,
-  handler: (i, r) => {
-    const e = i.get(M), t = i.get(T), n = i.get(x), s = L(n, r);
-    if (!s) return !1;
-    const { unitId: o, subUnitId: l } = s;
-    return e.getFilterModel(s.unitId, s.subUnitId) ? t.executeCommand(H.id, { unitId: o, subUnitId: l }) : !1;
-  }
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const sheetsFilterService = accessor.get(SheetsFilterService), commandService = accessor.get(ICommandService), instanceSrv = accessor.get(IUniverInstanceService), commandTarget = getSheetCommandTarget(instanceSrv, params);
+    if (!commandTarget) return !1;
+    const { unitId, subUnitId } = commandTarget;
+    return sheetsFilterService.getFilterModel(commandTarget.unitId, commandTarget.subUnitId) ? commandService.executeCommand(ReCalcSheetsFilterMutation.id, { unitId, subUnitId }) : !1;
+  }, "handler")
 };
-function $t(i, r, e) {
-  const t = [], n = {
-    id: R.id,
+function destructFilterModel(unitId, subUnitId, autoFilter) {
+  const mutations = [], setFilterMutation = {
+    id: SetSheetsFilterRangeMutation.id,
     params: {
-      unitId: i,
-      subUnitId: r,
-      range: e.ref
+      unitId,
+      subUnitId,
+      range: autoFilter.ref
     }
   };
-  return t.push(n), Ce(i, r, e).forEach((o) => t.push(o)), t;
+  return mutations.push(setFilterMutation), destructFilterCriteria(unitId, subUnitId, autoFilter).forEach((m) => mutations.push(m)), mutations;
 }
-function Ce(i, r, e) {
-  var n;
-  const t = [];
-  return (n = e.filterColumns) == null || n.forEach((s) => {
-    const o = {
-      id: p.id,
+__name(destructFilterModel, "destructFilterModel");
+function destructFilterCriteria(unitId, subUnitId, autoFilter) {
+  var _a4;
+  const mutations = [];
+  return (_a4 = autoFilter.filterColumns) == null || _a4.forEach((filterColumn) => {
+    const setFilterCriteriaMutation = {
+      id: SetSheetsFilterCriteriaMutation.id,
       params: {
-        unitId: i,
-        subUnitId: r,
-        col: s.colId,
-        criteria: s
+        unitId,
+        subUnitId,
+        col: filterColumn.colId,
+        criteria: filterColumn
       }
     };
-    t.push(o);
-  }), t;
+    mutations.push(setFilterCriteriaMutation);
+  }), mutations;
 }
-function Pt(i, r, e) {
-  var n;
-  const t = [];
-  return (n = e.filterColumns) == null || n.forEach((s) => {
-    const o = {
-      id: p.id,
+__name(destructFilterCriteria, "destructFilterCriteria");
+function generateRemoveCriteriaMutations(unitId, subUnitId, autoFilter) {
+  var _a4;
+  const mutations = [];
+  return (_a4 = autoFilter.filterColumns) == null || _a4.forEach((filterColumn) => {
+    const removeFilterCriteriaMutation = {
+      id: SetSheetsFilterCriteriaMutation.id,
       params: {
-        unitId: i,
-        subUnitId: r,
-        col: s.colId,
+        unitId,
+        subUnitId,
+        col: filterColumn.colId,
         criteria: null
       }
     };
-    t.push(o);
-  }), t;
+    mutations.push(removeFilterCriteriaMutation);
+  }), mutations;
 }
-function Ut(i, r, e, t) {
-  if (!t)
+__name(generateRemoveCriteriaMutations, "generateRemoveCriteriaMutations");
+function destructFilterColumn(unitId, subUnitId, colId, filterColumn) {
+  if (!filterColumn)
     return {
-      id: p.id,
+      id: SetSheetsFilterCriteriaMutation.id,
       params: {
-        unitId: i,
-        subUnitId: r,
-        col: e,
+        unitId,
+        subUnitId,
+        col: colId,
         criteria: null
       }
     };
-  const n = t.serialize();
+  const serialize = filterColumn.serialize();
   return {
-    id: p.id,
+    id: SetSheetsFilterCriteriaMutation.id,
     params: {
-      unitId: i,
-      subUnitId: r,
-      col: e,
-      criteria: n
+      unitId,
+      subUnitId,
+      col: colId,
+      criteria: serialize
     }
   };
 }
+__name(destructFilterColumn, "destructFilterColumn");
 export {
-  Wt as ClearSheetsFilterCriteriaCommand,
-  N as CustomFilterOperator,
-  rt as FILTER_MUTATIONS,
-  ht as FilterColumn,
-  D as FilterModel,
-  Vt as ReCalcSheetsFilterCommand,
-  H as ReCalcSheetsFilterMutation,
-  It as RemoveSheetFilterCommand,
-  O as RemoveSheetsFilterMutation,
-  Re as SHEET_FILTER_SNAPSHOT_ID,
-  xt as SetSheetFilterRangeCommand,
-  Dt as SetSheetsFilterCriteriaCommand,
-  p as SetSheetsFilterCriteriaMutation,
-  R as SetSheetsFilterRangeMutation,
-  M as SheetsFilterService,
-  Ht as SmartToggleSheetsFilterCommand,
-  le as UniverSheetsFilterPlugin,
-  lt as equals,
-  ne as getCustomFilterFn,
-  nt as greaterThan,
-  it as greaterThanOrEqualTo,
-  st as lessThan,
-  ot as lessThanOrEqualTo,
-  fe as notEquals
+  ClearSheetsFilterCriteriaCommand,
+  CustomFilterOperator,
+  FILTER_MUTATIONS,
+  FilterColumn,
+  FilterModel,
+  ReCalcSheetsFilterCommand,
+  ReCalcSheetsFilterMutation,
+  RemoveSheetFilterCommand,
+  RemoveSheetsFilterMutation,
+  SHEET_FILTER_SNAPSHOT_ID,
+  SetSheetFilterRangeCommand,
+  SetSheetsFilterCriteriaCommand,
+  SetSheetsFilterCriteriaMutation,
+  SetSheetsFilterRangeMutation,
+  SheetsFilterService,
+  SmartToggleSheetsFilterCommand,
+  UniverSheetsFilterPlugin,
+  equals,
+  getCustomFilterFn,
+  greaterThan,
+  greaterThanOrEqualTo,
+  lessThan,
+  lessThanOrEqualTo,
+  notEquals
 };