Skip to content

Instantly share code, notes, and snippets.

@vicapow

vicapow/d3_v3.x.x.x.js

Created February 8, 2019 22:16
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save vicapow/f90a539b7582dd97a58dda274147c0f0 to your computer and use it in GitHub Desktop.
Save vicapow/f90a539b7582dd97a58dda274147c0f0 to your computer and use it in GitHub Desktop.
Download ZIP
A d3 v3 Flow libdef
Raw
d3_v3.x.x.x.js
// @flow
declare module 'd3' {
declare module.exports: $Exports<'d3-es6-module'>;
}
declare module 'd3-es6-module' {
/**
* The current version of D3.js.
*/
declare export var version: string;
/**
* Find the first element that matches the given selector string.
*/
declare export function select(selector: string): Selection<any>;
/**
* Create a selection from the given node reference.
*/
declare export function select(node: EventTarget): Selection<any>;
/**
* Find all elements that match the given selector string.
*/
declare export function selectAll(selector: string): Selection<any>;
/**
* Create a selection from the given list of nodes.
*/
declare export function selectAll(nodes: EventTarget[]): Selection<any>;
/**
* Returns the root selection (as if by d3.select(document.documentElement)). This function may be used for 'instanceof' tests, and extending its prototype will add properties to all selections.
*/
declare export function selection(): Selection<any>;
/**
* Selections are grouped into arrays of nodes, with the parent tracked in the 'parentNode' property.
*/
declare export interface Group extends Array<EventTarget> {
parentNode: EventTarget;
}
declare export interface TouchList {}
declare export interface Update<Datum> {
/**
* Retrieve a grouped selection.
*/
[index: number]: Group;
/**
* The number of groups in this selection.
*/
length: number;
/**
* Retrieve the value of the given attribute for the first node in the selection.
*
* @param name The attribute name to query. May be prefixed (see d3.ns.prefix).
*/
attr(name: string): string;
/**
* For all nodes, set the attribute to the specified constant value. Use null to remove.
*
* @param name The attribute name, optionally prefixed.
* @param value The attribute value to use. Note that this is coerced to a string automatically.
*/
attr(name: string, value: Primitive): Update<Datum>;
/**
* Derive an attribute value for each node in the selection based on bound data.
*
* @param name The attribute name, optionally prefixed.
* @param value The function of the datum (the bound data item), index (the position in the subgrouping), and outer index (overall position in nested selections) which computes the attribute value. If the function returns null, the attribute is removed.
*/
attr(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => Primitive
): Update<Datum>;
/**
* Set multiple properties at once using an Object. D3 iterates over all enumerable properties and either sets or computes the attribute's value based on the corresponding entry in the Object.
*
* @param obj A key-value mapping corresponding to attributes and values. If the value is a simple string or number, it is taken as a constant. Otherwise, it is a function that derives the attribute value.
*/
attr(obj: {
[key: string]: Primitive | ((datum: Datum, index: number, outerIndex: number) => Primitive),
}): Update<Datum>;
/**
* Returns true if the first node in this selection has the given class list. If multiple classes are specified (i.e., "foo bar"), then returns true only if all classes match.
*
* @param name The class list to query.
*/
classed(name: string): boolean;
/**
* Adds (or removes) the given class list.
*
* @param name The class list to toggle. Spaces separate class names: "foo bar" is a list of two classes.
* @param value If true, add the classes. If false, remove them.
*/
classed(name: string, value: boolean): Update<Datum>;
/**
* Determine if the given class list should be toggled for each node in the selection.
*
* @param name The class list. Spaces separate multiple class names.
* @param value The function to run for each node. Should return true to add the class to the node, or false to remove it.
*/
classed(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => boolean
): Update<Datum>;
/**
* Set or derive classes for multiple class lists at once.
*
* @param obj An Object mapping class lists to values that are either plain booleans or functions that return booleans.
*/
classed(obj: {
[key: string]: boolean | ((datum: Datum, index: number, outerIndex: number) => boolean),
}): Update<Datum>;
/**
* Retrieve the computed style value for the first node in the selection.
* @param name The CSS property name to query
*/
style(name: string): string;
/**
* Set a style property for all nodes in the selection.
* @param name the CSS property name
* @param value the property value
* @param priority if specified, either null or the string "important" (no exclamation mark)
*/
style(name: string, value: Primitive, priority?: string): Update<Datum>;
/**
* Derive a property value for each node in the selection.
* @param name the CSS property name
* @param value the function to derive the value
* @param priority if specified, either null or the string "important" (no exclamation mark)
*/
style(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => Primitive,
priority?: string
): Update<Datum>;
/**
* Set a large number of CSS properties from an object.
*
* @param obj an Object whose keys correspond to CSS property names and values are either constants or functions that derive property values
* @param priority if specified, either null or the string "important" (no exclamation mark)
*/
style(
obj: {
[key: string]: Primitive | ((datum: Datum, index: number, outerIndex: number) => Primitive),
},
priority?: string
): Update<Datum>;
/**
* Retrieve an arbitrary node property such as the 'checked' property of checkboxes, or the 'value' of text boxes.
*
* @param name the node's property to retrieve
*/
property(name: string): any;
/**
* For each node, set the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__.
*
* @param name the property name
* @param value the property value
*/
property(name: string, value: any): Update<Datum>;
/**
* For each node, derive the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__.
*
* @param name the property name
* @param value the function used to derive the property's value
*/
property(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => any
): Update<Datum>;
/**
* Set multiple node properties. Caveats apply: take care not to mutate special properties like __proto__.
*
* @param obj an Object whose keys correspond to node properties and values are either constants or functions that will compute a value.
*/
property(obj: {
[key: string]: any | ((datum: Datum, index: number, outerIndex: number) => any),
}): Update<Datum>;
/**
* Retrieve the textContent of the first node in the selection.
*/
text(): string;
/**
* Set the textContent of each node in the selection.
* @param value the text to use for all nodes
*/
text(value: Primitive): Update<Datum>;
/**
* Compute the textContent of each node in the selection.
* @param value the function which will compute the text
*/
text(value: (datum: Datum, index: number, outerIndex: number) => Primitive): Update<Datum>;
/**
* Retrieve the HTML content of the first node in the selection. Uses 'innerHTML' internally and will not work with SVG or other elements without a polyfill.
*/
html(): string;
/**
* Set the HTML content of every node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill.
* @param value the HTML content to use.
*/
html(value: string): Selection<Datum>;
/**
* Compute the HTML content for each node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill.
* @param value the function to compute HTML content
*/
html(value: (datum: Datum, index: number, outerIndex: number) => string): Selection<Datum>;
/**
* Appends a new child to each node in the selection. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children.
*
* @param name the element name to append. May be prefixed (see d3.ns.prefix).
*/
append(name: string): Selection<Datum>;
/**
* Appends a new child to each node in the selection by computing a new node. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children.
*
* @param name the function to compute a new element
*/
append(name: (datum: Datum, index: number, outerIndex: number) => EventTarget): Update<Datum>;
/**
* Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the element name to append. May be prefixed (see d3.ns.prefix).
* @param before the selector to determine position (e.g., ":first-child")
*/
// https://github.com/d3/d3-3.x-api-reference/blob/master/Selections.md#insert
insert(name: string, before?: string): Update<Datum>;
/**
* Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the element name to append. May be prefixed (see d3.ns.prefix).
* @param before a function to determine the node to use as the next sibling
*/
// https://github.com/d3/d3-3.x-api-reference/blob/master/Selections.md#insert
insert(
name: string,
before?: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Update<Datum>;
/**
* Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the function to compute a new child
* @param before the selector to determine position (e.g., ":first-child")
*/
insert(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget,
before?: string
): Update<Datum>;
/**
* Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the function to compute a new child
* @param before a function to determine the node to use as the next sibling
*/
insert(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget,
before?: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Update<Datum>;
/**
* Removes the elements from the DOM. They are in a detached state and may be re-added (though there is currently no dedicated API for doing so).
*/
remove(): Update<Datum>;
/**
* Retrieves the data bound to the first group in this selection.
*/
data(): Datum[];
/**
* Binds data to this selection.
* @param data the array of data to bind to this selection
* @param key the optional function to determine the unique key for each piece of data. When unspecified, uses the index of the element.
*/
data<NewDatum>(
data: NewDatum[],
key?: (datum: NewDatum, index: number, outerIndex: number) => string
): Update<NewDatum>;
/**
* Derives data to bind to this selection.
* @param data the function to derive data. Must return an array.
* @param key the optional function to determine the unique key for each data item. When unspecified, uses the index of the element.
*/
data<NewDatum>(
data: (datum: Datum, index: number, outerIndex: number) => NewDatum[],
key?: (datum: NewDatum, index: number, outerIndex: number) => string
): Update<NewDatum>;
/**
* Filters the selection, returning only those nodes that match the given CSS selector.
* @param selector the CSS selector
*/
filter(selector: string): Update<Datum>;
/**
* Filters the selection, returning only those nodes for which the given function returned true.
* @param selector the filter function
*/
filter(selector: (datum: Datum, index: number, outerIndex: number) => boolean): Update<Datum>;
/**
* Return the data item bound to the first element in the selection.
*/
datum(): Datum;
/**
* Derive the data item for each node in the selection. Useful for situations such as the HTML5 'dataset' attribute.
* @param value the function to compute data for each node
*/
datum<NewDatum>(
value: (datum: Datum, index: number, outerIndex: number) => NewDatum
): Update<NewDatum>;
/**
* Set the data item for each node in the selection.
* @param value the constant element to use for each node
*/
datum<NewDatum>(value: NewDatum): Update<NewDatum>;
/**
* Reorders nodes in the selection based on the given comparator. Nodes are re-inserted into the document once sorted.
* @param comparator the comparison function, which defaults to d3.ascending
*/
sort(comparator?: (a: Datum, b: Datum) => number): Update<Datum>;
/**
* Reorders nodes in the document to match the selection order. More efficient than calling sort() if the selection is already ordered.
*/
order(): Update<Datum>;
/**
* Returns the listener (if any) for the given event.
* @param type the type of event to load the listener for. May have a namespace (e.g., ".foo") at the end.
*/
on(type: string): (datum: Datum, index: number, outerIndex: number) => any;
/**
* Adds a listener for the specified event. If one was already registered, it is removed before the new listener is added. The return value of the listener function is ignored.
* @param type the of event to listen to. May have a namespace (e.g., ".foo") at the end.
* @param listener an event listener function, or null to unregister
* @param capture sets the DOM useCapture flag
*/
on(
type: string,
listener: (datum: Datum, index: number, outerIndex: number) => any,
capture?: boolean
): Update<Datum>;
/**
* Begins a new transition. Interrupts any active transitions of the same name.
* @param name the transition name (defaults to "")
*/
transition(name?: string): Transition<Datum>;
/**
* Interrupts the active transition of the provided name. Does not cancel scheduled transitions.
* @param name the transition name (defaults to "")
*/
interrupt(name?: string): Update<Datum>;
/**
* Creates a subselection by finding the first descendent matching the selector string. Bound data is inherited.
* @param selector the CSS selector to match against
*/
select(selector: string): Update<Datum>;
/**
* Creates a subselection by using a function to find descendent elements. Bound data is inherited.
* @param selector the function to find matching descendants
*/
select(
selector: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Update<Datum>;
/**
* Creates a subselection by finding all descendents that match the given selector. Bound data is not inherited.
* @param selector the CSS selector to match against
*/
selectAll(selector: string): Update<Datum>;
/**
* Creates a subselection by using a function to find descendent elements. Bound data is not inherited.
* @param selector the function to find matching descendents
*/
selectAll(
selector: (
datum: Datum,
index: number,
outerIndex: number
) => Array<EventTarget> | NodeList<mixed>
): Update<any>;
/**
* Invoke the given function for each element in the selection. The return value of the function is ignored.
* @param func the function to invoke
*/
each(func: (datum: Datum, index: number, outerIndex: number) => any): Update<Datum>;
/**
* Call a function on the selection. sel.call(foo) is equivalent to foo(sel).
* @param func the function to call on the selection
* @param args any optional args
*/
call(func: (sel: Update<Datum>, ...args: any[]) => any, ...args: any[]): Update<Datum>;
/**
* Returns true if the current selection is empty.
*/
empty(): boolean;
/**
* Returns the first non-null element in the selection, or null otherwise.
*/
node(): Node;
/**
* Returns the total number of elements in the selection.
*/
size(): number;
/**
* Returns the placeholder nodes for each data element for which no corresponding DOM element was found.
*/
enter(): Enter<Datum>;
/**
* Returns a selection for those DOM nodes for which no new data element was found.
*/
exit(): Selection<Datum>;
}
declare export interface Enter<Datum> {
append(name: string): Selection<Datum>;
append(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
insert(name: string, before?: string): Selection<Datum>;
insert(
name: string,
before: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
insert(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget,
before?: string
): Selection<Datum>;
insert(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget,
before: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
select(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
call(func: (selection: Enter<Datum>, ...args: any[]) => any, ...args: any[]): Enter<Datum>;
empty(): boolean;
size(): number;
}
/**
* Administrivia: JavaScript primitive types, or "things that toString() predictably".
*/
declare export type Primitive = number | string | boolean;
/**
* Administrivia: anything with a valueOf(): number method is comparable, so we allow it in numeric operations
*/
declare export interface Numeric {
valueOf(): number;
}
/**
* A grouped array of nodes.
* @param Datum the data bound to this selection.
*/
declare export interface Selection<Datum> {
/**
* Retrieve a grouped selection.
*/
[index: number]: selection.Group;
/**
* The number of groups in this selection.
*/
length: number;
/**
* Retrieve the value of the given attribute for the first node in the selection.
*
* @param name The attribute name to query. May be prefixed (see d3.ns.prefix).
*/
attr(name: string): string;
/**
* For all nodes, set the attribute to the specified constant value. Use null to remove.
*
* @param name The attribute name, optionally prefixed.
* @param value The attribute value to use. Note that this is coerced to a string automatically.
*/
attr(name: string, value: Primitive): Selection<Datum>;
/**
* Derive an attribute value for each node in the selection based on bound data.
*
* @param name The attribute name, optionally prefixed.
* @param value The function of the datum (the bound data item), index (the position in the subgrouping), and outer index (overall position in nested selections) which computes the attribute value. If the function returns null, the attribute is removed.
*/
attr(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => Primitive
): Selection<Datum>;
/**
* Set multiple properties at once using an Object. D3 iterates over all enumerable properties and either sets or computes the attribute's value based on the corresponding entry in the Object.
*
* @param obj A key-value mapping corresponding to attributes and values. If the value is a simple string or number, it is taken as a constant. Otherwise, it is a function that derives the attribute value.
*/
attr(obj: {
[key: string]: Primitive | ((datum: Datum, index: number, outerIndex: number) => Primitive),
}): Selection<Datum>;
/**
* Returns true if the first node in this selection has the given class list. If multiple classes are specified (i.e., "foo bar"), then returns true only if all classes match.
*
* @param name The class list to query.
*/
classed(name: string): boolean;
/**
* Adds (or removes) the given class list.
*
* @param name The class list to toggle. Spaces separate class names: "foo bar" is a list of two classes.
* @param value If true, add the classes. If false, remove them.
*/
classed(name: string, value: boolean): Selection<Datum>;
/**
* Determine if the given class list should be toggled for each node in the selection.
*
* @param name The class list. Spaces separate multiple class names.
* @param value The function to run for each node. Should return true to add the class to the node, or false to remove it.
*/
classed(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => boolean
): Selection<Datum>;
/**
* Set or derive classes for multiple class lists at once.
*
* @param obj An Object mapping class lists to values that are either plain booleans or functions that return booleans.
*/
classed(obj: {
[key: string]: boolean | ((datum: Datum, index: number, outerIndex: number) => boolean),
}): Selection<Datum>;
/**
* Retrieve the computed style value for the first node in the selection.
* @param name The CSS property name to query
*/
style(name: string): string;
/**
* Set a style property for all nodes in the selection.
* @param name the CSS property name
* @param value the property value
* @param priority if specified, either null or the string "important" (no exclamation mark)
*/
style(name: string, value: Primitive, priority?: string): Selection<Datum>;
/**
* Derive a property value for each node in the selection.
* @param name the CSS property name
* @param value the function to derive the value
* @param priority if specified, either null or the string "important" (no exclamation mark)
*/
style(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => Primitive,
priority?: string
): Selection<Datum>;
/**
* Set a large number of CSS properties from an object.
*
* @param obj an Object whose keys correspond to CSS property names and values are either constants or functions that derive property values
* @param priority if specified, either null or the string "important" (no exclamation mark)
*/
style(
obj: {
[key: string]: Primitive | ((datum: Datum, index: number, outerIndex: number) => Primitive),
},
priority?: string
): Selection<Datum>;
/**
* Retrieve an arbitrary node property such as the 'checked' property of checkboxes, or the 'value' of text boxes.
*
* @param name the node's property to retrieve
*/
property(name: string): any;
/**
* For each node, set the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__.
*
* @param name the property name
* @param value the property value
*/
property(name: string, value: any): Selection<Datum>;
/**
* For each node, derive the property value. Internally, this sets the node property directly (e.g., node[name] = value), so take care not to mutate special properties like __proto__.
*
* @param name the property name
* @param value the function used to derive the property's value
*/
property(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => any
): Selection<Datum>;
/**
* Set multiple node properties. Caveats apply: take care not to mutate special properties like __proto__.
*
* @param obj an Object whose keys correspond to node properties and values are either constants or functions that will compute a value.
*/
property(obj: {
[key: string]: any | ((datum: Datum, index: number, innerInder: number) => any),
}): Selection<Datum>;
/**
* Retrieve the textContent of the first node in the selection.
*/
text(): string;
/**
* Set the textContent of each node in the selection.
* @param value the text to use for all nodes
*/
text(value: Primitive): Selection<Datum>;
/**
* Compute the textContent of each node in the selection.
* @param value the function which will compute the text
*/
text(value: (datum: Datum, index: number, outerIndex: number) => Primitive): Selection<Datum>;
/**
* Retrieve the HTML content of the first node in the selection. Uses 'innerHTML' internally and will not work with SVG or other elements without a polyfill.
*/
html(): string;
/**
* Set the HTML content of every node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill.
* @param value the HTML content to use.
*/
html(value: string): Selection<Datum>;
/**
* Compute the HTML content for each node in the selection. Uses 'innerHTML' internally and thus will not work with SVG or other elements without a polyfill.
* @param value the function to compute HTML content
*/
html(value: (datum: Datum, index: number, outerIndex: number) => string): Selection<Datum>;
/**
* Appends a new child to each node in the selection. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children.
*
* @param name the element name to append. May be prefixed (see d3.ns.prefix).
*/
append(name: string): Selection<Datum>;
/**
* Appends a new child to each node in the selection by computing a new node. This child will inherit the parent's data (if available). Returns a fresh selection consisting of the newly-appended children.
*
* @param name the function to compute a new element
*/
append(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
/**
* Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the element name to append. May be prefixed (see d3.ns.prefix).
* @param before the selector to determine position (e.g., ":first-child")
*/
insert(name: string, before?: string): Selection<Datum>;
/**
* Inserts a new child to each node in the selection. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the element name to append. May be prefixed (see d3.ns.prefix).
* @param before a function to determine the node to use as the next sibling
*/
insert(
name: string,
before?: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
/**
* Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the function to compute a new child
* @param before the selector to determine position (e.g., ":first-child")
*/
insert(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget,
before?: string
): Selection<Datum>;
/**
* Inserts a new child to the end of each node in the selection by computing a new node. This child will inherit its parent's data (if available). Returns a fresh selection consisting of the newly-inserted children.
* @param name the function to compute a new child
* @param before a function to determine the node to use as the next sibling
*/
insert(
name: (datum: Datum, index: number, outerIndex: number) => EventTarget,
before?: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
/**
* Removes the elements from the DOM. They are in a detached state and may be re-added (though there is currently no dedicated API for doing so).
*/
remove(): Selection<Datum>;
/**
* Retrieves the data bound to the first group in this selection.
*/
data(): Datum[];
/**
* Binds data to this selection.
* @param data the array of data to bind to this selection
* @param key the optional function to determine the unique key for each piece of data. When unspecified, uses the index of the element.
*/
data<NewDatum>(
data: NewDatum[],
key?: (datum: NewDatum, index: number, outerIndex: number) => string
): selection.Update<NewDatum>;
/**
* Derives data to bind to this selection.
* @param data the function to derive data. Must return an array.
* @param key the optional function to determine the unique key for each data item. When unspecified, uses the index of the element.
*/
data<NewDatum>(
data: (datum: Datum, index: number, outerIndex: number) => NewDatum[],
key?: (datum: NewDatum, index: number, outerIndex: number) => string
): selection.Update<NewDatum>;
/**
* Filters the selection, returning only those nodes that match the given CSS selector.
* @param selector the CSS selector
*/
filter(selector: string): Selection<Datum>;
/**
* Filters the selection, returning only those nodes for which the given function returned true.
* @param selector the filter function
*/
filter(
selector: (datum: Datum, index: number, outerIndex: number) => boolean
): Selection<Datum>;
/**
* Return the data item bound to the first element in the selection.
*/
datum(): Datum;
/**
* Derive the data item for each node in the selection. Useful for situations such as the HTML5 'dataset' attribute.
* @param value the function to compute data for each node
*/
datum<NewDatum>(
value: (datum: Datum, index: number, outerIndex: number) => NewDatum
): Selection<NewDatum>;
/**
* Set the data item for each node in the selection.
* @param value the constant element to use for each node
*/
datum<NewDatum>(value: NewDatum): Selection<NewDatum>;
/**
* Reorders nodes in the selection based on the given comparator. Nodes are re-inserted into the document once sorted.
* @param comparator the comparison function, which defaults to d3.ascending
*/
sort(comparator?: (a: Datum, b: Datum) => number): Selection<Datum>;
/**
* Reorders nodes in the document to match the selection order. More efficient than calling sort() if the selection is already ordered.
*/
order(): Selection<Datum>;
/**
* Returns the listener (if any) for the given event.
* @param type the type of event to load the listener for. May have a namespace (e.g., ".foo") at the end.
*/
on(type: string): (datum: Datum, index: number, outerIndex: number) => any;
/**
* Adds a listener for the specified event. If one was already registered, it is removed before the new listener is added. The return value of the listener function is ignored.
* @param type the of event to listen to. May have a namespace (e.g., ".foo") at the end.
* @param listener an event listener function, or null to unregister
* @param capture sets the DOM useCapture flag
*/
on(
type: string,
listener: (datum: Datum, index: number, outerIndex: number) => any,
capture?: boolean
): Selection<Datum>;
/**
* Begins a new transition. Interrupts any active transitions of the same name.
* @param name the transition name (defaults to "")
*/
transition(name?: string): Transition<Datum>;
/**
* Interrupts the active transition of the provided name. Does not cancel scheduled transitions.
* @param name the transition name (defaults to "")
*/
interrupt(name?: string): Selection<Datum>;
/**
* Creates a subselection by finding the first descendent matching the selector string. Bound data is inherited.
* @param selector the CSS selector to match against
*/
select(selector: string): Selection<Datum>;
/**
* Creates a subselection by using a function to find descendent elements. Bound data is inherited.
* @param selector the function to find matching descendants
*/
select(
selector: (datum: Datum, index: number, outerIndex: number) => EventTarget
): Selection<Datum>;
/**
* Creates a subselection by finding all descendents that match the given selector. Bound data is not inherited.
* @param selector the CSS selector to match against
*/
selectAll(selector: string): Selection<any>;
/**
* Creates a subselection by finding all descendants that match the given selector. Bound data is not inherited.
*
* Use this overload when data-binding a subselection (that is, sel.selectAll('.foo').data(d => ...)). The type will carry over.
*/
selectAll<T>(selector: string): Selection<T>;
/**
* Creates a subselection by using a function to find descendent elements. Bound data is not inherited.
* @param selector the function to find matching descendents
*/
selectAll(
selector: (
datum: Datum,
index: number,
outerIndex: number
) => Array<EventTarget> | NodeList<mixed>
): Selection<any>;
/**
* Creates a subselection by using a function to find descendent elements. Bound data is not inherited.
*
* Use this overload when data-binding a subselection (that is, sel.selectAll('.foo').data(d => ...)). The type will carry over.
* @param selector the function to find matching descendents
*/
selectAll<T>(
selector: (
datum: Datum,
index: number,
outerIndex: number
) => Array<EventTarget> | NodeList<mixed>
): Selection<T>;
/**
* Invoke the given function for each element in the selection. The return value of the function is ignored.
* @param func the function to invoke
*/
each(func: (datum: Datum, index: number, outerIndex: number) => any): Selection<Datum>;
/**
* Call a function on the selection. sel.call(foo) is equivalent to foo(sel).
* @param func the function to call on the selection
* @param args any optional args
*/
call(func: (sel: Selection<Datum>, ...args: any[]) => any, ...args: any[]): Selection<Datum>;
/**
* Returns true if the current selection is empty.
*/
empty(): boolean;
/**
* Returns the first non-null element in the selection, or null otherwise.
*/
node(): Node;
/**
* Returns the total number of elements in the selection.
*/
size(): number;
}
declare export function transition(): Transition<any>;
declare export interface Transition<Datum> {
transition(): Transition<Datum>;
delay(): number;
delay(delay: number): Transition<Datum>;
delay(delay: (datum: Datum, index: number, outerIndex: number) => number): Transition<Datum>;
duration(): number;
duration(duration: number): Transition<Datum>;
duration(
duration: (datum: Datum, index: number, outerIndex: number) => number
): Transition<Datum>;
ease(): (t: number) => number;
ease(value: string, ...args: any[]): Transition<Datum>;
ease(value: (t: number) => number): Transition<Datum>;
attr(name: string, value: Primitive): Transition<Datum>;
attr(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => Primitive
): Transition<Datum>;
attr(obj: {
[key: string]: Primitive | ((datum: Datum, index: number, outerIndex: number) => Primitive),
}): Transition<Datum>;
attrTween(
name: string,
tween: (datum: Datum, index: number, attr: string) => (t: number) => Primitive
): Transition<Datum>;
style(name: string, value: Primitive, priority?: string): Transition<Datum>;
style(
name: string,
value: (datum: Datum, index: number, outerIndex: number) => Primitive,
priority?: string
): Transition<Datum>;
style(
obj: {
[key: string]: Primitive | ((datum: Datum, index: number, outerIndex: number) => Primitive),
},
priority?: string
): Transition<Datum>;
styleTween(
name: string,
tween: (datum: Datum, index: number, attr: string) => (t: number) => Primitive,
priority?: string
): Transition<Datum>;
text(value: Primitive): Transition<Datum>;
text(value: (datum: Datum, index: number, outerIndex: number) => Primitive): Transition<Datum>;
tween(name: string, factory: () => (t: number) => any): Transition<Datum>;
remove(): Transition<Datum>;
select(selector: string): Transition<Datum>;
select(selector: (d: Datum, i: number) => EventTarget): Transition<Datum>;
selectAll(selector: string): Transition<any>;
selectAll(selector: (d: Datum, i: number) => EventTarget[]): Transition<any>;
filter(selector: string): Transition<Datum>;
filter(selector: (d: Datum, i: number) => boolean): Transition<Datum>;
each(type: string, listener: (d: Datum, i: number) => any): Transition<Datum>;
each(listener: (d: Datum, i: number) => any): Transition<Datum>;
call(
func: (transition: Transition<Datum>, ...args: any[]) => any,
...args: any[]
): Transition<Datum>;
empty(): boolean;
node(): Node;
size(): number;
}
declare export function ease(type: 'linear'): (t: number) => number;
declare export function ease(type: 'linear-in'): (t: number) => number;
declare export function ease(type: 'linear-out'): (t: number) => number;
declare export function ease(type: 'linear-in-out'): (t: number) => number;
declare export function ease(type: 'linear-out-in'): (t: number) => number;
declare export function ease(type: 'poly', k: number): (t: number) => number;
declare export function ease(type: 'poly-in', k: number): (t: number) => number;
declare export function ease(type: 'poly-out', k: number): (t: number) => number;
declare export function ease(type: 'poly-in-out', k: number): (t: number) => number;
declare export function ease(type: 'poly-out-in', k: number): (t: number) => number;
declare export function ease(type: 'quad'): (t: number) => number;
declare export function ease(type: 'quad-in'): (t: number) => number;
declare export function ease(type: 'quad-out'): (t: number) => number;
declare export function ease(type: 'quad-in-out'): (t: number) => number;
declare export function ease(type: 'quad-out-in'): (t: number) => number;
declare export function ease(type: 'cubic'): (t: number) => number;
declare export function ease(type: 'cubic-in'): (t: number) => number;
declare export function ease(type: 'cubic-out'): (t: number) => number;
declare export function ease(type: 'cubic-in-out'): (t: number) => number;
declare export function ease(type: 'cubic-out-in'): (t: number) => number;
declare export function ease(type: 'sin'): (t: number) => number;
declare export function ease(type: 'sin-in'): (t: number) => number;
declare export function ease(type: 'sin-out'): (t: number) => number;
declare export function ease(type: 'sin-in-out'): (t: number) => number;
declare export function ease(type: 'sin-out-in'): (t: number) => number;
declare export function ease(type: 'circle'): (t: number) => number;
declare export function ease(type: 'circle-in'): (t: number) => number;
declare export function ease(type: 'circle-out'): (t: number) => number;
declare export function ease(type: 'circle-in-out'): (t: number) => number;
declare export function ease(type: 'circle-out-in'): (t: number) => number;
declare export function ease(type: 'elastic', a?: number, b?: number): (t: number) => number;
declare export function ease(type: 'elastic-in', a?: number, b?: number): (t: number) => number;
declare export function ease(type: 'elastic-out', a?: number, b?: number): (t: number) => number;
declare export function ease(
type: 'elastic-in-out',
a?: number,
b?: number
): (t: number) => number;
declare export function ease(
type: 'elastic-out-in',
a?: number,
b?: number
): (t: number) => number;
declare export function ease(type: 'back', s: number): (t: number) => number;
declare export function ease(type: 'back-in', s: number): (t: number) => number;
declare export function ease(type: 'back-out', s: number): (t: number) => number;
declare export function ease(type: 'back-in-out', s: number): (t: number) => number;
declare export function ease(type: 'back-out-in', s: number): (t: number) => number;
declare export function ease(type: 'bounce'): (t: number) => number;
declare export function ease(type: 'bounce-in'): (t: number) => number;
declare export function ease(type: 'bounce-out'): (t: number) => number;
declare export function ease(type: 'bounce-in-out'): (t: number) => number;
declare export function ease(type: 'bounce-out-in'): (t: number) => number;
declare export function ease(type: string, ...args: any[]): (t: number) => number;
declare export interface Timer {
(func: () => any, delay?: number, time?: number): void;
flush(): void;
}
declare export var timer: Timer;
declare export interface BaseEvent {
type: string;
sourceEvent?: Event;
}
/**
* Define a D3-specific ZoomEvent per https://github.com/mbostock/d3/wiki/Zoom-Behavior#event
*/
declare export interface ZoomEvent extends BaseEvent {
scale: number;
translate: [number, number];
}
/**
* Define a D3-specific DragEvent per https://github.com/mbostock/d3/wiki/Drag-Behavior#on
*/
declare export interface DragEvent extends BaseEvent {
x: number;
y: number;
dx: number;
dy: number;
}
/**
* The current event's value. Use this variable in a handler registered with `selection.on`.
*/
declare export var event: Event | BaseEvent;
/**
* Returns the x and y coordinates of the mouse relative to the provided container element, using d3.event for the mouse's position on the page.
* @param container the container element (e.g. an SVG <g> element)
*/
declare export function mouse(container: EventTarget): [number, number];
/**
* Given a container element and a touch identifier, determine the x and y coordinates of the touch.
* @param container the container element (e.g., an SVG <svg> element)
* @param identifier the given touch identifier
*/
declare export function touch(container: EventTarget, identifer: number): [number, number];
/**
* Given a container element, a list of touches, and a touch identifier, determine the x and y coordinates of the touch.
* @param container the container element (e.g., an SVG <svg> element)
* @param identifier the given touch identifier
*/
declare export function touch(
container: EventTarget,
touches: TouchList,
identifer: number
): [number, number];
/**
* Given a container element and an optional list of touches, return the position of every touch relative to the container.
* @param container the container element
* @param touches an optional list of touches (defaults to d3.event.touches)
*/
declare export function touches(
container: EventTarget,
touches?: TouchList
): Array<[number, number]>;
// NB. this is limited to primitive values due to D3's use of the <, >, and >= operators. Results get weird for object instances.
/**
* Compares two primitive values for sorting (in ascending order).
*/
declare export function ascending(a: Primitive, b: Primitive): number;
/**
* Compares two primitive values for sorting (in ascending order).
*/
declare export function descending(a: Primitive, b: Primitive): number;
/**
* Return the minimum value in the array using natural order.
*/
declare export function min(array: number[]): number;
/**
* Return the minimum value in the array using natural order.
*/
declare export function min(array: string[]): string;
/**
* Return the minimum value in the array using natural order.
*/
declare export function min<T: Numeric>(array: T[]): T;
/**
* Return the minimum value in the array using natural order.
*/
declare export function min<T>(array: T[], accessor: (datum: T, index: number) => number): number;
/**
* Return the minimum value in the array using natural order.
*/
declare export function min<T>(array: T[], accessor: (datum: T, index: number) => string): string;
/**
* Return the minimum value in the array using natural order.
*/
declare export function min<T, U: Numeric>(
array: T[],
accessor: (datum: T, index: number) => U
): U;
/**
* Return the maximum value in the array of numbers using natural order.
*/
declare export function max(array: number[]): number;
/**
* Return the maximum value in the array of strings using natural order.
*/
declare export function max(array: string[]): string;
/**
* Return the maximum value in the array of numbers using natural order.
*/
declare export function max<T: Numeric>(array: T[]): T;
/**
* Return the maximum value in the array using natural order and a projection function to map values to numbers.
*/
declare export function max<T>(array: T[], accessor: (datum: T, index: number) => number): number;
/**
* Return the maximum value in the array using natural order and a projection function to map values to strings.
*/
declare export function max<T>(array: T[], accessor: (datum: T, index: number) => string): string;
/**
* Return the maximum value in the array using natural order and a projection function to map values to easily-sorted values.
*/
declare export function max<T, U: Numeric>(array: T[], accessor: (datum: T, index: number) => U): U;
/**
* Return the min and max simultaneously.
*/
declare export function extent(array: number[]): [number, number];
/**
* Return the min and max simultaneously.
*/
declare export function extent(array: string[]): [string, string];
/**
* Return the min and max simultaneously.
*/
declare export function extent<T: Numeric>(array: T[]): [T, T];
/**
* Return the min and max simultaneously.
*/
declare export function extent<T: Numeric>(array: Array<T | Primitive>): [T | Primitive, T | Primitive];
/**
* Return the min and max simultaneously.
*/
declare export function extent<T>(
array: T[],
accessor: (datum: T, index: number) => number
): [number, number];
/**
* Return the min and max simultaneously.
*/
declare export function extent<T>(
array: T[],
accessor: (datum: T, index: number) => string
): [string, string];
/**
* Return the min and max simultaneously.
*/
declare export function extent<T>(
array: T[],
accessor: (datum: T, index: number) => Date
): [Date, Date];
/**
* Return the min and max simultaneously.
*/
declare export function extent<T, U: Numeric>(
array: T[],
accessor: (datum: T, index: number) => U
): [U | Primitive, U | Primitive];
/**
* Compute the sum of an array of numbers.
*/
declare export function sum(array: number[]): number;
/**
* Compute the sum of an array, using the given accessor to convert values to numbers.
*/
declare export function sum<T>(array: T[], accessor: (datum: T, index: number) => number): number;
declare export function mean(array: number[]): number;
declare export function mean<T>(
array: T[],
accessor: (datum: T, index: number) => number
): number;
/**
* Compute the median of an array of numbers (the 0.5-quantile).
*/
declare export function median(array: number[]): number;
declare export function median<T>(
datum: T[],
accessor: (datum: T, index: number) => number
): number;
declare export function quantile(array: number[], p: number): number;
declare export function variance(array: number[]): number;
declare export function variance<T>(
array: T[],
accessor: (datum: T, index: number) => number
): number;
declare export function deviation(array: number[]): number;
declare export function deviation<T>(
array: T[],
accessor: (datum: T, index: number) => number
): number;
declare export function bisectLeft<T>(array: T[], x: T, lo?: number, hi?: number): number;
declare export var bisect: typeof bisectRight;
declare export function bisectRight<T>(array: T[], x: T, lo?: number, hi?: number): number;
declare export function bisector<T, U>(
accessor: (x: T) => U
): {
left: (array: T[], x: U, lo?: number, hi?: number) => number,
right: (array: T[], x: U, lo?: number, hi?: number) => number,
};
declare export function bisector<T, U>(
comparator: (a: T, b: U) => number
): {
left: (array: T[], x: U, lo?: number, hi?: number) => number,
right: (array: T[], x: U, lo?: number, hi?: number) => number,
};
declare export function shuffle<T>(array: T[], lo?: number, hi?: number): T[];
/**
* Returns the enumerable property names of the specified object.
* @param object a JavaScript object
*/
declare export function keys(object: { [key: string]: mixed }): string[];
/**
* Returns an array containing the property values of the specified object.
*/
declare export function values<T>(object: { [key: string]: T }): T[];
/**
* Returns an array containing the property values of the specified object.
*/
declare export function values<T>(object: { [key: number]: T }): T[];
/**
* Returns an array containing the property values of the specified object.
*/
declare export function values(object: { [key: string]: any }): any[];
/**
* Returns an array of key-value pairs containing the property values of the specified object.
*/
declare export function entries<T>(object: { [key: string]: T }): { key: string, value: T }[];
/**
* Returns an array of key-value pairs containing the property values of the specified object.
*/
declare export function entries<T>(object: { [key: number]: T }): { key: string, value: T }[];
/**
* Returns an array of key-value pairs containing the property values of the specified object.
*/
declare export function entries(object: { [key: string]: any }): { key: string, value: any }[];
/**
* A shim for ES6 maps. The implementation uses a JavaScript object internally, and thus keys are limited to strings.
*/
declare export interface Map<T> {
/**
* Does the map contain the given key?
*/
has(key: string): boolean;
/**
* Retrieve the value for the given key. Returns undefined if there is no value stored.
*/
get(key: string): T;
/**
* Set the value for the given key. Returns the new value.
*/
set(key: string, value: T): T;
/**
* Remove the value for the given key. Returns true if there was a value and false otherwise.
*/
remove(key: string): boolean;
/**
* Returns an array of all keys in arbitrary order.
*/
keys(): string[];
/**
* Returns an array of all values in arbitrary order.
*/
values(): T[];
/**
* Returns an array of key-value objects in arbitrary order.
*/
entries(): { key: string, value: T }[];
/**
* Calls the function for each key and value pair in the map. The 'this' context is the map itself.
*/
forEach(func: (key: string, value: T) => any): void;
/**
* Is this map empty?
*/
empty(): boolean;
/**
* Returns the number of elements stored in the map.
*/
size(): number;
}
/**
* Constructs an initially empty map.
*/
declare export function map<T>(): Map<T>;
/**
* Construct a new map by copying keys and values from the given one.
*/
declare export function map<T>(object: Map<T>): Map<T>;
/**
* Construct a new map by copying enumerable properties and values from the given object.
*/
declare export function map<T>(object: { [key: string]: T }): Map<T>;
/**
* Construct a new map by copying enumerable properties and values from the given object.
*/
declare export function map<T>(object: { [key: number]: T }): Map<T>;
/**
* Construct a new map by copying elements from the array. The key function is used to identify each object.
*/
declare export function map<T>(array: T[], key: (datum: T, index: number) => string): Map<T>;
/**
* Construct a new map by copying enumerable properties and values from the given object.
*/
declare export function map(object: { [key: string]: any }): Map<any>;
/**
* A shim for ES6 sets. Is only able to store strings.
*/
declare export interface Set {
/**
* Is the given string stored in this set?
*/
has(value: string): boolean;
/**
* Add the string to this set. Returns the value.
*/
add(value: string): string;
/**
* Remove the given value from the set. Returns true if it was stored, and false otherwise.
*/
remove(value: string): boolean;
/**
* Returns an array of the strings stored in this set.
*/
values(): string[];
/**
* Calls a given function for each value in the set. The return value of the function is ignored. The this context of the function is the set itself.
*/
forEach(func: (value: string) => any): void;
/**
* Is this set empty?
*/
empty(): boolean;
/**
* Returns the number of values stored in this set.
*/
size(): number;
}
/**
* Creates an initially-empty set.
*/
declare export function set(): Set;
/**
* Initializes a set from the given array of strings.
*/
declare export function set(array: string[]): Set;
/**
* Merges the specified arrays into a single array.
*/
declare export function merge<T>(arrays: T[][]): T[];
/**
* Generates a 0-based numeric sequence. The output range does not include 'stop'.
*/
declare export function range(stop: number): number[];
/**
* Generates a numeric sequence starting from the given start and stop values. 'step' defaults to 1. The output range does not include 'stop'.
*/
declare export function range(start: number, stop: number, step?: number): number[];
/**
* Given the specified array, return an array corresponding to the list of indices in 'keys'.
*/
declare export function permute<T>(array: { [key: number]: T }, keys: number[]): T[];
/**
* Given the specified object, return an array corresponding to the list of property names in 'keys'.
*/
declare export function permute<T>(object: { [key: string]: T }, keys: string[]): T[];
// TODO construct n-tuples from n input arrays
declare export function zip<T>(...arrays: T[][]): T[][];
declare export function transpose<T>(matrix: T[][]): T[][];
/**
* For each adjacent pair of elements in the specified array, returns a new array of tuples of elements i and i - 1.
* Returns the empty array if the input array has fewer than two elements.
*/
declare export function pairs<T>(array: T[]): Array<[T, T]>;
declare export interface Nest<T> {
key(func: (datum: T) => string): Nest<T>;
sortKeys(comparator: (a: string, b: string) => number): Nest<T>;
sortValues(comparator: (a: T, b: T) => number): Nest<T>;
rollup<U>(func: (values: T[]) => U): Nest<T>;
map(array: T[]): { [key: string]: any };
map(array: T[], mapType: typeof map): Map<any>;
entries(array: T[]): { key: string, values: any }[];
}
declare export function nest<T>(): Nest<T>;
declare export var random: {
normal(mean?: number, deviation?: number): () => number,
logNormal(mean?: number, deviation?: number): () => number,
bates(count: number): () => number,
irwinHall(count: number): () => number,
};
declare export interface Transform {
rotate: number;
translate: [number, number];
skew: number;
scale: [number, number];
toString(): string;
}
declare export function transform(transform: string): Transform;
declare export function format(specifier: string): (n: number) => string;
declare export interface FormatPrefix {
symbol: string;
scale(n: number): number;
}
declare export function formatPrefix(value: number, precision?: number): FormatPrefix;
declare export function round(x: number, n?: number): number;
declare export function requote(string: string): string;
declare export var rgb: {
new(r: number, g: number, b: number): Rgb,
new(color: string): Rgb,
(r: number, g: number, b: number): Rgb,
(color: string): Rgb,
};
declare export interface Rgb extends Color {
r: number;
g: number;
b: number;
brighter(k?: number): Rgb;
darker(k?: number): Rgb;
hsl(): Hsl;
toString(): string;
}
declare export var hsl: {
new(h: number, s: number, l: number): Hsl,
new(color: string): Hsl,
(h: number, s: number, l: number): Hsl,
(color: string): Hsl,
};
declare export interface Hsl extends Color {
h: number;
s: number;
l: number;
brighter(k?: number): Hsl;
darker(k?: number): Hsl;
toString(): string;
}
declare export var hcl: {
new(h: number, c: number, l: number): Hcl,
new(color: string): Hcl,
(h: number, c: number, l: number): Hcl,
(color: string): Hcl,
};
declare export interface Hcl extends Color {
h: number;
c: number;
l: number;
brighter(k?: number): Hcl;
darker(k?: number): Hcl;
}
declare export var lab: {
new(l: number, a: number, b: number): Lab,
new(color: string): Lab,
(l: number, a: number, b: number): Lab,
(color: string): Lab,
};
declare export interface Lab extends Color {
l: number;
a: number;
b: number;
brighter(k?: number): Lab;
darker(k?: number): Lab;
toString(): string;
}
declare export var color: {
(): Color,
new(): Color,
};
declare export interface Color {
rgb(): Rgb;
}
declare export interface Qualified {
space: string;
local: string;
}
declare export var ns: {
prefix: { [key: string]: string },
qualify: (name: string) => Qualified | string,
};
declare export function functor<T: (...args: Array<any>) => any>(value: T): T;
declare export function functor<T>(value: T): () => T;
declare export function rebind(target: {}, source: {}, ...names: string[]): any;
declare export function dispatch(...names: string[]): Dispatch;
declare export interface Dispatch {
on(type: string): (...args: any[]) => void;
on(type: string, listener: (...args: any[]) => any): Dispatch;
[event: string]: (...args: any[]) => void;
}
declare export interface Identity {
(n: number): number;
invert(n: number): number;
domain(): number[];
domain(numbers: number[]): Identity;
range(): number[];
range(numbers: number[]): Identity;
ticks(count?: number): number[];
tickFormat(count?: number, format?: string): (n: number) => string;
copy(): Identity;
}
declare export interface Linear<Range, Output> {
(x: number): Output;
invert(y: number): number;
domain(): number[];
domain(numbers: number[]): Linear<Range, Output>;
range(): Range[];
range(values: Range[]): Linear<Range, Output>;
rangeRound(values: number[]): Linear<number, number>;
interpolate(): (a: Range, b: Range) => (t: number) => Output;
interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Linear<Range, Output>;
clamp(): boolean;
clamp(clamp: boolean): Linear<Range, Output>;
nice(count?: number): Linear<Range, Output>;
ticks(count?: number): number[];
tickFormat(count?: number, format?: string): (n: number) => string;
copy(): Linear<Range, Output>;
}
declare export interface Pow<Range, Output> {
(x: number): Output;
invert(y: number): number;
domain(): number[];
domain(numbers: number[]): Pow<Range, Output>;
range(): Range[];
range(values: Range[]): Pow<Range, Output>;
rangeRound(values: number[]): Pow<number, number>;
exponent(): number;
exponent(k: number): Pow<Range, Output>;
interpolate(): (a: Range, b: Range) => (t: number) => Output;
interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Pow<Range, Output>;
clamp(): boolean;
clamp(clamp: boolean): Pow<Range, Output>;
nice(m?: number): Pow<Range, Output>;
ticks(count?: number): number[];
tickFormat(count?: number, format?: string): (n: number) => string;
copy(): Pow<Range, Output>;
}
declare export interface Log<Range, Output> {
(x: number): Output;
invert(y: number): number;
domain(): number[];
domain(numbers: number[]): Log<Range, Output>;
range(): Range[];
range(values: Range[]): Log<Range, Output>;
rangeRound(values: number[]): Log<number, number>;
base(): number;
base(base: number): Log<Range, Output>;
interpolate(): (a: Range, b: Range) => (t: number) => Output;
interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Log<Range, Output>;
clamp(): boolean;
clamp(clamp: boolean): Log<Range, Output>;
nice(): Log<Range, Output>;
ticks(): number[];
tickFormat(count?: number, format?: string): (t: number) => string;
copy(): Log<Range, Output>;
}
declare export interface Quantize<T> {
(x: number): T;
invertExtent(y: T): [number, number];
domain(): number[];
domain(numbers: number[]): Quantize<T>;
range(): T[];
range(values: T[]): Quantize<T>;
copy(): Quantize<T>;
}
declare export interface Quantile<T> {
(x: number): T;
invertExtent(y: T): [number, number];
domain(): number[];
domain(numbers: number[]): Quantile<T>;
range(): T[];
range(values: T[]): Quantile<T>;
quantiles(): number[];
copy(): Quantile<T>;
}
declare export interface Threshold<Domain, Range> {
(x: number): Range;
invertExtent(y: Range): [Domain, Domain];
domain(): Domain[];
domain(domain: Domain[]): Threshold<Domain, Range>;
range(): Range[];
range(values: Range[]): Threshold<Domain, Range>;
copy(): Threshold<Domain, Range>;
}
declare export interface Ordinal<Domain: { toString(): string }, Range> {
(x: Domain): Range;
domain(): Domain[];
domain(values: Domain[]): Ordinal<Domain, Range>;
range(): Range[];
range(values: Range[]): Ordinal<Domain, Range>;
rangePoints(interval: [number, number], padding?: number): Ordinal<Domain, number>;
rangeRoundPoints(interval: [number, number], padding?: number): Ordinal<Domain, number>;
rangeBands(
interval: [number, number],
padding?: number,
outerPadding?: number
): Ordinal<Domain, number>;
rangeRoundBands(
interval: [number, number],
padding?: number,
outerPadding?: number
): Ordinal<Domain, number>;
rangeBand(): number;
rangeExtent(): [number, number];
copy(): Ordinal<Domain, Range>;
}
declare export var scale: {
identity(): Identity,
linear(): Linear<number, number>,
linear<Output>(): Linear<Output, Output>,
linear<Range, Output>(): Linear<Range, Output>,
sqrt(): Pow<number, number>,
sqrt<Output>(): Pow<Output, Output>,
sqrt<Range, Output>(): Pow<Range, Output>,
pow(): Pow<number, number>,
pow<Output>(): Pow<Output, Output>,
pow<Range, Output>(): Pow<Range, Output>,
log(): Log<number, number>,
log<Output>(): Log<Output, Output>,
log<Range, Output>(): Log<Range, Output>,
quantize<T>(): Quantize<T>,
quantile<T>(): Quantile<T>,
threshold<Range>(): Threshold<number, Range>,
threshold<Domain, Range>(): Threshold<Domain, Range>,
ordinal<Range>(): Ordinal<string, Range>,
ordinal<Domain: { toString(): string }, Range>(): Ordinal<Domain, Range>,
category10(): Ordinal<string, string>,
category10<Domain: { toString(): string }>(): Ordinal<Domain, string>,
category20(): Ordinal<string, string>,
category20<Domain: { toString(): string }>(): Ordinal<Domain, string>,
category20b(): Ordinal<string, string>,
category20b<Domain: { toString(): string }>(): Ordinal<Domain, string>,
category20c(): Ordinal<string, string>,
category20c<Domain: { toString(): string }>(): Ordinal<Domain, string>,
};
declare export function interpolate(a: number, b: number): (t: number) => number;
declare export function interpolate(a: string, b: string): (t: number) => string;
declare export function interpolate(a: string | Color, b: Color): (t: number) => string;
declare export function interpolate(a: Array<string | Color>, b: Color[]): (t: number) => string;
declare export function interpolate<Range, Output>(
a: Range[],
b: Output[]
): (t: number) => Output[];
declare export function interpolate<Range, Output>(
a: Range[],
b: Range[]
): (t: number) => Output[];
declare export function interpolate(
a: { [key: string]: string | Color },
b: { [key: string]: Color }
): (t: number) => { [key: string]: string };
declare export function interpolate<Range, Output>(
a: { [key: string]: Range },
b: { [key: string]: Output }
): (t: number) => { [key: string]: Output };
declare export function interpolate<Range, Output>(
a: { [key: string]: Range },
b: { [key: string]: Range }
): (t: number) => { [key: string]: Output };
declare export function interpolateNumber(a: number, b: number): (t: number) => number;
declare export function interpolateRound(a: number, b: number): (t: number) => number;
declare export function interpolateString(a: string, b: string): (t: number) => string;
declare export function interpolateRgb(
a: string | Color,
b: string | Color
): (t: number) => string;
declare export function interpolateHsl(
a: string | Color,
b: string | Color
): (t: number) => string;
declare export function interpolateLab(
a: string | Color,
b: string | Color
): (t: number) => string;
declare export function interpolateHcl(
a: string | Color,
b: string | Color
): (t: number) => string;
declare export function interpolateArray(
a: Array<string | Color>,
b: Color[]
): (t: number) => string[];
declare export function interpolateArray<Range, Output>(
a: Range[],
b: Range[]
): (t: number) => Output[];
declare export function interpolateArray<Range, Output>(
a: Range[],
b: Output[]
): (t: number) => Output[];
declare export function interpolateObject(
a: { [key: string]: string | Color },
b: { [key: string]: Color }
): (t: number) => { [key: string]: string };
declare export function interpolateObject<Range, Output>(
a: { [key: string]: Range },
b: { [key: string]: Output }
): (t: number) => { [key: string]: Output };
declare export function interpolateObject<Range, Output>(
a: { [key: string]: Range },
b: { [key: string]: Range }
): (t: number) => { [key: string]: Output };
declare export function interpolateTransform(
a: string | Transform,
b: string | Transform
): (t: number) => string;
declare export function interpolateZoom(
a: [number, number, number],
b: [number, number, number]
): {
(t: number): [number, number, number],
duration: number,
};
declare export var interpolators: Array<(a: any, b: any) => (t: number) => any>;
declare export interface Interval {
(d: Date): Date;
floor(d: Date): Date;
round(d: Date): Date;
ceil(d: Date): Date;
range(start: Date, stop: Date, step?: number): Date[];
offset(date: Date, step: number): Date;
utc: {
(d: Date): Date,
floor(d: Date): Date,
round(d: Date): Date,
ceil(d: Date): Date,
range(start: Date, stop: Date, step?: number): Date[],
offset(date: Date, step: number): Date,
};
}
declare export interface Format {
(d: Date): string;
parse(input: string): Date;
}
declare export interface Scale<Range, Output> {
(x: Date): Output;
invert(y: number): Date;
domain(): Date[];
domain(dates: number[]): Scale<Range, Output>;
domain(dates: Date[]): Scale<Range, Output>;
nice(): Scale<Range, Output>;
nice(interval: Interval, step?: number): Scale<Range, Output>;
range(): Range[];
range(values: Range[]): Scale<Range, Output>;
rangeRound(values: number[]): Scale<number, number>;
interpolate(): (a: Range, b: Range) => (t: number) => Output;
interpolate(factory: (a: Range, b: Range) => (t: number) => Output): Scale<Range, Output>;
clamp(): boolean;
clamp(clamp: boolean): Scale<Range, Output>;
ticks(): Date[];
ticks(interval: Interval, step?: number): Date[];
ticks(count: number): Date[];
tickFormat(count: number): (d: Date) => string;
copy(): Scale<Range, Output>;
}
declare export var time: {
second: Interval,
minute: Interval,
hour: Interval,
day: Interval,
week: Interval,
sunday: Interval,
monday: Interval,
tuesday: Interval,
wednesday: Interval,
thursday: Interval,
friday: Interval,
saturday: Interval,
month: Interval,
year: Interval,
seconds(start: Date, stop: Date, step?: number): Date[],
minutes(start: Date, stop: Date, step?: number): Date[],
hours(start: Date, stop: Date, step?: number): Date[],
days(start: Date, stop: Date, step?: number): Date[],
weeks(start: Date, stop: Date, step?: number): Date[],
sundays(start: Date, stop: Date, step?: number): Date[],
mondays(start: Date, stop: Date, step?: number): Date[],
tuesdays(start: Date, stop: Date, step?: number): Date[],
wednesdays(start: Date, stop: Date, step?: number): Date[],
thursdays(start: Date, stop: Date, step?: number): Date[],
fridays(start: Date, stop: Date, step?: number): Date[],
saturdays(start: Date, stop: Date, step?: number): Date[],
months(start: Date, stop: Date, step?: number): Date[],
years(start: Date, stop: Date, step?: number): Date[],
dayOfYear(d: Date): number,
weekOfYear(d: Date): number,
sundayOfYear(d: Date): number,
mondayOfYear(d: Date): number,
tuesdayOfYear(d: Date): number,
wednesdayOfYear(d: Date): number,
fridayOfYear(d: Date): number,
saturdayOfYear(d: Date): number,
format(specifier: string): Format,
format: {
multi(formats: Array<[string, (d: Date) => boolean | number]>): Format,
utc(specifier: string): Format,
utc: {
multi(formats: Array<[string, (d: Date) => boolean | number]>): Format,
},
iso: Format,
},
scale(): Scale<number, number>,
scale<Output>(): Scale<Output, Output>,
scale<Range, Output>(): Scale<Range, Output>,
scale: {
utc(): Scale<number, number>,
utc<Output>(): Scale<Output, Output>,
utc<Range, Output>(): Scale<Range, Output>,
},
};
declare export interface Drag<Datum> {
(selection: Selection<Datum>): void;
on(type: string): (d: Datum, i: number) => any;
on(type: string, listener: (d: Datum, i: number) => any): Drag<Datum>;
origin(): (d: Datum, i: number) => { x: number, y: number };
origin(accessor: (d: Datum, i: number) => { x: number, y: number }): Drag<Datum>;
}
declare export function zoom<Datum>(): Zoom<Datum>;
declare export interface ZoomScale {
domain(): number[];
domain(values: number[]): ZoomScale;
invert(y: number): number;
range(values: number[]): ZoomScale;
range(): number[];
}
declare export interface Zoom<Datum> {
(selection: Selection<Datum>): void;
translate(): [number, number];
translate(translate: [number, number]): Zoom<Datum>;
scale(): number;
scale(scale: number): Zoom<Datum>;
scaleExtent(): [number, number];
scaleExtent(extent: [number, number]): Zoom<Datum>;
center(): [number, number];
center(center: [number, number]): Zoom<Datum>;
size(): [number, number];
size(size: [number, number]): Zoom<Datum>;
x(): ZoomScale;
x(x: ZoomScale): Zoom<Datum>;
y(): ZoomScale;
y(y: ZoomScale): Zoom<Datum>;
on(type: string): (d: Datum, i: number) => any;
on(type: string, listener: (d: Datum, i: number) => any): Zoom<Datum>;
event(selection: Selection<Datum>): void;
event(transition: Transition<Datum>): void;
}
declare export var behavior: {
drag<Datum>(): Drag<Datum>,
zoom<Datum>(): Zoom<Datum>,
};
declare export interface Path {
(feature: any, index?: number): string;
area(feature: any): number;
centroid(feature: any): [number, number];
bounds(feature: any): [[number, number], [number, number]];
projection(): Transform | ((coordinates: [number, number]) => [number, number]);
projection(stream: Transform): Path;
projection(projection: (coordinates: [number, number]) => [number, number]): Path;
pointRadius(): number | ((datum: any, index: number) => number);
pointRadius(radius: number): Path;
pointRadius(radius: (datum: any, index: number) => number): Path;
context(): CanvasRenderingContext2D;
context(context: CanvasRenderingContext2D): Path;
}
declare export interface Graticule {
(): any;
lines(): any[];
outline(): any;
extent(): [[number, number], [number, number]];
extent(extent: [[number, number], [number, number]]): Graticule;
majorExtent(): [[number, number], [number, number]];
majorExtent(extent: [[number, number], [number, number]]): Graticule;
minorExtent(): [[number, number], [number, number]];
minorExtent(extent: [[number, number], [number, number]]): Graticule;
step(): [number, number];
step(step: [number, number]): Graticule;
majorStep(): [number, number];
majorStep(step: [number, number]): Graticule;
minorStep(): [number, number];
minorStep(step: [number, number]): Graticule;
precision(): number;
precision(precision: number): Graticule;
}
declare export interface Circle {
(...args: any[]): any;
origin(): [number, number] | ((...args: any[]) => [number, number]);
origin(origin: [number, number]): Circle;
origin(origin: (...args: any[]) => [number, number]): Circle;
angle(): number;
angle(angle: number): Circle;
precision(): number;
precision(precision: number): Circle;
}
declare export interface Rotation {
(location: [number, number]): [number, number];
invert(location: [number, number]): [number, number];
}
declare export interface Listener {
point(x: number, y: number, z: number): void;
lineStart(): void;
lineEnd(): void;
polygonStart(): void;
polygonEnd(): void;
sphere(): void;
}
declare export interface TransformMethods {
point?: (x: number, y: number, z: number) => void;
lineStart?: () => void;
lineEnd?: () => void;
polygonStart?: () => void;
polygonEnd?: () => void;
sphere?: () => void;
}
declare export interface GeoTransform {
stream(stream: Listener): Listener;
}
declare export interface Projection {
(location: [number, number]): [number, number];
stream(listener: Listener): Listener;
rotation(): [number, number, number];
rotation([number, number, number]): Projection;
center(): [number, number];
center([number, number]): Projection;
translate(): [number, number];
translate([number, number]): Projection;
scale(): [number];
scale(number): Projection;
clipAngle(): [number];
clipAngle(number): Projection;
clipExtent(): [number, number];
clipExtent([number, number]): Projection;
precision(): [number];
precision(number): Projection;
}
declare export interface InvertibleProjection {
// properties below copied from `Projection` interface
(location: [number, number]): [number, number];
stream(listener: Listener): Listener;
rotation(): [number, number, number];
rotation([number, number, number]): InvertibleProjection;
center(): [number, number];
center([number, number]): InvertibleProjection;
translate(): [number, number];
translate([number, number]): InvertibleProjection;
scale(): [number];
scale(number): InvertibleProjection;
clipAngle(): [number];
clipAngle(number): InvertibleProjection;
clipExtent(): [number, number];
clipExtent([number, number]): InvertibleProjection;
precision(): [number];
precision(number): InvertibleProjection;
// properties above copied from `Projection` interface
invert(point: [number, number]): [number, number];
}
declare export interface ConicProjection {
// properties below copied from `InvertibleProjection` interface
(location: [number, number]): [number, number];
stream(listener: Listener): Listener;
rotation(): [number, number, number];
rotation([number, number, number]): ConicProjection;
center(): [number, number];
center([number, number]): ConicProjection;
translate(): [number, number];
translate([number, number]): ConicProjection;
scale(): [number];
scale(number): ConicProjection;
clipAngle(): [number];
clipAngle(number): ConicProjection;
clipExtent(): [number, number];
clipExtent([number, number]): ConicProjection;
precision(): [number];
precision(number): ConicProjection;
// properties above copied from `InvertibleProjection` interface
parallels(): [number, number];
parallels(parallels: [number, number]): ConicProjection;
}
declare export interface RawProjection {
(lambda: number, phi: number): [number, number];
}
declare export interface RawInvertibleProjection {
(lambda: number, phi: number): [number, number];
invert(x: number, y: number): [number, number];
}
declare export interface ClipExtent extends Transform {
extent(): [[number, number], [number, number]];
extent(extent: [[number, number], [number, number]]): ClipExtent;
}
declare export var geo: {
path(): Path,
graticule(): Graticule,
circle(): Circle,
area(feature: any): number,
centroid(feature: any): [number, number],
bounds(feature: any): [[number, number], [number, number]],
distance(a: [number, number], b: [number, number]): number,
length(feature: any): number,
interpolate(a: [number, number], b: [number, number]): (t: number) => [number, number],
rotation(rotate: [number, number] | [number, number, number]): Rotation,
stream(object: any, listener: Listener): void,
transform(methods: TransformMethods): GeoTransform,
clipExtent(): ClipExtent,
projection(raw: RawInvertibleProjection): InvertibleProjection,
projection(raw: RawProjection): Projection,
projectionMutator(
factory: (...args: any[]) => RawInvertibleProjection
): (...args: any[]) => InvertibleProjection,
projectionMutator(factory: (...args: any[]) => RawProjection): (...args: any[]) => Projection,
albers(): ConicProjection,
albersUsa(): ConicProjection,
azimuthalEqualArea(): InvertibleProjection,
azimuthalEqualArea: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
azimuthalEquidistant(): InvertibleProjection,
azimuthalEquidistant: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
conicConformal(): ConicProjection,
conicConformal: {
raw(phi0: number, phi1: number): RawInvertibleProjection,
},
conicEqualArea(): ConicProjection,
conicEqualArea: {
raw(phi0: number, phi1: number): RawInvertibleProjection,
},
conicEquidistant(): ConicProjection,
conicEquidistant: {
raw(phi0: number, phi1: number): RawInvertibleProjection,
},
equirectangular(): InvertibleProjection,
equirectangular: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
gnomonic(): InvertibleProjection,
gnomonic: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
mercator(): InvertibleProjection,
mercator: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
orthographic(): InvertibleProjection,
orthographic: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
stereographic(): InvertibleProjection,
stereographic: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
transverseMercator(): InvertibleProjection,
transverseMercator: {
raw(lambda: number, phi: number): [number, number],
raw: {
invert(x: number, y: number): [number, number],
},
},
};
declare export interface Line<T> {
(data: T[]): string;
x(): number | ((d: T, i: number) => number);
x(x: number): Line<T>;
x(x: (d: T, i: number) => number): Line<T>;
y(): number | ((d: T, i: number) => number);
y(x: number): Line<T>;
y(y: (d: T, i: number) => number): Line<T>;
interpolate(): string | ((points: Array<[number, number]>) => string);
interpolate(interpolate: 'linear'): Line<T>;
interpolate(interpolate: 'linear-closed'): Line<T>;
interpolate(interpolate: 'step'): Line<T>;
interpolate(interpolate: 'step-before'): Line<T>;
interpolate(interpolate: 'step-after'): Line<T>;
interpolate(interpolate: 'basis'): Line<T>;
interpolate(interpolate: 'basis-open'): Line<T>;
interpolate(interpolate: 'basis-closed'): Line<T>;
interpolate(interpolate: 'bundle'): Line<T>;
interpolate(interpolate: 'cardinal'): Line<T>;
interpolate(interpolate: 'cardinal-open'): Line<T>;
interpolate(interpolate: 'cardinal-closed'): Line<T>;
interpolate(interpolate: 'monotone'): Line<T>;
interpolate(interpolate: string | ((points: Array<[number, number]>) => string)): Line<T>;
tension(): number;
tension(tension: number): Line<T>;
defined(): (d: T, i: number) => boolean;
defined(defined: (d: T, i: number) => boolean): Line<T>;
}
declare export interface LineRadial<T> {
(data: T[]): string;
radius(): number | ((d: T, i: number) => number);
radius(radius: number): LineRadial<T>;
radius(radius: (d: T, i: number) => number): LineRadial<T>;
angle(): number | ((d: T, i: number) => number);
angle(angle: number): LineRadial<T>;
angle(angle: (d: T, i: number) => number): LineRadial<T>;
interpolate(): string | ((points: Array<[number, number]>) => string);
interpolate(interpolate: 'linear'): LineRadial<T>;
interpolate(interpolate: 'linear-closed'): LineRadial<T>;
interpolate(interpolate: 'step'): LineRadial<T>;
interpolate(interpolate: 'step-before'): LineRadial<T>;
interpolate(interpolate: 'step-after'): LineRadial<T>;
interpolate(interpolate: 'basis'): LineRadial<T>;
interpolate(interpolate: 'basis-open'): LineRadial<T>;
interpolate(interpolate: 'basis-closed'): LineRadial<T>;
interpolate(interpolate: 'bundle'): LineRadial<T>;
interpolate(interpolate: 'cardinal'): LineRadial<T>;
interpolate(interpolate: 'cardinal-open'): LineRadial<T>;
interpolate(interpolate: 'cardinal-closed'): LineRadial<T>;
interpolate(interpolate: 'monotone'): LineRadial<T>;
interpolate(interpolate: string | ((points: Array<[number, number]>) => string)): LineRadial<T>;
tension(): number;
tension(tension: number): LineRadial<T>;
defined(): (d: T, i: number) => boolean;
defined(defined: (d: T, i: number) => boolean): LineRadial<T>;
}
declare export interface Area<T> {
(data: T[]): string;
x(): number | ((d: T, i: number) => number);
x(x: number): Area<T>;
x(x: (d: T, i: number) => number): Area<T>;
x0(): number | ((d: T, i: number) => number);
x0(x0: number): Area<T>;
x0(x0: (d: T, i: number) => number): Area<T>;
x1(): number | ((d: T, i: number) => number);
x1(x1: number): Area<T>;
x1(x1: (d: T, i: number) => number): Area<T>;
y(): number | ((d: T, i: number) => number);
y(y: number): Area<T>;
y(y: (d: T, i: number) => number): Area<T>;
y0(): number | ((d: T, i: number) => number);
y0(y0: number): Area<T>;
y0(y0: (d: T, i: number) => number): Area<T>;
y1(): number | ((d: T, i: number) => number);
y1(y1: number): Area<T>;
y1(y1: (d: T, i: number) => number): Area<T>;
interpolate(): string | ((points: Array<[number, number]>) => string);
interpolate(interpolate: 'linear'): Area<T>;
interpolate(interpolate: 'step'): Area<T>;
interpolate(interpolate: 'step-before'): Area<T>;
interpolate(interpolate: 'step-after'): Area<T>;
interpolate(interpolate: 'basis'): Area<T>;
interpolate(interpolate: 'basis-open'): Area<T>;
interpolate(interpolate: 'cardinal'): Area<T>;
interpolate(interpolate: 'cardinal-open'): Area<T>;
interpolate(interpolate: 'monotone'): Area<T>;
interpolate(interpolate: string | ((points: Array<[number, number]>) => string)): Area<T>;
tension(): number;
tension(tension: number): Area<T>;
defined(): (d: T, i: number) => boolean;
defined(defined: (d: T, i: number) => boolean): Area<T>;
}
declare export interface AreaRadial<T> {
(data: T[]): string;
radius(): number | ((d: T, i: number) => number);
radius(radius: number): AreaRadial<T>;
radius(radius: (d: T, i: number) => number): AreaRadial<T>;
innerRadius(): number | ((d: T, i: number) => number);
innerRadius(innerRadius: number): AreaRadial<T>;
innerRadius(innerRadius: (d: T, i: number) => number): AreaRadial<T>;
outerRadius(): number | ((d: T, i: number) => number);
outerRadius(outerRadius: number): AreaRadial<T>;
outerRadius(outerRadius: (d: T, i: number) => number): AreaRadial<T>;
angle(): number | ((d: T, i: number) => number);
angle(angle: number): AreaRadial<T>;
angle(angle: (d: T, i: number) => number): AreaRadial<T>;
startAngle(): number | ((d: T, i: number) => number);
startAngle(startAngle: number): AreaRadial<T>;
startAngle(startAngle: (d: T, i: number) => number): AreaRadial<T>;
endAngle(): number | ((d: T, i: number) => number);
endAngle(endAngle: number): AreaRadial<T>;
endAngle(endAngle: (d: T, i: number) => number): AreaRadial<T>;
interpolate(): string | ((points: Array<[number, number]>) => string);
interpolate(interpolate: 'linear'): AreaRadial<T>;
interpolate(interpolate: 'step'): AreaRadial<T>;
interpolate(interpolate: 'step-before'): AreaRadial<T>;
interpolate(interpolate: 'step-after'): AreaRadial<T>;
interpolate(interpolate: 'basis'): AreaRadial<T>;
interpolate(interpolate: 'basis-open'): AreaRadial<T>;
interpolate(interpolate: 'cardinal'): AreaRadial<T>;
interpolate(interpolate: 'cardinal-open'): AreaRadial<T>;
interpolate(interpolate: 'monotone'): AreaRadial<T>;
interpolate(interpolate: string | ((points: Array<[number, number]>) => string)): AreaRadial<T>;
tension(): number;
tension(tension: number): AreaRadial<T>;
defined(): (d: T, i: number) => boolean;
defined(defined: (d: T, i: number) => boolean): AreaRadial<T>;
}
declare export interface Arc<T> {
(d: T, i?: number): string;
innerRadius(): (d: T, i: number) => number;
innerRadius(radius: number): Arc<T>;
innerRadius(radius: (d: T, i: number) => number): Arc<T>;
outerRadius(): (d: T, i: number) => number;
outerRadius(radius: number): Arc<T>;
outerRadius(radius: (d: T, i: number) => number): Arc<T>;
cornerRadius(): (d: T, i: number) => number;
cornerRadius(radius: number): Arc<T>;
cornerRadius(radius: (d: T, i: number) => number): Arc<T>;
padRadius(): string | ((d: T, i: number) => number);
padRadius(radius: 'auto'): Arc<T>;
padRadius(radius: string): Arc<T>;
padRadius(radius: (d: T, i: number) => number): Arc<T>;
startAngle(): (d: T, i: number) => number;
startAngle(angle: number): Arc<T>;
startAngle(angle: (d: T, i: number) => number): Arc<T>;
endAngle(): (d: T, i: number) => number;
endAngle(angle: number): Arc<T>;
endAngle(angle: (d: T, i: number) => number): Arc<T>;
padAngle(): (d: T, i: number) => number;
padAngle(angle: number): Arc<T>;
padAngle(angle: (d: T, i: number) => number): Arc<T>;
centroid(d: T, i?: number): [number, number];
}
declare export interface Symbol<T> {
(d: T, i?: number): string;
type(): (d: T, i: number) => string;
type(type: string): Symbol<T>;
type(type: (d: T, i: number) => string): Symbol<T>;
size(): (d: T, i: string) => number;
size(size: number): Symbol<T>;
size(size: (d: T, i: number) => number): Symbol<T>;
}
declare export interface ChordLink<ChordNode> {
source: ChordNode;
target: ChordNode;
}
declare export interface ChordNode {
radius: number;
startAngle: number;
endAngle: number;
}
declare export interface Chord<ChordLink, ChordNode> {
(d: ChordLink, i: number): string;
source(): (d: ChordLink, i: number) => ChordNode;
source(source: ChordNode): Chord<ChordLink, ChordNode>;
source(source: (d: ChordLink, i: number) => ChordNode): Chord<ChordLink, ChordNode>;
target(): (d: ChordLink, i: number) => ChordNode;
target(target: ChordNode): Chord<ChordLink, ChordNode>;
target(target: (d: ChordLink, i: number) => ChordNode): Chord<ChordLink, ChordNode>;
radius(): (d: ChordNode, i: number) => number;
radius(radius: number): Chord<ChordLink, ChordNode>;
radius(radius: (d: Node, i: number) => number): Chord<ChordLink, ChordNode>;
startAngle(): (d: ChordNode, i: number) => number;
startAngle(angle: number): Chord<ChordLink, ChordNode>;
startAngle(angle: (d: Node, i: number) => number): Chord<ChordLink, ChordNode>;
endAngle(): (d: ChordNode, i: number) => number;
endAngle(angle: number): Chord<ChordLink, ChordNode>;
endAngle(angle: (d: ChordNode, i: number) => number): Chord<ChordLink, ChordNode>;
}
declare export interface DiagonalLink<DiagonalNode> {
source: DiagonalNode;
target: DiagonalNode;
}
declare export interface DiagonalNode {
x: number;
y: number;
}
declare export interface Diagonal<DiagonalLink, DiagonalNode> {
(d: DiagonalLink, i?: number): string;
source(): (d: DiagonalLink, i: number) => DiagonalNode;
source(source: DiagonalNode): Diagonal<DiagonalLink, DiagonalNode>;
source(
source: (d: DiagonalLink, i: number) => { x: number, y: number }
): Diagonal<DiagonalLink, DiagonalNode>;
target(): (d: DiagonalLink, i: number) => DiagonalNode;
target(target: DiagonalNode): Diagonal<DiagonalLink, DiagonalNode>;
target(
target: (d: DiagonalLink, i: number) => { x: number, y: number }
): Diagonal<DiagonalLink, DiagonalNode>;
projection(): (d: DiagonalNode, i: number) => [number, number];
projection(
projection: (d: DiagonalNode, i: number) => [number, number]
): Diagonal<DiagonalLink, DiagonalNode>;
}
declare export interface DiagonalRadial<Link, Node> {
(d: Link, i: number): string;
source(): (d: Link, i: number) => Node;
source(source: Node): DiagonalRadial<Link, Node>;
source(source: (d: Link, i: number) => Node): DiagonalRadial<Link, Node>;
target(): (d: Link, i: number) => Node;
target(target: Node): DiagonalRadial<Link, Node>;
target(target: (d: Link, i: number) => Node): DiagonalRadial<Link, Node>;
projection(): (d: Node, i: number) => [number, number];
projection(projection: (d: Node, i: number) => [number, number]): DiagonalRadial<Link, Node>;
}
declare export interface Axis {
(selection: Selection<any>): void;
(selection: Transition<any>): void;
scale(): any;
scale(scale: any): Axis;
orient(): string;
orient(orientation: string): Axis;
ticks(): any[];
ticks(...args: any[]): Axis;
tickValues(): any[];
tickValues(values: any[]): Axis;
tickSize(): number;
tickSize(size: number): Axis;
tickSize(inner: number, outer: number): Axis;
innerTickSize(): number;
innerTickSize(size: number): Axis;
outerTickSize(): number;
outerTickSize(size: number): Axis;
tickPadding(): number;
tickPadding(padding: number): Axis;
tickFormat(): (t: any) => string;
tickFormat(format: (t: any) => string): Axis;
tickFormat(format: string): Axis;
}
declare export interface BrushScale<S> {
domain(): S[];
domain(domain: S[]): BrushScale<S>;
range(): S[];
range(range: number[]): BrushScale<S>;
invert?: (y: number) => S;
}
declare export interface Brush<T, X, Y> {
(selection: Selection<T>): void;
(selection: Transition<T>): void;
event(selection: Selection<T>): void;
event(selection: Transition<T>): void;
x(): BrushScale<X>;
x(x: BrushScale<X>): Brush<T, X, Y>;
x<A, B: X>(x: Ordinal<A, B> | Scale<A, B>): Brush<T, X, Y>;
y(): BrushScale<Y>;
y(y: BrushScale<Y>): Brush<T, X, Y>;
y<A, B: Y>(x: Ordinal<A, B> | Scale<A, B>): Brush<T, X, Y>;
// https://github.com/d3/d3-3.x-api-reference/blob/master/SVG-Controls.md#brush_extent
extent(): [X, X] | [Y, Y] | [[X, Y], [X, Y]] | null;
extent(extent: [X, X] | [Y, Y] | [[X, Y], [X, Y]]): Brush<T, X, Y>;
clamp(): boolean | [boolean, boolean];
clamp(clamp: boolean | [boolean, boolean]): Brush<T, X, Y>;
clear(): void;
empty(): boolean;
on(type: 'brushstart'): (datum: T, index: number) => void;
on(type: 'brush'): (datum: T, index: number) => void;
on(type: 'brushend'): (datum: T, index: number) => void;
on(type: string): (datum: T, index: number) => void;
on(type: 'brushstart', listener: (datum: T, index: number) => void): Brush<T, X, Y>;
on(type: 'brush', listener: (datum: T, index: number) => void): Brush<T, X, Y>;
on(type: 'brushend', listener: (datum: T, index: number) => void): Brush<T, X, Y>;
on(type: string, listener: (datum: T, index: number) => void): Brush<T, X, Y>;
}
declare export interface ArcArc {
innerRadius: number;
outerRadius: number;
startAngle: number;
endAngle: number;
padAngle: number;
}
declare export var svg: {
line: {
(): Line<[number, number]>,
radial(): LineRadial<[number, number]>,
radial<T>(): LineRadial<T>,
},
area(): Area<[number, number]>,
area<T>(): Area<T>,
area: {
radial(): AreaRadial<[number, number]>,
radial<T>(): AreaRadial<T>,
},
arc(): Arc<ArcArc>,
arc<T>(): Arc<T>,
symbol(): Symbol<{}>,
symbol<T>(): Symbol<T>,
symbolTypes: string[],
chord(): Chord<ChordLink<ChordNode>, ChordNode>,
chord<ChordNode>(): Chord<ChordLink<ChordNode>, ChordNode>,
chord<Link, Node>(): Chord<Link, Node>,
diagonal: {
(): Diagonal<DiagonalLink<DiagonalNode>, DiagonalNode>,
<Node>(): Diagonal<DiagonalLink<Node>, Node>,
<ChordLink, ChordNode>(): Diagonal<ChordLink, ChordNode>,
radial(): DiagonalRadial<ChordLink<ChordNode>, ChordNode>,
radial<ChordNode>(): DiagonalRadial<ChordLink<Node>, ChordNode>,
radial<ChordLink, ChordNode>(): DiagonalRadial<ChordLink, ChordNode>,
},
axis(): Axis,
brush(): Brush<any, number, number>,
brush<T>(): Brush<T, number, number>,
brush<T, X>(): Brush<T, X, X>,
brush<T, X, Y>(): Brush<T, X, Y>,
};
declare export class Xhr {
header(name: string): string;
header(name: string, value: string): Xhr;
mimeType(): string;
mimeType(type: string): Xhr;
responseType(): string;
responseType(type: string): Xhr;
response(): (request: XMLHttpRequest) => any;
response(value: (request: XMLHttpRequest) => any): Xhr;
get(callback?: (err: any, data: any) => void): Xhr;
post(data?: any, callback?: (err: any, data: any) => void): Xhr;
post(callback: (err: any, data: any) => void): Xhr;
send(method: string, data?: any, callback?: (err: any, data: any) => void): Xhr;
send(method: string, callback: (err: any, data: any) => void): Xhr;
abort(): Xhr;
on(type: 'beforesend'): (request: XMLHttpRequest) => void;
on(type: 'progress'): (request: XMLHttpRequest) => void;
on(type: 'load'): (response: any) => void;
on(type: 'error'): (err: any) => void;
on(type: string): (...args: any[]) => void;
on(type: 'beforesend', listener: (request: XMLHttpRequest) => void): Xhr;
on(type: 'progress', listener: (request: XMLHttpRequest) => void): Xhr;
on(type: 'load', listener: (response: any) => void): Xhr;
on(type: 'error', listener: (err: any) => void): Xhr;
on(type: string, listener: (...args: any[]) => void): Xhr;
}
declare export function xhr(
url: string,
mimeType?: string,
callback?: (err: any, data: any) => void
): Xhr;
declare export function xhr(url: string, callback: (err: any, data: any) => void): Xhr;
declare export function text(
url: string,
mimeType?: string,
callback?: (err: any, data: string) => void
): Xhr;
declare export function text(url: string, callback: (err: any, data: string) => void): Xhr;
declare export function json(url: string, callback?: (err: any, data: any) => void): Xhr;
declare export function xml(
url: string,
mimeType?: string,
callback?: (err: any, data: any) => void
): Xhr;
declare export function xml(url: string, callback: (err: any, data: any) => void): Xhr;
declare export function html(
url: string,
callback?: (err: any, data: DocumentFragment) => void
): Xhr;
declare export var csv: Dsv;
declare export var tsv: Dsv;
declare export function dsv(delimiter: string, mimeType: string): Dsv;
declare export interface Dsv {
(
url: string,
callback: (rows: { [key: string]: string }[]) => void
): DsvXhr<{ [key: string]: string }>;
(
url: string,
callback: (error: any, rows: { [key: string]: string }[]) => void
): DsvXhr<{ [key: string]: string }>;
(url: string): DsvXhr<{ [key: string]: string }>;
<T>(
url: string,
accessor: (row: { [key: string]: string }) => T,
callback: (rows: T[]) => void
): DsvXhr<T>;
<T>(
url: string,
accessor: (row: { [key: string]: string }) => T,
callback: (error: any, rows: T[]) => void
): DsvXhr<T>;
<T>(url: string, accessor: (row: { [key: string]: string }) => T): DsvXhr<T>;
parse(string: string): { [key: string]: string }[];
parse<T>(string: string, accessor: (row: { [key: string]: string }, index: number) => T): T[];
parseRows(string: string): string[][];
parseRows<T>(string: string, accessor: (row: string[], index: number) => T): T[];
format(rows: { [key: string]: any }[]): string;
formatRows(rows: string[][]): string;
}
declare export interface DsvXhr<T> extends Xhr {
row(): (row: { [key: string]: string }) => T;
row<U>(accessor: (row: { [key: string]: string }) => U): DsvXhr<U>;
header(name: string): string;
header(name: string, value: string): DsvXhr<T>;
mimeType(): string;
mimeType(type: string): DsvXhr<T>;
responseType(): string;
responseType(type: string): DsvXhr<T>;
response(): (request: XMLHttpRequest) => any;
response(value: (request: XMLHttpRequest) => any): DsvXhr<T>;
get(callback?: (err: XMLHttpRequest, data: T[]) => void): DsvXhr<T>;
post(data?: any, callback?: (err: XMLHttpRequest, data: T[]) => void): DsvXhr<T>;
post(callback: (err: XMLHttpRequest, data: T[]) => void): DsvXhr<T>;
send(
method: string,
data?: any,
callback?: (err: XMLHttpRequest, data: T[]) => void
): DsvXhr<T>;
send(method: string, callback: (err: XMLHttpRequest, data: T[]) => void): DsvXhr<T>;
abort(): DsvXhr<T>;
on(type: 'beforesend'): (request: XMLHttpRequest) => void;
on(type: 'progress'): (request: XMLHttpRequest) => void;
on(type: 'load'): (response: T[]) => void;
on(type: 'error'): (err: any) => void;
on(type: string): (...args: any[]) => void;
on(type: 'beforesend', listener: (request: XMLHttpRequest) => void): DsvXhr<T>;
on(type: 'progress', listener: (request: XMLHttpRequest) => void): DsvXhr<T>;
on(type: 'load', listener: (response: T[]) => void): DsvXhr<T>;
on(type: 'error', listener: (err: any) => void): DsvXhr<T>;
on(type: string, listener: (...args: any[]) => void): DsvXhr<T>;
}
declare export function locale(definition: LocaleDefinition): Locale;
declare export interface LocaleDefinition {
decimal: string;
thousands: string;
grouping: number[];
currency: [string, string];
dateTime: string;
date: string;
time: string;
periods: [string, string];
days: [string, string, string, string, string, string, string];
shortDays: [string, string, string, string, string, string, string];
months: [
string,
string,
string,
string,
string,
string,
string,
string,
string,
string,
string,
string,
];
shortMonths: [
string,
string,
string,
string,
string,
string,
string,
string,
string,
string,
string,
string,
];
}
declare export interface Locale {
numberFormat(specifier: string): (n: number) => string;
timeFormat: {
(specifier: string): Format,
utc(specifier: string): Format,
multi(formats: Array<[string, (d: Date) => boolean | number]>): Format,
};
}
declare export interface BundleNode {
parent: BundleNode;
}
declare export interface BundleLink<T: BundleNode> {
source: T;
target: T;
}
declare export interface Bundle<T: BundleNode> {
(links: BundleLink<T>[]): T[][];
}
declare export interface LayoutChordLink {
source: LayoutChordNode;
target: LayoutChordNode;
}
declare export interface LayoutChordNode {
index: number;
subindex: number;
startAngle: number;
endAngle: number;
value: number;
}
declare export interface LayoutChordGroup {
index: number;
startAngle: number;
endAngle: number;
value: number;
}
declare export interface LayoutChord {
matrix(): number[][];
matrix(matrix: number[][]): LayoutChord;
padding(): number;
padding(padding: number): LayoutChord;
sortGroups(): (a: number, b: number) => number;
sortGroups(comparator: (a: number, b: number) => number): LayoutChord;
sortSubgroups(): (a: number, b: number) => number;
sortSubgroups(comparator: (a: number, b: number) => number): LayoutChord;
sortChords(): (a: number, b: number) => number;
sortChords(comparator: (a: number, b: number) => number): LayoutChord;
chords(): LayoutChordLink[];
groups(): LayoutChordGroup[];
}
declare export interface ClusterResult {
parent?: ClusterResult;
children?: ClusterResult[];
depth?: number;
x?: number;
y?: number;
}
declare export interface ClusterLink<T: ClusterResult> {
source: T;
target: T;
}
declare export interface Cluster<T: ClusterResult> {
(root: T): T[];
nodes(root: T): T[];
links(nodes: T[]): ClusterLink<T>[];
children(): (node: T) => T[];
children(accessor: (node: T) => T[]): Cluster<T>;
sort(): (a: T, b: T) => number;
sort(comparator: (a: T, b: T) => number): Cluster<T>;
separation(): (a: T, b: T) => number;
separation(separation: (a: T, b: T) => number): Cluster<T>;
size(): [number, number];
size(size: [number, number]): Cluster<T>;
nodeSize(): [number, number];
nodeSize(nodeSize: [number, number]): Cluster<T>;
value(): (a: T) => number;
value(value: (a: T) => number): Cluster<T>;
}
declare export interface ForceLink<T: ForceNode> {
source: T | number;
target: T | number;
}
declare export interface ForceNode {
index?: number;
x?: number;
y?: number;
px?: number;
py?: number;
fixed?: boolean;
weight?: number;
}
declare export interface ForceEvent {
type: string;
alpha: number;
}
// https://github.com/d3/d3-3.x-api-reference/blob/master/Force-Layout.md#links
// Read the note at the end of the section where it talks about initial numbering
declare export interface Force<Link: ForceLink<ForceNode>, Node: ForceNode> {
size(): [number, number];
size(size: [number, number]): Force<Link, Node>;
linkDistance(): number | ((link: Link, index: number) => number);
linkDistance(distance: number): Force<Link, Node>;
linkDistance(distance: (link: Link, index: number) => number): Force<Link, Node>;
linkStrength(): number | ((link: Link, index: number) => number);
linkStrength(strength: number): Force<Link, Node>;
linkStrength(strength: (link: Link, index: number) => number): Force<Link, Node>;
friction(): number;
friction(friction: number): Force<Link, Node>;
charge(): number | ((node: Node, index: number) => number);
charge(charge: number): Force<Link, Node>;
charge(charge: (node: Node, index: number) => number): Force<Link, Node>;
chargeDistance(): number;
chargeDistance(distance: number): Force<Link, Node>;
theta(): number;
theta(theta: number): Force<Link, Node>;
gravity(): number;
gravity(gravity: number): Force<Link, Node>;
nodes(): Node[];
nodes(nodes: Node[]): Force<Link, Node>;
links(): Link[];
links(links: { source: number, target: number }[]): Force<Link, Node>;
links(links: Link[]): Force<Link, Node>;
start(): Force<Link, Node>;
tick(): Force<Link, Node>;
alpha(): number;
alpha(value: number): Force<Link, Node>;
resume(): Force<Link, Node>;
stop(): Force<Link, Node>;
on(type: string): (event: ForceEvent) => void;
on(type: string, listener: (event: ForceEvent) => void): Force<Link, Node>;
drag(): Drag<Node>;
drag(selection: Selection<Node>): void;
}
declare export interface HierarchyResult {
parent?: HierarchyResult;
children?: HierarchyResult[];
value?: number;
depth?: number;
}
declare export interface Hierarchy<T: HierarchyResult> {
(root: T): T[];
children(): (node: T) => T[];
children(accessor: (node: T) => T[]): Hierarchy<T>;
sort(): (a: T, b: T) => number;
sort(comparator: (a: T, b: T) => number): Hierarchy<T>;
value(): (node: T) => number;
value(accessor: (node: T) => number): Hierarchy<T>;
revalue(root: T): T[];
}
declare export interface HistogramBin<T> extends Array<T> {
x: number;
dx: number;
y: number;
}
declare export interface Histogram<T> {
(values: T[], index?: number): HistogramBin<T>[];
value(): (datum: T, index: number) => number;
value(value: (datum: T, index: number) => number): Histogram<T>;
range(): (values: T[], index: number) => [number, number];
range(range: (values: T[], index: number) => [number, number]): Histogram<T>;
range(range: [number, number]): Histogram<T>;
bins(): (range: [number, number], values: T[], index: number) => number[];
bins(count: number): Histogram<T>;
bins(thresholds: number[]): Histogram<T>;
bins(func: (range: [number, number], values: T[], index: number) => number[]): Histogram<T>;
frequency(): boolean;
frequency(frequency: boolean): Histogram<T>;
}
declare export interface PackNode {
parent?: PackNode;
children?: PackNode[];
value?: number;
depth?: number;
x?: number;
y?: number;
r?: number;
}
declare export interface PackLink<T: PackNode> {
source: PackNode;
target: PackNode;
}
declare export interface Pack<T: PackNode> {
(root: T): T[];
nodes(root: T): T[];
links(nodes: T[]): PackLink<T>[];
children(): (node: T, depth: number) => T[];
children(children: (node: T, depth: number) => T[]): Pack<T>;
sort(): (a: T, b: T) => number;
sort(comparator: (a: T, b: T) => number): Pack<T>;
value(): (node: T) => number;
value(value: (node: T) => number): Pack<T>;
size(): [number, number];
size(size: [number, number]): Pack<T>;
radius(): number | ((node: T) => number);
radius(radius: number): Pack<T>;
radius(radius: (node: T) => number): Pack<T>;
padding(): number;
padding(padding: number): Pack<T>;
}
declare export interface PartitionLink<T: PartitionNode> {
source: T;
target: T;
}
declare export interface PartitionNode {
parent?: PartitionNode;
children?: number;
value?: number;
depth?: number;
x?: number;
y?: number;
dx?: number;
dy?: number;
}
declare export interface Partition<T: PartitionNode> {
(root: T): T[];
nodes(root: T): T[];
links(nodes: T[]): PartitionLink<T>[];
children(): (node: T, depth: number) => T[];
children(children: (node: T, depth: number) => T[]): Partition<T>;
sort(): (a: T, b: T) => number;
sort(comparator: (a: T, b: T) => number): Partition<T>;
value(): (node: T) => number;
value(value: (node: T) => number): Partition<T>;
size(): [number, number];
size(size: [number, number]): Partition<T>;
}
declare export interface PieArc<T> {
value: number;
startAngle: number;
endAngle: number;
padAngle: number;
data: T;
}
declare export interface Pie<T> {
(data: T[], index?: number): PieArc<T>[];
value(): (datum: T, index: number) => number;
value(accessor: (datum: T, index: number) => number): Pie<T>;
sort(): (a: T, b: T) => number;
sort(comparator: (a: T, b: T) => number): Pie<T>;
startAngle(): number | ((data: T[], index: number) => number);
startAngle(angle: number): Pie<T>;
startAngle(angle: (data: T[], index: number) => number): Pie<T>;
endAngle(): number | ((data: T[], index: number) => number);
endAngle(angle: number): Pie<T>;
endAngle(angle: (data: T[], index: number) => number): Pie<T>;
padAngle(): number | ((data: T[], index: number) => number);
padAngle(angle: number): Pie<T>;
padAngle(angle: (data: T[], index: number) => number): Pie<T>;
}
declare export interface StackValue {
x: number;
y: number;
y0?: number;
}
declare export interface Stack<Series, Value> {
(layers: Series[], index?: number): Series[];
values(): (layer: Series, index: number) => Value[];
values(accessor: (layer: Series, index: number) => Value[]): Stack<Series, Value>;
offset(): (data: Array<[number, number]>) => number[];
offset(offset: 'silhouette'): Stack<Series, Value>;
offset(offset: 'wiggle'): Stack<Series, Value>;
offset(offset: 'expand'): Stack<Series, Value>;
offset(offset: 'zero'): Stack<Series, Value>;
offset(offset: string): Stack<Series, Value>;
offset(offset: (data: Array<[number, number]>) => number[]): Stack<Series, Value>;
order(): (data: Array<[number, number]>) => number[];
order(order: 'inside-out'): Stack<Series, Value>;
order(order: 'reverse'): Stack<Series, Value>;
order(order: 'default'): Stack<Series, Value>;
order(order: string): Stack<Series, Value>;
order(order: (data: Array<[number, number]>) => number[]): Stack<Series, Value>;
x(): (value: Value, index: number) => number;
x(accessor: (value: Value, index: number) => number): Stack<Series, Value>;
y(): (value: Value, index: number) => number;
y(accesor: (value: Value, index: number) => number): Stack<Series, Value>;
out(): (value: Value, y0: number, y: number) => void;
out(setter: (value: Value, y0: number, y: number) => void): Stack<Series, Value>;
}
declare export interface TreeLink<T: TreeNode> {
source: T;
target: T;
}
declare export interface TreeNode {
parent?: TreeNode;
children?: TreeNode[];
depth?: number;
x?: number;
y?: number;
}
declare export interface Tree<T> {
(root: T, index?: number): T[];
nodes(root: T, index?: number): T[];
links(nodes: T[]): TreeLink<T>[];
children(): (datum: T, index: number) => T[];
children(children: (datum: T, index: number) => ?T[]): Tree<T>;
separation(): (a: T, b: T) => number;
separation(separation: (a: T, b: T) => number): Tree<T>;
size(): [number, number];
size(size: [number, number]): Tree<T>;
nodeSize(): [number, number];
nodeSize(size: [number, number]): Tree<T>;
sort(): (a: T, b: T) => number;
sort(comparator?: ?(a: T, b: T) => number): Tree<T>;
value(): (datum: T, index: number) => number;
value(value: (datum: T, index: number) => number): Tree<T>;
}
declare export interface TreemapNode {
parent?: TreemapNode;
children?: TreemapNode[];
value?: number;
depth?: number;
x?: number;
y?: number;
dx?: number;
dy?: number;
}
declare export interface TreemapLink<T: TreemapNode> {
source: T;
target: T;
}
declare export type TreemapPadding = number | [number, number, number, number];
declare export interface Treemap<T: TreemapNode> {
(root: T, index?: number): T[];
nodes(root: T, index?: number): T[];
links(nodes: T[]): TreemapLink<T>[];
children(): (node: T, depth: number) => T[];
children(children: (node: T, depth: number) => T[]): Treemap<T>;
sort(): (a: T, b: T) => number;
sort(comparator: (a: T, b: T) => number): Treemap<T>;
value(): (node: T, index: number) => number;
value(value: (node: T, index: number) => number): Treemap<T>;
size(): [number, number];
size(size: [number, number]): Treemap<T>;
padding(): (node: T, depth: number) => TreemapPadding;
padding(padding: TreemapPadding): Treemap<T>;
padding(padding: (node: T, depth: number) => TreemapPadding): Treemap<T>;
round(): boolean;
round(round: boolean): Treemap<T>;
sticky(): boolean;
sticky(sticky: boolean): Treemap<T>;
mode(): string;
mode(mode: 'squarify'): Treemap<T>;
mode(mode: 'slice'): Treemap<T>;
mode(mode: 'dice'): Treemap<T>;
mode(mode: 'slice-dice'): Treemap<T>;
mode(mode: string): Treemap<T>;
ratio(): number;
ratio(ratio: number): Treemap<T>;
}
declare export var layout: {
bundle(): Bundle<BundleNode>,
bundle<T: BundleNode>(): Bundle<T>,
chord(): LayoutChord,
cluster(): Cluster<ClusterResult>,
cluster<T: ClusterResult>(): Cluster<T>,
force(): Force<ForceLink<ForceNode>, ForceNode>,
force<Node: ForceNode>(): Force<ForceLink<Node>, Node>,
force<Link: ForceLink<ForceNode>, Node: ForceNode>(): Force<Link, Node>,
hierarchy(): Hierarchy<HierarchyResult>,
hierarchy<T: HierarchyResult>(): Hierarchy<T>,
histogram(): Histogram<number>,
histogram<T>(): Histogram<T>,
pack(): Pack<PackNode>,
pack<T: PackNode>(): Pack<T>,
partition(): Partition<PartitionNode>,
partition<T: PartitionNode>(): Partition<T>,
pie(): Pie<number>,
pie<T>(): Pie<T>,
stack(): Stack<StackValue[], StackValue>,
stack<Value>(): Stack<Value[], Value>,
stack<Series, Value>(): Stack<Series, Value>,
tree(): Tree<TreeNode>,
tree<T: TreeNode>(): Tree<T>,
treemap(): Treemap<TreemapNode>,
treemap<T: TreemapNode>(): Treemap<T>,
};
declare export interface VoronoiLink<T> {
source: T;
target: T;
}
declare export interface Voronoi<T> {
(data: T[]): Array<[number, number]>;
x(): (vertex: T) => number;
x(x: (vertex: T) => number): Voronoi<T>;
y(): (vertex: T) => number;
y(y: (vertex: T) => number): Voronoi<T>;
clipExtent(): [[number, number], [number, number]];
clipExtent(extent: [[number, number], [number, number]]): Voronoi<T>;
links(data: T[]): VoronoiLink<T>[];
triangles(data: T[]): Array<[T, T, T]>;
}
declare export interface QuadtreeNode<T> {
nodes: [QuadtreeNode<T>, QuadtreeNode<T>, QuadtreeNode<T>, QuadtreeNode<T>];
leaf: boolean;
point: T;
x: number;
y: number;
}
declare export interface QuadtreeQuadtree<T> extends QuadtreeNode<T> {
add(point: T): void;
visit(
callback: (
node: QuadtreeQuadtree<T>,
x1: number,
y1: number,
x2: number,
y2: number
) => boolean | void
): void;
find(point: [number, number]): T;
}
declare export interface Quadtree<T> {
(points: T[]): QuadtreeQuadtree<T>;
x(): (datum: T, index: number) => number;
x(x: number): Quadtree<T>;
x(x: (datum: T, index: number) => number): Quadtree<T>;
y(): (datum: T, index: number) => number;
y(y: number): Quadtree<T>;
y(y: (datum: T, index: number) => number): Quadtree<T>;
extent(): [[number, number], [number, number]];
extent(extent: [[number, number], [number, number]]): Quadtree<T>;
}
declare export interface Hull<T> {
(vertices: T[]): Array<[number, number]>;
x(): (datum: T) => number;
x(x: (datum: T) => number): Hull<T>;
y(): (datum: T) => number;
y(y: (datum: T) => number): Hull<T>;
}
declare export interface Polygon {
area(): number;
centroid(): [number, number];
clip(subject: Array<[number, number]>): Array<[number, number]>;
}
declare export var geom: {
voronoi(): Voronoi<[number, number]>,
voronoi<T>(): Voronoi<T>,
/**
* @deprecated use d3.geom.voronoi().triangles() instead
*/
delaunay(
vertices: Array<[number, number]>
): Array<[[number, number], [number, number], [number, number]]>,
quadtree(): Quadtree<[number, number]>,
quadtree<T>(
nodes: T[],
x1?: number,
y1?: number,
x2?: number,
y2?: number
): QuadtreeQuadtree<T>,
hull(vertices: Array<[number, number]>): Array<[number, number]>,
hull(): Hull<[number, number]>,
hull<T>(): Hull<T>,
polygon(vertices: Array<[number, number]>): Polygon,
};
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment