@devisfuture/mega-collection 2.4.5 → 2.4.7

package/dist/filter/nested.d.ts

@@ -0,0 +1,32 @@
+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

package/dist/filter/nested.mjs

@@ -0,0 +1,246 @@
+import { createNestedFieldDescriptor as e } from "../internal.mjs";
+import { resolveCriteria as t } from "./criterion.mjs";
+//#region src/filter/nested.ts
+var n = class {
+	constructor(e = {
+		indexes: /* @__PURE__ */ new Map(),
+		itemPositions: /* @__PURE__ */ new Map()
+	}) {
+		this.storage = e, this.registeredFields = /* @__PURE__ */ new Set(), this.fieldDescriptors = /* @__PURE__ */ new Map();
+	}
+	registerFields(e) {
+		if (e?.length) for (let t = 0; t < e.length; t++) this.registerField(e[t]);
+	}
+	hasRegisteredFields() {
+		return this.registeredFields.size > 0;
+	}
+	hasField(e) {
+		return this.registeredFields.has(e);
+	}
+	clearIndexes() {
+		this.storage.indexes.clear(), this.storage.itemPositions.clear();
+	}
+	buildIndexes(e) {
+		this.storage.indexes.clear(), this.storage.itemPositions.clear();
+		for (let t of this.registeredFields) this.buildIndex(e, t);
+	}
+	addItems(e) {
+		if (!(e.length === 0 || this.storage.indexes.size === 0)) for (let t = 0; t < e.length; t++) this.addItem(e[t]);
+	}
+	removeItem(e) {
+		for (let t of this.storage.indexes.keys()) this.removeItemFromIndex(t, e);
+	}
+	updateItem(e, t) {
+		for (let n of this.storage.indexes.keys()) this.updateItemInIndex(n, e, t);
+	}
+	filter(e, t, n) {
+		let r = this.resolveCriteria(t);
+		if (e.length === 0 || r.length === 0) return e;
+		let i = [], a = [];
+		for (let e = 0; e < r.length; e++) {
+			let t = r[e];
+			if (this.storage.indexes.has(t.field)) {
+				i.push(t);
+				continue;
+			}
+			a.push(t);
+		}
+		let o = e;
+		if (i.length > 0 && (o = this.filterByIndexes(i, e, n), o.length === 0)) return o;
+		for (let e = 0; e < a.length; e++) if (o = this.filterLinearly(o, a[e]), o.length === 0) return o;
+		return o;
+	}
+	resolveCriteria(e) {
+		if (e.length === 0) return [];
+		let n = e[0];
+		return "hasValues" in n && "hasExclude" in n && "includedValues" in n ? e : t(e);
+	}
+	registerField(t) {
+		let n = e(t);
+		n && (this.registeredFields.add(t), this.fieldDescriptors.set(t, n));
+	}
+	buildIndex(e, t) {
+		let n = this.fieldDescriptors.get(t);
+		if (!n) return;
+		let { collectionKey: r, nestedKey: i } = n, a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map();
+		for (let t = 0, n = e.length; t < n; t++) {
+			let n = e[t], s = n[r];
+			if (Array.isArray(s)) for (let e = 0; e < s.length; e++) {
+				let t = s[e][i];
+				if (t == null) continue;
+				let r = a.get(t);
+				if (r) {
+					r[r.length - 1] !== n && (r.push(n), o.get(t).set(n, r.length - 1));
+					continue;
+				}
+				a.set(t, [n]);
+				let c = /* @__PURE__ */ new WeakMap();
+				c.set(n, 0), o.set(t, c);
+			}
+		}
+		this.storage.indexes.set(t, a), this.storage.itemPositions.set(t, o);
+	}
+	removeItemFromIndex(e, t) {
+		let n = this.fieldDescriptors.get(e), r = this.storage.indexes.get(e), i = this.storage.itemPositions.get(e);
+		if (!n || !r || !i) return;
+		let { collectionKey: a, nestedKey: o } = n, s = t[a];
+		if (!Array.isArray(s) || s.length === 0) return;
+		let c = /* @__PURE__ */ new Set();
+		for (let e = 0; e < s.length; e++) {
+			let t = s[e][o];
+			t != null && c.add(t);
+		}
+		for (let e of c) {
+			let n = r.get(e), a = i.get(e), o = a?.get(t);
+			if (!n || !a || o === void 0) continue;
+			let s = n.length - 1, c = n[s];
+			o !== s && (n[o] = c, a.set(c, o)), n.pop(), a.delete(t), n.length === 0 && (r.delete(e), i.delete(e));
+		}
+	}
+	addItem(e) {
+		for (let t of this.storage.indexes.keys()) this.addItemToIndex(t, e);
+	}
+	addItemToIndex(e, t) {
+		let n = this.fieldDescriptors.get(e), r = this.storage.indexes.get(e), i = this.storage.itemPositions.get(e);
+		if (!n || !r || !i) return;
+		let { collectionKey: a, nestedKey: o } = n, s = t[a];
+		if (!Array.isArray(s) || s.length === 0) return;
+		let c = /* @__PURE__ */ new Set();
+		for (let e = 0; e < s.length; e++) {
+			let t = s[e][o];
+			t != null && c.add(t);
+		}
+		for (let e of c) {
+			let n = r.get(e), a = i.get(e);
+			if (n && a) {
+				n.push(t), a.set(t, n.length - 1);
+				continue;
+			}
+			r.set(e, [t]);
+			let o = /* @__PURE__ */ new WeakMap();
+			o.set(t, 0), i.set(e, o);
+		}
+	}
+	updateItemInIndex(e, t, n) {
+		let r = this.fieldDescriptors.get(e), i = this.storage.indexes.get(e), a = this.storage.itemPositions.get(e);
+		if (!r || !i || !a) return;
+		let o = this.collectUniqueValues(n, r), s = this.collectUniqueValues(t, r);
+		if (this.areValueSetsEqual(o, s)) {
+			for (let e of o) {
+				let r = i.get(e), o = a.get(e), s = o?.get(n);
+				!r || !o || s === void 0 || (r[s] = t, o.delete(n), o.set(t, s));
+			}
+			return;
+		}
+		this.removeItemFromIndex(e, n), this.addItemToIndex(e, t);
+	}
+	collectUniqueValues(e, t) {
+		let { collectionKey: n, nestedKey: r } = t, i = e[n], a = /* @__PURE__ */ new Set();
+		if (!Array.isArray(i) || i.length === 0) return a;
+		for (let e = 0; e < i.length; e++) {
+			let t = i[e][r];
+			t != null && a.add(t);
+		}
+		return a;
+	}
+	areValueSetsEqual(e, t) {
+		if (e.size !== t.size) return !1;
+		for (let n of e) if (!t.has(n)) return !1;
+		return !0;
+	}
+	filterByIndexes(e, t, n) {
+		let r = e.filter((e) => e.hasValues), i = e.filter((e) => e.hasExclude), a = t === n ? null : new Set(t);
+		if (r.length === 0) return this.applyIndexedExclusions(t, i);
+		if (r.length === 1) {
+			let e = this.storage.indexes.get(r[0].field);
+			if (!e) return [];
+			let t = this.getItemsByValues(e, r[0].values);
+			if (t.length === 0) return [];
+			let n = [];
+			for (let e = 0; e < t.length; e++) {
+				let r = t[e];
+				a && !a.has(r) || n.push(r);
+			}
+			return this.applyIndexedExclusions(n, i);
+		}
+		let o = r.map((e) => ({
+			criterion: e,
+			size: this.estimateIndexSize(e)
+		})).sort((e, t) => e.size - t.size), s = a, c = [];
+		for (let e = 0; e < o.length; e++) {
+			let { criterion: t } = o[e], n = this.storage.indexes.get(t.field);
+			if (!n) return [];
+			let r = this.getItemsByValues(n, t.values);
+			if (r.length === 0) return [];
+			if (s === null) c = r;
+			else {
+				c = [];
+				for (let e = 0; e < r.length; e++) {
+					let t = r[e];
+					s.has(t) && c.push(t);
+				}
+			}
+			if (c.length === 0) return [];
+			s = new Set(c);
+		}
+		return this.applyIndexedExclusions(c, i);
+	}
+	getItemsByValues(e, t) {
+		if (t.length === 1) return e.get(t[0]) ?? [];
+		let n = /* @__PURE__ */ new Set(), r = [];
+		for (let i = 0; i < t.length; i++) {
+			let a = e.get(t[i]);
+			if (a) for (let e = 0; e < a.length; e++) {
+				let t = a[e];
+				n.has(t) || (n.add(t), r.push(t));
+			}
+		}
+		return r;
+	}
+	estimateIndexSize(e) {
+		let t = this.storage.indexes.get(e.field);
+		return t ? e.values.reduce((e, n) => {
+			let r = t.get(n);
+			return r ? e + r.length : e;
+		}, 0) : Infinity;
+	}
+	filterLinearly(e, t) {
+		let n = this.fieldDescriptors.get(t.field);
+		if (!n) return e;
+		let { collectionKey: r, nestedKey: i } = n, a = [];
+		for (let n = 0; n < e.length; n++) {
+			let o = e[n], s = o[r];
+			if (!Array.isArray(s)) continue;
+			let c = !t.hasValues, l = !1;
+			for (let e = 0; e < s.length; e++) {
+				let n = s[e][i];
+				if (t.hasExclude && t.excludedValues.has(n)) {
+					l = !0;
+					break;
+				}
+				t.hasValues && t.includedValues.has(n) && (c = !0);
+			}
+			!l && c && a.push(o);
+		}
+		return a;
+	}
+	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.storage.indexes.get(r.field);
+			if (!i) continue;
+			let a = this.getItemsByValues(i, r.exclude);
+			for (let e = 0; e < a.length; e++) n.add(a[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;
+	}
+};
+//#endregion
+export { n as FilterNestedCollection };

package/dist/filter/types.d.ts

@@ -0,0 +1,74 @@
+import type { IndexerStorage } from "../indexer";
+import type { CollectionItem, FilterCriterion } from "../types";
+import type { FilterEngine } from "./filter";
+export type FilterNestedCollectionStorage<T extends CollectionItem> = IndexerStorage<T>;
+export interface FilterEngineChain<T extends CollectionItem> {
+    filter(criteria: FilterCriterion<T>[]): T[] & FilterEngineChain<T>;
+    filter(data: T[], criteria: FilterCriterion<T>[]): T[] & FilterEngineChain<T>;
+    getOriginData(): T[];
+    add(items: T[]): FilterEngine<T>;
+    update(descriptor: import("../types").UpdateDescriptor<T>): FilterEngine<T>;
+    data(data: T[]): FilterEngine<T>;
+    clearIndexes(): FilterEngine<T>;
+    clearData(): FilterEngine<T>;
+    resetFilterState(): FilterEngine<T>;
+}
+export interface FilterEngineOptions<T extends CollectionItem = CollectionItem> {
+    data?: T[];
+    mutableExcludeField?: keyof T & string;
+    fields?: (keyof T & string)[];
+    nestedFields?: string[];
+    filterByPreviousResult?: boolean;
+}
+export type NestedFieldDescriptor = {
+    collectionKey: string;
+    nestedKey: string;
+};
+export type ResolvedFilterCriterion<T extends CollectionItem> = {
+    field: FilterCriterion<T>["field"];
+    values: any[];
+    exclude: any[];
+    hasValues: boolean;
+    hasExclude: boolean;
+    includedValues: Set<any> | null;
+    excludedValues: Set<any> | null;
+    cacheKeySegment: string;
+};
+export type FilterSequentialCacheEntry<T extends CollectionItem> = {
+    result: T[];
+    resultSet: Set<T> | null;
+};
+export type FilterEngineChainCallbacks<T extends CollectionItem> = {
+    filter: (dataOrCriteria: T[] | FilterCriterion<T>[], criteria?: FilterCriterion<T>[]) => T[] & FilterEngineChain<T>;
+    getOriginData: () => T[];
+    add: (items: T[]) => FilterEngine<T>;
+    update: (descriptor: import("../types").UpdateDescriptor<T>) => FilterEngine<T>;
+    data: (data: T[]) => FilterEngine<T>;
+    clearIndexes: () => FilterEngine<T>;
+    clearData: () => FilterEngine<T>;
+    resetFilterState: () => FilterEngine<T>;
+};
+export type FilterSequentialCache<T extends CollectionItem> = {
+    previousResult: T[] | null;
+    previousCriteria: ResolvedFilterCriterion<T>[] | null;
+    previousCriteriaKey: string | null;
+    previousBaseData: T[] | null;
+    previousResultsByCriteria: Map<string, FilterSequentialCacheEntry<T>>;
+    /** Cached Set of previousResult items — avoids O(m) Set construction on each filterViaIndex narrowing call. */
+    previousResultSet: Set<T> | null;
+};
+export type MutableExcludeRuntime = {
+    datasetPositions: Map<any, number>;
+    valueCounts: Map<any, number>;
+    duplicateValueCount: number;
+    hasDuplicateValues: boolean;
+};
+export type FilterRuntime<T extends CollectionItem> = {
+    indexedFields: Set<keyof T & string>;
+    indexerStorage: IndexerStorage<T>;
+    nestedStorage: FilterNestedCollectionStorage<T>;
+    deferredMutationVersion: number | null;
+    mutableExclude: MutableExcludeRuntime;
+    sequentialCache: FilterSequentialCache<T>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/filter/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CollectionItem } from "../types";
+import type { FilterRuntime } from "./types";
+export declare const createFilterRuntime: <T extends CollectionItem>() => FilterRuntime<T>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/filter/utils.mjs

@@ -0,0 +1,29 @@
+//#region src/filter/utils.ts
+var e = () => ({
+	indexedFields: /* @__PURE__ */ new Set(),
+	indexerStorage: {
+		indexes: /* @__PURE__ */ new Map(),
+		itemPositions: /* @__PURE__ */ new Map()
+	},
+	nestedStorage: {
+		indexes: /* @__PURE__ */ new Map(),
+		itemPositions: /* @__PURE__ */ new Map()
+	},
+	deferredMutationVersion: null,
+	mutableExclude: {
+		datasetPositions: /* @__PURE__ */ new Map(),
+		valueCounts: /* @__PURE__ */ new Map(),
+		duplicateValueCount: 0,
+		hasDuplicateValues: !1
+	},
+	sequentialCache: {
+		previousResult: null,
+		previousCriteria: null,
+		previousCriteriaKey: null,
+		previousBaseData: null,
+		previousResultsByCriteria: /* @__PURE__ */ new Map(),
+		previousResultSet: null
+	}
+});
+//#endregion
+export { e as createFilterRuntime };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as e } from "./chunk-BURK5sks.mjs";
+import { MergeEngines as e } from "./merge/merge-engines.mjs";
 export { e as MergeEngines };

