@mathstack/viz 1.1.4 → 2.0.3

package/src/lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/percent-over/percent-over.ts

@@ -0,0 +1,37 @@
+import { safeAssign } from '@mathstack/app-kit';
+import {
+  DomainPadding,
+  DomainPaddingType,
+  PaddedDomainArguments,
+} from '../domain-padding';
+import { PercentOverDomainPaddingOptions } from './percent-over-options';
+
+export class PercentOverDomainPadding
+  extends DomainPadding
+  implements PercentOverDomainPaddingOptions
+{
+  readonly percentOver: number;
+  readonly type: DomainPaddingType.percentOver;
+
+  constructor(options: PercentOverDomainPaddingOptions) {
+    super();
+    safeAssign(this, options);
+    this.type = DomainPaddingType.percentOver;
+  }
+
+  getPaddedValue(args: PaddedDomainArguments): number {
+    return this.getQuantitativeDomainMaxPercentOver(
+      args.value,
+      this.percentOver
+    );
+  }
+
+  private getQuantitativeDomainMaxPercentOver(
+    value: number,
+    percent: number
+  ): number {
+    let overValue = Math.abs(value) * (1 + percent);
+    if (value < 0) overValue = -overValue;
+    return overValue;
+  }
+}

package/{lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/pixel/pixel-options.d.ts → src/lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/pixel/pixel-options.ts}

@@ -1,3 +1,3 @@
-export interface PixelDomainPaddingOptions {
-    numPixels: number;
-}
+export interface PixelDomainPaddingOptions {
+  numPixels: number;
+}

package/src/lib/data-dimensions/continuous-quantitative/number-chart-position/domain-padding/pixel/pixel.ts

@@ -0,0 +1,73 @@
+import { safeAssign } from '@mathstack/app-kit';
+import { ScaleContinuousNumeric } from 'd3';
+import {
+  DomainPadding,
+  DomainPaddingType,
+  PaddedDomainArguments,
+} from '../domain-padding';
+import { PixelDomainPaddingOptions } from './pixel-options';
+
+export class PixelDomainPadding
+  extends DomainPadding
+  implements PixelDomainPaddingOptions
+{
+  readonly numPixels: number;
+  readonly type: DomainPaddingType.numPixels = DomainPaddingType.numPixels;
+
+  constructor(options: PixelDomainPaddingOptions) {
+    super();
+    safeAssign(this, options);
+    this.type = DomainPaddingType.numPixels;
+  }
+
+  getPaddedValue(args: PaddedDomainArguments): number {
+    let numPixels = this.numPixels;
+    if (args.dimensionRange[0] > args.dimensionRange[1]) {
+      // This covers the case when this is applied to the vertical axis
+      // On the vertical axis, the range is [highValue, lowValue], i.e. [100, 0]
+      numPixels = -1 * this.numPixels;
+    }
+    const value =
+      args.valueType === 'min'
+        ? args.unpaddedDomain[0]
+        : args.unpaddedDomain[1];
+    if (value === 0)
+      return args.valueType === 'min' ? value - numPixels : value + numPixels;
+    const adjustedPixelRange =
+      args.valueType === 'min' && args.unpaddedDomain[0] < 0
+        ? [args.dimensionRange[0] + numPixels, args.dimensionRange[1]]
+        : [args.dimensionRange[0], args.dimensionRange[1] - numPixels];
+    const scale = args.scaleFn(args.unpaddedDomain, adjustedPixelRange);
+    const targetVal =
+      args.valueType === 'min'
+        ? args.dimensionRange[0]
+        : args.dimensionRange[1];
+    return scale.invert(targetVal);
+  }
+
+  protected override getPaddedDomainForPositiveAndNegativeValues(
+    domainMinArgs: PaddedDomainArguments,
+    domainMaxArgs: PaddedDomainArguments,
+    unpaddedDomain: [number, number],
+    scaleFn: (
+      domain?: Iterable<number>,
+      range?: Iterable<number>
+    ) => ScaleContinuousNumeric<number, number>,
+    dimensionRange: [number, number]
+  ): [number, number] {
+    let adjustedPixelRange;
+    if (dimensionRange[0] < dimensionRange[1]) {
+      adjustedPixelRange = [
+        dimensionRange[0] + this.numPixels,
+        dimensionRange[1] - this.numPixels,
+      ];
+    } else {
+      adjustedPixelRange = [
+        dimensionRange[0] - this.numPixels,
+        dimensionRange[1] + this.numPixels,
+      ];
+    }
+    const scale = scaleFn(unpaddedDomain, adjustedPixelRange);
+    return [scale.invert(dimensionRange[0]), scale.invert(dimensionRange[1])];
+  }
+}