@expcat/tigercat-react 0.4.3 → 1.0.4

package/dist/chunk-YXWRSEP5.mjs

@@ -0,0 +1,286 @@
+import { useControlledState } from './chunk-UQMPEMY7.mjs';
+import React, { useRef, useMemo, useState, useCallback } from 'react';
+import { filterColumns, setDragData, createCardDragData, createColumnDragData, getDropIndex, getColumnDropIndex, parseDragData, moveCard, reorderColumns, classNames, getKanbanContainerClasses, isWipExceeded, getColumnCardCount, kanbanCardCountClasses, taskBoardWipExceededClasses, taskBoardColumnHeaderClasses, taskBoardColumnBodyClasses, taskBoardEmptyClasses, taskBoardDropIndicatorClasses, taskBoardCardClasses, taskBoardCardDraggingClasses, kanbanAddCardClasses, taskBoardColumnClasses, taskBoardColumnDropTargetClasses, taskBoardColumnDraggingClasses, kanbanAddColumnClasses } from '@expcat/tigercat-core';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+var Kanban = ({
+  columns: controlledColumns,
+  defaultColumns = [],
+  draggable = true,
+  columnDraggable = true,
+  enforceWipLimit = false,
+  beforeCardMove,
+  beforeColumnMove,
+  filterText = "",
+  hiddenColumns,
+  showCardCount = true,
+  allowAddCard = true,
+  allowAddColumn = false,
+  onCardMove,
+  onColumnMove,
+  onColumnsChange,
+  onCardAdd,
+  onColumnAdd,
+  renderCard,
+  renderColumnHeader,
+  className,
+  ...restProps
+}) => {
+  const boardRef = useRef(null);
+  const [rawColumns, setInternalColumns, isControlled] = useControlledState(
+    controlledColumns,
+    defaultColumns
+  );
+  const visibleColumns = useMemo(
+    () => filterColumns(rawColumns, filterText, hiddenColumns),
+    [rawColumns, filterText, hiddenColumns]
+  );
+  const [dragState, setDragState] = useState(null);
+  const [dropTargetCol, setDropTargetCol] = useState(null);
+  const [dropTargetIdx, setDropTargetIdx] = useState(-1);
+  function updateColumns(cols) {
+    if (!isControlled) setInternalColumns(cols);
+    onColumnsChange?.(cols);
+  }
+  function resetDrag() {
+    setDragState(null);
+    setDropTargetCol(null);
+    setDropTargetIdx(-1);
+  }
+  const handleCardDragStart = useCallback(
+    (e, card, colId, idx) => {
+      if (!draggable) return;
+      setDragData(e.nativeEvent.dataTransfer, createCardDragData(card.id, colId, idx));
+      setDragState({ type: "card", id: card.id, fromColumnId: colId, fromIndex: idx });
+    },
+    [draggable]
+  );
+  const handleColumnDragStart = useCallback(
+    (e, colId, idx) => {
+      if (!columnDraggable) return;
+      setDragData(e.nativeEvent.dataTransfer, createColumnDragData(colId, idx));
+      setDragState({ type: "column", id: colId, fromIndex: idx });
+    },
+    [columnDraggable]
+  );
+  const handleDragOver = useCallback(
+    (e, colId) => {
+      e.preventDefault();
+      if (!dragState) return;
+      setDropTargetCol(colId);
+      if (dragState.type === "card") {
+        const colEl = e.currentTarget.querySelector("[data-kanban-body]");
+        if (colEl) {
+          const cards = Array.from(colEl.querySelectorAll("[data-kanban-card]"));
+          const rects = cards.map((c) => c.getBoundingClientRect());
+          setDropTargetIdx(getDropIndex(e.clientY, rects));
+        }
+      }
+    },
+    [dragState]
+  );
+  const handleColumnDragOver = useCallback(
+    (e) => {
+      e.preventDefault();
+      if (!dragState || dragState.type !== "column") return;
+      const boardEl = boardRef.current;
+      if (!boardEl) return;
+      const cols = Array.from(boardEl.querySelectorAll("[data-kanban-column]"));
+      const rects = cols.map((c) => c.getBoundingClientRect());
+      setDropTargetIdx(getColumnDropIndex(e.clientX, rects));
+    },
+    [dragState]
+  );
+  const handleDrop = useCallback(
+    async (e) => {
+      e.preventDefault();
+      const data = parseDragData(e.nativeEvent.dataTransfer);
+      if (!data || !dragState) {
+        resetDrag();
+        return;
+      }
+      if (data.type === "card" && dropTargetCol != null) {
+        if (beforeCardMove) {
+          const evt = {
+            cardId: data.cardId,
+            fromColumnId: data.columnId,
+            toColumnId: dropTargetCol,
+            fromIndex: data.index,
+            toIndex: dropTargetIdx
+          };
+          const ok = await beforeCardMove(evt);
+          if (!ok) {
+            resetDrag();
+            return;
+          }
+        }
+        const result = moveCard(
+          rawColumns,
+          data.cardId,
+          data.columnId,
+          dropTargetCol,
+          dropTargetIdx,
+          { enforceWipLimit }
+        );
+        if (result) {
+          updateColumns(result.columns);
+          onCardMove?.(result.event);
+        }
+      } else if (data.type === "column") {
+        if (beforeColumnMove) {
+          const evt = {
+            columnId: data.columnId,
+            fromIndex: data.index,
+            toIndex: dropTargetIdx
+          };
+          const ok = await beforeColumnMove(evt);
+          if (!ok) {
+            resetDrag();
+            return;
+          }
+        }
+        const result = reorderColumns(rawColumns, data.index, dropTargetIdx);
+        if (result) {
+          updateColumns(result.columns);
+          onColumnMove?.(result.event);
+        }
+      }
+      resetDrag();
+    },
+    [
+      dragState,
+      dropTargetCol,
+      dropTargetIdx,
+      rawColumns,
+      enforceWipLimit,
+      beforeCardMove,
+      beforeColumnMove,
+      onCardMove,
+      onColumnMove
+    ]
+  );
+  const containerClasses = useMemo(
+    () => classNames(getKanbanContainerClasses(className)),
+    [className]
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: boardRef,
+      className: containerClasses,
+      role: "region",
+      "aria-label": "Kanban board",
+      onDragOver: handleColumnDragOver,
+      ...restProps,
+      children: [
+        visibleColumns.map((col, colIdx) => {
+          const wipExceeded = isWipExceeded(col);
+          const cardCount = getColumnCardCount(col);
+          const isDragOverCol = dropTargetCol === col.id;
+          const isColDragging = dragState?.type === "column" && dragState.id === col.id;
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              className: classNames(
+                taskBoardColumnClasses,
+                isDragOverCol && dragState?.type === "card" && taskBoardColumnDropTargetClasses,
+                isColDragging && taskBoardColumnDraggingClasses
+              ),
+              "data-kanban-column": "",
+              draggable: columnDraggable,
+              onDragStart: (e) => handleColumnDragStart(e, col.id, colIdx),
+              onDragOver: (e) => handleDragOver(e, col.id),
+              onDrop: handleDrop,
+              onDragEnd: resetDrag,
+              children: [
+                /* @__PURE__ */ jsxs(
+                  "div",
+                  {
+                    className: classNames(
+                      taskBoardColumnHeaderClasses,
+                      wipExceeded && taskBoardWipExceededClasses
+                    ),
+                    children: [
+                      renderColumnHeader ? renderColumnHeader(col) : /* @__PURE__ */ jsx("span", { children: col.title }),
+                      showCardCount && /* @__PURE__ */ jsx(
+                        "span",
+                        {
+                          className: classNames(
+                            kanbanCardCountClasses,
+                            wipExceeded && taskBoardWipExceededClasses
+                          ),
+                          children: cardCount.limit ? `${cardCount.count}/${cardCount.limit}` : `${cardCount.count}`
+                        }
+                      )
+                    ]
+                  }
+                ),
+                /* @__PURE__ */ jsxs("div", { className: taskBoardColumnBodyClasses, "data-kanban-body": "", children: [
+                  col.cards.length === 0 ? /* @__PURE__ */ jsx("div", { className: taskBoardEmptyClasses, children: "No cards" }) : col.cards.map((card, cardIdx) => {
+                    const isCardDragging = dragState?.type === "card" && dragState.id === card.id;
+                    return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+                      isDragOverCol && dragState?.type === "card" && dropTargetIdx === cardIdx && /* @__PURE__ */ jsx("div", { className: taskBoardDropIndicatorClasses }),
+                      /* @__PURE__ */ jsx(
+                        "div",
+                        {
+                          className: classNames(
+                            taskBoardCardClasses,
+                            isCardDragging && taskBoardCardDraggingClasses
+                          ),
+                          draggable,
+                          "data-kanban-card": "",
+                          onDragStart: (e) => handleCardDragStart(e, card, col.id, cardIdx),
+                          children: renderCard ? renderCard(card, col.id) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                            /* @__PURE__ */ jsx("div", { className: "font-medium text-sm", children: card.title }),
+                            card.description && /* @__PURE__ */ jsx("div", { className: "text-xs text-[var(--tiger-text-muted,#6b7280)] mt-1", children: card.description })
+                          ] })
+                        }
+                      )
+                    ] }, card.id);
+                  }),
+                  isDragOverCol && dragState?.type === "card" && dropTargetIdx >= col.cards.length && /* @__PURE__ */ jsx("div", { className: taskBoardDropIndicatorClasses })
+                ] }),
+                allowAddCard && /* @__PURE__ */ jsx(
+                  "div",
+                  {
+                    className: kanbanAddCardClasses,
+                    role: "button",
+                    tabIndex: 0,
+                    onClick: () => onCardAdd?.(col.id),
+                    onKeyDown: (e) => {
+                      if (e.key === "Enter" || e.key === " ") {
+                        e.preventDefault();
+                        onCardAdd?.(col.id);
+                      }
+                    },
+                    children: "+ Add card"
+                  }
+                )
+              ]
+            },
+            col.id
+          );
+        }),
+        allowAddColumn && /* @__PURE__ */ jsx(
+          "div",
+          {
+            className: kanbanAddColumnClasses,
+            role: "button",
+            tabIndex: 0,
+            onClick: () => onColumnAdd?.(),
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                onColumnAdd?.();
+              }
+            },
+            children: "+ Add column"
+          }
+        )
+      ]
+    }
+  );
+};
+var Kanban_default = Kanban;
+
+export { Kanban, Kanban_default };

