reactronic 0.22.109 → 0.22.202

package/README.md

@@ -302,39 +302,30 @@ function reaction(proto, prop, pd) // method only
 function cached(proto, prop, pd) // method only
 function options(value: Partial<MemberOptions>): F<any>
 
-function noSideEffects(value: boolean) // transaction & cached & reaction
-function sensitiveArgs(value: boolean) // cached & reaction
-function throttling(milliseconds: number) // reaction only
-function reentrance(value: Reentrance) // transaction & reaction
-function monitor(value: Monitor | null)
-function trace(value: Partial<TraceOptions>)
-
 function nonreactive<T>(func: F<T>, ...args: any[]): T
 function sensitive<T>(sensitivity: Sensitivity, func: F<T>, ...args: any[]): T
 
-// Options, ObjectOptions, Kind, Reentrance, Monitor, TraceOptions, ProfilingOptions
+// SnapshotOptions, MemberOptions, Kind, Reentrance, Monitor, LoggingOptions, ProfilingOptions
 
-interface Options {
-  readonly kind: Kind
-  readonly noSideEffects: boolean
-  readonly sensitiveArgs: boolean
-  readonly throttling: number // milliseconds, -1 is immediately, Number.MAX_SAFE_INTEGER is never
-  readonly reentrance: Reentrance
-  readonly monitor: Monitor | null
-  readonly trace?: Partial<TraceOptions>
+export interface SnapshotOptions {
+  readonly hint?: string
+  readonly standalone?: StandaloneMode
+  readonly journal?: TransactionJournal
+  readonly logging?: Partial<LoggingOptions>
+  readonly token?: any
 }
 
-export interface MemberOptions {
+interface MemberOptions {
   readonly kind: Kind
   readonly standalone: StandaloneMode
   readonly order: number
   readonly noSideEffects: boolean
-  readonly sensitiveArgs: boolean
+  readonly triggeringArgs: boolean
   readonly throttling: number // milliseconds, -1 is immediately, Number.MAX_SAFE_INTEGER is never
   readonly reentrance: Reentrance
   readonly journal: TransactionJournal | undefined
   readonly monitor: Monitor | null
-  readonly trace?: Partial<TraceOptions>
+  readonly logging?: Partial<LoggingOptions>
 }
 
 enum Kind {
@@ -375,8 +366,8 @@ interface Worker {
   whenFinished(): Promise<void>
 }
 
-interface TraceOptions {
-  readonly silent: boolean
+interface LoggingOptions {
+  readonly off: boolean
   readonly transaction: boolean
   readonly operation: boolean
   readonly step: boolean
@@ -451,12 +442,12 @@ class Reactronic {
   static takeSnapshot<T>(obj: T): T
   static dispose(obj: any): void
   static reactionsAutoStartDisabled: boolean
-  static readonly isTraceEnabled: boolean
-  static readonly traceOptions: TraceOptions
-  static setTraceMode(enabled: boolean, options?: TraceOptions)
-  static setTraceHint<T extends object>(obj: T, name: string | undefined): void
-  static getTraceHint<T extends object>(obj: T): string | undefined
-  static setProfilingMode(enabled: boolean, options?: Partial<ProfilingOptions>): void
+  static readonly isLogging: boolean
+  static readonly loggingOptions: LoggingOptions
+  static setLoggingMode(isOn: boolean, options?: LoggingOptions)
+  static setLoggingHint<T extends object>(obj: T, name: string | undefined): void
+  static getLoggingHint<T extends object>(obj: T): string | undefined
+  static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void
 }
 
 ```

package/build/dist/source/{Trace.d.ts → Logging.d.ts}

@@ -1,5 +1,5 @@
-export interface TraceOptions {
-    readonly silent: boolean;
+export interface LoggingOptions {
+    readonly enabled: boolean;
     readonly transaction: boolean;
     readonly operation: boolean;
     readonly step: boolean;
@@ -22,13 +22,13 @@ export interface ProfilingOptions {
     asyncActionDurationWarningThreshold: number;
     garbageCollectionSummaryInterval: number;
 }
-export declare const TraceLevel: {
-    ErrorsOnly: TraceOptions;
-    Reactions: TraceOptions;
-    Transactions: TraceOptions;
-    Operations: TraceOptions;
-    Debug: TraceOptions;
-    Silent: TraceOptions;
+export declare const LoggingLevel: {
+    Off: LoggingOptions;
+    ErrorsOnly: LoggingOptions;
+    Reactions: LoggingOptions;
+    Transactions: LoggingOptions;
+    Operations: LoggingOptions;
+    Debug: LoggingOptions;
 };
 declare global {
     interface Window {

package/build/dist/source/{Trace.js → Logging.js}

@@ -1,9 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TraceLevel = void 0;
-exports.TraceLevel = {
+exports.LoggingLevel = void 0;
+exports.LoggingLevel = {
+    Off: {
+        enabled: false,
+        transaction: false,
+        operation: false,
+        step: false,
+        monitor: false,
+        read: false,
+        write: false,
+        change: false,
+        obsolete: false,
+        error: true,
+        warning: true,
+        gc: false,
+        color: 37,
+        prefix: '',
+        margin1: 0,
+        margin2: 0,
+    },
     ErrorsOnly: {
-        silent: false,
+        enabled: true,
         transaction: false,
         operation: false,
         step: false,
@@ -21,7 +39,7 @@ exports.TraceLevel = {
         margin2: 0,
     },
     Reactions: {
-        silent: false,
+        enabled: true,
         transaction: false,
         operation: false,
         step: false,
@@ -39,7 +57,7 @@ exports.TraceLevel = {
         margin2: 0,
     },
     Transactions: {
-        silent: false,
+        enabled: true,
         transaction: true,
         operation: false,
         step: false,
@@ -57,7 +75,7 @@ exports.TraceLevel = {
         margin2: 0,
     },
     Operations: {
-        silent: false,
+        enabled: true,
         transaction: true,
         operation: true,
         step: false,
@@ -75,7 +93,7 @@ exports.TraceLevel = {
         margin2: 0,
     },
     Debug: {
-        silent: false,
+        enabled: true,
         transaction: true,
         operation: true,
         step: true,
@@ -92,22 +110,4 @@ exports.TraceLevel = {
         margin1: 0,
         margin2: 0,
     },
-    Silent: {
-        silent: true,
-        transaction: false,
-        operation: false,
-        step: false,
-        monitor: false,
-        read: false,
-        write: false,
-        change: false,
-        obsolete: false,
-        error: true,
-        warning: true,
-        gc: false,
-        color: 37,
-        prefix: '',
-        margin1: 0,
-        margin2: 0,
-    },
 };

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

@@ -1,13 +1,13 @@
-import { TraceOptions } from './Trace';
+import { LoggingOptions } from './Logging';
 import { StandaloneMode } from './impl/Data';
-export { TraceOptions, ProfilingOptions, TraceLevel } from './Trace';
+export { LoggingOptions, ProfilingOptions, LoggingLevel } from './Logging';
 import { TransactionJournal } from './impl/TransactionJournal';
 import { Monitor } from './impl/Monitor';
 export interface SnapshotOptions {
     readonly hint?: string;
     readonly standalone?: StandaloneMode;
     readonly journal?: TransactionJournal;
-    readonly trace?: Partial<TraceOptions>;
+    readonly logging?: Partial<LoggingOptions>;
     readonly token?: any;
 }
 export interface MemberOptions {
@@ -15,12 +15,12 @@ export interface MemberOptions {
     readonly standalone: StandaloneMode;
     readonly order: number;
     readonly noSideEffects: boolean;
-    readonly sensitiveArgs: boolean;
+    readonly triggeringArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly journal: TransactionJournal | undefined;
     readonly monitor: Monitor | null;
-    readonly trace?: Partial<TraceOptions>;
+    readonly logging?: Partial<LoggingOptions>;
 }
 export declare enum Kind {
     Plain = 0,

package/build/dist/source/Options.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reentrance = exports.Kind = exports.TraceLevel = void 0;
-var Trace_1 = require("./Trace");
-Object.defineProperty(exports, "TraceLevel", { enumerable: true, get: function () { return Trace_1.TraceLevel; } });
+exports.Reentrance = exports.Kind = exports.LoggingLevel = void 0;
+var Logging_1 = require("./Logging");
+Object.defineProperty(exports, "LoggingLevel", { enumerable: true, get: function () { return Logging_1.LoggingLevel; } });
 var Kind;
 (function (Kind) {
     Kind[Kind["Plain"] = 0] = "Plain";

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

@@ -1,6 +1,6 @@
 import { F } from './util/Utils';
 import { Controller } from './Controller';
-import { MemberOptions, TraceOptions, ProfilingOptions } from './Options';
+import { MemberOptions, LoggingOptions, ProfilingOptions } from './Options';
 export declare class Rx {
     static why(brief?: boolean): string;
     static getController<T>(method: F<T>): Controller<T>;
@@ -10,12 +10,12 @@ export declare class Rx {
     static dispose(obj: any): void;
     static get reactionsAutoStartDisabled(): boolean;
     static set reactionsAutoStartDisabled(value: boolean);
-    static get isTraceEnabled(): boolean;
-    static get traceOptions(): TraceOptions;
-    static setTraceMode(enabled: boolean, options?: TraceOptions): void;
-    static setTraceHint<T extends object>(obj: T, name: string | undefined): void;
-    static getTraceHint<T extends object>(obj: T, full?: boolean): string | undefined;
-    static setProfilingMode(enabled: boolean, options?: Partial<ProfilingOptions>): void;
+    static get isLogging(): boolean;
+    static get loggingOptions(): LoggingOptions;
+    static setLoggingMode(isOn: boolean, options?: LoggingOptions): void;
+    static setLoggingHint<T extends object>(obj: T, name: string | undefined): void;
+    static getLoggingHint<T extends object>(obj: T, full?: boolean): string | undefined;
+    static setProfilingMode(isOn: boolean, options?: Partial<ProfilingOptions>): void;
 }
 export declare function nonreactive<T>(func: F<T>, ...args: any[]): T;
 export declare function sensitive<T>(sensitivity: boolean, func: F<T>, ...args: any[]): T;

package/build/dist/source/Rx.js

@@ -16,12 +16,12 @@ class Rx {
     static dispose(obj) { Snapshot_1.Snapshot.dispose(obj); }
     static get reactionsAutoStartDisabled() { return Hooks_1.Hooks.reactionsAutoStartDisabled; }
     static set reactionsAutoStartDisabled(value) { Hooks_1.Hooks.reactionsAutoStartDisabled = value; }
-    static get isTraceEnabled() { return Dbg_1.Dbg.isOn; }
-    static get traceOptions() { return Dbg_1.Dbg.trace; }
-    static setTraceMode(enabled, options) { Dbg_1.Dbg.setTraceMode(enabled, options); }
-    static setTraceHint(obj, name) { Hooks_1.Hooks.setHint(obj, name); }
-    static getTraceHint(obj, full = false) { return Data_1.ObjectHolder.getHint(obj, full); }
-    static setProfilingMode(enabled, options) { Hooks_1.Hooks.setProfilingMode(enabled, options); }
+    static get isLogging() { return Dbg_1.Log.isOn; }
+    static get loggingOptions() { return Dbg_1.Log.opt; }
+    static setLoggingMode(isOn, options) { Dbg_1.Log.setMode(isOn, options); }
+    static setLoggingHint(obj, name) { Hooks_1.Hooks.setHint(obj, name); }
+    static getLoggingHint(obj, full = false) { return Data_1.ObjectHolder.getHint(obj, full); }
+    static setProfilingMode(isOn, options) { Hooks_1.Hooks.setProfilingMode(isOn, options); }
 }
 exports.Rx = Rx;
 function nonreactive(func, ...args) {

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

@@ -2,7 +2,7 @@ export { all, pause } from './util/Utils';
 export { SealedArray } from './util/SealedArray';
 export { SealedMap } from './util/SealedMap';
 export { SealedSet } from './util/SealedSet';
-export { MemberOptions, SnapshotOptions, Kind, Reentrance, TraceOptions, ProfilingOptions, TraceLevel } from './Options';
+export { MemberOptions, SnapshotOptions, Kind, Reentrance, LoggingOptions, ProfilingOptions, LoggingLevel } from './Options';
 export { Worker } from './Worker';
 export { Controller } from './Controller';
 export { Ref, ToggleRef, BoolOnly, GivenTypeOnly } from './Ref';

package/build/dist/source/api.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.options = exports.cached = exports.reaction = exports.transaction = exports.unobservable = exports.sensitive = exports.nonreactive = exports.Rx = exports.TransactionJournal = exports.Monitor = exports.Transaction = exports.Snapshot = exports.ObservableObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.TraceLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
+exports.options = exports.cached = exports.reaction = exports.transaction = exports.unobservable = exports.sensitive = exports.nonreactive = exports.Rx = exports.TransactionJournal = exports.Monitor = exports.Transaction = exports.Snapshot = exports.ObservableObject = exports.ToggleRef = exports.Ref = exports.Controller = exports.LoggingLevel = exports.Reentrance = exports.Kind = exports.SealedSet = exports.SealedMap = exports.SealedArray = exports.pause = exports.all = void 0;
 var Utils_1 = require("./util/Utils");
 Object.defineProperty(exports, "all", { enumerable: true, get: function () { return Utils_1.all; } });
 Object.defineProperty(exports, "pause", { enumerable: true, get: function () { return Utils_1.pause; } });
@@ -13,7 +13,7 @@ Object.defineProperty(exports, "SealedSet", { enumerable: true, get: function ()
 var Options_1 = require("./Options");
 Object.defineProperty(exports, "Kind", { enumerable: true, get: function () { return Options_1.Kind; } });
 Object.defineProperty(exports, "Reentrance", { enumerable: true, get: function () { return Options_1.Reentrance; } });
-Object.defineProperty(exports, "TraceLevel", { enumerable: true, get: function () { return Options_1.TraceLevel; } });
+Object.defineProperty(exports, "LoggingLevel", { enumerable: true, get: function () { return Options_1.LoggingLevel; } });
 var Controller_1 = require("./Controller");
 Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return Controller_1.Controller; } });
 var Ref_1 = require("./Ref");

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

@@ -18,7 +18,7 @@ class ObjectRevision {
         this.data = data;
         this.changes = new Set();
         this.conflicts = new Map();
-        if (Dbg_1.Dbg.isOn)
+        if (Dbg_1.Log.isOn)
             Object.freeze(this);
     }
 }

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

@@ -1,6 +1,6 @@
 import { F } from '../util/Utils';
 import { MemberOptions, Kind, Reentrance } from '../Options';
-import { TraceOptions, ProfilingOptions } from '../Trace';
+import { LoggingOptions, ProfilingOptions } from '../Logging';
 import { MemberName, ObjectHolder, StandaloneMode } from './Data';
 import { TransactionJournal } from './TransactionJournal';
 import { Monitor } from './Monitor';
@@ -15,12 +15,12 @@ export declare class OptionsImpl implements MemberOptions {
     readonly standalone: StandaloneMode;
     readonly order: number;
     readonly noSideEffects: boolean;
-    readonly sensitiveArgs: boolean;
+    readonly triggeringArgs: boolean;
     readonly throttling: number;
     readonly reentrance: Reentrance;
     readonly journal: TransactionJournal | undefined;
     readonly monitor: Monitor | null;
-    readonly trace?: Partial<TraceOptions>;
+    readonly logging?: Partial<LoggingOptions>;
     static readonly INITIAL: Readonly<OptionsImpl>;
     constructor(getter: Function | undefined, setter: Function | undefined, existing: OptionsImpl, patch: Partial<OptionsImpl>, implicit: boolean);
 }
@@ -41,10 +41,10 @@ export declare class Hooks implements ProxyHandler<ObjectHolder> {
     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 acquireObjectHolder(obj: any): ObjectHolder;
-    static createObjectHolder(proto: any, unobservable: any, blank: any, hint: string): ObjectHolder;
-    static setProfilingMode(enabled: boolean, options?: Partial<ProfilingOptions>): void;
+    static createObjectHolderForObservableObject(proto: any, unobservable: any, blank: any, hint: string): ObjectHolder;
+    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 createControllerAndGetHook: (h: ObjectHolder, m: MemberName, options: OptionsImpl) => F<any>;
+    static createOperation: (h: ObjectHolder, 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

@@ -10,7 +10,7 @@ class ObservableObject {
     constructor() {
         const proto = new.target.prototype;
         const initial = Data_1.Meta.getFrom(proto, Data_1.Meta.Initial);
-        const h = Hooks.createObjectHolder(proto, this, initial, new.target.name);
+        const h = Hooks.createObjectHolderForObservableObject(proto, this, initial, new.target.name);
         return h.proxy;
     }
     [Symbol.toStringTag]() {
@@ -24,12 +24,12 @@ const DEFAULT_OPTIONS = Object.freeze({
     standalone: false,
     order: 0,
     noSideEffects: false,
-    sensitiveArgs: false,
+    triggeringArgs: false,
     throttling: Number.MAX_SAFE_INTEGER,
     reentrance: Options_1.Reentrance.PreventWithError,
     journal: undefined,
     monitor: null,
-    trace: undefined,
+    logging: undefined,
 });
 class OptionsImpl {
     constructor(getter, setter, existing, patch, implicit) {
@@ -39,13 +39,13 @@ class OptionsImpl {
         this.standalone = merge(DEFAULT_OPTIONS.standalone, existing.standalone, patch.standalone, implicit);
         this.order = merge(DEFAULT_OPTIONS.order, existing.order, patch.order, implicit);
         this.noSideEffects = merge(DEFAULT_OPTIONS.noSideEffects, existing.noSideEffects, patch.noSideEffects, implicit);
-        this.sensitiveArgs = merge(DEFAULT_OPTIONS.sensitiveArgs, existing.sensitiveArgs, patch.sensitiveArgs, implicit);
+        this.triggeringArgs = merge(DEFAULT_OPTIONS.triggeringArgs, existing.triggeringArgs, patch.triggeringArgs, implicit);
         this.throttling = merge(DEFAULT_OPTIONS.throttling, existing.throttling, patch.throttling, implicit);
         this.reentrance = merge(DEFAULT_OPTIONS.reentrance, existing.reentrance, patch.reentrance, implicit);
         this.journal = merge(DEFAULT_OPTIONS.journal, existing.journal, patch.journal, implicit);
         this.monitor = merge(DEFAULT_OPTIONS.monitor, existing.monitor, patch.monitor, implicit);
-        this.trace = merge(DEFAULT_OPTIONS.trace, existing.trace, patch.trace, implicit);
-        if (Dbg_1.Dbg.isOn)
+        this.logging = merge(DEFAULT_OPTIONS.logging, existing.logging, patch.logging, implicit);
+        if (Dbg_1.Log.isOn)
             Object.freeze(this);
     }
 }
@@ -144,18 +144,18 @@ class Hooks {
         if (opts.getter === opts.setter) {
             const bootstrap = function () {
                 const h = Hooks.acquireObjectHolder(this);
-                const hook = Hooks.createControllerAndGetHook(h, member, opts);
-                Object.defineProperty(h.unobservable, member, { value: hook, enumerable, configurable });
-                return hook;
+                const operation = Hooks.createOperation(h, member, opts);
+                Object.defineProperty(h.unobservable, member, { value: operation, enumerable, configurable });
+                return operation;
             };
             return Object.defineProperty(proto, member, { get: bootstrap, enumerable, configurable: true });
         }
         else if (opts.setter === Utils_1.UNDEF) {
             const bootstrap = function () {
                 const h = Hooks.acquireObjectHolder(this);
-                const hook = Hooks.createControllerAndGetHook(h, member, opts);
-                Object.defineProperty(h.unobservable, member, { get: hook, enumerable, configurable });
-                return hook.call(this);
+                const operation = Hooks.createOperation(h, member, opts);
+                Object.defineProperty(h.unobservable, member, { get: operation, enumerable, configurable });
+                return operation.call(this);
             };
             return Object.defineProperty(proto, member, { get: bootstrap, enumerable, configurable: true });
         }
@@ -175,14 +175,12 @@ class Hooks {
             const initial = Data_1.Meta.getFrom(Object.getPrototypeOf(obj), Data_1.Meta.Initial);
             const rev = new Data_1.ObjectRevision(Snapshot_1.ROOT_REV.snapshot, Snapshot_1.ROOT_REV, Object.assign({}, initial));
             Data_1.Meta.set(rev.data, Data_1.Meta.Holder, h);
-            if (Dbg_1.Dbg.isOn)
-                Snapshot_1.Snapshot.freezeObjectRevision(rev);
             h = new Data_1.ObjectHolder(obj, obj, Hooks.proxy, rev, obj.constructor.name);
             Data_1.Meta.set(obj, Data_1.Meta.Holder, h);
         }
         return h;
     }
-    static createObjectHolder(proto, unobservable, blank, hint) {
+    static createObjectHolderForObservableObject(proto, unobservable, blank, hint) {
         const ctx = Snapshot_1.Snapshot.edit();
         const h = new Data_1.ObjectHolder(unobservable, undefined, Hooks.proxy, Snapshot_1.ROOT_REV, hint);
         ctx.getEditableRevision(h, Data_1.Meta.Holder, blank);
@@ -191,11 +189,11 @@ class Hooks {
                 h.proxy[m][Data_1.Meta.Controller].markObsolete();
         return h;
     }
-    static setProfilingMode(enabled, options) {
-        if (enabled) {
+    static setProfilingMode(isOn, options) {
+        if (isOn) {
             Hooks.repetitiveUsageWarningThreshold = options && options.repetitiveUsageWarningThreshold !== undefined ? options.repetitiveUsageWarningThreshold : 10;
-            Hooks.mainThreadBlockingWarningThreshold = options && options.mainThreadBlockingWarningThreshold !== undefined ? options.mainThreadBlockingWarningThreshold : 16.6;
-            Hooks.asyncActionDurationWarningThreshold = options && options.asyncActionDurationWarningThreshold !== undefined ? options.asyncActionDurationWarningThreshold : 150;
+            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;
         }
         else {
@@ -230,8 +228,8 @@ Hooks.mainThreadBlockingWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.asyncActionDurationWarningThreshold = Number.MAX_SAFE_INTEGER;
 Hooks.sensitivity = false;
 Hooks.proxy = new Hooks();
-Hooks.createControllerAndGetHook = function (h, m, options) {
-    throw (0, Dbg_1.misuse)('createControllerAndGetHook should never be called');
+Hooks.createOperation = function (h, m, options) {
+    throw (0, Dbg_1.misuse)('createOperation should never be called');
 };
 Hooks.rememberOperationOptions = function (proto, m, getter, setter, enumerable, configurable, options, implicit) {
     throw (0, Dbg_1.misuse)('rememberOperationOptions should never be called');

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

@@ -28,7 +28,7 @@ export declare class OperationController extends Controller<any> {
     private peek;
     private use;
     private edit;
-    private peekFromRevision;
+    private acquireFromRevision;
     private run;
     private static markObsolete;
 }
@@ -84,7 +84,7 @@ declare class Operation extends Observable implements Observer {
     private unsubscribeFromAllObservables;
     private subscribeTo;
     private static canSubscribe;
-    private static createControllerAndGetHook;
+    private static createOperation;
     private static rememberOperationOptions;
     static init(): void;
 }