@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-W6AWN7BC.js

@@ -0,0 +1,366 @@
+"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 _chunkXTV5JLLCjs = require('./chunk-XTV5JLLC.js');
+
+
+var _chunkWV5XHYW6js = require('./chunk-WV5XHYW6.js');
+
+
+var _chunkAX5XRD2Qjs = require('./chunk-AX5XRD2Q.js');
+
+
+var _chunkUVMQJOTXjs = require('./chunk-UVMQJOTX.js');
+
+
+var _chunkE5GD3H7Ljs = require('./chunk-E5GD3H7L.js');
+
+
+var _chunkUKLVOR4Ejs = require('./chunk-UKLVOR4E.js');
+
+
+var _chunk3QFHVAZTjs = require('./chunk-3QFHVAZT.js');
+
+// src/components/ScatterChart.tsx
+var _react = require('react');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var ScatterChart = ({
+  width = 320,
+  height = 200,
+  padding = 24,
+  data,
+  xScale,
+  yScale,
+  pointSize = 6,
+  pointColor = "var(--tiger-primary,#2563eb)",
+  pointOpacity,
+  pointStyle = "circle",
+  gradient = false,
+  animated = false,
+  pointBorderWidth = 0,
+  pointBorderColor = "white",
+  showGrid = true,
+  showAxis = true,
+  showXAxis = true,
+  showYAxis = true,
+  includeZero = false,
+  xAxisLabel,
+  yAxisLabel,
+  xTicks = 5,
+  yTicks = 5,
+  xTickValues,
+  yTickValues,
+  xTickFormat,
+  yTickFormat,
+  gridLineStyle = "solid",
+  gridStrokeWidth = 1,
+  // Interaction
+  hoverable = false,
+  hoveredIndex: hoveredIndexProp,
+  onHoveredIndexChange,
+  activeOpacity = 1,
+  inactiveOpacity = 0.25,
+  selectable = false,
+  selectedIndex: selectedIndexProp,
+  onSelectedIndexChange,
+  onPointClick,
+  onPointHover,
+  // Legend
+  showLegend = false,
+  legendPosition = "bottom",
+  legendMarkerSize = 10,
+  legendGap = 8,
+  legendFormatter,
+  // Tooltip
+  showTooltip = true,
+  tooltipFormatter,
+  // Other
+  colors,
+  title,
+  desc,
+  className
+}) => {
+  const gradientId = _react.useId.call(void 0, );
+  const gradientPrefix = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getStableChartGradientPrefix.call(void 0, "scatter", gradientId),
+    [gradientId]
+  );
+  const [mounted, setMounted] = _react.useState.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (animated) setMounted(true);
+  }, [animated]);
+  const {
+    tooltipPosition,
+    resolvedHoveredIndex,
+    activeIndex,
+    handleMouseEnter,
+    handleMouseMove,
+    handleMouseLeave,
+    handleClick,
+    handleKeyDown,
+    handleLegendClick,
+    handleLegendHover,
+    handleLegendLeave,
+    wrapperClasses
+  } = _chunkXTV5JLLCjs.useChartInteraction.call(void 0, {
+    hoverable,
+    hoveredIndexProp,
+    selectable,
+    selectedIndexProp,
+    activeOpacity,
+    inactiveOpacity,
+    legendPosition,
+    getData: (index) => data[index],
+    onHoveredIndexChange: (index) => {
+      _optionalChain([onHoveredIndexChange, 'optionalCall', _ => _(index)]);
+      _optionalChain([onPointHover, 'optionalCall', _2 => _2(index, index !== null ? data[index] : null)]);
+    },
+    onSelectedIndexChange,
+    callbacks: { onClick: onPointClick }
+  });
+  const innerRect = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getChartInnerRect.call(void 0, width, height, padding),
+    [width, height, padding]
+  );
+  const xValues = _react.useMemo.call(void 0, () => data.map((item) => item.x), [data]);
+  const yValues = _react.useMemo.call(void 0, () => data.map((item) => item.y), [data]);
+  const resolvedXScale = _react.useMemo.call(void 0, () => {
+    if (xScale) return xScale;
+    const extent = _tigercatcore.getNumberExtent.call(void 0, xValues, { includeZero });
+    return _tigercatcore.createLinearScale.call(void 0, extent, [0, innerRect.width]);
+  }, [xScale, xValues, includeZero, innerRect.width]);
+  const resolvedYScale = _react.useMemo.call(void 0, () => {
+    if (yScale) return yScale;
+    const extent = _tigercatcore.getNumberExtent.call(void 0, yValues, { includeZero });
+    return _tigercatcore.createLinearScale.call(void 0, extent, [innerRect.height, 0]);
+  }, [yScale, yValues, includeZero, innerRect.height]);
+  const palette = _react.useMemo.call(void 0, () => _tigercatcore.resolveChartPalette.call(void 0, colors, pointColor), [colors, pointColor]);
+  const points = _react.useMemo.call(void 0, 
+    () => data.map((item, index) => {
+      const color = _nullishCoalesce(item.color, () => ( palette[index % palette.length]));
+      const opacity = _tigercatcore.getChartElementOpacity.call(void 0, index, activeIndex, {
+        activeOpacity,
+        inactiveOpacity
+      });
+      const isHovered = resolvedHoveredIndex === index;
+      const baseSize = _nullishCoalesce(item.size, () => ( pointSize));
+      const r = isHovered ? _tigercatcore.getScatterHoverSize.call(void 0, baseSize) : baseSize;
+      return {
+        cx: resolvedXScale.map(item.x),
+        cy: resolvedYScale.map(item.y),
+        r,
+        baseSize,
+        color,
+        opacity: _nullishCoalesce(pointOpacity, () => ( opacity)),
+        isHovered,
+        datum: item
+      };
+    }),
+    [
+      data,
+      palette,
+      activeIndex,
+      activeOpacity,
+      inactiveOpacity,
+      resolvedHoveredIndex,
+      resolvedXScale,
+      resolvedYScale,
+      pointSize,
+      pointOpacity
+    ]
+  );
+  const legendItems = _react.useMemo.call(void 0, 
+    () => _tigercatcore.buildChartLegendItems.call(void 0, {
+      data,
+      palette,
+      activeIndex,
+      getLabel: (d, i) => legendFormatter ? legendFormatter(d, i) : _nullishCoalesce(d.label, () => ( `(${d.x}, ${d.y})`)),
+      getColor: (d, i) => _nullishCoalesce(d.color, () => ( palette[i % palette.length]))
+    }),
+    [data, legendFormatter, palette, activeIndex]
+  );
+  const tooltipContent = _react.useMemo.call(void 0, 
+    () => _tigercatcore.resolveChartTooltipContent.call(void 0, resolvedHoveredIndex, data, tooltipFormatter, (datum, index) => {
+      const label = _nullishCoalesce(datum.label, () => ( `Point ${index + 1}`));
+      return `${label}: (${datum.x}, ${datum.y})`;
+    }),
+    [resolvedHoveredIndex, data, tooltipFormatter]
+  );
+  const shouldShowXAxis = showAxis && showXAxis;
+  const shouldShowYAxis = showAxis && showYAxis;
+  const interactive = hoverable || selectable;
+  const chart = /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _chunkUKLVOR4Ejs.ChartCanvas,
+    {
+      width,
+      height,
+      padding,
+      title,
+      desc,
+      className: _tigercatcore.classNames.call(void 0, className),
+      children: [
+        gradient && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "defs", { children: palette.map((color, i) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+          "radialGradient",
+          {
+            id: `${gradientPrefix}-${i}`,
+            cx: "35%",
+            cy: "35%",
+            r: "65%",
+            children: [
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "0%", stopColor: "#fff", stopOpacity: 0.5 }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "50%", stopColor: color, stopOpacity: 0.95 }),
+              /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "stop", { offset: "100%", stopColor: color, stopOpacity: 1 })
+            ]
+          },
+          `grad-${i}`
+        )) }),
+        animated && mounted && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "style", { children: _tigercatcore.SCATTER_ENTRANCE_KEYFRAMES }),
+        showGrid && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunk3QFHVAZTjs.ChartGrid,
+          {
+            xScale: resolvedXScale,
+            yScale: resolvedYScale,
+            show: "both",
+            xTicks,
+            yTicks,
+            xTickValues,
+            yTickValues,
+            lineStyle: gridLineStyle,
+            strokeWidth: gridStrokeWidth
+          }
+        ),
+        shouldShowXAxis && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkE5GD3H7Ljs.ChartAxis,
+          {
+            scale: resolvedXScale,
+            orientation: "bottom",
+            y: innerRect.height,
+            ticks: xTicks,
+            tickValues: xTickValues,
+            tickFormat: xTickFormat,
+            label: xAxisLabel
+          }
+        ),
+        shouldShowYAxis && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          _chunkE5GD3H7Ljs.ChartAxis,
+          {
+            scale: resolvedYScale,
+            orientation: "left",
+            ticks: yTicks,
+            tickValues: yTickValues,
+            tickFormat: yTickFormat,
+            label: yAxisLabel
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _chunkAX5XRD2Qjs.ChartSeries, { data, type: "scatter", children: points.map((point, index) => {
+          const paletteIdx = index % palette.length;
+          const fill = gradient ? `url(#${gradientPrefix}-${paletteIdx})` : point.color;
+          const filterStyle = point.isHovered ? _tigercatcore.getScatterHoverShadow.call(void 0, point.color) : void 0;
+          const animDelay = animated && mounted ? `${index * 60}ms` : void 0;
+          const styleObj = {
+            ...filterStyle ? { filter: filterStyle } : {},
+            ...animDelay ? {
+              animation: `${_tigercatcore.SCATTER_ENTRANCE_CLASS} var(--tiger-motion-duration-slow,500ms) var(--tiger-motion-ease-spring,cubic-bezier(.34,1.56,.64,1)) ${animDelay} both`
+            } : {}
+          };
+          const sharedProps = {
+            fill,
+            opacity: point.opacity,
+            stroke: pointBorderColor,
+            strokeWidth: pointBorderWidth,
+            className: _tigercatcore.classNames.call(void 0, 
+              _tigercatcore.scatterPointTransitionClasses,
+              animDelay && _tigercatcore.SCATTER_ENTRANCE_CLASS,
+              interactive && "cursor-pointer"
+            ),
+            style: Object.keys(styleObj).length > 0 ? styleObj : void 0,
+            tabIndex: selectable ? 0 : void 0,
+            role: selectable ? "button" : "img",
+            "aria-label": _nullishCoalesce(point.datum.label, () => ( `Point ${index + 1}: (${point.datum.x}, ${point.datum.y})`)),
+            "data-point-index": index,
+            onMouseEnter: (e) => handleMouseEnter(index, e),
+            onMouseMove: handleMouseMove,
+            onMouseLeave: handleMouseLeave,
+            onClick: () => handleClick(index),
+            onKeyDown: (e) => handleKeyDown(e, index)
+          };
+          if (pointStyle === "circle") {
+            return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "circle",
+              {
+                cx: point.cx,
+                cy: point.cy,
+                r: point.r,
+                ...sharedProps
+              },
+              `point-${index}`
+            );
+          }
+          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "path",
+            {
+              d: _tigercatcore.getScatterPointPath.call(void 0, pointStyle, point.r),
+              transform: `translate(${point.cx},${point.cy})`,
+              ...sharedProps
+            },
+            `point-${index}`
+          );
+        }) })
+      ]
+    }
+  );
+  const tooltip = showTooltip && hoverable && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _chunkUVMQJOTXjs.ChartTooltip,
+    {
+      content: tooltipContent,
+      visible: resolvedHoveredIndex !== null && tooltipContent !== "",
+      x: tooltipPosition.x,
+      y: tooltipPosition.y
+    }
+  );
+  if (!showLegend) {
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "inline-block relative", children: [
+      chart,
+      tooltip
+    ] });
+  }
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: wrapperClasses, children: [
+    chart,
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      _chunkWV5XHYW6js.ChartLegend,
+      {
+        items: legendItems,
+        position: legendPosition,
+        markerSize: legendMarkerSize,
+        gap: legendGap,
+        interactive,
+        onItemClick: handleLegendClick,
+        onItemHover: handleLegendHover,
+        onItemLeave: handleLegendLeave
+      }
+    ),
+    tooltip
+  ] });
+};
+var ScatterChart_default = ScatterChart;
+
+
+
+
+exports.ScatterChart = ScatterChart; exports.ScatterChart_default = ScatterChart_default;

