@buildcanada/charts 0.3.6 → 0.3.8

package/dist/grapher/color/BinningStrategies.d.ts

@@ -0,0 +1,81 @@
+import { AutomaticBinningStrategy, MidpointMode, ResolvedBinningStrategy } from "../../types/index.js";
+/**
+ * Strategies:
+ * - The log scales result in log-like steps, e.g. 1, 2, 5, 10, ...
+ *   They are fully defined given a minValue, maxValue and steps, and
+ *   then generate as many bins as needed to cover the range.
+ *   `log-auto` chooses the step size automatically in order to get a decent number of bins.
+ * - The equal size bins result in evenly spaced steps, e.g. 0, 1, 2, 3, ...
+ *   They are defined by a minValue, maxValue, and a rough target number of bins.
+ *   `equalSizeBins-few-bins` chooses a small number of bins, while
+ *   `equalSizeBins-many-bins` chooses a large number of bins.
+ *   They then generate nice round bin thresholds given the input data.
+ * - `equalSizeBins-percent` is a special case, where for data that looks like percent
+ *   from 0% to 100% we want to mostly use 0%, 10%, 20%, etc. bins.
+ *
+ * Midpoints:
+ *  Sometimes, we do have a midpoint in our data. In many cases, a natural midpoint is zero
+ *  (e.g. for year-over-year change, net migration, temperature anomaly, etc.), but other
+ *  midpoints also make sense (e.g. for sex ratio, or survey responses ranging 0-10).
+ *  If we have a midpoint, then we want to account for it when binning, and generate bins
+ *  that are centered or symmetric around the midpoint.
+ */
+export interface BinningStrategyConfig {
+    strategy: AutomaticBinningStrategy;
+    minValue?: number;
+    maxValue?: number;
+    sortedValues: number[];
+    isPercent?: boolean;
+    numDecimalPlaces?: number;
+    midpointMode?: MidpointMode;
+    midpoint?: number;
+    createBinForMidpoint?: boolean;
+}
+export interface ResolvedBinningStrategyConfig {
+    strategy: ResolvedBinningStrategy;
+    minValue?: number;
+    maxValue?: number;
+    numDecimalPlaces?: number;
+    sortedValues: number[];
+    midpointMode: MidpointMode;
+    midpoint: number;
+}
+interface BinningStrategyOutput {
+    bins: number[];
+    midpoint?: number;
+}
+/**
+ * Calculates the log10 difference between two numbers, i.e. compute x such that lowerValue * 10^x = upperValue.
+ */
+export declare const calcMagnitudeDiff: (lowerValue: number, upperValue: number) => number;
+export declare const pruneUnusedBins: (bins: number[], { minValue, maxValue }: {
+    minValue?: number;
+    maxValue?: number;
+}) => number[];
+export declare const runBinningStrategy: (conf: BinningStrategyConfig) => BinningStrategyOutput;
+type MinMaxValueResult = {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+    field: string;
+};
+export declare const hasValidConfigForBinningStrategy: (strategy: AutomaticBinningStrategy, config: {
+    minValue?: number;
+    maxValue?: number;
+    midpoint?: number;
+}) => MinMaxValueResult;
+/**
+ * minValue and maxValue may either be explicitly given, or automatically computed from the data.
+ * If auto-computed, they are based on some very much heuristic rules, based on quantiles etc.
+ *
+ * This also means that these lines contain a bunch of magic numbers, which have been chosen like so
+ * because they work well in practice for most cases.
+ */
+export declare const computeMinMaxForStrategy: (strategy: ResolvedBinningStrategy, sortedValues: number[], conf?: Partial<ResolvedBinningStrategyConfig>) => {
+    minValue: number;
+    maxValue: number;
+};
+export declare const mirrorBinsAroundMidpoint: (binOffsets: number[], midpoint: number) => number[];
+export {};
+//# sourceMappingURL=BinningStrategies.d.ts.map

package/dist/grapher/color/BinningStrategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinningStrategies.d.ts","sourceRoot":"","sources":["../../../src/grapher/color/BinningStrategies.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,wBAAwB,EACxB,YAAY,EACZ,uBAAuB,EAC1B,MAAM,sBAAsB,CAAA;AAkB7B;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,wBAAwB,CAAA;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CACjC;AAED,MAAM,WAAW,6BAA6B;IAC1C,QAAQ,EAAE,uBAAuB,CAAA;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,YAAY,EAAE,YAAY,CAAA;IAC1B,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,UAAU,qBAAqB;IAC3B,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAA;CACpB;AAOD;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC1B,YAAY,MAAM,EAClB,YAAY,MAAM,KACnB,MAKF,CAAA;AAED,eAAO,MAAM,eAAe,GACxB,MAAM,MAAM,EAAE,EACd,wBAAwB;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KACjE,MAAM,EAgBR,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC3B,MAAM,qBAAqB,KAC5B,qBAiDF,CAAA;AAED,KAAK,iBAAiB,GAChB;IAAE,KAAK,EAAE,IAAI,CAAA;CAAE,GACf;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAErD,eAAO,MAAM,gCAAgC,GACzC,UAAU,wBAAwB,EAClC,QAAQ;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,KACpE,iBAsDF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACjC,UAAU,uBAAuB,EACjC,cAAc,MAAM,EAAE,EACtB,OAAO,OAAO,CAAC,6BAA6B,CAAC,KAC9C;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CA8DtC,CAAA;AA+KD,eAAO,MAAM,wBAAwB,GACjC,YAAY,MAAM,EAAE,EACpB,UAAU,MAAM,KACjB,MAAM,EAKR,CAAA"}

package/dist/grapher/color/BinningStrategies.js

