@d3plus/core 3.0.15 → 3.1.0

package/types/src/charts/Plot.d.ts

@@ -0,0 +1,199 @@
+import Viz from "./Viz.js";
+/**
+    Creates an x/y plot based on an array of data.
+*/
+export default class Plot extends Viz {
+    [key: string]: any;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+  */
+    constructor();
+    /**
+        Extends the preDraw behavior of the abstract Viz class.
+        @private
+  */
+    _preDraw(): void;
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+  */
+    _draw(callback?: () => void): this;
+    /**
+        Allows drawing custom shapes to be used as annotations in the provided x/y plot. This method accepts custom config objects for the [Shape](http://d3plus.org/docs/#Shape) class, either a single config object or an array of config objects. Each config object requires an additional parameter, the "shape", which denotes which [Shape](http://d3plus.org/docs/#Shape) sub-class to use ([Rect](http://d3plus.org/docs/#Rect), [Line](http://d3plus.org/docs/#Line), etc).
+  
+  Additionally, each config object can also contain an optional "layer" key, which defines whether the annotations will be displayed in "front" or in "back" of the primary visualization shapes. This value defaults to "back" if not present.
+  */
+    annotations(_: any): any;
+    /**
+        Determines whether the x and y axes should have their scales persist while users filter the data, the timeline being the prime example (set this to `true` to make the axes stay consistent when the timeline changes).
+  */
+    axisPersist(_: any): any;
+    /**
+         A d3plus-shape configuration Object used for styling the background rectangle of the inner x/y plot (behind all of the shapes and gridlines).
+  */
+    backgroundConfig(_: any): any;
+    /**
+        The pixel space between each bar in a group of bars.
+  */
+    barPadding(_: any): any;
+    /**
+        The baseline for the x/y plot.
+  */
+    baseline(_: any): any;
+    /**
+        Determines whether or not to add additional padding at the ends of x or y scales. The most commone use for this is in Scatter Plots, so that the shapes do not appear directly on the axis itself. The value provided can either be `true` or `false` to toggle the behavior for all shape types, or a keyed Object for each shape type (ie. `{Bar: false, Circle: true, Line: false}`).
+  */
+    buffer(_: any): any;
+    /**
+         The confidence interval as an array of [lower, upper] bounds.
+  
+  @example <caption>Can be called with accessor functions or static keys:</caption>
+         var data = {id: "alpha", value: 10, lci: 9, hci: 11};
+         ...
+         // Accessor functions
+         .confidence([function(d) { return d.lci }, function(d) { return d.hci }])
+  
+         // Or static keys
+         .confidence(["lci", "hci"])
+  */
+    confidence(_: any): any;
+    /**
+         Configuration object for shapes rendered as confidence intervals.
+  */
+    confidenceConfig(_: any): any;
+    /**
+        When the width or height of the chart is less than or equal to this pixel value, the discrete axis will not be shown. This helps produce slick sparklines. Set this value to `0` to disable the behavior entirely.
+  */
+    discreteCutoff(_: any): any;
+    /**
+        The pixel space between groups of bars.
+  */
+    groupPadding(_: any): any;
+    /**
+         The d3plus-shape config used on the Line shapes created to connect lineLabels to the end of their associated Line path.
+  */
+    labelConnectorConfig(_: any): any;
+    /**
+        The behavior to be used when calculating the position and size of each shape's label(s). The value passed can either be the _String_ name of the behavior to be used for all shapes, or an accessor _Function_ that will be provided each data point and will be expected to return the behavior to be used for that data point. The availability and options for this method depend on the default logic for each Shape. As an example, the values "outside" or "inside" can be set for Bar shapes, whose "auto" default will calculate the best position dynamically based on the available space.
+  */
+    labelPosition(_: any): any;
+    /**
+        Draws labels on the right side of any Line shapes that are drawn on the plot.
+  */
+    lineLabels(_: any): any;
+    /**
+        Shape config for the Circle shapes drawn by the lineMarkers method.
+  */
+    lineMarkerConfig(_: any): any;
+    /**
+        Draws circle markers on each vertex of a Line.
+  */
+    lineMarkers(_: any): any;
+    /**
+        A JavaScript [sort comparator function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) that receives each shape Class (ie. "Circle", "Line", etc) as it's comparator arguments. Shapes are drawn in groups based on their type, so you are defining the layering order for all shapes of said type.
+  */
+    shapeSort(_: any): any;
+    /**
+        Sets the size of bubbles to the given Number, data key, or function.
+  */
+    size(_: any): any;
+    /**
+        Sets the size scale maximum to the specified number.
+  */
+    sizeMax(_: any): any;
+    /**
+        Sets the size scale minimum to the specified number.
+  */
+    sizeMin(_: any): any;
+    /**
+        Sets the size scale to the specified string.
+  */
+    sizeScale(_: any): any;
+    /**
+        If *value* is specified, toggles shape stacking. If *value* is not specified, returns the current stack value.
+  */
+    stacked(_: any): any;
+    /**
+        Sets the stack offset. If *value* is not specified, returns the current stack offset function.
+  */
+    stackOffset(_: any): any;
+    /**
+        Sets the stack order. If *value* is not specified, returns the current stack order function.
+  */
+    stackOrder(_: any): any;
+    /**
+        Accessor function or string key for the x-axis value of each data point.
+  */
+    x(_: any): any;
+    /**
+         Accessor function or string key for the secondary x-axis value of each data point.
+  */
+    x2(_: any): any;
+    /**
+        A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the x-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+  */
+    xConfig(_: any): any;
+    /**
+        When the width of the chart is less than or equal to this pixel value, and the x-axis is not the discrete axis, it will not be shown. This helps produce slick sparklines. Set this value to `0` to disable the behavior entirely.
+  */
+    xCutoff(_: any): any;
+    /**
+        A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the secondary x-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+  */
+    x2Config(_: any): any;
+    /**
+        The x domain as an array. If either value is undefined, it will be calculated from the data.
+  */
+    xDomain(_: any): any;
+    /**
+         The x2 domain as an array. If either value is undefined, it will be calculated from the data.
+  */
+    x2Domain(_: any): any;
+    /**
+        Defines a custom sorting comparitor function to be used for discrete x axes.
+  */
+    xSort(_: any): any;
+    /**
+         Defines a custom sorting comparitor function to be used for discrete x2 axes.
+  */
+    x2Sort(_: any): any;
+    /**
+        Accessor function or string key for the y-axis value of each data point.
+  */
+    y(_: any): any;
+    /**
+         Accessor function or string key for the secondary y-axis value of each data point.
+  */
+    y2(_: any): any;
+    /**
+        A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the y-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+  
+  *Note:* If a "domain" array is passed to the y-axis config, it will be reversed.
+  */
+    yConfig(_: any): any;
+    /**
+        When the height of the chart is less than or equal to this pixel value, and the y-axis is not the discrete axis, it will not be shown. This helps produce slick sparklines. Set this value to `0` to disable the behavior entirely.
+  */
+    yCutoff(_: any): any;
+    /**
+        A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the secondary y-axis. Includes additional functionality where passing "auto" as the value for the [scale](http://d3plus.org/docs/#Axis.scale) method will determine if the scale should be "linear" or "log" based on the provided data.
+  */
+    y2Config(_: any): any;
+    /**
+        The y domain as an array. If either value is undefined, it will be calculated from the data.
+  */
+    yDomain(_: any): any;
+    /**
+         The y2 domain as an array. If either value is undefined, it will be calculated from the data.
+  */
+    y2Domain(_: any): any;
+    /**
+        Defines a custom sorting comparitor function to be used for discrete y axes.
+  */
+    ySort(_: any): any;
+    /**
+         Defines a custom sorting comparitor function to be used for discrete y2 axes.
+  */
+    y2Sort(_: any): any;
+}

