@signaldb/core 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index22.mjs

@@ -1,129 +1,35 @@
-import intersection from "./index29.mjs";
-function getMergedIndexInfo(queryFunctions, selector) {
-  return queryFunctions.reduce((memoOrPromise, queryFunction) => {
-    const resultOrPromise = queryFunction(selector);
-    const processResult = (memo2, result) => {
-      if (!result.matched)
-        return memo2;
-      const optimizedSelector = result.keepSelector ? memo2.optimizedSelector : Object.fromEntries(Object.entries(memo2.optimizedSelector).filter(([key]) => !result.fields.includes(key)));
-      return {
-        matched: true,
-        ids: [...new Set(memo2.matched ? intersection(memo2.ids, result.ids) : result.ids)],
-        optimizedSelector
-      };
-    };
-    if (resultOrPromise instanceof Promise) {
-      return resultOrPromise.then(async (result) => {
-        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
-        return processResult(memo2, result);
-      });
-    }
-    const memo = memoOrPromise;
-    if (memo instanceof Promise)
-      throw new Error("Mixing async and sync index providers is not supported");
-    return processResult(memo, resultOrPromise);
-  }, {
-    matched: false,
-    ids: [],
-    optimizedSelector: { ...selector }
-  });
+import get from "./index11.mjs";
+import set from "./index21.mjs";
+//#region src/utils/project.ts
+/**
+* Projects the fields of an object based on a specified fields configuration.
+* Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
+* with the desired fields included or excluded, based on the configuration.
+* @template T - The type of the object being projected.
+* @param item - The original object to project fields from.
+* @param fields - An object defining the fields to include (`1`) or exclude (`0`).
+*   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
+* @returns A new object with the specified fields included or excluded.
+*   - If all fields are set to `0`, the excluded fields are removed from the result.
+*   - If fields are set to `1`, only the included fields are retained.
+*/
+function project(item, fields) {
+	if (Object.values(fields).every((value) => value === 0)) {
+		const result = { ...item };
+		Object.keys(fields).forEach((key) => {
+			if (get(item, key) === void 0) return;
+			set(result, key, void 0, true);
+		});
+		return result;
+	}
+	const result = {};
+	Object.entries(fields).forEach(([key, value]) => {
+		const fieldValue = get(item, key);
+		if (fieldValue === void 0) return;
+		if (fieldValue == null && value !== 1) return;
+		set(result, key, value === 1 ? fieldValue : void 0);
+	});
+	return result;
 }
-function optimizeLogicGate(queryFunctions, logicGate, idsCallback) {
-  return logicGate.reduce((memoOrPromise, sel) => {
-    const getSelector = (indexInfo) => {
-      const { matched: selMatched, ids: selIds, optimizedSelector: optimizedSelector2 } = indexInfo;
-      if (selMatched) {
-        idsCallback(true, selIds);
-        if (Object.keys(optimizedSelector2).length > 0) {
-          return optimizedSelector2;
-        }
-      } else {
-        idsCallback(false, []);
-        return sel;
-      }
-    };
-    const indexInfoOrPromise = getIndexInfo(queryFunctions, sel);
-    if (indexInfoOrPromise instanceof Promise) {
-      return indexInfoOrPromise.then(async (indexInfo) => {
-        const memo2 = memoOrPromise instanceof Promise ? await memoOrPromise : memoOrPromise;
-        const optimizedSelector2 = getSelector(indexInfo);
-        if (optimizedSelector2)
-          memo2.push(optimizedSelector2);
-        return memo2;
-      });
-    }
-    const memo = memoOrPromise;
-    if (memo instanceof Promise)
-      throw new Error("Mixing async and sync index providers is not supported");
-    const optimizedSelector = getSelector(indexInfoOrPromise);
-    if (optimizedSelector)
-      memo.push(optimizedSelector);
-    return memo;
-  }, []);
-}
-function getIndexInfo(queryFunctions, selector) {
-  if (selector == null || Object.keys(selector).length <= 0) {
-    return {
-      matched: false,
-      ids: [],
-      optimizedSelector: selector
-    };
-  }
-  const { $and, $or, ...rest } = selector;
-  const flatInfoOrPromise = getMergedIndexInfo(queryFunctions, rest);
-  const processFlatInfo = (flatInfo) => {
-    let { matched, ids } = flatInfo;
-    const newSelector = flatInfo.optimizedSelector;
-    const $andNewOrPromise = Array.isArray($and) ? optimizeLogicGate(queryFunctions, $and, (match, selIds) => {
-      if (!match)
-        return;
-      ids = matched ? intersection(ids, selIds) : selIds;
-      matched = true;
-    }) : void 0;
-    const process$and = ($andNew) => {
-      if ($andNew && $andNew.length > 0)
-        newSelector.$and = $andNew;
-      let hasNonIndexField = false;
-      const matchedBefore = matched;
-      const idsBefore = ids;
-      const process$or = ($orNew) => {
-        if ($orNew && $orNew.length > 0)
-          newSelector.$or = $orNew;
-        if (hasNonIndexField) {
-          newSelector.$or = $or;
-          matched = matchedBefore;
-          ids = idsBefore;
-        }
-        return {
-          matched,
-          ids: ids || [],
-          optimizedSelector: newSelector
-        };
-      };
-      const $orNewOrPromise = Array.isArray($or) ? optimizeLogicGate(queryFunctions, $or, (match, selIds) => {
-        if (match) {
-          ids = [.../* @__PURE__ */ new Set([...ids, ...selIds])];
-          matched = true;
-        } else {
-          hasNonIndexField = true;
-        }
-      }) : void 0;
-      if ($orNewOrPromise instanceof Promise) {
-        return $orNewOrPromise.then(($orNew) => process$or($orNew));
-      }
-      return process$or($orNewOrPromise);
-    };
-    if ($andNewOrPromise instanceof Promise) {
-      return $andNewOrPromise.then(($andNew) => process$and($andNew));
-    }
-    return process$and($andNewOrPromise);
-  };
-  if (flatInfoOrPromise instanceof Promise) {
-    return flatInfoOrPromise.then(processFlatInfo);
-  }
-  return processFlatInfo(flatInfoOrPromise);
-}
-export {
-  getIndexInfo as default,
-  getMergedIndexInfo
-};
+//#endregion
+export { project as default };

package/dist/index23.cjs.js

@@ -0,0 +1,21 @@
+const require_project = require("./index22.cjs.js");
+//#region src/utils/projectItems.ts
+/**
+* Applies a query's field projection to a list of items, keeping the primary key unless the
+* projection excludes it outright. Returns the items untouched when there is no projection, so a
+* caller does not have to check for one first.
+* @template T - The type of the items.
+* @param items - The items to project.
+* @param fields - The projection, or `undefined` for none.
+* @returns The projected items.
+*/
+function projectItems(items, fields) {
+	if (!fields) return items;
+	const idExcluded = fields.id === 0;
+	return items.map((item) => ({
+		...idExcluded ? {} : { id: item.id },
+		...require_project.default(item, fields)
+	}));
+}
+//#endregion
+exports.default = projectItems;

package/dist/index23.mjs

@@ -1,8 +1,21 @@
-import { Query } from "mingo";
-function match(item, selector) {
-  const query = new Query(selector);
-  return query.test(item);
+import project from "./index22.mjs";
+//#region src/utils/projectItems.ts
+/**
+* Applies a query's field projection to a list of items, keeping the primary key unless the
+* projection excludes it outright. Returns the items untouched when there is no projection, so a
+* caller does not have to check for one first.
+* @template T - The type of the items.
+* @param items - The items to project.
+* @param fields - The projection, or `undefined` for none.
+* @returns The projected items.
+*/
+function projectItems(items, fields) {
+	if (!fields) return items;
+	const idExcluded = fields.id === 0;
+	return items.map((item) => ({
+		...idExcluded ? {} : { id: item.id },
+		...project(item, fields)
+	}));
 }
-export {
-  match as default
-};
+//#endregion
+export { projectItems as default };

package/dist/index24.cjs.js

@@ -0,0 +1,19 @@
+const require_get = require("./index11.cjs.js");
+let fast_sort = require("fast-sort");
+//#region src/utils/sortItems.ts
+/**
+* Sorts an array of items based on multiple fields and their specified sort order.
+* Uses the `fast-sort` library for efficient sorting.
+* @template T - The type of the items in the array.
+* @param items - The array of items to be sorted.
+* @param sortFields - An object defining the sort order for each field.
+*   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+* @returns A new array of items sorted based on the specified fields and their order.
+*/
+function sortItems(items, sortFields) {
+	return (0, fast_sort.sort)(items).by(Object.entries(sortFields).map(([key, value]) => {
+		return { [value === 1 ? "asc" : "desc"]: (i) => require_get.default(i, key) };
+	}));
+}
+//#endregion
+exports.default = sortItems;

package/dist/index24.mjs

@@ -1,28 +1,19 @@
-import get from "./index10.mjs";
-import set from "./index31.mjs";
-function project(item, fields) {
-  const allFieldsDeactivated = Object.values(fields).every((value) => value === 0);
-  if (allFieldsDeactivated) {
-    const result2 = { ...item };
-    Object.keys(fields).forEach((key) => {
-      const fieldValue = get(item, key);
-      if (fieldValue === void 0)
-        return;
-      set(result2, key, void 0, true);
-    });
-    return result2;
-  }
-  const result = {};
-  Object.entries(fields).forEach(([key, value]) => {
-    const fieldValue = get(item, key);
-    if (fieldValue === void 0)
-      return;
-    if (fieldValue == null && value !== 1)
-      return;
-    set(result, key, value === 1 ? fieldValue : void 0);
-  });
-  return result;
+import get from "./index11.mjs";
+import { sort } from "fast-sort";
+//#region src/utils/sortItems.ts
+/**
+* Sorts an array of items based on multiple fields and their specified sort order.
+* Uses the `fast-sort` library for efficient sorting.
+* @template T - The type of the items in the array.
+* @param items - The array of items to be sorted.
+* @param sortFields - An object defining the sort order for each field.
+*   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+* @returns A new array of items sorted based on the specified fields and their order.
+*/
+function sortItems(items, sortFields) {
+	return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
+		return { [value === 1 ? "asc" : "desc"]: (i) => get(i, key) };
+	}));
 }
