reactronic 0.22.300 → 0.22.303

package/README.md

@@ -19,13 +19,13 @@ 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, because reactronic **takes full care of tracking dependencies**
-between visual components (subscribers) and state (subscribing objects).
+between visual components (subscribers) and state (reactive objects).
 
 Transactional reactivity is based on four fundamental concepts:
 
-  - **Subscribing Objects** - a set of objects that store data of an
+  - **Reactive Objects** - a set of objects that store data of an
     application (state) and maintain subscription lists;
-  - **Transaction** - a function that makes changes in subscribing
+  - **Transaction** - a function that makes changes in reactive
     objects in transactional (atomic) way;
   - **Reaction** - a function that is executed automatically in
     response to changes made by a transaction;
@@ -40,10 +40,10 @@ Quick introduction and detailed description is below.
 ## Quick Introduction
 
 Here is an example of transactional reactive code with
-subscribing object, transaction and reaction:
+reactive object, transaction and reaction:
 
 ``` typescript
-class Demo extends SubscribingObject {
+class Demo extends ReactiveObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -70,7 +70,7 @@ to changes of these fields made by `saveContact` transaction.
 Here is an example of if cached value computed on-demand:
 
 ``` typescript
-class Demo extends SubscribingObject {
+class Demo extends ReactiveObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -95,14 +95,14 @@ invalidated, thus causing execution of depending reaction
 `printContact`. Then `printContact` reaction causes `contact`
 re-computation on the first use.
 
-## Subscribing Objects
+## Reactive Objects
 
-Subscribing objects store data of an application. All such objects
+Reactive objects 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 SubscribingObject {
+class MyModel extends ReactiveObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -110,18 +110,18 @@ class MyModel extends SubscribingObject {
 ```
 
 In the example above, the class `MyModel` is based on Reactronic's
-`SubscribingObject` class and all its properties `url`, `content`,
+`ReactiveObject` class and all its properties `url`, `content`,
 and `timestamp` are hooked.
 
 ## Transaction
 
-Transaction is a function that makes changes in subscribing objects
+Transaction is a function that makes changes in reactive objects
 in transactional (atomic) way. Such a function is instrumented with hooks
 to provide transparent atomicity (by implicit context switching
 and isolation).
 
 ``` typescript
-class MyModel extends SubscribingObject {
+class MyModel extends ReactiveObject {
   // ...
   @transaction
   async load(url: string): Promise<void> {
@@ -164,12 +164,12 @@ of asynchronous operations is fully completed.
 ## Reaction & Cache
 
 Reaction is an code block that is immediately called in response to
-changes made by a transaction in subscribing objects. Cache is a
+changes made by a transaction in reactive objects. Cache is a
 computed value having an associated function that is called
 on-demand to renew the value if it was marked as obsolete due to changes
 made by a transaction. Reactive and cached functions are
 instrumented with hooks to seamlessly subscribe to those
-subscribing objects and other cached functions (dependencies),
+reactive objects and other cached functions (dependencies),
 which are used during their execution.
 
 ``` tsx
@@ -223,15 +223,15 @@ function enqueues re-rendering request to React, which calls
 `render` function causing it to renew its cached value.
 
 In general case, all reactions and caches are automatically and
-immediately marked as obsolete when changes are made in those subscribing
+immediately marked as obsolete when changes are made in those reactive
 objects and cached functions 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 subscribing objects and reactions/caches (subscribing objects
-and subscribers). With Reactronic, you no longer need to create data change events
+all the reactive objects and reactions/caches.
+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 switching from the previous object version
 to a new one.
@@ -292,17 +292,17 @@ NPM: `npm install reactronic`
 
 // Classes
 
-class SubscribingObject { }
+class ReactiveObject { }
 
 // Decorators & Operators
 
-function subscribeless(proto, prop) // field only
+function isnonreactive(proto, prop) // field only
 function transaction(proto, prop, pd) // method only
 function reaction(proto, prop, pd) // method only
 function cached(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
-function nonsubscribing<T>(func: F<T>, ...args: any[]): T
+function nonreactive<T>(func: F<T>, ...args: any[]): T
 function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 // SnapshotOptions, MemberOptions, Kind, Reentrance, Monitor, LoggingOptions, ProfilingOptions

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

@@ -1,5 +1,5 @@
-import { SubscribingObject } from './impl/Hooks';
-export declare abstract class Buffer<T> extends SubscribingObject {
+import { ReactiveObject } from './impl/Hooks';
+export declare abstract class Buffer<T> extends ReactiveObject {
     abstract readonly capacity: number;
     abstract readonly count: number;
     abstract put(...items: T[]): void;

package/build/dist/source/Buffer.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Buffer = void 0;
 const Hooks_1 = require("./impl/Hooks");
-class Buffer extends Hooks_1.SubscribingObject {
+class Buffer extends Hooks_1.ReactiveObject {
     static create(hint, capacity) { throw new Error('not implemented'); }
 }
 exports.Buffer = Buffer;

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

@@ -23,12 +23,12 @@ export interface ProfilingOptions {
     garbageCollectionSummaryInterval: number;
 }
 export declare const LoggingLevel: {
-    Off: LoggingOptions;
-    ErrorsOnly: LoggingOptions;
-    Reactions: LoggingOptions;
-    Transactions: LoggingOptions;
-    Operations: LoggingOptions;
-    Debug: LoggingOptions;
+    readonly Off: LoggingOptions;
+    readonly ErrorsOnly: LoggingOptions;
+    readonly Reactions: LoggingOptions;
+    readonly Transactions: LoggingOptions;
+    readonly Operations: LoggingOptions;
+    readonly Debug: LoggingOptions;
 };
 declare global {
     interface Window {

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

@@ -11,7 +11,7 @@ export declare class Ref<T = any> {
     constructor(owner: any, name: string, index?: number);
     get value(): T;
     set value(value: T);
-    nonsubscribing(): T;
+    nonreactive(): T;
     observe(): T;
     unobserve(): T;
     static to<O extends object = object>(owner: O): {

package/build/dist/source/Ref.js

@@ -21,8 +21,8 @@ class Ref {
         else
             this.owner[this.name][this.index] = value;
     }
-    nonsubscribing() {
-        return (0, Rx_1.nonsubscribing)(() => this.value);
+    nonreactive() {
+        return (0, Rx_1.nonreactive)(() => this.value);
     }
     observe() {
         return this.value;

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

@@ -2,6 +2,7 @@ import { F } from './util/Utils';
 import { Controller } from './Controller';
 import { MemberOptions, LoggingOptions, ProfilingOptions } from './Options';
 export declare class Rx {
+    static getRevisionOf(obj: any): number;
     static why(brief?: boolean): string;
     static getController<T>(method: F<T>): Controller<T>;
     static pullLastResult<T>(method: F<Promise<T>>, args?: any[]): T | undefined;
@@ -17,9 +18,9 @@ export declare class Rx {
     static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
-export declare function nonsubscribing<T>(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 subscribeless(proto: object, prop: PropertyKey): any;
+export declare function isnonreactive(proto: object, prop: PropertyKey): any;
 export declare function transaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function reaction(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;
 export declare function cached(proto: object, prop: PropertyKey, pd: PropertyDescriptor): any;

package/build/dist/source/Rx.js

@@ -1,41 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.options = exports.cached = exports.reaction = exports.transaction = exports.subscribeless = exports.sensitive = exports.nonsubscribing = exports.Rx = void 0;
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = void 0;
 const Dbg_1 = require("./util/Dbg");
 const Options_1 = require("./Options");
 const Data_1 = require("./impl/Data");
-const Snapshot_1 = require("./impl/Snapshot");
+const Changeset_1 = require("./impl/Changeset");
 const Hooks_1 = require("./impl/Hooks");
 const Operation_1 = require("./impl/Operation");
 class Rx {
+    static getRevisionOf(obj) { return obj[Data_1.Meta.Revision]; }
     static why(brief = false) { return brief ? Operation_1.OperationController.briefWhy() : Operation_1.OperationController.why(); }
     static getController(method) { return Operation_1.OperationController.of(method); }
     static pullLastResult(method, args) { return Rx.getController(method).pullLastResult(args); }
     static configureCurrentOperation(options) { return Operation_1.OperationController.configureImpl(undefined, options); }
-    static takeSnapshot(obj) { return Snapshot_1.Snapshot.takeSnapshot(obj); }
-    static dispose(obj) { Snapshot_1.Snapshot.dispose(obj); }
+    static takeSnapshot(obj) { return Changeset_1.Changeset.takeSnapshot(obj); }
+    static dispose(obj) { Changeset_1.Changeset.dispose(obj); }
     static get reactionsAutoStartDisabled() { return Hooks_1.Hooks.reactionsAutoStartDisabled; }
     static set reactionsAutoStartDisabled(value) { Hooks_1.Hooks.reactionsAutoStartDisabled = value; }
     static get isLogging() { return Dbg_1.Log.isOn; }
     static get loggingOptions() { return Dbg_1.Log.opt; }
     static setLoggingMode(isOn, options) { Dbg_1.Log.setMode(isOn, options); }
     static setLoggingHint(obj, name) { Hooks_1.Hooks.setHint(obj, name); }
-    static getLoggingHint(obj, full = false) { return Data_1.DataHolder.getHint(obj, full); }
+    static getLoggingHint(obj, full = false) { return Data_1.ObjectHandle.getHint(obj, full); }
     static setProfilingMode(isOn, options) { Hooks_1.Hooks.setProfilingMode(isOn, options); }
 }
 exports.Rx = Rx;
-function nonsubscribing(func, ...args) {
+function nonreactive(func, ...args) {
     return Operation_1.OperationController.runWithin(undefined, func, ...args);
 }
-exports.nonsubscribing = nonsubscribing;
+exports.nonreactive = nonreactive;
 function sensitive(sensitivity, func, ...args) {
     return Hooks_1.Hooks.sensitive(sensitivity, func, ...args);
 }
 exports.sensitive = sensitive;
-function subscribeless(proto, prop) {
+function isnonreactive(proto, prop) {
     return Hooks_1.Hooks.decorateData(false, proto, prop);
 }
-exports.subscribeless = subscribeless;
+exports.isnonreactive = isnonreactive;
 function transaction(proto, prop, pd) {
     const opts = { kind: Options_1.Kind.Transaction };
     return Hooks_1.Hooks.decorateOperation(true, transaction, opts, proto, prop, pd);

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

@@ -6,9 +6,9 @@ export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, Profi
 export { Worker } from './Worker';
 export { Controller } from './Controller';
 export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
-export { SubscribingObject } from './impl/Hooks';
-export { Snapshot } from './impl/Snapshot';
+export { ReactiveObject } from './impl/Hooks';
+export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, nonsubscribing, sensitive, subscribeless, transaction, reaction, cached, options } from './Rx';
+export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.options = exports.cached = exports.reaction = exports.transaction = exports.subscribeless = exports.sensitive = exports.nonsubscribing = exports.Rx = exports.Journal = exports.Monitor = exports.Transaction = exports.Snapshot = exports.SubscribingObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.LoggingLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.isnonreactive = exports.sensitive = exports.nonreactive = exports.Rx = exports.Journal = exports.Monitor = exports.Transaction = exports.Changeset = exports.ReactiveObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.LoggingLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
 var Utils_1 = require("./util/Utils");
 Object.defineProperty(exports, "all", { enumerable: true, get: function () { return Utils_1.all; } });
 Object.defineProperty(exports, "pause", { enumerable: true, get: function () { return Utils_1.pause; } });
@@ -20,9 +20,9 @@ var Ref_1 = require("./Ref");
 Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return Ref_1.Ref; } });
 Object.defineProperty(exports, "ToggleRef", { enumerable: true, get: function () { return Ref_1.ToggleRef; } });
 var Hooks_1 = require("./impl/Hooks");
-Object.defineProperty(exports, "SubscribingObject", { enumerable: true, get: function () { return Hooks_1.SubscribingObject; } });
-var Snapshot_1 = require("./impl/Snapshot");
-Object.defineProperty(exports, "Snapshot", { enumerable: true, get: function () { return Snapshot_1.Snapshot; } });
+Object.defineProperty(exports, "ReactiveObject", { enumerable: true, get: function () { return Hooks_1.ReactiveObject; } });
+var Changeset_1 = require("./impl/Changeset");
+Object.defineProperty(exports, "Changeset", { enumerable: true, get: function () { return Changeset_1.Changeset; } });
 var Transaction_1 = require("./impl/Transaction");
 Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return Transaction_1.Transaction; } });
 var Monitor_1 = require("./impl/Monitor");
@@ -31,9 +31,9 @@ var Journal_1 = require("./impl/Journal");
 Object.defineProperty(exports, "Journal", { enumerable: true, get: function () { return Journal_1.Journal; } });
 var Rx_1 = require("./Rx");
 Object.defineProperty(exports, "Rx", { enumerable: true, get: function () { return Rx_1.Rx; } });
-Object.defineProperty(exports, "nonsubscribing", { enumerable: true, get: function () { return Rx_1.nonsubscribing; } });
+Object.defineProperty(exports, "nonreactive", { enumerable: true, get: function () { return Rx_1.nonreactive; } });
 Object.defineProperty(exports, "sensitive", { enumerable: true, get: function () { return Rx_1.sensitive; } });
-Object.defineProperty(exports, "subscribeless", { enumerable: true, get: function () { return Rx_1.subscribeless; } });
+Object.defineProperty(exports, "isnonreactive", { enumerable: true, get: function () { return Rx_1.isnonreactive; } });
 Object.defineProperty(exports, "transaction", { enumerable: true, get: function () { return Rx_1.transaction; } });
 Object.defineProperty(exports, "reaction", { enumerable: true, get: function () { return Rx_1.reaction; } });
 Object.defineProperty(exports, "cached", { enumerable: true, get: function () { return Rx_1.cached; } });

package/build/dist/source/impl/Changeset.d.ts

@@ -0,0 +1,60 @@
+import { Kind, SnapshotOptions } from '../Options';
+import { AbstractChangeset, ObjectSnapshot, MemberName, ObjectHandle, Subscription, Subscriber } from './Data';
+export declare const MAX_REVISION: number;
+export declare const UNDEFINED_REVISION: number;
+export declare class Changeset implements AbstractChangeset {
+    static idGen: number;
+    private static stampGen;
+    private static pending;
+    private static oldest;
+    static garbageCollectionSummaryInterval: number;
+    static lastGarbageCollectionSummaryTimestamp: number;
+    static totalObjectHandleCount: number;
+    static totalObjectSnapshotCount: number;
+    readonly id: number;
+    readonly options: SnapshotOptions;
+    get hint(): string;
+    get timestamp(): number;
+    private revision;
+    private bumper;
+    items: Map<ObjectHandle, ObjectSnapshot>;
+    reactions: Subscriber[];
+    sealed: boolean;
+    constructor(options: SnapshotOptions | null);
+    static current: () => Changeset;
+    static edit: () => Changeset;
+    static markUsed: (subscription: Subscription, os: ObjectSnapshot, m: MemberName, h: ObjectHandle, kind: Kind, weak: boolean) => void;
+    static markEdited: (oldValue: any, newValue: any, edited: boolean, os: ObjectSnapshot, m: MemberName, h: ObjectHandle) => void;
+    static isConflicting: (oldValue: any, newValue: any) => boolean;
+    static propagateAllChangesThroughSubscriptions: (changeset: Changeset) => void;
+    static revokeAllSubscriptions: (changeset: Changeset) => void;
+    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
+    seekSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getRelevantSnapshot(h: ObjectHandle, m: MemberName): ObjectSnapshot;
+    getEditableSnapshot(h: ObjectHandle, m: MemberName, value: any, token?: any): ObjectSnapshot;
+    static takeSnapshot<T>(obj: T): T;
+    static dispose(obj: any): void;
+    static doDispose(ctx: Changeset, h: ObjectHandle): ObjectSnapshot;
+    private isNewSnapshotRequired;
+    acquire(outer: Changeset): void;
+    bumpBy(timestamp: number): void;
+    rebase(): ObjectSnapshot[] | undefined;
+    private merge;
+    applyOrDiscard(error?: any): Array<Subscriber>;
+    static sealObjectSnapshot(h: ObjectHandle, os: ObjectSnapshot): void;
+    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
+    static freezeObjectSnapshot(os: ObjectSnapshot): ObjectSnapshot;
+    triggerGarbageCollection(): void;
+    private unlinkHistory;
+    static _init(): void;
+}
+export declare class Dump {
+    static valueHint: (value: any, m?: PropertyKey | undefined) => string;
+    static obj(h: ObjectHandle | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
+    static snapshot2(h: ObjectHandle, s: AbstractChangeset, m?: MemberName, o?: Subscription): string;
+    static snapshot(os: ObjectSnapshot, m?: MemberName): string;
+    static conflicts(conflicts: ObjectSnapshot[]): string;
+    static conflictingMemberHint(m: MemberName, ours: ObjectSnapshot, theirs: ObjectSnapshot): string;
+}
+export declare const EMPTY_SNAPSHOT: ObjectSnapshot;
+export declare const DefaultSnapshotOptions: SnapshotOptions;