reactronic 0.92.25006 → 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");
-  - **Reactive Process** - a function that is executed automatically in
-    response to changes made by a transaction;
-  - **Cached Result** -  function result that is remembered and, if the becomes
-  obsolete, causes its function to re-execute 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.
@@ -215,7 +220,8 @@ class Component<P> extends React.Component<P> {
   } // EnsureUpToDate is subscribed to render
 
   shouldComponentUpdate(): boolean {
-    return !RxSystem.getController(this.render).isUpToDate
+    const r = ReactiveSystem.getController(this.render)
+    return !r.isUpToDate
   }
 
   componentDidMount(): void {
@@ -224,7 +230,7 @@ class Component<P> extends React.Component<P> {
   }
 
   componentWillUnmount(): void {
-    atomicAction(RxSystem.dispose, this)
+    atomicAction(ReactiveSystem.dispose, this)
   }
 }
 ```

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 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.atomicAction,
-            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,6 +51,13 @@ export function unobservable(proto, prop) {
 export function observable(proto, prop) {
     return Mvcc.decorateData(true, proto, prop);
 }
+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.reactiveProcess,

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,7 +16,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, reactiveProcess, cachedResult, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.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";

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, reactiveProcess, cachedResult, nonreactive, sensitive, contextually, options } from "./ReactiveSystem.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/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, reactiveProcess, 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;
@@ -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.25006",
+  "version": "0.92.25007",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",