poetry-charts 0.0.2

data/vendor/d3-kernel/recharts/util/scale/getNiceTickValues.ts

@@ -0,0 +1,310 @@
+/**
+ * @fileOverview calculate tick values of scale
+ * @author xile611, arcthur
+ * @date 2015-09-17
+ */
+import Decimal from 'decimal.js-light';
+import { getDigitCount, rangeStep } from './util/arithmetic';
+import { NumberDomain } from '../types';
+import { NiceTicksAlgorithm } from '../../state/cartesianAxisSlice';
+
+/**
+ * Calculate a interval of a minimum value and a maximum value
+ *
+ * @param  {Number} min       The minimum value
+ * @param  {Number} max       The maximum value
+ * @return {Array} An interval
+ */
+export const getValidInterval = ([min, max]: [number, number]): [number, number] => {
+  let [validMin, validMax] = [min, max];
+
+  // exchange
+  if (min > max) {
+    [validMin, validMax] = [max, min];
+  }
+
+  return [validMin, validMax];
+};
+
+/**
+ * Calculate the step which is easy to understand between ticks, like 10, 20, 25
+ *
+ * @param  roughStep        The rough step calculated by dividing the difference by the tickCount
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step which is easy to understand between two ticks
+ */
+export const getAdaptiveStep = (roughStep: Decimal, allowDecimals: boolean, correctionFactor: number) => {
+  if (roughStep.lte(0)) {
+    return new Decimal(0);
+  }
+
+  const digitCount = getDigitCount(roughStep.toNumber());
+  // The ratio between the rough step and the smallest number which has a bigger
+  // order of magnitudes than the rough step
+  const digitCountValue = new Decimal(10).pow(digitCount);
+  const stepRatio = roughStep.div(digitCountValue);
+  // When an integer and a float multiplied, the accuracy of result may be wrong
+  const stepRatioScale = digitCount !== 1 ? 0.05 : 0.1;
+  const amendStepRatio = new Decimal(Math.ceil(stepRatio.div(stepRatioScale).toNumber()))
+    .add(correctionFactor)
+    .mul(stepRatioScale);
+
+  const formatStep = amendStepRatio.mul(digitCountValue);
+
+  return allowDecimals ? new Decimal(formatStep.toNumber()) : new Decimal(Math.ceil(formatStep.toNumber()));
+};
+
+type StepFunction = (roughStep: Decimal, allowDecimals: boolean, correctionFactor: number) => Decimal;
+
+/**
+ * The snap125 step algorithm snaps to nice numbers (1, 2, 2.5, 5) at each
+ * order of magnitude, producing human-friendly tick intervals like
+ * 0, 5, 10, 15, 20 instead of 0, 4, 8, 12, 16.
+ *
+ * This is opt-in and can be enabled via the `niceTicks` prop on axis components.
+ *
+ * @param  roughStep        The rough step calculated by dividing the difference by the tickCount
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step which is easy to understand between two ticks
+ */
+export const getSnap125Step: StepFunction = (roughStep: Decimal, allowDecimals: boolean, correctionFactor: number) => {
+  if (roughStep.lte(0)) {
+    return new Decimal(0);
+  }
+
+  const NICE_STEPS = [1, 2, 2.5, 5];
+
+  const roughNum = roughStep.toNumber();
+  const exponent = Math.floor(new Decimal(roughNum).abs().log(10).toNumber());
+  let magnitude = new Decimal(10).pow(exponent);
+
+  // normalized is in the range [1, 10)
+  const normalized = roughStep.div(magnitude).toNumber();
+
+  // Find the smallest nice step >= normalized (ceiling)
+  let niceIdx = NICE_STEPS.findIndex(s => s >= normalized - 1e-10);
+  if (niceIdx === -1) {
+    // normalized > 5 (e.g. 7.3), move to next order of magnitude
+    magnitude = magnitude.mul(10);
+    niceIdx = 0;
+  }
+
+  // Apply correction factor by stepping through the nice number sequence
+  niceIdx += correctionFactor;
+  if (niceIdx >= NICE_STEPS.length) {
+    const extraMag = Math.floor(niceIdx / NICE_STEPS.length);
+    niceIdx %= NICE_STEPS.length;
+    magnitude = magnitude.mul(new Decimal(10).pow(extraMag));
+  }
+
+  const niceStep = NICE_STEPS[niceIdx] ?? 1;
+  const formatStep = new Decimal(niceStep).mul(magnitude);
+
+  return allowDecimals ? formatStep : new Decimal(Math.ceil(formatStep.toNumber()));
+};
+
+/**
+ * calculate the ticks when the minimum value equals to the maximum value
+ *
+ * @param  value         The minimum value which is also the maximum value
+ * @param  tickCount     The count of ticks
+ * @param  allowDecimals Allow the ticks to be decimals or not
+ * @return array of ticks
+ */
+export const getTickOfSingleValue = (value: number, tickCount: number, allowDecimals: boolean): Array<number> => {
+  let step: Decimal = new Decimal(1);
+  // calculate the middle value of ticks
+  let middle = new Decimal(value);
+
+  if (!middle.isint() && allowDecimals) {
+    const absVal = Math.abs(value);
+
+    if (absVal < 1) {
+      // The step should be a float number when the difference is smaller than 1
+      step = new Decimal(10).pow(getDigitCount(value) - 1);
+
+      middle = new Decimal(Math.floor(middle.div(step).toNumber())).mul(step);
+    } else if (absVal > 1) {
+      // Return the maximum integer which is smaller than 'value' when 'value' is greater than 1
+      middle = new Decimal(Math.floor(value));
+    }
+  } else if (value === 0) {
+    middle = new Decimal(Math.floor((tickCount - 1) / 2));
+  } else if (!allowDecimals) {
+    middle = new Decimal(Math.floor(value));
+  }
+
+  const middleIndex = Math.floor((tickCount - 1) / 2);
+  const ticks: Array<number> = [];
+
+  for (let i = 0; i < tickCount; i++) {
+    ticks.push(middle.add(new Decimal(i - middleIndex).mul(step)).toNumber());
+  }
+
+  return ticks;
+};
+
+/**
+ * Calculate the step
+ *
+ * @param  min              The minimum value of an interval
+ * @param  max              The maximum value of an interval
+ * @param  tickCount        The count of ticks
+ * @param  allowDecimals    Allow the ticks to be decimals or not
+ * @param  correctionFactor A correction factor
+ * @return The step, minimum value of ticks, maximum value of ticks
+ */
+export const calculateStep = (
+  min: number,
+  max: number,
+  tickCount: number,
+  allowDecimals: boolean,
+  correctionFactor: number = 0,
+  stepFn: StepFunction = getAdaptiveStep,
+): {
+  step: Decimal;
+  tickMin: Decimal;
+  tickMax: Decimal;
+} => {
+  // dirty hack (for recharts' test)
+  if (!Number.isFinite((max - min) / (tickCount - 1))) {
+    return {
+      step: new Decimal(0),
+      tickMin: new Decimal(0),
+      tickMax: new Decimal(0),
+    };
+  }
+
+  // The step which is easy to understand between two ticks
+  const step = stepFn(new Decimal(max).sub(min).div(tickCount - 1), allowDecimals, correctionFactor);
+
+  // A medial value of ticks
+  let middle;
+
+  // When 0 is inside the interval, 0 should be a tick
+  if (min <= 0 && max >= 0) {
+    middle = new Decimal(0);
+  } else {
+    // calculate the middle value
+    middle = new Decimal(min).add(max).div(2);
+    // minus modulo value
+    middle = middle.sub(new Decimal(middle).mod(step));
+  }
+
+  let belowCount = Math.ceil(middle.sub(min).div(step).toNumber());
+  let upCount = Math.ceil(new Decimal(max).sub(middle).div(step).toNumber());
+  const scaleCount = belowCount + upCount + 1;
+
+  if (scaleCount > tickCount) {
+    // When more ticks need to cover the interval, step should be bigger.
+    return calculateStep(min, max, tickCount, allowDecimals, correctionFactor + 1, stepFn);
+  }
+  if (scaleCount < tickCount) {
+    // When less ticks can cover the interval, we should add some additional ticks
+    upCount = max > 0 ? upCount + (tickCount - scaleCount) : upCount;
+    belowCount = max > 0 ? belowCount : belowCount + (tickCount - scaleCount);
+  }
+
+  return {
+    step,
+    tickMin: middle.sub(new Decimal(belowCount).mul(step)),
+    tickMax: middle.add(new Decimal(upCount).mul(step)),
+  };
+};
+
+/**
+ * Calculate the ticks of an interval. Ticks can appear outside the interval
+ * if it makes them more rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount     The count of ticks
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @param niceTicksMode The algorithm to use for calculating nice ticks.
+ * @return array of ticks
+ */
+export const getNiceTickValues = (
+  [min, max]: NumberDomain,
+  tickCount = 6,
+  allowDecimals = true,
+  niceTicksMode: NiceTicksAlgorithm = 'auto',
+): number[] => {
+  // More than two ticks should be return
+  const count = Math.max(tickCount, 2);
+  const [cormin, cormax] = getValidInterval([min, max]);
+
+  if (cormin === -Infinity || cormax === Infinity) {
+    const values: Array<number> =
+      cormax === Infinity
+        ? [cormin, ...Array(tickCount - 1).fill(Infinity)]
+        : [...Array(tickCount - 1).fill(-Infinity), cormax];
+
+    return min > max ? values.reverse() : values;
+  }
+
+  if (cormin === cormax) {
+    return getTickOfSingleValue(cormin, tickCount, allowDecimals);
+  }
+
+  const stepFn = niceTicksMode === 'snap125' ? getSnap125Step : getAdaptiveStep;
+
+  // Get the step between two ticks
+  const { step, tickMin, tickMax } = calculateStep(cormin, cormax, count, allowDecimals, 0, stepFn);
+
+  const values = rangeStep(tickMin, tickMax.add(new Decimal(0.1).mul(step)), step);
+
+  return min > max ? values.reverse() : values;
+};
+
+/**
+ * Calculate the ticks of an interval.
+ * Ticks will be constrained to the interval [min, max] even if it makes them less rounded and nice.
+ *
+ * @param tuple of [min,max] min: The minimum value, max: The maximum value
+ * @param tickCount     The count of ticks. This function may return less than tickCount ticks if the interval is too small.
+ * @param allowDecimals Allow the ticks to be decimals or not
+ * @param niceTicksMode          The algorithm to use for calculating nice ticks. See {@link NiceTicksAlgorithm}.
+ * @return array of ticks
+ */
+export const getTickValuesFixedDomain = (
+  [min, max]: NumberDomain,
+  tickCount: number,
+  allowDecimals = true,
+  niceTicksMode: NiceTicksAlgorithm = 'auto',
+) => {
+  // More than two ticks should be return
+  const [cormin, cormax] = getValidInterval([min, max]);
+
+  if (cormin === -Infinity || cormax === Infinity) {
+    return [min, max];
+  }
+
+  if (cormin === cormax) {
+    return [cormin];
+  }
+
+  const stepFn = niceTicksMode === 'snap125' ? getSnap125Step : getAdaptiveStep;
+  const count = Math.max(tickCount, 2);
+  const step = stepFn(new Decimal(cormax).sub(cormin).div(count - 1), allowDecimals, 0);
+  let values = [...rangeStep(new Decimal(cormin), new Decimal(cormax), step), cormax];
+
+  if (allowDecimals === false) {
+    /*
+     * allowDecimals is false means that we want to have integer ticks.
+     * The step is guaranteed to be an integer in the code above which is great start
+     * but when the first step is not an integer, it will start stepping from a decimal value anyway.
+     * So we need to round all the values to integers after the fact.
+     * The domain boundary (cormax) is appended after the rangeStep values. When
+     * cormax rounds down to the same integer as the last rangeStep value, we end up
+     * with a duplicate trailing tick. Remove it.
+     */
+    values = values.map(value => Math.round(value));
+    const last = values.length - 1;
+    if (last > 0 && values[last] === values[last - 1]) {
+      values = values.slice(0, last);
+    }
+  }
+
+  return min > max ? values.reverse() : values;
+};

