@wcardinal/wcardinal-ui 0.296.0 → 0.297.0

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.296.0
+ Winter Cardinal UI v0.297.0
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -55034,38 +55034,59 @@
                 var gridlineShapes = this._major.gridline.shapes;
                 var parser = this._parser;
                 var offset = parser.padding * this._index;
+                var work = this._work;
                 var coordinate = void 0;
                 switch (parser.position) {
                     case DChartAxisPosition.TOP:
                         coordinate = plotArea.coordinate.x.get(parser.coordinate);
                         if (coordinate) {
-                            var domain = this.getDomain(plotArea, coordinate, this._work);
+                            var domain = this.getDomain(plotArea, coordinate, work);
+                            var domainFrom = domain.from;
+                            var domainTo = domain.to;
+                            var domainVisible = this.getDomainVisible(plotArea, coordinate, work);
+                            var domainVisibleFrom = domainVisible.from;
+                            var domainVisibleTo = domainVisible.to;
                             var plotAreaHeight = plotArea.height;
-                            return this.updateX(domain.from, domain.to, coordinate, majorShapes, minorShapes, gridlineShapes, 0 - offset, transform, plotAreaHeight);
+                            return this.updateX(domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, coordinate, majorShapes, minorShapes, gridlineShapes, 0 - offset, transform, plotAreaHeight);
                         }
                         break;
                     case DChartAxisPosition.BOTTOM:
                         coordinate = plotArea.coordinate.x.get(parser.coordinate);
                         if (coordinate) {
-                            var domain = this.getDomain(plotArea, coordinate, this._work);
+                            var domain = this.getDomain(plotArea, coordinate, work);
+                            var domainFrom = domain.from;
+                            var domainTo = domain.to;
+                            var domainVisible = this.getDomainVisible(plotArea, coordinate, work);
+                            var domainVisibleFrom = domainVisible.from;
+                            var domainVisibleTo = domainVisible.to;
                             var plotAreaHeight = plotArea.height;
-                            return this.updateX(domain.from, domain.to, coordinate, majorShapes, minorShapes, gridlineShapes, plotAreaHeight + offset, transform, plotAreaHeight);
+                            return this.updateX(domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, coordinate, majorShapes, minorShapes, gridlineShapes, plotAreaHeight + offset, transform, plotAreaHeight);
                         }
                         break;
                     case DChartAxisPosition.LEFT:
                         coordinate = plotArea.coordinate.y.get(parser.coordinate);
                         if (coordinate) {
-                            var range = this.getRange(plotArea, coordinate, this._work);
+                            var range = this.getRange(plotArea, coordinate, work);
+                            var rangeFrom = range.from;
+                            var rangeTo = range.to;
+                            var rangeVisible = this.getRangeVisible(plotArea, coordinate, work);
+                            var rangeVisibleFrom = rangeVisible.from;
+                            var rangeVisibleTo = rangeVisible.to;
                             var plotAreaWidth = plotArea.width;
-                            return this.updateY(range.from, range.to, coordinate, majorShapes, minorShapes, gridlineShapes, 0 - offset, transform, plotAreaWidth);
+                            return this.updateY(rangeFrom, rangeTo, rangeVisibleFrom, rangeVisibleTo, coordinate, majorShapes, minorShapes, gridlineShapes, 0 - offset, transform, plotAreaWidth);
                         }
                         break;
                     case DChartAxisPosition.RIGHT:
                         coordinate = plotArea.coordinate.y.get(parser.coordinate);
                         if (coordinate) {
-                            var range = this.getRange(plotArea, coordinate, this._work);
+                            var range = this.getRange(plotArea, coordinate, work);
+                            var rangeFrom = range.from;
+                            var rangeTo = range.to;
+                            var rangeVisible = this.getRangeVisible(plotArea, coordinate, work);
+                            var rangeVisibleFrom = rangeVisible.from;
+                            var rangeVisibleTo = rangeVisible.to;
                             var plotAreaWidth = plotArea.width;
-                            return this.updateY(range.from, range.to, coordinate, majorShapes, minorShapes, gridlineShapes, plotAreaWidth + offset, transform, plotAreaWidth);
+                            return this.updateY(rangeFrom, rangeTo, rangeVisibleFrom, rangeVisibleTo, coordinate, majorShapes, minorShapes, gridlineShapes, plotAreaWidth + offset, transform, plotAreaWidth);
                         }
                         break;
                 }
