reactronic 0.95.25048 → 0.96.26002

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

@@ -6,16 +6,16 @@ import { RxObject } from "../core/Mvcc.js";
 export type Script<E> = (this: E, o: E, basis: () => void) => void;
 export type ScriptAsync<E> = (this: E, o: E, basis: () => Promise<void>) => Promise<void>;
 export type Handler<E = unknown, R = void> = (o: E) => R;
-export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, signalArgs?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, body?: Script<E>, bodyTask?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationTask?: ScriptAsync<E>, finalization?: Script<E>, signalArgs?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
 export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
-export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, signalArgs?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+export declare function declare<E = void>(driver: ReactiveTreeNodeDriver<E>, bodyOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, bodyTask?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationTask?: ScriptAsync<E>, finalization?: Script<E>, signalArgs?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
 export declare function derivative<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
 export declare function launch<T>(node: ReactiveTreeNode<T>, signalArgs?: unknown): ReactiveTreeNode<T>;
 export declare abstract class ReactiveTreeNode<E = unknown> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
     static frameDuration: number;
-    static currentScriptPriority: Priority;
+    static currentBodyPriority: Priority;
     abstract readonly key: string;
     abstract readonly driver: ReactiveTreeNodeDriver<E>;
     abstract readonly declaration: Readonly<ReactiveTreeNodeDecl<E>>;
@@ -35,8 +35,8 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract has(mode: Mode): boolean;
     abstract configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
     static get current(): ReactiveTreeNode;
-    static get isFirstScriptRun(): boolean;
-    static launchScript(node: ReactiveTreeNode<any>, signalArgs: unknown): void;
+    static get isFirstBodyBuild(): boolean;
+    static buildBody(node: ReactiveTreeNode<any>, signalArgs: unknown): void;
     static launchFinalization(node: ReactiveTreeNode<any>): void;
     static launchNestedNodesThenDo(action: (error: unknown) => void): void;
     static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
@@ -48,12 +48,12 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export type ReactiveTreeNodeDecl<E = unknown> = {
-    script?: Script<E>;
-    scriptAsync?: ScriptAsync<E>;
+    body?: Script<E>;
+    bodyTask?: ScriptAsync<E>;
     key?: string;
     mode?: Mode;
     preparation?: Script<E>;
-    preparationAsync?: ScriptAsync<E>;
+    preparationTask?: ScriptAsync<E>;
     finalization?: Script<E>;
     signalArgs?: unknown;
     basis?: ReactiveTreeNodeDecl<E>;
@@ -66,7 +66,7 @@ export type ReactiveTreeNodeDriver<E = unknown> = {
     runPreparation(node: ReactiveTreeNode<E>): void;
     runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
     runMount(node: ReactiveTreeNode<E>): void;
-    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
+    buildBody(node: ReactiveTreeNode<E>): void | Promise<void>;
     declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
     provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
 };
@@ -82,7 +82,7 @@ export declare abstract class BaseDriver<E = unknown> implements ReactiveTreeNod
     runPreparation(node: ReactiveTreeNode<E>): void | Promise<void>;
     runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
     runMount(node: ReactiveTreeNode<E>): void;
-    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
+    buildBody(node: ReactiveTreeNode<E>): void | Promise<void>;
     declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): LinkedItem<ReactiveTreeNode> | undefined;
     provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
 }