data/vendor/d3-kernel/recharts/util/scale/util/arithmetic.ts

@@ -0,0 +1,54 @@
+/**
+ * @fileOverview Some common arithmetic methods
+ * @author xile611
+ * @date 2015-09-17
+ */
+import Decimal from 'decimal.js-light';
+
+/**
+ * Get the digit count of a number.
+ * If the absolute value is in the interval [0.1, 1), the result is 0.
+ * If the absolute value is in the interval [0.01, 0.1), the digit count is -1.
+ * If the absolute value is in the interval [0.001, 0.01), the digit count is -2.
+ *
+ * @param  {Number} value The number
+ * @return {Integer}      Digit count
+ */
+function getDigitCount(value: number) {
+  let result;
+
+  if (value === 0) {
+    result = 1;
+  } else {
+    result = Math.floor(new Decimal(value).abs().log(10).toNumber()) + 1;
+  }
+
+  return result;
+}
+
+/**
+ * Get the data in the interval [start, end) with a fixed step.
+ * Also handles JS calculation precision issues.
+ *
+ * @param  {Decimal} start Start point
+ * @param  {Decimal} end   End point, not included
+ * @param  {Decimal} step  Step size
+ * @return {Array}         Array of numbers
+ */
+function rangeStep(start: Decimal, end: Decimal, step: Decimal): Array<number> {
+  let num = new Decimal(start);
+  let i = 0;
+  const result: Array<number> = [];
+
+  // magic number to prevent infinite loop
+  while (num.lt(end) && i < 100000) {
+    result.push(num.toNumber());
+
+    num = num.add(step);
+    i++;
+  }
+
+  return result;
+}
+
+export { rangeStep, getDigitCount };