@@ -0,0 +1,300 @@
+import {
+  automaticBinningStrategies
+} from "../../types/index.js";
+import {
+  firstOfNonEmptyArray,
+  lastOfNonEmptyArray
+} from "../../utils/index.js";
+import { quantile } from "d3";
+import { sortedUniq } from "lodash-es";
+import * as R from "remeda";
+import { match, P } from "ts-pattern";
+import {
+  isLogBinningStrategy,
+  runLogBinningStrategy
+} from "./BinningStrategyLogarithmic.js";
+import {
+  isEqualSizeBinningStrategy,
+  runEqualSizeBinningStrategy
+} from "./BinningStrategyEqualSizeBins.js";
+const AUTO_EQUAL_BINS_MAX_MAGNITUDE_DIFF = 1.2;
+const calcMagnitudeDiff = (lowerValue, upperValue) => {
+  if (lowerValue > upperValue)
+    throw new Error("lowerValue must be less than upperValue");
+  return Math.log10(upperValue) - Math.log10(lowerValue);
+};
+const pruneUnusedBins = (bins, { minValue, maxValue }) => {
+  if (minValue !== void 0) {
+    bins = R.dropWhile(
+      bins,
+      (v, i) => bins[i + 1] !== void 0 && bins[i + 1] <= minValue
+    );
+  }
+  if (maxValue !== void 0) {
+    bins = R.dropLastWhile(
+      bins,
+      (v, i) => bins[i - 1] !== void 0 && bins[i - 1] >= maxValue
+    );
+  }
+  return bins;
+};
+const runBinningStrategy = (conf) => {
+  if (conf.sortedValues.length === 0) {
+    return { bins: [0] };
+  }
+  conf.midpoint ??= 0;
+  const hasValuesBelowMidpoint = conf.sortedValues[0] < conf.midpoint;
+  const hasValuesAboveMidpoint = lastOfNonEmptyArray(conf.sortedValues) > conf.midpoint;
+  const hasValuesBelowAndAboveMidpoint = hasValuesBelowMidpoint && hasValuesAboveMidpoint;
+  if (hasValuesBelowAndAboveMidpoint && conf.midpointMode === void 0) {
+    conf.midpointMode ??= "symmetric";
+  }
+  conf.midpointMode ??= "none";
+  let resolvedStrategy;
+  if (conf.strategy === "auto") {
+    resolvedStrategy = autoChooseBinningStrategy(conf);
+  } else {
+    resolvedStrategy = conf.strategy;
+  }
+  const validationResult = hasValidConfigForBinningStrategy(
+    conf.strategy,
+    conf
+  );
+  if (!validationResult.valid) return { bins: [0] };
+  let bins = runBinningStrategyAroundMidpoint({
+    ...conf,
+    midpointMode: conf.midpointMode,
+    midpoint: conf.midpoint,
+    strategy: resolvedStrategy
+  });
+  if (conf.createBinForMidpoint) {
+    const midpointIdx = R.sortedIndex(bins, conf.midpoint);
+    bins = bins.toSpliced(midpointIdx, 0, conf.midpoint);
+  }
+  return {
+    bins,
+    midpoint: conf.midpointMode !== "none" ? conf.midpoint : void 0
+  };
+};
+const hasValidConfigForBinningStrategy = (strategy, config) => {
+  const { minValue, maxValue, midpoint } = config;
+  if (!automaticBinningStrategies.includes(strategy))
+    return {
+      valid: false,
+      reason: `Binning: Invalid strategy '${strategy}'`,
+      field: "binningStrategy"
+    };
+  if (minValue !== void 0 && maxValue !== void 0 && maxValue < minValue) {
+    return {
+      valid: false,
+      reason: "Binning: minValue is greater than maxValue",
+      field: "minValue"
+    };
+  }
+  return match(strategy).with("auto", () => {
+    return { valid: true };
+  }).when(isEqualSizeBinningStrategy, () => {
+    return { valid: true };
+  }).when(isLogBinningStrategy, () => {
+    if (minValue !== void 0 && minValue <= 0) {
+      return {
+        valid: false,
+        reason: "Binning: Logarithmic binning requires non-zero positive minValue",
+        field: "minValue"
+      };
+    }
+    if (maxValue !== void 0 && maxValue <= 0) {
+      return {
+        valid: false,
+        reason: "Binning: Logarithmic binning requires non-zero positive maxValue",
+        field: "maxValue"
+      };
+    }
+    if (midpoint !== void 0 && midpoint !== 0) {
+      return {
+        valid: false,
+        reason: "Binning: Logarithmic binning does not support midpoints other than 0",
+        field: "midpoint"
+      };
+    }
+    return { valid: true };
+  }).exhaustive();
+};
+const computeMinMaxForStrategy = (strategy, sortedValues, conf) => {
+  let { minValue, maxValue } = conf || {};
+  if (conf?.midpointMode !== "none" && minValue !== void 0 && conf?.midpoint !== void 0) {
+    minValue = Math.max(minValue, conf.midpoint);
+  }
+  if (minValue !== void 0 && maxValue !== void 0) {
+    maxValue = Math.max(minValue, maxValue);
+    return { minValue, maxValue };
+  }
+  match(strategy).with("equalSizeBins-percent", () => {
+    minValue ??= 0;
+    maxValue ??= 100;
+  }).when(isEqualSizeBinningStrategy, () => {
+    const uniqValues = sortedUniq(sortedValues);
+    minValue ??= quantile(uniqValues, 0.05);
+    maxValue ??= quantile(uniqValues, 0.95);
+  }).when(isLogBinningStrategy, () => {
+    const posValues = R.dropWhile(sortedValues, (v) => v <= 0);
+    if (posValues.length === 0) {
+      throw new Error("Log binning strategy requires positive values");
+    }
+    const uniqValues = sortedUniq(posValues);
+    minValue ??= quantile(uniqValues, 0.15);
+    maxValue ??= quantile(uniqValues, 0.995);
+    if (minValue === void 0 || maxValue === void 0)
+      throw new Error("Couldn't obtain minValue or maxValue");
+    if (conf?.numDecimalPlaces !== void 0) {
+      if (minValue > 0)
+        minValue = Math.max(
+          minValue,
+          Math.pow(10, -conf.numDecimalPlaces)
+        );
+      if (maxValue < 0)
+        maxValue = Math.min(
+          maxValue,
+          -Math.pow(10, -conf.numDecimalPlaces)
+        );
+    }
+  }).exhaustive();
+  if (minValue === void 0 || maxValue === void 0)
+    throw new Error("Couldn't obtain minValue or maxValue");
+  maxValue = Math.max(minValue, maxValue);
+  return { minValue, maxValue };
+};
+const runBinningStrategyAroundMidpoint = (conf) => {
+  if (isLogBinningStrategy(conf.strategy) && conf.midpointMode !== "none" && conf.midpoint !== 0) {
+    throw new Error(
+      "Log binning strategy does not support midpoints other than 0"
+    );
+  }
+  const minValue = firstOfNonEmptyArray(conf.sortedValues);
+  const maxValue = lastOfNonEmptyArray(conf.sortedValues);
+  const bins = match(conf.midpointMode).with("none", () => {
+    return runResolvedBinningStrategy(conf, { hasMidpoint: false });
+  }).with(P.union("symmetric", "asymmetric"), () => {
+    const leftRange = Math.max(conf.midpoint - minValue, 0);
+    const rightRange = Math.max(maxValue - conf.midpoint, 0);
+    const biggerRange = Math.max(leftRange, rightRange);
+    let posValues;
+    if (biggerRange === leftRange) {
+      posValues = R.takeWhile(
+        conf.sortedValues,
+        (v) => v < conf.midpoint
+      ).map((v) => conf.midpoint - v).reverse();
+    } else {
+      posValues = R.dropWhile(
+        conf.sortedValues,
+        (v) => v <= conf.midpoint
+      ).map((v) => v - conf.midpoint);
+    }
+    const binsRight = runResolvedBinningStrategy(
+      { ...conf, sortedValues: posValues },
+      { hasMidpoint: true }
+    );
+    const bins2 = mirrorBinsAroundMidpoint(binsRight, conf.midpoint);
+    if (conf.midpointMode === "symmetric") {
+      return bins2;
+    } else {
+      return pruneUnusedBins(bins2, {
+        minValue,
+        maxValue
+      });
+    }
+  }).with("same-num-bins", () => {
+    const leftValues = R.takeWhile(
+      conf.sortedValues,
+      (v) => v < conf.midpoint
+    ).map((v) => conf.midpoint - v).reverse();
+    const rightValues = R.dropWhile(
+      conf.sortedValues,
+      (v) => v <= conf.midpoint
+    ).map((v) => v - conf.midpoint);
+    const binsRight = runResolvedBinningStrategy(
+      { ...conf, sortedValues: rightValues },
+      { hasMidpoint: true }
+    ).filter((v) => v !== 0);
+    const binsLeft = runResolvedBinningStrategy(
+      { ...conf, sortedValues: leftValues },
+      { hasMidpoint: true }
+    ).filter((v) => v !== 0);
+    return [
+      ...binsLeft.map((v) => conf.midpoint - v).reverse(),
+      conf.midpoint,
+      ...binsRight.map((v) => v + conf.midpoint)
+    ];
+  }).with(void 0, () => {
+    throw new Error("Invalid unresolved midpoint mode");
+  }).exhaustive();
+  return bins;
+};
+const runResolvedBinningStrategy = (conf, { hasMidpoint }) => {
+  const { minValue, maxValue } = computeMinMaxForStrategy(
+    conf.strategy,
+    conf.sortedValues,
+    conf
+  );
+  return match(conf.strategy).when(
+    isEqualSizeBinningStrategy,
+    () => runEqualSizeBinningStrategy(
+      { ...conf, minValue, maxValue },
+      { hasMidpoint }
+    )
+  ).when(
+    isLogBinningStrategy,
+    () => runLogBinningStrategy(
+      { ...conf, minValue, maxValue },
+      { hasMidpoint }
+    )
+  ).exhaustive();
+};
+const autoChooseBinningStrategy = (conf) => {
+  if (conf.midpointMode !== "none") {
+    return "equalSizeBins-normal";
+  }
+  const posValuesOnly = R.dropWhile(conf.sortedValues, (v) => v <= 0);
+  if (posValuesOnly.length === 0) {
+    return "equalSizeBins-normal";
+  }
+  const hasNegativeMinOrMaxValue = conf.minValue !== void 0 && conf.minValue <= 0 || conf.maxValue !== void 0 && conf.maxValue <= 0;
+  let minValueForLog, maxValueForLog;
+  if (hasNegativeMinOrMaxValue) {
+    minValueForLog = maxValueForLog = 0;
+  } else {
+    const { minValue, maxValue } = computeMinMaxForStrategy(
+      "log-auto",
+      posValuesOnly,
+      { minValue: conf.minValue, maxValue: conf.maxValue }
+    );
+    minValueForLog = minValue;
+    maxValueForLog = maxValue;
+  }
+  const magnitudeDiff = calcMagnitudeDiff(minValueForLog, maxValueForLog);
+  if (magnitudeDiff < AUTO_EQUAL_BINS_MAX_MAGNITUDE_DIFF || hasNegativeMinOrMaxValue) {
+    if (conf.isPercent) {
+      const lastValue = lastOfNonEmptyArray(posValuesOnly);
+      const percentile99 = quantile(posValuesOnly, 0.99);
+      if (lastValue <= 100 && percentile99 !== void 0 && percentile99 >= 60) {
+        return "equalSizeBins-percent";
+      }
+    }
+    return "equalSizeBins-normal";
+  }
+  return "log-auto";
+};
+const mirrorBinsAroundMidpoint = (binOffsets, midpoint) => {
+  const filteredRightBins = binOffsets.filter((v) => v !== 0);
+  const leftBins = filteredRightBins.map((v) => midpoint - v).reverse();
+  const rightBins = filteredRightBins.map((v) => v + midpoint);
+  return [...leftBins, midpoint, ...rightBins];
+};
+export {
+  calcMagnitudeDiff,
+  computeMinMaxForStrategy,
+  hasValidConfigForBinningStrategy,
+  mirrorBinsAroundMidpoint,
+  pruneUnusedBins,
+  runBinningStrategy
+};

