@qsxy/element-plus-react 1.0.0-next.1

package/dist/Tabs/Tabs.js

@@ -0,0 +1,279 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tabs/Tabs.tsx
+var Tabs_exports = {};
+__export(Tabs_exports, {
+  default: () => Tabs_default
+});
+module.exports = __toCommonJS(Tabs_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_dom_lib = require("dom-lib");
+var import_forEach = __toESM(require("lodash/forEach"));
+var import_omit = __toESM(require("lodash/omit"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var import_TabsContext = require("./TabsContext");
+var Tabs = (0, import_react.forwardRef)((props, ref) => {
+  const { type, tabPosition, stretch, classPrefix = "tabs", children, onTabClick, beforeLeave, center, editable, addable, closable, onTabRemove } = props;
+  const [activeName, setActiveName] = (0, import_hooks.useControlled)(props.activeName, props.defaultActiveName);
+  const { b, m, e, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const navRef = (0, import_react.useRef)(null);
+  const navScrollRef = (0, import_react.useRef)(null);
+  const elRef = (0, import_react.useRef)(null);
+  const activeBarRef = (0, import_react.useRef)(null);
+  const scrollable = (0, import_react.useRef)(false);
+  const scrollLeftRef = (0, import_react.useRef)(null);
+  const scrollRightRef = (0, import_react.useRef)(null);
+  const [isScroll, setIsScroll] = (0, import_react.useState)(false);
+  const [navOffset, setNavOffset] = (0, import_react.useState)(0);
+  const sizeName = (0, import_react.useMemo)(() => tabPosition && ["top", "bottom"].includes(tabPosition) ? "offsetWidth" : "offsetHeight", [tabPosition]);
+  const navStyle = (0, import_react.useMemo)(() => {
+    const dir = sizeName === "offsetWidth" ? "X" : "Y";
+    return {
+      transform: `translate${dir}(-${navOffset}px)`
+    };
+  }, [navOffset, sizeName]);
+  const getTabPaneInstance = (0, import_hooks.useChildrenInstance)("TabPane");
+  const navs = (0, import_react.useMemo)(() => {
+    const componentChildren = getTabPaneInstance(children);
+    return componentChildren.map((node, i) => {
+      return {
+        title: node.props.title,
+        name: node.props.name,
+        index: i,
+        active: (0, import_Util.isEmpty)(activeName) ? i === 0 : activeName === node.props.name,
+        disabled: node.props.disabled,
+        closable: node.props.closable === false ? false : node.props.closable || closable || editable,
+        props: (0, import_omit.default)(node.props, "children")
+      };
+    });
+  }, [getTabPaneInstance, children, activeName, closable, editable]);
+  const scrollPrev = (0, import_react.useCallback)(() => {
+    if (!navScrollRef.current) {
+      return;
+    }
+    const containerSize = navScrollRef.current[sizeName];
+    const currentOffset = navOffset;
+    if (!currentOffset) {
+      return;
+    }
+    const newOffset = currentOffset > containerSize ? currentOffset - containerSize : 0;
+    setNavOffset(newOffset);
+  }, [sizeName, navOffset]);
+  const scrollNext = (0, import_react.useCallback)(() => {
+    if (!navScrollRef.current || !navRef.current) {
+      return;
+    }
+    const navSize = navRef.current[sizeName];
+    const containerSize = navScrollRef.current[sizeName];
+    const currentOffset = navOffset;
+    if (navSize - currentOffset <= containerSize) {
+      return;
+    }
+    const newOffset = navSize - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize - containerSize;
+    setNavOffset(newOffset);
+  }, [sizeName, navOffset]);
+  const scrollToActiveTab = (0, import_react.useCallback)(() => {
+    const nav = navRef.current;
+    if (!scrollable.current || !elRef.current || !navScrollRef.current || !nav) {
+      return;
+    }
+    const activeTab = elRef.current.querySelector(".is-active");
+    if (!activeTab) {
+      return;
+    }
+    const navScroll = navScrollRef.current;
+    const isHorizontal = tabPosition && ["top", "bottom"].includes(tabPosition);
+    const activeTabBounding = activeTab.getBoundingClientRect();
+    const navScrollBounding = navScroll.getBoundingClientRect();
+    const maxOffset = isHorizontal ? nav.offsetWidth - navScrollBounding.width : nav.offsetHeight - navScrollBounding.height;
+    const currentOffset = navOffset;
+    let newOffset = currentOffset;
+    if (isHorizontal) {
+      if (activeTabBounding.left < navScrollBounding.left) {
+        newOffset = currentOffset - (navScrollBounding.left - activeTabBounding.left);
+      }
+      if (activeTabBounding.right > navScrollBounding.right) {
+        newOffset = currentOffset + activeTabBounding.right - navScrollBounding.right;
+      }
+    } else {
+      if (activeTabBounding.top < navScrollBounding.top) {
+        newOffset = currentOffset - (navScrollBounding.top - activeTabBounding.top);
+      }
+      if (activeTabBounding.bottom > navScrollBounding.bottom) {
+        newOffset = currentOffset + (activeTabBounding.bottom - navScrollBounding.bottom);
+      }
+    }
+    newOffset = Math.max(newOffset, 0);
+    setNavOffset(Math.min(newOffset, maxOffset));
+  }, [tabPosition, scrollable, navOffset]);
+  const update = (0, import_react.useCallback)(() => {
+    if (!navRef.current || !navScrollRef.current) {
+      return;
+    }
+    const navSize = navRef.current[sizeName];
+    const containerSize = navScrollRef.current[sizeName];
+    const currentOffset = navOffset;
+    if (containerSize < navSize) {
+      const _currentOffset = navOffset;
+      scrollable.current = {
+        prev: _currentOffset,
+        next: _currentOffset + containerSize < navSize
+      };
+      if (scrollLeftRef.current) {
+        (scrollable.current.prev === 0 ? import_dom_lib.addClass : import_dom_lib.removeClass)(scrollLeftRef.current, is("disabled"));
+      }
+      if (scrollRightRef.current) {
+        (scrollable.current.next ? import_dom_lib.removeClass : import_dom_lib.addClass)(scrollRightRef.current, is("disabled"));
+      }
+      setIsScroll(true);
+      if (navSize - _currentOffset < containerSize) {
+        setNavOffset(navSize - containerSize);
+      }
+    } else {
+      scrollable.current = false;
+      setIsScroll(false);
+      if (currentOffset > 0) {
+        setNavOffset(0);
+      }
+    }
+  }, [sizeName, navOffset, is]);
+  const getBarStyle = (0, import_react.useCallback)(() => {
+    var _a;
+    let offset = 0;
+    let tabSize = 0;
+    const sizeDir = sizeName === "offsetWidth" ? "X" : "Y";
+    (0, import_forEach.default)((_a = elRef.current) == null ? void 0 : _a.querySelectorAll(".r-tabs__item"), (el) => {
+      var _a2;
+      if ((0, import_dom_lib.hasClass)(el, "is-active")) {
+        tabSize = el[sizeName === "offsetWidth" ? "clientWidth" : "clientHeight"];
+        const position = sizeDir === "X" ? "left" : "top";
+        offset = el.getBoundingClientRect()[position] - (((_a2 = el.parentElement) == null ? void 0 : _a2.getBoundingClientRect()[position]) ?? 0);
+        const tabStyles = window.getComputedStyle(el);
+        if (sizeName === "offsetWidth") {
+          if (import_react.Children.count(children) > 1) {
+            tabSize -= parseFloat(tabStyles.paddingLeft) + parseFloat(tabStyles.paddingRight);
+          }
+          offset += parseFloat(tabStyles.paddingLeft);
+        }
+        return true;
+      }
+    });
+    if (activeBarRef.current) {
+      (0, import_dom_lib.addStyle)(activeBarRef.current, {
+        [sizeName === "offsetWidth" ? "width" : "height"]: `${tabSize}px`,
+        transform: `translate${sizeDir}(${offset}px)`
+      });
+    }
+  }, [sizeName, children]);
+  const changeCurrentName = (0, import_react.useCallback)(
+    (item) => {
+      setActiveName(item == null ? void 0 : item.name);
+      onTabClick == null ? void 0 : onTabClick({
+        paneName: item == null ? void 0 : item.name,
+        active: item == null ? void 0 : item.active,
+        index: item == null ? void 0 : item.index,
+        isClosable: (item == null ? void 0 : item.closable) ?? false,
+        props: item.props
+      });
+    },
+    [onTabClick, setActiveName]
+  );
+  const handleTabClick = (0, import_react.useCallback)(
+    (item) => {
+      if ((item == null ? void 0 : item.disabled) || (item == null ? void 0 : item.name) === activeName) {
+        return;
+      }
+      const canLeave = beforeLeave == null ? void 0 : beforeLeave(item.name, activeName);
+      if (canLeave instanceof Promise) {
+        canLeave.then(() => {
+          changeCurrentName(item);
+        });
+      } else if (canLeave !== false) {
+        changeCurrentName(item);
+      }
+    },
+    [activeName, beforeLeave, changeCurrentName]
+  );
+  (0, import_react.useEffect)(() => {
+    update();
+    if ((0, import_Util.isEmpty)(type)) {
+      getBarStyle();
+    }
+  }, [activeName, tabPosition, type, navOffset, navs]);
+  (0, import_react.useEffect)(() => {
+    setTimeout(() => scrollToActiveTab(), 0);
+  }, [activeName, tabPosition, type]);
+  (0, import_react.useEffect)(() => {
+    if ((0, import_Util.isEmpty)(activeName) && navs.length > 0) {
+      setActiveName(navs[0].name);
+    }
+  }, []);
+  const header = /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(e`header`, is(tabPosition)) }, /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(e`nav-wrap`, is(tabPosition, { scrollable: isScroll })), ref: elRef }, isScroll && /* @__PURE__ */ import_react.default.createElement("span", { ref: scrollLeftRef, className: (0, import_classnames.default)(e`nav-prev`, is("disabled")), onClick: scrollPrev }, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "angle-left" })), isScroll && /* @__PURE__ */ import_react.default.createElement("span", { ref: scrollRightRef, className: (0, import_classnames.default)(e`nav-next`), onClick: scrollNext }, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "angle-right" })), /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(e`nav-scroll`, is({ center })), style: props.headerStyle, ref: navScrollRef }, /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      className: (0, import_classnames.default)(e`nav`, is(tabPosition, { stretch: stretch && tabPosition && ["top", "bottom"].includes(tabPosition) })),
+      style: navStyle,
+      ref: navRef
+    },
+    (0, import_Util.isEmpty)(type) && /* @__PURE__ */ import_react.default.createElement("div", { ref: activeBarRef, className: (0, import_classnames.default)(e`active-bar`, is(tabPosition)) }),
+    navs.map((item) => {
+      const { active, disabled } = item;
+      return /* @__PURE__ */ import_react.default.createElement(
+        "div",
+        {
+          key: item.name,
+          className: (0, import_classnames.default)(e`item`, is(tabPosition, { active, disabled, closable: item.closable && !disabled })),
+          onClick: () => handleTabClick(item)
+        },
+        /* @__PURE__ */ import_react.default.createElement("div", null, item == null ? void 0 : item.title, item.closable && !item.disabled && /* @__PURE__ */ import_react.default.createElement(
+          import_Icon.Icon,
+          {
+            name: "close",
+            className: is`icon-close`,
+            onClick: (event) => {
+              event.stopPropagation();
+              onTabRemove == null ? void 0 : onTabRemove(item.name);
+            }
+          }
+        ))
+      );
+    }),
+    (addable || editable) && /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(e`item`, is(tabPosition)), style: { padding: "0 10px" }, onClick: props.onTabAdd }, /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "plus" }))
+  ))));
+  const content = /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(e`content`), style: props.contentStyle }, props.children);
+  return /* @__PURE__ */ import_react.default.createElement(import_TabsContext.TabsContext.Provider, { value: { activeName } }, /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b(), m(tabPosition), { [m(type)]: type }, props.className), style: props.style, ref }, tabPosition === "bottom" ? content : header, tabPosition === "bottom" ? header : content));
+});
+Tabs.defaultProps = {
+  tabPosition: "top"
+};
+Tabs.displayName = "Tabs";
+var Tabs_default = Tabs;

