reactronic 0.22.316 → 0.22.317

package/README.md

@@ -18,13 +18,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 (reactive objects).
+between visual components (observers) and state (observable objects).
 
 Transactional reactivity is based on four fundamental concepts:
 
-  - **Reactive Objects** - a set of objects that store data of an
+  - **Observable Objects** - a set of objects that store data of an
     application (state) and maintain subscription lists;
-  - **Transaction** - a function that makes changes in reactive
+  - **Transaction** - a function that makes changes in observable
     objects in transactional (atomic) way;
   - **Reaction** - a function that is executed automatically in
     response to changes made by a transaction;
@@ -39,10 +39,10 @@ Quick introduction and detailed description is below.
 ## Quick Introduction
 
 Here is an example of transactional reactive code with
-reactive object, transaction and reaction:
+observable object, transaction and reaction:
 
 ``` typescript
-class Demo extends ReactiveObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -69,7 +69,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 ReactiveObject {
+class Demo extends ObservableObject {
   name: string = 'Nezaboodka Software'
   email: string = 'contact@nezaboodka.com'
 
@@ -94,14 +94,14 @@ invalidated, thus causing execution of depending reaction
 `printContact`. Then `printContact` reaction causes `contact`
 re-computation on the first use.
 
-## Reactive Objects
+## Observable Objects
 
-Reactive objects store data of an application. All such objects
+Observable 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 ReactiveObject {
+class MyModel extends ObservableObject {
   url: string = "https://github.com/nezaboodka/reactronic"
   content: string = "transactional reactive state management"
   timestamp: Date = Date.now()
@@ -109,18 +109,18 @@ class MyModel extends ReactiveObject {
 ```
 
 In the example above, the class `MyModel` is based on Reactronic's
-`ReactiveObject` class and all its properties `url`, `content`,
+`ObservableObject` class and all its properties `url`, `content`,
 and `timestamp` are hooked.
 
 ## Transaction
 
