@signaldb/svelte 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/base/core/src/WorkerDataAdapterHost.js

@@ -11,8 +11,31 @@ const isEqual_1 = __importDefault(require("./utils/isEqual"));
 const getIndexInfo_1 = __importDefault(require("./getIndexInfo"));
 const getMatchingKeys_1 = __importDefault(require("./utils/getMatchingKeys"));
 const sortItems_1 = __importDefault(require("./utils/sortItems"));
-const project_1 = __importDefault(require("./utils/project"));
+const projectItems_1 = __importDefault(require("./utils/projectItems"));
 const compact_1 = __importDefault(require("./utils/compact"));
+const incrementalQueryUpdate_1 = __importDefault(require("./utils/incrementalQueryUpdate"));
+const queryDelta_1 = require("./utils/queryDelta");
+/**
+ * Turns the item states a write produced into the upsert/delete split a query update needs.
+ *
+ * The two lists are not symmetric: an item that is still there after the write is described by
+ * its new state, while an item that is gone — removed, or given a new id — is described by the id
+ * it used to have and nothing else. Mixing the states from before and after a write into one list
+ * loses exactly that distinction.
+ * @template T - The type of the items.
+ * @param previousItems - The items as they were before the write.
+ * @param modifiedItems - The items as they are after it.
+ * @returns The changeset describing the write.
+ */
+function toChangeset(previousItems, modifiedItems) {
+    const modifiedIds = new Set(modifiedItems.map(item => item.id));
+    return {
+        upserts: modifiedItems,
+        deletes: previousItems
+            .map(item => item.id)
+            .filter(id => !modifiedIds.has(id)),
+    };
+}
 class WorkerDataAdapterHost {
     workerContext;
     options;
@@ -180,15 +203,7 @@ class WorkerDataAdapterHost {
         const sorted = sort ? (0, sortItems_1.default)(items, sort) : items;
         const skipped = skip ? sorted.slice(skip) : sorted;
         const limited = limit ? skipped.slice(0, limit) : skipped;
-        const idExcluded = fields && fields.id === 0;
-        return limited.map((item) => {
-            if (!fields)
-                return item;
-            return {
-                ...idExcluded ? {} : { id: item.id },
-                ...(0, project_1.default)(item, fields),
-            };
-        });
+        return (0, projectItems_1.default)(limited, fields);
     }
     ensureQuery(collectionName, selector, options) {
         const id = (0, queryId_1.default)(selector, options);
@@ -197,17 +212,33 @@ class WorkerDataAdapterHost {
         }
         let query = this.queries.get(collectionName)?.get(id);
         if (!query) {
-            query = { selector, options };
+            query = { selector, options, items: null };
             this.queries.get(collectionName)?.set(id, query);
         }
         return query;
     }
-    emitQueryUpdate(collectionName, selector, options, state, error, items) {
+    setQueryItems(query, items) {
+        query.items = items;
+        query.itemIds = undefined;
+    }
+    queryItemIds(query) {
+        if (!query.itemIds)
+            query.itemIds = new Set((query.items ?? []).map(item => item.id));
+        return query.itemIds;
+    }
+    emitQueryUpdate(collectionName, selector, options, state, error, items, delta) {
         const id = (0, queryId_1.default)(selector, options);
         const collectionQueries = this.queries.get(collectionName);
         if (!collectionQueries)
             throw new Error(`Collection ${collectionName} not initialized!`);
-        this.respond(id, { collectionName, selector, options, state, error, items }, null, 'queryUpdate');
+        // `qid` is what the adapter routes on. It is derived from the same selector/options pair the
+        // adapter registered the query with, so sending it saves every recipient from re-deriving it.
+        //
+        // `items` and `delta` are alternatives: the first answer to a query carries the whole result
+        // because the recipient holds nothing yet, every answer after it carries only what changed.
+        // Everything in this message is structurally cloned on its way out of the worker, which is why
+        // it matters that editing one field of one row no longer costs a copy of the entire result.
+        this.respond(id, { collectionName, qid: id, selector, options, state, error, items, delta }, null, 'queryUpdate');
     }
     ensureStorageAdapter(name) {
         if (this.storageAdapters.has(name))
@@ -217,19 +248,49 @@ class WorkerDataAdapterHost {
             return; // no adapter returned
         this.storageAdapters.set(name, adapter);
     }
-    async checkQueryUpdates(collectionName, items) {
+    async checkQueryUpdates(collectionName, changes) {
         const queries = this.queries.get(collectionName);
         if (!queries)
             throw new Error(`Collection ${collectionName} not initialized!`);
-        const affectedQueries = [...queries.values()].filter(({ selector }) => items.some(item => (0, match_1.default)(item, selector))) ?? [];
+        if (changes.upserts.length === 0 && changes.deletes.length === 0)
+            return;
+        // A query is affected when the write produces something it should hold, or takes away
+        // something it already holds. The second half is what the write itself cannot tell us: an
+        // item that no longer matches, or that was removed outright, is invisible to the matcher.
+        const affectedQueries = [...queries.values()].filter((query) => {
+            const ids = this.queryItemIds(query);
+            if (changes.deletes.some(id => ids.has(id)))
+                return true;
+            return changes.upserts.some(item => ids.has(item.id) || (0, match_1.default)(item, query.selector));
+        });
         if (affectedQueries.length === 0)
             return; // no active queries affected
-        affectedQueries.forEach(({ selector, options }) => {
+        await Promise.all(affectedQueries.map(async (query) => {
+            const { selector, options } = query;
+            const previous = query.items;
+            const incremental = previous == null
+                ? null
+                : (0, incrementalQueryUpdate_1.default)(previous, selector, options, changes);
+            if (incremental != null) {
+                // Answered from the previous result, without touching the store — so there is no window in
+                // which the query is stale, and nothing to announce with an `'active'` state either.
+                const delta = (0, queryDelta_1.diffQueryResults)(previous, incremental);
+                if ((0, queryDelta_1.isEmptyQueryDelta)(delta))
+                    return;
+                this.setQueryItems(query, incremental);
+                this.emitQueryUpdate(collectionName, selector, options, 'complete', null, undefined, delta);
+                return;
+            }
             this.emitQueryUpdate(collectionName, selector, options, 'active', null);
-        });
-        await Promise.all(affectedQueries.map(async ({ selector, options }) => {
             const queryItems = await this.executeQuery(collectionName, selector, options);
-            this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
+            if (previous == null) {
+                this.setQueryItems(query, queryItems);
+                this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
+                return;
+            }
+            const delta = (0, queryDelta_1.diffQueryResults)(previous, queryItems);
+            this.setQueryItems(query, queryItems);
+            this.emitQueryUpdate(collectionName, selector, options, 'complete', null, undefined, delta);
         }));
     }
     registerCollection = async (collectionName, indices) => {
@@ -251,8 +312,11 @@ class WorkerDataAdapterHost {
         this.queries.delete(collectionName);
     };
     registerQuery = async (collectionName, selector, options) => {
-        this.ensureQuery(collectionName, selector, options);
+        const query = this.ensureQuery(collectionName, selector, options);
         const queryItems = await this.executeQuery(collectionName, selector, options);
+        // Always the full result, even for a query that is already registered: whoever is registering
+        // holds nothing for it yet, and a delta would be relative to a result only the host has seen.
+        this.setQueryItems(query, queryItems);
         this.emitQueryUpdate(collectionName, selector, options, 'complete', null, queryItems);
     };
     unregisterQuery = async (collectionName, selector, options) => {
@@ -276,7 +340,7 @@ class WorkerDataAdapterHost {
         });
         const newItems = result.filter(item => !(item instanceof Error));
         await storageAdapter.insert(newItems);
-        await this.checkQueryUpdates(collectionName, newItems);
+        await this.checkQueryUpdates(collectionName, { upserts: newItems, deletes: [] });
         return result;
     };
     updateOne = async (collectionName, parameters) => {
@@ -302,7 +366,7 @@ class WorkerDataAdapterHost {
         const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
         if (modifiedItems.length > 0) {
             await storageAdapter.replace(modifiedItems);
-            await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+            await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
         }
         return result;
     };
@@ -337,7 +401,7 @@ class WorkerDataAdapterHost {
         const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
         if (modifiedItems.length > 0) {
             await storageAdapter.replace(modifiedItems);
-            await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+            await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
         }
         return result;
     };
@@ -366,7 +430,7 @@ class WorkerDataAdapterHost {
         const modifiedItems = (0, compact_1.default)(result.filter(item => !(item instanceof Error)).flat());
         if (modifiedItems.length > 0) {
             await storageAdapter.replace(modifiedItems);
-            await this.checkQueryUpdates(collectionName, [...modifiedItems, ...previousItems]);
+            await this.checkQueryUpdates(collectionName, toChangeset(previousItems, modifiedItems));
         }
         return result;
     };
@@ -383,7 +447,10 @@ class WorkerDataAdapterHost {
         const items = result.flat();
         if (items.length > 0) {
             await storageAdapter.remove(items);
-            await this.checkQueryUpdates(collectionName, items);
+            await this.checkQueryUpdates(collectionName, {
+                upserts: [],
+                deletes: items.map(item => item.id),
+            });
         }
         return result;
     };
@@ -395,7 +462,10 @@ class WorkerDataAdapterHost {
         const items = result.flat();
         if (items.length > 0) {
             await storageAdapter.remove(items);
-            await this.checkQueryUpdates(collectionName, items);
+            await this.checkQueryUpdates(collectionName, {
+                upserts: [],
+                deletes: items.map(item => item.id),
+            });
         }
         return result;
     };

package/dist/base/core/src/index.d.ts

@@ -4,6 +4,8 @@ export type { default as Selector } from './types/Selector';
 export type { default as Modifier } from './types/Modifier';
 export type { BaseItem, ObserveCallbacks, CursorOptions, Transform, TransformAll, SortSpecifier, FieldSpecifier, AnyFindOptions, AsyncFindOptions, FindOptions, SyncFindOptions, CollectionOptions, QueryStateAccessor, } from './Collection';
 export type { default as DataAdapter } from './DataAdapter';
+export type { CollectionBackend, QueryOptions, StateChangeCallback, } from './DataAdapter';
+export type { QueryDelta } from './utils/queryDelta';
 export { default as Cursor } from './Collection/Cursor';
 export { default as Collection } from './Collection';
 export { default as createStorageAdapter } from './createStorageAdapter';

package/dist/base/core/src/utils/incrementalQueryUpdate.d.ts

@@ -0,0 +1,60 @@
+import type { QueryOptions } from '../DataAdapter';
+import type { BaseItem } from '../Collection/types';
+import type Selector from '../types/Selector';
+/**
+ * The items a write created, updated or removed, from the point of view of a store.
+ *
+ * `upserts` are the *current* state of every item that still exists; `deletes` are the ids of items
+ * that no longer do. A write that changes an item's id contributes to both. Callers are responsible
+ * for that split — an "affected items" list holding an item's state from before and after a write
+ * cannot be told apart from two unrelated items here.
+ */
+export interface QueryChangeset<T extends BaseItem> {
+    upserts: T[];
+    deletes: any[];
+}
+/**
+ * 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 `sort`: the previous items are projected, so the field the sort is keyed
+ *   on may no longer be there to sort by.
+ * - 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.
+ */
+export default function incrementalQueryUpdate<T extends BaseItem>(previous: T[], selector: Selector<T>, options: QueryOptions<T> | undefined, changes: QueryChangeset<T>): T[] | null;
+/**
+ * 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.
+ */
+export declare function mergeChangesetIntoResult<T extends BaseItem>(previous: T[], selector: Selector<T>, options: QueryOptions<T> | undefined, changes: QueryChangeset<T>): T[];

package/dist/base/core/src/utils/incrementalQueryUpdate.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = incrementalQueryUpdate;
+exports.mergeChangesetIntoResult = mergeChangesetIntoResult;
+const match_1 = __importDefault(require("./match"));
+const projectItems_1 = __importDefault(require("./projectItems"));
+const sortItems_1 = __importDefault(require("./sortItems"));
+/**
+ * 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 `sort`: the previous items are projected, so the field the sort is keyed
+ *   on may no longer be there to sort by.
+ * - 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)
+        return null;
+    if (limit != null && !windowStaysClosed(previous, selector, options, changes))
+        return null;
+    return mergeChangesetIntoResult(previous, selector, options, changes);
+}
+/**
+ * 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 (0, sortItems_1.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;
+    // A full window needs an edge to compare against, and comparing needs the field the sort is on
+    // to still be there.
+    if (sort == null || fields != null)
+        return false;
+    const edge = previous.at(-1);
+    const runnerUp = previous.at(-2);
+    // Which item is *the* edge has to be beyond doubt. Two items sorting equally at the end of the
+    // window are interchangeable, and so is the question of which of them a write displaces.
+    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)) {
+            // Coming from outside: it either takes a place inside, displacing the edge, or stays where
+            // it was. Sorting *equally* to the edge is the one answer the window cannot give, because
+            // the store may just as well have kept the edge and left this one out.
+            if (!(0, match_1.default)(item, selector))
+                return true;
+            return before || sortsBefore(edge, item, sort);
+        }
+        // An item that no longer matches leaves a place open, and what fills it is beyond the window.
+        if (!(0, match_1.default)(item, selector))
+            return false;
+        if (before)
+            return true;
+        // Not before the edge. The one item that may sit *on* the edge is the edge itself, and only
+        // while it has not actually moved — an edge that slides outwards gives up the last place, and
+        // what takes it is something the window has never seen.
+        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 = new Map();
+    previous.forEach(item => byId.set(item.id, item));
+    changes.deletes.forEach(id => byId.delete(id));
+    changes.upserts.forEach((item) => {
+        // Matched against the unprojected item: the selector is free to name fields the projection
+        // drops, and the stored result would have no answer for those.
+        if ((0, match_1.default)(item, selector)) {
+            byId.set(item.id, (0, projectItems_1.default)([item], fields)[0]);
+        }
+        else {
+            byId.delete(item.id);
+        }
+    });
+    const items = [...byId.values()];
+    const sorted = sort ? (0, sortItems_1.default)(items, sort) : items;
+    return limit == null ? sorted : sorted.slice(0, limit);
+}

package/dist/base/core/src/utils/projectItems.d.ts

@@ -0,0 +1,12 @@
+import type { QueryOptions } from '../DataAdapter';
+import type { BaseItem } from '../Collection/types';
+/**
+ * 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.
+ */
+export default function projectItems<T extends BaseItem>(items: T[], fields: QueryOptions<T>['fields']): T[];

package/dist/base/core/src/utils/projectItems.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = projectItems;
+const project_1 = __importDefault(require("./project"));
+/**
+ * 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 },
+        ...(0, project_1.default)(item, fields),
+    }));
+}

package/dist/base/core/src/utils/queryDelta.d.ts

@@ -0,0 +1,83 @@
+import type { BaseItem } from '../Collection/types';
+/**
+ * The change between two consecutive results of the same query, expressed so it can be applied to
+ * the earlier result to obtain the later one.
+ *
+ * Indices in `added` and `moved` are positions in the *resulting* array and are always ascending,
+ * which is what makes applying them a matter of splicing in order. Removals and moves name items by
+ * id only: whoever applies the delta still holds the previous result and can look the item up
+ * there, so there is no reason to send it twice — the point of the whole exercise is that a change
+ * costs the size of the change, not the size of the result.
+ */
+export interface QueryDelta<T extends BaseItem = BaseItem> {
+    /** Items that were not in the previous result, at their position in the new one. */
+    added: {
+        index: number;
+        item: T;
+    }[];
+    /** Items that were in the previous result and whose contents changed. */
+    changed: T[];
+    /** Ids of items that are no longer in the result. */
+    removed: any[];
+    /** Items that stayed, at their new position, because the order around them changed. */
+    moved: {
+        index: number;
+        id: any;
+    }[];
+    /** Length of the resulting array — lets a recipient verify it applied the delta to the result it was computed against. */
+    resultCount: number;
+}
+/**
+ * Checks whether a delta leaves the result it is applied to unchanged.
+ * @param delta - The delta to inspect.
+ * @returns `true` when applying the delta would be a no-op.
+ */
+export declare function isEmptyQueryDelta(delta: QueryDelta<any>): boolean;
+/**
+ * Calls a state-change callback, passing the delta only when there is one.
+ *
+ * A callback invoked as `callback(state, undefined)` has been handed two arguments, which is a
+ * different thing from being handed one — visible to anything that inspects arity, and to any test
+ * that asserts on the call.
+ * @template T - The type of the items.
+ * @param callback - The callback to invoke.
+ * @param state - The state to report.
+ * @param delta - The delta to report, if there is one.
+ */
+export declare function callWithDelta<T extends BaseItem>(callback: (state: 'active' | 'complete' | 'error', delta?: QueryDelta<T>) => void, state: 'active' | 'complete' | 'error', delta?: QueryDelta<T>): void;
+/**
+ * Checks whether a delta describes a change to the given result.
+ *
+ * A delta is only meaningful against the exact result it was computed from — it names positions in
+ * an array and items by id alone. Applying one to anything else produces a result that looks
+ * plausible and is wrong, and from then on every further delta compounds the error. This is the
+ * cheap structural check that catches that: every id the delta expects to find is there, every id
+ * it expects to be new is not, and the arithmetic on the length works out. It costs the size of the
+ * delta, not the size of the result.
+ * @template T - The type of the items.
+ * @param previous - The result the delta would be applied to.
+ * @param delta - The delta to check.
+ * @returns `true` when the delta can be applied.
+ */
+export declare function canApplyQueryDelta<T extends BaseItem>(previous: T[], delta: QueryDelta<T>): boolean;
+/**
+ * Computes the delta between two results of the same query.
+ *
+ * A fallback for the cases where the change that produced the new result is not available — a query
+ * that had to be re-executed in full, for instance. It costs a pass over both results, but it is
+ * paid once, on the side that has both of them, instead of shipping the entire new result to
+ * everyone who only needs to know what changed.
+ * @template T - The type of the items.
+ * @param previous - The result the delta should be relative to.
+ * @param next - The result the delta should produce.
+ * @returns The delta between the two results.
+ */
+export declare function diffQueryResults<T extends BaseItem>(previous: T[], next: T[]): QueryDelta<T>;
+/**
+ * Applies a delta to the result it was computed against.
+ * @template T - The type of the items.
+ * @param previous - The result the delta is relative to. Not modified.
+ * @param delta - The delta to apply.
+ * @returns The resulting items.
+ */
+export declare function applyQueryDelta<T extends BaseItem>(previous: T[], delta: QueryDelta<T>): T[];