admin/react
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
root
2025-12-28 20:50:08 +00:00
commit b1cd61c7b1
16845 changed files with 1594292 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
node_modules/@types/d3-array/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-array/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-array`
# Summary
This package contains type definitions for d3-array (https://github.com/d3/d3-array).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-array.
### Additional Details
* Last updated: Fri, 12 Sep 2025 20:02:35 GMT
* Dependencies: none
# Credits
These definitions were written by [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [Tom Wanzek](https://github.com/tomwanzek), [denisname](https://github.com/denisname), [Hugues Stefanski](https://github.com/ledragon), [Nathan Bierema](https://github.com/Methuselah96), and [Fil](https://github.com/Fil).

1118
node_modules/@types/d3-array/index.d.ts generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

56
node_modules/@types/d3-array/package.json generated vendored Normal file
View File

@@ -0,0 +1,56 @@
{
"name": "@types/d3-array",
"version": "3.2.2",
"description": "TypeScript definitions for d3-array",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-array",
"license": "MIT",
"contributors": [
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "denisname",
"githubUsername": "denisname",
"url": "https://github.com/denisname"
},
{
"name": "Hugues Stefanski",
"githubUsername": "ledragon",
"url": "https://github.com/ledragon"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
},
{
"name": "Fil",
"githubUsername": "Fil",
"url": "https://github.com/Fil"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-array"
},
"scripts": {},
"dependencies": {},
"peerDependencies": {},
"typesPublisherContentHash": "d8ff015b14e99aec79f6ac45682bd8237145131c804b94de0ed1e6bc003d5190",
"typeScriptVersion": "5.2"
}

21
node_modules/@types/d3-color/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-color/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-color`
# Summary
This package contains type definitions for d3-color (https://github.com/d3/d3-color/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-color.
### Additional Details
* Last updated: Tue, 07 Nov 2023 15:11:36 GMT
* Dependencies: none
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), [Hugues Stefanski](https://github.com/ledragon), [Nathan Bierema](https://github.com/Methuselah96), and [Fil](https://github.com/Fil).

669
node_modules/@types/d3-color/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,669 @@
// Last module patch version validated against: 3.1.0
// ---------------------------------------------------------------------------
// Shared Type Definitions and Interfaces
// ---------------------------------------------------------------------------
/**
* Type allowing for color objects from a specified color space
*/
export type ColorSpaceObject = RGBColor | HSLColor | LabColor | HCLColor | CubehelixColor;
/**
* A helper interface of methods common to color objects (including colors defined outside the d3-color standard module,
* e.g. in d3-hsv). This interface
*/
export interface ColorCommonInstance {
/**
* Returns true if and only if the color is displayable on standard hardware.
* For example, this returns false for an RGB color if any channel value is less than zero or greater than 255, or if the opacity is not in the range [0, 1].
*/
displayable(): boolean;
/**
* Returns a string representing this color according to the CSS Object Model specification,
* such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
* If this color is not displayable, a suitable displayable color is returned instead.
* For example, RGB channel values greater than 255 are clamped to 255.
*/
toString(): string;
/**
* Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
* If k is not specified, it defaults to 1. The behavior of this method is dependent on the implementing color space.
*
* @param k A color space dependent number to determine, how much brighter the returned color should be.
*/
brighter(k?: number): this;
/**
* Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
* If k is not specified, it defaults to 1. The behavior of this method is dependent on the implementing color space.
*
* @param k A color space dependent number to determine, how much darker the returned color should be.
*/
darker(k?: number): this;
/**
* Returns the RGB equivalent of this color. For RGB colors, that’s "this".
*/
rgb(): RGBColor;
/**
* Returns a hexadecimal string representing this color.
* If this color is not displayable, a suitable displayable color is returned instead.
* For example, RGB channel values greater than 255 are clamped to 255.
*/
hex(): string;
}
/**
* A Color object which serves as a base class for
* colorspace-specific sub-class implementations.
*/
export interface Color {
/**
* Returns true if and only if the color is displayable on standard hardware.
* For example, this returns false for an RGB color if any channel value is less than zero or greater than 255, or if the opacity is not in the range [0, 1].
*/
displayable(): boolean; // Note: While this method is used in prototyping for colors of specific colorspaces, it should not be called directly, as 'this.rgb' would not be implemented on Color
/**
* Returns a string representing this color according to the CSS Object Model specification,
* such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
* If this color is not displayable, a suitable displayable color is returned instead.
* For example, RGB channel values greater than 255 are clamped to 255.
*/
toString(): string; // Note: While this method is used in prototyping for colors of specific colorspaces, it should not be called directly, as 'this.rgb' would not be implemented on Color
/**
* Returns a hexadecimal string representing this color in RGB space, such as #f7eaba.
* If this color is not displayable, a suitable displayable color is returned instead.
* For example, RGB channel values greater than 255 are clamped to 255.
*/
formatHex(): string;
/**
* Returns a hexadecimal string representing this color in RGBA space, such as #f7eaba90.
* If this color is not displayable, a suitable displayable color is returned instead.
* For example, RGB channel values greater than 255 are clamped to 255.
*/
formatHex8(): string;
/**
* Returns a string representing this color according to the CSS Color Module Level 3 specification, such as hsl(257, 50%, 80%) or hsla(257, 50%, 80%, 0.2).
* If this color is not displayable, a suitable displayable color is returned instead by clamping S and L channel values to the interval [0, 100].
*/
formatHsl(): string;
/**
* Returns a string representing this color according to the CSS Object Model specification, such as rgb(247, 234, 186) or rgba(247, 234, 186, 0.2).
* If this color is not displayable, a suitable displayable color is returned instead by clamping RGB channel values to the interval [0, 255].
*/
formatRgb(): string;
/**
* @deprecated Use color.formatHex.
*/
hex(): string;
}
/**
* A Color factory object, which may also be used with instanceof to test if an object is a color instance.
*/
export interface ColorFactory extends Function {
/**
* Parses the specified CSS Color Module Level 3 specifier string, returning an RGB or HSL color.
* If the specifier was not valid, null is returned.
*
* @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
*/
(cssColorSpecifier: string): RGBColor | HSLColor | null;
/**
* Converts the provided color instance and returns an RGB or HSL color.
*
* @param color A permissible color space instance.
*/
(color: ColorSpaceObject | ColorCommonInstance): RGBColor | HSLColor;
/**
* Prototype of the factory, which can be used for instanceof testing
*/
readonly prototype: Color;
}
/**
* An RGB color object.
*/
export interface RGBColor extends Color {
/**
* Value of red channel
*/
r: number;
/**
* Value of green channel
*/
g: number;
/**
* Value of blue channel
*/
b: number;
/**
* Opacity value
*/
opacity: number;
/**
* Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much brighter the returned color should be.
*/
brighter(k?: number): this;
/**
* Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much darker the returned color should be.
*/
darker(k?: number): this;
/**
* Returns the RGB equivalent of this color.
*/
rgb(): this;
/**
* Returns a copy of this color.
*
* @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
*/
copy(
values?: {
r?: number | undefined;
g?: number | undefined;
b?: number | undefined;
opacity?: number | undefined;
},
): this;
/**
* Returns a new RGB color where the r, g, and b channels are clamped to the range [0, 255] and rounded to the nearest integer value,
* and the opacity is clamped to the range [0, 1].
*/
clamp(): this;
}
/**
* An RGB color factory object, which may also be used with instanceof to test if an object
* is an RGB color instance.
*/
export interface RGBColorFactory extends Function {
/**
* Constructs a new RGB color based on the specified channel values and opacity.
*
* @param r Red channel value.
* @param g Green channel value.
* @param b Blue channel value.
* @param opacity Optional opacity value, defaults to 1.
*/
(r: number, g: number, b: number, opacity?: number): RGBColor;
/**
* Parses the specified CSS Color Module Level 3 specifier string, returning an RGB color.
* If the specifier was not valid, null is returned.
*
* @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
*/
(cssColorSpecifier: string): RGBColor;
/**
* Converts the provided color instance and returns an RGB color. The color instance is converted to the RGB color space using color.rgb.
* Note that unlike color.rgb this method always returns a new instance, even if color is already an RGB color.
*
* @param color A permissible color space instance.
*/
// tslint:disable-next-line:unified-signatures
(color: ColorSpaceObject | ColorCommonInstance): RGBColor;
/**
* Prototype of the factory, which can be used for instanceof testing
*/
readonly prototype: RGBColor;
}
/**
* An HSL color object.
*/
export interface HSLColor extends Color {
/**
* Hue channel value.
*/
h: number;
/**
* Saturation channel value.
*/
s: number;
/**
* Lightness channel value.
*/
l: number;
/**
* Opacity value.
*/
opacity: number;
/**
* Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much brighter the returned color should be.
*/
brighter(k?: number): this;
/**
* Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much darker the returned color should be.
*/
darker(k?: number): this;
/**
* Returns the RGB color equivalent of this color.
*/
rgb(): RGBColor;
/**
* Returns a copy of this color.
*
* @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
*/
copy(
values?: {
h?: number | undefined;
s?: number | undefined;
l?: number | undefined;
opacity?: number | undefined;
},
): this;
/**
* Returns a new HSL color where the h channel is clamped to the range [0, 360), and the s, l, and opacity channels are clamped to the range [0, 1].
*/
clamp(): this;
}
/**
* An HSL color factory object, which may also be used with instanceof to test if an object
* is an HSL color instance.
*/
export interface HSLColorFactory extends Function {
/**
* Constructs a new HSL color based on the specified channel values and opacity.
*
* @param h Hue channel value.
* @param s Saturation channel value.
* @param l Lightness channel value.
* @param opacity Optional opacity value, defaults to 1.
*/
(h: number, s: number, l: number, opacity?: number): HSLColor;
/**
* Parses the specified CSS Color Module Level 3 specifier string, returning an HSL color.
* If the specifier was not valid, null is returned.
*
* @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
*/
(cssColorSpecifier: string): HSLColor;
/**
* Converts the provided color instance and returns an HSL color.
* The color instance is converted to the RGB color space using color.rgb and then converted to HSL.
* (Colors already in the HSL color space skip the conversion to RGB.)
*
* @param color A permissible color space instance.
*/
// tslint:disable-next-line:unified-signatures
(color: ColorSpaceObject | ColorCommonInstance): HSLColor;
/**
* Prototype of the factory, which can be used for instanceof testing
*/
readonly prototype: HSLColor;
}
/**
* A Lab (CIELAB) color object.
*/
export interface LabColor extends Color {
/**
* Lightness typically in the range [0, 100].
*/
l: number;
/**
* Position between red/magenta and green typically in [-160, +160].
*/
a: number;
/**
* Position between yellow and blue typically in [-160, +160].
*/
b: number;
/**
* Opacity value
*/
opacity: number;
/**
* Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much brighter the returned color should be.
*/
brighter(k?: number): this;
/**
* Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much darker the returned color should be.
*/
darker(k?: number): this;
/**
* Returns the RGB color equivalent of this color.
*/
rgb(): RGBColor;
/**
* Returns a copy of this color.
*
* @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
*/
copy(
values?: {
l?: number | undefined;
a?: number | undefined;
b?: number | undefined;
opacity?: number | undefined;
},
): this;
}
/**
* A Lab (CIELAB) color factory object, which may also be used with instanceof to test if an object
* is a Lab color instance.
*/
export interface LabColorFactory extends Function {
/**
* Constructs a new CIELAB color based on the specified channel values and opacity.
*
* @param l Lightness typically in the range [0, 100].
* @param a Position between red/magenta and green typically in [-160, +160].
* @param b Position between yellow and blue typically in [-160, +160].
* @param opacity Optional opacity value, defaults to 1.
*/
(l: number, a: number, b: number, opacity?: number): LabColor;
/**
* Parses the specified CSS Color Module Level 3 specifier string, returning a Lab color.
* If the specifier was not valid, null is returned.
*
* @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
*/
(cssColorSpecifier: string): LabColor;
/**
* Converts the provided color instance and returns a Lab color.
* The color instance is converted to the RGB color space using color.rgb and then converted to CIELAB.
* (Colors already in the Lab color space skip the conversion to RGB,
* and colors in the HCL color space are converted directly to CIELAB.)
*
* @param color A permissible color space instance.
*/
// tslint:disable-next-line:unified-signatures
(color: ColorSpaceObject | ColorCommonInstance): LabColor;
/**
* Prototype of the factory, which can be used for instanceof testing
*/
readonly prototype: LabColor;
}
/**
* A gray color factory for Lab (CIELAB) colors.
*/
export type GrayColorFactory =
/**
* Constructs a new CIELAB color with the specified l value and a = b = 0.
*
* @param l Lightness typically in the range [0, 100].
* @param opacity Optional opacity value, defaults to 1.
*/
(l: number, opacity?: number) => LabColor;
/**
* An HCL (CIELCH) color object.
*/
export interface HCLColor extends Color {
/**
* Hue channel value typically in [0, 360).
*/
h: number;
/**
* Chroma channel value typically in [0, 230].
*/
c: number;
/**
* Luminance channel value typically in the range [0, 100].
*/
l: number;
/**
* Opacity value
*/
opacity: number;
/**
* Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much brighter the returned color should be.
*/
brighter(k?: number): this;
/**
* Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much darker the returned color should be.
*/
darker(k?: number): this;
/**
* Returns the RGB color equivalent of this color.
*/
rgb(): RGBColor;
/**
* Returns a copy of this color.
*
* @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
*/
copy(
values?: {
h?: number | undefined;
c?: number | undefined;
l?: number | undefined;
opacity?: number | undefined;
},
): this;
}
/**
* An HCL (CIELCH) color factory object, which may also be used with instanceof to test if an object
* is an HCL color instance.
*/
export interface HCLColorFactory extends Function {
/**
* Constructs a new HCL color based on the specified channel values and opacity.
*
* @param h Hue channel value typically in [0, 360).
* @param c Chroma channel value typically in [0, 230].
* @param l Luminance channel value typically in the range [0, 100].
* @param opacity Optional opacity value, defaults to 1.
*/
(h: number, c: number, l: number, opacity?: number): HCLColor;
/**
* Parses the specified CSS Color Module Level 3 specifier string, returning an HCL color.
* If the specifier was not valid, null is returned.
*
* @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
*/
(cssColorSpecifier: string): HCLColor;
/**
* Converts the provided color instance and returns an HCL color.
* The color instance is converted to the RGB color space using color.rgb and then converted to HCL.
* (Colors already in the HCL color space skip the conversion to RGB,
* and colors in the Lab color space are converted directly to HCL.)
*
* @param color A permissible color space instance.
*/
// tslint:disable-next-line:unified-signatures
(color: ColorSpaceObject | ColorCommonInstance): HCLColor;
/**
* Prototype of the factory, which can be used for instanceof testing
*/
readonly prototype: HCLColor;
}
/**
* An LCH (CIELCH) color factory function to create an HCL color object.
*/
export interface LCHColorFactory {
/**
* Constructs a new HCL color based on the specified channel values and opacity.
*
* @param l Luminance channel value typically in the range [0, 100].
* @param c Chroma channel value typically in [0, 230].
* @param h Hue channel value typically in [0, 360).
* @param opacity Optional opacity value, defaults to 1.
*/
(l: number, c: number, h: number, opacity?: number): HCLColor;
/**
* Parses the specified CSS Color Module Level 3 specifier string, returning an HCL color.
* If the specifier was not valid, null is returned.
*
* @param cssColorSpecifier A CSS color Module Level 3 specifier string.
*/
(cssColorSpecifier: string): HCLColor;
/**
* Converts the provided color instance and returns an HCL color.
* The color instance is converted to the RGB color space using color.rgb and then converted to HCL.
* (Colors already in the HCL color space skip the conversion to RGB,
* and colors in the Lab color space are converted directly to HCL.)
*
* @param color A permissible color space instance.
*/
// tslint:disable-next-line:unified-signatures
(color: ColorSpaceObject | ColorCommonInstance): HCLColor;
}
/**
* Dave Green’s Cubehelix color object.
*/
export interface CubehelixColor extends Color {
/**
* Hue channel value.
*/
h: number;
/**
* Saturation channel value.
*/
s: number;
/**
* Lightness channel value.
*/
l: number;
/**
* Opacity value.
*/
opacity: number;
/**
* Returns a brighter copy of this color. If k is specified, it controls how much brighter the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much brighter the returned color should be.
*/
brighter(k?: number): this;
/**
* Returns a darker copy of this color. If k is specified, it controls how much darker the returned color should be.
* If k is not specified, it defaults to 1.
*
* @param k A color space dependent number to determine, how much darker the returned color should be.
*/
darker(k?: number): this;
/**
* Returns the RGB color equivalent of this color.
*/
rgb(): RGBColor;
/**
* Returns a copy of this color.
*
* @param values If values is specified, any enumerable own properties of values are assigned to the new returned color.
*/
copy(
values?: {
h?: number | undefined;
s?: number | undefined;
l?: number | undefined;
opacity?: number | undefined;
},
): this;
}
/**
* A color factory object for Dave Green's Cubehelix colors, which may also be used with instanceof to test if an object
* is a Cubehelix color instance.
*/
export interface CubehelixColorFactory extends Function {
/**
* Constructs a new Cubehelix color based on the specified channel values and opacity.
*
* @param h Hue channel value.
* @param s Saturation channel value.
* @param l Lightness channel value.
* @param opacity Optional opacity value, defaults to 1.
*/
(h: number, s: number, l: number, opacity?: number): CubehelixColor;
/**
* Parses the specified CSS Color Module Level 3 specifier string, returning an Cubehelix color.
* If the specifier was not valid, null is returned.
*
* @param cssColorSpecifier A CSS Color Module Level 3 specifier string.
*/
(cssColorSpecifier: string): CubehelixColor;
/**
* Converts the provided color instance and returns a Cubehelix color.
* The color instance is specified, it is converted to the RGB color space using color.rgb and then converted to Cubehelix.
* (Colors already in the Cubehelix color space skip the conversion to RGB.)
*
* @param color A permissible color space instance.
*/
// tslint:disable-next-line:unified-signatures
(color: ColorSpaceObject | ColorCommonInstance): CubehelixColor;
/**
* Prototype of the factory, which can be used for instanceof testing
*/
readonly prototype: CubehelixColor;
}
// --------------------------------------------------------------------------
// Color object factories
// --------------------------------------------------------------------------
/**
* A Color factory object, which may also be used with instanceof to test if an object is a color instance.
*/
export const color: ColorFactory;
/**
* An RGB color factory object, which may also be used with instanceof to test if an object
* is an RGB color instance.
*/
export const rgb: RGBColorFactory;
/**
* An HSL color factory object, which may also be used with instanceof to test if an object
* is an HSL color instance.
*/
export const hsl: HSLColorFactory;
/**
* A Lab (CIELAB) color factory object, which may also be used with instanceof to test if an object
* is a Lab color instance.
*/
export const lab: LabColorFactory;
/**
* A gray color factory for Lab (CIELAB) colors.
*/
export const gray: GrayColorFactory;
/**
* An HCL (CIELCH) color factory object, which may also be used with instanceof to test if an object
* is an HCL color instance.
*/
export const hcl: HCLColorFactory;
/**
* An LCH (CIELCH) color factory function to create an HCL color object.
*/
export const lch: LCHColorFactory;
/**
* A color factory object for Dave Green's Cubehelix colors, which may also be used with instanceof to test if an object
* is a Cubehelix color instance.
*/
export const cubehelix: CubehelixColorFactory;

55
node_modules/@types/d3-color/package.json generated vendored Normal file
View File

@@ -0,0 +1,55 @@
{
"name": "@types/d3-color",
"version": "3.1.3",
"description": "TypeScript definitions for d3-color",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-color",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "denisname",
"githubUsername": "denisname",
"url": "https://github.com/denisname"
},
{
"name": "Hugues Stefanski",
"githubUsername": "ledragon",
"url": "https://github.com/ledragon"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
},
{
"name": "Fil",
"githubUsername": "Fil",
"url": "https://github.com/Fil"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-color"
},
"scripts": {},
"dependencies": {},
"typesPublisherContentHash": "89cf9357324cddaa31cfb539b1c33d118648ed55319f2a0d26f24b004975a947",
"typeScriptVersion": "4.5"
}

