@expcat/tigercat-react 1.1.0 → 1.2.14

package/dist/chunk-QQFLRNI3.mjs

@@ -0,0 +1,202 @@
+// src/components/Signature.tsx
+import {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useRef,
+  useState
+} from "react";
+import {
+  classNames,
+  clampSignatureLineWidth,
+  cloneSignatureStrokes,
+  drawSignatureStrokes,
+  getSignatureCanvasDataUrl,
+  getSignatureCanvasWrapClasses,
+  getSignaturePoint,
+  isSignatureEmpty,
+  signatureCanvasClasses,
+  signatureClearButtonClasses,
+  signatureRootClasses,
+  signatureStrokesToSvg,
+  signatureSvgToDataUrl,
+  signatureToolbarClasses
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_WIDTH = 480;
+var DEFAULT_HEIGHT = 180;
+var Signature = forwardRef(
+  ({
+    width = DEFAULT_WIDTH,
+    height = DEFAULT_HEIGHT,
+    penColor = "#111827",
+    backgroundColor,
+    lineWidth = 2,
+    disabled = false,
+    readonly = false,
+    clearable = true,
+    exportType = "image/png",
+    quality = 0.92,
+    ariaLabel = "Signature pad",
+    clearText = "Clear",
+    className,
+    onChange,
+    onBegin,
+    onEnd,
+    style,
+    ...rest
+  }, ref) => {
+    const canvasRef = useRef(null);
+    const strokesRef = useRef([]);
+    const activeStrokeRef = useRef(null);
+    const [strokes, setStrokes] = useState([]);
+    const isDisabled = disabled || readonly;
+    const normalizedLineWidth = clampSignatureLineWidth(lineWidth);
+    const draw = useCallback(
+      (nextStrokes) => {
+        const canvas = canvasRef.current;
+        const context = canvas?.getContext("2d");
+        if (!canvas || !context) return;
+        const ratio = typeof window === "undefined" ? 1 : window.devicePixelRatio || 1;
+        canvas.width = width * ratio;
+        canvas.height = height * ratio;
+        canvas.style.width = `${width}px`;
+        canvas.style.height = `${height}px`;
+        context.setTransform(ratio, 0, 0, ratio, 0, 0);
+        drawSignatureStrokes(context, nextStrokes, { width, height, backgroundColor });
+      },
+      [backgroundColor, height, width]
+    );
+    useEffect(() => {
+      draw(strokes);
+    }, [draw, strokes]);
+    const toSVG = useCallback(
+      () => signatureStrokesToSvg(strokesRef.current, { width, height, backgroundColor }),
+      [backgroundColor, height, width]
+    );
+    const toDataURL = useCallback(
+      (type = exportType, nextQuality = quality) => {
+        if (type === "image/svg+xml") return signatureSvgToDataUrl(toSVG());
+        return getSignatureCanvasDataUrl(canvasRef.current, type, nextQuality);
+      },
+      [exportType, quality, toSVG]
+    );
+    const createPayload = useCallback(
+      (nextStrokes, type = exportType) => {
+        const value = type === "image/svg+xml" ? signatureSvgToDataUrl(
+          signatureStrokesToSvg(nextStrokes, { width, height, backgroundColor })
+        ) : getSignatureCanvasDataUrl(canvasRef.current, type, quality);
+        return {
+          value,
+          empty: isSignatureEmpty(nextStrokes),
+          strokes: cloneSignatureStrokes(nextStrokes),
+          exportType: type
+        };
+      },
+      [backgroundColor, exportType, height, quality, width]
+    );
+    const emitChange = useCallback(
+      (nextStrokes) => {
+        const payload = createPayload(nextStrokes);
+        onChange?.(payload);
+        return payload;
+      },
+      [createPayload, onChange]
+    );
+    const clear = useCallback(() => {
+      strokesRef.current = [];
+      activeStrokeRef.current = null;
+      setStrokes([]);
+      draw([]);
+      emitChange([]);
+    }, [draw, emitChange]);
+    useImperativeHandle(
+      ref,
+      () => ({
+        clear,
+        isEmpty: () => isSignatureEmpty(strokesRef.current),
+        toDataURL,
+        toSVG
+      }),
+      [clear, toDataURL, toSVG]
+    );
+    const getPointFromEvent = (event) => {
+      const rect = event.currentTarget.getBoundingClientRect();
+      return getSignaturePoint(event.clientX, event.clientY, rect, width, height);
+    };
+    const handlePointerDown = (event) => {
+      if (isDisabled) return;
+      event.preventDefault();
+      event.currentTarget.focus();
+      const stroke = {
+        color: penColor,
+        lineWidth: normalizedLineWidth,
+        points: [getPointFromEvent(event)]
+      };
+      const nextStrokes = [...strokesRef.current, stroke];
+      activeStrokeRef.current = stroke;
+      strokesRef.current = nextStrokes;
+      setStrokes(nextStrokes);
+      onBegin?.();
+    };
+    const handlePointerMove = (event) => {
+      const activeStroke = activeStrokeRef.current;
+      if (!activeStroke || isDisabled) return;
+      event.preventDefault();
+      activeStroke.points.push(getPointFromEvent(event));
+      const nextStrokes = [...strokesRef.current];
+      strokesRef.current = nextStrokes;
+      setStrokes(nextStrokes);
+    };
+    const finishStroke = () => {
+      if (!activeStrokeRef.current) return;
+      activeStrokeRef.current = null;
+      const payload = emitChange(strokesRef.current);
+      onEnd?.(payload);
+    };
+    const handleKeyDown = (event) => {
+      if (!clearable || isDisabled) return;
+      if (event.key !== "Delete" && event.key !== "Backspace") return;
+      event.preventDefault();
+      clear();
+    };
+    return /* @__PURE__ */ jsxs("div", { className: classNames(signatureRootClasses, className), style, ...rest, children: [
+      /* @__PURE__ */ jsx("div", { className: getSignatureCanvasWrapClasses(disabled, readonly), children: /* @__PURE__ */ jsx(
+        "canvas",
+        {
+          ref: canvasRef,
+          className: signatureCanvasClasses,
+          width,
+          height,
+          tabIndex: isDisabled ? -1 : 0,
+          role: "img",
+          "aria-label": ariaLabel,
+          "aria-disabled": isDisabled || void 0,
+          onPointerDown: handlePointerDown,
+          onPointerMove: handlePointerMove,
+          onPointerUp: finishStroke,
+          onPointerCancel: finishStroke,
+          onKeyDown: handleKeyDown
+        }
+      ) }),
+      clearable && /* @__PURE__ */ jsx("div", { className: signatureToolbarClasses, children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: signatureClearButtonClasses,
+          disabled: isDisabled || isSignatureEmpty(strokesRef.current),
+          onClick: clear,
+          children: clearText
+        }
+      ) })
+    ] });
+  }
+);
+Signature.displayName = "Signature";
+var Signature_default = Signature;
+
+export {
+  Signature,
+  Signature_default
+};