package/dist/chunk-WG3YS2QV.js

@@ -0,0 +1,329 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkP36GX65Njs = require('./chunk-P36GX65N.js');
+
+// src/components/List.tsx
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var spinnerSvg = _tigercatcore.getSpinnerSVG.call(void 0, "spinner");
+var LoadingSpinner = () => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  "svg",
+  {
+    className: _tigercatcore.getLoadingOverlaySpinnerClasses.call(void 0, ),
+    xmlns: "http://www.w3.org/2000/svg",
+    fill: "none",
+    viewBox: spinnerSvg.viewBox,
+    children: spinnerSvg.elements.map((el, index) => {
+      if (el.type === "circle") return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "circle", { ...el.attrs }, index);
+      if (el.type === "path") return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "path", { ...el.attrs }, index);
+      return null;
+    })
+  }
+);
+var List = ({
+  dataSource = [],
+  size = "md",
+  bordered = "divided",
+  loading = false,
+  emptyText = "No data",
+  split = true,
+  itemLayout = "horizontal",
+  header,
+  footer,
+  pagination = false,
+  grid,
+  virtual = false,
+  virtualHeight = 400,
+  virtualItemHeight = 40,
+  virtualOverscan = 5,
+  rowKey = "key",
+  hoverable = false,
+  renderItem,
+  onItemClick,
+  onPageChange,
+  className,
+  draggable: isDraggable = false,
+  onReorder,
+  ...divProps
+}) => {
+  const [currentPage, setCurrentPage] = _react.useState.call(void 0, 
+    pagination && typeof pagination === "object" ? pagination.current || 1 : 1
+  );
+  const dragIndexRef = _react2.default.useRef(null);
+  const [currentPageSize, setCurrentPageSize] = _react.useState.call(void 0, 
+    pagination && typeof pagination === "object" ? pagination.pageSize || 10 : 10
+  );
+  const paginatedData = _react.useMemo.call(void 0, () => {
+    if (pagination === false) {
+      return dataSource;
+    }
+    return _tigercatcore.paginateData.call(void 0, dataSource, currentPage, currentPageSize);
+  }, [dataSource, currentPage, currentPageSize, pagination]);
+  const paginationInfo = _react.useMemo.call(void 0, () => {
+    if (pagination === false) {
+      return null;
+    }
+    const total = dataSource.length;
+    return _tigercatcore.calculatePagination.call(void 0, total, currentPage, currentPageSize);
+  }, [dataSource.length, currentPage, currentPageSize, pagination]);
+  const listClasses = _react.useMemo.call(void 0, () => {
+    return _tigercatcore.classNames.call(void 0, _tigercatcore.getListClasses.call(void 0, bordered), _tigercatcore.listSizeClasses[size], className);
+  }, [bordered, size, className]);
+  const gridClasses = _react.useMemo.call(void 0, () => {
+    if (!grid) return "";
+    return _tigercatcore.classNames.call(void 0, 
+      _tigercatcore.listGridContainerClasses,
+      _tigercatcore.getGridColumnClasses.call(void 0, grid.column, grid.xs, grid.sm, grid.md, grid.lg, grid.xl, grid.xxl)
+    );
+  }, [grid]);
+  const handlePageChange = (page) => {
+    setCurrentPage(page);
+    _optionalChain([onPageChange, 'optionalCall', _ => _({ current: page, pageSize: currentPageSize })]);
+  };
+  const handlePageSizeChange = (pageSize) => {
+    setCurrentPageSize(pageSize);
+    setCurrentPage(1);
+    _optionalChain([onPageChange, 'optionalCall', _2 => _2({ current: 1, pageSize })]);
+  };
+  const handleItemClick = (item, index) => {
+    _optionalChain([onItemClick, 'optionalCall', _3 => _3(item, index)]);
+  };
+  const getItemKey = (item, index) => {
+    if (typeof rowKey === "function") {
+      return rowKey(item, index);
+    }
+    return item[rowKey] || index;
+  };
+  const renderListHeader = () => {
+    if (!header) return null;
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.getListHeaderFooterClasses.call(void 0, size, false), children: header });
+  };
+  const renderListFooter = () => {
+    if (!footer) return null;
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.getListHeaderFooterClasses.call(void 0, size, true), children: footer });
+  };
+  const renderDefaultListItem = (item, _index) => {
+    const itemContent = [];
+    const metaContent = [];
+    if (item.avatar) {
+      metaContent.push(
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listItemAvatarClasses, children: typeof item.avatar === "string" ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "img",
+          {
+            src: item.avatar,
+            alt: item.title || "Avatar",
+            className: "w-10 h-10 rounded-full object-cover"
+          }
+        ) : item.avatar }, "avatar")
+      );
+    }
+    const contentChildren = [];
+    if (item.title) {
+      contentChildren.push(
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listItemTitleClasses, children: item.title }, "title")
+      );
+    }
+    if (item.description) {
+      contentChildren.push(
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listItemDescriptionClasses, children: item.description }, "description")
+      );
+    }
+    if (contentChildren.length > 0) {
+      metaContent.push(
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listItemContentClasses, children: contentChildren }, "content")
+      );
+    }
+    if (metaContent.length > 0) {
+      itemContent.push(
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listItemMetaClasses, children: metaContent }, "meta")
+      );
+    }
+    if (item.extra) {
+      itemContent.push(
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listItemExtraClasses, children: item.extra }, "extra")
+      );
+    }
+    return itemContent;
+  };
+  const renderListItem = (item, index) => {
+    const key = getItemKey(item, index);
+    const itemClasses = _tigercatcore.getListItemClasses.call(void 0, 
+      size,
+      itemLayout,
+      split && bordered === "divided" && !grid,
+      hoverable
+    );
+    const clickable = typeof onItemClick === "function";
+    const handleClick = clickable ? () => handleItemClick(item, index) : void 0;
+    const handleKeyDown = clickable ? (e) => {
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        handleItemClick(item, index);
+      }
+    } : void 0;
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "div",
+      {
+        className: _tigercatcore.classNames.call(void 0, 
+          itemClasses,
+          clickable && "cursor-pointer",
+          isDraggable && "cursor-grab"
+        ),
+        role: "listitem",
+        tabIndex: clickable ? 0 : void 0,
+        onClick: handleClick,
+        onKeyDown: handleKeyDown,
+        draggable: isDraggable || void 0,
+        onDragStart: isDraggable ? () => {
+          dragIndexRef.current = index;
+        } : void 0,
+        onDragOver: isDraggable ? (e) => e.preventDefault() : void 0,
+        onDrop: isDraggable ? () => {
+          const from = dragIndexRef.current;
+          if (from === null || from === index) {
+            dragIndexRef.current = null;
+            return;
+          }
+          dragIndexRef.current = null;
+          const items = [...dataSource];
+          const [moved] = items.splice(from, 1);
+          items.splice(index, 0, moved);
+          _optionalChain([onReorder, 'optionalCall', _4 => _4(items, from, index)]);
+        } : void 0,
+        onDragEnd: isDraggable ? () => {
+          dragIndexRef.current = null;
+        } : void 0,
+        children: renderItem ? renderItem(item, index) : renderDefaultListItem(item, index)
+      },
+      key
+    );
+  };
+  const renderListItems = () => {
+    if (loading) {
+      return null;
+    }
+    if (paginatedData.length === 0) {
+      return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listEmptyStateClasses, role: "status", "aria-live": "polite", children: emptyText });
+    }
+    const items = paginatedData.map((item, index) => renderListItem(item, index));
+    if (grid) {
+      const gutter = grid.gutter;
+      return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        "div",
+        {
+          className: gridClasses,
+          style: gutter ? { gap: `${gutter}px` } : void 0,
+          children: items
+        }
+      );
+    }
+    if (virtual) {
+      return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+        _chunkP36GX65Njs.VirtualList,
+        {
+          itemCount: paginatedData.length,
+          itemHeight: virtualItemHeight,
+          height: virtualHeight,
+          overscan: virtualOverscan,
+          renderItem: ({ index }) => renderListItem(paginatedData[index], index)
+        }
+      );
+    }
+    return items;
+  };
+  const renderPagination = () => {
+    if (pagination === false || !paginationInfo) {
+      return null;
+    }
+    const { totalPages, startIndex, endIndex, hasNext, hasPrev } = paginationInfo;
+    const total = dataSource.length;
+    const paginationConfig = pagination;
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.getSimplePaginationContainerClasses.call(void 0, ), children: [
+      paginationConfig.showTotal !== false && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.getSimplePaginationTotalClasses.call(void 0, ), children: paginationConfig.totalText ? paginationConfig.totalText(total, [startIndex, endIndex]) : `Showing ${startIndex} to ${endIndex} of ${total} items` }),
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.getSimplePaginationControlsClasses.call(void 0, ), children: [
+        paginationConfig.showSizeChanger !== false && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "select",
+          {
+            className: _tigercatcore.getSimplePaginationSelectClasses.call(void 0, ),
+            value: currentPageSize,
+            onChange: (e) => handlePageSizeChange(Number(e.target.value)),
+            children: (paginationConfig.pageSizeOptions || [10, 20, 50, 100]).map((size2) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "option", { value: size2, children: [
+              size2,
+              " / page"
+            ] }, size2))
+          }
+        ),
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.getSimplePaginationButtonsWrapperClasses.call(void 0, ), children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "button",
+            {
+              className: _tigercatcore.getSimplePaginationButtonClasses.call(void 0, !hasPrev),
+              disabled: !hasPrev,
+              onClick: () => handlePageChange(currentPage - 1),
+              children: "Previous"
+            }
+          ),
+          /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: _tigercatcore.getSimplePaginationPageIndicatorClasses.call(void 0, ), children: [
+            "Page ",
+            currentPage,
+            " of ",
+            totalPages
+          ] }),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "button",
+            {
+              className: _tigercatcore.getSimplePaginationButtonClasses.call(void 0, !hasNext),
+              disabled: !hasNext,
+              onClick: () => handlePageChange(currentPage + 1),
+              children: "Next"
+            }
+          )
+        ] })
+      ] })
+    ] });
+  };
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: _tigercatcore.listWrapperClasses, children: [
+    /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { className: "relative", children: [
+      /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "div", { ...divProps, className: listClasses, role: "list", "aria-busy": loading || void 0, children: [
+        renderListHeader(),
+        renderListItems(),
+        renderListFooter()
+      ] }),
+      loading && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.listLoadingOverlayClasses, role: "status", "aria-live": "polite", children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, LoadingSpinner, {}) })
+    ] }),
+    renderPagination()
+  ] });
+};
+
+
+
+exports.List = List;