@wcardinal/wcardinal-ui 0.295.0 → 0.297.0

package/dist/wcardinal-ui.cjs.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
 
@@ -73263,6 +73263,41 @@ var DChartAxisBaseTickMinor = /** @class */ (function () {
     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;
@@ -73271,6 +73306,7 @@ var DChartAxisBaseTickContainer = /** @class */ (function () {
         this._minor = this.newMinor(parser, options);
         this._majorTicks = [];
         this._minorTicks = [];
+        this._work = new DChartRegionImpl(0, 0);
     }
     Object.defineProperty(DChartAxisBaseTickContainer.prototype, "major", {
         get: function () {
@@ -73310,54 +73346,86 @@ var DChartAxisBaseTickContainer = /** @class */ (function () {
         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;
@@ -73371,7 +73439,7 @@ var DChartAxisBaseTickContainer = /** @class */ (function () {
         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) {
@@ -73410,7 +73478,7 @@ var DChartAxisBaseTickContainer = /** @class */ (function () {
         }
         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;
@@ -73424,7 +73492,7 @@ var DChartAxisBaseTickContainer = /** @class */ (function () {
         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) {
@@ -73493,8 +73561,8 @@ var DChartAxisBaseTickContainer = /** @class */ (function () {
     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();
@@ -73925,41 +73993,6 @@ var DChartCoordinateTransformMarkImpl = /** @class */ (function () {
     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
@@ -74031,18 +74064,27 @@ var DChartCoordinateBase = /** @class */ (function () {
         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;
@@ -74123,8 +74165,8 @@ var DChartCoordinateBase = /** @class */ (function () {
     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;
@@ -74361,65 +74403,63 @@ var DChartCoordinateLinearTick = /** @class */ (function () {
             }
         }
     };
-    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;
+                        }
                     }
                 }
             }
@@ -74512,64 +74552,63 @@ var DChartCoordinateLogTick = /** @class */ (function () {
             }
         }
     };
-    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;
+                        }
                     }
                 }
             }