package/dist/grapher/color/BinningStrategies.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/grapher/color/BinningStrategies.ts"],
+  "sourcesContent": ["import {\n    automaticBinningStrategies,\n    AutomaticBinningStrategy,\n    MidpointMode,\n    ResolvedBinningStrategy,\n} from \"../../types/index.js\"\nimport {\n    firstOfNonEmptyArray,\n    lastOfNonEmptyArray,\n} from \"../../utils/index.js\"\nimport { quantile } from \"d3\"\nimport { sortedUniq } from \"lodash-es\"\nimport * as R from \"remeda\"\nimport { match, P } from \"ts-pattern\"\nimport {\n    isLogBinningStrategy,\n    runLogBinningStrategy,\n} from \"./BinningStrategyLogarithmic.js\"\nimport {\n    isEqualSizeBinningStrategy,\n    runEqualSizeBinningStrategy,\n} from \"./BinningStrategyEqualSizeBins.js\"\n\n/**\n * Strategies:\n * - The log scales result in log-like steps, e.g. 1, 2, 5, 10, ...\n *   They are fully defined given a minValue, maxValue and steps, and\n *   then generate as many bins as needed to cover the range.\n *   `log-auto` chooses the step size automatically in order to get a decent number of bins.\n * - The equal size bins result in evenly spaced steps, e.g. 0, 1, 2, 3, ...\n *   They are defined by a minValue, maxValue, and a rough target number of bins.\n *   `equalSizeBins-few-bins` chooses a small number of bins, while\n *   `equalSizeBins-many-bins` chooses a large number of bins.\n *   They then generate nice round bin thresholds given the input data.\n * - `equalSizeBins-percent` is a special case, where for data that looks like percent\n *   from 0% to 100% we want to mostly use 0%, 10%, 20%, etc. bins.\n *\n * Midpoints:\n *  Sometimes, we do have a midpoint in our data. In many cases, a natural midpoint is zero\n *  (e.g. for year-over-year change, net migration, temperature anomaly, etc.), but other\n *  midpoints also make sense (e.g. for sex ratio, or survey responses ranging 0-10).\n *  If we have a midpoint, then we want to account for it when binning, and generate bins\n *  that are centered or symmetric around the midpoint.\n */\n\nexport interface BinningStrategyConfig {\n    strategy: AutomaticBinningStrategy\n    minValue?: number\n    maxValue?: number\n    sortedValues: number[]\n    isPercent?: boolean\n    numDecimalPlaces?: number\n    midpointMode?: MidpointMode\n    midpoint?: number\n    createBinForMidpoint?: boolean\n}\n\nexport interface ResolvedBinningStrategyConfig {\n    strategy: ResolvedBinningStrategy\n    minValue?: number\n    maxValue?: number\n    numDecimalPlaces?: number\n    sortedValues: number[]\n    midpointMode: MidpointMode\n    midpoint: number\n}\n\ninterface BinningStrategyOutput {\n    bins: number[]\n    midpoint?: number\n}\n\n// If the log10 difference between the min and max values is less than or equal to 1.2,\n// the data is considered to be close enough in magnitude to use equal-size bins.\n// This threshold was chosen empirically.\nconst AUTO_EQUAL_BINS_MAX_MAGNITUDE_DIFF = 1.2\n\n/**\n * Calculates the log10 difference between two numbers, i.e. compute x such that lowerValue * 10^x = upperValue.\n */\nexport const calcMagnitudeDiff = (\n    lowerValue: number,\n    upperValue: number\n): number => {\n    if (lowerValue > upperValue)\n        throw new Error(\"lowerValue must be less than upperValue\")\n\n    return Math.log10(upperValue) - Math.log10(lowerValue)\n}\n\nexport const pruneUnusedBins = (\n    bins: number[],\n    { minValue, maxValue }: { minValue?: number; maxValue?: number }\n): number[] => {\n    if (minValue !== undefined) {\n        bins = R.dropWhile(\n            bins,\n            (v, i) => bins[i + 1] !== undefined && bins[i + 1] <= minValue\n        )\n    }\n\n    if (maxValue !== undefined) {\n        bins = R.dropLastWhile(\n            bins,\n            (v, i) => bins[i - 1] !== undefined && bins[i - 1] >= maxValue\n        )\n    }\n\n    return bins\n}\n\nexport const runBinningStrategy = (\n    conf: BinningStrategyConfig\n): BinningStrategyOutput => {\n    if (conf.sortedValues.length === 0) {\n        return { bins: [0] }\n    }\n\n    conf.midpoint ??= 0\n\n    const hasValuesBelowMidpoint = conf.sortedValues[0] < conf.midpoint\n    const hasValuesAboveMidpoint =\n        lastOfNonEmptyArray(conf.sortedValues) > conf.midpoint\n    const hasValuesBelowAndAboveMidpoint =\n        hasValuesBelowMidpoint && hasValuesAboveMidpoint\n\n    if (hasValuesBelowAndAboveMidpoint && conf.midpointMode === undefined) {\n        // Default to symmetric midpoint if there are negative and positive values\n        conf.midpointMode ??= \"symmetric\"\n    }\n\n    conf.midpointMode ??= \"none\"\n\n    let resolvedStrategy: ResolvedBinningStrategy\n    if (conf.strategy === \"auto\") {\n        resolvedStrategy = autoChooseBinningStrategy(conf)\n    } else {\n        resolvedStrategy = conf.strategy as ResolvedBinningStrategy\n    }\n\n    const validationResult = hasValidConfigForBinningStrategy(\n        conf.strategy,\n        conf\n    )\n    if (!validationResult.valid) return { bins: [0] } // Placeholder binning for invalid configurations\n\n    let bins = runBinningStrategyAroundMidpoint({\n        ...conf,\n        midpointMode: conf.midpointMode,\n        midpoint: conf.midpoint,\n        strategy: resolvedStrategy,\n    })\n\n    if (conf.createBinForMidpoint) {\n        const midpointIdx = R.sortedIndex(bins, conf.midpoint)\n        bins = bins.toSpliced(midpointIdx, 0, conf.midpoint)\n    }\n\n    return {\n        bins,\n        midpoint: conf.midpointMode !== \"none\" ? conf.midpoint : undefined,\n    }\n}\n\ntype MinMaxValueResult =\n    | { valid: true }\n    | { valid: false; reason: string; field: string }\n\nexport const hasValidConfigForBinningStrategy = (\n    strategy: AutomaticBinningStrategy,\n    config: { minValue?: number; maxValue?: number; midpoint?: number }\n): MinMaxValueResult => {\n    const { minValue, maxValue, midpoint } = config\n\n    if (!automaticBinningStrategies.includes(strategy))\n        return {\n            valid: false,\n            reason: `Binning: Invalid strategy '${strategy}'`,\n            field: \"binningStrategy\",\n        }\n\n    if (\n        minValue !== undefined &&\n        maxValue !== undefined &&\n        maxValue < minValue\n    ) {\n        return {\n            valid: false,\n            reason: \"Binning: minValue is greater than maxValue\",\n            field: \"minValue\",\n        }\n    }\n\n    return match(strategy)\n        .with(\"auto\", () => {\n            return { valid: true } as const\n        })\n        .when(isEqualSizeBinningStrategy, () => {\n            return { valid: true } as const\n        })\n        .when(isLogBinningStrategy, () => {\n            if (minValue !== undefined && minValue <= 0) {\n                return {\n                    valid: false,\n                    reason: \"Binning: Logarithmic binning requires non-zero positive minValue\",\n                    field: \"minValue\",\n                } as const\n            }\n            if (maxValue !== undefined && maxValue <= 0) {\n                return {\n                    valid: false,\n                    reason: \"Binning: Logarithmic binning requires non-zero positive maxValue\",\n                    field: \"maxValue\",\n                } as const\n            }\n            if (midpoint !== undefined && midpoint !== 0) {\n                return {\n                    valid: false,\n                    reason: \"Binning: Logarithmic binning does not support midpoints other than 0\",\n                    field: \"midpoint\",\n                } as const\n            }\n            return { valid: true } as const\n        })\n        .exhaustive()\n}\n\n/**\n * minValue and maxValue may either be explicitly given, or automatically computed from the data.\n * If auto-computed, they are based on some very much heuristic rules, based on quantiles etc.\n *\n * This also means that these lines contain a bunch of magic numbers, which have been chosen like so\n * because they work well in practice for most cases.\n */\nexport const computeMinMaxForStrategy = (\n    strategy: ResolvedBinningStrategy,\n    sortedValues: number[],\n    conf?: Partial<ResolvedBinningStrategyConfig>\n): { minValue: number; maxValue: number } => {\n    let { minValue, maxValue } = conf || {}\n    if (\n        conf?.midpointMode !== \"none\" &&\n        minValue !== undefined &&\n        conf?.midpoint !== undefined\n    ) {\n        // Ensure that the midpoint is within the min/max range, otherwise we'll get very weird results when mirroring around the midpoint\n        minValue = Math.max(minValue, conf.midpoint)\n    }\n    if (minValue !== undefined && maxValue !== undefined) {\n        maxValue = Math.max(minValue, maxValue)\n        return { minValue, maxValue }\n    }\n\n    match(strategy)\n        .with(\"equalSizeBins-percent\", () => {\n            // Percent strategy always uses 0 to 100\n            minValue ??= 0\n            maxValue ??= 100\n        })\n        .when(isEqualSizeBinningStrategy, () => {\n            const uniqValues = sortedUniq(sortedValues)\n            minValue ??= quantile(uniqValues, 0.05)\n            maxValue ??= quantile(uniqValues, 0.95)\n        })\n        .when(isLogBinningStrategy, () => {\n            const posValues = R.dropWhile(sortedValues, (v) => v <= 0)\n            if (posValues.length === 0) {\n                throw new Error(\"Log binning strategy requires positive values\")\n            }\n\n            const uniqValues = sortedUniq(posValues)\n            minValue ??= quantile(uniqValues, 0.15)\n            maxValue ??= quantile(uniqValues, 0.995)\n\n            if (minValue === undefined || maxValue === undefined)\n                throw new Error(\"Couldn't obtain minValue or maxValue\")\n\n            // Ensure that the min/max values are at least as high as the number of decimals precision.\n            // E.g. if we have 1 decimal place, the minimum value should be at least 0.1\n            if (conf?.numDecimalPlaces !== undefined) {\n                if (minValue > 0)\n                    minValue = Math.max(\n                        minValue,\n                        Math.pow(10, -conf.numDecimalPlaces)\n                    )\n                if (maxValue < 0)\n                    maxValue = Math.min(\n                        maxValue,\n                        -Math.pow(10, -conf.numDecimalPlaces)\n                    )\n            }\n        })\n        .exhaustive()\n\n    if (minValue === undefined || maxValue === undefined)\n        throw new Error(\"Couldn't obtain minValue or maxValue\")\n\n    // Ensure that we have minValue <= maxValue\n    maxValue = Math.max(minValue, maxValue)\n    return { minValue, maxValue }\n}\n\nconst runBinningStrategyAroundMidpoint = (\n    conf: ResolvedBinningStrategyConfig\n): number[] => {\n    if (\n        isLogBinningStrategy(conf.strategy) &&\n        conf.midpointMode !== \"none\" &&\n        conf.midpoint !== 0\n    ) {\n        throw new Error(\n            \"Log binning strategy does not support midpoints other than 0\"\n        )\n    }\n\n    const minValue = firstOfNonEmptyArray(conf.sortedValues)\n    const maxValue = lastOfNonEmptyArray(conf.sortedValues)\n\n    const bins = match(conf.midpointMode)\n        .with(\"none\", () => {\n            return runResolvedBinningStrategy(conf, { hasMidpoint: false })\n        })\n        .with(P.union(\"symmetric\", \"asymmetric\"), () => {\n            const leftRange = Math.max(conf.midpoint - minValue, 0)\n            const rightRange = Math.max(maxValue - conf.midpoint, 0)\n            const biggerRange = Math.max(leftRange, rightRange)\n\n            let posValues: number[]\n            if (biggerRange === leftRange) {\n                posValues = R.takeWhile(\n                    conf.sortedValues,\n                    (v) => v < conf.midpoint\n                )\n                    .map((v) => conf.midpoint - v)\n                    .reverse()\n            } else {\n                posValues = R.dropWhile(\n                    conf.sortedValues,\n                    (v) => v <= conf.midpoint\n                ).map((v) => v - conf.midpoint)\n            }\n\n            const binsRight = runResolvedBinningStrategy(\n                { ...conf, sortedValues: posValues },\n                { hasMidpoint: true }\n            )\n            const bins = mirrorBinsAroundMidpoint(binsRight, conf.midpoint)\n\n            if (conf.midpointMode === \"symmetric\") {\n                return bins\n            } else {\n                // asymmetric: create bins the same way, but then prune any unused ones\n\n                return pruneUnusedBins(bins, {\n                    minValue,\n                    maxValue,\n                })\n            }\n        })\n        .with(\"same-num-bins\", () => {\n            const leftValues = R.takeWhile(\n                conf.sortedValues,\n                (v) => v < conf.midpoint\n            )\n                .map((v) => conf.midpoint - v)\n                .reverse()\n\n            const rightValues = R.dropWhile(\n                conf.sortedValues,\n                (v) => v <= conf.midpoint\n            ).map((v) => v - conf.midpoint)\n\n            const binsRight = runResolvedBinningStrategy(\n                { ...conf, sortedValues: rightValues },\n                { hasMidpoint: true }\n            ).filter((v) => v !== 0)\n            const binsLeft = runResolvedBinningStrategy(\n                { ...conf, sortedValues: leftValues },\n                { hasMidpoint: true }\n            ).filter((v) => v !== 0)\n\n            return [\n                ...binsLeft.map((v) => conf.midpoint - v).reverse(),\n                conf.midpoint,\n                ...binsRight.map((v) => v + conf.midpoint),\n            ]\n        })\n        .with(undefined, () => {\n            throw new Error(\"Invalid unresolved midpoint mode\")\n        })\n        .exhaustive()\n\n    return bins\n}\n\nconst runResolvedBinningStrategy = (\n    conf: ResolvedBinningStrategyConfig,\n    { hasMidpoint }: { hasMidpoint: boolean }\n): number[] => {\n    const { minValue, maxValue } = computeMinMaxForStrategy(\n        conf.strategy,\n        conf.sortedValues,\n        conf\n    )\n    return match(conf.strategy)\n        .when(isEqualSizeBinningStrategy, () =>\n            runEqualSizeBinningStrategy(\n                { ...conf, minValue, maxValue },\n                { hasMidpoint }\n            )\n        )\n        .when(isLogBinningStrategy, () =>\n            runLogBinningStrategy(\n                { ...conf, minValue, maxValue },\n                { hasMidpoint }\n            )\n        )\n        .exhaustive()\n}\n\nconst autoChooseBinningStrategy = (\n    conf: BinningStrategyConfig\n): ResolvedBinningStrategy => {\n    if (conf.midpointMode !== \"none\") {\n        return \"equalSizeBins-normal\"\n    }\n\n    const posValuesOnly = R.dropWhile(conf.sortedValues, (v) => v <= 0)\n    if (posValuesOnly.length === 0) {\n        // All values are negative or zero, use equal size bins as a simple fallback (this is rare anyways)\n        return \"equalSizeBins-normal\"\n    }\n\n    // If either minValue or maxValue is non-positive, we cannot use log bins\n    const hasNegativeMinOrMaxValue =\n        (conf.minValue !== undefined && conf.minValue <= 0) ||\n        (conf.maxValue !== undefined && conf.maxValue <= 0)\n\n    let minValueForLog, maxValueForLog\n    if (hasNegativeMinOrMaxValue) {\n        minValueForLog = maxValueForLog = 0\n    } else {\n        const { minValue, maxValue } = computeMinMaxForStrategy(\n            \"log-auto\",\n            posValuesOnly,\n            { minValue: conf.minValue, maxValue: conf.maxValue }\n        )\n        minValueForLog = minValue\n        maxValueForLog = maxValue\n    }\n\n    const magnitudeDiff = calcMagnitudeDiff(minValueForLog, maxValueForLog)\n\n    if (\n        magnitudeDiff < AUTO_EQUAL_BINS_MAX_MAGNITUDE_DIFF ||\n        hasNegativeMinOrMaxValue\n    ) {\n        if (conf.isPercent) {\n            const lastValue = lastOfNonEmptyArray(posValuesOnly)\n            const percentile99 = quantile(posValuesOnly, 0.99)\n            if (\n                lastValue <= 100 &&\n                percentile99 !== undefined &&\n                percentile99 >= 60\n            ) {\n                return \"equalSizeBins-percent\"\n            }\n        }\n\n        return \"equalSizeBins-normal\"\n    }\n\n    return \"log-auto\"\n}\n\nexport const mirrorBinsAroundMidpoint = (\n    binOffsets: number[],\n    midpoint: number\n): number[] => {\n    const filteredRightBins = binOffsets.filter((v) => v !== 0)\n    const leftBins = filteredRightBins.map((v) => midpoint - v).reverse()\n    const rightBins = filteredRightBins.map((v) => v + midpoint)\n    return [...leftBins, midpoint, ...rightBins]\n}\n"],
+  "mappings": "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",
+  "names": ["bins"]
+}