data/vendor/d3-kernel/recharts/util/types.ts

@@ -0,0 +1,5 @@
+// Type shim for the verbatim recharts copies in this vendor tree: the
+// original `src/util/scale/getNiceTickValues.ts` imports NumberDomain from
+// `../types`; this file provides ONLY that type (from recharts
+// src/util/types.ts v3.9.2) so the copies bundle without modification.
+export type NumberDomain = readonly [min: number, max: number];

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: poetry-charts
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Matt Solt
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: poetry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+description: Charts whose geometry is computed on the server (Ruby; d3-scale/d3-shape
+  semantics, recharts' nice ticks) and shipped as finished SVG - no-JS valid, CSS-variable
+  themed, zero client chart math. Stimulus chrome reads server-embedded coordinates
+  for tooltips and legends; engines stay swappable behind a closed, versioned chart-spec
+  (Chart.js reference adapter).
+email:
+- mattsolt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitattributes"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- THIRD_PARTY_NOTICES.md
+- app/assets/stylesheets/poetry-charts.css
+- app/components/poetry/charts/adapter_chart/component.html.erb
+- app/components/poetry/charts/adapter_chart/component.rb
+- app/components/poetry/charts/adapter_chart/preview.rb
+- app/components/poetry/charts/adapter_chart/style.rb
+- app/components/poetry/charts/area_chart/component.html.erb
+- app/components/poetry/charts/area_chart/component.rb
+- app/components/poetry/charts/area_chart/preview.rb
+- app/components/poetry/charts/area_chart/style.rb
+- app/components/poetry/charts/bar_chart/component.html.erb
+- app/components/poetry/charts/bar_chart/component.rb
+- app/components/poetry/charts/bar_chart/preview.rb
+- app/components/poetry/charts/bar_chart/style.rb
+- app/components/poetry/charts/bar_math.rb
+- app/components/poetry/charts/cartesian_family.rb
+- app/components/poetry/charts/chart_family.rb
+- app/components/poetry/charts/composed_chart/component.html.erb
+- app/components/poetry/charts/composed_chart/component.rb
+- app/components/poetry/charts/composed_chart/preview.rb
+- app/components/poetry/charts/composed_chart/style.rb
+- app/components/poetry/charts/container/component.html.erb
+- app/components/poetry/charts/container/component.rb
+- app/components/poetry/charts/container/preview.rb
+- app/components/poetry/charts/container/style.rb
+- app/components/poetry/charts/error_bars.rb
+- app/components/poetry/charts/legend_content/component.html.erb
+- app/components/poetry/charts/legend_content/component.rb
+- app/components/poetry/charts/legend_content/preview.rb
+- app/components/poetry/charts/legend_content/style.rb
+- app/components/poetry/charts/line_chart/component.html.erb
+- app/components/poetry/charts/line_chart/component.rb
+- app/components/poetry/charts/line_chart/preview.rb
+- app/components/poetry/charts/line_chart/style.rb
+- app/components/poetry/charts/live.rb
+- app/components/poetry/charts/motion.rb
+- app/components/poetry/charts/pie_chart/component.html.erb
+- app/components/poetry/charts/pie_chart/component.rb
+- app/components/poetry/charts/pie_chart/preview.rb
+- app/components/poetry/charts/pie_chart/style.rb
+- app/components/poetry/charts/polar_family.rb
+- app/components/poetry/charts/radar_chart/component.html.erb
+- app/components/poetry/charts/radar_chart/component.rb
+- app/components/poetry/charts/radar_chart/preview.rb
+- app/components/poetry/charts/radar_chart/style.rb
+- app/components/poetry/charts/radial_bar_chart/component.html.erb
+- app/components/poetry/charts/radial_bar_chart/component.rb
+- app/components/poetry/charts/radial_bar_chart/preview.rb
+- app/components/poetry/charts/radial_bar_chart/style.rb
+- app/components/poetry/charts/reference_marks.rb
+- app/components/poetry/charts/scatter_chart/component.html.erb
+- app/components/poetry/charts/scatter_chart/component.rb
+- app/components/poetry/charts/scatter_chart/preview.rb
+- app/components/poetry/charts/scatter_chart/style.rb
+- app/components/poetry/charts/tooltip_content/component.html.erb
+- app/components/poetry/charts/tooltip_content/component.rb
+- app/components/poetry/charts/tooltip_content/preview.rb
+- app/components/poetry/charts/tooltip_content/style.rb
+- app/components/poetry/charts/tooltip_layer/component.html.erb
+- app/components/poetry/charts/tooltip_layer/component.rb
+- app/components/poetry/charts/tooltip_layer/style.rb
+- app/components/poetry/charts/tooltip_wiring.rb
+- app/helpers/poetry/charts/components_helper.rb
+- app/javascript/poetry/charts/adapter_controller.js
+- app/javascript/poetry/charts/adapter_registry.js
+- app/javascript/poetry/charts/adapters/chartjs.js
+- app/javascript/poetry/charts/d3.js
+- app/javascript/poetry/charts/index.js
+- app/javascript/poetry/charts/live/renderer.js
+- app/javascript/poetry/charts/live_controller.js
+- app/javascript/poetry/charts/motion/flip.js
+- app/javascript/poetry/charts/motion/sector.js
+- app/javascript/poetry/charts/motion/tween.js
+- app/javascript/poetry/charts/motion_controller.js
+- app/javascript/poetry/charts/tooltip_controller.js
+- app/javascript/poetry/charts/window_controller.js
+- config/component_descriptions.yml
+- config/component_registry.yml
+- config/controllers_manifest.json
+- config/importmap.rb
+- lib/poetry-charts.rb
+- lib/poetry/charts.rb
+- lib/poetry/charts/cartesian.rb
+- lib/poetry/charts/config.rb
+- lib/poetry/charts/engine.rb
+- lib/poetry/charts/geometry.rb
+- lib/poetry/charts/geometry/area.rb
+- lib/poetry/charts/geometry/curve.rb
+- lib/poetry/charts/geometry/line.rb
+- lib/poetry/charts/geometry/nice_ticks.rb
+- lib/poetry/charts/geometry/path.rb
+- lib/poetry/charts/geometry/scale/band.rb
+- lib/poetry/charts/geometry/scale/linear.rb
+- lib/poetry/charts/geometry/stack.rb
+- lib/poetry/charts/geometry/ticks.rb
+- lib/poetry/charts/polar.rb
+- lib/poetry/charts/spec.rb
+- lib/poetry/charts/theme_style.rb
+- lib/poetry/charts/version.rb
+- themes/default.css
+- themes/luma.css
+- themes/lyra.css
+- themes/maia.css
+- themes/mira.css
+- themes/nova.css
+- themes/rhea.css
+- themes/sera.css
+- themes/vega.css
+- vendor/d3-kernel/LICENSE-d3.txt
+- vendor/d3-kernel/LICENSE-decimal.js-light.txt
+- vendor/d3-kernel/LICENSE-recharts.txt
+- vendor/d3-kernel/README.md
+- vendor/d3-kernel/build.mjs
+- vendor/d3-kernel/entry.js
+- vendor/d3-kernel/recharts/state/cartesianAxisSlice.ts
+- vendor/d3-kernel/recharts/util/scale/getNiceTickValues.ts
+- vendor/d3-kernel/recharts/util/scale/util/arithmetic.ts
+- vendor/d3-kernel/recharts/util/types.ts
+homepage: https://poetryui.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://poetryui.com
+  documentation_uri: https://poetryui.com/docs
+  source_code_uri: https://github.com/roboruby/poetry-charts
+  changelog_uri: https://github.com/roboruby/poetry-charts/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/roboruby/poetry-charts/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: 'Poetry''s chart tier: server-rendered SVG charts for Rails.'
+test_files: []