@antv/gpt-vis 1.0.0 → 1.0.2

package/dist/cjs/util/crosshair-axis-labels.js

@@ -0,0 +1,401 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/crosshair-axis-labels.ts
+var crosshair_axis_labels_exports = {};
+__export(crosshair_axis_labels_exports, {
+  bindCrosshairAxisLabels: () => bindCrosshairAxisLabels
+});
+module.exports = __toCommonJS(crosshair_axis_labels_exports);
+var import_component = require("@antv/component");
+var import_g2 = require("@antv/g2");
+var import_tokens = require("./tokens");
+var MAX_CROSSHAIR_DECIMAL_PLACES = 6;
+var formatCrosshairAxisValue = (value, formatter, precision) => {
+  if (value === void 0 || value === null || value === "")
+    return "";
+  let displayValue = value;
+  try {
+    const formatted = formatter == null ? void 0 : formatter(value);
+    if (formatted !== void 0 && formatted !== null) {
+      const numericFormatted = typeof formatted === "number" || typeof formatted === "string" && formatted.trim() !== "" && Number.isFinite(Number(formatted)) ? Number(formatted) : void 0;
+      if (numericFormatted === void 0)
+        return String(formatted);
+      displayValue = numericFormatted;
+    }
+  } catch {
+  }
+  if (displayValue instanceof Date)
+    return displayValue.toLocaleString();
+  if (typeof displayValue === "number" && Number.isFinite(displayValue)) {
+    if (displayValue !== 0 && Math.abs(displayValue) < 10 ** -MAX_CROSSHAIR_DECIMAL_PLACES) {
+      return Number(displayValue.toPrecision(4)).toString();
+    }
+    const decimalPlaces = Math.min(
+      Math.max(precision ?? MAX_CROSSHAIR_DECIMAL_PLACES, 0),
+      MAX_CROSSHAIR_DECIMAL_PLACES
+    );
+    return Number(displayValue.toFixed(decimalPlaces)).toString();
+  }
+  return String(displayValue);
+};
+var getNumberPrecision = (value) => {
+  var _a;
+  if (!Number.isFinite(value) || value === 0)
+    return 0;
+  const normalizedValue = Number(value.toPrecision(12));
+  const [coefficient, exponentText = "0"] = Math.abs(normalizedValue).toExponential().split("e");
+  const coefficientPrecision = ((_a = coefficient.split(".")[1]) == null ? void 0 : _a.length) || 0;
+  return Math.max(0, coefficientPrecision - Number(exponentText));
+};
+var getCrosshairScalePrecision = (scale) => {
+  var _a;
+  const ticks = (_a = scale == null ? void 0 : scale.getTicks) == null ? void 0 : _a.call(scale);
+  if (!Array.isArray(ticks) || ticks.length < 2)
+    return void 0;
+  let interval = Number.POSITIVE_INFINITY;
+  for (let index = 1; index < ticks.length; index += 1) {
+    const current = Number(ticks[index]);
+    const previous = Number(ticks[index - 1]);
+    const difference = Math.abs(current - previous);
+    if (Number.isFinite(difference) && difference > 0)
+      interval = Math.min(interval, difference);
+  }
+  if (!Number.isFinite(interval))
+    return void 0;
+  return Math.min(getNumberPrecision(interval) + 2, MAX_CROSSHAIR_DECIMAL_PLACES);
+};
+var getCrosshairTagStyle = (theme, tokens) => ({
+  lineLineWidth: 0,
+  lineStrokeOpacity: 0,
+  linePointerEvents: "none",
+  tagPadding: [4, 7],
+  tagRadius: 6,
+  tagBackgroundFill: tokens.textPrimary,
+  tagBackgroundStroke: "transparent",
+  tagBackgroundLineWidth: 0,
+  tagBackgroundShadowColor: theme === "dark" ? "rgba(0, 0, 0, 0.38)" : "rgba(15, 23, 42, 0.18)",
+  tagBackgroundShadowBlur: 8,
+  tagBackgroundShadowOffsetY: 2,
+  tagLabelFill: tokens.background,
+  tagLabelFillOpacity: 1,
+  tagLabelFontFamily: import_tokens.CHART_FONT_FAMILY,
+  tagLabelFontSize: 11,
+  tagLabelFontWeight: 500,
+  tagLabelLineWidth: 0,
+  tagPointerEvents: "none"
+});
+var getStandaloneTagStyle = (theme, tokens) => ({
+  align: "start",
+  verticalAlign: "middle",
+  padding: [4, 7],
+  radius: 6,
+  backgroundFill: tokens.textPrimary,
+  backgroundStroke: "transparent",
+  backgroundLineWidth: 0,
+  backgroundShadowColor: theme === "dark" ? "rgba(0, 0, 0, 0.38)" : "rgba(15, 23, 42, 0.18)",
+  backgroundShadowBlur: 8,
+  backgroundShadowOffsetY: 2,
+  labelFill: tokens.background,
+  labelFillOpacity: 1,
+  labelFontFamily: import_tokens.CHART_FONT_FAMILY,
+  labelFontSize: 11,
+  labelFontWeight: 500,
+  labelLineWidth: 0,
+  pointerEvents: "none"
+});
+var clamp = (value, min, max) => Math.min(Math.max(value, Math.min(min, max)), Math.max(min, max));
+var invertCrosshairValue = (scale, value) => {
+  var _a, _b, _c;
+  if (!scale || typeof scale.invert !== "function" || value === void 0)
+    return void 0;
+  if (typeof scale.getBandWidth === "function") {
+    const domain = (_b = (_a = scale.getOptions) == null ? void 0 : _a.call(scale)) == null ? void 0 : _b.domain;
+    if (!Array.isArray(domain) || domain.length === 0 || !Number.isFinite(Number(value))) {
+      return void 0;
+    }
+    let nearestValue = domain[0];
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    for (const domainValue of domain) {
+      const start = Number((_c = scale.map) == null ? void 0 : _c.call(scale, domainValue));
+      const bandWidth = Number(scale.getBandWidth(domainValue)) || 0;
+      const distance = Math.abs(start + bandWidth / 2 - Number(value));
+      if (Number.isFinite(distance) && distance < nearestDistance) {
+        nearestValue = domainValue;
+        nearestDistance = distance;
+      }
+    }
+    return nearestValue;
+  }
+  try {
+    return scale.invert(value);
+  } catch {
+    return void 0;
+  }
+};
+var getTooltipPlot = (context) => {
+  var _a;
+  const root = (_a = context.canvas) == null ? void 0 : _a.getRoot();
+  if (!root)
+    return void 0;
+  return (0, import_g2.selectPlotArea)(root);
+};
+var getScaleField = (scale) => {
+  var _a, _b;
+  return (_b = (_a = scale == null ? void 0 : scale.getOptions) == null ? void 0 : _a.call(scale)) == null ? void 0 : _b.field;
+};
+var findYScaleByField = (view, yField) => {
+  var _a;
+  return (_a = Object.entries(view.scale).find(
+    ([scaleName, scale]) => /^y\d*$/.test(scaleName) && getScaleField(scale) === yField
+  )) == null ? void 0 : _a[1];
+};
+var getYScale = (view, yField) => yField ? findYScaleByField(view, yField) : view.scale.y;
+var getCartesianView = (context, yField) => {
+  var _a;
+  return (_a = context.views) == null ? void 0 : _a.find(
+    (view) => {
+      var _a2, _b;
+      return Boolean(((_a2 = view.scale) == null ? void 0 : _a2.x) && getYScale(view, yField)) && typeof ((_b = view.coordinate) == null ? void 0 : _b.invert) === "function";
+    }
+  );
+};
+var hasAxisField = (field, yField) => Array.isArray(field) ? field.includes(yField) : field === yField;
+var getYAxisLinePosition = (view, yField, position, fallback, plotX) => {
+  var _a;
+  if (!yField)
+    return fallback;
+  const axis = (_a = view.components) == null ? void 0 : _a.find(
+    ({ bbox, position: axisPosition, scales, type }) => type === "axisY" && axisPosition === position && Number.isFinite(Number(bbox == null ? void 0 : bbox.x)) && (scales == null ? void 0 : scales.some((scale) => hasAxisField(scale.field, yField)))
+  );
+  if (!(axis == null ? void 0 : axis.bbox))
+    return fallback;
+  const x = Number(axis.bbox.x);
+  const width = Number(axis.bbox.width);
+  const axisX = position === "right" || !Number.isFinite(width) ? x : x + width;
+  return axisX - plotX;
+};
+var getRuleLine = (rule) => {
+  var _a, _b, _c, _d;
+  const x1 = Number((_a = rule == null ? void 0 : rule.style) == null ? void 0 : _a.x1);
+  const x2 = Number((_b = rule == null ? void 0 : rule.style) == null ? void 0 : _b.x2);
+  const y1 = Number((_c = rule == null ? void 0 : rule.style) == null ? void 0 : _c.y1);
+  const y2 = Number((_d = rule == null ? void 0 : rule.style) == null ? void 0 : _d.y2);
+  if (![x1, x2, y1, y2].every(Number.isFinite))
+    return void 0;
+  return { x1, x2, y1, y2 };
+};
+var getPlotOffset = (plot) => {
+  var _a;
+  const [x = 0, y = 0] = ((_a = plot.getLocalPosition) == null ? void 0 : _a.call(plot)) || [];
+  return [Number.isFinite(Number(x)) ? Number(x) : 0, Number.isFinite(Number(y)) ? Number(y) : 0];
+};
+var invertCoordinate = (view, point) => {
+  try {
+    const inverted = view.coordinate.invert(point);
+    if (!Array.isArray(inverted) || inverted.length < 2)
+      return void 0;
+    const x = Number(inverted[0]);
+    const y = Number(inverted[1]);
+    return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var bindCrosshairAxisLabels = (chart, theme, {
+  showXLabel = true,
+  useStandaloneYLabel = false,
+  yAxisPosition = "left",
+  yField
+} = {}) => {
+  if (!chart || typeof chart.on !== "function")
+    return () => void 0;
+  const tagStyle = getCrosshairTagStyle(theme, (0, import_tokens.getChartVisualTokens)(theme));
+  const standaloneTagStyle = getStandaloneTagStyle(theme, (0, import_tokens.getChartVisualTokens)(theme));
+  let boundPlot = null;
+  let xCrosshair = null;
+  let yCrosshair = null;
+  let standaloneYTag = null;
+  let latestPointerY = null;
+  let latestXValue;
+  const destroyCrosshairs = () => {
+    xCrosshair == null ? void 0 : xCrosshair.destroy();
+    yCrosshair == null ? void 0 : yCrosshair.destroy();
+    standaloneYTag == null ? void 0 : standaloneYTag.destroy();
+    xCrosshair = null;
+    yCrosshair = null;
+    standaloneYTag = null;
+    boundPlot = null;
+  };
+  const hideCrosshairs = () => {
+    for (const crosshair of [xCrosshair, yCrosshair, standaloneYTag]) {
+      if (crosshair)
+        crosshair.style.visibility = "hidden";
+    }
+  };
+  const resetCrosshairs = () => {
+    latestPointerY = null;
+    latestXValue = void 0;
+    hideCrosshairs();
+  };
+  const ensureCrosshairs = (plot, xLine, yLine, xText, yText) => {
+    if (boundPlot !== plot)
+      destroyCrosshairs();
+    if (xCrosshair && yCrosshair)
+      return;
+    const layer = plot.parentNode || plot;
+    const [plotX, plotY] = getPlotOffset(plot);
+    const xStart = [xLine.x1 + plotX, xLine.y1 + plotY];
+    const xEnd = [xLine.x2 + plotX, xLine.y2 + plotY];
+    const yStart = [yLine.x1 + plotX, yLine.y1 + plotY];
+    const yEnd = [yLine.x2 + plotX, yLine.y2 + plotY];
+    if (showXLabel && !xCrosshair) {
+      xCrosshair = new import_component.LineCrosshair({
+        style: { ...tagStyle, startPos: xStart, endPos: xEnd, tagText: xText, tagPosition: "end" }
+      });
+      xCrosshair.style.zIndex = 7;
+      xCrosshair.style.pointerEvents = "none";
+      layer.appendChild(xCrosshair);
+    }
+    if (showXLabel && !useStandaloneYLabel && !yCrosshair) {
+      yCrosshair = new import_component.LineCrosshair({
+        style: {
+          ...tagStyle,
+          startPos: yStart,
+          endPos: yEnd,
+          tagText: yText,
+          tagPosition: yAxisPosition === "right" ? "end" : "start"
+        }
+      });
+      yCrosshair.style.zIndex = 7;
+      yCrosshair.style.pointerEvents = "none";
+      layer.appendChild(yCrosshair);
+    }
+    if ((useStandaloneYLabel || !showXLabel) && !standaloneYTag) {
+      standaloneYTag = new import_component.Tag({ style: { ...standaloneTagStyle, text: yText } });
+      standaloneYTag.style.zIndex = 7;
+      standaloneYTag.style.pointerEvents = "none";
+      layer.appendChild(standaloneYTag);
+    }
+    boundPlot = plot;
+  };
+  const updateCrosshairs = (event) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const context = chart.getContext();
+    const plot = getTooltipPlot(context);
+    const view = getCartesianView(context, yField);
+    if (!plot || !view) {
+      hideCrosshairs();
+      return;
+    }
+    const yScale = getYScale(view, yField);
+    const verticalRule = getRuleLine(plot.ruleY);
+    const horizontalRule = getRuleLine(plot.ruleX);
+    if (!verticalRule || !horizontalRule) {
+      hideCrosshairs();
+      return;
+    }
+    const [plotX, plotY] = getPlotOffset(plot);
+    const eventY = Number(event.offsetY ?? event.canvasY);
+    const globalY = Number.isFinite(eventY) ? eventY : latestPointerY;
+    const pointerY = Number.isFinite(globalY) ? Number(globalY) - plotY : horizontalRule.y1;
+    const x = clamp(verticalRule.x1, horizontalRule.x1, horizontalRule.x2);
+    const y = clamp(pointerY, verticalRule.y1, verticalRule.y2);
+    const invertedPosition = invertCoordinate(view, [x, y]);
+    const xValue = latestXValue ?? invertCrosshairValue(view.scale.x, invertedPosition == null ? void 0 : invertedPosition[0]);
+    const yValue = invertCrosshairValue(yScale, invertedPosition == null ? void 0 : invertedPosition[1]) ?? ((_c = (_b = (_a = event.data) == null ? void 0 : _a.items) == null ? void 0 : _b[0]) == null ? void 0 : _c.value);
+    const xText = formatCrosshairAxisValue(xValue, (_e = (_d = view.scale.x).getFormatter) == null ? void 0 : _e.call(_d));
+    const yText = formatCrosshairAxisValue(
+      yValue,
+      (_f = yScale == null ? void 0 : yScale.getFormatter) == null ? void 0 : _f.call(yScale),
+      getCrosshairScalePrecision(yScale)
+    );
+    if (!xText || !yText) {
+      hideCrosshairs();
+      return;
+    }
+    if ((_g = plot.ruleY) == null ? void 0 : _g.style) {
+      plot.ruleY.style.x1 = x;
+      plot.ruleY.style.x2 = x;
+    }
+    if ((_h = plot.ruleX) == null ? void 0 : _h.style) {
+      plot.ruleX.style.y1 = y;
+      plot.ruleX.style.y2 = y;
+    }
+    const displayVerticalRule = { ...verticalRule, x1: x, x2: x };
+    const displayHorizontalRule = { ...horizontalRule, y1: y, y2: y };
+    ensureCrosshairs(plot, displayVerticalRule, displayHorizontalRule, xText, yText);
+    if (showXLabel && !xCrosshair || (useStandaloneYLabel ? !standaloneYTag : !yCrosshair && !standaloneYTag))
+      return;
+    if (xCrosshair) {
+      xCrosshair.setText(xText);
+      xCrosshair.setPointer([x + plotX, verticalRule.y2 + plotY]);
+      xCrosshair.style.visibility = "visible";
+    }
+    if (yCrosshair) {
+      yCrosshair.setText(yText);
+      yCrosshair.setPointer([
+        (yAxisPosition === "right" ? horizontalRule.x2 : horizontalRule.x1) + plotX,
+        y + plotY
+      ]);
+      yCrosshair.style.visibility = "visible";
+    }
+    if (standaloneYTag) {
+      const yAxisX = getYAxisLinePosition(
+        view,
+        yField,
+        yAxisPosition,
+        yAxisPosition === "right" ? horizontalRule.x2 : horizontalRule.x1,
+        plotX
+      );
+      standaloneYTag.update({ text: yText });
+      standaloneYTag.setLocalPosition([yAxisX + plotX, y + plotY]);
+      standaloneYTag.style.visibility = "visible";
+    }
+  };
+  const onPointerMove = (event) => {
+    const y = Number(event.offsetY ?? event.canvasY);
+    if (Number.isFinite(y))
+      latestPointerY = y;
+    updateCrosshairs(event);
+  };
+  const onTooltipShow = (event) => {
+    var _a, _b;
+    if (!event.nativeEvent)
+      return;
+    if (((_b = (_a = event.data) == null ? void 0 : _a.data) == null ? void 0 : _b.x) !== void 0)
+      latestXValue = event.data.data.x;
+    updateCrosshairs(event);
+  };
+  chart.on("tooltip:show", onTooltipShow);
+  chart.on("tooltip:hide", resetCrosshairs);
+  chart.on("plot:pointermove", onPointerMove);
+  chart.on("plot:pointerleave", resetCrosshairs);
+  return () => {
+    var _a, _b, _c, _d;
+    (_a = chart.off) == null ? void 0 : _a.call(chart, "tooltip:show", onTooltipShow);
+    (_b = chart.off) == null ? void 0 : _b.call(chart, "tooltip:hide", resetCrosshairs);
+    (_c = chart.off) == null ? void 0 : _c.call(chart, "plot:pointermove", onPointerMove);
+    (_d = chart.off) == null ? void 0 : _d.call(chart, "plot:pointerleave", resetCrosshairs);
+    destroyCrosshairs();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindCrosshairAxisLabels
+});

package/dist/cjs/util/html.d.ts

@@ -0,0 +1 @@
+export declare const escapeHtml: (value: unknown) => string;

package/dist/cjs/util/html.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/html.ts
+var html_exports = {};
+__export(html_exports, {
+  escapeHtml: () => escapeHtml
+});
+module.exports = __toCommonJS(html_exports);
+var escapeHtml = (value) => (value == null ? "" : String(value)).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  escapeHtml
+});

