reactronic 0.93.25025 → 0.93.25026

package/README.md

@@ -28,14 +28,15 @@ concepts:
   - **Triggering Objects** - a set of objects that store
     data of an application (state) and cause reactions
     upon their changes;
-  - **Atomic Function** - a function that makes changes in
-    triggering objects in atomic way ("all or nothing");
-  - **Reactive Function** - a function that is
+  - **Atomic Block** - a code block that makes changes
+    in triggering objects in atomic way ("all or
+    nothing");
+  - **Reaction** - a function that is
     (re-)executed in response to changes made in
     triggering objects by atomic actions;
-  - **Cached Function** -  a function which result is
-    remembered and, if becomes obsolete, causes function
-    to re-execute on-demand.
+  - **Cache** -  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.
@@ -57,7 +58,7 @@ class Demo extends TriggeringObject {
     this.email = email
   }
 
-  @reactive
+  @reaction
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -83,12 +84,12 @@ class Demo extends TriggeringObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @cachedResult
+  @cache
   get contact(): string {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reactive
+  @reaction
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -192,7 +193,7 @@ execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cachedResult
+  @cache
   render(): React.JSX.Element {
     return (
       <div>
@@ -206,12 +207,12 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cachedResult
+  @cache
   render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
 
-  @reactive // called in response to changes
+  @reaction // called in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate()) {
       // Ask React to re-render
@@ -330,12 +331,12 @@ class TriggeringObject { }
 function trigger(boolean) // field only
 function trigger(proto, prop) // field only
 function atomic(proto, prop, pd) // method only
-function reactive(proto, prop, pd) // method only
-function cached(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>
 
-function nonReactiveRun<T>(func: F<T>, ...args: any[]): T
-function sensitiveRun<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
+function runNonReactively<T>(func: F<T>, ...args: any[]): T
+function runSensitively<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 // SnapshotOptions, MemberOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
 
@@ -363,8 +364,8 @@ type MemberOptions = {
 enum Kind {
   plain = 0,
   atomic = 1,
-  reactive = 2,
-  cached = 3
+  reaction = 2,
+  cache = 3
 }
 
 enum Reentrance {

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

@@ -26,8 +26,8 @@ export type MemberOptions = {
 export declare enum Kind {
     plain = 0,
     atomic = 1,
-    reactive = 2,
-    cached = 3
+    reaction = 2,
+    cache = 3
 }
 export declare enum Reentrance {
     preventWithError = 1,

package/build/dist/source/Options.js

@@ -3,8 +3,8 @@ export var Kind;
 (function (Kind) {
     Kind[Kind["plain"] = 0] = "plain";
     Kind[Kind["atomic"] = 1] = "atomic";
-    Kind[Kind["reactive"] = 2] = "reactive";
-    Kind[Kind["cached"] = 3] = "cached";
+    Kind[Kind["reaction"] = 2] = "reaction";
+    Kind[Kind["cache"] = 3] = "cache";
 })(Kind || (Kind = {}));
 export var Reentrance;
 (function (Reentrance) {

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

@@ -17,14 +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 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 runAtomically<T>(func: F<T>, ...args: any[]): T;
+export declare function runAtomically<T>(options: SnapshotOptions, func: F<T>, ...args: any[]): T;
+export declare function runNonReactively<T>(func: F<T>, ...args: any[]): T;
+export declare function runSensitively<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
+export declare function runContextually<T>(p: Promise<T>): Promise<T>;
 export declare function trigger(enabled: boolean): (proto: object, prop: PropertyKey) => any;
 export declare function trigger<T>(proto: object, prop: PropertyKey): any;
-export declare function atomicBlock(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
+export declare function atomic(proto: object, prop: PropertyKey, pd: PropertyDescriptor): 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 options(value: Partial<MemberOptions>): F<any>;

package/build/dist/source/ReactiveSystem.js

@@ -22,7 +22,7 @@ export class ReactiveSystem {
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
-export function atomicRun(p1, p2, p3) {
+export function runAtomically(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
@@ -36,13 +36,13 @@ export function atomicRun(p1, p2, p3) {
             return Transaction.run(p1, p2);
     }
 }
-export function nonReactiveRun(func, ...args) {
+export function runNonReactively(func, ...args) {
     return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
-export function sensitiveRun(sensitivity, func, ...args) {
+export function runSensitively(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
-export function contextualRun(p) {
+export function runContextually(p) {
     throw new Error("not implemented yet");
 }
 export function trigger(protoOrEnabled, prop) {
@@ -54,16 +54,16 @@ export function trigger(protoOrEnabled, prop) {
     else
         return Mvcc.decorateData(true, protoOrEnabled, prop);
 }
-export function atomicBlock(proto, prop, pd) {
+export function atomic(proto, prop, pd) {
     const opts = {
         kind: Kind.atomic,
         isolation: Isolation.joinToCurrentTransaction,
     };
-    return Mvcc.decorateOperation(true, atomicBlock, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
 }
 export function reaction(proto, prop, pd) {
     const opts = {
-        kind: Kind.reactive,
+        kind: Kind.reaction,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
@@ -71,7 +71,7 @@ export function reaction(proto, prop, pd) {
 }
 export function cache(proto, prop, pd) {
     const opts = {
-        kind: Kind.cached,
+        kind: Kind.cache,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };

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

@@ -27,7 +27,7 @@ export declare class Ref<T = any> {
     constructor(owner: any, name: string, index?: number);
     get variable(): T;
     set variable(value: T);
-    unobs(): T;
+    nonReactively(): T;
     observe(): T;
     unobserve(): T;
     static sameRefs(v1: Ref, v2: Ref): boolean;

package/build/dist/source/Ref.js

@@ -1,4 +1,4 @@
-import { atomicRun, nonReactiveRun } from "./ReactiveSystem.js";
+import { runAtomically, runNonReactively } from "./ReactiveSystem.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }
@@ -27,8 +27,8 @@ export class Ref {
         else
             this.owner[this.name][this.index] = value;
     }
-    unobs() {
-        return nonReactiveRun(() => this.variable);
+    nonReactively() {
+        return runNonReactively(() => this.variable);
     }
     observe() {
         return this.variable;
@@ -52,7 +52,7 @@ export class ToggleRef extends Ref {
     toggle() {
         const o = this.owner;
         const p = this.name;
-        atomicRun({ hint: `toggle ${o.constructor.name}.${p}` }, () => {
+        runAtomically({ 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,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 { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
-export { ReactiveSystem, trigger, atomicBlock, reaction, cache, options } from "./ReactiveSystem.js";
+export { runAtomically, runNonReactively, runSensitively, runContextually } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomic, reaction, cache, options } from "./ReactiveSystem.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";

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 { atomicRun, nonReactiveRun, sensitiveRun, contextualRun } from "./ReactiveSystem.js";
-export { ReactiveSystem, trigger, atomicBlock, reaction, cache, options } from "./ReactiveSystem.js";
+export { runAtomically, runNonReactively, runSensitively, runContextually } from "./ReactiveSystem.js";
+export { ReactiveSystem, trigger, atomic, reaction, cache, options } from "./ReactiveSystem.js";
 export { ReactiveLoop } from "./ReactiveLoop.js";
 export { ReactiveNode, Mode, Priority, BaseDriver, ReactiveNodeVariable } from "./core/ReactiveNode.js";

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

@@ -294,15 +294,15 @@ class Launch extends FieldVersion {
                 changeset.id === this.lastEditorChangesetId;
             if (!skip) {
                 const why = `${Dump.snapshot2(h, changeset, fk, trigger)}    ◀◀    ${outer}`;
-                const isReactive = this.options.kind === Kind.reactive;
+                const isReaction = this.options.kind === Kind.reaction;
                 this.obsoleteDueTo = why;
                 this.obsoleteSince = since;
                 if (Log.isOn && (Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
-                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", isReactive ? "█" : "▒", isReactive && changeset === EMPTY_OBJECT_VERSION.changeset
+                    Log.write(Log.opt.transaction && !Changeset.current().sealed ? "║" : " ", isReaction ? "█" : "▒", isReaction && changeset === EMPTY_OBJECT_VERSION.changeset
                         ? `${this.hint()} is reactive and will run automatically (order ${this.options.order})`
-                        : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, fk)} since s${since}${isReactive ? ` and will run automatically (order ${this.options.order})` : ""}`);
+                        : `${this.hint()} is obsolete due to ${Dump.snapshot2(h, changeset, fk)} since s${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ""}`);
                 this.unsubscribeFromAllTriggers();
-                if (isReactive)
+                if (isReaction)
                     collector.push(this);
                 else
                     (_b = this.reactions) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.operation.fieldKey, this.changeset, this.operation.ownerHandle, why, since, collector));
@@ -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.reactive)
+                            if (launch.options.kind === Kind.reaction)
                                 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.reactive)
+                    else if (this.options.kind === Kind.reaction)
                         misuse(`reactive ${this.hint()} failed and will not run anymore: ${e}`, e);
                 }
             }
@@ -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.reactive && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
+        if (launch.options.kind === Kind.reaction && launch.options.throttling < Number.MAX_SAFE_INTEGER) {
             const reactive = Meta.acquire(proto, Meta.Reactive);
             reactive[fk] = launch;
         }
-        else if (launch.options.kind === Kind.reactive && launch.options.throttling >= Number.MAX_SAFE_INTEGER) {
+        else if (launch.options.kind === Kind.reaction && 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 { TriggeringObject } from "../core/Mvcc.js";
 import { Transaction } from "../core/Transaction.js";
-import { ReactiveSystem, options, trigger, reaction, atomicRun, nonReactiveRun } from "../ReactiveSystem.js";
+import { ReactiveSystem, options, trigger, reaction, runAtomically, runNonReactively } 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.nodeSlot.instance;
         const owner = node.owner;
-        const hostCtx = nonReactiveRun(() => { var _a; return (_a = owner.context) === null || _a === void 0 ? void 0 : _a.value; });
+        const hostCtx = runNonReactively(() => { 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;
-            atomicRun({ isolation: Isolation.joinAsNestedTransaction }, () => {
+            runAtomically({ isolation: Isolation.joinAsNestedTransaction }, () => {
                 const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
@@ -484,18 +484,18 @@ function triggerScriptRunViaSlot(nodeSlot) {
                     });
                 });
             }
-            nonReactiveRun(node.script, node.declaration.triggers);
+            runNonReactively(node.script, node.declaration.triggers);
         }
         else if (node.owner !== node)
             runScriptNow(nodeSlot);
         else
-            atomicRun(() => runScriptNow(nodeSlot));
+            runAtomically(() => runScriptNow(nodeSlot));
     }
 }
 function mountOrRemountIfNecessary(node) {
     const driver = node.driver;
     if (node.stamp === Number.MAX_SAFE_INTEGER) {
-        nonReactiveRun(() => {
+        runNonReactively(() => {
             node.stamp = Number.MAX_SAFE_INTEGER - 1;
             driver.runPreparation(node);
             if (!node.has(Mode.manualMount)) {
@@ -506,7 +506,7 @@ function mountOrRemountIfNecessary(node) {
         });
     }
     else if (node.isMoved && !node.has(Mode.manualMount) && node.host !== node)
-        nonReactiveRun(() => driver.runMount(node));
+        runNonReactively(() => driver.runMount(node));
 }
 function runScriptNow(nodeSlot) {
     const node = nodeSlot.instance;
@@ -539,7 +539,7 @@ function triggerFinalization(nodeSlot, 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 = nonReactiveRun(() => driver.runFinalization(node, isLeader));
+        const childrenAreLeaders = runNonReactively(() => driver.runFinalization(node, isLeader));
         if (node.has(Mode.autonomous)) {
             nodeSlot.aux = undefined;
             const last = gLastToDispose;
@@ -548,7 +548,7 @@ function triggerFinalization(nodeSlot, isLeader, individual) {
             else
                 gFirstToDispose = gLastToDispose = nodeSlot;
             if (gFirstToDispose === nodeSlot)
-                atomicRun({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
+                runAtomically({ isolation: Isolation.disjoinForInternalDisposal, hint: `runDisposalLoop(initiator=${nodeSlot.instance.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }

package/package.json

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