-export {
-  project as default
-};
+//#endregion
+export { sortItems as default };

package/dist/index25.cjs.js

@@ -0,0 +1,157 @@
+const require_match = require("./index19.cjs.js");
+const require_projectItems = require("./index23.cjs.js");
+const require_sortItems = require("./index24.cjs.js");
+//#region src/utils/incrementalQueryUpdate.ts
+/**
+* Recomputes a query's result from its previous result and the change that was just written,
+* without going back to the store.
+*
+* A store re-executing the query instead reads every item it holds (or every item an index points
+* at) and filters, sorts and projects the lot — for a write that touched one row. This does the
+* same job in the size of the write, which is what a query's result costs to keep up to date when
+* the change that affects it is already in hand.
+*
+* Returns `null` when the previous result is not enough to answer, and the caller has to re-execute
+* the query after all:
+* - `limit` or `skip`: the result is a window onto a larger set, and an item leaving the window has
+*   to be replaced by one the previous result never contained.
+* - `fields` together with a `sort` the projection does not keep: the previous items are
+*   projected, so a sort key the projection dropped is no longer there to sort by. A projection
+*   that keeps every sort key is fine, and is the common case — a list sorted by the same date it
+*   displays.
+* - a `null` selector, which matches nothing and is not worth a special case.
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns The new result, or `null` when the query has to be re-executed.
+*/
+function incrementalQueryUpdate(previous, selector, options, changes) {
+	if (selector == null) return null;
+	const { sort, skip, limit, fields } = options || {};
+	if (skip != null) return null;
+	if (fields != null && sort != null && !sortKeysSurviveProjection(sort, fields)) return null;
+	if (limit != null && !windowStaysClosed(previous, selector, options, changes)) return null;
+	return mergeChangesetIntoResult(previous, selector, options, changes);
+}
+/**
+* Whether a projection keeps every field a sort is keyed on.
+*
+* The previous result is the projected items, so this decides whether they still carry what the
+* sort needs. Both projection modes are covered, because `project` treats an all-zero spec as an
+* exclusion and anything else as an inclusion:
+*
+* - An inclusion keeps a key when the key itself is included, or an ancestor of it is (`{a: 1}`
+*   keeps `a.b`), and always keeps `id` unless the spec excludes it outright.
+* - An exclusion keeps a key unless the key or an ancestor of it is excluded.
+*
+* Anything it cannot account for is a "no": re-executing is slower, not wrong.
+* @template T - The type of the items.
+* @param sort - The query's sort.
+* @param fields - The query's projection.
+* @returns `true` when every sort key survives the projection.
+*/
+function sortKeysSurviveProjection(sort, fields) {
+	const entries = Object.entries(fields);
+	if (entries.length === 0) return true;
+	const isExclusion = entries.every(([, value]) => value === 0);
+	const pathsFor = (key) => key.split(".").map((_, index, parts) => parts.slice(0, index + 1).join("."));
+	return Object.keys(sort).every((key) => {
+		const paths = pathsFor(key);
+		if (isExclusion) return paths.every((path) => fields[path] !== 0);
+		if (key === "id") return fields.id !== 0;
+		return paths.some((path) => fields[path] === 1);
+	});
+}
+/**
+* Whether two items are in the given order under the given sort, deciding ties against the caller.
+*
+* Uses the sort itself rather than a comparator of its own: a rule about which side of a window an
+* item falls on is only as good as its agreement with the ordering that drew the window. A tie
+* comes back as `false`, because a tie is exactly the case where an item could belong on either
+* side and the answer has to be taken from the store.
+* @template T - The type of the items.
+* @param item - The item whose position is in question.
+* @param edge - The item at the edge of the window.
+* @param sort - The query's sort.
+* @returns `true` when `item` sorts strictly before `edge`.
+*/
+function sortsBefore(item, edge, sort) {
+	return require_sortItems.default([edge, item], sort)[0] === item;
+}
+/**
+* Whether a change to a windowed query can be answered from the window alone.
+*
+* A window holds the first `limit` items in sort order, and nothing about what lies beyond it. An
+* item leaving the window therefore has to be replaced by one the window has never seen, and that
+* answer can only come from the store. An item arriving is a different matter: it takes its place
+* and pushes the last one out, and where that one goes is not the window's problem.
+*
+* The one case where none of this applies is a window that was never full, because then the query
+* already returns everything it matches and there is no "beyond".
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns `true` when the new window follows from the old one and the change.
+*/
+function windowStaysClosed(previous, selector, options, changes) {
+	const { sort, limit, fields } = options || {};
+	if (limit == null || previous.length < limit) return true;
+	if (sort == null || fields != null) return false;
+	const edge = previous.at(-1);
+	const runnerUp = previous.at(-2);
+	if (runnerUp != null && !sortsBefore(runnerUp, edge, sort)) return false;
+	const inWindow = new Set(previous.map((item) => item.id));
+	if (changes.deletes.some((id) => inWindow.has(id))) return false;
+	return changes.upserts.every((item) => {
+		if (item === edge) return true;
+		const before = sortsBefore(item, edge, sort);
+		if (!inWindow.has(item.id)) {
+			if (!require_match.default(item, selector)) return true;
+			return before || sortsBefore(edge, item, sort);
+		}
+		if (!require_match.default(item, selector)) return false;
+		if (before) return true;
+		return item.id === edge.id && !sortsBefore(edge, item, sort);
+	});
+}
+/**
+* Folds a change into a query's result, whatever the query's options.
+*
+* The unguarded version of `incrementalQueryUpdate`, for the places where the alternative is not a
+* more accurate answer but a wrong one — layering a write that has not been confirmed yet on top of
+* the last confirmed result, say. For a query returning everything it matches, this is exact. For a
+* window onto a larger set it is the closest the window itself can get: an item that no longer
+* belongs is dropped, one that does is placed, and the window is trimmed back to its length — but
+* an item pulled in from beyond the window is not something the window knows about.
+*
+* What it never does is re-examine the items already in the result. They matched when the store
+* produced them, they still match, and asking again is both wasteful and — for a projected result,
+* whose items no longer carry the fields the selector names — wrong.
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns The resulting items.
+*/
+function mergeChangesetIntoResult(previous, selector, options, changes) {
+	if (selector == null) return [];
+	const { sort, limit, fields } = options || {};
+	const byId = /* @__PURE__ */ new Map();
+	previous.forEach((item) => byId.set(item.id, item));
+	changes.deletes.forEach((id) => byId.delete(id));
+	changes.upserts.forEach((item) => {
+		if (require_match.default(item, selector)) byId.set(item.id, require_projectItems.default([item], fields)[0]);
+		else byId.delete(item.id);
+	});
+	const items = [...byId.values()];
+	const sorted = sort ? require_sortItems.default(items, sort) : items;
+	return limit == null ? sorted : sorted.slice(0, limit);
+}
+//#endregion
+exports.default = incrementalQueryUpdate;
+exports.mergeChangesetIntoResult = mergeChangesetIntoResult;