package/dist/cjs/util/index.d.ts

@@ -0,0 +1,6 @@
+export * from './animation';
+export * from './components';
+export * from './crosshair-axis-labels';
+export * from './interaction';
+export * from './theme';
+export * from './tokens';

package/dist/cjs/util/index.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/index.ts
+var util_exports = {};
+module.exports = __toCommonJS(util_exports);
+__reExport(util_exports, require("./animation"), module.exports);
+__reExport(util_exports, require("./components"), module.exports);
+__reExport(util_exports, require("./crosshair-axis-labels"), module.exports);
+__reExport(util_exports, require("./interaction"), module.exports);
+__reExport(util_exports, require("./theme"), module.exports);
+__reExport(util_exports, require("./tokens"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./animation"),
+  ...require("./components"),
+  ...require("./crosshair-axis-labels"),
+  ...require("./interaction"),
+  ...require("./theme"),
+  ...require("./tokens")
+});

package/dist/cjs/util/interaction.d.ts

@@ -0,0 +1,14 @@
+import type { VisualizationTheme } from '../types';
+export type SharedTooltipInteractionOptions = {
+    crosshairs?: boolean;
+};
+export type PointHighlightStateOptions = {
+    activeLineWidth?: number;
+    inactiveOpacity?: number;
+};
+export declare const getSharedTooltipInteraction: ({ crosshairs, }?: SharedTooltipInteractionOptions) => Record<string, boolean>;
+export declare const getCategoryBackgroundHighlightState: (theme: VisualizationTheme) => Record<string, any>;
+export declare const getCategoryHighlightInteraction: () => Record<string, any>;
+export declare const getPointHighlightState: ({ activeLineWidth, inactiveOpacity, }?: PointHighlightStateOptions) => Record<string, any>;
+export declare const getSeriesHighlightByColorInteraction: () => Record<string, boolean>;
+export declare const getLineHighlightState: (lineWidth: number) => Record<string, any>;

