@d3plus/core 3.0.16 → 3.1.0

package/types/src/charts/plotBuffers/Line.d.ts

@@ -0,0 +1,16 @@
+import type Plot from "../Plot.js";
+/**
+    @module lineBuffer
+    Adds a buffer to either side of the non-discrete axis.
+
+
+    @param buffer Defaults to the radius of the largest Circle.
+    @private
+*/
+export default function (this: Plot, { data, x, y, x2, y2, }: {
+    data: Record<string, unknown>[];
+    x: any;
+    y: any;
+    x2?: any;
+    y2?: any;
+}): [unknown, unknown];

package/types/src/charts/plotBuffers/Rect.d.ts

@@ -0,0 +1,19 @@
+import type Plot from "../Plot.js";
+/**
+    @module rectBuffer
+    Adds a buffer to either side of the non-discrete axis.
+
+
+    @param buffer Defaults to the width/height of the largest Rect.
+    @private
+*/
+export default function (this: Plot, { data, x, y, x2, y2, yScale, xScale, config, }: {
+    data: Record<string, unknown>[];
+    x: any;
+    y: any;
+    x2?: any;
+    y2?: any;
+    yScale?: string;
+    xScale?: string;
+    config?: Record<string, (...args: unknown[]) => unknown>;
+}): [unknown, unknown];

package/types/src/charts/plotBuffers/discreteBuffer.d.ts

@@ -0,0 +1,7 @@
+/**
+    @module discreteBuffer
+    Adds left/right padding to a point or time scale.
+    @private
+*/
+declare const discreteBuffer: (scale: any, data: Record<string, unknown>[], discrete: string) => void;
+export default discreteBuffer;

package/types/src/charts/plotBuffers/numericBuffer.d.ts

@@ -0,0 +1,5 @@
+/**
+    @module numericBuffer
+    @private
+*/
+export default function (axis: any, scale: string, value: number, size: number, range: number[], domain: number[], index: number, invert: boolean): number[];

package/types/src/components/Axis.d.ts

