@expcat/tigercat-react 1.0.7 → 1.2.0

package/dist/chunk-XFPJYKBQ.js

@@ -0,0 +1,98 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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; }// src/components/FloatButton.tsx
+var _react = require('react');
+var _reactdom = require('react-dom'); var _reactdom2 = _interopRequireDefault(_reactdom);
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var FloatButton = ({
+  shape = "circle",
+  size = "md",
+  type = "primary",
+  tooltip,
+  disabled = false,
+  ariaLabel,
+  className,
+  children,
+  onClick,
+  ...props
+}) => {
+  const classes = _react.useMemo.call(void 0, 
+    () => _tigercatcore.classNames.call(void 0, 
+      _tigercatcore.floatButtonBaseClasses,
+      _tigercatcore.floatButtonShapeClasses[shape],
+      _tigercatcore.floatButtonSizeClasses[size],
+      _tigercatcore.floatButtonTypeClasses[type],
+      disabled && _tigercatcore.floatButtonDisabledClasses,
+      className
+    ),
+    [shape, size, type, disabled, className]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+    "button",
+    {
+      className: classes,
+      type: "button",
+      disabled,
+      "aria-label": _nullishCoalesce(ariaLabel, () => ( tooltip)),
+      title: tooltip,
+      onClick: disabled ? void 0 : onClick,
+      ...props,
+      children
+    }
+  );
+};
+var FloatButtonGroup = ({
+  shape: _shape = "circle",
+  trigger = "click",
+  open: controlledOpen,
+  triggerNode,
+  children,
+  className,
+  onOpenChange,
+  ...props
+}) => {
+  const [internalOpen, setInternalOpen] = _react.useState.call(void 0, false);
+  const isOpen = _nullishCoalesce(controlledOpen, () => ( internalOpen));
+  const toggle = _react.useCallback.call(void 0, () => {
+    const next = !isOpen;
+    setInternalOpen(next);
+    _optionalChain([onOpenChange, 'optionalCall', _ => _(next)]);
+  }, [isOpen, onOpenChange]);
+  const handleMouseEnter = _react.useCallback.call(void 0, () => {
+    setInternalOpen(true);
+    _optionalChain([onOpenChange, 'optionalCall', _2 => _2(true)]);
+  }, [onOpenChange]);
+  const handleMouseLeave = _react.useCallback.call(void 0, () => {
+    setInternalOpen(false);
+    _optionalChain([onOpenChange, 'optionalCall', _3 => _3(false)]);
+  }, [onOpenChange]);
+  const groupClasses = _react.useMemo.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.floatButtonGroupClasses, className), [className]);
+  if (!_tigercatcore.isBrowser.call(void 0, )) return null;
+  const content = /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "div",
+    {
+      className: groupClasses,
+      onMouseEnter: trigger === "hover" ? handleMouseEnter : void 0,
+      onMouseLeave: trigger === "hover" ? handleMouseLeave : void 0,
+      ...props,
+      children: [
+        triggerNode && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { onClick: trigger === "click" ? toggle : void 0, children: triggerNode }),
+        isOpen && children
+      ]
+    }
+  );
+  return _reactdom2.default.createPortal(content, document.body);
+};
+
+
+
+
+exports.FloatButton = FloatButton; exports.FloatButtonGroup = FloatButtonGroup;

package/dist/chunk-XHT2VIDR.js

