reactronic 0.22.313 → 0.22.316

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

@@ -1,14 +1,13 @@
 import { UNDEF } from '../util/Utils';
-import { Sealant } from '../util/Sealant';
 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 ReactiveObject {
-    constructor() {
+export class MvccObject {
+    constructor(reactive) {
         const proto = new.target.prototype;
         const initial = Meta.getFrom(proto, Meta.Initial);
-        const h = Hooks.createHandleForReactiveObject(proto, this, initial, new.target.name);
+        const h = Mvcc.createHandleForMvccObject(proto, this, initial, new.target.name, reactive);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -16,71 +15,19 @@ export class ReactiveObject {
         return Dump.obj(h);
     }
 }
-export class ReactiveArray extends ReactiveObject {
+export class TransactionalObject extends MvccObject {
     constructor() {
-        super(...arguments);
-        this.a = new Array();
-    }
-    get length() { return this.a.length; }
-    set length(n) { this.a.length = n; }
-    get(n) { return this.a[n]; }
-    set(n, item) { this.mutable[n] = item; }
-    toString() { return this.a.toString(); }
-    toLocaleString() { return this.a.toLocaleString(); }
-    pop() { return this.mutable.pop(); }
-    push(...items) { return this.mutable.push(...items); }
-    concat(...items) { return this.a.concat(...items); }
-    join(separator) { return this.a.join(separator); }
-    reverse() { return this.mutable.reverse(); }
-    shift() { return this.mutable.shift(); }
-    slice(start, end) { return this.a.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); }
-    indexOf(searchElement, fromIndex) { return this.a.indexOf(searchElement, fromIndex); }
-    lastIndexOf(searchElement, fromIndex) { return this.a.lastIndexOf(searchElement, fromIndex); }
-    every(predicate, thisArg) { return this.a.every(predicate, thisArg); }
-    some(predicate, thisArg) { return this.a.some(predicate, thisArg); }
-    forEach(callbackfn, thisArg) { return this.a.forEach(callbackfn, thisArg); }
-    map(callbackfn, thisArg) { return this.a.map(callbackfn, thisArg); }
-    filter(predicate, thisArg) { return this.a.filter(predicate, thisArg); }
-    reduce(callbackfn, initialValue) { return this.a.reduce(callbackfn, initialValue); }
-    reduceRight(callbackfn, initialValue) { return this.a.reduceRight(callbackfn, initialValue); }
-    entries() { return this.a.entries(); }
-    keys() { return this.a.keys(); }
-    values() { return this.a.values(); }
-    get mutable() {
-        const createCopy = this.a[Sealant.CreateCopy];
-        if (createCopy)
-            return this.a = createCopy.call(this.a);
-        return this.a;
+        super(false);
     }
 }
-export class ReactiveMap extends ReactiveObject {
+export class ReactiveObject extends MvccObject {
     constructor() {
-        super(...arguments);
-        this.m = new Map();
-    }
-    clear() { this.mutable.clear(); }
-    delete(key) { return this.mutable.delete(key); }
-    forEach(callbackfn, thisArg) { this.m.forEach(callbackfn, thisArg); }
-    get(key) { return this.m.get(key); }
-    has(key) { return this.m.has(key); }
-    set(key, value) { this.mutable.set(key, value); return this; }
-    get size() { return this.m.size; }
-    entries() { return this.m.entries(); }
-    keys() { return this.m.keys(); }
-    values() { return this.m.values(); }
-    get mutable() {
-        const createCopy = this.m[Sealant.CreateCopy];
-        if (createCopy)
-            return this.m = createCopy.call(this.m);
-        return this.m;
+        super(true);
     }
 }
 const DEFAULT_OPTIONS = Object.freeze({
     kind: Kind.Plain,
-    standalone: false,
+    separation: false,
     order: 0,
     noSideEffects: false,
     triggeringArgs: false,
@@ -95,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);
@@ -112,7 +59,10 @@ 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 {
+export class Mvcc {
+    constructor(isReactive) {
+        this.isReactive = isReactive;
+    }
     getPrototypeOf(h) {
         return Reflect.getPrototypeOf(h.data);
     }
@@ -123,7 +73,8 @@ export class Hooks {
             const os = cs.getObjectSnapshot(h, m);
             result = os.data[m];
             if (result instanceof Subscription && !result.isOperation) {
-                Changeset.markUsed(result, os, m, h, Kind.Plain, false);
+                if (this.isReactive)
+                    Changeset.markUsed(result, os, m, h, Kind.Plain, false);
                 result = result.content;
             }
             else
@@ -138,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);
@@ -181,12 +132,12 @@ export class Hooks {
     static decorateData(reactive, proto, m) {
         if (reactive) {
             const get = function () {
-                const h = Hooks.acquireHandle(this);
-                return Hooks.handler.get(h, m, this);
+                const h = Mvcc.acquireHandle(this);
+                return Mvcc.reactive.get(h, m, this);
             };
             const set = function (value) {
-                const h = Hooks.acquireHandle(this);
-                return Hooks.handler.set(h, m, value, this);
+                const h = Mvcc.acquireHandle(this);
+                return Mvcc.reactive.set(h, m, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -201,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;
             };
@@ -213,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);
             };
@@ -225,7 +176,7 @@ 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) {
@@ -235,69 +186,71 @@ export class Hooks {
                 throw misuse('only objects can be reactive');
             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.handler, os, obj.constructor.name);
+            h = new ObjectHandle(obj, obj, Mvcc.reactive, 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 createHandleForReactiveObject(proto, data, blank, hint) {
+    static createHandleForMvccObject(proto, data, blank, hint, reactive) {
         const ctx = Changeset.edit();
-        const h = new ObjectHandle(data, undefined, Hooks.handler, EMPTY_SNAPSHOT, hint);
+        const mvcc = reactive ? Mvcc.reactive : 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.handler = new Hooks();
-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.reactive = 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(reactive: 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 ReactiveArray<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(reactive, array) {
+        super(reactive);
+        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 ReactiveArray 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 { ReactiveObject } from './Mvcc';
+export declare abstract class ReactiveCollection<T> extends ReactiveObject 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 { ReactiveObject } from './Mvcc';
+export class ReactiveCollection extends ReactiveObject {
+    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(reactive: 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 ReactiveMap<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(reactive, map) {
+        super(reactive);
+        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 ReactiveMap 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[];