package/dist/chunk-QQKP437L.js

@@ -1,10 +1,19 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var chunkVE3SYUMH_js = require('./chunk-VE3SYUMH.js');
-var react = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
+var _chunkVE3SYUMHjs = require('./chunk-VE3SYUMH.js');
 
+// src/components/Col.tsx
+var _react = require('react');
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
 var Col = ({
   span = 24,
   offset = 0,
@@ -15,27 +24,29 @@ var Col = ({
   style,
   ...divProps
 }) => {
-  const { gutter } = react.useContext(chunkVE3SYUMH_js.RowContext);
+  const { gutter } = _react.useContext.call(void 0, _chunkVE3SYUMHjs.RowContext);
   const isFlexSpanMode = flex !== void 0 && span === 0;
-  const colClasses = react.useMemo(
-    () => tigercatCore.classNames(
-      isFlexSpanMode ? "" : tigercatCore.getSpanClasses(span),
-      tigercatCore.getOffsetClasses(offset),
-      tigercatCore.getOrderClasses(order),
-      tigercatCore.getFlexClasses(flex),
-      tigercatCore.getColGutterClasses(gutter || 0),
+  const colClasses = _react.useMemo.call(void 0, 
+    () => _tigercatcore.classNames.call(void 0, 
+      isFlexSpanMode ? "" : _tigercatcore.getSpanClasses.call(void 0, span),
+      _tigercatcore.getOffsetClasses.call(void 0, offset),
+      _tigercatcore.getOrderClasses.call(void 0, order),
+      _tigercatcore.getFlexClasses.call(void 0, flex),
+      _tigercatcore.getColGutterClasses.call(void 0, gutter || 0),
       className
     ),
     [gutter, isFlexSpanMode, span, offset, order, flex, className]
   );
-  const mergedStyle = react.useMemo(
+  const mergedStyle = _react.useMemo.call(void 0, 
     () => ({
-      ...tigercatCore.getColMergedStyleVars(isFlexSpanMode ? void 0 : span, offset, order, flex),
+      ..._tigercatcore.getColMergedStyleVars.call(void 0, isFlexSpanMode ? void 0 : span, offset, order, flex),
       ...style
     }),
     [isFlexSpanMode, span, offset, order, flex, style]
   );
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: colClasses, style: mergedStyle, ...divProps, children });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: colClasses, style: mergedStyle, ...divProps, children });
 };
 
+
+
 exports.Col = Col;

package/dist/chunk-QWOE4FGJ.mjs

@@ -0,0 +1,227 @@
+// src/components/CronEditor.tsx
+import { useMemo, useState } from "react";
+import {
+  buildCronFieldValue,
+  classNames,
+  cronEditorBaseClasses,
+  cronEditorErrorClasses,
+  cronEditorFieldClasses,
+  cronEditorFieldsClasses,
+  cronEditorLabelClasses,
+  cronFieldMetas,
+  defaultCronExpression,
+  defaultCronPresets,
+  getCronEditorControlClasses,
+  getCronFieldIssue,
+  getCronFieldValue,
+  normalizeCronExpression,
+  parseCronFieldControl,
+  updateCronExpressionField,
+  validateCronExpression
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var modeOptions = [
+  { label: "Any", value: "any" },
+  { label: "Every", value: "every" },
+  { label: "Specific", value: "specific" },
+  { label: "Range", value: "range" },
+  { label: "Custom", value: "custom" }
+];
+var CronEditor = ({
+  value,
+  defaultValue = defaultCronExpression,
+  disabled = false,
+  readonly = false,
+  size = "md",
+  presets = defaultCronPresets,
+  ariaLabel = "Cron editor",
+  className,
+  onChange,
+  onValidate
+}) => {
+  const [innerValue, setInnerValue] = useState(defaultValue);
+  const expression = value ?? innerValue;
+  const validation = useMemo(() => validateCronExpression(expression), [expression]);
+  const inactive = disabled || readonly;
+  function commit(nextValue) {
+    const normalized = normalizeCronExpression(nextValue);
+    const nextValidation = validateCronExpression(normalized);
+    if (value === void 0) setInnerValue(normalized);
+    onChange?.(normalized, nextValidation);
+    onValidate?.(nextValidation);
+  }
+  function handleRawExpressionChange(nextValue) {
+    const nextValidation = validateCronExpression(nextValue);
+    if (value === void 0) setInnerValue(nextValue);
+    onChange?.(nextValue, nextValidation);
+    onValidate?.(nextValidation);
+  }
+  function handleFieldRawChange(meta, raw) {
+    commit(updateCronExpressionField(expression, meta.key, raw));
+  }
+  function handleModeChange(meta, control, mode) {
+    const nextControl = {
+      ...control,
+      mode,
+      value: control.value ?? meta.min,
+      start: control.start ?? meta.min,
+      end: control.end ?? meta.max,
+      step: control.step ?? 1
+    };
+    handleFieldRawChange(meta, buildCronFieldValue(nextControl, meta));
+  }
+  function renderFieldControl(meta, control) {
+    if (control.mode === "any") return null;
+    if (control.mode === "every") {
+      return /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "number",
+          min: 1,
+          max: meta.max,
+          className: getCronEditorControlClasses(size),
+          value: control.step ?? 1,
+          disabled: inactive,
+          "aria-label": `${meta.label} step`,
+          onChange: (event) => handleFieldRawChange(
+            meta,
+            buildCronFieldValue({ ...control, step: Number(event.target.value) }, meta)
+          )
+        }
+      );
+    }
+    if (control.mode === "specific") {
+      return /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "number",
+          min: meta.min,
+          max: meta.max,
+          className: getCronEditorControlClasses(size),
+          value: control.value ?? meta.min,
+          disabled: inactive,
+          "aria-label": `${meta.label} value`,
+          onChange: (event) => handleFieldRawChange(
+            meta,
+            buildCronFieldValue({ ...control, value: Number(event.target.value) }, meta)
+          )
+        }
+      );
+    }
+    if (control.mode === "range") {
+      return /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-2 gap-1", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "number",
+            min: meta.min,
+            max: meta.max,
+            className: getCronEditorControlClasses(size),
+            value: control.start ?? meta.min,
+            disabled: inactive,
+            "aria-label": `${meta.label} range start`,
+            onChange: (event) => handleFieldRawChange(
+              meta,
+              buildCronFieldValue({ ...control, start: Number(event.target.value) }, meta)
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "number",
+            min: meta.min,
+            max: meta.max,
+            className: getCronEditorControlClasses(size),
+            value: control.end ?? meta.max,
+            disabled: inactive,
+            "aria-label": `${meta.label} range end`,
+            onChange: (event) => handleFieldRawChange(
+              meta,
+              buildCronFieldValue({ ...control, end: Number(event.target.value) }, meta)
+            )
+          }
+        )
+      ] });
+    }
+    return /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "text",
+        className: getCronEditorControlClasses(size),
+        value: control.raw,
+        disabled: inactive,
+        "aria-label": `${meta.label} custom value`,
+        onChange: (event) => handleFieldRawChange(meta, event.target.value)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: classNames(cronEditorBaseClasses, className),
+      role: "group",
+      "aria-label": ariaLabel,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2 sm:flex-row", children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              type: "text",
+              className: classNames(getCronEditorControlClasses(size, !validation.valid), "flex-1"),
+              value: expression,
+              disabled,
+              readOnly: readonly,
+              "aria-label": "Cron expression",
+              onChange: (event) => handleRawExpressionChange(event.target.value)
+            }
+          ),
+          presets.length > 0 && /* @__PURE__ */ jsxs(
+            "select",
+            {
+              className: getCronEditorControlClasses(size),
+              value: presets.some((preset) => preset.value === expression) ? expression : "",
+              disabled: inactive,
+              "aria-label": "Cron preset",
+              onChange: (event) => {
+                if (event.target.value) commit(event.target.value);
+              },
+              children: [
+                /* @__PURE__ */ jsx("option", { value: "", children: "Preset" }),
+                presets.map((preset) => /* @__PURE__ */ jsx("option", { value: preset.value, children: preset.label }, preset.value))
+              ]
+            }
+          )
+        ] }),
+        validation.issues.filter((issue) => issue.field === "expression").map((issue) => /* @__PURE__ */ jsx("div", { className: cronEditorErrorClasses, children: issue.message }, issue.message)),
+        /* @__PURE__ */ jsx("div", { className: cronEditorFieldsClasses, children: cronFieldMetas.map((meta) => {
+          const raw = getCronFieldValue(expression, meta.key);
+          const control = parseCronFieldControl(raw);
+          const issue = getCronFieldIssue(validation, meta.key);
+          return /* @__PURE__ */ jsxs("div", { className: cronEditorFieldClasses, children: [
+            /* @__PURE__ */ jsx("label", { className: cronEditorLabelClasses, children: meta.label }),
+            /* @__PURE__ */ jsx(
+              "select",
+              {
+                className: getCronEditorControlClasses(size, !!issue),
+                value: control.mode,
+                disabled: inactive,
+                "aria-label": `${meta.label} mode`,
+                onChange: (event) => handleModeChange(meta, control, event.target.value),
+                children: modeOptions.map((mode) => /* @__PURE__ */ jsx("option", { value: mode.value, children: mode.label }, mode.value))
+              }
+            ),
+            renderFieldControl(meta, control),
+            issue && /* @__PURE__ */ jsx("div", { className: cronEditorErrorClasses, children: issue.message })
+          ] }, meta.key);
+        }) })
+      ]
+    }
+  );
+};
+var CronEditor_default = CronEditor;
+
+export {
+  CronEditor,
+  CronEditor_default
+};

