@expcat/tigercat-react 0.2.10 → 0.3.0

package/dist/chunk-Z6G4HABF.js

@@ -0,0 +1,272 @@
+'use strict';
+
+var React = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/components/Carousel.tsx
+var Carousel = React.forwardRef(
+  ({
+    autoplay = false,
+    autoplaySpeed = 3e3,
+    dots = true,
+    dotPosition = "bottom",
+    effect = "scroll",
+    arrows = false,
+    infinite = true,
+    speed = 500,
+    initialSlide = 0,
+    pauseOnHover = true,
+    pauseOnFocus = true,
+    className,
+    style,
+    onChange,
+    onBeforeChange,
+    children
+  }, ref) => {
+    const [currentIndex, setCurrentIndex] = React.useState(initialSlide);
+    const [isPaused, setIsPaused] = React.useState(false);
+    const autoplayTimerRef = React.useRef(null);
+    const slides = React.useMemo(() => {
+      return React__default.default.Children.toArray(children).filter((child) => React__default.default.isValidElement(child));
+    }, [children]);
+    const slideCount = slides.length;
+    const containerClasses = React.useMemo(
+      () => tigercatCore.classNames(tigercatCore.getCarouselContainerClasses(className)),
+      [className]
+    );
+    const trackClasses = React.useMemo(() => {
+      if (effect === "fade") {
+        return tigercatCore.carouselTrackFadeClasses;
+      }
+      return tigercatCore.carouselTrackScrollClasses;
+    }, [effect]);
+    const trackStyle = React.useMemo(() => {
+      if (effect === "scroll") {
+        return {
+          transform: tigercatCore.getScrollTransform(currentIndex),
+          transitionDuration: `${speed}ms`
+        };
+      }
+      return {};
+    }, [effect, currentIndex, speed]);
+    const getSlideClasses = React.useCallback(
+      (index) => {
+        const isActive = index === currentIndex;
+        if (effect === "fade") {
+          const positionClass = index === 0 ? "relative" : "absolute inset-0";
+          return tigercatCore.classNames(
+            positionClass,
+            "w-full transition-opacity ease-in-out",
+            isActive ? "opacity-100 z-10" : "opacity-0 z-0"
+          );
+        }
+        return tigercatCore.carouselSlideBaseClasses;
+      },
+      [effect, currentIndex]
+    );
+    const getSlideStyle = React.useCallback(() => {
+      return {
+        transitionDuration: `${speed}ms`
+      };
+    }, [speed]);
+    const dotsClasses = React.useMemo(() => {
+      return tigercatCore.getCarouselDotsClasses(dotPosition);
+    }, [dotPosition]);
+    const goTo = React.useCallback(
+      (index) => {
+        const clampedIndex = tigercatCore.clampSlideIndex(index, slideCount);
+        if (clampedIndex === currentIndex) return;
+        onBeforeChange?.(currentIndex, clampedIndex);
+        const prevIndex = currentIndex;
+        setCurrentIndex(clampedIndex);
+        onChange?.(clampedIndex, prevIndex);
+      },
+      [currentIndex, slideCount, onBeforeChange, onChange]
+    );
+    const next = React.useCallback(() => {
+      const nextIdx = tigercatCore.getNextSlideIndex(currentIndex, slideCount, infinite);
+      if (nextIdx !== currentIndex) {
+        goTo(nextIdx);
+      }
+    }, [currentIndex, slideCount, infinite, goTo]);
+    const prev = React.useCallback(() => {
+      const prevIdx = tigercatCore.getPrevSlideIndex(currentIndex, slideCount, infinite);
+      if (prevIdx !== currentIndex) {
+        goTo(prevIdx);
+      }
+    }, [currentIndex, slideCount, infinite, goTo]);
+    React.useImperativeHandle(
+      ref,
+      () => ({
+        next,
+        prev,
+        goTo
+      }),
+      [next, prev, goTo]
+    );
+    React.useEffect(() => {
+      if (autoplay && !isPaused) {
+        if (autoplayTimerRef.current) {
+          clearInterval(autoplayTimerRef.current);
+        }
+        autoplayTimerRef.current = setInterval(() => {
+          setCurrentIndex((prevIndex) => {
+            const nextIdx = tigercatCore.getNextSlideIndex(prevIndex, slideCount, infinite);
+            if (nextIdx !== prevIndex) {
+              onBeforeChange?.(prevIndex, nextIdx);
+              onChange?.(nextIdx, prevIndex);
+            }
+            return nextIdx;
+          });
+        }, autoplaySpeed);
+      }
+      return () => {
+        if (autoplayTimerRef.current) {
+          clearInterval(autoplayTimerRef.current);
+          autoplayTimerRef.current = null;
+        }
+      };
+    }, [autoplay, autoplaySpeed, isPaused, slideCount, infinite, onChange, onBeforeChange]);
+    const handleMouseEnter = React.useCallback(() => {
+      if (pauseOnHover && autoplay) {
+        setIsPaused(true);
+      }
+    }, [pauseOnHover, autoplay]);
+    const handleMouseLeave = React.useCallback(() => {
+      if (pauseOnHover && autoplay) {
+        setIsPaused(false);
+      }
+    }, [pauseOnHover, autoplay]);
+    const handleFocus = React.useCallback(() => {
+      if (pauseOnFocus && autoplay) {
+        setIsPaused(true);
+      }
+    }, [pauseOnFocus, autoplay]);
+    const handleBlur = React.useCallback(() => {
+      if (pauseOnFocus && autoplay) {
+        setIsPaused(false);
+      }
+    }, [pauseOnFocus, autoplay]);
+    const isPrevArrowDisabled = React.useMemo(
+      () => tigercatCore.isPrevDisabled(currentIndex, slideCount, infinite),
+      [currentIndex, slideCount, infinite]
+    );
+    const isNextArrowDisabled = React.useMemo(
+      () => tigercatCore.isNextDisabled(currentIndex, slideCount, infinite),
+      [currentIndex, slideCount, infinite]
+    );
+    const renderArrows = () => {
+      if (!arrows) return null;
+      return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: tigercatCore.getCarouselArrowClasses("prev", isPrevArrowDisabled),
+            onClick: prev,
+            disabled: isPrevArrowDisabled,
+            "aria-label": "Previous slide",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "svg",
+              {
+                xmlns: "http://www.w3.org/2000/svg",
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                className: "w-6 h-6",
+                children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: tigercatCore.carouselPrevArrowPath })
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: tigercatCore.getCarouselArrowClasses("next", isNextArrowDisabled),
+            onClick: next,
+            disabled: isNextArrowDisabled,
+            "aria-label": "Next slide",
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "svg",
+              {
+                xmlns: "http://www.w3.org/2000/svg",
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                className: "w-6 h-6",
+                children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: tigercatCore.carouselNextArrowPath })
+              }
+            )
+          }
+        )
+      ] });
+    };
+    const renderDots = () => {
+      if (!dots || slideCount <= 1) return null;
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: dotsClasses, role: "tablist", "aria-label": "Carousel navigation", children: slides.map((_, index) => /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: tigercatCore.getCarouselDotClasses(index === currentIndex),
+          onClick: () => goTo(index),
+          "aria-label": `Go to slide ${index + 1}`,
+          "aria-current": index === currentIndex ? "true" : "false"
+        },
+        index
+      )) });
+    };
+    const renderSlides = () => {
+      const slideElements = slides.map((slide, index) => /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          className: getSlideClasses(index),
+          style: effect === "fade" ? getSlideStyle() : void 0,
+          role: "group",
+          "aria-roledescription": "slide",
+          "aria-label": `Slide ${index + 1} of ${slideCount}`,
+          "aria-hidden": index !== currentIndex,
+          children: slide
+        },
+        index
+      ));
+      if (effect === "fade") {
+        return /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.classNames(trackClasses, "h-full"), children: slideElements });
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx("div", { className: trackClasses, style: trackStyle, children: slideElements });
+    };
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        className: containerClasses,
+        style,
+        role: "region",
+        "aria-roledescription": "carousel",
+        "aria-label": "Image carousel",
+        onMouseEnter: handleMouseEnter,
+        onMouseLeave: handleMouseLeave,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        children: [
+          renderSlides(),
+          renderArrows(),
+          renderDots()
+        ]
+      }
+    );
+  }
+);
+Carousel.displayName = "Carousel";
+
+exports.Carousel = Carousel;