package/dist/indexer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Indexer class that builds hash-map indexes for exact-value lookups
+ * on collection fields, enabling O(1) queries.
+ */
+import { CollectionItem } from "./types";
+export interface IndexerStorage<T extends CollectionItem> {
+    indexes: Map<string, Map<any, T[]>>;
+    itemPositions: Map<string, Map<any, WeakMap<T, number>>>;
+}
+export declare class Indexer<T extends CollectionItem> {
+    private readonly storage;
+    constructor(storage?: IndexerStorage<T>);
+    addItems(items: T[]): void;
+    /**
+     * Builds an index for the given field and data.
+     */
+    buildIndex(data: T[], field: keyof T & string): void;
+    /**
+     * Gets items that match the given value for the field.
+     */
+    getByValue(field: keyof T & string, value: any): T[];
+    /**
+     * Gets items that match any of the given values for the field.
+     *
+     * Note: buildIndex indexes scalar field values, so buckets are always
+     * disjoint — deduplication via Set is not needed. If multi-value field
+     * indexing is ever added, re-introduce dedup here.
+     */
+    getByValues(field: keyof T & string, values: any[]): T[];
+    hasIndex(field: string): boolean;
+    addItem(item: T): void;
+    updateItem(previousItem: T, nextItem: T): void;
+    removeItem(item: T): void;
+    clear(): void;
+    getIndexMap(field: string): Map<any, T[]> | undefined;
+    private removeItemFromField;
+    private updateItemInField;
+    private replaceItemReferenceInField;
+    private addItemToField;
+}
+//# sourceMappingURL=indexer.d.ts.map

