@expcat/tigercat-react 1.3.4 → 1.5.0

package/dist/{chunk-ONTRGV5T.js → chunk-7YI5TAPT.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkUKGQ7256js = require('./chunk-UKGQ7256.js');
+var _chunkL3WPA2RPjs = require('./chunk-L3WPA2RP.js');
 
 // src/components/RichTextEditor.tsx
 var _react = require('react');
@@ -25,7 +25,7 @@ var RichTextEditor = ({
   value,
   defaultValue = "",
   placeholder,
-  mode: _mode = "html",
+  mode = "html",
   toolbar,
   height = 300,
   readOnly = false,
@@ -37,31 +37,24 @@ var RichTextEditor = ({
 }) => {
   const editorRef = _react.useRef.call(void 0, null);
   const engineRef = _react.useRef.call(void 0, null);
-  const [currentContent, setInternalValue, isControlled] = _chunkUKGQ7256js.useControlledState.call(void 0, value, defaultValue);
+  const [currentContent, setContent] = _chunkL3WPA2RPjs.useControlledState.call(void 0, value, defaultValue, onChange);
+  const isControlled = value !== void 0;
   const [activeFormats, setActiveFormats] = _react.useState.call(void 0, /* @__PURE__ */ new Set());
   const toolbarItems = _nullishCoalesce(toolbar, () => ( _tigercatcore.defaultToolbar));
   const empty = _tigercatcore.isContentEmpty.call(void 0, currentContent);
-  const onChangeRef = _react.useRef.call(void 0, onChange);
-  const setInternalValueRef = _react.useRef.call(void 0, setInternalValue);
-  const isControlledRef = _react.useRef.call(void 0, isControlled);
-  _react.useEffect.call(void 0, () => {
-    onChangeRef.current = onChange;
-    setInternalValueRef.current = setInternalValue;
-    isControlledRef.current = isControlled;
-  }, [onChange, setInternalValue, isControlled]);
   _react.useEffect.call(void 0, () => {
     if (!editorRef.current) return;
     const factory = _nullishCoalesce(engine, () => ( _tigercatcore.builtinRichTextEngine));
     const instance = factory.create({
       element: editorRef.current,
       initialValue: isControlled ? value : defaultValue,
+      mode,
       readOnly,
       disabled,
       placeholder,
       toolbar: toolbarItems,
       notifyChange(html) {
-        if (!isControlledRef.current) setInternalValueRef.current(html);
-        _optionalChain([onChangeRef, 'access', _ => _.current, 'optionalCall', _2 => _2(html)]);
+        setContent(html);
       },
       notifyActiveFormats(next) {
         setActiveFormats(next);
@@ -79,16 +72,12 @@ var RichTextEditor = ({
     }
   }, [value, isControlled]);
   _react.useEffect.call(void 0, () => {
-    _optionalChain([engineRef, 'access', _3 => _3.current, 'optionalAccess', _4 => _4.setReadOnly, 'call', _5 => _5(readOnly, disabled)]);
+    _optionalChain([engineRef, 'access', _ => _.current, 'optionalAccess', _2 => _2.setReadOnly, 'call', _3 => _3(readOnly, disabled)]);
   }, [readOnly, disabled]);
   const execButtonAction = _react.useCallback.call(void 0, 
     (btn) => {
       if (readOnly || disabled) return;
-      if (btn.action && editorRef.current) {
-        btn.action(editorRef.current);
-        return;
-      }
-      _optionalChain([engineRef, 'access', _6 => _6.current, 'optionalAccess', _7 => _7.exec, 'call', _8 => _8(btn.name)]);
+      _optionalChain([engineRef, 'access', _4 => _4.current, 'optionalAccess', _5 => _5.exec, 'call', _6 => _6(btn.name)]);
     },
     [readOnly, disabled]
   );

package/dist/chunk-AI4V7L6K.mjs

@@ -0,0 +1,230 @@
+import {
+  useTigerConfig
+} from "./chunk-QAIBQHIO.mjs";
+
+// src/components/VirtualTable.tsx
+import { useCallback, useMemo, useRef, useState } from "react";
+import {
+  classNames,
+  isActivationKey,
+  resolveLocaleText,
+  mergeTigerLocale,
+  calculateVirtualRange,
+  calculateVirtualColumnRange,
+  getVirtualTableContainerClasses,
+  getVirtualTableRowClasses,
+  getVirtualRowKey,
+  getVirtualTableFixedInfo,
+  getVirtualTableFixedCellStyle,
+  getTableFixedCellClasses,
+  getTableFixedHeaderCellClasses,
+  getTableColgroup,
+  tableBaseClasses,
+  virtualTableHeaderClasses,
+  virtualTableHeaderCellClasses,
+  virtualTableCellClasses,
+  virtualTableEmptyClasses,
+  virtualTableLoadingClasses,
+  virtualTableFixedCellSelectedClasses
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_VIRTUAL_COLUMN_WIDTH = 150;
+var VirtualTable = ({
+  data = [],
+  columns = [],
+  rowHeight = 48,
+  height = 400,
+  width = "auto",
+  overscan = 5,
+  stickyHeader = true,
+  virtualizeColumns = false,
+  rowKey,
+  rowClassName,
+  loading = false,
+  emptyText,
+  locale,
+  selectable = false,
+  selectedKeys = [],
+  striped = false,
+  bordered = false,
+  className,
+  onRowClick,
+  onSelect,
+  renderCell,
+  ...rest
+}) => {
+  const config = useTigerConfig();
+  const mergedLocale = useMemo(
+    () => mergeTigerLocale(config.locale, locale),
+    [config.locale, locale]
+  );
+  const containerRef = useRef(null);
+  const [scrollTop, setScrollTop] = useState(0);
+  const [scrollLeft, setScrollLeft] = useState(0);
+  const range = useMemo(
+    () => calculateVirtualRange(scrollTop, height, data.length, rowHeight, overscan),
+    [scrollTop, height, data.length, rowHeight, overscan]
+  );
+  const visibleData = useMemo(
+    () => data.slice(range.start, range.end),
+    [data, range.start, range.end]
+  );
+  const selectedSet = useMemo(() => new Set(selectedKeys), [selectedKeys]);
+  const onScroll = useCallback(() => {
+    if (containerRef.current) {
+      setScrollTop(containerRef.current.scrollTop);
+      setScrollLeft(containerRef.current.scrollLeft);
+    }
+  }, []);
+  const containerClasses = useMemo(
+    () => getVirtualTableContainerClasses(bordered, className),
+    [bordered, className]
+  );
+  const fixedInfo = useMemo(() => getVirtualTableFixedInfo(columns), [columns]);
+  const columnWidths = useMemo(
+    () => columns.map((c) => typeof c.width === "number" ? c.width : DEFAULT_VIRTUAL_COLUMN_WIDTH),
+    [columns]
+  );
+  const colVirtualActive = virtualizeColumns && !fixedInfo.hasFixedColumns && width !== "auto";
+  const colRange = useMemo(
+    () => colVirtualActive ? calculateVirtualColumnRange(scrollLeft, width, columnWidths) : void 0,
+    [colVirtualActive, scrollLeft, width, columnWidths]
+  );
+  const visibleColumns = colRange ? columns.slice(colRange.start, colRange.end) : columns;
+  const colIndexOffset = colRange ? colRange.start : 0;
+  const colgroupEntries = useMemo(
+    () => fixedInfo.hasFixedColumns ? getTableColgroup({
+      columns: visibleColumns,
+      size: "md",
+      hasSelectionColumn: false,
+      expand: false
+    }) : [],
+    [fixedInfo.hasFixedColumns, visibleColumns]
+  );
+  const resolveRowClassName = (row, index) => typeof rowClassName === "function" ? rowClassName(row, index) : rowClassName;
+  const bottomHeight = Math.max(0, range.totalHeight - range.end * rowHeight);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className: classNames(
+        containerClasses,
+        rest.className
+      ),
+      style: {
+        height: `${height}px`,
+        ...width !== "auto" ? { width: `${width}px` } : {}
+      },
+      onScroll,
+      role: "grid",
+      "aria-rowcount": data.length,
+      children: [
+        /* @__PURE__ */ jsxs("table", { className: classNames(tableBaseClasses, "table-fixed"), children: [
+          colgroupEntries.length > 0 && /* @__PURE__ */ jsx("colgroup", { children: colgroupEntries.map((entry) => /* @__PURE__ */ jsx(
+            "col",
+            {
+              "data-tiger-table-col": entry.key,
+              style: entry.width ? { width: entry.width } : void 0
+            },
+            entry.key
+          )) }),
+          /* @__PURE__ */ jsx("thead", { className: stickyHeader ? virtualTableHeaderClasses : void 0, children: /* @__PURE__ */ jsxs("tr", { children: [
+            colRange && colRange.leftPad > 0 && /* @__PURE__ */ jsx("th", { "aria-hidden": true, style: { width: `${colRange.leftPad}px`, padding: 0 } }),
+            visibleColumns.map((col) => {
+              const widthStyle = col.width ? { width: typeof col.width === "number" ? `${col.width}px` : col.width } : {};
+              const stickyStyle = getVirtualTableFixedCellStyle(col.key, fixedInfo);
+              return /* @__PURE__ */ jsx(
+                "th",
+                {
+                  className: classNames(
+                    virtualTableHeaderCellClasses,
+                    getTableFixedHeaderCellClasses({
+                      view: "virtual-table",
+                      column: col,
+                      stickyHeader,
+                      fixedInfo
+                    })
+                  ),
+                  style: { ...widthStyle, ...stickyStyle },
+                  children: col.title ?? ""
+                },
+                col.key
+              );
+            }),
+            colRange && colRange.rightPad > 0 && /* @__PURE__ */ jsx("th", { "aria-hidden": true, style: { width: `${colRange.rightPad}px`, padding: 0 } })
+          ] }) }),
+          /* @__PURE__ */ jsxs("tbody", { children: [
+            /* @__PURE__ */ jsx("tr", { style: { height: `${range.offsetTop}px` }, "aria-hidden": true }),
+            visibleData.map((row, localIdx) => {
+              const globalIdx = range.start + localIdx;
+              const key = getVirtualRowKey(row, globalIdx, rowKey);
+              const isSelected = selectedSet.has(key);
+              const isInteractive = !!onRowClick || selectable;
+              const activate = () => {
+                onRowClick?.(row, globalIdx);
+                if (selectable) onSelect?.(key, row, globalIdx);
+              };
+              return /* @__PURE__ */ jsxs(
+                "tr",
+                {
+                  className: classNames(
+                    getVirtualTableRowClasses(globalIdx, striped, isSelected),
+                    resolveRowClassName(row, globalIdx)
+                  ),
+                  "aria-rowindex": globalIdx + 2,
+                  "aria-selected": selectable ? isSelected : void 0,
+                  tabIndex: isInteractive ? 0 : void 0,
+                  onClick: isInteractive ? activate : void 0,
+                  onKeyDown: isInteractive ? (e) => {
+                    if (isActivationKey(e)) {
+                      e.preventDefault();
+                      activate();
+                    }
+                  } : void 0,
+                  children: [
+                    colRange && colRange.leftPad > 0 && /* @__PURE__ */ jsx("td", { "aria-hidden": true, style: { width: `${colRange.leftPad}px`, padding: 0 } }),
+                    visibleColumns.map((col, colIdx) => /* @__PURE__ */ jsx(
+                      "td",
+                      {
+                        "aria-colindex": colIndexOffset + colIdx + 1,
+                        className: classNames(
+                          virtualTableCellClasses,
+                          getTableFixedCellClasses({
+                            view: "virtual-table",
+                            column: col,
+                            record: row,
+                            rowIndex: globalIdx,
+                            striped,
+                            stripedActive: striped && globalIdx % 2 === 1,
+                            selected: isSelected,
+                            hoverable: true,
+                            fixedInfo,
+                            selectedClassName: virtualTableFixedCellSelectedClasses
+                          })
+                        ),
+                        style: getVirtualTableFixedCellStyle(col.key, fixedInfo),
+                        children: renderCell ? renderCell(row[col.key], row, col) : String(row[col.key] ?? "")
+                      },
+                      col.key
+                    )),
+                    colRange && colRange.rightPad > 0 && /* @__PURE__ */ jsx("td", { "aria-hidden": true, style: { width: `${colRange.rightPad}px`, padding: 0 } })
+                  ]
+                },
+                key
+              );
+            }),
+            bottomHeight > 0 && /* @__PURE__ */ jsx("tr", { style: { height: `${bottomHeight}px` }, "aria-hidden": true })
+          ] })
+        ] }),
+        data.length === 0 && !loading && /* @__PURE__ */ jsx("div", { className: virtualTableEmptyClasses, children: resolveLocaleText("No data", emptyText, mergedLocale?.common?.emptyText) }),
+        loading && /* @__PURE__ */ jsx("div", { className: virtualTableLoadingClasses, children: resolveLocaleText("Loading...", mergedLocale?.common?.loadingText) })
+      ]
+    }
+  );
+};
+var VirtualTable_default = VirtualTable;
+
+export {
+  VirtualTable,
+  VirtualTable_default
+};

package/dist/chunk-AQOXANET.mjs

@@ -0,0 +1,222 @@
+import {
+  ChartTooltip
+} from "./chunk-O6YIPNXX.mjs";
+import {
+  ChartCanvas
+} from "./chunk-DKNVSQSV.mjs";
+
+// src/components/GaugeChart.tsx
+import React, { useId, useMemo, useState, useRef, useEffect } from "react";
+import {
+  classNames,
+  createGaugeArcPath,
+  createGaugeNeedlePath,
+  valueToGaugeAngle,
+  computeGaugeTicks,
+  getChartInnerRect,
+  chartAxisTickTextClasses,
+  getStableChartGradientPrefix,
+  createGaugeAnimation
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var GaugeChart = ({
+  width = 280,
+  height = 200,
+  padding = 24,
+  value,
+  min = 0,
+  max = 100,
+  startAngle = 135,
+  endAngle = 405,
+  arcWidth = 20,
+  showTicks = true,
+  tickCount = 5,
+  valueFormatter,
+  tooltipFormatter,
+  label,
+  segments,
+  trackColor = "var(--tiger-border,#e5e7eb)",
+  color = "var(--tiger-primary,#2563eb)",
+  gradient = false,
+  showTooltip = true,
+  title: chartTitle,
+  desc,
+  className
+}) => {
+  const innerRect = useMemo(
+    () => getChartInnerRect(width, height, padding),
+    [width, height, padding]
+  );
+  const radius = useMemo(
+    () => Math.min(innerRect.width, innerRect.height) / 2 - 4,
+    [innerRect.width, innerRect.height]
+  );
+  const cx = innerRect.width / 2;
+  const cy = innerRect.height / 2;
+  const needleAngle = useMemo(
+    () => valueToGaugeAngle(value, min, max, startAngle, endAngle),
+    [value, min, max, startAngle, endAngle]
+  );
+  const [animatedAngle, setAnimatedAngle] = useState(needleAngle);
+  const prevAngleRef = useRef(needleAngle);
+  useEffect(() => {
+    const from = prevAngleRef.current;
+    const to = needleAngle;
+    prevAngleRef.current = to;
+    if (from === to) return;
+    const ctrl = createGaugeAnimation({
+      from,
+      to,
+      onUpdate: (v) => setAnimatedAngle(v)
+    });
+    return () => ctrl.stop();
+  }, [needleAngle]);
+  const ticks = useMemo(
+    () => showTicks ? computeGaugeTicks(cx, cy, radius, min, max, startAngle, endAngle, tickCount) : [],
+    [showTicks, cx, cy, radius, min, max, startAngle, endAngle, tickCount]
+  );
+  const trackPath = createGaugeArcPath(cx, cy, radius, startAngle, endAngle, arcWidth);
+  const valuePath = animatedAngle > startAngle ? createGaugeArcPath(cx, cy, radius, startAngle, animatedAngle, arcWidth) : null;
+  const needlePath = createGaugeNeedlePath(cx, cy, radius - arcWidth - 6, animatedAngle);
+  const formattedValue = valueFormatter ? valueFormatter(value) : `${value}`;
+  const [tooltip, setTooltip] = useState({
+    visible: false,
+    x: 0,
+    y: 0
+  });
+  const tooltipContent = tooltipFormatter ? tooltipFormatter(value) : label ? `${label}: ${formattedValue}` : formattedValue;
+  const handleTooltipMove = (e) => {
+    if (!showTooltip) return;
+    setTooltip({ visible: true, x: e.clientX, y: e.clientY });
+  };
+  const handleTooltipLeave = () => setTooltip((t) => ({ ...t, visible: false }));
+  const gradientId = useId();
+  const gradientPrefix = useMemo(
+    () => getStableChartGradientPrefix("gauge", gradientId),
+    [gradientId]
+  );
+  const valueGradientId = `${gradientPrefix}-value`;
+  const wrapperRef = useRef(null);
+  const handleTooltipFocus = () => {
+    if (!showTooltip) return;
+    const rect = wrapperRef.current?.getBoundingClientRect();
+    if (rect)
+      setTooltip({ visible: true, x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 });
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: wrapperRef,
+      className: "inline-block relative",
+      tabIndex: showTooltip ? 0 : void 0,
+      role: "img",
+      "aria-label": label ? `${label}: ${formattedValue}` : formattedValue,
+      onMouseMove: handleTooltipMove,
+      onMouseLeave: handleTooltipLeave,
+      onFocus: handleTooltipFocus,
+      onBlur: handleTooltipLeave,
+      children: [
+        /* @__PURE__ */ jsxs(
+          ChartCanvas,
+          {
+            width,
+            height,
+            padding,
+            title: chartTitle,
+            desc,
+            className: classNames(className),
+            children: [
+              gradient && !segments && valuePath && /* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsxs("linearGradient", { id: valueGradientId, x1: 0, y1: 0, x2: 0, y2: 1, children: [
+                /* @__PURE__ */ jsx("stop", { offset: "0%", stopColor: color, stopOpacity: 1 }),
+                /* @__PURE__ */ jsx("stop", { offset: "100%", stopColor: color, stopOpacity: 0.55 })
+              ] }) }),
+              /* @__PURE__ */ jsx("path", { d: trackPath, fill: trackColor, strokeWidth: 0 }),
+              segments ? segments.map((seg, i) => {
+                const sStart = valueToGaugeAngle(seg.range[0], min, max, startAngle, endAngle);
+                const sEnd = valueToGaugeAngle(seg.range[1], min, max, startAngle, endAngle);
+                return /* @__PURE__ */ jsx(
+                  "path",
+                  {
+                    d: createGaugeArcPath(cx, cy, radius, sStart, sEnd, arcWidth),
+                    fill: seg.color,
+                    strokeWidth: 0
+                  },
+                  `seg-${i}`
+                );
+              }) : valuePath && /* @__PURE__ */ jsx(
+                "path",
+                {
+                  d: valuePath,
+                  fill: gradient ? `url(#${valueGradientId})` : color,
+                  strokeWidth: 0
+                }
+              ),
+              ticks.map((tick, i) => /* @__PURE__ */ jsxs(React.Fragment, { children: [
+                /* @__PURE__ */ jsx(
+                  "line",
+                  {
+                    x1: tick.x1,
+                    y1: tick.y1,
+                    x2: tick.x2,
+                    y2: tick.y2,
+                    stroke: "var(--tiger-text-secondary,#6b7280)",
+                    strokeWidth: 1
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  "text",
+                  {
+                    x: tick.x2 + (tick.x2 - tick.x1) * 1.5,
+                    y: tick.y2 + (tick.y2 - tick.y1) * 1.5,
+                    className: chartAxisTickTextClasses,
+                    textAnchor: "middle",
+                    dominantBaseline: "middle",
+                    style: { fontSize: "10px" },
+                    children: tick.label
+                  }
+                )
+              ] }, `tick-${i}`)),
+              /* @__PURE__ */ jsx("path", { d: needlePath, fill: "var(--tiger-text,#374151)" }),
+              /* @__PURE__ */ jsx("circle", { cx, cy, r: 5, fill: "var(--tiger-text,#374151)" }),
+              /* @__PURE__ */ jsx(
+                "text",
+                {
+                  x: cx,
+                  y: cy + radius * 0.35,
+                  className: "fill-[color:var(--tiger-text,#374151)] text-lg font-semibold tabular-nums",
+                  textAnchor: "middle",
+                  dominantBaseline: "middle",
+                  children: formattedValue
+                }
+              ),
+              label && /* @__PURE__ */ jsx(
+                "text",
+                {
+                  x: cx,
+                  y: cy + radius * 0.35 + 20,
+                  className: chartAxisTickTextClasses,
+                  textAnchor: "middle",
+                  dominantBaseline: "middle",
+                  children: label
+                }
+              )
+            ]
+          }
+        ),
+        showTooltip && /* @__PURE__ */ jsx(
+          ChartTooltip,
+          {
+            content: tooltipContent,
+            visible: tooltip.visible && tooltipContent !== "",
+            x: tooltip.x,
+            y: tooltip.y
+          }
+        )
+      ]
+    }
+  );
+};
+
+export {
+  GaugeChart
+};

package/dist/{chunk-YOAYDEWW.mjs → chunk-ATSI3UKS.mjs}

@@ -1,6 +1,6 @@
 import {
   useControlledState
-} from "./chunk-UQMPEMY7.mjs";
+} from "./chunk-WHYHLUXG.mjs";
 
 // src/components/MarkdownEditor.tsx
 import { useCallback, useMemo, useRef } from "react";
@@ -53,11 +53,8 @@ var MarkdownEditor = ({
   ...restProps
 }) => {
   const textareaRef = useRef(null);
-  const [currentValue, setInternalValue, isValueControlled] = useControlledState(
-    value,
-    defaultValue
-  );
-  const [currentMode, setInternalMode, isModeControlled] = useControlledState(mode, defaultMode);
+  const [currentValue, commitValue] = useControlledState(value, defaultValue, onChange);
+  const [currentMode, commitMode] = useControlledState(mode, defaultMode, onModeChange);
   const toolbarItems = useMemo(
     () => toolbar === false ? [] : toolbar ?? defaultMarkdownToolbar,
     [toolbar]
@@ -70,20 +67,6 @@ var MarkdownEditor = ({
     const parsedHeight = parseMarkdownHeight(height);
     return { ...parsedHeight ? { height: parsedHeight } : {}, ...style };
   }, [height, style]);
-  const commitValue = useCallback(
-    (nextValue) => {
-      if (!isValueControlled) setInternalValue(nextValue);
-      onChange?.(nextValue);
-    },
-    [isValueControlled, onChange, setInternalValue]
-  );
-  const commitMode = useCallback(
-    (nextMode) => {
-      if (!isModeControlled) setInternalMode(nextMode);
-      onModeChange?.(nextMode);
-    },
-    [isModeControlled, onModeChange, setInternalMode]
-  );
   const applyToolbarButton = useCallback(
     (button) => {
       if (readOnly || disabled) return;
@@ -137,7 +120,8 @@ var MarkdownEditor = ({
       ),
       role: "region",
       "aria-label": "Markdown preview",
-      dangerouslySetInnerHTML: { __html: currentValue ? previewHtml : placeholder || "" }
+      ...currentValue ? { dangerouslySetInnerHTML: { __html: previewHtml } } : {},
+      children: currentValue ? null : placeholder
     }
   );
   return /* @__PURE__ */ jsxs(

package/dist/{chunk-ZRHDNGWO.js → chunk-BR3WLDH7.js}

@@ -1,4 +1,8 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/components/Empty.tsx
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkTDODFBBOjs = require('./chunk-TDODFBBO.js');
+
+// src/components/Empty.tsx
 var _react = require('react');
 
 
@@ -9,6 +13,7 @@ var _react = require('react');
 
 
 
+
 var _tigercatcore = require('@expcat/tigercat-core');
 var _jsxruntime = require('react/jsx-runtime');
 var Empty = ({
@@ -19,9 +24,18 @@ var Empty = ({
   extra,
   className,
   children,
+  locale,
   ...props
 }) => {
-  const descText = _react.useMemo.call(void 0, () => _nullishCoalesce(description, () => ( _tigercatcore.getEmptyDescription.call(void 0, preset))), [description, preset]);
+  const config = _chunkTDODFBBOjs.useTigerConfig.call(void 0, );
+  const mergedLocale = _react.useMemo.call(void 0, 
+    () => _tigercatcore.mergeTigerLocale.call(void 0, config.locale, locale),
+    [config.locale, locale]
+  );
+  const descText = _react.useMemo.call(void 0, 
+    () => _nullishCoalesce(description, () => ( _tigercatcore.getEmptyDescription.call(void 0, preset, mergedLocale))),
+    [description, preset, mergedLocale]
+  );
   const wrapperClasses = _react.useMemo.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.emptyBaseClasses, className), [className]);
   return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: wrapperClasses, ...props, children: [
     showImage && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.emptyImageClasses, children: image !== void 0 ? image : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 

package/dist/{chunk-2Y5NIPHB.mjs → chunk-BRPOEVRT.mjs}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-6QML6T3Y.mjs";
 import {
   ChartLegend
-} from "./chunk-UBP7HZSU.mjs";
+} from "./chunk-ZG2W4HS5.mjs";
 import {
   ChartSeries
 } from "./chunk-SDLMB34Y.mjs";
 import {
   ChartTooltip
-} from "./chunk-NASC6XHN.mjs";
+} from "./chunk-O6YIPNXX.mjs";
 import {
   ChartCanvas
 } from "./chunk-DKNVSQSV.mjs";
@@ -158,6 +158,18 @@ var RadarChart = ({
     setHoveredPoint(null);
     handleHoverLeave();
   }, [handleHoverLeave]);
+  const showPointTooltipFromElement = useCallback(
+    (el, seriesIndex, pointIndex) => {
+      if (!hoverable) return;
+      const rect = el.getBoundingClientRect();
+      setHoveredPoint({ seriesIndex, pointIndex });
+      handleHoverEnter(seriesIndex, {
+        clientX: rect.left + rect.width / 2,
+        clientY: rect.top + rect.height / 2
+      });
+    },
+    [hoverable, handleHoverEnter]
+  );
   const innerRect = useMemo(
     () => getChartInnerRect(width, height, padding),
     [width, height, padding]
@@ -562,13 +574,30 @@ var RadarChart = ({
                         showTooltip && hoverable ? "cursor-pointer" : void 0,
                         "transition-[r] duration-150 ease-out"
                       ),
+                      role: showTooltip && hoverable ? "button" : "img",
+                      "aria-label": point.data.label ?? String(point.data.value),
+                      tabIndex: showTooltip && hoverable ? 0 : void 0,
                       "data-radar-point": "true",
                       "data-series-index": seriesIndex,
                       "data-series-key": item.seriesKey,
                       "data-point-index": point.index,
                       onMouseEnter: showTooltip && hoverable ? (e) => handlePointEnter(seriesIndex, point.index, e) : void 0,
                       onMouseMove: showTooltip && hoverable ? handlePointMove : void 0,
-                      onMouseLeave: showTooltip && hoverable ? handlePointLeave : void 0
+                      onMouseLeave: showTooltip && hoverable ? handlePointLeave : void 0,
+                      onFocus: showTooltip && hoverable ? (e) => showPointTooltipFromElement(e.currentTarget, seriesIndex, point.index) : void 0,
+                      onBlur: showTooltip && hoverable ? handlePointLeave : void 0,
+                      onKeyDown: showTooltip && hoverable ? (e) => {
+                        if (e.key === "Enter" || e.key === " ") {
+                          e.preventDefault();
+                          showPointTooltipFromElement(
+                            e.currentTarget,
+                            seriesIndex,
+                            point.index
+                          );
+                        } else if (e.key === "Escape") {
+                          handlePointLeave();
+                        }
+                      } : void 0
                     },
                     `point-${item.seriesKey}-${point.index}`
                   );