@d3plus/core 3.0.0-alpha.0

package/es/index.js

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

package/es/src/charts/AreaPlot.js

@@ -0,0 +1,86 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { constant } from "../utils/index.js";
+import { default as Plot } from "./Plot.js";
+var AreaPlot = /*#__PURE__*/ function(Plot) {
+    "use strict";
+    _inherits(AreaPlot, Plot);
+    function AreaPlot() {
+        _class_call_check(this, AreaPlot);
+        var _this;
+        _this = _call_super(this, AreaPlot);
+        _this._baseline = 0;
+        _this._discrete = "x";
+        _this._shape = constant("Area");
+        _this.x("x");
+        return _this;
+    }
+    return AreaPlot;
+}(Plot);
+/**
+    @class AreaPlot
+    @extends Plot
+    @desc Creates an area plot based on an array of data.
+    @example <caption>the equivalent of calling:</caption>
+new d3plus.Plot()
+  .baseline(0)
+  .discrete("x")
+  .shape("Area")
+*/ export { AreaPlot as default };

package/es/src/charts/BarChart.js

@@ -0,0 +1,93 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { constant } from "../utils/index.js";
+import { default as Plot } from "./Plot.js";
+var BarChart = /*#__PURE__*/ function(Plot) {
+    "use strict";
+    _inherits(BarChart, Plot);
+    function BarChart() {
+        _class_call_check(this, BarChart);
+        var _this;
+        _this = _call_super(this, BarChart);
+        _this._baseline = 0;
+        _this._discrete = "x";
+        var defaultLegend = _this._legend;
+        _this._legend = function(config, arr) {
+            var legendIds = arr.map(_this._groupBy[_this._legendDepth].bind(_this)).sort().join();
+            var barIds = _this._filteredData.map(_this._groupBy[_this._legendDepth].bind(_this)).sort().join();
+            if (legendIds === barIds) return false;
+            return defaultLegend.bind(_this)(config, arr);
+        };
+        _this._shape = constant("Bar");
+        _this.x("x");
+        return _this;
+    }
+    return BarChart;
+}(Plot);
+/**
+    @class BarChart
+    @extends Plot
+    @desc Creates a bar chart based on an array of data.
+    @example <caption>the equivalent of calling:</caption>
+new d3plus.Plot()
+  .baseline(0)
+  .discrete("x")
+  .shape("Bar")
+*/ export { BarChart as default };

package/es/src/charts/BoxWhisker.js

@@ -0,0 +1,97 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { assign } from "@d3plus/dom";
+import { constant } from "../utils/index.js";
+import { default as Plot } from "./Plot.js";
+var BoxWhisker = /*#__PURE__*/ function(Plot) {
+    "use strict";
+    _inherits(BoxWhisker, Plot);
+    function BoxWhisker() {
+        _class_call_check(this, BoxWhisker);
+        var _this;
+        _this = _call_super(this, BoxWhisker);
+        _this._discrete = "x";
+        _this._shape = constant("Box");
+        _this.x("x");
+        _this._tooltipConfig = assign(_this._tooltipConfig, {
+            title: function(d, i) {
+                if (!d) return "";
+                while(d.__d3plus__ && d.data){
+                    d = d.data;
+                    i = d.i;
+                }
+                if (_this._label) return _this._label(d, i);
+                var l = _this._ids(d, i).slice(0, _this._drawDepth);
+                return l[l.length - 1];
+            }
+        });
+        return _this;
+    }
+    return BoxWhisker;
+}(Plot);
+/**
+    @class BoxWhisker
+    @extends Plot
+    @desc Creates a simple box and whisker based on an array of data.
+    @example <caption>the equivalent of calling:</caption>
+new d3plus.Plot()
+  .discrete("x")
+  .shape("Box")
+*/ export { BoxWhisker as default };

package/es/src/charts/BumpChart.js

@@ -0,0 +1,148 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { constant } from "../utils/index.js";
+import { default as Plot } from "./Plot.js";
+var BumpChart = /*#__PURE__*/ function(Plot) {
+    "use strict";
+    _inherits(BumpChart, Plot);
+    function BumpChart() {
+        _class_call_check(this, BumpChart);
+        var _this;
+        _this = _call_super(this, BumpChart);
+        _this._discrete = "x";
+        _this._shape = constant("Line");
+        _this.x("x");
+        _this.y2(function(d) {
+            return _this._y(d);
+        });
+        _this.yConfig({
+            tickFormat: function(val) {
+                var data = _this._formattedData;
+                var xMin = _instanceof(data[0].x, Date) ? data[0].x.getTime() : data[0].x;
+                var startData = data.filter(function(d) {
+                    return (_instanceof(d.x, Date) ? d.x.getTime() : d.x) === xMin;
+                });
+                var d = startData.find(function(d) {
+                    return d.y === val;
+                });
+                return d ? _this._drawLabel(d, d.i) : "";
+            }
+        });
+        _this.y2Config({
+            tickFormat: function(val) {
+                var data = _this._formattedData;
+                var xMax = _instanceof(data[data.length - 1].x, Date) ? data[data.length - 1].x.getTime() : data[data.length - 1].x;
+                var endData = data.filter(function(d) {
+                    return (_instanceof(d.x, Date) ? d.x.getTime() : d.x) === xMax;
+                });
+                var d = endData.find(function(d) {
+                    return d.y === val;
+                });
+                return d ? _this._drawLabel(d, d.i) : "";
+            }
+        });
+        _this.ySort(function(a, b) {
+            return _this._y(b) - _this._y(a);
+        });
+        _this.y2Sort(function(a, b) {
+            return _this._y(b) - _this._y(a);
+        });
+        return _this;
+    }
+    return BumpChart;
+}(Plot);
+/**
+    @class BumpChart
+    @extends Plot
+    @desc Creates a bump chart based on an array of data.
+    @example <caption>the equivalent of calling:</caption>
+new d3plus.Plot()
+  .discrete("x")
+  .shape("Line")
+  .x("x")
+  .y2(d => this._y(d))
+  .yConfig({
+    tickFormat: val => {
+      const data = this._formattedData;
+      const xDomain = this._xDomain;
+      const startData = data.filter(d => d.x === xDomain[0]);
+      const d = startData.find(d => d.y === val);
+      return this._drawLabel(d, d.i);
+     }
+   })
+  .y2Config({
+    tickFormat: val => {
+      const data = this._formattedData;
+      const xDomain = this._xDomain;
+      const endData = data.filter(d => d.x === xDomain[xDomain.length - 1]);
+      const d = endData.find(d => d.y === val);
+      return this._drawLabel(d, d.i);
+     }
+   })
+  .ySort((a, b) => b.y - a.y)
+  .y2Sort((a, b) => b.y - a.y)
+*/ export { BumpChart as default };

package/es/src/charts/Donut.js

@@ -0,0 +1,84 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+import { min } from "d3-array";
+import { default as Pie } from "./Pie.js";
+var Donut = /*#__PURE__*/ function(Pie) {
+    "use strict";
+    _inherits(Donut, Pie);
+    function Donut() {
+        _class_call_check(this, Donut);
+        var _this;
+        _this = _call_super(this, Donut);
+        _this._innerRadius = function() {
+            return min([
+                _this._width - _this._margin.left - _this._margin.right,
+                _this._height - _this._margin.top - _this._margin.bottom
+            ]) / 4;
+        };
+        _this._padPixel = 2;
+        return _this;
+    }
+    return Donut;
+}(Pie);
+/**
+    @class Donut
+    @extends Pie
+    @desc Extends the Pie visualization to create a donut chart.
+*/ export { Donut as default };