@devisfuture/mega-collection 2.4.5 → 2.4.7

package/dist/filter/filter.mjs

@@ -0,0 +1,439 @@
+import { State as e } from "../State.mjs";
+import { DEFER_FILTER_MUTATION_INDEX_UPDATES_KEY as t, MERGE_SHARED_SCOPE as n } from "../constants.mjs";
+import { Indexer as r } from "../indexer.mjs";
+import { FilterEngineChainBuilder as i } from "./chain.mjs";
+import { FilterEngineError as a } from "./errors.mjs";
+import { isCriterionUnsatisfiable as o, matchesCriterionValue as s, resolveCriteria as c } from "./criterion.mjs";
+import { FilterNestedCollection as l } from "./nested.mjs";
+import { createFilterRuntime as u } from "./utils.mjs";
+//#region src/filter/filter.ts
+var d = class {
+	constructor(t = {}) {
+		this.chainBuilder = new i({
+			filter: (e, t) => t === void 0 ? this.filter(e) : this.filter(e, t),
+			getOriginData: () => this.getOriginData(),
+			add: (e) => this.add(e),
+			update: (e) => this.update(e),
+			data: (e) => this.data(e),
+			clearIndexes: () => this.clearIndexes(),
+			clearData: () => this.clearData(),
+			resetFilterState: () => this.resetFilterState()
+		}), this.mutableExcludeField = t.mutableExcludeField ?? null, this.state = t.state ?? new e(t.data ?? [], { filterByPreviousResult: t.filterByPreviousResult ?? !1 }), t.state && t.filterByPreviousResult && this.state.setFilterByPreviousResult(!0), this.filterByPreviousResult = this.state.isFilterByPreviousResultEnabled(), this.namespace = this.state.createNamespace("filter"), this.indexer = new r(this.runtime.indexerStorage), this.nestedCollection = new l(this.runtime.nestedStorage), this.nestedCollection.registerFields(t.nestedFields), this.state.subscribe((e) => this.handleStateMutation(e)), this.rebuildMutableExcludeState();
+		let n = t.fields?.length, a = this.nestedCollection.hasRegisteredFields();
+		if (n) for (let e of t.fields) this.indexedFields.add(e);
+		this.dataset.length > 0 && (n || a) && this.rebuildConfiguredIndexes();
+	}
+	get dataset() {
+		return this.state.getOriginData();
+	}
+	get runtime() {
+		return this.state.getOrCreateScopedValue(this.namespace, "runtime", u);
+	}
+	get mutableExcludeState() {
+		return this.runtime.mutableExclude;
+	}
+	get indexedFields() {
+		return this.runtime.indexedFields;
+	}
+	get sequentialCache() {
+		return this.runtime.sequentialCache;
+	}
+	shouldDeferMutationIndexUpdates() {
+		return this.state.getScopedValue(n, t) === !0;
+	}
+	markDeferredMutationState() {
+		this.runtime.deferredMutationVersion = this.state.getMutationVersion(), this.indexer.clear(), this.nestedCollection.clearIndexes(), this.clearMutableExcludeState(), this.resetFilterState();
+	}
+	ensureRuntimeReady() {
+		this.runtime.deferredMutationVersion !== null && (this.runtime.deferredMutationVersion = null, this.rebuildMutableExcludeState(), this.dataset.length > 0 && (this.indexedFields.size > 0 || this.nestedCollection.hasRegisteredFields()) && this.rebuildConfiguredIndexes());
+	}
+	rebuildConfiguredIndexes() {
+		this.indexer.clear(), this.nestedCollection.clearIndexes();
+		for (let e of this.indexedFields) this.buildIndex(this.dataset, e);
+		this.nestedCollection.hasRegisteredFields() && this.nestedCollection.buildIndexes(this.dataset);
+	}
+	buildIndex(e, t) {
+		if (!Array.isArray(e)) {
+			if (!this.dataset.length) throw a.missingDatasetForBuildIndex();
+			return this.indexer.buildIndex(this.dataset, e), this;
+		}
+		return this.resetFilterState(), this.rebuildMutableExcludeState(), this.indexer.buildIndex(e, t), this;
+	}
+	clearIndexes() {
+		return this.indexer.clear(), this.nestedCollection.clearIndexes(), this;
+	}
+	resetFilterState() {
+		return this.sequentialCache.previousResult = null, this.sequentialCache.previousCriteria = null, this.sequentialCache.previousCriteriaKey = null, this.sequentialCache.previousBaseData = null, this.sequentialCache.previousResultsByCriteria.clear(), this.sequentialCache.previousResultSet = null, this.state.clearPreviousResult(), this;
+	}
+	clearData() {
+		return this.state.clearData(), this;
+	}
+	data(e) {
+		return this.state.data(e), this;
+	}
+	add(e) {
+		return this.state.add(e), this;
+	}
+	update(e) {
+		return this.state.update(e), this;
+	}
+	applyAddedItems(e, t) {
+		return e.length === 0 ? this : (this.updateMutableExcludeStateForAddedItems(e, t), this.resetFilterState(), this.indexer.addItems(e), this.nestedCollection.addItems(e), this);
+	}
+	getOriginData() {
+		return this.state.getOriginData();
+	}
+	filter(e, t) {
+		return t === void 0 ? this.withChain(this.rawFilter(e)) : this.withChain(this.rawFilter(e, t));
+	}
+	rawFilter(e, t) {
+		this.ensureRuntimeReady();
+		let n = t === void 0;
+		if (n && !this.dataset.length) throw a.missingDatasetForFilter();
+		let r = c(n ? e : t), i = n ? this.dataset : e;
+		if (n) {
+			let e = this.applyMutableExclude(r);
+			if (e !== void 0) return e;
+		}
+		let s = i, l = r;
+		if (this.filterByPreviousResult) {
+			let e = this.resolveWithSequentialCache(i, n, r);
+			if (e.isFromCache) return e.result;
+			s = e.sourceData, l = e.executionCriteria;
+		}
+		if (r.length === 0) return this.filterByPreviousResult && this.resetFilterState(), i;
+		for (let e = 0; e < l.length; e++) if (o(l[e])) return this.createEmptyResult(n, i, r);
+		let u = [], d = [];
+		for (let e = 0; e < l.length; e++) {
+			let t = l[e];
+			this.nestedCollection.hasField(t.field) ? u.push(t) : d.push(t);
+		}
+		if (u.length > 0 && (s = this.nestedCollection.filter(s, u, this.dataset), s.length === 0)) return this.createEmptyResult(n, i, r);
+		if (d.length === 0) return this.storePreviousResult(s, n, i, r), s;
+		let f = [], p = [];
+		for (let e = 0; e < d.length; e++) {
+			let t = d[e];
+			this.indexer.hasIndex(t.field) ? f.push(t) : p.push(t);
+		}
+		let m;
+		if (f.length > 0 && p.length === 0) return m = this.filterViaIndex(f, s), this.storePreviousResult(m, n, i, r), m;
+		if (f.length > 0 && p.length > 0) {
+			let e = this.filterViaIndex(f, s);
+			return m = this.linearFilter(e, p), this.storePreviousResult(m, n, i, r), m;
+		}
+		return m = this.linearFilter(s, d), this.storePreviousResult(m, n, i, r), m;
+	}
+	resolveWithSequentialCache(e, t, n) {
+		let { previousResult: r, previousCriteria: i, previousCriteriaKey: a, previousBaseData: o, previousResultsByCriteria: s } = this.sequentialCache;
+		if (r === null || i === null || o !== e) return {
+			isFromCache: !1,
+			sourceData: e,
+			executionCriteria: n
+		};
+		let c = this.createCriteriaCacheKey(n), l = s.get(c);
+		if (c === a) return {
+			isFromCache: !0,
+			result: r
+		};
+		if (l !== void 0) return this.storePreviousResult(l.result, t, e, n, c, l.resultSet), {
+			isFromCache: !0,
+			result: l.result
+		};
+		let u = this.hasCriteriaBacktrack(i, n) || r.length === 0 && !this.canApplySequentiallyToEmptyResult(i, n);
+		return {
+			isFromCache: !1,
+			sourceData: u ? e : r,
+			executionCriteria: u ? n : this.createSequentialExecutionCriteria(i, n)
+		};
+	}
+	withChain(e) {
+		return this.chainBuilder.create(e);
+	}
+	handleStateMutation(e) {
+		if (this.shouldDeferMutationIndexUpdates() && (e.type === "add" || e.type === "update")) {
+			this.markDeferredMutationState();
+			return;
+		}
+		switch (e.type) {
+			case "add":
+				this.applyAddedItems(e.items, e.startIndex);
+				return;
+			case "update":
+				this.applyUpdatedItem(e.index, e.previousItem, e.nextItem);
+				return;
+			case "data":
+				this.runtime.deferredMutationVersion = null, this.rebuildMutableExcludeState(), this.resetFilterState(), this.rebuildConfiguredIndexes();
+				return;
+			case "clearData":
+				this.runtime.deferredMutationVersion = null, this.clearMutableExcludeState(), this.indexer.clear(), this.nestedCollection.clearIndexes(), this.resetFilterState();
+				return;
+			case "remove":
+				this.applyRemovedItem(e.field, e.value, e.removedItem, e.removedIndex, e.movedItem);
+				return;
+			case "removeMany":
+				this.applyRemovedItems(e.field, e.entries);
+				return;
+		}
+	}
+	rebuildMutableExcludeState() {
+		if (this.clearMutableExcludeState(), this.mutableExcludeField !== null) for (let e = 0; e < this.dataset.length; e++) {
+			let t = this.dataset[e][this.mutableExcludeField];
+			t != null && this.registerMutableExcludeValue(t, e);
+		}
+	}
+	updateMutableExcludeStateForAddedItems(e, t) {
+		if (this.mutableExcludeField !== null) for (let n = 0; n < e.length; n++) {
+			let r = e[n][this.mutableExcludeField];
+			r != null && this.registerMutableExcludeValue(r, t + n);
+		}
+	}
+	applyMutableExclude(e) {
+		if (this.mutableExcludeField === null || e.length !== 1) return;
+		let t = e[0];
+		if (!(t.field !== this.mutableExcludeField || t.hasValues || !t.hasExclude)) {
+			if (this.mutableExcludeState.hasDuplicateValues) throw a.duplicateMutableExcludeField(this.mutableExcludeField);
+			return this.state.removeByFieldValues(this.mutableExcludeField, t.exclude), this.resetFilterState(), this.dataset;
+		}
+	}
+	applyUpdatedItem(e, t, n) {
+		this.updateMutableExcludeStateForUpdatedItem(e, t, n), this.resetFilterState(), this.indexer.updateItem(t, n), this.nestedCollection.updateItem(n, t);
+	}
+	applyRemovedItem(e, t, n, r, i) {
+		if (e === this.mutableExcludeField && (this.unregisterMutableExcludeValue(t), this.mutableExcludeState.datasetPositions.delete(t), i !== null && this.mutableExcludeField !== null)) {
+			let e = i[this.mutableExcludeField];
+			e != null && this.mutableExcludeState.datasetPositions.set(e, r);
+		}
+		this.resetFilterState(), this.indexer.removeItem(n), this.nestedCollection.removeItem(n);
+	}
+	applyRemovedItems(e, t) {
+		for (let n = 0; n < t.length; n++) {
+			let r = t[n];
+			if (e === this.mutableExcludeField && (this.unregisterMutableExcludeValue(r.value), this.mutableExcludeState.datasetPositions.delete(r.value), r.movedItem !== null && this.mutableExcludeField !== null)) {
+				let e = r.movedItem[this.mutableExcludeField];
+				e != null && this.mutableExcludeState.datasetPositions.set(e, r.removedIndex);
+			}
+			this.indexer.removeItem(r.removedItem), this.nestedCollection.removeItem(r.removedItem);
+		}
+		this.resetFilterState();
+	}
+	updateMutableExcludeStateForUpdatedItem(e, t, n) {
+		if (this.mutableExcludeField === null) return;
+		let r = t[this.mutableExcludeField], i = n[this.mutableExcludeField];
+		if (r === i) {
+			i != null && this.mutableExcludeState.datasetPositions.set(i, e);
+			return;
+		}
+		r != null && (this.unregisterMutableExcludeValue(r), this.mutableExcludeState.datasetPositions.get(r) === e && this.mutableExcludeState.datasetPositions.delete(r)), i != null && this.registerMutableExcludeValue(i, e);
+	}
+	clearMutableExcludeState() {
+		this.mutableExcludeState.datasetPositions.clear(), this.mutableExcludeState.valueCounts.clear(), this.mutableExcludeState.duplicateValueCount = 0, this.mutableExcludeState.hasDuplicateValues = !1;
+	}
+	registerMutableExcludeValue(e, t) {
+		let n = (this.mutableExcludeState.valueCounts.get(e) ?? 0) + 1;
+		n === 2 && this.mutableExcludeState.duplicateValueCount++, this.mutableExcludeState.valueCounts.set(e, n), this.mutableExcludeState.datasetPositions.set(e, t), this.mutableExcludeState.hasDuplicateValues = this.mutableExcludeState.duplicateValueCount > 0;
+	}
+	unregisterMutableExcludeValue(e) {
+		let t = this.mutableExcludeState.valueCounts.get(e);
+		t !== void 0 && (t === 2 && this.mutableExcludeState.duplicateValueCount--, t <= 1 ? this.mutableExcludeState.valueCounts.delete(e) : this.mutableExcludeState.valueCounts.set(e, t - 1), this.mutableExcludeState.hasDuplicateValues = this.mutableExcludeState.duplicateValueCount > 0);
+	}
+	linearFilter(e, t) {
+		let n = [];
+		for (let r = 0; r < e.length; r++) {
+			let i = e[r], a = !0;
+			for (let e = 0; e < t.length; e++) {
+				let n = t[e];
+				if (!s(n, i[n.field])) {
+					a = !1;
+					break;
+				}
+			}
+			a && n.push(i);
+		}
+		return n;
+	}
+	filterViaIndex(e, t) {
+		let n = t !== this.dataset, r = null;
+		if (n) {
+			if (t === this.sequentialCache.previousResult && this.sequentialCache.previousResultSet !== null) r = this.sequentialCache.previousResultSet;
+			else if (r = new Set(t), t === this.sequentialCache.previousResult) {
+				this.sequentialCache.previousResultSet = r;
+				let e = this.sequentialCache.previousCriteriaKey;
+				if (e !== null) {
+					let t = this.sequentialCache.previousResultsByCriteria.get(e);
+					t && (t.resultSet = r);
+				}
+			}
+		}
+		let i = [], a = [];
+		for (let t = 0; t < e.length; t++) {
+			let n = e[t];
+			n.hasValues && i.push(n), n.hasExclude && a.push(n);
+		}
+		if (i.length === 0) return this.applyIndexedExclusions(t, a);
+		if (i.length === 1) {
+			let e = i[0], t = !1;
+			for (let n = 0; n < a.length; n++) if (a[n].field !== e.field) {
+				t = !0;
+				break;
+			}
+			if (r === null && !t) return e.values.length === 1 ? this.indexer.getByValue(e.field, e.values[0]).slice() : this.indexer.getByValues(e.field, e.values);
+			let n = this.indexer.getByValues(e.field, e.values), o = [];
+			for (let e = 0; e < n.length; e++) {
+				let t = n[e];
+				r && !r.has(t) || o.push(t);
+			}
+			return this.applyIndexedExclusions(o, a);
+		}
+		let o = i[0], c = this.estimateIndexSize(o);
+		for (let e = 1; e < i.length; e++) {
+			let t = i[e], n = this.estimateIndexSize(t);
+			n < c && (o = t, c = n);
+		}
+		let l = this.indexer.getByValues(o.field, o.values);
+		if (l.length === 0) return [];
+		let u = [];
+		for (let e = 0; e < l.length; e++) {
+			let t = l[e], n = !0;
+			if (!(r && !r.has(t))) {
+				for (let e = 0; e < i.length; e++) {
+					let r = i[e];
+					if (r !== o && !s(r, t[r.field])) {
+						n = !1;
+						break;
+					}
+				}
+				n && u.push(t);
+			}
+		}
+		return this.applyIndexedExclusions(u, a);
+	}
+	estimateIndexSize(e) {
+		let t = this.indexer.getIndexMap(e.field);
+		if (!t) return Infinity;
+		let n = 0;
+		for (let r = 0; r < e.values.length; r++) {
+			let i = t.get(e.values[r]);
+			i && (n += i.length);
+		}
+		return n;
+	}
+	applyIndexedExclusions(e, t) {
+		if (t.length === 0 || e.length === 0) return e;
+		let n = /* @__PURE__ */ new Set();
+		for (let e = 0; e < t.length; e++) {
+			let r = t[e], i = this.indexer.getIndexMap(r.field);
+			if (i) for (let e = 0; e < r.exclude.length; e++) {
+				let t = i.get(r.exclude[e]);
+				if (t) for (let e = 0; e < t.length; e++) n.add(t[e]);
+			}
+		}
+		if (n.size === 0) return e;
+		let r = [];
+		for (let t = 0; t < e.length; t++) {
+			let i = e[t];
+			n.has(i) || r.push(i);
+		}
+		return r;
+	}
+	createEmptyResult(e, t, n) {
+		let r = [];
+		return this.storePreviousResult(r, e, t, n), r;
+	}
+	storePreviousResult(e, t, n, r, i = this.createCriteriaCacheKey(r), a) {
+		if (!this.filterByPreviousResult) return;
+		let o = a === void 0 ? null : a;
+		this.sequentialCache.previousResult = e, this.sequentialCache.previousCriteria = r, this.sequentialCache.previousCriteriaKey = i, this.sequentialCache.previousBaseData = t ? this.dataset : n, this.sequentialCache.previousResultSet = o, this.state.setPreviousResult(e, t ? this.dataset : n), this.sequentialCache.previousResultsByCriteria.set(i, this.createSequentialCacheEntry(e, o));
+	}
+	createCriteriaCacheKey(e) {
+		let t = "";
+		for (let n = 0; n < e.length; n++) t += e[n].cacheKeySegment, t += ";";
+		return t;
+	}
+	createSequentialCacheEntry(e, t) {
+		return {
+			result: e,
+			resultSet: t
+		};
+	}
+	createSequentialExecutionCriteria(e, t) {
+		let n = /* @__PURE__ */ new Map();
+		for (let t = 0; t < e.length; t++) {
+			let r = e[t];
+			n.set(r.field, r);
+		}
+		return t.map((e) => {
+			let t = n.get(e.field);
+			if (!t || !t.hasValues || !e.hasValues || t.hasExclude || e.hasExclude || e.includedValues.size <= t.includedValues.size) return e;
+			for (let n of t.includedValues) if (!e.includedValues.has(n)) return e;
+			let r = [];
+			for (let n of e.includedValues) t.includedValues.has(n) || r.push(n);
+			return r.length === 0 ? e : {
+				...e,
+				values: r,
+				includedValues: new Set(r)
+			};
+		});
+	}
+	hasCriteriaBacktrack(e, t) {
+		let n = this.createCriteriaStateMap(e), r = this.createCriteriaStateMap(t);
+		for (let [e, t] of n) {
+			let n = r.get(e);
+			if (!n || this.isCriterionBacktracked(t, n)) return !0;
+		}
+		return !1;
+	}
+	canApplySequentiallyToEmptyResult(e, t) {
+		let n = this.createCriteriaStateMap(e), r = this.createCriteriaStateMap(t);
+		for (let [e, t] of r) {
+			let r = n.get(e);
+			if (r) {
+				if (r.hasValues !== t.hasValues && (r.hasValues || !t.hasValues)) return !1;
+				if (r.hasValues && t.hasValues) {
+					let e = r.includedValues, n = t.includedValues;
+					if (!this.areSetsEqual(e, n) && !this.isSubset(e, n)) return !1;
+				}
+				if (r.hasExclude !== t.hasExclude && (r.hasExclude || !t.hasExclude)) return !1;
+				if (r.hasExclude && t.hasExclude) {
+					let e = r.excludedValues, n = t.excludedValues;
+					if (!this.areSetsEqual(e, n) && !this.isSubset(e, n)) return !1;
+				}
+			}
+		}
+		return !0;
+	}
+	createCriteriaStateMap(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n = 0; n < e.length; n++) {
+			let r = e[n];
+			t.set(r.field, r);
+		}
+		return t;
+	}
+	isCriterionBacktracked(e, t) {
+		if (e.hasValues && !t.hasValues) return !0;
+		if (e.hasValues && t.hasValues) {
+			let n = e.includedValues, r = t.includedValues;
+			if (!this.areSetsEqual(n, r)) return this.isSubset(r, n);
+		}
+		if (!e.hasValues && t.hasValues) return !1;
+		if (e.hasExclude && !t.hasExclude) return !0;
+		if (!e.hasExclude && t.hasExclude) return !1;
+		if (e.hasExclude && t.hasExclude) {
+			let n = e.excludedValues, r = t.excludedValues;
+			if (!this.areSetsEqual(n, r)) return this.isSubset(r, n);
+		}
+		return !1;
+	}
+	isSubset(e, t) {
+		for (let n of e) if (!t.has(n)) return !1;
+		return !0;
+	}
+	areSetsEqual(e, t) {
+		if (e === t) return !0;
+		if (!e || !t || e.size !== t.size) return !1;
+		for (let n of e) if (!t.has(n)) return !1;
+		return !0;
+	}
+};
+//#endregion
+export { d as FilterEngine };