reactronic 0.94.25036 → 0.94.25037

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 { ScriptedList } from "./util/ScriptedList.js";
-export type { LinkedItem, ScriptedListReader } from "./util/ScriptedList.js";
+export { ReconciliationList } from "./util/ReconciliationList.js";
+export type { LinkedItem, ReconciliationListReader } from "./util/ReconciliationList.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 { ScriptedList } from "./util/ScriptedList.js";
+export { ReconciliationList } from "./util/ReconciliationList.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 → MvccReconciliationList.d.ts}

@@ -1,12 +1,12 @@
-import { ScriptedList, LinkedItem, ScriptedListReader } from "../util/ScriptedList.js";
+import { ReconciliationList, LinkedItem, ReconciliationListReader } from "../util/ReconciliationList.js";
 import { ObservableObject } from "./Mvcc.js";
-export declare abstract class ObservableScriptedList<T> extends ObservableObject implements ScriptedListReader<T> {
-    protected abstract impl: ScriptedList<T>;
+export declare abstract class ObservableReconciliationList<T> extends ObservableObject implements ReconciliationListReader<T> {
+    protected abstract impl: ReconciliationList<T>;
     get isStrict(): boolean;
     get count(): number;
     get countOfAdded(): number;
     get countOfRemoved(): number;
-    get isScriptingInProgress(): boolean;
+    get isReconciliationInProgress(): boolean;
     lookup(key: string): LinkedItem<T> | undefined;
     tryMergeAsExisting(key: string): LinkedItem<T> | undefined;
     mergeAsAdded(instance: T): LinkedItem<T>;
@@ -23,5 +23,5 @@ export declare abstract class ObservableScriptedList<T> extends ObservableObject
     isAdded(item: LinkedItem<T>): boolean;
     isMoved(item: LinkedItem<T>): boolean;
     isRemoved(item: LinkedItem<T>): boolean;
-    isAlive(item: LinkedItem<T>): boolean;
+    isFresh(item: LinkedItem<T>): boolean;
 }

package/build/dist/source/core/{MvccMergeList.js → MvccReconciliationList.js}

@@ -1,17 +1,17 @@
 import { ObservableObject } from "./Mvcc.js";
-export class ObservableScriptedList extends ObservableObject {
+export class ObservableReconciliationList 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; }
+    get isReconciliationInProgress() { return this.impl.isReconciliationInProgress; }
     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); }
+    beginMerge() { this.impl.beginReconciliation(); }
+    endMerge(error) { this.impl.endReconciliation(error); }
     resetAddedAndRemovedLists() { this.impl.resetAddedAndRemovedLists(); }
     firstItem() { return this.impl.firstItem(); }
     lastItem() { return this.impl.lastItem(); }
@@ -21,5 +21,5 @@ export class ObservableScriptedList extends ObservableObject {
     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); }
+    isFresh(item) { return this.impl.isFresh(item); }
 }

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

@@ -1,5 +1,5 @@
 import { LoggingOptions } from "../Logging.js";
-import { ScriptedList, ScriptedListReader, LinkedItem } from "../util/ScriptedList.js";
+import { ReconciliationList, ReconciliationListReader, LinkedItem } from "../util/ReconciliationList.js";
 import { Priority, Mode } from "../Enums.js";
 import { ReactivityOptions } from "../Options.js";
 import { ObservableObject } from "../core/Mvcc.js";
@@ -23,7 +23,7 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract readonly owner: ReactiveTreeNode;
     abstract element: E;
     abstract readonly host: ReactiveTreeNode;
-    abstract readonly children: ScriptedListReader<ReactiveTreeNode>;
+    abstract readonly children: ReconciliationListReader<ReactiveTreeNode>;
     abstract readonly slot: LinkedItem<ReactiveTreeNode<E>> | undefined;
     abstract readonly stamp: number;
     abstract readonly outer: ReactiveTreeNode;
@@ -112,7 +112,7 @@ declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
     readonly owner: ReactiveTreeNodeImpl;
     readonly element: E;
     host: ReactiveTreeNodeImpl;
-    readonly children: ScriptedList<ReactiveTreeNodeImpl>;
+    readonly children: ReconciliationList<ReactiveTreeNodeImpl>;
     slot: LinkedItem<ReactiveTreeNodeImpl<E>> | undefined;
     stamp: number;
     outer: ReactiveTreeNodeImpl;

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 { ScriptedList } from "../util/ScriptedList.js";
+import { ReconciliationList } from "../util/ReconciliationList.js";
 import { emitLetters, flags, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js";
 import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
 import { ObservableObject } from "../core/Mvcc.js";
@@ -57,7 +57,7 @@ export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, pre
     }
     else {
         result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
-        result.slot = ScriptedList.createItem(result);
+        result.slot = ReconciliationList.createItem(result);
     }
     return result;
 }
@@ -270,7 +270,7 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         }
         this.element = driver.create(this);
         this.host = thisAsUnknown;
-        this.children = new ScriptedList(getNodeKey, true);
+        this.children = new ReconciliationList(getNodeKey, true);
         this.slot = undefined;
         this.stamp = Number.MAX_SAFE_INTEGER;
         this.context = undefined;