package/dist/indexer.mjs

@@ -0,0 +1,101 @@
+//#region src/indexer.ts
+var e = class {
+	constructor(e = {
+		indexes: /* @__PURE__ */ new Map(),
+		itemPositions: /* @__PURE__ */ new Map()
+	}) {
+		this.storage = e;
+	}
+	addItems(e) {
+		if (!(e.length === 0 || this.storage.indexes.size === 0)) for (let t = 0; t < e.length; t++) this.addItem(e[t]);
+	}
+	buildIndex(e, t) {
+		let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
+		for (let i = 0, a = e.length; i < a; i++) {
+			let a = e[i], o = a[t];
+			if (o == null) continue;
+			let s = n.get(o);
+			if (s) s.push(a), r.get(o).set(a, s.length - 1);
+			else {
+				n.set(o, [a]);
+				let e = /* @__PURE__ */ new WeakMap();
+				e.set(a, 0), r.set(o, e);
+			}
+		}
+		this.storage.indexes.set(t, n), this.storage.itemPositions.set(t, r);
+	}
+	getByValue(e, t) {
+		let n = this.storage.indexes.get(e);
+		return n ? n.get(t) ?? [] : [];
+	}
+	getByValues(e, t) {
+		let n = this.storage.indexes.get(e);
+		if (!n) return [];
+		if (t.length === 1) return n.get(t[0]) ?? [];
+		if (t.length === 2) {
+			let e = n.get(t[0]), r = n.get(t[1]);
+			return e ? r ? e.concat(r) : e : r ?? [];
+		}
+		let r = [];
+		for (let e = 0; e < t.length; e++) {
+			let i = n.get(t[e]);
+			if (i !== void 0) for (let e = 0; e < i.length; e++) r.push(i[e]);
+		}
+		return r;
+	}
+	hasIndex(e) {
+		return this.storage.indexes.has(e);
+	}
+	addItem(e) {
+		for (let t of this.storage.indexes.keys()) this.addItemToField(t, e);
+	}
+	updateItem(e, t) {
+		for (let n of this.storage.indexes.keys()) this.updateItemInField(n, e, t);
+	}
+	removeItem(e) {
+		for (let t of this.storage.indexes.keys()) this.removeItemFromField(t, e);
+	}
+	clear() {
+		this.storage.indexes.clear(), this.storage.itemPositions.clear();
+	}
+	getIndexMap(e) {
+		return this.storage.indexes.get(e);
+	}
+	removeItemFromField(e, t) {
+		let n = t[e];
+		if (n == null) return;
+		let r = this.storage.indexes.get(e), i = this.storage.itemPositions.get(e), a = r?.get(n), o = i?.get(n), s = o?.get(t);
+		if (!r || !i || !a || !o || s === void 0) return;
+		let c = a.length - 1, l = a[c];
+		s !== c && (a[s] = l, o.set(l, s)), a.pop(), o.delete(t), a.length === 0 && (r.delete(n), i.delete(n));
+	}
+	updateItemInField(e, t, n) {
+		let r = t[e];
+		if (r === n[e]) {
+			if (r == null) return;
+			this.replaceItemReferenceInField(e, r, t, n);
+			return;
+		}
+		this.removeItemFromField(e, t), this.addItemToField(e, n);
+	}
+	replaceItemReferenceInField(e, t, n, r) {
+		let i = this.storage.indexes.get(e), a = this.storage.itemPositions.get(e), o = i?.get(t), s = a?.get(t), c = s?.get(n);
+		!o || !s || c === void 0 || (o[c] = r, s.delete(n), s.set(r, c));
+	}
+	addItemToField(e, t) {
+		let n = t[e];
+		if (n == null) return;
+		let r = this.storage.indexes.get(e), i = this.storage.itemPositions.get(e);
+		if (!r || !i) return;
+		let a = r.get(n), o = i.get(n);
+		if (a && o) {
+			a.push(t), o.set(t, a.length - 1);
+			return;
+		}
+		r.set(n, [t]);
+		let s = /* @__PURE__ */ new WeakMap();
+		s.set(t, 0), i.set(n, s);
+	}
+};
+//#endregion
+export { e as Indexer };