package/dist/chunk-Z6CRXABX.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Affix.tsx
+var Affix = ({
+  offsetTop = 0,
+  offsetBottom,
+  target,
+  zIndex = 10,
+  className,
+  children,
+  onChange,
+  ...props
+}) => {
+  const wrapperRef = react.useRef(null);
+  const placeholderRef = react.useRef(null);
+  const originalRectRef = react.useRef(null);
+  const [state, setState] = react.useState({ affixed: false, style: {} });
+  const prevAffixed = react.useRef(false);
+  const update = react.useCallback(() => {
+    const el = prevAffixed.current && placeholderRef.current ? placeholderRef.current : wrapperRef.current;
+    if (!el) return;
+    const rect = el.getBoundingClientRect();
+    if (!originalRectRef.current || !prevAffixed.current) {
+      originalRectRef.current = {
+        top: rect.top,
+        left: rect.left,
+        width: rect.width,
+        height: rect.height
+      };
+    }
+    const resolved = tigercatCore.resolveAffixTarget(target);
+    const containerRect = resolved.getRect();
+    const newState = tigercatCore.calculateAffixState(
+      originalRectRef.current,
+      containerRect,
+      offsetBottom !== void 0 ? void 0 : offsetTop,
+      offsetBottom,
+      zIndex
+    );
+    if (newState.affixed !== prevAffixed.current) {
+      prevAffixed.current = newState.affixed;
+      onChange?.(newState.affixed);
+    }
+    setState(newState);
+  }, [offsetTop, offsetBottom, target, zIndex, onChange]);
+  react.useEffect(() => {
+    const resolved = tigercatCore.resolveAffixTarget(target);
+    const scrollEl = resolved.element;
+    scrollEl.addEventListener("scroll", update, { passive: true });
+    window.addEventListener("resize", update, { passive: true });
+    update();
+    return () => {
+      scrollEl.removeEventListener("scroll", update);
+      window.removeEventListener("resize", update);
+    };
+  }, [target, update]);
+  const wrapperClasses = react.useMemo(() => tigercatCore.classNames(className), [className]);
+  if (state.affixed) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: placeholderRef, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          style: {
+            width: originalRectRef.current?.width ?? 0,
+            height: originalRectRef.current?.height ?? 0
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          ref: wrapperRef,
+          className: wrapperClasses,
+          style: state.style,
+          ...props,
+          children
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: wrapperRef, className: wrapperClasses, ...props, children });
+};
+
+exports.Affix = Affix;