@@ -0,0 +1,309 @@
+import { transition } from "d3-transition";
+import type { D3Selection } from "@d3plus/dom";
+import { TextBox } from "../components/index.js";
+import { BaseClass } from "../utils/index.js";
+/**
+    Creates an SVG scale based on an array of data.
+*/
+export default class Axis extends BaseClass {
+    _select: D3Selection;
+    _align: string;
+    _barConfig: Record<string, unknown>;
+    _data: any[];
+    _domain: any[];
+    _duration: number;
+    _gridConfig: Record<string, unknown>;
+    _gridLog: boolean;
+    _gridSize: number | undefined;
+    _grid: unknown[] | undefined;
+    _height: number;
+    _labelOffset: boolean;
+    _labelRotation: boolean | undefined;
+    _labels: unknown[] | undefined;
+    _locale: any;
+    _margin: Record<string, number>;
+    _maxSize: number;
+    _minSize: number;
+    _orient: string;
+    _outerBounds: Record<string, number>;
+    _padding: number;
+    _paddingInner: number;
+    _paddingOuter: number;
+    _position: {
+        horizontal: boolean;
+        width: string;
+        height: string;
+        x: string;
+        y: string;
+        opposite: string;
+    };
+    _range: (number | undefined)[] | undefined;
+    _rounding: string;
+    _roundingInsideMinPrefix: string;
+    _roundingInsideMinSuffix: string;
+    _roundingInsideMaxPrefix: string;
+    _roundingInsideMaxSuffix: string;
+    _scale: string;
+    _scalePadding: number;
+    _shape: string;
+    _shapeConfig: Record<string, any>;
+    _tickFormat: any;
+    _ticks: unknown[] | undefined;
+    _tickSize: number;
+    _tickSuffix: string;
+    _tickUnit: number;
+    _timeLocale: Record<string, unknown> | undefined;
+    _title: string | undefined;
+    _titleClass: TextBox;
+    _titleConfig: Record<string, any>;
+    _width: number;
+    _d3Scale: any;
+    _d3ScaleNegative: any;
+    _group: D3Selection;
+    _lastScale: ((d: unknown) => number) | undefined;
+    _availableTicks: unknown[];
+    _visibleTicks: unknown[];
+    _transition: ReturnType<typeof transition>;
+    _userFormat: ((d: unknown) => string) | false | undefined;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+  */
+    constructor();
+    /**
+        Sets positioning for the axis bar.
+        @param bar @private
+  */
+    _barPosition(bar: any): void;
+    /**
+        Returns the scale's domain, taking into account negative and positive log scales.
+        @private
+  */
+    _getDomain(): unknown[];
+    /**
+        Returns a value's scale position, taking into account negative and positive log scales.
+        @param d @private
+  */
+    _getPosition(d: unknown): number;
+    /**
+        Returns the scale's range, taking into account negative and positive log scales.
+        @private
+  */
+    _getRange(): unknown[];
+    /**
+        Returns the scale's labels, taking into account negative and positive log scales.
+        @private
+  */
+    _getLabels(): unknown[];
+    /**
+        Returns the scale's ticks, taking into account negative and positive log scales.
+        @private
+  */
+    _getTicks(): unknown[];
+    /**
+        Sets positioning for the grid lines.
+        @param lines @private
+  */
+    _gridPosition(lines: any, last?: boolean): void;
+    /**
+        Renders the current Axis to the page.
+      @param callback Optional callback invoked after rendering completes.
+  */
+    render(callback?: (...args: unknown[]) => unknown): this;
+    /**
+        The horizontal alignment.
+  */
+    align(): string;
+    align(_: string): this;
+    /**
+        Axis line style.
+  */
+    barConfig(): Record<string, unknown>;
+    barConfig(_: Record<string, unknown>): this;
+    /**
+        An array of data points, which helps determine which ticks should be shown and which time resolution should be displayed.
+  */
+    data(): any[];
+    data(_: any[]): this;
+    /**
+        Scale domain of the axis.
+  */
+    domain(): any[];
+    domain(_: any[]): this;
+    /**
+        Transition duration of the axis.
+  */
+    duration(): number;
+    duration(_: number): this;
+    /**
+        Grid values of the axis.
+  */
+    grid(): unknown[] | undefined;
+    grid(_: unknown[]): this;
+    /**
+        Grid config of the axis.
+  */
+    gridConfig(): Record<string, unknown>;
+    gridConfig(_: Record<string, unknown>): this;
+    /**
+        Grid behavior of the axis when scale is logarithmic.
+  */
+    gridLog(): boolean;
+    gridLog(_: boolean): this;
+    /**
+        Grid size of the axis.
+  */
+    gridSize(): number | undefined;
+    gridSize(_: number): this;
+    /**
+        Overall height of the axis.
+  */
+    height(): number;
+    height(_: number): this;
+    /**
+        Visible tick labels of the axis.
+  */
+    labels(): unknown[] | undefined;
+    labels(_: unknown[]): this;
+    /**
+        Whether to offset overlapping labels further from the axis to prevent collisions.
+  */
+    labelOffset(): boolean;
+    labelOffset(_: boolean): this;
+    /**
+        Whether to rotate horizontal axis labels -90 degrees.
+  */
+    labelRotation(): boolean | undefined;
+    labelRotation(_: boolean): this;
+    /**
+        Maximum size allowed for the space that contains the axis tick labels and title.
+  */
+    maxSize(): number;
+    maxSize(_: number): this;
+    /**
+        Minimum size alloted for the space that contains the axis tick labels and title.
+  */
+    minSize(): number;
+    minSize(_: number): this;
+    /**
+        The orientation of the shape.
+  */
+    orient(): string;
+    orient(_: string): this;
+    /**
+        Returns the outer bounds of the axis content. Must be called after rendering.
+        @example
+  {"width": 180, "height": 24, "x": 10, "y": 20}
+  */
+    outerBounds(): Record<string, number>;
+    /**
+        The padding between each tick label.
+  */
+    padding(): number;
+    padding(_: number): this;
+    /**
+        The inner padding of band scale.
+  */
+    paddingInner(): number;
+    paddingInner(_: number): this;
+    /**
+        The outer padding of band scales.
+  */
+    paddingOuter(): number;
+    paddingOuter(_: number): this;
+    /**
+        Scale range (in pixels) of the axis. The given array must have 2 values, but one may be `undefined` to allow the default behavior for that value.
+  */
+    range(): (number | undefined)[] | undefined;
+    range(_: (number | undefined)[]): this;
+    /**
+        The rounding method for more evenly spaced ticks at the extents of the scale. Can be "none" (default), "outside", or "inside".
+  */
+    rounding(): string;
+    rounding(_: string): this;
+    /**
+        The prefix for the minimum value of "inside" rounding scales.
+  */
+    roundingInsideMinPrefix(): string;
+    roundingInsideMinPrefix(_: string): this;
+    /**
+        The suffix for the minimum value of "inside" rounding scales.
+  */
+    roundingInsideMinSuffix(): string;
+    roundingInsideMinSuffix(_: string): this;
+    /**
+        The prefix for the maximum value of "inside" rounding scales.
+  */
+    roundingInsideMaxPrefix(): string;
+    roundingInsideMaxPrefix(_: string): this;
+    /**
+        The suffix for the maximum value of "inside" rounding scales.
+  */
+    roundingInsideMaxSuffix(): string;
+    roundingInsideMaxSuffix(_: string): this;
+    /**
+        Scale of the axis.
+  */
+    scale(): string;
+    scale(_: string): this;
+    /**
+        The "padding" property of the scale, often used in point scales.
+  */
+    scalePadding(): number;
+    scalePadding(_: number): this;
+    /**
+        The SVG container element as a d3 selector or DOM element.
+  */
+    select(): D3Selection;
+    select(_: string | HTMLElement): this;
+    /**
+        Tick shape constructor.
+  */
+    shape(): string;
+    shape(_: string): this;
+    /**
+        Tick style of the axis.
+  */
+    shapeConfig(): Record<string, any>;
+    shapeConfig(_: Record<string, any>): this;
+    /**
+        Tick formatter.
+  */
+    tickFormat(): any;
+    tickFormat(_: any): this;
+    /**
+        Tick values of the axis.
+  */
+    ticks(): unknown[] | undefined;
+    ticks(_: unknown[]): this;
+    /**
+        Tick size of the axis.
+  */
+    tickSize(): number;
+    tickSize(_: number): this;
+    /**
+        The tick abbreviation behavior for linear scales. Accepts "normal" (uses formatAbbreviate) or "smallest" (uses the suffix from the smallest tick as reference for every tick).
+  */
+    tickSuffix(): string;
+    tickSuffix(_: string): this;
+    /**
+        Defines a custom locale object to be used in time scale. This object must include the following properties: dateTime, date, time, periods, days, shortDays, months, shortMonths. For more information, you can revise [d3p.d3-time-format](https://github.com/d3/d3-time-format/blob/master/README.md#timeFormatLocale).
+  */
+    timeLocale(): Record<string, unknown> | undefined;
+    timeLocale(_: Record<string, unknown>): this;
+    /**
+        Title of the axis.
+  */
+    title(): string | undefined;
+    title(_: string): this;
+    /**
+        Title configuration of the axis.
+  */
+    titleConfig(): Record<string, unknown>;
+    titleConfig(_: Record<string, unknown>): this;
+    /**
+        Overall width of the axis.
+  */
+    width(): number;
+    width(_: number): this;
+}