package/dist/index25.mjs

@@ -1,11 +1,156 @@
-import { sort } from "fast-sort";
-import get from "./index10.mjs";
-function sortItems(items, sortFields) {
-  return sort(items).by(Object.entries(sortFields).map(([key, value]) => {
-    const order = value === 1 ? "asc" : "desc";
-    return { [order]: (i) => get(i, key) };
-  }));
-}
-export {
-  sortItems as default
-};
+import match from "./index19.mjs";
+import projectItems from "./index23.mjs";
+import sortItems from "./index24.mjs";
+//#region src/utils/incrementalQueryUpdate.ts
+/**
+* Recomputes a query's result from its previous result and the change that was just written,
+* without going back to the store.
+*
+* A store re-executing the query instead reads every item it holds (or every item an index points
+* at) and filters, sorts and projects the lot — for a write that touched one row. This does the
+* same job in the size of the write, which is what a query's result costs to keep up to date when
+* the change that affects it is already in hand.
+*
+* Returns `null` when the previous result is not enough to answer, and the caller has to re-execute
+* the query after all:
+* - `limit` or `skip`: the result is a window onto a larger set, and an item leaving the window has
+*   to be replaced by one the previous result never contained.
+* - `fields` together with a `sort` the projection does not keep: the previous items are
+*   projected, so a sort key the projection dropped is no longer there to sort by. A projection
+*   that keeps every sort key is fine, and is the common case — a list sorted by the same date it
+*   displays.
+* - a `null` selector, which matches nothing and is not worth a special case.
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns The new result, or `null` when the query has to be re-executed.
+*/
+function incrementalQueryUpdate(previous, selector, options, changes) {
+	if (selector == null) return null;
+	const { sort, skip, limit, fields } = options || {};
+	if (skip != null) return null;
+	if (fields != null && sort != null && !sortKeysSurviveProjection(sort, fields)) return null;
+	if (limit != null && !windowStaysClosed(previous, selector, options, changes)) return null;
+	return mergeChangesetIntoResult(previous, selector, options, changes);
+}
+/**
+* Whether a projection keeps every field a sort is keyed on.
+*
+* The previous result is the projected items, so this decides whether they still carry what the
+* sort needs. Both projection modes are covered, because `project` treats an all-zero spec as an
+* exclusion and anything else as an inclusion:
+*
+* - An inclusion keeps a key when the key itself is included, or an ancestor of it is (`{a: 1}`
+*   keeps `a.b`), and always keeps `id` unless the spec excludes it outright.
+* - An exclusion keeps a key unless the key or an ancestor of it is excluded.
+*
+* Anything it cannot account for is a "no": re-executing is slower, not wrong.
+* @template T - The type of the items.
+* @param sort - The query's sort.
+* @param fields - The query's projection.
+* @returns `true` when every sort key survives the projection.
+*/
+function sortKeysSurviveProjection(sort, fields) {
+	const entries = Object.entries(fields);
+	if (entries.length === 0) return true;
+	const isExclusion = entries.every(([, value]) => value === 0);
+	const pathsFor = (key) => key.split(".").map((_, index, parts) => parts.slice(0, index + 1).join("."));
+	return Object.keys(sort).every((key) => {
+		const paths = pathsFor(key);
+		if (isExclusion) return paths.every((path) => fields[path] !== 0);
+		if (key === "id") return fields.id !== 0;
+		return paths.some((path) => fields[path] === 1);
+	});
+}
+/**
+* Whether two items are in the given order under the given sort, deciding ties against the caller.
+*
+* Uses the sort itself rather than a comparator of its own: a rule about which side of a window an
+* item falls on is only as good as its agreement with the ordering that drew the window. A tie
+* comes back as `false`, because a tie is exactly the case where an item could belong on either
+* side and the answer has to be taken from the store.
+* @template T - The type of the items.
+* @param item - The item whose position is in question.
+* @param edge - The item at the edge of the window.
+* @param sort - The query's sort.
+* @returns `true` when `item` sorts strictly before `edge`.
+*/
+function sortsBefore(item, edge, sort) {
+	return sortItems([edge, item], sort)[0] === item;
+}
+/**
+* Whether a change to a windowed query can be answered from the window alone.
+*
+* A window holds the first `limit` items in sort order, and nothing about what lies beyond it. An
+* item leaving the window therefore has to be replaced by one the window has never seen, and that
+* answer can only come from the store. An item arriving is a different matter: it takes its place
+* and pushes the last one out, and where that one goes is not the window's problem.
+*
+* The one case where none of this applies is a window that was never full, because then the query
+* already returns everything it matches and there is no "beyond".
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns `true` when the new window follows from the old one and the change.
+*/
+function windowStaysClosed(previous, selector, options, changes) {
+	const { sort, limit, fields } = options || {};
+	if (limit == null || previous.length < limit) return true;
+	if (sort == null || fields != null) return false;
+	const edge = previous.at(-1);
+	const runnerUp = previous.at(-2);
+	if (runnerUp != null && !sortsBefore(runnerUp, edge, sort)) return false;
+	const inWindow = new Set(previous.map((item) => item.id));
+	if (changes.deletes.some((id) => inWindow.has(id))) return false;
+	return changes.upserts.every((item) => {
+		if (item === edge) return true;
+		const before = sortsBefore(item, edge, sort);
+		if (!inWindow.has(item.id)) {
+			if (!match(item, selector)) return true;
+			return before || sortsBefore(edge, item, sort);
+		}
+		if (!match(item, selector)) return false;
+		if (before) return true;
+		return item.id === edge.id && !sortsBefore(edge, item, sort);
+	});
+}
+/**
+* Folds a change into a query's result, whatever the query's options.
+*
+* The unguarded version of `incrementalQueryUpdate`, for the places where the alternative is not a
+* more accurate answer but a wrong one — layering a write that has not been confirmed yet on top of
+* the last confirmed result, say. For a query returning everything it matches, this is exact. For a
+* window onto a larger set it is the closest the window itself can get: an item that no longer
+* belongs is dropped, one that does is placed, and the window is trimmed back to its length — but
+* an item pulled in from beyond the window is not something the window knows about.
+*
+* What it never does is re-examine the items already in the result. They matched when the store
+* produced them, they still match, and asking again is both wasteful and — for a projected result,
+* whose items no longer carry the fields the selector names — wrong.
+* @template T - The type of the items.
+* @param previous - The query's previous result.
+* @param selector - The query's selector.
+* @param options - The query's options.
+* @param changes - The items the write created, updated or removed.
+* @returns The resulting items.
+*/
+function mergeChangesetIntoResult(previous, selector, options, changes) {
+	if (selector == null) return [];
+	const { sort, limit, fields } = options || {};
+	const byId = /* @__PURE__ */ new Map();
+	previous.forEach((item) => byId.set(item.id, item));
+	changes.deletes.forEach((id) => byId.delete(id));
+	changes.upserts.forEach((item) => {
+		if (match(item, selector)) byId.set(item.id, projectItems([item], fields)[0]);
+		else byId.delete(item.id);
+	});
+	const items = [...byId.values()];
+	const sorted = sort ? sortItems(items, sort) : items;
+	return limit == null ? sorted : sorted.slice(0, limit);
+}
+//#endregion
+export { incrementalQueryUpdate as default, mergeChangesetIntoResult };