package/dist/{chunk-24U2DQRP.mjs → chunk-ZD4BVRYG.mjs}

@@ -1,4 +1,4 @@
-import { DropdownContext } from './chunk-WGRYO5HX.mjs';
+import { DropdownContext } from './chunk-2UQC3WOI.mjs';
 import { useContext } from 'react';
 import { classNames, getDropdownItemClasses } from '@expcat/tigercat-core';
 import { jsx } from 'react/jsx-runtime';
@@ -29,6 +29,7 @@ var DropdownItem = ({
       type: "button",
       className: itemClasses,
       role: "menuitem",
+      tabIndex: -1,
       "aria-disabled": disabled,
       disabled,
       onClick: handleClick,

package/dist/chunk-ZRHDNGWO.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Empty.tsx
+var Empty = ({
+  preset = "default",
+  description,
+  showImage = true,
+  image,
+  extra,
+  className,
+  children,
+  ...props
+}) => {
+  const descText = react.useMemo(() => description ?? tigercatCore.getEmptyDescription(preset), [description, preset]);
+  const wrapperClasses = react.useMemo(() => tigercatCore.classNames(tigercatCore.emptyBaseClasses, className), [className]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: wrapperClasses, ...props, children: [
+    showImage && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.emptyImageClasses, children: image !== void 0 ? image : /* @__PURE__ */ jsxRuntime.jsx(
+      "svg",
+      {
+        xmlns: "http://www.w3.org/2000/svg",
+        viewBox: tigercatCore.emptyIllustrationViewBox,
+        className: "mx-auto h-24 w-24",
+        children: tigercatCore.emptyIllustrationPaths.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx(
+          "path",
+          {
+            d: p.d,
+            fill: p.fill ?? "none",
+            stroke: p.stroke,
+            strokeWidth: p.strokeWidth,
+            opacity: p.opacity
+          },
+          i
+        ))
+      }
+    ) }),
+    descText && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.emptyDescriptionClasses, children: descText }),
+    extra && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.emptyActionsClasses, children: extra }),
+    children && /* @__PURE__ */ jsxRuntime.jsx("div", { children })
+  ] });
+};
+
+exports.Empty = Empty;

