reactronic 0.94.25037 → 0.95.25043

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

@@ -21,9 +21,9 @@ import { Uri } from "../util/Uri.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";
+import { SxObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, observable, reactive, runAtomically, runNonReactively, manageReactiveOperation, disposeObservableObject } from "../System.js";
+import { ReactiveSystem, options, signal, reaction, runTransactional, runNonReactive, manageReaction, disposeSignallingObject } from "../System.js";
 export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, triggers, basis) {
     let result;
     let declaration;
@@ -46,17 +46,17 @@ export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, pre
             if (result.driver !== driver && driver !== undefined)
                 throw misuse(`changing element driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
             const exTriggers = result.declaration.triggers;
-            if (observablesAreEqual(declaration.triggers, exTriggers))
+            if (signalsAreEqual(declaration.triggers, exTriggers))
                 declaration.triggers = exTriggers;
             result.declaration = declaration;
         }
         else {
-            result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
+            result = new ReactiveTreeNode$(effectiveKey || generateKey(owner), driver, declaration, owner);
             result.slot = children.add(result);
         }
     }
     else {
-        result = new ReactiveTreeNodeImpl(effectiveKey || generateKey(owner), driver, declaration, owner);
+        result = new ReactiveTreeNode$(effectiveKey || generateKey(owner), driver, declaration, owner);
         result.slot = ReconciliationList.createItem(result);
     }
     return result;
@@ -74,7 +74,7 @@ export function launch(node, triggers) {
 }
 export class ReactiveTreeNode {
     static get current() {
-        return ReactiveTreeNodeImpl.nodeSlot.instance;
+        return ReactiveTreeNode$.nodeSlot.instance;
     }
     static get isFirstScriptRun() {
         return ReactiveTreeNode.current.stamp === 1;
@@ -82,7 +82,7 @@ export class ReactiveTreeNode {
     static launchScript(node, triggers) {
         const impl = node;
         const declaration = impl.declaration;
-        if (node.stamp >= Number.MAX_SAFE_INTEGER || !observablesAreEqual(triggers, declaration.triggers)) {
+        if (node.stamp >= Number.MAX_SAFE_INTEGER || !signalsAreEqual(triggers, declaration.triggers)) {
             declaration.triggers = triggers;
             launchScriptViaSlot(impl.slot);
         }
@@ -92,7 +92,7 @@ export class ReactiveTreeNode {
         launchFinalizationViaSlot(impl.slot, true, true);
     }
     static launchNestedNodesThenDo(action) {
-        launchNestedNodesThenDoImpl(ReactiveTreeNodeImpl.nodeSlot, undefined, action);
+        launchNestedNodesThenDoImpl(ReactiveTreeNode$.nodeSlot, undefined, action);
     }
     static markAsMounted(node, yes) {
         const n = node;
@@ -131,10 +131,10 @@ export class ReactiveTreeNode {
             ReactiveTreeNode.forEachChildRecursively(child.instance, action);
     }
     static getDefaultLoggingOptions() {
-        return ReactiveTreeNodeImpl.logging;
+        return ReactiveTreeNode$.logging;
     }
     static setDefaultLoggingOptions(logging) {
-        ReactiveTreeNodeImpl.logging = logging;
+        ReactiveTreeNode$.logging = logging;
     }
 }
 ReactiveTreeNode.shortFrameDuration = 16;
@@ -173,13 +173,13 @@ export class ReactiveTreeVariable {
         this.defaultValue = defaultValue;
     }
     set value(value) {
-        ReactiveTreeNodeImpl.setTreeVariableValue(this, value);
+        ReactiveTreeNode$.setTreeVariableValue(this, value);
     }
     get value() {
-        return ReactiveTreeNodeImpl.useTreeVariableValue(this);
+        return ReactiveTreeNode$.useTreeVariableValue(this);
     }
     get valueOrUndefined() {
-        return ReactiveTreeNodeImpl.tryUseTreeVariableValue(this);
+        return ReactiveTreeNode$.tryUseTreeVariableValue(this);
     }
 }
 export function generateKey(owner) {
@@ -234,7 +234,7 @@ function invokeFinalizationUsingBasisChain(element, declaration) {
     else if (basis)
         invokeFinalizationUsingBasisChain(element, basis);
 }
-class ReactiveTreeNodeContextImpl extends ObservableObject {
+class ReactiveTreeNodeContext$ extends SxObject {
     constructor(variable, value) {
         super();
         this.next = undefined;
@@ -243,14 +243,14 @@ class ReactiveTreeNodeContextImpl extends ObservableObject {
     }
 }
 __decorate([
-    observable(false),
+    signal(false),
     __metadata("design:type", Object)
-], ReactiveTreeNodeContextImpl.prototype, "next", void 0);
+], ReactiveTreeNodeContext$.prototype, "next", void 0);
 __decorate([
-    observable(false),
+    signal(false),
     __metadata("design:type", ReactiveTreeVariable)
-], ReactiveTreeNodeContextImpl.prototype, "variable", void 0);
-class ReactiveTreeNodeImpl extends ReactiveTreeNode {
+], ReactiveTreeNodeContext$.prototype, "variable", void 0);
+class ReactiveTreeNode$ extends ReactiveTreeNode {
     constructor(key, driver, declaration, owner) {
         super();
         const thisAsUnknown = this;
@@ -277,9 +277,9 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
         this.numerator = 0;
         this.priority = Priority.realtime;
         this.childrenShuffling = false;
-        ReactiveTreeNodeImpl.grandNodeCount++;
+        ReactiveTreeNode$.grandNodeCount++;
         if (this.has(Mode.autonomous))
-            ReactiveTreeNodeImpl.disposableNodeCount++;
+            ReactiveTreeNode$.disposableNodeCount++;
     }
     getUri(relativeTo) {
         const path = [];
@@ -309,7 +309,7 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
     configureReactivity(options) {
         if (this.stamp < Number.MAX_SAFE_INTEGER - 1 || !this.has(Mode.autonomous))
             throw misuse("reactronic can be configured only for elements with autonomous mode and only during preparation");
-        return manageReactiveOperation(this.script).configure(options);
+        return manageReaction(this.script).configure(options);
     }
     static get nodeSlot() {
         if (!gNodeSlot)
@@ -318,35 +318,35 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
     }
     static tryUseTreeVariableValue(variable) {
         var _a, _b;
-        let node = ReactiveTreeNodeImpl.nodeSlot.instance;
+        let node = ReactiveTreeNode$.nodeSlot.instance;
         while (((_a = node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && node.owner !== node)
             node = node.outer.slot.instance;
         return (_b = node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
     static useTreeVariableValue(variable) {
         var _a;
-        const result = (_a = ReactiveTreeNodeImpl.tryUseTreeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        const result = (_a = ReactiveTreeNode$.tryUseTreeVariableValue(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
         if (!result)
             throw misuse("unknown node variable");
         return result;
     }
     static setTreeVariableValue(variable, value) {
-        const node = ReactiveTreeNodeImpl.nodeSlot.instance;
+        const node = ReactiveTreeNode$.nodeSlot.instance;
         const owner = node.owner;
-        const hostCtx = runNonReactively(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
+        const hostCtx = runNonReactive(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            runAtomically({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            runTransactional({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
                     ctx.value = value;
                 }
                 else
-                    node.context = new ReactiveTreeNodeContextImpl(variable, value);
+                    node.context = new ReactiveTreeNodeContext$(variable, value);
             });
         }
         else if (hostCtx)
@@ -355,21 +355,21 @@ class ReactiveTreeNodeImpl extends ReactiveTreeNode {
             node.outer = owner.outer;
     }
 }
-ReactiveTreeNodeImpl.logging = undefined;
-ReactiveTreeNodeImpl.grandNodeCount = 0;
-ReactiveTreeNodeImpl.disposableNodeCount = 0;
+ReactiveTreeNode$.logging = undefined;
+ReactiveTreeNode$.grandNodeCount = 0;
+ReactiveTreeNode$.disposableNodeCount = 0;
 __decorate([
-    reactive,
+    reaction,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,
-        observableArgs: true,
+        signalArgs: true,
         noSideEffects: false,
     }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], ReactiveTreeNodeImpl.prototype, "script", null);
+], ReactiveTreeNode$.prototype, "script", null);
 function gatherAuthorityAndPath(node, path, relativeTo) {
     let authority;
     if (node.owner !== node && node.owner !== relativeTo) {
@@ -454,9 +454,9 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
         const node = owner.instance;
-        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveTreeNodeImpl.shortFrameDuration / 3)) {
-            let outerPriority = ReactiveTreeNodeImpl.currentScriptPriority;
-            ReactiveTreeNodeImpl.currentScriptPriority = priority;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveTreeNode$.shortFrameDuration / 3)) {
+            let outerPriority = ReactiveTreeNode$.currentScriptPriority;
+            ReactiveTreeNode$.currentScriptPriority = priority;
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
@@ -465,10 +465,10 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
                 for (const child of items) {
                     launchScriptViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
-                        ReactiveTreeNodeImpl.currentScriptPriority = outerPriority;
+                        ReactiveTreeNode$.currentScriptPriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
-                        outerPriority = ReactiveTreeNodeImpl.currentScriptPriority;
-                        ReactiveTreeNodeImpl.currentScriptPriority = priority;
+                        outerPriority = ReactiveTreeNode$.currentScriptPriority;
+                        ReactiveTreeNode$.currentScriptPriority = priority;
                         frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveTreeNode.frameDuration));
                     }
                     if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveTreeNode.shortFrameDuration / 3))
@@ -476,7 +476,7 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
                 }
             }
             finally {
-                ReactiveTreeNodeImpl.currentScriptPriority = outerPriority;
+                ReactiveTreeNode$.currentScriptPriority = outerPriority;
             }
         }
     });
@@ -489,23 +489,23 @@ function launchScriptViaSlot(nodeSlot) {
                 Transaction.outside(() => {
                     if (ReactiveSystem.isLogging)
                         ReactiveSystem.setLoggingHint(node.element, node.key);
-                    manageReactiveOperation(node.script).configure({
+                    manageReaction(node.script).configure({
                         order: node.level,
                     });
                 });
             }
-            runNonReactively(node.script, node.declaration.triggers);
+            runNonReactive(node.script, node.declaration.triggers);
         }
         else if (node.owner !== node)
             runScriptNow(nodeSlot);
         else
-            runAtomically(() => runScriptNow(nodeSlot));
+            runTransactional(() => runScriptNow(nodeSlot));
     }
 }
 function mountOrRemountIfNecessary(node) {
     const driver = node.driver;
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
-        runNonReactively(() => {
+        runNonReactive(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
             if (!node.has(Mode.external)) {
@@ -516,7 +516,7 @@ function mountOrRemountIfNecessary(node) {
         });
     }
     else if (node.isMoved && !node.has(Mode.external) && node.host !== node)
-        runNonReactively(() => driver.runMount(node));
+        runNonReactive(() => driver.runMount(node));
 }
 function runScriptNow(nodeSlot) {
     const node = nodeSlot.instance;
@@ -549,7 +549,7 @@ function launchFinalizationViaSlot(nodeSlot, isLeader, individual) {
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
             console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
         node.stamp = ~node.stamp;
-        const childrenAreLeaders = runNonReactively(() => driver.runFinalization(node, isLeader));
+        const childrenAreLeaders = runNonReactive(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
             nodeSlot.aux = undefined;
             const last = gLastToDispose;
@@ -558,13 +558,13 @@ function launchFinalizationViaSlot(nodeSlot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = nodeSlot;
             if (gFirstToDispose === nodeSlot)
-                runAtomically({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
+                runTransactional({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
         for (const child of node.children.items())
             launchFinalizationViaSlot(child, childrenAreLeaders, false);
-        ReactiveTreeNodeImpl.grandNodeCount--;
+        ReactiveTreeNode$.grandNodeCount--;
     }
 }
 function runDisposalLoop() {
@@ -574,9 +574,9 @@ function runDisposalLoop() {
         while (slot !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            disposeObservableObject(slot.instance);
+            disposeSignallingObject(slot.instance);
             slot = slot.aux;
-            ReactiveTreeNodeImpl.disposableNodeCount--;
+            ReactiveTreeNode$.disposableNodeCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
     });
@@ -602,7 +602,7 @@ function runInsideContextOfNode(nodeSlot, func, ...args) {
         gNodeSlot = outer;
     }
 }
-export function observablesAreEqual(a1, a2) {
+export function signalsAreEqual(a1, a2) {
     let result = a1 === a2;
     if (!result) {
         if (Array.isArray(a1)) {

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

@@ -0,0 +1,52 @@
+export type Extractor<T, Result> = (item: T) => Result;
+export type KeyExtractor<T> = Extractor<T, string | undefined>;
+export declare class LinkedList<T extends LinkedItem<T>> {
+    readonly keyOf: KeyExtractor<T>;
+    private isStrictOrder$;
+    private map;
+    items$: LinkedSubList<T>;
+    former$: LinkedSubList<T> | undefined;
+    constructor(keyExtractor: KeyExtractor<T>, isStrictOrder?: boolean);
+    get isStrictOrder(): boolean;
+    set isStrictOrder(value: boolean);
+    get isRenovationInProgress(): boolean;
+    get count(): number;
+    items(): Generator<T>;
+    lookup(key: string | undefined): T | undefined;
+    add(item: T, before?: T): void;
+    move(item: T, before: T | undefined): void;
+    remove(item: T): void;
+    static move$<T extends LinkedItem<T>>(list: LinkedList<T>, item: T, before: T | undefined): void;
+    static remove$<T extends LinkedItem<T>>(list: LinkedList<T>, item: T): void;
+    static removeKey$<T extends LinkedItem<T>>(list: LinkedList<T>, key: string | undefined): void;
+}
+export declare enum Mark {
+    prolonged = 0,
+    added = 1,
+    modified = 2,
+    removed = 3
+}
+export declare class LinkedItem<T extends LinkedItem<T>> {
+    private list$;
+    private next$;
+    private prev$;
+    private status;
+    constructor();
+    get list(): LinkedSubList<T> | undefined;
+    get next(): T | undefined;
+    get prev(): T | undefined;
+    get mark(): Mark;
+    get rank(): number;
+    get isManagedExternally(): boolean;
+    static setStatus$<T extends LinkedItem<T>>(item: T, mark: Mark, rank: number): void;
+    static link$<T extends LinkedItem<T>>(list: LinkedSubList<T> | undefined, item: T, before: T | undefined): void;
+    private static unlink;
+}
+export declare class LinkedSubList<T extends LinkedItem<T>> {
+    count: number;
+    first?: T;
+    last?: T;
+    items(): Generator<T>;
+    clear(): void;
+    grab(from: LinkedSubList<T>, join: boolean): void;
+}

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

@@ -0,0 +1,177 @@
+import { misuse } from "./Dbg.js";
+export class LinkedList {
+    constructor(keyExtractor, isStrictOrder = false) {
+        this.keyOf = keyExtractor;
+        this.isStrictOrder$ = isStrictOrder;
+        this.map = new Map();
+        this.items$ = new LinkedSubList();
+        this.former$ = undefined;
+    }
+    get isStrictOrder() { return this.isStrictOrder$; }
+    set isStrictOrder(value) {
+        if (this.former$ !== undefined)
+            throw misuse("cannot change strict mode in the middle of renovation");
+        this.isStrictOrder$ = value;
+    }
+    get isRenovationInProgress() {
+        return this.former$ !== undefined;
+    }
+    get count() {
+        var _a, _b;
+        return this.items$.count + ((_b = (_a = this.former$) === null || _a === void 0 ? void 0 : _a.count) !== null && _b !== void 0 ? _b : 0);
+    }
+    items() {
+        return this.items$.items();
+    }
+    lookup(key) {
+        return this.map.get(key);
+    }
+    add(item, before) {
+        const key = this.keyOf(item);
+        if (this.map.get(key) !== undefined)
+            throw misuse(`item with given key already exists: ${key}`);
+        this.map.set(key, item);
+        LinkedItem.link$(this.items$, item, before);
+    }
+    move(item, before) {
+        if (item.list !== this.items$)
+            throw misuse("cannot move item that belongs to another list");
+        if (!item.isManagedExternally)
+            throw misuse("cannot move given item outside of renovation cycle");
+        LinkedList.move$(this, item, before);
+    }
+    remove(item) {
+        if (item.list !== this.items$)
+            throw misuse("cannot remove item that belongs to another list");
+        if (!item.isManagedExternally)
+            throw misuse("cannot remove given item outside of renovation cycle");
+        LinkedList.remove$(this, item);
+    }
+    static move$(list, item, before) {
+        LinkedItem.link$(list.items$, item, before);
+    }
+    static remove$(list, item) {
+        LinkedList.removeKey$(list, list.keyOf(item));
+        LinkedItem.link$(undefined, item, undefined);
+    }
+    static removeKey$(list, key) {
+        list.map.delete(key);
+    }
+}
+export var Mark;
+(function (Mark) {
+    Mark[Mark["prolonged"] = 0] = "prolonged";
+    Mark[Mark["added"] = 1] = "added";
+    Mark[Mark["modified"] = 2] = "modified";
+    Mark[Mark["removed"] = 3] = "removed";
+})(Mark || (Mark = {}));
+const MARK_MOD = 4;
+export class LinkedItem {
+    constructor() {
+        this.list$ = undefined;
+        this.next$ = undefined;
+        this.prev$ = undefined;
+        this.status = 0;
+    }
+    get list() { return this.list$; }
+    get next() { return this.next$; }
+    get prev() { return this.prev$; }
+    get mark() { return this.status % MARK_MOD; }
+    get rank() { return Math.trunc(this.status / MARK_MOD); }
+    get isManagedExternally() { return this.status === 0; }
+    static setStatus$(item, mark, rank) {
+        item.status = rank * MARK_MOD + mark;
+    }
+    static link$(list, item, before) {
+        if (before === undefined) {
+            LinkedItem.unlink(item);
+            if (list !== undefined) {
+                item.list$ = list;
+                const last = list.last;
+                item.prev$ = last;
+                item.next$ = undefined;
+                if (last !== undefined)
+                    list.last = last.next$ = item;
+                else
+                    list.first = list.last = item;
+                list.count++;
+            }
+            else {
+                item.list$ = undefined;
+                item.next$ = undefined;
+                item.prev$ = undefined;
+            }
+        }
+        else {
+            if (list === before.list && list !== undefined) {
+                LinkedItem.unlink(item);
+                const after = before.prev$;
+                item.prev$ = after;
+                item.next$ = before;
+                before.prev$ = item;
+                if (after !== undefined)
+                    after.next$ = item;
+                if (before == list.first)
+                    list.first = item;
+                item.list$ = list;
+                list.count++;
+            }
+            else {
+                if (list !== before.list)
+                    throw misuse("sibling is not in the given list");
+                else if (before.list === undefined)
+                    throw misuse("cannot link to sibling that is not in a list");
+                else
+                    throw misuse("linked list invariant is broken");
+            }
+        }
+    }
+    static unlink(item) {
+        const list = item.list;
+        if (list) {
+            const prev = item.prev$;
+            if (prev !== undefined)
+                prev.next$ = item.next$;
+            const next = item.next$;
+            if (next !== undefined)
+                next.prev$ = item.prev$;
+            if (item === list.first)
+                list.first = item.next$;
+            if (item === list.last)
+                list.last = undefined;
+            list.count--;
+        }
+    }
+}
+export class LinkedSubList {
+    constructor() {
+        this.count = 0;
+        this.first = undefined;
+        this.last = undefined;
+    }
+    *items() {
+        let x = this.first;
+        while (x !== undefined) {
+            const next = x.next;
+            yield x;
+            x = next;
+        }
+    }
+    clear() {
+        this.count = 0;
+        this.first = undefined;
+        this.last = undefined;
+    }
+    grab(from, join) {
+        const head = from.first;
+        if (join !== undefined && head !== undefined) {
+            this.count += from.count;
+        }
+        else {
+            this.count = from.count;
+            this.first = head;
+            this.last = from.last;
+        }
+        from.clear();
+    }
+}

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

@@ -0,0 +1,20 @@
+import { LinkedList, LinkedItem } from "./LinkedList.js";
+export declare class LinkedListRenovation<T extends LinkedItem<T>> {
+    readonly list: LinkedList<T>;
+    readonly diff: Array<T> | undefined;
+    private lost$;
+    private expected;
+    private absent;
+    constructor(list: LinkedList<T>, diff?: Array<T>);
+    lookup(key: string | undefined): T | undefined;
+    tryToProlonge(key: string, resolution?: {
+        isDuplicate: boolean;
+    }, error?: string): T | undefined;
+    thisIsAdded(item: T, before?: T): T;
+    thisIsModified(item: T): void;
+    thisIsMoved(item: T, before: T | undefined): void;
+    thisIsRemoved(item: T): void;
+    get lostItemCount(): number;
+    lostItems(): Generator<T>;
+    done(error?: unknown): void;
+}