@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-QMK4OFC5.js

@@ -0,0 +1,235 @@
+"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 _chunkUKLVOR4Ejs = require('./chunk-UKLVOR4E.js');
+
+// src/components/Gantt.tsx
+var _react = require('react');
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+function Gantt({
+  data,
+  width = 760,
+  height = 360,
+  padding = 24,
+  scale = "week",
+  rowHeight = 40,
+  barHeight = 18,
+  taskLabelWidth = 140,
+  timelineHeight = 36,
+  minDate,
+  maxDate,
+  minBarWidth = 6,
+  showToday = false,
+  showProgress = true,
+  showDependencies = true,
+  hoverable = false,
+  selectable = false,
+  selectedId,
+  activeOpacity = 1,
+  inactiveOpacity = 0.35,
+  dateFormatter,
+  colors,
+  title,
+  desc,
+  ariaLabel = "Gantt chart",
+  className,
+  onTaskClick,
+  onTaskHover,
+  onSelectedIdChange
+}) {
+  const [innerSelectedId, setInnerSelectedId] = _react.useState.call(void 0, null);
+  const [hoveredId, setHoveredId] = _react.useState.call(void 0, null);
+  const resolvedSelectedId = selectedId === void 0 ? innerSelectedId : selectedId;
+  const innerRect = _react.useMemo.call(void 0, 
+    () => _tigercatcore.getChartInnerRect.call(void 0, width, height, padding),
+    [height, padding, width]
+  );
+  const layout = _react.useMemo.call(void 0, 
+    () => _tigercatcore.computeGanttLayout.call(void 0, data, {
+      width: innerRect.width,
+      rowHeight,
+      barHeight,
+      taskLabelWidth,
+      timelineHeight,
+      minDate,
+      maxDate,
+      minBarWidth,
+      scale,
+      colors,
+      today: showToday ? /* @__PURE__ */ new Date() : void 0,
+      dateFormatter
+    }),
+    [
+      barHeight,
+      colors,
+      data,
+      dateFormatter,
+      innerRect.width,
+      maxDate,
+      minBarWidth,
+      minDate,
+      rowHeight,
+      scale,
+      showToday,
+      taskLabelWidth,
+      timelineHeight
+    ]
+  );
+  const activeId = _nullishCoalesce(resolvedSelectedId, () => ( hoveredId));
+  const selectTask = (task) => {
+    if (selectable && !task.task.disabled) {
+      const nextId = resolvedSelectedId === task.id ? null : task.id;
+      if (selectedId === void 0) setInnerSelectedId(nextId);
+      _optionalChain([onSelectedIdChange, 'optionalCall', _ => _(nextId)]);
+    }
+    _optionalChain([onTaskClick, 'optionalCall', _2 => _2(task.task)]);
+  };
+  const setHoveredTask = (task) => {
+    if (!hoverable) return;
+    setHoveredId(_nullishCoalesce(_optionalChain([task, 'optionalAccess', _3 => _3.id]), () => ( null)));
+    _optionalChain([onTaskHover, 'optionalCall', _4 => _4(_nullishCoalesce(_optionalChain([task, 'optionalAccess', _5 => _5.task]), () => ( null)))]);
+  };
+  const getTaskOpacity = (task) => {
+    if (activeId === null) return activeOpacity;
+    return activeId === task.id ? activeOpacity : inactiveOpacity;
+  };
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    _chunkUKLVOR4Ejs.ChartCanvas,
+    {
+      width,
+      height,
+      padding,
+      title,
+      desc,
+      className: _tigercatcore.classNames.call(void 0, className),
+      role: "img",
+      "aria-label": ariaLabel,
+      children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { "data-series-type": "gantt", children: [
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { "data-gantt-axis": "true", children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "line",
+            {
+              x1: taskLabelWidth,
+              x2: layout.width,
+              y1: timelineHeight - 1,
+              y2: timelineHeight - 1,
+              stroke: "var(--tiger-border,#d1d5db)"
+            }
+          ),
+          layout.ticks.map((tick) => /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+              "line",
+              {
+                x1: tick.x,
+                x2: tick.x,
+                y1: 0,
+                y2: layout.height,
+                stroke: "var(--tiger-border,#e5e7eb)"
+              }
+            ),
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { x: tick.x + 4, y: 16, className: _tigercatcore.ganttAxisTextClasses, children: tick.label })
+          ] }, `${tick.label}-${tick.x}`))
+        ] }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "g", { "data-gantt-rows": "true", children: layout.tasks.map((task) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "rect",
+          {
+            x: 0,
+            y: timelineHeight + task.index * rowHeight,
+            width: layout.width,
+            height: rowHeight,
+            className: task.index % 2 === 0 ? _tigercatcore.ganttRowClasses : void 0,
+            opacity: task.index % 2 === 0 ? 0.75 : 0
+          },
+          `row-${task.id}`
+        )) }),
+        showToday && layout.todayX !== null ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "line",
+          {
+            x1: layout.todayX,
+            x2: layout.todayX,
+            y1: 0,
+            y2: layout.height,
+            className: _tigercatcore.ganttTodayLineClasses,
+            "data-gantt-today": "true"
+          }
+        ) : null,
+        showDependencies ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "g", { "data-gantt-dependencies": "true", children: layout.dependencies.map((dependency) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "path",
+          {
+            d: dependency.path,
+            className: _tigercatcore.ganttDependencyClasses
+          },
+          `${dependency.sourceId}-${dependency.targetId}`
+        )) }) : null,
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "g", { "data-gantt-tasks": "true", children: layout.tasks.map((task) => {
+          const selected = resolvedSelectedId === task.id;
+          const interactive = (hoverable || selectable) && !task.task.disabled;
+          return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "g", { opacity: getTaskOpacity(task), children: [
+            /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "text", { x: 0, y: task.y + task.height / 2 + 4, className: _tigercatcore.ganttLabelClasses, children: task.task.label }),
+            /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+              "g",
+              {
+                className: _tigercatcore.getGanttTaskClasses.call(void 0, interactive, selected),
+                role: interactive ? "button" : "group",
+                tabIndex: interactive ? 0 : void 0,
+                "aria-label": _tigercatcore.getGanttTaskAriaLabel.call(void 0, task.task),
+                onMouseEnter: () => setHoveredTask(task),
+                onMouseLeave: () => setHoveredTask(null),
+                onClick: () => selectTask(task),
+                onKeyDown: (event) => {
+                  if (event.key === "Enter" || event.key === " ") {
+                    event.preventDefault();
+                    selectTask(task);
+                  }
+                },
+                children: [
+                  /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "rect",
+                    {
+                      x: task.x,
+                      y: task.y,
+                      width: task.width,
+                      height: task.height,
+                      rx: 4,
+                      fill: task.color,
+                      stroke: selected ? "var(--tiger-text,#111827)" : void 0,
+                      strokeWidth: selected ? 2 : void 0
+                    }
+                  ),
+                  showProgress && task.progressWidth > 0 ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                    "rect",
+                    {
+                      x: task.x,
+                      y: task.y,
+                      width: task.progressWidth,
+                      height: task.height,
+                      rx: 4,
+                      className: _tigercatcore.ganttProgressClasses
+                    }
+                  ) : null
+                ]
+              }
+            )
+          ] }, task.id);
+        }) })
+      ] })
+    }
+  );
+}
+Gantt.displayName = "Gantt";
+
+
+
+exports.Gantt = Gantt;

