reactronic 0.92.25008 → 0.92.25010

package/README.md

@@ -27,14 +27,14 @@ concepts:
 
   - **Observable Objects** - a set of objects that store
     data of an application (state);
-  - **Atomic Action** - a function that makes changes in
+  - **Atomic Function** - a function that makes changes in
     observable objects in atomic way ("all or nothing");
-  - **Reactive Process** - recurrent and automatic
-    (re-)execution of a function in response to changes
-    made by atomic actions;
-  - **Cached Result** -  result value of a function that
-    is remembered and, if the becomes obsolete, causes
-    its function to re-execute on-demand.
+  - **Reactive Function** - a function that is
+    (re-)executed in response to changes made by atomic
+    actions;
+  - **Cached Function** -  a function which result is
+    remembered and, if becomes obsolete, causes function
+    to re-execute on-demand.
 
 Demo application built with Reactronic: https://nevod.io/#/playground.
 Source code of the demo: https://gitlab.com/nezaboodka/nevod.web.public/-/blob/master/README.md.
@@ -50,13 +50,13 @@ class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @atomicAction
+  @atomic
   saveContact(name: string, email: string): void {
     this.name = name
     this.email = email
   }
 
-  @reactiveProcess
+  @reactive
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -68,11 +68,11 @@ class Demo extends ObservableObject {
 
 In the example above, `Demo` is an observable object,
 meaning that access to its fields are seamlessly tracked
-to determine dependent reactive processes and cached
-results. Reactive process `printContact` reads `name`
-and `email` fields, thus depends on them. It is executed
-automatically in response to changes of these fields
-made by the atomic action `saveContact`.
+to determine dependent reactive and cached functions.
+Reactive function `printContact` reads `name` and `email`
+fields, thus depends on them. It is executed automatically
+in response to changes of these fields made by the atomic
+function `saveContact`.
 
 Here is an example of a cached result that is
 (re-)computed on-demand:
@@ -87,7 +87,7 @@ class Demo extends ObservableObject {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reactiveProcess
+  @reactive
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -100,8 +100,8 @@ computed from source fields `name` and `email`. Once
 computed, the result is cached and is reused until
 source fields `name` and `email` are changed. Once
 source fields changed, `contact` result becomes obsolete,
-thus causing execution of depending reactive process
-`printContact`. When function of reactive process
+thus causing execution of depending reactive function
+`printContact`. When function of reactive function
 `printContact` runs it reads `contact` and causes its
 re-computation.
 
@@ -124,19 +124,18 @@ In the example above, the class `MyModel` is based on
 Reactronic's `ObservableObject` class and all its
 properties `url`, `content`, and `timestamp` are hooked.
 
-## Atomic Action
+## Atomic Function
 
-Atomic action makes changes in observable objects
+Atomic function makes changes in observable objects
 in atomic (transactional) way, thus provoking execution
-of dependent reactive processes and recalculation of
-dependent cached results. Atomic action function is
-instrumented with hooks to provide transparent atomicity
+of dependent reactive and cached functions. Atomic
+function is instrumented with hooks to provide transparent atomicity
 (by implicit context switching and isolation).
 
 ``` typescript
 class MyModel extends ObservableObject {
   // ...
-  @atomicAction
+  @atomic
   async load(url: string): Promise<void> {
     this.url = url
     this.content = await fetch(url)
@@ -145,50 +144,50 @@ class MyModel extends ObservableObject {
 }
 ```
 
-In the example above, the atomic action `load` makes
+In the example above, the atomic function `load` makes
 changes to `url`, `content` and `timestamp` properties.
-While atomic action is running, the changes are visible
-only inside the action itself. The new values become
-atomically visible outside of the action only upon its
+While atomic function is running, the changes are visible
+only inside the function itself. The new values become
+atomically visible outside of the function only upon its
 completion.
 
 Atomicity is achieved by making changes in an isolated
 data snapshot that is not visible outside of the running
-action until it is fully finished and applied. Multiple
+function until it is fully finished and applied. Multiple
 objects and their properties can be changed with full
 respect to the all-or-nothing principle. To do so,
 separate data snapshot is automatically maintained for
-each atomic action. That is a logical snapshot that does
+each atomic function. That is a logical snapshot that does
 not create a full copy of all the data.
 
 Compensating rollback operations are not needed in case
-of the atomic action failure, because all the changes
-made by the atomic action in its logical snapshot are
-simply discarded. In case the atomic action is
+of the atomic function failure, because all the changes
+made by the atomic function in its logical snapshot are
+simply discarded. In case the atomic function is
 successfully applied, affected cached results are marked
 as obsolete and corresponding caching functions are
 re-executed in a proper order (but only when all the
 data changes are fully applied).
 
 Asynchronous operations (promises) are supported out of
-the box during atomic action execution. Atomic action
+the box during atomic function execution. Atomic function
 may consist of a set of asynchronous calls prolonging
-the action until completion of all of them. An
+the function until completion of all of them. An
 asynchronous call may spawn other asynchronous calls,
 which prolong atomic atomic execution until the whole
 chain of asynchronous operations is fully completed.
 
-## Reactive Process & Cached Result
+## Reactive & Cached Functions
 
-Reactive process function is automatically and
-immediately called in response to changes in observable
-objects made by atomic actions. Function of cached result
-is called on-demand to renew the result if it was marked
-as obsolete due to changes made by an atomic action.
-Functions of reactive processes and cached results are
-instrumented with hooks to seamlessly subscribe to those
-observable objects and other cached results
-(dependencies), which are used during their execution.
+Reactive function is automatically and immediately called
+in response to changes in observable objects made by
+atomic functions. Cached function is called on-demand to
+renew the result if it was marked as obsolete due to
+changes made by an atomic functions. Reactive and cached
+functions are instrumented with hooks to seamlessly
+subscribe to those observable objects and other cached
+functions (dependencies), which are used during their
+execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
@@ -211,7 +210,7 @@ class Component<P> extends React.Component<P> {
     throw new Error('render method is undefined')
   }
 
-  @reactiveProcess // called in response to changes
+  @reactive // called in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate()) {
       // Ask React to re-render
@@ -235,34 +234,32 @@ class Component<P> extends React.Component<P> {
 }
 ```
 
-In the example above, reactive process `refresh` is
-transparently subscribed to the cached result of
-function `render`. In turn, cached result of function
-`render` is subscribed to the properties `url` and
-`content` of a corresponding `MyModel` object. Once
-`url` or `content` values are changed, the `render`
-cached result becomes obsolete and causes the reactive
-process `refresh` to become obsolete and re-executed.
-While being executed, the reactive process function
+In the example above, reactive function `refresh` is
+transparently subscribed to the cached function `render`.
+In turn, cached function `render` is subscribed to the
+properties `url` and `content` of a corresponding `MyModel`
+object. Once `url` or `content` values are changed, the
+cached function `render` becomes obsolete and causes the
+reactive function `refresh` to become obsolete and
+re-executed. While being executed, the reactive function
 `refresh` enqueues re-rendering request to React, which
-calls `render` function causing it to renew its cached
-value.
-
-In general case, all reactive processes and cached
-results are automatically and immediately marked as
-obsolete when changes are made in those observable
-objects and other cached results that were used during
-their execution. And once marked, the functions are
+calls cached function `render` causing it to renew its
+cached value.
+
+In general case, all reactive and cached functions
+are automatically and immediately marked as obsolete
+when changes are made in those observable objects and
+other cached results that were used during their
+execution. And once marked, the functions are
 automatically executed again, either immediately (for
-reactive processes) or on-demand (for cached results).
+reactive functions) or on-demand (for cached functions).
 
 Reactronic takes full care of tracking dependencies
-between all the observable objects and reactive processes
-or cached results. With Reactronic, you no longer need
-to create data change events in one set of objects,
-subscribe to these events in other objects, and manually
-maintain switching from the previous object version to a
-new one.
+between all the observable objects and reactive/cached
+functions. With Reactronic, you no longer need to create
+data change events in one set of objects, subscribe to
+these events in other objects, and manually maintain
+switching from the previous object version to a new one.
 
 ## Behavior Options
 
@@ -270,20 +267,20 @@ There are multiple options to configure behavior of
 transactional reactivity.
 
 **Order** options defines order of execution for
-reactive processes:
+reactive functions:
 
   - (TBD)
 
-**Throttling** option defines how often reactive process
+**Throttling** option defines how often reactive function
 is executed in case of recurring changes:
 
   - `(ms)` - minimal delay in milliseconds between executions;
-  - `-1` - execute immediately once atomic action is applied (synchronously);
+  - `-1` - execute immediately once atomic function is applied (synchronously);
   - `0` - execute immediately via event loop (asynchronously with zero timeout);
   - `>= Number.MAX_SAFE_INTEGER` - never execute (suspended reaction).
 
 **Reentrance** option defines how to handle reentrant calls of atomic
-actions and reactive processes:
+and reactive functions:
 
   - `preventWithError` - fail with error if there is an existing call in progress;
   - `waitAndRestart` - wait for previous call to finish and then restart current one;
@@ -293,8 +290,8 @@ actions and reactive processes:
 
 **Indicator** is an object that maintains status of running functions,
 which it is attached to. A single indicator object can be shared between
-multiple atomic actions, reactive processes, and cached results, thus
-maintaining consolidated status for all of them (busy, workers, etc).
+multiple atomic, reactive, and cached functions, thus maintaining
+consolidated status for all of them (busy, workers, etc).
 
 ## Notes
 
@@ -331,13 +328,13 @@ class ObservableObject { }
 
 function observable(proto, prop) // field only
 function unobservable(proto, prop) // field only
-function atomicAction(proto, prop, pd) // method only
-function reactiveProcess(proto, prop, pd) // method only
-function cachedResult(proto, prop, pd) // method only
+function atomic(proto, prop, pd) // method only
+function reactive(proto, prop, pd) // method only
+function cached(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
-function nonreactive<T>(func: F<T>, ...args: any[]): T
-function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
+function nonReactiveRun<T>(func: F<T>, ...args: any[]): T
+function sensitiveRun<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 // SnapshotOptions, MemberOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
 
@@ -364,9 +361,9 @@ type MemberOptions = {
 
 enum Kind {
   plain = 0,
-  atomicAction = 1,
-  reactiveProcess = 2,
-  cachedResult = 3
+  atomic = 1,
+  reactive = 2,
+  cached = 3
 }
 
 enum Reentrance {

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

@@ -9,4 +9,6 @@ export declare class Clock extends ObservableObject {
     constructor(interval?: number);
     pause(value?: boolean): void;
     private tick;
+    protected activate(): void;
+    private put;
 }

package/build/dist/source/Clock.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { ObservableObject } from "./core/Mvcc.js";
-import { atomic } from "./ReactiveSystem.js";
+import { atomic, reactive } from "./ReactiveSystem.js";
 export class Clock extends ObservableObject {
     constructor(interval = 1000) {
         super();
@@ -19,7 +19,7 @@ export class Clock extends ObservableObject {
         this.interval = 0;
         this.paused = false;
         this.interval = interval;
-        this.tick();
+        this.put(new Date());
     }
     pause(value = true) {
         this.paused = value;
@@ -28,16 +28,22 @@ export class Clock extends ObservableObject {
         let calibration = 0;
         try {
             const now = new Date();
-            this.hour = now.getHours();
-            this.minute = now.getMinutes();
-            this.second = now.getSeconds();
-            this.ms = now.getMilliseconds();
+            this.put(now);
             calibration = now.getTime() % this.interval;
         }
         finally {
             setTimeout(() => this.tick(), this.interval - calibration);
         }
     }
+    activate() {
+        this.tick();
+    }
+    put(time) {
+        this.hour = time.getHours();
+        this.minute = time.getMinutes();
+        this.second = time.getSeconds();
+        this.ms = time.getMilliseconds();
+    }
 }
 __decorate([
     atomic,
@@ -51,3 +57,9 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], Clock.prototype, "tick", null);
+__decorate([
+    reactive,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Clock.prototype, "activate", null);

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

@@ -25,9 +25,9 @@ export type MemberOptions = {
 };
 export declare enum Kind {
     plain = 0,
-    atomicAction = 1,
-    reactiveProcess = 2,
-    cachedResult = 3
+    atomic = 1,
+    reactive = 2,
+    cached = 3
 }
 export declare enum Reentrance {
     preventWithError = 1,

package/build/dist/source/Options.js

@@ -2,9 +2,9 @@ export { LoggingLevel } from "./Logging.js";
 export var Kind;
 (function (Kind) {
     Kind[Kind["plain"] = 0] = "plain";
-    Kind[Kind["atomicAction"] = 1] = "atomicAction";
-    Kind[Kind["reactiveProcess"] = 2] = "reactiveProcess";
-    Kind[Kind["cachedResult"] = 3] = "cachedResult";
+    Kind[Kind["atomic"] = 1] = "atomic";
+    Kind[Kind["reactive"] = 2] = "reactive";
+    Kind[Kind["cached"] = 3] = "cached";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

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

@@ -0,0 +1,7 @@
+import { F } from "./util/Utils.js";
+import { ObservableObject } from "./core/Mvcc.js";
+export declare class ReactiveLoop<T> extends ObservableObject {
+    protected reactiveFunction: F<T>;
+    constructor(reactiveFunction: F<T>);
+    protected launch(): T;
+}

package/build/dist/source/{Reaction.js → ReactiveLoop.js}

@@ -9,13 +9,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { ObservableObject } from "./core/Mvcc.js";
 import { reactive } from "./ReactiveSystem.js";
-export class ReactiveProcess extends ObservableObject {
-    constructor(action) {
+export class ReactiveLoop extends ObservableObject {
+    constructor(reactiveFunction) {
         super();
-        this.action = action;
+        this.reactiveFunction = reactiveFunction;
     }
     launch() {
-        return this.action();
+        return this.reactiveFunction();
     }
 }
 __decorate([
@@ -23,4 +23,4 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], ReactiveProcess.prototype, "launch", null);
+], ReactiveLoop.prototype, "launch", null);

package/build/dist/source/ReactiveSystem.js

@@ -53,14 +53,14 @@ export function observable(proto, prop) {
 }
 export function atomic(proto, prop, pd) {
     const opts = {
-        kind: Kind.atomicAction,
+        kind: Kind.atomic,
         isolation: Isolation.joinToCurrentTransaction,
     };
     return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
 }
 export function reactive(proto, prop, pd) {
     const opts = {
-        kind: Kind.reactiveProcess,
+        kind: Kind.reactive,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
@@ -68,7 +68,7 @@ export function reactive(proto, prop, pd) {
 }
 export function cached(proto, prop, pd) {
     const opts = {
-        kind: Kind.cachedResult,
+        kind: Kind.cached,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };

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

@@ -18,7 +18,7 @@ export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
 export { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
 export { ReactiveSystem, observable, unobservable, atomic, reactive, cached, options } from "./ReactiveSystem.js";
-export { ReactiveProcess } from "./Reaction.js";
+export { ReactiveLoop } from "./ReactiveLoop.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export type { Script, ScriptAsync, Handler, ReactiveNodeDecl, ReactiveNodeDriver, ReactiveNodeContext } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

package/build/dist/source/api.js

@@ -14,6 +14,6 @@ export { Indicator } from "./core/Indicator.js";
 export { Journal } from "./core/Journal.js";
 export { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
 export { ReactiveSystem, observable, unobservable, atomic, reactive, cached, options } from "./ReactiveSystem.js";
-export { ReactiveProcess } from "./Reaction.js";
+export { ReactiveLoop } from "./ReactiveLoop.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

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

@@ -30,7 +30,7 @@ export declare class IndicatorImpl extends Indicator {
     whenIdle(): Promise<void>;
     enter(worker: Worker): void;
     leave(worker: Worker): void;
-    static create(hint: string, activationDelay: number, deactivationDelay: number, durationResolution: number): IndicatorImpl;
+    static createImpl(hint: string, activationDelay: number, deactivationDelay: number, durationResolution: number): IndicatorImpl;
     static enter(mon: IndicatorImpl, worker: Worker): void;
     static leave(mon: IndicatorImpl, worker: Worker): void;
     private static doCreate;

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

@@ -12,7 +12,7 @@ import { ObservableObject, Mvcc } from "./Mvcc.js";
 import { Transaction } from "./Transaction.js";
 export class Indicator extends ObservableObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
-        return IndicatorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
+        return IndicatorImpl.createImpl(hint, activationDelay, deactivationDelay, durationResolution);
     }
 }
 export class IndicatorImpl extends Indicator {
@@ -71,7 +71,7 @@ export class IndicatorImpl extends Indicator {
         workers.delete(worker);
         IndicatorImpl.deactivate(this, this.internals.deactivationDelay);
     }
-    static create(hint, activationDelay, deactivationDelay, durationResolution) {
+    static createImpl(hint, activationDelay, deactivationDelay, durationResolution) {
         return Transaction.run({ hint: "Indicator.create" }, IndicatorImpl.doCreate, hint, activationDelay, deactivationDelay, durationResolution);
     }
     static enter(mon, worker) {

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

@@ -99,7 +99,7 @@ export class OperationImpl {
         const ov = ctx.lookupObjectVersion(this.ownerHandle, this.fieldKey, false);
         const launch = this.acquireFromObjectVersion(ov, args);
         const applied = this.ownerHandle.applied.data[this.fieldKey];
-        const isReusable = launch.options.kind !== Kind.atomicAction && launch.cause !== BOOT_CAUSE &&
+        const isReusable = launch.options.kind !== Kind.atomic && launch.cause !== BOOT_CAUSE &&
             (ctx === launch.changeset || ctx.timestamp < launch.obsoleteSince || applied.obsoleteDueTo === undefined) &&
             (!launch.options.triggeringArgs || args === undefined ||
                 launch.args.length === args.length && launch.args.every((t, i) => t === args[i])) || ov.disposed;
@@ -175,7 +175,7 @@ export class OperationImpl {
             }
             else {
                 ror = this.peek(argsx);
-                if (ror.launch.options.kind === Kind.atomicAction || !ror.isReusable) {
+                if (ror.launch.options.kind === Kind.atomic || !ror.isReusable) {
                     ror = this.edit();
                     if (Log.isOn && Log.opt.operation)
                         Log.write("║", "  o", `${ror.launch.why()}`);
@@ -251,7 +251,7 @@ class Launch extends FieldVersion {
         let cause;
         if (this.cause)
             cause = `   ◀◀   ${this.cause}`;
-        else if (this.operation.options.kind === Kind.atomicAction)
+        else if (this.operation.options.kind === Kind.atomic)
             cause = "   ◀◀   operation";
         else
             cause = `   ◀◀   T${this.changeset.id}[${this.changeset.hint}]`;
@@ -294,7 +294,7 @@ class Launch extends FieldVersion {
                 changeset.id === this.lastEditorChangesetId;
             if (!skip) {
                 const why = `${Dump.snapshot2(h, changeset, fk, observable)}    ◀◀    ${outer}`;
-                const isReactive = this.options.kind === Kind.reactiveProcess;
+                const isReactive = this.options.kind === Kind.reactive;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 if (Log.isOn && (Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
@@ -326,14 +326,14 @@ class Launch extends FieldVersion {
                     const launch = this.operation.reuseOrRelaunch(false, undefined);
                     if (launch.result instanceof Promise)
                         launch.result.catch(error => {
-                            if (launch.options.kind === Kind.reactiveProcess)
+                            if (launch.options.kind === Kind.reactive)
                                 misuse(`reactive function ${launch.hint()} failed and will not run anymore: ${error}`, error);
                         });
                 }
                 catch (e) {
                     if (!nothrow)
                         throw e;
-                    else if (this.options.kind === Kind.reactiveProcess)
+                    else if (this.options.kind === Kind.reactive)
                         misuse(`reactive ${this.hint()} failed and will not run anymore: ${e}`, e);
                 }
             }
@@ -346,7 +346,7 @@ class Launch extends FieldVersion {
         }
     }
     isNotUpToDate() {
-        return !this.error && (this.options.kind === Kind.atomicAction ||
+        return !this.error && (this.options.kind === Kind.atomic ||
             !this.successor || this.successor.transaction.isCanceled);
     }
     reenterOver(head) {
@@ -469,9 +469,9 @@ class Launch extends FieldVersion {
             x.relaunchIfNotUpToDate(true, true);
     }
     static markUsed(observable, ov, fk, h, kind, weak) {
-        if (kind !== Kind.atomicAction) {
+        if (kind !== Kind.atomic) {
             const launch = Launch.current;
-            if (launch && launch.options.kind !== Kind.atomicAction &&
+            if (launch && launch.options.kind !== Kind.atomic &&
                 launch.transaction === Transaction.current && fk !== Meta.Handle) {
                 const ctx = Changeset.current();
                 if (ctx !== ov.changeset)
@@ -568,10 +568,10 @@ class Launch extends FieldVersion {
     }
     static enqueueReactiveFunctionsToRun(reactive) {
         const queue = Launch.queuedReactiveOperations;
-        const isReactiveLoopRequired = queue.length === 0;
+        const isKickOff = queue.length === 0;
         for (const r of reactive)
             queue.push(r);
-        if (isReactiveLoopRequired)
+        if (isKickOff)
             OperationImpl.proceedWithinGivenLaunch(undefined, Launch.processQueuedReactiveOperations);
     }
     static migrateFieldVersion(fv, target) {
@@ -652,11 +652,11 @@ class Launch extends FieldVersion {
         const rx = launch ? launch.operation : new OperationImpl(EMPTY_HANDLE, fk);
         const opts = launch ? launch.options : OptionsImpl.INITIAL;
         initial[fk] = launch = new Launch(Transaction.current, rx, EMPTY_OBJECT_VERSION.changeset, new OptionsImpl(getter, setter, opts, options, implicit), false);
-        if (launch.options.kind === Kind.reactiveProcess && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        if (launch.options.kind === Kind.reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
             reactive[fk] = launch;
         }
-        else if (launch.options.kind === Kind.reactiveProcess && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[fk];
         }

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

@@ -32,7 +32,7 @@ export declare abstract class Transaction implements Worker {
 }
 export declare class TransactionImpl extends Transaction {
     private static readonly none;
-    private static curr;
+    private static gCurr;
     private static isInspectionMode;
     private static frameStartTime;
     private static frameOverCounter;
@@ -47,7 +47,7 @@ export declare class TransactionImpl extends Transaction {
     private resolve;
     private reject;
     constructor(options: SnapshotOptions | null, parent?: TransactionImpl);
-    static get current(): TransactionImpl;
+    static get curr(): TransactionImpl;
     get id(): number;
     get hint(): string;
     get options(): SnapshotOptions;

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

@@ -13,7 +13,7 @@ import { Isolation } from "../Options.js";
 import { Meta } from "./Data.js";
 import { Changeset, Dump, EMPTY_OBJECT_VERSION, UNDEFINED_REVISION } from "./Changeset.js";
 export class Transaction {
-    static get current() { return TransactionImpl.current; }
+    static get current() { return TransactionImpl.curr; }
     whenFinished(includingParent) {
         return __awaiter(this, void 0, void 0, function* () { });
     }
@@ -23,12 +23,12 @@ export class Transaction {
     static outside(func, ...args) { return TransactionImpl.outside(func, ...args); }
     static isFrameOver(everyN = 1, timeLimit = 10) { return TransactionImpl.isFrameOver(everyN, timeLimit); }
     static requestNextFrame(sleepTime = 0) { return TransactionImpl.requestNextFrame(sleepTime); }
-    static get isCanceled() { return TransactionImpl.current.isCanceled; }
+    static get isCanceled() { return TransactionImpl.curr.isCanceled; }
 }
 export class TransactionImpl extends Transaction {
     constructor(options, parent) {
         super();
-        this.margin = TransactionImpl.curr !== undefined ? TransactionImpl.curr.margin + 1 : -1;
+        this.margin = TransactionImpl.gCurr !== undefined ? TransactionImpl.gCurr.margin + 1 : -1;
         this.parent = parent;
         this.changeset = new Changeset(options, parent === null || parent === void 0 ? void 0 : parent.changeset);
         this.pending = 0;
@@ -39,7 +39,7 @@ export class TransactionImpl extends Transaction {
         this.resolve = UNDEF;
         this.reject = UNDEF;
     }
-    static get current() { return TransactionImpl.curr; }
+    static get curr() { return TransactionImpl.gCurr; }
     get id() { return this.changeset.id; }
     get hint() { return this.changeset.hint; }
     get options() { return this.changeset.options; }
@@ -54,7 +54,7 @@ export class TransactionImpl extends Transaction {
         try {
             TransactionImpl.isInspectionMode = true;
             if (Log.isOn && Log.opt.transaction)
-                Log.write(" ", " ", `T${this.id}[${this.hint}] is being inspected by T${TransactionImpl.curr.id}[${TransactionImpl.curr.hint}]`);
+                Log.write(" ", " ", `T${this.id}[${this.hint}] is being inspected by T${TransactionImpl.gCurr.id}[${TransactionImpl.gCurr.hint}]`);
             return this.runImpl(undefined, func, ...args);
         }
         finally {
@@ -118,7 +118,7 @@ export class TransactionImpl extends Transaction {
     }
     static run(options, func, ...args) {
         const t = TransactionImpl.acquire(options);
-        const isRoot = t !== TransactionImpl.curr;
+        const isRoot = t !== TransactionImpl.gCurr;
         t.guard();
         let result = t.runImpl(options === null || options === void 0 ? void 0 : options.logging, func, ...args);
         if (isRoot) {
@@ -135,13 +135,13 @@ export class TransactionImpl extends Transaction {
         return TransactionImpl.run({ isolation: Isolation.disjoinFromOuterTransaction }, func, ...args);
     }
     static outside(func, ...args) {
-        const outer = TransactionImpl.curr;
+        const outer = TransactionImpl.gCurr;
         try {
-            TransactionImpl.curr = TransactionImpl.none;
+            TransactionImpl.gCurr = TransactionImpl.none;
             return func(...args);
         }
         finally {
-            TransactionImpl.curr = outer;
+            TransactionImpl.gCurr = outer;
         }
     }
     static isFrameOver(everyN = 1, timeLimit = 10) {
@@ -158,7 +158,7 @@ export class TransactionImpl extends Transaction {
     }
     static acquire(options) {
         var _a;
-        const outer = TransactionImpl.curr;
+        const outer = TransactionImpl.gCurr;
         const isolation = (_a = options === null || options === void 0 ? void 0 : options.isolation) !== null && _a !== void 0 ? _a : Isolation.joinToCurrentTransaction;
         if (outer.isFinished || outer.options.isolation === Isolation.disjoinFromOuterAndInnerTransactions)
             return new TransactionImpl(options);
@@ -170,7 +170,7 @@ export class TransactionImpl extends Transaction {
             return outer;
     }
     guard() {
-        if (this.sealed && TransactionImpl.curr !== this)
+        if (this.sealed && TransactionImpl.gCurr !== this)
             throw misuse("cannot run transaction that is already sealed");
     }
     wrapToRetry(p, func, ...args) {
@@ -210,14 +210,14 @@ export class TransactionImpl extends Transaction {
     }
     runImpl(logging, func, ...args) {
         let result;
-        const outer = TransactionImpl.curr;
+        const outer = TransactionImpl.gCurr;
         const p = this.parent;
         try {
             if (outer === TransactionImpl.none) {
                 TransactionImpl.frameStartTime = performance.now();
                 TransactionImpl.frameOverCounter = 0;
             }
-            TransactionImpl.curr = this;
+            TransactionImpl.gCurr = this;
             this.pending++;
             const acquired = this.changeset.acquire(outer.changeset);
             if (acquired && p)
@@ -241,11 +241,11 @@ export class TransactionImpl extends Transaction {
                 const reactive = this.applyOrDiscard();
                 if (p)
                     p.runImpl(undefined, () => p.pending--);
-                TransactionImpl.curr = outer;
+                TransactionImpl.gCurr = outer;
                 TransactionImpl.outside(Changeset.enqueueReactiveFunctionsToRun, reactive);
             }
             else
-                TransactionImpl.curr = outer;
+                TransactionImpl.gCurr = outer;
         }
         return result;
     }
@@ -457,12 +457,12 @@ export class TransactionImpl extends Transaction {
         return this.promise;
     }
     static getCurrentChangeset() {
-        return TransactionImpl.curr.changeset;
+        return TransactionImpl.gCurr.changeset;
     }
     static getEditableChangeset() {
         if (TransactionImpl.isInspectionMode)
             throw misuse("cannot make changes during transaction inspection");
-        return TransactionImpl.curr.changeset;
+        return TransactionImpl.gCurr.changeset;
     }
     static _init() {
         Changeset.current = TransactionImpl.getCurrentChangeset;
@@ -473,7 +473,7 @@ export class TransactionImpl extends Transaction {
     }
 }
 TransactionImpl.none = new TransactionImpl({ hint: "<none>" });
-TransactionImpl.curr = TransactionImpl.none;
+TransactionImpl.gCurr = TransactionImpl.none;
 TransactionImpl.isInspectionMode = false;
 TransactionImpl.frameStartTime = 0;
 TransactionImpl.frameOverCounter = 0;

package/package.json

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

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

@@ -1,7 +0,0 @@
-import { F } from "./util/Utils.js";
-import { ObservableObject } from "./core/Mvcc.js";
-export declare class ReactiveProcess<T> extends ObservableObject {
-    protected action: F<T>;
-    constructor(action: F<T>);
-    protected launch(): T;
-}