@x12i/charts 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,3 +1,106 @@
+import {
+  AXIS_FONT_SIZE,
+  DEFAULT_LOCALE,
+  ExpressionError,
+  MAX_HUES,
+  SVG_POINT_LIMIT,
+  TICK_PADDING,
+  TICK_SIZE,
+  annotationTone,
+  applyTransforms,
+  buildChartModel,
+  capitalize,
+  categoricalTones,
+  chartToCsv,
+  chartToTable,
+  checkWhere,
+  compileWhere,
+  computeAxisMargins,
+  correlation,
+  countPoints,
+  createBandScale,
+  createContinuousScale,
+  createDateFormatter,
+  createFormatters,
+  createNumberFormatter,
+  createPointScale,
+  createTimeTickFormatter,
+  cumulativeSum,
+  dashArrays,
+  dashStyles,
+  defaultMessages,
+  describeChart,
+  describeModel,
+  describeTarget,
+  divergingColor,
+  dodgePositions,
+  effectiveStack,
+  escapeCsvField,
+  estimateTextWidth,
+  evaluateWhere,
+  extent,
+  fitTickLabels,
+  forecastLinear,
+  formatList,
+  formatMessage,
+  formatShare,
+  fractionDigitsForStep,
+  histogramBins,
+  hitTest,
+  isNavKey,
+  isOpenMarker,
+  isRtlLocale,
+  isSupportedMark,
+  layoutChart,
+  linearRegression,
+  lttb,
+  lttbIndices,
+  markerPath,
+  markerShapes,
+  mean,
+  median,
+  minMax,
+  minMaxIndices,
+  modelToTable,
+  movingAverage,
+  navKeys,
+  navigate,
+  niceTicks,
+  patternIndex,
+  percentChange,
+  periodChange,
+  pointInfo,
+  quantile,
+  rampGradient,
+  readField,
+  regressionBand,
+  resolveMessages,
+  resolveRenderer,
+  resolveRows,
+  sequentialColor,
+  seriesStyle,
+  stackValues,
+  standardDeviation,
+  sum,
+  supportedMarks,
+  tableToCsv,
+  targetById,
+  themeColorsFromTokens,
+  toCategory,
+  toEChartsOption,
+  toNumber,
+  toTime,
+  toneCssVar,
+  toneTokenPath,
+  toneVarName,
+  tooltipFor,
+  trendDirection,
+  truncateLabel,
+  usesBandX,
+  valueDomain,
+  variance
+} from "./chunk-U3U6ZV7A.js";
+
 // src/spec.ts
 var chartTypes = [
   // Comparison
@@ -25,6 +128,7 @@ var chartTypes = [
   "ecdf",
   // Composition
   "donut",
+  "pie",
   "treemap",
   "waterfall",
   "funnel",
@@ -56,37 +160,443 @@ var chartTypes = [
   "timeline",
   "burndown",
   "cumulative-flow",
-  "calendar-heatmap"
+  "calendar-heatmap",
+  // Mixed marks on one plot (bars with lines, optionally on two axes)
+  "combo"
 ];
 function defineChartSpec(spec) {
   return spec;
 }
 
-// src/renderer.ts
-var SVG_POINT_LIMIT = 5e3;
-var CANVAS_ONLY = /* @__PURE__ */ new Set([
-  "candlestick",
-  "ohlc",
-  "sunburst",
-  "marimekko",
-  "hexbin",
-  "contour",
-  "sankey",
-  "chord",
-  "alluvial"
-]);
-function resolveRenderer({
-  renderer = "auto",
-  mark,
-  pointCount,
-  target = "screen"
-}) {
-  if (target !== "screen") return "svg";
-  if (renderer !== "auto") return renderer;
-  if (CANVAS_ONLY.has(mark)) return "canvas";
-  return pointCount > SVG_POINT_LIMIT ? "canvas" : "svg";
+// src/validate.ts
+var FIELD_TYPES = ["category", "number", "time", "boolean"];
+var SCALE_TYPES = ["linear", "log", "sqrt", "time", "band", "ordinal"];
+var STACK_MODES = ["none", "stacked", "normalized", "diverging"];
+var CARTESIAN = /* @__PURE__ */ new Set(["bar", "lollipop", "line", "area", "step", "sparkline", "combo", "scatter", "bubble", "waterfall"]);
+var MAX_SERIES = 8;
+var PROBE_ROWS = 200;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
-export { SVG_POINT_LIMIT, chartTypes, defineChartSpec, resolveRenderer };
-//# sourceMappingURL=index.js.map
+function validateChartSpec(input, options = {}) {
+  const issues = [];
+  const add = (severity, code, path, message) => {
+    issues.push({ severity, code, path, message });
+  };
+  if (!isRecord(input)) {
+    add("error", "spec-not-object", "", "A chart spec must be an object.");
+    return issues;
+  }
+  const spec = input;
+  if (typeof spec.title !== "string" || spec.title.trim() === "") {
+    add("error", "title-missing", "title", "Every chart needs a title that states the finding.");
+  }
+  if (!isRecord(spec.a11y) || typeof spec.a11y.description !== "string" || spec.a11y.description.trim() === "") {
+    add("error", "a11y-description-missing", "a11y.description", "Every chart needs an accessibility description.");
+  }
+  if (spec.version !== void 0 && spec.version !== 1) {
+    add("warning", "version-unknown", "version", `Unknown schema version ${String(spec.version)}.`);
+  }
+  const mark = spec.mark;
+  if (typeof mark !== "string" || !chartTypes.includes(mark)) {
+    add("error", "mark-invalid", "mark", `Unknown chart type "${String(mark)}".`);
+  } else if (!isSupportedMark(mark)) {
+    add("warning", "mark-unsupported", "mark", `The ${mark} chart type is not drawn by the SVG renderer; it needs a different renderer.`);
+  }
+  let rows;
+  const data = spec.data;
+  if (!isRecord(data)) {
+    add("error", "data-missing", "data", "A spec needs `data`: `{ values }` or `{ ref }`.");
+  } else if ("values" in data) {
+    if (!Array.isArray(data.values)) add("error", "data-invalid", "data.values", "`data.values` must be an array of rows.");
+    else rows = data.values;
+  } else if (typeof data.ref === "string") {
+    if (options.datasets) {
+      rows = options.datasets[data.ref];
+      if (!rows) add("error", "dataset-missing", "data.ref", `Dataset "${data.ref}" was not provided.`);
+    }
+  } else {
+    add("error", "data-invalid", "data", "`data` needs `values` or `ref`.");
+  }
+  const hasOwnSeriesData = Array.isArray(spec.series) && spec.series.length > 0 && spec.series.every((series2) => isRecord(series2) && Array.isArray(series2.points));
+  const literalGauge = (spec.mark === "gauge" || spec.mark === "progress-ring") && isRecord(spec.gauge) && typeof spec.gauge.value === "number";
+  if (rows && rows.length === 0 && !hasOwnSeriesData && !literalGauge) {
+    add("warning", "data-empty", "data", "The dataset has no rows; the chart will show its empty state.");
+  }
+  const fieldExists = (field) => {
+    if (!rows || rows.length === 0) return true;
+    return rows.slice(0, PROBE_ROWS).some((row) => isRecord(row) && readField(row, field) !== void 0);
+  };
+  const checkEncoding = (name) => {
+    const encoding = spec[name];
+    if (encoding === void 0) return;
+    if (!isRecord(encoding) || typeof encoding.field !== "string" || encoding.field === "") {
+      add("error", "encoding-invalid", name, `\`${name}\` needs a \`field\`.`);
+      return;
+    }
+    if (typeof encoding.type !== "string" || !FIELD_TYPES.includes(encoding.type)) {
+      add("error", "encoding-type-invalid", `${name}.type`, `\`${name}.type\` must be one of ${FIELD_TYPES.join(", ")}.`);
+    }
+    if (!fieldExists(encoding.field)) {
+      add("warning", "field-unknown", `${name}.field`, `No row has the field "${encoding.field}".`);
+    }
+    if ((name === "y" || name === "size") && encoding.type !== void 0 && encoding.type !== "number" && mark && CARTESIAN.has(mark)) {
+      add("warning", "encoding-type-unexpected", `${name}.type`, `\`${name}.type\` should be "number" for ${mark} charts.`);
+    }
+  };
+  ["x", "y", "color", "size", "value"].forEach(checkEncoding);
+  const series = Array.isArray(spec.series) ? spec.series : void 0;
+  const seriesList = series?.filter(isRecord) ?? [];
+  const hasSeries = seriesList.length > 0;
+  const seriesNeedY = hasSeries && seriesList.every((entry) => typeof entry.field === "string" || Array.isArray(entry.points));
+  if (mark) {
+    const needX = CARTESIAN.has(mark) || mark === "histogram" || mark === "heatmap" || mark === "pie" || mark === "donut";
+    if (needX && !spec.x && !hasOwnSeriesData) add("error", "encoding-x-missing", "x", `A ${mark} chart needs an \`x\` encoding.`);
+    const needY = CARTESIAN.has(mark) || mark === "pie" || mark === "donut" || mark === "heatmap";
+    if (needY && !spec.y && !seriesNeedY) add("error", "encoding-y-missing", "y", `A ${mark} chart needs a \`y\` encoding or series with a \`field\` or \`points\`.`);
+    if (mark === "heatmap" && !spec.value && !spec.color) add("error", "encoding-value-missing", "value", "A heatmap needs a `value` encoding for the cell color.");
+    if (mark === "bubble" && !spec.size && !seriesList.some((entry) => Array.isArray(entry.points) && entry.points.some((p) => isRecord(p) && p.size !== void 0))) {
+      add("warning", "bubble-size-missing", "size", "A bubble chart should have a `size` encoding; without it every bubble is the same size.");
+    }
+    if ((mark === "gauge" || mark === "progress-ring") && !(isRecord(spec.gauge) && typeof spec.gauge.value === "number") && !spec.value && !spec.y) {
+      add("error", "gauge-value-missing", "gauge.value", "A gauge needs `gauge.value` or a `value` encoding.");
+    }
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  seriesList.forEach((entry, index) => {
+    const path = `series[${index}]`;
+    if (typeof entry.id !== "string" || entry.id === "") {
+      add("error", "series-id-missing", `${path}.id`, "Every series needs an `id`.");
+    } else if (seenIds.has(entry.id)) {
+      add("error", "series-id-duplicate", `${path}.id`, `Series id "${entry.id}" is used twice.`);
+    } else {
+      seenIds.add(entry.id);
+    }
+    if (typeof entry.field !== "string" && !Array.isArray(entry.points) && !spec.y) {
+      add("error", "series-data-missing", path, "A series needs a `field` or its own `points`.");
+    }
+    if (typeof entry.field === "string" && !fieldExists(entry.field)) {
+      add("warning", "field-unknown", `${path}.field`, `No row has the field "${entry.field}".`);
+    }
+    if (entry.axis === "y2" && spec.dualAxis !== true) {
+      add("error", "series-axis-needs-dual-axis", `${path}.axis`, "A second value axis needs `dualAxis: true`, which adds a visible warning to the chart.");
+    }
+    if (entry.mark !== void 0 && mark !== "combo") {
+      add("warning", "series-mark-ignored", `${path}.mark`, "`series.mark` only applies when the chart type is `combo`.");
+    }
+  });
+  if (spec.dualAxis === true && !seriesList.some((entry) => entry.axis === "y2")) {
+    add("warning", "dual-axis-unused", "dualAxis", '`dualAxis` is set but no series uses `axis: "y2"`.');
+  }
+  if (mark === "combo" && hasSeries) {
+    const marks = new Set(seriesList.map((entry) => typeof entry.mark === "string" ? entry.mark : "bar"));
+    if (marks.size < 2) add("warning", "combo-single-mark", "series", "A combo chart mixes marks, for example `bar` and `line`; all series use the same one.");
+  }
+  let colorGroups = 0;
+  if (rows && isRecord(spec.color) && typeof spec.color.field === "string") {
+    const field = spec.color.field;
+    colorGroups = new Set(rows.slice(0, 5e3).map((row) => isRecord(row) ? String(readField(row, field)) : "")).size;
+  }
+  const seriesCount = hasSeries ? seriesList.length : colorGroups;
+  if (seriesCount > MAX_SERIES && mark !== "pie" && mark !== "donut" && mark !== "heatmap") {
+    add("warning", "too-many-series", hasSeries ? "series" : "color", `${seriesCount} series; charts use at most ${MAX_SERIES} hues. Group the rest as "Other" (a top-n transform does this).`);
+  }
+  if (spec.scales !== void 0 && !isRecord(spec.scales)) add("error", "scales-invalid", "scales", "`scales` must be an object.");
+  for (const axis of ["x", "y", "y2"]) {
+    const scale = isRecord(spec.scales) ? spec.scales[axis] : void 0;
+    if (scale === void 0) continue;
+    const path = `scales.${axis}`;
+    if (!isRecord(scale)) {
+      add("error", "scale-invalid", path, "A scale must be an object.");
+      continue;
+    }
+    if (scale.type !== void 0 && (typeof scale.type !== "string" || !SCALE_TYPES.includes(scale.type))) {
+      add("error", "scale-type-invalid", `${path}.type`, `Scale type must be one of ${SCALE_TYPES.join(", ")}.`);
+    }
+    if ((axis === "y" || axis === "y2") && (scale.type === "band" || scale.type === "ordinal" || scale.type === "time")) {
+      add("error", "scale-type-mismatch", `${path}.type`, `The value axis needs a quantitative scale (linear, log or sqrt), not ${String(scale.type)}.`);
+    }
+    if (scale.domain !== void 0) {
+      const quantitative = scale.type === void 0 || ["linear", "log", "sqrt", "time"].includes(String(scale.type));
+      if (!Array.isArray(scale.domain) || quantitative && scale.domain.length !== 2) {
+        add("error", "scale-domain-invalid", `${path}.domain`, "A quantitative scale domain is `[min, max]`.");
+      }
+    }
+    if (scale.padding !== void 0 && (typeof scale.padding !== "number" || scale.padding < 0 || scale.padding > 0.9)) {
+      add("error", "scale-padding-range", `${path}.padding`, "Band padding must be between 0 and 0.9.");
+    }
+    if (scale.type === "log" && rows) {
+      const field = axis === "y" ? spec.y?.field : void 0;
+      if (field && rows.slice(0, 5e3).some((row) => {
+        const value = toNumber(isRecord(row) ? readField(row, field) : void 0);
+        return value !== null && value <= 0;
+      })) {
+        add("error", "scale-log-nonpositive", path, "A log scale cannot show zero or negative values.");
+      }
+    }
+    if (axis === "y" && scale.type === void 0 && Array.isArray(scale.domain) && typeof scale.domain[0] === "number" && scale.domain[0] > 0 && (mark === "bar" || mark === "lollipop" || mark === "histogram" || mark === "area")) {
+      add("warning", "bar-baseline", `${path}.domain`, "Bars and areas should start at zero; a truncated baseline exaggerates differences.");
+    }
+  }
+  if (isRecord(spec.scales) && isRecord(spec.scales.y) && spec.scales.y.type === "log" && (mark === "bar" || mark === "area" || mark === "histogram")) {
+    add("warning", "bar-baseline", "scales.y.type", "Bars and areas on a log scale have no zero baseline.");
+  }
+  if (spec.stack !== void 0) {
+    if (typeof spec.stack !== "string" || !STACK_MODES.includes(spec.stack)) {
+      add("error", "stack-invalid", "stack", `\`stack\` must be one of ${STACK_MODES.join(", ")}.`);
+    } else if (spec.stack !== "none" && mark && !["bar", "area", "combo"].includes(mark)) {
+      add("warning", "stack-unsupported", "stack", `Stacking applies to bar, area and combo charts; ${mark} ignores it.`);
+    }
+  }
+  if (spec.orientation !== void 0 && spec.orientation !== "vertical" && spec.orientation !== "horizontal") {
+    add("error", "orientation-invalid", "orientation", "`orientation` must be vertical or horizontal.");
+  }
+  if (spec.orientation === "horizontal" && mark && !["bar", "lollipop", "waterfall"].includes(mark)) {
+    add("warning", "orientation-unsupported", "orientation", `Horizontal orientation applies to bar, lollipop and waterfall charts; ${mark} ignores it.`);
+  }
+  if (isRecord(spec.axes)) {
+    for (const axis of ["x", "y", "y2"]) {
+      const config = spec.axes[axis];
+      if (!isRecord(config)) continue;
+      if (config.ticks !== void 0 && (typeof config.ticks !== "number" || config.ticks < 1)) {
+        add("error", "axis-ticks-invalid", `axes.${axis}.ticks`, "Tick count must be at least 1.");
+      }
+      if (config.labelAngle !== void 0 && config.labelAngle !== "auto" && (typeof config.labelAngle !== "number" || config.labelAngle < -90 || config.labelAngle > 90)) {
+        add("error", "axis-label-angle", `axes.${axis}.labelAngle`, "Label angle is `auto` or a number from -90 to 90.");
+      }
+    }
+  }
+  const annotations = Array.isArray(spec.annotations) ? spec.annotations : [];
+  annotations.forEach((annotation, index) => {
+    const path = `annotations[${index}]`;
+    if (!isRecord(annotation) || typeof annotation.type !== "string") {
+      add("error", "annotation-invalid", path, "An annotation needs a `type`.");
+      return;
+    }
+    const label = annotation.type === "text" ? annotation.text : annotation.label;
+    if (typeof label !== "string" || label.trim() === "") {
+      add("error", "annotation-label-missing", path, "Targets, limits and forecasts are always labeled marks: add a label.");
+    }
+    if (annotation.type === "reference-line" && annotation.x === void 0 && annotation.y === void 0) {
+      add("error", "annotation-position-missing", path, "A reference line needs `x` or `y`.");
+    }
+    if (annotation.type === "reference-band" && (annotation.axis !== "x" && annotation.axis !== "y")) {
+      add("error", "annotation-axis-invalid", `${path}.axis`, 'A reference band needs `axis: "x"` or `"y"`.');
+    }
+    if (!["reference-line", "reference-band", "text", "forecast", "point"].includes(annotation.type)) {
+      add("error", "annotation-type-invalid", `${path}.type`, `Unknown annotation type "${annotation.type}".`);
+    }
+  });
+  const thresholds = Array.isArray(spec.thresholds) ? spec.thresholds : [];
+  thresholds.forEach((threshold, index) => {
+    const path = `thresholds[${index}]`;
+    if (!isRecord(threshold)) {
+      add("error", "threshold-invalid", path, "A threshold must be an object.");
+      return;
+    }
+    if (typeof threshold.label !== "string" || threshold.label.trim() === "") {
+      add("error", "threshold-label-missing", `${path}.label`, "Thresholds are always labeled.");
+    }
+    if (threshold.value === void 0 || typeof threshold.value !== "number" && typeof threshold.value !== "string") {
+      add("error", "threshold-value-invalid", `${path}.value`, "A threshold needs a numeric `value`.");
+    }
+    if (threshold.breach !== void 0 && threshold.breach !== "above" && threshold.breach !== "below") {
+      add("error", "threshold-breach-invalid", `${path}.breach`, "`breach` is `above` or `below`.");
+    }
+    if (threshold.axis === "y2" && spec.dualAxis !== true) {
+      add("error", "series-axis-needs-dual-axis", `${path}.axis`, "A threshold on the second axis needs `dualAxis: true`.");
+    }
+  });
+  const transforms = Array.isArray(spec.transforms) ? spec.transforms : [];
+  transforms.forEach((transform, index) => {
+    const path = `transforms[${index}]`;
+    if (!isRecord(transform) || typeof transform.type !== "string") {
+      add("error", "transform-invalid", path, "A transform needs a `type`.");
+      return;
+    }
+    const known = ["aggregate", "bin", "stack", "percent-of-total", "sort", "top-n", "rolling-average", "cumulative-sum", "period-change", "downsample"];
+    if (!known.includes(transform.type)) {
+      add("error", "transform-invalid", `${path}.type`, `Unknown transform "${transform.type}".`);
+      return;
+    }
+    const positiveInt = (key, min) => {
+      const value = transform[key];
+      if (typeof value !== "number" || !Number.isFinite(value) || value < min) {
+        add("error", "transform-parameter-invalid", `${path}.${key}`, `\`${key}\` must be a number of at least ${min}.`);
+      }
+    };
+    if (transform.type === "aggregate") {
+      if (!Array.isArray(transform.groupBy) || transform.groupBy.length === 0) add("error", "transform-parameter-invalid", `${path}.groupBy`, "`groupBy` needs at least one field.");
+      if (!["sum", "mean", "min", "max", "count"].includes(String(transform.op))) add("error", "transform-parameter-invalid", `${path}.op`, "`op` must be sum, mean, min, max or count.");
+      if (transform.op !== "count" && typeof transform.field !== "string") add("error", "transform-parameter-invalid", `${path}.field`, "Only `count` works without a `field`.");
+    }
+    if (transform.type === "rolling-average") positiveInt("window", 1);
+    if (transform.type === "top-n") positiveInt("n", 1);
+    if (transform.type === "downsample") positiveInt("threshold", 3);
+    if (transform.type === "period-change" && transform.periods !== void 0) positiveInt("periods", 1);
+    if (transform.type === "bin" && transform.maxBins !== void 0) positiveInt("maxBins", 1);
+    if (typeof transform.field === "string" && transform.type !== "aggregate" && !fieldExists(transform.field)) {
+      add("warning", "field-unknown", `${path}.field`, `No row has the field "${transform.field}".`);
+    }
+  });
+  if (isRecord(spec.highlight)) {
+    if (typeof spec.highlight.where !== "string") {
+      add("error", "highlight-invalid", "highlight.where", "`highlight.where` must be an expression string.");
+    } else {
+      const problem = checkWhere(spec.highlight.where);
+      if (problem) add("error", "highlight-expression-invalid", "highlight.where", `Highlight expression does not parse: ${problem}.`);
+    }
+  }
+  if (isRecord(spec.gauge)) {
+    const { min, max, value } = spec.gauge;
+    if (min !== void 0 && max !== void 0 && !(max > min)) add("error", "gauge-range-invalid", "gauge", "`gauge.max` must be greater than `gauge.min`.");
+    if (typeof value === "number" && min !== void 0 && max !== void 0 && (value < min || value > max)) {
+      add("warning", "gauge-value-out-of-range", "gauge.value", "The gauge value is outside its range; the arc is clamped.");
+    }
+  }
+  if (isRecord(spec.donut)) {
+    const radius = spec.donut.innerRadius;
+    if (radius !== void 0 && (typeof radius !== "number" || radius < 0 || radius > 0.9)) {
+      add("error", "donut-inner-radius-range", "donut.innerRadius", "`innerRadius` is a fraction from 0 to 0.9.");
+    }
+    if (typeof spec.donut.maxSlices === "number" && spec.donut.maxSlices > 5) {
+      add("warning", "too-many-slices", "donut.maxSlices", "Donuts read best with at most five slices.");
+    }
+  }
+  if ((mark === "pie" || mark === "donut") && rows && isRecord(spec.y) && typeof spec.y.field === "string") {
+    const field = spec.y.field;
+    if (rows.slice(0, 5e3).some((row) => (toNumber(isRecord(row) ? readField(row, field) : void 0) ?? 0) < 0)) {
+      add("error", "pie-negative", "y", "A part-to-whole chart cannot show negative values.");
+    }
+  }
+  if (spec.renderer !== void 0 && spec.renderer !== "svg" && spec.renderer !== "canvas" && spec.renderer !== "auto") {
+    add("error", "renderer-invalid", "renderer", "`renderer` must be svg, canvas or auto.");
+  }
+  if (spec.direction !== void 0 && !["ltr", "rtl", "auto"].includes(String(spec.direction))) {
+    add("error", "direction-invalid", "direction", "`direction` must be ltr, rtl or auto.");
+  }
+  if (isRecord(spec.interactions)) {
+    for (const name of ["brush", "zoom", "drilldown"]) {
+      if (spec.interactions[name] === true) {
+        add("warning", "interaction-unsupported", `interactions.${name}`, `\`interactions.${name}\` is part of the spec but this renderer does not implement it; it is ignored.`);
+      }
+    }
+  }
+  if (spec.renderer === "svg" && isRecord(data)) {
+    const count = rows ? resolveRows(spec, options.datasets)?.length ?? 0 : 0;
+    if (count > SVG_POINT_LIMIT) {
+      add("warning", "svg-point-limit", "renderer", `${count} rows is above the SVG comfort limit of ${SVG_POINT_LIMIT}; consider \`renderer: "auto"\` or a downsample transform.`);
+    }
+  }
+  return issues;
+}
+function isValidChartSpec(input, options = {}) {
+  return !validateChartSpec(input, options).some((issue) => issue.severity === "error");
+}
+export {
+  AXIS_FONT_SIZE,
+  DEFAULT_LOCALE,
+  ExpressionError,
+  MAX_HUES,
+  SVG_POINT_LIMIT,
+  TICK_PADDING,
+  TICK_SIZE,
+  annotationTone,
+  applyTransforms,
+  buildChartModel,
+  capitalize,
+  categoricalTones,
+  chartToCsv,
+  chartToTable,
+  chartTypes,
+  checkWhere,
+  compileWhere,
+  computeAxisMargins,
+  correlation,
+  countPoints,
+  createBandScale,
+  createContinuousScale,
+  createDateFormatter,
+  createFormatters,
+  createNumberFormatter,
+  createPointScale,
+  createTimeTickFormatter,
+  cumulativeSum,
+  dashArrays,
+  dashStyles,
+  defaultMessages,
+  defineChartSpec,
+  describeChart,
+  describeModel,
+  describeTarget,
+  divergingColor,
+  dodgePositions,
+  effectiveStack,
+  escapeCsvField,
+  estimateTextWidth,
+  evaluateWhere,
+  extent,
+  fitTickLabels,
+  forecastLinear,
+  formatList,
+  formatMessage,
+  formatShare,
+  fractionDigitsForStep,
+  histogramBins,
+  hitTest,
+  isNavKey,
+  isOpenMarker,
+  isRtlLocale,
+  isSupportedMark,
+  isValidChartSpec,
+  layoutChart,
+  linearRegression,
+  lttb,
+  lttbIndices,
+  markerPath,
+  markerShapes,
+  mean,
+  median,
+  minMax,
+  minMaxIndices,
+  modelToTable,
+  movingAverage,
+  navKeys,
+  navigate,
+  niceTicks,
+  patternIndex,
+  percentChange,
+  periodChange,
+  pointInfo,
+  quantile,
+  rampGradient,
+  readField,
+  regressionBand,
+  resolveMessages,
+  resolveRenderer,
+  resolveRows,
+  sequentialColor,
+  seriesStyle,
+  stackValues,
+  standardDeviation,
+  sum,
+  supportedMarks,
+  tableToCsv,
+  targetById,
+  themeColorsFromTokens,
+  toCategory,
+  toEChartsOption,
+  toNumber,
+  toTime,
+  toneCssVar,
+  toneTokenPath,
+  toneVarName,
+  tooltipFor,
+  trendDirection,
+  truncateLabel,
+  usesBandX,
+  validateChartSpec,
+  valueDomain,
+  variance
+};
 //# sourceMappingURL=index.js.map