reactronic 0.22.306 → 0.22.309

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

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSnapshotOptions = exports.EMPTY_SNAPSHOT = exports.Dump = exports.Changeset = exports.UNDEFINED_REVISION = exports.MAX_REVISION = void 0;
+const Utils_1 = require("../util/Utils");
+const Dbg_1 = require("../util/Dbg");
+const Sealant_1 = require("../util/Sealant");
+const SealedArray_1 = require("../util/SealedArray");
+const SealedMap_1 = require("../util/SealedMap");
+const SealedSet_1 = require("../util/SealedSet");
+const Data_1 = require("./Data");
+exports.MAX_REVISION = Number.MAX_SAFE_INTEGER;
+exports.UNDEFINED_REVISION = exports.MAX_REVISION - 1;
+Object.defineProperty(Data_1.ObjectHandle.prototype, '#this', {
+    configurable: false, enumerable: false,
+    get() {
+        const result = {};
+        const data = Changeset.current().getRelevantSnapshot(this, '#this').data;
+        for (const m in data) {
+            const v = data[m];
+            if (v instanceof Data_1.Subscription)
+                result[m] = v.content;
+            else if (v === Data_1.Meta.Nonreactive)
+                result[m] = this.data[m];
+            else
+                result[m] = v;
+        }
+        return result;
+    },
+});
+const EMPTY_ARRAY = Object.freeze([]);
+const EMPTY_MAP = Utils_1.Utils.freezeMap(new Map());
+class Changeset {
+    constructor(options) {
+        this.id = ++Changeset.idGen;
+        this.options = options !== null && options !== void 0 ? options : exports.DefaultSnapshotOptions;
+        this.revision = exports.UNDEFINED_REVISION;
+        this.bumper = 100;
+        this.items = new Map();
+        this.reactions = [];
+        this.sealed = false;
+    }
+    get hint() { var _a; return (_a = this.options.hint) !== null && _a !== void 0 ? _a : 'noname'; }
+    get timestamp() { return this.revision; }
+    seekSnapshot(h, m) {
+        let os = h.editing;
+        if (os && os.changeset !== this) {
+            os = this.items.get(h);
+            if (os)
+                h.editing = os;
+        }
+        if (!os) {
+            os = h.head;
+            while (os !== exports.EMPTY_SNAPSHOT && os.changeset.timestamp > this.timestamp)
+                os = os.former.snapshot;
+        }
+        return os;
+    }
+    getRelevantSnapshot(h, m) {
+        const r = this.seekSnapshot(h, m);
+        if (r === exports.EMPTY_SNAPSHOT)
+            throw (0, Dbg_1.misuse)(`object ${Dump.obj(h)} doesn't exist in snapshot v${this.revision} (${this.hint})`);
+        return r;
+    }
+    getEditableSnapshot(h, m, value, token) {
+        let os = this.seekSnapshot(h, m);
+        const existing = os.data[m];
+        if (existing !== Data_1.Meta.Nonreactive) {
+            if (this.isNewSnapshotRequired(h, os, m, existing, value, token)) {
+                this.bumpBy(os.changeset.timestamp);
+                const revision = m === Data_1.Meta.Handle ? 1 : os.revision + 1;
+                const data = Object.assign({}, m === Data_1.Meta.Handle ? value : os.data);
+                Data_1.Meta.set(data, Data_1.Meta.Handle, h);
+                Data_1.Meta.set(data, Data_1.Meta.Revision, new Data_1.Subscription(revision));
+                os = new Data_1.ObjectSnapshot(this, os, data);
+                this.items.set(h, os);
+                h.editing = os;
+                h.editors++;
+                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
+                    Dbg_1.Log.write('║', ' ⎘⎘', `${Dump.obj(h)} - new snapshot is created (revision ${revision})`);
+            }
+        }
+        else
+            os = exports.EMPTY_SNAPSHOT;
+        return os;
+    }
+    static takeSnapshot(obj) {
+        return obj[Data_1.Meta.Handle]['#this'];
+    }
+    static dispose(obj) {
+        const ctx = Changeset.edit();
+        const h = Data_1.Meta.get(obj, Data_1.Meta.Handle);
+        if (h !== undefined)
+            Changeset.doDispose(ctx, h);
+    }
+    static doDispose(ctx, h) {
+        const os = ctx.getEditableSnapshot(h, Data_1.Meta.Revision, Data_1.Meta.Undefined);
+        if (os !== exports.EMPTY_SNAPSHOT)
+            os.disposed = true;
+        return os;
+    }
+    isNewSnapshotRequired(h, os, m, existing, value, token) {
+        if (this.sealed && os.changeset !== exports.EMPTY_SNAPSHOT.changeset)
+            throw (0, Dbg_1.misuse)(`reactive property ${Dump.obj(h, m)} can only be modified inside transaction`);
+        if (m !== Data_1.Meta.Handle && value !== Data_1.Meta.Handle) {
+            if (os.changeset !== this || os.former.snapshot !== exports.EMPTY_SNAPSHOT) {
+                if (this.options.token !== undefined && token !== this.options.token)
+                    throw (0, Dbg_1.misuse)(`${this.hint} should not have side effects (trying to change ${Dump.snapshot(os, m)})`);
+            }
+            if (os === exports.EMPTY_SNAPSHOT)
+                throw (0, Dbg_1.misuse)(`member ${Dump.snapshot(os, m)} doesn't exist in snapshot v${this.revision} (${this.hint})`);
+        }
+        return os.changeset !== this && !this.sealed;
+    }
+    acquire(outer) {
+        if (!this.sealed && this.revision === exports.UNDEFINED_REVISION) {
+            const ahead = this.options.token === undefined || outer.revision === exports.UNDEFINED_REVISION;
+            this.revision = ahead ? Changeset.stampGen : outer.revision;
+            Changeset.pending.push(this);
+            if (Changeset.oldest === undefined)
+                Changeset.oldest = this;
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write('╔══', `v${this.revision}`, `${this.hint}`);
+        }
+    }
+    bumpBy(timestamp) {
+        if (timestamp > this.bumper)
+            this.bumper = timestamp;
+    }
+    rebase() {
+        let conflicts = undefined;
+        if (this.items.size > 0) {
+            this.items.forEach((os, h) => {
+                if (os.former.snapshot !== h.head) {
+                    const merged = this.merge(h, os);
+                    if (os.conflicts.size > 0) {
+                        if (!conflicts)
+                            conflicts = [];
+                        conflicts.push(os);
+                    }
+                    if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                        Dbg_1.Log.write('╠╝', '', `${Dump.snapshot2(h, os.changeset)} is merged with ${Dump.snapshot2(h, h.head.changeset)} among ${merged} properties with ${os.conflicts.size} conflicts.`);
+                }
+            });
+            if (this.options.token === undefined) {
+                if (this.bumper > 100) {
+                    this.bumper = this.revision;
+                    this.revision = ++Changeset.stampGen;
+                }
+                else
+                    this.revision = this.bumper + 1;
+            }
+            else {
+                this.revision = this.bumper;
+            }
+        }
+        return conflicts;
+    }
+    merge(h, ours) {
+        let counter = 0;
+        const head = h.head;
+        const headDisposed = head.disposed;
+        const oursDisposed = ours.disposed;
+        const merged = Object.assign({}, head.data);
+        ours.changes.forEach((o, m) => {
+            counter++;
+            merged[m] = ours.data[m];
+            if (headDisposed || oursDisposed) {
+                if (headDisposed !== oursDisposed) {
+                    if (headDisposed || this.options.standalone !== 'disposal') {
+                        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
+                            Dbg_1.Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} <> ${Dump.snapshot2(h, head.changeset, m)}`, 0, ' *** CONFLICT ***');
+                        ours.conflicts.set(m, head);
+                    }
+                }
+            }
+            else {
+                const conflict = Changeset.isConflicting(head.data[m], ours.former.snapshot.data[m]);
+                if (conflict)
+                    ours.conflicts.set(m, head);
+                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
+                    Dbg_1.Log.write('║╠', '', `${Dump.snapshot2(h, ours.changeset, m)} ${conflict ? '<>' : '=='} ${Dump.snapshot2(h, head.changeset, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
+            }
+        });
+        Utils_1.Utils.copyAllMembers(merged, ours.data);
+        ours.former.snapshot = head;
+        return counter;
+    }
+    applyOrDiscard(error) {
+        this.sealed = true;
+        this.items.forEach((os, h) => {
+            Changeset.sealObjectSnapshot(h, os);
+            h.editors--;
+            if (h.editors === 0)
+                h.editing = undefined;
+            if (!error) {
+                h.head = os;
+                if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                    Changeset.totalObjectSnapshotCount++;
+                    if (os.former.snapshot === exports.EMPTY_SNAPSHOT)
+                        Changeset.totalObjectHandleCount++;
+                }
+            }
+        });
+        if (Dbg_1.Log.isOn) {
+            if (Dbg_1.Log.opt.change && !error) {
+                this.items.forEach((os, h) => {
+                    const members = [];
+                    os.changes.forEach((o, m) => members.push(m.toString()));
+                    const s = members.join(', ');
+                    Dbg_1.Log.write('║', '√', `${Dump.snapshot2(h, os.changeset)} (${s}) is ${os.former.snapshot === exports.EMPTY_SNAPSHOT ? 'constructed' : `applied on top of ${Dump.snapshot2(h, os.former.snapshot.changeset)}`}`);
+                });
+            }
+            if (Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write(this.revision < exports.UNDEFINED_REVISION ? '╚══' : '═══', `v${this.revision}`, `${this.hint} - ${error ? 'CANCEL' : 'APPLY'}(${this.items.size})${error ? ` - ${error}` : ''}`);
+        }
+        if (!error)
+            Changeset.propagateAllChangesThroughSubscriptions(this);
+        return this.reactions;
+    }
+    static sealObjectSnapshot(h, os) {
+        if (!os.disposed)
+            os.changes.forEach((o, m) => Changeset.sealSubscription(os.data[m], m, h.proxy.constructor.name));
+        else
+            for (const m in os.former.snapshot.data)
+                os.data[m] = Data_1.Meta.Undefined;
+        if (Dbg_1.Log.isOn)
+            Changeset.freezeObjectSnapshot(os);
+    }
+    static sealSubscription(subscription, m, typeName) {
+        if (subscription instanceof Data_1.Subscription) {
+            const value = subscription.content;
+            if (value !== undefined && value !== null) {
+                const sealedType = Object.getPrototypeOf(value)[Sealant_1.Sealant.SealedType];
+                if (sealedType)
+                    subscription.content = Sealant_1.Sealant.seal(value, sealedType, typeName, m);
+            }
+        }
+    }
+    static freezeObjectSnapshot(os) {
+        Object.freeze(os.data);
+        Utils_1.Utils.freezeSet(os.changes);
+        Utils_1.Utils.freezeMap(os.conflicts);
+        return os;
+    }
+    triggerGarbageCollection() {
+        if (this.revision !== 0) {
+            if (this === Changeset.oldest) {
+                const p = Changeset.pending;
+                p.sort((a, b) => a.revision - b.revision);
+                let i = 0;
+                while (i < p.length && p[i].sealed) {
+                    p[i].unlinkHistory();
+                    i++;
+                }
+                Changeset.pending = p.slice(i);
+                Changeset.oldest = Changeset.pending[0];
+                const now = Date.now();
+                if (now - Changeset.lastGarbageCollectionSummaryTimestamp > Changeset.garbageCollectionSummaryInterval) {
+                    Dbg_1.Log.write('', '[G]', `Total object/snapshot count: ${Changeset.totalObjectHandleCount}/${Changeset.totalObjectSnapshotCount}`);
+                    Changeset.lastGarbageCollectionSummaryTimestamp = now;
+                }
+            }
+        }
+    }
+    unlinkHistory() {
+        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc)
+            Dbg_1.Log.write('', '[G]', `Dismiss history below v${this.revision}t${this.id} (${this.hint})`);
+        this.items.forEach((os, h) => {
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc && os.former.snapshot !== exports.EMPTY_SNAPSHOT)
+                Dbg_1.Log.write(' ', '  ', `${Dump.snapshot2(h, os.former.snapshot.changeset)} is ready for GC because overwritten by ${Dump.snapshot2(h, os.changeset)}`);
+            if (Changeset.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
+                if (os.former.snapshot !== exports.EMPTY_SNAPSHOT)
+                    Changeset.totalObjectSnapshotCount--;
+                if (os.disposed)
+                    Changeset.totalObjectHandleCount--;
+            }
+            os.former.snapshot = exports.EMPTY_SNAPSHOT;
+        });
+        this.items = EMPTY_MAP;
+        this.reactions = EMPTY_ARRAY;
+        if (Dbg_1.Log.isOn)
+            Object.freeze(this);
+    }
+    static _init() {
+        const boot = exports.EMPTY_SNAPSHOT.changeset;
+        boot.acquire(boot);
+        boot.applyOrDiscard();
+        boot.triggerGarbageCollection();
+        Changeset.freezeObjectSnapshot(exports.EMPTY_SNAPSHOT);
+        Changeset.idGen = 100;
+        Changeset.stampGen = 101;
+        Changeset.oldest = undefined;
+        SealedArray_1.SealedArray.prototype;
+        SealedMap_1.SealedMap.prototype;
+        SealedSet_1.SealedSet.prototype;
+    }
+}
+exports.Changeset = Changeset;
+Changeset.idGen = -1;
+Changeset.stampGen = 1;
+Changeset.pending = [];
+Changeset.oldest = undefined;
+Changeset.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
+Changeset.lastGarbageCollectionSummaryTimestamp = Date.now();
+Changeset.totalObjectHandleCount = 0;
+Changeset.totalObjectSnapshotCount = 0;
+Changeset.current = Utils_1.UNDEF;
+Changeset.edit = Utils_1.UNDEF;
+Changeset.markUsed = Utils_1.UNDEF;
+Changeset.markEdited = Utils_1.UNDEF;
+Changeset.isConflicting = Utils_1.UNDEF;
+Changeset.propagateAllChangesThroughSubscriptions = (changeset) => { };
+Changeset.revokeAllSubscriptions = (changeset) => { };
+Changeset.enqueueReactionsToRun = (reactions) => { };
+class Dump {
+    static obj(h, m, stamp, snapshotId, originSnapshotId, value) {
+        const member = m !== undefined ? `.${m.toString()}` : '';
+        let result;
+        if (h !== undefined) {
+            const v = value !== undefined && value !== Data_1.Meta.Undefined ? `[=${Dump.valueHint(value)}]` : '';
+            if (stamp === undefined)
+                result = `${h.hint}${member}${v} #${h.id}`;
+            else
+                result = `${h.hint}${member}${v} #${h.id}t${snapshotId}v${stamp}${originSnapshotId !== undefined && originSnapshotId !== 0 ? `t${originSnapshotId}` : ''}`;
+        }
+        else
+            result = `boot${member}`;
+        return result;
+    }
+    static snapshot2(h, s, m, o) {
+        var _a;
+        return Dump.obj(h, m, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.originSnapshotId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Data_1.Meta.Undefined);
+    }
+    static snapshot(os, m) {
+        const h = Data_1.Meta.get(os.data, Data_1.Meta.Handle);
+        const value = m !== undefined ? os.data[m] : undefined;
+        return Dump.obj(h, m, os.changeset.timestamp, os.changeset.id, value === null || value === void 0 ? void 0 : value.originSnapshotId);
+    }
+    static conflicts(conflicts) {
+        return conflicts.map(ours => {
+            const items = [];
+            ours.conflicts.forEach((theirs, m) => {
+                items.push(Dump.conflictingMemberHint(m, ours, theirs));
+            });
+            return items.join(', ');
+        }).join(', ');
+    }
+    static conflictingMemberHint(m, ours, theirs) {
+        return `${theirs.changeset.hint} (${Dump.snapshot(theirs, m)})`;
+    }
+}
+exports.Dump = Dump;
+Dump.valueHint = (value, m) => '???';
+exports.EMPTY_SNAPSHOT = new Data_1.ObjectSnapshot(new Changeset({ hint: '<empty>' }), undefined, {});
+exports.DefaultSnapshotOptions = Object.freeze({
+    hint: 'noname',
+    standalone: false,
+    journal: undefined,
+    logging: undefined,
+    token: undefined,
+});

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

@@ -0,0 +1,60 @@
+export { Meta } from './Meta';
+export interface AbstractChangeset {
+    readonly id: number;
+    readonly hint: string;
+    readonly timestamp: number;
+    readonly sealed: boolean;
+}
+export declare class Subscription {
+    content: any;
+    subscribers?: Set<Subscriber>;
+    get isOperation(): boolean;
+    get originSnapshotId(): number | undefined;
+    constructor(content: any);
+}
+export declare type StandaloneMode = boolean | 'isolated' | 'disposal';
+export interface Subscriber {
+    readonly order: number;
+    readonly subscriptions: Map<Subscription, SubscriptionInfo> | undefined;
+    readonly obsoleteSince: number;
+    hint(nop?: boolean): string;
+    markObsoleteDueTo(subscription: Subscription, m: MemberName, changeset: AbstractChangeset, h: ObjectHandle, outer: string, since: number, reactions: Array<Subscriber>): void;
+    runIfNotUpToDate(now: boolean, nothrow: boolean): void;
+}
+export declare type MemberName = PropertyKey;
+export interface SubscriptionInfo {
+    readonly memberHint: string;
+    readonly usageCount: number;
+}
+export declare class ObjectSnapshot {
+    readonly changeset: AbstractChangeset;
+    readonly former: {
+        snapshot: ObjectSnapshot;
+    };
+    readonly data: any;
+    readonly changes: Set<MemberName>;
+    readonly conflicts: Map<MemberName, ObjectSnapshot>;
+    constructor(changeset: AbstractChangeset, former: ObjectSnapshot | undefined, data: object);
+    get revision(): number;
+    get disposed(): boolean;
+    set disposed(value: boolean);
+}
+export declare class ObjectHandle {
+    private static generator;
+    readonly id: number;
+    readonly data: any;
+    readonly proxy: any;
+    head: ObjectSnapshot;
+    editing?: ObjectSnapshot;
+    editors: number;
+    hint: string;
+    constructor(data: any, proxy: any, handler: ProxyHandler<ObjectHandle>, head: ObjectSnapshot, hint: string);
+    static getHint(obj: object, full: boolean): string | undefined;
+}
+export declare type PatchSet = Map<object, Map<MemberName, ValuePatch>>;
+export interface ValuePatch {
+    memberName: MemberName;
+    patchKind: 'update' | 'add' | 'remove';
+    freshValue: any;
+    formerValue: any;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectHandle = exports.ObjectSnapshot = exports.Subscription = exports.Meta = void 0;
+const Dbg_1 = require("../util/Dbg");
+const Meta_1 = require("./Meta");
+var Meta_2 = require("./Meta");
+Object.defineProperty(exports, "Meta", { enumerable: true, get: function () { return Meta_2.Meta; } });
+class Subscription {
+    constructor(content) { this.content = content; }
+    get isOperation() { return false; }
+    get originSnapshotId() { return 0; }
+}
+exports.Subscription = Subscription;
+class ObjectSnapshot {
+    constructor(changeset, former, data) {
+        this.changeset = changeset;
+        this.former = { snapshot: former || this };
+        this.data = data;
+        this.changes = new Set();
+        this.conflicts = new Map();
+        if (Dbg_1.Log.isOn)
+            Object.freeze(this);
+    }
+    get revision() {
+        return this.data[Meta_1.Meta.Revision].content;
+    }
+    get disposed() { return this.revision < 0; }
+    set disposed(value) {
+        const rev = this.revision;
+        if (rev < 0 !== value)
+            this.data[Meta_1.Meta.Revision].content = ~rev;
+    }
+}
+exports.ObjectSnapshot = ObjectSnapshot;
+class ObjectHandle {
+    constructor(data, proxy, handler, head, hint) {
+        this.id = ++ObjectHandle.generator;
+        this.data = data;
+        this.proxy = proxy || new Proxy(this, handler);
+        this.head = head;
+        this.editing = undefined;
+        this.editors = 0;
+        this.hint = hint;
+    }
+    static getHint(obj, full) {
+        const h = Meta_1.Meta.get(obj, Meta_1.Meta.Handle);
+        return h !== undefined ? (full ? `${h.hint}#${h.id}` : h.hint) : undefined;
+    }
+}
+exports.ObjectHandle = ObjectHandle;
+ObjectHandle.generator = 19;

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

@@ -0,0 +1,96 @@
+import { F } from '../util/Utils';
+import { MemberOptions, Kind, Reentrance } from '../Options';
+import { LoggingOptions, ProfilingOptions } from '../Logging';
+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;
+    entries(): IterableIterator<[number, T]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<T>;
+    private get mutable();
+}
+export declare class ReactiveMap<K, V> extends ReactiveObject {
+    private m;
+    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>;
+    private get mutable();
+}
+export declare class OptionsImpl implements MemberOptions {
+    readonly getter: Function;
+    readonly setter: Function;
+    readonly kind: Kind;
+    readonly standalone: StandaloneMode;
+    readonly order: number;
+    readonly noSideEffects: boolean;
+    readonly triggeringArgs: boolean;
+    readonly throttling: number;
+    readonly reentrance: Reentrance;
+    readonly journal: Journal | undefined;
+    readonly monitor: Monitor | null;
+    readonly logging?: Partial<LoggingOptions>;
+    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<ObjectHandle> {
+    static reactionsAutoStartDisabled: boolean;
+    static repetitiveUsageWarningThreshold: number;
+    static mainThreadBlockingWarningThreshold: number;
+    static asyncActionDurationWarningThreshold: number;
+    static sensitivity: boolean;
+    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 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: 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;
+}