reactronic 0.94.25037 → 0.95.25043

package/build/dist/source/util/LinkedListRenovation.js

@@ -0,0 +1,134 @@
+import { misuse } from "./Dbg.js";
+import { LinkedList, LinkedItem, LinkedSubList, Mark } from "./LinkedList.js";
+export class LinkedListRenovation {
+    constructor(list, diff) {
+        if (list.former$ !== undefined)
+            throw misuse("renovation is in progress already");
+        const former = list.items$;
+        this.list = list;
+        this.diff = diff;
+        this.lost$ = former;
+        this.expected = former.first;
+        this.absent = undefined;
+        list.former$ = former;
+        list.items$ = new LinkedSubList();
+    }
+    lookup(key) {
+        let result = undefined;
+        if (key !== undefined && key !== this.absent) {
+            result = this.list.lookup(key);
+            if (result !== undefined) {
+                if (this.list.keyOf(result) !== key) {
+                    this.absent = key;
+                    result = undefined;
+                }
+            }
+            else
+                this.absent = key;
+        }
+        return result;
+    }
+    tryToProlonge(key, resolution, error) {
+        var _a, _b;
+        const list = this.list;
+        if (!list.isRenovationInProgress)
+            throw misuse(error !== null && error !== void 0 ? error : "renovation is no longer in progress");
+        let x = this.expected;
+        if (key !== (x ? list.keyOf(x) : undefined))
+            x = this.lookup(key);
+        if (x !== undefined) {
+            const result = this.list.items$;
+            if (x.list !== result) {
+                const next = x.next;
+                const expected = (_a = grabExternalIfAny(result, x)) !== null && _a !== void 0 ? _a : x;
+                LinkedItem.link$(result, x, undefined);
+                if (list.isStrictOrder && expected !== this.expected) {
+                    LinkedItem.setStatus$(x, Mark.modified, result.count);
+                    (_b = this.diff) === null || _b === void 0 ? void 0 : _b.push(x);
+                }
+                else
+                    LinkedItem.setStatus$(x, Mark.prolonged, result.count);
+                this.expected = next;
+                if (resolution)
+                    resolution.isDuplicate = false;
+            }
+            else if (resolution)
+                resolution.isDuplicate = true;
+            else
+                throw misuse(`duplicate linked item key: ${key}`);
+        }
+        else if (resolution)
+            resolution.isDuplicate = false;
+        return x;
+    }
+    thisIsAdded(item, before) {
+        var _a;
+        this.list.add(item, before);
+        LinkedItem.setStatus$(item, Mark.added, this.list.items$.count);
+        this.absent = undefined;
+        this.expected = undefined;
+        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
+        return item;
+    }
+    thisIsModified(item) {
+        if (item.list !== this.list.items$)
+            throw misuse("only prolonged items can be marked as modified");
+        const m = item.mark;
+        if (m === Mark.prolonged)
+            LinkedItem.setStatus$(item, Mark.modified, item.rank);
+        else if (m !== Mark.modified)
+            throw misuse("item is renovated already and cannot be marked as modified");
+    }
+    thisIsMoved(item, before) {
+        var _a;
+        if (item.list !== this.list.former$)
+            throw misuse("cannot move item which doesn't belong to former list");
+        LinkedList.move$(this.list, item, before);
+        LinkedItem.setStatus$(item, Mark.modified, 0);
+        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
+    }
+    thisIsRemoved(item) {
+        var _a;
+        if (item.list !== this.list.former$)
+            throw misuse("cannot remove item which doesn't belong to former list");
+        LinkedList.remove$(this.list, item);
+        LinkedItem.setStatus$(item, Mark.removed, 0);
+        (_a = this.diff) === null || _a === void 0 ? void 0 : _a.push(item);
+    }
+    get lostItemCount() { return this.lost$.count; }
+    lostItems() { return this.lost$.items(); }
+    done(error) {
+        const list = this.list;
+        if (!list.isRenovationInProgress)
+            throw misuse("renovation is ended already");
+        const items = this.list.items$;
+        const lost = this.lost$;
+        if (error === undefined) {
+            for (const x of lost.items()) {
+                if (!x.isManagedExternally) {
+                    LinkedList.removeKey$(list, list.keyOf(x));
+                    LinkedItem.setStatus$(x, Mark.removed, 0);
+                }
+                else
+                    LinkedItem.link$(items, x, undefined);
+            }
+        }
+        else {
+            for (const x of lost.items()) {
+                LinkedItem.link$(items, x, undefined);
+                LinkedItem.setStatus$(x, Mark.prolonged, items.count);
+            }
+        }
+        list.former$ = undefined;
+    }
+}
+function grabExternalIfAny(list, item) {
+    let x = item.prev;
+    let before = undefined;
+    while (x !== undefined && x.isManagedExternally) {
+        LinkedItem.link$(list, x, before);
+        before = x;
+        x = x.prev;
+    }
+    return before;
+}