@@ -0,0 +1,429 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _chunkTDODFBBOjs = require('./chunk-TDODFBBO.js');
+
+// src/components/TaskBoard.tsx
+var _react = require('react'); var _react2 = _interopRequireDefault(_react);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var _jsxruntime = require('react/jsx-runtime');
+var CardItem = _react2.default.memo(
+  ({ card, column, isDragging, isKbGrabbed, draggable, dragHintText, renderCard, dragCtrl }) => {
+    const cardClasses = _tigercatcore.classNames.call(void 0, 
+      _tigercatcore.taskBoardCardClasses,
+      isDragging && _tigercatcore.taskBoardCardDraggingClasses,
+      isKbGrabbed && "ring-2 ring-[var(--tiger-primary,#2563eb)]"
+    );
+    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+      "div",
+      {
+        className: cardClasses,
+        draggable,
+        tabIndex: 0,
+        role: "listitem",
+        "aria-roledescription": dragHintText,
+        "aria-grabbed": isKbGrabbed ? "true" : void 0,
+        "data-tiger-taskboard-card": "",
+        "data-tiger-taskboard-card-id": String(card.id),
+        onDragStart: (e) => {
+          if (e.dataTransfer) dragCtrl.cardDragStart(e.dataTransfer, card, column);
+        },
+        onDragEnd: () => dragCtrl.dragEnd(),
+        onTouchStart: (e) => dragCtrl.cardTouchStart(e.nativeEvent, e.currentTarget, card, column),
+        onTouchMove: (e) => dragCtrl.cardTouchMove(e.nativeEvent),
+        onTouchEnd: () => dragCtrl.cardTouchEnd(),
+        onKeyDown: (e) => {
+          if (dragCtrl.cardKeyDown(e.key, card, column)) e.preventDefault();
+        },
+        children: renderCard ? renderCard(card, column.id) : /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "font-medium text-sm text-[var(--tiger-text,#1f2937)]", children: card.title }),
+          card.description && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: "mt-1 text-xs text-[var(--tiger-text-muted,#6b7280)] line-clamp-2", children: card.description })
+        ] })
+      }
+    );
+  },
+  (prev, next) => prev.card.id === next.card.id && prev.isDragging === next.isDragging && prev.isKbGrabbed === next.isKbGrabbed && prev.draggable === next.draggable && prev.card === next.card
+);
+CardItem.displayName = "TaskBoardCardItem";
+var ColumnItem = _react2.default.memo(
+  ({
+    column,
+    colIndex,
+    isDropTarget,
+    isColDragging,
+    dropIdx,
+    draggable,
+    columnDraggable,
+    labels,
+    renderCardProp,
+    renderColumnHeader,
+    renderColumnFooter,
+    renderEmptyColumn,
+    onCardAdd,
+    dragType,
+    dragCtrl,
+    dragStateId,
+    kbDragStateId,
+    showCardCount,
+    allowAddCard
+  }) => {
+    const wipOver = _tigercatcore.isWipExceeded.call(void 0, column);
+    const cardCount = showCardCount ? _tigercatcore.getColumnCardCount.call(void 0, column) : null;
+    const colClasses = _tigercatcore.classNames.call(void 0, 
+      _tigercatcore.taskBoardColumnClasses,
+      isDropTarget && _tigercatcore.taskBoardColumnDropTargetClasses,
+      isColDragging && _tigercatcore.taskBoardColumnDraggingClasses
+    );
+    let cardsContent;
+    if (column.cards.length > 0) {
+      const nodes = [];
+      column.cards.forEach((card, i) => {
+        if (isDropTarget && dropIdx === i) {
+          nodes.push(/* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.taskBoardDropIndicatorClasses }, `drop-${i}`));
+        }
+        const isDragging = dragStateId === card.id;
+        const isKbGrabbed = kbDragStateId === card.id;
+        nodes.push(
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            CardItem,
+            {
+              card,
+              column,
+              isDragging,
+              isKbGrabbed,
+              draggable,
+              dragHintText: labels.dragHintText,
+              renderCard: renderCardProp,
+              dragCtrl
+            },
+            String(card.id)
+          )
+        );
+      });
+      if (isDropTarget && dropIdx >= column.cards.length) {
+        nodes.push(/* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.taskBoardDropIndicatorClasses }, "drop-end"));
+      }
+      cardsContent = nodes;
+    } else {
+      cardsContent = isDropTarget ? /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.taskBoardDropIndicatorClasses }, "drop-empty") : renderEmptyColumn ? renderEmptyColumn(column) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "div", { className: _tigercatcore.taskBoardEmptyClasses, children: _tigercatcore.resolveLocaleText.call(void 0, labels.emptyColumnText) });
+    }
+    const wipTitle = column.wipLimit != null ? _tigercatcore.resolveLocaleText.call(void 0, labels.wipLimitText.replace("{limit}", String(column.wipLimit))) : void 0;
+    return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+      "div",
+      {
+        className: colClasses,
+        "data-tiger-taskboard-column": "",
+        "data-tiger-taskboard-column-id": String(column.id),
+        onDragOver: dragType === "column" ? (e) => {
+          e.preventDefault();
+          dragCtrl.columnDragOver();
+        } : void 0,
+        onDrop: dragType === "column" ? (e) => {
+          e.preventDefault();
+          if (e.dataTransfer) dragCtrl.columnDrop(e.dataTransfer, e.clientX);
+        } : void 0,
+        children: [
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "div",
+            {
+              className: _tigercatcore.taskBoardColumnHeaderClasses,
+              draggable: columnDraggable,
+              onDragStart: (e) => {
+                if (e.dataTransfer) dragCtrl.columnDragStart(e.dataTransfer, column, colIndex);
+              },
+              onDragEnd: () => dragCtrl.dragEnd(),
+              onTouchStart: (e) => dragCtrl.columnTouchStart(
+                e.nativeEvent,
+                e.currentTarget,
+                column,
+                colIndex
+              ),
+              onTouchMove: (e) => dragCtrl.columnTouchMove(e.nativeEvent),
+              onTouchEnd: () => dragCtrl.columnTouchEnd(),
+              style: columnDraggable ? { cursor: "grab" } : void 0,
+              children: renderColumnHeader ? renderColumnHeader(column) : /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
+                /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: wipOver ? _tigercatcore.taskBoardWipExceededClasses : void 0, children: [
+                  column.title,
+                  showCardCount && cardCount ? null : column.wipLimit != null ? /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, "span", { className: "ml-2 text-xs font-normal opacity-70", title: wipTitle, children: [
+                    "(",
+                    column.cards.length,
+                    "/",
+                    column.wipLimit,
+                    ")"
+                  ] }) : /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "ml-2 text-xs font-normal opacity-50", children: column.cards.length })
+                ] }),
+                showCardCount && cardCount && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+                  "span",
+                  {
+                    className: _tigercatcore.classNames.call(void 0, 
+                      _tigercatcore.kanbanCardCountClasses,
+                      wipOver && _tigercatcore.taskBoardWipExceededClasses
+                    ),
+                    children: cardCount.limit ? `${cardCount.count}/${cardCount.limit}` : `${cardCount.count}`
+                  }
+                ),
+                column.description && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { className: "text-xs font-normal text-[var(--tiger-text-muted,#6b7280)] truncate max-w-[120px]", children: column.description })
+              ] })
+            }
+          ),
+          /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            "div",
+            {
+              className: _tigercatcore.taskBoardColumnBodyClasses,
+              role: "list",
+              "aria-label": column.title,
+              onDragOver: (e) => {
+                e.preventDefault();
+                dragCtrl.cardDragOver(e.clientY, e.currentTarget, column);
+              },
+              onDrop: (e) => {
+                e.preventDefault();
+                if (e.dataTransfer) dragCtrl.cardDrop(e.dataTransfer, column);
+              },
+              onDragLeave: (e) => dragCtrl.dragLeave(e.currentTarget, e.relatedTarget),
+              children: cardsContent
+            }
+          ),
+          renderColumnFooter ? renderColumnFooter(column) : onCardAdd || allowAddCard ? /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+            "div",
+            {
+              className: _tigercatcore.classNames.call(void 0, 
+                "border-t border-[var(--tiger-border,#e5e7eb)]",
+                _tigercatcore.taskBoardAddCardClasses
+              ),
+              role: "button",
+              tabIndex: 0,
+              onClick: () => _optionalChain([onCardAdd, 'optionalCall', _ => _(column.id)]),
+              onKeyDown: (e) => {
+                if (e.key === "Enter" || e.key === " ") {
+                  e.preventDefault();
+                  _optionalChain([onCardAdd, 'optionalCall', _2 => _2(column.id)]);
+                }
+              },
+              children: [
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: "+" }),
+                /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "span", { children: _tigercatcore.resolveLocaleText.call(void 0, labels.addCardText) })
+              ]
+            }
+          ) : null
+        ]
+      }
+    );
+  },
+  (prev, next) => prev.column === next.column && prev.colIndex === next.colIndex && prev.isDropTarget === next.isDropTarget && prev.isColDragging === next.isColDragging && prev.dropIdx === next.dropIdx && prev.draggable === next.draggable && prev.columnDraggable === next.columnDraggable && prev.dragType === next.dragType && prev.dragStateId === next.dragStateId && prev.kbDragStateId === next.kbDragStateId && prev.onCardAdd === next.onCardAdd && prev.showCardCount === next.showCardCount && prev.allowAddCard === next.allowAddCard
+);
+ColumnItem.displayName = "TaskBoardColumnItem";
+var TaskBoard = ({
+  columns: controlledColumns,
+  defaultColumns = [],
+  draggable = true,
+  columnDraggable = true,
+  enforceWipLimit = false,
+  beforeCardMove,
+  beforeColumnMove,
+  onCardMove,
+  onColumnMove,
+  onColumnsChange,
+  onCardAdd,
+  filterText = "",
+  hiddenColumns,
+  showCardCount = false,
+  allowAddCard = false,
+  allowAddColumn = false,
+  onColumnAdd,
+  renderCard: renderCardProp,
+  renderColumnHeader,
+  renderColumnFooter,
+  renderEmptyColumn,
+  locale,
+  className,
+  style,
+  ...rest
+}) => {
+  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 labels = _react.useMemo.call(void 0, () => _tigercatcore.getTaskBoardLabels.call(void 0, mergedLocale), [mergedLocale]);
+  const [innerColumns, setInnerColumns] = _react.useState.call(void 0, defaultColumns);
+  _react.useEffect.call(void 0, () => {
+    if (controlledColumns !== void 0) setInnerColumns(controlledColumns);
+  }, [controlledColumns]);
+  const currentColumns = _nullishCoalesce(controlledColumns, () => ( innerColumns));
+  const visibleColumns = _react.useMemo.call(void 0, () => {
+    if (!filterText && (!hiddenColumns || hiddenColumns.length === 0)) {
+      return currentColumns;
+    }
+    return _tigercatcore.filterColumns.call(void 0, currentColumns, filterText, hiddenColumns);
+  }, [currentColumns, filterText, hiddenColumns]);
+  const columnsRef = _react.useRef.call(void 0, currentColumns);
+  columnsRef.current = currentColumns;
+  const updateColumns = _react.useCallback.call(void 0, 
+    (next) => {
+      setInnerColumns(next);
+      _optionalChain([onColumnsChange, 'optionalCall', _3 => _3(next)]);
+    },
+    [onColumnsChange]
+  );
+  const [dragSnap, setDragSnap] = _react.useState.call(void 0, _tigercatcore.createDefaultDragSnapshot);
+  const boardRef = _react.useRef.call(void 0, null);
+  const beforeCardMoveRef = _react.useRef.call(void 0, beforeCardMove);
+  beforeCardMoveRef.current = beforeCardMove;
+  const beforeColumnMoveRef = _react.useRef.call(void 0, beforeColumnMove);
+  beforeColumnMoveRef.current = beforeColumnMove;
+  const onCardMoveRef = _react.useRef.call(void 0, onCardMove);
+  onCardMoveRef.current = onCardMove;
+  const onColumnMoveRef = _react.useRef.call(void 0, onColumnMove);
+  onColumnMoveRef.current = onColumnMove;
+  const enforceWipLimitRef = _react.useRef.call(void 0, enforceWipLimit);
+  enforceWipLimitRef.current = enforceWipLimit;
+  const applyCardMove = _react.useCallback.call(void 0, 
+    async (cardId, fromColumnId, toColumnId, toIdx) => {
+      const result = _tigercatcore.moveCard.call(void 0, columnsRef.current, cardId, fromColumnId, toColumnId, toIdx, {
+        enforceWipLimit: enforceWipLimitRef.current
+      });
+      if (!result) return;
+      if (beforeCardMoveRef.current) {
+        const ok = await beforeCardMoveRef.current(result.event);
+        if (!ok) return;
+      }
+      updateColumns(result.columns);
+      _optionalChain([onCardMoveRef, 'access', _4 => _4.current, 'optionalCall', _5 => _5(result.event)]);
+    },
+    [updateColumns]
+  );
+  const applyColumnMove = _react.useCallback.call(void 0, 
+    async (fromIdx, toIdx) => {
+      const cols = columnsRef.current;
+      const result = _tigercatcore.reorderColumns.call(void 0, cols, fromIdx, Math.min(toIdx, cols.length - 1));
+      if (!result) return;
+      if (beforeColumnMoveRef.current) {
+        const ok = await beforeColumnMoveRef.current(result.event);
+        if (!ok) return;
+      }
+      updateColumns(result.columns);
+      _optionalChain([onColumnMoveRef, 'access', _6 => _6.current, 'optionalCall', _7 => _7(result.event)]);
+    },
+    [updateColumns]
+  );
+  const dragCtrlRef = _react.useRef.call(void 0, null);
+  if (!dragCtrlRef.current) {
+    dragCtrlRef.current = _tigercatcore.createTaskBoardDragController.call(void 0, 
+      {
+        onStateChange: setDragSnap,
+        applyCardMove: (...args) => applyCardMoveRef.current(...args),
+        applyColumnMove: (...args) => applyColumnMoveRef.current(...args),
+        getBoardEl: () => boardRef.current,
+        getColumnCount: () => columnsRef.current.length
+      },
+      { draggable, columnDraggable }
+    );
+  }
+  const dragCtrl = dragCtrlRef.current;
+  const applyCardMoveRef = _react.useRef.call(void 0, applyCardMove);
+  applyCardMoveRef.current = applyCardMove;
+  const applyColumnMoveRef = _react.useRef.call(void 0, applyColumnMove);
+  applyColumnMoveRef.current = applyColumnMove;
+  _react.useEffect.call(void 0, () => {
+    dragCtrl.setOptions({ draggable, columnDraggable });
+  }, [draggable, columnDraggable, dragCtrl]);
+  _react.useEffect.call(void 0, () => {
+    dragCtrl.init();
+    return () => dragCtrl.dispose();
+  }, [dragCtrl]);
+  const wrapperClasses = _react.useMemo.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.taskBoardBaseClasses, className), [className]);
+  const dragType = _nullishCoalesce(_optionalChain([dragSnap, 'access', _8 => _8.drag, 'optionalAccess', _9 => _9.type]), () => ( null));
+  const dragStateId = _optionalChain([dragSnap, 'access', _10 => _10.drag, 'optionalAccess', _11 => _11.type]) === "card" ? dragSnap.drag.id : null;
+  const kbDragStateId = _nullishCoalesce(_optionalChain([dragSnap, 'access', _12 => _12.kbDrag, 'optionalAccess', _13 => _13.id]), () => ( null));
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    "div",
+    {
+      ref: boardRef,
+      className: wrapperClasses,
+      style,
+      role: "region",
+      "aria-label": _tigercatcore.resolveLocaleText.call(void 0, labels.boardAriaLabel),
+      "data-tiger-task-board": "",
+      ...rest,
+      children: [
+        visibleColumns.map((col, i) => {
+          const isDropTarget = _optionalChain([dragSnap, 'access', _14 => _14.drag, 'optionalAccess', _15 => _15.type]) === "card" && dragSnap.dropTargetColumnId === col.id;
+          const isColDragging = _optionalChain([dragSnap, 'access', _16 => _16.drag, 'optionalAccess', _17 => _17.type]) === "column" && dragSnap.drag.id === col.id;
+          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+            ColumnItem,
+            {
+              column: col,
+              colIndex: i,
+              isDropTarget,
+              isColDragging,
+              dropIdx: isDropTarget ? dragSnap.dropIndex : -1,
+              draggable,
+              columnDraggable,
+              labels,
+              renderCardProp,
+              renderColumnHeader,
+              renderColumnFooter,
+              renderEmptyColumn,
+              onCardAdd,
+              dragType,
+              dragCtrl,
+              dragStateId,
+              kbDragStateId,
+              showCardCount,
+              allowAddCard
+            },
+            String(col.id)
+          );
+        }),
+        allowAddColumn && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+          "div",
+          {
+            className: _tigercatcore.kanbanAddColumnClasses,
+            role: "button",
+            tabIndex: 0,
+            onClick: () => _optionalChain([onColumnAdd, 'optionalCall', _18 => _18()]),
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                _optionalChain([onColumnAdd, 'optionalCall', _19 => _19()]);
+              }
+            },
+            children: "+ Add column"
+          }
+        )
+      ]
+    }
+  );
+};
+var TaskBoard_default = TaskBoard;
+
+
+
+
+exports.TaskBoard = TaskBoard; exports.TaskBoard_default = TaskBoard_default;

package/dist/chunk-XJ7U2W7S.mjs

@@ -1,7 +1,9 @@
-import { getSpaceStyle, getSpaceClasses } from '@expcat/tigercat-core';
-import { jsx } from 'react/jsx-runtime';
-
 // src/components/Space.tsx
+import {
+  getSpaceClasses,
+  getSpaceStyle
+} from "@expcat/tigercat-core";
+import { jsx } from "react/jsx-runtime";
 var Space = ({
   direction = "horizontal",
   size = "md",
@@ -24,4 +26,6 @@ var Space = ({
   );
 };
 
-export { Space };
+export {
+  Space
+};

package/dist/chunk-XMTEMBQV.mjs

@@ -0,0 +1,139 @@
+// src/components/Affix.tsx
+import { useEffect, useRef, useState, useMemo, useCallback } from "react";
+import {
+  classNames,
+  calculateAffixState,
+  resolveAffixTarget,
+  createAffixObserver
+} from "@expcat/tigercat-core";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Affix = ({
+  offsetTop = 0,
+  offsetBottom,
+  target,
+  zIndex = 10,
+  className,
+  style,
+  children,
+  onChange,
+  ...props
+}) => {
+  const wrapperRef = useRef(null);
+  const sentinelRef = useRef(null);
+  const originalRectRef = useRef(null);
+  const [state, setState] = useState({ affixed: false, style: {} });
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const recalcStyle = useCallback(
+    (affixed) => {
+      const el = wrapperRef.current;
+      if (!el) return;
+      if (!stateRef.current.affixed) {
+        const rect = el.getBoundingClientRect();
+        originalRectRef.current = {
+          top: rect.top,
+          left: rect.left,
+          width: rect.width,
+          height: rect.height
+        };
+      }
+      if (!originalRectRef.current) return;
+      const resolved = resolveAffixTarget(target);
+      const containerRect = resolved.getRect();
+      if (!affixed) {
+        if (stateRef.current.affixed) {
+          setState({ affixed: false, style: {} });
+          onChangeRef.current?.(false);
+        }
+        return;
+      }
+      const forcedTop = offsetBottom !== void 0 ? containerRect.bottom - originalRectRef.current.height + offsetBottom + 1 : -1;
+      const next = calculateAffixState(
+        {
+          top: forcedTop,
+          left: originalRectRef.current.left,
+          width: originalRectRef.current.width,
+          height: originalRectRef.current.height
+        },
+        containerRect,
+        offsetBottom !== void 0 ? void 0 : offsetTop,
+        offsetBottom,
+        zIndex
+      );
+      if (!next.affixed) {
+        if (stateRef.current.affixed) {
+          setState({ affixed: false, style: {} });
+          onChangeRef.current?.(false);
+        }
+        return;
+      }
+      const wasAffixed = stateRef.current.affixed;
+      setState(next);
+      if (!wasAffixed) onChangeRef.current?.(true);
+    },
+    [offsetTop, offsetBottom, target, zIndex]
+  );
+  useEffect(() => {
+    if (!sentinelRef.current) return void 0;
+    const resolved = resolveAffixTarget(target);
+    const root = resolved.element === window ? null : resolved.element;
+    const stop = createAffixObserver(sentinelRef.current, {
+      offsetTop,
+      offsetBottom,
+      root,
+      onToggle: (affixed) => recalcStyle(affixed)
+    });
+    let resizeObs = null;
+    const onResize = () => {
+      if (stateRef.current.affixed) recalcStyle(true);
+    };
+    if (typeof ResizeObserver !== "undefined" && wrapperRef.current) {
+      resizeObs = new ResizeObserver(() => onResize());
+      resizeObs.observe(wrapperRef.current);
+    }
+    window.addEventListener("resize", onResize, { passive: true });
+    return () => {
+      stop();
+      resizeObs?.disconnect();
+      window.removeEventListener("resize", onResize);
+    };
+  }, [offsetTop, offsetBottom, target, recalcStyle]);
+  const wrapperClasses = useMemo(() => classNames(className), [className]);
+  const wrapperStyle = useMemo(
+    () => state.affixed ? { ...state.style, ...style } : style,
+    [state.affixed, state.style, style]
+  );
+  const sentinel = /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: sentinelRef,
+      "aria-hidden": "true",
+      style: { display: "block", width: 0, height: 0, pointerEvents: "none" }
+    }
+  );
+  if (state.affixed) {
+    return /* @__PURE__ */ jsxs("div", { children: [
+      sentinel,
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            width: originalRectRef.current?.width ?? 0,
+            height: originalRectRef.current?.height ?? 0
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { ref: wrapperRef, className: wrapperClasses, style: wrapperStyle, ...props, children })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { children: [
+    sentinel,
+    /* @__PURE__ */ jsx("div", { ref: wrapperRef, className: wrapperClasses, style: wrapperStyle, ...props, children })
+  ] });
+};
+
+export {
+  Affix
+};