@devisfuture/mega-collection 2.4.2 → 2.4.4

package/README.md

@@ -9,7 +9,6 @@ If this package saved you some time, a ⭐ on GitHub would be much appreciated.
 ## Table of Contents
 
 - [What does this package solve](#what-does-this-package-solve) – what problem this package helps with
-- [Features](#features) – what the package can do
 - [How it works](#how-it-works) – plain-English explanation of how each engine works internally
 - [Benchmarks](#benchmarks) – performance numbers and how to run them
 - [React demo](#react-demo) – example project and live demo
@@ -33,8 +32,6 @@ If this package saved you some time, a ⭐ on GitHub would be much appreciated.
   - [`TextSearchEngine<T>`](#textsearchenginet-search-module) – engine for text search
   - [`FilterEngine<T>`](#filterenginet-filter-module) – engine for filtering
   - [`SortEngine<T>`](#sortenginet-sort-module) – engine for sorting
-- [Types](#types) – TypeScript types you can import
-- [Build](#build) – commands for build and development
 - [Contributing](#contributing) – contribution rules
 - [Security](#security) – security policy
 - [License](#license) – license information

package/dist/chunk-BTXXf5A-.mjs

@@ -0,0 +1,183 @@
+//#region src/State.ts
+var e = class {
+	constructor(e = [], t = {}) {
+		this.itemIndexLookup = /* @__PURE__ */ new WeakMap(), this.mutationVersion = 0, this.namespaceSequence = 0, this.previousResultState = null, this.indexMaps = /* @__PURE__ */ new Map(), this.scopedRegistry = /* @__PURE__ */ new Map(), this.listeners = /* @__PURE__ */ new Set(), this.originData = e, this.filterByPreviousResult = t.filterByPreviousResult ?? !1, this.rebuildItemIndexLookup();
+	}
+	subscribe(e) {
+		return this.listeners.add(e), () => {
+			this.listeners.delete(e);
+		};
+	}
+	getOriginData() {
+		return this.originData;
+	}
+	getItemIndex(e) {
+		return this.itemIndexLookup.get(e);
+	}
+	getMutationVersion() {
+		return this.mutationVersion;
+	}
+	isFilterByPreviousResultEnabled() {
+		return this.filterByPreviousResult;
+	}
+	setFilterByPreviousResult(e) {
+		this.filterByPreviousResult = e, e || this.clearPreviousResult();
+	}
+	getPreviousResult() {
+		return this.getPreviousResultState()?.result ?? null;
+	}
+	getPreviousResultState() {
+		return this.previousResultState === null || this.previousResultState.version !== this.mutationVersion ? null : this.previousResultState;
+	}
+	setPreviousResult(e, t) {
+		this.previousResultState = {
+			result: e,
+			sourceData: t,
+			version: this.mutationVersion
+		};
+	}
+	clearPreviousResult() {
+		this.previousResultState = null;
+	}
+	createNamespace(e = "scope") {
+		return this.namespaceSequence += 1, `${e}:${this.namespaceSequence}`;
+	}
+	getScopedValue(e, t) {
+		return this.scopedRegistry.get(e)?.get(t);
+	}
+	getOrCreateScopedValue(e, t, n) {
+		let r = this.getScopedValue(e, t);
+		if (r !== void 0) return r;
+		let i = this.getOrCreateScope(e), a = n();
+		return i.set(t, a), a;
+	}
+	setScopedValue(e, t, n) {
+		return this.getOrCreateScope(e).set(t, n), n;
+	}
+	deleteScopedValue(e, t) {
+		let n = this.scopedRegistry.get(e);
+		n && (n.delete(t), n.size === 0 && this.scopedRegistry.delete(e));
+	}
+	clearScope(e) {
+		this.scopedRegistry.delete(e);
+	}
+	data(e) {
+		this.originData = e, this.bumpMutationVersion(), this.rebuildItemIndexLookup();
+		for (let e of this.indexMaps.keys()) this.rebuildIndexMap(e);
+		this.emit({
+			type: "data",
+			data: e
+		});
+	}
+	add(e) {
+		if (e.length === 0) return;
+		let t = this.originData.length;
+		for (let n = 0; n < e.length; n++) this.originData.push(e[n]), this.itemIndexLookup.set(e[n], t + n);
+		this.bumpMutationVersion();
+		for (let [n, r] of this.indexMaps) for (let i = 0; i < e.length; i++) r.set(e[i][n], t + i);
+		this.emit({
+			type: "add",
+			items: e,
+			startIndex: t
+		});
+	}
+	update(e) {
+		let { field: t, data: n } = e, r = n[t];
+		if (r == null) return;
+		let i = this.getOrCreateIndexMap(t).get(r);
+		if (i === void 0) return;
+		let a = this.originData[i];
+		this.originData[i] = n, this.itemIndexLookup.delete(a), this.itemIndexLookup.set(n, i), this.bumpMutationVersion();
+		for (let [e, t] of this.indexMaps) {
+			let r = a[e], o = n[e];
+			r !== o && (t.get(r) === i && t.delete(r), t.set(o, i));
+		}
+		this.emit({
+			type: "update",
+			field: t,
+			index: i,
+			previousItem: a,
+			nextItem: n
+		});
+	}
+	clearData() {
+		let e = [];
+		this.originData = e, this.itemIndexLookup = /* @__PURE__ */ new WeakMap(), this.bumpMutationVersion();
+		for (let e of this.indexMaps.values()) e.clear();
+		this.emit({
+			type: "clearData",
+			data: e
+		});
+	}
+	removeByFieldValue(e, t) {
+		let n = this.getOrCreateIndexMap(e).get(t);
+		if (n === void 0) return;
+		let r = this.originData.length - 1, i = this.originData[n], a = n === r ? null : this.originData[r];
+		n !== r && a && (this.originData[n] = a, this.itemIndexLookup.set(a, n)), this.originData.pop(), this.itemIndexLookup.delete(i), this.bumpMutationVersion();
+		for (let [e, t] of this.indexMaps) {
+			let r = i[e];
+			t.get(r) === n && t.delete(r), a && t.set(a[e], n);
+		}
+		this.emit({
+			type: "remove",
+			field: e,
+			value: t,
+			removedItem: i,
+			removedIndex: n,
+			movedItem: a,
+			movedFromIndex: a ? r : null
+		});
+	}
+	removeByFieldValues(e, t) {
+		if (t.length === 0) return;
+		let n = this.getOrCreateIndexMap(e), r = [];
+		for (let e = 0; e < t.length; e++) {
+			let i = t[e], a = n.get(i);
+			if (a === void 0) continue;
+			let o = this.originData.length - 1, s = this.originData[a], c = a === o ? null : this.originData[o];
+			a !== o && c && (this.originData[a] = c, this.itemIndexLookup.set(c, a)), this.originData.pop(), this.itemIndexLookup.delete(s);
+			for (let [e, t] of this.indexMaps) {
+				let n = s[e];
+				t.get(n) === a && t.delete(n), c && t.set(c[e], a);
+			}
+			r.push({
+				value: i,
+				removedItem: s,
+				removedIndex: a,
+				movedItem: c,
+				movedFromIndex: c ? o : null
+			});
+		}
+		r.length !== 0 && (this.bumpMutationVersion(), this.emit({
+			type: "removeMany",
+			field: e,
+			entries: r
+		}));
+	}
+	emit(e) {
+		for (let t of this.listeners) t(e);
+	}
+	getOrCreateScope(e) {
+		let t = this.scopedRegistry.get(e);
+		if (t) return t;
+		let n = /* @__PURE__ */ new Map();
+		return this.scopedRegistry.set(e, n), n;
+	}
+	bumpMutationVersion() {
+		this.mutationVersion += 1, this.clearPreviousResult();
+	}
+	getOrCreateIndexMap(e) {
+		return this.indexMaps.get(e) || this.rebuildIndexMap(e);
+	}
+	rebuildIndexMap(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n = 0; n < this.originData.length; n++) t.set(this.originData[n][e], n);
+		return this.indexMaps.set(e, t), t;
+	}
+	rebuildItemIndexLookup() {
+		this.itemIndexLookup = /* @__PURE__ */ new WeakMap();
+		for (let e = 0; e < this.originData.length; e++) this.itemIndexLookup.set(this.originData[e], e);
+	}
+}, t = "__merge__";
+//#endregion
+export { e as n, t };

package/dist/chunk-l_-R9TTp.mjs

@@ -0,0 +1,512 @@
+import { n as e, t } from "./chunk-BTXXf5A-.mjs";
+//#region src/merge/chain.ts
+function n(e) {
+	return {
+		value: e,
+		enumerable: !1,
+		configurable: !0,
+		writable: !0
+	};
+}
+var r = class {
+	constructor(e) {
+		this.callbacks = e;
+	}
+	create(e) {
+		let t = e;
+		return Object.defineProperties(t, {
+			search: n((e, t) => t === void 0 ? this.callbacks.search(e) : this.callbacks.search(e, t)),
+			sort: n((t, n, r) => n === void 0 ? this.callbacks.sort(e, t, r) : this.callbacks.sort(t, n, r)),
+			filter: n((t, n) => n === void 0 ? this.callbacks.filter(e, t) : this.callbacks.filter(t, n)),
+			add: n((e) => this.callbacks.add(e)),
+			update: n((e) => this.callbacks.update(e)),
+			clearIndexes: n((t) => (this.callbacks.clearIndexes(t), this.create(e))),
+			clearData: n((t) => (this.callbacks.clearData(t), this.create(e))),
+			data: n((e) => this.callbacks.data(e)),
+			getOriginData: n(() => this.callbacks.getOriginData())
+		}), t;
+	}
+};
+//#endregion
+//#region src/merge/module-adapters.ts
+function i(e) {
+	return typeof e == "object" && !!e;
+}
+function a(e, t) {
+	return i(e) && typeof e[t] == "function";
+}
+function o(e) {
+	return a(e, "search") && a(e, "getOriginData");
+}
+function s(e) {
+	return a(e, "sort") && a(e, "getOriginData");
+}
+function c(e) {
+	return a(e, "rawFilter") && a(e, "getOriginData");
+}
+var l = (e) => {
+	let { prototype: t } = e;
+	return c(t) ? "filter" : s(t) ? "sort" : o(t) ? "search" : null;
+}, u = (e, t, n, r) => {
+	let i = new e({
+		data: t,
+		state: n,
+		...r
+	});
+	return c(i) ? {
+		moduleName: "filter",
+		executeFilter: (e, t) => t === void 0 ? i.rawFilter(e) : i.rawFilter(e, t),
+		clearIndexes: () => i.clearIndexes()
+	} : s(i) ? {
+		moduleName: "sort",
+		executeSort: (e, t, n) => t === void 0 ? i.sort(e) : i.sort(e, t, n),
+		clearIndexes: () => i.clearIndexes()
+	} : o(i) ? {
+		moduleName: "search",
+		executeSearch: (e, t) => t === void 0 ? i.search(e) : i.search(e, t),
+		clearIndexes: () => i.clearIndexes()
+	} : null;
+}, d = "deferSortMutationCacheUpdates", f = "deferSearchMutationIndexUpdates", p = "deferFilterMutationIndexUpdates", m = {
+	search: "TextSearchEngine",
+	sort: "SortEngine",
+	filter: "FilterEngine"
+}, h = class e extends Error {
+	constructor(e) {
+		super(e), this.name = "MergeEnginesError";
+	}
+	static unavailableEngine(t) {
+		let n = m[t];
+		return new e(`MergeEngines: ${n} is not available.`);
+	}
+	static unavailableGetOriginData() {
+		return new e("MergeEngines: getOriginData is not available.");
+	}
+	static invalidFilterByPreviousResultOption() {
+		return new e("MergeEngines: \"filter.filterByPreviousResult\" is not supported. Configure \"filterByPreviousResult\" on the MergeEngines root options.");
+	}
+}, g = class {
+	constructor(n) {
+		this.previousSearchState = null, this.previousFilterState = null, this.previousSortState = null;
+		let { imports: i, data: a, filterByPreviousResult: o = !1, ...s } = n;
+		this.validateFilterByPreviousResultOptions(s.filter), this.state = new e(a, { filterByPreviousResult: o });
+		let c = new Set(i), m = null, h = null, g = null;
+		for (let e of c) {
+			let t = l(e);
+			if (!t) continue;
+			let n = this.getModuleInitOptions(t, e.name, s), r = u(e, a, this.state, n);
+			r && (r.moduleName === "search" && !m && (m = r), r.moduleName === "sort" && !h && (h = r), r.moduleName === "filter" && !g && (g = r));
+		}
+		this.searchModule = m, this.sortModule = h, this.filterModule = g, this.sortModule && this.state.setScopedValue(t, d, !0), this.searchModule && this.state.setScopedValue(t, f, !0), this.filterModule && this.state.setScopedValue(t, p, !0), this.state.subscribe((e) => this.handleStateMutation(e)), this.chainBuilder = new r({
+			search: (e, t) => t === void 0 ? this.search(e) : this.search(e, t),
+			sort: (e, t, n) => this.sort(e, t, n),
+			filter: (e, t) => this.filter(e, t),
+			getOriginData: () => this.getOriginData(),
+			add: (e) => this.add(e),
+			update: (e) => this.update(e),
+			data: (e) => this.data(e),
+			clearIndexes: (e) => this.clearIndexes(e),
+			clearData: (e) => this.clearData(e)
+		});
+	}
+	getAdapter(e) {
+		return e === "search" ? this.searchModule : e === "sort" ? this.sortModule : this.filterModule;
+	}
+	getModuleInitOptions(e, t, n) {
+		let r = {};
+		for (let a of [e, t]) {
+			let e = n[a];
+			i(e) && Object.assign(r, e);
+		}
+		return r;
+	}
+	validateFilterByPreviousResultOptions(e) {
+		if (i(e) && Object.prototype.hasOwnProperty.call(e, "filterByPreviousResult")) throw h.invalidFilterByPreviousResultOption();
+	}
+	isPreviousResultEnabled() {
+		return this.state.isFilterByPreviousResultEnabled();
+	}
+	getPreviousResultInput() {
+		return this.isPreviousResultEnabled() ? this.state.getPreviousResult() : null;
+	}
+	trackPreviousResult(e, t) {
+		return this.isPreviousResultEnabled() && this.state.setPreviousResult(e, t), e;
+	}
+	clearOperationState(e) {
+		(!e || e === "search") && (this.previousSearchState = null), (!e || e === "filter") && (this.previousFilterState = null), (!e || e === "sort") && (this.previousSortState = null);
+	}
+	createSearchCacheKey(e, t) {
+		return JSON.stringify([e, t ?? null]);
+	}
+	createSortCacheKey(e, t) {
+		return JSON.stringify({
+			descriptors: e,
+			inPlace: t ?? !1
+		});
+	}
+	createFilterCacheKey(e) {
+		return JSON.stringify(e);
+	}
+	handleStateMutation(e) {
+		switch (e.type) {
+			case "add":
+				this.queueSearchCacheMutation(e), this.queueFilterCacheMutation(e), this.queueSortCacheMutation(e);
+				return;
+			case "update":
+				this.queueSearchCacheMutation(e), this.queueFilterCacheMutation(e), this.queueSortCacheMutation(e);
+				return;
+			case "remove":
+				this.previousSearchState = null, this.previousFilterState = null, this.queueSortCacheMutation(e);
+				return;
+			case "removeMany":
+				this.previousSearchState = null, this.previousFilterState = null, this.queueSortCacheMutation(e);
+				return;
+			case "data":
+			case "clearData":
+				this.previousSearchState = null, this.previousFilterState = null, this.previousSortState = null;
+				return;
+		}
+	}
+	queueSearchCacheMutation(e) {
+		let t = this.previousSearchState;
+		if (t !== null) {
+			if (!this.canPatchStoredDatasetSearch(t)) {
+				this.previousSearchState = null;
+				return;
+			}
+			this.previousSearchState = {
+				...t,
+				version: this.state.getMutationVersion(),
+				pendingMutations: t.pendingMutations.concat(e)
+			};
+		}
+	}
+	queueFilterCacheMutation(e) {
+		let t = this.previousFilterState;
+		if (t !== null) {
+			if (!this.canPatchStoredDatasetFilter(t)) {
+				this.previousFilterState = null;
+				return;
+			}
+			this.previousFilterState = {
+				...t,
+				version: this.state.getMutationVersion(),
+				pendingMutations: t.pendingMutations.concat(e)
+			};
+		}
+	}
+	queueSortCacheMutation(e) {
+		let t = this.previousSortState;
+		if (t !== null) {
+			if (!this.canPatchStoredDatasetSort(t)) {
+				this.previousSortState = null;
+				return;
+			}
+			this.previousSortState = {
+				...t,
+				version: this.state.getMutationVersion(),
+				pendingMutations: t.pendingMutations.concat(e)
+			};
+		}
+	}
+	resolvePendingSortCache(e) {
+		if (e.pendingMutations.length === 0) return e;
+		let t = {
+			...e,
+			pendingMutations: []
+		};
+		for (let n = 0; n < e.pendingMutations.length; n++) if (t = this.applySortCacheMutation(t, e.pendingMutations[n]), t === null) return null;
+		return t;
+	}
+	resolvePendingSearchCache(e) {
+		if (e.pendingMutations.length === 0) return e;
+		let t = {
+			...e,
+			pendingMutations: []
+		};
+		for (let n = 0; n < e.pendingMutations.length; n++) if (t = this.applySearchCacheMutation(t, e.pendingMutations[n]), t === null) return null;
+		return t;
+	}
+	resolvePendingFilterCache(e) {
+		if (e.pendingMutations.length === 0) return e;
+		let t = {
+			...e,
+			pendingMutations: []
+		};
+		for (let n = 0; n < e.pendingMutations.length; n++) if (t = this.applyFilterCacheMutation(t, e.pendingMutations[n]), t === null) return null;
+		return t;
+	}
+	applySortCacheMutation(e, t) {
+		switch (t.type) {
+			case "add": return this.patchSortCacheForAddedItems(e, t.items);
+			case "update": return this.patchSortCacheForUpdatedItem(e, t.previousItem, t.nextItem);
+			case "remove": return this.patchSortCacheForRemovedItems(e, [t.removedItem]);
+			case "removeMany": return this.patchSortCacheForRemovedItems(e, t.entries.map((e) => e.removedItem));
+			case "data":
+			case "clearData": return null;
+		}
+	}
+	applySearchCacheMutation(e, t) {
+		switch (t.type) {
+			case "add": return this.patchSearchCacheForAddedItems(e, t.items);
+			case "update": return this.patchSearchCacheForUpdatedItem(e, t.previousItem, t.nextItem);
+			case "remove":
+			case "removeMany":
+			case "data":
+			case "clearData": return null;
+		}
+	}
+	applyFilterCacheMutation(e, t) {
+		switch (t.type) {
+			case "add": return this.patchFilterCacheForAddedItems(e, t.items);
+			case "update": return this.patchFilterCacheForUpdatedItem(e, t.previousItem, t.nextItem);
+			case "remove":
+			case "removeMany":
+			case "data":
+			case "clearData": return null;
+		}
+	}
+	canPatchStoredDatasetSearch(e) {
+		return e.originData === this.state.getOriginData() && e.field !== null;
+	}
+	canPatchStoredDatasetFilter(e) {
+		if (e.sourceData !== this.state.getOriginData()) return !1;
+		for (let t = 0; t < e.criteria.length; t++) if (!this.isPatchableFilterCriterion(e.criteria[t])) return !1;
+		return !0;
+	}
+	canPatchStoredDatasetSort(e) {
+		return e.sourceData === this.state.getOriginData();
+	}
+	compareItemsByDescriptors(e, t, n) {
+		for (let r = 0; r < n.length; r++) {
+			let { field: i, direction: a } = n[r], o = e[i], s = t[i];
+			if (o < s) return a === "asc" ? -1 : 1;
+			if (o > s) return a === "asc" ? 1 : -1;
+		}
+		return (this.state.getItemIndex(e) ?? -1) - (this.state.getItemIndex(t) ?? -1);
+	}
+	findSortInsertPosition(e, t, n) {
+		let r = 0, i = e.length;
+		for (; r < i;) {
+			let a = r + i >> 1;
+			this.compareItemsByDescriptors(e[a], t, n) <= 0 ? r = a + 1 : i = a;
+		}
+		return r;
+	}
+	findDatasetInsertPosition(e, t) {
+		let n = this.state.getItemIndex(t) ?? 2 ** 53 - 1;
+		for (let t = 0; t < e.length; t++) if ((this.state.getItemIndex(e[t]) ?? 2 ** 53 - 1) > n) return t;
+		return e.length;
+	}
+	doesItemMatchSearchCache(e, t) {
+		if (e.field === null || e.lowerQuery.length === 0) return !1;
+		let n = t[e.field];
+		return typeof n == "string" && n.toLowerCase().includes(e.lowerQuery);
+	}
+	patchSearchCacheForAddedItems(e, t) {
+		if (!this.canPatchStoredDatasetSearch(e)) return null;
+		let n = e.result.slice();
+		for (let r = 0; r < t.length; r++) {
+			let i = t[r];
+			this.doesItemMatchSearchCache(e, i) && n.push(i);
+		}
+		return {
+			...e,
+			result: n,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+	}
+	patchSearchCacheForUpdatedItem(e, t, n) {
+		if (!this.canPatchStoredDatasetSearch(e)) return null;
+		let r = e.result.slice(), i = r.indexOf(t), a = this.doesItemMatchSearchCache(e, n);
+		if (i !== -1) a ? r[i] = n : r.splice(i, 1);
+		else if (a) {
+			let e = this.findDatasetInsertPosition(r, n);
+			r.splice(e, 0, n);
+		}
+		return {
+			...e,
+			result: r,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+	}
+	isPatchableFilterCriterion(e) {
+		return !String(e.field).includes(".");
+	}
+	doesItemMatchFilterCache(e, t) {
+		for (let n = 0; n < e.criteria.length; n++) {
+			let r = e.criteria[n];
+			if (!this.isPatchableFilterCriterion(r)) return !1;
+			let i = t[r.field];
+			if (r.values !== void 0 && r.values.length > 0 && !r.values.includes(i) || r.exclude !== void 0 && r.exclude.length > 0 && r.exclude.includes(i)) return !1;
+		}
+		return !0;
+	}
+	patchFilterCacheForAddedItems(e, t) {
+		if (!this.canPatchStoredDatasetFilter(e)) return null;
+		let n = e.result.slice();
+		for (let r = 0; r < t.length; r++) {
+			let i = t[r];
+			this.doesItemMatchFilterCache(e, i) && n.push(i);
+		}
+		return {
+			...e,
+			result: n,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+	}
+	patchFilterCacheForUpdatedItem(e, t, n) {
+		if (!this.canPatchStoredDatasetFilter(e)) return null;
+		let r = e.result.slice(), i = r.indexOf(t), a = this.doesItemMatchFilterCache(e, n);
+		if (i !== -1) a ? r[i] = n : r.splice(i, 1);
+		else if (a) {
+			let e = this.findDatasetInsertPosition(r, n);
+			r.splice(e, 0, n);
+		}
+		return {
+			...e,
+			result: r,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+	}
+	patchSortCacheForAddedItems(e, t) {
+		if (!this.canPatchStoredDatasetSort(e)) return null;
+		let n = e.result.slice();
+		for (let r = 0; r < t.length; r++) {
+			let i = t[r], a = this.findSortInsertPosition(n, i, e.descriptors);
+			n.splice(a, 0, i);
+		}
+		return {
+			...e,
+			result: n,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+	}
+	patchSortCacheForUpdatedItem(e, t, n) {
+		if (!this.canPatchStoredDatasetSort(e)) return null;
+		let r = e.result.slice(), i = r.indexOf(t);
+		if (i === -1) return e.result.indexOf(n) === -1 ? null : {
+			...e,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+		if (!e.descriptors.some(({ field: e }) => t[e] !== n[e])) return r[i] = n, {
+			...e,
+			result: r,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+		r.splice(i, 1);
+		let a = this.findSortInsertPosition(r, n, e.descriptors);
+		return r.splice(a, 0, n), {
+			...e,
+			result: r,
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+	}
+	patchSortCacheForRemovedItems(e, t) {
+		if (!this.canPatchStoredDatasetSort(e)) return null;
+		let n = new Set(t);
+		return {
+			...e,
+			result: Array.prototype.filter.call(e.result, (e) => !n.has(e)),
+			pendingMutations: [],
+			version: this.state.getMutationVersion()
+		};
+	}
+	search(e, t) {
+		if (!this.searchModule) throw h.unavailableEngine("search");
+		let n = this.state.getOriginData(), r = this.state.getMutationVersion(), i = this.createSearchCacheKey(e, t), a = this.previousSearchState;
+		if (a?.originData === n && a.key === i && a.version === r) {
+			let e = this.resolvePendingSearchCache(a);
+			if (e !== null) return this.previousSearchState = e, this.withChain(this.trackPreviousResult(e.result, n));
+			this.previousSearchState = null;
+		}
+		let o = t === void 0 ? this.searchModule.executeSearch(e) : this.searchModule.executeSearch(e, t);
+		return this.previousSearchState = {
+			key: i,
+			originData: n,
+			result: o,
+			version: r,
+			field: t === void 0 ? null : e,
+			lowerQuery: (t ?? e).trim().toLowerCase(),
+			pendingMutations: []
+		}, this.withChain(this.trackPreviousResult(o, n));
+	}
+	sort(e, t, n) {
+		if (!this.sortModule) throw h.unavailableEngine("sort");
+		let r, i;
+		if (t === void 0 ? (i = e, r = this.getPreviousResultInput() ?? this.state.getOriginData()) : (r = e, i = t), !n) {
+			let e = this.state.getMutationVersion(), a = this.createSortCacheKey(i, n), o = this.previousSortState;
+			if (o?.sourceData === r && o.key === a && o.version === e) {
+				let e = this.resolvePendingSortCache(o);
+				if (e !== null) return this.previousSortState = e, this.withChain(this.trackPreviousResult(e.result, r));
+				this.previousSortState = null;
+			}
+			let s = t === void 0 && r === this.state.getOriginData() ? this.sortModule.executeSort(i) : this.sortModule.executeSort(r, i, n);
+			return this.previousSortState = {
+				key: a,
+				sourceData: r,
+				result: s,
+				version: e,
+				descriptors: i,
+				pendingMutations: []
+			}, this.withChain(this.trackPreviousResult(s, r));
+		}
+		return this.withChain(this.trackPreviousResult(this.sortModule.executeSort(r, i, n), r));
+	}
+	filter(e, t) {
+		if (!this.filterModule) throw h.unavailableEngine("filter");
+		if (t === void 0) {
+			let t = this.getPreviousResultInput(), n = t ?? this.state.getOriginData(), r = e, i = this.state.getMutationVersion(), a = this.createFilterCacheKey(r), o = this.previousFilterState;
+			if (o?.sourceData === n && o.key === a && o.version === i) {
+				let e = this.resolvePendingFilterCache(o);
+				if (e !== null) return this.previousFilterState = e, this.withChain(this.trackPreviousResult(e.result, n));
+				this.previousFilterState = null;
+			}
+			let s = t === null ? this.filterModule.executeFilter(r) : this.filterModule.executeFilter(t, r);
+			return this.previousFilterState = {
+				key: a,
+				sourceData: n,
+				result: s,
+				version: i,
+				criteria: r,
+				pendingMutations: []
+			}, this.withChain(this.trackPreviousResult(s, n));
+		}
+		let n = e;
+		return this.withChain(this.trackPreviousResult(this.filterModule.executeFilter(n, t), n));
+	}
+	withChain(e) {
+		return this.chainBuilder.create(e);
+	}
+	getOriginData() {
+		if (this.searchModule || this.sortModule || this.filterModule) return this.state.getOriginData();
+		throw h.unavailableGetOriginData();
+	}
+	add(e) {
+		return e.length === 0 || this.state.add(e), this;
+	}
+	update(e) {
+		return this.state.update(e), this;
+	}
+	clearIndexes(e) {
+		let t = this.getAdapter(e);
+		if (t) return t.clearIndexes(), this.clearOperationState(e), this;
+		throw h.unavailableEngine(e);
+	}
+	data(e) {
+		return this.state.data(e), this;
+	}
+	clearData(e) {
+		if (this.getAdapter(e)) return this.state.clearData(), this;
+		throw h.unavailableEngine(e);
+	}
+};
+//#endregion
+export { g as t };