reactronic 0.94.25036 → 0.95.25040

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/{ScriptedList.d.ts → ReconciliationList.d.ts}

@@ -1,20 +1,21 @@
 export type GetListItemKey<T = unknown> = (item: T) => string | undefined;
-export type ScriptedListReader<T> = {
+export type ReconciliationListReader<T> = {
     readonly isStrict: boolean;
     readonly count: number;
     readonly countOfAdded: number;
     readonly countOfRemoved: number;
-    readonly isScriptingInProgress: boolean;
+    readonly isReconciliationInProgress: boolean;
     lookup(key: string): LinkedItem<T> | undefined;
     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;
-    isAlive(item: LinkedItem<T>): boolean;
+    isActual(item: LinkedItem<T>): boolean;
+    isExternal(item: LinkedItem<T>): boolean;
 };
 export type LinkedItem<T> = {
     readonly instance: T;
@@ -23,12 +24,12 @@ export type LinkedItem<T> = {
     readonly prev?: LinkedItem<T>;
     aux?: LinkedItem<T>;
 };
-export declare class ScriptedList<T> implements ScriptedListReader<T> {
+export declare class ReconciliationList<T> implements ReconciliationListReader<T> {
     readonly getKey: GetListItemKey<T>;
     private strict;
     private map;
-    private cycle;
-    private current;
+    private tag;
+    private actual;
     private added;
     private removed;
     private lastNotFoundKey;
@@ -39,7 +40,7 @@ export declare class ScriptedList<T> implements ScriptedListReader<T> {
     get count(): number;
     get countOfAdded(): number;
     get countOfRemoved(): number;
-    get isScriptingInProgress(): boolean;
+    get isReconciliationInProgress(): boolean;
     lookup(key: string | undefined): LinkedItem<T> | undefined;
     tryReuse(key: string, resolution?: {
         isDuplicate: boolean;
@@ -47,18 +48,19 @@ export declare class ScriptedList<T> implements ScriptedListReader<T> {
     add(instance: T): LinkedItem<T>;
     remove(item: LinkedItem<T>): void;
     move(item: LinkedItem<T>, after: LinkedItem<T>): void;
-    beginScriptExecution(): void;
-    endScriptExecution(error?: unknown): void;
-    resetAddedAndRemovedLists(): void;
+    beginReconciliation(): void;
+    endReconciliation(error?: unknown): 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;
-    isAlive(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/{ScriptedList.js → ReconciliationList.js}

@@ -1,11 +1,11 @@
 import { misuse } from "./Dbg.js";
-export class ScriptedList {
+export class ReconciliationList {
     constructor(getKey, strict = false) {
         this.getKey = getKey;
         this.strict = strict;
         this.map = new Map();
-        this.cycle = ~0;
-        this.current = new LinkedItemChain();
+        this.tag = ~0;
+        this.actual = new LinkedItemChain();
         this.added = new LinkedItemChain();
         this.removed = new LinkedItemChain();
         this.lastNotFoundKey = undefined;
@@ -13,12 +13,12 @@ export class ScriptedList {
     }
     get isStrict() { return this.strict; }
     set isStrict(value) {
-        if (this.isScriptingInProgress && this.current.count > 0)
-            throw misuse("cannot change strict mode in the middle of script execution");
+        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.current.count;
+        return this.actual.count;
     }
     get countOfAdded() {
         return this.added.count;
@@ -26,8 +26,8 @@ export class ScriptedList {
     get countOfRemoved() {
         return this.removed.count;
     }
-    get isScriptingInProgress() {
-        return this.cycle > 0;
+    get isReconciliationInProgress() {
+        return this.tag > 0;
     }
     lookup(key) {
         let result = undefined;
@@ -45,21 +45,21 @@ export class ScriptedList {
         return result;
     }
     tryReuse(key, resolution, error) {
-        const cycle = this.cycle;
-        if (cycle < 0)
-            throw misuse(error !== null && error !== void 0 ? error : "script execution is not in progress");
+        const tag = this.tag;
+        if (tag < 0)
+            throw misuse(error !== null && error !== void 0 ? error : "reconciliation is not in progress");
         let item = this.strictNextItem;
         if (key !== (item ? this.getKey(item.instance) : undefined))
             item = this.lookup(key);
         if (item) {
-            if (item.cycle !== cycle) {
-                item.cycle = cycle;
+            if (item.tag !== tag) {
+                item.tag = tag;
                 if (this.strict && item !== this.strictNextItem)
-                    item.status = cycle;
+                    item.moving = tag;
                 this.strictNextItem = item.next;
                 this.removed.exclude(item);
-                item.index = this.current.count;
-                this.current.include(item);
+                item.index = this.actual.count;
+                this.actual.include(item);
                 if (resolution)
                     resolution.isDuplicate = false;
             }
@@ -76,55 +76,52 @@ export class ScriptedList {
         const key = this.getKey(instance);
         if (this.lookup(key) !== undefined)
             throw misuse(`key is already in use: ${key}`);
-        let cycle = this.cycle;
-        if (cycle < 0) {
-            cycle = ~this.cycle + 1;
-            this.cycle = ~cycle;
-        }
-        const item = new LinkedItemImpl(instance, cycle);
+        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.current.count;
-        this.current.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.current.exclude(t);
+            this.actual.exclude(t);
             this.removed.include(t);
-            t.cycle--;
+            t.tag--;
         }
     }
     move(item, after) {
         throw misuse("not implemented");
     }
-    beginScriptExecution() {
-        if (this.isScriptingInProgress)
-            throw misuse("script execution is in progress already");
-        this.cycle = ~this.cycle + 1;
-        this.strictNextItem = this.current.first;
-        this.removed.grab(this.current, false);
-        this.added.reset();
-    }
-    endScriptExecution(error) {
-        if (!this.isScriptingInProgress)
-            throw misuse("script execution is ended already");
-        this.cycle = ~this.cycle;
+    beginReconciliation() {
+        if (this.isReconciliationInProgress)
+            throw misuse("reconciliation is in progress already");
+        this.tag = ~this.tag + 1;
+        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 currentCount = this.current.count;
-            if (currentCount > 0) {
+            const actualCount = this.actual.count;
+            if (actualCount > 0) {
                 const getKey = this.getKey;
-                if (currentCount > 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.current.items())
+                    for (const x of this.actual.items())
                         map.set(getKey(x.instance), x);
                 }
             }
@@ -132,35 +129,35 @@ export class ScriptedList {
                 this.map = new Map();
         }
         else {
-            this.current.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.current.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.current.first;
+        return this.actual.first;
     }
     lastItem() {
-        return this.current.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.current.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 ScriptedList {
                 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 cycle = this.cycle;
-        if (cycle < 0)
-            cycle = ~cycle;
-        return t.status === ~cycle && t.cycle > 0;
+        let tag = this.tag;
+        if (tag < 0)
+            tag = ~tag;
+        return t.moving === ~tag && t.tag > 0;
     }
     isMoved(item) {
         const t = item;
-        let cycle = this.cycle;
-        if (cycle < 0)
-            cycle = ~cycle;
-        return t.status === cycle && t.cycle > 0;
+        let tag = this.tag;
+        if (tag < 0)
+            tag = ~tag;
+        return t.moving === tag && t.tag > 0;
     }
     isRemoved(item) {
         const t = item;
-        const cycle = this.cycle;
-        return cycle > 0 ? t.cycle < cycle : t.cycle < cycle - 1;
+        const tag = this.tag;
+        return tag > 0 ? t.tag < tag : t.tag < tag - 1;
+    }
+    isActual(item) {
+        const t = item;
+        return t.tag === this.tag;
     }
-    isAlive(item) {
+    isExternal(item) {
         const t = item;
-        return t.cycle === this.cycle;
+        return t.tag === 0;
     }
     markAsMoved(item) {
         const t = item;
-        if (t.cycle > 0)
-            t.status = t.cycle;
+        if (t.tag > 0)
+            t.moving = t.tag;
     }
     static createItem(instance) {
-        return new LinkedItemImpl(instance, 0);
+        return new LinkedItem$(instance, 0);
     }
 }
-class LinkedItemImpl {
-    constructor(instance, cycle) {
+class LinkedItem$ {
+    constructor(instance, tag) {
         this.instance = instance;
         this.index = -1;
-        this.cycle = cycle;
-        this.status = ~cycle;
+        this.tag = 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.25036",
+  "version": "0.95.25040",
   "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",

package/build/dist/source/core/MvccMergeList.d.ts

@@ -1,27 +0,0 @@
-import { ScriptedList, LinkedItem, ScriptedListReader } from "../util/ScriptedList.js";
-import { ObservableObject } from "./Mvcc.js";
-export declare abstract class ObservableScriptedList<T> extends ObservableObject implements ScriptedListReader<T> {
-    protected abstract impl: ScriptedList<T>;
-    get isStrict(): boolean;
-    get count(): number;
-    get countOfAdded(): number;
-    get countOfRemoved(): number;
-    get isScriptingInProgress(): boolean;
-    lookup(key: string): LinkedItem<T> | undefined;
-    tryMergeAsExisting(key: string): LinkedItem<T> | undefined;
-    mergeAsAdded(instance: T): LinkedItem<T>;
-    mergeAsRemoved(item: LinkedItem<T>): void;
-    move(item: LinkedItem<T>, after: LinkedItem<T>): void;
-    beginMerge(): void;
-    endMerge(error?: unknown): void;
-    resetAddedAndRemovedLists(): void;
-    firstItem(): LinkedItem<T> | undefined;
-    lastItem(): LinkedItem<T> | undefined;
-    items(): Generator<LinkedItem<T>>;
-    itemsAdded(reset?: boolean): Generator<LinkedItem<T>>;
-    itemsRemoved(reset?: boolean): Generator<LinkedItem<T>>;
-    isAdded(item: LinkedItem<T>): boolean;
-    isMoved(item: LinkedItem<T>): boolean;
-    isRemoved(item: LinkedItem<T>): boolean;
-    isAlive(item: LinkedItem<T>): boolean;
-}

package/build/dist/source/core/MvccMergeList.js

@@ -1,25 +0,0 @@
-import { ObservableObject } from "./Mvcc.js";
-export class ObservableScriptedList extends ObservableObject {
-    get isStrict() { return this.impl.isStrict; }
-    get count() { return this.impl.count; }
-    get countOfAdded() { return this.impl.countOfAdded; }
-    get countOfRemoved() { return this.impl.countOfRemoved; }
-    get isScriptingInProgress() { return this.impl.isScriptingInProgress; }
-    lookup(key) { return this.impl.lookup(key); }
-    tryMergeAsExisting(key) { return this.impl.tryReuse(key); }
-    mergeAsAdded(instance) { return this.impl.add(instance); }
-    mergeAsRemoved(item) { return this.impl.remove(item); }
-    move(item, after) { this.impl.move(item, after); }
-    beginMerge() { this.impl.beginScriptExecution(); }
-    endMerge(error) { this.impl.endScriptExecution(error); }
-    resetAddedAndRemovedLists() { this.impl.resetAddedAndRemovedLists(); }
-    firstItem() { return this.impl.firstItem(); }
-    lastItem() { return this.impl.lastItem(); }
-    items() { return this.impl.items(); }
-    itemsAdded(reset) { return this.impl.itemsAdded(reset); }
-    itemsRemoved(reset) { return this.impl.itemsRemoved(reset); }
-    isAdded(item) { return this.impl.isAdded(item); }
-    isMoved(item) { return this.impl.isMoved(item); }
-    isRemoved(item) { return this.impl.isRemoved(item); }
-    isAlive(item) { return this.impl.isAlive(item); }
-}