package/types/src/charts/Priestley.d.ts

@@ -0,0 +1,37 @@
+import Viz from "./Viz.js";
+/**
+    Creates a priestley timeline based on an array of data.
+*/
+export default class Priestley extends Viz {
+    [key: string]: any;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+  */
+    constructor();
+    /**
+        Extends the render behavior of the abstract Viz class.
+        @private
+  */
+    _draw(callback?: () => void): this;
+    /**
+        Configuration object for the axis.
+  */
+    axisConfig(_: any): any;
+    /**
+        Accessor function or string key for the end date of each data point.
+  */
+    end(_: any): any;
+    /**
+        The [paddingInner](https://github.com/d3/d3-scale#band_paddingInner) value of the underlining [Band Scale](https://github.com/d3/d3-scale#band-scales) used to determine the height of each bar. Values should be a ratio between 0 and 1 representing the space in between each rectangle.
+  */
+    paddingInner(_: any): any;
+    /**
+        The [paddingOuter](https://github.com/d3/d3-scale#band_paddingOuter) value of the underlining [Band Scale](https://github.com/d3/d3-scale#band-scales) used to determine the height of each bar. Values should be a ratio between 0 and 1 representing the space around the outer rectangles.
+  */
+    paddingOuter(_: any): any;
+    /**
+        Accessor function or string key for the start date of each data point.
+  */
+    start(_: any): any;
+}