package/dist/internal.d.ts

@@ -0,0 +1,6 @@
+export declare function createChainMethodDescriptor<TValue>(value: TValue): PropertyDescriptor;
+export declare function createNestedFieldDescriptor(fieldPath: string): {
+    collectionKey: string;
+    nestedKey: string;
+} | null;
+//# sourceMappingURL=internal.d.ts.map

package/dist/{chunk-C5Zpu_ol.mjs → internal.mjs}

@@ -15,4 +15,4 @@ function t(e) {
 	};
 }
 //#endregion
-export { t as n, e as t };
+export { e as createChainMethodDescriptor, t as createNestedFieldDescriptor };

package/dist/merge/chain.d.ts

@@ -0,0 +1,9 @@
+import type { CollectionItem } from "../types";
+import type { MergeEnginesChain, MergeEnginesChainCallbacks } from "./types";
+export type { MergeEnginesChain, MergeModuleName } from "./types";
+export declare class MergeEnginesChainBuilder<T extends CollectionItem> {
+    private readonly callbacks;
+    constructor(callbacks: MergeEnginesChainCallbacks<T>);
+    create(result: T[]): T[] & MergeEnginesChain<T>;
+}
+//# sourceMappingURL=chain.d.ts.map

package/dist/merge/chain.mjs

