reactronic 0.22.313 → 0.22.316

package/README.md

@@ -195,7 +195,7 @@ class Component<P> extends React.Component<P> {
   @reaction // called immediately in response to changes
   ensureUpToDate(): void {
     if (this.shouldComponentUpdate())
-      Transaction.off(() => this.setState({})) // ask React to re-render
+      Transaction.outside(() => this.setState({})) // ask React to re-render
   } // ensureUpToDate is subscribed to render
 
   shouldComponentUpdate(): boolean {
@@ -291,11 +291,12 @@ NPM: `npm install reactronic`
 
 // Classes
 
+class TransactionalObject { }
 class ReactiveObject { }
 
 // Decorators & Operators
 
-function isnonreactive(proto, prop) // field only
+function raw(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
@@ -308,7 +309,7 @@ function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
 export interface SnapshotOptions {
   readonly hint?: string
-  readonly standalone?: StandaloneMode
+  readonly separation?: SeparationMode
   readonly journal?: Journal
   readonly logging?: Partial<LoggingOptions>
   readonly token?: any
@@ -316,7 +317,7 @@ export interface SnapshotOptions {
 
 interface MemberOptions {
   readonly kind: Kind
-  readonly standalone: StandaloneMode
+  readonly separation: SeparationMode
   readonly order: number
   readonly noSideEffects: boolean
   readonly triggeringArgs: boolean
@@ -436,8 +437,7 @@ class Reactronic {
   static why(short: boolean = false): string
   static getMethodCache<T>(method: F<T>): Cache<T>
   static configureCurrentOperation(options: Partial<Options>): Options
-  // static configureObject<T extends object>(obj: T, options: Partial<ObjectOptions>): void
-  // static assign<T, P extends keyof T>(obj: T, prop: P, value: T[P], sensitivity: Sensitivity)
+  static getRevisionOf(obj: any): number
   static takeSnapshot<T>(obj: T): T
   static dispose(obj: any): void
   static reactionsAutoStartDisabled: boolean

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

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './impl/Hooks';
+import { ReactiveObject } from './impl/Mvcc';
 export declare abstract class Buffer<T> extends ReactiveObject {
     abstract readonly capacity: number;
     abstract readonly count: number;

package/build/dist/source/Buffer.js

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

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

@@ -1,18 +1,18 @@
 import { LoggingOptions } from './Logging';
-import { StandaloneMode } from './impl/Data';
+import { SeparationMode } from './impl/Data';
 export { LoggingOptions, ProfilingOptions, LoggingLevel } from './Logging';
 import { Journal } from './impl/Journal';
 import { Monitor } from './impl/Monitor';
 export interface SnapshotOptions {
     readonly hint?: string;
-    readonly standalone?: StandaloneMode;
+    readonly separation?: SeparationMode;
     readonly journal?: Journal;
     readonly logging?: Partial<LoggingOptions>;
     readonly token?: any;
 }
 export interface MemberOptions {
     readonly kind: Kind;
-    readonly standalone: StandaloneMode;
+    readonly separation: SeparationMode;
     readonly order: number;
     readonly noSideEffects: boolean;
     readonly triggeringArgs: boolean;

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

@@ -2,11 +2,11 @@ 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;
     static configureCurrentOperation(options: Partial<MemberOptions>): MemberOptions;
+    static getRevisionOf(obj: any): number;
     static takeSnapshot<T>(obj: T): T;
     static dispose(obj: any): void;
     static get reactionsAutoStartDisabled(): boolean;
@@ -20,7 +20,7 @@ export declare class Rx {
 }
 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 isnonreactive(proto: object, prop: PropertyKey): any;
+export declare function raw(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

@@ -2,46 +2,46 @@ import { Log } from './util/Dbg';
 import { Kind } from './Options';
 import { Meta, ObjectHandle } from './impl/Data';
 import { Changeset } from './impl/Changeset';
-import { Hooks } from './impl/Hooks';
+import { Mvcc } from './impl/Mvcc';
 import { OperationController } from './impl/Operation';
 export class Rx {
-    static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static why(brief = false) { return brief ? OperationController.briefWhy() : OperationController.why(); }
-    static getController(method) { return OperationController.of(method); }
+    static getController(method) { return OperationController.getControllerOf(method); }
     static pullLastResult(method, args) { return Rx.getController(method).pullLastResult(args); }
     static configureCurrentOperation(options) { return OperationController.configureImpl(undefined, options); }
+    static getRevisionOf(obj) { return obj[Meta.Revision]; }
     static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
     static dispose(obj) { Changeset.dispose(obj); }
-    static get reactionsAutoStartDisabled() { return Hooks.reactionsAutoStartDisabled; }
-    static set reactionsAutoStartDisabled(value) { Hooks.reactionsAutoStartDisabled = value; }
+    static get reactionsAutoStartDisabled() { return Mvcc.reactionsAutoStartDisabled; }
+    static set reactionsAutoStartDisabled(value) { Mvcc.reactionsAutoStartDisabled = value; }
     static get isLogging() { return Log.isOn; }
     static get loggingOptions() { return Log.opt; }
     static setLoggingMode(isOn, options) { Log.setMode(isOn, options); }
-    static setLoggingHint(obj, name) { Hooks.setHint(obj, name); }
+    static setLoggingHint(obj, name) { Mvcc.setHint(obj, name); }
     static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
-    static setProfilingMode(isOn, options) { Hooks.setProfilingMode(isOn, options); }
+    static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
 }
 export function nonreactive(func, ...args) {
     return OperationController.runWithin(undefined, func, ...args);
 }
 export function sensitive(sensitivity, func, ...args) {
-    return Hooks.sensitive(sensitivity, func, ...args);
+    return Mvcc.sensitive(sensitivity, func, ...args);
 }
-export function isnonreactive(proto, prop) {
-    return Hooks.decorateData(false, proto, prop);
+export function raw(proto, prop) {
+    return Mvcc.decorateData(false, proto, prop);
 }
 export function transaction(proto, prop, pd) {
     const opts = { kind: Kind.Transaction };
-    return Hooks.decorateOperation(true, transaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, transaction, opts, proto, prop, pd);
 }
 export function reaction(proto, prop, pd) {
     const opts = { kind: Kind.Reaction, throttling: -1 };
-    return Hooks.decorateOperation(true, reaction, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
 }
 export function cached(proto, prop, pd) {
     const opts = { kind: Kind.Cache, noSideEffects: true };
-    return Hooks.decorateOperation(true, cached, opts, proto, prop, pd);
+    return Mvcc.decorateOperation(true, cached, opts, proto, prop, pd);
 }
 export function options(value) {
-    return Hooks.decorateOperationParametrized(options, value);
+    return Mvcc.decorateOperationParametrized(options, value);
 }

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

@@ -1,4 +1,5 @@
 export { all, pause } from './util/Utils';
+export { Collection, Item, CollectionReader } from './util/Collection';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
@@ -6,9 +7,11 @@ export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, Profi
 export { Worker } from './Worker';
 export { Controller } from './Controller';
 export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';
-export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { TransactionalObject, ReactiveObject } from './impl/Mvcc';
+export { TransactionalArray, ReactiveArray } from './impl/MvccArray';
+export { TransactionalMap, ReactiveMap } from './impl/MvccMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';
+export { Rx, nonreactive, sensitive, raw, transaction, reaction, cached, options } from './Rx';

package/build/dist/source/api.js

@@ -1,13 +1,16 @@
 export { all, pause } from './util/Utils';
+export { Collection } from './util/Collection';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
 export { Kind, Reentrance, LoggingLevel } from './Options';
 export { Controller } from './Controller';
 export { Ref, ToggleRef } from './Ref';
-export { ReactiveObject, ReactiveArray, ReactiveMap } from './impl/Hooks';
+export { TransactionalObject, ReactiveObject } from './impl/Mvcc';
+export { TransactionalArray, ReactiveArray } from './impl/MvccArray';
+export { TransactionalMap, ReactiveMap } from './impl/MvccMap';
 export { Changeset } from './impl/Changeset';
 export { Transaction } from './impl/Transaction';
 export { Monitor } from './impl/Monitor';
 export { Journal } from './impl/Journal';
-export { Rx, nonreactive, sensitive, isnonreactive, transaction, reaction, cached, options } from './Rx';
+export { Rx, nonreactive, sensitive, raw, transaction, reaction, cached, options } from './Rx';

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

@@ -7,11 +7,11 @@ import { SealedSet } from '../util/SealedSet';
 import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
 export const MAX_REVISION = Number.MAX_SAFE_INTEGER;
 export const UNDEFINED_REVISION = MAX_REVISION - 1;
-Object.defineProperty(ObjectHandle.prototype, '#this', {
+Object.defineProperty(ObjectHandle.prototype, '#this#', {
     configurable: false, enumerable: false,
     get() {
         const result = {};
-        const data = Changeset.current().getObjectSnapshot(this, '#this').data;
+        const data = Changeset.current().getObjectSnapshot(this, '#this#').data;
         for (const m in data) {
             const v = data[m];
             if (v instanceof Subscription)
@@ -81,7 +81,7 @@ export class Changeset {
         return os;
     }
     static takeSnapshot(obj) {
-        return obj[Meta.Handle]['#this'];
+        return obj[Meta.Handle]['#this#'];
     }
     static dispose(obj) {
         const ctx = Changeset.edit();
@@ -165,7 +165,7 @@ export class Changeset {
             merged[m] = ours.data[m];
             if (headDisposed || oursDisposed) {
                 if (headDisposed !== oursDisposed) {
-                    if (headDisposed || this.options.standalone !== 'disposal') {
+                    if (headDisposed || this.options.separation !== 'disposal') {
                         if (Log.isOn && Log.opt.change)
                             Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} <> ${Dump.snapshot2(h, head.changeset, m)}`, 0, ' *** CONFLICT ***');
                         ours.conflicts.set(m, head);
@@ -351,7 +351,7 @@ Dump.valueHint = (value, m) => '???';
 export const EMPTY_SNAPSHOT = new ObjectSnapshot(new Changeset({ hint: '<empty>' }), undefined, {});
 export const DefaultSnapshotOptions = Object.freeze({
     hint: 'noname',
-    standalone: false,
+    separation: false,
     journal: undefined,
     logging: undefined,
     token: undefined,

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

@@ -12,7 +12,7 @@ export declare class Subscription {
     get originSnapshotId(): number | undefined;
     constructor(content: any);
 }
-export declare type StandaloneMode = boolean | 'isolated' | 'disposal';
+export declare type SeparationMode = boolean | 'isolated' | 'disposal';
 export interface Subscriber {
     readonly order: number;
     readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;

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

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './Hooks';
+import { ReactiveObject } from './Mvcc';
 import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
 export declare type Saver = (patch: PatchSet) => Promise<void>;
 export declare abstract class Journal extends ReactiveObject {

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

@@ -1,4 +1,4 @@
-import { ReactiveObject } from './Hooks';
+import { ReactiveObject } from './Mvcc';
 import { Meta, Subscription } from './Data';
 import { Changeset, EMPTY_SNAPSHOT } from './Changeset';
 import { Transaction } from './Transaction';
@@ -22,7 +22,7 @@ export class JournalImpl extends Journal {
     get canUndo() { return this._edits.length > 0 && this._position > 0; }
     get canRedo() { return this._position < this._edits.length; }
     edited(p) {
-        Transaction.run({ hint: 'EditJournal.edited', standalone: 'isolated' }, () => {
+        Transaction.run({ hint: 'EditJournal.edited', separation: 'isolated' }, () => {
             const items = this._edits = this._edits.toMutable();
             if (items.length >= this._capacity)
                 items.shift();
@@ -40,7 +40,7 @@ export class JournalImpl extends Journal {
             throw new Error('not implemented');
     }
     undo(count = 1) {
-        Transaction.run({ hint: 'Journal.undo', standalone: 'isolated' }, () => {
+        Transaction.run({ hint: 'Journal.undo', separation: 'isolated' }, () => {
             let i = this._position - 1;
             while (i >= 0 && count > 0) {
                 const patch = this._edits[i];
@@ -52,7 +52,7 @@ export class JournalImpl extends Journal {
         });
     }
     redo(count = 1) {
-        Transaction.run({ hint: 'Journal.redo', standalone: 'isolated' }, () => {
+        Transaction.run({ hint: 'Journal.redo', separation: 'isolated' }, () => {
             let i = this._position;
             while (i < this._edits.length && count > 0) {
                 const patch = this._edits[i];

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

@@ -1,5 +1,5 @@
 import { Worker } from '../Worker';
-import { ReactiveObject } from './Hooks';
+import { ReactiveObject } from './Mvcc';
 export declare abstract class Monitor extends ReactiveObject {
     abstract readonly isActive: boolean;
     abstract readonly counter: number;

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

@@ -1,4 +1,4 @@
-import { ReactiveObject, Hooks } from './Hooks';
+import { ReactiveObject, Mvcc } from './Mvcc';
 import { Transaction } from './Transaction';
 export class Monitor extends ReactiveObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
@@ -44,7 +44,7 @@ export class MonitorImpl extends Monitor {
     }
     static doCreate(hint, activationDelay, deactivationDelay, durationResolution) {
         const m = new MonitorImpl();
-        Hooks.setHint(m, hint);
+        Mvcc.setHint(m, hint);
         m.internals.activationDelay = activationDelay;
         m.internals.deactivationDelay = deactivationDelay;
         m.internals.durationResolution = durationResolution;
@@ -59,7 +59,7 @@ export class MonitorImpl extends Monitor {
         }
         if (delay >= 0) {
             if (mon.internals.activationTimeout === undefined)
-                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.activate', standalone: 'isolated' }, MonitorImpl.activate, mon, -1), delay);
+                mon.internals.activationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.activate', separation: 'isolated' }, MonitorImpl.activate, mon, -1), delay);
         }
         else if (active)
             mon.isActive = true;
@@ -67,7 +67,7 @@ export class MonitorImpl extends Monitor {
     static deactivate(mon, delay) {
         if (delay >= 0) {
             clearTimeout(mon.internals.deactivationTimeout);
-            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.deactivate', standalone: 'isolated' }, MonitorImpl.deactivate, mon, -1), delay);
+            mon.internals.deactivationTimeout = setTimeout(() => Transaction.run({ hint: 'Monitor.deactivate', separation: 'isolated' }, MonitorImpl.deactivate, mon, -1), delay);
         }
         else if (mon.counter <= 0) {
             mon.isActive = false;

package/build/dist/source/impl/{Hooks.d.ts → Mvcc.d.ts}

@@ -1,64 +1,24 @@
 import { F } from '../util/Utils';
 import { MemberOptions, Kind, Reentrance } from '../Options';
 import { LoggingOptions, ProfilingOptions } from '../Logging';
-import { MemberName, ObjectHandle, StandaloneMode } from './Data';
+import { MemberName, ObjectHandle, SeparationMode } from './Data';
 import { Journal } from './Journal';
 import { Monitor } from './Monitor';
-export declare abstract class ReactiveObject {
-    constructor();
+export declare abstract class MvccObject {
+    protected constructor(reactive: boolean);
     [Symbol.toStringTag](): string;
 }
-export declare class ReactiveArray<T> extends ReactiveObject {
-    private a;
-    get length(): number;
-    set length(n: number);
-    get(n: number): T;
-    set(n: number, item: T): void;
-    toString(): string;
-    toLocaleString(): string;
-    pop(): T | undefined;
-    push(...items: T[]): number;
-    concat(...items: (T | ConcatArray<T>)[]): T[];
-    join(separator?: string): string;
-    reverse(): T[];
-    shift(): T | undefined;
-    slice(start?: number, end?: number): T[];
-    sort(compareFn?: (a: T, b: T) => number): this;
-    splice(start: number, deleteCount?: number): T[];
-    unshift(...items: T[]): number;
-    indexOf(searchElement: T, fromIndex?: number): number;
-    lastIndexOf(searchElement: T, fromIndex?: number): number;
-    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
-    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
-    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
-    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
-    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
-    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
-    entries(): IterableIterator<[number, T]>;
-    keys(): IterableIterator<number>;
-    values(): IterableIterator<T>;
-    private get mutable();
+export declare abstract class TransactionalObject extends MvccObject {
+    constructor();
 }
-export declare class ReactiveMap<K, V> extends ReactiveObject {
-    private m;
-    clear(): void;
-    delete(key: K): boolean;
-    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
-    get(key: K): V | undefined;
-    has(key: K): boolean;
-    set(key: K, value: V): this;
-    get size(): number;
-    entries(): IterableIterator<[K, V]>;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    private get mutable();
+export declare abstract class ReactiveObject extends MvccObject {
+    constructor();
 }
 export declare class OptionsImpl implements MemberOptions {
     readonly getter: Function;
     readonly setter: Function;
     readonly kind: Kind;
-    readonly standalone: StandaloneMode;
+    readonly separation: SeparationMode;
     readonly order: number;
     readonly noSideEffects: boolean;
     readonly triggeringArgs: boolean;
@@ -70,13 +30,16 @@ export declare class OptionsImpl implements MemberOptions {
     static readonly INITIAL: Readonly<OptionsImpl>;
     constructor(getter: Function | undefined, setter: Function | undefined, existing: OptionsImpl, patch: Partial<OptionsImpl>, implicit: boolean);
 }
-export declare class Hooks implements ProxyHandler<ObjectHandle> {
+export declare class Mvcc implements ProxyHandler<ObjectHandle> {
     static reactionsAutoStartDisabled: boolean;
     static repetitiveUsageWarningThreshold: number;
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
-    static readonly handler: Hooks;
+    static readonly transactional: Mvcc;
+    static readonly reactive: Mvcc;
+    readonly isReactive: boolean;
+    constructor(isReactive: boolean);
     getPrototypeOf(h: ObjectHandle): object | null;
     get(h: ObjectHandle, m: MemberName, receiver: any): any;
     set(h: ObjectHandle, m: MemberName, value: any, receiver: any): boolean;
@@ -87,7 +50,7 @@ export declare class Hooks implements ProxyHandler<ObjectHandle> {
     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 createHandleForReactiveObject(proto: any, data: any, blank: any, hint: string): ObjectHandle;
+    static createHandleForMvccObject(proto: any, data: any, blank: any, hint: string, reactive: 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;