reactronic/build/dist/source/System.js

Reactronic - Transactional Reactive State Management

import { Log, misuse } from "./util/Dbg.js";
import { Kind, Isolation } from "./Enums.js";
import { Meta, ObjectHandle } from "./core/Data.js";
import { Changeset } from "./core/Changeset.js";
import { Mvcc } from "./core/Mvcc.js";
import { Transaction } from "./core/Transaction.js";
import { ReactionImpl } from "./core/Operation.js";
export class ReactiveSystem {
    static why(brief = false) { return brief ? ReactionImpl.briefWhy() : ReactionImpl.why(); }
    static getRevisionOf(obj) { return obj[Meta.Revision]; }
    static takeSnapshot(obj) { return Changeset.takeSnapshot(obj); }
    static get reactivityAutoStartDisabled() { return Mvcc.reactivityAutoStartDisabled; }
    static set reactivityAutoStartDisabled(value) { Mvcc.reactivityAutoStartDisabled = value; }
    static get isLogging() { return Log.isOn; }
    static get loggingOptions() { return Log.opt; }
    static setLoggingMode(isOn, options) { Log.setMode(isOn, options); }
    static setLoggingHint(obj, name) { Mvcc.setHint(obj, name); }
    static getLoggingHint(obj, full = false) { return ObjectHandle.getHint(obj, full); }
    static setProfilingMode(isOn, options) { Mvcc.setProfilingMode(isOn, options); }
}
export function runTransactional(p1, p2, p3) {
    if (p1 instanceof Function) {
        if (p2 !== undefined)
            return Transaction.run(null, p1, ...p2);
        else
            return Transaction.run(null, p1);
    }
    else {
        if (p3 !== undefined)
            return Transaction.run(p1, p2, ...p3);
        else
            return Transaction.run(p1, p2);
    }
}
export function runNonReactive(func, ...args) {
    return ReactionImpl.proceedWithinGivenLaunch(undefined, func, ...args);
}
export function runSensitive(sensitivity, func, ...args) {
    return Mvcc.sensitive(sensitivity, func, ...args);
}
export function runContextual(p) {
    throw misuse("not implemented yet");
}
export function manageReaction(method) {
    return ReactionImpl.manageReaction(method);
}
export function configureCurrentReaction(options) {
    return ReactionImpl.configureImpl(undefined, options);
}
export function disposeSignallingObject(obj) {
    Changeset.dispose(obj);
}
export function signal(protoOrEnabled, prop) {
    if (typeof (protoOrEnabled) === "boolean") {
        return (proto, prop) => {
            return Mvcc.decorateData(protoOrEnabled, proto, prop);
        };
    }
    else
        return Mvcc.decorateData(true, protoOrEnabled, prop);
}
export function transaction(proto, prop, pd) {
    const opts = {
        kind: Kind.transaction,
        isolation: Isolation.joinToCurrentTransaction,
    };
    return Mvcc.decorateOperation(true, transaction, opts, proto, prop, pd);
}
export function reaction(proto, prop, pd) {
    const opts = {
        kind: Kind.reaction,
        isolation: Isolation.joinAsNestedTransaction,
        throttling: -1,
    };
    return Mvcc.decorateOperation(true, reaction, opts, proto, prop, pd);
}
export function cache(proto, prop, pd) {
    const opts = {
        kind: Kind.cache,
        isolation: Isolation.joinToCurrentTransaction,
        noSideEffects: true,
    };
    return Mvcc.decorateOperation(true, cache, opts, proto, prop, pd);
}
export function options(value) {
    return Mvcc.decorateOperationParametrized(options, value);
}