package/dist/chunk-ZYJTHGQW.js

@@ -0,0 +1,181 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Input.tsx
+var Input = ({
+  size = "md",
+  type = "text",
+  status = "default",
+  errorMessage,
+  _shakeTrigger,
+  prefix,
+  suffix,
+  value,
+  defaultValue,
+  placeholder = "",
+  disabled = false,
+  readonly = false,
+  required = false,
+  maxLength,
+  minLength,
+  name,
+  id,
+  autoComplete,
+  autoFocus = false,
+  clearable = false,
+  showPassword = false,
+  showCount = false,
+  onInput,
+  onChange,
+  onFocus,
+  onBlur,
+  onClear,
+  className,
+  style,
+  ...props
+}) => {
+  tigercatCore.injectShakeStyle();
+  const wrapperRef = react.useRef(null);
+  const inputRef = react.useRef(null);
+  const reactId = react.useId();
+  const errorMsgId = `tiger-input-error-${reactId}`;
+  const [internalValue, setInternalValue] = react.useState(defaultValue ?? "");
+  const [passwordVisible, setPasswordVisible] = react.useState(false);
+  react.useEffect(() => {
+    if (status === "error" && wrapperRef.current) {
+      const el = wrapperRef.current;
+      el.classList.remove(tigercatCore.SHAKE_CLASS);
+      void el.offsetWidth;
+      el.classList.add(tigercatCore.SHAKE_CLASS);
+    }
+  }, [status, _shakeTrigger]);
+  const handleAnimationEnd = react.useCallback(() => {
+    wrapperRef.current?.classList.remove(tigercatCore.SHAKE_CLASS);
+  }, []);
+  const isControlled = value !== void 0;
+  const inputValue = isControlled ? value : internalValue;
+  const currentValStr = String(inputValue);
+  const handleInput = (event) => {
+    if (!isControlled) {
+      setInternalValue(tigercatCore.parseInputValue(event.currentTarget, type));
+    }
+    onInput?.(event);
+  };
+  const handleChange = (event) => {
+    if (!isControlled) {
+      setInternalValue(tigercatCore.parseInputValue(event.currentTarget, type));
+    }
+    onChange?.(event);
+  };
+  const handleClear = () => {
+    if (!isControlled) {
+      setInternalValue("");
+    }
+    onClear?.();
+    inputRef.current?.focus();
+  };
+  const togglePasswordVisibility = () => {
+    setPasswordVisible((v) => !v);
+  };
+  const hasPrefix = !!prefix;
+  const hasSuffix = !!suffix || clearable || showPassword;
+  const activeError = status === "error" && !!errorMessage;
+  const showClear = clearable && !disabled && !readonly && currentValStr.length > 0;
+  const showPasswordToggle = showPassword && type === "password" && !disabled;
+  const effectiveType = showPassword && type === "password" ? passwordVisible ? "text" : "password" : type;
+  const inputClasses = tigercatCore.getInputClasses({
+    size,
+    status,
+    hasPrefix,
+    hasSuffix
+  });
+  const renderSuffix = () => {
+    if (activeError) {
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { id: errorMsgId, className: tigercatCore.getInputErrorClasses(size), children: errorMessage });
+    }
+    if (showClear) {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: tigercatCore.getInputClearButtonClasses(size),
+          onClick: handleClear,
+          "aria-label": "Clear input",
+          tabIndex: -1,
+          children: "\u2715"
+        }
+      );
+    }
+    if (showPasswordToggle) {
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: tigercatCore.getInputPasswordToggleClasses(size),
+          onClick: togglePasswordVisibility,
+          "aria-label": passwordVisible ? "Hide password" : "Show password",
+          tabIndex: -1,
+          children: passwordVisible ? "\u{1F648}" : "\u{1F441}"
+        }
+      );
+    }
+    if (suffix) {
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.getInputAffixClasses("suffix", size), children: suffix });
+    }
+    return null;
+  };
+  const wrapperNode = /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      ref: wrapperRef,
+      className: tigercatCore.classNames(tigercatCore.getInputWrapperClasses(), className),
+      style,
+      onAnimationEnd: handleAnimationEnd,
+      children: [
+        hasPrefix && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.getInputAffixClasses("prefix", size), children: prefix }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            ...props,
+            ref: inputRef,
+            className: inputClasses,
+            type: effectiveType,
+            value: inputValue,
+            placeholder,
+            disabled,
+            readOnly: readonly,
+            required,
+            maxLength,
+            minLength,
+            name,
+            id,
+            autoComplete,
+            autoFocus,
+            ...status === "error" ? { "aria-invalid": true } : {},
+            ...activeError ? { "aria-describedby": errorMsgId } : {},
+            onInput: handleInput,
+            onChange: handleChange,
+            onFocus,
+            onBlur
+          }
+        ),
+        renderSuffix()
+      ]
+    }
+  );
+  if (showCount) {
+    const count = currentValStr.length;
+    const isOver = maxLength !== void 0 && count > maxLength;
+    const countText = maxLength !== void 0 ? `${count} / ${maxLength}` : `${count}`;
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+      wrapperNode,
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.getInputCountClasses(isOver), children: countText })
+    ] });
+  }
+  return wrapperNode;
+};
+
+exports.Input = Input;

