reactronic 0.92.25005 → 0.92.25007

package/README.md

@@ -13,23 +13,28 @@ Reactronic is an experimental JavaScript library that provides
 [transactional reactive](https://blog.nezaboodka.com/post/2019/593-modern-database-should-natively-support-transactionally-reactive-programming)
 state management in a Web application.
 
-Transactional reactivity means that state changes are being made in an
-isolated data snapshot and then, once atomically applied, are
-**consistently propagated** to corresponding visual components for
-(re)rendering. All that is done in automatic, seamless, and fine-grained
+Transactional reactivity means that state changes are
+being made in an isolated data snapshot and then, once
+atomically applied, are **consistently propagated** to
+corresponding visual components for (re)rendering. All
+that is done in automatic, seamless, and fine-grained
 way. Reactronic **takes full care of tracking dependencies**
-between visual components (observers) and state (observable objects).
-
-Transactional reactivity is based on four fundamental concepts:
-
-  - **Observable Objects** - a set of objects that store data of an
-    application (state);
-  - **Atomic Action** - a function that makes changes in observable
-    objects in atomic way ("all or nothing");
-  - **Reaction** - a function that is executed automatically in
-    response to changes made by a transaction;
-  - **Cache** -  a function which result is remembered and, if the becomes
-  obsolete, recomputed on-demand.
+between visual components (observers) and state
+(observable objects).
+
+Transactional reactivity is based on four fundamental
+concepts:
+
+  - **Observable Objects** - a set of objects that store
+    data of an application (state);
+  - **Atomic Action** - 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.
 
 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.
@@ -51,7 +56,7 @@ class Demo extends ObservableObject {
     this.email = email
   }
 
-  @reaction
+  @reactiveProcess
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -63,25 +68,26 @@ 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 reactions and caches. Reaction
-`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 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`.
 
-Here is an example of a cached value (re-)computed on-demand:
+Here is an example of a cached result that is
+(re-)computed on-demand:
 
 ``` typescript
 class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @cache
+  @cachedResult
   get contact(): string {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reaction
+  @reactiveProcess
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -89,19 +95,22 @@ class Demo extends ObservableObject {
 }
 ```
 
-In the example above, the value of `contact` is computed from
-source fields `name` and `email` upon first use. Once computed,
-the result is cached and is reused until source fields `name`
-and `email` are changed. Once source fields changed, `contact`
-value becomes obsolete, thus causing execution of depending
-reaction function `printContact`. When `printContact` function
-runs it reads `contact` and causes its re-computation.
+In the example above, the result of `contact` getter is
+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
+`printContact` runs it reads `contact` and causes its
+re-computation.
 
 ## Observable Objects
 
-Observable objects store data of an application. All such objects
-are transparently hooked to track access to their properties,
-both on reads and writes.
+Observable objects are aimed to store data of an
+application. All such objects are transparently hooked
+to track access to their properties, both on reads and
+writes.
 
 ``` typescript
 class MyModel extends ObservableObject {
@@ -111,18 +120,18 @@ class MyModel extends ObservableObject {
 }
 ```
 
-In the example above, the class `MyModel` is based on Reactronic's
-`ObservableObject` class and all its properties `url`, `content`,
-and `timestamp` are hooked.
+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 action makes changes in observable objects
-in transactional (atomic) way, thus provoking execution
-of dependent reactions and recalculation of dependent
-caches. Atomic action function is instrumented with
-hooks to provide transparent atomicity (by implicit
-context switching and isolation).
+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
+(by implicit context switching and isolation).
 
 ``` typescript
 class MyModel extends ObservableObject {
@@ -137,48 +146,53 @@ class MyModel extends ObservableObject {
 ```
 
 In the example above, the atomic action `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 completion.
-
-Atomicity is achieved by making changes in an isolated data
-snapshot that is not visible outside of the running transaction
-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 transaction.
-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
-transaction failure, because all the changes made by the transaction
-in its logical snapshot are simply discarded. In case the transaction
-is successfully applied, affected caches 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 transaction execution. The transaction may consist of a set of
-asynchronous calls prolonging the transaction until completion of
-all of them. An asynchronous call may spawn other asynchronous
-calls, which prolong transaction execution until the whole chain
-of asynchronous operations is fully completed.
-
-## Reaction & Cache
-
-Reaction function is automatically and immediately called in
-response to changes in observable objects made by an atomic action.
-Cache function is called on-demand to renew the value if it was
-marked as obsolete due to changes made by an atomic action.
-Reaction and cache functions are instrumented with hooks
-to seamlessly subscribe to those observable objects and
-other cache functions (dependencies), which are used
-during their execution.
+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
+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
+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
+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
+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
+may consist of a set of asynchronous calls prolonging
+the action 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 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.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cache
+  @cachedResult
   render(): React.JSX.Element {
     return (
       <div>
@@ -192,72 +206,84 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cache
+  @cachedResult
   render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
 
-  @reaction // called immediately in response to changes
+  @reactiveProcess // called in response to changes
   ensureUpToDate(): void {
-    if (this.shouldComponentUpdate())
-      Transaction.outside(() => this.setState({})) // ask React to re-render
-  } // ensureUpToDate is subscribed to render
+    if (this.shouldComponentUpdate()) {
+      // Ask React to re-render
+      Transaction.outside(() => this.setState({}))
+    }
+  } // EnsureUpToDate is subscribed to render
 
   shouldComponentUpdate(): boolean {
-    return !RxSystem.getController(this.render).isUpToDate
+    const r = ReactiveSystem.getController(this.render)
+    return !r.isUpToDate
   }
 
   componentDidMount(): void {
-    this.ensureUpToDate() // run to subscribe for the first time
+    // Run to subscribe for the first time
+    this.ensureUpToDate()
   }
 
   componentWillUnmount(): void {
-    atomicAction(RxSystem.dispose, this)
+    atomicAction(ReactiveSystem.dispose, this)
   }
 }
 ```
 
-In the example above, reaction function `refresh` is transparently subscribed
-to the cache function `render`. In turn, cache function `render` is
-subscribed to the properties `url` and `content` of a corresponding
-`MyModel` object. Once `url` or `content` values are changed, the
-`render` cache becomes obsolete and causes the reaction function `refresh` to become
-obsolete as well and re-executed. While being executed, the reaction function `refresh`
-enqueues re-rendering request to React, which calls
-`render` function causing it to renew its cached value.
-
-In general case, all reactions and caches are automatically and
-immediately marked as obsolete when changes are made in those observable
-objects and other cached functions that were used during their execution.
-And once marked, the functions are automatically executed again,
-either immediately (for reaction functions) or on-demand
-(for cache functions).
-
-Reactronic takes full care of tracking dependencies between
-all the observable objects and reaction/caches.
-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.
+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
+`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
+automatically executed again, either immediately (for
+reactive processes) or on-demand (for cached results).
+
+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.
 
 ## Behavior Options
 
-There are multiple options to configure behavior of transactional reactivity.
+There are multiple options to configure behavior of
+transactional reactivity.
 
-**Order** options defines order of execution for reactions:
+**Order** options defines order of execution for
+reactive processes:
 
   - (TBD)
 
-**Throttling** option defines how often reaction is executed in case
-of recurring changes:
+**Throttling** option defines how often reactive process
+is executed in case of recurring changes:
 
   - `(ms)` - minimal delay in milliseconds between executions;
-  - `-1` - execute immediately once transaction is applied (synchronously);
+  - `-1` - execute immediately once atomic action 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 reactions:
+actions and reactive processes:
 
   - `preventWithError` - fail with error if there is an existing call in progress;
   - `waitAndRestart` - wait for previous call to finish and then restart current one;
@@ -267,8 +293,8 @@ actions and reactions:
 
 **Indicator** is an object that maintains status of running functions,
 which it is attached to. A single indicator object can be shared between
-multiple transactional, reactive, and cached functions, thus maintaining
-consolidated status for all of them (busy, workers, etc).
+multiple atomic actions, reactive processes, and cached results, thus
+maintaining consolidated status for all of them (busy, workers, etc).
 
 ## Notes
 
@@ -306,8 +332,8 @@ class ObservableObject { }
 function observable(proto, prop) // field only
 function unobservable(proto, prop) // field only
 function atomicAction(proto, prop, pd) // method only
-function reaction(proto, prop, pd) // method only
-function cache(proto, prop, pd) // method only
+function reactiveProcess(proto, prop, pd) // method only
+function cachedResult(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
 function nonreactive<T>(func: F<T>, ...args: any[]): T
@@ -338,9 +364,9 @@ type MemberOptions = {
 
 enum Kind {
   plain = 0,
-  transaction = 1,
-  reaction = 2,
-  cache = 3
+  atomicAction = 1,
+  reactiveProcess = 2,
+  cachedResult = 3
 }
 
 enum Reentrance {

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

@@ -25,9 +25,9 @@ export type MemberOptions = {
 };
 export declare enum Kind {
     plain = 0,
-    apply = 1,
-    reaction = 2,
-    cache = 3
+    atomicAction = 1,
+    reactiveProcess = 2,
+    cachedResult = 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["apply"] = 1] = "apply";
-    Kind[Kind["reaction"] = 2] = "reaction";
-    Kind[Kind["cache"] = 3] = "cache";
+    Kind[Kind["atomicAction"] = 1] = "atomicAction";
+    Kind[Kind["reactiveProcess"] = 2] = "reactiveProcess";
+    Kind[Kind["cachedResult"] = 3] = "cachedResult";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

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

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

package/build/dist/source/Reaction.js

@@ -8,8 +8,8 @@ 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 { reaction } from "./ReactiveSystem.js";
-export class Reaction extends ObservableObject {
+import { reactiveProcess } from "./ReactiveSystem.js";
+export class ReactiveProcess extends ObservableObject {
     constructor(action) {
         super();
         this.action = action;
@@ -19,8 +19,8 @@ export class Reaction extends ObservableObject {
     }
 }
 __decorate([
-    reaction,
+    reactiveProcess,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], Reaction.prototype, "launch", null);
+], ReactiveProcess.prototype, "launch", null);

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

@@ -17,16 +17,14 @@ export declare class ReactiveSystem {
     static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
+export declare function atomically<T>(func: F<T>, ...args: any[]): T;
+export declare function atomically<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
 export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
-export declare function nonreactive2<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
-export declare function nonreactive2<T>(func: F<T>, ...args: any[]): T;
 export declare function sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
 export declare function contextually<T>(p: Promise<T>): Promise<T>;
-export declare function atomicAction<T>(func: F<T>, ...args: any[]): T;
-export declare function atomicAction<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
-export declare function atomicAction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function unobservable(proto: object, prop: PropertyKey): any;
 export declare function observable(proto: object, prop: PropertyKey): any;
-export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
-export declare function cache(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function atomicAction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function reactiveProcess(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function cachedResult(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function options(value: Partial<MemberOptions>): F<any>;

package/build/dist/source/ReactiveSystem.js

@@ -22,53 +22,28 @@ export class ReactiveSystem {
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
-export function nonreactive(func, ...args) {
-    return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
-}
-export function nonreactive2(p1, p2, p3) {
-    if (p1 instanceof Function) {
-        return OperationImpl.proceedWithinGivenLaunch(undefined, () => {
-            if (p2 !== undefined)
-                return Transaction.run(null, p1, ...p2);
-            else
-                return Transaction.run(null, p1);
-        });
-    }
-    else {
-        return OperationImpl.proceedWithinGivenLaunch(undefined, () => {
-            if (p3 !== undefined)
-                return Transaction.run(p1, p2, ...p3);
-            else
-                return Transaction.run(p1, p2);
-        });
-    }
-}
-export function sensitive(sensitivity, func, ...args) {
-    return Mvcc.sensitive(sensitivity, func, ...args);
-}
-export function contextually(p) {
-    throw new Error("not implemented yet");
-}
-export function atomicAction(p1, p2, p3) {
+export function atomically(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
         else
             return Transaction.run(null, p1);
     }
-    else if (p2 instanceof Function) {
+    else {
         if (p3 !== undefined)
             return Transaction.run(p1, p2, ...p3);
         else
             return Transaction.run(p1, p2);
     }
-    else {
-        const opts = {
-            kind: Kind.apply,
-            isolation: Isolation.joinToCurrentTransaction,
-        };
-        return Mvcc.decorateOperation(true, atomicAction, opts, p1, p2, p3);
-    }
+}
+export function nonreactive(func, ...args) {
+    return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
+}
+export function sensitive(sensitivity, func, ...args) {
+    return Mvcc.sensitive(sensitivity, func, ...args);
+}
+export function contextually(p) {
+    throw new Error("not implemented yet");
 }
 export function unobservable(proto, prop) {
     return Mvcc.decorateData(false, proto, prop);
@@ -76,21 +51,28 @@ export function unobservable(proto, prop) {
 export function observable(proto, prop) {
     return Mvcc.decorateData(true, proto, prop);
 }
-export function reaction(proto, prop, pd) {
+export function atomicAction(proto, prop, pd) {
+    const opts = {
+        kind: Kind.atomicAction,
+        isolation: Isolation.joinToCurrentTransaction,
+    };
+    return Mvcc.decorateOperation(true, atomicAction, opts, proto, prop, pd);
+}
+export function reactiveProcess(proto, prop, pd) {
     const opts = {
-        kind: Kind.reaction,
+        kind: Kind.reactiveProcess,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
-    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reactiveProcess, opts, proto, prop, pd);
 }
-export function cache(proto, prop, pd) {
+export function cachedResult(proto, prop, pd) {
     const opts = {
-        kind: Kind.cache,
+        kind: Kind.cachedResult,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };
-    return Mvcc.decorateOperation(true, cache, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cachedResult, opts, proto, prop, pd);
 }
 export function options(value) {
     return Mvcc.decorateOperationParametrized(options, value);

package/build/dist/source/Ref.js

@@ -1,4 +1,4 @@
-import { atomicAction, nonreactive } from "./ReactiveSystem.js";
+import { atomically, nonreactive } from "./ReactiveSystem.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -52,7 +52,7 @@ export class ToggleRef extends Ref {
     toggle() {
         const o = this.owner;
         const p = this.name;
-        atomicAction({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        atomically({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
             const v = o[p];
             const isOn = v === this.valueOn || (v instanceof Ref && this.valueOn instanceof Ref &&
                 Ref.sameRefs(v, this.valueOn));

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

@@ -16,8 +16,9 @@ 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 { ReactiveSystem, observable, unobservable, atomicAction, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
-export { Reaction } from "./Reaction.js";
+export { atomically, nonreactive, sensitive, contextually } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, atomicAction, reactiveProcess, cachedResult, options } from "./ReactiveSystem.js";
+export { ReactiveProcess } from "./Reaction.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

@@ -12,7 +12,8 @@ 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 { ReactiveSystem, observable, unobservable, atomicAction, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
-export { Reaction } from "./Reaction.js";
+export { atomically, nonreactive, sensitive, contextually } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, atomicAction, reactiveProcess, cachedResult, options } from "./ReactiveSystem.js";
+export { ReactiveProcess } from "./Reaction.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";
 export { Clock } from "./Clock.js";

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.apply && launch.cause !== BOOT_CAUSE &&
+        const isReusable = launch.options.kind !== Kind.atomicAction && 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.apply || !ror.isReusable) {
+                if (ror.launch.options.kind === Kind.atomicAction || !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.apply)
+        else if (this.operation.options.kind === Kind.atomicAction)
             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.reaction;
+                const isReactive = this.options.kind === Kind.reactiveProcess;
                 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.reaction)
+                            if (launch.options.kind === Kind.reactiveProcess)
                                 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.reaction)
+                    else if (this.options.kind === Kind.reactiveProcess)
                         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.apply ||
+        return !this.error && (this.options.kind === Kind.atomicAction ||
             !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.apply) {
+        if (kind !== Kind.atomicAction) {
             const launch = Launch.current;
-            if (launch && launch.options.kind !== Kind.apply &&
+            if (launch && launch.options.kind !== Kind.atomicAction &&
                 launch.transaction === Transaction.current && fk !== Meta.Handle) {
                 const ctx = Changeset.current();
                 if (ctx !== ov.changeset)
@@ -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.reaction && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        if (launch.options.kind === Kind.reactiveProcess && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
             reactive[fk] = launch;
         }
-        else if (launch.options.kind === Kind.reaction && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.reactiveProcess && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.getFrom(proto, Meta.Reactive);
             delete reactive[fk];
         }

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

@@ -22,7 +22,7 @@ import { emitLetters, getCallerInfo, proceedSyncOrAsync } from "../util/Utils.js
 import { Isolation, Reentrance } from "../Options.js";
 import { ObservableObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, unobservable, reaction, nonreactive, atomicAction } from "../ReactiveSystem.js";
+import { ReactiveSystem, options, unobservable, reactiveProcess, atomically, nonreactive } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -339,7 +339,7 @@ class ReactiveNodeImpl extends ReactiveNode {
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            atomicAction({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            atomically({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
@@ -359,7 +359,7 @@ ReactiveNodeImpl.logging = undefined;
 ReactiveNodeImpl.grandNodeCount = 0;
 ReactiveNodeImpl.disposableNodeCount = 0;
 __decorate([
-    reaction,
+    reactiveProcess,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,
@@ -546,7 +546,7 @@ function triggerFinalization(slot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = slot;
             if (gFirstToDispose === slot)
-                atomicAction({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
+                atomically({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

package/package.json

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