package/dist/cjs/util/interaction.js

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/util/interaction.ts
+var interaction_exports = {};
+__export(interaction_exports, {
+  getCategoryBackgroundHighlightState: () => getCategoryBackgroundHighlightState,
+  getCategoryHighlightInteraction: () => getCategoryHighlightInteraction,
+  getLineHighlightState: () => getLineHighlightState,
+  getPointHighlightState: () => getPointHighlightState,
+  getSeriesHighlightByColorInteraction: () => getSeriesHighlightByColorInteraction,
+  getSharedTooltipInteraction: () => getSharedTooltipInteraction
+});
+module.exports = __toCommonJS(interaction_exports);
+var import_tokens = require("./tokens");
+var getSharedTooltipInteraction = ({
+  crosshairs = false
+} = {}) => ({
+  shared: true,
+  series: true,
+  crosshairs
+});
+var getCategoryBackgroundHighlightState = (theme) => {
+  const tokens = (0, import_tokens.getChartVisualTokens)(theme);
+  return {
+    active: {
+      backgroundFill: tokens.grid,
+      backgroundFillOpacity: theme === "dark" ? 0.56 : 0.58,
+      backgroundLineWidth: 0,
+      backgroundPadding: 0.08,
+      backgroundRadius: 4
+    }
+  };
+};
+var getCategoryHighlightInteraction = () => ({
+  background: true,
+  region: true
+});
+var getPointHighlightState = ({
+  activeLineWidth = import_tokens.CHART_STYLE_DEFAULTS.pointActiveLineWidth,
+  inactiveOpacity
+} = {}) => ({
+  active: {
+    lineWidth: activeLineWidth,
+    stroke: (_datum, _index, _data, element) => {
+      var _a, _b;
+      return ((_a = element == null ? void 0 : element.style) == null ? void 0 : _a.fill) || ((_b = element == null ? void 0 : element.style) == null ? void 0 : _b.stroke);
+    },
+    fillOpacity: 1,
+    zIndex: 10
+  },
+  ...inactiveOpacity === void 0 ? {} : {
+    inactive: {
+      fillOpacity: inactiveOpacity,
+      strokeOpacity: inactiveOpacity
+    }
+  }
+});
+var getSeriesHighlightByColorInteraction = () => ({
+  elementHighlightByColor: true
+});
+var getLineHighlightState = (lineWidth) => ({
+  active: { lineWidth: lineWidth + 1, strokeOpacity: 1 },
+  inactive: { strokeOpacity: import_tokens.CHART_STYLE_DEFAULTS.inactiveOpacity }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCategoryBackgroundHighlightState,
+  getCategoryHighlightInteraction,
+  getLineHighlightState,
+  getPointHighlightState,
+  getSeriesHighlightByColorInteraction,
+  getSharedTooltipInteraction
+});