package/dist/components/ActivityFeed.js

@@ -2,22 +2,22 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var chunkJ3HKED4B_js = require('../chunk-J3HKED4B.js');
+var chunkVHWTMNQN_js = require('../chunk-VHWTMNQN.js');
 require('../chunk-PR3PQUKM.js');
 require('../chunk-QYYAXM5F.js');
 require('../chunk-2GKTVAAB.js');
 require('../chunk-VCULFIZ5.js');
-require('../chunk-I5TCE5E7.js');
-require('../chunk-SSQOCZ6O.js');
+require('../chunk-UF3DXKCI.js');
+require('../chunk-UIO6O4MI.js');
 require('../chunk-CI2WHAT2.js');
 
 
 
 Object.defineProperty(exports, "ActivityFeed", {
   enumerable: true,
-  get: function () { return chunkJ3HKED4B_js.ActivityFeed; }
+  get: function () { return chunkVHWTMNQN_js.ActivityFeed; }
 });
 Object.defineProperty(exports, "default", {
   enumerable: true,
-  get: function () { return chunkJ3HKED4B_js.ActivityFeed_default; }
+  get: function () { return chunkVHWTMNQN_js.ActivityFeed_default; }
 });

package/dist/components/ActivityFeed.mjs

@@ -1,8 +1,8 @@
-export { ActivityFeed, ActivityFeed_default as default } from '../chunk-MTL2QUM3.mjs';
+export { ActivityFeed, ActivityFeed_default as default } from '../chunk-HSHVLIEL.mjs';
 import '../chunk-JVTAKNRO.mjs';
 import '../chunk-XZVQ3PJS.mjs';
 import '../chunk-AVUXDQYO.mjs';
 import '../chunk-TGKNEMD4.mjs';
