reactronic 0.22.300 → 0.22.303

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

@@ -1,24 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hooks = exports.OptionsImpl = exports.SubscribingObject = 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");
-class SubscribingObject {
+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.createDataHolderForSubscribingObject(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.SubscribingObject = SubscribingObject;
+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,42 +136,42 @@ 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);
         }
         return result;
     }
-    static decorateData(subscribing, proto, m) {
-        if (subscribing) {
+    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;
             return Object.defineProperty(proto, m, { get, set, enumerable, configurable });
         }
         else
-            Data_1.Meta.acquire(proto, Data_1.Meta.Initial)[m] = Data_1.Meta.Nonsubscribing;
+            Data_1.Meta.acquire(proto, Data_1.Meta.Initial)[m] = Data_1.Meta.Nonreactive;
     }
     static decorateOperation(implicit, decorator, options, proto, member, pd) {
         var _a, _b, _c, _d;
@@ -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 createDataHolderForSubscribingObject(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,7 +1,7 @@
-import { SubscribingObject } from './Hooks';
-import { DataHolder, DataRevision, PatchSet } from './Data';
+import { ReactiveObject } from './Hooks';
+import { ObjectHandle, ObjectSnapshot, PatchSet } from './Data';
 export declare type Saver = (patch: PatchSet) => Promise<void>;
-export declare abstract class Journal extends SubscribingObject {
+export declare abstract class Journal extends ReactiveObject {
     abstract capacity: number;
     abstract readonly edits: ReadonlyArray<PatchSet>;
     abstract readonly unsaved: PatchSet;
@@ -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,10 +3,10 @@ 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.SubscribingObject {
+class Journal extends Hooks_1.ReactiveObject {
     static create() { return new JournalImpl(); }
 }
 exports.Journal = Journal;
@@ -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,10 +1,10 @@
 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 Nonsubscribing: unique symbol;
+    static readonly Nonreactive: unique symbol;
     static readonly Undefined: unique symbol;
     static get<T>(obj: any, sym: symbol): T;
     static set(obj: any, sym: symbol, value: any): any;

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

@@ -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.Nonsubscribing = Symbol('rxNonsubscribing');
-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/Monitor.d.ts

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

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MonitorImpl = exports.Monitor = void 0;
 const Hooks_1 = require("./Hooks");
 const Transaction_1 = require("./Transaction");
-class Monitor extends Hooks_1.SubscribingObject {
+class Monitor extends Hooks_1.ReactiveObject {
     static create(hint, activationDelay, deactivationDelay, durationResolution) {
         return MonitorImpl.create(hint, activationDelay, deactivationDelay, durationResolution);
     }

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

@@ -1,15 +1,15 @@
 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;
-    get nonsubscribing(): any;
+    get nonreactive(): any;
     get args(): ReadonlyArray<any>;
     get result(): any;
     get error(): boolean;
@@ -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;