package/dist/index26.cjs.js

@@ -0,0 +1,38 @@
+//#region src/utils/queryId.ts
+/**
+* Returns true when `options` is effectively "empty" for the purpose of queryId generation.
+* Treats `undefined`/`null` as empty, and only considers plain objects with zero own enumerable keys as empty.
+* Arrays and non-object values are not considered empty.
+* @param options - Query options to test.
+* @returns `true` if `options` is `null`/`undefined` or a plain object with no own keys; otherwise `false`.
+*/
+function isEmptyOptions(options) {
+	if (options == null) return true;
+	if (typeof options !== "object") return false;
+	if (Array.isArray(options)) return false;
+	return Object.keys(options).length === 0;
+}
+var noOptions = {};
+var cache = /* @__PURE__ */ new WeakMap();
+/**
+* Generates a unique identifier for a query based on its selector and options.
+* @param selector - The selector object.
+* @param options - The query options object (optional).
+* @returns A unique identifier string for the query.
+*/
+function queryId(selector, options) {
+	if (!(selector != null && typeof selector === "object" && (options == null || typeof options === "object"))) {
+		const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
+		return `${JSON.stringify(selector)}:${optionsId}`;
+	}
+	const optionsKey = options ?? noOptions;
+	const cachedForSelector = cache.get(selector);
+	const cached = cachedForSelector?.get(optionsKey);
+	if (cached != null) return cached;
+	const id = `${JSON.stringify(selector)}:${isEmptyOptions(options) ? -1 : JSON.stringify(options)}`;
+	if (cachedForSelector) cachedForSelector.set(optionsKey, id);
+	else cache.set(selector, new WeakMap([[optionsKey, id]]));
+	return id;
+}
+//#endregion
+exports.default = queryId;