@d3plus/core 3.0.16 → 3.1.1

package/es/src/utils/index.js

@@ -4,4 +4,3 @@ export { default as configPrep } from "./configPrep.js";
 export { default as constant } from "./constant.js";
 export { default as getProp } from "./getProp.js";
 export { default as RESET } from "./RESET.js";
-export { default as uuid } from "./uuid.js";

package/package.json

@@ -1,18 +1,25 @@
 {
   "name": "@d3plus/core",
-  "version": "3.0.16",
+  "version": "3.1.1",
   "description": "Data visualization made easy. A javascript library that extends the popular D3.js to enable fast and beautiful visualizations.",
   "license": "MIT",
   "type": "module",
-  "exports": "./es/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./es/index.js"
+    }
+  },
   "browser": "./umd/d3plus-core.full.js",
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "sideEffects": false,
   "files": [
     "umd",
-    "es"
+    "es",
+    "types"
   ],
   "homepage": "https://d3plus.org",
   "repository": {
@@ -27,43 +34,44 @@
     "data",
     "visualization"
   ],
-  "scripts": {
-    "build:esm": "node ../../scripts/build-esm.js",
-    "build:umd": "node ../../scripts/build-umd.js",
-    "dev": "node ../../scripts/dev.js",
-    "test": "eslint index.js src/**/*.js && eslint --global=it test && mocha 'test/**/*-test.js'"
-  },
   "dependencies": {
-    "@d3plus/color": "3.0.16",
-    "@d3plus/data": "3.0.16",
-    "@d3plus/dom": "3.0.16",
-    "@d3plus/format": "3.0.16",
-    "@d3plus/locales": "3.0.16",
-    "@d3plus/math": "3.0.16",
-    "@d3plus/text": "3.0.16",
-    "@popperjs/core": "^2.11.8",
+    "@floating-ui/dom": "^1.6.0",
     "d3-array": "^3.2.4",
     "d3-brush": "^3.0.0",
-    "d3-collection": "^1.0.7",
     "d3-color": "^3.1.0",
     "d3-composite-projections": "^1.4.0",
     "d3-force": "^3.0.0",
     "d3-geo": "^3.1.1",
     "d3-geo-projection": "^4.0.0",
     "d3-hierarchy": "^3.1.2",
+    "d3-interpolate": "^3.0.1",
     "d3-interpolate-path": "^2.3.0",
     "d3-polygon": "^3.0.1",
-    "d3-queue": "^3.0.7",
     "d3-sankey": "^0.12.3",
     "d3-scale": "^4.0.2",
     "d3-selection": "^3.0.0",
     "d3-shape": "^3.2.0",
     "d3-tile": "^1.0.0",
+    "d3-time-format": "^4.1.0",
     "d3-transition": "^3.0.1",
     "d3-zoom": "^3.0.0",
-    "lrucache": "^1.0.3",
     "open-color": "^1.9.1",
     "textures": "^1.2.3",
-    "topojson-client": "^3.1.0"
+    "topojson-client": "^3.1.0",
+    "@d3plus/dom": "3.1.1",
+    "@d3plus/locales": "3.1.1",
+    "@d3plus/format": "3.1.1",
+    "@d3plus/text": "3.1.1",
+    "@d3plus/data": "3.1.1",
+    "@d3plus/color": "3.1.1",
+    "@d3plus/math": "3.1.1"
+  },
+  "scripts": {
+    "build:esm": "node ../../scripts/build-esm.js",
+    "build:types": "tsc",
+    "build:umd": "node ../../scripts/build-umd.js",
+    "dev": "node ../../scripts/dev.js",
+    "test": "eslint index.ts src/**/*.ts && eslint --global=it test && mocha 'test/**/*-test.js'",
+    "test:coverage": "c8 -r text -r lcov --src src mocha 'test/**/*-test.js'"
   }
 }

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export { AreaPlot, BarChart, BoxWhisker, BumpChart, Donut, Geomap, LinePlot, Matrix, Network, Pack, Pie, Plot, Priestley, Radar, RadialMatrix, Rings, Sankey, StackedArea, Tree, Treemap, Viz, } from "./src/charts/index.js";
+export { Axis, AxisBottom, AxisLeft, AxisRight, AxisTop, ColorScale, Legend, Message, TextBox, Timeline, Tooltip, } from "./src/components/index.js";
+export { Area, Bar, Box, Circle, Image, Line, Path, Rect, Shape, Whisker, } from "./src/shapes/index.js";
+export { accessor, BaseClass, configPrep, constant, RESET, } from "./src/utils/index.js";
+export type { D3plusConfig, AxisConfig, TooltipConfig, } from "./src/utils/index.js";

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

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

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

