@ds-mo/ui 13.6.1 → 13.7.0

package/dist/lib/utils/index.js

@@ -288,6 +288,9 @@ import {
   dimensionSpace200,
   dimensionSpace300,
   dimensionSpace400,
+  dimensionStrokeWidth012,
+  dimensionStrokeWidth025,
+  dimensionStrokeWidth037,
   typographyLineheightLg,
   typographyLineheightMd,
   typographyLineheightSm,
@@ -310,6 +313,9 @@ var TOKEN_DEFAULTS = {
   space300: dimensionSpace300,
   space400: dimensionSpace400,
   radius025: dimensionRadius025,
+  strokeWidth012: dimensionStrokeWidth012,
+  strokeWidth025: dimensionStrokeWidth025,
+  strokeWidth037: dimensionStrokeWidth037,
   size200: dimensionSize200,
   size300: dimensionSize300,
   size400: dimensionSize400,
@@ -422,6 +428,479 @@ function controlWidthClass(width) {
   };
 }
 
+// node_modules/d3-array/src/ascending.js
+function ascending(a, b) {
+  return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+}
+
+// node_modules/d3-array/src/descending.js
+function descending(a, b) {
+  return a == null || b == null ? NaN : b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
+}
+
+// node_modules/d3-array/src/bisector.js
+function bisector(f) {
+  let compare1, compare2, delta;
+  if (f.length !== 2) {
+    compare1 = ascending;
+    compare2 = (d, x) => ascending(f(d), x);
+    delta = (d, x) => f(d) - x;
+  } else {
+    compare1 = f === ascending || f === descending ? f : zero;
+    compare2 = f;
+    delta = f;
+  }
+  function left(a, x, lo = 0, hi = a.length) {
+    if (lo < hi) {
+      if (compare1(x, x) !== 0) return hi;
+      do {
+        const mid = lo + hi >>> 1;
+        if (compare2(a[mid], x) < 0) lo = mid + 1;
+        else hi = mid;
+      } while (lo < hi);
+    }
+    return lo;
+  }
+  function right(a, x, lo = 0, hi = a.length) {
+    if (lo < hi) {
+      if (compare1(x, x) !== 0) return hi;
+      do {
+        const mid = lo + hi >>> 1;
+        if (compare2(a[mid], x) <= 0) lo = mid + 1;
+        else hi = mid;
+      } while (lo < hi);
+    }
+    return lo;
+  }
+  function center(a, x, lo = 0, hi = a.length) {
+    const i = left(a, x, lo, hi - 1);
+    return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
+  }
+  return { left, center, right };
+}
+function zero() {
+  return 0;
+}
+
+// node_modules/d3-array/src/number.js
+function number(x) {
+  return x === null ? NaN : +x;
+}
+
+// node_modules/d3-array/src/bisect.js
+var ascendingBisect = bisector(ascending);
+var bisectRight = ascendingBisect.right;
+var bisectLeft = ascendingBisect.left;
+var bisectCenter = bisector(number).center;
+var bisect_default = bisectRight;
+
+// node_modules/d3-array/src/count.js
+function count(values, valueof) {
+  let count2 = 0;
+  if (valueof === void 0) {
+    for (let value of values) {
+      if (value != null && (value = +value) >= value) {
+        ++count2;
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+        ++count2;
+      }
+    }
+  }
+  return count2;
+}
+
+// node_modules/d3-array/src/variance.js
+function variance(values, valueof) {
+  let count2 = 0;
+  let delta;
+  let mean = 0;
+  let sum = 0;
+  if (valueof === void 0) {
+    for (let value of values) {
+      if (value != null && (value = +value) >= value) {
+        delta = value - mean;
+        mean += delta / ++count2;
+        sum += delta * (value - mean);
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
+        delta = value - mean;
+        mean += delta / ++count2;
+        sum += delta * (value - mean);
+      }
+    }
+  }
+  if (count2 > 1) return sum / (count2 - 1);
+}
+
+// node_modules/d3-array/src/deviation.js
+function deviation(values, valueof) {
+  const v = variance(values, valueof);
+  return v ? Math.sqrt(v) : v;
+}
+
+// node_modules/d3-array/src/extent.js
+function extent(values, valueof) {
+  let min;
+  let max;
+  if (valueof === void 0) {
+    for (const value of values) {
+      if (value != null) {
+        if (min === void 0) {
+          if (value >= value) min = max = value;
+        } else {
+          if (min > value) min = value;
+          if (max < value) max = value;
+        }
+      }
+    }
+  } else {
+    let index = -1;
+    for (let value of values) {
+      if ((value = valueof(value, ++index, values)) != null) {
+        if (min === void 0) {
+          if (value >= value) min = max = value;
+        } else {
+          if (min > value) min = value;
+          if (max < value) max = value;
+        }
+      }
+    }
+  }
+  return [min, max];
+}
+
+// node_modules/d3-array/src/identity.js
+function identity(x) {
+  return x;
+}
+
+// node_modules/d3-array/src/array.js
+var array = Array.prototype;
+var slice = array.slice;
+var map = array.map;
+
+// node_modules/d3-array/src/constant.js
+function constant(x) {
+  return () => x;
+}
+
+// node_modules/d3-array/src/ticks.js
+var e10 = Math.sqrt(50);
+var e5 = Math.sqrt(10);
+var e2 = Math.sqrt(2);
+function tickSpec(start, stop, count2) {
+  const step = (stop - start) / Math.max(0, count2), power = Math.floor(Math.log10(step)), error = step / Math.pow(10, power), factor = error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1;
+  let i1, i2, inc;
+  if (power < 0) {
+    inc = Math.pow(10, -power) / factor;
+    i1 = Math.round(start * inc);
+    i2 = Math.round(stop * inc);
+    if (i1 / inc < start) ++i1;
+    if (i2 / inc > stop) --i2;
+    inc = -inc;
+  } else {
+    inc = Math.pow(10, power) * factor;
+    i1 = Math.round(start / inc);
+    i2 = Math.round(stop / inc);
+    if (i1 * inc < start) ++i1;
+    if (i2 * inc > stop) --i2;
+  }
+  if (i2 < i1 && 0.5 <= count2 && count2 < 2) return tickSpec(start, stop, count2 * 2);
+  return [i1, i2, inc];
+}
+function ticks(start, stop, count2) {
+  stop = +stop, start = +start, count2 = +count2;
+  if (!(count2 > 0)) return [];
+  if (start === stop) return [start];
+  const reverse = stop < start, [i1, i2, inc] = reverse ? tickSpec(stop, start, count2) : tickSpec(start, stop, count2);
+  if (!(i2 >= i1)) return [];
+  const n = i2 - i1 + 1, ticks2 = new Array(n);
+  if (reverse) {
+    if (inc < 0) for (let i = 0; i < n; ++i) ticks2[i] = (i2 - i) / -inc;
+    else for (let i = 0; i < n; ++i) ticks2[i] = (i2 - i) * inc;
+  } else {
+    if (inc < 0) for (let i = 0; i < n; ++i) ticks2[i] = (i1 + i) / -inc;
+    else for (let i = 0; i < n; ++i) ticks2[i] = (i1 + i) * inc;
+  }
+  return ticks2;
+}
+function tickIncrement(start, stop, count2) {
+  stop = +stop, start = +start, count2 = +count2;
+  return tickSpec(start, stop, count2)[2];
+}
+
+// node_modules/d3-array/src/nice.js
+function nice(start, stop, count2) {
+  let prestep;
+  while (true) {
+    const step = tickIncrement(start, stop, count2);
+    if (step === prestep || step === 0 || !isFinite(step)) {
+      return [start, stop];
+    } else if (step > 0) {
+      start = Math.floor(start / step) * step;
+      stop = Math.ceil(stop / step) * step;
+    } else if (step < 0) {
+      start = Math.ceil(start * step) / step;
+      stop = Math.floor(stop * step) / step;
+    }
+    prestep = step;
+  }
+}
+
+// node_modules/d3-array/src/threshold/sturges.js
+function thresholdSturges(values) {
+  return Math.max(1, Math.ceil(Math.log(count(values)) / Math.LN2) + 1);
+}
+
+// node_modules/d3-array/src/bin.js
+function bin() {
+  var value = identity, domain = extent, threshold = thresholdSturges;
+  function histogram(data) {
+    if (!Array.isArray(data)) data = Array.from(data);
+    var i, n = data.length, x, step, values = new Array(n);
+    for (i = 0; i < n; ++i) {
+      values[i] = value(data[i], i, data);
+    }
+    var xz = domain(values), x0 = xz[0], x1 = xz[1], tz = threshold(values, x0, x1);
+    if (!Array.isArray(tz)) {
+      const max = x1, tn = +tz;
+      if (domain === extent) [x0, x1] = nice(x0, x1, tn);
+      tz = ticks(x0, x1, tn);
+      if (tz[0] <= x0) step = tickIncrement(x0, x1, tn);
+      if (tz[tz.length - 1] >= x1) {
+        if (max >= x1 && domain === extent) {
+          const step2 = tickIncrement(x0, x1, tn);
+          if (isFinite(step2)) {
+            if (step2 > 0) {
+              x1 = (Math.floor(x1 / step2) + 1) * step2;
+            } else if (step2 < 0) {
+              x1 = (Math.ceil(x1 * -step2) + 1) / -step2;
+            }
+          }
+        } else {
+          tz.pop();
+        }
+      }
+    }
+    var m = tz.length, a = 0, b = m;
+    while (tz[a] <= x0) ++a;
+    while (tz[b - 1] > x1) --b;
+    if (a || b < m) tz = tz.slice(a, b), m = b - a;
+    var bins = new Array(m + 1), bin2;
+    for (i = 0; i <= m; ++i) {
+      bin2 = bins[i] = [];
+      bin2.x0 = i > 0 ? tz[i - 1] : x0;
+      bin2.x1 = i < m ? tz[i] : x1;
+    }
+    if (isFinite(step)) {
+      if (step > 0) {
+        for (i = 0; i < n; ++i) {
+          if ((x = values[i]) != null && x0 <= x && x <= x1) {
+            bins[Math.min(m, Math.floor((x - x0) / step))].push(data[i]);
+          }
+        }
+      } else if (step < 0) {
+        for (i = 0; i < n; ++i) {
+          if ((x = values[i]) != null && x0 <= x && x <= x1) {
+            const j = Math.floor((x0 - x) * step);
+            bins[Math.min(m, j + (tz[j] <= x))].push(data[i]);
+          }
+        }
+      }
+    } else {
+      for (i = 0; i < n; ++i) {
+        if ((x = values[i]) != null && x0 <= x && x <= x1) {
+          bins[bisect_default(tz, x, 0, m)].push(data[i]);
+        }
+      }
+    }
+    return bins;
+  }
+  histogram.value = function(_) {
+    return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
+  };
+  histogram.domain = function(_) {
+    return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
+  };
+  histogram.thresholds = function(_) {
+    return arguments.length ? (threshold = typeof _ === "function" ? _ : constant(Array.isArray(_) ? slice.call(_) : _), histogram) : threshold;
+  };
+  return histogram;
+}
+
+// node_modules/d3-array/src/quantile.js
+function quantileSorted(values, p, valueof = number) {
+  if (!(n = values.length) || isNaN(p = +p)) return;
+  if (p <= 0 || n < 2) return +valueof(values[0], 0, values);
+  if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+  var n, i = (n - 1) * p, i0 = Math.floor(i), value0 = +valueof(values[i0], i0, values), value1 = +valueof(values[i0 + 1], i0 + 1, values);
+  return value0 + (value1 - value0) * (i - i0);
+}
+
+// src/wc/utils/chart-grammar.ts
+function defineChart(chart) {
+  return { chart };
+}
+function createMark(kind, data, options) {
+  return { kind, data, options };
+}
+function polar(options) {
+  return { kind: "polar", data: [], options };
+}
+var identity2 = (value) => value;
+function lineY(data, options = {}) {
+  return createMark("line-y", data, { x: options.x ?? ((_, index) => index), y: options.y ?? identity2, ...options });
+}
+function areaY(data, options = {}) {
+  return createMark("area-y", data, { x: options.x ?? ((_, index) => index), y: options.y ?? identity2, ...options });
+}
+function barY(data, options = {}) {
+  return createMark("bar-y", data, { x: options.x ?? ((_, index) => index), y: options.y ?? identity2, ...options });
+}
+function barX(data, options = {}) {
+  return createMark("bar-x", data, { x: options.x ?? identity2, y: options.y ?? ((_, index) => index), ...options });
+}
+function boxY(data, options = {}) {
+  return createMark("box-y", data, { x: options.x ?? (() => "distribution"), y: options.y ?? identity2, ...options });
+}
+function dot(data, options = {}) {
+  return createMark("dot", data, { x: options.x ?? ((_, index) => index), y: options.y ?? identity2, ...options });
+}
+function ruleX(data, options = {}) {
+  return createMark("rule-x", data, { x: options.x ?? identity2, ...options });
+}
+function ruleY(data, options = {}) {
+  return createMark("rule-y", data, { y: options.y ?? identity2, ...options });
+}
+function bandX(data, options) {
+  return createMark("band-x", data, options);
+}
+function bandY(data, options) {
+  return createMark("band-y", data, options);
+}
+function rect(data, options) {
+  return createMark("rect", data, options);
+}
+function cell(data, options) {
+  return createMark("cell", data, options);
+}
+function textMark(data, options = {}) {
+  return createMark("text", data, { x: options.x ?? ((_, index) => index), y: options.y ?? ((_, index) => index), text: options.text ?? identity2, ...options });
+}
+function arcMark(data, options = {}) {
+  return createMark("arc", data, { theta1: options.theta1 ?? "theta1", theta2: options.theta2 ?? "theta2", ...options });
+}
+function radialLine(data, options = {}) {
+  return createMark("radial-line", data, { angle: options.angle ?? ((_, index) => index), radius: options.radius ?? identity2, ...options });
+}
+function radialArea(data, options = {}) {
+  return createMark("radial-area", data, { angle: options.angle ?? ((_, index) => index), radius: options.radius ?? identity2, ...options });
+}
+function radialDot(data, options = {}) {
+  return createMark("radial-dot", data, { angle: options.angle ?? ((_, index) => index), radius: options.radius ?? identity2, ...options });
+}
+function channelValue(datum, index, data, channel) {
+  if (channel === void 0) return void 0;
+  if (typeof channel === "function") return channel(datum, index, data);
+  if (datum == null || typeof datum !== "object") return void 0;
+  return datum[channel];
+}
+function normalizeStack(data, options) {
+  const rows = data.map((datum, index) => {
+    const group = channelValue(datum, index, data, options.group);
+    const series = channelValue(datum, index, data, options.series);
+    const value = channelValue(datum, index, data, options.value);
+    if (group === void 0 || series === void 0) throw new TypeError("normalizeStack requires a group and series key for every row.");
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new RangeError("normalizeStack values must be finite, non-negative numbers.");
+    return { data: datum, group, series, value };
+  });
+  const totals = /* @__PURE__ */ new Map();
+  rows.forEach((row) => totals.set(chartValueKey(row.group), (totals.get(chartValueKey(row.group)) ?? 0) + row.value));
+  return rows.map((row) => ({ ...row, proportion: (totals.get(chartValueKey(row.group)) ?? 0) > 0 ? row.value / totals.get(chartValueKey(row.group)) : 0 }));
+}
+function pieLayout(data, options) {
+  const ordered = data.map((datum, index) => ({ datum, index }));
+  if (options.sort) ordered.sort((a, b) => options.sort?.(a.datum, b.datum) ?? 0);
+  const values = ordered.map(({ datum, index }) => {
+    const value = channelValue(datum, index, data, options.value);
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+  });
+  const total = values.reduce((sum, value) => sum + value, 0);
+  let position = 0;
+  return ordered.flatMap(({ datum, index }, orderedIndex) => {
+    const value = values[orderedIndex] ?? 0;
+    if (!(value > 0) || !(total > 0)) return [];
+    const theta1 = position;
+    position += value / total;
+    const key = channelValue(datum, index, data, options.key) ?? index;
+    const label = channelValue(datum, index, data, options.label) ?? String(key);
+    return [{ data: datum, index, key, label, value, theta1, theta2: position }];
+  });
+}
+function binX(data, options) {
+  const generator = bin().value((datum, index, rows) => channelValue(datum, index, Array.from(rows), options.value) ?? Number.NaN);
+  if (typeof options.thresholds === "number") generator.thresholds(options.thresholds);
+  else if (options.thresholds !== void 0) generator.thresholds([...options.thresholds]);
+  const bins = generator(data);
+  let cumulative = 0;
+  return bins.flatMap((bin2) => {
+    const x1 = bin2.x0;
+    const x2 = bin2.x1;
+    if (x1 === void 0 || x2 === void 0) return [];
+    cumulative += bin2.length;
+    return [{ key: `bin:${x1}:${x2}`, x1, x2, x: (x1 + x2) / 2, count: bin2.length, cumulative, rows: [...bin2] }];
+  });
+}
+function cumulativeBins(bins) {
+  let cumulative = 0;
+  return bins.map((bin2) => ({ ...bin2, cumulative: cumulative += bin2.count }));
+}
+function densityX(data, options) {
+  const values = data.map((datum, index) => channelValue(datum, index, data, options.value)).filter((value) => typeof value === "number" && Number.isFinite(value)).sort((a, b) => a - b);
+  if (values.length === 0) return [];
+  const [minimum = 0, maximum = minimum + 1] = extent(values);
+  const span = Math.max(Number.EPSILON, maximum - minimum);
+  const sampleCount = Math.max(8, options.samples ?? 48);
+  const sampleValues = ticks(minimum, maximum, sampleCount);
+  const sigma = deviation(values) ?? span / 6;
+  const bandwidth = Math.max(Number.EPSILON, options.bandwidth ?? 1.06 * sigma * Math.pow(values.length, -0.2));
+  const normalizer = 1 / (Math.sqrt(2 * Math.PI) * bandwidth * values.length);
+  return sampleValues.map((x) => ({
+    key: `density:${x}`,
+    x,
+    density: values.reduce((sum, value) => {
+      const u = (x - value) / bandwidth;
+      return sum + Math.exp(-0.5 * u * u);
+    }, 0) * normalizer
+  }));
+}
+function boxStatistics(values, whisker = 1.5) {
+  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (sorted.length === 0) return void 0;
+  const q1 = quantileSorted(sorted, 0.25);
+  const median = quantileSorted(sorted, 0.5);
+  const q3 = quantileSorted(sorted, 0.75);
+  const iqr = q3 - q1;
+  const lowerFence = q1 - whisker * iqr;
+  const upperFence = q3 + whisker * iqr;
+  const lower = sorted.find((value) => value >= lowerFence) ?? sorted[0];
+  const upper = [...sorted].reverse().find((value) => value <= upperFence) ?? sorted[sorted.length - 1];
+  return { q1, median, q3, lower, upper, outliers: sorted.filter((value) => value < lower || value > upper) };
+}
+function chartValueKey(value) {
+  if (value instanceof Date) return `date:${value.getTime()}`;
+  return `${typeof value}:${String(value)}`;
+}
+
 // src/wc/utils/control-text.ts
 var CONTROL_TEXT_VARIANT = {
   lg: "text-body-large",
@@ -457,15 +936,37 @@ export {
   SCROLL_EDGE_FADE_SIZE_VAR,
   TOKEN_CSS_LENGTHS,
   TOKEN_DEFAULTS,
+  arcMark,
+  areaY,
+  bandX,
+  bandY,
+  barX,
+  barY,
+  binX,
+  boxStatistics,
+  boxY,
+  cell,
   choicePopupMinWidth,
   clearCssLengthPxCache,
   computeMetricChange,
   controlWidthClass,
+  cumulativeBins,
+  defineChart,
+  densityX,
+  dot,
   formatCompactNumber,
   formatPercentage,
   isScrollAtEdge,
+  lineY,
+  normalizeStack,
   parseCssTimeMs,
+  pieLayout,
+  polar,
   prefersReducedMotion,
+  radialArea,
+  radialDot,
+  radialLine,
+  rect,
   registerIcons,
   resolveChoicePopupAlignOffset,
   resolveCssLengthPx,
@@ -477,6 +978,8 @@ export {
   restoreNumberArrayFormState,
   restoreStringArrayFormState,
   restoreStringFormState,
+  ruleX,
+  ruleY,
   scrollEdgeFadeClassMap,
   scrollEdgeFadeMaskImage,
   scrollEdgeFadeMaskStyle,
@@ -484,6 +987,7 @@ export {
   setFormControlValue,
   setRepeatedFormControlValue,
   setRequiredValidity,
+  textMark,
   truncateSvgTextToWidth
 };
 //# sourceMappingURL=index.js.map