kylefang/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/zhigang1992/DefinitelyTyped.git synced 2026-04-24 05:06:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Chores Fixes Enhancements Additions:

Browse Source 
* d3-array: Changed name of import alias in test file for consistency with other test files. Deleted excess line at end of definition.
* d3-axis: Enhanced Axis.scale() getter to use generic for refined return type casting. Return type can now be more specific than AxisScale minimal interface compliance. Used `this` as return type for chainable setter methods on Axis.
* d3-brush: Use ValueFn type alias from d3-selection for harmonization of callbacks. Use `this` as return type of chainable setter methods. Fixed return type of BrushBehavior.move(...) to be void
* d3-chord: Use `this` as return type of chainable setter methods.
* d3-collection: Use `this` as return type of chainable setter methods.
* d3-color: Use `this` as return type of chainable setter methods. Added helper interface ColorCommonInstance as a fallback to allow extensibility of color spaces e.g. as through d3-hsv
* d3-dispatch: Use `this` as return type of chainable setter methods.
* d3-drag:  Use ValueFn type alias from d3-selection for harmonization of callbacks. Use `this` as return type of chainable setter methods.
* d3-ease: Removed excess space.
* d3-force: Use `this` as return type of chainable setter methods. Fixed return type of Simulation.tick() to be void. Fixed Force.initialize(...) to be optional when defining a custom force. Enhanced Simulation.force(...) getter to use generic to to cast return type to specific force type, when details are know. Updated related tests.
* d3-hsv: New definitions and tests added
* d3-interpolate: Use ColorCommonInstance to allow more general color spaces than the color space objects defined in d3-color, e.g. d3-hsv. Added related tests.
* d3-quadtree: Use `this` as return type of chainable setter methods.
* d3-scale: Fixed missing support of coercible numeric value as input to ScaleSequential. Use `this` as return type of chainable setter methods.
* d3-selection: Added type alias ValueFn which is used to harmonize callback functions. Use `this` as return type of chainable setter methods, where no new selection is returned. Removed outdated comments.
* d3-selection-multi: Added new definitions with tests.
* d3-shape: Use `this` as return type of chainable setter methods. Removed spurious `?` from callback signatures.
* d3-time: Use `this` as return type of chainable setter methods.
* d3-transition: Added type alias ValueFn which is used to harmonize callback functions. Use `this` as return type of chainable setter methods, where no new transition is returned.
* d3-voronoi: Use `this` as return type of chainable setter methods.
* d3-zoom:  Use `this` as return type of chainable setter methods. Note that ZoomTransform.scale(...) and ZoomTransform.translate(...) return new ZoomTranform objects. Use ValueFn to harmonize callbacks.

Updates the prime for the newly developed D3 version 4 definitions on a file-by-file basis.
This commit is contained in:
Tom Wanzek
2016-08-17 18:20:41 -04:00
parent 50c30849c1
commit 61e748a7c0
37 changed files with 1005 additions and 638 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
d3-array/d3-array-tests.ts
View File

