@expcat/tigercat-react 2.1.2 → 2.1.4

package/dist/chunk-Z3CRHC5F.mjs

@@ -1,430 +0,0 @@
-import {
-  useTigerConfig
-} from "./chunk-YSIXURBW.mjs";
-
-// src/components/Tabs.tsx
-import React, {
-  createContext,
-  useContext,
-  useState,
-  useMemo,
-  useCallback,
-  useId,
-  useRef
-} from "react";
-import {
-  classNames,
-  closeIconPathD,
-  closeIconViewBox,
-  getTabsContainerClasses,
-  getTabItemClasses,
-  getTabNavClasses,
-  getTabNavListClasses,
-  getTabNavListStyle,
-  getTabPaneClasses,
-  getTabIndicatorClasses,
-  getTabIndicatorStyle,
-  getGestureTouchPoint,
-  resolveSwipeGesture,
-  isKeyActive,
-  getNextActiveKey,
-  mergeTigerLocale,
-  getTabsLabels,
-  tabAddButtonClasses,
-  tabCloseButtonClasses,
-  tabContentBaseClasses
-} from "@expcat/tigercat-core";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-var TabsContext = createContext(null);
-function useTabsContext() {
-  return useContext(TabsContext);
-}
-var TabPane = ({
-  tabKey,
-  label,
-  disabled = false,
-  closable,
-  icon,
-  className,
-  style,
-  children,
-  renderMode = "pane",
-  tabId,
-  panelId
-}) => {
-  const tabsContext = useTabsContext();
-  if (!tabsContext) {
-    throw new Error("TabPane must be used within a Tabs component");
-  }
-  const isActive = useMemo(() => {
-    return isKeyActive(tabKey, tabsContext.activeKey);
-  }, [tabKey, tabsContext.activeKey]);
-  const hasBeenActivatedRef = useRef(isActive);
-  if (isActive) hasBeenActivatedRef.current = true;
-  const isClosable = useMemo(() => {
-    return closable !== void 0 ? closable : tabsContext.closable && tabsContext.type === "editable-card";
-  }, [closable, tabsContext.closable, tabsContext.type]);
-  const tabItemClasses = useMemo(() => {
-    return getTabItemClasses(isActive, disabled, tabsContext.type, tabsContext.size);
-  }, [isActive, disabled, tabsContext.type, tabsContext.size]);
-  const tabPaneClasses = useMemo(() => {
-    return classNames(getTabPaneClasses(isActive), className);
-  }, [isActive, className]);
-  const handleClick = () => {
-    if (!disabled) {
-      tabsContext.handleTabClick(tabKey);
-    }
-  };
-  const handleKeyDown = (event) => {
-    if (disabled) {
-      return;
-    }
-    if (isClosable && (event.key === "Backspace" || event.key === "Delete")) {
-      event.preventDefault();
-      tabsContext.handleTabClose(tabKey, event);
-      return;
-    }
-    const isVertical = tabsContext.tabPosition === "left" || tabsContext.tabPosition === "right";
-    const nextKeys = isVertical ? ["ArrowDown"] : ["ArrowRight"];
-    const prevKeys = isVertical ? ["ArrowUp"] : ["ArrowLeft"];
-    const key = event.key;
-    if (nextKeys.includes(key) || prevKeys.includes(key) || key === "Home" || key === "End" || key === "Enter" || key === " ") {
-      event.preventDefault();
-    }
-    if (key === "Enter" || key === " ") {
-      tabsContext.handleTabClick(tabKey);
-      return;
-    }
-    const tabList = event.currentTarget?.closest('[role="tablist"]');
-    const tabButtons = Array.from(tabList?.querySelectorAll('[role="tab"]') ?? []);
-    const enabled = tabButtons.filter((button) => button.getAttribute("aria-disabled") !== "true");
-    const currentIndex = enabled.findIndex((button) => button.id === tabId);
-    if (currentIndex === -1) {
-      return;
-    }
-    const focusByIndex = (index) => {
-      const next = enabled[index];
-      if (!next) return;
-      next.focus();
-      const nextKey = next.getAttribute("data-tiger-tab-key");
-      if (nextKey != null) {
-        const parsed = nextKey.startsWith("n:") ? Number(nextKey.slice(2)) : nextKey.startsWith("s:") ? nextKey.slice(2) : nextKey;
-        tabsContext.handleTabClick(parsed);
-      }
-    };
-    if (nextKeys.includes(key)) {
-      focusByIndex((currentIndex + 1) % enabled.length);
-      return;
-    }
-    if (prevKeys.includes(key)) {
-      focusByIndex((currentIndex - 1 + enabled.length) % enabled.length);
-      return;
-    }
-    if (key === "Home") {
-      focusByIndex(0);
-      return;
-    }
-    if (key === "End") {
-      focusByIndex(enabled.length - 1);
-    }
-  };
-  const handleClose = (event) => {
-    event.stopPropagation();
-    if (!disabled) {
-      tabsContext.handleTabClose(tabKey, event);
-    }
-  };
-  if (renderMode === "tab") {
-    return /* @__PURE__ */ jsxs(
-      "div",
-      {
-        className: tabItemClasses,
-        role: "tab",
-        id: tabId,
-        "aria-controls": panelId,
-        "aria-selected": isActive,
-        "aria-disabled": disabled,
-        tabIndex: disabled ? -1 : isActive ? 0 : -1,
-        "data-tiger-tabs-id": tabsContext.idBase,
-        "data-tiger-tab-key": typeof tabKey === "number" ? `n:${tabKey}` : `s:${tabKey}`,
-        onClick: handleClick,
-        onKeyDown: handleKeyDown,
-        children: [
-          icon && /* @__PURE__ */ jsx("span", { className: "flex items-center", children: icon }),
-          /* @__PURE__ */ jsx("span", { children: label }),
-          isClosable && /* @__PURE__ */ jsx(
-            "button",
-            {
-              type: "button",
-              className: tabCloseButtonClasses,
-              "aria-label": tabsContext.labels.closeTabAriaLabel.replace("{label}", String(label)),
-              tabIndex: -1,
-              onClick: handleClose,
-              children: /* @__PURE__ */ jsx("svg", { className: "w-4 h-4", fill: "none", stroke: "currentColor", viewBox: closeIconViewBox, children: /* @__PURE__ */ jsx(
-                "path",
-                {
-                  strokeLinecap: "round",
-                  strokeLinejoin: "round",
-                  strokeWidth: "2",
-                  d: closeIconPathD
-                }
-              ) })
-            }
-          )
-        ]
-      }
-    );
-  }
-  const shouldRender = tabsContext.lazy ? hasBeenActivatedRef.current && (isActive || !tabsContext.destroyInactiveTabPane) : isActive || !tabsContext.destroyInactiveTabPane;
-  if (!shouldRender) {
-    return null;
-  }
-  return /* @__PURE__ */ jsx(
-    "div",
-    {
-      className: tabPaneClasses,
-      style,
-      role: "tabpanel",
-      id: panelId,
-      "aria-labelledby": tabId,
-      "aria-hidden": !isActive,
-      children
-    }
-  );
-};
-var Tabs = ({
-  activeKey: controlledActiveKey,
-  defaultActiveKey,
-  type = "line",
-  tabPosition = "top",
-  size = "medium",
-  closable = false,
-  centered = false,
-  destroyInactiveTabPane = false,
-  lazy = false,
-  swipeable = true,
-  className,
-  style,
-  locale,
-  labels: labelsOverride,
-  onActiveKeyChange,
-  onTabClick,
-  onEdit,
-  children
-}) => {
-  const config = useTigerConfig();
-  const reactId = useId();
-  const idBase = useMemo(() => `tiger-tabs-${reactId.replace(/[^a-zA-Z0-9_-]/g, "")}`, [reactId]);
-  const mergedLocale = useMemo(
-    () => mergeTigerLocale(config.locale, locale),
-    [config.locale, locale]
-  );
-  const labels = useMemo(
-    () => getTabsLabels(mergedLocale, labelsOverride),
-    [mergedLocale, labelsOverride]
-  );
-  const [internalActiveKey, setInternalActiveKey] = useState(
-    defaultActiveKey
-  );
-  const swipeStartRef = useRef(null);
-  const containerClasses = useMemo(() => {
-    return classNames(getTabsContainerClasses(tabPosition), className);
-  }, [tabPosition, className]);
-  const tabNavClasses = useMemo(() => {
-    return getTabNavClasses(tabPosition, type);
-  }, [tabPosition, type]);
-  const tabNavListClasses = useMemo(() => {
-    return getTabNavListClasses(tabPosition, centered);
-  }, [tabPosition, centered]);
-  const { tabItems, tabPanes, firstTabKey, tabKeys, enabledTabKeys } = useMemo(() => {
-    const items = [];
-    const panes = [];
-    const keys = [];
-    const enabledKeys = [];
-    let firstKey;
-    React.Children.forEach(children, (child) => {
-      if (!React.isValidElement(child) || child.type !== TabPane) return;
-      const key = child.props.tabKey;
-      if (firstKey === void 0) firstKey = key;
-      keys.push(key);
-      if (!child.props.disabled) enabledKeys.push(key);
-      const tabId = `${idBase}-tab-${String(key)}`;
-      const panelId = `${idBase}-panel-${String(key)}`;
-      items.push(
-        React.cloneElement(child, {
-          key: `tab-${String(key)}`,
-          renderMode: "tab",
-          tabId,
-          panelId
-        })
-      );
-      panes.push(
-        React.cloneElement(child, {
-          key: `pane-${String(key)}`,
-          renderMode: "pane",
-          tabId,
-          panelId
-        })
-      );
-    });
-    return {
-      tabItems: items,
-      tabPanes: panes,
-      firstTabKey: firstKey,
-      tabKeys: keys,
-      enabledTabKeys: enabledKeys
-    };
-  }, [children, idBase]);
-  const activeKey = controlledActiveKey !== void 0 ? controlledActiveKey : internalActiveKey !== void 0 ? internalActiveKey : firstTabKey;
-  const activeTabIndex = useMemo(() => tabKeys.indexOf(activeKey ?? ""), [tabKeys, activeKey]);
-  const handleTabClick = useCallback(
-    (key) => {
-      onTabClick?.(key);
-      if (key === activeKey) {
-        return;
-      }
-      if (controlledActiveKey === void 0) {
-        setInternalActiveKey(key);
-      }
-      onActiveKeyChange?.(key);
-    },
-    [activeKey, controlledActiveKey, onActiveKeyChange, onTabClick]
-  );
-  const handleTabClose = useCallback(
-    (key, event) => {
-      event.stopPropagation();
-      if (controlledActiveKey === void 0 && key === activeKey) {
-        setInternalActiveKey(getNextActiveKey(key, activeKey, tabKeys));
-      }
-      onEdit?.({ targetKey: key, action: "remove" });
-    },
-    [onEdit, controlledActiveKey, activeKey, tabKeys]
-  );
-  const handleTabAdd = useCallback(() => {
-    onEdit?.({ targetKey: void 0, action: "add" });
-  }, [onEdit]);
-  const activateAdjacentTab = useCallback(
-    (direction) => {
-      if (enabledTabKeys.length <= 1) return;
-      const currentIndex = enabledTabKeys.indexOf(activeKey ?? enabledTabKeys[0]);
-      const baseIndex = currentIndex >= 0 ? currentIndex : 0;
-      const nextKey = enabledTabKeys[(baseIndex + direction + enabledTabKeys.length) % enabledTabKeys.length];
-      handleTabClick(nextKey);
-    },
-    [activeKey, enabledTabKeys, handleTabClick]
-  );
-  const handleContentTouchStart = useCallback(
-    (event) => {
-      if (!swipeable || event.touches.length !== 1) return;
-      swipeStartRef.current = getGestureTouchPoint(event.touches, event.timeStamp);
-    },
-    [swipeable]
-  );
-  const handleContentTouchEnd = useCallback(
-    (event) => {
-      if (!swipeable || !swipeStartRef.current || event.changedTouches.length !== 1) return;
-      const endPoint = getGestureTouchPoint(event.changedTouches, event.timeStamp);
-      const swipe = resolveSwipeGesture(swipeStartRef.current, endPoint, {
-        minDistance: 48,
-        maxCrossAxisRatio: 0.75
-      });
-      swipeStartRef.current = null;
-      if (!swipe) return;
-      if (swipe.direction === "left") activateAdjacentTab(1);
-      if (swipe.direction === "right") activateAdjacentTab(-1);
-    },
-    [activateAdjacentTab, swipeable]
-  );
-  const contextValue = useMemo(
-    () => ({
-      activeKey,
-      type,
-      size,
-      tabPosition,
-      closable,
-      destroyInactiveTabPane,
-      lazy,
-      swipeable,
-      idBase,
-      labels,
-      handleTabClick,
-      handleTabClose
-    }),
-    [
-      activeKey,
-      type,
-      size,
-      tabPosition,
-      closable,
-      destroyInactiveTabPane,
-      lazy,
-      swipeable,
-      idBase,
-      labels,
-      handleTabClick,
-      handleTabClose
-    ]
-  );
-  const tabNavContent = /* @__PURE__ */ jsx(
-    "div",
-    {
-      className: tabNavClasses,
-      role: "tablist",
-      "aria-orientation": tabPosition === "left" || tabPosition === "right" ? "vertical" : "horizontal",
-      children: /* @__PURE__ */ jsxs(
-        "div",
-        {
-          className: tabNavListClasses,
-          style: getTabNavListStyle(type, tabPosition, tabKeys.length),
-          children: [
-            type === "line" && /* @__PURE__ */ jsx(
-              "div",
-              {
-                "data-tiger-tabs-indicator": "true",
-                "aria-hidden": "true",
-                className: getTabIndicatorClasses(type, tabPosition),
-                style: getTabIndicatorStyle(activeTabIndex, tabKeys.length, tabPosition)
-              }
-            ),
-            tabItems,
-            type === "editable-card" && /* @__PURE__ */ jsx(
-              "button",
-              {
-                type: "button",
-                className: tabAddButtonClasses,
-                onClick: handleTabAdd,
-                "aria-label": labels.addTabAriaLabel,
-                children: "+"
-              }
-            )
-          ]
-        }
-      )
-    }
-  );
-  const tabContent = /* @__PURE__ */ jsx(
-    "div",
-    {
-      className: tabContentBaseClasses,
-      onTouchStart: handleContentTouchStart,
-      onTouchEnd: handleContentTouchEnd,
-      onTouchCancel: () => {
-        swipeStartRef.current = null;
-      },
-      children: tabPanes
-    }
-  );
-  return /* @__PURE__ */ jsx(TabsContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx("div", { className: containerClasses, style, children: tabPosition === "bottom" ? /* @__PURE__ */ jsxs(Fragment, { children: [
-    tabContent,
-    tabNavContent
-  ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-    tabNavContent,
-    tabContent
-  ] }) }) });
-};
-
-export {
-  useTabsContext,
-  TabPane,
-  Tabs
-};