package/dist/grapher/color/BinningStrategyEqualSizeBins.d.ts

@@ -0,0 +1,13 @@
+import { BinningStrategyIncludingManual, EqualSizeBinningStrategy, ResolvedBinningStrategy } from "../../types/index.js";
+import { RequiredBy } from "../../utils/index.js";
+import { ResolvedBinningStrategyConfig } from "./BinningStrategies.js";
+export declare const isEqualSizeBinningStrategy: (strategy: BinningStrategyIncludingManual | ResolvedBinningStrategy) => strategy is EqualSizeBinningStrategy;
+export declare const runEqualSizeBinningStrategy: (conf: RequiredBy<ResolvedBinningStrategyConfig, "minValue" | "maxValue">, { hasMidpoint }?: {
+    hasMidpoint?: boolean;
+}) => number[];
+export declare const createEqualSizeBins: ({ minValue, maxValue, targetBinCount, }: {
+    minValue: number;
+    maxValue: number;
+    targetBinCount: readonly number[];
+}) => number[];
+//# sourceMappingURL=BinningStrategyEqualSizeBins.d.ts.map

package/dist/grapher/color/BinningStrategyEqualSizeBins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinningStrategyEqualSizeBins.d.ts","sourceRoot":"","sources":["../../../src/grapher/color/BinningStrategyEqualSizeBins.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,8BAA8B,EAC9B,wBAAwB,EACxB,uBAAuB,EAC1B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAEH,UAAU,EAEb,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAA;AAEtE,eAAO,MAAM,0BAA0B,GACnC,UAAU,8BAA8B,GAAG,uBAAuB,KACnE,QAAQ,IAAI,wBAAiE,CAAA;AAEhF,eAAO,MAAM,2BAA2B,GACpC,MAAM,UAAU,CAAC,6BAA6B,EAAE,UAAU,GAAG,UAAU,CAAC,EACxE,kBAAiB;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,KAChD,MAAM,EAWR,CAAA;AA0BD,eAAO,MAAM,mBAAmB,GAAI,yCAIjC;IACC,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,SAAS,MAAM,EAAE,CAAA;CACpC,KAAG,MAAM,EAiET,CAAA"}

