@woosh/meep-engine 3.30.0 → 3.31.0

package/src/core/clipboard/safeClipboardReadText.js

@@ -1,55 +1,90 @@
 import { obtainClipBoard } from "./obtainClipBoard.js";
 
 /**
- * Reads text from the clipboard, falling back to a file picker prompt when no clipboard is available.
+ * Prompts for a file and resolves with its text.
+ *
+ * Every exit has to settle the promise and take the hidden input back out of the document -
+ * `input[type=file]` fires no event when the dialog is dismissed in most browsers, so a cancel
+ * used to leave the caller pending forever and one detached node behind per attempt.
+ *
  * @returns {Promise<string>}
  */
-export async function safeClipboardReadText() {
+function promptForFileText() {
+    return new Promise((resolve, reject) => {
 
-    return obtainClipBoard().then(() => {
+        const fileInput = document.createElement("input");
 
-        const navigator = globalThis.navigator;
-        return navigator.clipboard.readText();
-    }, () => {
-        // clipboard not available
-        console.log(`No clipboard available, using a prompt instead`);
+        fileInput.type = 'file';
+        fileInput.style.display = 'none';
 
-        function clickElem(elem) {
-            // Thx user1601638 on Stack Overflow (6/6/2018 - https://stackoverflow.com/questions/13405129/javascript-create-and-save-file )
-            var eventMouse = document.createEvent("MouseEvents")
-            eventMouse.initMouseEvent("click", true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null)
-            elem.dispatchEvent(eventMouse)
-        }
+        let settled = false;
 
-        function openFile(func) {
-            const fileInput = document.createElement("input");
-
-            const readFile = function (e) {
-                var file = e.target.files[0];
-                if (!file) {
-                    return;
-                }
-                var reader = new FileReader();
-                reader.onload = function (e) {
-                    var contents = e.target.result;
-                    fileInput.func(contents)
-                    document.body.removeChild(fileInput)
-                }
-                reader.readAsText(file)
+        function finish(callback, argument) {
+            if (settled) {
+                return;
             }
-            fileInput.type = 'file'
-            fileInput.style.display = 'none'
-            fileInput.onchange = readFile
-            fileInput.func = func
-            document.body.appendChild(fileInput)
-            clickElem(fileInput)
+
+            settled = true;
+
+            if (fileInput.parentNode !== null) {
+                fileInput.parentNode.removeChild(fileInput);
+            }
+
+            callback(argument);
         }
 
-        return new Promise((resolve, reject) => {
-            openFile(resolve);
-        });
+        fileInput.onchange = function (e) {
+            const file = e.target.files[0];
+
+            if (!file) {
+                finish(reject, new Error('No file was selected'));
+
+                return;
+            }
+
+            const reader = new FileReader();
+
+            reader.onload = function (event) {
+                finish(resolve, event.target.result);
+            };
 
+            reader.onerror = function () {
+                finish(reject, reader.error !== null ? reader.error : new Error('Failed to read file'));
+            };
 
+            reader.readAsText(file);
+        };
+
+        fileInput.oncancel = function () {
+            finish(reject, new Error('File selection was cancelled'));
+        };
+
+        document.body.appendChild(fileInput);
+
+        // `click()` rather than the legacy createEvent/initMouseEvent pair, which needs the
+        // document's own `window` as its view and throws when the two do not match
+        fileInput.click();
     });
+}
+
+/**
+ * Reads text from the clipboard, falling back to a file picker prompt when no clipboard is available.
+ * @returns {Promise<string>}
+ */
+export async function safeClipboardReadText() {
+
+    // NOTE: `.catch` after the operation, not the second argument of the same `.then`. As a sibling
+    // handler the fallback covered only `obtainClipBoard()` rejecting, and never the rejection
+    // `readText` itself produces - NotAllowedError whenever the document is not focused.
+    return obtainClipBoard()
+        .then(clipboard => {
+            return clipboard.readText();
+        })
+        .catch(() => {
+            // no clipboard, or the clipboard refused the read
+            console.log(`No clipboard available, using a prompt instead`);
+
+            return promptForFileText();
+        });
 
 }

package/src/core/clipboard/safeClipboardWriteText.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safeClipboardWriteText.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/safeClipboardWriteText.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6CAJW,MAAM,cACN,MAAM,GACJ,QAAQ,IAAI,CAAC,CAezB"}
+{"version":3,"file":"safeClipboardWriteText.d.ts","sourceRoot":"","sources":["../../../../src/core/clipboard/safeClipboardWriteText.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,6CAJW,MAAM,cACN,MAAM,GACJ,QAAQ,IAAI,CAAC,CAiBzB"}

package/src/core/clipboard/safeClipboardWriteText.js

@@ -9,15 +9,17 @@ import { downloadAsFile } from "../binary/downloadAsFile.js";
  */
 export async function safeClipboardWriteText(text, data_name = "data") {
 
-    return obtainClipBoard().then(
-        () => {
-            const navigator = globalThis.navigator;
-            return navigator.clipboard.writeText(text);
-        },
-        () => {
-            // no clipboard available
+    // NOTE: `.catch` after the operation, not the second argument of the same `.then`. As a sibling
+    // handler the fallback covered only `obtainClipBoard()` rejecting, and never the rejection the
+    // clipboard call itself produces - `writeText` rejects with NotAllowedError whenever the
+    // document is not focused, which is the failure that actually occurs.
+    return obtainClipBoard()
+        .then(clipboard => {
+            return clipboard.writeText(text);
+        })
+        .catch(() => {
+            // no clipboard, or the clipboard refused the write
             console.log(`No clipboard available, downloading instead`);
             downloadAsFile(text, `${data_name}.json`);
-        }
-    );
+        });
 }

package/src/core/collection/array/iterator/ArrayIteratorRandom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ArrayIteratorRandom.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/iterator/ArrayIteratorRandom.js"],"names":[],"mappings":"AAIA;;IACI,YAAQ;IACR,kBAAgB;IAChB;;;MAA2B;IAE3B;;;OAGG;IACH,WAFW,MAAM,QAIhB;IAED,4BAYC;IAED,wBAgBC;CACJ;sCA9CqC,4BAA4B"}
+{"version":3,"file":"ArrayIteratorRandom.d.ts","sourceRoot":"","sources":["../../../../../../src/core/collection/array/iterator/ArrayIteratorRandom.js"],"names":[],"mappings":"AAIA;;IACI,YAAQ;IACR,kBAAgB;IAChB;;;MAA2B;IAE3B;;;OAGG;IACH,WAFW,MAAM,QAIhB;IAED,4BAkBC;IAED,wBAgBC;CACJ;sCApDqC,4BAA4B"}

package/src/core/collection/array/iterator/ArrayIteratorRandom.js

@@ -20,6 +20,12 @@ export class ArrayIteratorRandom extends AbstractArrayIterator {
 
         //initialize sequence
         const n = data.length;
+
+        // the sequence is reused across calls, so it has to be cut back to the new length as well
+        // as filled - otherwise `next` walks the high-water mark of every previous input and hands
+        // out `undefined` and duplicates
+        this.__sequence.length = n;
+
         for (let i = 0; i < n; i++) {
             this.__sequence[i] = i;
         }

package/src/core/collection/heap/IndexedFloatMinHeap.d.ts

@@ -11,6 +11,12 @@ export class IndexedFloatMinHeap {
     __data_float32: Float32Array;
     /**
      * Maps id → slot index in [0, size), or SLOT_NOT_PRESENT.
+     *
+     * Every keyed method asserts its id against this length first. Reading past the end
+     * yields `undefined`, which is neither a slot nor the sentinel, so `contains` would
+     * answer yes and hand back `undefined` as the slot — and `undefined << 1` is 0, so the
+     * write lands on the root. A scanning heap just answers "not here"; this one corrupts
+     * silently, which is worth a stripped-in-production check.
      * @type {Uint32Array}
      */
     __slot_of_id: Uint32Array;

package/src/core/collection/heap/IndexedFloatMinHeap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IndexedFloatMinHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/IndexedFloatMinHeap.js"],"names":[],"mappings":"AAoCA;IAGI;;;OAGG;IACH,yBAHW,MAAM,0BACN,MAAM,EAoBhB;IAxBD,eAAW;IAaP,wBAA4C;IAC5C,2BAA4E;IAC5E,2BAAwD;IACxD,6BAA0D;IAE1D;;;OAGG;IACH,cAFU,WAAW,CAE2B;IAIpD,mBAEC;IAED;;;OAGG;IACH,cAQC;IAED,2BAEC;IAED;;;OAGG;IACH,qBAkBC;IAED;;;;OAIG;IACH,oBAsBC;IAED;;;;OAIG;IACH,kBAYC;IAED,wBAUC;IAED;;;OAGG;IACH,WAHW,MAAM,SACN,MAAM,QAehB;IAED;;OAEG;IACH,WAFa,MAAM,CAuBlB;IAED;;;OAGG;IACH,WAHW,MAAM,aACN,MAAM,QAehB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CA+BnB;CACJ"}
+{"version":3,"file":"IndexedFloatMinHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/IndexedFloatMinHeap.js"],"names":[],"mappings":"AAoCA;IAGI;;;OAGG;IACH,yBAHW,MAAM,0BACN,MAAM,EA0BhB;IA9BD,eAAW;IAaP,wBAA4C;IAC5C,2BAA4E;IAC5E,2BAAwD;IACxD,6BAA0D;IAE1D;;;;;;;;;OASG;IACH,cAFU,WAAW,CAE2B;IAIpD,mBAEC;IAED;;;OAGG;IACH,cAQC;IAED,2BAIC;IAED;;;OAGG;IACH,qBAkBC;IAED;;;;OAIG;IACH,oBAsBC;IAED;;;;OAIG;IACH,kBAYC;IAED,wBAUC;IAED;;;OAGG;IACH,WAHW,MAAM,SACN,MAAM,QAiBhB;IAED;;OAEG;IACH,WAFa,MAAM,CAuBlB;IAED;;;OAGG;IACH,WAHW,MAAM,aACN,MAAM,QAiBhB;IAED;;;OAGG;IACH,WAHW,MAAM,GACJ,OAAO,CAiCnB;CACJ"}

package/src/core/collection/heap/IndexedFloatMinHeap.js

@@ -55,6 +55,12 @@ export class IndexedFloatMinHeap {
 
         /**
          * Maps id → slot index in [0, size), or SLOT_NOT_PRESENT.
+         *
+         * Every keyed method asserts its id against this length first. Reading past the end
+         * yields `undefined`, which is neither a slot nor the sentinel, so `contains` would
+         * answer yes and hand back `undefined` as the slot — and `undefined << 1` is 0, so the
+         * write lands on the root. A scanning heap just answers "not here"; this one corrupts
+         * silently, which is worth a stripped-in-production check.
          * @type {Uint32Array}
          */
         this.__slot_of_id = new Uint32Array(id_capacity);
@@ -80,6 +86,8 @@ export class IndexedFloatMinHeap {
     }
 
     contains(id) {
+        assert.lessThan(id, this.__slot_of_id.length, 'id outside the range this heap was built for');
+
         return this.__slot_of_id[id] !== SLOT_NOT_PRESENT;
     }
 
@@ -172,6 +180,8 @@ export class IndexedFloatMinHeap {
      * @param {number} score
      */
     insert(id, score) {
+        assert.lessThan(id, this.__slot_of_id.length, 'id outside the range this heap was built for');
+
         if (this.__slot_of_id[id] !== SLOT_NOT_PRESENT) {
             throw new Error(`id ${id} already in heap`);
         }
@@ -217,6 +227,8 @@ export class IndexedFloatMinHeap {
      * @param {number} new_score
      */
     update(id, new_score) {
+        assert.lessThan(id, this.__slot_of_id.length, 'id outside the range this heap was built for');
+
         const slot = this.__slot_of_id[id];
         if (slot === SLOT_NOT_PRESENT) {
             throw new Error(`id ${id} not in heap`);
@@ -236,6 +248,8 @@ export class IndexedFloatMinHeap {
      * @returns {boolean} true if the id was present and removed
      */
     remove(id) {
+        assert.lessThan(id, this.__slot_of_id.length, 'id outside the range this heap was built for');
+
         const slot = this.__slot_of_id[id];
         if (slot === SLOT_NOT_PRESENT) {
             return false;

package/src/core/collection/list/FilteredListProjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FilteredListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/FilteredListProjection.js"],"names":[],"mappings":"AAKA;IAaI;;;;;OAKG;IACH,qCAHW,sBAAsB,EAiBhC;IAhCD;;;OAGG;IACH,QAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAED;IASZ;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,SAFU,sBAAsB,CAEV;IAEtB,wBAAoD;IAGxD,eAMC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,0BAGC;IAED;;;OAGG;IACH,4BAGC;IAED,aAUC;IAED,eAQC;IAED,cAiFC;CACJ;iBAvLgB,WAAW"}
+{"version":3,"file":"FilteredListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/FilteredListProjection.js"],"names":[],"mappings":"AAIA;IAaI;;;;;OAKG;IACH,qCAHW,sBAAsB,EAiBhC;IAhCD;;;OAGG;IACH,QAFU,OAAO,CAEG;IAEpB;;;OAGG;IACH,UAFU,OAAO,CAED;IASZ;;;OAGG;IACH,eAAkB;IAElB;;;OAGG;IACH,SAFU,sBAAsB,CAEV;IAEtB,wBAAoD;IAGxD,eAMC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,sBAEC;IAED;;;OAGG;IACH,0BAGC;IAED;;;OAGG;IACH,4BAGC;IAED,aAUC;IAED,eAQC;IAED,cAmCC;CACJ;iBA1IgB,WAAW"}

package/src/core/collection/list/FilteredListProjection.js

@@ -1,7 +1,6 @@
 import { frameThrottle } from "../../function/frameThrottle.js";
-import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
-import { array_set_diff } from "../array/array_set_diff.js";
 import List from "./List.js";
+import { list_apply_ordered_diff } from "./list_apply_ordered_diff.js";
 
 export class FilteredListProjection {
     /**
@@ -107,11 +106,6 @@ export class FilteredListProjection {
         const output = this.output;
         const filters = this.filters.asArray();
 
-        /**
-         *
-         * @type {T[]}
-         */
-        const oldOutput = output.asArray().slice();
         /**
          *
          * @type {T[]}
@@ -136,52 +130,11 @@ export class FilteredListProjection {
             newOutput.push(v);
         }
 
-        const diff = array_set_diff(oldOutput, newOutput, invokeObjectEquals);
-
-        //resolve diff
-        const removals = diff.uniqueA;
-
-        removals.forEach(item => output.removeOneOf(item));
-
-        const additions = diff.uniqueB;
-
-        //sort additions by their position in the input
-        additions.sort((a, b) => {
-            const ai = input.indexOf(a);
-            const bi = input.indexOf(b);
-
-            return bi - ai;
-        });
-
-        /**
-         *
-         * @param {Item} item
-         * @return {number}
-         */
-        function computeInsertionPosition(item) {
-            //find where the item is in the input
-            const inputIndex = input.indexOf(item);
-
-            for (let i = inputIndex - 1; i >= 0; i--) {
-                const prev = input.get(i);
-
-                //look for previous item in the output
-                const j = output.indexOf(prev);
-
-                if (j !== -1) {
-                    return j + 1;
-                }
-            }
-
-            //insert in the beginning
-            return 0;
-        }
-
-        additions.forEach(item => {
-            //find a place for insertion
-            const p = computeInsertionPosition(item);
-
-            output.insert(p, item);
-        });
+        // `newOutput` is a subsequence of the input, and after the removals the output holds only
+        // entries that survived the filters, so walking back through `newOutput` for an addition's
+        // predecessor reaches the same entry that walking back through the whole input did — every
+        // input entry between two consecutive `newOutput` entries was filtered out and so is not in the
+        // output to be found.
+        list_apply_ordered_diff(output, newOutput);
     }
 }

package/src/core/collection/list/List.d.ts

@@ -94,6 +94,10 @@ declare class List<T> {
      * Replace the data, replacements is performed surgically, meaning that diff is computed and add/remove operations are performed on the set
      * This method is tailored to work well with visualisation as only elements that's missing from the new set is removed, and only elements that are new to are added
      * Conversely, relevant events are dispatched that can observe. This results in fewer changes required to the visualisation
+     *
+     * Surviving entries keep the order they already had — see {@link list_apply_ordered_diff}, which is
+     * the walk, and which `FilteredListProjection#apply` also runs.
+     *
      * @param {T[]} new_data
      */
     patch(new_data: T[]): void;

package/src/core/collection/list/List.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}

package/src/core/collection/list/List.js

@@ -3,7 +3,7 @@ import Signal from "../../events/signal/Signal.js";
 import { objectsEqual } from "../../function/objectsEqual.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
 import { array_index_by_equality } from "../array/array_index_by_equality.js";
-import { array_set_diff } from "../array/array_set_diff.js";
+import { list_apply_ordered_diff } from "./list_apply_ordered_diff.js";
 
 
 
@@ -238,59 +238,14 @@ class List {
      * Replace the data, replacements is performed surgically, meaning that diff is computed and add/remove operations are performed on the set
      * This method is tailored to work well with visualisation as only elements that's missing from the new set is removed, and only elements that are new to are added
      * Conversely, relevant events are dispatched that can observe. This results in fewer changes required to the visualisation
+     *
+     * Surviving entries keep the order they already had — see {@link list_apply_ordered_diff}, which is
+     * the walk, and which `FilteredListProjection#apply` also runs.
+     *
      * @param {T[]} new_data
      */
     patch(new_data) {
-
-        const data = this.data;
-
-        const diff = array_set_diff(data, new_data, objectsEqual);
-
-        //resolve diff
-        const removals = diff.uniqueA;
-
-        const removalCount = removals.length;
-
-        for (let i = 0; i < removalCount; i++) {
-            const item = removals[i];
-
-            this.removeOneOf(item);
-        }
-
-        const additions = diff.uniqueB;
-
-        //sort additions by their position in the input
-        additions.sort((a, b) => {
-            const ai = new_data.indexOf(a);
-            const bi = new_data.indexOf(b);
-
-            return bi - ai;
-        });
-
-        const additionsCount = additions.length;
-
-        for (let i = 0; i < additionsCount; i++) {
-            const item = additions[i];
-
-            //find where the item is in the input
-            const inputIndex = new_data.indexOf(item);
-
-            let p = 0;
-            for (let i = inputIndex - 1; i >= 0; i--) {
-                const prev = new_data[i];
-
-                //look for previous item in the output
-                const j = this.indexOf(prev);
-
-                if (j !== -1) {
-                    p = j + 1;
-                    break;
-                }
-            }
-
-            this.insert(p, item);
-        }
-
+        list_apply_ordered_diff(this, new_data, objectsEqual);
     }
 
     /**
@@ -767,7 +722,10 @@ class List {
                 }
 
             } else {
-                this.data = [];
+                // truncate in place, matching the signalling branch above. Assigning a fresh array
+                // here would make the aliasing of the array `asArray` hands out depend on whether
+                // some unrelated observer happens to be subscribed.
+                this.data.length = 0;
                 this.length = 0;
             }
 

package/src/core/collection/list/SortedListProjection.d.ts

@@ -30,6 +30,13 @@ export class SortedListProjection<T> {
      * @param {T} el
      */
     handleAddition(el: T): void;
+    /**
+     * Without this the output only ever grows - it is correct at `build()` time and drifts from
+     * then on.
+     *
+     * @param {T} el
+     */
+    handleRemoval(el: T): void;
     build(): void;
 }
 import List from "./List.js";

package/src/core/collection/list/SortedListProjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SortedListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/SortedListProjection.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAOI;;;;OAIG;IACH,mBAHW,KAAK,CAAC,CAAC,qBACE,CAAC,QAAC,CAAC,KAAE,MAAM,EAc9B;IAvBD;;;OAGG;IACH,QAFU,KAAK,CAAC,CAAC,CAEG;IAQhB;;;OAGG;IACH,OAFU,KAAK,CAAC,CAAC,CAEC;IAElB;;;OAGG;IACH,mBAFmB,CAAC,QAAE,CAAC,KAAG,MAAM,CAEJ;IAGhC,aAIC;IAED,eAEC;IAED;;;OAGG;IACH,mBAFW,CAAC,QASX;IAGD,cAUC;CAEJ;iBAnEgB,WAAW"}
+{"version":3,"file":"SortedListProjection.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/SortedListProjection.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAOI;;;;OAIG;IACH,mBAHW,KAAK,CAAC,CAAC,qBACE,CAAC,QAAC,CAAC,KAAE,MAAM,EAc9B;IAvBD;;;OAGG;IACH,QAFU,KAAK,CAAC,CAAC,CAEG;IAQhB;;;OAGG;IACH,OAFU,KAAK,CAAC,CAAC,CAEC;IAElB;;;OAGG;IACH,mBAFmB,CAAC,QAAE,CAAC,KAAG,MAAM,CAEJ;IAGhC,aAKC;IAED,eAGC;IAED;;;OAGG;IACH,mBAFW,CAAC,QASX;IAED;;;;;OAKG;IACH,kBAFW,CAAC,QAIX;IAGD,cAUC;CAEJ;iBA/EgB,WAAW"}

package/src/core/collection/list/SortedListProjection.js

@@ -32,12 +32,14 @@ export class SortedListProjection {
 
     link() {
         this.input.on.added.add(this.handleAddition, this);
+        this.input.on.removed.add(this.handleRemoval, this);
 
         this.build();
     }
 
     unlink() {
         this.input.on.added.remove(this.handleAddition, this);
+        this.input.on.removed.remove(this.handleRemoval, this);
     }
 
     /**
@@ -53,6 +55,16 @@ export class SortedListProjection {
         this.output.insert(where + 1, el);
     }
 
+    /**
+     * Without this the output only ever grows - it is correct at `build()` time and drifts from
+     * then on.
+     *
+     * @param {T} el
+     */
+    handleRemoval(el) {
+        this.output.removeOneOf(el);
+    }
+
 
     build() {
         this.output.reset();

package/src/core/collection/list/list_apply_ordered_diff.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bring a {@link List} into line with `desired` by removing and inserting only what differs — so that
+ * a view observing the list's `added`/`removed` signals redraws only what moved.
+ *
+ * Five steps: diff the two as multisets, remove everything the list has and `desired` does not, then
+ * take the additions in reverse order of their position in `desired` and insert each one directly
+ * after the nearest element before it in `desired` that the list already holds. Working back to front
+ * is what makes the positions stable — an insertion never shifts an element a later insertion is
+ * measuring against.
+ *
+ * **Surviving elements are not reordered.** This is a diff-and-place, not an assignment: an element
+ * present in both keeps the position it already had, and only the additions are placed. So a list of
+ * `[1, 2, 3, 4]` against a desired `[4, 5, 1]` becomes `[1, 4, 5]`, not `[4, 5, 1]`. That is the point
+ * of the operation for a view — reordering survivors would cost the redraw the diff exists to avoid.
+ *
+ * One `equals` governs all three questions the walk asks: what is common, what to remove, and where an
+ * addition's predecessor is. It defaults to {@link objectsEqual}, which is the rule
+ * {@link List#removeOneOf} applies, so the diff choosing what to remove agrees with the removal doing
+ * it. `invokeObjectEquals` does not agree — it calls `a.equals(b)` unconditionally, and so throws on a
+ * list of primitives.
+ *
+ * This walk was written out twice, in `List#patch` and `FilteredListProjection#apply`, with three
+ * different equality rules between the two copies — including a predecessor lookup by identity that
+ * sent an addition to the front of the list whenever its predecessor was an `equals`-but-not-identical
+ * twin. The sort in both copies also called `indexOf` from inside the comparator, an O(n^2 log n) that
+ * the position map below removes.
+ *
+ * @template T
+ * @param {List<T>} list the list to bring into line, modified in place
+ * @param {T[]} desired the entries it should hold, in the order additions should be placed by
+ * @param {(a: T, b: T) => boolean} [equals] how to decide two entries are the same entry
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function list_apply_ordered_diff<T>(list: List<T>, desired: T[], equals?: (a: T, b: T) => boolean): void;
+//# sourceMappingURL=list_apply_ordered_diff.d.ts.map

package/src/core/collection/list/list_apply_ordered_diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list_apply_ordered_diff.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/list_apply_ordered_diff.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iGAL2B,OAAO,QAoDjC"}

package/src/core/collection/list/list_apply_ordered_diff.js

@@ -0,0 +1,87 @@
+import { objectsEqual } from "../../function/objectsEqual.js";
+import { array_index_by_equality } from "../array/array_index_by_equality.js";
+import { array_set_diff } from "../array/array_set_diff.js";
+
+/**
+ * Bring a {@link List} into line with `desired` by removing and inserting only what differs — so that
+ * a view observing the list's `added`/`removed` signals redraws only what moved.
+ *
+ * Five steps: diff the two as multisets, remove everything the list has and `desired` does not, then
+ * take the additions in reverse order of their position in `desired` and insert each one directly
+ * after the nearest element before it in `desired` that the list already holds. Working back to front
+ * is what makes the positions stable — an insertion never shifts an element a later insertion is
+ * measuring against.
+ *
+ * **Surviving elements are not reordered.** This is a diff-and-place, not an assignment: an element
+ * present in both keeps the position it already had, and only the additions are placed. So a list of
+ * `[1, 2, 3, 4]` against a desired `[4, 5, 1]` becomes `[1, 4, 5]`, not `[4, 5, 1]`. That is the point
+ * of the operation for a view — reordering survivors would cost the redraw the diff exists to avoid.
+ *
+ * One `equals` governs all three questions the walk asks: what is common, what to remove, and where an
+ * addition's predecessor is. It defaults to {@link objectsEqual}, which is the rule
+ * {@link List#removeOneOf} applies, so the diff choosing what to remove agrees with the removal doing
+ * it. `invokeObjectEquals` does not agree — it calls `a.equals(b)` unconditionally, and so throws on a
+ * list of primitives.
+ *
+ * This walk was written out twice, in `List#patch` and `FilteredListProjection#apply`, with three
+ * different equality rules between the two copies — including a predecessor lookup by identity that
+ * sent an addition to the front of the list whenever its predecessor was an `equals`-but-not-identical
+ * twin. The sort in both copies also called `indexOf` from inside the comparator, an O(n^2 log n) that
+ * the position map below removes.
+ *
+ * @template T
+ * @param {List<T>} list the list to bring into line, modified in place
+ * @param {T[]} desired the entries it should hold, in the order additions should be placed by
+ * @param {(a: T, b: T) => boolean} [equals] how to decide two entries are the same entry
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function list_apply_ordered_diff(list, desired, equals = objectsEqual) {
+    const diff = array_set_diff(list.asArray(), desired, equals);
+
+    const removals = diff.uniqueA;
+
+    const removal_count = removals.length;
+
+    for (let i = 0; i < removal_count; i++) {
+        list.removeOneOf(removals[i]);
+    }
+
+    const additions = diff.uniqueB;
+
+    const addition_count = additions.length;
+
+    if (addition_count === 0) {
+        return;
+    }
+
+    // first position of each entry in `desired`, which is what `indexOf` would answer, taken once
+    // instead of once per comparison
+    const position = new Map();
+
+    for (let i = desired.length - 1; i >= 0; i--) {
+        position.set(desired[i], i);
+    }
+
+    additions.sort((a, b) => position.get(b) - position.get(a));
+
+    for (let i = 0; i < addition_count; i++) {
+        const item = additions[i];
+
+        const desired_index = position.get(item);
+
+        let insertion_index = 0;
+
+        for (let j = desired_index - 1; j >= 0; j--) {
+            const predecessor = array_index_by_equality(list.asArray(), desired[j], equals);
+
+            if (predecessor !== -1) {
+                insertion_index = predecessor + 1;
+                break;
+            }
+        }
+
+        list.insert(insertion_index, item);
+    }
+}

package/src/core/collection/map/BiMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BiMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/BiMap.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IAEI;;;OAGG;IACH,SAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEC;IACpB;;;OAGG;IACH,UAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEE;IAGrB;;;;;;;;OAQG;IACH,WAHW,CAAC,OACD,CAAC,QAKX;IAED;;;;;OAKG;IACH,qBAHW,CAAC,GACC,OAAO,CAanB;IAED;;;;;OAKG;IACH,iBAHW,CAAC,GACC,OAAO,CAanB;IAED;;OAEG;IACH,mBAEC;IAED,cAGC;IAED;;;;OAIG;IACH,qBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,uBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAGL,2BAAmB;IACnB,oCAAmB;CAHlB"}
+{"version":3,"file":"BiMap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/map/BiMap.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IAEI;;;OAGG;IACH,SAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEC;IACpB;;;OAGG;IACH,UAFU,IAAI,CAAC,EAAE,CAAC,CAAC,CAEE;IAGrB;;;;;;;;OAQG;IACH,WAHW,CAAC,OACD,CAAC,QAgBX;IAED;;;;;OAKG;IACH,qBAHW,CAAC,GACC,OAAO,CAcnB;IAED;;;;;OAKG;IACH,iBAHW,CAAC,GACC,OAAO,CAcnB;IAED;;OAEG;IACH,mBAEC;IAED,cAGC;IAED;;;;OAIG;IACH,qBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,uBAHW,CAAC,GACC,CAAC,GAAC,SAAS,CAIvB;IAGL,2BAAmB;IACnB,oCAAmB;CAHlB"}