reactronic 0.95.25046 → 0.95.25048

package/README.md

@@ -48,7 +48,7 @@ Quick introduction and detailed description is below.
 Here is an example of transactional reactive code:
 
 ``` typescript
-class Demo extends SignallingObject {
+class Demo extends RxObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -115,7 +115,7 @@ to track access to their properties, both on reads and
 writes.
 
 ``` typescript
-class MyModel extends SignallingObject {
+class MyModel extends RxObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -123,7 +123,7 @@ class MyModel extends SignallingObject {
 ```
 
 In the example above, the class `MyModel` is based on
-Reactronic's `SignallingObject` class and all its
+Reactronic's `RxObject` class and all its
 properties `url`, `content`, and `timestamp` are hooked.
 
 ## Transactional Function
@@ -136,7 +136,7 @@ provide transparent atomicity (by implicit context
 switching and isolation).
 
 ``` typescript
-class MyModel extends SignallingObject {
+class MyModel extends RxObject {
   // ...
   @transaction
   async load(url: string): Promise<void> {
@@ -232,7 +232,7 @@ class Component<P> extends React.Component<P> {
   }
 
   componentWillUnmount(): void {
-    runTransactional(disposeSignallingObject, this)
+    runTransactional(disposeRxObject, this)
   }
 }
 ```
@@ -325,7 +325,7 @@ NPM: `npm install reactronic`
 // Classes
 
 class TxObject { } // transactional object
-class SxObject { } // signalling object
+class RxObject { } // reactive object
 
 // Decorators & Operators
 

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

@@ -1,6 +1,6 @@
 import { F } from "./util/Utils.js";
-import { SxObject } from "./core/Mvcc.js";
-export declare class ReactionEx<T> extends SxObject {
+import { RxObject } from "./core/Mvcc.js";
+export declare class ReactionEx<T> extends RxObject {
     protected operation: F<T>;
     constructor(operation: F<T>);
     protected launch(): T;

package/build/dist/source/OperationEx.js

@@ -7,9 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { SxObject } from "./core/Mvcc.js";
+import { RxObject } from "./core/Mvcc.js";
 import { reaction } from "./System.js";
-export class ReactionEx extends SxObject {
+export class ReactionEx extends RxObject {
     constructor(operation) {
         super();
         this.operation = operation;

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

@@ -1,5 +1,5 @@
-import { SxObject } from "./core/Mvcc.js";
-export declare abstract class Pipe<T> extends SxObject {
+import { RxObject } from "./core/Mvcc.js";
+export declare abstract class Pipe<T> extends RxObject {
     abstract readonly capacity: number;
     abstract readonly count: number;
     abstract put(...items: T[]): void;

package/build/dist/source/Pipe.js

@@ -1,5 +1,5 @@
 import { misuse } from "./util/Dbg.js";
-import { SxObject } from "./core/Mvcc.js";
-export class Pipe extends SxObject {
+import { RxObject } from "./core/Mvcc.js";
+export class Pipe extends RxObject {
     static create(hint, capacity) { throw misuse("not implemented"); }
 }

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

@@ -20,7 +20,7 @@ export declare function runSensitive<T>(sensitivity: boolean, func: F<T>, ...arg
 export declare function runContextual<T>(p: Promise<T>): Promise<T>;
 export declare function manageReaction<T>(method: F<T>): Reaction<T>;
 export declare function configureCurrentReaction(options: Partial<ReactivityOptions>): ReactivityOptions;
-export declare function disposeSignallingObject(obj: any): void;
+export declare function disposeRxObject(obj: any): void;
 export declare function signal(enabled: boolean): (proto: object, prop: PropertyKey) => any;
 export declare function signal<T>(proto: object, prop: PropertyKey): any;
 export declare function transaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;

package/build/dist/source/System.js

@@ -47,7 +47,7 @@ export function manageReaction(method) {
 export function configureCurrentReaction(options) {
     return ReactionImpl.configureImpl(undefined, options);
 }
-export function disposeSignallingObject(obj) {
+export function disposeRxObject(obj) {
     Changeset.dispose(obj);
 }
 export function signal(protoOrEnabled, prop) {

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

@@ -11,14 +11,14 @@ export type { Reaction, ReactivityOptions, SnapshotOptions, LoggingOptions, Prof
 export type { Worker } from "./Worker.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
 export type { BoolOnly, GivenTypeOnly } from "./Ref.js";
-export { TxObject, SxObject } from "./core/Mvcc.js";
-export { TxArray, SxArray } from "./core/MvccArray.js";
-export { TxMap, SxMap } from "./core/MvccMap.js";
+export { TxObject, RxObject } from "./core/Mvcc.js";
+export { TxArray, RxArray } from "./core/MvccArray.js";
+export { TxMap, RxMap } from "./core/MvccMap.js";
 export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
-export { runTransactional, runNonReactive, runSensitive, runContextual, manageReaction, configureCurrentReaction, disposeSignallingObject } from "./System.js";
+export { runTransactional, runNonReactive, runSensitive, runContextual, manageReaction, configureCurrentReaction, disposeRxObject } from "./System.js";
 export { ReactiveSystem, signal, transaction, reaction, cache, options } from "./System.js";
 export { ReactionEx } from "./OperationEx.js";
 export { declare, derivative, launch, ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";

package/build/dist/source/api.js

@@ -7,14 +7,14 @@ export { SealedSet } from "./util/SealedSet.js";
 export { LoggingLevel } from "./Options.js";
 export { Mode, Priority, Kind, Reentrance, Isolation } from "./Enums.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
-export { TxObject, SxObject } from "./core/Mvcc.js";
-export { TxArray, SxArray } from "./core/MvccArray.js";
-export { TxMap, SxMap } from "./core/MvccMap.js";
+export { TxObject, RxObject } from "./core/Mvcc.js";
+export { TxArray, RxArray } from "./core/MvccArray.js";
+export { TxMap, RxMap } from "./core/MvccMap.js";
 export { Changeset } from "./core/Changeset.js";
 export { Transaction } from "./core/Transaction.js";
 export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
-export { runTransactional, runNonReactive, runSensitive, runContextual, manageReaction, configureCurrentReaction, disposeSignallingObject } from "./System.js";
+export { runTransactional, runNonReactive, runSensitive, runContextual, manageReaction, configureCurrentReaction, disposeRxObject } from "./System.js";
 export { ReactiveSystem, signal, transaction, reaction, cache, options } from "./System.js";
 export { ReactionEx } from "./OperationEx.js";
 export { declare, derivative, launch, ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";

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

@@ -1,6 +1,6 @@
 import { Worker } from "../Worker.js";
-import { SxObject } from "./Mvcc.js";
-export declare abstract class Indicator extends SxObject {
+import { RxObject } from "./Mvcc.js";
+export declare abstract class Indicator extends RxObject {
     abstract readonly isBusy: boolean;
     abstract readonly counter: number;
     abstract readonly workers: ReadonlySet<Worker>;

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

@@ -8,9 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Isolation } from "../Enums.js";
-import { SxObject, Mvcc } from "./Mvcc.js";
+import { RxObject, Mvcc } from "./Mvcc.js";
 import { Transaction } from "./Transaction.js";
-export class Indicator extends SxObject {
+export class Indicator extends RxObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return IndicatorImpl.createImpl(hint, activationDelay, deactivationDelay, durationResolution);
     }

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

@@ -1,7 +1,7 @@
-import { SxObject } from "./Mvcc.js";
+import { RxObject } from "./Mvcc.js";
 import { ObjectHandle, ObjectVersion, PatchSet } from "./Data.js";
 export type Saver = (patch: PatchSet) => Promise<void>;
-export declare abstract class Journal extends SxObject {
+export declare abstract class Journal extends RxObject {
     abstract capacity: number;
     abstract readonly edits: ReadonlyArray<PatchSet>;
     abstract readonly unsaved: PatchSet;

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

@@ -1,11 +1,11 @@
 import { misuse } from "../util/Dbg.js";
 import { Isolation } from "../Enums.js";
-import { SxObject } from "./Mvcc.js";
+import { RxObject } from "./Mvcc.js";
 import { Meta, ContentFootprint } from "./Data.js";
 import { Changeset, EMPTY_OBJECT_VERSION } from "./Changeset.js";
 import { Transaction } from "./Transaction.js";
 import { Sealant } from "../util/Sealant.js";
-export class Journal extends SxObject {
+export class Journal extends RxObject {
     static create() { return new JournalImpl(); }
 }
 export class JournalImpl extends Journal {

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

@@ -12,7 +12,7 @@ export declare abstract class MvccObject {
 export declare abstract class TxObject extends MvccObject {
     constructor();
 }
-export declare abstract class SxObject extends MvccObject {
+export declare abstract class RxObject extends MvccObject {
     constructor();
 }
 export declare class OptionsImpl implements ReactivityOptions {
@@ -39,7 +39,7 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
     static readonly tx: Mvcc;
-    static readonly sx: Mvcc;
+    static readonly rx: Mvcc;
     readonly isSignal: boolean;
     constructor(isSignal: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;

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

@@ -20,7 +20,7 @@ export class TxObject extends MvccObject {
         super(false);
     }
 }
-export class SxObject extends MvccObject {
+export class RxObject extends MvccObject {
     constructor() {
         super(true);
     }
@@ -125,11 +125,11 @@ export class Mvcc {
             Meta.acquire(proto, Meta.Initial)[fk] = new ContentFootprint(undefined, 0);
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.sx.get(h, fk, this);
+                return Mvcc.rx.get(h, fk, this);
             };
             const set = function (value) {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.sx.set(h, fk, value, this);
+                return Mvcc.rx.set(h, fk, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -178,7 +178,7 @@ export class Mvcc {
                 throw misuse("only objects can be signalling");
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
             const ov = new ObjectVersion(EMPTY_OBJECT_VERSION.changeset, EMPTY_OBJECT_VERSION, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Mvcc.sx, ov, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Mvcc.rx, ov, obj.constructor.name);
             Meta.set(ov.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
             Meta.set(ov.data, Meta.Revision, new ContentFootprint(1, 0));
@@ -187,7 +187,7 @@ export class Mvcc {
     }
     static createHandleForMvccObject(proto, data, blank, hint, isSignal) {
         const ctx = Changeset.edit();
-        const mvcc = isSignal ? Mvcc.sx : Mvcc.tx;
+        const mvcc = isSignal ? Mvcc.rx : Mvcc.tx;
         const h = new ObjectHandle(data, undefined, mvcc, EMPTY_OBJECT_VERSION, hint);
         ctx.getEditableObjectVersion(h, Meta.Handle, blank);
         if (!Mvcc.reactivityAutoStartDisabled)
@@ -237,7 +237,7 @@ Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.sensitivity = false;
 Mvcc.tx = new Mvcc(false);
-Mvcc.sx = new Mvcc(true);
+Mvcc.rx = new Mvcc(true);
 Mvcc.createOperationDescriptor = function (h, fk, options) {
     throw misuse("this implementation of createOperationDescriptor should never be called");
 };

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

@@ -53,7 +53,7 @@ export declare class TxArray<T> extends MvccArray<T> {
     constructor(arrayLength?: number);
     constructor(...items: T[]);
 }
-export declare class SxArray<T> extends MvccArray<T> {
+export declare class RxArray<T> extends MvccArray<T> {
     constructor();
     constructor(arrayLength: number);
     constructor(arrayLength?: number);

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

@@ -51,7 +51,7 @@ export class TxArray extends MvccArray {
         super(false, new Array(...args));
     }
 }
-export class SxArray extends MvccArray {
+export class RxArray extends MvccArray {
     constructor(...args) {
         super(true, new Array(...args));
     }

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

@@ -19,7 +19,7 @@ export declare class TxMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }
-export declare class SxMap<K, V> extends MvccMap<K, V> {
+export declare class RxMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }

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

@@ -28,7 +28,7 @@ export class TxMap extends MvccMap {
         super(false, args !== undefined ? new Map(args) : new Map());
     }
 }
-export class SxMap extends MvccMap {
+export class RxMap extends MvccMap {
     constructor(args) {
         super(true, args !== undefined ? new Map(args) : new Map());
     }

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

@@ -1,6 +1,6 @@
 import { ReconciliationList, LinkedItem, ReconciliationListReader } from "../util/ReconciliationList.js";
-import { SxObject } from "./Mvcc.js";
-export declare abstract class SxReconciliationList<T> extends SxObject implements ReconciliationListReader<T> {
+import { RxObject } from "./Mvcc.js";
+export declare abstract class RxReconciliationList<T> extends RxObject implements ReconciliationListReader<T> {
     protected abstract impl: ReconciliationList<T>;
     get isStrict(): boolean;
     get count(): number;

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

@@ -1,5 +1,5 @@
-import { SxObject } from "./Mvcc.js";
-export class SxReconciliationList extends SxObject {
+import { RxObject } from "./Mvcc.js";
+export class RxReconciliationList extends RxObject {
     get isStrict() { return this.impl.isStrict; }
     get count() { return this.impl.count; }
     get countOfAdded() { return this.impl.countOfAdded; }

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

@@ -8,7 +8,7 @@ import { Mvcc, OptionsImpl } from "./Mvcc.js";
 import { JournalImpl } from "./Journal.js";
 const BOOT_ARGS = [];
 const BOOT_CAUSE = "<boot>";
-const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.sx, EMPTY_OBJECT_VERSION, "<boot>");
+const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.rx, EMPTY_OBJECT_VERSION, "<boot>");
 export class ReactionImpl {
     configure(options) { return ReactionImpl.configureImpl(this, options); }
     get options() { return this.peek(undefined).footprint.options; }

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

@@ -2,15 +2,15 @@ import { LoggingOptions } from "../Logging.js";
 import { ReconciliationList, ReconciliationListReader, LinkedItem } from "../util/ReconciliationList.js";
 import { Priority, Mode } from "../Enums.js";
 import { ReactivityOptions } from "../Options.js";
-import { SxObject } from "../core/Mvcc.js";
+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>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
+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>, 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>, triggers?: unknown, basis?: 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 derivative<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
-export declare function launch<T>(node: ReactiveTreeNode<T>, triggers?: unknown): ReactiveTreeNode<T>;
+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;
@@ -36,7 +36,7 @@ export declare abstract class ReactiveTreeNode<E = unknown> {
     abstract configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
     static get current(): ReactiveTreeNode;
     static get isFirstScriptRun(): boolean;
-    static launchScript(node: ReactiveTreeNode<any>, triggers: unknown): void;
+    static launchScript(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;
@@ -55,7 +55,7 @@ export type ReactiveTreeNodeDecl<E = unknown> = {
     preparation?: Script<E>;
     preparationAsync?: ScriptAsync<E>;
     finalization?: Script<E>;
-    triggers?: unknown;
+    signalArgs?: unknown;
     basis?: ReactiveTreeNodeDecl<E>;
 };
 export type ReactiveTreeNodeDriver<E = unknown> = {
@@ -95,7 +95,7 @@ export declare class ReactiveTreeVariable<T extends Object = Object> {
 }
 export declare function generateKey(owner?: ReactiveTreeNode$): string;
 export declare function getModeUsingBasisChain(declaration?: ReactiveTreeNodeDecl<any>): Mode;
-declare class ReactiveTreeNodeContext$<T extends Object = Object> extends SxObject implements ReactiveTreeNodeContext<T> {
+declare class ReactiveTreeNodeContext$<T extends Object = Object> extends RxObject implements ReactiveTreeNodeContext<T> {
     next: ReactiveTreeNodeContext$<object> | undefined;
     variable: ReactiveTreeVariable<T>;
     value: T;
@@ -126,7 +126,7 @@ declare class ReactiveTreeNode$<E = unknown> extends ReactiveTreeNode<E> {
     set strictOrder(value: boolean);
     get isMoved(): boolean;
     has(mode: Mode): boolean;
-    script(_triggers: unknown): void;
+    script(_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

@@ -21,16 +21,16 @@ 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 { SxObject } from "../core/Mvcc.js";
+import { RxObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.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) {
+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) {
     let result;
     let declaration;
     if (scriptOrDeclaration instanceof Function) {
         declaration = {
             script: scriptOrDeclaration, scriptAsync, key, mode,
-            preparation, preparationAsync, finalization, triggers, basis,
+            preparation, preparationAsync, finalization, signalArgs, basis,
         };
     }
     else
@@ -45,9 +45,9 @@ export function declare(driver, scriptOrDeclaration, scriptAsync, key, mode, pre
             result = existing.instance;
             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 (signalsAreEqual(declaration.triggers, exTriggers))
-                declaration.triggers = exTriggers;
+            const exSignalArgs = result.declaration.signalArgs;
+            if (signalsAreEqual(declaration.signalArgs, exSignalArgs))
+                declaration.signalArgs = exSignalArgs;
             result.declaration = declaration;
         }
         else {
@@ -68,8 +68,8 @@ export function derivative(declaration, basis) {
         declaration = basis !== null && basis !== void 0 ? basis : {};
     return declaration;
 }
-export function launch(node, triggers) {
-    ReactiveTreeNode.launchScript(node, triggers);
+export function launch(node, signalArgs) {
+    ReactiveTreeNode.launchScript(node, signalArgs);
     return node;
 }
 export class ReactiveTreeNode {
@@ -79,11 +79,11 @@ export class ReactiveTreeNode {
     static get isFirstScriptRun() {
         return ReactiveTreeNode.current.stamp === 1;
     }
-    static launchScript(node, triggers) {
+    static launchScript(node, signalArgs) {
         const impl = node;
         const declaration = impl.declaration;
-        if (node.stamp >= Number.MAX_SAFE_INTEGER || !signalsAreEqual(triggers, declaration.triggers)) {
-            declaration.triggers = triggers;
+        if (node.stamp >= Number.MAX_SAFE_INTEGER || !signalsAreEqual(signalArgs, declaration.signalArgs)) {
+            declaration.signalArgs = signalArgs;
             launchScriptViaSlot(impl.slot);
         }
     }
@@ -234,7 +234,7 @@ function invokeFinalizationUsingBasisChain(element, declaration) {
     else if (basis)
         invokeFinalizationUsingBasisChain(element, basis);
 }
-class ReactiveTreeNodeContext$ extends SxObject {
+class ReactiveTreeNodeContext$ extends RxObject {
     constructor(variable, value) {
         super();
         this.next = undefined;
@@ -303,7 +303,7 @@ class ReactiveTreeNode$ extends ReactiveTreeNode {
     has(mode) {
         return flags(getModeUsingBasisChain(this.declaration), mode);
     }
-    script(_triggers) {
+    script(_signalArgs) {
         runScriptNow(this.slot);
     }
     configureReactivity(options) {
@@ -494,7 +494,7 @@ function launchScriptViaSlot(nodeSlot) {
                     });
                 });
             }
-            runNonReactive(node.script, node.declaration.triggers);
+            runNonReactive(node.script, node.declaration.signalArgs);
         }
         else if (node.owner !== node)
             runScriptNow(nodeSlot);
@@ -574,7 +574,7 @@ function runDisposalLoop() {
         while (slot !== undefined) {
             if (Transaction.isFrameOver(500, 5))
                 yield Transaction.requestNextFrame();
-            disposeSignallingObject(slot.instance);
+            disposeRxObject(slot.instance);
             slot = slot.aux;
             ReactiveTreeNode$.disposableNodeCount--;
         }

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

@@ -5,10 +5,11 @@ export declare class LinkedList<T extends LinkedItem<T>> {
     private isStrictOrder$;
     private map;
     items$: LinkedSubList<T>;
-    private renovation;
+    private renovation$;
     constructor(keyExtractor: KeyExtractor<T>, isStrictOrder?: boolean);
     get isStrictOrder(): boolean;
     set isStrictOrder(value: boolean);
+    get renovation(): LinkedListRenovation<T>;
     get isRenovationInProgress(): boolean;
     get count(): number;
     items(): Generator<T>;
@@ -17,7 +18,7 @@ export declare class LinkedList<T extends LinkedItem<T>> {
     move(item: T, before: T | undefined): void;
     remove(item: T): void;
     beginRenovation(diff?: Array<T>): LinkedListRenovation<T>;
-    endRenovation(error?: unknown): void;
+    endRenovation(error?: unknown): LinkedListRenovation<T>;
     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;

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

@@ -5,20 +5,26 @@ export class LinkedList {
         this.isStrictOrder$ = isStrictOrder;
         this.map = new Map();
         this.items$ = new LinkedSubList();
-        this.renovation = undefined;
+        this.renovation$ = undefined;
     }
     get isStrictOrder() { return this.isStrictOrder$; }
     set isStrictOrder(value) {
-        if (this.renovation !== undefined)
+        if (this.renovation$ !== undefined)
             throw misuse("cannot change strict mode in the middle of renovation");
         this.isStrictOrder$ = value;
     }
+    get renovation() {
+        const r = this.renovation$;
+        if (r === undefined)
+            throw misuse("renovation is not in progress");
+        return r;
+    }
     get isRenovationInProgress() {
-        return this.renovation !== undefined;
+        return this.renovation$ !== undefined;
     }
     get count() {
         var _a, _b;
-        return this.items$.count + ((_b = (_a = this.renovation) === null || _a === void 0 ? void 0 : _a.lostItemCount) !== null && _b !== void 0 ? _b : 0);
+        return this.items$.count + ((_b = (_a = this.renovation$) === null || _a === void 0 ? void 0 : _a.lostItemCount) !== null && _b !== void 0 ? _b : 0);
     }
     items() {
         return this.items$.items();
@@ -48,16 +54,16 @@ export class LinkedList {
         LinkedList.remove$(this, item);
     }
     beginRenovation(diff) {
-        if (this.renovation !== undefined)
+        if (this.renovation$ !== undefined)
             throw misuse("renovation is in progress already");
         const former = this.items$;
         const renovation = new LinkedListRenovation(this, former, diff);
         this.items$ = new LinkedSubList();
-        this.renovation = renovation;
+        this.renovation$ = renovation;
         return renovation;
     }
     endRenovation(error) {
-        const renovation = this.renovation;
+        const renovation = this.renovation$;
         if (renovation === undefined)
             throw misuse("renovation is ended already");
         const items = this.items$;
@@ -77,7 +83,8 @@ export class LinkedList {
                 LinkedItem.setStatus$(x, Mark.prolonged, items.count);
             }
         }
-        this.renovation = undefined;
+        this.renovation$ = undefined;
+        return renovation;
     }
     static move$(list, item, before) {
         LinkedItem.link$(list.items$, item, before);

package/package.json

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