@@ -126,7 +126,7 @@ declare class ReactiveTreeNode$<E = unknown> extends ReactiveTreeNode<E> {
     set strictOrder(value: boolean);
     get isMoved(): boolean;
     has(mode: Mode): boolean;
-    script(_signalArgs: unknown): void;
+    body(_signalArgs: unknown): void;
     configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
     static get nodeSlot(): LinkedItem<ReactiveTreeNode$>;
     static tryUseTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;

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

@@ -24,23 +24,23 @@ import { Priority, Mode, Isolation, Reentrance } from "../Enums.js";
 import { RxObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
 import { ReactiveSystem, options, signal, reaction, runTransactional, runNonReactive, manageReaction, disposeRxObject } from "../System.js";
-export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, preparation, preparationAsync, finalization, signalArgs, basis) {
+export function declare(driver, bodyOrDeclaration, bodyTask, key, mode, preparation, preparationTask, finalization, signalArgs, basis) {
     let result;
     let declaration;
-    if (scriptOrDeclaration instanceof Function) {
+    if (bodyOrDeclaration instanceof Function) {
         declaration = {
-            script: scriptOrDeclaration, scriptAsync, key, mode,
-            preparation, preparationAsync, finalization, signalArgs, basis,
+            body: bodyOrDeclaration, bodyTask, key, mode,
+            preparation, preparationTask, finalization, signalArgs, basis,
         };
     }
     else
-        declaration = scriptOrDeclaration !== null && scriptOrDeclaration !== void 0 ? scriptOrDeclaration : {};
+        declaration = bodyOrDeclaration !== null && bodyOrDeclaration !== void 0 ? bodyOrDeclaration : {};
     let effectiveKey = declaration.key;
     const owner = gNodeSlot === null || gNodeSlot === void 0 ? void 0 : gNodeSlot.instance;
     if (owner) {
         let existing = owner.driver.declareChild(owner, driver, declaration, declaration.basis);
         const children = owner.children;
-        existing !== null && existing !== void 0 ? existing : (existing = children.tryReuse(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 'body' only"));
         if (existing) {
             result = existing.instance;
             if (result.driver !== driver && driver !== undefined)
@@ -69,22 +69,22 @@ export function derivative(declaration, basis) {
     return declaration;
 }
 export function launch(node, signalArgs) {
-    ReactiveTreeNode.launchScript(node, signalArgs);
+    ReactiveTreeNode.buildBody(node, signalArgs);
     return node;
 }
 export class ReactiveTreeNode {
     static get current() {
         return ReactiveTreeNode$.nodeSlot.instance;
     }
-    static get isFirstScriptRun() {
+    static get isFirstBodyBuild() {
         return ReactiveTreeNode.current.stamp === 1;
     }
-    static launchScript(node, signalArgs) {
+    static buildBody(node, signalArgs) {
         const impl = node;
         const declaration = impl.declaration;
         if (node.stamp >= Number.MAX_SAFE_INTEGER || !signalsAreEqual(signalArgs, declaration.signalArgs)) {
             declaration.signalArgs = signalArgs;
-            launchScriptViaSlot(impl.slot);
+            buildBodyViaSlot(impl.slot);
         }
     }
     static launchFinalization(node) {
@@ -140,7 +140,7 @@ export class ReactiveTreeNode {
 ReactiveTreeNode.shortFrameDuration = 16;
 ReactiveTreeNode.longFrameDuration = 300;
 ReactiveTreeNode.frameDuration = ReactiveTreeNode.longFrameDuration;
-ReactiveTreeNode.currentScriptPriority = Priority.realtime;
+ReactiveTreeNode.currentBodyPriority = Priority.realtime;
 export class BaseDriver {
     constructor(name, isPartition, initialize) {
         this.name = name;
@@ -158,8 +158,8 @@ export class BaseDriver {
     }
     runMount(node) {
     }
-    runScript(node) {
-        return invokeScriptUsingBasisChain(node.element, node.declaration);
+    buildBody(node) {
+        return invokeBuildBodyUsingBasisChain(node.element, node.declaration);
     }
     declareChild(ownerNode, childDriver, childDeclaration, childBasis) {
         return undefined;
@@ -196,32 +196,32 @@ export function getModeUsingBasisChain(declaration) {
     var _a;
     return (_a = declaration === null || declaration === void 0 ? void 0 : declaration.mode) !== null && _a !== void 0 ? _a : ((declaration === null || declaration === void 0 ? void 0 : declaration.basis) ? getModeUsingBasisChain(declaration === null || declaration === void 0 ? void 0 : declaration.basis) : Mode.default);
 }
-function invokeScriptUsingBasisChain(element, declaration) {
+function invokeBuildBodyUsingBasisChain(element, declaration) {
     let result = undefined;
     const basis = declaration.basis;
-    const script = declaration.script;
-    const scriptAsync = declaration.scriptAsync;
-    if (script && scriptAsync)
-        throw misuse("'script' and 'scriptAsync' cannot be defined together");
-    if (script)
-        result = script.call(element, element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP);
-    else if (scriptAsync)
-        result = scriptAsync.call(element, element, basis ? () => invokeScriptUsingBasisChain(element, basis) : NOP_ASYNC);
+    const body = declaration.body;
+    const bodyTask = declaration.bodyTask;
+    if (body && bodyTask)
+        throw misuse("'body' and 'bodyTask' cannot be defined together");
+    if (body)
+        result = body.call(element, element, basis ? () => invokeBuildBodyUsingBasisChain(element, basis) : NOP);
+    else if (bodyTask)
+        result = bodyTask.call(element, element, basis ? () => invokeBuildBodyUsingBasisChain(element, basis) : NOP_ASYNC);
     else if (basis)
-        result = invokeScriptUsingBasisChain(element, basis);
+        result = invokeBuildBodyUsingBasisChain(element, basis);
     return result;
 }
 function invokePreparationUsingBasisChain(element, declaration) {
     let result = undefined;
     const basis = declaration.basis;
     const preparation = declaration.preparation;
-    const preparationAsync = declaration.preparationAsync;
-    if (preparation && preparationAsync)
-        throw misuse("'preparation' and 'preparationAsync' cannot be defined together");
+    const preparationTask = declaration.preparationTask;
+    if (preparation && preparationTask)
+        throw misuse("'preparation' and 'preparationTask' cannot be defined together");
     if (preparation)
         result = preparation.call(element, element, basis ? () => invokePreparationUsingBasisChain(element, basis) : NOP);
-    else if (preparationAsync)
-        result = preparationAsync.call(element, element, basis ? () => invokePreparationUsingBasisChain(element, basis) : NOP_ASYNC);
+    else if (preparationTask)
+        result = preparationTask.call(element, element, basis ? () => invokePreparationUsingBasisChain(element, basis) : NOP_ASYNC);
     else if (basis)
         result = invokePreparationUsingBasisChain(element, basis);
     return result;
@@ -303,13 +303,13 @@ class ReactiveTreeNode$ extends ReactiveTreeNode {
     has(mode) {
         return flags(getModeUsingBasisChain(this.declaration), mode);
     }
-    script(_signalArgs) {
-        runScriptNow(this.slot);
+    body(_signalArgs) {
+        buildBodyNow(this.slot);
     }
     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 manageReaction(this.script).configure(options);
+        return manageReaction(this.body).configure(options);
     }
     static get nodeSlot() {
         if (!gNodeSlot)
@@ -369,7 +369,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], ReactiveTreeNode$.prototype, "script", null);
+], ReactiveTreeNode$.prototype, "body", null);
 function gatherAuthorityAndPath(node, path, relativeTo) {
     let authority;
     if (node.owner !== node && node.owner !== relativeTo) {
@@ -409,7 +409,7 @@ function launchNestedNodesThenDoImpl(nodeSlot, error, action) {
                         mounting = markToMountIfNecessary(mounting, host, child, children, sequential);
                         const p = (_a = childNode.priority) !== null && _a !== void 0 ? _a : Priority.realtime;
                         if (p === Priority.realtime)
-                            launchScriptViaSlot(child);
+                            buildBodyViaSlot(child);
                         else if (p === Priority.normal)
                             p1 = push(child, p1);
                         else
@@ -418,7 +418,7 @@ function launchNestedNodesThenDoImpl(nodeSlot, error, action) {
                             partition = childNode;
                     }
                     if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                        promised = startIncrementalNestedScriptsRun(nodeSlot, children, p1, p2).then(() => action(error), e => action(e));
+                        promised = startIncrementalNestedBodyBuild(nodeSlot, children, p1, p2).then(() => action(error), e => action(e));
                 }
             }
             finally {
@@ -441,34 +441,34 @@ function markToMountIfNecessary(mounting, host, nodeSlot, children, sequential)
     node.host = host;
     return mounting;
 }
-function startIncrementalNestedScriptsRun(ownerSlot, allChildren, priority1, priority2) {
+function startIncrementalNestedBodyBuild(ownerSlot, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
         const stamp = ownerSlot.instance.stamp;
         if (priority1)
-            yield runNestedScriptsIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.normal);
+            yield runNestedBodyBuildIncrementally(ownerSlot, stamp, allChildren, priority1, Priority.normal);
         if (priority2)
-            yield runNestedScriptsIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.background);
+            yield runNestedBodyBuildIncrementally(ownerSlot, stamp, allChildren, priority2, Priority.background);
     });
 }
-function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priority) {
+function runNestedBodyBuildIncrementally(owner, stamp, allChildren, items, priority) {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
         const node = owner.instance;
         if (!Transaction.isCanceled || !Transaction.isFrameOver(1, ReactiveTreeNode$.shortFrameDuration / 3)) {
-            let outerPriority = ReactiveTreeNode$.currentScriptPriority;
-            ReactiveTreeNode$.currentScriptPriority = priority;
+            let outerPriority = ReactiveTreeNode$.currentBodyPriority;
+            ReactiveTreeNode$.currentBodyPriority = priority;
             try {
                 if (node.childrenShuffling)
                     shuffle(items);
                 const frameDurationLimit = priority === Priority.background ? ReactiveTreeNode.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(ReactiveTreeNode.frameDuration / 4, ReactiveTreeNode.shortFrameDuration));
                 for (const child of items) {
-                    launchScriptViaSlot(child);
+                    buildBodyViaSlot(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
-                        ReactiveTreeNode$.currentScriptPriority = outerPriority;
+                        ReactiveTreeNode$.currentBodyPriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
-                        outerPriority = ReactiveTreeNode$.currentScriptPriority;
-                        ReactiveTreeNode$.currentScriptPriority = priority;
+                        outerPriority = ReactiveTreeNode$.currentBodyPriority;
+                        ReactiveTreeNode$.currentBodyPriority = priority;
                         frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, ReactiveTreeNode.frameDuration));
                     }
                     if (Transaction.isCanceled && Transaction.isFrameOver(1, ReactiveTreeNode.shortFrameDuration / 3))
@@ -476,12 +476,12 @@ function runNestedScriptsIncrementally(owner, stamp, allChildren, items, priorit
                 }
             }
             finally {
-                ReactiveTreeNode$.currentScriptPriority = outerPriority;
+                ReactiveTreeNode$.currentBodyPriority = outerPriority;
             }
         }
     });
 }
-function launchScriptViaSlot(nodeSlot) {
+function buildBodyViaSlot(nodeSlot) {
     const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         if (node.has(Mode.autonomous)) {
@@ -489,17 +489,17 @@ function launchScriptViaSlot(nodeSlot) {
                 Transaction.outside(() => {
                     if (ReactiveSystem.isLogging)
                         ReactiveSystem.setLoggingHint(node.element, node.key);
-                    manageReaction(node.script).configure({
+                    manageReaction(node.body).configure({
                         order: node.level,
                     });
                 });
             }
-            runNonReactive(node.script, node.declaration.signalArgs);
+            runNonReactive(node.body, node.declaration.signalArgs);
         }
         else if (node.owner !== node)
-            runScriptNow(nodeSlot);
+            buildBodyNow(nodeSlot);
         else
-            runTransactional(() => runScriptNow(nodeSlot));
+            runTransactional(() => buildBodyNow(nodeSlot));
     }
 }
 function mountOrRemountIfNecessary(node) {
@@ -518,7 +518,7 @@ function mountOrRemountIfNecessary(node) {
     else if (node.isMoved && !node.has(Mode.external) && node.host !== node)
         runNonReactive(() => driver.runMount(node));
 }
-function runScriptNow(nodeSlot) {
+function buildBodyNow(nodeSlot) {
     const node = nodeSlot.instance;
     if (node.stamp >= 0) {
         let result = undefined;
@@ -530,12 +530,12 @@ function runScriptNow(nodeSlot) {
                     node.numerator = 0;
                     node.children.beginReconciliation();
                     const driver = node.driver;
-                    result = driver.runScript(node);
+                    result = driver.buildBody(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); });
                 }
                 catch (e) {
                     launchNestedNodesThenDoImpl(nodeSlot, e, NOP);
-                    console.log(`Reactive node script failed: ${node.key}`);
+                    console.log(`Reactive node body build failed: ${node.key}`);
                     console.log(`${e}`);
                 }
             }

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

@@ -1,7 +1,7 @@
 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>;
+    readonly keyExtractor: KeyExtractor<T>;
     private isStrictOrder$;
     private map;
     items$: LinkedSubList<T>;
@@ -13,18 +13,20 @@ export declare class LinkedList<T extends LinkedItem<T>> {
     get isRenovationInProgress(): boolean;
     get count(): number;
     items(): Generator<T>;
-    lookup(key: string | undefined): T | undefined;
+    tryLookup(key: string): T | undefined;
+    lookup(key: string): T;
     add(item: T, before?: T): void;
     move(item: T, before: T | undefined): void;
     remove(item: T): void;
     beginRenovation(diff?: Array<T>): LinkedListRenovation<T>;
     endRenovation(error?: unknown): LinkedListRenovation<T>;
+    extractKey(item: T): string;
     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;
+    static removeKey$<T extends LinkedItem<T>>(list: LinkedList<T>, key: string): void;
 }
 export declare enum Mark {
-    prolonged = 0,
+    reaffirmed = 0,
     added = 1,
     modified = 2,
     removed = 3
@@ -60,8 +62,8 @@ export declare class LinkedListRenovation<T extends LinkedItem<T>> {
     private expected;
     private absent;
     constructor(list: LinkedList<T>, former: LinkedSubList<T>, diff?: Array<T>);
-    lookup(key: string | undefined): T | undefined;
-    tryToProlong(key: string, resolution?: {
+    tryLookup(key: string): T | undefined;
+    tryReaffirm(key: string, resolution?: {
         isDuplicate: boolean;
     }, error?: string): T | undefined;
     thisIsAdded(item: T, before?: T): T;

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

@@ -1,7 +1,7 @@
 import { misuse } from "./Dbg.js";
 export class LinkedList {
     constructor(keyExtractor, isStrictOrder = false) {
-        this.keyOf = keyExtractor;
+        this.keyExtractor = keyExtractor;
         this.isStrictOrder$ = isStrictOrder;
         this.map = new Map();
         this.items$ = new LinkedSubList();
@@ -29,11 +29,17 @@ export class LinkedList {
     items() {
         return this.items$.items();
     }
-    lookup(key) {
+    tryLookup(key) {
         return this.map.get(key);
     }
+    lookup(key) {
+        const result = this.tryLookup(key);
+        if (result === undefined)
+            throw misuse(`item with given key doesn't exist: ${key}`);
+        return result;
+    }
     add(item, before) {
-        const key = this.keyOf(item);
+        const key = this.extractKey(item);
         if (this.map.get(key) !== undefined)
             throw misuse(`item with given key already exists: ${key}`);
         this.map.set(key, item);
@@ -70,7 +76,7 @@ export class LinkedList {
         if (error === undefined) {
             for (const x of renovation.lostItems()) {
                 if (!x.isManagedExternally) {
-                    LinkedList.removeKey$(this, this.keyOf(x));
+                    LinkedList.removeKey$(this, this.extractKey(x));
                     LinkedItem.setStatus$(x, Mark.removed, 0);
                 }
                 else
@@ -80,17 +86,24 @@ export class LinkedList {
         else {
             for (const x of renovation.lostItems()) {
                 LinkedItem.link$(items, x, undefined);
-                LinkedItem.setStatus$(x, Mark.prolonged, items.count);
+                LinkedItem.setStatus$(x, Mark.reaffirmed, items.count);
             }
         }
         this.renovation$ = undefined;
         return renovation;
     }
+    extractKey(item) {
+        const result = this.keyExtractor(item);
+        if (result === undefined)
+            throw misuse("given item has no key");
+        return result;
+    }
     static move$(list, item, before) {
         LinkedItem.link$(list.items$, item, before);
     }
     static remove$(list, item) {
-        LinkedList.removeKey$(list, list.keyOf(item));
+        const key = list.extractKey(item);
+        LinkedList.removeKey$(list, key);
         LinkedItem.link$(undefined, item, undefined);
     }
     static removeKey$(list, key) {
@@ -99,7 +112,7 @@ export class LinkedList {
 }
 export var Mark;
 (function (Mark) {
-    Mark[Mark["prolonged"] = 0] = "prolonged";
+    Mark[Mark["reaffirmed"] = 0] = "reaffirmed";
     Mark[Mark["added"] = 1] = "added";
     Mark[Mark["modified"] = 2] = "modified";
     Mark[Mark["removed"] = 3] = "removed";
@@ -222,12 +235,12 @@ export class LinkedListRenovation {
         this.expected = former.first;
         this.absent = undefined;
     }
-    lookup(key) {
+    tryLookup(key) {
         let result = undefined;
         if (key !== undefined && key !== this.absent) {
-            result = this.list.lookup(key);
+            result = this.list.tryLookup(key);
             if (result !== undefined) {
-                if (this.list.keyOf(result) !== key) {
+                if (this.list.keyExtractor(result) !== key) {
                     this.absent = key;
                     result = undefined;
                 }
@@ -237,14 +250,14 @@ export class LinkedListRenovation {
         }
         return result;
     }
-    tryToProlong(key, resolution, error) {
+    tryReaffirm(key, resolution, error) {
         var _a, _b;
         const list = this.list;
         if (!list.isRenovationInProgress)
             throw misuse(error !== null && error !== void 0 ? error : "renovation is no longer in progress");
         let x = this.expected;
-        if (key !== (x ? list.keyOf(x) : undefined))
-            x = this.lookup(key);
+        if (key !== (x ? list.keyExtractor(x) : undefined))
+            x = this.tryLookup(key);
         if (x !== undefined) {
             const result = this.list.items$;
             if (x.list !== result) {
@@ -256,7 +269,7 @@ export class LinkedListRenovation {
                     (_b = this.diff) === null || _b === void 0 ? void 0 : _b.push(x);
                 }
                 else
-                    LinkedItem.setStatus$(x, Mark.prolonged, result.count);
+                    LinkedItem.setStatus$(x, Mark.reaffirmed, result.count);
                 this.expected = next;
                 if (resolution)
                     resolution.isDuplicate = false;
@@ -281,9 +294,9 @@ export class LinkedListRenovation {
     }
     thisIsModified(item) {
         if (item.list !== this.list.items$)
-            throw misuse("only prolonged items can be marked as modified");
+            throw misuse("only reaffirmed items can be marked as modified");
         const m = item.mark;
-        if (m === Mark.prolonged)
+        if (m === Mark.reaffirmed)
             LinkedItem.setStatus$(item, Mark.modified, item.rank);
         else if (m !== Mark.modified)
             throw misuse("item is renovated already and cannot be marked as modified");

package/package.json

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