package/dist/chunk-ZN2BZCTI.js

@@ -0,0 +1,192 @@
+'use strict';
+
+var chunkCIL2AC3F_js = require('./chunk-CIL2AC3F.js');
+var chunkR7MS42PL_js = require('./chunk-R7MS42PL.js');
+var chunkA3DJSVTE_js = require('./chunk-A3DJSVTE.js');
+var chunkTZ26HQAW_js = require('./chunk-TZ26HQAW.js');
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+var ChatWindow = ({
+  messages = [],
+  value,
+  defaultValue = "",
+  placeholder = "\u8BF7\u8F93\u5165\u6D88\u606F",
+  disabled = false,
+  maxLength,
+  emptyText = "\u6682\u65E0\u6D88\u606F",
+  sendText = "\u53D1\u9001",
+  messageListAriaLabel,
+  inputAriaLabel,
+  sendAriaLabel,
+  statusText,
+  statusVariant = "info",
+  showAvatar = true,
+  showName = true,
+  showTime = false,
+  inputType = "textarea",
+  inputRows = 3,
+  sendOnEnter = true,
+  allowShiftEnter = true,
+  allowEmpty = false,
+  clearOnSend = true,
+  statusVariant: _sv,
+  onChange,
+  onSend,
+  renderMessage,
+  className,
+  ...props
+}) => {
+  const [innerValue, setInnerValue] = react.useState(value ?? defaultValue);
+  react.useEffect(() => {
+    if (value !== void 0) {
+      setInnerValue(value);
+    }
+  }, [value]);
+  const inputValue = value !== void 0 ? value : innerValue;
+  const wrapperClasses = react.useMemo(
+    () => tigercatCore.classNames(
+      "tiger-chat-window flex flex-col w-full rounded-lg border border-[var(--tiger-border,#e5e7eb)] bg-[var(--tiger-surface,#ffffff)]",
+      className
+    ),
+    [className]
+  );
+  const canSend = react.useMemo(() => {
+    if (disabled) return false;
+    if (allowEmpty) return true;
+    const raw = String(inputValue ?? "");
+    return raw.trim().length > 0;
+  }, [allowEmpty, disabled, inputValue]);
+  const handleValueChange = react.useCallback(
+    (nextValue) => {
+      if (value === void 0) {
+        setInnerValue(nextValue);
+      }
+      onChange?.(nextValue);
+    },
+    [onChange, value]
+  );
+  const handleSend = react.useCallback(() => {
+    if (!canSend) return;
+    const payload = String(inputValue ?? "");
+    onSend?.(payload);
+    if (clearOnSend) {
+      if (value === void 0) {
+        setInnerValue("");
+      }
+      onChange?.("");
+    }
+  }, [canSend, clearOnSend, inputValue, onSend, onChange, value]);
+  const handleKeyDown = react.useCallback(
+    (event) => {
+      if (!sendOnEnter) return;
+      if (event.key !== "Enter") return;
+      if (inputType === "textarea" && allowShiftEnter && event.shiftKey) return;
+      event.preventDefault();
+      handleSend();
+    },
+    [allowShiftEnter, handleSend, inputType, sendOnEnter]
+  );
+  const renderMessageItem = react.useCallback(
+    (message, index) => {
+      const isSelf = message.direction === "self";
+      const statusInfo = message.status ? tigercatCore.getChatMessageStatusInfo(message.status) : void 0;
+      const timeText = showTime ? tigercatCore.formatChatTime(message.time) : "";
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          className: tigercatCore.classNames(
+            "flex gap-3 items-start",
+            isSelf ? "flex-row-reverse" : "justify-start"
+          ),
+          "data-tiger-chat-message": true,
+          role: "listitem",
+          children: [
+            showAvatar && message.user ? /* @__PURE__ */ jsxRuntime.jsx(
+              chunkTZ26HQAW_js.Avatar,
+              {
+                size: "sm",
+                src: message.user.avatar,
+                text: message.user.name,
+                className: "flex-shrink-0"
+              }
+            ) : null,
+            /* @__PURE__ */ jsxRuntime.jsxs("div", { className: tigercatCore.classNames("flex flex-col max-w-[75%]", isSelf && "items-end"), children: [
+              showName && message.user?.name && /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  className: tigercatCore.classNames(
+                    "text-xs mb-1 text-[var(--tiger-text-muted,#6b7280)]",
+                    isSelf && "text-right"
+                  ),
+                  children: message.user.name
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  className: tigercatCore.classNames(
+                    "rounded-lg px-3 py-2 text-sm break-words",
+                    isSelf ? "bg-[var(--tiger-primary,#2563eb)] text-white rounded-tr-none" : "bg-[var(--tiger-surface-muted,#f3f4f6)] text-[var(--tiger-text,#111827)] rounded-tl-none"
+                  ),
+                  "data-tiger-chat-bubble": true,
+                  children: renderMessage?.(message, index) ?? message.content
+                }
+              ),
+              statusInfo && /* @__PURE__ */ jsxRuntime.jsx("div", { className: tigercatCore.classNames("text-xs mt-1", statusInfo.className), children: message.statusText || statusInfo.text }),
+              timeText && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs mt-1 text-[var(--tiger-text-muted,#6b7280)]", children: timeText })
+            ] })
+          ]
+        },
+        message.id ?? index
+      );
+    },
+    [renderMessage, showAvatar, showName, showTime]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: wrapperClasses, "data-tiger-chat-window": true, ...props, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className: "flex-1 overflow-auto p-4 space-y-3",
+        role: "log",
+        "aria-live": "polite",
+        "aria-relevant": "additions text",
+        "aria-label": messageListAriaLabel ?? "\u6D88\u606F\u5217\u8868",
+        children: messages.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "h-full flex items-center justify-center text-[var(--tiger-text-muted,#6b7280)]", children: emptyText }) : messages.map(renderMessageItem)
+      }
+    ),
+    statusText && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-4 py-1.5 border-t border-[var(--tiger-border,#e5e7eb)] text-xs italic text-[var(--tiger-text-muted,#6b7280)]", children: statusText }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-end gap-3 px-4 py-3 border-t border-[var(--tiger-border,#e5e7eb)] bg-[var(--tiger-surface,#ffffff)] rounded-b-lg", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1", children: inputType === "input" ? /* @__PURE__ */ jsxRuntime.jsx(
+        chunkCIL2AC3F_js.Input,
+        {
+          value: inputValue,
+          placeholder,
+          disabled,
+          maxLength,
+          "aria-label": inputAriaLabel ?? placeholder ?? "\u6D88\u606F\u8F93\u5165",
+          onChange: (event) => handleValueChange(event.currentTarget.value),
+          onKeyDown: handleKeyDown
+        }
+      ) : /* @__PURE__ */ jsxRuntime.jsx(
+        chunkR7MS42PL_js.Textarea,
+        {
+          value: inputValue,
+          placeholder,
+          disabled,
+          maxLength,
+          rows: inputRows,
+          "aria-label": inputAriaLabel ?? placeholder ?? "\u6D88\u606F\u8F93\u5165",
+          onChange: (event) => handleValueChange(event.currentTarget.value),
+          onKeyDown: handleKeyDown
+        }
+      ) }),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkA3DJSVTE_js.Button, { disabled: !canSend, onClick: handleSend, "aria-label": sendAriaLabel ?? sendText, children: sendText })
+    ] })
+  ] });
+};
+var ChatWindow_default = ChatWindow;
+
+exports.ChatWindow = ChatWindow;
+exports.ChatWindow_default = ChatWindow_default;