package/dist/grapher/color/BinningStrategyEqualSizeBins.js

@@ -0,0 +1,76 @@
+import {
+  normaliseToSingleDigitNumber,
+  roundSigFig
+} from "../../utils/index.js";
+import * as R from "remeda";
+import { match, P } from "ts-pattern";
+const isEqualSizeBinningStrategy = (strategy) => strategy.startsWith("equalSizeBins-");
+const runEqualSizeBinningStrategy = (conf, { hasMidpoint } = {}) => {
+  if (!isEqualSizeBinningStrategy(conf.strategy)) {
+    throw new Error("Invalid strategy");
+  }
+  const { minValue, maxValue } = conf;
+  const targetBinCount = getTargetBinCountForEqualSizeBinsStrategy(
+    conf.strategy,
+    { hasMidpoint }
+  );
+  return createEqualSizeBins({ minValue, maxValue, targetBinCount });
+};
+const getTargetBinCountForEqualSizeBinsStrategy = (strategy, { hasMidpoint } = {}) => {
+  return match(strategy).with(
+    "equalSizeBins-few-bins",
+    () => hasMidpoint ? [1, 3] : [2, 5]
+  ).with(
+    "equalSizeBins-normal",
+    () => hasMidpoint ? [3, 6] : [5, 9]
+  ).with(
+    P.union("equalSizeBins-many-bins", "equalSizeBins-percent"),
+    () => hasMidpoint ? [4, 8] : [8, 12]
+  ).exhaustive();
+};
+const createEqualSizeBins = ({
+  minValue,
+  maxValue,
+  targetBinCount
+}) => {
+  if (minValue > maxValue) {
+    throw new Error("minValue must be less than maxValue");
+  }
+  const range = maxValue - minValue;
+  const { normalised: normalisedRange, factor } = normaliseToSingleDigitNumber(range);
+  const stepSizeCandidates = [1, 0.1, 0.5, 0.2, 2, 3, 0.3, 0.75, 0.25];
+  const stepSizeInfo = stepSizeCandidates.map((candidateStepSize) => {
+    const numSteps = Math.ceil(normalisedRange / candidateStepSize);
+    return { stepSize: candidateStepSize, numSteps };
+  });
+  let stepSize = stepSizeInfo.find(
+    (info) => info.numSteps >= targetBinCount[0] && info.numSteps <= targetBinCount[1]
+  )?.stepSize;
+  if (stepSize === void 0) {
+    console.warn(
+      "Equal size binning: Couldn't find a step size fitting targetBinCount; instead using next-best candidate",
+      { targetBinCount, minValue, maxValue }
+    );
+    const stepSizeDifference = (candidate) => Math.max(candidate - targetBinCount[1], 0) * 1 + // this is how many more bins there are than targetBinCount specifies
+    Math.max(targetBinCount[0] - candidate, 0) * 2;
+    stepSize = R.firstBy(
+      stepSizeInfo,
+      (info) => stepSizeDifference(info.numSteps)
+    )?.stepSize;
+  }
+  if (stepSize === void 0) {
+    throw new Error("Could not find a valid step size");
+  }
+  const actualStepSize = stepSize * factor;
+  const minValueRounded = Math.floor(minValue / actualStepSize) * actualStepSize;
+  const steps = Math.ceil((maxValue - minValueRounded) / actualStepSize);
+  return R.range(0, steps + 1).map((i) => {
+    const value = i * actualStepSize;
+    return minValueRounded + roundSigFig(value, 3);
+  });
+};
+export {
+  createEqualSizeBins,
+  isEqualSizeBinningStrategy,
+  runEqualSizeBinningStrategy
+};

