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

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

@@ -0,0 +1,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmptyQueryDelta = isEmptyQueryDelta;
+exports.callWithDelta = callWithDelta;
+exports.canApplyQueryDelta = canApplyQueryDelta;
+exports.diffQueryResults = diffQueryResults;
+exports.applyQueryDelta = applyQueryDelta;
+const isEqual_1 = __importDefault(require("./isEqual"));
+/**
+ * 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.
+ */
+function isEmptyQueryDelta(delta) {
+    return delta.added.length === 0
+        && delta.changed.length === 0
+        && delta.removed.length === 0
+        && delta.moved.length === 0;
+}
+/**
+ * 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.
+ */
+function callWithDelta(callback, state, delta) {
+    if (delta == null) {
+        callback(state);
+        return;
+    }
+    callback(state, delta);
+}
+/**
+ * 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.
+ */
+function canApplyQueryDelta(previous, delta) {
+    const present = new Set(previous.map(item => item.id));
+    const seen = new Set();
+    const claim = (id, shouldExist) => {
+        if (seen.has(id))
+            return false;
+        seen.add(id);
+        return present.has(id) === shouldExist;
+    };
+    const expectedCount = previous.length - delta.removed.length + delta.added.length;
+    if (expectedCount !== delta.resultCount)
+        return false;
+    if (!delta.removed.every(id => claim(id, true)))
+        return false;
+    if (!delta.added.every(({ index, item }) => claim(item.id, false)
+        && index >= 0 && index < delta.resultCount))
+        return false;
+    if (!delta.changed.every(item => present.has(item.id)))
+        return false;
+    return delta.moved.every(({ index, id }) => present.has(id)
+        && !delta.removed.includes(id)
+        && index >= 0 && index < delta.resultCount);
+}
+/**
+ * Indices of the longest strictly increasing subsequence of the given numbers.
+ * Used to decide which items keep their place when a result is reordered: everything outside the
+ * subsequence has to move, everything inside it is already in the right relative order.
+ * @param sequence - The numbers to inspect.
+ * @returns The indices into `sequence` that form the longest increasing subsequence.
+ */
+function longestIncreasingSubsequence(sequence) {
+    if (sequence.length === 0)
+        return [];
+    // `tails[length - 1]` is the index of the smallest possible tail of an increasing subsequence of
+    // that length; `previous` links each index back to its predecessor so the run can be walked out.
+    const tails = [];
+    const previous = Array.from({ length: sequence.length }).fill(-1);
+    for (let index = 0; index < sequence.length; index += 1) {
+        const value = sequence[index];
+        let low = 0;
+        let high = tails.length;
+        while (low < high) {
+            const middle = (low + high) >> 1;
+            if (sequence[tails[middle]] < value) {
+                low = middle + 1;
+            }
+            else {
+                high = middle;
+            }
+        }
+        if (low > 0)
+            previous[index] = tails[low - 1];
+        tails[low] = index;
+    }
+    const result = [];
+    let cursor = tails.at(-1);
+    while (cursor !== -1) {
+        result.push(cursor);
+        cursor = previous[cursor];
+    }
+    return result.toReversed();
+}
+/**
+ * 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.
+ */
+function diffQueryResults(previous, next) {
+    // Both arrays are walked in full here, so the cheap ways out are worth taking. Two results
+    // holding the same items in the same places are the common case by some margin: this is asked
+    // several times per write, and most of those ask about a query the write did not really change.
+    if (holdsTheSameItems(previous, next)) {
+        return { added: [], changed: [], removed: [], moved: [], resultCount: next.length };
+    }
+    const previousIndexById = new Map();
+    previous.forEach((item, index) => previousIndexById.set(item.id, index));
+    const added = [];
+    const changed = [];
+    // Positions in `previous` of the items that survive, in the order they appear in `next`. An
+    // increasing run in here is a stretch of items whose relative order did not change — and when
+    // the whole thing is increasing, nothing moved and the work below can be skipped entirely.
+    const survivingPreviousIndices = [];
+    const survivingNextIndices = [];
+    const survived = Array.from({ length: previous.length }).fill(false);
+    let orderPreserved = true;
+    let lastPreviousIndex = -1;
+    next.forEach((item, index) => {
+        const previousIndex = previousIndexById.get(item.id);
+        if (previousIndex == null) {
+            added.push({ index, item });
+            return;
+        }
+        survived[previousIndex] = true;
+        if (!(0, isEqual_1.default)(previous[previousIndex], item))
+            changed.push(item);
+        if (previousIndex < lastPreviousIndex)
+            orderPreserved = false;
+        lastPreviousIndex = previousIndex;
+        survivingPreviousIndices.push(previousIndex);
+        survivingNextIndices.push(index);
+    });
+    const removed = [];
+    previous.forEach((item, index) => {
+        if (!survived[index])
+            removed.push(item.id);
+    });
+    const moved = [];
+    if (!orderPreserved) {
+        const stationary = new Set(longestIncreasingSubsequence(survivingPreviousIndices)
+            .map(position => survivingNextIndices[position]));
+        survivingNextIndices.forEach((nextIndex) => {
+            if (stationary.has(nextIndex))
+                return;
+            moved.push({ index: nextIndex, id: next[nextIndex].id });
+        });
+    }
+    return { added, changed, removed, moved, resultCount: next.length };
+}
+/**
+ * Whether two results hold the same items in the same order, by identity.
+ *
+ * Items are replaced rather than mutated wherever they come from, so identity is a sound answer to
+ * "unchanged" — and a wrong one is impossible, only a missed shortcut.
+ * @template T - The type of the items.
+ * @param previous - One result.
+ * @param next - The other.
+ * @returns `true` when the two are element-for-element the same objects.
+ */
+function holdsTheSameItems(previous, next) {
+    if (previous === next)
+        return true;
+    if (previous.length !== next.length)
+        return false;
+    return previous.every((item, index) => item === next[index]);
+}
+/**
+ * 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.
+ */
+function applyQueryDelta(previous, delta) {
+    const removed = new Set(delta.removed);
+    const changedById = new Map(delta.changed.map(item => [item.id, item]));
+    const movedIds = new Set(delta.moved.map(({ id }) => id));
+    const stationary = [];
+    const byId = new Map();
+    previous.forEach((item) => {
+        if (removed.has(item.id))
+            return;
+        const current = changedById.get(item.id) ?? item;
+        byId.set(current.id, current);
+        if (!movedIds.has(current.id))
+            stationary.push(current);
+    });
+    // Insertions carry positions in the resulting array, so splicing them in ascending order lands
+    // every one of them at its final index — each is placed only after everything before it is there.
+    const insertions = [
+        ...delta.added.map(({ index, item }) => ({ index, item })),
+        ...delta.moved.map(({ index, id }) => ({ index, item: byId.get(id) })),
+    ].sort((a, b) => a.index - b.index); // eslint-disable-line unicorn/no-array-sort -- unavailable on Hermes
+    const result = stationary;
+    insertions.forEach(({ index, item }) => {
+        if (item == null)
+            return;
+        result.splice(index, 0, item);
+    });
+    return result;
+}

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

