@devisfuture/mega-collection 2.4.6 → 2.4.7

package/dist/merge/merge-engines.d.ts

@@ -0,0 +1,75 @@
+/**
+ * MergeEngines class that provides a unified interface for text search,
+ * sorting, and filtering operations on collections.
+ */
+import type { CollectionItem, FilterCriterion, SortDescriptor, UpdateDescriptor } from "../types";
+import { MergeEnginesChain } from "./chain";
+import type { MergeEnginesOptions, MergeModuleName } from "./types";
+export declare class MergeEngines<T extends CollectionItem> {
+    private readonly state;
+    private previousSearchState;
+    private previousFilterState;
+    private previousSortState;
+    private readonly searchModule;
+    private readonly sortModule;
+    private readonly filterModule;
+    private readonly chainBuilder;
+    /**
+     * Creates a new MergeEngines instance with the given options.
+     * Collects all modules from imports.
+     */
+    constructor(options: MergeEnginesOptions<T>);
+    private getAdapter;
+    /**
+     * Gets the initialization options for a module.
+     */
+    private getModuleInitOptions;
+    private validateFilterByPreviousResultOptions;
+    private isPreviousResultEnabled;
+    private getPreviousResultInput;
+    private trackPreviousResult;
+    private clearOperationState;
+    private createSearchCacheKey;
+    private createSortCacheKey;
+    private createFilterCacheKey;
+    private handleStateMutation;
+    private queueSearchCacheMutation;
+    private queueFilterCacheMutation;
+    private queueSortCacheMutation;
+    private resolvePendingSortCache;
+    private resolvePendingSearchCache;
+    private resolvePendingFilterCache;
+    private applySortCacheMutation;
+    private applySearchCacheMutation;
+    private applyFilterCacheMutation;
+    private canPatchStoredDatasetSearch;
+    private canPatchStoredDatasetFilter;
+    private canPatchStoredDatasetSort;
+    private compareItemsByDescriptors;
+    private findSortInsertPosition;
+    private findDatasetInsertPosition;
+    private doesItemMatchSearchCache;
+    private patchSearchCacheForAddedItems;
+    private patchSearchCacheForUpdatedItem;
+    private isPatchableFilterCriterion;
+    private doesItemMatchFilterCache;
+    private patchFilterCacheForAddedItems;
+    private patchFilterCacheForUpdatedItem;
+    private patchSortCacheForAddedItems;
+    private patchSortCacheForUpdatedItem;
+    private patchSortCacheForRemovedItems;
+    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>;
+    private withChain;
+    getOriginData(): T[];
+    add(items: T[]): this;
+    update(descriptor: UpdateDescriptor<T>): this;
+    clearIndexes(module: MergeModuleName): this;
+    data(data: T[]): this;
+    clearData(module: MergeModuleName): this;
+}
+//# sourceMappingURL=merge-engines.d.ts.map

package/dist/{chunk-BURK5sks.mjs → merge/merge-engines.mjs}

