reactronic 0.22.314 → 0.22.317

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

@@ -3,11 +3,11 @@ import { Log, misuse } from '../util/Dbg';
 import { Kind, Reentrance } from '../Options';
 import { ObjectSnapshot, ObjectHandle, Subscription, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT } from './Changeset';
-export class HookedObject {
-    constructor(reactive) {
+export class MvccObject {
+    constructor(observable) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Hooks.createHandleForReactronicObject(proto, this, initial, new.target.name, reactive);
+        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, observable);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -15,14 +15,19 @@ export class HookedObject {
         return Dump.obj(h);
     }
 }
-export class ReactiveObject extends HookedObject {
+export class TransactionalObject extends MvccObject {
+    constructor() {
+        super(false);
+    }
+}
+export class ObservableObject extends MvccObject {
     constructor() {
         super(true);
     }
 }
 const DEFAULT_OPTIONS = Object.freeze({
     kind: Kind.Plain,
-    standalone: false,
+    separation: false,
     order: 0,
     noSideEffects: false,
     triggeringArgs: false,
@@ -37,7 +42,7 @@ export class OptionsImpl {
         this.getter = getter !== undefined ? getter : existing.getter;
         this.setter = setter !== undefined ? setter : existing.setter;
         this.kind = merge(DEFAULT_OPTIONS.kind, existing.kind, patch.kind, implicit);
-        this.standalone = merge(DEFAULT_OPTIONS.standalone, existing.standalone, patch.standalone, implicit);
+        this.separation = merge(DEFAULT_OPTIONS.separation, existing.separation, patch.separation, implicit);
         this.order = merge(DEFAULT_OPTIONS.order, existing.order, patch.order, implicit);
         this.noSideEffects = merge(DEFAULT_OPTIONS.noSideEffects, existing.noSideEffects, patch.noSideEffects, implicit);
         this.triggeringArgs = merge(DEFAULT_OPTIONS.triggeringArgs, existing.triggeringArgs, patch.triggeringArgs, implicit);
@@ -54,9 +59,9 @@ OptionsImpl.INITIAL = Object.freeze(new OptionsImpl(UNDEF, UNDEF, Object.assign(
 function merge(def, existing, patch, implicit) {
     return patch !== undefined && (existing === def || !implicit) ? patch : existing;
 }
-export class Hooks {
-    constructor(isReactive) {
-        this.isReactive = isReactive;
+export class Mvcc {
+    constructor(isObservable) {
+        this.isObservable = isObservable;
     }
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
@@ -68,7 +73,7 @@ export class Hooks {
             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;
             }
@@ -84,7 +89,7 @@ export class Hooks {
         if (os !== EMPTY_SNAPSHOT) {
             let curr = os.data[m];
             if (curr !== undefined || (os.former.snapshot.changeset === EMPTY_SNAPSHOT.changeset && (m in h.data) === false)) {
-                if (curr === undefined || curr.content !== value || Hooks.sensitivity) {
+                if (curr === undefined || curr.content !== value || Mvcc.sensitivity) {
                     const existing = curr === null || curr === void 0 ? void 0 : curr.content;
                     if (os.former.snapshot.data[m] === curr) {
                         curr = os.data[m] = new Subscription(value);
@@ -124,22 +129,22 @@ export class Hooks {
         }
         return result;
     }
-    static decorateData(reactive, proto, m) {
-        if (reactive) {
+    static decorateData(isObservable, proto, m) {
+        if (isObservable) {
             const get = function () {
-                const h = Hooks.acquireHandle(this);
-                return Hooks.reactive.get(h, m, this);
+                const h = Mvcc.acquireHandle(this);
+                return Mvcc.observable.get(h, m, this);
             };
             const set = function (value) {
-                const h = Hooks.acquireHandle(this);
-                return Hooks.reactive.set(h, m, value, this);
+                const h = Mvcc.acquireHandle(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;
@@ -147,11 +152,11 @@ export class Hooks {
             pd = EMPTY_PROP_DESCRIPTOR;
         const enumerable = (_a = pd.enumerable) !== null && _a !== void 0 ? _a : true;
         const configurable = (_b = pd.configurable) !== null && _b !== void 0 ? _b : true;
-        const opts = Hooks.rememberOperationOptions(proto, member, (_c = pd.value) !== null && _c !== void 0 ? _c : pd.get, (_d = pd.value) !== null && _d !== void 0 ? _d : pd.set, true, configurable, options, implicit);
+        const opts = Mvcc.rememberOperationOptions(proto, member, (_c = pd.value) !== null && _c !== void 0 ? _c : pd.get, (_d = pd.value) !== null && _d !== void 0 ? _d : pd.set, true, configurable, options, implicit);
         if (opts.getter === opts.setter) {
             const bootstrap = function () {
-                const h = Hooks.acquireHandle(this);
-                const operation = Hooks.createOperation(h, member, opts);
+                const h = Mvcc.acquireHandle(this);
+                const operation = Mvcc.createOperation(h, member, opts);
                 Object.defineProperty(h.data, member, { value: operation, enumerable, configurable });
                 return operation;
             };
@@ -159,8 +164,8 @@ export class Hooks {
         }
         else if (opts.setter === UNDEF) {
             const bootstrap = function () {
-                const h = Hooks.acquireHandle(this);
-                const operation = Hooks.createOperation(h, member, opts);
+                const h = Mvcc.acquireHandle(this);
+                const operation = Mvcc.createOperation(h, member, opts);
                 Object.defineProperty(h.data, member, { get: operation, enumerable, configurable });
                 return operation.call(this);
             };
@@ -171,81 +176,81 @@ export class Hooks {
     }
     static decorateOperationParametrized(decorator, options) {
         return function (proto, prop, pd) {
-            return Hooks.decorateOperation(false, decorator, options, proto, prop, pd);
+            return Mvcc.decorateOperation(false, decorator, options, proto, prop, pd);
         };
     }
     static acquireHandle(obj) {
         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, Hooks.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 createHandleForReactronicObject(proto, data, blank, hint, reactive) {
+    static createHandleForMvccObject(proto, data, blank, hint, isObservable) {
         const ctx = Changeset.edit();
-        const hooks = reactive ? Hooks.reactive : Hooks.transactional;
-        const h = new ObjectHandle(data, undefined, hooks, EMPTY_SNAPSHOT, hint);
+        const mvcc = isObservable ? Mvcc.observable : Mvcc.transactional;
+        const h = new ObjectHandle(data, undefined, mvcc, EMPTY_SNAPSHOT, hint);
         ctx.getEditableObjectSnapshot(h, Meta.Handle, blank);
-        if (!Hooks.reactionsAutoStartDisabled)
+        if (!Mvcc.reactionsAutoStartDisabled)
             for (const m in Meta.getFrom(proto, Meta.Reactions))
                 h.proxy[m][Meta.Controller].markObsolete();
         return h;
     }
     static setProfilingMode(isOn, options) {
         if (isOn) {
-            Hooks.repetitiveUsageWarningThreshold = options && options.repetitiveUsageWarningThreshold !== undefined ? options.repetitiveUsageWarningThreshold : 10;
-            Hooks.mainThreadBlockingWarningThreshold = options && options.mainThreadBlockingWarningThreshold !== undefined ? options.mainThreadBlockingWarningThreshold : 14;
-            Hooks.asyncActionDurationWarningThreshold = options && options.asyncActionDurationWarningThreshold !== undefined ? options.asyncActionDurationWarningThreshold : 300;
+            Mvcc.repetitiveUsageWarningThreshold = options && options.repetitiveUsageWarningThreshold !== undefined ? options.repetitiveUsageWarningThreshold : 10;
+            Mvcc.mainThreadBlockingWarningThreshold = options && options.mainThreadBlockingWarningThreshold !== undefined ? options.mainThreadBlockingWarningThreshold : 14;
+            Mvcc.asyncActionDurationWarningThreshold = options && options.asyncActionDurationWarningThreshold !== undefined ? options.asyncActionDurationWarningThreshold : 300;
             Changeset.garbageCollectionSummaryInterval = options && options.garbageCollectionSummaryInterval !== undefined ? options.garbageCollectionSummaryInterval : 100;
         }
         else {
-            Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
-            Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
-            Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Mvcc.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
+            Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
             Changeset.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
         }
     }
     static sensitive(sensitivity, func, ...args) {
-        const restore = Hooks.sensitivity;
-        Hooks.sensitivity = sensitivity;
+        const restore = Mvcc.sensitivity;
+        Mvcc.sensitivity = sensitivity;
         try {
             return func(...args);
         }
         finally {
-            Hooks.sensitivity = restore;
+            Mvcc.sensitivity = restore;
         }
     }
     static setHint(obj, hint) {
         if (hint) {
-            const h = Hooks.acquireHandle(obj);
+            const h = Mvcc.acquireHandle(obj);
             h.hint = hint;
         }
         return obj;
     }
     static getHint(obj) {
-        const h = Hooks.acquireHandle(obj);
+        const h = Mvcc.acquireHandle(obj);
         return h.hint;
     }
 }
-Hooks.reactionsAutoStartDisabled = false;
-Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
-Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
-Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
-Hooks.sensitivity = false;
-Hooks.transactional = new Hooks(false);
-Hooks.reactive = new Hooks(true);
-Hooks.createOperation = function (h, m, options) {
-    throw misuse('createOperation should never be called');
+Mvcc.reactionsAutoStartDisabled = false;
+Mvcc.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
+Mvcc.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
+Mvcc.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
+Mvcc.sensitivity = false;
+Mvcc.transactional = new Mvcc(false);
+Mvcc.observable = new Mvcc(true);
+Mvcc.createOperation = function (h, m, options) {
+    throw misuse('this implementation of createOperation should never be called');
 };
-Hooks.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
-    throw misuse('rememberOperationOptions should never be called');
+Mvcc.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
+    throw misuse('this implementation of rememberOperationOptions should never be called');
 };
 const EMPTY_PROP_DESCRIPTOR = {
     configurable: true,

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

@@ -0,0 +1,60 @@
+import { MvccObject } from './Mvcc';
+export declare class MvccArray<T> extends MvccObject {
+    private all;
+    constructor(isObservable: boolean, array: Array<T>);
+    get length(): number;
+    set length(n: number);
+    getItem(n: number): T;
+    setItem(n: number, item: T): void;
+    toString(): string;
+    toLocaleString(): string;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    concat(...items: (T | ConcatArray<T>)[]): T[];
+    concat(...items: 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[];
+    splice(start: number, deleteCount: number, ...items: T[]): T[];
+    unshift(...items: T[]): number;
+    includes(searchElement: T, fromIndex?: number): boolean;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
+    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[];
+    filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    find<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
+    findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
+    fill(value: T, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
+    [Symbol.iterator](): IterableIterator<T>;
+    entries(): IterableIterator<[number, T]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<T>;
+    private get mutable();
+}
+export declare class TransactionalArray<T> extends MvccArray<T> {
+    constructor();
+    constructor(arrayLength: number);
+    constructor(arrayLength?: number);
+    constructor(...items: T[]);
+}
+export declare class ObservableArray<T> extends MvccArray<T> {
+    constructor();
+    constructor(arrayLength: number);
+    constructor(arrayLength?: number);
+    constructor(...items: T[]);
+}

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

@@ -0,0 +1,58 @@
+import { Sealant } from '../util/Sealant';
+import { MvccObject } from './Mvcc';
+export class MvccArray extends MvccObject {
+    constructor(isObservable, array) {
+        super(isObservable);
+        this.all = array;
+    }
+    get length() { return this.all.length; }
+    set length(n) { this.mutable.length = n; }
+    getItem(n) { return this.all[n]; }
+    setItem(n, item) { this.mutable[n] = item; }
+    toString() { return this.all.toString(); }
+    toLocaleString() { return this.all.toLocaleString(); }
+    pop() { return this.mutable.pop(); }
+    push(...items) { return this.mutable.push(...items); }
+    concat(...items) { return this.all.concat(...items); }
+    join(separator) { return this.all.join(separator); }
+    reverse() { return this.mutable.reverse(); }
+    shift() { return this.mutable.shift(); }
+    slice(start, end) { return this.all.slice(start, end); }
+    sort(compareFn) { this.mutable.sort(compareFn); return this; }
+    splice(start, deleteCount, ...items) { return this.mutable.splice(start, deleteCount, ...items); }
+    unshift(...items) { return this.mutable.unshift(...items); }
+    includes(searchElement, fromIndex) { return this.all.includes(searchElement, fromIndex); }
+    indexOf(searchElement, fromIndex) { return this.all.indexOf(searchElement, fromIndex); }
+    lastIndexOf(searchElement, fromIndex) { return this.all.lastIndexOf(searchElement, fromIndex); }
+    every(predicate, thisArg) { return this.all.every(predicate, thisArg); }
+    some(predicate, thisArg) { return this.all.some(predicate, thisArg); }
+    forEach(callbackfn, thisArg) { return this.all.forEach(callbackfn, thisArg); }
+    map(callbackfn, thisArg) { return this.all.map(callbackfn, thisArg); }
+    filter(predicate, thisArg) { return this.all.filter(predicate, thisArg); }
+    reduce(callbackfn, initialValue) { return initialValue !== undefined ? this.all.reduce(callbackfn, initialValue) : this.all.reduce(callbackfn); }
+    reduceRight(callbackfn, initialValue) { return initialValue !== undefined ? this.all.reduceRight(callbackfn, initialValue) : this.all.reduceRight(callbackfn); }
+    find(predicate, thisArg) { return this.all.find(predicate, thisArg); }
+    findIndex(predicate, thisArg) { return this.all.findIndex(predicate, thisArg); }
+    fill(value, start, end) { this.mutable.fill(value, start, end); return this; }
+    copyWithin(target, start, end) { this.mutable.copyWithin(target, start, end); return this; }
+    [Symbol.iterator]() { return this.all[Symbol.iterator](); }
+    entries() { return this.all.entries(); }
+    keys() { return this.all.keys(); }
+    values() { return this.all.values(); }
+    get mutable() {
+        const createCopy = this.all[Sealant.CreateCopy];
+        if (createCopy)
+            return this.all = createCopy.call(this.all);
+        return this.all;
+    }
+}
+export class TransactionalArray extends MvccArray {
+    constructor(args) {
+        super(false, args !== undefined ? new Array(args) : new Array());
+    }
+}
+export class ObservableArray extends MvccArray {
+    constructor(args) {
+        super(true, args !== undefined ? new Array(args) : new Array());
+    }
+}

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

@@ -0,0 +1,25 @@
+import { Collection, Item, CollectionReader } from '../util/Collection';
+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;
+    get addedCount(): number;
+    get removedCount(): number;
+    get isMergeInProgress(): boolean;
+    lookup(key: string): Item<T> | undefined;
+    claim(key: string): Item<T> | undefined;
+    add(self: T): Item<T>;
+    remove(item: Item<T>): void;
+    move(item: Item<T>, after: Item<T>): void;
+    beginMerge(): void;
+    endMerge(error?: unknown): void;
+    resetAddedAndRemovedLists(): void;
+    items(): Generator<Item<T>>;
+    addedItems(reset?: boolean): Generator<Item<T>>;
+    removedItems(reset?: boolean): Generator<Item<T>>;
+    isAdded(item: Item<T>): boolean;
+    isMoved(item: Item<T>): boolean;
+    isRemoved(item: Item<T>): boolean;
+    isCurrent(item: Item<T>): boolean;
+}

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

@@ -0,0 +1,23 @@
+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; }
+    get removedCount() { return this.a.removedCount; }
+    get isMergeInProgress() { return this.a.isMergeInProgress; }
+    lookup(key) { return this.a.lookup(key); }
+    claim(key) { return this.a.claim(key); }
+    add(self) { return this.a.add(self); }
+    remove(item) { return this.a.remove(item); }
+    move(item, after) { this.a.move(item, after); }
+    beginMerge() { this.a.beginMerge(); }
+    endMerge(error) { this.a.endMerge(error); }
+    resetAddedAndRemovedLists() { this.a.resetAddedAndRemovedLists(); }
+    items() { return this.a.items(); }
+    addedItems(reset) { return this.a.addedItems(reset); }
+    removedItems(reset) { return this.a.removedItems(reset); }
+    isAdded(item) { return this.a.isAdded(item); }
+    isMoved(item) { return this.a.isMoved(item); }
+    isRemoved(item) { return this.a.isRemoved(item); }
+    isCurrent(item) { return this.a.isCurrent(item); }
+}

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

@@ -0,0 +1,25 @@
+import { MvccObject } from './Mvcc';
+export declare class MvccMap<K, V> extends MvccObject {
+    private all;
+    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;
+    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>;
+    [Symbol.toStringTag](): string;
+    private get mutable();
+}
+export declare class TransactionalMap<K, V> extends MvccMap<K, V> {
+    constructor();
+    constructor(iterable?: Iterable<readonly [K, V]> | null);
+}
+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

@@ -0,0 +1,35 @@
+import { Sealant } from '../util/Sealant';
+import { MvccObject } from './Mvcc';
+export class MvccMap extends MvccObject {
+    constructor(isObservable, map) {
+        super(isObservable);
+        this.all = map;
+    }
+    clear() { this.mutable.clear(); }
+    delete(key) { return this.mutable.delete(key); }
+    forEach(callbackfn, thisArg) { this.all.forEach(callbackfn, thisArg); }
+    get(key) { return this.all.get(key); }
+    has(key) { return this.all.has(key); }
+    set(key, value) { this.mutable.set(key, value); return this; }
+    get size() { return this.all.size; }
+    entries() { return this.all.entries(); }
+    keys() { return this.all.keys(); }
+    values() { return this.all.values(); }
+    [Symbol.toStringTag]() { return this.all[Symbol.toStringTag]; }
+    get mutable() {
+        const createCopy = this.all[Sealant.CreateCopy];
+        if (createCopy)
+            return this.all = createCopy.call(this.all);
+        return this.all;
+    }
+}
+export class TransactionalMap extends MvccMap {
+    constructor(args) {
+        super(true, args !== undefined ? new Map(args) : new Map());
+    }
+}
+export class ObservableMap extends MvccMap {
+    constructor(args) {
+        super(true, args !== undefined ? new Map(args) : new Map());
+    }
+}

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

@@ -3,7 +3,7 @@ import { MemberOptions } from '../Options';
 import { Controller } from '../Controller';
 import { MemberName, ObjectHandle, Subscription, Subscriber, SubscriptionInfo, AbstractChangeset } from './Data';
 import { Transaction } from './Transaction';
-import { OptionsImpl } from './Hooks';
+import { OptionsImpl } from './Mvcc';
 export declare class OperationController extends Controller<any> {
     readonly objectHandle: ObjectHandle;
     readonly memberName: MemberName;
@@ -19,7 +19,7 @@ export declare class OperationController extends Controller<any> {
     pullLastResult(args?: any[]): any;
     constructor(h: ObjectHandle, m: MemberName);
     useOrRun(weak: boolean, args: any[] | undefined): Operation;
-    static of(method: F<any>): Controller<any>;
+    static getControllerOf(method: F<any>): Controller<any>;
     static configureImpl(self: OperationController | undefined, options: Partial<MemberOptions>): MemberOptions;
     static runWithin<T>(op: Operation | undefined, func: F<T>, ...args: any[]): T;
     static why(): string;
@@ -55,7 +55,7 @@ declare class Operation extends Subscription implements Subscriber {
     get originSnapshotId(): number;
     hint(): string;
     get order(): number;
-    get ['#this'](): string;
+    get ['#this#'](): string;
     why(): string;
     briefWhy(): string;
     dependencies(): string[];

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

@@ -5,11 +5,11 @@ import { ObjectHandle, Subscription, Meta } from './Data';
 import { Changeset, Dump, EMPTY_SNAPSHOT, MAX_REVISION } from './Changeset';
 import { Transaction } from './Transaction';
 import { MonitorImpl } from './Monitor';
-import { Hooks, OptionsImpl } from './Hooks';
+import { Mvcc, OptionsImpl } from './Mvcc';
 import { JournalImpl } from './Journal';
 const BOOT_ARGS = [];
 const BOOT_CAUSE = '<boot>';
-const EMPTY_HANDLE = new ObjectHandle(undefined, undefined, Hooks.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();
@@ -36,12 +36,12 @@ export class OperationController extends Controller {
             && (!weak || op.cause === BOOT_CAUSE || !op.successor ||
                 op.successor.transaction.isFinished)) {
             const outerOpts = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.options;
-            const standalone = weak || opts.standalone || opts.kind === Kind.Reaction ||
+            const separation = weak || opts.separation || opts.kind === Kind.Reaction ||
                 (opts.kind === Kind.Transaction && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Kind.Cache)) ||
                 (opts.kind === Kind.Cache && (oc.snapshot.changeset.sealed ||
                     oc.snapshot.former.snapshot !== EMPTY_SNAPSHOT));
             const token = opts.noSideEffects ? this : undefined;
-            const oc2 = this.run(oc, standalone, opts, token, args);
+            const oc2 = this.run(oc, separation, opts, token, args);
             const ctx2 = oc2.operation.changeset;
             if (!weak || ctx === ctx2 || (ctx2.sealed && ctx.timestamp >= ctx2.timestamp))
                 oc = oc2;
@@ -53,7 +53,7 @@ export class OperationController extends Controller {
         Changeset.markUsed(t, oc.snapshot, this.memberName, this.objectHandle, t.options.kind, weak);
         return t;
     }
-    static of(method) {
+    static getControllerOf(method) {
         const ctl = Meta.get(method, Meta.Controller);
         if (!ctl)
             throw misuse(`given method is not decorated as reactronic one: ${method.name}`);
@@ -137,8 +137,8 @@ export class OperationController extends Controller {
         if (op.controller !== this) {
             if (os.changeset !== EMPTY_SNAPSHOT.changeset) {
                 const hint = Log.isOn ? `${Dump.obj(this.objectHandle, m)}/boot` : 'MethodController/init';
-                const standalone = os.changeset.sealed || os.former.snapshot !== EMPTY_SNAPSHOT;
-                op = Transaction.run({ hint, standalone, token: this }, () => {
+                const separation = os.changeset.sealed || os.former.snapshot !== EMPTY_SNAPSHOT;
+                op = Transaction.run({ hint, separation, token: this }, () => {
                     const h = this.objectHandle;
                     let r2 = Changeset.current().getObjectSnapshot(h, m);
                     let op2 = r2.data[m];
@@ -168,10 +168,10 @@ export class OperationController extends Controller {
         }
         return op;
     }
-    run(existing, standalone, options, token, args) {
+    run(existing, separation, options, token, args) {
         const hint = Log.isOn ? `${Dump.obj(this.objectHandle, this.memberName)}${args && args.length > 0 && (typeof args[0] === 'number' || typeof args[0] === 'string') ? ` - ${args[0]}` : ''}` : `${Dump.obj(this.objectHandle, this.memberName)}`;
         let oc = existing;
-        const opts = { hint, standalone, journal: options.journal, logging: options.logging, token };
+        const opts = { hint, separation, journal: options.journal, logging: options.logging, token };
         const result = Transaction.run(opts, (argsx) => {
             if (!oc.operation.transaction.isCanceled) {
                 oc = this.edit();
@@ -226,7 +226,7 @@ class Operation extends Subscription {
     get originSnapshotId() { return this.changeset.id; }
     hint() { return `${Dump.snapshot2(this.controller.objectHandle, this.changeset, this.controller.memberName)}`; }
     get order() { return this.options.order; }
-    get ['#this']() {
+    get ['#this#']() {
         return `Operation: ${this.why()}`;
     }
     why() {
@@ -254,7 +254,7 @@ class Operation extends Subscription {
             const ms = Date.now() - started;
             if (Log.isOn && Log.opt.step && this.result)
                 Log.writeAs({ margin2: this.margin }, '║', '_/', `${this.hint()} - step out `, 0, this.started > 0 ? '        │' : '');
-            if (ms > Hooks.mainThreadBlockingWarningThreshold)
+            if (ms > Mvcc.mainThreadBlockingWarningThreshold)
                 Log.write('', '[!]', this.why(), ms, '    *** main thread is too busy ***');
             return result;
         };
@@ -410,7 +410,7 @@ class Operation extends Subscription {
         this.started = -this.started;
         if (Log.isOn && Log.opt.operation)
             Log.write('║', `${op}`, `${this.hint()} ${message}`, ms, highlight);
-        if (ms > (main ? Hooks.mainThreadBlockingWarningThreshold : Hooks.asyncActionDurationWarningThreshold))
+        if (ms > (main ? Mvcc.mainThreadBlockingWarningThreshold : Mvcc.asyncActionDurationWarningThreshold))
             Log.write('', '[!]', this.why(), ms, main ? '    *** main thread is too busy ***' : '    *** async is too long ***');
         this.cause = undefined;
         if (this.options.monitor)
@@ -419,17 +419,17 @@ class Operation extends Subscription {
     monitorEnter(mon) {
         const options = {
             hint: 'Monitor.enter',
-            standalone: 'isolated',
+            separation: 'isolated',
             logging: Log.isOn && Log.opt.monitor ? undefined : Log.global
         };
         OperationController.runWithin(undefined, Transaction.run, options, MonitorImpl.enter, mon, this.transaction);
     }
     monitorLeave(mon) {
-        Transaction.off(() => {
+        Transaction.outside(() => {
             const leave = () => {
                 const options = {
                     hint: 'Monitor.leave',
-                    standalone: 'isolated',
+                    separation: 'isolated',
                     logging: Log.isOn && Log.opt.monitor ? undefined : Log.DefaultLevel
                 };
                 OperationController.runWithin(undefined, Transaction.run, options, MonitorImpl.leave, mon, this.transaction);
@@ -520,9 +520,9 @@ class Operation extends Subscription {
         }
         if (curr instanceof Operation) {
             if (curr.changeset === os.changeset && curr.subscriptions !== undefined) {
-                if (Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
+                if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                     curr.subscriptions.forEach((info, v) => {
-                        if (info.usageCount > Hooks.repetitiveUsageWarningThreshold)
+                        if (info.usageCount > Mvcc.repetitiveUsageWarningThreshold)
                             Log.write('', '[!]', `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, ' *** WARNING ***');
                     });
                 }
@@ -566,7 +566,7 @@ class Operation extends Subscription {
         const ok = Operation.canSubscribe(subscription, os, m, h, timestamp);
         if (ok) {
             let times = 0;
-            if (Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
+            if (Mvcc.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
                 const existing = this.subscriptions.get(subscription);
                 times = existing ? existing.usageCount + 1 : 1;
             }
@@ -628,8 +628,8 @@ class Operation extends Subscription {
         Changeset.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
         Changeset.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
         Changeset.enqueueReactionsToRun = Operation.enqueueReactionsToRun;
-        Hooks.createOperation = Operation.createOperation;
-        Hooks.rememberOperationOptions = Operation.rememberOperationOptions;
+        Mvcc.createOperation = Operation.createOperation;
+        Mvcc.rememberOperationOptions = Operation.rememberOperationOptions;
         Promise.prototype.then = reactronicHookedThen;
         try {
             Object.defineProperty(globalThis, 'rWhy', {

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

@@ -22,8 +22,8 @@ export declare abstract class Transaction implements Worker {
     whenFinished(): Promise<void>;
     static create(options: SnapshotOptions | null): Transaction;
     static run<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
-    static standalone<T>(func: F<T>, ...args: any[]): T;
-    static off<T>(func: F<T>, ...args: any[]): T;
+    static separate<T>(func: F<T>, ...args: any[]): T;
+    static outside<T>(func: F<T>, ...args: any[]): T;
     static isFrameOver(everyN?: number, timeLimit?: number): boolean;
     static requestNextFrame(sleepTime?: number): Promise<void>;
     static get isCanceled(): boolean;