reactronic 0.94.25034 → 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 { MergeList } from "./util/MergeList.js";
-export type { MergedItem, MergeListReader } from "./util/MergeList.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 { MergeList } from "./util/MergeList.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/MvccReconciliationList.d.ts

@@ -0,0 +1,27 @@
+import { ReconciliationList, LinkedItem, ReconciliationListReader } from "../util/ReconciliationList.js";
+import { ObservableObject } from "./Mvcc.js";
+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 isReconciliationInProgress(): 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;
+    isFresh(item: LinkedItem<T>): boolean;
+}

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

@@ -0,0 +1,25 @@
+import { ObservableObject } from "./Mvcc.js";
+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 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.beginReconciliation(); }
+    endMerge(error) { this.impl.endReconciliation(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); }
+    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 { MergeList, MergeListReader, MergedItem } from "../util/MergeList.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,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: ReconciliationListReader<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: ReconciliationList<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 { 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";
@@ -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 = ReconciliationList.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 ReconciliationList(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.isReconciliationInProgress) {
             let promised = undefined;
             try {
-                children.endMerge(error);
-                for (const child of children.removedItems(true))
-                    launchFinalization(child, true, true);
+                children.endReconciliation(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.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); });
@@ -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/ReconciliationList.d.ts

@@ -0,0 +1,64 @@
+export type GetListItemKey<T = unknown> = (item: T) => string | undefined;
+export type ReconciliationListReader<T> = {
+    readonly isStrict: boolean;
+    readonly count: number;
+    readonly countOfAdded: number;
+    readonly countOfRemoved: number;
+    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>>;
+    isAdded(item: LinkedItem<T>): boolean;
+    isMoved(item: LinkedItem<T>): boolean;
+    isRemoved(item: LinkedItem<T>): boolean;
+    isFresh(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 ReconciliationList<T> implements ReconciliationListReader<T> {
+    readonly getKey: GetListItemKey<T>;
+    private strict;
+    private map;
+    private tag;
+    private fresh;
+    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 isReconciliationInProgress(): 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;
+    beginReconciliation(): void;
+    endReconciliation(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;
+    isFresh(item: LinkedItem<T>): boolean;
+    markAsMoved(item: LinkedItem<T>): void;
+    static createItem<T>(instance: T): LinkedItem<T>;
+}

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

@@ -1,32 +1,32 @@
 import { misuse } from "./Dbg.js";
-export class MergeList {
+export class ReconciliationList {
     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.fresh = 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.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 addedCount() {
+    get countOfAdded() {
         return this.added.count;
     }
-    get removedCount() {
+    get countOfRemoved() {
         return this.removed.count;
     }
-    get isMergeInProgress() {
+    get isReconciliationInProgress() {
         return this.tag > 0;
     }
     lookup(key) {
@@ -44,10 +44,10 @@ export class MergeList {
         }
         return result;
     }
-    tryMergeAsExisting(key, resolution, error) {
+    tryReuse(key, resolution, error) {
         const tag = this.tag;
         if (tag < 0)
-            throw misuse(error !== null && error !== void 0 ? error : "merge is not in progress");
+            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);
@@ -58,8 +58,8 @@ export class MergeList {
                     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;
             }
@@ -72,7 +72,7 @@ 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}`);
@@ -81,19 +81,19 @@ export class MergeList {
             tag = ~this.tag + 1;
             this.tag = ~tag;
         }
-        const item = new MergedItemImpl(instance, tag);
+        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;
     }
-    mergeAsRemoved(item) {
+    remove(item) {
         const t = item;
         if (!this.isRemoved(t)) {
-            this.current.exclude(t);
+            this.fresh.exclude(t);
             this.removed.include(t);
             t.tag--;
         }
@@ -101,30 +101,30 @@ export class MergeList {
     move(item, after) {
         throw misuse("not implemented");
     }
-    beginMerge() {
-        if (this.isMergeInProgress)
-            throw misuse("merge is in progress already");
+    beginReconciliation() {
+        if (this.isReconciliationInProgress)
+            throw misuse("reconciliation is in progress already");
         this.tag = ~this.tag + 1;
-        this.strictNextItem = this.current.first;
-        this.removed.grab(this.current, false);
+        this.strictNextItem = this.fresh.first;
+        this.removed.grab(this.fresh, false);
         this.added.reset();
     }
-    endMerge(error) {
-        if (!this.isMergeInProgress)
-            throw misuse("merge is ended already");
+    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 MergeList {
                 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();
         }
@@ -145,22 +145,22 @@ export class MergeList {
         this.removed.reset();
         this.added.reset();
     }
-    firstMergedItem() {
-        return this.current.first;
+    firstItem() {
+        return this.fresh.first;
     }
-    lastMergedItem() {
-        return this.current.last;
+    lastItem() {
+        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;
             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;
@@ -200,7 +200,7 @@ export class MergeList {
         const tag = this.tag;
         return tag > 0 ? t.tag < tag : t.tag < tag - 1;
     }
-    isActual(item) {
+    isFresh(item) {
         const t = item;
         return t.tag === this.tag;
     }
@@ -210,10 +210,10 @@ export class MergeList {
             t.status = t.tag;
     }
     static createItem(instance) {
-        return new MergedItemImpl(instance, 0);
+        return new LinkedItemImpl(instance, 0);
     }
 }
-class MergedItemImpl {
+class LinkedItemImpl {
     constructor(instance, tag) {
         this.instance = instance;
         this.index = -1;
@@ -224,7 +224,7 @@ class MergedItemImpl {
         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.25037",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",

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

@@ -1,27 +0,0 @@
-import { MergeList, MergedItem, MergeListReader } from "../util/MergeList.js";
-import { ObservableObject } from "./Mvcc.js";
-export declare abstract class ObservableMergeList<T> extends ObservableObject implements MergeListReader<T> {
-    protected abstract impl: MergeList<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;
-    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;
-}

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

@@ -1,25 +0,0 @@
-import { ObservableObject } from "./Mvcc.js";
-export class ObservableMergeList 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; }
-    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); }
-    move(item, after) { this.impl.move(item, after); }
-    beginMerge() { this.impl.beginMerge(); }
-    endMerge(error) { this.impl.endMerge(error); }
-    resetAddedAndRemovedLists() { this.impl.resetAddedAndRemovedLists(); }
-    firstMergedItem() { return this.impl.firstMergedItem(); }
-    lastMergedItem() { return this.impl.lastMergedItem(); }
-    items() { return this.impl.items(); }
-    addedItems(reset) { return this.impl.addedItems(reset); }
-    removedItems(reset) { return this.impl.removedItems(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); }
-}

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>;
-}