reactronic 0.94.25034 → 0.94.25036

package/build/dist/source/api.d.ts

@@ -1,7 +1,7 @@
 export { all, pause, proceedSyncOrAsync } from "./util/Utils.js";
 export { Uri } from "./util/Uri.js";
-export { MergeList } from "./util/MergeList.js";
-export type { MergedItem, MergeListReader } from "./util/MergeList.js";
+export { ScriptedList } from "./util/ScriptedList.js";
+export type { LinkedItem, ScriptedListReader } from "./util/ScriptedList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";

package/build/dist/source/api.js

@@ -1,6 +1,6 @@
 export { all, pause, proceedSyncOrAsync } from "./util/Utils.js";
 export { Uri } from "./util/Uri.js";
-export { MergeList } from "./util/MergeList.js";
+export { ScriptedList } from "./util/ScriptedList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";

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

@@ -1,27 +1,27 @@
-import { MergeList, MergedItem, MergeListReader } from "../util/MergeList.js";
+import { ScriptedList, LinkedItem, ScriptedListReader } from "../util/ScriptedList.js";
 import { ObservableObject } from "./Mvcc.js";
-export declare abstract class ObservableMergeList<T> extends ObservableObject implements MergeListReader<T> {
-    protected abstract impl: MergeList<T>;
+export declare abstract class ObservableScriptedList<T> extends ObservableObject implements ScriptedListReader<T> {
+    protected abstract impl: ScriptedList<T>;
     get isStrict(): boolean;
     get count(): number;
-    get addedCount(): number;
-    get removedCount(): number;
-    get isMergeInProgress(): boolean;
-    lookup(key: string): MergedItem<T> | undefined;
-    tryMergeAsExisting(key: string): MergedItem<T> | undefined;
-    mergeAsAdded(instance: T): MergedItem<T>;
-    mergeAsRemoved(item: MergedItem<T>): void;
-    move(item: MergedItem<T>, after: MergedItem<T>): void;
+    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;
-    firstMergedItem(): MergedItem<T> | undefined;
-    lastMergedItem(): MergedItem<T> | undefined;
-    items(): Generator<MergedItem<T>>;
-    addedItems(reset?: boolean): Generator<MergedItem<T>>;
-    removedItems(reset?: boolean): Generator<MergedItem<T>>;
-    isAdded(item: MergedItem<T>): boolean;
-    isMoved(item: MergedItem<T>): boolean;
-    isRemoved(item: MergedItem<T>): boolean;
-    isActual(item: MergedItem<T>): boolean;
+    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 +1,25 @@
 import { ObservableObject } from "./Mvcc.js";
-export class ObservableMergeList extends ObservableObject {
+export class ObservableScriptedList extends ObservableObject {
     get isStrict() { return this.impl.isStrict; }
     get count() { return this.impl.count; }
-    get addedCount() { return this.impl.addedCount; }
-    get removedCount() { return this.impl.removedCount; }
-    get isMergeInProgress() { return this.impl.isMergeInProgress; }
+    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.tryMergeAsExisting(key); }
-    mergeAsAdded(instance) { return this.impl.mergeAsAdded(instance); }
-    mergeAsRemoved(item) { return this.impl.mergeAsRemoved(item); }
+    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.beginMerge(); }
-    endMerge(error) { this.impl.endMerge(error); }
+    beginMerge() { this.impl.beginScriptExecution(); }
+    endMerge(error) { this.impl.endScriptExecution(error); }
     resetAddedAndRemovedLists() { this.impl.resetAddedAndRemovedLists(); }
-    firstMergedItem() { return this.impl.firstMergedItem(); }
-    lastMergedItem() { return this.impl.lastMergedItem(); }
+    firstItem() { return this.impl.firstItem(); }
+    lastItem() { return this.impl.lastItem(); }
     items() { return this.impl.items(); }
-    addedItems(reset) { return this.impl.addedItems(reset); }
-    removedItems(reset) { return this.impl.removedItems(reset); }
+    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); }
-    isActual(item) { return this.impl.isActual(item); }
+    isAlive(item) { return this.impl.isAlive(item); }
 }

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

@@ -1,5 +1,5 @@
 import { LoggingOptions } from "../Logging.js";
-import { MergeList, MergeListReader, MergedItem } from "../util/MergeList.js";
+import { ScriptedList, ScriptedListReader, LinkedItem } from "../util/ScriptedList.js";
 import { Priority, Mode } from "../Enums.js";
 import { ReactivityOptions } from "../Options.js";
 import { ObservableObject } from "../core/Mvcc.js";