package/dist/chunk-QYYAXM5F.js

@@ -1,10 +1,14 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/components/Link.tsx
+var _react = require('react');
 
-var react = require('react');
-var tigercatCore = require('@expcat/tigercat-core');
-var jsxRuntime = require('react/jsx-runtime');
 
-// src/components/Link.tsx
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
 var Link = ({
   variant = "primary",
   size = "md",
@@ -20,41 +24,41 @@ var Link = ({
   className,
   ...props
 }) => {
-  const linkClasses = react.useMemo(
-    () => tigercatCore.classNames(
-      tigercatCore.linkBaseClasses,
-      tigercatCore.getLinkVariantClasses(variant, void 0, { disabled }),
-      tigercatCore.linkSizeClasses[size],
+  const linkClasses = _react.useMemo.call(void 0, 
+    () => _tigercatcore.classNames.call(void 0, 
+      _tigercatcore.linkBaseClasses,
+      _tigercatcore.getLinkVariantClasses.call(void 0, variant, void 0, { disabled }),
+      _tigercatcore.linkSizeClasses[size],
       underline && "hover:underline",
-      disabled && tigercatCore.linkDisabledClasses,
+      disabled && _tigercatcore.linkDisabledClasses,
       className
     ),
     [variant, size, underline, disabled, className]
   );
-  const computedRel = react.useMemo(() => tigercatCore.getSecureRel(target, rel), [target, rel]);
-  const handleClick = react.useCallback(
+  const computedRel = _react.useMemo.call(void 0, () => _tigercatcore.getSecureRel.call(void 0, target, rel), [target, rel]);
+  const handleClick = _react.useCallback.call(void 0, 
     (event) => {
       if (disabled) {
         event.preventDefault();
         event.stopPropagation();
         return;
       }
-      onClick?.(event);
+      _optionalChain([onClick, 'optionalCall', _ => _(event)]);
     },
     [disabled, onClick]
   );
-  const handleKeyDown = react.useCallback(
+  const handleKeyDown = _react.useCallback.call(void 0, 
     (event) => {
       if (disabled && (event.key === "Enter" || event.key === " ")) {
         event.preventDefault();
         event.stopPropagation();
         return;
       }
-      onKeyDown?.(event);
+      _optionalChain([onKeyDown, 'optionalCall', _2 => _2(event)]);
     },
     [disabled, onKeyDown]
   );
-  return /* @__PURE__ */ jsxRuntime.jsx(
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
     "a",
     {
       ...props,
@@ -71,4 +75,6 @@ var Link = ({
   );
 };
 
+
+
 exports.Link = Link;

package/dist/{chunk-D45GM4YH.mjs → chunk-R2KUNFDN.mjs}

@@ -1,11 +1,29 @@
-import { useChartInteraction } from './chunk-6QML6T3Y.mjs';
-import { ChartLegend } from './chunk-UBP7HZSU.mjs';
-import { ChartTooltip } from './chunk-2IUTFPQQ.mjs';
-import { ChartCanvas } from './chunk-DKNVSQSV.mjs';
-import { useMemo } from 'react';
-import { getChartInnerRect, resolveChartPalette, getSunburstGradientPrefix, computeSunburstArcs, buildChartLegendItems, resolveChartTooltipContent, classNames, getChartElementOpacity } from '@expcat/tigercat-core';
-import { jsx, jsxs } from 'react/jsx-runtime';
+import {
+  useChartInteraction
+} from "./chunk-6QML6T3Y.mjs";
+import {
+  ChartLegend
+} from "./chunk-UBP7HZSU.mjs";
+import {
+  ChartTooltip
+} from "./chunk-NASC6XHN.mjs";
+import {
+  ChartCanvas
+} from "./chunk-DKNVSQSV.mjs";
 
+// src/components/SunburstChart.tsx
+import { useId, useMemo } from "react";
+import {
+  classNames,
+  computeSunburstArcs,
+  getChartElementOpacity,
+  getChartInnerRect,
+  getStableChartGradientPrefix,
+  resolveChartPalette,
+  buildChartLegendItems,
+  resolveChartTooltipContent
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
 var SunburstChart = ({
   width = 320,
   height = 320,
@@ -40,7 +58,11 @@ var SunburstChart = ({
     [width, height, padding]
   );
   const palette = useMemo(() => resolveChartPalette(colors), [colors]);
-  const gradientPrefix = useMemo(() => getSunburstGradientPrefix(), []);
+  const gradientId = useId();
+  const gradientPrefix = useMemo(
+    () => getStableChartGradientPrefix("sunburst", gradientId),
+    [gradientId]
+  );
   const outerRadius = useMemo(
     () => Math.min(innerRect.width, innerRect.height) / 2,
     [innerRect.width, innerRect.height]
@@ -154,7 +176,7 @@ var SunburstChart = ({
               strokeWidth: 1,
               className: classNames(interactive && "cursor-pointer"),
               style: {
-                transition: "opacity 0.2s ease-out, filter 0.2s ease-out",
+                transition: "opacity var(--tiger-motion-duration-base,0.2s) var(--tiger-motion-ease-decelerate,ease-out), filter var(--tiger-motion-duration-base,0.2s) var(--tiger-motion-ease-decelerate,ease-out)",
                 filter: activeIndex === arc.index ? "var(--tiger-chart-block-active-filter, none)" : "none"
               },
               tabIndex: selectable ? 0 : void 0,
@@ -205,4 +227,6 @@ var SunburstChart = ({
   ] });
 };
 
-export { SunburstChart };
+export {
+  SunburstChart
+};

package/dist/{chunk-7Y5XUZJ4.mjs → chunk-R4OVIDAY.mjs}

@@ -1,8 +1,20 @@
-import { useRef, useState, useMemo, useCallback } from 'react';
-import { calculateVirtualRange, getVirtualTableContainerClasses, getVirtualTableFixedInfo, classNames, virtualTableHeaderClasses, getVirtualTableFixedCellStyle, virtualTableHeaderCellClasses, getVirtualRowKey, getVirtualTableRowClasses, virtualTableCellClasses, virtualTableEmptyClasses, virtualTableLoadingClasses } from '@expcat/tigercat-core';
-import { jsxs, jsx } from 'react/jsx-runtime';
-
 // src/components/VirtualTable.tsx
+import { useCallback, useMemo, useRef, useState } from "react";
+import {
+  classNames,
+  calculateVirtualRange,
+  getVirtualTableContainerClasses,
+  getVirtualTableRowClasses,
+  getVirtualRowKey,
+  getVirtualTableFixedInfo,
+  getVirtualTableFixedCellStyle,
+  virtualTableHeaderClasses,
+  virtualTableHeaderCellClasses,
+  virtualTableCellClasses,
+  virtualTableEmptyClasses,
+  virtualTableLoadingClasses
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
 var VirtualTable = ({
   data = [],
   columns = [],
@@ -43,10 +55,7 @@ var VirtualTable = ({
     () => getVirtualTableContainerClasses(bordered, className),
     [bordered, className]
   );
-  const fixedInfo = useMemo(
-    () => getVirtualTableFixedInfo(columns),
-    [columns]
-  );
+  const fixedInfo = useMemo(() => getVirtualTableFixedInfo(columns), [columns]);
   const bottomHeight = Math.max(0, range.totalHeight - range.end * rowHeight);
   return /* @__PURE__ */ jsxs(
     "div",
@@ -113,4 +122,7 @@ var VirtualTable = ({
 };
 var VirtualTable_default = VirtualTable;
 
-export { VirtualTable, VirtualTable_default };
+export {
+  VirtualTable,
+  VirtualTable_default
+};