@devisfuture/mega-collection 2.4.5 → 2.4.7

package/dist/sort/sorter.mjs

@@ -0,0 +1,375 @@
+import { State as e } from "../State.mjs";
+import { DEFER_SORT_MUTATION_CACHE_UPDATES_KEY as t, MERGE_SHARED_SCOPE as n } from "../constants.mjs";
+import { SortEngineError as r } from "./errors.mjs";
+import { canUseUint32Radix as i, createSortRuntime as a, radixSortUint32 as o } from "./utils.mjs";
+//#region src/sort/sorter.ts
+var 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", a);
+	}
+	get cache() {
+		return this.runtime.cache;
+	}
+	get indexedFields() {
+		return this.runtime.indexedFields;
+	}
+	shouldDeferMutationCacheUpdates() {
+		return this.state.getScopedValue(n, t) === !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 a = 0;
+		for (; a < n && e[a][t] == null;) a++;
+		if (a < n && typeof e[a][t] == "number") {
+			let a = new Float64Array(n);
+			for (let r = 0; r < n; r++) a[r] = e[r][t];
+			i(a, n) ? o(r, a, n) : r.sort((e, t) => a[e] - a[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 a = e.length, s = new Float64Array(a);
+		for (let n = 0; n < a; n++) s[n] = e[n][t];
+		let c = new Uint32Array(a);
+		for (let e = 0; e < a; e++) c[e] = e;
+		return i(s, a) ? o(c, s, a) : 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 };

package/dist/sort/types.d.ts

@@ -0,0 +1,18 @@
+import type { CollectionItem } from "../types";
+export interface SortIndex<T extends CollectionItem = CollectionItem> {
+    indexes: Uint32Array;
+    reverseIndex: Uint32Array;
+    ascItems: T[] | null;
+    descItems: T[] | null;
+    hasDuplicateValues: boolean;
+    version: number;
+}
+export interface SortEngineOptions<T extends CollectionItem = CollectionItem> {
+    data?: T[];
+    fields?: (keyof T & string)[];
+}
+export type SortRuntime<T extends CollectionItem> = {
+    indexedFields: Set<keyof T & string>;
+    cache: Map<string, SortIndex<T>>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/sort/utils.d.ts

@@ -0,0 +1,17 @@
+import type { CollectionItem } from "../types";
+import type { SortRuntime } from "./types";
+/**
+ * Returns true if every value in `values` is a non-negative 32-bit integer,
+ * i.e. it can be treated as a Uint32 without precision loss.
+ */
+export declare function canUseUint32Radix(values: Float64Array, length: number): boolean;
+/**
+ * 2-pass LSD radix sort — sorts `indexes` so that `values[indexes[i]]` is
+ * non-decreasing.  Requires all values to be in [0, 2^32-1] integers.
+ *
+ * Time  O(2n + 2·65536)  ≈ O(n)
+ * Space O(n + 65536)     for temp buffer + count array
+ */
+export declare function radixSortUint32(indexes: Uint32Array, values: Float64Array, length: number): void;
+export declare const createSortRuntime: <T extends CollectionItem>() => SortRuntime<T>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/sort/utils.mjs

@@ -0,0 +1,38 @@
+//#region src/sort/utils.ts
+function e(e, t) {
+	for (let n = 0; n < t; n++) {
+		let t = e[n];
+		if (t !== t >>> 0) return !1;
+	}
+	return !0;
+}
+function t(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 n = () => ({
+	indexedFields: /* @__PURE__ */ new Set(),
+	cache: /* @__PURE__ */ new Map()
+});
+//#endregion
+export { e as canUseUint32Radix, n as createSortRuntime, t as radixSortUint32 };

package/dist/types.d.ts

@@ -0,0 +1,73 @@
+export type CollectionItem = Record<string, any>;
+export type IndexableKey<T> = {
+    [K in keyof T]: T[K] extends string | number ? K : never;
+}[keyof T];
+export interface UpdateDescriptor<T extends CollectionItem> {
+    field: IndexableKey<T> & string;
+    data: T;
+}
+export interface FilterCriterion<T extends CollectionItem> {
+    field: (keyof T & string) | (string & {});
+    values?: any[];
+    exclude?: any[];
+}
+export type SortDirection = "asc" | "desc";
+export interface SortDescriptor<T extends CollectionItem> {
+    field: keyof T & string;
+    direction: SortDirection;
+}
+export type StateListener<T extends CollectionItem> = (mutation: StateMutation<T>) => void;
+export interface StateRegistryFactory<TValue> {
+    (): TValue;
+}
+export interface StateOptions {
+    filterByPreviousResult?: boolean;
+}
+export interface StatePreviousResult<T extends CollectionItem> {
+    result: T[];
+    sourceData: T[];
+    version: number;
+}
+export type StateAddMutation<T extends CollectionItem> = {
+    type: "add";
+    items: T[];
+    startIndex: number;
+};
+export type StateUpdateMutation<T extends CollectionItem> = {
+    type: "update";
+    field: IndexableKey<T> & string;
+    index: number;
+    previousItem: T;
+    nextItem: T;
+};
+export type StateDataMutation<T extends CollectionItem> = {
+    type: "data";
+    data: T[];
+};
+export type StateClearMutation<T extends CollectionItem> = {
+    type: "clearData";
+    data: T[];
+};
+export type StateRemoveMutation<T extends CollectionItem> = {
+    type: "remove";
+    field: IndexableKey<T> & string;
+    value: T[IndexableKey<T> & string];
+    removedItem: T;
+    removedIndex: number;
+    movedItem: T | null;
+    movedFromIndex: number | null;
+};
+export type StateRemoveManyEntry<T extends CollectionItem> = {
+    value: T[IndexableKey<T> & string];
+    removedItem: T;
+    removedIndex: number;
+    movedItem: T | null;
+    movedFromIndex: number | null;
+};
+export type StateRemoveManyMutation<T extends CollectionItem> = {
+    type: "removeMany";
+    field: IndexableKey<T> & string;
+    entries: StateRemoveManyEntry<T>[];
+};
+export type StateMutation<T extends CollectionItem> = StateAddMutation<T> | StateUpdateMutation<T> | StateDataMutation<T> | StateClearMutation<T> | StateRemoveMutation<T> | StateRemoveManyMutation<T>;
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,62 +1,39 @@
 {
   "name": "@devisfuture/mega-collection",
-  "version": "2.4.5",
+  "version": "2.4.7",
   "description": "High-performance search, filter & sort engine for 100K+ item collections in JavaScript/TypeScript",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.mts",
+      "types": "./dist/index.d.ts",
       "default": "./dist/index.mjs"
     },
     "./search": {
-      "types": "./dist/search/index.d.mts",
+      "types": "./dist/search/index.d.ts",
       "default": "./dist/search/index.mjs"
     },
     "./filter": {
-      "types": "./dist/filter/index.d.mts",
+      "types": "./dist/filter/index.d.ts",
       "default": "./dist/filter/index.mjs"
     },
     "./sort": {
-      "types": "./dist/sort/index.d.mts",
+      "types": "./dist/sort/index.d.ts",
       "default": "./dist/sort/index.mjs"
     },
     "./merge": {
-      "types": "./dist/merge/index.d.mts",
+      "types": "./dist/merge/index.d.ts",
       "default": "./dist/merge/index.mjs"
     },
     "./package.json": "./package.json"
   },
-  "typesVersions": {
-    "*": {
-      "search": [
-        "./dist/search/index.d.mts"
-      ],
-      "filter": [
-        "./dist/filter/index.d.mts"
-      ],
-      "sort": [
-        "./dist/sort/index.d.mts"
-      ],
-      "merge": [
-        "./dist/merge/index.d.mts"
-      ]
-    }
-  },
   "files": [
-    "dist/index.mjs",
-    "dist/index.d.mts",
-    "dist/chunk-*.mjs",
-    "dist/search/index.mjs",
-    "dist/search/index.d.mts",
-    "dist/filter/index.mjs",
-    "dist/filter/index.d.mts",
-    "dist/sort/index.mjs",
-    "dist/sort/index.d.mts",
-    "dist/merge/index.mjs",
-    "dist/merge/index.d.mts"
+    "dist/**/*.mjs",
+    "dist/**/*.d.ts",
+    "dist/index.d.ts"
   ],
   "sideEffects": false,
   "scripts": {
-    "build:types": "tsc --emitDeclarationOnly && node ./scripts/rename-dts-to-dmts.js",
+    "build:types": "tsc --emitDeclarationOnly",
     "build": "vite build && npm run build:types",
     "build:watch": "vite build --watch",
     "dev": "vite build --watch",