@@ -23,8 +23,8 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract readonly owner: ReactiveTreeNode;
     abstract element: E;
     abstract readonly host: ReactiveTreeNode;
-    abstract readonly children: MergeListReader<ReactiveTreeNode>;
-    abstract readonly slot: MergedItem<ReactiveTreeNode<E>> | undefined;
+    abstract readonly children: ScriptedListReader<ReactiveTreeNode>;
+    abstract readonly slot: LinkedItem<ReactiveTreeNode<E>> | undefined;
     abstract readonly stamp: number;
     abstract readonly outer: ReactiveTreeNode;
     abstract readonly context: ReactiveTreeNodeContext | undefined;
@@ -67,7 +67,7 @@ export type ReactiveTreeNodeDriver<E = unknown> = {
     runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
     runMount(node: ReactiveTreeNode<E>): void;
     runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
-    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): MergedItem<ReactiveTreeNode> | undefined;
+    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
     provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
 };
 export type ReactiveTreeNodeContext<T extends Object = Object> = {
@@ -83,7 +83,7 @@ export declare abstract class BaseDriver<E = unknown> implements ReactiveTreeNod
     runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
     runMount(node: ReactiveTreeNode<E>): void;
     runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
-    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): MergedItem<ReactiveTreeNode> | undefined;
+    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
     provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
 }
 export declare class ReactiveTreeVariable<T extends Object = Object> {
@@ -112,8 +112,8 @@ declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
     readonly owner: ReactiveTreeNodeImpl;
     readonly element: E;
     host: ReactiveTreeNodeImpl;
-    readonly children: MergeList<ReactiveTreeNodeImpl>;
-    slot: MergedItem<ReactiveTreeNodeImpl<E>> | undefined;
+    readonly children: ScriptedList<ReactiveTreeNodeImpl>;
+    slot: LinkedItem<ReactiveTreeNodeImpl<E>> | undefined;
     stamp: number;
     outer: ReactiveTreeNodeImpl;
     context: ReactiveTreeNodeContextImpl<any> | undefined;
@@ -128,7 +128,7 @@ declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
     has(mode: Mode): boolean;
     script(_triggers: unknown): void;
     configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
-    static get nodeSlot(): MergedItem<ReactiveTreeNodeImpl>;
+    static get nodeSlot(): LinkedItem<ReactiveTreeNodeImpl>;
     static tryUseTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
     static useTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
     static setTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;

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

@@ -18,7 +18,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { misuse } from "../util/Dbg.js";
 import { Uri } from "../util/Uri.js";
-import { MergeList } from "../util/MergeList.js";
+import { ScriptedList } from "../util/ScriptedList.js";
 import { emitLetters, flags, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
 import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
 import { ObservableObject } from "../core/Mvcc.js";
@@ -40,7 +40,7 @@ export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, pre
     if (owner) {
         let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
         const children = owner.children;
-        existing !== null && existing !== void 0 ? existing : (existing = children.tryMergeAsExisting(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'script' only"));
+        existing !== null && existing !== void 0 ? existing : (existing = children.tryReuse(effectiveKey = effectiveKey || generateKey(owner), undefined, "nested elements can be declared inside 'script' only"));
         if (existing) {
             result = existing.instance;
             if (result.driver !== driver && driver !== undefined)
@@ -52,12 +52,12 @@ export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, pre
         }
         else {
             result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-            result.slot = children.mergeAsAdded(result);
+            result.slot = children.add(result);
         }
     }
     else {
         result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-        result.slot = MergeList.createItem(result);
+        result.slot = ScriptedList.createItem(result);
     }
     return result;
 }
@@ -89,7 +89,7 @@ export class ReactiveTreeNode {
     }
     static launchFinalization(node) {
         const impl = node;
-        launchFinalization(impl.slot, true, true);
+        launchFinalizationViaSlot(impl.slot, true, true);
     }
     static launchNestedNodesThenDo(action) {
         launchNestedNodesThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
@@ -270,7 +270,7 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         }
         this.element = driver.create(this);
         this.host = thisAsUnknown;
-        this.children = new MergeList(getNodeKey, true);
+        this.children = new ScriptedList(getNodeKey, true);
         this.slot = undefined;
         this.stamp = Number.MAX_SAFE_INTEGER;
         this.context = undefined;
@@ -388,12 +388,12 @@ function launchNestedNodesThenDoImpl(nodeSlot, error, action) {
         var _a;
         const owner = nodeSlot.instance;
         const children = owner.children;
-        if (children.isMergeInProgress) {
+        if (children.isScriptingInProgress) {
             let promised = undefined;
             try {
-                children.endMerge(error);
-                for (const child of children.removedItems(true))
-                    launchFinalization(child, true, true);
+                children.endScriptExecution(error);
+                for (const child of children.itemsRemoved(true))
+                    launchFinalizationViaSlot(child, true, true);
                 if (!error) {
                     const sequential = children.isStrict;
                     let p1 = undefined;
@@ -528,7 +528,7 @@ function runScriptNow(nodeSlot) {
                 try {
                     node.stamp++;
                     node.numerator = 0;
-                    node.children.beginMerge();
+                    node.children.beginScriptExecution();
                     const driver = node.driver;
                     result = driver.runScript(node);
                     result = proceedSyncOrAsync(result, v => { launchNestedNodesThenDoImpl(nodeSlot, undefined, NOP); return v; }, e => { console.log(e); launchNestedNodesThenDoImpl(nodeSlot, e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
@@ -542,7 +542,7 @@ function runScriptNow(nodeSlot) {
         });
     }
 }
-function launchFinalization(nodeSlot, isLeader, individual) {
+function launchFinalizationViaSlot(nodeSlot, isLeader, individual) {
     const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         const driver = node.driver;
@@ -563,7 +563,7 @@ function launchFinalization(nodeSlot, isLeader, individual) {
                 });
         }
         for (const child of node.children.items())
-            launchFinalization(child, childrenAreLeaders, false);
+            launchFinalizationViaSlot(child, childrenAreLeaders, false);
         ReactiveTreeNodeImpl.grandNodeCount--;
     }
 }

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

@@ -0,0 +1,64 @@
+export type GetListItemKey<T = unknown> = (item: T) => string | undefined;
+export type ScriptedListReader<T> = {
+    readonly isStrict: boolean;
+    readonly count: number;
+    readonly countOfAdded: number;
+    readonly countOfRemoved: number;
+    readonly isScriptingInProgress: 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>>;
+    isAdded(item: LinkedItem<T>): boolean;
+    isMoved(item: LinkedItem<T>): boolean;
+    isRemoved(item: LinkedItem<T>): boolean;
+    isAlive(item: LinkedItem<T>): boolean;
+};
+export type LinkedItem<T> = {
+    readonly instance: T;
+    readonly index: number;
+    readonly next?: LinkedItem<T>;
+    readonly prev?: LinkedItem<T>;
+    aux?: LinkedItem<T>;
+};
+export declare class ScriptedList<T> implements ScriptedListReader<T> {
+    readonly getKey: GetListItemKey<T>;
+    private strict;
+    private map;
+    private cycle;
+    private current;
+    private added;
+    private removed;
+    private lastNotFoundKey;
+    private strictNextItem?;
+    constructor(getKey: GetListItemKey<T>, strict?: boolean);
+    get isStrict(): boolean;
+    set isStrict(value: boolean);
+    get count(): number;
+    get countOfAdded(): number;
+    get countOfRemoved(): number;
+    get isScriptingInProgress(): boolean;
+    lookup(key: string | undefined): LinkedItem<T> | undefined;
+    tryReuse(key: string, resolution?: {
+        isDuplicate: boolean;
+    }, error?: string): LinkedItem<T> | undefined;
+    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;
+    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>>;
+    isAdded(item: LinkedItem<T>): boolean;
+    isMoved(item: LinkedItem<T>): boolean;
+    isRemoved(item: LinkedItem<T>): boolean;
+    isAlive(item: LinkedItem<T>): boolean;
+    markAsMoved(item: LinkedItem<T>): void;
+    static createItem<T>(instance: T): LinkedItem<T>;
+}

package/build/dist/source/util/{MergeList.js → ScriptedList.js}

@@ -1,33 +1,33 @@
 import { misuse } from "./Dbg.js";
-export class MergeList {
+export class ScriptedList {
     constructor(getKey, strict = false) {
         this.getKey = getKey;
         this.strict = strict;
         this.map = new Map();
-        this.tag = ~0;
-        this.current = new MergeItemChain();
-        this.added = new MergeItemChain();
-        this.removed = new MergeItemChain();
+        this.cycle = ~0;
+        this.current = new LinkedItemChain();
+        this.added = new LinkedItemChain();
+        this.removed = new LinkedItemChain();
         this.lastNotFoundKey = undefined;
         this.strictNextItem = undefined;
     }
     get isStrict() { return this.strict; }
     set isStrict(value) {
-        if (this.isMergeInProgress && this.current.count > 0)
-            throw misuse("cannot change strict mode in the middle of merge");
+        if (this.isScriptingInProgress && this.current.count > 0)
+            throw misuse("cannot change strict mode in the middle of script execution");
         this.strict = value;
     }
     get count() {
         return this.current.count;
     }
-    get addedCount() {
+    get countOfAdded() {
         return this.added.count;
     }
-    get removedCount() {
+    get countOfRemoved() {
         return this.removed.count;
     }
-    get isMergeInProgress() {
-        return this.tag > 0;
+    get isScriptingInProgress() {
+        return this.cycle > 0;
     }
     lookup(key) {
         let result = undefined;
@@ -44,18 +44,18 @@ export class MergeList {
         }
         return result;
     }
-    tryMergeAsExisting(key, resolution, error) {
-        const tag = this.tag;
-        if (tag < 0)
-            throw misuse(error !== null && error !== void 0 ? error : "merge is not in progress");
+    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");
         let item = this.strictNextItem;
         if (key !== (item ? this.getKey(item.instance) : undefined))
             item = this.lookup(key);
         if (item) {
-            if (item.tag !== tag) {
-                item.tag = tag;
+            if (item.cycle !== cycle) {
+                item.cycle = cycle;
                 if (this.strict && item !== this.strictNextItem)
-                    item.status = tag;
+                    item.status = cycle;
                 this.strictNextItem = item.next;
                 this.removed.exclude(item);
                 item.index = this.current.count;
@@ -72,16 +72,16 @@ export class MergeList {
             resolution.isDuplicate = false;
         return item;
     }
-    mergeAsAdded(instance) {
+    add(instance) {
         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;
+        let cycle = this.cycle;
+        if (cycle < 0) {
+            cycle = ~this.cycle + 1;
+            this.cycle = ~cycle;
         }
-        const item = new MergedItemImpl(instance, tag);
+        const item = new LinkedItemImpl(instance, cycle);
         this.map.set(key, item);
         this.lastNotFoundKey = undefined;
         this.strictNextItem = undefined;
@@ -90,29 +90,29 @@ export class MergeList {
         this.added.aux(item);
         return item;
     }
-    mergeAsRemoved(item) {
+    remove(item) {
         const t = item;
         if (!this.isRemoved(t)) {
             this.current.exclude(t);
             this.removed.include(t);
-            t.tag--;
+            t.cycle--;
         }
     }
     move(item, after) {
         throw misuse("not implemented");
     }
-    beginMerge() {
-        if (this.isMergeInProgress)
-            throw misuse("merge is in progress already");
-        this.tag = ~this.tag + 1;
+    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();
     }
-    endMerge(error) {
-        if (!this.isMergeInProgress)
-            throw misuse("merge is ended already");
-        this.tag = ~this.tag;
+    endScriptExecution(error) {
+        if (!this.isScriptingInProgress)
+            throw misuse("script execution is ended already");
+        this.cycle = ~this.cycle;
         if (error === undefined) {
             const currentCount = this.current.count;
             if (currentCount > 0) {
@@ -145,10 +145,10 @@ export class MergeList {
         this.removed.reset();
         this.added.reset();
     }
-    firstMergedItem() {
+    firstItem() {
         return this.current.first;
     }
-    lastMergedItem() {
+    lastItem() {
         return this.current.last;
     }
     *items(onlyAfter) {
@@ -160,7 +160,7 @@ export class MergeList {
             x = next;
         }
     }
-    *addedItems(reset) {
+    *itemsAdded(reset) {
         let x = this.added.first;
         while (x !== undefined) {
             const next = x.aux;
@@ -171,7 +171,7 @@ export class MergeList {
         if (reset)
             this.added.reset();
     }
-    *removedItems(reset) {
+    *itemsRemoved(reset) {
         let x = this.removed.first;
         while (x !== undefined) {
             const next = x.next;
@@ -183,48 +183,48 @@ export class MergeList {
     }
     isAdded(item) {
         const t = item;
-        let tag = this.tag;
-        if (tag < 0)
-            tag = ~tag;
-        return t.status === ~tag && t.tag > 0;
+        let cycle = this.cycle;
+        if (cycle < 0)
+            cycle = ~cycle;
+        return t.status === ~cycle && t.cycle > 0;
     }
     isMoved(item) {
         const t = item;
-        let tag = this.tag;
-        if (tag < 0)
-            tag = ~tag;
-        return t.status === tag && t.tag > 0;
+        let cycle = this.cycle;
+        if (cycle < 0)
+            cycle = ~cycle;
+        return t.status === cycle && t.cycle > 0;
     }
     isRemoved(item) {
         const t = item;
-        const tag = this.tag;
-        return tag > 0 ? t.tag < tag : t.tag < tag - 1;
+        const cycle = this.cycle;
+        return cycle > 0 ? t.cycle < cycle : t.cycle < cycle - 1;
     }
-    isActual(item) {
+    isAlive(item) {
         const t = item;
-        return t.tag === this.tag;
+        return t.cycle === this.cycle;
     }
     markAsMoved(item) {
         const t = item;
-        if (t.tag > 0)
-            t.status = t.tag;
+        if (t.cycle > 0)
+            t.status = t.cycle;
     }
     static createItem(instance) {
-        return new MergedItemImpl(instance, 0);
+        return new LinkedItemImpl(instance, 0);
     }
 }
-class MergedItemImpl {
-    constructor(instance, tag) {
+class LinkedItemImpl {
+    constructor(instance, cycle) {
         this.instance = instance;
         this.index = -1;
-        this.tag = tag;
-        this.status = ~tag;
+        this.cycle = cycle;
+        this.status = ~cycle;
         this.next = undefined;
         this.prev = undefined;
         this.aux = undefined;
     }
 }
-class MergeItemChain {
+class LinkedItemChain {
     constructor() {
         this.count = 0;
         this.first = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.94.25034",
+  "version": "0.94.25036",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",

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

@@ -1,64 +0,0 @@
-export type GetMergedItemKey<T = unknown> = (item: T) => string | undefined;
-export type MergeListReader<T> = {
-    readonly isStrict: boolean;
-    readonly count: number;
-    readonly addedCount: number;
-    readonly removedCount: number;
-    readonly isMergeInProgress: boolean;
-    lookup(key: string): MergedItem<T> | undefined;
-    firstMergedItem(): MergedItem<T> | undefined;
-    lastMergedItem(): MergedItem<T> | undefined;
-    items(onlyAfter?: MergedItem<T>): Generator<MergedItem<T>>;
-    addedItems(reset?: boolean): Generator<MergedItem<T>>;
-    removedItems(reset?: boolean): Generator<MergedItem<T>>;
-    isAdded(item: MergedItem<T>): boolean;
-    isMoved(item: MergedItem<T>): boolean;
-    isRemoved(item: MergedItem<T>): boolean;
-    isActual(item: MergedItem<T>): boolean;
-};
-export type MergedItem<T> = {
-    readonly instance: T;
-    readonly index: number;
-    readonly next?: MergedItem<T>;
-    readonly prev?: MergedItem<T>;
-    aux?: MergedItem<T>;
-};
-export declare class MergeList<T> implements MergeListReader<T> {
-    readonly getKey: GetMergedItemKey<T>;
-    private strict;
-    private map;
-    private tag;
-    private current;
-    private added;
-    private removed;
-    private lastNotFoundKey;
-    private strictNextItem?;
-    constructor(getKey: GetMergedItemKey<T>, strict?: boolean);
-    get isStrict(): boolean;
-    set isStrict(value: boolean);
-    get count(): number;
-    get addedCount(): number;
-    get removedCount(): number;
-    get isMergeInProgress(): boolean;
-    lookup(key: string | undefined): MergedItem<T> | undefined;
-    tryMergeAsExisting(key: string, resolution?: {
-        isDuplicate: boolean;
-    }, error?: string): MergedItem<T> | undefined;
-    mergeAsAdded(instance: T): MergedItem<T>;
-    mergeAsRemoved(item: MergedItem<T>): void;
-    move(item: MergedItem<T>, after: MergedItem<T>): void;
-    beginMerge(): void;
-    endMerge(error?: unknown): void;
-    resetAddedAndRemovedLists(): void;
-    firstMergedItem(): MergedItem<T> | undefined;
-    lastMergedItem(): MergedItem<T> | undefined;
-    items(onlyAfter?: MergedItem<T>): Generator<MergedItem<T>>;
-    addedItems(reset?: boolean): Generator<MergedItem<T>>;
-    removedItems(reset?: boolean): Generator<MergedItem<T>>;
-    isAdded(item: MergedItem<T>): boolean;
-    isMoved(item: MergedItem<T>): boolean;
-    isRemoved(item: MergedItem<T>): boolean;
-    isActual(item: MergedItem<T>): boolean;
-    markAsMoved(item: MergedItem<T>): void;
-    static createItem<T>(instance: T): MergedItem<T>;
-}