package/dist/Tabs/TabsContext.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export interface TabsContextProps {
+    activeName: string | number;
+}
+export declare const TabsContext: import("react").Context<TabsContextProps>;

package/dist/Tabs/TabsContext.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tabs/TabsContext.ts
+var TabsContext_exports = {};
+__export(TabsContext_exports, {
+  TabsContext: () => TabsContext
+});
+module.exports = __toCommonJS(TabsContext_exports);
+var import_react = require("react");
+var TabsContext = (0, import_react.createContext)({
+  activeName: ""
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TabsContext
+});

package/dist/Tabs/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TabPane } from './TabPane';
+export { default as Tabs } from './Tabs';
+export type { TabPaneName, TabPaneProps, TabsPaneContext, TabsProps } from './typings';

package/dist/Tabs/index.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tabs/index.ts
+var Tabs_exports = {};
+__export(Tabs_exports, {
+  TabPane: () => import_TabPane.default,
+  Tabs: () => import_Tabs.default
+});
+module.exports = __toCommonJS(Tabs_exports);
+var import_TabPane = __toESM(require("./TabPane"));
+var import_Tabs = __toESM(require("./Tabs"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TabPane,
+  Tabs
+});

package/dist/Tabs/typings.d.ts

@@ -0,0 +1,54 @@
+import React from 'react';
+import { BaseProps, NativeProps } from '../types/common';
+export interface TabsProps extends BaseProps, NativeProps<'--el-tabs-header-height' | '--el-tabs-header-margin-bottom'> {
+    defaultActiveName?: TabPaneName;
+    activeName?: TabPaneName;
+    type?: 'card' | 'border-card' | null;
+    closable?: boolean;
+    addable?: boolean;
+    editable?: boolean;
+    tabPosition?: 'top' | 'right' | 'bottom' | 'left';
+    stretch?: boolean;
+    center?: boolean;
+    classPrefix?: string;
+    headerStyle?: React.CSSProperties;
+    contentStyle?: React.CSSProperties;
+    children?: React.ReactElement<TabPaneProps> | React.ReactElement<TabPaneProps>[];
+    beforeLeave?: (newTabName: TabPaneName, oldTabName: TabPaneName) => void | boolean | Promise<void | boolean>;
+    onTabClick?: (context: TabsPaneContext) => void;
+    onTabAdd?: () => void;
+    onTabRemove?: (name: TabPaneName | undefined) => void;
+    formatter?: (name: TabPaneName | undefined) => void;
+}
+export interface Navs {
+    title: string | React.ReactElement;
+    name: string;
+    index: number;
+    active: boolean;
+    disabled: boolean;
+    closable: boolean;
+    props: TabPaneProps;
+}
+export interface TabPaneProps extends BaseProps, NativeProps {
+    title: string | React.ReactElement;
+    name: string;
+    closable?: boolean;
+    disabled?: boolean;
+    lazy?: boolean;
+    classPrefix?: string;
+    onTabShow?: () => void;
+    onTabClose?: () => void;
+    data?: Record<TabPaneName, any>;
+}
+export interface Scrollable {
+    next?: boolean;
+    prev?: number;
+}
+export interface TabsPaneContext {
+    props: TabPaneProps;
+    paneName: TabPaneName | undefined;
+    active: boolean;
+    index: number;
+    isClosable: boolean;
+}
+export type TabPaneName = string | number;