package/dist/types-0oVwMXtR.d.mts

@@ -1,33 +0,0 @@
-import { TableProps as TableProps$1, SortState } from '@expcat/tigercat-core';
-
-/**
- * Public React Table prop interface — extends shared core contract with
- * React-style event callbacks and className support.
- */
-interface TableProps<T = Record<string, unknown>> extends TableProps$1<T> {
-    onChange?: (params: {
-        sort: SortState;
-        filters: Record<string, unknown>;
-        pagination: {
-            current: number;
-            pageSize: number;
-        } | null;
-    }) => void;
-    onRowClick?: (record: T, index: number) => void;
-    onSelectionChange?: (selectedKeys: (string | number)[]) => void;
-    onSortChange?: (sort: SortState) => void;
-    onFilterChange?: (filters: Record<string, unknown>) => void;
-    onHiddenColumnKeysChange?: (hiddenKeys: string[]) => void;
-    onPageChange?: (page: {
-        current: number;
-        pageSize: number;
-    }) => void;
-    onExpandChange?: (expandedKeys: (string | number)[], record: T, expanded: boolean) => void;
-    onCellChange?: (rowIndex: number, columnKey: string, newValue: string) => void;
-    onColumnOrderChange?: (columns: TableProps$1<T>['columns']) => void;
-    onRowOrderChange?: (rows: T[]) => void;
-    onExport?: (csv: string) => void;
-    className?: string;
-}
-
-export type { TableProps as T };