package/dist/chunk-ZPWDDAFE.js

@@ -0,0 +1,162 @@
+'use strict';
+
+var react = require('react');
+var tigercatCore = require('@expcat/tigercat-core');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/components/Anchor.tsx
+var AnchorContext = react.createContext(null);
+function useAnchorContext() {
+  return react.useContext(AnchorContext);
+}
+var Anchor = ({
+  affix = true,
+  bounds = 5,
+  offsetTop = 0,
+  showInkInFixed = false,
+  targetOffset,
+  getCurrentAnchor,
+  getContainer = () => window,
+  direction = "vertical",
+  className,
+  style,
+  onClick,
+  onChange,
+  children
+}) => {
+  const [activeLink, setActiveLink] = react.useState("");
+  const [links, setLinks] = react.useState([]);
+  const anchorRef = react.useRef(null);
+  const inkRef = react.useRef(null);
+  const isScrollingRef = react.useRef(false);
+  const animationFrameRef = react.useRef(null);
+  const getContainerRef = react.useRef(getContainer);
+  getContainerRef.current = getContainer;
+  const scrollOffset = react.useMemo(() => targetOffset ?? offsetTop, [targetOffset, offsetTop]);
+  const registerLink = react.useCallback((href) => {
+    setLinks((prevLinks) => {
+      if (href && !prevLinks.includes(href)) {
+        return [...prevLinks, href];
+      }
+      return prevLinks;
+    });
+  }, []);
+  const unregisterLink = react.useCallback((href) => {
+    setLinks((prevLinks) => prevLinks.filter((l) => l !== href));
+  }, []);
+  const scrollTo = react.useCallback(
+    (href) => {
+      const container = getContainerRef.current();
+      tigercatCore.scrollToAnchor(href, container, scrollOffset);
+    },
+    [scrollOffset]
+  );
+  const handleLinkClick = react.useCallback(
+    (href, event) => {
+      onClick?.(event, href);
+      isScrollingRef.current = true;
+      setActiveLink(href);
+      scrollTo(href);
+      setTimeout(() => {
+        isScrollingRef.current = false;
+      }, 500);
+    },
+    [onClick, scrollTo]
+  );
+  const scrollHandlerRef = react.useRef(null);
+  const boundContainerRef = react.useRef(null);
+  react.useEffect(() => {
+    const timeoutId = setTimeout(() => {
+      const container = getContainerRef.current();
+      boundContainerRef.current = container;
+      const handleScroll = () => {
+        if (isScrollingRef.current) return;
+        if (animationFrameRef.current !== null) {
+          cancelAnimationFrame(animationFrameRef.current);
+        }
+        animationFrameRef.current = requestAnimationFrame(() => {
+          const currentContainer = getContainerRef.current();
+          const newActiveLink = tigercatCore.findActiveAnchor(links, currentContainer, bounds, scrollOffset);
+          const finalActiveLink = getCurrentAnchor ? getCurrentAnchor(newActiveLink) : newActiveLink;
+          setActiveLink((prevActiveLink) => {
+            if (finalActiveLink !== prevActiveLink) {
+              onChange?.(finalActiveLink);
+              return finalActiveLink;
+            }
+            return prevActiveLink;
+          });
+        });
+      };
+      scrollHandlerRef.current = handleScroll;
+      container.addEventListener("scroll", handleScroll, { passive: true });
+      handleScroll();
+    }, 0);
+    return () => {
+      clearTimeout(timeoutId);
+      if (boundContainerRef.current && scrollHandlerRef.current) {
+        boundContainerRef.current.removeEventListener("scroll", scrollHandlerRef.current);
+      }
+      if (animationFrameRef.current !== null) {
+        cancelAnimationFrame(animationFrameRef.current);
+      }
+    };
+  }, [links, bounds, scrollOffset, getCurrentAnchor, onChange]);
+  react.useEffect(() => {
+    if (!inkRef.current || !anchorRef.current || !activeLink) {
+      return;
+    }
+    const activeLinkElement = anchorRef.current.querySelector(
+      `[data-anchor-href="${activeLink}"]`
+    );
+    if (!activeLinkElement) {
+      return;
+    }
+    const anchorRect = anchorRef.current.getBoundingClientRect();
+    const linkRect = activeLinkElement.getBoundingClientRect();
+    if (direction === "vertical") {
+      inkRef.current.style.top = `${linkRect.top - anchorRect.top}px`;
+      inkRef.current.style.height = `${linkRect.height}px`;
+    } else {
+      inkRef.current.style.left = `${linkRect.left - anchorRect.left}px`;
+      inkRef.current.style.width = `${linkRect.width}px`;
+    }
+  }, [activeLink, direction]);
+  const wrapperClasses = react.useMemo(
+    () => tigercatCore.classNames(tigercatCore.getAnchorWrapperClasses(affix, className)),
+    [affix, className]
+  );
+  const inkContainerClasses = react.useMemo(() => tigercatCore.getAnchorInkContainerClasses(direction), [direction]);
+  const inkActiveClasses = react.useMemo(() => tigercatCore.getAnchorInkActiveClasses(direction), [direction]);
+  const linkListClasses = react.useMemo(() => tigercatCore.getAnchorLinkListClasses(direction), [direction]);
+  const showInk = react.useMemo(() => {
+    if (!affix) return true;
+    return showInkInFixed;
+  }, [affix, showInkInFixed]);
+  const wrapperStyle = react.useMemo(() => {
+    const baseStyle = {};
+    if (affix && offsetTop > 0) {
+      baseStyle.top = `${offsetTop}px`;
+    }
+    return { ...baseStyle, ...style };
+  }, [affix, offsetTop, style]);
+  const contextValue = react.useMemo(
+    () => ({
+      activeLink,
+      direction,
+      registerLink,
+      unregisterLink,
+      handleLinkClick,
+      scrollTo
+    }),
+    [activeLink, direction, registerLink, unregisterLink, handleLinkClick, scrollTo]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(AnchorContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: anchorRef, className: wrapperClasses, style: wrapperStyle, children: [
+    showInk && /* @__PURE__ */ jsxRuntime.jsx("div", { className: inkContainerClasses, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: inkRef, className: inkActiveClasses }) }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: linkListClasses, children })
+  ] }) });
+};
+var Anchor_default = Anchor;
+
+exports.Anchor = Anchor;
+exports.Anchor_default = Anchor_default;
+exports.useAnchorContext = useAnchorContext;