@@ -0,0 +1,16 @@
+import { default as Plot } from "./Plot.js";
+/**
+    Creates a bar chart based on an array of data.
+    @example <caption>the equivalent of calling:</caption>
+new d3plus.Plot()
+  .baseline(0)
+  .discrete("x")
+  .shape("Bar")
+*/
+export default class BarChart extends Plot {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Plot.
+        @private
+    */
+    constructor();
+}

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

@@ -0,0 +1,11 @@
+import { default as Plot } from "./Plot.js";
+/**
+    Creates a simple box and whisker based on an array of data.
+*/
+export default class BoxWhisker extends Plot {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Plot.
+        @private
+    */
+    constructor();
+}

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

@@ -0,0 +1,36 @@
+import { default as Plot } from "./Plot.js";
+/**
+    Creates a bump chart based on an array of data.
+    @example <caption>the equivalent of calling:</caption>
+new d3plus.Plot()
+  .discrete("x")
+  .shape("Line")
+  .y2(d => this._y(d))
+  .yConfig({
+    tickFormat: val => {
+      const data = this._formattedData;
+      const xDomain = this._xDomain;
+      const startData = data.filter(d => d.x === xDomain[0]);
+      const d = startData.find(d => d.y === val);
+      return this._drawLabel(d, d.i);
+     }
+   })
+  .y2Config({
+    tickFormat: val => {
+      const data = this._formattedData;
+      const xDomain = this._xDomain;
+      const endData = data.filter(d => d.x === xDomain[xDomain.length - 1]);
+      const d = endData.find(d => d.y === val);
+      return this._drawLabel(d, d.i);
+     }
+   })
+  .ySort((a, b) => b.y - a.y)
+  .y2Sort((a, b) => b.y - a.y)
+*/
+export default class BumpChart extends Plot {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Plot.
+        @private
+    */
+    constructor();
+}

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

@@ -0,0 +1,11 @@
+import { default as Pie } from "./Pie.js";
+/**
+    Extends the Pie visualization to create a donut chart.
+*/
+export default class Donut extends Pie {
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+    */
+    constructor();
+}

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

