cx 26.7.6 → 26.8.0

package/dist/widgets.js

@@ -17901,7 +17901,12 @@ class Grid extends ContainerBase$1 {
 				let line = instance.row[`line${l}`];
 				let sortColumn = line && line.columns && line.columns.find((c) => (c.sortField || c.field) == sortField);
 				if (sortColumn) {
-					data.sorters[0].value = isDefined(sortColumn.sortValue) ? sortColumn.sortValue : sortColumn.value;
+					// precedence: sortValue > sortField > value > field
+					data.sorters[0].value = isDefined(sortColumn.sortValue)
+						? sortColumn.sortValue
+						: sortColumn.sortField
+							? undefined
+							: sortColumn.value;
 					data.sorters[0].comparer = sortColumn.comparer;
 					data.sorters[0].sortOptions = sortColumn.sortOptions;
 					break;
@@ -18209,7 +18214,11 @@ class Grid extends ContainerBase$1 {
 							mods.push("sortable");
 							let sorter = data.sorters && data.sorters[0];
 							let sortColumnField = hdwidget.sortField || hdwidget.field;
-							let sortColumnValue = isDefined(hdwidget.sortValue) ? hdwidget.sortValue : hdwidget.value;
+							let sortColumnValue = isDefined(hdwidget.sortValue)
+								? hdwidget.sortValue
+								: hdwidget.sortField
+									? undefined
+									: hdwidget.value;
 							// a sort is identified by its (field, value selector) pair, so columns
 							// sorting by the same field through different value selectors don't both match
 							let sorted =
@@ -18386,7 +18395,9 @@ class Grid extends ContainerBase$1 {
 		let { data } = instance;
 		let header = column.components[`header${headerLine + 1}`];
 		let field = column.sortField || column.field;
-		let value = isDefined(column.sortValue) ? column.sortValue : column.value;
+		// precedence: sortValue > sortField > value > field; the comparer prefers value
+		// over field, so value must not be attached when an explicit sortField is set
+		let value = isDefined(column.sortValue) ? column.sortValue : column.sortField ? undefined : column.value;
 		let comparer = column.comparer;
 		let sortOptions = column.sortOptions;
 		if (header && header.allowSorting && column.sortable && (field || isDefined(value))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cx",
-  "version": "26.7.6",
+  "version": "26.8.0",
   "description": "Advanced JavaScript UI framework for admin and dashboard applications with ready to use grid, form and chart components.",
   "exports": {
     "./data": {

package/src/charts/LineGraph.tsx

@@ -42,10 +42,14 @@ export interface LineGraphConfig extends WidgetConfig {
    /** Indicate that values should be stacked on top of the other values. Default value is `false`. */
    stacked?: BooleanProp;
 
-   /** Set to `true` to enable smooth (curved) line rendering. */
+   /**
+    * Set to `true` to enable smooth (curved) line rendering. Uses monotone cubic
+    * interpolation which never overshoots the actual data range, i.e. the curve
+    * stays within the vertical bounds of the data.
+    */
    smooth?: BooleanProp;
 
-   /** Controls the curvature of smooth lines. Value should be between 0 and 0.4. Default is 0.05. */
+   /** @deprecated Smoothing is based on monotone cubic interpolation and its curvature is not configurable. This property is ignored. */
    smoothingRatio?: NumberProp;
 
    /** Name of the horizontal axis. Default value is `x`. */
@@ -128,7 +132,6 @@ export class LineGraph extends Widget {
    declare legendShape: string;
    declare stack: string;
    declare smooth: boolean;
-   declare smoothingRatio: number;
 
    constructor(config: LineGraphConfig) {
       super(config);
@@ -159,7 +162,6 @@ export class LineGraph extends Widget {
          stack: undefined,
          stacked: undefined,
          smooth: undefined,
-         smoothingRatio: undefined,
       });
    }
 
@@ -168,11 +170,6 @@ export class LineGraph extends Widget {
 
       if (data.name && !data.colorName) data.colorName = data.name;
 
-      if (data.smooth && data.smoothingRatio != null) {
-         if (data.smoothingRatio < 0) data.smoothingRatio = 0;
-         if (data.smoothingRatio > 0.4) data.smoothingRatio = 0.4;
-      }
-
       super.prepareData(context, instance);
    }
 
@@ -299,19 +296,17 @@ export class LineGraph extends Widget {
       };
 
       let line: React.ReactNode, area: React.ReactNode;
-      const r = data.smoothingRatio;
 
       let linePath = "";
       if (data.line) {
          lineSpans.forEach((span) => {
-            span.forEach((p, i) => {
-               linePath +=
-                  i == 0
-                     ? `M ${p.x} ${p.y}`
-                     : !data.smooth || span.length < 2
-                       ? `L ${p.x} ${p.y}`
-                       : this.getCurvedPathSegment(p, span, i - 1, i - 2, i - 1, i + 1, r);
-            });
+            if (span.length == 0) return;
+            linePath += `M ${span[0].x} ${span[0].y}`;
+            if (data.smooth && span.length >= 2) linePath += this.getMonotoneSpanPath(span, "y");
+            else
+               span.forEach((p, i) => {
+                  if (i > 0) linePath += `L ${p.x} ${p.y}`;
+               });
          });
 
          line = (
@@ -326,34 +321,20 @@ export class LineGraph extends Widget {
       if (data.area) {
          let areaPath = "";
          lineSpans.forEach((span) => {
-            let closePath = "";
-            span.forEach((p, i) => {
-               let segment = "";
-               if (i == 0) {
-                  segment = `M ${p.x} ${p.y}`;
-
-                  // closing point
-                  closePath =
-                     !data.smooth || span.length < 2
-                        ? `L ${p.x} ${p.y0}`
-                        : this.getCurvedPathSegment(p, span, i + 1, i + 2, i + 1, i - 1, r, "y0");
-               } else {
-                  if (!data.smooth) {
-                     segment = `L ${p.x} ${p.y}`;
-                     closePath = `L ${p.x} ${p.y0}` + closePath;
-                  } else {
-                     segment = this.getCurvedPathSegment(p, span, i - 1, i - 2, i - 1, i + 1, r, "y");
-
-                     // closing point
-                     if (i < span.length - 1)
-                        closePath = this.getCurvedPathSegment(p, span, i + 1, i + 2, i + 1, i - 1, r, "y0") + closePath;
-                  }
-               }
-               areaPath += segment;
-            });
-
-            areaPath += `L ${span[span.length - 1].x} ${span[span.length - 1].y0}`;
-            areaPath += closePath;
+            if (span.length == 0) return;
+            let last = span[span.length - 1];
+            areaPath += `M ${span[0].x} ${span[0].y}`;
+            if (data.smooth && span.length >= 2) {
+               areaPath += this.getMonotoneSpanPath(span, "y");
+               areaPath += `L ${last.x} ${last.y0}`;
+               areaPath += this.getMonotoneSpanPath(span, "y0", true);
+            } else {
+               span.forEach((p, i) => {
+                  if (i > 0) areaPath += `L ${p.x} ${p.y}`;
+               });
+               areaPath += `L ${last.x} ${last.y0}`;
+               for (let i = span.length - 2; i >= 0; i--) areaPath += `L ${span[i].x} ${span[i].y0}`;
+            }
             areaPath += "Z";
          });
 
@@ -374,61 +355,63 @@ export class LineGraph extends Widget {
       );
    }
 
-   getCurvedPathSegment(
-      p: LinePoint,
-      points: LinePoint[],
-      i1: number,
-      i2: number,
-      j1: number,
-      j2: number,
-      r: number,
-      yField: "y" | "y0" = "y",
-   ): string {
-      const [sx, sy] = this.getControlPoint({ cp: points[i1], pp: points[i2], r, np: p, yField });
-      const [ex, ey] = this.getControlPoint({ cp: p, pp: points[j1], np: points[j2], r, reverse: true, yField });
-
-      return `C ${sx} ${sy}, ${ex} ${ey}, ${p.x} ${p[yField]}`;
-   }
+   // Fritsch-Carlson monotone cubic interpolation. Tangents are limited so the
+   // curve between two points never leaves their vertical range (no overshoot).
+   getMonotoneTangents(span: LinePoint[], yField: "y" | "y0"): number[] {
+      const n = span.length;
+      const m: number[] = new Array(n).fill(0);
+      if (n < 2) return m;
 
-   getControlPoint({
-      cp,
-      pp,
-      np,
-      r,
-      reverse,
-      yField = "y",
-   }: {
-      cp: LinePoint;
-      pp: LinePoint | undefined;
-      np: LinePoint | undefined;
-      r: number;
-      reverse?: boolean;
-      yField?: "y" | "y0";
-   }): [number, number] {
-      // When 'current' is the first or last point of the array 'previous' or 'next' don't exist. Replace with 'current'.
-      const p = pp || cp;
-      const n = np || cp;
-
-      // Properties of the opposed-line
-      let { angle, length } = this.getLineInfo(p.x, p[yField], n.x, n[yField]);
-      // If it is end-control-point, add PI to the angle to go backward
-      angle = angle + (reverse ? Math.PI : 0);
-      length = length * r;
-      // The control point position is relative to the current point
-      const x = cp.x + Math.cos(angle) * length;
-      const y = cp[yField] + Math.sin(angle) * length;
-      return [x, y];
-   }
+      const secant = (i: number): number => {
+         const h = span[i + 1].x - span[i].x;
+         return h != 0 ? (span[i + 1][yField] - span[i][yField]) / h : 0;
+      };
 
-   getLineInfo(p1x: number, p1y: number, p2x: number, p2y: number): { length: number; angle: number } {
-      const lengthX = p2x - p1x;
-      const lengthY = p2y - p1y;
+      if (n == 2) {
+         m[0] = m[1] = secant(0);
+         return m;
+      }
 
-      return {
-         length: Math.sqrt(Math.pow(lengthX, 2) + Math.pow(lengthY, 2)),
-         angle: Math.atan2(lengthY, lengthX),
-      };
+      for (let i = 1; i < n - 1; i++) {
+         const h0 = span[i].x - span[i - 1].x;
+         const h1 = span[i + 1].x - span[i].x;
+         const s0 = secant(i - 1);
+         const s1 = secant(i);
+         const p = (s0 * h1 + s1 * h0) / (h0 + h1);
+         m[i] = (Math.sign(s0) + Math.sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;
+      }
+
+      const hFirst = span[1].x - span[0].x;
+      m[0] = hFirst != 0 ? (3 * secant(0) - m[1]) / 2 : m[1];
+
+      const hLast = span[n - 1].x - span[n - 2].x;
+      m[n - 1] = hLast != 0 ? (3 * secant(n - 2) - m[n - 2]) / 2 : m[n - 2];
+
+      return m;
+   }
+
+   // Emits cubic bezier segments for the whole span using monotone tangents.
+   // Assumes the path cursor is at the first (or last, when reversed) span point.
+   getMonotoneSpanPath(span: LinePoint[], yField: "y" | "y0", reverse?: boolean): string {
+      const m = this.getMonotoneTangents(span, yField);
+      let path = "";
+      if (!reverse)
+         for (let i = 1; i < span.length; i++) {
+            const p0 = span[i - 1];
+            const p1 = span[i];
+            const dx = (p1.x - p0.x) / 3;
+            path += `C ${p0.x + dx} ${p0[yField] + dx * m[i - 1]}, ${p1.x - dx} ${p1[yField] - dx * m[i]}, ${p1.x} ${p1[yField]}`;
+         }
+      else
+         for (let i = span.length - 1; i > 0; i--) {
+            const p0 = span[i - 1];
+            const p1 = span[i];
+            const dx = (p1.x - p0.x) / 3;
+            path += `C ${p1.x - dx} ${p1[yField] - dx * m[i]}, ${p0.x + dx} ${p0[yField] + dx * m[i - 1]}, ${p0.x} ${p0[yField]}`;
+         }
+      return path;
    }
+
 }
 
 LineGraph.prototype.xAxis = "x";
@@ -449,7 +432,6 @@ LineGraph.prototype.stack = "stack";
 LineGraph.prototype.hiddenBase = false;
 
 LineGraph.prototype.smooth = false;
-LineGraph.prototype.smoothingRatio = 0.05;
 LineGraph.prototype.styled = true;
 
 Widget.alias("line-graph", LineGraph);

package/src/charts/axis/NumericAxis.spec.ts

@@ -0,0 +1,40 @@
+import assert from "assert";
+import { NumericScale } from "./NumericScale";
+
+// Build a scale with a value range of [0, 100] mapped onto a wider pixel range
+// [0, 500] (factor ~5), so a value's pixel differs substantially from the value.
+function makeScale() {
+   const scale = new NumericScale();
+   scale.reset(0, 100, 1, [[1, 2, 5, 10]], 25, 0, 40, 0, false, false, 0, 0);
+   scale.measure(0, 500);
+   return scale;
+}
+
+describe("NumericScale.trackValue", function () {
+   it("maps a pixel back to its value when unconstrained", function () {
+      const scale = makeScale();
+      const px = scale.map(50); // pixel for the mid-range value 50 (~250)
+      assert.ok(Math.abs(scale.trackValue(px, 0, false) - 50) < 1e-6);
+   });
+
+   // Regression guard: `constrain = true` must clamp the computed value, not the
+   // raw pixel coordinate. The original bug was:
+   //     if (constrain) value = this.constrainValue(v);   // v is the pixel
+   // which, because the pixel range is wider than the value range, wrongly
+   // clamped an in-range value whose pixel landed outside [min, max]. It should
+   // clamp `value`, like TimeScale.trackValue does.
+   it("constrains the returned value, not the pixel", function () {
+      const scale = makeScale();
+      const value = 50; // squarely inside [0, 100]
+      const px = scale.map(value); // ~250 px, i.e. outside [0, 100]
+
+      const constrained = scale.trackValue(px, 0, true);
+
+      // 50 is already inside the axis range, so constraining must leave it be.
+      assert.ok(
+         Math.abs(constrained - 50) < 1e-6,
+         `expected trackValue(px, 0, true) to constrain the value to 50, but got ${constrained} ` +
+            `(the pixel ${px} was clamped instead of the value)`,
+      );
+   });
+});

package/src/charts/axis/NumericAxis.tsx

@@ -2,12 +2,10 @@
 
 import { Axis, AxisConfig, AxisInstance } from "./Axis";
 import { VDOM } from "../../ui/Widget";
-import { Stack } from "./Stack";
+import { NumericScale } from "./NumericScale";
 import { Format } from "../../util/Format";
-import { isNumber } from "../../util/isNumber";
 import { RenderingContext } from "../../ui/RenderingContext";
 import { NumberProp, BooleanProp, StringProp } from "../../ui/Prop";
-import { Console } from "../../util/Console";
 
 export interface NumericAxisConfig extends AxisConfig {
    /** Minimum value. */
@@ -148,290 +146,3 @@ NumericAxis.prototype.minLabelTickSize = 0;
 NumericAxis.prototype.minTickStep = 0;
 
 Axis.alias("numeric", NumericAxis);
-
-class NumericScale {
-   min: number;
-   max: number;
-   snapToTicks: number;
-   tickDivisions: number[][];
-   minLabelDistance: number;
-   minLabelTickSize: number;
-   minTickDistance: number;
-   minTickStep: number;
-   tickSizes: number[];
-   normalized: boolean;
-   inverted: boolean;
-   minValue?: number;
-   maxValue?: number;
-   minValuePadded: number;
-   maxValuePadded: number;
-   stacks: Record<string, Stack>;
-   lowerDeadZone: number;
-   upperDeadZone: number;
-   origin: number;
-   scale: { factor: number; min: number; max: number; minPadding: number; maxPadding: number };
-   a: number;
-   b: number;
-   shouldUpdate: boolean;
-
-   reset(
-      min: number,
-      max: number,
-      snapToTicks: number,
-      tickDivisions: number[][],
-      minTickDistance: number,
-      minTickStep: number,
-      minLabelDistance: number,
-      minLabelTickSize: number,
-      normalized: boolean,
-      inverted: boolean,
-      lowerDeadZone: number,
-      upperDeadZone: number,
-   ): void {
-      this.min = min;
-      this.max = max;
-      this.snapToTicks = snapToTicks;
-      this.tickDivisions = tickDivisions;
-      this.minLabelDistance = minLabelDistance;
-      this.minLabelTickSize = minLabelTickSize;
-      this.minTickDistance = minTickDistance;
-      this.minTickStep = minTickStep;
-      this.tickSizes = [];
-      this.normalized = normalized;
-      this.inverted = inverted;
-      delete this.minValue;
-      delete this.maxValue;
-      this.stacks = {};
-      this.lowerDeadZone = lowerDeadZone || 0;
-      this.upperDeadZone = upperDeadZone || 0;
-   }
-
-   map(v: number, offset: number = 0): number {
-      return this.origin + (v + offset - this.scale.min + this.scale.minPadding) * this.scale.factor;
-   }
-
-   decodeValue(n: number): number {
-      return n;
-   }
-
-   encodeValue(v: number): number {
-      return v;
-   }
-
-   constrainValue(v: number): number {
-      return Math.max(this.scale.min, Math.min(this.scale.max, v));
-   }
-
-   trackValue(v: number, offset: number = 0, constrain: boolean = false): number {
-      let value = (v - this.origin) / this.scale.factor - offset + this.scale.min - this.scale.minPadding;
-      if (constrain) value = this.constrainValue(v);
-      return value;
-   }
-
-   hash(): any {
-      let r: any = {
-         origin: this.origin,
-         factor: this.scale.factor,
-         min: this.scale.min,
-         max: this.scale.max,
-         minPadding: this.scale.minPadding,
-         maxPadding: this.scale.maxPadding,
-      };
-      r.stacks = Object.keys(this.stacks)
-         .map((s) => this.stacks[s].info?.join(","))
-         .join(":");
-      return r;
-   }
-
-   isSame(x: any): boolean {
-      let hash = this.hash();
-      let same = x && !Object.keys(hash).some((k) => x[k] !== hash[k]);
-      this.shouldUpdate = !same;
-      return same;
-   }
-
-   measure(a: number, b: number): void {
-      this.a = a;
-      this.b = b;
-
-      if (this.minValue != null && this.min == null) this.min = this.minValue;
-      if (this.maxValue != null && this.max == null) this.max = this.maxValue;
-
-      for (let s in this.stacks) {
-         let info = this.stacks[s].measure(this.normalized);
-         let [min, max] = info;
-         if (this.min == null || min < this.min) this.min = min;
-         if (this.max == null || max > this.max) this.max = max;
-         this.stacks[s].info = info;
-      }
-
-      if (this.min == null) this.min = 0;
-      if (this.max == null) this.max = this.normalized ? 1 : 100;
-
-      if (this.min == this.max) {
-         if (this.min == 0) {
-            this.min = -1;
-            this.max = 1;
-         } else {
-            let delta = Math.abs(this.min) * 0.1;
-            this.min -= delta;
-            this.max += delta;
-         }
-      }
-
-      this.origin = this.inverted ? this.b : this.a;
-
-      this.scale = this.getScale();
-
-      this.calculateTicks();
-   }
-
-   getScale(tickSizes?: number[]): { factor: number; min: number; max: number; minPadding: number; maxPadding: number } {
-      let { min, max } = this;
-      let smin = min;
-      let smax = max;
-
-      let tickSize;
-      if (tickSizes && isNumber(this.snapToTicks) && tickSizes.length > 0) {
-         tickSize = tickSizes[Math.min(tickSizes.length - 1, this.snapToTicks)];
-         smin = Math.floor(smin / tickSize) * tickSize;
-         smax = Math.ceil(smax / tickSize) * tickSize;
-      } else {
-         if (this.minValue === min) smin = this.minValuePadded;
-         if (this.maxValue === max) smax = this.maxValuePadded;
-      }
-
-      let minPadding = this.minValue === min ? Math.max(0, smin - this.minValuePadded) : 0;
-      let maxPadding = this.maxValue === max ? Math.max(0, this.maxValuePadded - smax) : 0;
-
-      let sign = this.b > this.a ? 1 : -1;
-
-      let factor =
-         smin < smax
-            ? (Math.abs(this.b - this.a) - this.lowerDeadZone - this.upperDeadZone) /
-              (smax - smin + minPadding + maxPadding)
-            : 0;
-
-      if (factor < 0) factor = 0;
-
-      if (factor > 0 && (this.lowerDeadZone > 0 || this.upperDeadZone > 0)) {
-         while (factor * (min - smin) < this.lowerDeadZone) smin -= this.lowerDeadZone / factor;
-
-         while (factor * (smax - max) < this.upperDeadZone) smax += this.upperDeadZone / factor;
-
-         if (tickSize! > 0 && isNumber(this.snapToTicks)) {
-            smin = Math.floor(smin / tickSize!) * tickSize!;
-            smax = Math.ceil(smax / tickSize!) * tickSize!;
-            minPadding = this.minValue === min ? Math.max(0, smin - this.minValuePadded) : 0;
-            maxPadding = this.maxValue === max ? Math.max(0, this.maxValuePadded - smax) : 0;
-         }
-
-         factor = smin < smax ? Math.abs(this.b - this.a) / (smax - smin + minPadding + maxPadding) : 0;
-      }
-
-      return {
-         factor: sign * (this.inverted ? -factor : factor),
-         min: smin,
-         max: smax,
-         minPadding,
-         maxPadding,
-      };
-   }
-
-   acknowledge(value: number, width: number = 0, offset: number = 0): void {
-      if (value == null) return;
-
-      if (this.minValue == null || value < this.minValue) {
-         this.minValue = value;
-         this.minValuePadded = value + offset - width / 2;
-      }
-      if (this.maxValue == null || value > this.maxValue) {
-         this.maxValue = value;
-         this.maxValuePadded = value + offset + width / 2;
-      }
-   }
-
-   getStack(name: string): Stack {
-      let s = this.stacks[name];
-      if (!s) s = this.stacks[name] = new Stack();
-      return s;
-   }
-
-   stacknowledge(name: string, ordinal: any, value: any): any {
-      return this.getStack(name).acknowledge(ordinal, value);
-   }
-
-   stack(name: string, ordinal: any, value: any): number | null {
-      let v = this.getStack(name).stack(ordinal, value);
-      return v != null ? this.map(v) : null;
-   }
-
-   findTickSize(minPxDist: number): number | undefined {
-      return this.tickSizes.find((a) => a >= this.minLabelTickSize && a * Math.abs(this.scale.factor) >= minPxDist);
-   }
-
-   getTickSizes(): number[] {
-      return this.tickSizes;
-   }
-
-   calculateTicks(): void {
-      let dist = this.minLabelDistance / Math.abs(this.scale.factor);
-      let unit = Math.pow(10, Math.floor(Math.log10(dist)));
-
-      let bestLabelDistance = Infinity;
-      let bestTicks: number[] = [];
-      let bestScale = this.scale;
-
-      for (let i = 0; i < this.tickDivisions.length; i++) {
-         let divs = this.tickDivisions[i];
-         let tickSizes = divs.filter((ts) => ts >= this.minTickStep).map((ts) => ts * unit);
-         let scale = this.getScale(tickSizes);
-         tickSizes.forEach((size, level) => {
-            let labelDistance = size * Math.abs(scale.factor);
-            if (labelDistance >= this.minLabelDistance && labelDistance < bestLabelDistance) {
-               bestScale = scale;
-               bestTicks = tickSizes;
-               bestLabelDistance = labelDistance;
-            }
-         });
-      }
-      this.scale = bestScale;
-      this.tickSizes = bestTicks.filter(
-         (ts) => ts >= this.minTickStep && ts * Math.abs(bestScale.factor) >= this.minTickDistance,
-      );
-      if (this.tickSizes.length > 0) {
-         let max = this.tickSizes[this.tickSizes.length - 1];
-         this.tickSizes.push(2 * max);
-         this.tickSizes.push(5 * max);
-         this.tickSizes.push(10 * max);
-         let min = this.tickSizes[0];
-         let minDist = min * Math.abs(bestScale.factor);
-         if (min / 10 >= this.minTickStep && minDist / 10 >= this.minTickDistance) this.tickSizes.splice(0, 0, min / 10);
-         else if (min / 5 >= this.minTickStep && minDist / 5 >= this.minTickDistance) this.tickSizes.splice(0, 0, min / 5);
-         else if (min / 2 >= this.minTickStep && minDist / 2 >= this.minTickDistance) this.tickSizes.splice(0, 0, min / 2);
-      }
-   }
-
-   getTicks(tickSizes: number[]): number[][] {
-      return tickSizes.map((size) => {
-         let start = Math.ceil((this.scale.min - this.scale.minPadding) / size);
-         let end = Math.floor((this.scale.max + this.scale.maxPadding) / size);
-         let result: number[] = [];
-         for (let i = start; i <= end; i++) result.push(i * size + 0);
-         return result;
-      });
-   }
-
-   mapGridlines(): number[] {
-      let size = this.tickSizes[0];
-      let start = Math.ceil((this.scale.min - this.scale.minPadding) / size);
-      let end = Math.floor((this.scale.max + this.scale.maxPadding) / size);
-      let result: number[] = [];
-      for (let i = start; i <= end; i++) result.push(this.map(i * size));
-      return result;
-   }
-
-   book(): void {
-      Console.warn("NumericAxis does not support the autoSize flag for column and bar graphs.");
-   }
-}