@devisfuture/mega-collection 2.4.5 → 2.4.7

package/dist/search/types.d.ts

@@ -0,0 +1,93 @@
+import type { CollectionItem } from "../types";
+export interface TextSearchEngineOptions<T extends CollectionItem = CollectionItem> {
+    data?: T[];
+    fields?: (keyof T & string)[];
+    nestedFields?: string[];
+    /**
+     * Minimum query length required to trigger a search. Defaults to `1`.
+     *
+     * Queries shorter than the trigram length (3) always use a linear scan even
+     * when an index is configured, because the index only stores trigrams. Set
+     * `minQueryLength` to `3` or higher to skip sub-trigram queries entirely and
+     * guarantee that every accepted query hits the index.
+     */
+    minQueryLength?: number;
+    /**
+     * When `true`, each search narrows its source to the previous result if the
+     * new query includes the previous query as a prefix/substring. Useful for
+     * search-as-you-type scenarios where the user incrementally refines the query.
+     *
+     * Call {@link TextSearchEngine.resetSearchState} to discard the saved result
+     * and force the next search to scan the full dataset.
+     */
+    filterByPreviousResult?: boolean;
+    /**
+     * Suppresses non-production fallback warnings.
+     * Diagnostic warnings also stop accumulating in {@link TextSearchEngine.getWarnings}.
+     */
+    silent?: boolean;
+}
+export interface SearchQueryOptions {
+    limit?: number;
+    offset?: number;
+}
+export interface TextSearchEngineStats {
+    totalQueries: number;
+    indexedQueries: number;
+    fallbackQueries: number;
+    fallbackRate: number;
+    fallbackFields: Record<string, number>;
+}
+export type NestedFieldDescriptor = {
+    collectionKey: string;
+    nestedKey: string;
+};
+export type SearchIndex = {
+    ngramMap: Map<string, Set<number>>;
+    normalizedValues: string[];
+    version: number;
+};
+export interface SearchNestedCollectionStorage {
+    ngramIndexes: Map<string, Map<string, Set<number>>>;
+    normalizedFieldValues: Map<string, string[]>;
+}
+export type SearchRuntime<T extends CollectionItem> = {
+    indexedFields: Set<keyof T & string>;
+    flatIndexes: Map<string, SearchIndex>;
+    nestedStorage: SearchNestedCollectionStorage;
+    deferredMutationVersion: number | null;
+    filterByPreviousResult: boolean;
+    previousResultIndices: number[] | null;
+    previousResultLookup: Uint8Array | null;
+    previousQuery: string | null;
+    stats: {
+        totalQueries: number;
+        indexedQueries: number;
+        fallbackQueries: number;
+        fallbackFields: Map<string, number>;
+    };
+};
+export type SearchResult<T extends CollectionItem> = {
+    items: T[];
+    indices: number[];
+};
+export type SearchWindow = {
+    offset: number;
+    limit: number;
+    take: number;
+    hasWindow: boolean;
+};
+export type SearchSource = {
+    indices: number[] | null;
+    lookup: Uint8Array | null;
+};
+export type IntersectPostingListsOptions = {
+    restrictionLookup?: Uint8Array | null;
+    take?: number;
+};
+export type IntersectPostingListsInCandidatesOptions = {
+    candidateIndices: readonly number[];
+    restrictionLookup?: Uint8Array | null;
+    take?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/search/utils.d.ts

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

package/dist/search/utils.mjs

@@ -0,0 +1,22 @@
+//#region src/search/utils.ts
+var e = () => ({
+	indexedFields: /* @__PURE__ */ new Set(),
+	flatIndexes: /* @__PURE__ */ new Map(),
+	nestedStorage: {
+		ngramIndexes: /* @__PURE__ */ new Map(),
+		normalizedFieldValues: /* @__PURE__ */ new Map()
+	},
+	deferredMutationVersion: null,
+	filterByPreviousResult: !1,
+	previousResultIndices: null,
+	previousResultLookup: null,
+	previousQuery: null,
+	stats: {
+		totalQueries: 0,
+		indexedQueries: 0,
+		fallbackQueries: 0,
+		fallbackFields: /* @__PURE__ */ new Map()
+	}
+});
+//#endregion
+export { e as createSearchRuntime };

package/dist/sort/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class SortEngineError extends Error {
+    constructor(message: string);
+    static missingDatasetForSort(): SortEngineError;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/sort/errors.mjs

@@ -0,0 +1,11 @@
+//#region src/sort/errors.ts
+var e = class e extends Error {
+	constructor(e) {
+		super(e), this.name = "SortEngineError";
+	}
+	static missingDatasetForSort() {
+		return new e("SortEngine: no dataset in memory.");
+	}
+};
+//#endregion
+export { e as SortEngineError };

package/dist/sort/index.mjs

@@ -1,416 +1,2 @@
-import { a as e, i as t, r as n } from "../chunk-BJZg_1dI.mjs";
-//#region src/sort/errors.ts
-var r = class e extends Error {
-	constructor(e) {
-		super(e), this.name = "SortEngineError";
-	}
-	static missingDatasetForSort() {
-		return new e("SortEngine: no dataset in memory.");
-	}
-};
-//#endregion
-//#region src/sort/utils.ts
-function i(e, t) {
-	for (let n = 0; n < t; n++) {
-		let t = e[n];
-		if (t !== t >>> 0) return !1;
-	}
-	return !0;
-}
-function a(e, t, n) {
-	let r = new Uint32Array(n), i = new Uint32Array(65536);
-	for (let r = 0; r < n; r++) i[t[e[r]] & 65535]++;
-	let a = 0;
-	for (let e = 0; e < 65536; e++) {
-		let t = i[e];
-		i[e] = a, a += t;
-	}
-	for (let a = 0; a < n; a++) {
-		let n = t[e[a]] & 65535;
-		r[i[n]++] = e[a];
-	}
-	i.fill(0);
-	for (let e = 0; e < n; e++) i[t[r[e]] >>> 16 & 65535]++;
-	a = 0;
-	for (let e = 0; e < 65536; e++) {
-		let t = i[e];
-		i[e] = a, a += t;
-	}
-	for (let a = 0; a < n; a++) {
-		let n = t[r[a]] >>> 16 & 65535;
-		e[i[n]++] = r[a];
-	}
-}
-var o = () => ({
-	indexedFields: /* @__PURE__ */ new Set(),
-	cache: /* @__PURE__ */ new Map()
-}), s = class {
-	constructor(t = {}) {
-		if (this.state = t.state ?? new e(t.data ?? []), this.namespace = this.state.createNamespace("sort"), this.state.subscribe((e) => this.handleStateMutation(e)), t.fields?.length) {
-			for (let e of t.fields) this.indexedFields.add(e);
-			this.dataset.length > 0 && this.rebuildConfiguredIndexes();
-		}
-	}
-	get dataset() {
-		return this.state.getOriginData();
-	}
-	get runtime() {
-		return this.state.getOrCreateScopedValue(this.namespace, "runtime", o);
-	}
-	get cache() {
-		return this.runtime.cache;
-	}
-	get indexedFields() {
-		return this.runtime.indexedFields;
-	}
-	shouldDeferMutationCacheUpdates() {
-		return this.state.getScopedValue(t, n) === !0;
-	}
-	invalidateCachedIndexes() {
-		for (let e of this.indexedFields) this.cache.delete(e);
-	}
-	rebuildConfiguredIndexes() {
-		this.cache.clear();
-		for (let e of this.indexedFields) this.buildIndexForDataset(e);
-	}
-	buildIndexForDataset(e) {
-		this.dataset.length && this.buildIndexFromData(this.dataset, e);
-	}
-	buildIndexFromData(e, t) {
-		let n = e.length, r = new Uint32Array(n);
-		for (let e = 0; e < n; e++) r[e] = e;
-		let o = 0;
-		for (; o < n && e[o][t] == null;) o++;
-		if (o < n && typeof e[o][t] == "number") {
-			let o = new Float64Array(n);
-			for (let r = 0; r < n; r++) o[r] = e[r][t];
-			i(o, n) ? a(r, o, n) : r.sort((e, t) => o[e] - o[t]);
-		} else {
-			let i = Array(n);
-			for (let r = 0; r < n; r++) i[r] = e[r][t];
-			r.sort((e, t) => {
-				let n = i[e], r = i[t];
-				return n < r ? -1 : n > r ? 1 : 0;
-			});
-		}
-		let s = new Uint32Array(n);
-		for (let e = 0; e < n; e++) s[r[e]] = e;
-		this.cache.set(t, {
-			indexes: r,
-			reverseIndex: s,
-			ascItems: null,
-			descItems: null,
-			hasDuplicateValues: this.hasDuplicateValuesForIndexes(e, r, t),
-			version: this.state.getMutationVersion()
-		});
-	}
-	clearIndexes() {
-		return this.cache.clear(), 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) {
-		if (t === 0) return this;
-		if (this.shouldDeferMutationCacheUpdates()) return this.invalidateCachedIndexes(), this;
-		for (let n of this.indexedFields) {
-			let r = this.cache.get(n);
-			if (r) {
-				if (!this.shouldMaintainIncrementally(r)) {
-					this.cache.delete(n);
-					continue;
-				}
-				this.updateCachedIndexForAddedItems(n, e, t);
-			}
-		}
-		return this;
-	}
-	getOriginData() {
-		return this.state.getOriginData();
-	}
-	handleStateMutation(e) {
-		switch (e.type) {
-			case "add":
-				this.applyAddedItems(e.startIndex, e.items.length);
-				return;
-			case "update":
-				this.applyUpdatedItem(e.index, e.previousItem, e.nextItem);
-				return;
-			case "data":
-				this.rebuildConfiguredIndexes();
-				return;
-			case "clearData":
-				this.cache.clear();
-				return;
-			case "remove":
-				this.applyRemovedItem(e.removedIndex, e.movedFromIndex);
-				return;
-			case "removeMany":
-				this.applyRemovedItemsBatch(e.entries);
-				return;
-		}
-	}
-	sort(e, t, n = !1) {
-		let i = t === void 0, a, o;
-		if (i) {
-			if (!this.dataset.length) throw r.missingDatasetForSort();
-			a = this.dataset, o = e;
-		} else a = e, o = t;
-		if (o.length === 0 || a.length === 0) return a;
-		if (o.length === 1) {
-			let { field: e, direction: t } = o[0];
-			if (i && this.indexedFields.has(e)) {
-				let n = this.cache.get(e), r = this.state.getMutationVersion();
-				return (!n || n.version !== r) && (this.buildIndexForDataset(e), n = this.cache.get(e)), this.getCachedSortedItems(n, t);
-			}
-			return this.sortNumericFastPath(a, e, t, n);
-		}
-		return this.sortMultiField(a, o, n, i);
-	}
-	sortNumericFastPath(e, t, n, r) {
-		if (e.length === 0 || typeof e[0][t] != "number") {
-			let i = r ? e : e.slice();
-			return i.sort((e, r) => {
-				let i = e[t], a = r[t], o = i < a ? -1 : i > a ? 1 : 0;
-				return n === "asc" ? o : -o;
-			}), i;
-		}
-		let o = e.length, s = new Float64Array(o);
-		for (let n = 0; n < o; n++) s[n] = e[n][t];
-		let c = new Uint32Array(o);
-		for (let e = 0; e < o; e++) c[e] = e;
-		return i(s, o) ? a(c, s, o) : c.sort((e, t) => s[e] - s[t]), this.materializeItemsFromIndexes(e, c, n);
-	}
-	sortMultiField(e, t, n, r) {
-		let [i, ...a] = t;
-		if (r && this.indexedFields.has(i.field)) {
-			let e = this.cache.get(i.field), t = this.state.getMutationVersion();
-			(!e || e.version !== t) && (this.buildIndexForDataset(i.field), e = this.cache.get(i.field));
-			let n = e.hasDuplicateValues ? this.getCachedSortedItems(e, i.direction).slice() : this.getCachedSortedItems(e, i.direction);
-			return e.hasDuplicateValues ? this.sortTieGroups(n, i.field, a) : n;
-		}
-		let o = n ? e : e.slice(), s = this.buildComparator(t);
-		return o.sort(s), o;
-	}
-	sortTieGroups(e, t, n) {
-		if (n.length === 0) return e;
-		let r = this.buildComparator(n), i = e.length, a = 0;
-		for (; a < i;) {
-			let n = a + 1, o = e[a][t];
-			for (; n < i && e[n][t] === o;) n++;
-			if (n - a > 1) {
-				let t = e.slice(a, n);
-				t.sort(r);
-				for (let r = a; r < n; r++) e[r] = t[r - a];
-			}
-			a = n;
-		}
-		return e;
-	}
-	materializeItemsFromIndexes(e, t, n) {
-		let r = t.length, i = Array(r);
-		if (n === "asc") {
-			for (let n = 0; n < r; n++) i[n] = e[t[n]];
-			return i;
-		}
-		for (let n = 0; n < r; n++) i[n] = e[t[r - 1 - n]];
-		return i;
-	}
-	getCachedSortedItems(e, t) {
-		return t === "asc" ? (e.ascItems === null && (e.ascItems = this.materializeItemsFromIndexes(this.dataset, e.indexes, "asc")), e.ascItems) : (e.descItems === null && (e.descItems = this.getCachedSortedItems(e, "asc").slice().reverse()), e.descItems);
-	}
-	shouldMaintainIncrementally(e) {
-		return e.ascItems !== null || e.descItems !== null;
-	}
-	hasDuplicateValuesForIndexes(e, t, n) {
-		for (let r = 1; r < t.length; r++) if (e[t[r - 1]][n] === e[t[r]][n]) return !0;
-		return !1;
-	}
-	compareIndexesByField(e, t, n) {
-		let r = this.dataset[t][e], i = this.dataset[n][e];
-		if (typeof r == "number" && typeof i == "number") {
-			let e = r - i;
-			if (e !== 0) return e;
-		} else {
-			if (r < i) return -1;
-			if (r > i) return 1;
-		}
-		return t - n;
-	}
-	applyUpdatedItem(e, t, n) {
-		if (this.shouldDeferMutationCacheUpdates()) {
-			this.invalidateCachedIndexes();
-			return;
-		}
-		for (let r of this.indexedFields) {
-			if (t[r] === n[r]) continue;
-			let i = this.cache.get(r);
-			if (i) {
-				if (!this.shouldMaintainIncrementally(i)) {
-					this.cache.delete(r);
-					continue;
-				}
-				this.updateCachedIndexForUpdatedItem(r, e);
-			}
-		}
-	}
-	updateCachedIndexForUpdatedItem(e, t) {
-		let n = this.cache.get(e);
-		if (!n) return;
-		let { indexes: r, reverseIndex: i } = n, a = r.length, o = i[t];
-		if (o >= a || r[o] !== t) {
-			this.cache.delete(e);
-			return;
-		}
-		r.copyWithin(o, o + 1);
-		let s = a - 1, c = 0, l = s;
-		for (; c < l;) {
-			let n = c + l >> 1;
-			this.compareIndexesByField(e, r[n], t) <= 0 ? c = n + 1 : l = n;
-		}
-		let u = c;
-		r.copyWithin(u + 1, u, s), r[u] = t, n.ascItems !== null && (n.ascItems.copyWithin(o, o + 1), n.ascItems.copyWithin(u + 1, u, s), n.ascItems[u] = this.dataset[t]);
-		let d = Math.min(o, u), f = Math.max(o, u);
-		for (let e = d; e <= f; e++) i[r[e]] = e;
-		if (n.descItems = null, !n.hasDuplicateValues) {
-			let i = u > 0 ? r[u - 1] : -1, o = u + 1 < a ? r[u + 1] : -1;
-			n.hasDuplicateValues = i !== -1 && this.dataset[i][e] === this.dataset[t][e] || o !== -1 && this.dataset[o][e] === this.dataset[t][e];
-		}
-		n.version = this.state.getMutationVersion();
-	}
-	updateCachedIndexForAddedItems(e, t, n) {
-		let r = this.cache.get(e);
-		if (!r) return;
-		let i = Array(n);
-		for (let e = 0; e < n; e++) i[e] = t + e;
-		i.sort((t, n) => this.compareIndexesByField(e, t, n));
-		let a = new Uint32Array(r.indexes.length + n), o = -1, s = r.hasDuplicateValues, c = 0, l = 0, u = 0;
-		for (; c < r.indexes.length && l < i.length;) {
-			let t = this.compareIndexesByField(e, r.indexes[c], i[l]) <= 0 ? r.indexes[c++] : i[l++];
-			a[u] = t, !s && o !== -1 && this.dataset[o][e] === this.dataset[t][e] && (s = !0), o = t, u += 1;
-		}
-		for (; c < r.indexes.length;) {
-			let t = r.indexes[c++];
-			a[u] = t, !s && o !== -1 && this.dataset[o][e] === this.dataset[t][e] && (s = !0), o = t, u += 1;
-		}
-		for (; l < i.length;) {
-			let t = i[l++];
-			a[u] = t, !s && o !== -1 && this.dataset[o][e] === this.dataset[t][e] && (s = !0), o = t, u += 1;
-		}
-		let d = new Uint32Array(a.length);
-		for (let e = 0; e < a.length; e++) d[a[e]] = e;
-		r.indexes = a, r.reverseIndex = d, r.ascItems = r.ascItems ? this.materializeItemsFromIndexes(this.dataset, a, "asc") : null, r.descItems = null, r.hasDuplicateValues = s, r.version = this.state.getMutationVersion();
-	}
-	applyRemovedItem(e, t) {
-		if (this.shouldDeferMutationCacheUpdates()) {
-			this.invalidateCachedIndexes();
-			return;
-		}
-		for (let n of this.indexedFields) {
-			let r = this.cache.get(n);
-			if (r) {
-				if (!this.shouldMaintainIncrementally(r)) {
-					this.cache.delete(n);
-					continue;
-				}
-				this.updateCachedIndexForRemovedItem(n, e, t);
-			}
-		}
-	}
-	applyRemovedItemsBatch(e) {
-		if (this.shouldDeferMutationCacheUpdates()) {
-			this.invalidateCachedIndexes();
-			return;
-		}
-		for (let t of this.indexedFields) {
-			let n = this.cache.get(t);
-			if (n) {
-				if (!this.shouldMaintainIncrementally(n)) {
-					this.cache.delete(t);
-					continue;
-				}
-				if (!n.hasDuplicateValues) {
-					this.updateUniqueCachedIndexForRemovedItems(n, e), n.version = this.state.getMutationVersion();
-					continue;
-				}
-				this.cache.delete(t);
-			}
-		}
-	}
-	updateCachedIndexForRemovedItem(e, t, n) {
-		let r = this.cache.get(e);
-		if (!r) return;
-		if (!r.hasDuplicateValues) {
-			this.updateUniqueCachedIndexForRemovedItem(r, t, n), r.version = this.state.getMutationVersion();
-			return;
-		}
-		let i = [];
-		for (let e = 0; e < r.indexes.length; e++) {
-			let a = r.indexes[e];
-			a === t || a === n || i.push(a);
-		}
-		if (n !== null && n !== t) {
-			let n = 0, r = i.length;
-			for (; n < r;) {
-				let a = n + r >> 1;
-				this.compareIndexesByField(e, i[a], t) <= 0 ? n = a + 1 : r = a;
-			}
-			i.splice(n, 0, t);
-		}
-		let a = Uint32Array.from(i), o = new Uint32Array(this.dataset.length);
-		for (let e = 0; e < a.length; e++) {
-			let t = a[e];
-			o[t] = e;
-		}
-		r.indexes = a, r.reverseIndex = o, r.ascItems = r.ascItems ? this.materializeItemsFromIndexes(this.dataset, a, "asc") : null, r.descItems = null, r.hasDuplicateValues = r.hasDuplicateValues ? this.hasDuplicateValuesForIndexes(this.dataset, a, e) : !1, r.version = this.state.getMutationVersion();
-	}
-	updateUniqueCachedIndexForRemovedItem(e, t, n) {
-		let r = e.indexes.length - 1, i = new Uint32Array(r), a = new Uint32Array(this.dataset.length), o = e.ascItems === null ? null : Array(r), s = 0;
-		for (let r = 0; r < e.indexes.length; r++) {
-			let c = e.indexes[r];
-			if (c === t) continue;
-			let l = n !== null && c === n ? t : c;
-			i[s] = l, a[l] = s, o !== null && (o[s] = this.dataset[l]), s += 1;
-		}
-		e.indexes = i, e.reverseIndex = a, e.ascItems = o, e.descItems = null;
-	}
-	updateUniqueCachedIndexForRemovedItems(e, t) {
-		let n = e.indexes.length, r = new Uint32Array(n), i = new Int32Array(n);
-		for (let e = 0; e < n; e++) r[e] = e, i[e] = -1;
-		let a = n;
-		for (let e = 0; e < t.length; e++) {
-			let n = t[e];
-			n.movedFromIndex !== null && (r[n.removedIndex] = r[n.movedFromIndex]), --a;
-		}
-		let o = new Uint32Array(a), s = new Uint32Array(a), c = e.ascItems === null ? null : Array(a);
-		for (let e = 0; e < a; e++) i[r[e]] = e;
-		let l = 0;
-		for (let t = 0; t < e.indexes.length; t++) {
-			let n = i[e.indexes[t]];
-			n !== -1 && (o[l] = n, s[n] = l, c !== null && (c[l] = this.dataset[n]), l += 1);
-		}
-		e.indexes = o, e.reverseIndex = s, e.ascItems = c, e.descItems = null;
-	}
-	buildComparator(e) {
-		let t = e.map(({ field: e }) => e), n = e.map(({ direction: e }) => e === "asc" ? 1 : -1), r = t.length;
-		return (e, i) => {
-			for (let a = 0; a < r; a++) {
-				let r = t[a], o = e[r], s = i[r];
-				if (o < s) return -n[a];
-				if (o > s) return n[a];
-			}
-			return 0;
-		};
-	}
-};
-//#endregion
-export { s as SortEngine };
+import { SortEngine as e } from "./sorter.mjs";
+export { e as SortEngine };

package/dist/sort/sorter.d.ts

@@ -0,0 +1,47 @@
+import { State } from "../State";
+import { CollectionItem, SortDescriptor, type UpdateDescriptor } from "../types";
+import type { SortEngineOptions } from "./types";
+export declare class SortEngine<T extends CollectionItem> {
+    private readonly state;
+    private readonly namespace;
+    constructor(options?: SortEngineOptions<T> & {
+        state?: State<T>;
+    });
+    private get dataset();
+    private get runtime();
+    private get cache();
+    private get indexedFields();
+    private shouldDeferMutationCacheUpdates;
+    private invalidateCachedIndexes;
+    private rebuildConfiguredIndexes;
+    private buildIndexForDataset;
+    private buildIndexFromData;
+    clearIndexes(): this;
+    clearData(): this;
+    data(data: T[]): this;
+    add(items: T[]): this;
+    update(descriptor: UpdateDescriptor<T>): this;
+    private applyAddedItems;
+    getOriginData(): T[];
+    private handleStateMutation;
+    sort(descriptors: SortDescriptor<T>[]): T[];
+    sort(data: T[], descriptors: SortDescriptor<T>[], inPlace?: boolean): T[];
+    private sortNumericFastPath;
+    private sortMultiField;
+    private sortTieGroups;
+    private materializeItemsFromIndexes;
+    private getCachedSortedItems;
+    private shouldMaintainIncrementally;
+    private hasDuplicateValuesForIndexes;
+    private compareIndexesByField;
+    private applyUpdatedItem;
+    private updateCachedIndexForUpdatedItem;
+    private updateCachedIndexForAddedItems;
+    private applyRemovedItem;
+    private applyRemovedItemsBatch;
+    private updateCachedIndexForRemovedItem;
+    private updateUniqueCachedIndexForRemovedItem;
+    private updateUniqueCachedIndexForRemovedItems;
+    private buildComparator;
+}
+//# sourceMappingURL=sorter.d.ts.map