package/dist/Tabs/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tabs/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Tag/Tag.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { TagProps } from './typings';
+declare const Tag: React.ForwardRefExoticComponent<TagProps & React.RefAttributes<HTMLSpanElement>>;
+export default Tag;

package/dist/Tag/Tag.js

@@ -0,0 +1,76 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tag/Tag.tsx
+var Tag_exports = {};
+__export(Tag_exports, {
+  default: () => Tag_default
+});
+module.exports = __toCommonJS(Tag_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_Transition = require("../Transition");
+var import_hooks = require("../hooks");
+var Tag = (0, import_react.forwardRef)((props, ref) => {
+  const { type, closable, size, color, theme, round, hit, classPrefix = "tag", className, style, onClick, onClose, disableTransitions } = props;
+  const { b, m, e, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const onClickTag = (0, import_react.useCallback)(
+    (event) => {
+      event == null ? void 0 : event.stopPropagation();
+      onClick == null ? void 0 : onClick(event);
+    },
+    [onClick]
+  );
+  const onCloseTag = (0, import_react.useCallback)(
+    (event) => {
+      event == null ? void 0 : event.stopPropagation();
+      onClose == null ? void 0 : onClose(event);
+    },
+    [onClose]
+  );
+  return /* @__PURE__ */ import_react.default.createElement(import_Transition.Transition, { name: disableTransitions ? "" : "r-zoom-in-center", visible: true, display: "", transitionAppear: true, unmountOnExit: true, duration: 200 }, /* @__PURE__ */ import_react.default.createElement(
+    "span",
+    {
+      ref,
+      className: (0, import_classnames.default)(b(), m(type, theme, { [size]: size }), is({ round, hit }), className),
+      style: { background: color, ...style },
+      onClick: onClickTag,
+      onMouseEnter: props.onMouseEnter,
+      onMouseLeave: props.onMouseLeave
+    },
+    /* @__PURE__ */ import_react.default.createElement("span", { className: e`content` }, props.children),
+    closable && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "xmark", className: e`close`, onClick: onCloseTag })
+  ));
+});
+Tag.defaultProps = {
+  type: "primary",
+  theme: "light"
+};
+Tag.displayName = "Tag";
+var Tag_default = Tag;