package/build/dist/source/util/ReconciliationList.d.ts

@@ -9,12 +9,13 @@ export type ReconciliationListReader<T> = {
     firstItem(): LinkedItem<T> | undefined;
     lastItem(): LinkedItem<T> | undefined;
     items(onlyAfter?: LinkedItem<T>): Generator<LinkedItem<T>>;
-    itemsAdded(reset?: boolean): Generator<LinkedItem<T>>;
-    itemsRemoved(reset?: boolean): Generator<LinkedItem<T>>;
+    itemsAdded(clear?: boolean): Generator<LinkedItem<T>>;
+    itemsRemoved(clear?: boolean): Generator<LinkedItem<T>>;
     isAdded(item: LinkedItem<T>): boolean;
     isMoved(item: LinkedItem<T>): boolean;
     isRemoved(item: LinkedItem<T>): boolean;
-    isFresh(item: LinkedItem<T>): boolean;
+    isActual(item: LinkedItem<T>): boolean;
+    isExternal(item: LinkedItem<T>): boolean;
 };
 export type LinkedItem<T> = {
     readonly instance: T;
@@ -28,7 +29,7 @@ export declare class ReconciliationList<T> implements ReconciliationListReader<T
     private strict;
     private map;
     private tag;
-    private fresh;
+    private actual;
     private added;
     private removed;
     private lastNotFoundKey;
@@ -49,16 +50,17 @@ export declare class ReconciliationList<T> implements ReconciliationListReader<T
     move(item: LinkedItem<T>, after: LinkedItem<T>): void;
     beginReconciliation(): void;
     endReconciliation(error?: unknown): void;
-    resetAddedAndRemovedLists(): void;
+    clearAddedAndRemoved(): void;
     firstItem(): LinkedItem<T> | undefined;
     lastItem(): LinkedItem<T> | undefined;
     items(onlyAfter?: LinkedItem<T>): Generator<LinkedItem<T>>;
-    itemsAdded(reset?: boolean): Generator<LinkedItem<T>>;
-    itemsRemoved(reset?: boolean): Generator<LinkedItem<T>>;
+    itemsAdded(clear?: boolean): Generator<LinkedItem<T>>;
+    itemsRemoved(clear?: boolean): Generator<LinkedItem<T>>;
     isAdded(item: LinkedItem<T>): boolean;
     isMoved(item: LinkedItem<T>): boolean;
     isRemoved(item: LinkedItem<T>): boolean;
-    isFresh(item: LinkedItem<T>): boolean;
+    isActual(item: LinkedItem<T>): boolean;
+    isExternal(item: LinkedItem<T>): boolean;
     markAsMoved(item: LinkedItem<T>): void;
     static createItem<T>(instance: T): LinkedItem<T>;
 }

package/build/dist/source/util/ReconciliationList.js