package/dist/components/ActivityFeed.d.mts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ActivityFeedProps as ActivityFeedProps$1, ActivityItem, ActivityGroup } from '@expcat/tigercat-core';
+
+interface ActivityFeedProps extends Omit<ActivityFeedProps$1, 'renderItem' | 'renderGroupHeader'>, Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    renderItem?: (item: ActivityItem, index: number, group?: ActivityGroup) => React.ReactNode;
+    renderGroupHeader?: (group: ActivityGroup) => React.ReactNode;
+}
+declare const ActivityFeed: React.FC<ActivityFeedProps>;
+
+export { ActivityFeed, type ActivityFeedProps, ActivityFeed as default };

package/dist/components/ActivityFeed.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { ActivityFeedProps as ActivityFeedProps$1, ActivityItem, ActivityGroup } from '@expcat/tigercat-core';
+
+interface ActivityFeedProps extends Omit<ActivityFeedProps$1, 'renderItem' | 'renderGroupHeader'>, Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    renderItem?: (item: ActivityItem, index: number, group?: ActivityGroup) => React.ReactNode;
+    renderGroupHeader?: (group: ActivityGroup) => React.ReactNode;
+}
+declare const ActivityFeed: React.FC<ActivityFeedProps>;
+
+export { ActivityFeed, type ActivityFeedProps, ActivityFeed as default };

