@carbon/charts 0.27.0 → 0.29.1

package/src/services/essentials/dom-utils.js

@@ -0,0 +1,193 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+// Internal Imports
+import { Service } from "../service";
+// D3 Imports
+import { select } from "d3-selection";
+import { Tools } from "../../tools";
+// import the settings for the css prefix
+import settings from "carbon-components/src/globals/js/settings";
+// MISC
+import ResizeObserver from "resize-observer-polyfill";
+var DOMUtils = /** @class */ (function (_super) {
+    __extends(DOMUtils, _super);
+    function DOMUtils() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DOMUtils.getSVGElementSize = function (svgSelector, options) {
+        if (!svgSelector.attr) {
+            svgSelector = select(svgSelector);
+        }
+        var attrDimensions = {
+            width: svgSelector.attr("width"),
+            height: svgSelector.attr("height")
+        };
+        var bbox, bboxDimensions, boundingRect, boundingRectDimensions;
+        // In many versions of Firefox
+        // getBBox will cause an "NSFailure" error
+        try {
+            bbox = svgSelector.node().getBBox();
+            bboxDimensions = {
+                width: bbox.width,
+                height: bbox.height
+            };
+        }
+        catch (e) { }
+        try {
+            boundingRect = svgSelector.node().getBoundingClientRect();
+            boundingRectDimensions = {
+                width: boundingRect.width,
+                height: boundingRect.height
+            };
+        }
+        catch (e) { }
+        var clientDimensions = {
+            width: svgSelector.node().clientWidth,
+            height: svgSelector.node().clientHeight
+        };
+        var validateDimensions = function (dimensions) {
+            if (dimensions && dimensions.width && dimensions.height &&
+                !isNaN(dimensions.height) && !isNaN(dimensions.width) &&
+                ("" + dimensions.width + dimensions.height).indexOf("%") === -1 &&
+                dimensions.width > 0 && dimensions.height > 0) {
+                return true;
+            }
+            return false;
+        };
+        // If both attribute values are numbers
+        // And not percentages or NaN
+        if (options) {
+            if (options.useAttrs && validateDimensions(attrDimensions)) {
+                return attrDimensions;
+            }
+            if (options.useClientDimensions && validateDimensions(clientDimensions)) {
+                return clientDimensions;
+            }
+            if (options.useBBox && validateDimensions(bboxDimensions)) {
+                return bboxDimensions;
+            }
+            if (options.useBoundingRect && validateDimensions(boundingRectDimensions)) {
+                return boundingRectDimensions;
+            }
+        }
+        try {
+            var nativeDimensions = {
+                width: Tools.getProperty(svgSelector.node(), "width", "baseVal", "value"),
+                height: Tools.getProperty(svgSelector.node(), "height", "baseVal", "value")
+            };
+            if (validateDimensions(nativeDimensions)) {
+                return nativeDimensions;
+            }
+        }
+        catch (e) {
+            if (validateDimensions(clientDimensions)) {
+                return clientDimensions;
+            }
+            if (validateDimensions(bboxDimensions)) {
+                return bboxDimensions;
+            }
+            if (validateDimensions(attrDimensions)) {
+                return attrDimensions;
+            }
+        }
+        return {
+            width: 0,
+            height: 0
+        };
+    };
+    DOMUtils.appendOrSelect = function (parent, query) {
+        var querySections = query.split(".");
+        var elementToAppend = querySections[0];
+        var selection = parent.select(query);
+        if (selection.empty()) {
+            return parent.append(elementToAppend)
+                .attr("class", querySections.slice(1).join(" "));
+        }
+        return selection;
+    };
+    DOMUtils.prototype.init = function () {
+        // Add width & height to the chart holder if necessary, and add a classname
+        this.styleHolderElement();
+        // Add main SVG
+        this.addSVGElement();
+        if (this.model.getOptions().resizable) {
+            this.addResizeListener();
+        }
+    };
+    DOMUtils.prototype.update = function () {
+        this.styleHolderElement();
+    };
+    DOMUtils.prototype.styleHolderElement = function () {
+        var holderElement = this.getHolder();
+        // Add class to chart holder
+        select(this.getHolder()).classed(settings.prefix + "--chart-holder", true);
+        // In order for resize events to not clash with these updates
+        // We'll check if the width & height values passed in options
+        // Have changed, before setting them to the holder
+        var _a = this.model.getOptions(), width = _a.width, height = _a.height;
+        if (width !== this.width) {
+            // Apply formatted width attribute to chart
+            holderElement.style.width = width;
+            this.width = width;
+        }
+        if (height !== this.height) {
+            // Apply formatted width attribute to chart
+            holderElement.style.height = height;
+            this.height = height;
+        }
+    };
+    DOMUtils.prototype.getHolder = function () {
+        return this.model.get("holder");
+    };
+    DOMUtils.prototype.addSVGElement = function () {
+        var chartsprefix = Tools.getProperty(this.model.getOptions(), "style", "prefix");
+        var svg = select(this.getHolder())
+            .append("svg")
+            .classed(settings.prefix + "--" + chartsprefix + "--chart-svg", true)
+            .attr("height", "100%")
+            .attr("width", "100%");
+        this.svg = svg.node();
+    };
+    DOMUtils.prototype.getMainSVG = function () {
+        return this.svg;
+    };
+    DOMUtils.prototype.addResizeListener = function () {
+        var _this = this;
+        var holder = this.getHolder();
+        if (!holder) {
+            return;
+        }
+        // Grab current dimensions of the chart holder
+        var containerWidth = holder.clientWidth;
+        var containerHeight = holder.clientHeight;
+        // The resize callback function
+        var resizeCallback = Tools.debounce(function (entries, observer) {
+            if (!holder) {
+                return;
+            }
+            if (Math.abs(containerWidth - holder.clientWidth) > 1
+                || Math.abs(containerHeight - holder.clientHeight) > 1) {
+                containerWidth = holder.clientWidth;
+                containerHeight = holder.clientHeight;
+                _this.services.events.dispatchEvent("chart-resize");
+            }
+        }, 12.5);
+        // Observe the behaviour of resizing on the holder
+        var resizeObserver = new ResizeObserver(resizeCallback);
+        resizeObserver.observe(holder);
+    };
+    return DOMUtils;
+}(Service));
+export { DOMUtils };
+//# sourceMappingURL=../../../../src/services/essentials/dom-utils.js.map

