@types/d3-hierarchy

method nodeSize

nodeSize: { (): [number, number] | null; (size: [number, number]): this };

• Returns the current node size, which defaults to null. A node size of null indicates that a layout size will be used instead.

• Sets this cluster layout’s node size to the specified [width, height] array and returns this cluster layout. When a node size is specified, the root node is always positioned at <0, 0>.

  Parameter size

  The specified two-element size array.

method separation

separation: {
    (): (a: HierarchyPointNode<Datum>, b: HierarchyPointNode<Datum>) => number;
    (
        separation: (
            a: HierarchyPointNode<Datum>,
            b: HierarchyPointNode<Datum>
        ) => number
    ): this;
};

• Returns the current separation accessor, which defaults to: (a, b) => a.parent == b.parent ? 1 : 2.

• Sets the separation accessor to the specified function and returns this cluster layout. The separation accessor is used to separate neighboring leaves.

  Parameter separation

  The separation function is passed two leaves a and b, and must return the desired separation. The nodes are typically siblings, though the nodes may be more distantly related if the layout decides to place such nodes adjacent.

method size

size: { (): [number, number] | null; (size: [number, number]): this };

• Returns the current layout size, which defaults to [1, 1]. A layout size of null indicates that a node size will be used instead.

• Sets this cluster layout’s size to the specified [width, height] array and returns the cluster layout. The size represent an arbitrary coordinate system; for example, to produce a radial layout, a size of [360, radius] corresponds to a breadth of 360° and a depth of radius.

  Parameter size

  The specified two-element size array.

call signature

(root: HierarchyNode<Datum>): HierarchyPointNode<Datum>;

• Lays out the specified root hierarchy. You may want to call root.sort before passing the hierarchy to the cluster layout.

  Parameter root

  The specified root hierarchy.

property source

source: HierarchyCircularNode<Datum>;

• The source of the link.

property target

target: HierarchyCircularNode<Datum>;

• The target of the link.

property r

r: number;

• The radius of the circle.

property x

x: number;

• The x-coordinate of the circle’s center.

property y

y: number;

• The y-coordinate of the circle’s center.

method links

links: () => Array<HierarchyCircularLink<Datum>>;

• Returns an array of links for this node, where each link is an object that defines source and target properties. The source of each link is the parent node, and the target is a child node.

property source

source: HierarchyNode<Datum>;

• The source of the link.

property target

target: HierarchyNode<Datum>;

• The target of the link.

property children

children?: this[] | undefined;

• An array of child nodes, if any; undefined for leaf nodes.

property data

data: Datum;

• The associated data, as specified to the constructor.

property depth

readonly depth: number;

• Zero for the root node, and increasing by one for each descendant generation.

property height

readonly height: number;

• Zero for leaf nodes, and the greatest distance from any descendant leaf for internal nodes.

property id

readonly id?: string | undefined;

• Optional node id string set by StratifyOperator, if hierarchical data was created from tabular data using stratify().

property parent

parent: this | null;

• The parent node, or null for the root node.

property value

readonly value?: number | undefined;

• Aggregated numeric value as calculated by sum(value) or count(), if previously invoked.

property x

x?: number | undefined;

• The x position of this node. Set after a tree has been laid out by tree or cluster.

  const root = d3.hierarchy(datum);
  const treeLayout = d3.tree();
  treeLayout(root);
  // x and y are now set on root and its descendants

property y

y?: number | undefined;

• The y position of this node. Set after a tree has been laid out by tree or cluster.

  const root = d3.hierarchy(datum);
  const treeLayout = d3.tree();
  treeLayout(root);
  // x and y are now set on root and its descendants

method [Symbol.iterator]

[Symbol.iterator]: () => Iterator<this>;

• Returns an iterator over the node’s descendants in breadth-first order.

method ancestors

ancestors: () => this[];

• Returns the array of ancestors nodes, starting with this node, then followed by each parent up to the root.

method copy

copy: () => this;

• Return a deep copy of the subtree starting at this node. The returned deep copy shares the same data, however. The returned node is the root of a new tree; the returned node’s parent is always null and its depth is always zero.

method count

count: () => this;

• Computes the number of leaves under this node and assigns it to node.value, and similarly for every descendant of node. If this node is a leaf, its count is one. Returns this node.

method descendants

