reactronic 0.22.302 → 0.22.303

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

@@ -1,13 +1,42 @@
 import { F } from '../util/Utils';
 import { MemberOptions, Kind, Reentrance } from '../Options';
 import { LoggingOptions, ProfilingOptions } from '../Logging';
-import { MemberName, DataHolder, StandaloneMode } from './Data';
+import { MemberName, ObjectHandle, StandaloneMode } from './Data';
 import { Journal } from './Journal';
 import { Monitor } from './Monitor';
 export declare abstract class ReactiveObject {
     constructor();
     [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;
+    private get mutable();
+}
 export declare class OptionsImpl implements MemberOptions {
     readonly getter: Function;
     readonly setter: Function;
@@ -24,27 +53,27 @@ 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<DataHolder> {
+export declare class Hooks implements ProxyHandler<ObjectHandle> {
     static reactionsAutoStartDisabled: boolean;
     static repetitiveUsageWarningThreshold: number;
     static mainThreadBlockingWarningThreshold: number;
     static asyncActionDurationWarningThreshold: number;
     static sensitivity: boolean;
-    static readonly proxy: Hooks;
-    getPrototypeOf(h: DataHolder): object | null;
-    get(h: DataHolder, m: MemberName, receiver: any): any;
-    set(h: DataHolder, m: MemberName, value: any, receiver: any): boolean;
-    has(h: DataHolder, m: MemberName): boolean;
-    getOwnPropertyDescriptor(h: DataHolder, m: MemberName): PropertyDescriptor | undefined;
-    ownKeys(h: DataHolder): Array<string | symbol>;
+    static readonly handler: Hooks;
+    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 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 acquireDataHolder(obj: any): DataHolder;
-    static createDataHolderForReactiveObject(proto: any, data: any, blank: any, hint: string): DataHolder;
+    static acquireHandle(obj: any): ObjectHandle;
+    static createHandleForReactiveObject(proto: any, data: any, blank: any, hint: string): 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;
-    static createOperation: (h: DataHolder, m: MemberName, options: OptionsImpl) => F<any>;
+    static createOperation: (h: ObjectHandle, m: MemberName, options: OptionsImpl) => F<any>;
     static rememberOperationOptions: (proto: any, m: MemberName, getter: Function | undefined, setter: Function | undefined, enumerable: boolean, configurable: boolean, options: Partial<MemberOptions>, implicit: boolean) => OptionsImpl;
 }

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

@@ -1,24 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hooks = exports.OptionsImpl = exports.ReactiveObject = void 0;
+exports.Hooks = exports.OptionsImpl = exports.ReactiveArray = exports.ReactiveObject = void 0;
 const Utils_1 = require("../util/Utils");
+const Sealant_1 = require("../util/Sealant");
 const Dbg_1 = require("../util/Dbg");
 const Options_1 = require("../Options");
 const Data_1 = require("./Data");
-const Snapshot_1 = require("./Snapshot");
+const Changeset_1 = require("./Changeset");
 class ReactiveObject {
     constructor() {
         const proto = new.target.prototype;
         const initial = Data_1.Meta.getFrom(proto, Data_1.Meta.Initial);
-        const h = Hooks.createDataHolderForReactiveObject(proto, this, initial, new.target.name);
+        const h = Hooks.createHandleForReactiveObject(proto, this, initial, new.target.name);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
-        const h = Data_1.Meta.get(this, Data_1.Meta.Holder);
-        return Snapshot_1.Dump.obj(h);
+        const h = Data_1.Meta.get(this, Data_1.Meta.Handle);
+        return Changeset_1.Dump.obj(h);
     }
 }
 exports.ReactiveObject = ReactiveObject;
+class ReactiveArray extends ReactiveObject {
+    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); }
+    get mutable() {
+        const createCopy = this.a[Sealant_1.Sealant.CreateCopy];
+        if (createCopy)
+            return this.a = createCopy.call(this.a);
+        return this.a;
+    }
+}
+exports.ReactiveArray = ReactiveArray;
 const DEFAULT_OPTIONS = Object.freeze({
     kind: Options_1.Kind.Plain,
     standalone: false,
@@ -60,32 +99,32 @@ class Hooks {
     }
     get(h, m, receiver) {
         let result;
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-        result = r.data[m];
+        const os = Changeset_1.Changeset.current().getRelevantSnapshot(h, m);
+        result = os.data[m];
         if (result instanceof Data_1.Subscription && !result.isOperation) {
-            Snapshot_1.Snapshot.markUsed(result, r, m, h, Options_1.Kind.Plain, false);
+            Changeset_1.Changeset.markUsed(result, os, m, h, Options_1.Kind.Plain, false);
             result = result.content;
         }
-        else if (m === Data_1.Meta.Holder) {
+        else if (m === Data_1.Meta.Handle) {
         }
         else
             result = Reflect.get(h.data, m, receiver);
         return result;
     }
     set(h, m, value, receiver) {
-        const r = Snapshot_1.Snapshot.edit().getEditableRevision(h, m, value);
-        if (r !== Snapshot_1.ROOT_REV) {
-            let curr = r.data[m];
-            if (curr !== undefined || (r.former.revision.snapshot === Snapshot_1.ROOT_REV.snapshot && (m in h.data) === false)) {
+        const os = Changeset_1.Changeset.edit().getEditableSnapshot(h, m, value);
+        if (os !== Changeset_1.EMPTY_SNAPSHOT) {
+            let curr = os.data[m];
+            if (curr !== undefined || (os.former.snapshot.changeset === Changeset_1.EMPTY_SNAPSHOT.changeset && (m in h.data) === false)) {
                 if (curr === undefined || curr.content !== value || Hooks.sensitivity) {
                     const existing = curr === null || curr === void 0 ? void 0 : curr.content;
-                    if (r.former.revision.data[m] === curr) {
-                        curr = r.data[m] = new Data_1.Subscription(value);
-                        Snapshot_1.Snapshot.markEdited(existing, value, true, r, m, h);
+                    if (os.former.snapshot.data[m] === curr) {
+                        curr = os.data[m] = new Data_1.Subscription(value);
+                        Changeset_1.Changeset.markEdited(existing, value, true, os, m, h);
                     }
                     else {
                         curr.content = value;
-                        Snapshot_1.Snapshot.markEdited(existing, value, true, r, m, h);
+                        Changeset_1.Changeset.markEdited(existing, value, true, os, m, h);
                     }
                 }
             }
@@ -97,21 +136,21 @@ class Hooks {
         return true;
     }
     has(h, m) {
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-        return m in r.data || m in h.data;
+        const os = Changeset_1.Changeset.current().getRelevantSnapshot(h, m);
+        return m in os.data || m in h.data;
     }
     getOwnPropertyDescriptor(h, m) {
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-        const pd = Reflect.getOwnPropertyDescriptor(r.data, m);
+        const os = Changeset_1.Changeset.current().getRelevantSnapshot(h, m);
+        const pd = Reflect.getOwnPropertyDescriptor(os.data, m);
         if (pd)
             pd.configurable = pd.writable = true;
         return pd;
     }
     ownKeys(h) {
-        const r = Snapshot_1.Snapshot.current().getCurrentRevision(h, Data_1.Meta.Holder);
+        const os = Changeset_1.Changeset.current().getRelevantSnapshot(h, Data_1.Meta.Handle);
         const result = [];
-        for (const m of Object.getOwnPropertyNames(r.data)) {
-            const value = r.data[m];
+        for (const m of Object.getOwnPropertyNames(os.data)) {
+            const value = os.data[m];
             if (!(value instanceof Data_1.Subscription) || !value.isOperation)
                 result.push(m);
         }
@@ -120,12 +159,12 @@ class Hooks {
     static decorateData(reactive, proto, m) {
         if (reactive) {
             const get = function () {
-                const h = Hooks.acquireDataHolder(this);
-                return Hooks.proxy.get(h, m, this);
+                const h = Hooks.acquireHandle(this);
+                return Hooks.handler.get(h, m, this);
             };
             const set = function (value) {
-                const h = Hooks.acquireDataHolder(this);
-                return Hooks.proxy.set(h, m, value, this);
+                const h = Hooks.acquireHandle(this);
+                return Hooks.handler.set(h, m, value, this);
             };
             const enumerable = true;
             const configurable = false;
@@ -143,7 +182,7 @@ class Hooks {
         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);
         if (opts.getter === opts.setter) {
             const bootstrap = function () {
-                const h = Hooks.acquireDataHolder(this);
+                const h = Hooks.acquireHandle(this);
                 const operation = Hooks.createOperation(h, member, opts);
                 Object.defineProperty(h.data, member, { value: operation, enumerable, configurable });
                 return operation;
@@ -152,7 +191,7 @@ class Hooks {
         }
         else if (opts.setter === Utils_1.UNDEF) {
             const bootstrap = function () {
-                const h = Hooks.acquireDataHolder(this);
+                const h = Hooks.acquireHandle(this);
                 const operation = Hooks.createOperation(h, member, opts);
                 Object.defineProperty(h.data, member, { get: operation, enumerable, configurable });
                 return operation.call(this);
@@ -167,23 +206,24 @@ class Hooks {
             return Hooks.decorateOperation(false, decorator, options, proto, prop, pd);
         };
     }
-    static acquireDataHolder(obj) {
-        let h = obj[Data_1.Meta.Holder];
+    static acquireHandle(obj) {
+        let h = obj[Data_1.Meta.Handle];
         if (!h) {
             if (obj !== Object(obj) || Array.isArray(obj))
                 throw (0, Dbg_1.misuse)('only objects can be reactive');
             const initial = Data_1.Meta.getFrom(Object.getPrototypeOf(obj), Data_1.Meta.Initial);
-            const rev = new Data_1.DataRevision(Snapshot_1.ROOT_REV.snapshot, Snapshot_1.ROOT_REV, Object.assign({}, initial));
-            Data_1.Meta.set(rev.data, Data_1.Meta.Holder, h);
-            h = new Data_1.DataHolder(obj, obj, Hooks.proxy, rev, obj.constructor.name);
-            Data_1.Meta.set(obj, Data_1.Meta.Holder, h);
+            const os = new Data_1.ObjectSnapshot(Changeset_1.EMPTY_SNAPSHOT.changeset, Changeset_1.EMPTY_SNAPSHOT, Object.assign({}, initial));
+            h = new Data_1.ObjectHandle(obj, obj, Hooks.handler, os, obj.constructor.name);
+            Data_1.Meta.set(os.data, Data_1.Meta.Handle, h);
+            Data_1.Meta.set(obj, Data_1.Meta.Handle, h);
+            Data_1.Meta.set(os.data, Data_1.Meta.Revision, new Data_1.Subscription(1));
         }
         return h;
     }
-    static createDataHolderForReactiveObject(proto, data, blank, hint) {
-        const ctx = Snapshot_1.Snapshot.edit();
-        const h = new Data_1.DataHolder(data, undefined, Hooks.proxy, Snapshot_1.ROOT_REV, hint);
-        ctx.getEditableRevision(h, Data_1.Meta.Holder, blank);
+    static createHandleForReactiveObject(proto, data, blank, hint) {
+        const ctx = Changeset_1.Changeset.edit();
+        const h = new Data_1.ObjectHandle(data, undefined, Hooks.handler, Changeset_1.EMPTY_SNAPSHOT, hint);
+        ctx.getEditableSnapshot(h, Data_1.Meta.Handle, blank);
         if (!Hooks.reactionsAutoStartDisabled)
             for (const m in Data_1.Meta.getFrom(proto, Data_1.Meta.Reactions))
                 h.proxy[m][Data_1.Meta.Controller].markObsolete();
@@ -194,13 +234,13 @@ class Hooks {
             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;
-            Snapshot_1.Snapshot.garbageCollectionSummaryInterval = options && options.garbageCollectionSummaryInterval !== undefined ? options.garbageCollectionSummaryInterval : 100;
+            Changeset_1.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;
-            Snapshot_1.Snapshot.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
+            Changeset_1.Changeset.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
         }
     }
     static sensitive(sensitivity, func, ...args) {
@@ -215,7 +255,7 @@ class Hooks {
     }
     static setHint(obj, hint) {
         if (hint) {
-            const h = Hooks.acquireDataHolder(obj);
+            const h = Hooks.acquireHandle(obj);
             h.hint = hint;
         }
         return obj;
@@ -227,7 +267,7 @@ Hooks.repetitiveUsageWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.sensitivity = false;
-Hooks.proxy = new Hooks();
+Hooks.handler = new Hooks();
 Hooks.createOperation = function (h, m, options) {
     throw (0, Dbg_1.misuse)('createOperation should never be called');
 };

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

@@ -1,5 +1,5 @@
 import { ReactiveObject } from './Hooks';
-import { DataHolder, DataRevision, PatchSet } from './Data';
+import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
 export declare type Saver = (patch: PatchSet) => Promise<void>;
 export declare abstract class Journal extends ReactiveObject {
     abstract capacity: number;
@@ -28,7 +28,7 @@ export declare class JournalImpl extends Journal {
     saved(patch: PatchSet): void;
     undo(count?: number): void;
     redo(count?: number): void;
-    static buildPatch(hint: string, changeset: Map<DataHolder, DataRevision>): PatchSet;
+    static buildPatch(hint: string, items: Map<ObjectHandle, ObjectSnapshot>): PatchSet;
     static applyPatch(patch: PatchSet, undoing: boolean): void;
     mergePatchToUnsaved(patch: PatchSet, undoing: boolean): void;
 }

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JournalImpl = exports.Journal = void 0;
 const Hooks_1 = require("./Hooks");
 const Data_1 = require("./Data");
-const Snapshot_1 = require("./Snapshot");
+const Changeset_1 = require("./Changeset");
 const Transaction_1 = require("./Transaction");
 const Sealant_1 = require("../util/Sealant");
 class Journal extends Hooks_1.ReactiveObject {
@@ -15,7 +15,7 @@ class JournalImpl extends Journal {
         super(...arguments);
         this._capacity = 5;
         this._edits = [];
-        this._unsaved = { hint: 'unsaved', objects: new Map() };
+        this._unsaved = { hint: 'unsaved', items: new Map() };
         this._position = 0;
     }
     get capacity() { return this._capacity; }
@@ -39,7 +39,7 @@ class JournalImpl extends Journal {
     }
     saved(patch) {
         if (this._unsaved === patch)
-            this._unsaved = { hint: 'unsaved', objects: new Map() };
+            this._unsaved = { hint: 'unsaved', items: new Map() };
         else
             throw new Error('not implemented');
     }
@@ -67,66 +67,77 @@ class JournalImpl extends Journal {
             this._position = i;
         });
     }
-    static buildPatch(hint, changeset) {
-        const patch = { hint, objects: new Map() };
-        changeset.forEach((r, h) => {
-            const op = { data: {}, former: {} };
-            const former = r.former.revision !== Snapshot_1.ROOT_REV ? r.former.revision.data : undefined;
-            r.changes.forEach(m => {
-                op.data[m] = unseal(r.data[m]);
+    static buildPatch(hint, items) {
+        const patch = { hint, items: new Map() };
+        items.forEach((os, h) => {
+            const op = new Map();
+            const former = os.former.snapshot !== Changeset_1.EMPTY_SNAPSHOT ? os.former.snapshot.data : undefined;
+            os.changes.forEach(m => {
+                const vp = {
+                    memberName: m, patchKind: 'update',
+                    freshValue: unseal(os.data[m]), formerValue: undefined,
+                };
                 if (former)
-                    op.former[m] = unseal(former[m]);
+                    vp.formerValue = unseal(former[m]);
+                op.set(m, vp);
             });
             if (!former) {
-                delete op.data[Data_1.Meta.Disposed];
-                op.former[Data_1.Meta.Disposed] = Data_1.Meta.Disposed;
+                const vp = {
+                    memberName: Data_1.Meta.Revision, patchKind: 'remove',
+                    freshValue: Data_1.Meta.Undefined, formerValue: undefined,
+                };
+                op.set(Data_1.Meta.Revision, vp);
             }
-            patch.objects.set(h.proxy, op);
+            patch.items.set(h.proxy, op);
         });
         return patch;
     }
     static applyPatch(patch, undoing) {
-        const ctx = Snapshot_1.Snapshot.edit();
-        patch.objects.forEach((dp, obj) => {
-            const h = Data_1.Meta.get(obj, Data_1.Meta.Holder);
-            const data = undoing ? dp.former : dp.data;
-            if (data[Data_1.Meta.Disposed] === undefined) {
-                for (const m in data) {
-                    const value = data[m];
-                    const r = ctx.getEditableRevision(h, m, value);
-                    if (r.snapshot === ctx) {
-                        r.data[m] = new Data_1.Subscription(value);
-                        const existing = r.former.revision.data[m];
-                        Snapshot_1.Snapshot.markEdited(existing, value, existing !== value, r, m, h);
+        const ctx = Changeset_1.Changeset.edit();
+        patch.items.forEach((op, obj) => {
+            const h = Data_1.Meta.get(obj, Data_1.Meta.Handle);
+            const rev = op.get(Data_1.Meta.Revision);
+            const disposed = rev && (undoing ? rev.formerValue : rev.freshValue) === Data_1.Meta.Undefined;
+            if (!disposed) {
+                op.forEach((vp, m) => {
+                    const value = undoing ? vp.formerValue : vp.freshValue;
+                    const os = ctx.getEditableSnapshot(h, m, value);
+                    if (os.changeset === ctx) {
+                        os.data[m] = new Data_1.Subscription(value);
+                        const existing = os.former.snapshot.data[m];
+                        Changeset_1.Changeset.markEdited(existing, value, existing !== value, os, m, h);
                     }
-                }
+                });
             }
             else
-                Snapshot_1.Snapshot.doDispose(ctx, h);
+                Changeset_1.Changeset.doDispose(ctx, h);
         });
     }
     mergePatchToUnsaved(patch, undoing) {
         const unsaved = this._unsaved;
-        patch.objects.forEach((dp, obj) => {
-            let merged = unsaved.objects.get(obj);
-            if (!merged)
-                unsaved.objects.set(obj, merged = { data: {}, former: {} });
-            const data = undoing ? dp.former : dp.data;
-            const former = undoing ? dp.data : dp.former;
-            for (const m in data) {
-                const value = data[m];
-                if (value !== merged.former[m]) {
-                    merged.data[m] = value;
-                    if (m in merged.former === false)
-                        merged.former[m] = former[m];
+        patch.items.forEach((op, obj) => {
+            let result = unsaved.items.get(obj);
+            if (!result)
+                unsaved.items.set(obj, result = new Map());
+            op.forEach((vp, m) => {
+                let merged = result.get(m);
+                if (!merged)
+                    result.set(m, merged = {
+                        memberName: m, patchKind: 'update',
+                        freshValue: undefined, formerValue: undefined,
+                    });
+                const value = undoing ? vp.formerValue : vp.freshValue;
+                const former = undoing ? vp.freshValue : vp.formerValue;
+                if (value !== merged.formerValue) {
+                    merged.freshValue = value;
+                    merged.formerValue = former;
                 }
                 else {
-                    delete merged.data[m];
-                    delete merged.former[m];
-                    if (Object.keys(merged.data).length === 0)
-                        unsaved.objects.delete(obj);
+                    result.delete(m);
+                    if (result.size === 0)
+                        unsaved.items.delete(obj);
                 }
-            }
+            });
         });
     }
 }

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

@@ -1,7 +1,7 @@
 export declare abstract class Meta {
-    static readonly Holder: unique symbol;
+    static readonly Handle: unique symbol;
+    static readonly Revision: unique symbol;
     static readonly Controller: unique symbol;
-    static readonly Disposed: unique symbol;
     static readonly Initial: unique symbol;
     static readonly Reactions: unique symbol;
     static readonly Nonreactive: unique symbol;

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

@@ -24,10 +24,10 @@ class Meta {
     }
 }
 exports.Meta = Meta;
-Meta.Holder = Symbol('rxHolder');
-Meta.Controller = Symbol('rxController');
-Meta.Disposed = Symbol('rxDisposed');
-Meta.Initial = Symbol('rxInitial');
-Meta.Reactions = Symbol('rxReactions');
-Meta.Nonreactive = Symbol('rxNonreactive');
-Meta.Undefined = Symbol('rxUndefined');
+Meta.Handle = Symbol('rx-handle');
+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.Undefined = Symbol('rx-undefined');

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

@@ -1,11 +1,11 @@
 import { F } from '../util/Utils';
 import { MemberOptions } from '../Options';
 import { Controller } from '../Controller';
-import { MemberName, DataHolder, Subscription, Subscriber, SubscriptionInfo, AbstractSnapshot } from './Data';
+import { MemberName, ObjectHandle, Subscription, Subscriber, SubscriptionInfo, AbstractChangeset } from './Data';
 import { Transaction } from './Transaction';
 import { OptionsImpl } from './Hooks';
 export declare class OperationController extends Controller<any> {
-    readonly ownHolder: DataHolder;
+    readonly objectHandle: ObjectHandle;
     readonly memberName: MemberName;
     configure(options: Partial<MemberOptions>): MemberOptions;
     get options(): MemberOptions;
@@ -17,7 +17,7 @@ export declare class OperationController extends Controller<any> {
     get isUpToDate(): boolean;
     markObsolete(): void;
     pullLastResult(args?: any[]): any;
-    constructor(ownHolder: DataHolder, memberName: MemberName);
+    constructor(h: ObjectHandle, m: MemberName);
     useOrRun(weak: boolean, args: any[] | undefined): Operation;
     static of(method: F<any>): Controller<any>;
     static configureImpl(self: OperationController | undefined, options: Partial<MemberOptions>): MemberOptions;
@@ -28,7 +28,7 @@ export declare class OperationController extends Controller<any> {
     private peek;
     private use;
     private edit;
-    private acquireFromRevision;
+    private acquireFromSnapshot;
     private run;
     private static markObsolete;
 }
@@ -39,7 +39,7 @@ declare class Operation extends Subscription implements Subscriber {
     readonly margin: number;
     readonly transaction: Transaction;
     readonly controller: OperationController;
-    readonly snapshot: AbstractSnapshot;
+    readonly changeset: AbstractChangeset;
     subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
     options: OptionsImpl;
     cause: string | undefined;
@@ -50,7 +50,7 @@ declare class Operation extends Subscription implements Subscriber {
     obsoleteDueTo: string | undefined;
     obsoleteSince: number;
     successor: Operation | undefined;
-    constructor(controller: OperationController, snapshot: AbstractSnapshot, former: Operation | OptionsImpl);
+    constructor(controller: OperationController, changeset: AbstractChangeset, former: Operation | OptionsImpl);
     get isOperation(): boolean;
     get originSnapshotId(): number;
     hint(): string;
@@ -61,7 +61,7 @@ declare class Operation extends Subscription implements Subscriber {
     dependencies(): string[];
     wrap<T>(func: F<T>): F<T>;
     run(proxy: any, args: any[] | undefined): void;
-    markObsoleteDueTo(subscription: Subscription, memberName: MemberName, snapshot: AbstractSnapshot, holder: DataHolder, outer: string, since: number, reactions: Subscriber[]): void;
+    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactions: Subscriber[]): void;
     runIfNotUpToDate(now: boolean, nothrow: boolean): void;
     isNotUpToDate(): boolean;
     reenterOver(head: Operation): this;