reactronic/build/dist/source/core/TreeNode.d.ts

Reactronic - Transactional Reactive State Management

import { LoggingOptions } from "../Logging.js";
import { MergeList, MergeListReader, MergedItem } from "../util/MergeList.js";
import { Priority, Mode } from "../Enums.js";
import { ReactivityOptions } from "../Options.js";
import { ObservableObject } from "../core/Mvcc.js";
export type Script<E> = (el: E, basis: () => void) => void;
export type ScriptAsync<E> = (el: E, basis: () => Promise<void>) => Promise<void>;
export type Handler<E = unknown, R = void> = (el: E) => R;
export declare abstract class ReactiveTreeNode<E = unknown> {
    static readonly shortFrameDuration = 16;
    static readonly longFrameDuration = 300;
    static frameDuration: number;
    static currentScriptPriority: Priority;
    abstract readonly key: string;
    abstract readonly driver: ReactiveTreeNodeDriver<E>;
    abstract readonly declaration: Readonly<ReactiveTreeNodeDecl<E>>;
    abstract readonly level: number;
    abstract readonly owner: ReactiveTreeNode;
    abstract element: E;
    abstract readonly host: ReactiveTreeNode;
    abstract readonly children: MergeListReader<ReactiveTreeNode>;
    abstract readonly slot: MergedItem<ReactiveTreeNode<E>> | undefined;
    abstract readonly stamp: number;
    abstract readonly outer: ReactiveTreeNode;
    abstract readonly context: ReactiveTreeNodeContext | undefined;
    abstract priority?: Priority;
    abstract childrenShuffling: boolean;
    abstract strictOrder: boolean;
    abstract has(mode: Mode): boolean;
    abstract configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
    static get current(): ReactiveTreeNode;
    static get isFirstScriptRun(): boolean;
    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, script?: Script<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, declaration?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
    static declare<E = void>(driver: ReactiveTreeNodeDriver<E>, scriptOrDeclaration?: Script<E> | ReactiveTreeNodeDecl<E>, scriptAsync?: ScriptAsync<E>, key?: string, mode?: Mode, preparation?: Script<E>, preparationAsync?: ScriptAsync<E>, finalization?: Script<E>, triggers?: unknown, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNode<E>;
    static withBasis<E = void>(declaration?: ReactiveTreeNodeDecl<E>, basis?: ReactiveTreeNodeDecl<E>): ReactiveTreeNodeDecl<E>;
    static triggerScriptRun(node: ReactiveTreeNode<any>, triggers: unknown): void;
    static triggerFinalization(node: ReactiveTreeNode<any>): void;
    static runNestedNodeScriptsThenDo(action: (error: unknown) => void): void;
    static markAsMounted(node: ReactiveTreeNode<any>, yes: boolean): void;
    static findMatchingHost<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
    static findMatchingPrevSibling<E = unknown, R = unknown>(node: ReactiveTreeNode<E>, match: Handler<ReactiveTreeNode<E>, boolean>): ReactiveTreeNode<R> | undefined;
    static forEachChildRecursively<E = unknown>(node: ReactiveTreeNode<E>, action: Handler<ReactiveTreeNode<E>>): void;
    static getDefaultLoggingOptions(): LoggingOptions | undefined;
    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
}
export type ReactiveTreeNodeDecl<E = unknown> = {
    script?: Script<E>;
    scriptAsync?: ScriptAsync<E>;
    key?: string;
    mode?: Mode;
    preparation?: Script<E>;
    preparationAsync?: ScriptAsync<E>;
    finalization?: Script<E>;
    triggers?: unknown;
    basis?: ReactiveTreeNodeDecl<E>;
};
export type ReactiveTreeNodeDriver<E = unknown> = {
    readonly name: string;
    readonly isPartition: boolean;
    readonly initialize?: Handler<E>;
    create(node: ReactiveTreeNode<E>): E;
    runPreparation(node: ReactiveTreeNode<E>): void;
    runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
    runMount(node: ReactiveTreeNode<E>): void;
    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): MergedItem<ReactiveTreeNode> | undefined;
    provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
};
export type ReactiveTreeNodeContext<T extends Object = Object> = {
    value: T;
};
export declare abstract class BaseDriver<E = unknown> implements ReactiveTreeNodeDriver<E> {
    readonly name: string;
    readonly isPartition: boolean;
    readonly initialize?: Handler<E> | undefined;
    constructor(name: string, isPartition: boolean, initialize?: Handler<E> | undefined);
    abstract create(node: ReactiveTreeNode<E>): E;
    runPreparation(node: ReactiveTreeNode<E>): void | Promise<void>;
    runFinalization(node: ReactiveTreeNode<E>, isLeader: boolean): boolean;
    runMount(node: ReactiveTreeNode<E>): void;
    runScript(node: ReactiveTreeNode<E>): void | Promise<void>;
    declareChild(ownerNode: ReactiveTreeNode<E>, childDriver: ReactiveTreeNodeDriver<any>, childDeclaration?: ReactiveTreeNodeDecl<any>, childBasis?: ReactiveTreeNodeDecl<any>): MergedItem<ReactiveTreeNode> | undefined;
    provideHost(node: ReactiveTreeNode<E>): ReactiveTreeNode<E>;
}
export declare class ReactiveTreeVariable<T extends Object = Object> {
    readonly defaultValue: T | undefined;
    constructor(defaultValue?: T);
    set value(value: T);
    get value(): T;
    get valueOrUndefined(): T | undefined;
}
export declare function generateKey(owner: ReactiveTreeNodeImpl): string;
export declare function getModeUsingBasisChain(declaration?: ReactiveTreeNodeDecl<any>): Mode;
declare class ReactiveTreeNodeContextImpl<T extends Object = Object> extends ObservableObject implements ReactiveTreeNodeContext<T> {
    next: ReactiveTreeNodeContextImpl<object> | undefined;
    variable: ReactiveTreeVariable<T>;
    value: T;
    constructor(variable: ReactiveTreeVariable<T>, value: T);
}
declare class ReactiveTreeNodeImpl<E = unknown> extends ReactiveTreeNode<E> {
    static logging: LoggingOptions | undefined;
    static grandNodeCount: number;
    static disposableNodeCount: number;
    readonly key: string;
    readonly driver: ReactiveTreeNodeDriver<E>;
    declaration: ReactiveTreeNodeDecl<E>;
    readonly level: number;
    readonly owner: ReactiveTreeNodeImpl;
    readonly element: E;
    host: ReactiveTreeNodeImpl;
    readonly children: MergeList<ReactiveTreeNodeImpl>;
    slot: MergedItem<ReactiveTreeNodeImpl<E>> | undefined;
    stamp: number;
    outer: ReactiveTreeNodeImpl;
    context: ReactiveTreeNodeContextImpl<any> | undefined;
    numerator: number;
    priority: Priority;
    childrenShuffling: boolean;
    constructor(key: string, driver: ReactiveTreeNodeDriver<E>, declaration: Readonly<ReactiveTreeNodeDecl<E>>, owner: ReactiveTreeNodeImpl | undefined);
    get strictOrder(): boolean;
    set strictOrder(value: boolean);
    get isMoved(): boolean;
    has(mode: Mode): boolean;
    script(_triggers: unknown): void;
    configureReactivity(options: Partial<ReactivityOptions>): ReactivityOptions;
    static get nodeSlot(): MergedItem<ReactiveTreeNodeImpl>;
    static tryUseTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T | undefined;
    static useTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>): T;
    static setTreeVariableValue<T extends Object>(variable: ReactiveTreeVariable<T>, value: T | undefined): void;
}
export declare function observablesAreEqual(a1: any, a2: any): boolean;
export {};