descendants: () => this[];

• Returns the array of descendant nodes, starting with this node, then followed by each child in topological order.

method each

each: <T = undefined>(
    func: (this: T, node: this, index: number, thisNode: this) => void,
    that?: T
) => this;

• Invokes the specified function for node and each descendant in breadth-first order, such that a given node is only visited if all nodes of lesser depth have already been visited, as well as all preceding nodes of the same depth.

  Parameter func

  The specified function is passed the current descendant, the zero-based traversal index, and this node.

  Parameter that

  If that is specified, it is the this context of the callback.

method eachAfter

eachAfter: <T = undefined>(
    func: (this: T, node: this, index: number, thisNode: this) => void,
    that?: T
) => this;

• Invokes the specified function for node and each descendant in post-order traversal, such that a given node is only visited after all of its descendants have already been visited.

  Parameter func

  The specified function is passed the current descendant, the zero-based traversal index, and this node.

  Parameter that

  If that is specified, it is the this context of the callback.

method eachBefore

eachBefore: <T = undefined>(
    func: (this: T, node: this, index: number, thisNode: this) => void,
    that?: T
) => this;

• Invokes the specified function for node and each descendant in pre-order traversal, such that a given node is only visited after all of its ancestors have already been visited.

  Parameter func

  The specified function is passed the current descendant, the zero-based traversal index, and this node.

  Parameter that

  If that is specified, it is the this context of the callback.

method find

find: (filter: (node: this) => boolean) => this | undefined;

• Returns the first node in the hierarchy from this node for which the specified filter returns a truthy value. undefined if no such node is found.

  Parameter filter

  Filter.

method leaves

leaves: () => this[];

• Returns the array of leaf nodes in traversal order; leaves are nodes with no children.

method links

links: () => Array<HierarchyLink<Datum>>;

• Returns an array of links for this node, where each link is an object that defines source and target properties. The source of each link is the parent node, and the target is a child node.

method path

path: (target: this) => this[];

• Returns the shortest path through the hierarchy from this node to the specified target node. The path starts at this node, ascends to the least common ancestor of this node and the target node, and then descends to the target node.

  Parameter target

  The target node.

method sort

sort: (compare: (a: this, b: this) => number) => this;

• Sorts the children of this node, if any, and each of this node’s descendants’ children, in pre-order traversal using the specified compare function, and returns this node.

  Parameter compare

  The compare function is passed two nodes a and b to compare. If a should be before b, the function must return a value less than zero; if b should be before a, the function must return a value greater than zero; otherwise, the relative order of a and b are not specified. See array.sort for more.

method sum

sum: (value: (d: Datum) => number) => this;

• Evaluates the specified value function for this node and each descendant in post-order traversal, and returns this node. The node.value property of each node is set to the numeric value returned by the specified function plus the combined value of all descendants.

  Parameter value

  The value function is passed the node’s data, and must return a non-negative number.

construct signature

new (data: Datum): this;

property source

source: HierarchyPointNode<Datum>;

• The source of the link.

property target

target: HierarchyPointNode<Datum>;

• The target of the link.

property x

x: number;

• The x-coordinate of the node.

property y

y: number;

• The y-coordinate of the node.

method links

links: () => Array<HierarchyPointLink<Datum>>;

• Returns an array of links for this node, where each link is an object that defines source and target properties. The source of each link is the parent node, and the target is a child node.

property source

source: HierarchyRectangularNode<Datum>;

• The source of the link.

property target

target: HierarchyRectangularNode<Datum>;

• The target of the link.

property x0

x0: number;

• The left edge of the rectangle.

property x1

x1: number;

• The right edge of the rectangle.

property y0

y0: number;

• The top edge of the rectangle

property y1

y1: number;

• The bottom edge of the rectangle.

method links

links: () => Array<HierarchyRectangularLink<Datum>>;

• Returns an array of links for this node, where each link is an object that defines source and target properties. The source of each link is the parent node, and the target is a child node.

property r

r: number;

• The radius of the circle.

property x

x: number;

• The x-coordinate of the circle’s center.

property y

y: number;

• The y-coordinate of the circle’s center.

method padding

padding: {
    (): (node: HierarchyCircularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyCircularNode<Datum>) => number): this;
};

• Returns the current padding accessor, which defaults to the constant zero.

