reactronic 0.22.302 → 0.22.306

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

@@ -1,721 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rejectRethrow = exports.resolveReturn = exports.OperationController = void 0;
-const Dbg_1 = require("../util/Dbg");
-const Options_1 = require("../Options");
-const Controller_1 = require("../Controller");
-const Data_1 = require("./Data");
-const Snapshot_1 = require("./Snapshot");
-const Transaction_1 = require("./Transaction");
-const Monitor_1 = require("./Monitor");
-const Hooks_1 = require("./Hooks");
-const Journal_1 = require("./Journal");
-const BOOT_ARGS = [];
-const BOOT_CAUSE = '<boot>';
-const ROOT_HOLDER = new Data_1.DataHolder(undefined, undefined, Hooks_1.Hooks.proxy, Snapshot_1.ROOT_REV, '<root>');
-class OperationController extends Controller_1.Controller {
-    constructor(ownHolder, memberName) {
-        super();
-        this.ownHolder = ownHolder;
-        this.memberName = memberName;
-    }
-    configure(options) { return OperationController.configureImpl(this, options); }
-    get options() { return this.peek(undefined).operation.options; }
-    get nonreactive() { return this.peek(undefined).operation.content; }
-    get args() { return this.use().operation.args; }
-    get result() { return this.useOrRun(true, undefined).content; }
-    get error() { return this.use().operation.error; }
-    get stamp() { return this.use().revision.snapshot.timestamp; }
-    get isUpToDate() { return this.use().isUpToDate; }
-    markObsolete() { Transaction_1.Transaction.run({ hint: Dbg_1.Log.isOn ? `markObsolete(${Snapshot_1.Dump.obj(this.ownHolder, this.memberName)})` : 'markObsolete()' }, OperationController.markObsolete, this); }
-    pullLastResult(args) { return this.useOrRun(true, args).content; }
-    useOrRun(weak, args) {
-        var _a;
-        let oc = this.peek(args);
-        const ctx = oc.snapshot;
-        const op = oc.operation;
-        const opts = op.options;
-        if (!oc.isUpToDate && oc.revision.data[Data_1.Meta.Disposed] === undefined
-            && (!weak || op.cause === BOOT_CAUSE || !op.successor ||
-                op.successor.transaction.isFinished)) {
-            const outerOpts = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.options;
-            const standalone = weak || opts.standalone || opts.kind === Options_1.Kind.Reaction ||
-                (opts.kind === Options_1.Kind.Transaction && outerOpts && (outerOpts.noSideEffects || outerOpts.kind === Options_1.Kind.Cache)) ||
-                (opts.kind === Options_1.Kind.Cache && (oc.revision.snapshot.sealed ||
-                    oc.revision.former.revision !== Snapshot_1.ROOT_REV));
-            const token = opts.noSideEffects ? this : undefined;
-            const oc2 = this.run(oc, standalone, opts, token, args);
-            const ctx2 = oc2.operation.snapshot;
-            if (!weak || ctx === ctx2 || (ctx2.sealed && ctx.timestamp >= ctx2.timestamp))
-                oc = oc2;
-        }
-        else if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation && (opts.logging === undefined ||
-            opts.logging.operation === undefined || opts.logging.operation === true))
-            Dbg_1.Log.write(Transaction_1.Transaction.current.isFinished ? '' : '║', ' (=)', `${Snapshot_1.Dump.rev2(oc.operation.controller.ownHolder, oc.snapshot, this.memberName)} result is reused from T${oc.operation.transaction.id}[${oc.operation.transaction.hint}]`);
-        const t = oc.operation;
-        Snapshot_1.Snapshot.markUsed(t, oc.revision, this.memberName, this.ownHolder, t.options.kind, weak);
-        return t;
-    }
-    static of(method) {
-        const ctl = Data_1.Meta.get(method, Data_1.Meta.Controller);
-        if (!ctl)
-            throw (0, Dbg_1.misuse)(`given method is not decorated as reactronic one: ${method.name}`);
-        return ctl;
-    }
-    static configureImpl(self, options) {
-        let op;
-        if (self)
-            op = self.edit().operation;
-        else
-            op = Operation.current;
-        if (!op)
-            throw (0, Dbg_1.misuse)('reactronic decorator is only applicable to methods');
-        op.options = new Hooks_1.OptionsImpl(op.options.getter, op.options.setter, op.options, options, false);
-        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
-            Dbg_1.Log.write('║', '  ✎', `${op.hint()}.options are changed`);
-        return op.options;
-    }
-    static runWithin(op, func, ...args) {
-        let result = undefined;
-        const outer = Operation.current;
-        try {
-            Operation.current = op;
-            result = func(...args);
-        }
-        catch (e) {
-            if (op)
-                op.error = e;
-            throw e;
-        }
-        finally {
-            Operation.current = outer;
-        }
-        return result;
-    }
-    static why() {
-        var _a, _b;
-        return (_b = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.why()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
-    }
-    static briefWhy() {
-        var _a, _b;
-        return (_b = (_a = Operation.current) === null || _a === void 0 ? void 0 : _a.briefWhy()) !== null && _b !== void 0 ? _b : BOOT_CAUSE;
-    }
-    static dependencies() {
-        const op = Operation.current;
-        return op ? op.dependencies() : ['Rx.dependencies should be called from inside of reactive method'];
-    }
-    peek(args) {
-        const ctx = Snapshot_1.Snapshot.current();
-        const r = ctx.seekRevision(this.ownHolder, this.memberName);
-        const op = this.acquireFromRevision(r, args);
-        const isValid = op.options.kind !== Options_1.Kind.Transaction && op.cause !== BOOT_CAUSE &&
-            (ctx === op.snapshot || ctx.timestamp < op.obsoleteSince) &&
-            (!op.options.triggeringArgs || args === undefined ||
-                op.args.length === args.length && op.args.every((t, i) => t === args[i])) ||
-            r.data[Data_1.Meta.Disposed] !== undefined;
-        return { operation: op, isUpToDate: isValid, snapshot: ctx, revision: r };
-    }
-    use() {
-        const oc = this.peek(undefined);
-        Snapshot_1.Snapshot.markUsed(oc.operation, oc.revision, this.memberName, this.ownHolder, oc.operation.options.kind, true);
-        return oc;
-    }
-    edit() {
-        const h = this.ownHolder;
-        const m = this.memberName;
-        const ctx = Snapshot_1.Snapshot.edit();
-        const r = ctx.getEditableRevision(h, m, Data_1.Meta.Holder, this);
-        let op = this.acquireFromRevision(r, undefined);
-        if (op.snapshot !== r.snapshot) {
-            const op2 = new Operation(this, r.snapshot, op);
-            r.data[m] = op2.reenterOver(op);
-            ctx.bumpBy(r.former.revision.snapshot.timestamp);
-            Snapshot_1.Snapshot.markEdited(op, op2, true, r, m, h);
-            op = op2;
-        }
-        return { operation: op, isUpToDate: true, snapshot: ctx, revision: r };
-    }
-    acquireFromRevision(r, args) {
-        const m = this.memberName;
-        let op = r.data[m];
-        if (op.controller !== this) {
-            if (r.snapshot !== Snapshot_1.ROOT_REV.snapshot) {
-                const hint = Dbg_1.Log.isOn ? `${Snapshot_1.Dump.obj(this.ownHolder, m)}/boot` : 'MethodController/init';
-                const standalone = r.snapshot.sealed || r.former.revision !== Snapshot_1.ROOT_REV;
-                op = Transaction_1.Transaction.run({ hint, standalone, token: this }, () => {
-                    const h = this.ownHolder;
-                    let r2 = Snapshot_1.Snapshot.current().getCurrentRevision(h, m);
-                    let op2 = r2.data[m];
-                    if (op2.controller !== this) {
-                        r2 = Snapshot_1.Snapshot.edit().getEditableRevision(h, m, Data_1.Meta.Holder, this);
-                        const t = new Operation(this, r2.snapshot, op2);
-                        if (args)
-                            t.args = args;
-                        t.cause = BOOT_CAUSE;
-                        r2.data[m] = t;
-                        Snapshot_1.Snapshot.markEdited(op2, t, true, r2, m, h);
-                        op2 = t;
-                    }
-                    return op2;
-                });
-            }
-            else {
-                const t = new Operation(this, r.snapshot, op);
-                if (args)
-                    t.args = args;
-                t.cause = BOOT_CAUSE;
-                r.data[m] = t;
-                op = t;
-                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
-                    Dbg_1.Log.write('║', '  ⎘', `${Snapshot_1.Dump.obj(this.ownHolder, m)} is cloned outside of transaction`);
-            }
-        }
-        return op;
-    }
-    run(existing, standalone, options, token, args) {
-        const hint = Dbg_1.Log.isOn ? `${Snapshot_1.Dump.obj(this.ownHolder, this.memberName)}${args && args.length > 0 && (typeof args[0] === 'number' || typeof args[0] === 'string') ? ` - ${args[0]}` : ''}` : `${Snapshot_1.Dump.obj(this.ownHolder, this.memberName)}`;
-        let oc = existing;
-        const opts = { hint, standalone, journal: options.journal, logging: options.logging, token };
-        const result = Transaction_1.Transaction.run(opts, (argsx) => {
-            if (!oc.operation.transaction.isCanceled) {
-                oc = this.edit();
-                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation)
-                    Dbg_1.Log.write('║', '  𝑓', `${oc.operation.why()}`);
-                oc.operation.run(this.ownHolder.proxy, argsx);
-            }
-            else {
-                oc = this.peek(argsx);
-                if (oc.operation.options.kind === Options_1.Kind.Transaction || !oc.isUpToDate) {
-                    oc = this.edit();
-                    if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation)
-                        Dbg_1.Log.write('║', '  𝑓', `${oc.operation.why()}`);
-                    oc.operation.run(this.ownHolder.proxy, argsx);
-                }
-            }
-            return oc.operation.result;
-        }, args);
-        oc.operation.result = result;
-        return oc;
-    }
-    static markObsolete(self) {
-        const oc = self.peek(undefined);
-        const ctx = oc.snapshot;
-        oc.operation.markObsoleteDueTo(oc.operation, self.memberName, Snapshot_1.ROOT_REV.snapshot, ROOT_HOLDER, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
-    }
-}
-exports.OperationController = OperationController;
-class Operation extends Data_1.Subscription {
-    constructor(controller, snapshot, former) {
-        super(undefined);
-        this.margin = Operation.current ? Operation.current.margin + 1 : 1;
-        this.transaction = Transaction_1.Transaction.current;
-        this.controller = controller;
-        this.snapshot = snapshot;
-        this.subscriptions = new Map();
-        if (former instanceof Operation) {
-            this.options = former.options;
-            this.args = former.args;
-            this.cause = former.obsoleteDueTo;
-        }
-        else {
-            this.options = former;
-            this.args = BOOT_ARGS;
-            this.cause = undefined;
-        }
-        this.started = 0;
-        this.obsoleteSince = 0;
-        this.obsoleteDueTo = undefined;
-        this.successor = undefined;
-    }
-    get isOperation() { return true; }
-    get originSnapshotId() { return this.snapshot.id; }
-    hint() { return `${Snapshot_1.Dump.rev2(this.controller.ownHolder, this.snapshot, this.controller.memberName)}`; }
-    get order() { return this.options.order; }
-    get ['#this']() {
-        return `Operation: ${this.why()}`;
-    }
-    why() {
-        let cause;
-        if (this.cause)
-            cause = `   <<   ${this.cause}`;
-        else if (this.controller.options.kind === Options_1.Kind.Transaction)
-            cause = '   <<   operation';
-        else
-            cause = `   <<   T${this.snapshot.id}[${this.snapshot.hint}]`;
-        return `${this.hint()}${cause}`;
-    }
-    briefWhy() {
-        return this.why();
-    }
-    dependencies() {
-        throw (0, Dbg_1.misuse)('not implemented yet');
-    }
-    wrap(func) {
-        const wrappedForOperation = (...args) => {
-            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.step && this.result)
-                Dbg_1.Log.writeAs({ margin2: this.margin }, '║', '‾\\', `${this.hint()} - step in  `, 0, '        │');
-            const started = Date.now();
-            const result = OperationController.runWithin(this, func, ...args);
-            const ms = Date.now() - started;
-            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.step && this.result)
-                Dbg_1.Log.writeAs({ margin2: this.margin }, '║', '_/', `${this.hint()} - step out `, 0, this.started > 0 ? '        │' : '');
-            if (ms > Hooks_1.Hooks.mainThreadBlockingWarningThreshold)
-                Dbg_1.Log.write('', '[!]', this.why(), ms, '    *** main thread is too busy ***');
-            return result;
-        };
-        return wrappedForOperation;
-    }
-    run(proxy, args) {
-        if (args)
-            this.args = args;
-        this.obsoleteSince = Snapshot_1.MAX_TIMESTAMP;
-        if (!this.error)
-            OperationController.runWithin(this, Operation.run, this, proxy);
-        else
-            this.result = Promise.reject(this.error);
-    }
-    markObsoleteDueTo(subscription, memberName, snapshot, holder, outer, since, reactions) {
-        var _a, _b, _c;
-        if (this.subscriptions !== undefined) {
-            const skip = !subscription.isOperation &&
-                snapshot === this.snapshot;
-            if (!skip) {
-                const why = `${Snapshot_1.Dump.rev2(holder, snapshot, memberName, subscription)}    <<    ${outer}`;
-                this.unsubscribeFromAllSubscriptions();
-                this.obsoleteDueTo = why;
-                this.obsoleteSince = since;
-                const isReaction = this.options.kind === Options_1.Kind.Reaction;
-                if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.obsolete || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.obsolete)))
-                    Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', isReaction ? '█' : '▒', isReaction && snapshot === Snapshot_1.ROOT_REV.snapshot
-                        ? `${this.hint()} is a reaction and will run automatically (order ${this.options.order})`
-                        : `${this.hint()} is obsolete due to ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)} since v${since}${isReaction ? ` and will run automatically (order ${this.options.order})` : ''}`);
-                if (isReaction)
-                    reactions.push(this);
-                else
-                    (_b = this.subscribers) === null || _b === void 0 ? void 0 : _b.forEach(s => s.markObsoleteDueTo(this, this.controller.memberName, this.snapshot, this.controller.ownHolder, why, since, reactions));
-                const tran = this.transaction;
-                if (tran.snapshot === snapshot) {
-                }
-                else if (!tran.isFinished && this !== subscription)
-                    tran.cancel(new Error(`T${tran.id}[${tran.hint}] is canceled due to obsolete ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)} changed by T${snapshot.id}[${snapshot.hint}]`), null);
-            }
-            else if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.obsolete || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.obsolete)))
-                Dbg_1.Log.write(' ', 'x', `${this.hint()} is not obsolete due to its own change to ${Snapshot_1.Dump.rev2(holder, snapshot, memberName)}`);
-        }
-    }
-    runIfNotUpToDate(now, nothrow) {
-        const t = this.options.throttling;
-        const interval = Date.now() + this.started;
-        const hold = t ? t - interval : 0;
-        if (now || hold < 0) {
-            if (this.isNotUpToDate()) {
-                try {
-                    const op = this.controller.useOrRun(false, undefined);
-                    if (op.result instanceof Promise)
-                        op.result.catch(error => {
-                            if (op.options.kind === Options_1.Kind.Reaction)
-                                (0, Dbg_1.misuse)(`reaction ${op.hint()} failed and will not run anymore: ${error}`, error);
-                        });
-                }
-                catch (e) {
-                    if (!nothrow)
-                        throw e;
-                    else if (this.options.kind === Options_1.Kind.Reaction)
-                        (0, Dbg_1.misuse)(`reaction ${this.hint()} failed and will not run anymore: ${e}`, e);
-                }
-            }
-        }
-        else if (t < Number.MAX_SAFE_INTEGER) {
-            if (hold > 0)
-                setTimeout(() => this.runIfNotUpToDate(true, true), hold);
-            else
-                this.addToDeferredReactions();
-        }
-    }
-    isNotUpToDate() {
-        return !this.error && (this.options.kind === Options_1.Kind.Transaction ||
-            !this.successor || this.successor.transaction.isCanceled);
-    }
-    reenterOver(head) {
-        let error = undefined;
-        const opponent = head.successor;
-        if (opponent && !opponent.transaction.isFinished) {
-            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.obsolete)
-                Dbg_1.Log.write('║', ' [!]', `${this.hint()} is trying to re-enter over ${opponent.hint()}`);
-            switch (head.options.reentrance) {
-                case Options_1.Reentrance.PreventWithError:
-                    if (!opponent.transaction.isCanceled)
-                        throw (0, Dbg_1.misuse)(`${head.hint()} (${head.why()}) is not reentrant over ${opponent.hint()} (${opponent.why()})`);
-                    error = new Error(`T${this.transaction.id}[${this.transaction.hint}] is on hold/PreventWithError due to canceled T${opponent.transaction.id}[${opponent.transaction.hint}]`);
-                    this.transaction.cancel(error, opponent.transaction);
-                    break;
-                case Options_1.Reentrance.WaitAndRestart:
-                    error = new Error(`T${this.transaction.id}[${this.transaction.hint}] is on hold/WaitAndRestart due to active T${opponent.transaction.id}[${opponent.transaction.hint}]`);
-                    this.transaction.cancel(error, opponent.transaction);
-                    break;
-                case Options_1.Reentrance.CancelAndWaitPrevious:
-                    error = new Error(`T${this.transaction.id}[${this.transaction.hint}] is on hold/CancelAndWaitPrevious due to active T${opponent.transaction.id}[${opponent.transaction.hint}]`);
-                    this.transaction.cancel(error, opponent.transaction);
-                    opponent.transaction.cancel(new Error(`T${opponent.transaction.id}[${opponent.transaction.hint}] is canceled due to re-entering T${this.transaction.id}[${this.transaction.hint}]`), null);
-                    break;
-                case Options_1.Reentrance.CancelPrevious:
-                    opponent.transaction.cancel(new Error(`T${opponent.transaction.id}[${opponent.transaction.hint}] is canceled due to re-entering T${this.transaction.id}[${this.transaction.hint}]`), null);
-                    break;
-                case Options_1.Reentrance.RunSideBySide:
-                    break;
-            }
-        }
-        if (!error)
-            head.successor = this;
-        else
-            this.error = error;
-        return this;
-    }
-    static run(op, proxy) {
-        op.enter();
-        try {
-            op.result = op.options.getter.call(proxy, ...op.args);
-        }
-        finally {
-            op.leaveOrAsync();
-        }
-    }
-    enter() {
-        if (this.options.monitor)
-            this.monitorEnter(this.options.monitor);
-        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation)
-            Dbg_1.Log.write('║', '‾\\', `${this.hint()} - enter`, undefined, `    [ ${Snapshot_1.Dump.obj(this.controller.ownHolder, this.controller.memberName)} ]`);
-        this.started = Date.now();
-    }
-    leaveOrAsync() {
-        if (this.result instanceof Promise) {
-            this.result = this.result.then(value => {
-                this.content = value;
-                this.leave(false, '  ⚐', '- finished  ', ' OK ──┘');
-                return value;
-            }, error => {
-                this.error = error;
-                this.leave(false, '  ⚐', '- finished  ', 'ERR ──┘');
-                throw error;
-            });
-            if (Dbg_1.Log.isOn) {
-                if (Dbg_1.Log.opt.operation)
-                    Dbg_1.Log.write('║', '_/', `${this.hint()} - leave... `, 0, 'ASYNC ──┐');
-                else if (Dbg_1.Log.opt.transaction)
-                    Dbg_1.Log.write('║', '  ', `${this.why()} ...`, 0, 'ASYNC');
-            }
-        }
-        else {
-            this.content = this.result;
-            this.leave(true, '_/', '- leave');
-        }
-    }
-    leave(main, op, message, highlight = undefined) {
-        const ms = Date.now() - this.started;
-        this.started = -this.started;
-        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.operation)
-            Dbg_1.Log.write('║', `${op}`, `${this.hint()} ${message}`, ms, highlight);
-        if (ms > (main ? Hooks_1.Hooks.mainThreadBlockingWarningThreshold : Hooks_1.Hooks.asyncActionDurationWarningThreshold))
-            Dbg_1.Log.write('', '[!]', this.why(), ms, main ? '    *** main thread is too busy ***' : '    *** async is too long ***');
-        this.cause = undefined;
-        if (this.options.monitor)
-            this.monitorLeave(this.options.monitor);
-    }
-    monitorEnter(mon) {
-        const options = {
-            hint: 'Monitor.enter',
-            standalone: 'isolated',
-            logging: Dbg_1.Log.isOn && Dbg_1.Log.opt.monitor ? undefined : Dbg_1.Log.global
-        };
-        OperationController.runWithin(undefined, Transaction_1.Transaction.run, options, Monitor_1.MonitorImpl.enter, mon, this.transaction);
-    }
-    monitorLeave(mon) {
-        Transaction_1.Transaction.off(() => {
-            const leave = () => {
-                const options = {
-                    hint: 'Monitor.leave',
-                    standalone: 'isolated',
-                    logging: Dbg_1.Log.isOn && Dbg_1.Log.opt.monitor ? undefined : Dbg_1.Log.DefaultLevel
-                };
-                OperationController.runWithin(undefined, Transaction_1.Transaction.run, options, Monitor_1.MonitorImpl.leave, mon, this.transaction);
-            };
-            this.transaction.whenFinished().then(leave, leave);
-        });
-    }
-    addToDeferredReactions() {
-        Operation.deferredReactions.push(this);
-        if (Operation.deferredReactions.length === 1)
-            setTimeout(Operation.processDeferredReactions, 0);
-    }
-    static processDeferredReactions() {
-        const reactions = Operation.deferredReactions;
-        Operation.deferredReactions = [];
-        for (const x of reactions)
-            x.runIfNotUpToDate(true, true);
-    }
-    static markUsed(subscription, r, m, h, kind, weak) {
-        if (kind !== Options_1.Kind.Transaction) {
-            const op = Operation.current;
-            if (op && op.options.kind !== Options_1.Kind.Transaction &&
-                op.transaction === Transaction_1.Transaction.current && m !== Data_1.Meta.Holder) {
-                const ctx = Snapshot_1.Snapshot.current();
-                if (ctx !== r.snapshot)
-                    ctx.bumpBy(r.snapshot.timestamp);
-                const t = weak ? -1 : ctx.timestamp;
-                if (!op.subscribeTo(subscription, r, m, h, t))
-                    op.markObsoleteDueTo(subscription, m, r.snapshot, h, BOOT_CAUSE, ctx.timestamp, ctx.reactions);
-            }
-        }
-    }
-    static markEdited(oldValue, newValue, edited, r, m, h) {
-        edited ? r.changes.add(m) : r.changes.delete(m);
-        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
-            edited ? Dbg_1.Log.write('║', '  ✎', `${Snapshot_1.Dump.rev2(h, r.snapshot, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`) : Dbg_1.Log.write('║', '  ✎', `${Snapshot_1.Dump.rev2(h, r.snapshot, m)} is changed from ${valueHint(oldValue, m)} to ${valueHint(newValue, m)}`, undefined, ' (same as previous)');
-    }
-    static isConflicting(oldValue, newValue) {
-        let result = oldValue !== newValue;
-        if (result)
-            result = oldValue instanceof Operation && oldValue.cause !== BOOT_CAUSE;
-        return result;
-    }
-    static propagateAllChangesThroughSubscriptions(snapshot) {
-        var _a;
-        const since = snapshot.timestamp;
-        const reactions = snapshot.reactions;
-        snapshot.changeset.forEach((r, h) => {
-            if (!r.changes.has(Data_1.Meta.Disposed))
-                r.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(false, since, r, m, h, reactions));
-            else
-                for (const m in r.former.revision.data)
-                    Operation.propagateMemberChangeThroughSubscriptions(true, since, r, m, h, reactions);
-        });
-        reactions.sort(compareReactionsByOrder);
-        (_a = snapshot.options.journal) === null || _a === void 0 ? void 0 : _a.edited(Journal_1.JournalImpl.buildPatch(snapshot.hint, snapshot.changeset));
-    }
-    static revokeAllSubscriptions(snapshot) {
-        snapshot.changeset.forEach((r, h) => r.changes.forEach((o, m) => Operation.propagateMemberChangeThroughSubscriptions(true, snapshot.timestamp, r, m, h, undefined)));
-    }
-    static propagateMemberChangeThroughSubscriptions(unsubscribe, timestamp, r, m, h, reactions) {
-        var _a;
-        const curr = r.data[m];
-        if (reactions) {
-            const former = r.former.revision.data[m];
-            if (former !== undefined && former instanceof Data_1.Subscription) {
-                const why = `T${r.snapshot.id}[${r.snapshot.hint}]`;
-                if (former instanceof Operation) {
-                    if ((former.obsoleteSince === Snapshot_1.MAX_TIMESTAMP || former.obsoleteSince <= 0)) {
-                        former.obsoleteDueTo = why;
-                        former.obsoleteSince = timestamp;
-                        former.unsubscribeFromAllSubscriptions();
-                    }
-                    const formerSuccessor = former.successor;
-                    if (formerSuccessor !== curr) {
-                        if (formerSuccessor && !formerSuccessor.transaction.isFinished)
-                            formerSuccessor.transaction.cancel(new Error(`T${formerSuccessor.transaction.id}[${formerSuccessor.transaction.hint}] is canceled by T${r.snapshot.id}[${r.snapshot.hint}] and will not run anymore`), null);
-                    }
-                    else
-                        former.successor = undefined;
-                }
-                (_a = former.subscribers) === null || _a === void 0 ? void 0 : _a.forEach(s => s.markObsoleteDueTo(former, m, r.snapshot, h, why, timestamp, reactions));
-            }
-        }
-        if (curr instanceof Operation) {
-            if (curr.snapshot === r.snapshot && curr.subscriptions !== undefined) {
-                if (Hooks_1.Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                    curr.subscriptions.forEach((info, v) => {
-                        if (info.usageCount > Hooks_1.Hooks.repetitiveUsageWarningThreshold)
-                            Dbg_1.Log.write('', '[!]', `${curr.hint()} uses ${info.memberHint} ${info.usageCount} times (consider remembering it in a local variable)`, 0, ' *** WARNING ***');
-                    });
-                }
-                if (unsubscribe)
-                    curr.unsubscribeFromAllSubscriptions();
-            }
-        }
-        else if (curr instanceof Data_1.Subscription && curr.subscribers) {
-        }
-    }
-    static enqueueReactionsToRun(reactions) {
-        const queue = Operation.queuedReactions;
-        const isReactionLoopRequired = queue.length === 0;
-        for (const r of reactions)
-            queue.push(r);
-        if (isReactionLoopRequired)
-            OperationController.runWithin(undefined, Operation.runQueuedReactionsLoop);
-    }
-    static runQueuedReactionsLoop() {
-        const queue = Operation.queuedReactions;
-        let i = 0;
-        while (i < queue.length) {
-            const reaction = queue[i];
-            reaction.runIfNotUpToDate(false, true);
-            i++;
-        }
-        Operation.queuedReactions = [];
-    }
-    unsubscribeFromAllSubscriptions() {
-        var _a;
-        (_a = this.subscriptions) === null || _a === void 0 ? void 0 : _a.forEach((info, value) => {
-            var _a;
-            value.subscribers.delete(this);
-            if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                Dbg_1.Log.write(Dbg_1.Log.opt.transaction && !Snapshot_1.Snapshot.current().sealed ? '║' : ' ', '-', `${this.hint()} is unsubscribed from ${info.memberHint}`);
-        });
-        this.subscriptions = undefined;
-    }
-    subscribeTo(subscription, r, m, h, timestamp) {
-        var _a, _b, _c;
-        const ok = Operation.canSubscribe(subscription, r, m, h, timestamp);
-        if (ok) {
-            let times = 0;
-            if (Hooks_1.Hooks.repetitiveUsageWarningThreshold < Number.MAX_SAFE_INTEGER) {
-                const existing = this.subscriptions.get(subscription);
-                times = existing ? existing.usageCount + 1 : 1;
-            }
-            if (this.subscriptions !== undefined) {
-                if (!subscription.subscribers)
-                    subscription.subscribers = new Set();
-                const info = { memberHint: Snapshot_1.Dump.rev2(h, r.snapshot, m), usageCount: times };
-                subscription.subscribers.add(this);
-                this.subscriptions.set(subscription, info);
-                if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_a = this.options.logging) === null || _a === void 0 ? void 0 : _a.read)))
-                    Dbg_1.Log.write('║', '  ∞ ', `${this.hint()} is subscribed to ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}${info.usageCount > 1 ? ` (${info.usageCount} times)` : ''}`);
-            }
-            else if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_b = this.options.logging) === null || _b === void 0 ? void 0 : _b.read)))
-                Dbg_1.Log.write('║', '  x ', `${this.hint()} is obsolete and is NOT subscribed to ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}`);
-        }
-        else {
-            if (Dbg_1.Log.isOn && (Dbg_1.Log.opt.read || ((_c = this.options.logging) === null || _c === void 0 ? void 0 : _c.read)))
-                Dbg_1.Log.write('║', '  x ', `${this.hint()} is NOT subscribed to already obsolete ${Snapshot_1.Dump.rev2(h, r.snapshot, m)}`);
-        }
-        return ok;
-    }
-    static canSubscribe(subscription, r, m, h, timestamp) {
-        let result = !r.snapshot.sealed || subscription === h.head.data[m];
-        if (result && timestamp !== -1)
-            result = !(subscription instanceof Operation && timestamp >= subscription.obsoleteSince);
-        return result;
-    }
-    static createOperation(h, m, options) {
-        const ctl = new OperationController(h, m);
-        const operation = (...args) => {
-            return ctl.useOrRun(false, args).result;
-        };
-        Data_1.Meta.set(operation, Data_1.Meta.Controller, ctl);
-        return operation;
-    }
-    static rememberOperationOptions(proto, m, getter, setter, enumerable, configurable, options, implicit) {
-        const initial = Data_1.Meta.acquire(proto, Data_1.Meta.Initial);
-        let op = initial[m];
-        const ctl = op ? op.controller : new OperationController(ROOT_HOLDER, m);
-        const opts = op ? op.options : Hooks_1.OptionsImpl.INITIAL;
-        initial[m] = op = new Operation(ctl, Snapshot_1.ROOT_REV.snapshot, new Hooks_1.OptionsImpl(getter, setter, opts, options, implicit));
-        if (op.options.kind === Options_1.Kind.Reaction && op.options.throttling < Number.MAX_SAFE_INTEGER) {
-            const reactions = Data_1.Meta.acquire(proto, Data_1.Meta.Reactions);
-            reactions[m] = op;
-        }
-        else if (op.options.kind === Options_1.Kind.Reaction && op.options.throttling >= Number.MAX_SAFE_INTEGER) {
-            const reactions = Data_1.Meta.getFrom(proto, Data_1.Meta.Reactions);
-            delete reactions[m];
-        }
-        return op.options;
-    }
-    static init() {
-        Object.freeze(BOOT_ARGS);
-        Dbg_1.Log.getMergedLoggingOptions = getMergedLoggingOptions;
-        Snapshot_1.Dump.valueHint = valueHint;
-        Snapshot_1.Snapshot.markUsed = Operation.markUsed;
-        Snapshot_1.Snapshot.markEdited = Operation.markEdited;
-        Snapshot_1.Snapshot.isConflicting = Operation.isConflicting;
-        Snapshot_1.Snapshot.propagateAllChangesThroughSubscriptions = Operation.propagateAllChangesThroughSubscriptions;
-        Snapshot_1.Snapshot.revokeAllSubscriptions = Operation.revokeAllSubscriptions;
-        Snapshot_1.Snapshot.enqueueReactionsToRun = Operation.enqueueReactionsToRun;
-        Hooks_1.Hooks.createOperation = Operation.createOperation;
-        Hooks_1.Hooks.rememberOperationOptions = Operation.rememberOperationOptions;
-        Promise.prototype.then = reactronicHookedThen;
-        try {
-            Object.defineProperty(globalThis, 'rWhy', {
-                get: OperationController.why, configurable: false, enumerable: false,
-            });
-            Object.defineProperty(globalThis, 'rBriefWhy', {
-                get: OperationController.briefWhy, configurable: false, enumerable: false,
-            });
-        }
-        catch (e) {
-        }
-        try {
-            Object.defineProperty(global, 'rWhy', {
-                get: OperationController.why, configurable: false, enumerable: false,
-            });
-            Object.defineProperty(global, 'rBriefWhy', {
-                get: OperationController.briefWhy, configurable: false, enumerable: false,
-            });
-        }
-        catch (e) {
-        }
-    }
-}
-Operation.current = undefined;
-Operation.queuedReactions = [];
-Operation.deferredReactions = [];
-function valueHint(value, m) {
-    let result = '';
-    if (Array.isArray(value))
-        result = `Array(${value.length})`;
-    else if (value instanceof Set)
-        result = `Set(${value.size})`;
-    else if (value instanceof Map)
-        result = `Map(${value.size})`;
-    else if (value instanceof Operation)
-        result = `${Snapshot_1.Dump.rev2(value.controller.ownHolder, value.snapshot, m)}`;
-    else if (value === Data_1.Meta.Disposed)
-        result = '<disposed>';
-    else if (value === Data_1.Meta.Undefined)
-        result = '◌';
-    else if (typeof (value) === 'string')
-        result = `"${value.toString().slice(0, 20)}"`;
-    else if (value !== undefined && value !== null)
-        result = value.toString().slice(0, 20);
-    else
-        result = '◌';
-    return result;
-}
-function getMergedLoggingOptions(local) {
-    const t = Transaction_1.Transaction.current;
-    let res = Dbg_1.Log.merge(t.options.logging, t.id > 1 ? 31 + t.id % 6 : 37, t.id > 1 ? `T${t.id}` : `-${Snapshot_1.Snapshot.idGen.toString().replace(/[0-9]/g, '-')}`, Dbg_1.Log.global);
-    res = Dbg_1.Log.merge({ margin1: t.margin }, undefined, undefined, res);
-    if (Operation.current)
-        res = Dbg_1.Log.merge({ margin2: Operation.current.margin }, undefined, undefined, res);
-    if (local)
-        res = Dbg_1.Log.merge(local, undefined, undefined, res);
-    return res;
-}
-const ORIGINAL_PROMISE_THEN = Promise.prototype.then;
-function reactronicHookedThen(resolve, reject) {
-    const tran = Transaction_1.Transaction.current;
-    if (!tran.isFinished) {
-        if (!resolve)
-            resolve = resolveReturn;
-        if (!reject)
-            reject = rejectRethrow;
-        const op = Operation.current;
-        if (op) {
-            resolve = op.wrap(resolve);
-            reject = op.wrap(reject);
-        }
-        resolve = tran.wrap(resolve, false);
-        reject = tran.wrap(reject, true);
-    }
-    return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
-}
-function compareReactionsByOrder(a, b) {
-    return a.order - b.order;
-}
-function resolveReturn(value) {
-    return value;
-}
-exports.resolveReturn = resolveReturn;
-function rejectRethrow(error) {
-    throw error;
-}
-exports.rejectRethrow = rejectRethrow;
-Operation.init();