package/dist/grapher/color/BinningStrategyEqualSizeBins.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/grapher/color/BinningStrategyEqualSizeBins.ts"],
+  "sourcesContent": ["import {\n    BinningStrategyIncludingManual,\n    EqualSizeBinningStrategy,\n    ResolvedBinningStrategy,\n} from \"../../types/index.js\"\nimport {\n    normaliseToSingleDigitNumber,\n    RequiredBy,\n    roundSigFig,\n} from \"../../utils/index.js\"\nimport * as R from \"remeda\"\nimport { match, P } from \"ts-pattern\"\nimport { ResolvedBinningStrategyConfig } from \"./BinningStrategies.js\"\n\nexport const isEqualSizeBinningStrategy = (\n    strategy: BinningStrategyIncludingManual | ResolvedBinningStrategy\n): strategy is EqualSizeBinningStrategy => strategy.startsWith(\"equalSizeBins-\")\n\nexport const runEqualSizeBinningStrategy = (\n    conf: RequiredBy<ResolvedBinningStrategyConfig, \"minValue\" | \"maxValue\">,\n    { hasMidpoint }: { hasMidpoint?: boolean } = {}\n): number[] => {\n    if (!isEqualSizeBinningStrategy(conf.strategy)) {\n        throw new Error(\"Invalid strategy\")\n    }\n\n    const { minValue, maxValue } = conf\n    const targetBinCount = getTargetBinCountForEqualSizeBinsStrategy(\n        conf.strategy,\n        { hasMidpoint }\n    )\n    return createEqualSizeBins({ minValue, maxValue, targetBinCount })\n}\n\n/**\n * The equal-size binning strategies all operate with a range of target bins depending on the strategy.\n * For example, [5, 9] means that there should be at least 5 bins and at most 9.\n * If there is a midpoint, the number of bins needs to be adjusted downward, because we are potentially\n * creating up to twice as many bins overall.\n */\nconst getTargetBinCountForEqualSizeBinsStrategy = (\n    strategy: EqualSizeBinningStrategy,\n    { hasMidpoint }: { hasMidpoint?: boolean } = {}\n): readonly [number, number] => {\n    return match(strategy)\n        .with(\"equalSizeBins-few-bins\", () =>\n            hasMidpoint ? ([1, 3] as const) : ([2, 5] as const)\n        )\n        .with(\"equalSizeBins-normal\", () =>\n            hasMidpoint ? ([3, 6] as const) : ([5, 9] as const)\n        )\n        .with(\n            P.union(\"equalSizeBins-many-bins\", \"equalSizeBins-percent\"),\n            () => (hasMidpoint ? ([4, 8] as const) : ([8, 12] as const))\n        )\n        .exhaustive()\n}\n\nexport const createEqualSizeBins = ({\n    minValue,\n    maxValue,\n    targetBinCount,\n}: {\n    minValue: number\n    maxValue: number\n    targetBinCount: readonly number[]\n}): number[] => {\n    if (minValue > maxValue) {\n        throw new Error(\"minValue must be less than maxValue\")\n    }\n\n    const range = maxValue - minValue\n\n    // Normalise the range to be within 1 and 10\n    const { normalised: normalisedRange, factor } =\n        normaliseToSingleDigitNumber(range)\n\n    // These are all common and \"good\" step sizes\n    const stepSizeCandidates = [1, 0.1, 0.5, 0.2, 2, 3, 0.3, 0.75, 0.25]\n\n    // Compute the number of bins we would get for each candidate step size\n    const stepSizeInfo = stepSizeCandidates.map((candidateStepSize) => {\n        // if (normalisedRange === 0) return true\n\n        const numSteps = Math.ceil(normalisedRange / candidateStepSize)\n        return { stepSize: candidateStepSize, numSteps }\n        // return numSteps >= targetBinCount[0] && numSteps <= targetBinCount[1]\n    })\n\n    // Find the first step size that gives us the target bin count\n    let stepSize = stepSizeInfo.find(\n        (info) =>\n            info.numSteps >= targetBinCount[0] &&\n            info.numSteps <= targetBinCount[1]\n    )?.stepSize\n\n    if (stepSize === undefined) {\n        // It could be interesting to see which charts cause this\n        console.warn(\n            \"Equal size binning: Couldn't find a step size fitting targetBinCount; instead using next-best candidate\",\n            { targetBinCount, minValue, maxValue }\n        )\n\n        // prefer too many bins over too few (by weighing \"too many\" less highly than \"too few\")\n        const stepSizeDifference = (candidate: number): number =>\n            Math.max(candidate - targetBinCount[1], 0) * 1 + // this is how many more bins there are than targetBinCount specifies\n            Math.max(targetBinCount[0] - candidate, 0) * 2 // and this is how many fewer there are\n\n        // Find the step size that minimizes the distance function, i.e. such that we are not much above/below what targetBinCount requests\n        stepSize = R.firstBy(stepSizeInfo, (info) =>\n            stepSizeDifference(info.numSteps)\n        )?.stepSize\n    }\n\n    if (stepSize === undefined) {\n        // This should never happen\n        throw new Error(\"Could not find a valid step size\")\n    }\n\n    const actualStepSize = stepSize * factor\n\n    // Round min value to step size, e.g. if the step size is 20 then this would round 50 down to 40\n    const minValueRounded =\n        Math.floor(minValue / actualStepSize) * actualStepSize\n\n    const steps = Math.ceil((maxValue - minValueRounded) / actualStepSize)\n\n    return R.range(0, steps + 1).map((i) => {\n        const value = i * actualStepSize\n        return minValueRounded + roundSigFig(value, 3) // to avoid floating point issues\n    })\n}\n"],
+  "mappings": "AAKA;AAAA,EACI;AAAA,EAEA;AAAA,OACG;AACP,YAAY,OAAO;AACnB,SAAS,OAAO,SAAS;AAGlB,MAAM,6BAA6B,CACtC,aACuC,SAAS,WAAW,gBAAgB;AAExE,MAAM,8BAA8B,CACvC,MACA,EAAE,YAAY,IAA+B,CAAC,MACnC;AACX,MAAI,CAAC,2BAA2B,KAAK,QAAQ,GAAG;AAC5C,UAAM,IAAI,MAAM,kBAAkB;AAAA,EACtC;AAEA,QAAM,EAAE,UAAU,SAAS,IAAI;AAC/B,QAAM,iBAAiB;AAAA,IACnB,KAAK;AAAA,IACL,EAAE,YAAY;AAAA,EAClB;AACA,SAAO,oBAAoB,EAAE,UAAU,UAAU,eAAe,CAAC;AACrE;AAQA,MAAM,4CAA4C,CAC9C,UACA,EAAE,YAAY,IAA+B,CAAC,MAClB;AAC5B,SAAO,MAAM,QAAQ,EAChB;AAAA,IAAK;AAAA,IAA0B,MAC5B,cAAe,CAAC,GAAG,CAAC,IAAe,CAAC,GAAG,CAAC;AAAA,EAC5C,EACC;AAAA,IAAK;AAAA,IAAwB,MAC1B,cAAe,CAAC,GAAG,CAAC,IAAe,CAAC,GAAG,CAAC;AAAA,EAC5C,EACC;AAAA,IACG,EAAE,MAAM,2BAA2B,uBAAuB;AAAA,IAC1D,MAAO,cAAe,CAAC,GAAG,CAAC,IAAe,CAAC,GAAG,EAAE;AAAA,EACpD,EACC,WAAW;AACpB;AAEO,MAAM,sBAAsB,CAAC;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AACJ,MAIgB;AACZ,MAAI,WAAW,UAAU;AACrB,UAAM,IAAI,MAAM,qCAAqC;AAAA,EACzD;AAEA,QAAM,QAAQ,WAAW;AAGzB,QAAM,EAAE,YAAY,iBAAiB,OAAO,IACxC,6BAA6B,KAAK;AAGtC,QAAM,qBAAqB,CAAC,GAAG,KAAK,KAAK,KAAK,GAAG,GAAG,KAAK,MAAM,IAAI;AAGnE,QAAM,eAAe,mBAAmB,IAAI,CAAC,sBAAsB;AAG/D,UAAM,WAAW,KAAK,KAAK,kBAAkB,iBAAiB;AAC9D,WAAO,EAAE,UAAU,mBAAmB,SAAS;AAAA,EAEnD,CAAC;AAGD,MAAI,WAAW,aAAa;AAAA,IACxB,CAAC,SACG,KAAK,YAAY,eAAe,CAAC,KACjC,KAAK,YAAY,eAAe,CAAC;AAAA,EACzC,GAAG;AAEH,MAAI,aAAa,QAAW;AAExB,YAAQ;AAAA,MACJ;AAAA,MACA,EAAE,gBAAgB,UAAU,SAAS;AAAA,IACzC;AAGA,UAAM,qBAAqB,CAAC,cACxB,KAAK,IAAI,YAAY,eAAe,CAAC,GAAG,CAAC,IAAI;AAAA,IAC7C,KAAK,IAAI,eAAe,CAAC,IAAI,WAAW,CAAC,IAAI;AAGjD,eAAW,EAAE;AAAA,MAAQ;AAAA,MAAc,CAAC,SAChC,mBAAmB,KAAK,QAAQ;AAAA,IACpC,GAAG;AAAA,EACP;AAEA,MAAI,aAAa,QAAW;AAExB,UAAM,IAAI,MAAM,kCAAkC;AAAA,EACtD;AAEA,QAAM,iBAAiB,WAAW;AAGlC,QAAM,kBACF,KAAK,MAAM,WAAW,cAAc,IAAI;AAE5C,QAAM,QAAQ,KAAK,MAAM,WAAW,mBAAmB,cAAc;AAErE,SAAO,EAAE,MAAM,GAAG,QAAQ,CAAC,EAAE,IAAI,CAAC,MAAM;AACpC,UAAM,QAAQ,IAAI;AAClB,WAAO,kBAAkB,YAAY,OAAO,CAAC;AAAA,EACjD,CAAC;AACL;",
+  "names": []
+}