@@ -0,0 +1,120 @@
+import { zoomTransform } from "d3-zoom";
+import type { DataPoint } from "@d3plus/data";
+import Viz from "./Viz.js";
+/**
+    Creates a geographical map with zooming, panning, image tiles, and the ability to layer choropleth paths and coordinate points. See [this example](https://d3plus.org/examples/d3plus-geomap/getting-started/) for help getting started.
+*/
+export default class Geomap extends Viz {
+    [key: string]: any;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+    */
+    constructor();
+    /**
+        Renders map tiles based on the current zoom level.
+        @private
+    */
+    _renderTiles(transform?: ReturnType<typeof zoomTransform>, duration?: number): void;
+    /**
+        Extends the draw behavior of the abstract Viz class.
+        @private
+    */
+    _draw(callback?: () => void): this;
+    /**
+        Topojson files sometimes include small geographies that negatively impact how the library determines the default zoom level (for example, a small island or territory far off the coast that is barely visible to the eye). The fitFilter method can be used to remove specific geographies from the logic used to determine the zooming.
+  
+  The *value* passed can be a single id to remove, an array of ids, or a filter function. Take a look at the [Choropleth Example](http://d3plus.org/examples/d3plus-geomap/getting-started/) to see it in action.
+    */
+    fitFilter(_?: string | string[] | ((d: Record<string, unknown>) => boolean)): this | ((d: Record<string, unknown>) => boolean);
+    /**
+        If the topojson being used to determine the zoom fit (either the main [topojson](#Geomap.topojson) object or the [fitObject](#Geomap.fitObject)) contains multiple geographical sets (for example, a file containing state and county boundaries), use this method to indentify which set to use for the zoom fit.
+  
+  If not specified, the first key in the *Array* returned from using `Object.keys` on the topojson will be used.
+    */
+    fitKey(_?: string): this | string;
+    /**
+        The topojson to be used for the initial projection [fit extent](https://github.com/d3/d3-geo#projection_fitExtent). The value passed should either be a valid Topojson *Object* 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 needs to return the final Topojson *Object*.
+        @param _ `undefined`
+        @param f Topojson data or a URL to load.
+    */
+    fitObject(_?: Record<string, unknown> | string, f?: (data: unknown) => Record<string, unknown>): this | Record<string, unknown>;
+    /**
+        The color visible behind any shapes drawn on the map projection. By default, a color value matching the color used in the map tiles is used to help mask the loading time needed to render the tiles. Any value CSS color value may be used, including hexidecimal, rgb, rgba, and color strings like `"blue"` and `"transparent"`.
+        @param _ "#d4dadc"]
+    */
+    ocean(_?: string): this | string;
+    /**
+        The accessor to be used when detecting coordinate points in the objects passed to the [data](https://d3plus.org/docs/#Viz.data) method. Values are expected to be in the format `[longitude, latitude]`, which is in-line with d3's expected coordinate mapping.
+    */
+    point(_?: ((d: DataPoint, i: number) => number[]) | number[]): this | ((d: DataPoint, i: number) => number[]);
+    /**
+        The accessor or static value to be used for sizing coordinate points.
+    */
+    pointSize(_?: number | ((d: DataPoint, i: number) => number)): this | number | ((d: DataPoint, i: number) => number);
+    /**
+        The maximum pixel radius used in the scale for sizing coordinate points.
+        @param _ 10]
+    */
+    pointSizeMax(_?: number): this | number;
+    /**
+        The minimum pixel radius used in the scale for sizing coordinate points.
+        @param _ 5]
+    */
+    pointSizeMin(_?: number): this | number;
+    /**
+        The map projection used when displaying topojson and coordinate points. All projections from [d3-geo](https://github.com/d3/d3-geo#projections), [d3-geo-projection](https://github.com/d3/d3-geo-projection#api-reference), and [d3-composite-projections](http://geoexamples.com/d3-composite-projections/) are accepted, either as the string name (ie. "geoMercator") or the generator function itself. Map tiles are only usable when the projection is set to Mercator (the default).
+        @param _ "geoMercator"
+    */
+    projection(_?: string | ((...args: unknown[]) => unknown)): this | ((...args: unknown[]) => unknown);
+    /**
+        The outer padding between the edge of the visualization and the shapes drawn. The value passed can be either a single number to be used on all sides, or a CSS string pattern (ie. `"20px 0 10px"`).
+        @param _ 20]
+    */
+    projectionPadding(_?: number | string): this | Record<string, number>;
+    /**
+        An array that corresponds to the value passed to the projection's [rotate](https://github.com/d3/d3-geo#projection_rotate) function. Use this method to shift the centerpoint of a map.
+        @param _ [0, 0]]
+    */
+    projectionRotate(_?: number[]): this | number[];
+    /**
+        Toggles the visibility of the map tiles.
+        @param _ true]
+    */
+    tiles(_?: boolean): this | boolean;
+    /**
+        By default, d3plus uses the `light_all` style provided by [CARTO](https://carto.com/location-data-services/basemaps/) for it's map tiles. The [tileUrl](https://d3plus.org/docs/#Geomap.tileUrl) method changes the base URL used for fetching the tiles, as long as the string passed contains `{x}`, `{y}`, and `{z}` variables enclosed in curly brackets for the zoom logic to load the correct tiles.
+        @param _ "https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png"]
+    */
+    tileUrl(_?: string): this | string;
+    /**
+        The topojson to be used for drawing geographical paths. The value passed should either be a valid Topojson *Object* 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 Topojson *Obejct*.
+        @param _ []
+        @param f Topojson data or a URL to load.
+    */
+    topojson(_?: Record<string, unknown> | string, f?: (data: unknown) => Record<string, unknown>): this | Record<string, unknown>;
+    /**
+        The function is used to set default color of the map.
+        @param _ string
+    */
+    topojsonFill(_?: string | ((d: DataPoint, i: number) => string)): this | string | ((d: DataPoint, i: number) => string);
+    /**
+        If the [topojson](#Geomap.topojson) being used contains boundaries that should not be shown, this method can be used to filter them out of the final output. The *value* passed can be a single id to remove, an array of ids, or a filter function.
+    */
+    topojsonFilter(_?: string | string[] | ((d: Record<string, unknown>) => boolean)): this | ((d: Record<string, unknown>) => boolean);
+    /**
+        If the [topojson](#Geomap.topojson) contains multiple geographical sets (for example, a file containing state and county boundaries), use this method to indentify which set to use.
+  
+  If not specified, the first key in the *Array* returned from using `Object.keys` on the topojson will be used.
+    */
+    topojsonKey(_?: string): this | string;
+    /**
+        The accessor used to map each topojson geometry to it's corresponding [data](https://d3plus.org/docs/#Viz.data) point.
+        @param _ "id"
+    */
+    topojsonId(_?: string | ((d: Record<string, unknown>) => string)): this | ((d: Record<string, unknown>) => string);
+}

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

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

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