package/dist/Tag/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Tag } from './Tag';
+export type { TagProps } from './typings';

package/dist/Tag/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tag/index.ts
+var Tag_exports = {};
+__export(Tag_exports, {
+  Tag: () => import_Tag.default
+});
+module.exports = __toCommonJS(Tag_exports);
+var import_Tag = __toESM(require("./Tag"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tag
+});

package/dist/Tag/typings.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { BaseProps, NativeProps, TooltipBaseProps, TypeAttributes } from '../types/common';
+export interface TagProps extends Omit<TooltipBaseProps<HTMLSpanElement>, 'onClick'>, BaseProps, NativeProps {
+    type?: TypeAttributes.Appearance;
+    closable?: boolean;
+    disableTransitions?: boolean;
+    hit?: boolean;
+    round?: boolean;
+    color?: string;
+    size?: TypeAttributes.Size;
+    theme?: 'dark' | 'light' | 'plain';
+    onClick?: (e?: React.MouseEvent<HTMLSpanElement>) => void;
+    onClose?: (e?: React.MouseEvent<HTMLSpanElement>) => void;
+}

package/dist/Tag/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Tag/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/TimeLine/TimeLine.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TimeLineProps } from './typings';
+declare const TimeLine: FC<TimeLineProps>;
+export default TimeLine;

package/dist/TimeLine/TimeLine.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TimeLine/TimeLine.tsx
+var TimeLine_exports = {};
+__export(TimeLine_exports, {
+  default: () => TimeLine_default
+});
+module.exports = __toCommonJS(TimeLine_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_hooks = require("../hooks");
+var TimeLine = (props) => {
+  const { classPrefix = "timeline" } = props;
+  const { b } = (0, import_hooks.useClassNames)(classPrefix);
+  return /* @__PURE__ */ import_react.default.createElement("ul", { className: (0, import_classnames.default)(b(), props.className), style: props.style }, props.children);
+};
+var TimeLine_default = TimeLine;

package/dist/TimeLine/TimeLineItem.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TimeLineItemProps } from './typings';
+declare const TimeLineItem: FC<TimeLineItemProps>;
+export default TimeLineItem;