package/dist/components/ActivityFeed.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var chunk4IO2M3ZJ_js = require('../chunk-4IO2M3ZJ.js');
+require('../chunk-IQINYCU6.js');
+require('../chunk-MKWXJZ3T.js');
+require('../chunk-6MGEGOYJ.js');
+require('../chunk-2TS6X5RA.js');
+require('../chunk-YYGTJKP5.js');
+require('../chunk-VO4WDK4K.js');
+require('../chunk-TZ26HQAW.js');
+
+
+
+Object.defineProperty(exports, "ActivityFeed", {
+  enumerable: true,
+  get: function () { return chunk4IO2M3ZJ_js.ActivityFeed; }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () { return chunk4IO2M3ZJ_js.ActivityFeed_default; }
+});

package/dist/components/ActivityFeed.mjs

@@ -0,0 +1,8 @@
+export { ActivityFeed, ActivityFeed_default as default } from '../chunk-WKGCUR7O.mjs';
+import '../chunk-LADCWARG.mjs';
+import '../chunk-WSJO2PIE.mjs';
+import '../chunk-PUDU34R4.mjs';
+import '../chunk-DIZNY6N4.mjs';
+import '../chunk-6YDIBMCM.mjs';
+import '../chunk-VD3IK5XT.mjs';
+import '../chunk-V2HVHLBY.mjs';