• Sets this pack layout’s padding accessor to the specified number and returns this pack layout. Returns the current padding accessor, which defaults to the constant zero.

  When siblings are packed, tangent siblings will be separated by approximately the specified padding; the enclosing parent circle will also be separated from its children by approximately the specified padding. If an explicit radius is not specified, the padding is approximate because a two-pass algorithm is needed to fit within the layout size: the circles are first packed without padding; a scaling factor is computed and applied to the specified padding; and lastly the circles are re-packed with padding.

  Parameter padding

  The specified padding value.

• Sets this pack layout’s padding accessor to the specified function and returns this pack layout. Returns the current padding accessor, which defaults to the constant zero.

  When siblings are packed, tangent siblings will be separated by approximately the specified padding; the enclosing parent circle will also be separated from its children by approximately the specified padding. If an explicit radius is not specified, the padding is approximate because a two-pass algorithm is needed to fit within the layout size: the circles are first packed without padding; a scaling factor is computed and applied to the specified padding; and lastly the circles are re-packed with padding.

  Parameter padding

  The specified padding function.

method radius

radius: {
    (): (node: HierarchyCircularNode<Datum>) => number;
    (radius: (node: HierarchyCircularNode<Datum>) => number): this;
};

• Returns the current radius accessor, which defaults to null.

• Sets the pack layout’s radius accessor to the specified function and returns this pack layout. If the radius accessor is null, the radius of each leaf circle is derived from the leaf node.value (computed by node.sum); the radii are then scaled proportionally to fit the layout size. If the radius accessor is not null, the radius of each leaf circle is specified exactly by the function.

  Parameter radius

  The specified radius accessor.

method size

size: { (): [number, number]; (size: [number, number]): this };

• Returns the current size, which defaults to [1, 1].

• Sets this pack layout’s size to the specified [width, height] array and returns this pack layout.

  Parameter size

  The specified two-element size array.

call signature

(root: HierarchyNode<Datum>): HierarchyCircularNode<Datum>;

• Lays out the specified root hierarchy. You must call root.sum before passing the hierarchy to the pack layout. You probably also want to call root.sort to order the hierarchy before computing the layout.

  Parameter root

  The specified root hierarchy.

property r

r: number;

• The radius of the circle.

property x

x?: number | undefined;

• The x-coordinate of the circle’s center.

property y

y?: number | undefined;

• The y-coordinate of the circle’s center.

method padding

padding: { (): number; (padding: number): this };

• Returns the current padding, which defaults to zero.

• Sets the padding to the specified number and returns this partition layout. The padding is used to separate a node’s adjacent children.

  Parameter padding

  The specified padding value.

method round

round: { (): boolean; (round: boolean): this };

• Returns the current rounding state, which defaults to false.

• Enables or disables rounding according to the given boolean and returns this partition layout.

  Parameter round

  The specified boolean flag.

method size

size: { (): [number, number]; (size: [number, number]): this };

• Returns the current size, which defaults to [1, 1].

• Sets this partition layout’s size to the specified [width, height] array and returns this partition layout.

  Parameter size

  The specified two-element size array.

call signature

(root: HierarchyNode<Datum>): HierarchyRectangularNode<Datum>;

• Lays out the specified root hierarchy. You must call root.sum before passing the hierarchy to the partition layout. You probably also want to call root.sort to order the hierarchy before computing the layout.

  Parameter root

  The specified root hierarchy.

method ratio

ratio: (ratio: number) => RatioSquarifyTilingFactory;

• Specifies the desired aspect ratio of the generated rectangles. Note that the orientation of the generated rectangles (tall or wide) is not implied by the ratio. Furthermore, the rectangles ratio are not guaranteed to have the exact specified aspect ratio. If not specified, the aspect ratio defaults to the golden ratio, φ = (1 + sqrt(5)) / 2, per Kong et al.

  Parameter ratio

  The specified ratio value greater than or equal to one.

call signature

(
    node: HierarchyRectangularNode<any>,
    x0: number,
    y0: number,
    x1: number,
    y1: number
): void;

method id

id: {
    (): (d: Datum, i: number, data: Datum[]) => string | null | '' | undefined;
    (id: (d: Datum, i: number, data: Datum[]) => string): this;
};

• Returns the current id accessor, which defaults to: (d) => d.id.