package/dist/{chunk-QLHFXYWA.mjs → chunk-QOEE2PW5.mjs}

@@ -1,8 +1,35 @@
-import React, { forwardRef, useState, useRef, useMemo, useCallback, useImperativeHandle, useEffect } from 'react';
-import { classNames, getCarouselContainerClasses, carouselTrackFadeClasses, carouselTrackScrollClasses, getScrollTransform, getCarouselDotsClasses, clampSlideIndex, getNextSlideIndex, getPrevSlideIndex, isPrevDisabled, isNextDisabled, getCarouselDotClasses, carouselSlideBaseClasses, getCarouselArrowClasses, carouselPrevArrowPath, carouselNextArrowPath } from '@expcat/tigercat-core';
-import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-
 // src/components/Carousel.tsx
+import React, {
+  useState,
+  useCallback,
+  useEffect,
+  useRef,
+  useMemo,
+  useImperativeHandle,
+  forwardRef
+} from "react";
+import {
+  classNames,
+  getCarouselContainerClasses,
+  carouselTrackScrollClasses,
+  carouselTrackFadeClasses,
+  carouselSlideBaseClasses,
+  getCarouselDotsClasses,
+  getCarouselDotClasses,
+  getCarouselArrowClasses,
+  getNextSlideIndex,
+  getPrevSlideIndex,
+  isNextDisabled,
+  isPrevDisabled,
+  clampSlideIndex,
+  getScrollTransform,
+  getCarouselTouchPoint,
+  resolveCarouselSwipeDirection,
+  createCarouselAutoplayController,
+  carouselPrevArrowPath,
+  carouselNextArrowPath
+} from "@expcat/tigercat-core";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 var Carousel = forwardRef(
   ({
     autoplay = false,
@@ -24,6 +51,9 @@ var Carousel = forwardRef(
   }, ref) => {
     const [currentIndex, setCurrentIndex] = useState(initialSlide);
     const [isPaused, setIsPaused] = useState(false);
+    const containerRef = useRef(null);
+    const touchStartRef = useRef(null);
+    const touchCurrentRef = useRef(null);
     const onChangeRef = useRef(onChange);
     const onBeforeChangeRef = useRef(onBeforeChange);
     onChangeRef.current = onChange;
@@ -34,6 +64,17 @@ var Carousel = forwardRef(
       return React.Children.toArray(children).filter((child) => React.isValidElement(child));
     }, [children]);
     const slideCount = slides.length;
+    const navigateByDirection = useCallback(
+      (direction) => {
+        const current = currentIndexRef.current;
+        const targetIndex = direction === "next" ? getNextSlideIndex(current, slideCount, infinite) : getPrevSlideIndex(current, slideCount, infinite);
+        if (targetIndex === current) return;
+        onBeforeChangeRef.current?.(current, targetIndex);
+        setCurrentIndex(targetIndex);
+        onChangeRef.current?.(targetIndex, current);
+      },
+      [slideCount, infinite]
+    );
     const containerClasses = useMemo(
       () => classNames(getCarouselContainerClasses(className)),
       [className]
@@ -100,17 +141,65 @@ var Carousel = forwardRef(
     );
     useEffect(() => {
       if (!autoplay || isPaused) return;
-      const timer = setInterval(() => {
-        const curr = currentIndexRef.current;
-        const nextIdx = getNextSlideIndex(curr, slideCount, infinite);
-        if (nextIdx !== curr) {
-          onBeforeChangeRef.current?.(curr, nextIdx);
-          setCurrentIndex(nextIdx);
-          onChangeRef.current?.(nextIdx, curr);
+      const controller = createCarouselAutoplayController({
+        interval: autoplaySpeed,
+        onAdvance: () => {
+          const curr = currentIndexRef.current;
+          const nextIdx = getNextSlideIndex(curr, slideCount, infinite);
+          if (nextIdx !== curr) {
+            onBeforeChangeRef.current?.(curr, nextIdx);
+            setCurrentIndex(nextIdx);
+            onChangeRef.current?.(nextIdx, curr);
+          }
         }
-      }, autoplaySpeed);
-      return () => clearInterval(timer);
+      });
+      controller.start();
+      return () => controller.stop();
     }, [autoplay, autoplaySpeed, isPaused, slideCount, infinite]);
+    useEffect(() => {
+      const container = containerRef.current;
+      if (!container || slideCount <= 1) return;
+      const resetTouchGesture = () => {
+        touchStartRef.current = null;
+        touchCurrentRef.current = null;
+      };
+      const handleTouchStart = (event) => {
+        const point = getCarouselTouchPoint(event.touches);
+        touchStartRef.current = point;
+        touchCurrentRef.current = point;
+      };
+      const handleTouchMove = (event) => {
+        if (!touchStartRef.current) return;
+        const point = getCarouselTouchPoint(event.touches);
+        if (point) {
+          touchCurrentRef.current = point;
+        }
+      };
+      const handleTouchEnd = (event) => {
+        const direction = resolveCarouselSwipeDirection(
+          touchStartRef.current,
+          getCarouselTouchPoint(event.changedTouches) ?? touchCurrentRef.current
+        );
+        resetTouchGesture();
+        if (direction) {
+          navigateByDirection(direction);
+        }
+      };
+      const handleTouchCancel = () => {
+        resetTouchGesture();
+      };
+      container.addEventListener("touchstart", handleTouchStart, { passive: true });
+      container.addEventListener("touchmove", handleTouchMove, { passive: true });
+      container.addEventListener("touchend", handleTouchEnd, { passive: true });
+      container.addEventListener("touchcancel", handleTouchCancel, { passive: true });
+      return () => {
+        resetTouchGesture();
+        container.removeEventListener("touchstart", handleTouchStart);
+        container.removeEventListener("touchmove", handleTouchMove);
+        container.removeEventListener("touchend", handleTouchEnd);
+        container.removeEventListener("touchcancel", handleTouchCancel);
+      };
+    }, [navigateByDirection, slideCount]);
     const handleMouseEnter = useCallback(() => {
       if (pauseOnHover && autoplay) {
         setIsPaused(true);
@@ -206,6 +295,7 @@ var Carousel = forwardRef(
     return /* @__PURE__ */ jsxs(
       "div",
       {
+        ref: containerRef,
         className: containerClasses,
         style,
         role: "region",
@@ -226,4 +316,6 @@ var Carousel = forwardRef(
 );
 Carousel.displayName = "Carousel";
 
-export { Carousel };
+export {
+  Carousel
+};

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

@@ -0,0 +1,52 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+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,
+  order,
+  flex,
+  children,
+  className,
+  style,
+  ...divProps
+}) => {
+  const { gutter } = _react.useContext.call(void 0, _chunkVE3SYUMHjs.RowContext);
+  const isFlexSpanMode = flex !== void 0 && span === 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.call(void 0, 
+    () => ({
+      ..._tigercatcore.getColMergedStyleVars.call(void 0, isFlexSpanMode ? void 0 : span, offset, order, flex),
+      ...style
+    }),
+    [isFlexSpanMode, span, offset, order, flex, style]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: colClasses, style: mergedStyle, ...divProps, children });
+};
+
+
+
+exports.Col = Col;