package/dist/grapher/color/BinningStrategyLogarithmic.d.ts

@@ -0,0 +1,8 @@
+import { RequiredBy } from "../../utils/index.js";
+import { BinningStrategyIncludingManual, LogBinningStrategy } from "../../types/index.js";
+import { ResolvedBinningStrategyConfig } from "./BinningStrategies.js";
+export declare const isLogBinningStrategy: (strategy: BinningStrategyIncludingManual) => strategy is LogBinningStrategy;
+export declare const runLogBinningStrategy: (conf: RequiredBy<ResolvedBinningStrategyConfig, "minValue" | "maxValue">, { hasMidpoint }?: {
+    hasMidpoint?: boolean;
+}) => number[];
+//# sourceMappingURL=BinningStrategyLogarithmic.d.ts.map

package/dist/grapher/color/BinningStrategyLogarithmic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinningStrategyLogarithmic.d.ts","sourceRoot":"","sources":["../../../src/grapher/color/BinningStrategyLogarithmic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAClE,OAAO,EACH,8BAA8B,EAC9B,kBAAkB,EAErB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAGH,6BAA6B,EAChC,MAAM,wBAAwB,CAAA;AAI/B,eAAO,MAAM,oBAAoB,GAC7B,UAAU,8BAA8B,KACzC,QAAQ,IAAI,kBAAiD,CAAA;AA2BhE,eAAO,MAAM,qBAAqB,GAC9B,MAAM,UAAU,CAAC,6BAA6B,EAAE,UAAU,GAAG,UAAU,CAAC,EACxE,kBAAiB;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAO,KAChD,MAAM,EAsCR,CAAA"}