package/types/src/charts/Radar.d.ts

@@ -0,0 +1,38 @@
+import Viz from "./Viz.js";
+/**
+    Creates a radar visualization based on an array of data.
+*/
+export default class Radar extends Viz {
+    [key: string]: any;
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Viz.
+        @private
+  */
+    constructor();
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+  */
+    _draw(callback?: () => void): this;
+    /**
+        Configuration object for the radial spokes, circles, and labels.
+  */
+    axisConfig(_: any): any;
+    /**
+        Accessor function for the metric value used as each axis.
+  */
+    metric(_: any): any;
+    /**
+        Determines how much pixel spaces to give the outer labels.
+  */
+    outerPadding(_: any): any;
+    /**
+        The value accessor used to determine each data point's position along each axis.
+  
+  @example
+  function value(d) {
+    return d.value;
+  }
+  */
+    value(_: any): any;
+}

package/types/src/charts/RadialMatrix.d.ts

@@ -0,0 +1,78 @@
+import Viz from "./Viz.js";
+/**
+    Creates a radial layout of a rows/columns Matrix of any dataset. See [this example](https://d3plus.org/examples/d3plus-matrix/radial-matrix/) for help getting started using the Matrix class.
+*/
+export default class RadialMatrix extends Viz {
+    [key: string]: any;
+    /**
+      Invoked when creating a new class instance, and sets any default parameters.
+      @private
+    */
+    constructor();
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+    */
+    _draw(callback?: () => void): this;
+    /**
+        The pixel padding in between each cell.
+  */
+    cellPadding(_: any): any;
+    /**
+        Determines which key in your data should be used for each column in the matrix. Can be either a String that matches a key used in every data point, or an accessor function that receives a data point and it's index in the data array, and is expected to return it's column value.
+  
+  @example
+  function column(d) {
+    return d.name;
+  }
+    */
+    column(_: any): any;
+    /**
+        A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the column labels.
+  */
+    columnConfig(_: any): any;
+    /**
+        A manual list of IDs to be used for rows.
+  */
+    columnList(_: any): any;
+    /**
+        A sort comparator function that is run on the unique set of column values.
+  
+  @example
+  function column(a, b) {
+    return a.localeCompare(b);
+  }
+    */
+    columnSort(_: any): any;
+    /**
+        The radius (in pixels) for the inner donut hole of the diagram. Can either be a static Number, or an accessor function that receives the outer radius as it's only argument.
+  
+  @example
+  function(outerRadius) {
+    return outerRadius / 5;
+  }
+    */
+    innerRadius(_: any): any;
+    /**
+        Determines which key in your data should be used for each row in the matrix. Can be either a String that matches a key used in every data point, or an accessor function that receives a data point and it's index in the data array, and is expected to return it's row value.
+  
+  @example
+  function row(d) {
+    return d.name;
+  }
+    */
+    row(_: any): any;
+    /**
+        A manual list of IDs to be used for rows.
+  */
+    rowList(_: any): any;
+    /**
+        A sort comparator function that is run on the unique set of row values.
+  
+  @example
+  function row(a, b) {
+    return a.localeCompare(b);
+  }
+    */
+    rowSort(_: any): any;
+}

package/types/src/charts/Rings.d.ts