21
node_modules/@types/d3-ease/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-ease/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-ease`
# Summary
This package contains type definitions for d3-ease (https://github.com/d3/d3-ease/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-ease.
### Additional Details
* Last updated: Tue, 07 Nov 2023 15:11:36 GMT
* Dependencies: none
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

316
node_modules/@types/d3-ease/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,316 @@
// Last module patch version validated against: 3.0.1
// --------------------------------------------------------------------------
// Easing Functions
// --------------------------------------------------------------------------
/**
* Linear easing; the identity function; linear(t) returns t.
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeLinear(normalizedTime: number): number;
/**
* Symmetric quadratic easing; scales quadIn for t in [0, 0.5] and quadOut for t in [0.5, 1]. Also equivalent to poly.exponent(2).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeQuad(normalizedTime: number): number;
/**
* Quadratic easing; equivalent to polyIn.exponent(2).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeQuadIn(normalizedTime: number): number;
/**
* Reverse quadratic easing; equivalent to 1 - quadIn(1 - t). Also equivalent to polyOut.exponent(2).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeQuadOut(normalizedTime: number): number;
/**
* Symmetric quadratic easing; scales quadIn for t in [0, 0.5] and quadOut for t in [0.5, 1]. Also equivalent to poly.exponent(2).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeQuadInOut(normalizedTime: number): number;
/**
* Symmetric cubic easing; scales cubicIn for t in [0, 0.5] and cubicOut for t in [0.5, 1]. Also equivalent to poly.exponent(3).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCubic(normalizedTime: number): number;
/**
* Cubic easing; equivalent to polyIn.exponent(3).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCubicIn(normalizedTime: number): number;
/**
* Reverse cubic easing; equivalent to 1 - cubicIn(1 - t). Also equivalent to polyOut.exponent(3).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCubicOut(normalizedTime: number): number;
/**
* Symmetric cubic easing; scales cubicIn for t in [0, 0.5] and cubicOut for t in [0.5, 1]. Also equivalent to poly.exponent(3).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCubicInOut(normalizedTime: number): number;
/**
* Polynomial easing function factory
*/
export interface PolynomialEasingFactory {
/**
* Calculate eased time.
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
(normalizedTime: number): number;
/**
* Returns a new polynomial easing with the specified exponent e.
* If the exponent is not specified, it defaults to 3, equivalent to cubic.
*
* @param e Exponent for polynomial easing.
*/
exponent(e: number): PolynomialEasingFactory;
}
/**
* Symmetric polynomial easing/easing factory; scales polyIn for t in [0, 0.5] and polyOut for t in [0.5, 1].
* If the exponent is not specified, it defaults to 3, equivalent to cubic.
*/
export const easePoly: PolynomialEasingFactory;
/**
* Polynomial easing/easing factory; raises t to the specified exponent.
* If the exponent is not specified, it defaults to 3, equivalent to cubicIn.
*/
export const easePolyIn: PolynomialEasingFactory;
/**
* Reverse polynomial easing/easing factory; equivalent to 1 - polyIn(1 - t).
* If the exponent is not specified, it defaults to 3, equivalent to cubicOut.
*/
export const easePolyOut: PolynomialEasingFactory;
/**
* Symmetric polynomial easing/easing factory; scales polyIn for t in [0, 0.5] and polyOut for t in [0.5, 1].
* If the exponent is not specified, it defaults to 3, equivalent to cubic.
*/
export const easePolyInOut: PolynomialEasingFactory;
/**
* Symmetric sinusoidal easing; scales sinIn for t in [0, 0.5] and sinOut for t in [0.5, 1].
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeSin(normalizedTime: number): number;
/**
* Sinusoidal easing; returns sin(t).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeSinIn(normalizedTime: number): number;
/**
* Reverse sinusoidal easing; equivalent to 1 - sinIn(1 - t).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeSinOut(normalizedTime: number): number;
/**
* Symmetric sinusoidal easing; scales sinIn for t in [0, 0.5] and sinOut for t in [0.5, 1].
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeSinInOut(normalizedTime: number): number;
/**
* Symmetric exponential easing; scales expIn for t in [0, 0.5] and expOut for t in [0.5, 1].
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeExp(normalizedTime: number): number;
/**
* Exponential easing; raises 2 to the exponent 10 * (t - 1).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeExpIn(normalizedTime: number): number;
/**
* Reverse exponential easing; equivalent to 1 - expIn(1 - t).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeExpOut(normalizedTime: number): number;
/**
* Symmetric exponential easing; scales expIn for t in [0, 0.5] and expOut for t in [0.5, 1].
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeExpInOut(normalizedTime: number): number;
/**
* Symmetric circular easing; scales circleIn for t in [0, 0.5] and circleOut for t in [0.5, 1].
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCircle(normalizedTime: number): number;
/**
* Circular easing.
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCircleIn(normalizedTime: number): number;
/**
* Reverse circular easing; equivalent to 1 - circleIn(1 - t).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCircleOut(normalizedTime: number): number;
/**
* Symmetric circular easing; scales circleIn for t in [0, 0.5] and circleOut for t in [0.5, 1].
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeCircleInOut(normalizedTime: number): number;
/**
* Reverse bounce easing; equivalent to 1 - bounceIn(1 - t).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeBounce(normalizedTime: number): number;
/**
* Bounce easing, like a rubber ball.
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeBounceIn(normalizedTime: number): number;
/**
* Reverse bounce easing; equivalent to 1 - bounceIn(1 - t).
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeBounceOut(normalizedTime: number): number;
/**
* Symmetric bounce easing; scales bounceIn for t in [0, 0.5] and bounceOut for t in [0.5, 1].
*
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
export function easeBounceInOut(normalizedTime: number): number;
/**
* Anticipatory easing function factory
*/
export interface BackEasingFactory {
/**
* Calculate eased time.
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
(normalizedTime: number): number;
/**
* Returns a new back easing with the specified overshoot s.
* The degree of overshoot is configurable; if not specified, it defaults to 1.70158.
*
* @param s Overshoot parameter
*/
overshoot(s: number): BackEasingFactory;
}
/**
* Symmetric anticipatory easing; scales backIn for t in [0, 0.5] and backOut for t in [0.5, 1].
* The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
*/
export const easeBack: BackEasingFactory;
/**
* Anticipatory easing, like a dancer bending their knees before jumping off the floor.
* The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
*/
export const easeBackIn: BackEasingFactory;
/**
* Reverse anticipatory easing; equivalent to 1 - backIn(1 - t).
* The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
*/
export const easeBackOut: BackEasingFactory;
/**
* Symmetric anticipatory easing; scales backIn for t in [0, 0.5] and backOut for t in [0.5, 1].
* The degree of overshoot is configurable; it not specified, it defaults to 1.70158.
*/
export const easeBackInOut: BackEasingFactory;
/**
* Elastic easing function factory
*/
export interface ElasticEasingFactory {
/**
* Calculate eased time.
* @param normalizedTime Normalized time typically in the range [0, 1]
*/
(normalizedTime: number): number;
/**
* Returns a new elastic easing with the specified amplitude a.
* Defaults to 1,if not specified.
*
* @param a Amplitude for elastic easing.
*/
amplitude(a: number): ElasticEasingFactory;
/**
* Returns a new elastic easing with the specified amplitude a.
* Defaults to 0.3,if not specified.
*
* @param p Period for elastic easing.
*/
period(p: number): ElasticEasingFactory;
}
/**
* Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).
* The amplitude and period of the oscillation are configurable;
* if not specified, they default to 1 and 0.3, respectively.
*/
export const easeElastic: ElasticEasingFactory;
/**
* Elastic easing, like a rubber band.
* The amplitude and period of the oscillation are configurable;
* if not specified, they default to 1 and 0.3, respectively.
*/
export const easeElasticIn: ElasticEasingFactory;
/**
* Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).
* The amplitude and period of the oscillation are configurable;
* if not specified, they default to 1 and 0.3, respectively.
*/
export const easeElasticOut: ElasticEasingFactory;
/**
* Symmetric elastic easing; scales elasticIn for t in [0, 0.5] and elasticOut for t in [0.5, 1].
* The amplitude and period of the oscillation are configurable;
* if not specified, they default to 1 and 0.3, respectively.
*/
export const easeElasticInOut: ElasticEasingFactory;

40
node_modules/@types/d3-ease/package.json generated vendored Normal file
View File

@@ -0,0 +1,40 @@
{
"name": "@types/d3-ease",
"version": "3.0.2",
"description": "TypeScript definitions for d3-ease",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-ease",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-ease"
},
"scripts": {},
"dependencies": {},
"typesPublisherContentHash": "2995c518f8de4fa6f2abb2f13065cb4fe65acaea9422f9883b24414ef50cd1ab",
"typeScriptVersion": "4.5"
}

21
node_modules/@types/d3-interpolate/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-interpolate/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-interpolate`
# Summary
This package contains type definitions for d3-interpolate (https://github.com/d3/d3-interpolate/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-interpolate.
### Additional Details
* Last updated: Tue, 07 Nov 2023 15:11:37 GMT
* Dependencies: [@types/d3-color](https://npmjs.com/package/@types/d3-color)
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

387
node_modules/@types/d3-interpolate/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,387 @@
// Last module patch version validated against: 3.0.1
import { ColorCommonInstance } from "d3-color";
// ---------------------------------------------------------------------------
// Shared Type Definitions and Interfaces
// ---------------------------------------------------------------------------
export interface ZoomInterpolator extends Function {
(t: number): ZoomView;
/**
* Recommended duration of zoom transition in milliseconds.
*/
duration: number;
/**
* Given a zoom interpolator, returns a new zoom interpolator using the specified curvature rho.
* When rho is close to 0, the interpolator is almost linear.
* The default curvature is sqrt(2).
* @param rho
*/
rho(rho: number): this;
}
export interface ColorGammaInterpolationFactory extends Function {
(a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
/**
* Returns a new interpolator factory of the same type using the specified *gamma*.
* For example, to interpolate from purple to orange with a gamma of 2.2 in RGB space: `d3.interpolateRgb.gamma(2.2)("purple", "orange")`.
* See Eric Brasseur’s article, [Gamma error in picture scaling](https://web.archive.org/web/20160112115812/http://www.4p8.com/eric.brasseur/gamma.html), for more on gamma correction.
*/
gamma(g: number): ColorGammaInterpolationFactory;
}
/**
* Type zoomView is used to represent a numeric array with three elements.
* In order of appearance the elements correspond to:
* - cx: *x*-coordinate of the center of the viewport
* - cy: *y*-coordinate of the center of the viewport
* - width: size of the viewport
*/
export type ZoomView = [number, number, number];
export type TypedArray =
| Int8Array
| Uint8Array
| Int16Array
| Uint16Array
| Int32Array
| Uint32Array
| Uint8ClampedArray
| Float32Array
| Float64Array;
export type NumberArray = TypedArray | DataView;
// ---------------------------------------------------------------------------
// Interpolation Function Factories
// ---------------------------------------------------------------------------
/**
* Returns an `null` constant interpolator.
*/
export function interpolate(a: any, b: null): (t: number) => null;
/**
* Returns an boolean constant interpolator of value `b`.
*/
export function interpolate(a: any, b: boolean): (t: number) => boolean;
/**
* Returns a `interpolateRgb` interpolator.
*/
export function interpolate(a: string | ColorCommonInstance, b: ColorCommonInstance): (t: number) => string;
/**
* Returns a `interpolateDate` interpolator.
*/
export function interpolate(a: Date, b: Date): (t: number) => Date;
/**
* Returns a `interpolateNumber` interpolator.
*/
export function interpolate(
a: number | { valueOf(): number },
b: number | { valueOf(): number },
): (t: number) => number;
/**
* Returns a `interpolateNumberArray` interpolator.
*/
export function interpolate<T extends NumberArray>(a: NumberArray | number[], b: T): (t: number) => T;
/**
* Returns a `interpolateString` interpolator. If `b` is a string coercible to a color use use `interpolateRgb`.
*/
export function interpolate(a: string | { toString(): string }, b: string): (t: number) => string;
/**
* Returns a `interpolateArray` interpolator.
*/
export function interpolate<U extends any[]>(a: any[], b: U): (t: number) => U;
/**
* Returns a `interpolateObject` interpolator.
*/
export function interpolate<U extends object>(a: any, b: U): (t: number) => U;
/**
* Returns an interpolator between the two numbers `a` and `b`.
* The returned interpolator is equivalent to: `(t) => a * (1 - t) + b * t`.
*/
export function interpolateNumber(
a: number | { valueOf(): number },
b: number | { valueOf(): number },
): (t: number) => number;
/**
* Returns an interpolator between the two numbers `a` and `b`; the interpolator is similar to `interpolateNumber`,
* except it will round the resulting value to the nearest integer.
*/
export function interpolateRound(
a: number | { valueOf(): number },
b: number | { valueOf(): number },
): (t: number) => number;
/**
* Returns an interpolator between the two strings `a` and `b`.
* The string interpolator finds numbers embedded in `a` and `b`, where each number is of the form understood by JavaScript.
* A few examples of numbers that will be detected within a string: `-1`, `42`, `3.14159`, and `6.0221413e+23`.
*
* For each number embedded in `b`, the interpolator will attempt to find a corresponding number in `a`.
* If a corresponding number is found, a numeric interpolator is created using `interpolateNumber`.
* The remaining parts of the string `b` are used as a template.
*
* For example, if `a` is `"300 12px sans-serif"`, and `b` is `"500 36px Comic-Sans"`, two embedded numbers are found.
* The remaining static parts (of string `b`) are a space between the two numbers (`" "`), and the suffix (`"px Comic-Sans"`).
* The result of the interpolator at `t` = 0.5 is `"400 24px Comic-Sans"`.
*/
export function interpolateString(
a: string | { toString(): string },
b: string | { toString(): string },
): (t: number) => string;
/**
* Returns an interpolator between the two dates `a` and `b`.
*
* Note: *no defensive copy* of the returned date is created; the same Date instance is returned for every evaluation of the interpolator.
* No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
*/
export function interpolateDate(a: Date, b: Date): (t: number) => Date;
export type ArrayInterpolator<A extends any[]> = (t: number) => A;
/**
* Returns an interpolator between the two arrays `a` and `b`. Internally, an array template is created that is the same length in `b`.
* For each element in `b`, if there exists a corresponding element in `a`, a generic interpolator is created for the two elements using `interpolate`.
* If there is no such element, the static value from `b` is used in the template.
* Then, for the given parameter `t`, the template’s embedded interpolators are evaluated. The updated array template is then returned.
*
* For example, if `a` is the array `[0, 1]` and `b` is the array `[1, 10, 100]`, then the result of the interpolator for `t = 0.5` is the array `[0.5, 5.5, 100]`.
*
* Note: *no defensive copy* of the template array is created; modifications of the returned array may adversely affect subsequent evaluation of the interpolator.
* No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
*/
export function interpolateArray<A extends any[]>(a: any[], b: A): ArrayInterpolator<A>;
/**
* interpolateNumberArray is called
*/
export function interpolateArray<T extends NumberArray>(a: NumberArray | number[], b: T): (t: number) => T;
/**
* Returns an interpolator between the two arrays of numbers a and b.
* Internally, an array template is created that is the same type and length as b.
* For each element in b, if there exists a corresponding element in a, the values are directly interpolated in the array template.
* If there is no such element, the static value from b is copied.
* The updated array template is then returned.
*
* Note: For performance reasons, no defensive copy is made of the template array and the arguments a and b; modifications of these arrays may affect subsequent evaluation of the interpolator.
*/
export function interpolateNumberArray<T extends NumberArray | number[]>(
a: NumberArray | number[],
b: T,
): (t: number) => T;
/**
* Returns an interpolator between the two objects `a` and `b`. Internally, an object template is created that has the same properties as `b`.
* For each property in `b`, if there exists a corresponding property in `a`, a generic interpolator is created for the two elements using `interpolate`.
* If there is no such property, the static value from `b` is used in the template.
* Then, for the given parameter `t`, the template's embedded interpolators are evaluated and the updated object template is then returned.
*
* For example, if `a` is the object `{x: 0, y: 1}` and `b` is the object `{x: 1, y: 10, z: 100}`, the result of the interpolator for `t = 0.5` is the object `{x: 0.5, y: 5.5, z: 100}`.
*
* Note: *no defensive copy* of the template object is created; modifications of the returned object may adversely affect subsequent evaluation of the interpolator.
* No copy is made for performance reasons; interpolators are often part of the inner loop of animated transitions.
*/
export function interpolateObject<U extends object>(a: any, b: U): (t: number) => U;
/**
* Returns an interpolator between the two 2D CSS transforms represented by `a` and `b`.
* Each transform is decomposed to a standard representation of translate, rotate, *x*-skew and scale; these component transformations are then interpolated.
* This behavior is standardized by CSS: see [matrix decomposition for animation](http://www.w3.org/TR/css3-2d-transforms/#matrix-decomposition).
*/
export function interpolateTransformCss(a: string, b: string): (t: number) => string;
/**
* Returns an interpolator between the two 2D SVG transforms represented by `a` and `b`.
* Each transform is decomposed to a standard representation of translate, rotate, *x*-skew and scale; these component transformations are then interpolated.
* This behavior is standardized by CSS: see [matrix decomposition for animation](http://www.w3.org/TR/css3-2d-transforms/#matrix-decomposition).
*/
export function interpolateTransformSvg(a: string, b: string): (t: number) => string;
/**
* Returns an interpolator between the two views `a` and `b` of a two-dimensional plane,
* based on [“Smooth and efficient zooming and panning”](http://www.win.tue.nl/~vanwijk/zoompan.pdf).
* Each view is defined as an array of three numbers: *cx*, *cy* and *width*.
* The first two coordinates *cx*, *cy* represent the center of the viewport; the last coordinate *width* represents the size of the viewport.
*
* The returned interpolator exposes a *duration* property which encodes the recommended transition duration in milliseconds.
* This duration is based on the path length of the curved trajectory through *x,y* space.
* If you want to a slower or faster transition, multiply this by an arbitrary scale factor (*V* as described in the original paper).
*/
export function interpolateZoom(a: ZoomView, b: ZoomView): ZoomInterpolator;
/**
* Returns a discrete interpolator for the given array of values. The returned interpolator maps `t` in `[0, 1 / n)` to values[0],
* `t` in `[1 / n, 2 / n)` to `values[1]`, and so on, where `n = values.length`. In effect, this is a lightweight quantize scale with a fixed domain of [0, 1].
*/
export function interpolateDiscrete<T>(values: T[]): (t: number) => T;
// Sampling ------------------------------------------------------------------
/**
* Returns `n` uniformly-spaced samples from the specified `interpolator`, where `n` is an integer greater than one.
* The first sample is always at `t = 0`, and the last sample is always at `t = 1`.
* This can be useful in generating a fixed number of samples from a given interpolator,
* such as to derive the range of a [quantize scale](https://github.com/d3/d3-scale#quantize-scales) from a [continuous interpolator](https://github.com/d3/d3-scale#interpolateWarm).
*
* Caution: this method will not work with interpolators that do not return defensive copies of their output,
* such as `d3.interpolateArray`, `d3.interpolateDate` and `d3.interpolateObject`. For those interpolators, you must wrap the interpolator and create a copy for each returned value.
*/
export function quantize<T>(interpolator: (t: number) => T, n: number): T[];
// Color Spaces
/**
* Returns an RGB color space interpolator between the two colors `a` and `b` with a configurable gamma. If the gamma is not specified, it defaults to 1.0.
* The colors `a` and `b` need not be in RGB; they will be converted to RGB using [`d3.rgb`](https://github.com/d3/d3-color#rgb). The return value of the interpolator is an RGB string.
*/
export const interpolateRgb: ColorGammaInterpolationFactory;
/**
* Returns a uniform nonrational B-spline interpolator through the specified array of *colors*, which are converted to RGB color space.
* Implicit control points are generated such that the interpolator returns `colors[0]` at `t = 0` and `colors[colors.length - 1]` at `t = 1`.
* Opacity interpolation is not currently supported. See also `d3.interpolateBasis`, and see [d3-scale-chromatic](https://github.com/d3/d3-scale-chromatic) for examples.
*/
export function interpolateRgbBasis(colors: Array<string | ColorCommonInstance>): (t: number) => string;
/**
* Returns a uniform nonrational B-spline interpolator through the specified array of colors, which are converted to RGB color space.
* The control points are implicitly repeated such that the resulting spline has cyclical C² continuity when repeated around `t` in [0,1];
* this is useful, for example, to create cyclical color scales. Opacity interpolation is not currently supported.
* See also `d3.interpolateBasisClosed, and see [d3-scale-chromatic](https://github.com/d3/d3-scale-chromatic) for examples.
*/
export function interpolateRgbBasisClosed(colors: Array<string | ColorCommonInstance>): (t: number) => string;
/**
* Returns an HSL color space interpolator between the two colors *a* and *b*. The colors *a* and *b* need not be in HSL;
* they will be converted to HSL using `d3.hsl`. If either color’s hue or saturation is NaN, the opposing color’s channel value is used.
* The shortest path between hues is used. The return value of the interpolator is an RGB string.
*/
export function interpolateHsl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
/**
* Like `interpolateHsl`, but does not use the shortest path between hues.
*/
export function interpolateHslLong(
a: string | ColorCommonInstance,
b: string | ColorCommonInstance,
): (t: number) => string;
/**
* Returns a Lab color space interpolator between the two colors *a* and *b*. The colors *a* and *b* need not be in Lab;
* they will be converted to Lab using `d3.lab`. The return value of the interpolator is an RGB string.
*/
export function interpolateLab(a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
/**
* Returns an HCL color space interpolator between the two colors `a` and `b`. The colors `a` and `b` need not be in HCL;
* they will be converted to HCL using `d3.hcl`. If either color’s hue or chroma is NaN, the opposing color’s channel value is used.
* The shortest path between hues is used. The return value of the interpolator is an RGB string.
*/
export function interpolateHcl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): (t: number) => string;
/**
* Like `interpolateHcl`, but does not use the shortest path between hues.
*/
export function interpolateHclLong(
a: string | ColorCommonInstance,
b: string | ColorCommonInstance,
): (t: number) => string;
/**
* Returns a Cubehelix color space interpolator between the two colors `a` and `b` using a configurable `gamma`.
* If the gamma is not specified, it defaults to 1.0. The colors `a` and `b` need not be in Cubehelix;
* they will be converted to Cubehelix using [`d3.cubehelix`](https://github.com/d3/d3-color#cubehelix).
* If either color’s hue or saturation is NaN, the opposing color’s channel value is used. The shortest path between hues is used. The return value of the interpolator is an RGB string.
*/
export const interpolateCubehelix: ColorGammaInterpolationFactory;
/**
* Like `interpolateCubehelix`, but does not use the shortest path between hues.
*/
export const interpolateCubehelixLong: ColorGammaInterpolationFactory;
/**
* Returns an interpolator between the two hue angles `a` and `b`. If either hue is NaN, the opposing value is used.
* The shortest path between hues is used. The return value of the interpolator is a number in `[0, 360)`.
*/
export function interpolateHue(a: number, b: number): (t: number) => number;
// Splines -------------------------------------------------------------------
/**
* Returns a uniform nonrational B-spline interpolator through the specified array of `values`, which must be numbers.
* Implicit control points are generated such that the interpolator returns `values[0]` at `t` = 0 and `values[values.length - 1]` at `t` = 1.
* See also [`d3.curveBasis`](https://github.com/d3/d3-shape#curveBasis).
*/
export function interpolateBasis(splineNodes: number[]): (t: number) => number;
/**
* Returns a uniform nonrational B-spline interpolator through the specified array of `values`, which must be numbers.
* The control points are implicitly repeated such that the resulting one-dimensional spline has cyclical C² continuity when repeated around `t` in [0,1].
* See also [`d3.curveBasisClosed`](https://github.com/d3/d3-shape#curveBasisClosed).
*/
export function interpolateBasisClosed(splineNodes: number[]): (t: number) => number;
// Piecewise -----------------------------------------------------------------
/**
* Returns a piecewise zoom interpolator, composing zoom interpolators for each adjacent pair of zoom view.
* The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
* and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
* For example, to blend through three different zoom views: `d3.piecewise(d3.interpolateZoom, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
*
* interpolate defaults to d3.interpolate.
*/
export function piecewise(values: ZoomView[]): ZoomInterpolator;
/**
* Returns a piecewise zoom interpolator, composing zoom interpolators for each adjacent pair of zoom view.
* The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
* and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
* For example, to blend through three different zoom views: `d3.piecewise(d3.interpolateZoom, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
*/
export function piecewise(
interpolate: (a: ZoomView, b: ZoomView) => ZoomInterpolator,
values: ZoomView[],
): ZoomInterpolator;
/**
* Returns a piecewise array interpolator, composing array interpolators for each adjacent pair of arrays.
* The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
* and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
* For example, to blend through three different arrays: `d3.piecewise(d3.interpolateArray, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
*
* interpolate defaults to d3.interpolate.
*/
export function piecewise<A extends any[]>(values: A[]): ArrayInterpolator<A>;
/**
* Returns a piecewise array interpolator, composing array interpolators for each adjacent pair of arrays.
* The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
* and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
* For example, to blend through three different arrays: `d3.piecewise(d3.interpolateArray, [[0, 0, 1], [0, 0, 10], [0, 0, 15]])`.
*/
export function piecewise<A extends any[]>(
interpolate: (a: any[], b: A) => ArrayInterpolator<A>,
values: A[],
): ArrayInterpolator<A>;
/**
* Returns a piecewise interpolator, composing interpolators for each adjacent pair of values.
* The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
* and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
* For example, to blend through red, green and blue: `d3.piecewise(d3.interpolateRgb.gamma(2.2), ["red", "green", "blue"])`.
*
* interpolate defaults to d3.interpolate.
*/
export function piecewise(values: unknown[]): (t: number) => any;
/**
* Returns a piecewise interpolator, composing interpolators for each adjacent pair of values.
* The returned interpolator maps `t` in `[0, 1 / (n - 1)]` to `interpolate(values[0], values[1])`, `t` in `[1 / (n - 1), 2 / (n - 1)]` to `interpolate(values[1], values[2])`,
* and so on, where `n = values.length`. In effect, this is a lightweight linear scale.
* For example, to blend through red, green and blue: `d3.piecewise(d3.interpolateRgb.gamma(2.2), ["red", "green", "blue"])`.
*/
export function piecewise<TData>(interpolate: (a: TData, b: TData) => unknown, values: TData[]): (t: number) => any;

47
node_modules/@types/d3-interpolate/package.json generated vendored Normal file
View File

@@ -0,0 +1,47 @@
{
"name": "@types/d3-interpolate",
"version": "3.0.4",
"description": "TypeScript definitions for d3-interpolate",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-interpolate",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "denisname",
"githubUsername": "denisname",
"url": "https://github.com/denisname"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-interpolate"
},
"scripts": {},
"dependencies": {
"@types/d3-color": "*"
},
"typesPublisherContentHash": "d315fc677144695b44f1447ef7429c9ff248886716c2e9f742d031abcb319115",
"typeScriptVersion": "4.5"
}

21
node_modules/@types/d3-path/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-path/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-path`
# Summary
This package contains type definitions for d3-path (https://github.com/d3/d3-path/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-path.
### Additional Details
* Last updated: Tue, 04 Feb 2025 22:02:37 GMT
* Dependencies: none
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), and [Nathan Bierema](https://github.com/Methuselah96).

108
node_modules/@types/d3-path/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,108 @@
// Last module patch version validated against: 3.1.0
/**
* A D3 path serializer implementing CanvasPathMethods
*/
export interface Path {
/**
* Move to the specified point ⟨x, y⟩. Equivalent to context.moveTo and SVG’s “moveto” command.
*
* @param x x-Coordinate of point to move to
* @param y y-Coordinate of point to move to
*/
moveTo(x: number, y: number): void;
/**
* Ends the current subpath and causes an automatic straight line to be drawn from the current point to the initial point of the current subpath.
* Equivalent to context.closePath and SVG’s “closepath” command.
*/
closePath(): void;
/**
* Draws a straight line from the current point to the specified point ⟨x, y⟩.
* Equivalent to context.lineTo and SVG’s “lineto” command.
*
* @param x x-Coordinate of point to draw the line to
* @param y y-Coordinate of point to draw the line to
*/
lineTo(x: number, y: number): void;
/**
* Draws a quadratic Bézier segment from the current point to the specified point ⟨x, y⟩, with the specified control point ⟨cpx, cpy⟩.
* Equivalent to context.quadraticCurveTo and SVG’s quadratic Bézier curve commands.
*
* @param cpx x-Coordinate of the control point for the quadratic Bézier curve
* @param cpy y-Coordinate of the control point for the quadratic Bézier curve
* @param x x-Coordinate of point to draw the curve to
* @param y y-Coordinate of point to draw the curve to
*/
quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
/**
* Draws a cubic Bézier segment from the current point to the specified point ⟨x, y⟩, with the specified control points ⟨cpx1, cpy1⟩ and ⟨cpx2, cpy2⟩.
* Equivalent to context.bezierCurveTo and SVG’s cubic Bézier curve commands.
*
* @param cpx1 x-Coordinate of the first control point for the Bézier curve
* @param cpy1 y-Coordinate of the first control point for the Bézier curve
* @param cpx2 x-Coordinate of the second control point for the Bézier curve
* @param cpy2 y-Coordinate of the second control point for the Bézier curve
* @param x x-Coordinate of point to draw the curve to
* @param y y-Coordinate of point to draw the curve to
*/
bezierCurveTo(cpx1: number, cpy1: number, cpx2: number, cpy2: number, x: number, y: number): void;
/**
* Draws a circular arc segment with the specified radius that starts tangent to the line between the current point and the specified point ⟨x1, y1⟩
* and ends tangent to the line between the specified points ⟨x1, y1⟩ and ⟨x2, y2⟩. If the first tangent point is not equal to the current point,
* a straight line is drawn between the current point and the first tangent point. Equivalent to context.arcTo and uses SVG’s elliptical arc curve commands.
*
* @param x1 x-Coordinate of the first tangent point
* @param y1 y-Coordinate of the first tangent point
* @param x2 x-Coordinate of the second tangent point
* @param y2 y-Coordinate of the second tangent point
* @param radius Radius of the arc segment
*/
arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
/**
* Draws a circular arc segment with the specified center ⟨x, y⟩, radius, startAngle and endAngle. If anticlockwise is true,
* the arc is drawn in the anticlockwise direction; otherwise, it is drawn in the clockwise direction.
* If the current point is not equal to the starting point of the arc, a straight line is drawn from the current point to the start of the arc.
* Equivalent to context.arc and uses SVG’s elliptical arc curve commands.
*
* @param x x-Coordinate of the center point of the arc segment
* @param y y-Coordinate of the center point of the arc segment
* @param radius Radius of the arc segment
* @param startAngle Start angle of arc segment
* @param endAngle End angle of arc segment
* @param anticlockwise Flag indicating directionality (true = anti-clockwise, false = clockwise)
*/
arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void;
/**
* Creates a new subpath containing just the four points ⟨x, y⟩, ⟨x + w, y⟩, ⟨x + w, y + h⟩, ⟨x, y + h⟩,
* with those four points connected by straight lines, and then marks the subpath as closed. Equivalent to context.rect and uses SVG’s “lineto” commands.
*
* @param x x-Coordinate of starting point for drawing the rectangle
* @param y y-Coordinate of starting point for drawing the rectangle
* @param w Width of rectangle
* @param h Height of rectangle
*/
rect(x: number, y: number, w: number, h: number): void;
/**
* Returns the string representation of this path according to SVG’s path data specification.
*/
toString(): string;
}
/**
* Construct a D3 Path serializer
*/
export function path(): Path;
/**
* Like {@link path}, except limits the digits after the decimal to the specified number of digits.
* Useful for reducing the size of generated SVG path data.
*/
export function pathRound(digits?: number): Path;

41
node_modules/@types/d3-path/package.json generated vendored Normal file
View File

@@ -0,0 +1,41 @@
{
"name": "@types/d3-path",
"version": "3.1.1",
"description": "TypeScript definitions for d3-path",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-path",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-path"
},
"scripts": {},
"dependencies": {},
"peerDependencies": {},
"typesPublisherContentHash": "a49fc946781c1138c0dd932ed2a34ea60587bcc0b39790e4eb9a51cb32aaa90b",
"typeScriptVersion": "5.0"
}

21
node_modules/@types/d3-scale/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-scale/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-scale`
# Summary
This package contains type definitions for d3-scale (https://github.com/d3/d3-scale/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-scale.
### Additional Details
* Last updated: Wed, 05 Feb 2025 00:46:59 GMT
* Dependencies: [@types/d3-time](https://npmjs.com/package/@types/d3-time)
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), [rulonder](https://github.com/rulonder), and [Nathan Bierema](https://github.com/Methuselah96).

2669
node_modules/@types/d3-scale/index.d.ts generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

53
node_modules/@types/d3-scale/package.json generated vendored Normal file
View File

@@ -0,0 +1,53 @@
{
"name": "@types/d3-scale",
"version": "4.0.9",
"description": "TypeScript definitions for d3-scale",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-scale",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "denisname",
"githubUsername": "denisname",
"url": "https://github.com/denisname"
},
{
"name": "rulonder",
"githubUsername": "rulonder",
"url": "https://github.com/rulonder"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-scale"
},
"scripts": {},
"dependencies": {
"@types/d3-time": "*"
},
"peerDependencies": {},
"typesPublisherContentHash": "c7eb4d63d0dfb659f0f8e359a4de33ed1f690bdea8051641bffa941f06a92f4d",
"typeScriptVersion": "5.0"
}

21
node_modules/@types/d3-shape/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-shape/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-shape`
# Summary
This package contains type definitions for d3-shape (https://github.com/d3/d3-shape/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-shape.
### Additional Details
* Last updated: Mon, 06 Jan 2025 00:46:49 GMT
* Dependencies: [@types/d3-path](https://npmjs.com/package/@types/d3-path)
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), [Nathan Bierema](https://github.com/Methuselah96), and [Fil](https://github.com/Fil).

2680
node_modules/@types/d3-shape/index.d.ts generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

53
node_modules/@types/d3-shape/package.json generated vendored Normal file
View File

@@ -0,0 +1,53 @@
{
"name": "@types/d3-shape",
"version": "3.1.7",
"description": "TypeScript definitions for d3-shape",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-shape",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "denisname",
"githubUsername": "denisname",
"url": "https://github.com/denisname"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
},
{
"name": "Fil",
"githubUsername": "Fil",
"url": "https://github.com/Fil"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-shape"
},
"scripts": {},
"dependencies": {
"@types/d3-path": "*"
},
"peerDependencies": {},
"typesPublisherContentHash": "799d9815b06c799db603989ab56ae5a207ba179664cd07cbc5d754a2e542d4ca",
"typeScriptVersion": "5.0"
}

21
node_modules/@types/d3-time/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-time/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-time`
# Summary
This package contains type definitions for d3-time (https://github.com/d3/d3-time/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-time.
### Additional Details
* Last updated: Mon, 25 Nov 2024 10:02:27 GMT
* Dependencies: none
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

697
node_modules/@types/d3-time/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,697 @@
// Last module patch version validated against: 3.0.0
// ---------------------------------------------------------------
// Interfaces
// ---------------------------------------------------------------
/**
* A D3 Time Interval
*/
export interface TimeInterval {
/**
* Returns a new date representing the latest interval boundary date before or equal to date.
* Equivalent to interval.floor, except it date is not specified, it defaults to the current time.
* For example, d3.timeYear(date) and d3.timeYear.floor(date) are equivalent.
*
* For example, timeDay(date) typically returns 12:00 AM local time on the given date.
*
* This function is idempotent: if the specified date is already floored to the current interval,
* a new date with an identical time is returned.
* Furthermore, the returned date is the minimum expressible value of the associated interval,
* such that interval.floor(interval.floor(date) - 1) returns the preceding interval boundary date.
*
* Note that the == and === operators do not compare by value with Date objects,
* and thus you cannot use them to tell whether the specified date has already been floored.
* Instead, coerce to a number and then compare.
*
* This is more reliable than testing whether the time is 12:00 AM, as in some time zones midnight may not exist due to daylight saving.
*
* @param date A date object.
*/
(date?: Date): Date;
/**
* Returns a new date representing the latest interval boundary date before or equal to date.
*
* For example, timeDay.floor(date) typically returns 12:00 AM local time on the given date.
*
* This method is idempotent: if the specified date is already floored to the current interval,
* a new date with an identical time is returned.
* Furthermore, the returned date is the minimum expressible value of the associated interval,
* such that interval.floor(interval.floor(date) - 1) returns the preceding interval boundary date.
*
* Note that the == and === operators do not compare by value with Date objects,
* and thus you cannot use them to tell whether the specified date has already been floored.
* Instead, coerce to a number and then compare.
*
* This is more reliable than testing whether the time is 12:00 AM, as in some time zones midnight may not exist due to daylight saving.
*
* @param date A date object.
*/
floor(date: Date): Date;
/**
* Returns a new date representing the closest interval boundary date to date.
*
* For example, timeDay.round(date) typically returns 12:00 AM local time on the given date if it is on or before noon,
* and 12:00 AM of the following day if it is after noon.
*
* This method is idempotent: if the specified date is already rounded to the current interval, a new date with an identical time is returned.
*
* @param date A date object.
*/
round(date: Date): Date;
/**
* Returns a new date representing the earliest interval boundary date after or equal to date.
*
* For example, timeDay.ceil(date) typically returns 12:00 AM local time on the date following the given date.
*
* This method is idempotent: if the specified date is already ceilinged to the current interval,
* a new date with an identical time is returned. Furthermore,
* the returned date is the maximum expressible value of the associated interval,
* such that interval.ceil(interval.ceil(date) + 1) returns the following interval boundary date.
*
* @param date A date object.
*/
ceil(date: Date): Date;
/**
* Returns a new date equal to date plus step intervals.
*
* If step is not specified it defaults to 1.
*
* This method does not round the specified date to the interval. For example, if date is today at 5:34 PM,
* then timeDay.offset(date, 1) returns 5:34 PM tomorrow (even if daylight saving changes!).
*
* @param date A date object.
* @param step An optional number of steps to apply when calculating the offset date.
* If step is negative, then the returned date will be before the specified date;
* if step is zero, then a copy of the specified date is returned; if step is not an integer, it is floored.
*/
offset(date: Date, step?: number): Date;
/**
* Returns an array of dates representing every interval boundary after or equal to start (inclusive) and before stop (exclusive).
*
* If step is specified, then every step-th boundary will be returned; for example,
* for the timeDay interval a step of 2 will return every other day.
* If step is not an integer, it is floored.
*
* The first date in the returned array is the earliest boundary after or equal to start;
* subsequent dates are offset by step intervals and floored.
* Thus, two overlapping ranges may be inconsistent.
*
* To make ranges consistent when a step is specified, use CountableInterval.every instead.
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
range(start: Date, stop: Date, step?: number): Date[];
/**
* Returns a new interval that is a filtered subset of this interval using the specified test function.
*
* @param test A test function which is passed a date and should return true if and only if
* the specified date should be considered part of the interval.
*/
filter(test: (date: Date) => boolean): TimeInterval;
}
/**
* A D3 Countable Time Interval
*/
export interface CountableTimeInterval extends TimeInterval {
/**
* Returns the number of interval boundaries after start (exclusive) and before or equal to end (inclusive).
*
* Note that this behavior is slightly different than interval.range,
* because its purpose is to return the zero-based number of the specified end date relative to the specified start date.
*
* @param start A start date object.
* @param end An end date object.
*/
count(start: Date, end: Date): number;
/**
* Returns a filtered view of this interval representing every stepth date.
*
* The meaning of step is dependent on this interval’s parent interval as defined by the field function.
*
* For example, timeMinute.every(15) returns an interval representing every fifteen minutes,
* starting on the hour: :00, :15, :30, :45, etc. Note that for some intervals,
* the resulting dates may not be uniformly-spaced;
* timeDay’s parent interval is timeMonth, and thus the interval number resets at the start of each month.
*
* If step is not valid, returns null. If step is one, returns this interval.
*
* This method can be used in conjunction with interval.range to ensure that two overlapping ranges are consistent.
*
* The returned filtered interval does not support interval.count. See also interval.filter.
*
* @param step Number of steps.
*/
every(step: number): TimeInterval | null;
}
// ---------------------------------------------------------------
// Custom (Countable)Interval Factories
// ---------------------------------------------------------------
/**
* Constructs a new custom interval given the specified floor and offset functions.
*
* The returned custom interval is not countable, i.e. does not expose the methods "count(..)" and "every(...)".
*
* @param floor A floor function which takes a single date as an argument and rounds it down to the nearest interval boundary.
* @param offset An offset function which takes a date and an integer step as arguments and advances
* the specified date by the specified number of boundaries; the step may be positive, negative or zero.
*/
export function timeInterval(
floor: (date: Date) => void,
offset: (date: Date, step: number) => void,
): TimeInterval;
/**
* Constructs a new custom interval given the specified floor, offset and count functions.
*
* The returned custom interval is countable and exposes the methods "count(..)" and "every(...)".
*
* Note: due to an internal optimization, the specified count function must not invoke interval.count on other time intervals.
*
* @param floor A floor function which takes a single date as an argument and rounds it down to the nearest interval boundary.
* @param offset An offset function which takes a date and an integer step as arguments and advances
* the specified date by the specified number of boundaries; the step may be positive, negative or zero.
* @param count A count function which takes a start date and an end date, already floored to the current interval,
* and returns the number of boundaries between the start (exclusive) and end (inclusive).
* Note: due to an internal optimization, the specified count function must not invoke interval.count on other time intervals.
* @param field An optional field function which takes a date, already floored to the current interval,
* and returns the field value of the specified date,
* corresponding to the number of boundaries between this date (exclusive) and the latest previous parent boundary.
* For example, for the timeDay interval, this returns the number of days since the start of the month.
* If a field function is not specified, it defaults to counting the number of interval boundaries since
* the UNIX epoch of January 1, 1970 UTC. The field function defines the behavior of interval.every.
*/
export function timeInterval(
floor: (date: Date) => void,
offset: (date: Date, step: number) => void,
count: (start: Date, end: Date) => number,
field?: (date: Date) => number,
): CountableTimeInterval;
// ---------------------------------------------------------------
// Built-In Factories and Date Array Creators
// ---------------------------------------------------------------
// local time ----------------------------------------------------------
/**
* Milliseconds Interval in Local Time; the shortest available time unit.
*/
export const timeMillisecond: CountableTimeInterval;
/**
* This is a convenience alias for timeMillisecond.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeMilliseconds(start: Date, stop: Date, step?: number): Date[];
/**
* Seconds Interval in Local Time; seconds (e.g., 01:23:45.0000 AM); 1,000 milliseconds.
*/
export const timeSecond: CountableTimeInterval;
/**
* This is a convenience alias for timeSecond.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeSeconds(start: Date, stop: Date, step?: number): Date[];
/**
* Minutes Interval in Local Time; minutes (e.g., 01:02:00 AM); 60 seconds. Note that ECMAScript ignores leap seconds.
*/
export const timeMinute: CountableTimeInterval;
/**
* This is a convenience alias for timeMinute.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeMinutes(start: Date, stop: Date, step?: number): Date[];
/**
* Hours Interval in Local Time; Hours (e.g., 01:00 AM); 60 minutes.
*
* Note that advancing time by one hour in local time can return the same hour or skip an hour due to daylight saving.
*/
export const timeHour: CountableTimeInterval;
/**
* This is a convenience alias for timeHour.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeHours(start: Date, stop: Date, step?: number): Date[];
/**
* Days Interval in Local Time; days (e.g., February 7, 2012 at 12:00 AM); typically 24 hours.
* Days in local time may range from 23 to 25 hours due to daylight saving.
*/
export const timeDay: CountableTimeInterval;
/**
* This is a convenience alias for timeDay.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeDays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval in Local Time. Alias for sunday; 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeWeek: CountableTimeInterval;
/**
* This is a convenience alias for timeWeek.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeWeeks(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Sunday-based weeks in Local Time (e.g., February 5, 2012 at 12:00 AM).
* 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeSunday: CountableTimeInterval;
/**
* This is a convenience alias for timeSunday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeSundays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Monday-based weeks in Local Time (e.g., February 6, 2012 at 12:00 AM).
* 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeMonday: CountableTimeInterval;
/**
* This is a convenience alias for timeMonday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeMondays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Tuesday-based weeks in Local Time (e.g., February 7, 2012 at 12:00 AM).
* 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeTuesday: CountableTimeInterval;
/**
* This is a convenience alias for timeTuesday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeTuesdays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Wednesday-based weeks in Local Time (e.g., February 8, 2012 at 12:00 AM).
* 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeWednesday: CountableTimeInterval;
/**
* This is a convenience alias for timeWednesday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeWednesdays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Thursday-based weeks in Local Time (e.g., February 9, 2012 at 12:00 AM).
* 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeThursday: CountableTimeInterval;
/**
* This is a convenience alias for timeThursday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeThursdays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Friday-based weeks in Local Time (e.g., February 10, 2012 at 12:00 AM).
* 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeFriday: CountableTimeInterval;
/**
* This is a convenience alias for timeFriday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeFridays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Saturday-based weeks in Local Time (e.g., February 11, 2012 at 12:00 AM).
* 7 days and typically 168 hours.
*
* Weeks in local time may range from 167 to 169 hours due on daylight saving.
*/
export const timeSaturday: CountableTimeInterval;
/**
* This is a convenience alias for timeSaturday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeSaturdays(start: Date, stop: Date, step?: number): Date[];
/**
* Month Interval in Local Time; months (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to 31 days.
*/
export const timeMonth: CountableTimeInterval;
/**
* This is a convenience alias for timeMonth.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeMonths(start: Date, stop: Date, step?: number): Date[];
/**
* Year Interval in Local Time; years (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to 366 days.
*/
export const timeYear: CountableTimeInterval;
/**
* This is a convenience alias for timeYear.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function timeYears(start: Date, stop: Date, step?: number): Date[];
// utc Coordinated Universal Time ----------------------------------------------------------
/**
* Milliseconds Interval in Coordinated Universal Time (UTC); the shortest available time unit.
*/
export const utcMillisecond: CountableTimeInterval;
/**
* This is a convenience alias for utcMillisecond.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcMilliseconds(start: Date, stop: Date, step?: number): Date[];
/**
* Seconds Interval in Coordinated Universal Time (UTC); seconds (e.g., 01:23:45.0000 AM); 1,000 milliseconds.
*/
export const utcSecond: CountableTimeInterval;
/**
* This is a convenience alias for utcSecond.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcSeconds(start: Date, stop: Date, step?: number): Date[];
/**
* Minutes Interval in Coordinated Universal Time (UTC); minutes (e.g., 01:02:00 AM); 60 seconds.
* Note that ECMAScript ignores leap seconds.
*/
export const utcMinute: CountableTimeInterval;
/**
* This is a convenience alias for utcMinute.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcMinutes(start: Date, stop: Date, step?: number): Date[];
/**
* Hours Interval in Coordinated Universal Time (UTC); Hours (e.g., 01:00 AM); 60 minutes.
*/
export const utcHour: CountableTimeInterval;
/**
* This is a convenience alias for utcHour.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcHours(start: Date, stop: Date, step?: number): Date[];
/**
* Days Interval in Coordinated Universal Time (UTC); days (e.g., February 7, 2012 at 12:00 AM); 24 hours.
*/
export const utcDay: CountableTimeInterval;
/**
* This is a convenience alias for utcDay.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcDays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval in Local Time. Alias for sunday; 7 days and 168 hours.
*/
export const utcWeek: CountableTimeInterval;
/**
* This is a convenience alias for utcWeek.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcWeeks(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Sunday-based weeks in Coordinated Universal Time (UTC) (e.g., February 5, 2012 at 12:00 AM).
* 7 days and 168 hours.
*/
export const utcSunday: CountableTimeInterval;
/**
* This is a convenience alias for utcSunday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcSundays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Monday-based weeks in Coordinated Universal Time (UTC) (e.g., February 6, 2012 at 12:00 AM).
* 7 days and 168 hours.
*/
export const utcMonday: CountableTimeInterval;
/**
* This is a convenience alias for utcMonday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcMondays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Tuesday-based weeks in Coordinated Universal Time (UTC) (e.g., February 7, 2012 at 12:00 AM).
* 7 days and 168 hours.
*/
export const utcTuesday: CountableTimeInterval;
/**
* This is a convenience alias for utcTuesday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcTuesdays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Wednesday-based weeks in Coordinated Universal Time (UTC) (e.g., February 8, 2012 at 12:00 AM).
* 7 days and 168 hours.
*/
export const utcWednesday: CountableTimeInterval;
/**
* This is a convenience alias for utcWednesday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcWednesdays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Thursday-based weeks in Coordinated Universal Time (UTC) (e.g., February 9, 2012 at 12:00 AM).
* 7 days and 168 hours.
*/
export const utcThursday: CountableTimeInterval;
/**
* This is a convenience alias for utcThursday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcThursdays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Friday-based weeks in Coordinated Universal Time (UTC) (e.g., February 10, 2012 at 12:00 AM).
* 7 days and 168 hours.
*/
export const utcFriday: CountableTimeInterval;
/**
* This is a convenience alias for utcFriday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcFridays(start: Date, stop: Date, step?: number): Date[];
/**
* Week Interval for Saturday-based weeks in Coordinated Universal Time (UTC) (e.g., February 11, 2012 at 12:00 AM).
* 7 days and 168 hours.
*/
export const utcSaturday: CountableTimeInterval;
/**
* This is a convenience alias for utcSaturday.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcSaturdays(start: Date, stop: Date, step?: number): Date[];
/**
* Month Interval in Coordinated Universal Time (UTC); months (e.g., February 1, 2012 at 12:00 AM); ranges from 28 to 31 days.
*/
export const utcMonth: CountableTimeInterval;
/**
* This is a convenience alias for utcMonth.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcMonths(start: Date, stop: Date, step?: number): Date[];
/**
* Year Interval in Coordinated Universal Time (UTC); years (e.g., January 1, 2012 at 12:00 AM); ranges from 365 to 366 days.
*/
export const utcYear: CountableTimeInterval;
/**
* This is a convenience alias for utcYear.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function utcYears(start: Date, stop: Date, step?: number): Date[];
/**
* Like d3.utcDay, except it counts days since the UNIX epoch (January 1, 1970) such that interval.every returns uniformly-spaced dates rather than varying based on day-of-month.
*/
export const unixDay: CountableTimeInterval;
/**
* This is a convenience alias for unixDay.range(...).
*
* @param start A start date object for the range.
* @param stop A stop date object for the range.
* @param step An optional number of steps to apply when calculating the dates in the range.
*/
export function unixDays(start: Date, stop: Date, step?: number): Date[];
/**
* Equivalent to d3.utcTicks, but in local time.
*/
export function timeTicks(start: Date, stop: Date, count: number): Date[];
/**
* Returns the time interval that would be used by d3.timeTicks given the same arguments.
*/
export function timeTickInterval(start: Date, stop: Date, count: number): TimeInterval | null;
/**
* Returns an array of approximately count dates at regular intervals between start and stop (inclusive).
* If stop is before start, dates are returned in reverse chronological order; otherwise dates are returned in chronological order.
*/
export function utcTicks(start: Date, stop: Date, count: number): Date[];
/**
* Returns the time interval that would be used by d3.utcTicks given the same arguments.
* If there is no associated interval, such as when start or stop is invalid, returns null.
*/
export function utcTickInterval(start: Date, stop: Date, count: number): TimeInterval | null;

46
node_modules/@types/d3-time/package.json generated vendored Normal file
View File

@@ -0,0 +1,46 @@
{
"name": "@types/d3-time",
"version": "3.0.4",
"description": "TypeScript definitions for d3-time",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-time",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "denisname",
"githubUsername": "denisname",
"url": "https://github.com/denisname"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-time"
},
"scripts": {},
"dependencies": {},
"peerDependencies": {},
"typesPublisherContentHash": "995c6a7a1f21328f5dceb32804c5f3d92ab20a98694246d9c8f213f4eef298ed",
"typeScriptVersion": "4.9"
}

21
node_modules/@types/d3-timer/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,21 @@
MIT License
Copyright (c) Microsoft Corporation.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE

15
node_modules/@types/d3-timer/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/d3-timer`
# Summary
This package contains type definitions for d3-timer (https://github.com/d3/d3-timer/).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-timer.
### Additional Details
* Last updated: Tue, 07 Nov 2023 15:11:37 GMT
* Dependencies: none
# Credits
These definitions were written by [Tom Wanzek](https://github.com/tomwanzek), [Alex Ford](https://github.com/gustavderdrache), [Boris Yankov](https://github.com/borisyankov), [denisname](https://github.com/denisname), and [Nathan Bierema](https://github.com/Methuselah96).

68
node_modules/@types/d3-timer/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,68 @@
// Last module patch version validated against: 3.0.1
/**
* Returns the current time as defined by performance.now if available, and Date.now if not.
* The current time is updated at the start of a frame; it is thus consistent during the frame, and any timers scheduled during the same frame will be synchronized.
* If this method is called outside of a frame, such as in response to a user event, the current time is calculated and then fixed until the next frame,
* again ensuring consistent timing during event handling.
*/
export function now(): number;
export interface Timer {
/**
* Restart a timer with the specified callback and optional delay and time.
* This is equivalent to stopping this timer and creating a new timer with the specified arguments,
* although this timer retains the original invocation priority.
*
* @param callback A callback function to be invoked and passed in the apparent
* elapsed time since the timer became active in milliseconds.
* @param delay An optional numeric delay in milliseconds (default = 0) relative to time.
* @param time An optional time in milliseconds relative to which the delay is calculated (default = now).
*/
restart(callbackFn: (elapsed: number) => void, delay?: number, time?: number): void;
/**
* Stop the timer.
*/
stop(): void;
}
/**
* Schedules and returns a new timer, invoking the specified callback repeatedly until the timer is stopped.
* The callback is passed the (apparent) elapsed time since the timer became active.
*
* @param callback A callback function to be invoked and passed in the apparent
* elapsed time since the timer became active in milliseconds.
* @param delay An optional numeric delay in milliseconds (default = 0) relative to time.
* @param time An optional time in milliseconds relative to which the delay is calculated (default = now).
*/
export function timer(callback: (elapsed: number) => void, delay?: number, time?: number): Timer;
/**
* Immediately invoke any eligible timer callbacks.
*/
export function timerFlush(): void;
/**
* Schedules and returns a new timer, invoking the specified callback. The timer is stopped automatically
* on its first callback. The callback is passed the (apparent) elapsed time since the timer became active.
*
* @param callback A callback function to be invoked and passed in the apparent
* elapsed time since the timer became active in milliseconds.
* @param delay An optional numeric delay in milliseconds (default = 0) relative to time.
* @param time An optional time in milliseconds relative to which the delay is calculated (default = now).
*/
export function timeout(callback: (elapsed: number) => void, delay?: number, time?: number): Timer;
/**
* Schedules and returns a new timer, invoking the specified callback repeatedly every 'delay' milliseconds
* until the timer is stopped.
* The callback is passed the (apparent) elapsed time since the timer became active.
*
* @param callback A callback function to be invoked and passed in the apparent
* elapsed time since the timer became active in milliseconds.
* @param delay An optional numeric delay in milliseconds between repeat invocations of the callback.
* If not specified, the interval timer behaves like the regular timer.
* @param time An optional time in milliseconds relative to which the initial delay is calculated (default = now).
*/
export function interval(callback: (elapsed: number) => void, delay?: number, time?: number): Timer;

45
node_modules/@types/d3-timer/package.json generated vendored Normal file
View File

@@ -0,0 +1,45 @@
{
"name": "@types/d3-timer",
"version": "3.0.2",
"description": "TypeScript definitions for d3-timer",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/d3-timer",
"license": "MIT",
"contributors": [
{
"name": "Tom Wanzek",
"githubUsername": "tomwanzek",
"url": "https://github.com/tomwanzek"
},
{
"name": "Alex Ford",
"githubUsername": "gustavderdrache",
"url": "https://github.com/gustavderdrache"
},
{
"name": "Boris Yankov",
"githubUsername": "borisyankov",
"url": "https://github.com/borisyankov"
},
{
"name": "denisname",
"githubUsername": "denisname",
"url": "https://github.com/denisname"
},
{
"name": "Nathan Bierema",
"githubUsername": "Methuselah96",
"url": "https://github.com/Methuselah96"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/d3-timer"
},
"scripts": {},
"dependencies": {},
"typesPublisherContentHash": "a51fc6981e6d12715fd052f7e598dd291c354465025cbb33ece1895bdab4109c",
"typeScriptVersion": "4.5"
}