package/dist/grapher/color/BinningStrategyLogarithmic.js

@@ -0,0 +1,70 @@
+import { numberMagnitude } from "../../utils/index.js";
+import {
+  calcMagnitudeDiff,
+  pruneUnusedBins
+} from "./BinningStrategies.js";
+import * as R from "remeda";
+import { match } from "ts-pattern";
+const isLogBinningStrategy = (strategy) => strategy.startsWith("log-");
+const autoChooseLogBinningStrategy = (magnitudeDiff) => {
+  if (magnitudeDiff >= 3.6) {
+    return "log-10";
+  }
+  if (magnitudeDiff >= 2.6) {
+    return "log-1-3";
+  }
+  return "log-1-2-5";
+};
+const runLogBinningStrategy = (conf, { hasMidpoint } = {}) => {
+  const { minValue, maxValue } = conf;
+  if (minValue <= 0 || maxValue <= 0) {
+    throw new Error("Log binning strategy only supports positive values");
+  }
+  let resolvedStrategy;
+  if (conf.strategy === "log-auto") {
+    let magnitudeDiff = calcMagnitudeDiff(minValue, maxValue);
+    if (hasMidpoint) magnitudeDiff *= 1.8;
+    resolvedStrategy = autoChooseLogBinningStrategy(magnitudeDiff);
+  } else {
+    resolvedStrategy = conf.strategy;
+  }
+  const bins = match(resolvedStrategy).with(
+    "log-10",
+    () => createLogBins({ minValue, maxValue, logSteps: [1] })
+  ).with(
+    "log-1-3",
+    () => createLogBins({ minValue, maxValue, logSteps: [1, 3] })
+  ).with(
+    "log-1-2-5",
+    () => createLogBins({ minValue, maxValue, logSteps: [1, 2, 5] })
+  ).exhaustive();
+  if (!hasMidpoint && conf.midpoint !== void 0 && bins[0] > conf.midpoint) {
+    bins.unshift(conf.midpoint);
+  }
+  return bins;
+};
+const createLogBins = ({
+  minValue,
+  maxValue,
+  logSteps
+}) => {
+  if (minValue <= 0 || maxValue <= 0) {
+    throw new Error("createLogBins only supports positive values");
+  }
+  const exponentMin = numberMagnitude(minValue) - 1;
+  const exponentMax = numberMagnitude(maxValue) - 1;
+  const candidates = R.range(exponentMin, exponentMax + 1).flatMap(
+    (magnitude) => {
+      const factor = Math.pow(10, magnitude);
+      return logSteps.map((step) => step * factor);
+    }
+  );
+  if ((R.last(candidates) ?? 0) < maxValue) {
+    candidates.push(1 * Math.pow(10, exponentMax + 1));
+  }
+  return pruneUnusedBins(candidates, { minValue, maxValue });
+};
+export {
+  isLogBinningStrategy,
+  runLogBinningStrategy
+};