@@ -17,6 +17,19 @@ function isEmptyOptions(options) {
         return false;
     return Object.keys(options).length === 0;
 }
+// Stands in for absent options so they can be a `WeakMap` key like any other pair half.
+const noOptions = {};
+// Ids are asked for far more often than queries are created — every cursor read resolves its query
+// through one, and a single `postMessage` round trip goes through several. Serializing the same two
+// objects over and over is pure waste, so a pair of objects that has been seen before answers from
+// here. Keyed weakly on both halves: an entry lives exactly as long as the objects it describes,
+// and a selector built fresh at the call site simply misses and is collected again.
+//
+// The cache assumes a selector or options object is not mutated after it has been used to identify
+// a query. That already holds today for a different reason — a query is registered, cached and
+// looked up under the id its selector had at registration time, so mutating it afterwards loses the
+// query either way.
+const cache = new WeakMap();
 /**
  * Generates a unique identifier for a query based on its selector and options.
  * @param selector - The selector object.
@@ -24,7 +37,25 @@ function isEmptyOptions(options) {
  * @returns A unique identifier string for the query.
  */
 function queryId(selector, options) {
+    const isCacheable = selector != null && typeof selector === 'object'
+        && (options == null || typeof options === 'object');
+    if (!isCacheable) {
+        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 selectorId = JSON.stringify(selector);
     const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
-    return `${selectorId}:${optionsId}`;
+    const id = `${selectorId}:${optionsId}`;
+    if (cachedForSelector) {
+        cachedForSelector.set(optionsKey, id);
+    }
+    else {
+        cache.set(selector, new WeakMap([[optionsKey, id]]));
+    }
+    return id;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@signaldb/svelte",
   "type": "module",
-  "version": "2.0.0-beta.13",
+  "version": "2.0.0-beta.14",
   "scripts": {
     "build": "tsc -d --noEmit false",
     "analyze-bundle": "bundle-analyzer ./dist --upload-token=$BUNDLE_ANALYZER_UPLOAD_TOKEN --bundle-name=@signaldb/svelte",