reactronic 0.92.25006 → 0.92.25008

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

package/build/dist/source/Reaction.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 { reactiveProcess } from "./ReactiveSystem.js";
+import { reactive } from "./ReactiveSystem.js";
 export class ReactiveProcess extends ObservableObject {
     constructor(action) {
         super();
@@ -19,7 +19,7 @@ export class ReactiveProcess extends ObservableObject {
     }
 }
 __decorate([
-    reactiveProcess,
+    reactive,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)

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 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 atomicRun<T>(func: F<T>, ...args: any[]): T;
+export declare function atomicRun<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function nonReactiveRun<T>(func: F<T>, ...args: any[]): T;
+export declare function sensitiveRun<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+export declare function contextualRun<T>(p: Promise<T>): Promise<T>;
 export declare function unobservable(proto: object, prop: PropertyKey): any;
 export declare function observable(proto: object, prop: PropertyKey): 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 atomic(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function reactive(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function cached(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 atomicRun(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 nonReactiveRun(func, ...args) {
+    return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
+}
+export function sensitiveRun(sensitivity, func, ...args) {
+    return Mvcc.sensitive(sensitivity, func, ...args);
+}
+export function contextualRun(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 reactiveProcess(proto, prop, pd) {
+export function atomic(proto, prop, pd) {
+    const opts = {
+        kind: Kind.atomicAction,
+        isolation: Isolation.joinToCurrentTransaction,
+    };
+    return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
+}
+export function reactive(proto, prop, pd) {
     const opts = {
         kind: Kind.reactiveProcess,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
-    return Mvcc.decorateOperation(true, reactiveProcess, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reactive, opts, proto, prop, pd);
 }
-export function cachedResult(proto, prop, pd) {
+export function cached(proto, prop, pd) {
     const opts = {
         kind: Kind.cachedResult,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };
-    return Mvcc.decorateOperation(true, cachedResult, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cached, 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 { atomicRun, nonReactiveRun } from "./ReactiveSystem.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -28,7 +28,7 @@ export class Ref {
             this.owner[this.name][this.index] = value;
     }
     unobs() {
-        return nonreactive(() => this.variable);
+        return nonReactiveRun(() => this.variable);
     }
     observe() {
         return this.variable;
@@ -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}` }, () => {
+        atomicRun({ 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 { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, atomic, reactive, cached, 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 { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
+export { ReactiveSystem, observable, unobservable, atomic, reactive, cached, 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, reactive, atomicRun, nonReactiveRun } from "../ReactiveSystem.js";
 export var Mode;
 (function (Mode) {
     Mode[Mode["default"] = 0] = "default";
@@ -333,13 +333,13 @@ class ReactiveNodeImpl extends ReactiveNode {
     static setNodeVariableValue(variable, value) {
         const node = ReactiveNodeImpl.ownSlot.instance;
         const owner = node.owner;
-        const hostCtx = nonreactive(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
+        const hostCtx = nonReactiveRun(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
                 node.outer = owner;
             else
                 node.outer = owner.outer;
-            atomicAction({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            atomicRun({ 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([
-    reactiveProcess,
+    reactive,
     options({
         reentrance: Reentrance.cancelAndWaitPrevious,
         allowObsoleteToFinish: true,
@@ -484,7 +484,7 @@ function triggerUpdateViaSlot(slot) {
                     });
                 });
             }
-            nonreactive(node.update, node.declaration.triggers);
+            nonReactiveRun(node.update, node.declaration.triggers);
         }
         else
             updateNow(slot);
@@ -493,7 +493,7 @@ function triggerUpdateViaSlot(slot) {
 function mountOrRemountIfNecessary(node) {
     const driver = node.driver;
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
-        nonreactive(() => {
+        nonReactiveRun(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
             if (!node.has(Mode.manualMount)) {
@@ -504,7 +504,7 @@ function mountOrRemountIfNecessary(node) {
         });
     }
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
-        nonreactive(() => driver.runMount(node));
+        nonReactiveRun(() => driver.runMount(node));
 }
 function updateNow(slot) {
     const node = slot.instance;
@@ -537,7 +537,7 @@ function triggerFinalization(slot, isLeader, individual) {
         if (individual && node.key !== node.declaration.key && !driver.isPartition)
             console.log(`WARNING: it is recommended to assign explicit key for conditional element in order to avoid unexpected side effects: ${node.key}`);
         node.stamp = ~node.stamp;
-        const childrenAreLeaders = nonreactive(() => driver.runFinalization(node, isLeader));
+        const childrenAreLeaders = nonReactiveRun(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
             slot.aux = undefined;
             const last = gLastToDispose;
@@ -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})` }, () => {
+                atomicRun({ 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.25008",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",