• Sets the id accessor to the given function. The id accessor is invoked for each element in the input data passed to the stratify operator. The returned string is then used to identify the node's relationships in conjunction with the parent id. For leaf nodes, the id may be undefined, null or the empty string; otherwise, the id must be unique.

  Parameter id

  The id accessor.

method parentId

parentId: {
    (): (d: Datum, i: number, data: Datum[]) => string | null | '' | undefined;
    (parentId: (d: Datum, i: number, data: Datum[]) => string): this;
};

• Returns the current parent id accessor, which defaults to: (d) => d.parentId.

• Sets the parent id accessor to the given function. The parent id accessor is invoked for each element in the input data passed to the stratify operator. The returned string is then used to identify the node's relationships in conjunction with the id. For the root node, the parent id should be undefined, null or the empty string. There must be exactly one root node in the input data, and no circular relationships.

  Parameter parentId

  The parent id accessor.

method path

path: {
    (): (d: Datum, i: number, data: Datum[]) => string;
    (path: (d: Datum, i: number, data: Datum[]) => string): this;
};

• Returns the current path accessor, which defaults to undefined.

• If path is specified, sets the path accessor to the given function and returns this stratify operator. Otherwise, returns the current path accessor, which defaults to undefined. If a path accessor is set, the id and parentId arguments are ignored, and a unix-like hierarchy is computed on the slash-delimited strings returned by the path accessor, imputing parent nodes and ids as necessary.

  Parameter path

  The path accessor.

call signature

(data: Datum[]): HierarchyNode<Datum>;

• Generates a new hierarchy from the specified tabular data. Each node in the returned object has a shallow copy of the properties from the corresponding data object, excluding the following reserved properties: id, parentId, children.

  Parameter data

  The root specified data.

  Throws

  Error on missing id, ambiguous id, cycle, multiple roots or no root.

method nodeSize

nodeSize: { (): [number, number] | null; (size: [number, number]): this };

• Returns the current node size, which defaults to null. A node size of null indicates that a layout size will be used instead.

• Sets this tree layout’s node size to the specified [width, height] array and returns this tree layout. When a node size is specified, the root node is always positioned at <0, 0>.

  Parameter size

  The specified two-element size array.

method separation

separation: {
    (): (a: HierarchyPointNode<Datum>, b: HierarchyPointNode<Datum>) => number;
    (
        separation: (
            a: HierarchyPointNode<Datum>,
            b: HierarchyPointNode<Datum>
        ) => number
    ): this;
};

• Returns the current separation accessor, which defaults to: (a, b) => a.parent == b.parent ? 1 : 2.

• Sets the separation accessor to the specified function and returns this tree layout. The separation accessor is used to separate neighboring nodes.

  Parameter separation

  The separation function is passed two nodes a and b, and must return the desired separation. The nodes are typically siblings, though the nodes may be more distantly related if the layout decides to place such nodes adjacent.

method size

size: { (): [number, number] | null; (size: [number, number]): this };

• Returns the current layout size, which defaults to [1, 1]. A layout size of null indicates that a node size will be used instead.

• Sets this tree layout’s size to the specified [width, height] array and returns the tree layout. The size represent an arbitrary coordinate system; for example, to produce a radial layout, a size of [360, radius] corresponds to a breadth of 360° and a depth of radius.

  Parameter size

  The specified two-element size array.

call signature

(root: HierarchyNode<Datum>): HierarchyPointNode<Datum>;

• Lays out the specified root hierarchy. You may want to call root.sort before passing the hierarchy to the tree layout.

  Parameter root

  The specified root hierarchy.

method padding

padding: {
    (): (node: HierarchyRectangularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyRectangularNode<Datum>) => number): this;
};

• Returns the current inner padding function.

• Sets the inner and outer padding to the specified number and returns this treemap layout.

  Parameter padding

  The specified padding value.

• Sets the inner and outer padding to the specified function and returns this treemap layout.

  Parameter padding

  The specified padding function.

method paddingBottom

paddingBottom: {
    (): (node: HierarchyRectangularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyRectangularNode<Datum>) => number): this;
};

• Returns the current bottom padding function, which defaults to the constant zero.

• Sets the bottom padding to the specified number and returns this treemap layout. The bottom padding is used to separate the bottom edge of a node from its children.

  Parameter padding

  The specified bottom padding value.