@@ -0,0 +1,23 @@
+import { createChainMethodDescriptor as e } from "../internal.mjs";
+//#region src/merge/chain.ts
+var t = class {
+	constructor(e) {
+		this.callbacks = e;
+	}
+	create(t) {
+		let n = t;
+		return Object.defineProperties(n, {
+			search: e((e, t) => t === void 0 ? this.callbacks.search(e) : this.callbacks.search(e, t)),
+			sort: e((e, n, r) => n === void 0 ? this.callbacks.sort(t, e, r) : this.callbacks.sort(e, n, r)),
+			filter: e((e, n) => n === void 0 ? this.callbacks.filter(t, e) : this.callbacks.filter(e, n)),
+			add: e((e) => this.callbacks.add(e)),
+			update: e((e) => this.callbacks.update(e)),
+			clearIndexes: e((e) => (this.callbacks.clearIndexes(e), this.create(t))),
+			clearData: e((e) => (this.callbacks.clearData(e), this.create(t))),
+			data: e((e) => this.callbacks.data(e)),
+			getOriginData: e(() => this.callbacks.getOriginData())
+		}), n;
+	}
+};
+//#endregion
+export { t as MergeEnginesChainBuilder };

package/dist/merge/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const MODULE_TO_ENGINE: {
+    readonly search: "TextSearchEngine";
+    readonly sort: "SortEngine";
+    readonly filter: "FilterEngine";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/merge/constants.mjs

@@ -0,0 +1,8 @@
+//#region src/merge/constants.ts
+var e = {
+	search: "TextSearchEngine",
+	sort: "SortEngine",
+	filter: "FilterEngine"
+};
+//#endregion
+export { e as MODULE_TO_ENGINE };

package/dist/merge/errors.d.ts

@@ -0,0 +1,8 @@
+import type { MergeModuleName } from "./types";
+export declare class MergeEnginesError extends Error {
+    constructor(message: string);
+    static unavailableEngine(module: MergeModuleName): MergeEnginesError;
+    static unavailableGetOriginData(): MergeEnginesError;
+    static invalidFilterByPreviousResultOption(): MergeEnginesError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/merge/errors.mjs

@@ -0,0 +1,19 @@
+import { MODULE_TO_ENGINE as e } from "./constants.mjs";
+//#region src/merge/errors.ts
+var t = class t extends Error {
+	constructor(e) {
+		super(e), this.name = "MergeEnginesError";
+	}
+	static unavailableEngine(n) {
+		let r = e[n];
+		return new t(`MergeEngines: ${r} is not available.`);
+	}
+	static unavailableGetOriginData() {
+		return new t("MergeEngines: getOriginData is not available.");
+	}
+	static invalidFilterByPreviousResultOption() {
+		return new t("MergeEngines: \"filter.filterByPreviousResult\" is not supported. Configure \"filterByPreviousResult\" on the MergeEngines root options.");
+	}
+};
+//#endregion
+export { t as MergeEnginesError };

package/dist/merge/index.mjs

@@ -1,2 +1,2 @@
-import { t as e } from "../chunk-BURK5sks.mjs";
+import { MergeEngines as e } from "./merge-engines.mjs";
 export { e as MergeEngines };