@univerjs/sheets-filter 0.4.1 → 0.4.2-nightly.202410301606
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/es/facade.js +133 -0
- package/lib/es/index.js +77 -583
- package/lib/sheets-filter.command-CL_iGKJ6.mjs +713 -0
- package/lib/types/commands/commands/sheets-filter.command.d.ts +57 -0
- package/lib/types/facade/f-filter.d.ts +54 -0
- package/lib/types/facade/f-range.d.ts +25 -0
- package/lib/types/facade/f-worksheet.d.ts +9 -0
- package/lib/types/facade/index.d.ts +1 -0
- package/lib/types/index.d.ts +1 -0
- package/lib/types/models/filter-model.d.ts +1 -1
- package/lib/umd/facade.js +1 -0
- package/lib/umd/index.js +1 -1
- package/package.json +10 -13
- package/LICENSE +0 -176
- package/lib/cjs/index.js +0 -1
|
@@ -0,0 +1,713 @@
|
|
|
1
|
+
var __defProp = Object.defineProperty;
|
|
2
|
+
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
|
|
3
|
+
var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
|
|
4
|
+
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
|
|
5
|
+
import { CommandType, isNumeric, Disposable, Rectangle, mergeSets, Tools, extractPureTextFromCell, CellValueType, UniverInstanceType, fromCallback, IResourceManagerService, IUniverInstanceService, ICommandService, IUndoRedoService, ErrorService, LocaleService, sequenceExecute } from "@univerjs/core";
|
|
6
|
+
import { BehaviorSubject, merge, filter, switchMap, of } from "rxjs";
|
|
7
|
+
import { getSheetCommandTarget, SheetsSelectionsService, isSingleCellSelection, expandToContinuousRange } from "@univerjs/sheets";
|
|
8
|
+
import { SheetsFilterService as SheetsFilterService$1, SetSheetsFilterRangeMutation as SetSheetsFilterRangeMutation$1, RemoveSheetsFilterMutation as RemoveSheetsFilterMutation$1, SetSheetsFilterCriteriaMutation as SetSheetsFilterCriteriaMutation$1, ReCalcSheetsFilterMutation as ReCalcSheetsFilterMutation$1 } from "@univerjs/sheets-filter";
|
|
9
|
+
const SetSheetsFilterRangeMutation = {
|
|
10
|
+
id: "sheet.mutation.set-filter-range",
|
|
11
|
+
type: CommandType.MUTATION,
|
|
12
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
13
|
+
const { subUnitId, unitId, range } = params;
|
|
14
|
+
return accessor.get(SheetsFilterService).ensureFilterModel(unitId, subUnitId).setRange(range), !0;
|
|
15
|
+
}, "handler")
|
|
16
|
+
}, SetSheetsFilterCriteriaMutation = {
|
|
17
|
+
id: "sheet.mutation.set-filter-criteria",
|
|
18
|
+
type: CommandType.MUTATION,
|
|
19
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
20
|
+
const { subUnitId, unitId, criteria, col, reCalc = !0 } = params, filterModel = accessor.get(SheetsFilterService).getFilterModel(unitId, subUnitId);
|
|
21
|
+
return filterModel ? (filterModel.setCriteria(col, criteria, reCalc), !0) : !1;
|
|
22
|
+
}, "handler")
|
|
23
|
+
}, RemoveSheetsFilterMutation = {
|
|
24
|
+
id: "sheet.mutation.remove-filter",
|
|
25
|
+
type: CommandType.MUTATION,
|
|
26
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
27
|
+
const { unitId, subUnitId } = params;
|
|
28
|
+
return accessor.get(SheetsFilterService).removeFilterModel(unitId, subUnitId);
|
|
29
|
+
}, "handler")
|
|
30
|
+
}, ReCalcSheetsFilterMutation = {
|
|
31
|
+
id: "sheet.mutation.re-calc-filter",
|
|
32
|
+
type: CommandType.MUTATION,
|
|
33
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
34
|
+
const { unitId, subUnitId } = params, filterModel = accessor.get(SheetsFilterService).getFilterModel(unitId, subUnitId);
|
|
35
|
+
return filterModel ? (filterModel.reCalc(), !0) : !1;
|
|
36
|
+
}, "handler")
|
|
37
|
+
};
|
|
38
|
+
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 || {});
|
|
39
|
+
const greaterThan = {
|
|
40
|
+
operator: CustomFilterOperator.GREATER_THAN,
|
|
41
|
+
fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value > compare : !1, "fn")
|
|
42
|
+
}, greaterThanOrEqualTo = {
|
|
43
|
+
operator: CustomFilterOperator.GREATER_THAN_OR_EQUAL,
|
|
44
|
+
fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value >= compare : !1, "fn")
|
|
45
|
+
}, lessThan = {
|
|
46
|
+
operator: CustomFilterOperator.LESS_THAN,
|
|
47
|
+
fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value < compare : !1, "fn")
|
|
48
|
+
}, lessThanOrEqualTo = {
|
|
49
|
+
operator: CustomFilterOperator.LESS_THAN_OR_EQUAL,
|
|
50
|
+
fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value <= compare : !1, "fn")
|
|
51
|
+
}, equals = {
|
|
52
|
+
operator: CustomFilterOperator.EQUAL,
|
|
53
|
+
fn: /* @__PURE__ */ __name((value, compare) => ensureNumber(value) ? value === compare : !1, "fn")
|
|
54
|
+
}, notEquals = {
|
|
55
|
+
operator: CustomFilterOperator.NOT_EQUALS,
|
|
56
|
+
fn: /* @__PURE__ */ __name((value, compare) => {
|
|
57
|
+
if (typeof compare == "string") {
|
|
58
|
+
if (compare === " ")
|
|
59
|
+
return value != null;
|
|
60
|
+
const ensuredString = ensureString(value);
|
|
61
|
+
return ensuredString && isWildCardString(compare) ? !createREGEXFromWildChar(compare).test(ensuredString) : ensuredString !== compare;
|
|
62
|
+
}
|
|
63
|
+
return ensureNumber(value) ? value !== compare : !0;
|
|
64
|
+
}, "fn")
|
|
65
|
+
}, CustomFilterFnRegistry = /* @__PURE__ */ new Map([]), ALL_CUSTOM_FILTER_FUNCTIONS = [greaterThan, greaterThanOrEqualTo, lessThan, lessThanOrEqualTo, equals, notEquals];
|
|
66
|
+
ALL_CUSTOM_FILTER_FUNCTIONS.forEach((fn) => {
|
|
67
|
+
CustomFilterFnRegistry.set(fn.operator, fn);
|
|
68
|
+
});
|
|
69
|
+
function isNumericFilterFn(operator) {
|
|
70
|
+
return !!operator;
|
|
71
|
+
}
|
|
72
|
+
__name(isNumericFilterFn, "isNumericFilterFn");
|
|
73
|
+
const textMatch = {
|
|
74
|
+
fn: /* @__PURE__ */ __name((value, compare) => {
|
|
75
|
+
const ensured = ensureString(value);
|
|
76
|
+
return ensured === null ? compare === "" : createREGEXFromWildChar(compare).test(ensured);
|
|
77
|
+
}, "fn")
|
|
78
|
+
};
|
|
79
|
+
function getCustomFilterFn(operator) {
|
|
80
|
+
return operator ? CustomFilterFnRegistry.get(operator) : textMatch;
|
|
81
|
+
}
|
|
82
|
+
__name(getCustomFilterFn, "getCustomFilterFn");
|
|
83
|
+
function ensureNumber(value) {
|
|
84
|
+
return typeof value == "number";
|
|
85
|
+
}
|
|
86
|
+
__name(ensureNumber, "ensureNumber");
|
|
87
|
+
function ensureNumeric(value) {
|
|
88
|
+
return !!(typeof value == "number" || typeof value == "string" && isNumeric(value));
|
|
89
|
+
}
|
|
90
|
+
__name(ensureNumeric, "ensureNumeric");
|
|
91
|
+
function ensureString(value) {
|
|
92
|
+
return typeof value == "boolean" || value == null ? null : typeof value == "string" ? value : value.toString();
|
|
93
|
+
}
|
|
94
|
+
__name(ensureString, "ensureString");
|
|
95
|
+
function isWildCardString(str) {
|
|
96
|
+
return typeof str == "number" ? !1 : str.indexOf("*") !== -1 || str.indexOf("?") !== -1;
|
|
97
|
+
}
|
|
98
|
+
__name(isWildCardString, "isWildCardString");
|
|
99
|
+
function createREGEXFromWildChar(wildChar) {
|
|
100
|
+
const regexpStr = wildChar.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("?", ".").replace(/[*]/g, ".$&");
|
|
101
|
+
return new RegExp(`^${regexpStr}$`);
|
|
102
|
+
}
|
|
103
|
+
__name(createREGEXFromWildChar, "createREGEXFromWildChar");
|
|
104
|
+
const EMPTY = /* @__PURE__ */ __name(() => /* @__PURE__ */ new Set(), "EMPTY"), _FilterModel = class _FilterModel extends Disposable {
|
|
105
|
+
constructor(unitId, subUnitId, _worksheet) {
|
|
106
|
+
super();
|
|
107
|
+
__publicField(this, "_filteredOutRows$", new BehaviorSubject(EMPTY()));
|
|
108
|
+
/** An observable value. A set of filtered out rows. */
|
|
109
|
+
__publicField(this, "filteredOutRows$", this._filteredOutRows$.asObservable());
|
|
110
|
+
// TODO: we may need to update which cols have criteria rather than simple boolean
|
|
111
|
+
__publicField(this, "_hasCriteria$", new BehaviorSubject(!1));
|
|
112
|
+
__publicField(this, "hasCriteria$", this._hasCriteria$.asObservable());
|
|
113
|
+
__publicField(this, "_filterColumnByIndex", /* @__PURE__ */ new Map());
|
|
114
|
+
__publicField(this, "_alreadyFilteredOutRows", EMPTY());
|
|
115
|
+
__publicField(this, "_range");
|
|
116
|
+
this.unitId = unitId, this.subUnitId = subUnitId, this._worksheet = _worksheet;
|
|
117
|
+
}
|
|
118
|
+
get filteredOutRows() {
|
|
119
|
+
return this._filteredOutRows$.getValue();
|
|
120
|
+
}
|
|
121
|
+
set filteredOutRows(rows) {
|
|
122
|
+
this._alreadyFilteredOutRows = rows, this._filteredOutRows$.next(rows);
|
|
123
|
+
}
|
|
124
|
+
dispose() {
|
|
125
|
+
super.dispose(), this._filteredOutRows$.complete(), this._hasCriteria$.complete();
|
|
126
|
+
}
|
|
127
|
+
/**
|
|
128
|
+
* Serialize this filter model to the JSON format representation.
|
|
129
|
+
*/
|
|
130
|
+
serialize() {
|
|
131
|
+
const result = {
|
|
132
|
+
ref: Rectangle.clone(this._range),
|
|
133
|
+
filterColumns: this._getAllFilterColumns(!0).sort(([offset1], [offset2]) => offset1 - offset2).map(([_, filterColumn]) => filterColumn.serialize())
|
|
134
|
+
};
|
|
135
|
+
return this._alreadyFilteredOutRows && (result.cachedFilteredOut = Array.from(this._alreadyFilteredOutRows).sort()), result;
|
|
136
|
+
}
|
|
137
|
+
/**
|
|
138
|
+
* Deserialize auto filter info to construct a `FilterModel` object.
|
|
139
|
+
* @param unitId workbook id
|
|
140
|
+
* @param subUnitId worksheet id
|
|
141
|
+
* @param worksheet the Worksheet object
|
|
142
|
+
* @param autoFilter auto filter data
|
|
143
|
+
*/
|
|
144
|
+
static deserialize(unitId, subUnitId, worksheet, autoFilter) {
|
|
145
|
+
const filterModel = new _FilterModel(unitId, subUnitId, worksheet);
|
|
146
|
+
return filterModel._dump(autoFilter), filterModel;
|
|
147
|
+
}
|
|
148
|
+
_dump(autoFilter) {
|
|
149
|
+
var _a2;
|
|
150
|
+
this.setRange(autoFilter.ref), (_a2 = autoFilter.filterColumns) == null || _a2.forEach((filterColumn) => this._setCriteriaWithoutReCalc(filterColumn.colId, filterColumn)), autoFilter.cachedFilteredOut && (this._alreadyFilteredOutRows = new Set(autoFilter.cachedFilteredOut), this._emit()), this._emitHasCriteria();
|
|
151
|
+
}
|
|
152
|
+
isRowFiltered(row) {
|
|
153
|
+
return this._alreadyFilteredOutRows.has(row);
|
|
154
|
+
}
|
|
155
|
+
getRange() {
|
|
156
|
+
if (!this._range)
|
|
157
|
+
throw new Error("[FilterModel] could not get range before a range is set!");
|
|
158
|
+
return this._range;
|
|
159
|
+
}
|
|
160
|
+
/**
|
|
161
|
+
* Get filtered out rows except the specific column. This method is considered as "pure". In
|
|
162
|
+
* another word it would not change `filteredOutRows` on `FilterModel` nor `FilterColumn`.
|
|
163
|
+
* @param col
|
|
164
|
+
*/
|
|
165
|
+
getFilteredOutRowsExceptCol(col) {
|
|
166
|
+
return this._getAllFilterColumns(!0).filter(([colOffset]) => colOffset !== col).reduce((acc, [, filterColumn]) => {
|
|
167
|
+
const newResult = filterColumn.calc({ getAlreadyFilteredOutRows: /* @__PURE__ */ __name(() => acc, "getAlreadyFilteredOutRows") });
|
|
168
|
+
return newResult ? mergeSets(acc, newResult) : acc;
|
|
169
|
+
}, /* @__PURE__ */ new Set());
|
|
170
|
+
}
|
|
171
|
+
/**
|
|
172
|
+
* Set range of the filter model, this would remove some `IFilterColumn`
|
|
173
|
+
* if the new range not overlaps the old range.
|
|
174
|
+
*/
|
|
175
|
+
setRange(range) {
|
|
176
|
+
this._range = range, this._getAllFilterColumns(!0).forEach(([col, filterColumn]) => {
|
|
177
|
+
filterColumn.setRangeAndColumn({
|
|
178
|
+
startRow: range.startRow,
|
|
179
|
+
endRow: range.endRow,
|
|
180
|
+
startColumn: col,
|
|
181
|
+
endColumn: col
|
|
182
|
+
}, col);
|
|
183
|
+
});
|
|
184
|
+
}
|
|
185
|
+
/**
|
|
186
|
+
* Set or remove filter criteria on a specific row.
|
|
187
|
+
*/
|
|
188
|
+
setCriteria(col, criteria, reCalc = !1) {
|
|
189
|
+
if (!this._range)
|
|
190
|
+
throw new Error("[FilterModel] could not set criteria before a range is set!");
|
|
191
|
+
if (!criteria) {
|
|
192
|
+
this._removeCriteria(col), this._rebuildAlreadyFilteredOutRowsWithCache(), reCalc && this._reCalcAllColumns(), this._emit(), this._emitHasCriteria();
|
|
193
|
+
return;
|
|
194
|
+
}
|
|
195
|
+
this._setCriteriaWithoutReCalc(col, criteria), reCalc && (this._rebuildAlreadyFilteredOutRowsWithCache(), this._reCalcWithNoCacheColumns(), this._emit(), this._emitHasCriteria());
|
|
196
|
+
}
|
|
197
|
+
getAllFilterColumns() {
|
|
198
|
+
return this._getAllFilterColumns(!0);
|
|
199
|
+
}
|
|
200
|
+
getFilterColumn(index) {
|
|
201
|
+
var _a2;
|
|
202
|
+
return (_a2 = this._filterColumnByIndex.get(index)) != null ? _a2 : null;
|
|
203
|
+
}
|
|
204
|
+
reCalc() {
|
|
205
|
+
this._reCalcAllColumns(), this._emit();
|
|
206
|
+
}
|
|
207
|
+
_getAllFilterColumns(withCol = !1) {
|
|
208
|
+
const columns = Array.from(this._filterColumnByIndex.entries());
|
|
209
|
+
return withCol ? columns : columns.map(([_, filterColumn]) => filterColumn);
|
|
210
|
+
}
|
|
211
|
+
_reCalcAllColumns() {
|
|
212
|
+
this._alreadyFilteredOutRows = EMPTY(), this._getAllFilterColumns().forEach((filterColumn) => filterColumn.__clearCache()), this._reCalcWithNoCacheColumns();
|
|
213
|
+
}
|
|
214
|
+
_setCriteriaWithoutReCalc(col, criteria) {
|
|
215
|
+
const range = this._range;
|
|
216
|
+
if (!range)
|
|
217
|
+
throw new Error("[FilterModel] could not set criteria before a range is set!");
|
|
218
|
+
const { startColumn, endColumn } = range;
|
|
219
|
+
if (col > endColumn || col < startColumn)
|
|
220
|
+
throw new Error(`[FilterModel] could not set criteria on column ${col} which is out of range!`);
|
|
221
|
+
let filterColumn;
|
|
222
|
+
this._filterColumnByIndex.has(col) ? filterColumn = this._filterColumnByIndex.get(col) : (filterColumn = new FilterColumn(
|
|
223
|
+
this.unitId,
|
|
224
|
+
this.subUnitId,
|
|
225
|
+
this._worksheet,
|
|
226
|
+
criteria,
|
|
227
|
+
{ getAlreadyFilteredOutRows: /* @__PURE__ */ __name(() => this._alreadyFilteredOutRows, "getAlreadyFilteredOutRows") }
|
|
228
|
+
), filterColumn.setRangeAndColumn(range, col), this._filterColumnByIndex.set(col, filterColumn)), filterColumn.setCriteria(criteria);
|
|
229
|
+
}
|
|
230
|
+
_removeCriteria(col) {
|
|
231
|
+
const filterColumn = this._filterColumnByIndex.get(col);
|
|
232
|
+
filterColumn && (filterColumn.dispose(), this._filterColumnByIndex.delete(col));
|
|
233
|
+
}
|
|
234
|
+
_emit() {
|
|
235
|
+
this._filteredOutRows$.next(this._alreadyFilteredOutRows);
|
|
236
|
+
}
|
|
237
|
+
_emitHasCriteria() {
|
|
238
|
+
this._hasCriteria$.next(this._filterColumnByIndex.size > 0);
|
|
239
|
+
}
|
|
240
|
+
_rebuildAlreadyFilteredOutRowsWithCache() {
|
|
241
|
+
const newFilteredOutRows = this._getAllFilterColumns().filter((filterColumn) => filterColumn.hasCache()).reduce((acc, filterColumn) => mergeSets(acc, filterColumn.filteredOutRows), /* @__PURE__ */ new Set());
|
|
242
|
+
this._alreadyFilteredOutRows = newFilteredOutRows;
|
|
243
|
+
}
|
|
244
|
+
_reCalcWithNoCacheColumns() {
|
|
245
|
+
const noCacheFilteredOutRows = this._getAllFilterColumns().filter((filterColumn) => !filterColumn.hasCache());
|
|
246
|
+
for (const filterColumn of noCacheFilteredOutRows) {
|
|
247
|
+
const filteredRows = filterColumn.reCalc();
|
|
248
|
+
filteredRows && (this._alreadyFilteredOutRows = mergeSets(this._alreadyFilteredOutRows, filteredRows));
|
|
249
|
+
}
|
|
250
|
+
}
|
|
251
|
+
};
|
|
252
|
+
__name(_FilterModel, "FilterModel");
|
|
253
|
+
let FilterModel = _FilterModel;
|
|
254
|
+
const _FilterColumn = class _FilterColumn extends Disposable {
|
|
255
|
+
constructor(unitId, subUnitId, _worksheet, _criteria, _filterColumnContext) {
|
|
256
|
+
super();
|
|
257
|
+
__publicField(this, "_filteredOutRows", null);
|
|
258
|
+
/** Cache the filter function. */
|
|
259
|
+
__publicField(this, "_filterFn", null);
|
|
260
|
+
__publicField(this, "_range", null);
|
|
261
|
+
__publicField(this, "_column", 0);
|
|
262
|
+
__publicField(this, "_filterByValues", !1);
|
|
263
|
+
this.unitId = unitId, this.subUnitId = subUnitId, this._worksheet = _worksheet, this._criteria = _criteria, this._filterColumnContext = _filterColumnContext;
|
|
264
|
+
}
|
|
265
|
+
get filteredOutRows() {
|
|
266
|
+
return this._filteredOutRows;
|
|
267
|
+
}
|
|
268
|
+
dispose() {
|
|
269
|
+
super.dispose(), this._filteredOutRows = null;
|
|
270
|
+
}
|
|
271
|
+
/**
|
|
272
|
+
* @internal
|
|
273
|
+
*/
|
|
274
|
+
__clearCache() {
|
|
275
|
+
this._filteredOutRows = null;
|
|
276
|
+
}
|
|
277
|
+
serialize() {
|
|
278
|
+
if (!this._criteria)
|
|
279
|
+
throw new Error("[FilterColumn]: could not serialize without a filter column!");
|
|
280
|
+
return Tools.deepClone({
|
|
281
|
+
...this._criteria,
|
|
282
|
+
colId: this._column
|
|
283
|
+
});
|
|
284
|
+
}
|
|
285
|
+
hasCache() {
|
|
286
|
+
return this._filteredOutRows !== null;
|
|
287
|
+
}
|
|
288
|
+
// The first row should be omitted!
|
|
289
|
+
setRangeAndColumn(range, column) {
|
|
290
|
+
this._range = range, this._column = column;
|
|
291
|
+
}
|
|
292
|
+
setCriteria(criteria) {
|
|
293
|
+
this._criteria = criteria, this._generateFilterFn(), this._filteredOutRows = null;
|
|
294
|
+
}
|
|
295
|
+
getColumnData() {
|
|
296
|
+
return Tools.deepClone(this._criteria);
|
|
297
|
+
}
|
|
298
|
+
/**
|
|
299
|
+
* Trigger new calculation on this `FilterModel` instance.
|
|
300
|
+
*
|
|
301
|
+
* @external DO NOT EVER call this method from `FilterColumn` itself. The whole process heavily relies on
|
|
302
|
+
* `filteredOutByOthers`, and it is more comprehensible if we let `FilterModel` take full control over the process.
|
|
303
|
+
*/
|
|
304
|
+
reCalc() {
|
|
305
|
+
return this._filteredOutRows = this.calc(this._filterColumnContext), this._filteredOutRows;
|
|
306
|
+
}
|
|
307
|
+
calc(context) {
|
|
308
|
+
if (!this._filterFn)
|
|
309
|
+
throw new Error("[FilterColumn] cannot calculate without a filter fn!");
|
|
310
|
+
if (!this._range)
|
|
311
|
+
throw new Error("[FilterColumn] cannot calculate without a range!");
|
|
312
|
+
if (typeof this._column != "number")
|
|
313
|
+
throw new TypeError("[FilterColumn] cannot calculate without a column offset!");
|
|
314
|
+
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();
|
|
315
|
+
for (const range of this._worksheet.iterateByColumn(iterateRange, !1, !1)) {
|
|
316
|
+
const { row, rowSpan, col } = range;
|
|
317
|
+
if (filteredOutByOthers.has(row) && (!rowSpan || rowSpan === 1))
|
|
318
|
+
continue;
|
|
319
|
+
const value = this._filterByValues ? extractPureTextFromCell(this._worksheet.getCell(row, col)) : getFilterValueForConditionalFiltering(this._worksheet, row, col);
|
|
320
|
+
if (!this._filterFn(value) && (filteredOutRows.add(row), rowSpan))
|
|
321
|
+
for (let i = 1; i < rowSpan; i++)
|
|
322
|
+
filteredOutRows.add(row + i);
|
|
323
|
+
}
|
|
324
|
+
return filteredOutRows;
|
|
325
|
+
}
|
|
326
|
+
_generateFilterFn() {
|
|
327
|
+
this._criteria && (this._filterFn = generateFilterFn(this._criteria), this._filterByValues = !!this._criteria.filters);
|
|
328
|
+
}
|
|
329
|
+
};
|
|
330
|
+
__name(_FilterColumn, "FilterColumn");
|
|
331
|
+
let FilterColumn = _FilterColumn;
|
|
332
|
+
function generateFilterFn(column) {
|
|
333
|
+
if (column.filters)
|
|
334
|
+
return filterByValuesFnFactory(column.filters);
|
|
335
|
+
if (column.customFilters)
|
|
336
|
+
return customFilterFnFactory(column.customFilters);
|
|
337
|
+
throw new Error("[FilterModel]: other types of filters are not supported yet.");
|
|
338
|
+
}
|
|
339
|
+
__name(generateFilterFn, "generateFilterFn");
|
|
340
|
+
function filterByValuesFnFactory(values) {
|
|
341
|
+
const includeBlank = !!values.blank, valuesSet = new Set(values.filters);
|
|
342
|
+
return (value) => value === void 0 || value === "" ? includeBlank : valuesSet.has(typeof value == "string" ? value : `${value}`);
|
|
343
|
+
}
|
|
344
|
+
__name(filterByValuesFnFactory, "filterByValuesFnFactory");
|
|
345
|
+
function customFilterFnFactory(customFilters) {
|
|
346
|
+
const customFilterFns = customFilters.customFilters.map((filter2) => generateCustomFilterFn(filter2));
|
|
347
|
+
return isCompoundCustomFilter(customFilterFns) ? customFilters.and ? AND(customFilterFns) : OR(customFilterFns) : customFilterFns[0];
|
|
348
|
+
}
|
|
349
|
+
__name(customFilterFnFactory, "customFilterFnFactory");
|
|
350
|
+
function AND(filterFns) {
|
|
351
|
+
const [fn1, fn2] = filterFns;
|
|
352
|
+
return (value) => fn1(value) && fn2(value);
|
|
353
|
+
}
|
|
354
|
+
__name(AND, "AND");
|
|
355
|
+
function OR(filterFns) {
|
|
356
|
+
const [fn1, fn2] = filterFns;
|
|
357
|
+
return (value) => fn1(value) || fn2(value);
|
|
358
|
+
}
|
|
359
|
+
__name(OR, "OR");
|
|
360
|
+
function isCompoundCustomFilter(filter2) {
|
|
361
|
+
return filter2.length === 2;
|
|
362
|
+
}
|
|
363
|
+
__name(isCompoundCustomFilter, "isCompoundCustomFilter");
|
|
364
|
+
function generateCustomFilterFn(filter2) {
|
|
365
|
+
const compare = filter2.val;
|
|
366
|
+
if (filter2.operator === CustomFilterOperator.NOT_EQUALS && !ensureNumeric(compare))
|
|
367
|
+
return (value) => notEquals.fn(value, compare);
|
|
368
|
+
if (isNumericFilterFn(filter2.operator)) {
|
|
369
|
+
if (!ensureNumeric(compare)) return () => !1;
|
|
370
|
+
const customFilterFn2 = getCustomFilterFn(filter2.operator), ensuredNumber = Number(compare);
|
|
371
|
+
return (value) => customFilterFn2.fn(value, ensuredNumber);
|
|
372
|
+
}
|
|
373
|
+
const customFilterFn = getCustomFilterFn(filter2.operator);
|
|
374
|
+
return (value) => customFilterFn.fn(value, compare);
|
|
375
|
+
}
|
|
376
|
+
__name(generateCustomFilterFn, "generateCustomFilterFn");
|
|
377
|
+
function getFilterValueForConditionalFiltering(worksheet, row, col) {
|
|
378
|
+
const interceptedCell = worksheet.getCell(row, col);
|
|
379
|
+
if (!interceptedCell) return null;
|
|
380
|
+
const rawCell = worksheet.getCellRaw(row, col);
|
|
381
|
+
return interceptedCell && !rawCell ? extractFilterValueFromCell(interceptedCell) : rawCell ? interceptedCell.t === CellValueType.NUMBER && typeof interceptedCell.v == "string" ? rawCell.v : extractFilterValueFromCell(rawCell) : null;
|
|
382
|
+
}
|
|
383
|
+
__name(getFilterValueForConditionalFiltering, "getFilterValueForConditionalFiltering");
|
|
384
|
+
function extractFilterValueFromCell(cell) {
|
|
385
|
+
var _a2, _b;
|
|
386
|
+
const richTextValue = (_b = (_a2 = cell.p) == null ? void 0 : _a2.body) == null ? void 0 : _b.dataStream;
|
|
387
|
+
if (richTextValue) return richTextValue.trimEnd();
|
|
388
|
+
const rawValue = cell.v;
|
|
389
|
+
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" : "";
|
|
390
|
+
}
|
|
391
|
+
__name(extractFilterValueFromCell, "extractFilterValueFromCell");
|
|
392
|
+
var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
|
|
393
|
+
for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
|
|
394
|
+
(decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
|
|
395
|
+
return kind && result && __defProp2(target, key, result), result;
|
|
396
|
+
}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam");
|
|
397
|
+
const FILTER_MUTATIONS = /* @__PURE__ */ new Set([
|
|
398
|
+
SetSheetsFilterRangeMutation.id,
|
|
399
|
+
SetSheetsFilterCriteriaMutation.id,
|
|
400
|
+
RemoveSheetsFilterMutation.id,
|
|
401
|
+
ReCalcSheetsFilterMutation.id
|
|
402
|
+
]), SHEET_FILTER_SNAPSHOT_ID = "SHEET_FILTER_PLUGIN";
|
|
403
|
+
var _a;
|
|
404
|
+
let SheetsFilterService = (_a = class extends Disposable {
|
|
405
|
+
constructor(_resourcesManagerService, _univerInstanceService, _commandService) {
|
|
406
|
+
super();
|
|
407
|
+
__publicField(this, "_filterModels", /* @__PURE__ */ new Map());
|
|
408
|
+
__publicField(this, "_loadedUnitId$", new BehaviorSubject(null));
|
|
409
|
+
__publicField(this, "loadedUnitId$", this._loadedUnitId$.asObservable());
|
|
410
|
+
__publicField(this, "_errorMsg$", new BehaviorSubject(null));
|
|
411
|
+
__publicField(this, "errorMsg$", this._errorMsg$.asObservable());
|
|
412
|
+
__publicField(this, "_activeFilterModel$", new BehaviorSubject(null));
|
|
413
|
+
/** An observable value emitting the current Workbook's active Worksheet's filter model (if there is one). */
|
|
414
|
+
__publicField(this, "activeFilterModel$", this._activeFilterModel$.asObservable());
|
|
415
|
+
this._resourcesManagerService = _resourcesManagerService, this._univerInstanceService = _univerInstanceService, this._commandService = _commandService, this._initModel(), this._initActiveFilterModel();
|
|
416
|
+
}
|
|
417
|
+
/** The current Workbook's active Worksheet's filter model (if there is one). */
|
|
418
|
+
get activeFilterModel() {
|
|
419
|
+
return this._activeFilterModel$.getValue();
|
|
420
|
+
}
|
|
421
|
+
/**
|
|
422
|
+
*
|
|
423
|
+
* @param unitId
|
|
424
|
+
* @param subUnitId
|
|
425
|
+
*/
|
|
426
|
+
ensureFilterModel(unitId, subUnitId) {
|
|
427
|
+
const already = this.getFilterModel(unitId, subUnitId);
|
|
428
|
+
if (already)
|
|
429
|
+
return already;
|
|
430
|
+
const workbook = this._univerInstanceService.getUniverSheetInstance(unitId);
|
|
431
|
+
if (!workbook)
|
|
432
|
+
throw new Error(`[SheetsFilterService]: could not create "FilterModel" on a non-existing workbook ${unitId}!`);
|
|
433
|
+
const worksheet = workbook.getSheetBySheetId(subUnitId);
|
|
434
|
+
if (!worksheet)
|
|
435
|
+
throw new Error(`[SheetsFilterService]: could not create "FilterModel" on a non-existing worksheet ${subUnitId}!`);
|
|
436
|
+
const filterModel = new FilterModel(unitId, subUnitId, worksheet);
|
|
437
|
+
return this._cacheFilterModel(unitId, subUnitId, filterModel), filterModel;
|
|
438
|
+
}
|
|
439
|
+
getFilterModel(unitId, subUnitId) {
|
|
440
|
+
var _a2, _b;
|
|
441
|
+
return (_b = (_a2 = this._filterModels.get(unitId)) == null ? void 0 : _a2.get(subUnitId)) != null ? _b : null;
|
|
442
|
+
}
|
|
443
|
+
removeFilterModel(unitId, subUnitId) {
|
|
444
|
+
const already = this.getFilterModel(unitId, subUnitId);
|
|
445
|
+
return already ? (already.dispose(), this._filterModels.get(unitId).delete(subUnitId), !0) : !1;
|
|
446
|
+
}
|
|
447
|
+
setFilterErrorMsg(content) {
|
|
448
|
+
this._errorMsg$.next(content);
|
|
449
|
+
}
|
|
450
|
+
_updateActiveFilterModel() {
|
|
451
|
+
let workbook;
|
|
452
|
+
try {
|
|
453
|
+
if (workbook = this._univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET), !workbook) {
|
|
454
|
+
this._activeFilterModel$.next(null);
|
|
455
|
+
return;
|
|
456
|
+
}
|
|
457
|
+
} catch (err) {
|
|
458
|
+
console.error("[SheetsFilterService]: could not get active workbook!", err);
|
|
459
|
+
return;
|
|
460
|
+
}
|
|
461
|
+
const activeSheet = workbook.getActiveSheet(!0);
|
|
462
|
+
if (!activeSheet) {
|
|
463
|
+
this._activeFilterModel$.next(null);
|
|
464
|
+
return;
|
|
465
|
+
}
|
|
466
|
+
const unitId = activeSheet.getUnitId(), subUnitId = activeSheet.getSheetId(), filterModel = this.getFilterModel(unitId, subUnitId);
|
|
467
|
+
this._activeFilterModel$.next(filterModel);
|
|
468
|
+
}
|
|
469
|
+
_initActiveFilterModel() {
|
|
470
|
+
this.disposeWithMe(
|
|
471
|
+
merge(
|
|
472
|
+
// source1: executing filter related mutations
|
|
473
|
+
fromCallback(this._commandService.onCommandExecuted.bind(this._commandService)).pipe(filter(([command]) => command.type === CommandType.MUTATION && FILTER_MUTATIONS.has(command.id))),
|
|
474
|
+
// source2: activate sheet changes
|
|
475
|
+
this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET).pipe(switchMap((workbook) => {
|
|
476
|
+
var _a2;
|
|
477
|
+
return (_a2 = workbook == null ? void 0 : workbook.activeSheet$) != null ? _a2 : of(null);
|
|
478
|
+
}))
|
|
479
|
+
).subscribe(() => this._updateActiveFilterModel())
|
|
480
|
+
);
|
|
481
|
+
}
|
|
482
|
+
_serializeAutoFiltersForUnit(unitId) {
|
|
483
|
+
const allFilterModels = this._filterModels.get(unitId);
|
|
484
|
+
if (!allFilterModels)
|
|
485
|
+
return "{}";
|
|
486
|
+
const json = {};
|
|
487
|
+
return allFilterModels.forEach((model, worksheetId) => {
|
|
488
|
+
json[worksheetId] = model.serialize();
|
|
489
|
+
}), JSON.stringify(json);
|
|
490
|
+
}
|
|
491
|
+
_deserializeAutoFiltersForUnit(unitId, json) {
|
|
492
|
+
const workbook = this._univerInstanceService.getUniverSheetInstance(unitId);
|
|
493
|
+
Object.keys(json).forEach((worksheetId) => {
|
|
494
|
+
const autoFilter = json[worksheetId], filterModel = FilterModel.deserialize(unitId, worksheetId, workbook.getSheetBySheetId(worksheetId), autoFilter);
|
|
495
|
+
this._cacheFilterModel(unitId, worksheetId, filterModel);
|
|
496
|
+
});
|
|
497
|
+
}
|
|
498
|
+
_initModel() {
|
|
499
|
+
this._resourcesManagerService.registerPluginResource({
|
|
500
|
+
pluginName: SHEET_FILTER_SNAPSHOT_ID,
|
|
501
|
+
businesses: [UniverInstanceType.UNIVER_SHEET],
|
|
502
|
+
toJson: /* @__PURE__ */ __name((id) => this._serializeAutoFiltersForUnit(id), "toJson"),
|
|
503
|
+
parseJson: /* @__PURE__ */ __name((json) => JSON.parse(json), "parseJson"),
|
|
504
|
+
onLoad: /* @__PURE__ */ __name((unitId, value) => {
|
|
505
|
+
this._deserializeAutoFiltersForUnit(unitId, value), this._loadedUnitId$.next(unitId), this._updateActiveFilterModel();
|
|
506
|
+
}, "onLoad"),
|
|
507
|
+
onUnLoad: /* @__PURE__ */ __name((unitId) => {
|
|
508
|
+
const allFilterModels = this._filterModels.get(unitId);
|
|
509
|
+
allFilterModels && (allFilterModels.forEach((model) => model.dispose()), this._filterModels.delete(unitId));
|
|
510
|
+
}, "onUnLoad")
|
|
511
|
+
});
|
|
512
|
+
}
|
|
513
|
+
_cacheFilterModel(unitId, subUnitId, filterModel) {
|
|
514
|
+
this._filterModels.has(unitId) || this._filterModels.set(unitId, /* @__PURE__ */ new Map()), this._filterModels.get(unitId).set(subUnitId, filterModel);
|
|
515
|
+
}
|
|
516
|
+
}, __name(_a, "SheetsFilterService"), _a);
|
|
517
|
+
SheetsFilterService = __decorateClass([
|
|
518
|
+
__decorateParam(0, IResourceManagerService),
|
|
519
|
+
__decorateParam(1, IUniverInstanceService),
|
|
520
|
+
__decorateParam(2, ICommandService)
|
|
521
|
+
], SheetsFilterService);
|
|
522
|
+
const SetSheetFilterRangeCommand = {
|
|
523
|
+
id: "sheet.command.set-filter-range",
|
|
524
|
+
type: CommandType.COMMAND,
|
|
525
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
526
|
+
const sheetsFilterService = accessor.get(SheetsFilterService$1), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), instanceSrv = accessor.get(IUniverInstanceService), { unitId, subUnitId, range } = params;
|
|
527
|
+
if (!getSheetCommandTarget(instanceSrv, params) || sheetsFilterService.getFilterModel(unitId, subUnitId)) return !1;
|
|
528
|
+
if (range.endRow === range.startRow) {
|
|
529
|
+
const errorService = accessor.get(ErrorService), localeService = accessor.get(LocaleService);
|
|
530
|
+
return errorService.emit(localeService.t("sheets-filter.command.not-valid-filter-range")), !1;
|
|
531
|
+
}
|
|
532
|
+
const redoMutation = { id: SetSheetsFilterRangeMutation$1.id, params: { unitId, subUnitId, range } }, result = commandService.syncExecuteCommand(redoMutation.id, redoMutation.params);
|
|
533
|
+
return result && undoRedoService.pushUndoRedo({
|
|
534
|
+
unitID: unitId,
|
|
535
|
+
undoMutations: [{ id: RemoveSheetsFilterMutation$1.id, params: { unitId, subUnitId } }],
|
|
536
|
+
redoMutations: [redoMutation]
|
|
537
|
+
}), result;
|
|
538
|
+
}, "handler")
|
|
539
|
+
}, RemoveSheetFilterCommand = {
|
|
540
|
+
id: "sheet.command.remove-sheet-filter",
|
|
541
|
+
type: CommandType.COMMAND,
|
|
542
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
543
|
+
const univerInstanceService = accessor.get(IUniverInstanceService), sheetsFilterService = accessor.get(SheetsFilterService$1), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), commandTarget = getSheetCommandTarget(univerInstanceService, params);
|
|
544
|
+
if (!commandTarget) return !1;
|
|
545
|
+
const { unitId, subUnitId } = commandTarget, filterModel = sheetsFilterService.getFilterModel(unitId, subUnitId);
|
|
546
|
+
if (!filterModel) return !1;
|
|
547
|
+
const autoFilter = filterModel == null ? void 0 : filterModel.serialize(), undoMutations = destructFilterModel(unitId, subUnitId, autoFilter), result = commandService.syncExecuteCommand(RemoveSheetsFilterMutation$1.id, { unitId, subUnitId });
|
|
548
|
+
return result && undoRedoService.pushUndoRedo({
|
|
549
|
+
unitID: unitId,
|
|
550
|
+
undoMutations,
|
|
551
|
+
redoMutations: [{ id: RemoveSheetsFilterMutation$1.id, params: { unitId, subUnitId } }]
|
|
552
|
+
}), result;
|
|
553
|
+
}, "handler")
|
|
554
|
+
}, SmartToggleSheetsFilterCommand = {
|
|
555
|
+
id: "sheet.command.smart-toggle-filter",
|
|
556
|
+
type: CommandType.COMMAND,
|
|
557
|
+
handler: /* @__PURE__ */ __name(async (accessor) => {
|
|
558
|
+
const univerInstanceService = accessor.get(IUniverInstanceService), sheetsFilterService = accessor.get(SheetsFilterService$1), commandService = accessor.get(ICommandService), currentWorkbook = univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET), currentWorksheet = currentWorkbook == null ? void 0 : currentWorkbook.getActiveSheet();
|
|
559
|
+
if (!currentWorksheet || !currentWorkbook) return !1;
|
|
560
|
+
const unitId = currentWorkbook.getUnitId(), subUnitId = currentWorksheet.getSheetId();
|
|
561
|
+
if (sheetsFilterService.getFilterModel(unitId, subUnitId))
|
|
562
|
+
return commandService.executeCommand(RemoveSheetFilterCommand.id, { unitId, subUnitId });
|
|
563
|
+
const lastSelection = accessor.get(SheetsSelectionsService).getCurrentLastSelection();
|
|
564
|
+
if (!lastSelection) return !1;
|
|
565
|
+
const startRange = lastSelection.range, targetFilterRange = isSingleCellSelection(lastSelection) ? expandToContinuousRange(startRange, { left: !0, right: !0, up: !0, down: !0 }, currentWorksheet) : startRange;
|
|
566
|
+
return commandService.executeCommand(SetSheetFilterRangeCommand.id, {
|
|
567
|
+
unitId,
|
|
568
|
+
subUnitId,
|
|
569
|
+
range: targetFilterRange
|
|
570
|
+
});
|
|
571
|
+
}, "handler")
|
|
572
|
+
}, SetSheetsFilterCriteriaCommand = {
|
|
573
|
+
id: "sheet.command.set-filter-criteria",
|
|
574
|
+
type: CommandType.COMMAND,
|
|
575
|
+
handler: /* @__PURE__ */ __name(async (accessor, params) => {
|
|
576
|
+
const sheetsFilterService = accessor.get(SheetsFilterService$1), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), { unitId, subUnitId, col, criteria } = params, filterModel = sheetsFilterService.getFilterModel(unitId, subUnitId);
|
|
577
|
+
if (!filterModel) return !1;
|
|
578
|
+
const range = filterModel.getRange();
|
|
579
|
+
if (!range || col < range.startColumn || col > range.endColumn) return !1;
|
|
580
|
+
const filterColumn = filterModel.getFilterColumn(col), undoMutation = destructFilterColumn(unitId, subUnitId, col, filterColumn), redoMutation = {
|
|
581
|
+
id: SetSheetsFilterCriteriaMutation$1.id,
|
|
582
|
+
params: {
|
|
583
|
+
unitId,
|
|
584
|
+
subUnitId,
|
|
585
|
+
col,
|
|
586
|
+
criteria
|
|
587
|
+
}
|
|
588
|
+
}, result = commandService.syncExecuteCommand(redoMutation.id, redoMutation.params);
|
|
589
|
+
return result && undoRedoService.pushUndoRedo({
|
|
590
|
+
unitID: unitId,
|
|
591
|
+
undoMutations: [undoMutation],
|
|
592
|
+
redoMutations: [redoMutation]
|
|
593
|
+
}), result;
|
|
594
|
+
}, "handler")
|
|
595
|
+
}, ClearSheetsFilterCriteriaCommand = {
|
|
596
|
+
id: "sheet.command.clear-filter-criteria",
|
|
597
|
+
type: CommandType.COMMAND,
|
|
598
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
599
|
+
const sheetsFilterService = accessor.get(SheetsFilterService$1), undoRedoService = accessor.get(IUndoRedoService), commandService = accessor.get(ICommandService), instanceSrv = accessor.get(IUniverInstanceService), commandTarget = getSheetCommandTarget(instanceSrv, params);
|
|
600
|
+
if (!commandTarget) return !1;
|
|
601
|
+
const { unitId, subUnitId } = commandTarget, filterModel = sheetsFilterService.getFilterModel(commandTarget.unitId, commandTarget.subUnitId);
|
|
602
|
+
if (!filterModel) return !1;
|
|
603
|
+
const autoFilter = filterModel.serialize(), undoMutations = destructFilterCriteria(unitId, subUnitId, autoFilter), redoMutations = generateRemoveCriteriaMutations(unitId, subUnitId, autoFilter);
|
|
604
|
+
return sequenceExecute(redoMutations, commandService).result ? (undoRedoService.pushUndoRedo({
|
|
605
|
+
unitID: unitId,
|
|
606
|
+
undoMutations,
|
|
607
|
+
redoMutations
|
|
608
|
+
}), !0) : !1;
|
|
609
|
+
}, "handler")
|
|
610
|
+
}, ReCalcSheetsFilterCommand = {
|
|
611
|
+
id: "sheet.command.re-calc-filter",
|
|
612
|
+
type: CommandType.COMMAND,
|
|
613
|
+
handler: /* @__PURE__ */ __name((accessor, params) => {
|
|
614
|
+
const sheetsFilterService = accessor.get(SheetsFilterService$1), commandService = accessor.get(ICommandService), instanceSrv = accessor.get(IUniverInstanceService), commandTarget = getSheetCommandTarget(instanceSrv, params);
|
|
615
|
+
if (!commandTarget) return !1;
|
|
616
|
+
const { unitId, subUnitId } = commandTarget;
|
|
617
|
+
return sheetsFilterService.getFilterModel(commandTarget.unitId, commandTarget.subUnitId) ? commandService.executeCommand(ReCalcSheetsFilterMutation$1.id, { unitId, subUnitId }) : !1;
|
|
618
|
+
}, "handler")
|
|
619
|
+
};
|
|
620
|
+
function destructFilterModel(unitId, subUnitId, autoFilter) {
|
|
621
|
+
const mutations = [], setFilterMutation = {
|
|
622
|
+
id: SetSheetsFilterRangeMutation$1.id,
|
|
623
|
+
params: {
|
|
624
|
+
unitId,
|
|
625
|
+
subUnitId,
|
|
626
|
+
range: autoFilter.ref
|
|
627
|
+
}
|
|
628
|
+
};
|
|
629
|
+
return mutations.push(setFilterMutation), destructFilterCriteria(unitId, subUnitId, autoFilter).forEach((m) => mutations.push(m)), mutations;
|
|
630
|
+
}
|
|
631
|
+
__name(destructFilterModel, "destructFilterModel");
|
|
632
|
+
function destructFilterCriteria(unitId, subUnitId, autoFilter) {
|
|
633
|
+
var _a2;
|
|
634
|
+
const mutations = [];
|
|
635
|
+
return (_a2 = autoFilter.filterColumns) == null || _a2.forEach((filterColumn) => {
|
|
636
|
+
const setFilterCriteriaMutation = {
|
|
637
|
+
id: SetSheetsFilterCriteriaMutation$1.id,
|
|
638
|
+
params: {
|
|
639
|
+
unitId,
|
|
640
|
+
subUnitId,
|
|
641
|
+
col: filterColumn.colId,
|
|
642
|
+
criteria: filterColumn
|
|
643
|
+
}
|
|
644
|
+
};
|
|
645
|
+
mutations.push(setFilterCriteriaMutation);
|
|
646
|
+
}), mutations;
|
|
647
|
+
}
|
|
648
|
+
__name(destructFilterCriteria, "destructFilterCriteria");
|
|
649
|
+
function generateRemoveCriteriaMutations(unitId, subUnitId, autoFilter) {
|
|
650
|
+
var _a2;
|
|
651
|
+
const mutations = [];
|
|
652
|
+
return (_a2 = autoFilter.filterColumns) == null || _a2.forEach((filterColumn) => {
|
|
653
|
+
const removeFilterCriteriaMutation = {
|
|
654
|
+
id: SetSheetsFilterCriteriaMutation$1.id,
|
|
655
|
+
params: {
|
|
656
|
+
unitId,
|
|
657
|
+
subUnitId,
|
|
658
|
+
col: filterColumn.colId,
|
|
659
|
+
criteria: null
|
|
660
|
+
}
|
|
661
|
+
};
|
|
662
|
+
mutations.push(removeFilterCriteriaMutation);
|
|
663
|
+
}), mutations;
|
|
664
|
+
}
|
|
665
|
+
__name(generateRemoveCriteriaMutations, "generateRemoveCriteriaMutations");
|
|
666
|
+
function destructFilterColumn(unitId, subUnitId, colId, filterColumn) {
|
|
667
|
+
if (!filterColumn)
|
|
668
|
+
return {
|
|
669
|
+
id: SetSheetsFilterCriteriaMutation$1.id,
|
|
670
|
+
params: {
|
|
671
|
+
unitId,
|
|
672
|
+
subUnitId,
|
|
673
|
+
col: colId,
|
|
674
|
+
criteria: null
|
|
675
|
+
}
|
|
676
|
+
};
|
|
677
|
+
const serialize = filterColumn.serialize();
|
|
678
|
+
return {
|
|
679
|
+
id: SetSheetsFilterCriteriaMutation$1.id,
|
|
680
|
+
params: {
|
|
681
|
+
unitId,
|
|
682
|
+
subUnitId,
|
|
683
|
+
col: colId,
|
|
684
|
+
criteria: serialize
|
|
685
|
+
}
|
|
686
|
+
};
|
|
687
|
+
}
|
|
688
|
+
__name(destructFilterColumn, "destructFilterColumn");
|
|
689
|
+
export {
|
|
690
|
+
CustomFilterOperator as C,
|
|
691
|
+
FilterColumn as F,
|
|
692
|
+
ReCalcSheetsFilterMutation as R,
|
|
693
|
+
SetSheetsFilterCriteriaMutation as S,
|
|
694
|
+
SheetsFilterService as a,
|
|
695
|
+
SetSheetsFilterRangeMutation as b,
|
|
696
|
+
RemoveSheetsFilterMutation as c,
|
|
697
|
+
SHEET_FILTER_SNAPSHOT_ID as d,
|
|
698
|
+
FilterModel as e,
|
|
699
|
+
equals as f,
|
|
700
|
+
getCustomFilterFn as g,
|
|
701
|
+
greaterThan as h,
|
|
702
|
+
greaterThanOrEqualTo as i,
|
|
703
|
+
lessThanOrEqualTo as j,
|
|
704
|
+
FILTER_MUTATIONS as k,
|
|
705
|
+
lessThan as l,
|
|
706
|
+
ClearSheetsFilterCriteriaCommand as m,
|
|
707
|
+
notEquals as n,
|
|
708
|
+
ReCalcSheetsFilterCommand as o,
|
|
709
|
+
RemoveSheetFilterCommand as p,
|
|
710
|
+
SetSheetFilterRangeCommand as q,
|
|
711
|
+
SetSheetsFilterCriteriaCommand as r,
|
|
712
|
+
SmartToggleSheetsFilterCommand as s
|
|
713
|
+
};
|