package/types/src/components/AxisBottom.d.ts

@@ -0,0 +1,11 @@
+import { default as Axis } from "./Axis.js";
+/**
+    Shorthand method for creating an axis where the ticks are drawn below the horizontal domain path. Extends all functionality of the base [Axis](#Axis) class.
+*/
+export default class AxisBottom extends Axis {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Axis.
+        @private
+    */
+    constructor();
+}

package/types/src/components/AxisLeft.d.ts

@@ -0,0 +1,11 @@
+import { default as Axis } from "./Axis.js";
+/**
+    Shorthand method for creating an axis where the ticks are drawn to the left of the vertical domain path. Extends all functionality of the base [Axis](#Axis) class.
+*/
+export default class AxisLeft extends Axis {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Axis.
+        @private
+    */
+    constructor();
+}

package/types/src/components/AxisRight.d.ts

@@ -0,0 +1,11 @@
+import { default as Axis } from "./Axis.js";
+/**
+    Shorthand method for creating an axis where the ticks are drawn to the right of the vertical domain path. Extends all functionality of the base [Axis](#Axis) class.
+*/
+export default class AxisRight extends Axis {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Axis.
+        @private
+    */
+    constructor();
+}

package/types/src/components/AxisTop.d.ts

@@ -0,0 +1,11 @@
+import { default as Axis } from "./Axis.js";
+/**
+    Shorthand method for creating an axis where the ticks are drawn above the vertical domain path. Extends all functionality of the base [Axis](#Axis) class.
+*/
+export default class AxisTop extends Axis {
+    /**
+        Invoked when creating a new class instance, and overrides any default parameters inherited from Axis.
+        @private
+    */
+    constructor();
+}