package/src/services/essentials/events.js

@@ -0,0 +1,53 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+// Internal Imports
+import { Service } from "../service";
+var Events = /** @class */ (function (_super) {
+    __extends(Events, _super);
+    function Events() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Events.prototype.init = function () {
+        // Setup the event fragment on the DOM
+        this.documentFragment = document.createDocumentFragment();
+    };
+    Events.prototype.addEventListener = function (type, listener) {
+        // Need the casting to any here since typescript
+        // Is expecting a function of type EventListenerOrEventListenerObject here
+        // Which seems unreasonable
+        this.documentFragment.addEventListener(type, listener);
+    };
+    Events.prototype.removeEventListener = function (type, listener) {
+        // Need the casting to any here since typescript
+        // Is expecting a function of type EventListenerOrEventListenerObject here
+        // Which seems unreasonable
+        this.documentFragment.removeEventListener(type, listener);
+    };
+    Events.prototype.dispatchEvent = function (eventType, eventDetail) {
+        var newEvent;
+        if (eventDetail) {
+            newEvent = new CustomEvent(eventType, {
+                detail: eventDetail
+            });
+        }
+        else {
+            newEvent = document.createEvent("Event");
+            newEvent.initEvent(eventType, false, true);
+        }
+        this.documentFragment.dispatchEvent(newEvent);
+    };
+    return Events;
+}(Service));
+export { Events };
+//# sourceMappingURL=../../../../src/services/essentials/events.js.map

package/src/services/essentials/transitions.js