-import '../chunk-LIV33O73.mjs';
-import '../chunk-3M2IG6IN.mjs';
+import '../chunk-HLS4CHWX.mjs';
+import '../chunk-P6E3DILH.mjs';
 import '../chunk-FE7PEZTI.mjs';

package/dist/components/Affix.d.mts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { AffixProps as AffixProps$1 } from '@expcat/tigercat-core';
+
+interface AffixProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'>, AffixProps$1 {
+    children?: React.ReactNode;
+    /** Callback when affixed state changes */
+    onChange?: (affixed: boolean) => void;
+}
+declare const Affix: React.FC<AffixProps>;
+
+export { Affix, type AffixProps };

package/dist/components/Affix.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { AffixProps as AffixProps$1 } from '@expcat/tigercat-core';
+
+interface AffixProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'>, AffixProps$1 {
+    children?: React.ReactNode;
+    /** Callback when affixed state changes */
+    onChange?: (affixed: boolean) => void;
+}
+declare const Affix: React.FC<AffixProps>;
+
+export { Affix, type AffixProps };

package/dist/components/Affix.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkZ6CRXABX_js = require('../chunk-Z6CRXABX.js');
+
+
+
+Object.defineProperty(exports, "Affix", {
+  enumerable: true,
+  get: function () { return chunkZ6CRXABX_js.Affix; }
+});