package/types/src/components/ColorScale.d.ts

@@ -0,0 +1,208 @@
+import type { D3Selection } from "@d3plus/dom";
+import type { DataPoint } from "@d3plus/data";
+import { Axis, TextBox } from "../components/index.js";
+import { Rect } from "../shapes/index.js";
+import { BaseClass } from "../utils/index.js";
+import Legend from "./Legend.js";
+/**
+    Creates an SVG color scale based on an array of data.
+*/
+export default class ColorScale extends BaseClass {
+    _select: D3Selection;
+    _axisClass: Axis;
+    _axisConfig: Record<string, unknown>;
+    _axisTest: Axis;
+    _align: string;
+    _buckets: number | number[];
+    _bucketAxis: boolean;
+    _bucketFormat: (tick: number, i: number, ticks: number[], allValues: number[]) => string;
+    _bucketJoiner: (a: string, b: string) => string;
+    _centered: boolean;
+    _color: string | string[];
+    _colorMax: string;
+    _colorMid: string;
+    _colorMin: string;
+    _colorScale: any;
+    _data: DataPoint[];
+    _domain: number[] | undefined;
+    _duration: number;
+    _group: D3Selection;
+    _height: number;
+    _labelClass: TextBox;
+    _labelConfig: Record<string, unknown>;
+    _labelMin: string | undefined;
+    _labelMax: string | undefined;
+    _legendClass: Legend;
+    _legendConfig: Record<string, unknown>;
+    _midpoint: number;
+    _orient: string;
+    _outerBounds: Record<string, number>;
+    _padding: number;
+    _rectClass: Rect;
+    _rectConfig: Record<string, unknown>;
+    _scale: string;
+    _size: number;
+    _value: (d: DataPoint, i?: number) => unknown;
+    _width: number;
+    /**
+        Invoked when creating a new class instance, and sets any default parameters.
+        @private
+  */
+    constructor();
+    /**
+        Renders the current ColorScale to the page.
+      @param callback Optional callback invoked after rendering completes.
+  */
+    render(callback?: (...args: unknown[]) => unknown): this;
+    /**
+        The [ColorScale](http://d3plus.org/docs/#ColorScale) is constructed by combining an [Axis](http://d3plus.org/docs/#Axis) for the ticks/labels and a [Rect](http://d3plus.org/docs/#Rect) for the actual color box (or multiple boxes, as in a jenks scale). Because of this, there are separate configs for the [Axis](http://d3plus.org/docs/#Axis) class used to display the text ([axisConfig](http://d3plus.org/docs/#ColorScale.axisConfig)) and the [Rect](http://d3plus.org/docs/#Rect) class used to draw the color breaks ([rectConfig](http://d3plus.org/docs/#ColorScale.rectConfig)). This method acts as a pass-through to the config method of the [Axis](http://d3plus.org/docs/#Axis). An example usage of this method can be seen [here](http://d3plus.org/examples/d3plus-legend/colorScale-dark/).
+  */
+    axisConfig(): Record<string, unknown>;
+    axisConfig(_: Record<string, unknown>): this;
+    /**
+        The horizontal alignment.
+  */
+    align(): string;
+    align(_: string): this;
+    /**
+        The number of discrete buckets to create in a bucketed color scale. Will be overridden by any custom Array of colors passed to the `color` method. Optionally, users can supply an Array of values used to separate buckets, such as `[0, 10, 25, 50, 90]` for a percentage scale. This value would create 4 buckets, with each value representing the break point between each bucket (so 5 values makes 4 buckets).
+  */
+    buckets(): number | number[];
+    buckets(_: number | number[]): this;
+    /**
+        Determines whether or not to use an Axis to display bucket scales (both "buckets" and "jenks"). When set to `false`, bucketed scales will use the `Legend` class to display squares for each range of data. When set to `true`, bucketed scales will be displayed on an `Axis`, similar to "linear" scales.
+  */
+    bucketAxis(): boolean;
+    bucketAxis(_: boolean): this;
+    /**
+        A function for formatting the labels associated to each bucket in a bucket-type scale ("jenks", "quantile", etc). The function is passed four arguments: the start value of the current bucket, it's index in the full Array of buckets, the full Array of buckets, and an Array of every value present in the data used to construct the buckets. Keep in mind that the end value for the bucket is not actually the next bucket in the list, but includes every value up until that next bucket value (less than, but not equal to). By default, d3plus will make the end value slightly less than it's current value, so that it does not overlap with the start label for the next bucket.
+  */
+    bucketFormat(): (tick: number, i: number, ticks: number[], allValues: number[]) => string;
+    bucketFormat(_: (tick: number, i: number, ticks: number[], allValues: number[]) => string): this;
+    /**
+        A function that receives the minimum and maximum values of a bucket, and is expected to return the full label.
+  */
+    bucketJoiner(): (a: string, b: string) => string;
+    bucketJoiner(_: (a: string, b: string) => string): this;
+    /**
+        Determines whether or not to display a midpoint centered Axis. Does not apply to quantile scales.
+  */
+    centered(): boolean;
+    centered(_: boolean): this;
+    /**
+        Overrides the default internal logic of `colorMin`, `colorMid`, and `colorMax` to only use just this specified color. If a single color is given as a String, then the scale is interpolated by lightening that color. Otherwise, the function expects an Array of color values to be used in order for the scale.
+  */
+    color(): string | string[];
+    color(_: string | string[]): this;
+    /**
+        Defines the color to be used for numbers greater than the value of the `midpoint` on the scale (defaults to `0`). Colors in between this value and the value of `colorMid` will be interpolated, unless a custom Array of colors has been specified using the `color` method.
+  */
+    colorMax(): string;
+    colorMax(_: string): this;
+    /**
+        Defines the color to be used for the midpoint of a diverging scale, based on the current value of the `midpoint` method (defaults to `0`). Colors in between this value and the values of `colorMin` and `colorMax` will be interpolated, unless a custom Array of colors has been specified using the `color` method.
+  */
+    colorMid(): string;
+    colorMid(_: string): this;
+    /**
+        Defines the color to be used for numbers less than the value of the `midpoint` on the scale (defaults to `0`). Colors in between this value and the value of `colorMid` will be interpolated, unless a custom Array of colors has been specified using the `color` method.
+  */
+    colorMin(): string;
+    colorMin(_: string): this;
+    /**
+        The data array used to create shapes. A shape key will be drawn for each object in the array.
+  */
+    data(): DataPoint[];
+    data(_: DataPoint[]): this;
+    /**
+        In a linear scale, this Array of 2 values defines the min and max values used in the color scale. Any values outside of this range will be mapped to the nearest color value.
+  */
+    domain(): number[] | undefined;
+    domain(_: number[]): this;
+    /**
+        Transition duration of the ColorScale.
+  */
+    duration(): number;
+    duration(_: number): this;
+    /**
+        Overall height of the ColorScale.
+  */
+    height(): number;
+    height(_: number): this;
+    /**
+        A pass-through for the [TextBox](http://d3plus.org/docs/#TextBox) class used to style the labelMin and labelMax text.
+  */
+    labelConfig(): Record<string, unknown>;
+    labelConfig(_: Record<string, unknown>): this;
+    /**
+        Defines a text label to be displayed off of the end of the minimum point in the scale (currently only available in horizontal orientation).
+  */
+    labelMin(): string | undefined;
+    labelMin(_: string): this;
+    /**
+        Defines a text label to be displayed off of the end of the maximum point in the scale (currently only available in horizontal orientation).
+  */
+    labelMax(): string | undefined;
+    labelMax(_: string): this;
+    /**
+        The [ColorScale](http://d3plus.org/docs/#ColorScale) is constructed by combining an [Axis](http://d3plus.org/docs/#Axis) for the ticks/labels and a [Rect](http://d3plus.org/docs/#Rect) for the actual color box (or multiple boxes, as in a jenks scale). Because of this, there are separate configs for the [Axis](http://d3plus.org/docs/#Axis) class used to display the text ([axisConfig](http://d3plus.org/docs/#ColorScale.axisConfig)) and the [Rect](http://d3plus.org/docs/#Rect) class used to draw the color breaks ([rectConfig](http://d3plus.org/docs/#ColorScale.rectConfig)). This method acts as a pass-through to the config method of the [Axis](http://d3plus.org/docs/#Axis). An example usage of this method can be seen [here](http://d3plus.org/examples/d3plus-legend/colorScale-dark/).
+  */
+    legendConfig(): Record<string, unknown>;
+    legendConfig(_: Record<string, unknown>): this;
+    /**
+        The number value to be used as the anchor for `colorMid`, and defines the center point of the diverging color scale.
+  */
+    midpoint(): number;
+    midpoint(_: number): this;
+    /**
+        The flow orientation of the ColorScale items.
+  */
+    orient(): string;
+    orient(_: string): this;
+    /**
+        Returns the outer bounds of the ColorScale content. Must be called after rendering.
+        @example
+  {"width": 180, "height": 24, "x": 10, "y": 20}
+  */
+    outerBounds(): Record<string, number>;
+    /**
+        The padding between each key.
+  */
+    padding(): number;
+    padding(_: number): this;
+    /**
+        The [ColorScale](http://d3plus.org/docs/#ColorScale) is constructed by combining an [Axis](http://d3plus.org/docs/#Axis) for the ticks/labels and a [Rect](http://d3plus.org/docs/#Rect) for the actual color box (or multiple boxes, as in a jenks scale). Because of this, there are separate configs for the [Axis](http://d3plus.org/docs/#Axis) class used to display the text ([axisConfig](http://d3plus.org/docs/#ColorScale.axisConfig)) and the [Rect](http://d3plus.org/docs/#Rect) class used to draw the color breaks ([rectConfig](http://d3plus.org/docs/#ColorScale.rectConfig)). This method acts as a pass-through to the config method of the [Rect](http://d3plus.org/docs/#Rect). An example usage of this method can be seen [here](http://d3plus.org/examples/d3plus-legend/colorScale-dark/).
+  */
+    rectConfig(): Record<string, unknown>;
+    rectConfig(_: Record<string, unknown>): this;
+    /**
+        Scale of the ColorScale.
+  */
+    scale(): string;
+    scale(_: string): this;
+    /**
+        The SVG container element for this visualization. 3 selector or DOM element.
+  */
+    select(): D3Selection;
+    select(_: string | HTMLElement): this;
+    /**
+        The height of horizontal color scales, and width when positioned vertical.
+  */
+    size(): number;
+    size(_: number): this;
+    /**
+        The value accessor used to determine each data point's position on the color scale.
+  
+  @example
+  function value(d) {
+    return d.value;
+  }
+  */
+    value(): (d: DataPoint, i?: number) => DataPoint[keyof DataPoint];
+    value(_: ((d: DataPoint, i?: number) => DataPoint[keyof DataPoint]) | string): this;
+    /**
+        Overall width of the ColorScale.
+  */
+    width(): number;
+    width(_: number): this;
+}