reactronic 0.92.25007 → 0.92.25009

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

@@ -9,4 +9,5 @@ export declare class Clock extends ObservableObject {
     constructor(interval?: number);
     pause(value?: boolean): void;
     private tick;
+    protected start(): void;
 }

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, reactive } from "./ReactiveSystem.js";
 export class Clock extends ObservableObject {
     constructor(interval = 1000) {
         super();
@@ -19,7 +19,6 @@ export class Clock extends ObservableObject {
         this.interval = 0;
         this.paused = false;
         this.interval = interval;
-        this.tick();
     }
     pause(value = true) {
         this.paused = value;
@@ -38,16 +37,25 @@ export class Clock extends ObservableObject {
             setTimeout(() => this.tick(), this.interval - calibration);
         }
     }
+    start() {
+        this.tick();
+    }
 }
 __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)
 ], Clock.prototype, "tick", null);
+__decorate([
+    reactive,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Clock.prototype, "start", null);

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,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 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 sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
-export declare function contextually<T>(p: Promise<T>): Promise<T>;
+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 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 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,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 atomically(p1, p2, p3) {
+export function atomicRun(p1, p2, p3) {
     if (p1 instanceof Function) {
         if (p2 !== undefined)
             return Transaction.run(null, p1, ...p2);
@@ -36,13 +36,13 @@ export function atomically(p1, p2, p3) {
             return Transaction.run(p1, p2);
     }
 }
-export function nonreactive(func, ...args) {
+export function nonReactiveRun(func, ...args) {
     return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
-export function sensitive(sensitivity, func, ...args) {
+export function sensitiveRun(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
 }
-export function contextually(p) {
+export function contextualRun(p) {
     throw new Error("not implemented yet");
 }
 export function unobservable(proto, prop) {
@@ -51,28 +51,28 @@ export function unobservable(proto, prop) {
 export function observable(proto, prop) {
     return Mvcc.decorateData(true, proto, prop);
 }
-export function atomicAction(proto, prop, pd) {
+export function atomic(proto, prop, pd) {
     const opts = {
         kind: Kind.atomicAction,
         isolation: Isolation.joinToCurrentTransaction,
     };
-    return Mvcc.decorateOperation(true, atomicAction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
 }
-export function reactiveProcess(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 { atomically, 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;
-        atomically({ 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,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 { atomically, nonreactive, sensitive, contextually } from "./ReactiveSystem.js";
-export { ReactiveSystem, observable, unobservable, atomicAction, reactiveProcess, cachedResult, 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,8 +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 { atomically, nonreactive, sensitive, contextually } from "./ReactiveSystem.js";
-export { ReactiveSystem, observable, unobservable, atomicAction, reactiveProcess, cachedResult, 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, atomically, nonreactive } 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;
-            atomically({ 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)
-                atomically({ 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.25007",
+  "version": "0.92.25009",
   "description": "Reactronic - Transactional Reactive State Management",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",