reactronic 0.93.25026 → 0.94.25028

package/README.md

@@ -20,20 +20,20 @@ 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 (reactive functions) and
-application state (triggering objects).
+application state (observable objects).
 
 Transactional reactivity is based on four fundamental
 concepts:
 
-  - **Triggering Objects** - a set of objects that store
+  - **Observable Objects** - a set of objects that store
     data of an application (state) and cause reactions
     upon their changes;
   - **Atomic Block** - a code block that makes changes
-    in triggering objects in atomic way ("all or
+    in observable 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;
+    observable objects by atomic actions;
   - **Cache** -  a function which result is remembered
     and, if becomes obsolete, causes function to
     re-execute on-demand.
@@ -48,7 +48,7 @@ Quick introduction and detailed description is below.
 Here is an example of transactional reactive code:
 
 ``` typescript
-class Demo extends TriggeringObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -58,7 +58,7 @@ class Demo extends TriggeringObject {
     this.email = email
   }
 
-  @reaction
+  @reactive
   printContact(): void {
     // depends on `name` and `email` and reacts to their changes
     if (this.email.indexOf('@') >= 0)
@@ -68,7 +68,7 @@ class Demo extends TriggeringObject {
 }
 ```
 
-In the example above, `Demo` is a triggering object,
+In the example above, `Demo` is an observable object,
 meaning that access to its fields are seamlessly tracked
 to determine dependent reactive and cached functions.
 Reactive function `printContact` reads `name` and `email`
@@ -80,16 +80,16 @@ Here is an example of a cached result that is
 (re-)computed on-demand:
 
 ``` typescript
-class Demo extends TriggeringObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
-  @cache
+  @cached
   get contact(): string {
     return this.name + ' <' + this.email + '>'
   }
 
-  @reaction
+  @reactive
   printContact(): void {
     if (this.contact !== '')
       Console.log(this.contact)
@@ -107,15 +107,15 @@ thus causing execution of depending reactive function
 `printContact` runs it reads `contact` and causes its
 re-computation.
 
-## Triggering Objects
+## Observable Objects
 
-Triggering objects (triggers) are aimed to store data of
+Observable objects are aimed to store data of
 an application. All such objects are transparently hooked
 to track access to their properties, both on reads and
 writes.
 
 ``` typescript
-class MyModel extends TriggeringObject {
+class MyModel extends ObservableObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -123,19 +123,19 @@ class MyModel extends TriggeringObject {
 ```
 
 In the example above, the class `MyModel` is based on
-Reactronic's `TriggeringObject` class and all its
+Reactronic's `ObservableObject` class and all its
 properties `url`, `content`, and `timestamp` are hooked.
 
 ## Atomic Function
 
-Atomic function makes changes in triggering objects
+Atomic function makes changes in observable objects
 in atomic (transactional) way, thus provoking execution
 of dependent reactive and cached functions. Atomic
 function is instrumented with hooks to provide transparent atomicity
 (by implicit context switching and isolation).
 
 ``` typescript
-class MyModel extends TriggeringObject {
+class MyModel extends ObservableObject {
   // ...
   @atomic
   async load(url: string): Promise<void> {
@@ -182,18 +182,18 @@ chain of asynchronous operations is fully completed.
 ## Reactive & Cached Functions
 
 Reactive function is automatically and immediately called
-in response to changes in triggering objects made by
+in response to changes in observable objects made by
 atomic functions. Cached function is called on-demand to
 renew the result if it was marked as obsolete due to
 changes made by an atomic functions. Reactive and cached
 functions are instrumented with hooks to seamlessly
-subscribe to those triggering objects and other cached
+subscribe to those observable objects and other cached
 functions (dependencies), which are used during their
 execution.
 
 ``` tsx
 class MyView extends Component<{model: MyModel}> {
-  @cache
+  @cached
   render(): React.JSX.Element {
     return (
       <div>
@@ -207,12 +207,12 @@ class MyView extends Component<{model: MyModel}> {
 
 ``` tsx
 class Component<P> extends React.Component<P> {
-  @cache
+  @cached
   render(): React.JSX.Element {
     throw new Error('render method is undefined')
   }
 
-  @reaction // called in response to changes
+  @reactive // called in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate()) {
       // Ask React to re-render
@@ -221,7 +221,7 @@ class Component<P> extends React.Component<P> {
   } // EnsureUpToDate is subscribed to render
 
   shouldComponentUpdate(): boolean {
-    const r = ReactiveSystem.getController(this.render)
+    const r = ReactiveSystem.getDescriptor(this.render)
     return !r.isUpToDate
   }
 
@@ -250,14 +250,14 @@ cached value.
 
 In general case, all reactive and cached functions
 are automatically and immediately marked as obsolete
-when changes are made in those triggering objects and
+when changes are made in those observable objects and
 other cached results that were used during their
 execution. And once marked, the functions are
 automatically executed again, either immediately (for
 reactive functions) or on-demand (for cached functions).
 
 Reactronic takes full care of tracking dependencies
-between all the triggering objects and reactive/cached
+between all the observable objects and reactive/cached
 functions. With Reactronic, you no longer need to create
 data change events in one set of objects, subscribe to
 these events in other objects, and manually maintain
@@ -323,22 +323,22 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class TransactionalObject { }
-class TriggeringObject { }
+class AtomicObject { }
+class ObservableObject { }
 
 // Decorators & Operators
 
-function trigger(boolean) // field only
-function trigger(proto, prop) // field only
+function observable(boolean) // field only
+function observable(proto, prop) // field only
 function atomic(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 options(value: Partial<ReactivityOptions>): F<any>
 
 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
+// SnapshotOptions, ReactivityOptions, Kind, Reentrance, Indicator, LoggingOptions, ProfilingOptions
 
 export type SnapshotOptions = {
   readonly hint?: string
@@ -348,12 +348,12 @@ export type SnapshotOptions = {
   readonly token?: any
 }
 
-type MemberOptions = {
+type ReactivityOptions = {
   readonly kind: Kind
   readonly isolation: Isolation
   readonly order: number
   readonly noSideEffects: boolean
-  readonly triggeringArgs: boolean
+  readonly observableArgs: boolean
   readonly throttling: number // milliseconds, -1 is immediately, Number.MAX_SAFE_INTEGER is never
   readonly reentrance: Reentrance
   readonly journal: Journal | undefined

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

@@ -0,0 +1,32 @@
+export declare enum Mode {
+    default = 0,
+    autonomous = 1,
+    manualMount = 2,
+    rootNode = 4
+}
+export declare enum Priority {
+    realtime = 0,
+    normal = 1,
+    background = 2
+}
+export declare enum Kind {
+    plain = 0,
+    atomic = 1,
+    reactive = 2,
+    cached = 3
+}
+export declare enum Reentrance {
+    preventWithError = 1,
+    waitAndRestart = 0,
+    cancelPrevious = -1,
+    cancelAndWaitPrevious = -2,
+    overwritePrevious = -3,
+    runSideBySide = -4
+}
+export declare enum Isolation {
+    joinToCurrentTransaction = 0,
+    joinAsNestedTransaction = 1,
+    disjoinFromOuterTransaction = 2,
+    disjoinFromOuterAndInnerTransactions = 3,
+    disjoinForInternalDisposal = 4
+}

package/build/dist/source/Enums.js

@@ -0,0 +1,37 @@
+export var Mode;
+(function (Mode) {
+    Mode[Mode["default"] = 0] = "default";
+    Mode[Mode["autonomous"] = 1] = "autonomous";
+    Mode[Mode["manualMount"] = 2] = "manualMount";
+    Mode[Mode["rootNode"] = 4] = "rootNode";
+})(Mode || (Mode = {}));
+export var Priority;
+(function (Priority) {
+    Priority[Priority["realtime"] = 0] = "realtime";
+    Priority[Priority["normal"] = 1] = "normal";
+    Priority[Priority["background"] = 2] = "background";
+})(Priority || (Priority = {}));
+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 = {}));
+export var Reentrance;
+(function (Reentrance) {
+    Reentrance[Reentrance["preventWithError"] = 1] = "preventWithError";
+    Reentrance[Reentrance["waitAndRestart"] = 0] = "waitAndRestart";
+    Reentrance[Reentrance["cancelPrevious"] = -1] = "cancelPrevious";
+    Reentrance[Reentrance["cancelAndWaitPrevious"] = -2] = "cancelAndWaitPrevious";
+    Reentrance[Reentrance["overwritePrevious"] = -3] = "overwritePrevious";
+    Reentrance[Reentrance["runSideBySide"] = -4] = "runSideBySide";
+})(Reentrance || (Reentrance = {}));
+export var Isolation;
+(function (Isolation) {
+    Isolation[Isolation["joinToCurrentTransaction"] = 0] = "joinToCurrentTransaction";
+    Isolation[Isolation["joinAsNestedTransaction"] = 1] = "joinAsNestedTransaction";
+    Isolation[Isolation["disjoinFromOuterTransaction"] = 2] = "disjoinFromOuterTransaction";
+    Isolation[Isolation["disjoinFromOuterAndInnerTransactions"] = 3] = "disjoinFromOuterAndInnerTransactions";
+    Isolation[Isolation["disjoinForInternalDisposal"] = 4] = "disjoinForInternalDisposal";
+})(Isolation || (Isolation = {}));

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

@@ -0,0 +1,7 @@
+import { F } from "./util/Utils.js";
+import { ObservableObject } from "./core/Mvcc.js";
+export declare class ReactiveOperationEx<T> extends ObservableObject {
+    protected operation: F<T>;
+    constructor(operation: F<T>);
+    protected launch(): T;
+}

package/build/dist/source/{ReactiveLoop.js → OperationEx.js}

@@ -7,20 +7,20 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { TriggeringObject } from "./core/Mvcc.js";
-import { reaction } from "./ReactiveSystem.js";
-export class ReactiveLoop extends TriggeringObject {
-    constructor(reactiveFunction) {
+import { ObservableObject } from "./core/Mvcc.js";
+import { reactive } from "./System.js";
+export class ReactiveOperationEx extends ObservableObject {
+    constructor(operation) {
         super();
-        this.reactiveFunction = reactiveFunction;
+        this.operation = operation;
     }
     launch() {
-        return this.reactiveFunction();
+        return this.operation();
     }
 }
 __decorate([
-    reaction,
+    reactive,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], ReactiveLoop.prototype, "launch", null);
+], ReactiveOperationEx.prototype, "launch", null);

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

@@ -1,5 +1,6 @@
 import { LoggingOptions } from "./Logging.js";
 export { LoggingLevel } from "./Logging.js";
+import { Kind, Reentrance, Isolation } from "./Enums.js";
 export type { LoggingOptions, ProfilingOptions } from "./Logging.js";
 import { Journal } from "./core/Journal.js";
 import { Indicator } from "./core/Indicator.js";
@@ -10,12 +11,12 @@ export type SnapshotOptions = {
     readonly logging?: Partial<LoggingOptions>;
     readonly token?: any;
 };
-export type MemberOptions = {
+export type ReactivityOptions = {
     readonly kind: Kind;
     readonly isolation: Isolation;
     readonly order: number;
     readonly noSideEffects: boolean;
-    readonly triggeringArgs: boolean;
+    readonly observableArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly allowObsoleteToFinish: boolean;
@@ -23,35 +24,14 @@ export type MemberOptions = {
     readonly indicator: Indicator | null;
     readonly logging?: Partial<LoggingOptions>;
 };
-export declare enum Kind {
-    plain = 0,
-    atomic = 1,
-    reaction = 2,
-    cache = 3
-}
-export declare enum Reentrance {
-    preventWithError = 1,
-    waitAndRestart = 0,
-    cancelPrevious = -1,
-    cancelAndWaitPrevious = -2,
-    overwritePrevious = -3,
-    runSideBySide = -4
-}
-export declare enum Isolation {
-    joinToCurrentTransaction = 0,
-    joinAsNestedTransaction = 1,
-    disjoinFromOuterTransaction = 2,
-    disjoinFromOuterAndInnerTransactions = 3,
-    disjoinForInternalDisposal = 4
-}
-export type Operation<T> = {
-    readonly options: MemberOptions;
+export type ReactiveOperation<T> = {
+    readonly options: ReactivityOptions;
     readonly args: ReadonlyArray<any>;
     readonly result: T;
     readonly error: any;
     readonly stamp: number;
     readonly isReusable: boolean;
-    configure(options: Partial<MemberOptions>): MemberOptions;
+    configure(options: Partial<ReactivityOptions>): ReactivityOptions;
     markObsolete(): void;
-    pullLastResult(args?: any[]): T | undefined;
+    pullLastResult(args?: any[]): any;
 };

package/build/dist/source/Options.js

@@ -1,25 +1 @@
 export { LoggingLevel } from "./Logging.js";
-export var Kind;
-(function (Kind) {
-    Kind[Kind["plain"] = 0] = "plain";
-    Kind[Kind["atomic"] = 1] = "atomic";
-    Kind[Kind["reaction"] = 2] = "reaction";
-    Kind[Kind["cache"] = 3] = "cache";
-})(Kind || (Kind = {}));
-export var Reentrance;
-(function (Reentrance) {
-    Reentrance[Reentrance["preventWithError"] = 1] = "preventWithError";
-    Reentrance[Reentrance["waitAndRestart"] = 0] = "waitAndRestart";
-    Reentrance[Reentrance["cancelPrevious"] = -1] = "cancelPrevious";
-    Reentrance[Reentrance["cancelAndWaitPrevious"] = -2] = "cancelAndWaitPrevious";
-    Reentrance[Reentrance["overwritePrevious"] = -3] = "overwritePrevious";
-    Reentrance[Reentrance["runSideBySide"] = -4] = "runSideBySide";
-})(Reentrance || (Reentrance = {}));
-export var Isolation;
-(function (Isolation) {
-    Isolation[Isolation["joinToCurrentTransaction"] = 0] = "joinToCurrentTransaction";
-    Isolation[Isolation["joinAsNestedTransaction"] = 1] = "joinAsNestedTransaction";
-    Isolation[Isolation["disjoinFromOuterTransaction"] = 2] = "disjoinFromOuterTransaction";
-    Isolation[Isolation["disjoinFromOuterAndInnerTransactions"] = 3] = "disjoinFromOuterAndInnerTransactions";
-    Isolation[Isolation["disjoinForInternalDisposal"] = 4] = "disjoinForInternalDisposal";
-})(Isolation || (Isolation = {}));

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

@@ -1,5 +1,5 @@
-import { TriggeringObject } from "./core/Mvcc.js";
-export declare abstract class Pipe<T> extends TriggeringObject {
+import { ObservableObject } from "./core/Mvcc.js";
+export declare abstract class Pipe<T> extends ObservableObject {
     abstract readonly capacity: number;
     abstract readonly count: number;
     abstract put(...items: T[]): void;

package/build/dist/source/Pipe.js

@@ -1,4 +1,4 @@
-import { TriggeringObject } from "./core/Mvcc.js";
-export class Pipe extends TriggeringObject {
+import { ObservableObject } from "./core/Mvcc.js";
+export class Pipe extends ObservableObject {
     static create(hint, capacity) { throw new Error("not implemented"); }
 }

package/build/dist/source/Ref.js

@@ -1,4 +1,4 @@
-import { runAtomically, runNonReactively } from "./ReactiveSystem.js";
+import { runAtomically, runNonReactively } from "./System.js";
 export function refs(owner) {
     return new Proxy(owner, RefGettingProxy);
 }

package/build/dist/source/{ReactiveSystem.d.ts → System.d.ts}

@@ -1,13 +1,9 @@
 import { F } from "./util/Utils.js";
-import { Operation, MemberOptions, LoggingOptions, ProfilingOptions, SnapshotOptions } from "./Options.js";
+import { ReactiveOperation, ReactivityOptions, LoggingOptions, ProfilingOptions, SnapshotOptions } from "./Options.js";
 export declare class ReactiveSystem {
     static why(brief?: boolean): string;
-    static getOperation<T>(method: F<T>): Operation<T>;
-    static pullLastResult<T>(method: F<Promise<T>>, args?: any[]): T | undefined;
-    static configureCurrentOperation(options: Partial<MemberOptions>): MemberOptions;
     static getRevisionOf(obj: any): number;
     static takeSnapshot<T>(obj: T): T;
-    static dispose(obj: any): void;
     static get reactivityAutoStartDisabled(): boolean;
     static set reactivityAutoStartDisabled(value: boolean);
     static get isLogging(): boolean;
@@ -22,9 +18,12 @@ export declare function runAtomically<T>(options: SnapshotOptions, func: F<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 manageReactiveOperation<T>(method: F<T>): ReactiveOperation<T>;
+export declare function configureCurrentReactiveOperation(options: Partial<ReactivityOptions>): ReactivityOptions;
+export declare function disposeObservableObject(obj: any): void;
+export declare function observable(enabled: boolean): (proto: object, prop: PropertyKey) => any;
+export declare function observable<T>(proto: object, prop: PropertyKey): 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>;
+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<ReactivityOptions>): F<any>;

package/build/dist/source/{ReactiveSystem.js → System.js}

@@ -1,18 +1,14 @@
 import { Log } from "./util/Dbg.js";
-import { Kind, Isolation } from "./Options.js";
+import { Kind, Isolation } from "./Enums.js";
 import { Meta, ObjectHandle } from "./core/Data.js";
 import { Changeset } from "./core/Changeset.js";
 import { Mvcc } from "./core/Mvcc.js";
 import { Transaction } from "./core/Transaction.js";
-import { OperationImpl } from "./core/Operation.js";
+import { ReactiveOperationImpl } from "./core/Operation.js";
 export class ReactiveSystem {
-    static why(brief = false) { return brief ? OperationImpl.briefWhy() : OperationImpl.why(); }
-    static getOperation(method) { return OperationImpl.getControllerOf(method); }
-    static pullLastResult(method, args) { return ReactiveSystem.getOperation(method).pullLastResult(args); }
-    static configureCurrentOperation(options) { return OperationImpl.configureImpl(undefined, options); }
+    static why(brief = false) { return brief ? ReactiveOperationImpl.briefWhy() : ReactiveOperationImpl.why(); }
     static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
-    static dispose(obj) { Changeset.dispose(obj); }
     static get reactivityAutoStartDisabled() { return Mvcc.reactivityAutoStartDisabled; }
     static set reactivityAutoStartDisabled(value) { Mvcc.reactivityAutoStartDisabled = value; }
     static get isLogging() { return Log.isOn; }
@@ -37,7 +33,7 @@ export function runAtomically(p1, p2, p3) {
     }
 }
 export function runNonReactively(func, ...args) {
-    return OperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
+    return ReactiveOperationImpl.proceedWithinGivenLaunch(undefined, func, ...args);
 }
 export function runSensitively(sensitivity, func, ...args) {
     return Mvcc.sensitive(sensitivity, func, ...args);
@@ -45,7 +41,16 @@ export function runSensitively(sensitivity, func, ...args) {
 export function runContextually(p) {
     throw new Error("not implemented yet");
 }
-export function trigger(protoOrEnabled, prop) {
+export function manageReactiveOperation(method) {
+    return ReactiveOperationImpl.manageReactiveOperation(method);
+}
+export function configureCurrentReactiveOperation(options) {
+    return ReactiveOperationImpl.configureImpl(undefined, options);
+}
+export function disposeObservableObject(obj) {
+    Changeset.dispose(obj);
+}
+export function observable(protoOrEnabled, prop) {
     if (typeof (protoOrEnabled) === "boolean") {
         return (proto, prop) => {
             return Mvcc.decorateData(protoOrEnabled, proto, prop);
@@ -61,21 +66,21 @@ export function atomic(proto, prop, pd) {
     };
     return Mvcc.decorateOperation(true, atomic, opts, proto, prop, pd);
 }
-export function reaction(proto, prop, pd) {
+export function reactive(proto, prop, pd) {
     const opts = {
-        kind: Kind.reaction,
+        kind: Kind.reactive,
         isolation: Isolation.joinAsNestedTransaction,
         throttling: -1,
     };
-    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reactive, opts, proto, prop, pd);
 }
-export function cache(proto, prop, pd) {
+export function cached(proto, prop, pd) {
     const opts = {
-        kind: Kind.cache,
+        kind: Kind.cached,
         isolation: Isolation.joinToCurrentTransaction,
         noSideEffects: true,
     };
-    return Mvcc.decorateOperation(true, cache, 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/api.d.ts

@@ -4,20 +4,22 @@ export type { MergedItem, MergeListReader } from "./util/MergeList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";
-export { Kind, Reentrance, Isolation, LoggingLevel } from "./Options.js";
-export type { Operation, MemberOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
+export { LoggingLevel } from "./Options.js";
+export { Mode, Priority, Kind, Reentrance, Isolation } from "./Enums.js";
+export type { ReactiveOperation, ReactivityOptions, SnapshotOptions, LoggingOptions, ProfilingOptions } from "./Options.js";
 export type { Worker } from "./Worker.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
 export type { BoolOnly, GivenTypeOnly } from "./Ref.js";
-export { TransactionalObject, TriggeringObject } from "./core/Mvcc.js";
-export { TransactionalArray, TriggeringArray } from "./core/MvccArray.js";
-export { TransactionalMap, TriggeringMap } from "./core/MvccMap.js";
+export { AtomicObject, ObservableObject } from "./core/Mvcc.js";
+export { AtomicArray, ObservableArray } from "./core/MvccArray.js";
+export { AtomicMap, ObservableMap } from "./core/MvccMap.js";
 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 { 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";
+export { runAtomically, runNonReactively, runSensitively, runContextually, manageReactiveOperation, configureCurrentReactiveOperation, disposeObservableObject } from "./System.js";
+export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
+export { ReactiveOperationEx } from "./OperationEx.js";
+export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { ReactiveTree } from "./core/Tree.js";
+export type { Script, ScriptAsync, Handler, ReactiveTreeNodeDecl, ReactiveTreeNodeDriver, ReactiveTreeNodeContext } from "./core/TreeNode.js";

package/build/dist/source/api.js

@@ -3,16 +3,18 @@ export { MergeList } from "./util/MergeList.js";
 export { SealedArray } from "./util/SealedArray.js";
 export { SealedMap } from "./util/SealedMap.js";
 export { SealedSet } from "./util/SealedSet.js";
-export { Kind, Reentrance, Isolation, LoggingLevel } from "./Options.js";
+export { LoggingLevel } from "./Options.js";
+export { Mode, Priority, Kind, Reentrance, Isolation } from "./Enums.js";
 export { Ref, ToggleRef, refs, toggleRefs, customToggleRefs } from "./Ref.js";
-export { TransactionalObject, TriggeringObject } from "./core/Mvcc.js";
-export { TransactionalArray, TriggeringArray } from "./core/MvccArray.js";
-export { TransactionalMap, TriggeringMap } from "./core/MvccMap.js";
+export { AtomicObject, ObservableObject } from "./core/Mvcc.js";
+export { AtomicArray, ObservableArray } from "./core/MvccArray.js";
+export { AtomicMap, ObservableMap } from "./core/MvccMap.js";
 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 { 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 { runAtomically, runNonReactively, runSensitively, runContextually, manageReactiveOperation, configureCurrentReactiveOperation, disposeObservableObject } from "./System.js";
+export { ReactiveSystem, observable, atomic, reactive, cached, options } from "./System.js";
+export { ReactiveOperationEx } from "./OperationEx.js";
+export { ReactiveTreeNode, BaseDriver, ReactiveTreeVariable } from "./core/TreeNode.js";
+export { ReactiveTree } from "./core/Tree.js";