@@ -0,0 +1,63 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+// Internal Imports
+import { Service } from "../service";
+import * as Configuration from "../../configuration";
+import { Tools } from "../../tools";
+// D3 Imports
+import { transition } from "d3-transition";
+var Transitions = /** @class */ (function (_super) {
+    __extends(Transitions, _super);
+    function Transitions() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.pendingTransitions = {};
+        return _this;
+    }
+    // transitions: Transition<any, any, any, any>[];
+    Transitions.prototype.init = function () {
+        var _this = this;
+        this.services.events
+            .addEventListener("model-update", function () {
+            _this.pendingTransitions = {};
+        });
+    };
+    Transitions.prototype.getTransition = function (name, animate) {
+        var _this = this;
+        if (this.model.getOptions().animations === false || animate === false) {
+            return this.getInstantTransition(name);
+        }
+        var t = transition(name)
+            .duration(Tools.getProperty(Configuration.transitions, name, "duration") || Configuration.transitions.default.duration);
+        this.pendingTransitions[t._id] = t;
+        t.on("end interrupt cancel", function () {
+            delete _this.pendingTransitions[t._id];
+        });
+        return t;
+    };
+    Transitions.prototype.getInstantTransition = function (name) {
+        var _this = this;
+        var t = transition(name).duration(0);
+        this.pendingTransitions[t._id] = t;
+        t.on("end interrupt cancel", function () {
+            delete _this.pendingTransitions[t._id];
+        });
+        return t;
+    };
+    Transitions.prototype.getPendingTransitions = function () {
+        return this.pendingTransitions;
+    };
+    return Transitions;
+}(Service));
+export { Transitions };
+//# sourceMappingURL=../../../../src/services/essentials/transitions.js.map

package/src/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./essentials/dom-utils";
+export * from "./essentials/events";
+export * from "./essentials/transitions";
+export * from "./scales-cartesian";
+export * from "./curves";

package/src/services/index.js

@@ -0,0 +1,8 @@
+// Essentials
+export * from "./essentials/dom-utils";
+export * from "./essentials/events";
+export * from "./essentials/transitions";
+// MISC
+export * from "./scales-cartesian";
+export * from "./curves";
+//# sourceMappingURL=../../../src/services/index.js.map

package/src/services/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AAEzC,OAAO;AACP,cAAc,oBAAoB,CAAC;AACnC,cAAc,UAAU,CAAC","sourcesContent":["// Essentials\nexport * from \"./essentials/dom-utils\";\nexport * from \"./essentials/events\";\nexport * from \"./essentials/transitions\";\n\n// MISC\nexport * from \"./scales-cartesian\";\nexport * from \"./curves\";\n"]}

package/src/services/scales-cartesian.d.ts

@@ -0,0 +1,39 @@
+import { Service } from "./service";
+import { AxisPositions, CartesianOrientations } from "../interfaces";
+export declare class CartesianScales extends Service {
+    protected scaleTypes: {
+        top: any;
+        right: any;
+        bottom: any;
+        left: any;
+    };
+    protected scales: {
+        top: any;
+        right: any;
+        bottom: any;
+        left: any;
+    };
+    protected domainAxisPosition: AxisPositions;
+    protected rangeAxisPosition: AxisPositions;
+    protected orientation: CartesianOrientations;
+    getDomainAxisPosition(): AxisPositions;
+    getRangeAxisPosition(): AxisPositions;
+    update(animate?: boolean): void;
+    determineOrientation(): void;
+    getOrientation(): CartesianOrientations;
+    getScaleByPosition(axisPosition: AxisPositions): any;
+    getScaleTypeByPosition(axisPosition: AxisPositions): any;
+    getDomainScale(): any;
+    getRangeScale(): any;
+    getMainXAxisPosition(): AxisPositions;
+    getMainYAxisPosition(): AxisPositions;
+    getMainXScale(): any;
+    getMainYScale(): any;
+    getValueFromScale(axisPosition: AxisPositions, datum: any, index?: number): any;
+    getDomainValue(d: any, i: any): any;
+    getRangeValue(d: any, i: any): any;
+    /** Uses the primary Y Axis to get data items associated with that value.  */
+    getDataFromDomain(domainValue: any): any[];
+    protected getScaleDomain(axisPosition: AxisPositions): any;
+    protected createScale(axisPosition: AxisPositions): any;
+}