@@ -1,95 +1,22 @@
-import { a as e, i as t, n, r, t as i } from "./chunk-BJZg_1dI.mjs";
-import { t as a } from "./chunk-C5Zpu_ol.mjs";
-//#region src/merge/chain.ts
-var o = class {
-	constructor(e) {
-		this.callbacks = e;
-	}
-	create(e) {
-		let t = e;
-		return Object.defineProperties(t, {
-			search: a((e, t) => t === void 0 ? this.callbacks.search(e) : this.callbacks.search(e, t)),
-			sort: a((t, n, r) => n === void 0 ? this.callbacks.sort(e, t, r) : this.callbacks.sort(t, n, r)),
-			filter: a((t, n) => n === void 0 ? this.callbacks.filter(e, t) : this.callbacks.filter(t, n)),
-			add: a((e) => this.callbacks.add(e)),
-			update: a((e) => this.callbacks.update(e)),
-			clearIndexes: a((t) => (this.callbacks.clearIndexes(t), this.create(e))),
-			clearData: a((t) => (this.callbacks.clearData(t), this.create(e))),
-			data: a((e) => this.callbacks.data(e)),
-			getOriginData: a(() => this.callbacks.getOriginData())
-		}), t;
-	}
-};
-//#endregion
-//#region src/merge/module-adapters.ts
-function s(e) {
-	return typeof e == "object" && !!e;
-}
-function c(e, t) {
-	return s(e) && typeof e[t] == "function";
-}
-function l(e) {
-	return c(e, "search") && c(e, "getOriginData");
-}
-function u(e) {
-	return c(e, "sort") && c(e, "getOriginData");
-}
-function d(e) {
-	return c(e, "rawFilter") && c(e, "getOriginData");
-}
-var f = (e) => {
-	let { prototype: t } = e;
-	return d(t) ? "filter" : u(t) ? "sort" : l(t) ? "search" : null;
-}, p = (e, t, n, r) => {
-	let i = new e({
-		data: t,
-		state: n,
-		...r
-	});
-	return d(i) ? {
-		moduleName: "filter",
-		executeFilter: (e, t) => t === void 0 ? i.rawFilter(e) : i.rawFilter(e, t),
-		clearIndexes: () => i.clearIndexes()
-	} : u(i) ? {
-		moduleName: "sort",
-		executeSort: (e, t, n) => t === void 0 ? i.sort(e) : i.sort(e, t, n),
-		clearIndexes: () => i.clearIndexes()
-	} : l(i) ? {
-		moduleName: "search",
-		executeSearch: (e, t) => t === void 0 ? i.search(e) : i.search(e, t),
-		clearIndexes: () => i.clearIndexes()
-	} : null;
-}, 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(a) {
+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: s, data: c, filterByPreviousResult: l = !1, ...u } = a;
-		this.validateFilterByPreviousResultOptions(u.filter), this.state = new e(c, { filterByPreviousResult: l });
-		let d = new Set(s), m = null, h = null, g = null;
-		for (let e of d) {
-			let t = f(e);
+		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 n = this.getModuleInitOptions(t, e.name, u), r = p(e, c, this.state, n);
-			r && (r.moduleName === "search" && !m && (m = r), r.moduleName === "sort" && !h && (h = r), r.moduleName === "filter" && !g && (g = r));
+			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(t, r, !0), this.searchModule && this.state.setScopedValue(t, n, !0), this.filterModule && this.state.setScopedValue(t, i, !0), this.state.subscribe((e) => this.handleStateMutation(e)), this.chainBuilder = new o({
+		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),
@@ -105,15 +32,15 @@ var f = (e) => {
 		return e === "search" ? this.searchModule : e === "sort" ? this.sortModule : this.filterModule;
 	}
 	getModuleInitOptions(e, t, n) {
-		let r = {};
-		for (let i of [e, t]) {
-			let e = n[i];
-			s(e) && Object.assign(r, e);
+		let i = {};
+		for (let a of [e, t]) {
+			let e = n[a];
+			r(e) && Object.assign(i, e);
 		}
-		return r;
+		return i;
 	}
 	validateFilterByPreviousResultOptions(e) {
-		if (s(e) && Object.prototype.hasOwnProperty.call(e, "filterByPreviousResult")) throw h.invalidFilterByPreviousResultOption();
+		if (r(e) && Object.prototype.hasOwnProperty.call(e, "filterByPreviousResult")) throw a.invalidFilterByPreviousResultOption();
 	}
 	isPreviousResultEnabled() {
 		return this.state.isFilterByPreviousResultEnabled();
@@ -413,26 +340,26 @@ var f = (e) => {
 		};
 	}
 	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 (!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 o = t === void 0 ? this.searchModule.executeSearch(e) : this.searchModule.executeSearch(e, t);
+		let s = t === void 0 ? this.searchModule.executeSearch(e) : this.searchModule.executeSearch(e, t);
 		return this.previousSearchState = {
 			key: i,
 			originData: n,
-			result: o,
+			result: s,
 			version: r,
 			field: t === void 0 ? null : e,
 			lowerQuery: (t ?? e).trim().toLowerCase(),
 			pendingMutations: []
-		}, this.withChain(this.trackPreviousResult(o, n));
+		}, this.withChain(this.trackPreviousResult(s, n));
 	}
 	sort(e, t, n) {
-		if (!this.sortModule) throw h.unavailableEngine("sort");
+		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;
@@ -454,7 +381,7 @@ var f = (e) => {
 		return this.withChain(this.trackPreviousResult(this.sortModule.executeSort(r, i, n), r));
 	}
 	filter(e, t) {
-		if (!this.filterModule) throw h.unavailableEngine("filter");
+		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) {
@@ -480,7 +407,7 @@ var f = (e) => {
 	}
 	getOriginData() {
 		if (this.searchModule || this.sortModule || this.filterModule) return this.state.getOriginData();
-		throw h.unavailableGetOriginData();
+		throw a.unavailableGetOriginData();
 	}
 	add(e) {
 		return e.length === 0 || this.state.add(e), this;
@@ -491,15 +418,15 @@ var f = (e) => {
 	clearIndexes(e) {
 		let t = this.getAdapter(e);
 		if (t) return t.clearIndexes(), this.clearOperationState(e), this;
-		throw h.unavailableEngine(e);
+		throw a.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);
+		throw a.unavailableEngine(e);
 	}
 };
 //#endregion
-export { g as t };
+export { u as MergeEngines };

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

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

@@ -0,0 +1,41 @@
+//#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

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

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