@wcardinal/wcardinal-ui 0.295.0 → 0.297.0

package/dist/wcardinal-ui.js

@@ -1,5 +1,5 @@
 /*
- Winter Cardinal UI v0.295.0
+ Winter Cardinal UI v0.297.0
  Copyright (C) 2019 Toshiba Corporation
  SPDX-License-Identifier: Apache-2.0
 
@@ -54947,6 +54947,41 @@
         return DChartAxisBaseTickMinor;
     }());
 
+    /*
+     * Copyright (C) 2019 Toshiba Corporation
+     * SPDX-License-Identifier: Apache-2.0
+     */
+    var DChartRegionImpl = /** @class */ (function () {
+        function DChartRegionImpl(from, to) {
+            this.from = from;
+            this.to = to;
+        }
+        DChartRegionImpl.prototype.set = function (from, to) {
+            if (from != null) {
+                this.from = from;
+            }
+            if (to != null) {
+                this.to = to;
+            }
+            return this;
+        };
+        DChartRegionImpl.prototype.add = function (from, to) {
+            if (!isNaN$1(from)) {
+                this.from = isNaN$1(this.from) ? from : Math.min(this.from, from);
+            }
+            if (!isNaN$1(to)) {
+                this.to = isNaN$1(this.to) ? to : Math.max(this.to, to);
+            }
+            return this;
+        };
+        DChartRegionImpl.prototype.clear = function () {
+            this.from = NaN;
+            this.to = NaN;
+            return this;
+        };
+        return DChartRegionImpl;
+    }());
+
     var DChartAxisBaseTickContainer = /** @class */ (function () {
         function DChartAxisBaseTickContainer(parser, options) {
             this._parser = parser;
@@ -54955,6 +54990,7 @@
             this._minor = this.newMinor(parser, options);
             this._majorTicks = [];
             this._minorTicks = [];
+            this._work = new DChartRegionImpl(0, 0);
         }
         Object.defineProperty(DChartAxisBaseTickContainer.prototype, "major", {
             get: function () {
@@ -54994,54 +55030,86 @@
             var minorShapes = this._minor.shapes;
             if (container != null && majorShapes && minorShapes) {
                 var plotArea = container.plotArea;
-                var bounds = plotArea.getBoundsInContainer();
                 var transform = plotArea.container.transform.localTransform;
                 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 domainFrom = coordinate.unmap(coordinate.transform.unmap(bounds.x));
-                            var domainTo = coordinate.unmap(coordinate.transform.unmap(bounds.x + bounds.width));
+                            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(domainFrom, domainTo, 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 domainFrom = coordinate.unmap(coordinate.transform.unmap(bounds.x));
-                            var domainTo = coordinate.unmap(coordinate.transform.unmap(bounds.x + bounds.width));
+                            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(domainFrom, domainTo, 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 domainFrom = coordinate.unmap(coordinate.transform.unmap(bounds.y));
-                            var domainTo = coordinate.unmap(coordinate.transform.unmap(bounds.y + bounds.height));
+                            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(domainFrom, domainTo, 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 domainFrom = coordinate.unmap(coordinate.transform.unmap(bounds.y));
-                            var domainTo = coordinate.unmap(coordinate.transform.unmap(bounds.y + bounds.height));
+                            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(domainFrom, domainTo, coordinate, majorShapes, minorShapes, gridlineShapes, plotAreaWidth + offset, transform, plotAreaWidth);
+                            return this.updateY(rangeFrom, rangeTo, rangeVisibleFrom, rangeVisibleTo, coordinate, majorShapes, minorShapes, gridlineShapes, plotAreaWidth + offset, transform, plotAreaWidth);
                         }
                         break;
                 }
             }
             return false;
         };
-        DChartAxisBaseTickContainer.prototype.updateX = function (domainMin, domainMax, coordinate, majorShapes, minorShapes, gridlineShapes, shapePositionY, transform, plotAreaHeight) {
+        DChartAxisBaseTickContainer.prototype.getDomain = function (plotArea, coordinate, result) {
+            var bounds = plotArea.getBoundsInContainer();
+            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.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;
@@ -55055,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) {
@@ -55094,7 +55162,7 @@
             }
             return true;
         };
-        DChartAxisBaseTickContainer.prototype.updateY = function (domainMin, domainMax, 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;
@@ -55108,7 +55176,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, 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) {
@@ -55177,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();
@@ -55609,41 +55677,6 @@
         return DChartCoordinateTransformMarkImpl;
     }());
 
-    /*
-     * Copyright (C) 2019 Toshiba Corporation
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    var DChartRegionImpl = /** @class */ (function () {
-        function DChartRegionImpl(from, to) {
-            this.from = from;
-            this.to = to;
-        }
-        DChartRegionImpl.prototype.set = function (from, to) {
-            if (from != null) {
-                this.from = from;
-            }
-            if (to != null) {
-                this.to = to;
-            }
-            return this;
-        };
-        DChartRegionImpl.prototype.add = function (from, to) {
-            if (!isNaN$1(from)) {
-                this.from = isNaN$1(this.from) ? from : Math.min(this.from, from);
-            }
-            if (!isNaN$1(to)) {
-                this.to = isNaN$1(this.to) ? to : Math.max(this.to, to);
-            }
-            return this;
-        };
-        DChartRegionImpl.prototype.clear = function () {
-            this.from = NaN;
-            this.to = NaN;
-            return this;
-        };
-        return DChartRegionImpl;
-    }());
-
     /*
      * Copyright (C) 2019 Toshiba Corporation
      * SPDX-License-Identifier: Apache-2.0
@@ -55715,18 +55748,27 @@
             var container = this._container;
             if (container) {
                 var plotArea = container.container.plotArea;
-                var padding = plotArea.padding;
                 var work = this._work;
                 switch (this._direction) {
                     case DChartCoordinateDirection.X:
-                        this.doFit_(padding.getLeft(), plotArea.width - padding.getRight(), this.toFitDomain(from, to, plotArea, work), result);
+                        this.getPixelDomain(plotArea, work);
+                        this.doFit_(work.from, work.to, this.toFitDomain(from, to, plotArea, work), result);
                         break;
                     case DChartCoordinateDirection.Y:
-                        this.doFit_(plotArea.height - padding.getBottom(), padding.getTop(), this.toFitRange(from, to, plotArea, work), result);
+                        this.getPixelRange(plotArea, work);
+                        this.doFit_(work.from, work.to, this.toFitRange(from, to, plotArea, work), result);
                         break;
                 }
             }
         };
+        DChartCoordinateBase.prototype.getPixelDomain = function (plotArea, result) {
+            var padding = plotArea.padding;
+            return result.set(padding.getLeft(), plotArea.width - padding.getRight());
+        };
+        DChartCoordinateBase.prototype.getPixelRange = function (plotArea, result) {
+            var padding = plotArea.padding;
+            return result.set(plotArea.height - padding.getBottom(), padding.getTop());
+        };
         DChartCoordinateBase.prototype.toFitDomain = function (from, to, plotArea, result) {
             if (from == null) {
                 from = this._from;
@@ -55807,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;
@@ -56045,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;
+                            }
                         }
                     }
                 }
@@ -56196,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;
+                            }
                         }
                     }
                 }