-Transaction is a function that makes changes in reactive objects
+Transaction is a function that makes changes in observable 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 ReactiveObject {
+class MyModel extends ObservableObject {
   // ...
   @transaction
   async load(url: string): Promise<void> {
@@ -163,12 +163,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 reactive objects. Cache is a
+changes made by a transaction in observable 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
-reactive objects and other cached functions (dependencies),
+observable objects and other cached functions (dependencies),
 which are used during their execution.
 
 ``` tsx
@@ -222,14 +222,14 @@ 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 reactive
+immediately marked as obsolete when changes are made in those observable
 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 reactive objects and reactions/caches.
+all the observable 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
@@ -292,7 +292,7 @@ NPM: `npm install reactronic`
 // Classes
 
 class TransactionalObject { }
-class ReactiveObject { }
+class ObservableObject { }
 
 // Decorators & Operators
 

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

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

package/build/dist/source/Buffer.js

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './impl/Mvcc';
-export class Buffer extends ReactiveObject {
+import { ObservableObject } from './impl/Mvcc';
+export class Buffer extends ObservableObject {
     static create(hint, capacity) { throw new Error('not implemented'); }
 }

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

@@ -7,9 +7,9 @@ export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, Profi
 export { Worker } from './Worker';
 export { Controller } from './Controller';
 export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
-export { TransactionalObject, ReactiveObject } from './impl/Mvcc';
-export { TransactionalArray, ReactiveArray } from './impl/MvccArray';
-export { TransactionalMap, ReactiveMap } from './impl/MvccMap';
+export { TransactionalObject, ObservableObject } from './impl/Mvcc';
+export { TransactionalArray, ObservableArray } from './impl/MvccArray';
+export { TransactionalMap, ObservableMap } from './impl/MvccMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';

package/build/dist/source/api.js

@@ -6,9 +6,9 @@ export { SealedSet } from './util/SealedSet';
 export { Kind, Reentrance, LoggingLevel } from './Options';
 export { Controller } from './Controller';
 export { Ref, ToggleRef } from './Ref';
-export { TransactionalObject, ReactiveObject } from './impl/Mvcc';
-export { TransactionalArray, ReactiveArray } from './impl/MvccArray';
-export { TransactionalMap, ReactiveMap } from './impl/MvccMap';
+export { TransactionalObject, ObservableObject } from './impl/Mvcc';
+export { TransactionalArray, ObservableArray } from './impl/MvccArray';
+export { TransactionalMap, ObservableMap } from './impl/MvccMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';

package/build/dist/source/impl/Changeset.js

@@ -16,7 +16,7 @@ Object.defineProperty(ObjectHandle.prototype, '#this#', {
             const v = data[m];
             if (v instanceof Subscription)
                 result[m] = v.content;
-            else if (v === Meta.Nonreactive)
+            else if (v === Meta.Raw)
                 result[m] = this.data[m];
             else
                 result[m] = v;
@@ -61,7 +61,7 @@ export class Changeset {
     getEditableObjectSnapshot(h, m, value, token) {
         let os = this.lookupObjectSnapshot(h, m);
         const existing = os.data[m];
-        if (existing !== Meta.Nonreactive) {
+        if (existing !== Meta.Raw) {
             if (this.isNewSnapshotRequired(h, os, m, existing, value, token)) {
                 this.bumpBy(os.changeset.timestamp);
                 const revision = m === Meta.Handle ? 1 : os.revision + 1;
@@ -97,7 +97,7 @@ export class Changeset {
     }
     isNewSnapshotRequired(h, os, m, existing, value, token) {
         if (this.sealed && os.changeset !== EMPTY_SNAPSHOT.changeset)
-            throw misuse(`reactive property ${Dump.obj(h, m)} can only be modified inside transaction`);
+            throw misuse(`observable property ${Dump.obj(h, m)} can only be modified inside transaction`);
         if (m !== Meta.Handle) {
             if (value !== Meta.Handle) {
                 if (os.changeset !== this || os.former.snapshot !== EMPTY_SNAPSHOT) {

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

@@ -1,7 +1,7 @@
-import { ReactiveObject } from './Mvcc';
+import { ObservableObject } from './Mvcc';
 import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
 export declare type Saver = (patch: PatchSet) => Promise<void>;
-export declare abstract class Journal extends ReactiveObject {
+export declare abstract class Journal extends ObservableObject {
     abstract capacity: number;
     abstract readonly edits: ReadonlyArray<PatchSet>;
     abstract readonly unsaved: PatchSet;

package/build/dist/source/impl/Journal.js

@@ -1,9 +1,9 @@
-import { ReactiveObject } from './Mvcc';
+import { ObservableObject } from './Mvcc';
 import { Meta, Subscription } from './Data';
 import { Changeset, EMPTY_SNAPSHOT } from './Changeset';
 import { Transaction } from './Transaction';
 import { Sealant } from '../util/Sealant';
-export class Journal extends ReactiveObject {
+export class Journal extends ObservableObject {
     static create() { return new JournalImpl(); }
 }
 export class JournalImpl extends Journal {

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

@@ -4,7 +4,7 @@ export declare abstract class Meta {
     static readonly Controller: unique symbol;
     static readonly Initial: unique symbol;
     static readonly Reactions: unique symbol;
-    static readonly Nonreactive: unique symbol;
+    static readonly Raw: unique symbol;
     static readonly Undefined: unique symbol;
     static get<T>(obj: any, sym: symbol): T;
     static set(obj: any, sym: symbol, value: any): any;

package/build/dist/source/impl/Meta.js

@@ -25,5 +25,5 @@ Meta.Revision = Symbol('rx-revision');
 Meta.Controller = Symbol('rx-controller');
 Meta.Initial = Symbol('rx-initial');
 Meta.Reactions = Symbol('rx-reactions');
-Meta.Nonreactive = Symbol('rx-nonreactive');
+Meta.Raw = Symbol('rx-raw');
 Meta.Undefined = Symbol('rx-undefined');

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

@@ -1,6 +1,6 @@
 import { Worker } from '../Worker';
-import { ReactiveObject } from './Mvcc';
-export declare abstract class Monitor extends ReactiveObject {
+import { ObservableObject } from './Mvcc';
+export declare abstract class Monitor extends ObservableObject {
     abstract readonly isActive: boolean;
     abstract readonly counter: number;
     abstract readonly workers: ReadonlySet<Worker>;

package/build/dist/source/impl/Monitor.js

@@ -1,6 +1,6 @@
-import { ReactiveObject, Mvcc } from './Mvcc';
+import { ObservableObject, Mvcc } from './Mvcc';
 import { Transaction } from './Transaction';
-export class Monitor extends ReactiveObject {
+export class Monitor extends ObservableObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return MonitorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
     }

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

@@ -5,13 +5,13 @@ import { MemberName, ObjectHandle, SeparationMode } from './Data';
 import { Journal } from './Journal';
 import { Monitor } from './Monitor';
 export declare abstract class MvccObject {
-    protected constructor(reactive: boolean);
+    protected constructor(observable: boolean);
     [Symbol.toStringTag](): string;
 }
 export declare abstract class TransactionalObject extends MvccObject {
     constructor();
 }
-export declare abstract class ReactiveObject extends MvccObject {
+export declare abstract class ObservableObject extends MvccObject {
     constructor();
 }
 export declare class OptionsImpl implements MemberOptions {
@@ -37,20 +37,20 @@ export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
     static readonly transactional: Mvcc;
-    static readonly reactive: Mvcc;
-    readonly isReactive: boolean;
-    constructor(isReactive: boolean);
+    static readonly observable: Mvcc;
+    readonly isObservable: boolean;
+    constructor(isObservable: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
     get(h: ObjectHandle, m: MemberName, receiver: any): any;
     set(h: ObjectHandle, m: MemberName, value: any, receiver: any): boolean;
     has(h: ObjectHandle, m: MemberName): boolean;
     getOwnPropertyDescriptor(h: ObjectHandle, m: MemberName): PropertyDescriptor | undefined;
     ownKeys(h: ObjectHandle): Array<string | symbol>;
-    static decorateData(reactive: boolean, proto: any, m: MemberName): any;
+    static decorateData(isObservable: boolean, proto: any, m: MemberName): any;
     static decorateOperation(implicit: boolean, decorator: Function, options: Partial<MemberOptions>, proto: any, member: MemberName, pd: PropertyDescriptor | undefined): any;
     static decorateOperationParametrized(decorator: Function, options: Partial<MemberOptions>): F<any>;
     static acquireHandle(obj: any): ObjectHandle;
-    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, reactive: boolean): ObjectHandle;
+    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, isObservable: boolean): ObjectHandle;
     static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
     static sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;
     static setHint<T>(obj: T, hint: string | undefined): T;

package/build/dist/source/impl/Mvcc.js

@@ -4,10 +4,10 @@ import { Kind, Reentrance } from '../Options';
 import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset';
 export class MvccObject {
-    constructor(reactive) {
+    constructor(observable) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, reactive);
+        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, observable);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -20,7 +20,7 @@ export class TransactionalObject extends MvccObject {
         super(false);
     }
 }
-export class ReactiveObject extends MvccObject {
+export class ObservableObject extends MvccObject {
     constructor() {
         super(true);
     }
@@ -60,8 +60,8 @@ function merge(def, existing, patch, implicit) {
     return patch !== undefined && (existing === def || !implicit) ? patch : existing;
 }
 export class Mvcc {
-    constructor(isReactive) {
-        this.isReactive = isReactive;
+    constructor(isObservable) {
+        this.isObservable = isObservable;
     }
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
@@ -73,7 +73,7 @@ export class Mvcc {
             const os = cs.getObjectSnapshot(h, m);
             result = os.data[m];
             if (result instanceof Subscription && !result.isOperation) {
-                if (this.isReactive)
+                if (this.isObservable)
                     Changeset.markUsed(result, os, m, h, Kind.Plain, false);
                 result = result.content;
             }
@@ -129,22 +129,22 @@ export class Mvcc {
         }
         return result;
     }
-    static decorateData(reactive, proto, m) {
-        if (reactive) {
+    static decorateData(isObservable, proto, m) {
+        if (isObservable) {
             const get = function () {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.reactive.get(h, m, this);
+                return Mvcc.observable.get(h, m, this);
             };
             const set = function (value) {
                 const h = Mvcc.acquireHandle(this);
-                return Mvcc.reactive.set(h, m, value, this);
+                return Mvcc.observable.set(h, m, value, this);
             };
             const enumerable = true;
             const configurable = false;
             return Object.defineProperty(proto, m, { get, set, enumerable, configurable });
         }
         else
-            Meta.acquire(proto, Meta.Initial)[m] = Meta.Nonreactive;
+            Meta.acquire(proto, Meta.Initial)[m] = Meta.Raw;
     }
     static decorateOperation(implicit, decorator, options, proto, member, pd) {
         var _a, _b, _c, _d;
@@ -183,19 +183,19 @@ export class Mvcc {
         let h = obj[Meta.Handle];
         if (!h) {
             if (obj !== Object(obj) || Array.isArray(obj))
-                throw misuse('only objects can be reactive');
+                throw misuse('only objects can be observable');
             const initial = Meta.getFrom(Object.getPrototypeOf(obj), Meta.Initial);
             const os = new ObjectSnapshot(EMPTY_SNAPSHOT.changeset, EMPTY_SNAPSHOT, Object.assign({}, initial));
-            h = new ObjectHandle(obj, obj, Mvcc.reactive, os, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Mvcc.observable, os, obj.constructor.name);
             Meta.set(os.data, Meta.Handle, h);
             Meta.set(obj, Meta.Handle, h);
             Meta.set(os.data, Meta.Revision, new Subscription(1));
         }
         return h;
     }
-    static createHandleForMvccObject(proto, data, blank, hint, reactive) {
+    static createHandleForMvccObject(proto, data, blank, hint, isObservable) {
         const ctx = Changeset.edit();
-        const mvcc = reactive ? Mvcc.reactive : Mvcc.transactional;
+        const mvcc = isObservable ? Mvcc.observable : Mvcc.transactional;
         const h = new ObjectHandle(data, undefined, mvcc, EMPTY_SNAPSHOT, hint);
         ctx.getEditableObjectSnapshot(h, Meta.Handle, blank);
         if (!Mvcc.reactionsAutoStartDisabled)
@@ -245,7 +245,7 @@ Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Mvcc.sensitivity = false;
 Mvcc.transactional = new Mvcc(false);
-Mvcc.reactive = new Mvcc(true);
+Mvcc.observable = new Mvcc(true);
 Mvcc.createOperation = function (h, m, options) {
     throw misuse('this implementation of createOperation should never be called');
 };

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

@@ -1,7 +1,7 @@
 import { MvccObject } from './Mvcc';
 export declare class MvccArray<T> extends MvccObject {
     private all;
-    constructor(reactive: boolean, array: Array<T>);
+    constructor(isObservable: boolean, array: Array<T>);
     get length(): number;
     set length(n: number);
     getItem(n: number): T;
@@ -52,7 +52,7 @@ export declare class TransactionalArray<T> extends MvccArray<T> {
     constructor(arrayLength?: number);
     constructor(...items: T[]);
 }
-export declare class ReactiveArray<T> extends MvccArray<T> {
+export declare class ObservableArray<T> extends MvccArray<T> {
     constructor();
     constructor(arrayLength: number);
     constructor(arrayLength?: number);

package/build/dist/source/impl/MvccArray.js

@@ -1,8 +1,8 @@
 import { Sealant } from '../util/Sealant';
 import { MvccObject } from './Mvcc';
 export class MvccArray extends MvccObject {
-    constructor(reactive, array) {
-        super(reactive);
+    constructor(isObservable, array) {
+        super(isObservable);
         this.all = array;
     }
     get length() { return this.all.length; }
@@ -51,7 +51,7 @@ export class TransactionalArray extends MvccArray {
         super(false, args !== undefined ? new Array(args) : new Array());
     }
 }
-export class ReactiveArray extends MvccArray {
+export class ObservableArray extends MvccArray {
     constructor(args) {
         super(true, args !== undefined ? new Array(args) : new Array());
     }

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

@@ -1,6 +1,6 @@
 import { Collection, Item, CollectionReader } from '../util/Collection';
-import { ReactiveObject } from './Mvcc';
-export declare abstract class ReactiveCollection<T> extends ReactiveObject implements CollectionReader<T> {
+import { ObservableObject } from './Mvcc';
+export declare abstract class ObservableCollection<T> extends ObservableObject implements CollectionReader<T> {
     protected abstract a: Collection<T>;
     get strict(): boolean;
     get count(): number;

package/build/dist/source/impl/MvccCollection.js

@@ -1,5 +1,5 @@
-import { ReactiveObject } from './Mvcc';
-export class ReactiveCollection extends ReactiveObject {
+import { ObservableObject } from './Mvcc';
+export class ObservableCollection extends ObservableObject {
     get strict() { return this.a.strict; }
     get count() { return this.a.count; }
     get addedCount() { return this.a.addedCount; }

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

@@ -1,7 +1,7 @@
 import { MvccObject } from './Mvcc';
 export declare class MvccMap<K, V> extends MvccObject {
     private all;
-    constructor(reactive: boolean, map: Map<K, V>);
+    constructor(isObservable: boolean, map: Map<K, V>);
     clear(): void;
     delete(key: K): boolean;
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
@@ -19,7 +19,7 @@ export declare class TransactionalMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }
-export declare class ReactiveMap<K, V> extends MvccMap<K, V> {
+export declare class ObservableMap<K, V> extends MvccMap<K, V> {
     constructor();
     constructor(iterable?: Iterable<readonly [K, V]> | null);
 }

package/build/dist/source/impl/MvccMap.js

@@ -1,8 +1,8 @@
 import { Sealant } from '../util/Sealant';
 import { MvccObject } from './Mvcc';
 export class MvccMap extends MvccObject {
-    constructor(reactive, map) {
-        super(reactive);
+    constructor(isObservable, map) {
+        super(isObservable);
         this.all = map;
     }
     clear() { this.mutable.clear(); }
@@ -28,7 +28,7 @@ export class TransactionalMap extends MvccMap {
         super(true, args !== undefined ? new Map(args) : new Map());
     }
 }
-export class ReactiveMap extends MvccMap {
+export class ObservableMap extends MvccMap {
     constructor(args) {
         super(true, args !== undefined ? new Map(args) : new Map());
     }

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

@@ -9,7 +9,7 @@ import { Mvcc, OptionsImpl } from './Mvcc';
 import { JournalImpl } from './Journal';
 const BOOT_ARGS = [];
 const BOOT_CAUSE = '<boot>';
-const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.reactive, EMPTY_SNAPSHOT, '<empty>');
+const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Mvcc.observable, EMPTY_SNAPSHOT, '<empty>');
 export class OperationController extends Controller {
     constructor(h, m) {
         super();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.22.316",
+  "version": "0.22.317",
   "description": "Reactronic - Transactional Reactive State Management",
   "type": "module",
   "main": "build/dist/source/api.js",