@@ -5,7 +5,7 @@ export class ReconciliationList {
         this.strict = strict;
         this.map = new Map();
         this.tag = ~0;
-        this.fresh = new LinkedItemChain();
+        this.actual = new LinkedItemChain();
         this.added = new LinkedItemChain();
         this.removed = new LinkedItemChain();
         this.lastNotFoundKey = undefined;
@@ -13,12 +13,12 @@ export class ReconciliationList {
     }
     get isStrict() { return this.strict; }
     set isStrict(value) {
-        if (this.isReconciliationInProgress && this.fresh.count > 0)
+        if (this.isReconciliationInProgress && this.actual.count > 0)
             throw misuse("cannot change strict mode in the middle of reconciliation");
         this.strict = value;
     }
     get count() {
-        return this.fresh.count;
+        return this.actual.count;
     }
     get countOfAdded() {
         return this.added.count;
@@ -55,11 +55,11 @@ export class ReconciliationList {
             if (item.tag !== tag) {
                 item.tag = tag;
                 if (this.strict && item !== this.strictNextItem)
-                    item.status = tag;
+                    item.moving = tag;
                 this.strictNextItem = item.next;
                 this.removed.exclude(item);
-                item.index = this.fresh.count;
-                this.fresh.include(item);
+                item.index = this.actual.count;
+                this.actual.include(item);
                 if (resolution)
                     resolution.isDuplicate = false;
             }
@@ -76,24 +76,21 @@ export class ReconciliationList {
         const key = this.getKey(instance);
         if (this.lookup(key) !== undefined)
             throw misuse(`key is already in use: ${key}`);
-        let tag = this.tag;
-        if (tag < 0) {
-            tag = ~this.tag + 1;
-            this.tag = ~tag;
-        }
-        const item = new LinkedItemImpl(instance, tag);
+        const tag = this.tag > 0 ? this.tag : 0;
+        const item = new LinkedItem$(instance, tag);
         this.map.set(key, item);
         this.lastNotFoundKey = undefined;
         this.strictNextItem = undefined;
-        item.index = this.fresh.count;
-        this.fresh.include(item);
-        this.added.aux(item);
+        item.index = this.actual.count;
+        this.actual.include(item);
+        if (tag !== 0)
+            this.added.includeAux(item);
         return item;
     }
     remove(item) {
         const t = item;
         if (!this.isRemoved(t)) {
-            this.fresh.exclude(t);
+            this.actual.exclude(t);
             this.removed.include(t);
             t.tag--;
         }
@@ -105,26 +102,26 @@ export class ReconciliationList {
         if (this.isReconciliationInProgress)
             throw misuse("reconciliation is in progress already");
         this.tag = ~this.tag + 1;
-        this.strictNextItem = this.fresh.first;
-        this.removed.grab(this.fresh, false);
-        this.added.reset();
+        this.strictNextItem = this.actual.first;
+        this.removed.grab(this.actual, false);
+        this.added.clear();
     }
     endReconciliation(error) {
         if (!this.isReconciliationInProgress)
             throw misuse("reconciliation is ended already");
         this.tag = ~this.tag;
         if (error === undefined) {
-            const freshCount = this.fresh.count;
-            if (freshCount > 0) {
+            const actualCount = this.actual.count;
+            if (actualCount > 0) {
                 const getKey = this.getKey;
-                if (freshCount > this.removed.count) {
+                if (actualCount > this.removed.count) {
                     const map = this.map;
                     for (const x of this.removed.items())
                         map.delete(getKey(x.instance));
                 }
                 else {
                     const map = this.map = new Map();
-                    for (const x of this.fresh.items())
+                    for (const x of this.actual.items())
                         map.set(getKey(x.instance), x);
                 }
             }
@@ -132,35 +129,35 @@ export class ReconciliationList {
                 this.map = new Map();
         }
         else {
-            this.fresh.grab(this.removed, true);
+            this.actual.grab(this.removed, true);
             const getKey = this.getKey;
-            for (const x of this.added.itemsViaAux()) {
+            for (const x of this.added.itemsAux()) {
                 this.map.delete(getKey(x.instance));
-                this.fresh.exclude(x);
+                this.actual.exclude(x);
             }
-            this.added.reset();
+            this.added.clear();
         }
     }
-    resetAddedAndRemovedLists() {
-        this.removed.reset();
-        this.added.reset();
+    clearAddedAndRemoved() {
+        this.removed.clear();
+        this.added.clear();
     }
     firstItem() {
-        return this.fresh.first;
+        return this.actual.first;
     }
     lastItem() {
-        return this.fresh.last;
+        return this.actual.last;
     }
     *items(onlyAfter) {
         var _a;
-        let x = (_a = onlyAfter === null || onlyAfter === void 0 ? void 0 : onlyAfter.next) !== null && _a !== void 0 ? _a : this.fresh.first;
+        let x = (_a = onlyAfter === null || onlyAfter === void 0 ? void 0 : onlyAfter.next) !== null && _a !== void 0 ? _a : this.actual.first;
         while (x !== undefined) {
             const next = x.next;
             yield x;
             x = next;
         }
     }
-    *itemsAdded(reset) {
+    *itemsAdded(clear) {
         let x = this.added.first;
         while (x !== undefined) {
             const next = x.aux;
@@ -168,57 +165,61 @@ export class ReconciliationList {
                 yield x;
             x = next;
         }
-        if (reset)
-            this.added.reset();
+        if (clear)
+            this.added.clear();
     }
-    *itemsRemoved(reset) {
+    *itemsRemoved(clear) {
         let x = this.removed.first;
         while (x !== undefined) {
             const next = x.next;
             yield x;
             x = next;
         }
-        if (reset)
-            this.removed.reset();
+        if (clear)
+            this.removed.clear();
     }
     isAdded(item) {
         const t = item;
         let tag = this.tag;
         if (tag < 0)
             tag = ~tag;
-        return t.status === ~tag && t.tag > 0;
+        return t.moving === ~tag && t.tag > 0;
     }
     isMoved(item) {
         const t = item;
         let tag = this.tag;
         if (tag < 0)
             tag = ~tag;
-        return t.status === tag && t.tag > 0;
+        return t.moving === tag && t.tag > 0;
     }
     isRemoved(item) {
         const t = item;
         const tag = this.tag;
         return tag > 0 ? t.tag < tag : t.tag < tag - 1;
     }
-    isFresh(item) {
+    isActual(item) {
         const t = item;
         return t.tag === this.tag;
     }
+    isExternal(item) {
+        const t = item;
+        return t.tag === 0;
+    }
     markAsMoved(item) {
         const t = item;
         if (t.tag > 0)
-            t.status = t.tag;
+            t.moving = t.tag;
     }
     static createItem(instance) {
-        return new LinkedItemImpl(instance, 0);
+        return new LinkedItem$(instance, 0);
     }
 }
-class LinkedItemImpl {
+class LinkedItem$ {
     constructor(instance, tag) {
         this.instance = instance;
         this.index = -1;
         this.tag = tag;
-        this.status = ~tag;
+        this.moving = ~tag;
         this.next = undefined;
         this.prev = undefined;
         this.aux = undefined;
@@ -238,7 +239,7 @@ class LinkedItemChain {
             x = next;
         }
     }
-    *itemsViaAux() {
+    *itemsAux() {
         let x = this.first;
         while (x !== undefined) {
             const next = x.aux;
@@ -246,7 +247,7 @@ class LinkedItemChain {
             x = next;
         }
     }
-    reset() {
+    clear() {
         this.count = 0;
         this.first = undefined;
         this.last = undefined;
@@ -267,7 +268,7 @@ class LinkedItemChain {
             this.first = head;
             this.last = from.last;
         }
-        from.reset();
+        from.clear();
     }
     include(item) {
         const last = this.last;
@@ -279,6 +280,15 @@ class LinkedItemChain {
             this.first = this.last = item;
         this.count++;
     }
+    includeAux(item) {
+        item.aux = undefined;
+        const last = this.last;
+        if (last)
+            this.last = last.aux = item;
+        else
+            this.first = this.last = item;
+        this.count++;
+    }
     exclude(item) {
         if (item.prev !== undefined)
             item.prev.next = item.next;
@@ -288,13 +298,4 @@ class LinkedItemChain {
             this.first = item.next;
         this.count--;
     }
-    aux(item) {
-        item.aux = undefined;
-        const last = this.last;
-        if (last)
-            this.last = last.aux = item;
-        else
-            this.first = this.last = item;
-        this.count++;
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.94.25037",
+  "version": "0.95.25043",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -31,16 +31,17 @@
   },
   "homepage": "https://github.com/nezaboodka/reactronic/blob/master/README.md#readme",
   "devDependencies": {
-    "@types/node": "22.13.0",
-    "@types/react": "19.0.8",
-    "@typescript-eslint/eslint-plugin": "8.22.0",
-    "@typescript-eslint/parser": "8.22.0",
-    "ava": "6.2.0",
+    "@types/node": "24.10.2",
+    "@types/react": "19.2.7",
+    "@typescript-eslint/eslint-plugin": "8.49.0",
+    "@typescript-eslint/parser": "8.49.0",
+    "tsimp": "2.0.12",
+    "ava": "6.4.1",
     "c8": "10.1.3",
-    "eslint": "9.19.0",
-    "react": "19.0.0",
+    "eslint": "9.39.1",
+    "react": "19.2.1",
     "ts-node": "10.9.2",
-    "typescript": "5.5.4"
+    "typescript": "5.9.3"
   },
   "scripts": {
     "build": "eslint source/**.ts test/**.test.ts react/**.tsx && tsc",