ag-charts-community

import { Node } from "./node"; import { Scene } from "./scene"; declare type ValueFn<P, GDatum, PDatum> = (parent: P, data: PDatum, index: number, groups: (P | undefined)[]) => GDatum[]; declare type KeyFn<N, G, GDatum> = (node: N, datum: GDatum, index: number, groups: (G | undefined)[]) => string; export declare class EnterNode { constructor(parent: Node | EnterNode, datum: any); scene?: Scene; parent: Node | EnterNode; datum: any; next: Node | EnterNode | null; appendChild<T extends Node>(node: T): T; insertBefore<T extends Node>(node: T, nextNode?: Node | null): T; } /** * G - type of the selected node(s). * GDatum - type of the datum of the selected node(s). * P - type of the parent node(s). * PDatum - type of the datum of the parent node(s). */ export declare class Selection<G extends Node | EnterNode, P extends Node | EnterNode, GDatum = any, PDatum = any> { constructor(groups: (G | undefined)[][], parents: (P | undefined)[]); groups: (G | undefined)[][]; parents: (P | undefined)[]; static select<G extends Node, P extends Node | EnterNode>(node: G | (() => G)): Selection<G, P, any, any>; static selectAll<G extends Node>(nodes?: G[] | null): Selection<G, Node | EnterNode, any, any>; /** * Creates new nodes, appends them to the nodes of this selection and returns them * as a new selection. The created nodes inherit the datums and the parents of the nodes * they replace. * @param Class The constructor function to use to create the new nodes. */ append<N extends Node>(Class: new () => N): Selection<N, P, GDatum, GDatum>; /** * Same as the {@link append}, but accepts a custom creator function with the * {@link NodeSelector} signature rather than a constructor function. * @param creator */ private appendFn; /** * Runs the given selector that returns a single node for every node in each group. * The original nodes are then replaced by the nodes returned by the selector * and returned as a new selection. * The selected nodes inherit the datums and the parents of the original nodes. */ select<N extends Node>(selector: (node: G, datum: GDatum, index: number, group: (G | undefined)[]) => N | undefined): Selection<N, P, GDatum, GDatum>; /** * Same as {@link select}, but uses the given {@param Class} (constructor) as a selector. * @param Class The constructor function to use to find matching nodes. */ selectByClass<N extends Node>(Class: new () => N): Selection<N, P, GDatum, GDatum>; selectByTag<N extends Node>(tag: number): Selection<N, P, GDatum, GDatum>; selectAllByClass<N extends Node, NDatum = any>(Class: new () => N): Selection<N, G, NDatum, GDatum>; selectAllByTag<N extends Node, NDatum = any>(tag: number): Selection<N, G, NDatum, GDatum>; private selectNone; /** * Runs the given selector that returns a group of nodes for every node in each group. * The original nodes are then replaced by the groups of nodes returned by the selector * and returned as a new selection. The original nodes become the parent nodes for each * group in the new selection. The selected nodes do not inherit the datums of the original nodes. * If called without any parameters, creates a new selection with an empty group for each * node in this selection. */ selectAll<N extends Node, NDatum = any>(selectorAll?: (node: G, datum: GDatum, index: number, group: (G | undefined)[]) => N[]): Selection<N, G, NDatum, GDatum>; /** * Runs the given callback for every node in this selection and returns this selection. * @param cb */ each(cb: (node: G, datum: GDatum, index: number, group: (G | undefined)[]) => void): this; remove(): this; merge(other: Selection<G, P, GDatum, PDatum>): Selection<G, P, GDatum, PDatum>; /** * Return the first non-null element in this selection. * If the selection is empty, returns null. */ node(): G | null; attr<K extends keyof G>(name: K, value: Exclude<G[K], Function>): this; attrFn<K extends keyof G>(name: K, value: (node: G, datum: GDatum, index: number, group: (G | undefined)[]) => Exclude<G[K], Function>): this; /** * Invokes the given function once, passing in this selection. * Returns this selection. Facilitates method chaining. * @param cb */ call(cb: (selection: this) => void): this; /** * Returns the total number of nodes in this selection. */ get size(): number; /** * Returns the array of data for the selected elements. */ get data(): GDatum[]; private enterGroups?; private exitGroups?; get enter(): Selection<EnterNode, P, GDatum, PDatum>; get exit(): Selection<G, P, GDatum, PDatum>; /** * Binds the given value to each selected node and returns this selection * with its {@link GDatum} type changed to the type of the given value. * This method doesn't compute a join and doesn't affect indexes or the enter and exit selections. * This method can also be used to clear bound data. * @param value */ setDatum<GDatum>(value: GDatum): Selection<G, P, GDatum, PDatum>; /** * Returns the bound datum for the first non-null element in the selection. * This is generally useful only if you know the selection contains exactly one element. */ get datum(): GDatum; /** * Binds the specified array of values with the selected nodes, returning a new selection * that represents the _update_ selection: the nodes successfully bound to the values. * Also defines the {@link enter} and {@link exit} selections on the returned selection, * which can be used to add or remove the nodes to correspond to the new data. * The `values` is an array of values of a particular type, or a function that returns * an array of values for each group. * When values are assigned to the nodes, they are stored in the {@link Node.datum} property. * @param values * @param key */ setData<GDatum>(values: GDatum[] | ValueFn<P, GDatum, PDatum>, key?: KeyFn<Node | EnterNode, G | GDatum, GDatum>): Selection<G, P, GDatum, PDatum>; private bindIndex; private static keyPrefix; private bindKey; } export {};