package/src/services/scales-cartesian.js

@@ -0,0 +1,292 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+// Internal Imports
+import { Service } from "./service";
+import { AxisPositions, CartesianOrientations, ScaleTypes } from "../interfaces";
+import { Tools } from "../tools";
+// D3 Imports
+import { scaleBand, scaleLinear, scaleTime, scaleLog } from "d3-scale";
+import { min, extent } from "d3-array";
+import { timeFormatDefaultLocale } from "d3-time-format";
+var englishLocale = require("d3-time-format/locale/en-US.json");
+// Misc
+import { differenceInYears, addYears, subYears, differenceInMonths, addMonths, subMonths, differenceInDays, addDays, subDays, differenceInHours, addHours, subHours, differenceInMinutes, addMinutes, subMinutes } from "date-fns";
+var CartesianScales = /** @class */ (function (_super) {
+    __extends(CartesianScales, _super);
+    function CartesianScales() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.scaleTypes = {
+            top: null,
+            right: null,
+            bottom: null,
+            left: null
+        };
+        _this.scales = {
+            top: null,
+            right: null,
+            bottom: null,
+            left: null
+        };
+        return _this;
+    }
+    CartesianScales.prototype.getDomainAxisPosition = function () {
+        return this.domainAxisPosition;
+    };
+    CartesianScales.prototype.getRangeAxisPosition = function () {
+        return this.rangeAxisPosition;
+    };
+    CartesianScales.prototype.update = function (animate) {
+        var _this = this;
+        if (animate === void 0) { animate = true; }
+        this.determineOrientation();
+        var axisPositions = Object.keys(AxisPositions).map(function (axisPositionKey) { return AxisPositions[axisPositionKey]; });
+        axisPositions.forEach(function (axisPosition) {
+            _this.scales[axisPosition] = _this.createScale(axisPosition);
+        });
+    };
+    CartesianScales.prototype.determineOrientation = function () {
+        var _this = this;
+        var options = this.model.getOptions();
+        // Manually specifying positions here
+        // In order to enforce a priority
+        [
+            AxisPositions.LEFT,
+            AxisPositions.BOTTOM,
+            AxisPositions.RIGHT,
+            AxisPositions.TOP
+        ].forEach(function (axisPosition) {
+            var axisOptions = Tools.getProperty(options, "axes", axisPosition);
+            if (axisOptions) {
+                var scaleType = axisOptions.scaleType || ScaleTypes.LINEAR;
+                _this.scaleTypes[axisPosition] = scaleType;
+                if (scaleType === ScaleTypes.LINEAR) {
+                    _this.rangeAxisPosition = axisPosition;
+                }
+                else {
+                    _this.domainAxisPosition = axisPosition;
+                }
+            }
+        });
+        if (this.rangeAxisPosition === AxisPositions.LEFT && this.domainAxisPosition === AxisPositions.BOTTOM) {
+            this.orientation = CartesianOrientations.VERTICAL;
+        }
+        else {
+            this.orientation = CartesianOrientations.HORIZONTAL;
+        }
+    };
+    CartesianScales.prototype.getOrientation = function () {
+        return this.orientation;
+    };
+    CartesianScales.prototype.getScaleByPosition = function (axisPosition) {
+        return this.scales[axisPosition];
+    };
+    CartesianScales.prototype.getScaleTypeByPosition = function (axisPosition) {
+        return this.scaleTypes[axisPosition];
+    };
+    CartesianScales.prototype.getDomainScale = function () {
+        return this.scales[this.domainAxisPosition];
+    };
+    CartesianScales.prototype.getRangeScale = function () {
+        return this.scales[this.rangeAxisPosition];
+    };
+    // Find the main x-axis out of the 2 x-axis on the chart (when 2D axis is used)
+    CartesianScales.prototype.getMainXAxisPosition = function () {
+        var possibleXAxisPositions = [AxisPositions.BOTTOM, AxisPositions.TOP];
+        return [this.domainAxisPosition, this.rangeAxisPosition]
+            .find(function (position) { return possibleXAxisPositions.indexOf(position) > -1; });
+    };
+    // Find the main y-axis out of the 2 y-axis on the chart (when 2D axis is used)
+    CartesianScales.prototype.getMainYAxisPosition = function () {
+        var possibleYAxisPositions = [AxisPositions.LEFT, AxisPositions.RIGHT];
+        return [this.domainAxisPosition, this.rangeAxisPosition]
+            .find(function (position) { return possibleYAxisPositions.indexOf(position) > -1; });
+    };
+    CartesianScales.prototype.getMainXScale = function () {
+        return this.scales[this.getMainXAxisPosition()];
+    };
+    CartesianScales.prototype.getMainYScale = function () {
+        return this.scales[this.getMainYAxisPosition()];
+    };
+    CartesianScales.prototype.getValueFromScale = function (axisPosition, datum, index) {
+        var value = isNaN(datum) ? datum.value : datum;
+        var scaleType = this.scaleTypes[axisPosition];
+        var scale = this.scales[axisPosition];
+        if (scaleType === ScaleTypes.LABELS) {
+            var correspondingLabel = this.model.getDisplayData().labels[index];
+            return scale(correspondingLabel) + scale.step() / 2;
+        }
+        else if (scaleType === ScaleTypes.TIME) {
+            return scale(new Date(datum.date || datum.label));
+        }
+        return scale(value);
+    };
+    CartesianScales.prototype.getDomainValue = function (d, i) {
+        return this.getValueFromScale(this.domainAxisPosition, d, i);
+    };
+    CartesianScales.prototype.getRangeValue = function (d, i) {
+        return this.getValueFromScale(this.rangeAxisPosition, d, i);
+    };
+    /** Uses the primary Y Axis to get data items associated with that value.  */
+    CartesianScales.prototype.getDataFromDomain = function (domainValue) {
+        var displayData = this.model.getDisplayData();
+        var activePoints = [];
+        var scaleType = this.scaleTypes[this.domainAxisPosition];
+        switch (scaleType) {
+            case ScaleTypes.LABELS:
+                // based on labels we use the index to get the associated data
+                var index_1 = displayData.labels.indexOf(domainValue);
+                displayData.datasets.forEach(function (dataset) {
+                    activePoints.push({
+                        datasetLabel: dataset.label,
+                        value: dataset.data[index_1],
+                    });
+                });
+                break;
+            case ScaleTypes.TIME:
+                // time series we filter using the date
+                var domainKey_1 = Object.keys(displayData.datasets[0].data[0]).filter(function (key) { return key !== "value"; })[0];
+                displayData.datasets.forEach(function (dataset) {
+                    var sharedLabel = dataset.label;
+                    // filter the items in each dataset for the points associated with the Domain
+                    var dataItems = dataset.data.filter(function (item) {
+                        var date1 = new Date(item[domainKey_1]);
+                        var date2 = new Date(domainValue);
+                        return date1.getTime() === date2.getTime();
+                    });
+                    // assign the shared label on the data items and add them to the array
+                    dataItems.forEach(function (item) {
+                        activePoints.push(Object.assign({ datasetLabel: sharedLabel,
+                            value: item.value,
+                        }, item));
+                    });
+                });
+                break;
+        }
+        return activePoints;
+    };
+    CartesianScales.prototype.getScaleDomain = function (axisPosition) {
+        var options = this.model.getOptions();
+        var axisOptions = Tools.getProperty(options, "axes", axisPosition);
+        var _a = this.model.getDisplayData(), datasets = _a.datasets, labels = _a.labels;
+        // If scale is a LABELS scale, return some labels as the domain
+        if (axisOptions && axisOptions.scaleType === ScaleTypes.LABELS) {
+            if (labels) {
+                return labels;
+            }
+            else {
+                return this.model.getDisplayData().datasets[0].data.map(function (d, i) { return i + 1; });
+            }
+        }
+        // Get the extent of the domain
+        var domain;
+        // If the scale is stacked
+        if (axisOptions.stacked) {
+            domain = extent(labels.reduce(function (m, label, i) {
+                var correspondingValues = datasets.map(function (dataset) {
+                    return !isNaN(dataset.data[i]) ? dataset.data[i] : dataset.data[i].value;
+                });
+                var totalValue = correspondingValues.reduce(function (a, b) { return a + b; }, 0);
+                // Save both the total value and the minimum
+                return m.concat(totalValue, min(correspondingValues));
+            }, [])
+                // Currently stack layouts in the library
+                // Only support positive values
+                .concat(0));
+        }
+        else {
+            // Get all the chart's data values in a flat array
+            var allDataValues = datasets.reduce(function (dataValues, dataset) {
+                dataset.data.forEach(function (datum) {
+                    if (axisOptions.scaleType === ScaleTypes.TIME) {
+                        dataValues = dataValues.concat(datum.date);
+                    }
+                    else {
+                        dataValues = dataValues.concat(isNaN(datum) ? datum.value : datum);
+                    }
+                });
+                return dataValues;
+            }, []);
+            if (axisOptions.scaleType !== ScaleTypes.TIME) {
+                allDataValues = allDataValues.concat(0);
+            }
+            domain = extent(allDataValues);
+        }
+        if (axisOptions.scaleType === ScaleTypes.TIME) {
+            var spaceToAddToEdges = Tools.getProperty(options, "timeScale", "addSpaceOnEdges");
+            if (spaceToAddToEdges) {
+                var startDate = new Date(domain[0]);
+                var endDate = new Date(domain[1]);
+                if (differenceInYears(endDate, startDate) > 1) {
+                    return [subYears(startDate, spaceToAddToEdges), addYears(endDate, spaceToAddToEdges)];
+                }
+                if (differenceInMonths(endDate, startDate) > 1) {
+                    return [subMonths(startDate, spaceToAddToEdges), addMonths(endDate, spaceToAddToEdges)];
+                }
+                if (differenceInDays(endDate, startDate) > 1) {
+                    return [subDays(startDate, spaceToAddToEdges), addDays(endDate, spaceToAddToEdges)];
+                }
+                if (differenceInHours(endDate, startDate) > 1) {
+                    return [subHours(startDate, spaceToAddToEdges), addHours(endDate, spaceToAddToEdges)];
+                }
+                if (differenceInMinutes(endDate, startDate) > 1) {
+                    return [subMinutes(startDate, spaceToAddToEdges), addMinutes(endDate, spaceToAddToEdges)];
+                }
+                return [startDate, endDate];
+            }
+            return [
+                new Date(domain[0]),
+                new Date(domain[1])
+            ];
+        }
+        // TODO - Work with design to improve logic
+        domain[1] = domain[1] * 1.1;
+        // if the lower bound of the domain is less than 0, we want to add padding
+        if (domain[0] < 0) {
+            domain[0] = domain[0] * 1.1;
+        }
+        return domain;
+    };
+    CartesianScales.prototype.createScale = function (axisPosition) {
+        var options = this.model.getOptions();
+        var axisOptions = Tools.getProperty(options, "axes", axisPosition);
+        if (!axisOptions) {
+            return null;
+        }
+        var scaleType = Tools.getProperty(axisOptions, "scaleType") || ScaleTypes.LINEAR;
+        this.scaleTypes[axisPosition] = scaleType;
+        // Set the date/time locale
+        if (scaleType === ScaleTypes.TIME) {
+            var timeLocale = Tools.getProperty(options, "locale", "time") || englishLocale;
+            timeFormatDefaultLocale(timeLocale);
+        }
+        var scale;
+        if (scaleType === ScaleTypes.TIME) {
+            scale = scaleTime();
+        }
+        else if (scaleType === ScaleTypes.LOG) {
+            scale = scaleLog().base(axisOptions.base || 10);
+        }
+        else if (scaleType === ScaleTypes.LABELS) {
+            scale = scaleBand();
+        }
+        else {
+            scale = scaleLinear();
+        }
+        scale.domain(this.getScaleDomain(axisPosition));
+        return scale;
+    };
+    return CartesianScales;
+}(Service));
+export { CartesianScales };
+//# sourceMappingURL=../../../src/services/scales-cartesian.js.map