@devisfuture/mega-collection 2.4.7 → 2.5.0

package/dist/merge/merge-engines.mjs

@@ -1,432 +0,0 @@
-import { State as e } from "../State.mjs";
-import { MergeEnginesChainBuilder as t } from "./chain.mjs";
-import { createMergeModuleAdapter as n, isRecord as r, resolveMergeModuleName as i } from "./module-adapters.mjs";
-import { MergeEnginesError as a } from "./errors.mjs";
-import { DEFER_FILTER_MUTATION_INDEX_UPDATES_KEY as o, DEFER_SEARCH_MUTATION_INDEX_UPDATES_KEY as s, DEFER_SORT_MUTATION_CACHE_UPDATES_KEY as c, MERGE_SHARED_SCOPE as l } from "../constants.mjs";
-//#region src/merge/merge-engines.ts
-var u = class {
-	constructor(r) {
-		this.previousSearchState = null, this.previousFilterState = null, this.previousSortState = null;
-		let { imports: a, data: u, filterByPreviousResult: d = !1, ...f } = r;
-		this.validateFilterByPreviousResultOptions(f.filter), this.state = new e(u, { filterByPreviousResult: d });
-		let p = new Set(a), m = null, h = null, g = null;
-		for (let e of p) {
-			let t = i(e);
-			if (!t) continue;
-			let r = this.getModuleInitOptions(t, e.name, f), a = n(e, u, this.state, r);
-			a && (a.moduleName === "search" && !m && (m = a), a.moduleName === "sort" && !h && (h = a), a.moduleName === "filter" && !g && (g = a));
-		}
-		this.searchModule = m, this.sortModule = h, this.filterModule = g, this.sortModule && this.state.setScopedValue(l, c, !0), this.searchModule && this.state.setScopedValue(l, s, !0), this.filterModule && this.state.setScopedValue(l, o, !0), this.state.subscribe((e) => this.handleStateMutation(e)), this.chainBuilder = new t({
-			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 i = {};
-		for (let a of [e, t]) {
-			let e = n[a];
-			r(e) && Object.assign(i, e);
-		}
-		return i;
-	}
-	validateFilterByPreviousResultOptions(e) {
-		if (r(e) && Object.prototype.hasOwnProperty.call(e, "filterByPreviousResult")) throw a.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 a.unavailableEngine("search");
-		let n = this.state.getOriginData(), r = this.state.getMutationVersion(), i = this.createSearchCacheKey(e, t), o = this.previousSearchState;
-		if (o?.originData === n && o.key === i && o.version === r) {
-			let e = this.resolvePendingSearchCache(o);
-			if (e !== null) return this.previousSearchState = e, this.withChain(this.trackPreviousResult(e.result, n));
-			this.previousSearchState = null;
-		}
-		let s = t === void 0 ? this.searchModule.executeSearch(e) : this.searchModule.executeSearch(e, t);
-		return this.previousSearchState = {
-			key: i,
-			originData: n,
-			result: s,
-			version: r,
-			field: t === void 0 ? null : e,
-			lowerQuery: (t ?? e).trim().toLowerCase(),
-			pendingMutations: []
-		}, this.withChain(this.trackPreviousResult(s, n));
-	}
-	sort(e, t, n) {
-		if (!this.sortModule) throw a.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 a.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 a.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 a.unavailableEngine(e);
-	}
-	data(e) {
-		return this.state.data(e), this;
-	}
-	clearData(e) {
-		if (this.getAdapter(e)) return this.state.clearData(), this;
-		throw a.unavailableEngine(e);
-	}
-};
-//#endregion
-export { u as MergeEngines };

package/dist/merge/module-adapters.d.ts

@@ -1,7 +0,0 @@
-import type { State } from "../State";
-import type { CollectionItem } from "../types";
-import type { EngineConstructor, MergeModuleAdapter, MergeModuleName } from "./types";
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare const resolveMergeModuleName: (EngineModule: EngineConstructor) => MergeModuleName | null;
-export declare const createMergeModuleAdapter: <T extends CollectionItem>(EngineModule: EngineConstructor, data: T[], state: State<T>, config: Record<string, unknown>) => MergeModuleAdapter<T> | null;
-//# sourceMappingURL=module-adapters.d.ts.map

package/dist/merge/module-adapters.mjs

@@ -1,41 +0,0 @@
-//#region src/merge/module-adapters.ts
-function e(e) {
-	return typeof e == "object" && !!e;
-}
-function t(t, n) {
-	return e(t) && typeof t[n] == "function";
-}
-function n(e) {
-	return t(e, "search") && t(e, "getOriginData");
-}
-function r(e) {
-	return t(e, "sort") && t(e, "getOriginData");
-}
-function i(e) {
-	return t(e, "rawFilter") && t(e, "getOriginData");
-}
-var a = (e) => {
-	let { prototype: t } = e;
-	return i(t) ? "filter" : r(t) ? "sort" : n(t) ? "search" : null;
-}, o = (e, t, a, o) => {
-	let s = new e({
-		data: t,
-		state: a,
-		...o
-	});
-	return i(s) ? {
-		moduleName: "filter",
-		executeFilter: (e, t) => t === void 0 ? s.rawFilter(e) : s.rawFilter(e, t),
-		clearIndexes: () => s.clearIndexes()
-	} : r(s) ? {
-		moduleName: "sort",
-		executeSort: (e, t, n) => t === void 0 ? s.sort(e) : s.sort(e, t, n),
-		clearIndexes: () => s.clearIndexes()
-	} : n(s) ? {
-		moduleName: "search",
-		executeSearch: (e, t) => t === void 0 ? s.search(e) : s.search(e, t),
-		clearIndexes: () => s.clearIndexes()
-	} : null;
-};
-//#endregion
-export { o as createMergeModuleAdapter, e as isRecord, a as resolveMergeModuleName };

package/dist/merge/types.d.ts

@@ -1,125 +0,0 @@
-import type { CollectionItem, FilterCriterion, StateMutation, SortDescriptor, UpdateDescriptor } from "../types";
-import type { MergeEngines } from "./merge-engines";
-export type MergeModuleName = "search" | "sort" | "filter";
-export interface MergeSearchOptions<T extends CollectionItem = CollectionItem> {
-    data?: T[];
-    fields?: (keyof T & string)[];
-    nestedFields?: string[];
-    minQueryLength?: number;
-    filterByPreviousResult?: boolean;
-}
-export interface MergeSortOptions<T extends CollectionItem = CollectionItem> {
-    data?: T[];
-    fields?: (keyof T & string)[];
-}
-export interface MergeFilterOptions<T extends CollectionItem = CollectionItem> {
-    data?: T[];
-    mutableExcludeField?: keyof T & string;
-    fields?: (keyof T & string)[];
-    nestedFields?: string[];
-}
-export interface MergeEnginesChain<T extends CollectionItem> {
-    search(query: string): T[] & MergeEnginesChain<T>;
-    search(field: (keyof T & string) | (string & {}), query: string): T[] & MergeEnginesChain<T>;
-    sort(descriptors: SortDescriptor<T>[]): T[] & MergeEnginesChain<T>;
-    sort(data: T[], descriptors: SortDescriptor<T>[], inPlace?: boolean): T[] & MergeEnginesChain<T>;
-    filter(criteria: FilterCriterion<T>[]): T[] & MergeEnginesChain<T>;
-    filter(data: T[], criteria: FilterCriterion<T>[]): T[] & MergeEnginesChain<T>;
-    getOriginData(): T[];
-    add(items: T[]): MergeEngines<T>;
-    update(descriptor: UpdateDescriptor<T>): MergeEngines<T>;
-    data(data: T[]): MergeEngines<T>;
-    clearIndexes(module: MergeModuleName): T[] & MergeEnginesChain<T>;
-    clearData(module: MergeModuleName): T[] & MergeEnginesChain<T>;
-}
-export interface EngineConstructor {
-    new (options: Record<string, unknown>): object;
-    prototype: object;
-    name: string;
-}
-export interface EngineApi {
-    [methodName: string]: ((...args: unknown[]) => unknown) | undefined;
-}
-export interface MergeEnginesOptions<T extends CollectionItem> {
-    imports: EngineConstructor[];
-    data: T[];
-    filterByPreviousResult?: boolean;
-    search?: MergeSearchOptions<T>;
-    filter?: MergeFilterOptions<T>;
-    sort?: MergeSortOptions<T>;
-    [key: string]: unknown;
-}
-export type MergeEnginesChainCallbacks<T extends CollectionItem> = {
-    search: (fieldOrQuery: string, maybeQuery?: string) => T[] & MergeEnginesChain<T>;
-    sort: (dataOrDescriptors: T[] | SortDescriptor<T>[], descriptors?: SortDescriptor<T>[], inPlace?: boolean) => T[] & MergeEnginesChain<T>;
-    filter: (dataOrCriteria: T[] | FilterCriterion<T>[], criteria?: FilterCriterion<T>[]) => T[] & MergeEnginesChain<T>;
-    getOriginData: () => T[];
-    add: (items: T[]) => MergeEngines<T>;
-    update: (descriptor: UpdateDescriptor<T>) => MergeEngines<T>;
-    data: (data: T[]) => MergeEngines<T>;
-    clearIndexes: (module: MergeModuleName) => MergeEngines<T>;
-    clearData: (module: MergeModuleName) => MergeEngines<T>;
-};
-export type BaseModuleAdapter = {
-    moduleName: MergeModuleName;
-    clearIndexes: () => unknown;
-};
-export type SearchModuleAdapter<T extends CollectionItem> = BaseModuleAdapter & {
-    moduleName: "search";
-    executeSearch: (fieldOrQuery: string, maybeQuery?: string) => T[];
-};
-export type SortModuleAdapter<T extends CollectionItem> = BaseModuleAdapter & {
-    moduleName: "sort";
-    executeSort: (dataOrDescriptors: T[] | SortDescriptor<T>[], descriptors?: SortDescriptor<T>[], inPlace?: boolean) => T[];
-};
-export type FilterModuleAdapter<T extends CollectionItem> = BaseModuleAdapter & {
-    moduleName: "filter";
-    executeFilter: (dataOrCriteria: T[] | FilterCriterion<T>[], criteria?: FilterCriterion<T>[]) => T[];
-};
-export interface MergeModuleAdapterMap<T extends CollectionItem> {
-    search: SearchModuleAdapter<T>;
-    sort: SortModuleAdapter<T>;
-    filter: FilterModuleAdapter<T>;
-}
-export type MergeModuleAdapter<T extends CollectionItem, TModuleName extends MergeModuleName = MergeModuleName> = MergeModuleAdapterMap<T>[TModuleName];
-export interface MergeBaseEngine {
-    clearIndexes(): unknown;
-}
-export interface MergeSearchEngine<T extends CollectionItem> extends MergeBaseEngine {
-    search(query: string): T[];
-    search(field: (keyof T & string) | (string & {}), query: string): T[];
-}
-export interface MergeSortEngine<T extends CollectionItem> extends MergeBaseEngine {
-    sort(descriptors: SortDescriptor<T>[]): T[];
-    sort(data: T[], descriptors: SortDescriptor<T>[], inPlace?: boolean): T[];
-}
-export interface MergeFilterEngine<T extends CollectionItem> extends MergeBaseEngine {
-    rawFilter(criteria: FilterCriterion<T>[]): T[];
-    rawFilter(data: T[], criteria: FilterCriterion<T>[]): T[];
-}
-export type MergeSearchCache<T extends CollectionItem> = {
-    key: string;
-    originData: T[];
-    result: T[];
-    version: number;
-    field: string | null;
-    lowerQuery: string;
-    pendingMutations: StateMutation<T>[];
-};
-export type MergeFilterCache<T extends CollectionItem> = {
-    key: string;
-    sourceData: T[];
-    result: T[];
-    version: number;
-    criteria: FilterCriterion<T>[];
-    pendingMutations: StateMutation<T>[];
-};
-export type MergeSortCache<T extends CollectionItem> = {
-    key: string;
-    sourceData: T[];
-    result: T[];
-    version: number;
-    descriptors: SortDescriptor<T>[];
-    pendingMutations: StateMutation<T>[];
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/search/constants.d.ts

@@ -1,5 +0,0 @@
-export declare const MINIMUM_NGRAM_LENGTH = 2;
-export declare const MAXIMUM_NGRAM_LENGTH = 3;
-export declare const MINIMUM_INDEXED_QUERY_LENGTH = 2;
-export declare const MAXIMUM_QUERY_GRAMS_FOR_INTERSECTION = 12;
-//# sourceMappingURL=constants.d.ts.map

package/dist/search/nested.d.ts

@@ -1,41 +0,0 @@
-import { CollectionItem } from "../types";
-import type { SearchNestedCollectionStorage } from "./types";
-export declare class SearchNestedCollection<T extends CollectionItem> {
-    private readonly storage;
-    private readonly registeredFields;
-    private readonly fieldDescriptors;
-    constructor(storage?: SearchNestedCollectionStorage);
-    registerFields(fieldPaths?: readonly string[]): void;
-    hasRegisteredFields(): boolean;
-    hasField(fieldPath: string): boolean;
-    hasIndexes(): boolean;
-    clearIndexes(): void;
-    buildIndexes(data: T[]): void;
-    addItems(items: T[], startIndex: number): void;
-    updateItem(item: T, previousItem: T, itemIndex: number): void;
-    removeItem(item: T, itemIndex: number): void;
-    moveItem(item: T, fromIndex: number, toIndex: number): void;
-    /**
-     * Returns dataset indices of items matching the query across all registered
-     * nested fields. Deduplicates indices that appear in multiple nested fields.
-     */
-    searchAllIndexedFieldIndices(lowerQuery: string, uniqueQueryGrams: ReadonlySet<string>, restrictionLookup?: Uint8Array | null, candidateIndices?: readonly number[] | null): number[];
-    searchIndexedField(data: T[], fieldPath: string, lowerQuery: string, uniqueQueryGrams: ReadonlySet<string>, restrictionLookup?: Uint8Array | null, candidateIndices?: readonly number[] | null, take?: number): T[];
-    /**
-     * Core indexed search for a nested field: returns dataset indices of items
-     * whose nested values match the query.
-     */
-    searchIndexedFieldIndices(fieldPath: string, lowerQuery: string, uniqueQueryGrams: ReadonlySet<string>, restrictionLookup?: Uint8Array | null, candidateIndices?: readonly number[] | null, take?: number): number[];
-    searchFieldLinear(data: T[], fieldPath: string, lowerQuery: string): T[];
-    searchFieldLinearIndices(data: T[], fieldPath: string, lowerQuery: string, sourceIndices?: readonly number[]): number[];
-    matchesAnyField(item: T, lowerQuery: string): boolean;
-    private registerField;
-    private getNormalizedValues;
-    private buildIndex;
-    private addItemsToField;
-    private updateItemInField;
-    private removeItemFromField;
-    private moveItemForField;
-    private getNormalizedItemValue;
-}
-//# sourceMappingURL=nested.d.ts.map