reactronic 0.92.25004 → 0.92.25005

package/README.md

@@ -24,11 +24,11 @@ Transactional reactivity is based on four fundamental concepts:
 
   - **Observable Objects** - a set of objects that store data of an
     application (state);
-  - **Applying Function** - it makes changes in observable
+  - **Atomic Action** - a function that makes changes in observable
     objects in atomic way ("all or nothing");
-  - **Reaction Function** - it is executed automatically in
+  - **Reaction** - a function that is executed automatically in
     response to changes made by a transaction;
-  - **Cache Function** - its result is remembered and, if the becomes
+  - **Cache** -  a function which result is remembered and, if the becomes
   obsolete, recomputed on-demand.
 
 Demo application built with Reactronic: https://nevod.io/#/playground.
@@ -45,7 +45,7 @@ class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @apply
+  @atomicAction
   saveContact(name: string, email: string): void {
     this.name = name
     this.email = email
@@ -64,10 +64,10 @@ 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
-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 applying
-function `saveContact`.
+`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:
 
@@ -115,19 +115,19 @@ In the example above, the class `MyModel` is based on Reactronic's
 `ObservableObject` class and all its properties `url`, `content`,
 and `timestamp` are hooked.
 
-## Apply
+## Atomic Action
 
-Applying function makes changes in observable objects
+Atomic action makes changes in observable objects
 in transactional (atomic) way, thus provoking execution
 of dependent reactions and recalculation of dependent
-caches. Applying function is instrumented with hooks to
-provide transparent atomicity (by implicit context
-switching and isolation).
+caches. Atomic action function is instrumented with
+hooks to provide transparent atomicity (by implicit
+context switching and isolation).
 
 ``` typescript
 class MyModel extends ObservableObject {
   // ...
-  @apply
+  @atomicAction
   async load(url: string): Promise<void> {
     this.url = url
     this.content = await fetch(url)
@@ -136,11 +136,11 @@ class MyModel extends ObservableObject {
 }
 ```
 
-In the example above, the applying function `load` makes
+In the example above, the atomic action `load` makes
 changes to `url`, `content` and `timestamp` properties. While
-applying transaction is running, the changes are visible only inside the
-transaction itself. The new values become atomically visible outside
-of the transaction only upon its completion.
+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
@@ -168,9 +168,9 @@ 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 applying function.
+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 applying function.
+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
@@ -212,7 +212,7 @@ class Component<P> extends React.Component<P> {
   }
 
   componentWillUnmount(): void {
-    apply(RxSystem.dispose, this)
+    atomicAction(RxSystem.dispose, this)
   }
 }
 ```
@@ -256,8 +256,8 @@ of recurring changes:
   - `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 applying
-and reaction functions:
+**Reentrance** option defines how to handle reentrant calls of atomic
+actions and reactions:
 
   - `preventWithError` - fail with error if there is an existing call in progress;
   - `waitAndRestart` - wait for previous call to finish and then restart current one;
@@ -305,7 +305,7 @@ class ObservableObject { }
 
 function observable(proto, prop) // field only
 function unobservable(proto, prop) // field only
-function apply(proto, prop, pd) // method only
+function atomicAction(proto, prop, pd) // method only
 function reaction(proto, prop, pd) // method only
 function cache(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>

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 { apply } from "./ReactiveSystem.js";
+import { atomicAction } from "./ReactiveSystem.js";
 export class Clock extends ObservableObject {
     constructor(interval = 1000) {
         super();
@@ -40,13 +40,13 @@ export class Clock extends ObservableObject {
     }
 }
 __decorate([
-    apply,
+    atomicAction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Boolean]),
     __metadata("design:returntype", void 0)
 ], Clock.prototype, "pause", null);
 __decorate([
-    apply,
+    atomicAction,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)

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

@@ -18,11 +18,13 @@ export declare class ReactiveSystem {
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
 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 apply<T>(func: F<T>, ...args: any[]): T;
-export declare function apply<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
-export declare function apply(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+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;

package/build/dist/source/ReactiveSystem.js

@@ -25,13 +25,31 @@ export class ReactiveSystem {
 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 apply(p1, p2, p3) {
+export function atomicAction(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
@@ -49,7 +67,7 @@ export function apply(p1, p2, p3) {
             kind: Kind.apply,
             isolation: Isolation.joinToCurrentTransaction,
         };
-        return Mvcc.decorateOperation(true, apply, opts, p1, p2, p3);
+        return Mvcc.decorateOperation(true, atomicAction, opts, p1, p2, p3);
     }
 }
 export function unobservable(proto, prop) {

package/build/dist/source/Ref.js

@@ -1,4 +1,4 @@
-import { apply, nonreactive } from "./ReactiveSystem.js";
+import { atomicAction, 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;
-        apply({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        atomicAction({ 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,7 +16,7 @@ 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, apply, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, atomicAction, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
 export { Reaction } 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";

package/build/dist/source/api.js

@@ -12,7 +12,7 @@ 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, apply, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, atomicAction, reaction, cache, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.js";
 export { Reaction } 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

@@ -744,8 +744,8 @@ function reactronicHookedThen(resolve, reject) {
             resolve = launch.wrap(resolve);
             reject = launch.wrap(reject);
         }
-        resolve = tran.wrap(resolve, false);
-        reject = tran.wrap(reject, true);
+        resolve = tran.wrapAsPending(resolve, false);
+        reject = tran.wrapAsPending(reject, true);
     }
     return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
 }

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, apply } from "../ReactiveSystem.js";
+import { ReactiveSystem, options, unobservable, reaction, nonreactive, atomicAction } 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;
-            apply({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            atomicAction({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
@@ -546,7 +546,7 @@ function triggerFinalization(slot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = slot;
             if (gFirstToDispose === slot)
-                apply({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
+                atomicAction({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${slot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

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

@@ -17,7 +17,7 @@ export declare abstract class Transaction implements Worker {
     abstract inspect<T>(func: F<T>, ...args: any[]): T;
     abstract apply(): void;
     abstract seal(): this;
-    abstract wrap<T>(func: F<T>, secondary: boolean): F<T>;
+    abstract wrapAsPending<T>(func: F<T>, secondary: boolean): F<T>;
     abstract cancel(error: Error, retryAfterOrIgnore?: Worker | null): this;
     abstract readonly isCanceled: boolean;
     abstract readonly isFinished: boolean;
@@ -33,7 +33,7 @@ export declare abstract class Transaction implements Worker {
 export declare class TransactionImpl extends Transaction {
     private static readonly none;
     private static curr;
-    private static inspection;
+    private static isInspectionMode;
     private static frameStartTime;
     private static frameOverCounter;
     readonly margin: number;
@@ -57,9 +57,9 @@ export declare class TransactionImpl extends Transaction {
     inspect<T>(func: F<T>, ...args: any[]): T;
     apply(): void;
     seal(): this;
-    wrap<T>(func: F<T>, error: boolean): F<T>;
-    private static wrapperEnter;
-    private static wrapperLeave;
+    wrapAsPending<T>(func: F<T>, secondary: boolean): F<T>;
+    private static preparePendingFunction;
+    private static runPendingFunction;
     cancel(error: Error, restartAfter?: Worker | null): this;
     get isCanceled(): boolean;
     get isFinished(): boolean;

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

@@ -50,15 +50,15 @@ export class TransactionImpl extends Transaction {
         return this.runImpl(undefined, func, ...args);
     }
     inspect(func, ...args) {
-        const restore = TransactionImpl.inspection;
+        const outer = TransactionImpl.isInspectionMode;
         try {
-            TransactionImpl.inspection = true;
+            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}]`);
             return this.runImpl(undefined, func, ...args);
         }
         finally {
-            TransactionImpl.inspection = restore;
+            TransactionImpl.isInspectionMode = outer;
         }
     }
     apply() {
@@ -73,27 +73,27 @@ export class TransactionImpl extends Transaction {
             this.run(TransactionImpl.seal, this, undefined, undefined);
         return this;
     }
-    wrap(func, error) {
+    wrapAsPending(func, secondary) {
         this.guard();
         const self = this;
-        const inspect = TransactionImpl.inspection;
-        if (!inspect)
-            self.run(TransactionImpl.wrapperEnter, self, error);
+        const inspection = TransactionImpl.isInspectionMode;
+        if (!inspection)
+            self.run(TransactionImpl.preparePendingFunction, self, secondary);
         else
-            self.inspect(TransactionImpl.wrapperEnter, self, error);
-        const wrappedForTransaction = (...args) => {
-            if (!inspect)
-                return self.runImpl(undefined, TransactionImpl.wrapperLeave, self, error, func, ...args);
+            self.inspect(TransactionImpl.preparePendingFunction, self, secondary);
+        const wrappedAsPendingForTransaction = (...args) => {
+            if (!inspection)
+                return self.runImpl(undefined, TransactionImpl.runPendingFunction, self, secondary, func, ...args);
             else
-                return self.inspect(TransactionImpl.wrapperLeave, self, error, func, ...args);
+                return self.inspect(TransactionImpl.runPendingFunction, self, secondary, func, ...args);
         };
-        return wrappedForTransaction;
+        return wrappedAsPendingForTransaction;
     }
-    static wrapperEnter(t, error) {
-        if (!error)
+    static preparePendingFunction(t, secondary) {
+        if (!secondary)
             t.pending++;
     }
-    static wrapperLeave(t, error, func, ...args) {
+    static runPendingFunction(t, secondary, func, ...args) {
         t.pending--;
         const result = func(...args);
         return result;
@@ -118,10 +118,10 @@ export class TransactionImpl extends Transaction {
     }
     static run(options, func, ...args) {
         const t = TransactionImpl.acquire(options);
-        const root = t !== TransactionImpl.curr;
+        const isRoot = t !== TransactionImpl.curr;
         t.guard();
         let result = t.runImpl(options === null || options === void 0 ? void 0 : options.logging, func, ...args);
-        if (root) {
+        if (isRoot) {
             if (result instanceof Promise) {
                 result = TransactionImpl.outside(() => {
                     return t.wrapToRetry(t.wrapToWaitUntilFinish(result), func, ...args);
@@ -231,7 +231,7 @@ export class TransactionImpl extends Transaction {
             }
         }
         catch (e) {
-            if (!TransactionImpl.inspection)
+            if (!TransactionImpl.isInspectionMode)
                 this.cancel(e);
             throw e;
         }
@@ -460,7 +460,7 @@ export class TransactionImpl extends Transaction {
         return TransactionImpl.curr.changeset;
     }
     static getEditableChangeset() {
-        if (TransactionImpl.inspection)
+        if (TransactionImpl.isInspectionMode)
             throw misuse("cannot make changes during transaction inspection");
         return TransactionImpl.curr.changeset;
     }
@@ -474,7 +474,7 @@ export class TransactionImpl extends Transaction {
 }
 TransactionImpl.none = new TransactionImpl({ hint: "<none>" });
 TransactionImpl.curr = TransactionImpl.none;
-TransactionImpl.inspection = false;
+TransactionImpl.isInspectionMode = false;
 TransactionImpl.frameStartTime = 0;
 TransactionImpl.frameOverCounter = 0;
 TransactionImpl.migrateFieldVersion = function (fv, target) {

package/package.json

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