package/dist/cjs/util/theme.d.ts

@@ -1,26 +1,20 @@
+import type { Theme } from '@antv/g2';
+import type { VisualizationTheme } from '../types';
 export declare const DEFAULT_COLOR_PALETTE: string[];
 export declare const ACADEMY_COLOR_PALETTE: string[];
-export declare const THEME_MAP: Record<string, any>;
-/**
- * Get normalized theme name for G2.
- * Converts 'default' to 'light' for G2 compatibility.
- */
-export declare const getTheme: (theme: string) => string;
-/**
- * Get theme object from THEME_MAP.
- * This should be used for visualization components to properly support dark theme with multiple marks.
- */
-export declare const getThemeObject: (theme: string) => any;
-/**
- * Get theme color palette based on theme name.
- */
-export declare const getThemeColors: (theme: string) => string[];
-/**
- * Get background color based on theme.
- */
-export declare const getBackgroundColor: (theme: string) => string;
-/**
- * Normalize palette to always return an array.
- * Handles the case where a single color is parsed as a string instead of an array.
- */
-export declare const normalizePalette: (palette: string | string[] | undefined, theme: string) => string[];
+type G2ThemeType = 'light' | 'dark' | 'academy';
+type ChartTheme = Theme & {
+    enter?: {
+        duration?: number;
+        easing?: string;
+    };
+    elementHighlightByColor?: Record<string, unknown>;
+    elementHoverScale?: Record<string, unknown>;
+};
+export declare const THEME_MAP: Record<VisualizationTheme, ChartTheme>;
+export declare const getTheme: (theme: VisualizationTheme) => G2ThemeType;
+export declare const getThemeObject: (theme: VisualizationTheme) => ChartTheme;
+export declare const getThemeColors: (theme: VisualizationTheme) => string[];
+export declare const getBackgroundColor: (theme: VisualizationTheme) => string;
+export declare const normalizePalette: (palette: string | string[] | undefined, theme: VisualizationTheme) => string[];
+export {};