• Sets the bottom padding to the specified function and returns this treemap layout. The function is invoked for each node with children, being passed the current node. The bottom padding is used to separate the bottom edge of a node from its children.

  Parameter padding

  The specified bottom padding function.

method paddingInner

paddingInner: {
    (): (node: HierarchyRectangularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyRectangularNode<Datum>) => number): this;
};

• Returns the current inner padding function, which defaults to the constant zero.

• Sets the inner padding to the specified number and returns this treemap layout. The inner padding is used to separate a node’s adjacent children.

  Parameter padding

  The specified inner padding value.

• Sets the inner padding to the specified function and returns this treemap layout. The function is invoked for each node with children, being passed the current node. The inner padding is used to separate a node’s adjacent children.

  Parameter padding

  The specified inner padding function.

method paddingLeft

paddingLeft: {
    (): (node: HierarchyRectangularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyRectangularNode<Datum>) => number): this;
};

• Returns the current left padding function, which defaults to the constant zero.

• Sets the left padding to the specified number and returns this treemap layout. The left padding is used to separate the left edge of a node from its children.

  Parameter padding

  The specified left padding value.

• Sets the left padding to the specified function and returns this treemap layout. The function is invoked for each node with children, being passed the current node. The left padding is used to separate the left edge of a node from its children.

  Parameter padding

  The specified left padding function.

method paddingOuter

paddingOuter: {
    (): (node: HierarchyRectangularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyRectangularNode<Datum>) => number): this;
};

• Returns the current top padding function.

• Sets the top, right, bottom and left padding to the specified function and returns this treemap layout.

  Parameter padding

  The specified padding outer value.

• Sets the top, right, bottom and left padding to the specified function and returns this treemap layout.

  Parameter padding

  The specified padding outer function.

method paddingRight

paddingRight: {
    (): (node: HierarchyRectangularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyRectangularNode<Datum>) => number): this;
};

• Returns the current right padding function, which defaults to the constant zero.

• Sets the right padding to the specified number and returns this treemap layout. The right padding is used to separate the right edge of a node from its children.

  Parameter padding

  The specified right padding value.

• Sets the right padding to the specified function and returns this treemap layout. The function is invoked for each node with children, being passed the current node. The right padding is used to separate the right edge of a node from its children.

  Parameter padding

  The specified right padding function.

method paddingTop

paddingTop: {
    (): (node: HierarchyRectangularNode<Datum>) => number;
    (padding: number): this;
    (padding: (node: HierarchyRectangularNode<Datum>) => number): this;
};

• Returns the current top padding function, which defaults to the constant zero.

• Sets the top padding to the specified number and returns this treemap layout. The top padding is used to separate the top edge of a node from its children.

  Parameter padding

  The specified top padding value.

• Sets the top padding to the specified function and returns this treemap layout. The function is invoked for each node with children, being passed the current node. The top padding is used to separate the top edge of a node from its children.

  Parameter padding

  The specified top padding function.

method round

round: { (): boolean; (round: boolean): this };

• Returns the current rounding state, which defaults to false.

• Enables or disables rounding according to the given boolean and returns this treemap layout.

  Parameter round

  The specified boolean flag.

method size

size: { (): [number, number]; (size: [number, number]): this };

• Returns the current size, which defaults to [1, 1].

• Sets this treemap layout’s size to the specified [width, height] array and returns this treemap layout.

  Parameter size

  The specified two-element size array.

method tile

tile: {
    (): (
        node: HierarchyRectangularNode<Datum>,
        x0: number,
        y0: number,
        x1: number,
        y1: number
    ) => void;
    (
        tile: (
            node: HierarchyRectangularNode<Datum>,
            x0: number,
            y0: number,
            x1: number,
            y1: number
        ) => void
    ): this;
};

• Returns the current tiling method, which defaults to d3.treemapSquarify with the golden ratio.

• Sets the tiling method to the specified function and returns this treemap layout.

  Parameter tile

  The specified tiling function.

call signature

(root: HierarchyNode<Datum>): HierarchyRectangularNode<Datum>;

• Lays out the specified root hierarchy. You must call root.sum before passing the hierarchy to the treemap layout. You probably also want to call root.sort to order the hierarchy before computing the layout.

  Parameter root

  The specified root hierarchy.