@@ -0,0 +1,74 @@
+import type { DataPoint } from "@d3plus/data";
+import Viz from "./Viz.js";
+/**
+    Creates a simple rows/columns Matrix view of any dataset. See [this example](https://d3plus.org/examples/d3plus-matrix/getting-started/) for help getting started using the Matrix class.
+*/
+export default class Matrix 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(_?: number): this | number;
+    /**
+        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(_?: string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint])): this | string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]);
+    /**
+        A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the column labels.
+  */
+    columnConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
+    /**
+        A manual list of IDs to be used for columns.
+  */
+    columnList(_?: DataPoint[keyof DataPoint][]): this | DataPoint[keyof DataPoint][];
+    /**
+        A sort comparator function that is run on the unique set of column values.
+  
+  @example
+  function column(a, b) {
+    return a.localeCompare(b);
+  }
+    */
+    columnSort(_?: (...args: unknown[]) => unknown): this | ((...args: unknown[]) => unknown);
+    /**
+        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(_?: string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint])): this | string | ((d: DataPoint, i: number) => DataPoint[keyof DataPoint]);
+    /**
+        A pass-through to the underlying [Axis](http://d3plus.org/docs/#Axis) config used for the row labels.
+  */
+    rowConfig(_?: Record<string, unknown>): this | Record<string, unknown>;
+    /**
+        A manual list of IDs to be used for rows.
+  */
+    rowList(_?: DataPoint[keyof DataPoint][]): this | DataPoint[keyof DataPoint][];
+    /**
+        A sort comparator function that is run on the unique set of row values.
+  
+  @example
+  function row(a, b) {
+    return a.localeCompare(b);
+  }
+    */
+    rowSort(_?: (...args: unknown[]) => unknown): this | ((...args: unknown[]) => unknown);
+}

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

@@ -0,0 +1,78 @@
+import Viz from "./Viz.js";
+/**
+    Creates a network visualization based on a defined set of nodes and edges. [Click here](http://d3plus.org/examples/d3plus-network/getting-started/) for help getting started using the Network class.
+*/
+export default class Network 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 predefined *Array* of edges that connect each object passed to the [node](#Network.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 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 network.
+  */
+    size(_?: any): any;
+    /**
+        Defines the maximum pixel radius used in size scaling. By default, the maximum size is determined by half the distance of the two closest nodes.
+  */
+    sizeMax(_?: any): any;
+    /**
+        Defines the minimum pixel radius used in size scaling.
+  */
+    sizeMin(_?: any): any;
+    /**
+        The type of [continuous d3-scale](https://github.com/d3/d3-scale#continuous-scales) used when calculating the pixel size of nodes in the network.
+  */
+    sizeScale(_?: any): any;
+    /**
+        The x position accessor for each node. The data passed to .data() takes priority over the .nodes() data array. By default, the x and y positions are determined dynamically based on default force layout properties.
+  */
+    x(_?: any): any;
+    /**
+        The y position accessor for each node. The data passed to .data() takes priority over the .nodes() data array. By default, the x and y positions are determined dynamically based on default force layout properties.
+  */
+    y(_?: any): any;
+}

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

@@ -0,0 +1,47 @@
+import Viz from "./Viz.js";
+/**
+    Uses the [d3 pack layout](https://github.com/d3/d3-hierarchy#pack) to creates Circle Packing chart based on an array of data.
+*/
+export default class Pack 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;
+    /**
+        The inner and outer padding for the pack layout.
+  */
+    layoutPadding(_: any): any;
+    /**
+        The opacity of nested circles within the pack layout.
+  */
+    packOpacity(_: any): any;
+    /**
+        Sort comparator function for the pack 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 circle in the pack layout.
+  
+  @example
+  function sum(d) {
+    return d.sum;
+  }
+  */
+    sum(_: any): any;
+}

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

@@ -0,0 +1,44 @@
+import type { DataPoint } from "@d3plus/data";
+import Viz from "./Viz.js";
+/**
+    Uses the [d3 pie layout](https://github.com/d3/d3-shape#pies) to creates SVG arcs based on an array of data.
+*/
+export default class Pie 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 value, or function that returns a pixel value, that is used as the inner radius of the Pie (creating a Donut).
+  */
+    innerRadius(_?: number | (() => number)): this | number | (() => number);
+    /**
+        The padding between each arc, set as a radian value between \`0\` and \`1\`.
+  
+  If set, this will override any previously set padPixel value.
+  */
+    padAngle(_?: number): this | number;
+    /**
+        The padding between each arc, set as a pixel number value.
+  
+  By default the value is \`0\`, which shows no padding between each arc.
+  
+  If \`padAngle\` is defined, the \`padPixel\` value will not be considered.
+  */
+    padPixel(_?: number): this | number;
+    /**
+        A comparator function that sorts the Pie slices.
+  */
+    sort(_?: (...args: unknown[]) => unknown): this | ((...args: unknown[]) => unknown);
+    /**
+        The accessor key for each data point used to calculate the size of each Pie section.
+    */
+    value(_?: string | ((d: DataPoint, i: number) => number)): this | string | ((d: DataPoint, i: number) => number);
+}