@@ -55077,12 +55098,18 @@
             var transform = coordinate.transform;
             return result.set(coordinate.unmap(transform.unmap(bounds.x)), coordinate.unmap(transform.unmap(bounds.x + bounds.width)));
         };
+        DChartAxisBaseTickContainer.prototype.getDomainVisible = function (plotArea, coordinate, result) {
+            return result;
+        };
         DChartAxisBaseTickContainer.prototype.getRange = function (plotArea, coordinate, result) {
             var bounds = plotArea.getBoundsInContainer();
             var transform = coordinate.transform;
             return result.set(coordinate.unmap(transform.unmap(bounds.y)), coordinate.unmap(transform.unmap(bounds.y + bounds.height)));
         };
-        DChartAxisBaseTickContainer.prototype.updateX = function (domainMin, domainMax, coordinate, majorShapes, minorShapes, gridlineShapes, shapePositionY, transform, plotAreaHeight) {
+        DChartAxisBaseTickContainer.prototype.getRangeVisible = function (plotArea, coordinate, result) {
+            return result;
+        };
+        DChartAxisBaseTickContainer.prototype.updateX = function (domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, coordinate, majorShapes, minorShapes, gridlineShapes, shapePositionY, transform, plotAreaHeight) {
             var tick = this._parser.tick;
             var majorTick = tick.major;
             var majorCount = majorTick.count;
@@ -55096,7 +55123,7 @@
             var minorFormatter = minorTick.formatter;
             var majorTicks = this._majorTicks;
             var minorTicks = this._minorTicks;
-            this.newTicks(coordinate, domainMin, domainMax, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorTicks, minorTicks);
+            this.newTicks(coordinate, domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorTicks, minorTicks);
             var a = transform.a;
             var tx = transform.tx;
             for (var i = 0; i < majorCapacity; ++i) {
@@ -55135,7 +55162,7 @@
             }
             return true;
         };
-        DChartAxisBaseTickContainer.prototype.updateY = function (rangeMin, rangeMax, coordinate, majorShapes, minorShapes, gridlineShapes, shapePositionX, transform, plotAreaWidth) {
+        DChartAxisBaseTickContainer.prototype.updateY = function (rangeFrom, rangeTo, rangeVisibleFrom, rangeVisibleTo, coordinate, majorShapes, minorShapes, gridlineShapes, shapePositionX, transform, plotAreaWidth) {
             var tick = this._parser.tick;
             var majorTick = tick.major;
             var majorCount = majorTick.count;
@@ -55149,7 +55176,7 @@
             var minorFormatter = minorTick.formatter;
             var majorTicks = this._majorTicks;
             var minorTicks = this._minorTicks;
-            this.newTicks(coordinate, rangeMin, rangeMax, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorTicks, minorTicks);
+            this.newTicks(coordinate, rangeFrom, rangeTo, rangeVisibleFrom, rangeVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorTicks, minorTicks);
             var d = transform.d;
             var ty = transform.ty;
             for (var i = 0; i < majorCapacity; ++i) {
@@ -55218,8 +55245,8 @@
         DChartAxisBaseTickContainer.prototype.hideMinor = function (shape) {
             shape.visible = false;
         };
-        DChartAxisBaseTickContainer.prototype.newTicks = function (coordinate, domainMin, domainMax, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult) {
-            coordinate.ticks(domainMin, domainMax, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult);
+        DChartAxisBaseTickContainer.prototype.newTicks = function (coordinate, domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult) {
+            coordinate.ticks(domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult);
         };
         DChartAxisBaseTickContainer.prototype.destroy = function () {
             this._major.destroy();
@@ -55822,8 +55849,8 @@
         DChartCoordinateBase.prototype.unmapAll = function (values, ifrom, iend, stride, offset) {
             // DO NOTHING
         };
-        DChartCoordinateBase.prototype.ticks = function (domainFrom, domainTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult) {
-            this._tick.calculate(domainFrom, domainTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult, this);
+        DChartCoordinateBase.prototype.ticks = function (domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult) {
+            this._tick.calculate(domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult, this);
         };
         DChartCoordinateBase.prototype.toTheme = function (options) {
             var _a;
@@ -56060,65 +56087,63 @@
                 }
             }
         };
-        DChartCoordinateLinearTick.prototype.calculate = function (domainFrom, domainTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult, coordinate) {
+        DChartCoordinateLinearTick.prototype.calculate = function (domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult, coordinate) {
             if (majorCount <= 0) {
                 return;
             }
             var transform = coordinate.transform;
             var domainMin = Math.min(domainFrom, domainTo);
             var domainMax = Math.max(domainFrom, domainTo);
-            var majorStepMapped = this.toMajorStep(domainMin, domainMax, majorCount, majorStep);
+            var domainVisibleMin = Math.min(domainVisibleFrom, domainVisibleTo);
+            var domainVisibleMax = Math.max(domainVisibleFrom, domainVisibleTo);
+            var domainVisibleMinMapped = coordinate.map(domainVisibleMin);
+            var domainVisibleMaxMapped = coordinate.map(domainVisibleMax);
+            var from0 = Math.min(domainVisibleMinMapped, domainVisibleMaxMapped);
+            var to0 = Math.max(domainVisibleMinMapped, domainVisibleMaxMapped);
+            var domainMinMapped = coordinate.map(domainMin);
+            var domainMaxMapped = coordinate.map(domainMax);
+            var from1 = Math.min(domainMinMapped, domainMaxMapped);
+            var to1 = Math.max(domainMinMapped, domainMaxMapped);
+            var from = Math.max(from0, from1);
+            var to = Math.min(to0, to1);
+            var imajor = 0;
+            var iminor = 0;
+            var majorStepMapped = this.toMajorStep(domainMinMapped, domainMaxMapped, majorCount, majorStep);
             if (majorStepMapped <= 0) {
-                majorResult[0] = domainMin;
-                majorResult[1] = transform.map(coordinate.map(domainMin));
-                majorResult[2] = 0;
-                for (var i = 1; i < majorCapacity; ++i) {
-                    var imajorResult = i * 3;
-                    majorResult[imajorResult + 0] = NaN;
-                    majorResult[imajorResult + 1] = NaN;
-                    majorResult[imajorResult + 2] = NaN;
-                }
-                for (var i = 0; i < minorCount; ++i) {
-                    var iminorResult = i * 3;
-                    minorResult[iminorResult + 0] = NaN;
-                    minorResult[iminorResult + 1] = NaN;
-                    minorResult[iminorResult + 2] = NaN;
+                if (from <= domainMinMapped && domainMinMapped <= to) {
+                    majorResult[0] = domainMin;
+                    majorResult[1] = transform.map(domainMinMapped);
+                    majorResult[2] = 0;
+                    imajor += 1;
                 }
-                return;
             }
-            // Major tick start position
-            var idomainStart = Math.floor(domainMin / majorStepMapped) - 1;
-            var idomainEnd = Math.ceil(domainMax / majorStepMapped) + 1;
-            var domainMinMapped = transform.map(coordinate.map(domainMin));
-            var domainMaxMapped = transform.map(coordinate.map(domainMax));
-            var from = Math.min(domainMinMapped, domainMaxMapped) - 0.5;
-            var to = Math.max(domainMinMapped, domainMaxMapped) + 0.5;
-            // Major / minor tick positions
-            var minorStepMapped = this.toMinorStep(majorStepMapped, minorCountPerMajor, minorStep);
-            var imajor = 0;
-            var iminor = 0;
-            for (var i = idomainStart; i <= idomainEnd; ++i) {
-                var majorPosition = i * majorStepMapped;
-                if (imajor < majorCapacity) {
-                    var majorPositionMapped = transform.map(coordinate.map(majorPosition));
-                    if (from <= majorPositionMapped && majorPositionMapped <= to) {
-                        var imajorResult = imajor * 3;
-                        majorResult[imajorResult + 0] = majorPosition;
-                        majorResult[imajorResult + 1] = majorPositionMapped;
-                        majorResult[imajorResult + 2] = majorStepMapped;
-                        imajor += 1;
-                    }
-                }
-                for (var j = 0; j < minorCountPerMajor; j += 1) {
-                    if (iminor < minorCount) {
-                        var minorPosition = majorPosition + (j + 1) * minorStepMapped;
-                        var minorPositionMapped = transform.map(coordinate.map(minorPosition));
-                        if (from <= minorPositionMapped && minorPositionMapped <= to) {
-                            var iminorResult = iminor * 3;
-                            minorResult[iminorResult + 0] = minorPosition;
-                            minorResult[iminorResult + 1] = minorPositionMapped;
-                            minorResult[iminorResult + 2] = minorStepMapped;
-                            iminor += 1;
+            else {
+                // Major tick start position
+                var idomainStartMapped = Math.floor(domainMinMapped / majorStepMapped) - 1;
+                var idomainEndMapped = Math.ceil(domainMaxMapped / majorStepMapped) + 1;
+                // Major / minor tick positions
+                var minorStepMapped = this.toMinorStep(majorStepMapped, minorCountPerMajor, minorStep);
+                for (var i = idomainStartMapped; i <= idomainEndMapped; ++i) {
+                    var majorPositionMapped = i * majorStepMapped;
+                    if (imajor < majorCapacity) {
+                        if (from <= majorPositionMapped && majorPositionMapped <= to) {
+                            var imajorResult = imajor * 3;
+                            majorResult[imajorResult + 0] = coordinate.unmap(majorPositionMapped);
+                            majorResult[imajorResult + 1] = transform.map(majorPositionMapped);
+                            majorResult[imajorResult + 2] = majorStepMapped;
+                            imajor += 1;
+                        }
+                    }
+                    for (var j = 0; j < minorCountPerMajor; j += 1) {
+                        if (iminor < minorCount) {
+                            var minorPositionMapped = majorPositionMapped + (j + 1) * minorStepMapped;
+                            if (from <= minorPositionMapped && minorPositionMapped <= to) {
+                                var iminorResult = iminor * 3;
+                                minorResult[iminorResult + 0] = coordinate.unmap(minorPositionMapped);
+                                minorResult[iminorResult + 1] = transform.map(minorPositionMapped);
+                                minorResult[iminorResult + 2] = minorStepMapped;
+                                iminor += 1;
+                            }
                         }
                     }
                 }
@@ -56211,64 +56236,63 @@
                 }
             }
         };
-        DChartCoordinateLogTick.prototype.calculate = function (domainFrom, domainTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult, coordinate) {
+        DChartCoordinateLogTick.prototype.calculate = function (domainFrom, domainTo, domainVisibleFrom, domainVisibleTo, majorCount, majorCapacity, majorStep, minorCountPerMajor, minorCount, minorStep, majorResult, minorResult, coordinate) {
             if (majorCount <= 0) {
                 return;
             }
             var transform = coordinate.transform;
-            var domainFromMapped = coordinate.map(domainFrom);
-            var domainToMapped = coordinate.map(domainTo);
-            var domainMinMapped = Math.min(domainFromMapped, domainToMapped);
-            var domainMaxMapped = Math.max(domainFromMapped, domainToMapped);
+            var domainMin = Math.min(domainFrom, domainTo);
+            var domainMax = Math.max(domainFrom, domainTo);
+            var domainVisibleMin = Math.min(domainVisibleFrom, domainVisibleTo);
+            var domainVisibleMax = Math.max(domainVisibleFrom, domainVisibleTo);
+            var domainVisibleMinMapped = coordinate.map(domainVisibleMin);
+            var domainVisibleMaxMapped = coordinate.map(domainVisibleMax);
+            var from0 = Math.min(domainVisibleMinMapped, domainVisibleMaxMapped);
+            var to0 = Math.max(domainVisibleMinMapped, domainVisibleMaxMapped);
+            var domainMinMapped = coordinate.map(domainMin);
+            var domainMaxMapped = coordinate.map(domainMax);
+            var from1 = Math.min(domainMinMapped, domainMaxMapped);
+            var to1 = Math.max(domainMinMapped, domainMaxMapped);
+            var from = Math.max(from0, from1);
+            var to = Math.min(to0, to1);
+            var imajor = 0;
+            var iminor = 0;
             var majorStepMapped = this.toMajorStep(domainMinMapped, domainMaxMapped, majorCount, majorStep);
             if (majorStepMapped <= 0) {
-                var domainMin = Math.min(domainFrom, domainTo);
-                majorResult[0] = domainMin;
-                majorResult[1] = transform.map(coordinate.map(domainMin));
-                majorResult[2] = 0;
-                for (var i = 1; i < majorCount; ++i) {
-                    var imajorResult = i * 3;
-                    majorResult[imajorResult + 0] = NaN;
-                    majorResult[imajorResult + 1] = NaN;
-                    majorResult[imajorResult + 2] = NaN;
-                }
-                for (var i = 0; i < minorCount; ++i) {
-                    var iminorResult = i * 3;
-                    minorResult[iminorResult + 0] = NaN;
-                    minorResult[iminorResult + 1] = NaN;
-                    minorResult[iminorResult + 2] = NaN;
+                if (from <= domainMinMapped && domainMinMapped <= to) {
+                    majorResult[0] = domainMin;
+                    majorResult[1] = transform.map(domainMinMapped);
+                    majorResult[2] = 0;
+                    imajor += 1;
                 }
-                return;
             }
-            // Major tick start position
-            var idomainStartMapped = Math.floor(domainMinMapped / majorStepMapped) - 1;
-            var idomainEndMapped = Math.ceil(domainMaxMapped / majorStepMapped) + 1;
-            // Major / minor tick positions
-            var minorStepMapped = this.toMinorStep(majorStepMapped, minorCountPerMajor, minorStep);
-            var imajor = 0;
-            var iminor = 0;
-            for (var i = idomainStartMapped; i <= idomainEndMapped; ++i) {
-                var majorPositionMapped = i * majorStepMapped;
-                if (imajor < majorCapacity) {
-                    if (domainMinMapped <= majorPositionMapped &&
-                        majorPositionMapped <= domainMaxMapped) {
-                        var imajorResult = imajor * 3;
-                        majorResult[imajorResult + 0] = coordinate.unmap(majorPositionMapped);
-                        majorResult[imajorResult + 1] = transform.map(majorPositionMapped);
-                        majorResult[imajorResult + 2] = coordinate.unmap(majorPositionMapped - 1);
-                        imajor += 1;
-                    }
-                }
-                for (var j = 0; j < minorCountPerMajor; j += 1) {
-                    if (iminor < minorCount) {
-                        var minorPositionMapped = majorPositionMapped + (j + 1) * minorStepMapped;
-                        if (domainMinMapped <= minorPositionMapped &&
-                            minorPositionMapped <= domainMaxMapped) {
-                            var iminorResult = iminor * 3;
-                            minorResult[iminorResult + 0] = coordinate.unmap(minorPositionMapped);
-                            minorResult[iminorResult + 1] = transform.map(minorPositionMapped);
-                            minorResult[iminorResult + 2] = coordinate.unmap(minorPositionMapped - 1);
-                            iminor += 1;
+            else {
+                // Major tick start position
+                var idomainStartMapped = Math.floor(domainMinMapped / majorStepMapped) - 1;
+                var idomainEndMapped = Math.ceil(domainMaxMapped / majorStepMapped) + 1;
+                // Major / minor tick positions
+                var minorStepMapped = this.toMinorStep(majorStepMapped, minorCountPerMajor, minorStep);
+                for (var i = idomainStartMapped; i <= idomainEndMapped; ++i) {
+                    var majorPositionMapped = i * majorStepMapped;
+                    if (imajor < majorCapacity) {
+                        if (from <= majorPositionMapped && majorPositionMapped <= to) {
+                            var imajorResult = imajor * 3;
+                            majorResult[imajorResult + 0] = coordinate.unmap(majorPositionMapped);
+                            majorResult[imajorResult + 1] = transform.map(majorPositionMapped);
+                            majorResult[imajorResult + 2] = coordinate.unmap(majorPositionMapped - 1);
+                            imajor += 1;
+                        }
+                    }
+                    for (var j = 0; j < minorCountPerMajor; j += 1) {
+                        if (iminor < minorCount) {
+                            var minorPositionMapped = majorPositionMapped + (j + 1) * minorStepMapped;
+                            if (from <= minorPositionMapped && minorPositionMapped <= to) {
+                                var iminorResult = iminor * 3;
+                                minorResult[iminorResult + 0] = coordinate.unmap(minorPositionMapped);
+                                minorResult[iminorResult + 1] = transform.map(minorPositionMapped);
+                                minorResult[iminorResult + 2] = coordinate.unmap(minorPositionMapped - 1);
+                                iminor += 1;
+                            }
                         }
                     }
                 }