@@ -0,0 +1,74 @@
+import Viz from "./Viz.js";
+/**
+    Creates a ring visualization based on a defined set of nodes and edges. [Click here](http://d3plus.org/examples/d3plus-network/simple-rings/) for help getting started using the Rings class.
+*/
+export default class Rings extends Viz {
+    [key: string]: any;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+  */
+    constructor();
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+  */
+    _draw(callback?: () => void): this;
+    /**
+     The center node, specified by id.
+  */
+    center(_: any): any;
+    /**
+        The hover callback function for highlighting shapes on mouseover.
+  */
+    hover(_: any): this;
+    /**
+        A predefined *Array* of edges that connect each object passed to the [node](#Rings.node) method. The `source` and `target` keys in each link need to map to the nodes in one of three ways:
+  1. The index of the node in the nodes array (as in [this](http://d3plus.org/examples/d3plus-network/getting-started/) example).
+  2. The actual node *Object* itself.
+  3. A *String* value matching the `id` of the node.
+  
+  The value passed should either be an *Array* of data or a *String* representing a filepath or URL to be loaded. An optional formatting function can be passed as a second argument to this method. This custom function will be passed the data that has been loaded, as long as there are no errors. This function should return the final links *Array*.
+      @param f Array of link objects or a URL to load links from.
+  */
+    links(_: any, f?: any): any;
+    /**
+        Defines the thickness of the links connecting each node. The value provided can be either a pixel Number to be used for all links, or an accessor function that returns a specific data value to be used in an automatically calculated linear scale.
+  */
+    linkSize(_: any): any;
+    /**
+        Defines the minimum pixel stroke width used in link sizing.
+  */
+    linkSizeMin(_: any): any;
+    /**
+        The type of [continuous d3-scale](https://github.com/d3/d3-scale#continuous-scales) used when calculating the pixel size of links in the network.
+  */
+    linkSizeScale(_: any): any;
+    /**
+        The node group accessor(s). This method overrides the default .groupBy() function from being used with the data passed to .nodes().
+  */
+    nodeGroupBy(_: any): any;
+    /**
+        The list of nodes to be used for drawing the rings network. The value passed should either be an *Array* of data or a *String* representing a filepath or URL to be loaded.
+  
+  Additionally, a custom formatting function can be passed as a second argument to this method. This custom function will be passed the data that has been loaded, as long as there are no errors. This function should return the final node *Array*.
+      @param f Array of node objects or a URL to load nodes from.
+  */
+    nodes(_: any, f?: any): any;
+    /**
+        The size accessor for each node in the rings layout.
+  */
+    size(_: any): any;
+    /**
+        The size scale maximum. By default, the maximum size is determined by half the distance of the two closest nodes.
+  */
+    sizeMax(_: any): any;
+    /**
+        The size scale minimum.
+  */
+    sizeMin(_: any): any;
+    /**
+        The size scale.
+  */
+    sizeScale(_: any): any;
+}

package/types/src/charts/Sankey.d.ts

@@ -0,0 +1,81 @@
+import Viz from "./Viz.js";
+/**
+    Creates a sankey visualization based on a defined set of nodes and links. [Click here](http://d3plus.org/examples/d3plus-network/sankey-diagram/) for help getting started using the Sankey class.
+*/
+export default class Sankey extends Viz {
+    [key: string]: any;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+  */
+    constructor();
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+  */
+    _draw(callback?: () => void): this;
+    /**
+        The hover callback function for highlighting shapes on mouseover.
+  */
+    hover(_: any): this;
+    /**
+        A pass-through for the d3-sankey [iterations](https://github.com/d3/d3-sankey?tab=readme-ov-file#sankey_iterations) function.
+  */
+    iterations(_: any): any;
+    /**
+        A predefined *Array* of edges that connect each object passed to the [node](#Sankey.node) method. The `source` and `target` keys in each link need to map to the nodes in one of one way:
+  1. A *String* value matching the `id` of the node.
+  
+  The value passed should be an *Array* of data. An optional formatting function can be passed as a second argument to this method. This custom function will be passed the data that has been loaded, as long as there are no errors. This function should return the final links *Array*.
+      @param f Array of link objects or a URL to load links from.
+  */
+    links(_: any, f?: any): any;
+    /**
+        A pass-through for the d3-sankey [linkSort](https://github.com/d3/d3-sankey?tab=readme-ov-file#sankey_linkSort) function.
+  */
+    linkSort(_: any): any;
+    /**
+        The key inside of each link Object that references the source node.
+  */
+    linksSource(_: any): any;
+    /**
+        The key inside of each link Object that references the target node.
+  */
+    linksTarget(_: any): any;
+    /**
+        The nodeAlign property of the sankey layout, which can be "left", "right", "center", or "justify".
+  */
+    nodeAlign(_: any): any;
+    /**
+        The node id accessor(s).
+  */
+    nodeId(_: any): any;
+    /**
+        The list of nodes to be used for drawing the network. The value passed must be an *Array* of data.
+  
+  Additionally, a custom formatting function can be passed as a second argument to this method. This custom function will be passed the data that has been loaded, as long as there are no errors. This function should return the final node *Array*.
+      @param f Array of node objects or a URL to load nodes from.
+  */
+    nodes(_: any, f?: any): any;
+    /**
+        Padding of the node. By default, the nodePadding size is 8.
+  */
+    nodePadding(_: any): any;
+    /**
+        A pass-through for the d3-sankey [nodeSort](https://github.com/d3/d3-sankey?tab=readme-ov-file#sankey_nodeSort) function.
+  */
+    nodeSort(_: any): any;
+    /**
+        Width of the node. By default, the nodeWidth size is 30.
+  */
+    nodeWidth(_: any): any;
+    /**
+        Width of the links.
+  
+  @example
+  function value(d) {
+    return d.value;
+  }
+  */
+    value(_: any): any;
+}