@@ -6,7 +6,7 @@
* are not intended as functional tests.
*/
import * as d3 from 'd3-array';
import * as d3Array from 'd3-array';
import { scaleTime } from 'd3-scale';
import { timeYear } from 'd3-time';
@@ -47,8 +47,8 @@ let date: Date;
let extentNum: [number, number];
let extentStr: [string, string];
let extentNumeric: [NumCoercible, NumCoercible];
let extentDateMixed: [d3.Primitive, d3.Primitive];
let extentMixed: [d3.Primitive | NumCoercible, d3.Primitive | NumCoercible];
let extentDateMixed: [d3Array.Primitive, d3Array.Primitive];
let extentMixed: [d3Array.Primitive | NumCoercible, d3Array.Primitive | NumCoercible];
let extentDate: [Date, Date];
let numbersArray = [10, 20, 30, 40, 50];
@@ -72,35 +72,35 @@ let mixedObjectArray = [
// without accessors
num = d3.max(numbersArray);
str = d3.max(stringyNumbersArray);
numeric = d3.max(numericArray);
date = d3.max(dateArray);
num = d3Array.max(numbersArray);
str = d3Array.max(stringyNumbersArray);
numeric = d3Array.max(numericArray);
date = d3Array.max(dateArray);
// with accessors
num = d3.max(mixedObjectArray, function (datum, index, array) {
num = d3Array.max(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.num;
});
str = d3.max(mixedObjectArray, function (datum, index, array) {
str = d3Array.max(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.str;
});
numeric = d3.max(mixedObjectArray, function (datum, index, array) {
numeric = d3Array.max(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.numeric;
});
date = d3.max(mixedObjectArray, function (datum, index, array) {
date = d3Array.max(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -111,35 +111,35 @@ date = d3.max(mixedObjectArray, function (datum, index, array) {
// without accessors
num = d3.min(numbersArray);
str = d3.min(stringyNumbersArray);
numeric = d3.min(numericArray);
date = d3.min(dateArray);
num = d3Array.min(numbersArray);
str = d3Array.min(stringyNumbersArray);
numeric = d3Array.min(numericArray);
date = d3Array.min(dateArray);
// with accessors
num = d3.min(mixedObjectArray, function (datum, index, array) {
num = d3Array.min(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.num;
});
str = d3.min(mixedObjectArray, function (datum, index, array) {
str = d3Array.min(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.str;
});
numeric = d3.min(mixedObjectArray, function (datum, index, array) {
numeric = d3Array.min(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.numeric;
});
date = d3.min(mixedObjectArray, function (datum, index, array) {
date = d3Array.min(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -150,36 +150,36 @@ date = d3.min(mixedObjectArray, function (datum, index, array) {
// without accessors
extentNum = d3.extent(numbersArray);
extentStr = d3.extent(stringyNumbersArray);
extentNumeric = d3.extent(numericArray);
extentDate = d3.extent(dateArray);
extentMixed = d3.extent([new NumCoercible(10), 13, '12', true]);
extentNum = d3Array.extent(numbersArray);
extentStr = d3Array.extent(stringyNumbersArray);
extentNumeric = d3Array.extent(numericArray);
extentDate = d3Array.extent(dateArray);
extentMixed = d3Array.extent([new NumCoercible(10), 13, '12', true]);
// with accessors
extentNum = d3.extent(mixedObjectArray, function (datum, index, array) {
extentNum = d3Array.extent(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.num;
});
extentStr = d3.extent(mixedObjectArray, function (datum, index, array) {
extentStr = d3Array.extent(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.str;
});
extentMixed = d3.extent(mixedObjectArray, function (datum, index, array) {
extentMixed = d3Array.extent(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
return datum.numeric;
});
extentDateMixed = d3.extent(mixedObjectArray, function (datum, index, array) {
extentDateMixed = d3Array.extent(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -188,9 +188,9 @@ extentDateMixed = d3.extent(mixedObjectArray, function (datum, index, array) {
// mean() ----------------------------------------------------------------------
num = d3.mean(numbersArray);
num = d3Array.mean(numbersArray);
num = d3.mean(mixedObjectArray, function (datum, index, array) {
num = d3Array.mean(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -199,9 +199,9 @@ num = d3.mean(mixedObjectArray, function (datum, index, array) {
// median() --------------------------------------------------------------------
num = d3.median(numbersArray);
num = d3Array.median(numbersArray);
num = d3.median(mixedObjectArray, function (datum, index, array) {
num = d3Array.median(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -210,9 +210,9 @@ num = d3.median(mixedObjectArray, function (datum, index, array) {
// quantile() ------------------------------------------------------------------
num = d3.quantile(numbersArray, 0.5);
num = d3Array.quantile(numbersArray, 0.5);
num = d3.quantile(mixedObjectArray, 0.5, function (datum, index, array) {
num = d3Array.quantile(mixedObjectArray, 0.5, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -222,9 +222,9 @@ num = d3.quantile(mixedObjectArray, 0.5, function (datum, index, array) {
// sum() -----------------------------------------------------------------------
num = d3.sum(numbersArray);
num = d3Array.sum(numbersArray);
num = d3.sum(mixedObjectArray, function (datum, index, array) {
num = d3Array.sum(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -233,9 +233,9 @@ num = d3.sum(mixedObjectArray, function (datum, index, array) {
// deviation() -----------------------------------------------------------------
num = d3.deviation(numbersArray);
num = d3Array.deviation(numbersArray);
num = d3.deviation(mixedObjectArray, function (datum, index, array) {
num = d3Array.deviation(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -244,9 +244,9 @@ num = d3.deviation(mixedObjectArray, function (datum, index, array) {
// variance() ------------------------------------------------------------------
num = d3.variance(numbersArray);
num = d3Array.variance(numbersArray);
num = d3.variance(mixedObjectArray, function (datum, index, array) {
num = d3Array.variance(mixedObjectArray, function (datum, index, array) {
let d: MixedObject = datum;
let i: number = index;
let arr: Array<MixedObject> = array;
@@ -259,65 +259,65 @@ num = d3.variance(mixedObjectArray, function (datum, index, array) {
// scan() ----------------------------------------------------------------------
num = d3.scan(mixedObjectArray, function (a, b) {
num = d3Array.scan(mixedObjectArray, function (a, b) {
return a.num - b.num; // a and b are of type MixedObject
});
// bisectLeft() ----------------------------------------------------------------
num = d3.bisectLeft([0, 2, 3, 4, 7, 8], 4);
num = d3.bisectLeft([0, 2, 3, 4, 7, 8], 4, 1);
num = d3.bisectLeft([0, 2, 3, 4, 7, 8], 4, 1, 4);
num = d3Array.bisectLeft([0, 2, 3, 4, 7, 8], 4);
num = d3Array.bisectLeft([0, 2, 3, 4, 7, 8], 4, 1);
num = d3Array.bisectLeft([0, 2, 3, 4, 7, 8], 4, 1, 4);
num = d3.bisectLeft(['0', '2', '3', '4', '7', '8'], '21');
num = d3.bisectLeft(['0', '2', '3', '4', '7', '8'], '21', 1);
num = d3.bisectLeft(['0', '2', '3', '4', '7', '8'], '21', 1, 4);
num = d3Array.bisectLeft(['0', '2', '3', '4', '7', '8'], '21');
num = d3Array.bisectLeft(['0', '2', '3', '4', '7', '8'], '21', 1);
num = d3Array.bisectLeft(['0', '2', '3', '4', '7', '8'], '21', 1, 4);
num = d3.bisectLeft([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1));
num = d3.bisectLeft([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1);
num = d3.bisectLeft([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1, 2);
num = d3Array.bisectLeft([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1));
num = d3Array.bisectLeft([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1);
num = d3Array.bisectLeft([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1, 2);
// bisectRight() ---------------------------------------------------------------
num = d3.bisectRight([0, 2, 3, 4, 7, 8], 4);
num = d3.bisectRight([0, 2, 3, 4, 7, 8], 4, 1);
num = d3.bisectRight([0, 2, 3, 4, 7, 8], 4, 1, 4);
num = d3Array.bisectRight([0, 2, 3, 4, 7, 8], 4);
num = d3Array.bisectRight([0, 2, 3, 4, 7, 8], 4, 1);
num = d3Array.bisectRight([0, 2, 3, 4, 7, 8], 4, 1, 4);
num = d3.bisectRight(['0', '2', '3', '4', '7', '8'], '21');
num = d3.bisectRight(['0', '2', '3', '4', '7', '8'], '21', 1);
num = d3.bisectRight(['0', '2', '3', '4', '7', '8'], '21', 1, 4);
num = d3Array.bisectRight(['0', '2', '3', '4', '7', '8'], '21');
num = d3Array.bisectRight(['0', '2', '3', '4', '7', '8'], '21', 1);
num = d3Array.bisectRight(['0', '2', '3', '4', '7', '8'], '21', 1, 4);
num = d3.bisectRight([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1));
num = d3.bisectRight([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1);
num = d3.bisectRight([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1, 2);
num = d3Array.bisectRight([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1));
num = d3Array.bisectRight([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1);
num = d3Array.bisectRight([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1, 2);
// bisect() --------------------------------------------------------------------
num = d3.bisect([0, 2, 3, 4, 7, 8], 4);
num = d3.bisect([0, 2, 3, 4, 7, 8], 4, 1);
num = d3.bisect([0, 2, 3, 4, 7, 8], 4, 1, 4);
num = d3Array.bisect([0, 2, 3, 4, 7, 8], 4);
num = d3Array.bisect([0, 2, 3, 4, 7, 8], 4, 1);
num = d3Array.bisect([0, 2, 3, 4, 7, 8], 4, 1, 4);
num = d3.bisect(['0', '2', '3', '4', '7', '8'], '21');
num = d3.bisect(['0', '2', '3', '4', '7', '8'], '21', 1);
num = d3.bisect(['0', '2', '3', '4', '7', '8'], '21', 1, 4);
num = d3Array.bisect(['0', '2', '3', '4', '7', '8'], '21');
num = d3Array.bisect(['0', '2', '3', '4', '7', '8'], '21', 1);
num = d3Array.bisect(['0', '2', '3', '4', '7', '8'], '21', 1, 4);
num = d3.bisect([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1));
num = d3.bisect([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1);
num = d3.bisect([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1, 2);
num = d3Array.bisect([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1));
num = d3Array.bisect([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1);
num = d3Array.bisect([new Date(2010, 1, 1), new Date(2011, 1, 1), new Date(2012, 1, 1), new Date(2013, 1, 1)], new Date(2011, 2, 1), 1, 2);
// bisector() ------------------------------------------------------------------
mixedObjectArray.sort(function (a, b) { return a.date.valueOf() - b.date.valueOf(); });
let mixedObjectDateBisectorObject: d3.Bisector<MixedObject, Date>;
let mixedObjectDateBisectorObject: d3Array.Bisector<MixedObject, Date>;
// define using accessor
mixedObjectDateBisectorObject = d3.bisector<MixedObject, Date>(function (el) {
mixedObjectDateBisectorObject = d3Array.bisector<MixedObject, Date>(function (el) {
return el.date;
});
// define using comparator
mixedObjectDateBisectorObject = d3.bisector<MixedObject, Date>(function (el, x) {
mixedObjectDateBisectorObject = d3Array.bisector<MixedObject, Date>(function (el, x) {
return el.date.valueOf() - x.valueOf();
});
@@ -334,15 +334,15 @@ num = mixedObjectDateBisectorObject.right(mixedObjectArray, new Date(2015, 3, 14
// ascending() -----------------------------------------------------------------
num = d3.ascending(10, 20);
num = d3.ascending('10', '20');
num = d3.ascending(new Date(2016, 6, 13), new Date(2016, 6, 14));
num = d3Array.ascending(10, 20);
num = d3Array.ascending('10', '20');
num = d3Array.ascending(new Date(2016, 6, 13), new Date(2016, 6, 14));
// descending() ----------------------------------------------------------------
num = d3.descending(10, 20);
num = d3.descending('10', '20');
num = d3.descending(new Date(2016, 6, 13), new Date(2016, 6, 14));
num = d3Array.descending(10, 20);
num = d3Array.descending('10', '20');
num = d3Array.descending(new Date(2016, 6, 13), new Date(2016, 6, 14));
// -----------------------------------------------------------------------------
// Test Transforming Arrays
@@ -367,20 +367,20 @@ let testArrays: MixedObject[][] = [
let mergedArray: MixedObject[];
mergedArray = d3.merge(testArrays); // inferred type
mergedArray = d3.merge<MixedObject>(testArrays); // explicit type
mergedArray = d3Array.merge(testArrays); // inferred type
mergedArray = d3Array.merge<MixedObject>(testArrays); // explicit type
// mergedArray = d3.merge<MixedObject>([[10, 40, 30], [15, 30]]); // fails, type mismatch
// pairs() ---------------------------------------------------------------------
let pairs: Array<[MixedObject, MixedObject]>;
pairs = d3.pairs(mergedArray);
pairs = d3Array.pairs(mergedArray);
// permute() -------------------------------------------------------------------
// getting a permutation of array elements
mergedArray = d3.permute(mergedArray, [1, 0, 2, 5, 3, 4, 6]);
mergedArray = d3Array.permute(mergedArray, [1, 0, 2, 5, 3, 4, 6]);
// Getting an ordered array with object properties
@@ -391,35 +391,35 @@ let testObject = {
more: [10, 30, 40]
};
let x: Array<number | string | Date | number[]> = d3.permute(testObject, ['name', 'val', 'when', 'more']);
let x: Array<number | string | Date | number[]> = d3Array.permute(testObject, ['name', 'val', 'when', 'more']);
// range() ---------------------------------------------------------------------
numbersArray = d3.range(10);
numbersArray = d3.range(1, 10);
numbersArray = d3.range(1, 10, 0.5);
numbersArray = d3Array.range(10);
numbersArray = d3Array.range(1, 10);
numbersArray = d3Array.range(1, 10, 0.5);
// shuffle() -------------------------------------------------------------------
mergedArray = d3.shuffle(mergedArray);
mergedArray = d3Array.shuffle(mergedArray);
mergedArray = d3.shuffle(mergedArray, 1);
mergedArray = d3Array.shuffle(mergedArray, 1);
mergedArray = d3.shuffle(mergedArray, 1, 3);
mergedArray = d3Array.shuffle(mergedArray, 1, 3);
// ticks() ---------------------------------------------------------------------
numbersArray = d3.ticks(1, 10, 5);
numbersArray = d3Array.ticks(1, 10, 5);
// tickStep() ------------------------------------------------------------------
numbersArray = d3.tickStep(1, 10, 5);
numbersArray = d3Array.tickStep(1, 10, 5);
// transpose() -----------------------------------------------------------------
testArrays = d3.transpose([
testArrays = d3Array.transpose([
[
new MixedObject(10, new Date(2016, 6, 1)),
new MixedObject(50, new Date(2017, 4, 15))
@@ -432,7 +432,7 @@ testArrays = d3.transpose([
// zip() -----------------------------------------------------------------------
testArrays = d3.zip(
testArrays = d3Array.zip(
[
new MixedObject(10, new Date(2016, 6, 1)),
new MixedObject(20, new Date(2016, 7, 30)),
@@ -454,11 +454,11 @@ let tScale = scaleTime();
// Create histogram generator ==================================================
let defaultHistogram: d3.HistogramGenerator<number, number>;
defaultHistogram = d3.histogram();
let defaultHistogram: d3Array.HistogramGenerator<number, number>;
defaultHistogram = d3Array.histogram();
let testHistogram: d3.HistogramGenerator<MixedObject, Date>;
testHistogram = d3.histogram<MixedObject, Date>();
let testHistogram: d3Array.HistogramGenerator<MixedObject, Date>;
testHistogram = d3Array.histogram<MixedObject, Date>();
// Configure histogram generator ===============================================
@@ -501,7 +501,7 @@ domainAccessorFn = testHistogram.domain();
defaultHistogram = defaultHistogram.thresholds(3);
// with threshold count generator
defaultHistogram = defaultHistogram.thresholds(d3.thresholdScott);
defaultHistogram = defaultHistogram.thresholds(d3Array.thresholdScott);
// with thresholds value array
@@ -518,10 +518,10 @@ testHistogram = testHistogram.thresholds(tScale.ticks(timeYear));
// Use histogram generator =====================================================
let defaultBins: Array<d3.Bin<number, number>>;
let defaultBins: Array<d3Array.Bin<number, number>>;
defaultBins = defaultHistogram([-1, 0, 1, 1, 3, 20, 234]);
let defaultBin: d3.Bin<number, number>;
let defaultBin: d3Array.Bin<number, number>;
defaultBin = defaultBins[0];
num = defaultBin.length; // defaultBin is array
@@ -529,10 +529,10 @@ num = defaultBin[0]; // with element type number
num = defaultBin.x0; // bin lower bound is number
num = defaultBin.x1; // bin upper bound is number
let testBins: Array<d3.Bin<MixedObject, Date>>;
let testBins: Array<d3Array.Bin<MixedObject, Date>>;
testBins = testHistogram(mixedObjectArray);
let testBin: d3.Bin<MixedObject, Date>;
let testBin: d3Array.Bin<MixedObject, Date>;
testBin = testBins[0];
num = testBin.length; // defaultBin is array
@@ -544,8 +544,8 @@ date = testBin.x1; // bin upper bound is Date
// Histogram Tresholds =========================================================
num = d3.thresholdFreedmanDiaconis([-1, 0, 1, 1, 3, 20, 234], -1, 234);
num = d3Array.thresholdFreedmanDiaconis([-1, 0, 1, 1, 3, 20, 234], -1, 234);
num = d3.thresholdScott([-1, 0, 1, 1, 3, 20, 234], -1, 234);
num = d3Array.thresholdScott([-1, 0, 1, 1, 3, 20, 234], -1, 234);
num = d3.thresholdSturges([-1, 0, 1, 1, 3, 20, 234]);
num = d3Array.thresholdSturges([-1, 0, 1, 1, 3, 20, 234]);

21
d3-array/index.d.ts vendored
View File

@@ -157,7 +157,7 @@ export function sum<T>(array: T[], accessor: (datum: T, index: number, array: T[
export function deviation(array: number[]): number | undefined;
/**
* Compute the standard deviation, defined as the square root of the bias-corrected variance, of the given array,
* Compute the standard deviation, defined as the square root of the bias-corrected variance, of the given array,
* using the given accessor to convert values to numbers.
*/
export function deviation<T>(array: T[], accessor: (datum: T, index: number, array: T[]) => number): number | undefined;
@@ -255,7 +255,7 @@ export function range(start: number, stop: number, step?: number): number[];
export function shuffle<T>(array: T[], lo?: number, hi?: number): T[];
/**
* Generate an array of approximately count + 1 uniformly-spaced, nicely-rounded values between start and stop (inclusive).
* Generate an array of approximately count + 1 uniformly-spaced, nicely-rounded values between start and stop (inclusive).
*/
export function ticks(start: number, stop: number, count: number): number[];
@@ -274,7 +274,7 @@ export function transpose<T>(matrix: T[][]): T[][];
/**
* Returns an array of arrays, where the ith array contains the ith element from each of the argument arrays.
* The returned array is truncated in length to the shortest array in arrays. If arrays contains only a single array, the returned array
* The returned array is truncated in length to the shortest array in arrays. If arrays contains only a single array, the returned array
* contains one-element arrays. With no arguments, the returned array is empty.
*/
export function zip<T>(...arrays: T[][]): T[][];
@@ -311,7 +311,7 @@ export interface HistogramGenerator<Datum, Value extends number | Date> {
/**
* Divide the domain uniformly into approximately count bins. IMPORTANT: This threshold
* setting approach only works, when the materialized values are numbers!
*
*
* @param count The desired number of uniform bins.
*/
thresholds(count: number): this;
@@ -319,10 +319,10 @@ export interface HistogramGenerator<Datum, Value extends number | Date> {
* Set a threshold accessor function, which returns the desired number of bins.
* Divides the domain uniformly into approximately count bins. IMPORTANT: This threshold
* setting approach only works, when the materialized values are numbers!
*
*
* @param count A function which accepts as arguments the array of materialized values, and
* optionally the domain minimum and maximum. The function calcutates and returns the suggested
* number of bins.
* number of bins.
*/
thresholds(count: ThresholdCountGenerator): this;
/**
@@ -332,12 +332,12 @@ export interface HistogramGenerator<Datum, Value extends number | Date> {
*/
thresholds(thresholds: Value[]): this;
/**
* Set a threshold accessor function, which returns the array of values to be used as
* Set a threshold accessor function, which returns the array of values to be used as
* thresholds in determining the bins.
*
*
* @param thresholds A function which accepts as arguments the array of materialized values, and
* optionally the domain minimum and maximum. The function calcutates and returns the array of values to be used as
* thresholds in determining the bins.
* optionally the domain minimum and maximum. The function calcutates and returns the array of values to be used as
* thresholds in determining the bins.
*/
thresholds(thresholds: ThresholdArrayGenerator<Value>): this;
}
@@ -354,4 +354,3 @@ export function thresholdFreedmanDiaconis(values: number[], min: number, max: nu
export function thresholdScott(values: number[], min: number, max: number): number; // of type ThresholdCountGenerator
export function thresholdSturges(values: number[]): number; // of type ThresholdCountGenerator

9
d3-axis/d3-axis-tests.ts
View File

@@ -13,6 +13,7 @@ import {
scaleOrdinal,
ScaleOrdinal,
scalePow,
ScalePower,
scaleTime,
ScaleTime,
} from 'd3-scale';
@@ -70,11 +71,17 @@ let leftAxis: d3Axis.Axis<number | { valueOf(): number }> = d3Axis.axisLeft(scal
// scale(...) ----------------------------------------------------------------
leftAxis = leftAxis.scale(scalePow());
let powerScale: ScalePower<number, number> = leftAxis.scale<ScalePower<number, number>>();
// powerScale = leftAxis.scale(); // fails, without casting as AxisScale is purposely generic
bottomAxis = bottomAxis.scale(scaleOrdinal<number>());
// bottomAxis = bottomAxis.scale(scalePow()) // fails, domain of scale incompatible with domain of axis
let axisScale: d3Axis.AxisScale<string> = bottomAxis.scale();
// let ordinalScale: ScaleOrdinal<string, number> = bottomAxis.scale(); // fails, without casting as AxisScale is purposely generic
let ordinalScale: ScaleOrdinal<string, number> = bottomAxis.scale<ScaleOrdinal<string, number>>();
// ordinalScale = bottomAxis.scale(); // fails, without casting as AxisScale is purposely generic
// ticks(...) ----------------------------------------------------------------

39
d3-axis/index.d.ts vendored
View File

@@ -1,11 +1,10 @@
// Type definitions for D3JS d3-axis module 1.0.0
// Project: https://github.com/d3/d3-axis/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Selection, TransitionLike } from 'd3-selection';
// --------------------------------------------------------------------------
// Shared Types and Interfaces
// --------------------------------------------------------------------------
@@ -67,14 +66,14 @@ export interface Axis<Domain> {
/**
* Gets the current scale underlying the axis.
*/
scale(): AxisScale<Domain>;
scale<A extends AxisScale<Domain>>(): A;
/**
* Sets the scale and returns the axis.
*
* @param scale The scale to be used for axis generation
*/
scale(scale: AxisScale<Domain>): Axis<Domain>;
scale(scale: AxisScale<Domain>): this;
/**
* Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
@@ -82,7 +81,7 @@ export interface Axis<Domain> {
* @param count Number of ticks that should be rendered
* @param specifier An optional format specifier to customize how the tick values are formatted.
*/
ticks(count: number, specifier?: string): Axis<Domain>;
ticks(count: number, specifier?: string): this;
/**
* Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
@@ -92,12 +91,12 @@ export interface Axis<Domain> {
* in d3-time. E.g. as obtained by passing in d3.timeMinute.every(15).
* @param specifier An optional format specifier to customize how the tick values are formatted.
*/
ticks(interval: AxisTimeInterval, specifier?: string): Axis<Domain>;
ticks(interval: AxisTimeInterval, specifier?: string): this;
/**
* Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
*/
ticks(arg0: any, ...args: any[]): Axis<Domain>;
ticks(arg0: any, ...args: any[]): this;
/**
* Get an array containing the currently set arguments to be passed into scale.ticks and scale.tickFormat.
@@ -109,7 +108,7 @@ export interface Axis<Domain> {
*
* @param args An array containing a single element representing the count, i.e. number of ticks to be rendered.
*/
tickArguments(args: [number]): Axis<Domain>;
tickArguments(args: [number]): this;
/**
* Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
@@ -117,7 +116,7 @@ export interface Axis<Domain> {
* @param args An array containing two elements. The first element represents the count, i.e. number of ticks to be rendered. The second
* element is a string representing the format specifier to customize how the tick values are formatted.
*/
tickArguments(args: [number, string]): Axis<Domain>;
tickArguments(args: [number, string]): this;
/**
* Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
@@ -126,7 +125,7 @@ export interface Axis<Domain> {
* @param args An array containing a single element representing a time interval used to generate date-based ticks.
* This is typically a TimeInterval/CountableTimeInterval as defined in d3-time. E.g. as obtained by passing in d3.timeMinute.every(15).
*/
tickArguments(args: [AxisTimeInterval]): Axis<Domain>;
tickArguments(args: [AxisTimeInterval]): this;
/**
* Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
@@ -136,14 +135,14 @@ export interface Axis<Domain> {
* This is typically a TimeInterval/CountableTimeInterval as defined in d3-time. E.g. as obtained by passing in d3.timeMinute.every(15).
* The second element is a string representing the format specifier to customize how the tick values are formatted.
*/
tickArguments(args: [AxisTimeInterval, string]): Axis<Domain>;
tickArguments(args: [AxisTimeInterval, string]): this;
/**
* Sets the arguments that will be passed to scale.ticks and scale.tickFormat when the axis is rendered, and returns the axis generator.
*
* @param args An array with arguments suitable for the scale to be used for tick generation
*/
tickArguments(args: any[]): Axis<Domain>;
tickArguments(args: any[]): this;
/**
* Returns the current tick values, which defaults to null.
@@ -158,14 +157,14 @@ export interface Axis<Domain> {
*
* @param values An array with values from the Domain of the scale underlying the axis.
*/
tickValues(values: Domain[]): Axis<Domain>;
tickValues(values: Domain[]): this;
/**
* Clears any previously-set explicit tick values and reverts back to the scale’s tick generator.
*
* @param values null
*/
tickValues(values: null): Axis<Domain>;
tickValues(values: null): this;
/**
@@ -179,7 +178,7 @@ export interface Axis<Domain> {
* @param format A function mapping a value from the axis Domain to a formatted string
* for display purposes.
*/
tickFormat(format: (domainValue: Domain) => string): Axis<Domain>;
tickFormat(format: (domainValue: Domain) => string): this;
/**
* Reset the tick format function. A null format indicates that the scale’s
@@ -189,7 +188,7 @@ export interface Axis<Domain> {
*
* @param format null
*/
tickFormat(format: null): Axis<Domain>;
tickFormat(format: null): this;
/**
* Get the current inner tick size, which defaults to 6.
@@ -200,7 +199,7 @@ export interface Axis<Domain> {
*
* @param size Tick size in pixels (Default is 6).
*/
tickSize(size: number): Axis<Domain>;
tickSize(size: number): this;
/**
* Get the current inner tick size, which defaults to 6.
@@ -216,7 +215,7 @@ export interface Axis<Domain> {
*
* @param size Tick size in pixels (Default is 6).
*/
tickSizeInner(size: number): Axis<Domain>;
tickSizeInner(size: number): this;
/**
* Get the current outer tick size, which defaults to 6.
@@ -240,7 +239,7 @@ export interface Axis<Domain> {
*
* @param size Tick size in pixels (Default is 6).
*/
tickSizeOuter(size: number): Axis<Domain>;
tickSizeOuter(size: number): this;
/**
* Get the current padding, which defaults to 3.
@@ -252,7 +251,7 @@ export interface Axis<Domain> {
*
* @param padding Padding in pixels (Default is 3).
*/
tickPadding(padding: number): Axis<Domain>;
tickPadding(padding: number): this;
}

30
d3-brush/index.d.ts vendored
View File

@@ -1,9 +1,9 @@
// Type definitions for D3JS d3-brush module 1.0.1
// Project: https://github.com/d3/d3-brush/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { ArrayLike, Selection, TransitionLike } from 'd3-selection';
import { ArrayLike, Selection, TransitionLike, ValueFn } from 'd3-selection';
/**
* Type alias for a BrushSelection. For a two-dimensional brush, it must be defined as [[x0, y0], [x1, y1]],
@@ -15,20 +15,20 @@ export type BrushSelection = [[number, number], [number, number]] | [number, num
export interface BrushBehavior<Datum> {
(group: Selection<SVGGElement, Datum, any, any>, ...args: any[]): void;
move(group: Selection<SVGGElement, Datum, any, any>, selection: BrushSelection): BrushBehavior<Datum>;
move(group: Selection<SVGGElement, Datum, any, any>, selection: (this: SVGGElement, d?: Datum, i?: number, group?: Array<SVGGElement> | ArrayLike<SVGGElement>) => BrushSelection): BrushBehavior<Datum>;
move(group: TransitionLike<SVGGElement, Datum>, selection: BrushSelection): BrushBehavior<Datum>;
move(group: TransitionLike<SVGGElement, Datum>, selection: (this: SVGGElement, d?: Datum, i?: number, group?: Array<SVGGElement> | ArrayLike<SVGGElement>) => BrushSelection): BrushBehavior<Datum>;
extent(): (this: SVGGElement, d: Datum, i: number, group: Array<SVGGElement> | ArrayLike<SVGGElement>) => [[number, number], [number, number]];
extent(extent: [[number, number], [number, number]]): BrushBehavior<Datum>;
extent(extent: (this: SVGGElement, d: Datum, i: number, group: Array<SVGGElement> | ArrayLike<SVGGElement>) => [[number, number], [number, number]]): BrushBehavior<Datum>;
filter(): (this: SVGGElement, datum: Datum, index: number, group: Array<SVGGElement> | ArrayLike<SVGGElement>) => boolean;
filter(filterFn: (this: SVGGElement, datum: Datum, index: number, group: Array<SVGGElement> | ArrayLike<SVGGElement>) => boolean): BrushBehavior<Datum>;
move(group: Selection<SVGGElement, Datum, any, any>, selection: BrushSelection): void;
move(group: Selection<SVGGElement, Datum, any, any>, selection: ValueFn<SVGGElement, Datum, BrushSelection>): void;
move(group: TransitionLike<SVGGElement, Datum>, selection: BrushSelection): void;
move(group: TransitionLike<SVGGElement, Datum>, selection: ValueFn<SVGGElement, Datum, BrushSelection>): void;
extent(): ValueFn<SVGGElement, Datum, [[number, number], [number, number]]>;
extent(extent: [[number, number], [number, number]]): this;
extent(extent: ValueFn<SVGGElement, Datum, [[number, number], [number, number]]>): this;
filter(): ValueFn<SVGGElement, Datum, boolean>;
filter(filterFn: ValueFn<SVGGElement, Datum, boolean>): this;
handleSize(): number;
handleSize(size: number): BrushBehavior<Datum>;
on(typenames: string): (this: SVGGElement, datum: Datum, index: number, group: Array<SVGGElement> | ArrayLike<SVGGElement>) => void;
on(typenames: string, callback: null): BrushBehavior<Datum>;
on(typenames: string, callback: (this: SVGGElement, datum: Datum, index: number, group: Array<SVGGElement> | ArrayLike<SVGGElement>) => void): BrushBehavior<Datum>;
handleSize(size: number): this;
on(typenames: string): ValueFn<SVGGElement, Datum, void>;
on(typenames: string, callback: null): this;
on(typenames: string, callback: ValueFn<SVGGElement, Datum, void>): this;
}

36
d3-chord/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-chord module 1.0.0
// Project: https://github.com/d3/d3-chord/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// ---------------------------------------------------------------------
@@ -34,16 +34,16 @@ export interface Chords extends Array<Chord> {
export interface ChordLayout {
(matrix: number[][]): Chords;
padAngle(): number;
padAngle(angle: number): ChordLayout;
padAngle(angle: number): this;
sortGroups(): ((a: number, b: number) => number) | null;
sortGroups(compare: null): ChordLayout;
sortGroups(compare: (a: number, b: number) => number): ChordLayout;
sortGroups(compare: null): this;
sortGroups(compare: (a: number, b: number) => number): this;
sortSubgroups(): ((a: number, b: number) => number) | null;
sortSubgroups(compare: null): ChordLayout;
sortSubgroups(compare: (a: number, b: number) => number): ChordLayout;
sortSubgroups(compare: null): this;
sortSubgroups(compare: (a: number, b: number) => number): this;
sortChords(): ((a: number, b: number) => number) | null;
sortChords(compare: null): ChordLayout;
sortChords(compare: (a: number, b: number) => number): ChordLayout;
sortChords(compare: null): this;
sortChords(compare: (a: number, b: number) => number): this;
}
export function chord(): ChordLayout;
@@ -56,21 +56,21 @@ export function chord(): ChordLayout;
export interface RibbonGenerator<This, ChordDatum, ChordSubgroupDatum> {
(this: This, d: ChordDatum, ...args: any[]): string | undefined;
source(): (this: This, d: ChordDatum, ...args: any[]) => ChordSubgroupDatum;
source(source: (this: This, d: ChordDatum, ...args: any[]) => ChordSubgroupDatum): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
source(source: (this: This, d: ChordDatum, ...args: any[]) => ChordSubgroupDatum): this;
target(): (this: This, d: ChordDatum, ...args: any[]) => ChordSubgroupDatum;
target(target: (this: This, d: ChordDatum, ...args: any[]) => ChordSubgroupDatum): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
target(target: (this: This, d: ChordDatum, ...args: any[]) => ChordSubgroupDatum): this;
radius(): (this: This, d: ChordSubgroupDatum, ...args: any[]) => number;
radius(radius: number): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
radius(radius: (this: This, d: ChordSubgroupDatum, ...args: any[]) => number): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
radius(radius: number): this;
radius(radius: (this: This, d: ChordSubgroupDatum, ...args: any[]) => number): this;
startAngle(): (this: This, d: ChordSubgroupDatum, ...args: any[]) => number;
startAngle(angle: number): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
startAngle(angle: (this: This, d: ChordSubgroupDatum, ...args: any[]) => number): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
startAngle(angle: number): this;
startAngle(angle: (this: This, d: ChordSubgroupDatum, ...args: any[]) => number): this;
endAngle(): (this: This, d: ChordSubgroupDatum, ...args: any[]) => number;
endAngle(angle: number): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
endAngle(angle: (this: This, d: ChordSubgroupDatum, ...args: any[]) => number): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
endAngle(angle: number): this;
endAngle(angle: (this: This, d: ChordSubgroupDatum, ...args: any[]) => number): this;
context(): CanvasRenderingContext2D | null;
context(context: CanvasRenderingContext2D): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
context(context: null): RibbonGenerator<This, ChordDatum, ChordSubgroupDatum>;
context(context: CanvasRenderingContext2D): this;
context(context: null): this;
}
export function ribbon(): RibbonGenerator<any, Chord, ChordSubgroup>;

10
d3-collection/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-collection module 1.0.0
// Project: https://github.com/d3/d3-collection/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**
@@ -104,10 +104,10 @@ export interface NestedObject<Datum, RollupType> {
}
interface Nest<Datum, RollupType> {
key(func: (datum: Datum) => string): Nest<Datum, RollupType>;
sortKeys(comparator: (a: string, b: string) => number): Nest<Datum, RollupType>;
sortValues(comparator: (a: Datum, b: Datum) => number): Nest<Datum, RollupType>;
rollup(func: (values: Datum[]) => RollupType): Nest<Datum, RollupType>;
key(func: (datum: Datum) => string): this;
sortKeys(comparator: (a: string, b: string) => number): this;
sortValues(comparator: (a: Datum, b: Datum) => number): this;
rollup(func: (values: Datum[]) => RollupType): this;
map(array: Datum[]): Map<any>; // more specifically it returns NestedMap<Datum, RollupType>
object(array: Datum[]): { [key: string]: any }; // more specifically it returns NestedObject<Datum, RollupType>
entries(array: Datum[]): Array<{ key: string; values: any; value: RollupType | undefined }>; // more specifically it returns NestedArray<Datum, RollupType>

46
d3-color/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-color module 1.0.0
// Project: https://github.com/d3/d3-color/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// ---------------------------------------------------------------------------
@@ -12,6 +12,17 @@
*/
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 {
displayable(): boolean;
toString(): string;
brighter(k?: number): this;
darker(k?: number): this;
rgb(): RGBColor;
}
export interface Color {
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
@@ -20,7 +31,7 @@ export interface Color {
export interface ColorFactory extends Function {
(cssColorSpecifier: string): RGBColor | HSLColor;
(color: ColorSpaceObject): RGBColor | HSLColor;
(color: ColorSpaceObject | ColorCommonInstance): RGBColor | HSLColor;
// prototype: Color;
}
@@ -29,8 +40,8 @@ export interface RGBColor extends Color {
g: number;
b: number;
opacity: number;
brighter(k?: number): RGBColor;
darker(k?: number): RGBColor;
brighter(k?: number): this;
darker(k?: number): this;
displayable(): boolean;
rgb(): RGBColor;
toString(): string;
@@ -39,7 +50,7 @@ export interface RGBColor extends Color {
export interface RGBColorFactory extends Function {
(r: number, g: number, b: number, opacity?: number): RGBColor;
(cssColorSpecifier: string): RGBColor;
(color: ColorSpaceObject): RGBColor;
(color: ColorSpaceObject | ColorCommonInstance): RGBColor;
// prototype: RGBColor;
}
@@ -48,8 +59,8 @@ export interface HSLColor extends Color {
s: number;
l: number;
opacity: number;
brighter(k?: number): HSLColor;
darker(k?: number): HSLColor;
brighter(k?: number): this;
darker(k?: number): this;
displayable(): boolean;
rgb(): RGBColor;
}
@@ -57,7 +68,7 @@ export interface HSLColor extends Color {
export interface HSLColorFactory extends Function {
(h: number, s: number, l: number, opacity?: number): HSLColor;
(cssColorSpecifier: string): HSLColor;
(color: ColorSpaceObject): HSLColor;
(color: ColorSpaceObject | ColorCommonInstance): HSLColor;
// prototype: HSLColor;
}
@@ -66,15 +77,15 @@ export interface LabColor extends Color {
a: number;
b: number;
opacity: number;
brighter(k?: number): LabColor;
darker(k?: number): LabColor;
brighter(k?: number): this;
darker(k?: number): this;
rgb(): RGBColor;
}
export interface LabColorFactory extends Function {
(l: number, a: number, b: number, opacity?: number): LabColor;
(cssColorSpecifier: string): LabColor;
(color: ColorSpaceObject): LabColor;
(color: ColorSpaceObject | ColorCommonInstance): LabColor;
// prototype: LabColor;
}
@@ -83,15 +94,15 @@ export interface HCLColor extends Color {
c: number;
l: number;
opacity: number;
brighter(k?: number): HCLColor;
darker(k?: number): HCLColor;
brighter(k?: number): this;
darker(k?: number): this;
rgb(): RGBColor;
}
export interface HCLColorFactory extends Function {
(h: number, l: number, c: number, opacity?: number): HCLColor;
(cssColorSpecifier: string): HCLColor;
(color: ColorSpaceObject): HCLColor;
(color: ColorSpaceObject | ColorCommonInstance): HCLColor;
// prototype: HCLColor;
}
@@ -100,15 +111,15 @@ export interface CubehelixColor extends Color {
s: number;
l: number;
opacity: number;
brighter(k?: number): CubehelixColor;
darker(k?: number): CubehelixColor;
brighter(k?: number): this;
darker(k?: number): this;
rgb(): RGBColor;
}
export interface CubehelixColorFactory extends Function {
(h: number, s: number, l: number, opacity?: number): CubehelixColor;
(cssColorSpecifier: string): CubehelixColor;
(color: ColorSpaceObject): CubehelixColor;
(color: ColorSpaceObject | ColorCommonInstance): CubehelixColor;
// prototype: CubehelixColor;
}
@@ -127,4 +138,3 @@ export var lab: LabColorFactory;
export var hcl: HCLColorFactory;
export var cubehelix: CubehelixColorFactory;

6
d3-dispatch/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-dispatch module 1.0.0
// Project: https://github.com/d3/d3-dispatch/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export interface Dispatch<T extends EventTarget> {
@@ -9,8 +9,8 @@ export interface Dispatch<T extends EventTarget> {
copy(): Dispatch<T>;
on(typenames: string): (this: T, ...args: any[]) => void;
on(typenames: string, callback: null): Dispatch<T>;
on(typenames: string, callback: (this: T, ...args: any[]) => void): Dispatch<T>;
on(typenames: string, callback: null): this;
on(typenames: string, callback: (this: T, ...args: any[]) => void): this;
}
export function dispatch<T extends EventTarget>(...types: string[]): Dispatch<T>;

30
d3-drag/index.d.ts vendored
View File

@@ -1,9 +1,9 @@
// Type definitions for D3JS d3-drag module 1.0.0
// Project: https://github.com/d3/d3-drag/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { ArrayLike, Selection } from 'd3-selection';
import { ArrayLike, Selection, ValueFn } from 'd3-selection';
// --------------------------------------------------------------------------
@@ -35,16 +35,16 @@ export interface SubjectPosition {
export interface DragBehavior<GElement extends DraggedElementBaseType, Datum, Subject> extends Function {
(selection: Selection<GElement, Datum, any, any>, ...args: any[]): void;
container(): (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => DragContainerElement;
container(accessor: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => DragContainerElement): DragBehavior<GElement, Datum, Subject>;
container(container: DragContainerElement): DragBehavior<GElement, Datum, Subject>;
filter(): (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => boolean;
filter(filterFn: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => boolean): DragBehavior<GElement, Datum, Subject>;
subject(): (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => Subject;
subject(accessor: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => Subject): DragBehavior<GElement, Datum, Subject>;
on(typenames: string): (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => any;
on(typenames: string, callback: null): DragBehavior<GElement, Datum, Subject>;
on(typenames: string, callback: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => any): DragBehavior<GElement, Datum, Subject>;
container(): ValueFn<GElement, Datum, DragContainerElement>;
container(accessor: ValueFn<GElement, Datum, DragContainerElement>): this;
container(container: DragContainerElement): this;
filter(): ValueFn<GElement, Datum, boolean>;
filter(filterFn: ValueFn<GElement, Datum, boolean>): this;
subject(): ValueFn<GElement, Datum, Subject>;
subject(accessor: ValueFn<GElement, Datum, Subject>): this;
on(typenames: string): ValueFn<GElement, Datum, void>;
on(typenames: string, callback: null): this;
on(typenames: string, callback: ValueFn<GElement, Datum, void>): this;
}
export function drag<GElement extends DraggedElementBaseType, Datum>(): DragBehavior<GElement, Datum, Datum | SubjectPosition>;
@@ -62,9 +62,9 @@ export interface D3DragEvent<GElement extends DraggedElementBaseType, Datum, Sub
identifier: 'mouse' | number;
active: number;
sourceEvent: any;
on(typenames: string): (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => void;
on(typenames: string, callback: null): D3DragEvent<GElement, Datum, Subject>;
on(typenames: string, callback: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => void): D3DragEvent<GElement, Datum, Subject>;
on(typenames: string): ValueFn<GElement, Datum, void>;
on(typenames: string, callback: null): this;
on(typenames: string, callback: ValueFn<GElement, Datum, void>): this;
}
export function dragDisable(window: Window): void;

76
d3-ease/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-ease module 1.0.0
// Project: https://github.com/d3/d3-ease/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// --------------------------------------------------------------------------
@@ -8,49 +8,49 @@
// --------------------------------------------------------------------------
export function easeLinear(normalizedTime: number): number;
export function easeLinear(normalizedTime: number): number;
export function easeQuad(normalizedTime: number): number;
export function easeQuadIn(normalizedTime: number): number;
export function easeQuadOut(normalizedTime: number): number;
export function easeQuadInOut(normalizedTime: number): number;
export function easeQuad(normalizedTime: number): number;
export function easeQuadIn(normalizedTime: number): number;
export function easeQuadOut(normalizedTime: number): number;
export function easeQuadInOut(normalizedTime: number): number;
export function easeCubic(normalizedTime: number): number;
export function easeCubicIn(normalizedTime: number): number;
export function easeCubicOut(normalizedTime: number): number;
export function easeCubicInOut(normalizedTime: number): number;
export function easeCubic(normalizedTime: number): number;
export function easeCubicIn(normalizedTime: number): number;
export function easeCubicOut(normalizedTime: number): number;
export function easeCubicInOut(normalizedTime: number): number;
export function easePoly(normalizedTime: number): number;
export function easePolyIn(normalizedTime: number): number;
export function easePolyOut(normalizedTime: number): number;
export function easePolyInOut(normalizedTime: number): number;
export function easePoly(normalizedTime: number): number;
export function easePolyIn(normalizedTime: number): number;
export function easePolyOut(normalizedTime: number): number;
export function easePolyInOut(normalizedTime: number): number;
export function easeSin(normalizedTime: number): number;
export function easeSinIn(normalizedTime: number): number;
export function easeSinOut(normalizedTime: number): number;
export function easeSinInOut(normalizedTime: number): number;
export function easeSin(normalizedTime: number): number;
export function easeSinIn(normalizedTime: number): number;
export function easeSinOut(normalizedTime: number): number;
export function easeSinInOut(normalizedTime: number): number;
export function easeExp(normalizedTime: number): number;
export function easeExpIn(normalizedTime: number): number;
export function easeExpOut(normalizedTime: number): number;
export function easeExpInOut(normalizedTime: number): number;
export function easeExp(normalizedTime: number): number;
export function easeExpIn(normalizedTime: number): number;
export function easeExpOut(normalizedTime: number): number;
export function easeExpInOut(normalizedTime: number): number;
export function easeCircle(normalizedTime: number): number;
export function easeCircleIn(normalizedTime: number): number;
export function easeCircleOut(normalizedTime: number): number;
export function easeCircleInOut(normalizedTime: number): number;
export function easeCircle(normalizedTime: number): number;
export function easeCircleIn(normalizedTime: number): number;
export function easeCircleOut(normalizedTime: number): number;
export function easeCircleInOut(normalizedTime: number): number;
export function easeBounce(normalizedTime: number): number;
export function easeBounceIn(normalizedTime: number): number;
export function easeBounceOut(normalizedTime: number): number;
export function easeBounceInOut(normalizedTime: number): number;
export function easeBounce(normalizedTime: number): number;
export function easeBounceIn(normalizedTime: number): number;
export function easeBounceOut(normalizedTime: number): number;
export function easeBounceInOut(normalizedTime: number): number;
export function easeBack(normalizedTime: number): number;
export function easeBackIn(normalizedTime: number): number;
export function easeBackOut(normalizedTime: number): number;
export function easeBackInOut(normalizedTime: number): number;
export function easeBack(normalizedTime: number): number;
export function easeBackIn(normalizedTime: number): number;
export function easeBackOut(normalizedTime: number): number;
export function easeBackInOut(normalizedTime: number): number;
export function easeElastic(normalizedTime: number): number;
export function easeElasticIn(normalizedTime: number): number;
export function easeElasticOut(normalizedTime: number): number;
export function easeElasticInOut(normalizedTime: number): number;
export function easeElastic(normalizedTime: number): number;
export function easeElasticIn(normalizedTime: number): number;
export function easeElasticOut(normalizedTime: number): number;
export function easeElasticInOut(normalizedTime: number): number;

18
d3-force/d3-force-tests.ts
View File

@@ -452,22 +452,26 @@ nodeLinkSimulation
let f: d3Force.Force<SimNode, SimLink>;
// getter with generic force returned
f = nodeLinkSimulation.force('charge');
f = nodeLinkSimulation.force('link');
// getter with force type cast to improve return type specificity
let fLink: d3Force.ForceLink<SimNode, SimLink>;
// fLink = nodeLinkSimulation.force('link'); // fails, as ForceLink specific properties are missing from 'generic' force
// Need explicit, careful type casting to a specific force type
fLink = <d3Force.ForceLink<SimNode, SimLink>>nodeLinkSimulation.force('link');
fLink = nodeLinkSimulation.force<d3Force.ForceLink<SimNode, SimLink>>('link');
// This is mainly an issue for ForceLinks, if once wants to get the links from an initialized force
// or re-set new links for an initialized force, e.g.:
simLinks = (<d3Force.ForceLink<SimNode, SimLink>>nodeLinkSimulation.force('link')).links();
simLinks = nodeLinkSimulation.force<d3Force.ForceLink<SimNode, SimLink>>('link').links();
// fLink = nodeLinkSimulation.force('link'); // fails, as ForceLink specific properties are missing from 'generic' force
// The same could be followed for custom forces.
// on() --------------------------------------------------------------------------------
@@ -511,11 +515,11 @@ nodeSimulation = nodeSimulation.on('tick', null);
// restart() --------------------------------------------------------------------------
nodeLinkSimulation.restart();
nodeLinkSimulation = nodeLinkSimulation.restart();
// stop() -----------------------------------------------------------------------------
nodeLinkSimulation.stop();
nodeLinkSimulation = nodeLinkSimulation.stop();
// tick() -----------------------------------------------------------------------------

84
d3-force/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-force module 1.0.0
// Project: https://github.com/d3/d3-force/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -31,28 +31,28 @@ export interface SimulationLinkDatum<NodeDatum extends SimulationNodeDatum> {
}
export interface Simulation<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum>> {
restart(): Simulation<NodeDatum, LinkDatum>;
stop(): Simulation<NodeDatum, LinkDatum>;
tick(): Simulation<NodeDatum, LinkDatum>;
restart(): this;
stop(): this;
tick(): void;
nodes(): Array<NodeDatum>;
nodes(nodesData: Array<NodeDatum>): Simulation<NodeDatum, LinkDatum>;
nodes(nodesData: Array<NodeDatum>): this;
alpha(): number;
alpha(alpha: number): Simulation<NodeDatum, LinkDatum>;
alpha(alpha: number): this;
alphaMin(): number;
alphaMin(min: number): Simulation<NodeDatum, LinkDatum>;
alphaMin(min: number): this;
alphaDecay(): number;
alphaDecay(decay: number): Simulation<NodeDatum, LinkDatum>;
alphaDecay(decay: number): this;
alphaTarget(): number;
alphaTarget(target: number): Simulation<NodeDatum, LinkDatum>;
alphaTarget(target: number): this;
velocityDecay(): number;
velocityDecay(decay: number): Simulation<NodeDatum, LinkDatum>;
force(name: string): Force<NodeDatum, LinkDatum>; // force names are arbitrary, so return type inference is not possible
force(name: string, force: null): Simulation<NodeDatum, LinkDatum>;
force(name: string, force: Force<NodeDatum, LinkDatum>): Simulation<NodeDatum, LinkDatum>;
velocityDecay(decay: number): this;
force<F extends Force<NodeDatum, LinkDatum>>(name: string): F; // force names are arbitrary, so return type inference is not possible
force(name: string, force: null): this;
force(name: string, force: Force<NodeDatum, LinkDatum>): this;
find(x: number, y: number, radius?: number): NodeDatum | undefined;
on(typenames: 'tick' | 'end' | string): (this: Simulation<NodeDatum, LinkDatum>) => void;
on(typenames: 'tick' | 'end' | string, listener: null): Simulation<NodeDatum, LinkDatum>;
on(typenames: 'tick' | 'end' | string, listener: (this: this) => void): Simulation<NodeDatum, LinkDatum>;
on(typenames: 'tick' | 'end' | string, listener: null): this;
on(typenames: 'tick' | 'end' | string, listener: (this: this) => void): this;
}
export function forceSimulation<NodeDatum extends SimulationNodeDatum>(nodesData?: Array<NodeDatum>): Simulation<NodeDatum, undefined>;
@@ -65,7 +65,7 @@ export function forceSimulation<NodeDatum extends SimulationNodeDatum, LinkDatum
export interface Force<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum>> {
(alpha: number): void;
initialize(nodes: Array<NodeDatum>): void;
initialize?(nodes: Array<NodeDatum>): void;
}
@@ -73,9 +73,9 @@ export interface Force<NodeDatum extends SimulationNodeDatum, LinkDatum extends
export interface ForceCenter<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
x(): number;
x(x: number): ForceCenter<NodeDatum>;
x(x: number): this;
y(): number;
y(y: number): ForceCenter<NodeDatum>;
y(y: number): this;
}
export function forceCenter<NodeDatum extends SimulationNodeDatum>(x?: number, y?: number): ForceCenter<NodeDatum>;
@@ -84,12 +84,12 @@ export function forceCenter<NodeDatum extends SimulationNodeDatum>(x?: number, y
export interface ForceCollide<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
radius(): (node: NodeDatum, i: number, nodes: Array<NodeDatum>) => number;
radius(radius: number): ForceCollide<NodeDatum>;
radius(radius: (node: NodeDatum, i: number, nodes: Array<NodeDatum>) => number): ForceCollide<NodeDatum>;
radius(radius: number): this;
radius(radius: (node: NodeDatum, i: number, nodes: Array<NodeDatum>) => number): this;
strength(): number;
strength(strength: number): ForceCollide<NodeDatum>;
strength(strength: number): this;
iterations(): number;
iterations(iterations: number): ForceCollide<NodeDatum>;
iterations(iterations: number): this;
}
export function forceCollide<NodeDatum extends SimulationNodeDatum>(): ForceCollide<NodeDatum>;
@@ -100,17 +100,17 @@ export function forceCollide<NodeDatum extends SimulationNodeDatum>(radius: (nod
export interface ForceLink<NodeDatum extends SimulationNodeDatum, LinkDatum extends SimulationLinkDatum<NodeDatum>> extends Force<NodeDatum, LinkDatum> {
links(): Array<LinkDatum>;
links(links: Array<LinkDatum>): ForceLink<NodeDatum, LinkDatum>;
links(links: Array<LinkDatum>): this;
id(): (node: NodeDatum, i: number, nodesData: Array<NodeDatum>) => (string | number);
id(id: (node: NodeDatum, i: number, nodesData: Array<NodeDatum>) => string): ForceLink<NodeDatum, LinkDatum>;
id(id: (node: NodeDatum, i: number, nodesData: Array<NodeDatum>) => string): this;
distance(): (link: LinkDatum, i: number, links: Array<LinkDatum>) => number;
distance(distance: number): ForceLink<NodeDatum, LinkDatum>;
distance(distance: (link: LinkDatum, i: number, links: Array<LinkDatum>) => number): ForceLink<NodeDatum, LinkDatum>;
distance(distance: number): this;
distance(distance: (link: LinkDatum, i: number, links: Array<LinkDatum>) => number): this;
strength(): (link: LinkDatum, i: number, links: Array<LinkDatum>) => number;
strength(strength: number): ForceLink<NodeDatum, LinkDatum>;
strength(strength: (link: LinkDatum, i: number, links: Array<LinkDatum>) => number): ForceLink<NodeDatum, LinkDatum>;
strength(strength: number): this;
strength(strength: (link: LinkDatum, i: number, links: Array<LinkDatum>) => number): this;
iterations(): number;
iterations(iterations: number): ForceLink<NodeDatum, LinkDatum>;
iterations(iterations: number): this;
}
export function forceLink<NodeDatum extends SimulationNodeDatum, LinksDatum extends SimulationLinkDatum<NodeDatum>>(): ForceLink<NodeDatum, LinksDatum>;
@@ -120,14 +120,14 @@ export function forceLink<NodeDatum extends SimulationNodeDatum, LinksDatum exte
export interface ForceManyBody<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
strength(): (d: NodeDatum, i: number, data: Array<NodeDatum>) => number;
strength(strength: number): ForceManyBody<NodeDatum>;
strength(strength: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): ForceManyBody<NodeDatum>;
strength(strength: number): this;
strength(strength: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): this;
theta(): number;
theta(theta: number): ForceManyBody<NodeDatum>;
theta(theta: number): this;
distanceMin(): number;
distanceMin(distance: number): ForceManyBody<NodeDatum>;
distanceMin(distance: number): this;
distanceMax(): number;
distanceMax(distance: number): ForceManyBody<NodeDatum>;
distanceMax(distance: number): this;
}
export function forceManyBody<NodeDatum extends SimulationNodeDatum>(): ForceManyBody<NodeDatum>;
@@ -136,11 +136,11 @@ export function forceManyBody<NodeDatum extends SimulationNodeDatum>(): ForceMan
export interface ForceX<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
strength(): (d: NodeDatum, i: number, data: Array<NodeDatum>) => number;
strength(strength: number): ForceX<NodeDatum>;
strength(strength: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): ForceX<NodeDatum>;
strength(strength: number): this;
strength(strength: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): this;
x(): (d: NodeDatum, i: number, data: Array<NodeDatum>) => number;
x(x: number): ForceX<NodeDatum>;
x(x: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): ForceX<NodeDatum>;
x(x: number): this;
x(x: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): this;
}
export function forceX<NodeDatum extends SimulationNodeDatum>(): ForceX<NodeDatum>;
@@ -149,11 +149,11 @@ export function forceX<NodeDatum extends SimulationNodeDatum>(x: (d: NodeDatum,
export interface ForceY<NodeDatum extends SimulationNodeDatum> extends Force<NodeDatum, any> {
strength(): (d: NodeDatum, i: number, data: Array<NodeDatum>) => number;
strength(strength: number): ForceY<NodeDatum>;
strength(strength: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): ForceY<NodeDatum>;
strength(strength: number): this;
strength(strength: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): this;
y(): (d: NodeDatum, i: number, data: Array<NodeDatum>) => number;
y(y: number): ForceY<NodeDatum>;
y(y: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): ForceY<NodeDatum>;
y(y: number): this;
y(y: (d: NodeDatum, i: number, data: Array<NodeDatum>) => number): this;
}
export function forceY<NodeDatum extends SimulationNodeDatum>(): ForceY<NodeDatum>;

2
d3-format/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-format module 1.0.0
// Project: https://github.com/d3/d3-format/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**

2
d3-hierarchy/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-hierarchy module 1.0.0
// Project: https://github.com/d3/d3-hierarchy/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// -----------------------------------------------------------------------

45
d3-hsv/d3-hsv-tests.ts Normal file
View File

@@ -0,0 +1,45 @@
/**
* Typescript definition tests for d3/d3-hsv module
*
* Note: These tests are intended to test the definitions only
* in the sense of typing and call signature consistency. They
* are not intended as functional tests.
*/
import {hsv, HSVColor} from 'd3-hsv';
import {rgb, RGBColor} from 'd3-color';
let c: RGBColor,
cHSV: HSVColor,
displayable: boolean,
cString: string;
// hsv signature
cHSV = hsv(120, 0.4, 0.5);
cHSV = hsv(120, 0.4, 0.5, 0.5);
// specifier signature
cHSV = hsv('rgb(255, 255, 255)');
cHSV = hsv('rgb(10%, 20%, 30%)');
cHSV = hsv('rgba(255, 255, 255, 0.4)');
cHSV = hsv('rgba(10%, 20%, 30%, 0.4)');
cHSV = hsv('hsl(120, 50%, 20%)');
cHSV = hsv('hsla(120, 50%, 20%, 0.4)');
cHSV = hsv('#ffeeaa');
cHSV = hsv('#fea');
cHSV = hsv('steelblue');
// color signature
c = rgb('steelblue');
cHSV = hsv(c);
cHSV = hsv(cHSV);
// method signatures
cHSV = cHSV.brighter();
cHSV = cHSV.brighter(0.2);
cHSV = cHSV.darker();
cHSV = cHSV.darker(0.2);
displayable = cHSV.displayable();
cString = cHSV.toString();
console.log('Channels = (h : %d, s: %d, v: %d)', cHSV.h, cHSV.s, cHSV.v);
console.log('Opacity = %d', cHSV.opacity);

26
d3-hsv/index.d.ts vendored Normal file
View File

@@ -0,0 +1,26 @@
// Type definitions for D3JS d3-hsv module 0.0.3
// Project: https://github.com/d3/d3-hsv/
// Definitions by: Yuri Feldman <https://github.com/arrayjam>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {Color, RGBColor, ColorSpaceObject, ColorCommonInstance} from 'd3-color';
type ColorSpaceObjectWithHSV = ColorSpaceObject | HSVColor;
export interface HSVColorFactory extends Function {
(h: number, s: number, v: number, opacity?: number): HSVColor;
(cssColorSpecifier: string): HSVColor;
(color: HSVColor | ColorSpaceObject | ColorCommonInstance): HSVColor;
}
export interface HSVColor extends Color {
h: number;
s: number;
v: number;
opacity: number;
brighter(k?: number): this;
darker(k?: number): this;
rgb(): RGBColor;
}
export var hsv: HSVColorFactory;

19
d3-hsv/tsconfig.json Normal file
View File

@@ -0,0 +1,19 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"noImplicitAny": true,
"strictNullChecks": false,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"d3-hsv-tests.ts"
]
}

16
d3-interpolate/d3-interpolate-tests.ts
View File

@@ -6,8 +6,9 @@
* are not intended as functional tests.
*/
import * as d3Interpolate from 'd3-interpolate';
import * as d3Color from 'd3-color';
import * as d3Interpolate from 'd3-interpolate';
import * as d3Hsv from 'd3-hsv';
// Preparatory steps -------------------------------------------------------------------
@@ -56,6 +57,7 @@ let num: number,
arrStr: string[],
objKeyVal: { [key: string]: any },
objRGBColor: d3Color.RGBColor,
objHSVColor: d3Hsv.HSVColor,
zoom: [number, number, number];
// test interpolate(a, b) signature ----------------------------------------------------
@@ -65,6 +67,7 @@ iNum = d3Interpolate.interpolate('1', 5);
// color interpolator returning a color string
iString = d3Interpolate.interpolate('seagreen', d3Color.rgb(100, 100, 100));
iString = d3Interpolate.interpolate('seagreen', d3Hsv.hsv(60, 1, 0.2, 0.4));
iString = d3Interpolate.interpolate('seagreen', 'steelblue'); // as used with valid color name string
// date interpolator
@@ -168,6 +171,7 @@ arrStr = d3Interpolate.quantize<string>(d3Interpolate.interpolateString('-1', '2
// without gamma correction
iString = d3Interpolate.interpolateRgb('seagreen', 'steelblue');
iString = d3Interpolate.interpolateRgb(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateRgb(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
str = iString(0.5);
// with gamma correction
@@ -176,34 +180,41 @@ iString = d3Interpolate.interpolateRgb.gamma(2.2)('purple', 'orange');
// test interpolateRgbBasis(color) and interpolateRgbBasisClosed(color) signatures -------------------------
iString = d3Interpolate.interpolateRgbBasis(['seagreen', d3Color.rgb('steelblue'), 'rgb(100, 100, 100)']);
iString = d3Interpolate.interpolateRgbBasisClosed(['seagreen', d3Color.rgb('steelblue'), 'rgb(100, 100, 100)']);
iString = d3Interpolate.interpolateRgbBasis(['seagreen', d3Hsv.hsv('steelblue'), 'rgb(100, 100, 100)']);
iString = d3Interpolate.interpolateRgbBasisClosed(['seagreen', d3Hsv.hsv('steelblue'), 'rgb(100, 100, 100)']);
// test interpolateHsl(a, b) and interpolateHslLong(a, b)----------------------------------------------------------------
iString = d3Interpolate.interpolateHsl('seagreen', 'steelblue');
iString = d3Interpolate.interpolateHsl(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateHsl(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
iString = d3Interpolate.interpolateHslLong('seagreen', 'steelblue');
iString = d3Interpolate.interpolateHslLong(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateHslLong(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
// test interpolateLab(a, b) --------------------------------------------------------------------------------------------
iString = d3Interpolate.interpolateLab('seagreen', 'steelblue');
iString = d3Interpolate.interpolateLab(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateLab(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
// test interpolateHcl(a, b) and interpolateHclLong(a, b) ----------------------------------------------------------------
iString = d3Interpolate.interpolateHcl('seagreen', 'steelblue');
iString = d3Interpolate.interpolateHcl(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateHcl(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
iString = d3Interpolate.interpolateHclLong('seagreen', 'steelblue');
iString = d3Interpolate.interpolateHclLong(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateHclLong(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
// test interpolateCubehelix(a, b) and interpolateCubehelixLong(a, b) ---------------------------------------------------
// without gamma correction
iString = d3Interpolate.interpolateCubehelix('seagreen', 'steelblue');
iString = d3Interpolate.interpolateCubehelix(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateCubehelix(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
str = iString(0.5);
// with gamma correction
@@ -212,6 +223,7 @@ iString = d3Interpolate.interpolateCubehelix.gamma(2.2)('purple', 'orange');
// without gamma correction
iString = d3Interpolate.interpolateCubehelixLong('seagreen', 'steelblue');
iString = d3Interpolate.interpolateCubehelixLong(d3Color.rgb('seagreen'), d3Color.hcl('steelblue'));
iString = d3Interpolate.interpolateCubehelixLong(d3Color.rgb('seagreen'), d3Hsv.hsv('steelblue'));
str = iString(0.5);
// with gamma correction

22
d3-interpolate/index.d.ts vendored
View File

@@ -1,9 +1,9 @@
// Type definitions for D3JS d3-interpolate module 1.1.0
// Project: https://github.com/d3/d3-interpolate/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { ColorSpaceObject } from '../d3-color';
import { ColorCommonInstance } from 'd3-color';
// --------------------------------------------------------------------------
@@ -20,7 +20,7 @@ export interface ZoomInterpolator extends Function {
}
export interface ColorGammaInterpolationFactory extends Function {
(a: string | ColorSpaceObject, b: string | ColorSpaceObject): ((t: number) => string);
(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
gamma(g: number): ColorGammaInterpolationFactory;
}
@@ -39,7 +39,7 @@ export type ZoomView = [number, number, number];
export function interpolate(a: any, b: null): ((t: number) => null);
export function interpolate(a: number | { valueOf(): number }, b: number): ((t: number) => number);
export function interpolate(a: any, b: ColorSpaceObject): ((t: number) => string);
export function interpolate(a: any, b: ColorCommonInstance): ((t: number) => string);
export function interpolate(a: Date, b: Date): ((t: number) => Date);
export function interpolate(a: string | { toString(): string }, b: string): ((t: number) => string);
export function interpolate<U extends Array<any>>(a: Array<any>, b: U): ((t: number) => U);
@@ -78,14 +78,14 @@ export function quantize<T>(interpolator: ((t: number) => T), n: number): Array<
export var interpolateRgb: ColorGammaInterpolationFactory;
export function interpolateRgbBasis(colors: Array<string | ColorSpaceObject>): ((t: number) => string);
export function interpolateRgbBasisClosed(colors: Array<string | ColorSpaceObject>): ((t: number) => string);
export function interpolateRgbBasis(colors: Array<string | ColorCommonInstance>): ((t: number) => string);
export function interpolateRgbBasisClosed(colors: Array<string | ColorCommonInstance>): ((t: number) => string);
export function interpolateHsl(a: string | ColorSpaceObject, b: string | ColorSpaceObject): ((t: number) => string);
export function interpolateHslLong(a: string | ColorSpaceObject, b: string | ColorSpaceObject): ((t: number) => string);
export function interpolateLab(a: string | ColorSpaceObject, b: string | ColorSpaceObject): ((t: number) => string);
export function interpolateHcl(a: string | ColorSpaceObject, b: string | ColorSpaceObject): ((t: number) => string);
export function interpolateHclLong(a: string | ColorSpaceObject, b: string | ColorSpaceObject): ((t: number) => string);
export function interpolateHsl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
export function interpolateHslLong(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
export function interpolateLab(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
export function interpolateHcl(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
export function interpolateHclLong(a: string | ColorCommonInstance, b: string | ColorCommonInstance): ((t: number) => string);
export var interpolateCubehelix: ColorGammaInterpolationFactory;
export var interpolateCubehelixLong: ColorGammaInterpolationFactory;

2
d3-path/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-path module 1.0.0
// Project: https://github.com/d3/d3-path/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export interface Path {

2
d3-polygon/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-polygon module 1.0.0
// Project: https://github.com/d3/d3-polygon/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**

24
d3-quadtree/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-quadtree module 1.0.0
// Project: https://github.com/d3/d3-quadtree/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**
@@ -20,27 +20,27 @@ export interface QuadtreeLeaf<T> {
*
* A child quadrant may be undefined if it is empty.
*/
export interface QuadtreeInternalNode<T> extends Array<QuadtreeInternalNode<T> | QuadtreeLeaf<T> | undefined> {}
export interface QuadtreeInternalNode<T> extends Array<QuadtreeInternalNode<T> | QuadtreeLeaf<T> | undefined> { }
export interface Quadtree<T> {
x(): (d: T) => number;
x(x: (d: T) => number): Quadtree<T>;
x(x: (d: T) => number): this;
y(): (d: T) => number;
y(y: (d: T) => number): Quadtree<T>;
y(y: (d: T) => number): this;
extent(): [[number, number], [number, number]] | undefined;
extent(extend: [[number, number], [number, number]]): Quadtree<T>;
cover(x: number, y: number): Quadtree<T>;
add(datum: T): Quadtree<T>;
addAll(data: Array<T>): Quadtree<T>;
remove(datum: T): Quadtree<T>;
removeAll(data: Array<T>): Quadtree<T>;
extent(extend: [[number, number], [number, number]]): this;
cover(x: number, y: number): this;
add(datum: T): this;
addAll(data: Array<T>): this;
remove(datum: T): this;
removeAll(data: Array<T>): this;
copy(): Quadtree<T>;
root(): QuadtreeInternalNode<T> | QuadtreeLeaf<T>;
data(): Array<T>;
size(): number;
find(x: number, y: number, radius?: number): T | undefined;
visit(callback: (node: QuadtreeInternalNode<T> | QuadtreeLeaf<T>, x0: number, y0: number, x1: number, y1: number) => (void | boolean)): Quadtree<T>;
visitAfter(callback: (node: QuadtreeInternalNode<T> | QuadtreeLeaf<T>, x0: number, y0: number, x1: number, y1: number) => void): Quadtree<T>;
visit(callback: (node: QuadtreeInternalNode<T> | QuadtreeLeaf<T>, x0: number, y0: number, x1: number, y1: number) => (void | boolean)): this;
visitAfter(callback: (node: QuadtreeInternalNode<T> | QuadtreeLeaf<T>, x0: number, y0: number, x1: number, y1: number) => void): this;
}

2
d3-queue/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-queue module 3.0.1
// Project: https://github.com/d3/d3-queue/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**

2
d3-random/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-random module 1.0.0
// Project: https://github.com/d3/d3-random/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**

118
d3-scale/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-scale module 1.0.1
// Project: https://github.com/d3/d3-scale/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { CountableTimeInterval, TimeInterval } from 'd3-time';
@@ -28,22 +28,22 @@ export interface ScaleLinear<Range, Output> {
*/
invert(value: number | { valueOf(): number }): number;
domain(): Array<number>;
domain(domain: Array<number | { valueOf(): number }>): ScaleLinear<Range, Output>;
domain(domain: Array<number | { valueOf(): number }>): this;
range(): Array<Range>;
range(range: Array<Range>): ScaleLinear<Range, Output>;
range(range: Array<Range>): this;
/**
* Important: While value should come out of range R, this is method is only applicable to
* values that can be coerced to numeric.
*/
rangeRound(range: Array<number | { valueOf(): number }>): ScaleLinear<Range, Output>;
rangeRound(range: Array<number | { valueOf(): number }>): this;
clamp(): boolean;
clamp(clamp: boolean): ScaleLinear<Range, Output>;
interpolate(): InterpolatorFactory<any, any>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): ScaleLinear<Range, Output>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): this;
interpolate<NewOutput>(interpolate: InterpolatorFactory<Range, NewOutput>): ScaleLinear<Range, NewOutput>;
ticks(count?: number): Array<number>;
tickFormat(count?: number, specifier?: string): ((d: number | { valueOf(): number }) => string);
nice(count?: number): ScaleLinear<Range, Output>;
nice(count?: number): this;
copy(): ScaleLinear<Range, Output>;
}
@@ -64,26 +64,26 @@ export interface ScalePower<Range, Output> {
*/
invert(value: number | { valueOf(): number }): number;
domain(): Array<number>;
domain(domain: Array<number | { valueOf(): number }>): ScalePower<Range, Output>;
domain(domain: Array<number | { valueOf(): number }>): this;
range(): Array<Range>;
range(range: Array<Range>): ScalePower<Range, Output>;
range(range: Array<Range>): this;
/**
* Important: While value should come out of range R, this is method is only applicable to
* values that can be coerced to numeric.
*/
rangeRound(range: Array<number | { valueOf(): number }>): ScalePower<Range, Output>;
rangeRound(range: Array<number | { valueOf(): number }>): this;
clamp(): boolean;
clamp(clamp: boolean): ScalePower<Range, Output>;
clamp(clamp: boolean): this;
interpolate(): InterpolatorFactory<any, any>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): ScalePower<Range, Output>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): this;
interpolate<NewOutput>(interpolate: InterpolatorFactory<Range, NewOutput>): ScalePower<Range, NewOutput>;
ticks(count?: number): Array<number>;
tickFormat(count?: number, specifier?: string): ((d: number | { valueOf(): number }) => string);
nice(count?: number): ScalePower<Range, Output>;
nice(count?: number): this;
copy(): ScalePower<Range, Output>;
exponent(): number;
exponent(exponent: number): ScalePower<Range, Output>;
exponent(exponent: number): this;
}
export function scalePow(): ScalePower<number, number>;
@@ -107,26 +107,26 @@ export interface ScaleLogarithmic<Range, Output> {
*/
invert(value: number | { valueOf(): number }): number;
domain(): Array<number>;
domain(domain: Array<number | { valueOf(): number }>): ScaleLogarithmic<Range, Output>;
domain(domain: Array<number | { valueOf(): number }>): this;
range(): Array<Range>;
range(range: Array<Range>): ScaleLogarithmic<Range, Output>;
range(range: Array<Range>): this;
/**
* Important: While value should come out of range R, this is method is only applicable to
* values that can be coerced to numeric.
*/
rangeRound(range: Array<number | { valueOf(): number }>): ScaleLogarithmic<Range, Output>;
rangeRound(range: Array<number | { valueOf(): number }>): this;
clamp(): boolean;
clamp(clamp: boolean): ScaleLogarithmic<Range, Output>;
clamp(clamp: boolean): this;
interpolate(): InterpolatorFactory<any, any>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): ScaleLogarithmic<Range, Output>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): this;
interpolate<NewOutput>(interpolate: InterpolatorFactory<Range, NewOutput>): ScaleLogarithmic<Range, NewOutput>;
ticks(count?: number): Array<number>;
tickFormat(count?: number, specifier?: string): ((d: number | { valueOf(): number }) => string);
nice(count?: number): ScaleLogarithmic<Range, Output>;
nice(count?: number): this;
copy(): ScaleLogarithmic<Range, Output>;
base(): number;
base(base: number): ScaleLogarithmic<Range, Output>;
base(base: number): this;
}
export function scaleLog(): ScaleLogarithmic<number, number>;
@@ -146,12 +146,12 @@ export interface ScaleIdentity {
*/
invert(value: number | { valueOf(): number }): number;
domain(): Array<number>;
domain(domain: Array<number | { valueOf(): number }>): ScaleIdentity;
domain(domain: Array<number | { valueOf(): number }>): this;
range(): Array<number>;
range(range: Array<Range | { valueOf(): number }>): ScaleIdentity;
range(range: Array<Range | { valueOf(): number }>): this;
ticks(count?: number): Array<number>;
tickFormat(count?: number, specifier?: string): ((d: number | { valueOf(): number }) => string);
nice(count?: number): ScaleIdentity;
nice(count?: number): this;
copy(): ScaleIdentity;
}
@@ -170,18 +170,18 @@ export interface ScaleTime<Range, Output> {
*/
invert(value: number | { valueOf(): number }): Date;
domain(): Array<Date>;
domain(domain: Array<Date>): ScaleTime<Range, Output>;
domain(domain: Array<Date>): this;
range(): Array<Range>;
range(range: Array<Range>): ScaleTime<Range, Output>;
range(range: Array<Range>): this;
/**
* Important: While value should come out of range R, this is method is only applicable to
* values that can be coerced to numeric.
*/
rangeRound(range: Array<number | { valueOf(): number }>): ScaleTime<Range, Output>;
rangeRound(range: Array<number | { valueOf(): number }>): this;
clamp(): boolean;
clamp(clamp: boolean): ScaleTime<Range, Output>;
clamp(clamp: boolean): this;
interpolate(): InterpolatorFactory<any, any>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): ScaleTime<Range, Output>;
interpolate(interpolate: InterpolatorFactory<Range, Output>): this;
interpolate<NewOutput>(interpolate: InterpolatorFactory<Range, NewOutput>): ScaleTime<Range, NewOutput>;
ticks(): Array<Date>;
ticks(count: number): Array<Date>;
@@ -189,9 +189,9 @@ export interface ScaleTime<Range, Output> {
tickFormat(): ((d: Date) => string);
tickFormat(count: number, specifier?: string): ((d: Date) => string);
tickFormat(interval: TimeInterval, specifier?: string): ((d: Date) => string);
nice(): ScaleTime<Range, Output>;
nice(count: number): ScaleTime<Range, Output>;
nice(interval: CountableTimeInterval, step?: number): ScaleTime<Range, Output>;
nice(): this;
nice(count: number): this;
nice(interval: CountableTimeInterval, step?: number): this;
copy(): ScaleTime<Range, Output>;
}
@@ -209,13 +209,13 @@ export function scaleUtc<Range, Output>(): ScaleTime<Range, Output>;
export interface ScaleSequential<Output> {
(value: number): Output;
(value: number | { valueOf(): number }): Output;
domain(): [number, number];
domain(domain: [number | { valueOf(): number }, number | { valueOf(): number }]): ScaleSequential<Output>;
domain(domain: [number | { valueOf(): number }, number | { valueOf(): number }]): this;
clamp(): boolean;
clamp(clamp: boolean): ScaleSequential<Output>;
clamp(clamp: boolean): this;
interpolator(): ((t: number) => Output);
interpolator(interpolator: ((t: number) => Output)): ScaleSequential<Output>;
interpolator(interpolator: ((t: number) => Output)): this;
interpolator<NewOutput>(interpolator: ((t: number) => NewOutput)): ScaleSequential<NewOutput>;
copy(): ScaleSequential<Output>;
}
@@ -255,12 +255,12 @@ export interface ScaleQuantize<Range> {
*/
invertExtent(value: Range): [number, number];
domain(): [number, number];
domain(domain: [number | { valueOf(): number }, number | { valueOf(): number }]): ScaleQuantize<Range>;
domain(domain: [number | { valueOf(): number }, number | { valueOf(): number }]): this;
range(): Array<Range>;
range(range: Array<Range>): ScaleQuantize<Range>;
range(range: Array<Range>): this;
ticks(count?: number): Array<number>;
tickFormat(count?: number, specifier?: string): ((d: number | { valueOf(): number }) => string);
nice(count?: number): ScaleQuantize<Range>;
nice(count?: number): this;
copy(): ScaleQuantize<Range>;
}
@@ -275,9 +275,9 @@ export interface ScaleQuantile<Range> {
(value: number | { valueOf(): number }): Range;
invertExtent(value: Range): [number, number];
domain(): Array<number>;
domain(domain: Array<number | { valueOf(): number }>): ScaleQuantile<Range>;
domain(domain: Array<number | { valueOf(): number }>): this;
range(): Array<Range>;
range(range: Array<Range>): ScaleQuantile<Range>;
range(range: Array<Range>): this;
quantiles(): Array<number>;
copy(): ScaleQuantile<Range>;
}
@@ -298,9 +298,9 @@ export interface ScaleThreshold<Domain extends number | string | Date, Range> {
*/
invertExtent(value: Range): [Domain, Domain] | [undefined, Domain] | [Domain, undefined] | [undefined, undefined];
domain(): Array<Domain>;
domain(domain: Array<Domain>): ScaleThreshold<Domain, Range>;
domain(domain: Array<Domain>): this;
range(): Array<Range>;
range(range: Array<Range>): ScaleThreshold<Domain, Range>;
range(range: Array<Range>): this;
copy(): ScaleThreshold<Domain, Range>;
}
@@ -315,11 +315,11 @@ export function scaleThreshold<Domain extends number | string | Date, Range>():
export interface ScaleOrdinal<Domain extends { toString(): string }, Range> {
(x: Domain): Range;
domain(): Array<Domain>;
domain(domain: Array<Domain>): ScaleOrdinal<Domain, Range>;
domain(domain: Array<Domain>): this;
range(): Array<Range>;
range(range: Array<Range>): ScaleOrdinal<Domain, Range>;
range(range: Array<Range>): this;
unknown(): Range | { name: 'implicit' };
unknown(value: Range | { name: 'implicit' }): ScaleOrdinal<Domain, Range>;
unknown(value: Range | { name: 'implicit' }): this;
copy(): ScaleOrdinal<Domain, Range>;
}
@@ -336,16 +336,16 @@ export const scaleImplicit: { name: 'implicit' };
export interface ScaleBand<Domain extends { toString(): string }> {
(x: Domain): number | undefined;
domain(): Array<Domain>;
domain(domain: Array<Domain>): ScaleBand<Domain>;
domain(domain: Array<Domain>): this;
range(): [number, number];
range(range: [number | { valueOf(): number }, number | { valueOf(): number }]): ScaleBand<Domain>;
rangeRound(range: [number | { valueOf(): number }, number | { valueOf(): number }]): ScaleBand<Domain>;
range(range: [number | { valueOf(): number }, number | { valueOf(): number }]): this;
rangeRound(range: [number | { valueOf(): number }, number | { valueOf(): number }]): this;
round(): boolean;
round(round: boolean): ScaleBand<Domain>;
round(round: boolean): this;
paddingInner(): number;
paddingInner(padding: number): ScaleBand<Domain>;
paddingInner(padding: number): this;
paddingOuter(): number;
paddingOuter(padding: number): ScaleBand<Domain>;
paddingOuter(padding: number): this;
/**
* Returns the inner padding.
*/
@@ -353,9 +353,9 @@ export interface ScaleBand<Domain extends { toString(): string }> {
/**
* A convenience method for setting the inner and outer padding to the same padding value.
*/
padding(padding: number): ScaleBand<Domain>;
padding(padding: number): this;
align(): number;
align(align: number): ScaleBand<Domain>;
align(align: number): this;
bandwidth(): number;
step(): number;
copy(): ScaleBand<Domain>;
@@ -371,12 +371,12 @@ export function scaleBand<Domain extends { toString(): string }>(): ScaleBand<Do
export interface ScalePoint<Domain extends { toString(): string }> {
(x: Domain): number | undefined;
domain(): Array<Domain>;
domain(domain: Array<Domain>): ScalePoint<Domain>;
domain(domain: Array<Domain>): this;
range(): [number, number];
range(range: [number | { valueOf(): number }, number | { valueOf(): number }]): ScalePoint<Domain>;
rangeRound(range: [number | { valueOf(): number }, number | { valueOf(): number }]): ScalePoint<Domain>;
range(range: [number | { valueOf(): number }, number | { valueOf(): number }]): this;
rangeRound(range: [number | { valueOf(): number }, number | { valueOf(): number }]): this;
round(): boolean;
round(round: boolean): ScalePoint<Domain>;
round(round: boolean): this;
/**
* Returns the current outer padding which defaults to 0.
* The outer padding determines the ratio of the range that is reserved for blank space
@@ -388,9 +388,9 @@ export interface ScalePoint<Domain extends { toString(): string }> {
* The outer padding determines the ratio of the range that is reserved for blank space
* before the first point and after the last point.
*/
padding(padding: number): ScalePoint<Domain>;
padding(padding: number): this;
align(): number;
align(align: number): ScalePoint<Domain>;
align(align: number): this;
bandwidth(): number;
step(): number;
copy(): ScalePoint<Domain>;

151
d3-selection-multi/d3-selection-multi-tests.ts Normal file
View File

@@ -0,0 +1,151 @@
/**
* Typescript definition tests for d3/d3-selection-multi module
*
* Note: These tests are intended to test the definitions only
* in the sense of typing and call signature consistency. They
* are not intended as functional tests.
*/
import {Selection} from 'd3-selection';
import {Transition} from 'd3-transition';
import * as d3SelectionMulti from 'd3-selection-multi';
let selection: Selection<HTMLAnchorElement, string, null, undefined>;
// Selection.attrs
// Simple object
selection = selection.attrs({
foo: 1,
bar: '2',
baz: true,
});
// Function values
selection = selection.attrs({
foo: () => 1,
bar: (d) => d,
baz: (d, i) => i !== 0,
bat: function () {
return this.href;
},
});
// Function that returns a map
selection = selection.attrs(function (d) {
return this.id ? null : { id: d };
});
// Selection.styles
// Each test is repeated twice: once without the priority, and another time with
// Simple object
selection = selection.styles({
top: 0,
color: 'red',
});
selection = selection.styles({
top: 0,
color: 'red',
}, 'important');
// Function values
selection = selection.styles({
top: (d, i) => i + 'px',
color: d => d,
});
selection = selection.styles({
top: (d, i) => i + 'px',
color: d => d,
}, 'important');
// Functions that return a map
selection.styles(function (d) {
return this.id ? { color: 'red' } : { color: d };
});
selection = selection.styles(function (d) {
return this.id ? { color: 'red' } : { color: d };
}, 'important');
// Selection.properties
// Simple object
selection = selection.properties({
foo: 1,
bar: 'bar',
});
// Function values
selection = selection.properties({
foo: (d, i) => i,
bar: d => d,
});
// Function that returns an object
selection = selection.properties(function (d) {
return this.href ? null : { href: d };
});
let transition: Transition<HTMLAnchorElement, string, null, undefined>;
// Transition.attrs
// Simple object
transition = transition.attrs({
foo: 1,
bar: '2',
baz: true,
});
// Function values
transition = transition.attrs({
foo: () => 1,
bar: (d) => d,
baz: (d, i) => i !== 0,
bat: function () {
return this.href;
},
});
// Function that returns a map
transition = transition.attrs(function (d) {
return this.id ? null : { id: d };
});
// Transition.styles
// As above, the tests are repeated with the priority 'important' passed in
// Simple object
transition = transition.styles({
top: 0,
color: 'red',
});
transition = transition.styles({
top: 0,
color: 'red',
}, 'important');
// Function values
transition = transition.styles({
top: (d, i) => i + 'px',
color: d => d,
});
transition = transition.styles({
top: (d, i) => i + 'px',
color: d => d,
}, 'important');
// Function that returns a map
transition = transition.styles(function (d) {
return this.id ? { color: 'red' } : { color: d };
});
transition = transition.styles(function (d) {
return this.id ? { color: 'red' } : { color: d };
}, 'important');

93
d3-selection-multi/index.d.ts vendored Normal file
View File

@@ -0,0 +1,93 @@
// Type definitions for D3JS d3-selection-multi module 1.0.0
// Project: https://github.com/d3/d3-selection-multi/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {Selection, BaseType, ArrayLike, ValueFn} from 'd3-selection';
import {Transition} from 'd3-transition';
// An object mapping attribute (or style or property) names to value accessors
export type ValueMap<Element, Datum> = { [key: string]: number | string | boolean | null | ValueFn<Element, Datum, number | string | boolean | null> };
declare module 'd3-selection' {
export interface Selection<GElement extends BaseType, Datum, PElement extends BaseType, PDatum> {
/**
* Set multiple attributes on the given selection. Attribute values may be constant or derived from each node and its bound data.
*
* @param attrs An object used as a map of attribute names to set
*/
attrs(attrs: ValueMap<GElement, Datum>): this;
/**
* Derive a map of attributes to be set on the selection.
*
* @param attrs A function that returns an object of attribute names and values to set.
*/
attrs(attrs: ValueFn<GElement, Datum, ValueMap<GElement, Datum>>): this;
/**
* Set multiple CSS style properties on the given selection. Style properties may be constant or derived from each node and its bound data.
*
* @param style An object used as a map of style properties to set.
* @param priority The CSS priority (either "important" or undefined).
*/
styles(style: ValueMap<GElement, Datum>, priority?: 'important'): this;
/**
* Derive a map of style properties to be set on the selection.
*
* @param style A function that returns an object of style properties and the values to be set.
* @param priority The CSS priority (either "important" or undefined)
*/
styles(style: ValueFn<GElement, Datum, ValueMap<GElement, Datum>>, priority?: 'important'): this;
/**
* Set multiple object properties directly on the selection's node(s). Property values may be constants or derived from each node and its bound data.
*
* @param props An object used as a map of object properties to be set.
*/
properties(props: ValueMap<GElement, Datum>): this;
/**
* Derive a map of object properties to be set on the selection's node(s).
*
* @param props A function that returns an object of properties and their values.
*/
properties(props: ValueFn<GElement, Datum, ValueMap<GElement, Datum>>): this;
}
}
declare module 'd3-transition' {
export interface Transition<GElement extends BaseType, Datum, PElement extends BaseType, PDatum> {
/**
* Set multiple attribute values. The transition will animate from the present value to the new value. Attribute values may be constant or derived from each node and its bound data.
*
* @param attrs An object used as a map of attributes and their values.
*/
attrs(attrs: ValueMap<GElement, Datum>): this;
/**
* Derive a map of attribute values to set.
*
* @param attrs A function returning a map of attributes and their values.
*/
attrs(attrs: ValueFn<GElement, Datum, ValueMap<GElement, Datum>>): this;
/**
* Set multiple style properties. The transition will animate from the present value to the new value. Attribute values may be constant or derived from each node and its bound data.
*
* @param style A map of style properties and their values
* @param priority The CSS priority (either "important" or undefined)
*/
styles(style: ValueMap<GElement, Datum>, priority?: 'important'): this;
/**
* Derive a map of style properties to be set.
*
* @param style A function returning a map of style properties and their values
* @param priority The CSS priority (either "important" or undefined)
*/
styles(style: ValueFn<GElement, Datum, ValueMap<GElement, Datum>>, priority?: 'important'): this;
}
}

19
d3-selection-multi/tsconfig.json Normal file
View File

@@ -0,0 +1,19 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"noImplicitAny": true,
"strictNullChecks": false,
"baseUrl": "../",
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"d3-selection-multi-tests.ts"
]
}

101
d3-selection/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-selection module 1.0.0
// Project: https://github.com/d3/d3-selection/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// --------------------------------------------------------------------------
@@ -21,7 +21,7 @@ export interface ArrayLike<T> {
[index: number]: T;
}
// TODO: Review Use for enter()
export interface EnterElement {
ownerDocument: Document;
namespaceURI: string;
@@ -56,6 +56,11 @@ export type CustomEventParameters = {
detail: any;
}
/**
* Callback type for selections and transitions
*/
export type ValueFn<Element, Datum, Result> = (this: Element, datum: Datum, index: number, groups: Array<Element> | ArrayLike<Element>) => Result;
/**
* TransitionLike is a helper interface to represent a quasi-Transition, without specifying the full Transition interface in this file.
@@ -70,9 +75,9 @@ export type CustomEventParameters = {
export interface TransitionLike<GElement extends BaseType, Datum> {
selection(): Selection<GElement, Datum, any, any>;
on(type: string, listener: null): TransitionLike<GElement, Datum>;
on(type: string, listener: (this: GElement, datum: Datum, index: number, group: Array<GElement> | ArrayLike<GElement>) => any): TransitionLike<GElement, Datum>;
on(type: string, listener: ValueFn<GElement, Datum, void>): TransitionLike<GElement, Datum>;
tween(name: string, tweenFn: null): TransitionLike<GElement, Datum>;
tween(name: string, tweenFn: (this: GElement, datum?: Datum, i?: number, group?: GElement[] | ArrayLike<GElement>) => ((t: number) => void)): TransitionLike<GElement, Datum>;
tween(name: string, tweenFn: ValueFn<GElement, Datum, ((t: number) => void)>): TransitionLike<GElement, Datum>;
}
@@ -100,115 +105,105 @@ interface Selection<GElement extends BaseType, Datum, PElement extends BaseType,
select<DescElement extends BaseType>(selector: string): Selection<DescElement, Datum, PElement, PDatum>;
select<DescElement extends BaseType>(selector: null): Selection<null, undefined, PElement, PDatum>; // _groups are set to empty array, first generic type is set to null by convention
select<DescElement extends BaseType>(selector: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => DescElement): Selection<DescElement, Datum, PElement, PDatum>;
select<DescElement extends BaseType>(selector: ValueFn<GElement, Datum, DescElement>): Selection<DescElement, Datum, PElement, PDatum>;
selectAll(): Selection<null, undefined, GElement, Datum>; // _groups are set to empty array, first generic type is set to null by convention
selectAll(selector: null): Selection<null, undefined, GElement, Datum>; // _groups are set to empty array, first generic type is set to null by convention
selectAll<DescElement extends BaseType, OldDatum>(selector: string): Selection<DescElement, OldDatum, GElement, Datum>;
selectAll<DescElement extends BaseType, OldDatum>(selector: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (Array<DescElement> | ArrayLike<DescElement>)): Selection<DescElement, OldDatum, GElement, Datum>;
selectAll<DescElement extends BaseType, OldDatum>(selector: ValueFn<GElement, Datum, Array<DescElement> | ArrayLike<DescElement>>): Selection<DescElement, OldDatum, GElement, Datum>;
// Modifying -------------------------------
attr(name: string): string;
attr(name: string, value: null): Selection<GElement, Datum, PElement, PDatum>;
attr(name: string, value: string | number | boolean): Selection<GElement, Datum, PElement, PDatum>;
attr(name: string, value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (string | number | boolean)): Selection<GElement, Datum, PElement, PDatum>;
attr(name: string, value: null): this;
attr(name: string, value: string | number | boolean): this;
attr(name: string, value: ValueFn<GElement, Datum, string | number | boolean>): this;
classed(name: string): boolean;
classed(name: string, value: boolean): Selection<GElement, Datum, PElement, PDatum>;
classed(name: string, value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => boolean): Selection<GElement, Datum, PElement, PDatum>;
classed(name: string, value: boolean): this;
classed(name: string, value: ValueFn<GElement, Datum, boolean>): this;
style(name: string): string;
style(name: string, value: null): Selection<GElement, Datum, PElement, PDatum>;
style(name: string, value: string | number | boolean, priority?: null | 'important'): Selection<GElement, Datum, PElement, PDatum>;
style(name: string, value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (string | number | boolean), priority?: null | 'important'): Selection<GElement, Datum, PElement, PDatum>;
style(name: string, value: null): this;
style(name: string, value: string | number | boolean, priority?: null | 'important'): this;
style(name: string, value: ValueFn<GElement, Datum, string | number | boolean>, priority?: null | 'important'): this;
property(name: string): any;
property(name: string, value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => any): Selection<GElement, Datum, PElement, PDatum>;
property(name: string, value: null): Selection<GElement, Datum, PElement, PDatum>;
property(name: string, value: any): Selection<GElement, Datum, PElement, PDatum>;
property(name: string, value: ValueFn<GElement, Datum, any>): this;
property(name: string, value: null): this;
property(name: string, value: any): this;
text(): string;
text(value: string | number | boolean): Selection<GElement, Datum, PElement, PDatum>;
text(value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (string | number | boolean)): Selection<GElement, Datum, PElement, PDatum>;
text(value: string | number | boolean): this;
text(value: ValueFn<GElement, Datum, string | number | boolean>): this;
html(): string;
html(value: string): Selection<GElement, Datum, PElement, PDatum>;
html(value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => string): Selection<GElement, Datum, PElement, PDatum>;
html(value: string): this;
html(value: ValueFn<GElement, Datum, string>): this;
append<ChildElement extends BaseType>(type: string): Selection<ChildElement, Datum, PElement, PDatum>;
append<ChildElement extends BaseType>(type: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => ChildElement): Selection<ChildElement, Datum, PElement, PDatum>;
append<ChildElement extends BaseType>(type: ValueFn<GElement, Datum, ChildElement>): Selection<ChildElement, Datum, PElement, PDatum>;
insert<ChildElement extends BaseType>(type: string, before: string): Selection<ChildElement, Datum, PElement, PDatum>;
insert<ChildElement extends BaseType>(type: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => ChildElement, before: string): Selection<ChildElement, Datum, PElement, PDatum>;
insert<ChildElement extends BaseType>(type: string, before: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => BaseType): Selection<ChildElement, Datum, PElement, PDatum>;
insert<ChildElement extends BaseType>(type: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => ChildElement,
before: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => BaseType): Selection<ChildElement, Datum, PElement, PDatum>;
insert<ChildElement extends BaseType>(type: ValueFn<GElement, Datum, ChildElement>, before: string): Selection<ChildElement, Datum, PElement, PDatum>;
insert<ChildElement extends BaseType>(type: string, before: ValueFn<GElement, Datum, BaseType>): Selection<ChildElement, Datum, PElement, PDatum>;
insert<ChildElement extends BaseType>(type: ValueFn<GElement, Datum, ChildElement>, before: ValueFn<GElement, Datum, BaseType>): Selection<ChildElement, Datum, PElement, PDatum>;
/**
* Removes the selected elements from the document.
* Returns this selection (the removed elements) which are now detached from the DOM.
*/
remove(): Selection<GElement, Datum, PElement, PDatum>;
remove(): this;
merge(other: Selection<GElement, Datum, PElement, PDatum>): Selection<GElement, Datum, PElement, PDatum>;
filter(selector: string): Selection<GElement, Datum, PElement, PDatum>;
filter(selector: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => boolean): Selection<GElement, Datum, PElement, PDatum>;
filter(selector: string): this;
filter(selector: ValueFn<GElement, Datum, boolean>): this;
sort(comparator?: (a: Datum, b: Datum) => number): Selection<GElement, Datum, PElement, PDatum>;
sort(comparator?: (a: Datum, b: Datum) => number): this;
order(): Selection<GElement, Datum, PElement, PDatum>;
order(): this;
raise(): Selection<GElement, Datum, PElement, PDatum>;
raise(): this;
lower(): Selection<GElement, Datum, PElement, PDatum>;
lower(): this;
// Data Join ---------------------------------
datum(): Datum;
datum(value: null): Selection<GElement, undefined, PElement, PDatum>;
datum<NewDatum>(value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => NewDatum): Selection<GElement, NewDatum, PElement, PDatum>;
datum<NewDatum>(value: ValueFn<GElement, Datum, NewDatum>): Selection<GElement, NewDatum, PElement, PDatum>;
datum<NewDatum>(value: NewDatum): Selection<GElement, NewDatum, PElement, PDatum>;
data(): Datum[];
data<NewDatum>(
data: Array<NewDatum>,
key?: (this: GElement | PElement, datum?: Datum | NewDatum, index?: number, group?: Array<GElement | PElement> | ArrayLike<GElement | PElement>) => string
): Selection<GElement, NewDatum, PElement, PDatum>;
data<NewDatum>(
data: (this: PElement, datum?: PDatum, index?: number, group?: Array<PElement> | ArrayLike<PElement>) => Array<NewDatum>,
key?: (this: GElement | PElement, datum?: Datum | NewDatum, index?: number, group?: Array<GElement | PElement> | ArrayLike<GElement | PElement>) => string
): Selection<GElement, NewDatum, PElement, PDatum>;
data<NewDatum>(data: Array<NewDatum>, key?: ValueFn<GElement | PElement, Datum | NewDatum, string>): Selection<GElement, NewDatum, PElement, PDatum>;
data<NewDatum>(data: ValueFn<PElement, PDatum, Array<NewDatum>>, key?: ValueFn<GElement | PElement, Datum | NewDatum, string>): Selection<GElement, NewDatum, PElement, PDatum>;
// TODO: Enter Selection returns GElements of type EnterNode, which do not meet the minimum interface of BaseType = Element
// HACK: Keep enter() selection 'as-if' they are of type GElement, while overly permissive, this may be of little practical relevance,
// given that the normal next step is an .append(...), which would address the matter
enter(): Selection<EnterElement, Datum, PElement, PDatum>;
// TODO: Review this: The type Datum on the exit items is actually of the type prior to calling data(...), as by definition, no new data of type NewDatum exists for these
// The type Datum on the exit items is actually of the type prior to calling data(...), as by definition, no new data of type NewDatum exists for these
// elements. Due to the chaining, .data(...).exit(...), however, the definition would imply that the exit group elements have assumed the NewDatum type.
// This seems to imply the following workaroud: Recast the exit Selection to OldDatum, if needed, or ommit and allow exit group elements to be of type any.
exit<OldDatum>(): Selection<GElement, OldDatum, PElement, PDatum>;
// Event Handling -------------------
on(type: string): (this: GElement, datum: Datum, index: number, group: Array<GElement> | ArrayLike<GElement>) => void;
on(type: string, listener: null): Selection<GElement, Datum, PElement, PDatum>;
on(type: string, listener: (this: GElement, datum: Datum, index: number, group: Array<GElement> | ArrayLike<GElement>) => void, capture?: boolean): Selection<GElement, Datum, PElement, PDatum>;
on(type: string): ValueFn<GElement, Datum, void>;
on(type: string, listener: null): this;
on(type: string, listener: ValueFn<GElement, Datum, void>, capture?: boolean): this;
dispatch(type: string, parameters?: CustomEventParameters): Selection<GElement, Datum, PElement, PDatum>;
dispatch(type: string, parameters?: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => CustomEventParameters): Selection<GElement, Datum, PElement, PDatum>;
dispatch(type: string, parameters?: CustomEventParameters): this;
dispatch(type: string, parameters?: ValueFn<GElement, Datum, CustomEventParameters>): this;
// Control Flow ----------------------
each(valueFn: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => void): Selection<GElement, Datum, PElement, PDatum>;
each(valueFn: ValueFn<GElement, Datum, void>): this;
call(func: (selection: Selection<GElement, Datum, PElement, PDatum>, ...args: any[]) => void, ...args: any[]): Selection<GElement, Datum, PElement, PDatum>;
call(func: (selection: Selection<GElement, Datum, PElement, PDatum>, ...args: any[]) => void, ...args: any[]): this;
empty(): boolean;

242
d3-shape/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-shape module 1.0.0
// Project: https://github.com/d3/d3-shape/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// -----------------------------------------------------------------------------------
@@ -19,26 +19,26 @@ export interface Arc<This, Datum> {
(this: This, d: Datum, ...args: any[]): string | undefined;
centroid(d: Datum, ...args: any[]): [number, number];
innerRadius(): (this: This, d: Datum, ...args: any[]) => number;
innerRadius(radius: number): Arc<This, Datum>;
innerRadius(radius: (this: This, d: Datum, ...args: any[]) => number): Arc<This, Datum>;
innerRadius(radius: number): this;
innerRadius(radius: (this: This, d: Datum, ...args: any[]) => number): this;
outerRadius(): (this: This, d: Datum, ...args: any[]) => number;
outerRadius(radius: number): Arc<This, Datum>;
outerRadius(radius: (this: This, d: Datum, ...args: any[]) => number): Arc<This, Datum>;
outerRadius(radius: number): this;
outerRadius(radius: (this: This, d: Datum, ...args: any[]) => number): this;
cornerRadius(): (this: This, d: Datum, ...args: any[]) => number;
cornerRadius(radius: number): Arc<This, Datum>;
cornerRadius(radius: (this: This, d: Datum, ...args: any[]) => number): Arc<This, Datum>;
cornerRadius(radius: number): this;
cornerRadius(radius: (this: This, d: Datum, ...args: any[]) => number): this;
startAngle(): (this: This, d: Datum, ...args: any[]) => number;
startAngle(angle: number): Arc<This, Datum>;
startAngle(angle: (this: This, d: Datum, ...args: any[]) => number): Arc<This, Datum>;
startAngle(angle: number): this;
startAngle(angle: (this: This, d: Datum, ...args: any[]) => number): this;
endAngle(): (this: This, d: Datum, ...args: any[]) => number;
endAngle(angle: number): Arc<This, Datum>;
endAngle(angle: (this: This, d: Datum, ...args: any[]) => number): Arc<This, Datum>;
endAngle(angle: number): this;
endAngle(angle: (this: This, d: Datum, ...args: any[]) => number): this;
padAngle(): (this: This, d: Datum, ...args: any[]) => number;
padAngle(angle: number): Arc<This, Datum>;
padAngle(angle: (this: This, d: Datum, ...args: any[]) => number): Arc<This, Datum>;
padAngle(angle: number): this;
padAngle(angle: (this: This, d: Datum, ...args: any[]) => number): this;
context(): CanvasRenderingContext2D | null;
context(context: CanvasRenderingContext2D): Arc<This, Datum>;
context(context: null): Arc<This, Datum>;
context(context: CanvasRenderingContext2D): this;
context(context: null): this;
}
export function arc(): Arc<any, DefaultArcObject>;
@@ -62,24 +62,24 @@ export interface PieArcDatum<T> {
export interface Pie<This, Datum> {
(this: This, data: Array<Datum>, ...args: any[]): Array<PieArcDatum<Datum>>;
value(): (d: Datum, i?: number, data?: Array<Datum>) => number;
value(value: number): Pie<This, Datum>;
value(value: (d: Datum, i?: number, data?: Array<Datum>) => number): Pie<This, Datum>;
value(): (d: Datum, i: number, data: Array<Datum>) => number;
value(value: number): this;
value(value: (d: Datum, i: number, data: Array<Datum>) => number): this;
sort(): ((a: Datum, b: Datum) => number) | null;
sort(comparator: (a: Datum, b: Datum) => number): Pie<This, Datum>;
sort(comparator: null): Pie<This, Datum>;
sort(comparator: (a: Datum, b: Datum) => number): this;
sort(comparator: null): this;
sortValues(): ((a: number, b: number) => number) | null;
sortValues(comparator: (a: number, b: number) => number): Pie<This, Datum>;
sortValues(comparator: null): Pie<This, Datum>;
sortValues(comparator: (a: number, b: number) => number): this;
sortValues(comparator: null): this;
startAngle(): (this: This, data: Array<Datum>, ...args: any[]) => number;
startAngle(angle: number): Pie<This, Datum>;
startAngle(angle: (this: This, data: Array<Datum>, ...args: any[]) => number): Pie<This, Datum>;
startAngle(angle: number): this;
startAngle(angle: (this: This, data: Array<Datum>, ...args: any[]) => number): this;
endAngle(): (this: This, data: Array<Datum>, ...args: any[]) => number;
endAngle(angle: number): Pie<This, Datum>;
endAngle(angle: (this: This, data: Array<Datum>, ...args: any[]) => number): Pie<This, Datum>;
endAngle(angle: number): this;
endAngle(angle: (this: This, data: Array<Datum>, ...args: any[]) => number): this;
padAngle(): (this: This, data: Array<Datum>, ...args: any[]) => number;
padAngle(angle: number): Pie<This, Datum>;
padAngle(angle: (this: This, data: Array<Datum>, ...args: any[]) => number): Pie<This, Datum>;
padAngle(angle: number): this;
padAngle(angle: (this: This, data: Array<Datum>, ...args: any[]) => number): this;
}
export function pie(): Pie<any, number | { valueOf(): number }>;
@@ -93,20 +93,20 @@ export function pie<This, Datum>(): Pie<This, Datum>;
export interface Line<Datum> {
(data: Array<Datum>): string | undefined;
x(): (d: Datum, index?: number, data?: Array<Datum>) => number;
x(x: number): Line<Datum>;
x(x: (d: Datum, index?: number, data?: Array<Datum>) => number): Line<Datum>;
y(): (d: Datum, index?: number, data?: Array<Datum>) => number;
y(y: number): Line<Datum>;
y(y: (d: Datum, index?: number, data?: Array<Datum>) => number): Line<Datum>;
defined(): (d: Datum, index?: number, data?: Array<Datum>) => boolean;
defined(defined: boolean): Line<Datum>;
defined(defined: (d: Datum, index?: number, data?: Array<Datum>) => boolean): Line<Datum>;
x(): (d: Datum, index: number, data: Array<Datum>) => number;
x(x: number): this;
x(x: (d: Datum, index: number, data: Array<Datum>) => number): this;
y(): (d: Datum, index: number, data: Array<Datum>) => number;
y(y: number): this;
y(y: (d: Datum, index: number, data: Array<Datum>) => number): this;
defined(): (d: Datum, index: number, data: Array<Datum>) => boolean;
defined(defined: boolean): this;
defined(defined: (d: Datum, index: number, data: Array<Datum>) => boolean): this;
curve(): CurveFactory | CurveFactoryLineOnly;
curve(curve: CurveFactory | CurveFactoryLineOnly): Line<Datum>;
curve(curve: CurveFactory | CurveFactoryLineOnly): this;
context(): CanvasRenderingContext2D | null;
context(context: CanvasRenderingContext2D): Line<Datum>;
context(context: null): Line<Datum>;
context(context: CanvasRenderingContext2D): this;
context(context: null): this;
}
export function line(): Line<[number, number]>;
export function line<Datum>(): Line<Datum>;
@@ -114,20 +114,20 @@ export function line<This, Datum>(): Line<Datum>;
export interface RadialLine<Datum> {
(data: Array<Datum>): string | undefined;
angle(): (d: Datum, index?: number, data?: Array<Datum>) => number;
angle(angle: number): RadialLine<Datum>;
angle(angle: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialLine<Datum>;
radius(): (d: Datum, index?: number, data?: Array<Datum>) => number;
radius(radius: number): RadialLine<Datum>;
radius(radius: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialLine<Datum>;
defined(): (d: Datum, index?: number, data?: Array<Datum>) => boolean;
defined(defined: boolean): RadialLine<Datum>;
defined(defined: (d: Datum, index?: number, data?: Array<Datum>) => boolean): RadialLine<Datum>;
angle(): (d: Datum, index: number, data: Array<Datum>) => number;
angle(angle: number): this;
angle(angle: (d: Datum, index: number, data: Array<Datum>) => number): this;
radius(): (d: Datum, index: number, data: Array<Datum>) => number;
radius(radius: number): this;
radius(radius: (d: Datum, index: number, data: Array<Datum>) => number): this;
defined(): (d: Datum, index: number, data: Array<Datum>) => boolean;
defined(defined: boolean): this;
defined(defined: (d: Datum, index: number, data: Array<Datum>) => boolean): this;
curve(): CurveFactory | CurveFactoryLineOnly;
curve(curve: CurveFactory | CurveFactoryLineOnly): RadialLine<Datum>;
curve(curve: CurveFactory | CurveFactoryLineOnly): this;
context(): CanvasRenderingContext2D | null;
context(context: CanvasRenderingContext2D): RadialLine<Datum>;
context(context: null): RadialLine<Datum>;
context(context: CanvasRenderingContext2D): this;
context(context: null): this;
}
export function radialLine(): RadialLine<[number, number]>;
@@ -140,32 +140,32 @@ export function radialLine<Datum>(): RadialLine<Datum>;
export interface Area<Datum> {
(data: Array<Datum>): string | undefined;
x(): (d: Datum, index?: number, data?: Array<Datum>) => number;
x(x: number): Area<Datum>;
x(x: (d: Datum, index?: number, data?: Array<Datum>) => number): Area<Datum>;
x0(): (d: Datum, index?: number, data?: Array<Datum>) => number;
x0(x0: number): Area<Datum>;
x0(x0: (d: Datum, index?: number, data?: Array<Datum>) => number): Area<Datum>;
x1(): ((d: Datum, index?: number, data?: Array<Datum>) => number) | null;
x1(x: number): Area<Datum>;
x1(x: (d: Datum, index?: number, data?: Array<Datum>) => number): Area<Datum>;
y(): (d: Datum, index?: number, data?: Array<Datum>) => number;
y(y: number): Area<Datum>;
y(y: (d: Datum, index?: number, data?: Array<Datum>) => number): Area<Datum>;
y0(): (d: Datum, index?: number, data?: Array<Datum>) => number;
y0(y: number): Area<Datum>;
y0(y: (d: Datum, index?: number, data?: Array<Datum>) => number): Area<Datum>;
y1(): (d: Datum, index?: number, data?: Array<Datum>) => number;
y1(y: number): Area<Datum>;
y1(y: (d: Datum, index?: number, data?: Array<Datum>) => number): Area<Datum>;
defined(): (d: Datum, index?: number, data?: Array<Datum>) => boolean;
defined(defined: boolean): Area<Datum>;
defined(defined: (d: Datum, index?: number, data?: Array<Datum>) => boolean): Area<Datum>;
x(): (d: Datum, index: number, data: Array<Datum>) => number;
x(x: number): this;
x(x: (d: Datum, index: number, data: Array<Datum>) => number): this;
x0(): (d: Datum, index: number, data: Array<Datum>) => number;
x0(x0: number): this;
x0(x0: (d: Datum, index: number, data: Array<Datum>) => number): this;
x1(): ((d: Datum, index: number, data: Array<Datum>) => number) | null;
x1(x: number): this;
x1(x: (d: Datum, index: number, data: Array<Datum>) => number): this;
y(): (d: Datum, index: number, data: Array<Datum>) => number;
y(y: number): this;
y(y: (d: Datum, index: number, data: Array<Datum>) => number): this;
y0(): (d: Datum, index: number, data: Array<Datum>) => number;
y0(y: number): this;
y0(y: (d: Datum, index: number, data: Array<Datum>) => number): this;
y1(): (d: Datum, index: number, data: Array<Datum>) => number;
y1(y: number): this;
y1(y: (d: Datum, index: number, data: Array<Datum>) => number): this;
defined(): (d: Datum, index: number, data: Array<Datum>) => boolean;
defined(defined: boolean): this;
defined(defined: (d: Datum, index: number, data: Array<Datum>) => boolean): this;
curve(): CurveFactory;
curve(curve: CurveFactory): Area<Datum>;
curve(curve: CurveFactory): this;
context(): CanvasRenderingContext2D | null;
context(context: CanvasRenderingContext2D): Area<Datum>;
context(context: null): Area<Datum>;
context(context: CanvasRenderingContext2D): this;
context(context: null): this;
lineX0(): Line<Datum>;
lineY0(): Line<Datum>;
lineX1(): Line<Datum>;
@@ -178,32 +178,32 @@ export function area<Datum>(): Area<Datum>;
export interface RadialArea<Datum> {
(data: Array<Datum>): string | undefined;
angle(): (d: Datum, index?: number, data?: Array<Datum>) => number;
angle(angle: number): RadialArea<Datum>;
angle(angle: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialArea<Datum>;
startAngle(): (d: Datum, index?: number, data?: Array<Datum>) => number;
startAngle(angle: number): RadialArea<Datum>;
startAngle(angle: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialArea<Datum>;
endAngle(): ((d: Datum, index?: number, data?: Array<Datum>) => number) | null;
endAngle(angle: number): RadialArea<Datum>;
endAngle(angle: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialArea<Datum>;
radius(): (d: Datum, index?: number, data?: Array<Datum>) => number;
radius(radius: number): RadialArea<Datum>;
radius(radius: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialArea<Datum>;
innerRadius(): (d: Datum, index?: number, data?: Array<Datum>) => number;
innerRadius(radius: number): RadialArea<Datum>;
innerRadius(radius: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialArea<Datum>;
outerRadius(): (d: Datum, index?: number, data?: Array<Datum>) => number;
outerRadius(radius: number): RadialArea<Datum>;
outerRadius(radius: (d: Datum, index?: number, data?: Array<Datum>) => number): RadialArea<Datum>;
defined(): (d: Datum, index?: number, data?: Array<Datum>) => boolean;
defined(defined: boolean): RadialArea<Datum>;
defined(defined: (d: Datum, index?: number, data?: Array<Datum>) => boolean): RadialArea<Datum>;
angle(): (d: Datum, index: number, data: Array<Datum>) => number;
angle(angle: number): this;
angle(angle: (d: Datum, index: number, data: Array<Datum>) => number): this;
startAngle(): (d: Datum, index: number, data: Array<Datum>) => number;
startAngle(angle: number): this;
startAngle(angle: (d: Datum, index: number, data: Array<Datum>) => number): this;
endAngle(): ((d: Datum, index: number, data: Array<Datum>) => number) | null;
endAngle(angle: number): this;
endAngle(angle: (d: Datum, index: number, data: Array<Datum>) => number): this;
radius(): (d: Datum, index: number, data: Array<Datum>) => number;
radius(radius: number): this;
radius(radius: (d: Datum, index: number, data: Array<Datum>) => number): this;
innerRadius(): (d: Datum, index: number, data: Array<Datum>) => number;
innerRadius(radius: number): this;
innerRadius(radius: (d: Datum, index: number, data: Array<Datum>) => number): this;
outerRadius(): (d: Datum, index: number, data: Array<Datum>) => number;
outerRadius(radius: number): this;
outerRadius(radius: (d: Datum, index: number, data: Array<Datum>) => number): this;
defined(): (d: Datum, index: number, data: Array<Datum>) => boolean;
defined(defined: boolean): this;
defined(defined: (d: Datum, index: number, data: Array<Datum>) => boolean): this;
curve(): CurveFactory;
curve(curve: CurveFactory): RadialArea<Datum>;
curve(curve: CurveFactory): this;
context(): CanvasRenderingContext2D | null;
context(context: CanvasRenderingContext2D): RadialArea<Datum>;
context(context: null): RadialArea<Datum>;
context(context: CanvasRenderingContext2D): this;
context(context: null): this;
lineStartAngle(): RadialLine<Datum>;
lineInnerRadius(): RadialLine<Datum>;
lineEndAngle(): RadialLine<Datum>;
@@ -243,13 +243,13 @@ export var curveBasisOpen: CurveFactory;
export var curveBasisClosed: CurveFactory;
export interface CurveBundleFactory extends CurveFactoryLineOnly {
beta(beta: number): CurveBundleFactory;
beta(beta: number): this;
}
export var curveBundle: CurveBundleFactory;
export interface CurveCardinalFactory extends CurveFactory {
tension(tension: number): CurveCardinalFactory;
tension(tension: number): this;
}
export var curveCardinal: CurveCardinalFactory;
@@ -257,7 +257,7 @@ export var curveCardinalOpen: CurveCardinalFactory;
export var curveCardinalClosed: CurveCardinalFactory;
export interface CurveCatmullRomFactory extends CurveFactory {
alpha(alpha: number): CurveCatmullRomFactory;
alpha(alpha: number): this;
}
export var curveCatmullRom: CurveCatmullRomFactory;
@@ -292,15 +292,15 @@ export interface SymbolType {
export interface Symbol<This, Datum> {
(this: This, d?: Datum, ...args: any[]): undefined | string;
size(): (this: This, d?: Datum, ...args: any[]) => number;
size(size: number): Symbol<This, Datum>;
size(size: (this: This, d?: Datum, ...args: any[]) => number): Symbol<This, Datum>;
type(): (this: This, d?: Datum, ...args: any[]) => SymbolType;
type(type: SymbolType): Symbol<This, Datum>;
type(type: (this: This, d?: Datum, ...args: any[]) => SymbolType): Symbol<This, Datum>;
size(): (this: This, d: Datum, ...args: any[]) => number;
size(size: number): this;
size(size: (this: This, d: Datum, ...args: any[]) => number): this;
type(): (this: This, d: Datum, ...args: any[]) => SymbolType;
type(type: SymbolType): this;
type(type: (this: This, d: Datum, ...args: any[]) => SymbolType): this;
context(): CanvasRenderingContext2D | null;
context(context: CanvasRenderingContext2D): Symbol<This, Datum>;
context(context: null): Symbol<This, Datum>;
context(context: CanvasRenderingContext2D): this;
context(context: null): this;
}
@@ -342,21 +342,21 @@ export interface Stack<This, Datum, Key> {
(data: Array<Datum>, ...args: any[]): Array<Series<Datum, Key>>;
keys(): (this: This, data: Array<Datum>, ...args: any[]) => Array<Key>;
keys(keys: Array<Key>): Stack<This, Datum, Key>;
keys(keys: (this: This, data: Array<Datum>, ...args: any[]) => Array<Key>): Stack<This, Datum, Key>;
keys(keys: Array<Key>): this;
keys(keys: (this: This, data: Array<Datum>, ...args: any[]) => Array<Key>): this;
value(): (d: Datum, key: Key, j?: number, data?: Array<Datum>) => number;
value(value: number): Stack<This, Datum, Key>;
value(value: (d: Datum, key: Key, j?: number, data?: Array<Datum>) => number): Stack<This, Datum, Key>;
value(): (d: Datum, key: Key, j: number, data: Array<Datum>) => number;
value(value: number): this;
value(value: (d: Datum, key: Key, j: number, data: Array<Datum>) => number): this;
order(): (series: Series<Datum, Key>) => Array<number>;
order(order: null): Stack<This, Datum, Key>;
order(order: Array<number>): Stack<This, Datum, Key>;
order(order: (series: Series<Datum, Key>) => Array<number>): Stack<This, Datum, Key>;
order(order: null): this;
order(order: Array<number>): this;
order(order: (series: Series<Datum, Key>) => Array<number>): this;
offset(): (series: Series<Datum, Key>, order: Array<number>) => void;
offset(offset: null): Stack<This, Datum, Key>;
offset(offset: (series: Series<Datum, Key>, order: Array<number>) => void): Stack<This, Datum, Key>;
offset(offset: null): this;
offset(offset: (series: Series<Datum, Key>, order: Array<number>) => void): this;
}

2
d3-time-format/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for d3JS d3-time-format module 2.0.0
// Project: https://github.com/d3/d3-time-format/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**

4
d3-time/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-time module 1.0.0
// Project: https://github.com/d3/d3-time/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// ---------------------------------------------------------------
@@ -14,7 +14,7 @@ export interface TimeInterval {
ceil(date: Date): Date;
offset(date: Date, step?: number): Date;
range(start: Date, stop: Date, step?: number): Date[];
filter(test: (date: Date) => boolean): TimeInterval;
filter(test: (date: Date) => boolean): this;
}
export interface CountableTimeInterval extends TimeInterval {

2
d3-timer/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for d3JS d3-timer module 1.0.1
// Project: https://github.com/d3/d3-timer/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek<https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/**

58
d3-transition/index.d.ts vendored
View File

@@ -1,9 +1,9 @@
// Type definitions for D3JS d3-transition module 1.0.0
// Project: https://github.com/d3/d3-transition/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { ArrayLike, BaseType, Selection } from 'd3-selection';
import { ArrayLike, BaseType, Selection, ValueFn } from 'd3-selection';
/**
* Extend interface 'Selection' by declaration merging with 'd3-selection'
@@ -26,56 +26,56 @@ export interface Transition<GElement extends BaseType, Datum, PElement extends B
// Sub-selection -------------------------
select<DescElement extends BaseType>(selector: string): Transition<DescElement, Datum, PElement, PDatum>;
select<DescElement extends BaseType>(selector: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => DescElement): Transition<DescElement, Datum, PElement, PDatum>;
select<DescElement extends BaseType>(selector: ValueFn<GElement, Datum, DescElement>): Transition<DescElement, Datum, PElement, PDatum>;
// NB: while the empty selections (null or undefined selector) are defined on the underlying object, they should not be exposed in the type definition API
// as they are meaningless on transitions.)
// selectAll(): Transition<undefined, undefined, GElement, Datum>; // _groups are set to empty array, first generic type is set to undefined by convention
// selectAll(selector: null): Transition<undefined, undefined, GElement, Datum>; // _groups are set to empty array, first generic type is set to undefined by convention
selectAll<DescElement extends BaseType, OldDatum>(selector: string): Transition<DescElement, OldDatum, GElement, Datum>;
selectAll<DescElement extends BaseType, OldDatum>(selector: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (Array<DescElement> | ArrayLike<DescElement>)): Transition<DescElement, OldDatum, GElement, Datum>;
selectAll<DescElement extends BaseType, OldDatum>(selector: ValueFn<GElement, Datum, Array<DescElement> | ArrayLike<DescElement>>): Transition<DescElement, OldDatum, GElement, Datum>;
selection(): Selection<GElement, Datum, PElement, PDatum>;
transition(): Transition<GElement, Datum, PElement, PDatum>;
// Modifying -------------------------------
attr(name: string, value: null): Transition<GElement, Datum, PElement, PDatum>;
attr(name: string, value: string | number | boolean): Transition<GElement, Datum, PElement, PDatum>;
attr(name: string, value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (string | number | boolean)): Transition<GElement, Datum, PElement, PDatum>;
attrTween(name: string, tweenFn: (this: GElement, datum?: Datum, i?: number, group?: GElement[] | ArrayLike<GElement>) => ((t: number) => (string | number | boolean))): Transition<GElement, Datum, PElement, PDatum>;
attr(name: string, value: null): this;
attr(name: string, value: string | number | boolean): this;
attr(name: string, value: ValueFn<GElement, Datum, string | number | boolean>): this;
attrTween(name: string, tweenFn: ValueFn<GElement, Datum, (t: number) => (string | number | boolean)>): this;
style(name: string, value: null): Transition<GElement, Datum, PElement, PDatum>;
style(name: string, value: string | number | boolean, priority?: null | 'important'): Transition<GElement, Datum, PElement, PDatum>;
style(name: string, value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (string | number | boolean), priority?: null | 'important'): Transition<GElement, Datum, PElement, PDatum>;
styleTween(name: string, tweenFn: (this: GElement, datum?: Datum, i?: number, group?: GElement[] | ArrayLike<GElement>) => ((t: number) => (string | number | boolean)), priority?: null | 'important'): Transition<GElement, Datum, PElement, PDatum>;
style(name: string, value: null): this;
style(name: string, value: string | number | boolean, priority?: null | 'important'): this;
style(name: string, value: ValueFn<GElement, Datum, string | number | boolean>, priority?: null | 'important'): this;
styleTween(name: string, tweenFn: ValueFn<GElement, Datum, (t: number) => (string | number | boolean)>, priority?: null | 'important'): this;
text(value: null): Transition<GElement, Datum, PElement, PDatum>;
text(value: string | number | boolean): Transition<GElement, Datum, PElement, PDatum>;
text(value: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => (string | number | boolean)): Transition<GElement, Datum, PElement, PDatum>;
text(value: null): this;
text(value: string | number | boolean): this;
text(value: ValueFn<GElement, Datum, string | number | boolean>): this;
tween(name: string): (this: GElement, datum?: Datum, i?: number, group?: GElement[] | ArrayLike<GElement>) => ((t: number) => void);
tween(name: string, tweenFn: null): Transition<GElement, Datum, PElement, PDatum>;
tween(name: string, tweenFn: (this: GElement, datum?: Datum, i?: number, group?: GElement[] | ArrayLike<GElement>) => ((t: number) => void)): Transition<GElement, Datum, PElement, PDatum>;
tween(name: string): ValueFn<GElement, Datum, (t: number) => void>;
tween(name: string, tweenFn: null): this;
tween(name: string, tweenFn: ValueFn<GElement, Datum, (t: number) => void>): this;
remove(): Transition<GElement, Datum, PElement, PDatum>;
remove(): this;
merge(other: Transition<GElement, Datum, PElement, PDatum>): Transition<GElement, Datum, PElement, PDatum>;
filter(filter: string): Transition<GElement, Datum, PElement, PDatum>;
filter(filter: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => boolean): Transition<GElement, Datum, PElement, PDatum>;
filter(filter: string): this;
filter(filter: ValueFn<GElement, Datum, boolean>): this;
// Event Handling -------------------
on(type: string): (this: GElement, datum: Datum, index: number, group: Array<GElement> | ArrayLike<GElement>) => any;
on(type: string, listener: null): Transition<GElement, Datum, PElement, PDatum>;
on(type: string, listener: (this: GElement, datum: Datum, index: number, group: Array<GElement> | ArrayLike<GElement>) => any): Transition<GElement, Datum, PElement, PDatum>;
on(type: string): ValueFn<GElement, Datum, void>;
on(type: string, listener: null): this;
on(type: string, listener: ValueFn<GElement, Datum, void>): this;
// Control Flow ----------------------
each(valueFn: (this: GElement, datum?: Datum, index?: number, group?: Array<GElement> | ArrayLike<GElement>) => void): Transition<GElement, Datum, PElement, PDatum>;
each(valueFn: ValueFn<GElement, Datum, void>): this;
call(func: (transition: Transition<GElement, Datum, PElement, PDatum>, ...args: any[]) => any, ...args: any[]): Transition<GElement, Datum, PElement, PDatum>;
call(func: (transition: Transition<GElement, Datum, PElement, PDatum>, ...args: any[]) => any, ...args: any[]): this;
empty(): boolean;
@@ -87,13 +87,13 @@ export interface Transition<GElement extends BaseType, Datum, PElement extends B
// Transition Configuration ----------------------
delay(): number;
delay(milliseconds: number): Transition<GElement, Datum, PElement, PDatum>;
delay(milliseconds: number): this;
duration(): number;
duration(milliseconds: number): Transition<GElement, Datum, PElement, PDatum>;
duration(milliseconds: number): this;
ease(): (normalizedTime: number) => number;
ease(easingFn: (normalizedTime: number) => number): Transition<GElement, Datum, PElement, PDatum>;
ease(easingFn: (normalizedTime: number) => number): this;
}

10
d3-voronoi/index.d.ts vendored
View File

@@ -1,6 +1,6 @@
// Type definitions for D3JS d3-voronoi module 1.0.1
// Project: https://github.com/d3/d3-voronoi/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// --------------------------------------------------------------------------
@@ -53,13 +53,13 @@ export interface VoronoiLink<T> {
export interface VoronoiLayout<T> {
(data: Array<T>): VoronoiDiagram<T>;
x(): (d: T) => number;
x(x: (d: T) => number): VoronoiLayout<T>;
x(x: (d: T) => number): this;
y(): (d: T) => number;
y(y: (d: T) => number): VoronoiLayout<T>;
y(y: (d: T) => number): this;
extent(): [[number, number], [number, number]] | null;
extent(extent: [[number, number], [number, number]]): VoronoiLayout<T>;
extent(extent: [[number, number], [number, number]]): this;
size(): [number, number] | null;
size(size: [number, number]): VoronoiLayout<T>;
size(size: [number, number]): this;
polygons(data: Array<T>): Array<VoronoiPolygon<T>>;
triangles(data: Array<T>): Array<VoronoiTriangle<T>>;
links(data: Array<T>): Array<VoronoiLink<T>>;

66
d3-zoom/index.d.ts vendored
View File

@@ -1,9 +1,9 @@
// Type definitions for d3JS d3-zoom module 1.0.2
// Project: https://github.com/d3/d3-zoom/
// Definitions by: Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>, Tom Wanzek <https://github.com/tomwanzek>
// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { ArrayLike, Selection, TransitionLike } from 'd3-selection';
import { ArrayLike, Selection, TransitionLike, ValueFn } from 'd3-selection';
// --------------------------------------------------------------------------
@@ -24,9 +24,9 @@ type ZoomedElementBaseType = Element;
*/
export interface ZoomScale {
domain(): Array<number>;
domain(domain: Array<number>): ZoomScale;
domain(domain: Array<number>): this;
range(): Array<number>;
range(range: Array<number>): ZoomScale;
range(range: Array<number>): this;
copy(): ZoomScale;
invert(value: number): number;
}
@@ -39,60 +39,48 @@ export interface ZoomScale {
export interface ZoomBehavior<ZoomRefElement extends ZoomedElementBaseType, Datum> extends Function {
(selection: Selection<ZoomRefElement, Datum, any, any>, ...args: any[]): void;
transform(selection: Selection<ZoomRefElement, Datum, any, any>, transform: ZoomTransform): void;
transform(selection: Selection<ZoomRefElement, Datum, any, any>, transform: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => ZoomTransform): void;
transform(selection: Selection<ZoomRefElement, Datum, any, any>, transform: ValueFn<ZoomRefElement, Datum, ZoomTransform>): void;
transform(transition: TransitionLike<ZoomRefElement, Datum>, transform: ZoomTransform): void;
transform(transition: TransitionLike<ZoomRefElement, Datum>, transform: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => ZoomTransform): void;
transform(transition: TransitionLike<ZoomRefElement, Datum>, transform: ValueFn<ZoomRefElement, Datum, ZoomTransform>): void;
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: number, y: number): void;
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>,
x: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number,
y: number): void;
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>,
x: number,
y: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number): void;
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>,
x: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number,
y: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement>) => number): void;
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: ValueFn<ZoomRefElement, Datum, number>, y: number): void;
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: number, y: ValueFn<ZoomRefElement, Datum, number>): void;
translateBy(selection: Selection<ZoomRefElement, Datum, any, any>, x: ValueFn<ZoomRefElement, Datum, number>, y: ValueFn<ZoomRefElement, Datum, number>): void;
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: number, y: number): void;
translateBy(transition: TransitionLike<ZoomRefElement, Datum>,
x: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number,
y: number): void;
translateBy(transition: TransitionLike<ZoomRefElement, Datum>,
x: number,
y: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number): void;
translateBy(transition: TransitionLike<ZoomRefElement, Datum>,
x: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number,
y: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number): void;
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: ValueFn<ZoomRefElement, Datum, number>, y: number): void;
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: number, y: ValueFn<ZoomRefElement, Datum, number>): void;
translateBy(transition: TransitionLike<ZoomRefElement, Datum>, x: ValueFn<ZoomRefElement, Datum, number>, y: ValueFn<ZoomRefElement, Datum, number>): void;
scaleBy(selection: Selection<ZoomRefElement, Datum, any, any>, k: number): void;
scaleBy(selection: Selection<ZoomRefElement, Datum, any, any>, k: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number): void;
scaleBy(selection: Selection<ZoomRefElement, Datum, any, any>, k: ValueFn<ZoomRefElement, Datum, number>): void;
scaleBy(transition: TransitionLike<ZoomRefElement, Datum>, k: number): void;
scaleBy(transition: TransitionLike<ZoomRefElement, Datum>, k: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number): void;
scaleBy(transition: TransitionLike<ZoomRefElement, Datum>, k: ValueFn<ZoomRefElement, Datum, number>): void;
scaleTo(selection: Selection<ZoomRefElement, Datum, any, any>, k: number): void;
scaleTo(selection: Selection<ZoomRefElement, Datum, any, any>, k: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number): void;
scaleTo(selection: Selection<ZoomRefElement, Datum, any, any>, k: ValueFn<ZoomRefElement, Datum, number>): void;
scaleTo(transition: TransitionLike<ZoomRefElement, Datum>, k: number): void;
scaleTo(transition: TransitionLike<ZoomRefElement, Datum>, k: (this: ZoomRefElement, d?: Datum, i?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => number): void;
scaleTo(transition: TransitionLike<ZoomRefElement, Datum>, k: ValueFn<ZoomRefElement, Datum, number>): void;
filter(): (this: ZoomRefElement, datum: Datum, index: number, group: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => boolean;
filter(filterFn: (this: ZoomRefElement, d?: Datum, index?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => boolean): ZoomBehavior<ZoomRefElement, Datum>;
filter(): ValueFn<ZoomRefElement, Datum, boolean>;
filter(filterFn: ValueFn<ZoomRefElement, Datum, boolean>): this;
extent(): (this: ZoomRefElement, d: Datum, index: number, group: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => [[number, number], [number, number]];
extent(extent: [[number, number], [number, number]]): ZoomBehavior<ZoomRefElement, Datum>;
extent(extent: (this: ZoomRefElement, d?: Datum, index?: number, group?: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => [[number, number], [number, number]]): ZoomBehavior<ZoomRefElement, Datum>;
extent(): ValueFn<ZoomRefElement, Datum, [[number, number], [number, number]]>;
extent(extent: [[number, number], [number, number]]): this;
extent(extent: ValueFn<ZoomRefElement, Datum, [[number, number], [number, number]]>): this;
scaleExtent(): [number, number];
scaleExtent(extent: [number, number]): ZoomBehavior<ZoomRefElement, Datum>;
scaleExtent(extent: [number, number]): this;
translateExtent(): [[number, number], [number, number]];
translateExtent(extent: [[number, number], [number, number]]): ZoomBehavior<ZoomRefElement, Datum>;
translateExtent(extent: [[number, number], [number, number]]): this;
duration(): number;
duration(duration: number): ZoomBehavior<ZoomRefElement, Datum>;
duration(duration: number): this;
on(typenames: string): (this: ZoomRefElement, datum: Datum, index: number, group: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => void;
on(typenames: string, callback: null): ZoomBehavior<ZoomRefElement, Datum>;
on(typenames: string, callback: (this: ZoomRefElement, datum: Datum, index: number, group: Array<ZoomRefElement> | ArrayLike<ZoomRefElement>) => void): ZoomBehavior<ZoomRefElement, Datum>;
on(typenames: string): ValueFn<ZoomRefElement, Datum, void>;
on(typenames: string, callback: null): this;
on(typenames: string, callback: ValueFn<ZoomRefElement, Datum, void>): this;
}