Type Alias BaseNodeType<TNode, TOptional, TOther>

Type declaration

• • (data: MarkOptional<TNode, TOptional>): TNode

  • Node constructor. Requires all keys from TNode except those in TOptional (which may be omitted).

    Parameters

    • data: MarkOptional<TNode, TOptional>

    Returns TNode

• OptionaldefaultGenerators?: { [K in keyof TNode]?: () => TNode[K] }

  Default generators defined so far.

• actions:function

  • actions<TActions extends Record<string, (this: TNode, ...args: any) => any>>(
        actions: TActions,
    ): BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [k in string
            | number
            | symbol]: PrependArgument<TActions[k], TNode>
        },
    >

    Registers action methods for nodes of this type

    Actions are methods that can modify the node state and are automatically wrapped in MobX actions for proper state tracking.

    Type Parameters

    • TActions extends Record<string, (this: TNode, ...args: any) => any>

      Record of action methods

    Parameters

    • actions: TActions

      An object of action methods

    Returns BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [k in string
            | number
            | symbol]: PrependArgument<TActions[k], TNode>
        },
    >

    The same NodeType with added action methods that accept a node as their first parameter

• computeds:function

  • computeds<TComputeds extends Record<string, ComputedEntry<TNode, any>>>(
        computeds: TComputeds,
    ): BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [k in string
            | number
            | symbol]: TComputeds[k] extends () => any
                ? PrependArgument<any[any], TNode>
                : TComputeds[k] extends ComputedFnWithOptions<TNode, any>
                    ? PrependArgument<any[any]["get"], TNode>
                    : never
        },
    >

    Registers computed methods for nodes of this type

    Computed methods derive values from the node state and are automatically memoized by MobX for performance optimization.

    Type Parameters

    • TComputeds extends Record<string, ComputedEntry<TNode, any>>

      Record of computed properties

    Parameters

    • computeds: TComputeds

      Function that receives a node and returns an object of computed accessor methods

    Returns BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [k in string
            | number
            | symbol]: TComputeds[k] extends () => any
                ? PrependArgument<any[any], TNode>
                : TComputeds[k] extends ComputedFnWithOptions<TNode, any>
                    ? PrependArgument<any[any]["get"], TNode>
                    : never
        },
    >

    The same NodeType with added computed methods that accept a node as their first parameter

• defaults:function

  • defaults<TGen extends { [K in string | number | symbol]?: () => TNode[K] }>(
        defaultGenerators: TGen,
    ): BaseNodeType<TNode, TOptional | keyof TGen & keyof TNode, TOther>

    Define default values for keys in TOptional. When omitted, those properties are filled with the results of these generators.

    Type Parameters

    • TGen extends { [K in string | number | symbol]?: () => TNode[K] }

      Record of default value generators

    Parameters

    • defaultGenerators: TGen

    Returns BaseNodeType<TNode, TOptional | keyof TGen & keyof TNode, TOther>

• getters:function

  • getters<TGetters extends Record<string, (this: TNode, ...args: any) => any>>(
        getters: TGetters,
    ): BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [k in string
            | number
            | symbol]: PrependArgument<TGetters[k], TNode>
        },
    >

    Registers getter methods for nodes of this type

    Getters are methods that derive values from the node state without modifying it.

    Type Parameters

    • TGetters extends Record<string, (this: TNode, ...args: any) => any>

      Record of getter methods

    Parameters

    • getters: TGetters

      An object of getter methods

    Returns BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [k in string
            | number
            | symbol]: PrependArgument<TGetters[k], TNode>
        },
    >

    The same NodeType with added getter methods that accept a node as their first parameter

• settersFor:function

  • settersFor<K extends string>(
        ...properties: readonly K[],
    ): BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [P in string as `set${Capitalize<P>}`]: (
                node: TNode,
                value: Readonly<TNode[P]>,
            ) => void
        },
    >

    Generates setter methods for specified properties

    Type Parameters

    • K extends string

    Parameters

    • ...properties: readonly K[]

      Names of properties to create setters for

    Returns BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [P in string as `set${Capitalize<P>}`]: (
                node: TNode,
                value: Readonly<TNode[P]>,
            ) => void
        },
    >

    The same NodeType with added setter methods

• snapshot:function

  • snapshot(data: MarkOptional<TNode, TOptional>): TNode

    Returns a snapshot based on the provided data.

    Parameters

    • data: MarkOptional<TNode, TOptional>

    Returns TNode

• volatile:function

  • volatile<TVolatiles extends Record<string, () => any>>(
        volatile: TVolatiles,
    ): BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [K in string
            | number
            | symbol as `set${Capitalize<string & K>}`]: (
                n: TNode,
                value: ReturnType<TVolatiles[K]>,
            ) => void
        } & {
            [K in string
            | number
            | symbol as `get${Capitalize<string & K>}`]: (
                n: TNode,
            ) => ReturnType<TVolatiles[K]>
        } & {
            [K in string
            | number
            | symbol as `reset${Capitalize<string & K>}`]: (n: TNode) => void
        },
    >

    Adds volatile state properties to nodes of this type

    Volatile state is not persisted in snapshots and is local to each node instance.

    Type Parameters

    • TVolatiles extends Record<string, () => any>

      Record of volatile property getter functions

    Parameters

    • volatile: TVolatiles

      Object where each key defines a getter function for volatile state

    Returns BaseNodeType<
        TNode,
        TOptional,
        TOther & {
            [K in string
            | number
            | symbol as `set${Capitalize<string & K>}`]: (
                n: TNode,
                value: ReturnType<TVolatiles[K]>,
            ) => void
        } & {
            [K in string
            | number
            | symbol as `get${Capitalize<string & K>}`]: (
                n: TNode,
            ) => ReturnType<TVolatiles[K]>
        } & {
            [K in string
            | number
            | symbol as `reset${Capitalize<string & K>}`]: (n: TNode) => void
        },
    >

    The same NodeType with added accessor methods for the volatile state