@thi.ng/atom/transacted.d.ts

Mutable wrappers for nested immutable values with optional undo/redo history and transaction support

import type { DeepPath, Fn, Maybe, OptPathVal, Path, Path0, Path1, Path2, Path3, Path4, Path5, Path6, Path7, Path8, PathVal, Watch } from "@thi.ng/api";
import type { IAtom, SwapFn } from "./api.js";
/**
 * Return a new {@link Transacted} state wrapper.
 *
 * @param parent -
 */
export declare const defTransacted: <T>(parent: IAtom<T>) => Transacted<T>;
/**
 * Like {@link defTransacted}, but immediately starts new transaction as
 * well, i.e. same as `defTransacted(state).begin()`.
 *
 * @param parent -
 */
export declare const beginTransaction: <T>(parent: IAtom<T>) => Transacted<T>;
/**
 * An "anonymous" version of {@link Transacted.updateAsTransaction}. Takes an
 * atom, wraps it as a {@link Transacted} and calls given `fn` with it to update
 * the state as a single transaction. If the update function returns true, the
 * transaction will be committed, else cancelled. Returns atom.
 *
 * @remarks
 * **IMPORTANT:** Within body of the update function **only** work with the
 * transaction wrapper given as argument! **DO NOT** update the original state
 * atom!
 *
 * If an error occurs during the update, the transaction will be canceled, the
 * wrapper silently removed and the error re-thrown.
 *
 * @param parent
 * @param fn
 */
export declare const updateAsTransaction: <T>(parent: IAtom<T>, fn: Fn<Transacted<T>, boolean>) => IAtom<T>;
export declare class Transacted<T> implements IAtom<T> {
    parent: IAtom<T>;
    current: Maybe<T>;
    protected id: string;
    protected isActive: boolean;
    protected _watches: any;
    constructor(parent: IAtom<T>);
    get value(): T;
    set value(val: T);
    get isTransaction(): boolean;
    deref(): T;
    equiv(o: any): boolean;
    reset(val: T): T;
    resetIn(path: Path0, val: T): T;
    resetIn<A>(path: Path1<T, A>, val: PathVal<T, [A]>): T;
    resetIn<A, B>(path: Path2<T, A, B>, val: PathVal<T, [A, B]>): T;
    resetIn<A, B, C>(path: Path3<T, A, B, C>, val: PathVal<T, [A, B, C]>): T;
    resetIn<A, B, C, D>(path: Path4<T, A, B, C, D>, val: PathVal<T, [A, B, C, D]>): T;
    resetIn<A, B, C, D, E>(path: Path5<T, A, B, C, D, E>, val: PathVal<T, [A, B, C, D, E]>): T;
    resetIn<A, B, C, D, E, F>(path: Path6<T, A, B, C, D, E, F>, val: PathVal<T, [A, B, C, D, E, F]>): T;
    resetIn<A, B, C, D, E, F, G>(path: Path7<T, A, B, C, D, E, F, G>, val: PathVal<T, [A, B, C, D, E, F, G]>): T;
    resetIn<A, B, C, D, E, F, G, H>(path: Path8<T, A, B, C, D, E, F, G, H>, val: PathVal<T, [A, B, C, D, E, F, G, H]>): T;
    resetIn<A, B, C, D, E, F, G, H>(path: DeepPath<T, A, B, C, D, E, F, G, H>, val: any): T;
    resetInUnsafe(path: Path, val: any): T;
    swap(fn: SwapFn<T, T>, ...args: any[]): T;
    swapIn<A>(path: Path0, fn: SwapFn<T, T>, ...args: any[]): T;
    swapIn<A>(path: Path1<T, A>, fn: SwapFn<OptPathVal<T, [A]>, PathVal<T, [A]>>, ...args: any[]): T;
    swapIn<A, B>(path: Path2<T, A, B>, fn: SwapFn<OptPathVal<T, [A, B]>, PathVal<T, [A, B]>>, ...args: any[]): T;
    swapIn<A, B, C>(path: Path3<T, A, B, C>, fn: SwapFn<OptPathVal<T, [A, B, C]>, PathVal<T, [A, B, C]>>, ...args: any[]): T;
    swapIn<A, B, C, D>(path: Path4<T, A, B, C, D>, fn: SwapFn<OptPathVal<T, [A, B, C, D]>, PathVal<T, [A, B, C, D]>>, ...args: any[]): T;
    swapIn<A, B, C, D, E>(path: Path5<T, A, B, C, D, E>, fn: SwapFn<OptPathVal<T, [A, B, C, D, E]>, PathVal<T, [A, B, C, D, E]>>, ...args: any[]): T;
    swapIn<A, B, C, D, E, F>(path: Path6<T, A, B, C, D, E, F>, fn: SwapFn<OptPathVal<T, [A, B, C, D, E, F]>, PathVal<T, [A, B, C, D, E, F]>>, ...args: any[]): T;
    swapIn<A, B, C, D, E, F, G>(path: Path7<T, A, B, C, D, E, F, G>, fn: SwapFn<OptPathVal<T, [A, B, C, D, E, F, G]>, PathVal<T, [A, B, C, D, E, F, G]>>, ...args: any[]): T;
    swapIn<A, B, C, D, E, F, G, H>(path: Path8<T, A, B, C, D, E, F, G, H>, fn: SwapFn<OptPathVal<T, [A, B, C, D, E, F, G, H]>, PathVal<T, [A, B, C, D, E, F, G, H]>>, ...args: any[]): T;
    swapIn<A, B, C, D, E, F, G, H>(path: DeepPath<T, A, B, C, D, E, F, G, H>, fn: SwapFn<any, any>, ...args: any[]): T;
    swapInUnsafe(path: Path, fn: SwapFn<any, any>, ...args: any[]): T;
    begin(): this;
    commit(): T;
    cancel(): void;
    /**
     * Starts a new transaction and calls given `fn` with this instance to
     * update the state (presumably in multiple stages) as a single transaction.
     * If the update function returns true, the transaction will be committed,
     * else cancelled.
     *
     * @remarks
     * **IMPORTANT:** Within body of the update function **only** work with the
     * transaction wrapper given as argument! **DO NOT** update the original
     * state atom!
     *
     * If an error occurs during the update, the transaction will be canceled
     * and the error re-thrown.
     *
     * @param fn
     */
    updateAsTransaction(fn: Fn<Transacted<T>, boolean>): void;
    addWatch(id: string, watch: Watch<T>): boolean;
    removeWatch(id: string): boolean;
    notifyWatches(old: T, curr: T): void;
    release(): boolean;
    protected ensureTx(): void;
}
//# sourceMappingURL=transacted.d.ts.map