@devisfuture/mega-collection 2.4.7 → 2.4.8

package/dist/filter/filter.d.ts

@@ -1,89 +0,0 @@
-/**
- * FilterEngine class for filtering collections by multiple criteria,
- * supporting indexed lookups and linear scans for large datasets.
- */
-import { State } from "../State";
-import { CollectionItem, FilterCriterion, type UpdateDescriptor } from "../types";
-import { FilterEngineChain } from "./chain";
-import type { FilterEngineOptions } from "./types";
-export declare class FilterEngine<T extends CollectionItem> {
-    private readonly indexer;
-    private readonly filterByPreviousResult;
-    private readonly mutableExcludeField;
-    private readonly state;
-    private readonly namespace;
-    private readonly nestedCollection;
-    private readonly chainBuilder;
-    /**
-     * Creates a new FilterEngine with optional data and fields to index.
-     */
-    constructor(options?: FilterEngineOptions<T> & {
-        state?: State<T>;
-    });
-    private get dataset();
-    private get runtime();
-    private get mutableExcludeState();
-    private get indexedFields();
-    private get sequentialCache();
-    private shouldDeferMutationIndexUpdates;
-    private markDeferredMutationState;
-    private ensureRuntimeReady;
-    private rebuildConfiguredIndexes;
-    /**
-     * Builds an index for the given field.
-     */
-    private buildIndex;
-    clearIndexes(): this;
-    resetFilterState(): this;
-    clearData(): this;
-    data(data: T[]): this;
-    add(items: T[]): this;
-    update(descriptor: UpdateDescriptor<T>): this;
-    private applyAddedItems;
-    getOriginData(): T[];
-    /**
-     * Filters the data based on the given criteria.
-     */
-    filter(criteria: FilterCriterion<T>[]): T[] & FilterEngineChain<T>;
-    filter(data: T[], criteria: FilterCriterion<T>[]): T[] & FilterEngineChain<T>;
-    rawFilter(criteria: FilterCriterion<T>[]): T[];
-    rawFilter(data: T[], criteria: FilterCriterion<T>[]): T[];
-    private resolveWithSequentialCache;
-    private withChain;
-    private handleStateMutation;
-    private rebuildMutableExcludeState;
-    private updateMutableExcludeStateForAddedItems;
-    private applyMutableExclude;
-    private applyUpdatedItem;
-    private applyRemovedItem;
-    private applyRemovedItems;
-    private updateMutableExcludeStateForUpdatedItem;
-    private clearMutableExcludeState;
-    private registerMutableExcludeValue;
-    private unregisterMutableExcludeValue;
-    /**
-     * Filters data linearly without index.
-     */
-    private linearFilter;
-    /**
-     * Filters data using the index.
-     */
-    private filterViaIndex;
-    /**
-     * Estimates the size of the index for a criterion.
-     */
-    private estimateIndexSize;
-    private applyIndexedExclusions;
-    private createEmptyResult;
-    private storePreviousResult;
-    private createCriteriaCacheKey;
-    private createSequentialCacheEntry;
-    private createSequentialExecutionCriteria;
-    private hasCriteriaBacktrack;
-    private canApplySequentiallyToEmptyResult;
-    private createCriteriaStateMap;
-    private isCriterionBacktracked;
-    private isSubset;
-    private areSetsEqual;
-}
-//# sourceMappingURL=filter.d.ts.map

package/dist/filter/filter.mjs

@@ -1,439 +0,0 @@
-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 };

package/dist/filter/nested.d.ts

@@ -1,32 +0,0 @@
-import { CollectionItem, type FilterCriterion } from "../types";
-import type { FilterNestedCollectionStorage } from "./types";
-export declare class FilterNestedCollection<T extends CollectionItem> {
-    private readonly storage;
-    private readonly registeredFields;
-    private readonly fieldDescriptors;
-    constructor(storage?: FilterNestedCollectionStorage<T>);
-    registerFields(fieldPaths?: readonly string[]): void;
-    hasRegisteredFields(): boolean;
-    hasField(fieldPath: string): boolean;
-    clearIndexes(): void;
-    buildIndexes(data: T[]): void;
-    addItems(items: T[]): void;
-    removeItem(item: T): void;
-    updateItem(nextItem: T, previousItem: T): void;
-    filter(sourceData: T[], criteria: FilterCriterion<T>[], dataset: T[]): T[];
-    private resolveCriteria;
-    private registerField;
-    private buildIndex;
-    private removeItemFromIndex;
-    private addItem;
-    private addItemToIndex;
-    private updateItemInIndex;
-    private collectUniqueValues;
-    private areValueSetsEqual;
-    private filterByIndexes;
-    private getItemsByValues;
-    private estimateIndexSize;
-    private filterLinearly;
-    private applyIndexedExclusions;
-}
-//# sourceMappingURL=nested.d.ts.map