@@ -388,10 +388,10 @@ function launchNestedNodesThenDoImpl(nodeSlot, error, action) {
         var _a;
         const owner = nodeSlot.instance;
         const children = owner.children;
-        if (children.isScriptingInProgress) {
+        if (children.isReconciliationInProgress) {
             let promised = undefined;
             try {
-                children.endScriptExecution(error);
+                children.endReconciliation(error);
                 for (const child of children.itemsRemoved(true))
                     launchFinalizationViaSlot(child, true, true);
                 if (!error) {
@@ -528,7 +528,7 @@ function runScriptNow(nodeSlot) {
                 try {
                     node.stamp++;
                     node.numerator = 0;
-                    node.children.beginScriptExecution();
+                    node.children.beginReconciliation();
                     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); });

package/build/dist/source/util/{ScriptedList.d.ts → ReconciliationList.d.ts}

@@ -1,10 +1,10 @@
 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;
@@ -14,7 +14,7 @@ export type ScriptedListReader<T> = {
     isAdded(item: LinkedItem<T>): boolean;
     isMoved(item: LinkedItem<T>): boolean;
     isRemoved(item: LinkedItem<T>): boolean;
-    isAlive(item: LinkedItem<T>): boolean;
+    isFresh(item: LinkedItem<T>): boolean;
 };
 export type LinkedItem<T> = {
     readonly instance: T;
@@ -23,12 +23,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 fresh;
     private added;
     private removed;
     private lastNotFoundKey;
@@ -39,7 +39,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,8 +47,8 @@ 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;
+    beginReconciliation(): void;
+    endReconciliation(error?: unknown): void;
     resetAddedAndRemovedLists(): void;
     firstItem(): LinkedItem<T> | undefined;
     lastItem(): LinkedItem<T> | undefined;
@@ -58,7 +58,7 @@ export declare class ScriptedList<T> implements ScriptedListReader<T> {
     isAdded(item: LinkedItem<T>): boolean;
     isMoved(item: LinkedItem<T>): boolean;
     isRemoved(item: LinkedItem<T>): boolean;
-    isAlive(item: LinkedItem<T>): boolean;
+    isFresh(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.fresh = 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.fresh.count > 0)
+            throw misuse("cannot change strict mode in the middle of reconciliation");
         this.strict = value;
     }
     get count() {
-        return this.current.count;
+        return this.fresh.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.status = tag;
                 this.strictNextItem = item.next;
                 this.removed.exclude(item);
-                item.index = this.current.count;
-                this.current.include(item);
+                item.index = this.fresh.count;
+                this.fresh.include(item);
                 if (resolution)
                     resolution.isDuplicate = false;
             }
@@ -76,55 +76,55 @@ 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;
+        let tag = this.tag;
+        if (tag < 0) {
+            tag = ~this.tag + 1;
+            this.tag = ~tag;
         }
-        const item = new LinkedItemImpl(instance, cycle);
+        const item = new LinkedItemImpl(instance, tag);
         this.map.set(key, item);
         this.lastNotFoundKey = undefined;
         this.strictNextItem = undefined;
-        item.index = this.current.count;
-        this.current.include(item);
+        item.index = this.fresh.count;
+        this.fresh.include(item);
         this.added.aux(item);
         return item;
     }
     remove(item) {
         const t = item;
         if (!this.isRemoved(t)) {
-            this.current.exclude(t);
+            this.fresh.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);
+    beginReconciliation() {
+        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();
     }
-    endScriptExecution(error) {
-        if (!this.isScriptingInProgress)
-            throw misuse("script execution is ended already");
-        this.cycle = ~this.cycle;
+    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 freshCount = this.fresh.count;
+            if (freshCount > 0) {
                 const getKey = this.getKey;
-                if (currentCount > this.removed.count) {
+                if (freshCount > 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.fresh.items())
                         map.set(getKey(x.instance), x);
                 }
             }
@@ -132,11 +132,11 @@ export class ScriptedList {
                 this.map = new Map();
         }
         else {
-            this.current.grab(this.removed, true);
+            this.fresh.grab(this.removed, true);
             const getKey = this.getKey;
             for (const x of this.added.itemsViaAux()) {
                 this.map.delete(getKey(x.instance));
-                this.current.exclude(x);
+                this.fresh.exclude(x);
             }
             this.added.reset();
         }
@@ -146,14 +146,14 @@ export class ScriptedList {
         this.added.reset();
     }
     firstItem() {
-        return this.current.first;
+        return this.fresh.first;
     }
     lastItem() {
-        return this.current.last;
+        return this.fresh.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.fresh.first;
         while (x !== undefined) {
             const next = x.next;
             yield x;
@@ -183,42 +183,42 @@ export class ScriptedList {
     }
     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.status === ~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.status === 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;
     }
-    isAlive(item) {
+    isFresh(item) {
         const t = item;
-        return t.cycle === this.cycle;
+        return t.tag === this.tag;
     }
     markAsMoved(item) {
         const t = item;
-        if (t.cycle > 0)
-            t.status = t.cycle;
+        if (t.tag > 0)
+            t.status = t.tag;
     }
     static createItem(instance) {
         return new LinkedItemImpl(instance, 0);
     }
 }
 class LinkedItemImpl {
-    constructor(instance, cycle) {
+    constructor(instance, tag) {
         this.instance = instance;
         this.index = -1;
-        this.cycle = cycle;
-        this.status = ~cycle;
+        this.tag = tag;
+        this.status = ~tag;
         this.next = undefined;
         this.prev = undefined;
         this.aux = undefined;

package/package.json

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