package/types/src/charts/StackedArea.d.ts

@@ -0,0 +1,14 @@
+import { default as AreaPlot } from "./AreaPlot.js";
+/**
+    Creates a stacked area plot based on an array of data.
+    @example <caption>the equivalent of calling:</caption>
+new d3plus.AreaPlot()
+  .stacked(true)
+*/
+export default class StackedArea extends AreaPlot {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Plot.
+        @private
+    */
+    constructor();
+}

package/types/src/charts/Tree.d.ts

@@ -0,0 +1,33 @@
+import Viz from "./Viz.js";
+/**
+    Uses d3's [tree layout](https://github.com/d3/d3-hierarchy#tree) to create a tidy tree chart based on an array of data.
+*/
+export default class Tree extends Viz {
+    [key: string]: any;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+  */
+    constructor();
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+  */
+    _draw(callback?: () => void): this;
+    /**
+        Changes the orientation of the entire Tree, either "vertical" (top to bottom) or "horizontal" (left to right).
+  */
+    orient(_: any): any;
+    /**
+        The separation function between neighboring nodes.
+  
+  From the [d3-hierarchy documentation](https://github.com/d3/d3-hierarchy#tree_separation):
+  > The separation accessor is used to separate neighboring nodes. The separation function is passed two nodes a and b, and must return the desired separation. The nodes are typically siblings, though the nodes may be more distantly related if the layout decides to place such nodes adjacent.
+  
+  @example
+  function separation(a, b) {
+    return a.parent === b.parent ? 1 : 2;
+  }
+  */
+    separation(_: any): any;
+}

package/types/src/charts/Treemap.d.ts

@@ -0,0 +1,51 @@
+import Viz from "./Viz.js";
+/**
+    Uses the [d3 treemap layout](https://github.com/mbostock/d3/wiki/Treemap-Layout) to creates SVG rectangles based on an array of data. See [this example](https://d3plus.org/examples/d3plus-hierarchy/getting-started/) for help getting started using the treemap generator.
+*/
+export default class Treemap extends Viz {
+    [key: string]: any;
+    /**
+      Invoked when creating a new class instance, and sets any default parameters.
+      @private
+  */
+    constructor();
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+  */
+    _draw(callback?: () => void): this;
+    /**
+     * Applies the threshold algorithm for Treemaps.
+     * @param {Array} data The data to process.
+     * @private
+  */
+    _thresholdFunction(data: any): any;
+    /**
+        The inner and outer padding.
+  */
+    layoutPadding(_: any): any;
+    /**
+        Sort comparator function for the treemap layout. Defaults to descending order by the associated input data's numeric value attribute.
+  
+  @example
+  function comparator(a, b) {
+    return b.value - a.value;
+  }
+  */
+    sort(_: any): any;
+    /**
+        The sum accessor used for sizing each rectangle in the treemap.
+  
+  @example
+  function sum(d) {
+    return d.sum;
+  }
+  */
+    sum(_: any): any;
+    /**
+        The tiling method used when calculating the size and position of the rectangles.
+  
+  Can either be a string referring to a d3-hierarchy [tiling method](https://github.com/d3/d3-hierarchy#treemap-tiling), or a custom function in the same format.
+  */
+    tile(_: any): any;
+}