@bifrostui/react 2.0.0-alpha.3 → 2.0.0-alpha.30

package/dist/Tabs/miniapp/TabIndicator.js

@@ -0,0 +1,301 @@
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var TabIndicator_exports = {};
+__export(TabIndicator_exports, {
+  default: () => TabIndicator_default
+});
+module.exports = __toCommonJS(TabIndicator_exports);
+var import_react = __toESM(require("react"));
+var import_clsx = __toESM(require("clsx"));
+var import_taro = __toESM(require("@tarojs/taro"));
+var import_utils = require("@bifrostui/utils");
+var import_classes = require("../classes");
+var import_queryBatch = require("./utils/queryBatch");
+const isValidTabValue = (value) => {
+  return value !== void 0 && value !== null;
+};
+const TabIndicator = ({
+  currentValue,
+  registeredTabValues,
+  wrapperId,
+  scrollViewId,
+  registrationVersion
+}) => {
+  const indicatorRef = (0, import_react.useRef)(null);
+  const animationTimerRef = (0, import_react.useRef)(null);
+  const positionCacheRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const containerInfoRef = (0, import_react.useRef)(null);
+  const indicatorWidthRef = (0, import_react.useRef)(24);
+  const isInitializedRef = (0, import_react.useRef)(false);
+  const initRetryCountRef = (0, import_react.useRef)(0);
+  const maxInitRetries = 5;
+  const isInitializingRef = (0, import_react.useRef)(false);
+  const initVersionRef = (0, import_react.useRef)(0);
+  const isMountedRef = (0, import_react.useRef)(true);
+  const updateIndicatorPosition = (0, import_utils.useEventCallback)(() => {
+    const indicator = indicatorRef.current;
+    if (!indicator)
+      return;
+    if (!isValidTabValue(currentValue) || !registeredTabValues.includes(currentValue)) {
+      indicator.style.opacity = "0";
+      return;
+    }
+    const cachedPosition = positionCacheRef.current.get(currentValue);
+    const containerInfo = containerInfoRef.current;
+    if (!cachedPosition || !containerInfo || !isInitializedRef.current) {
+      if (!isInitializedRef.current) {
+        initializePositions();
+      }
+      return;
+    }
+    const activeTabLeft = cachedPosition.left;
+    const activeTabWidth = cachedPosition.width;
+    const indicatorWidth = indicatorWidthRef.current;
+    const x = activeTabLeft + (activeTabWidth - indicatorWidth) / 2;
+    indicator.style.transform = `translate(${x}px, 0px)`;
+    indicator.style.opacity = "1";
+  });
+  const initializePositions = (0, import_utils.useEventCallback)(() => __async(void 0, null, function* () {
+    if (!isMountedRef.current)
+      return;
+    if (isInitializingRef.current)
+      return;
+    isInitializingRef.current = true;
+    initVersionRef.current += 1;
+    const currentVersion = initVersionRef.current;
+    try {
+      const result = yield (0, import_queryBatch.batchQueryTabs)({
+        scrollViewId,
+        wrapperId,
+        tabValues: registeredTabValues
+      });
+      if (!isMountedRef.current)
+        return;
+      if (currentVersion !== initVersionRef.current)
+        return;
+      const { scrollView, scrollFields, wrapper, indicator, tabs } = result;
+      if (!scrollView || !wrapper || !indicator || !scrollFields) {
+        if (initRetryCountRef.current < maxInitRetries) {
+          initRetryCountRef.current += 1;
+          if (animationTimerRef.current) {
+            clearTimeout(animationTimerRef.current);
+          }
+          animationTimerRef.current = setTimeout(() => {
+            if (!isMountedRef.current)
+              return;
+            isInitializingRef.current = false;
+            initializePositions();
+          }, 100);
+        } else {
+          isInitializingRef.current = false;
+        }
+        return;
+      }
+      if (!indicator.width || indicator.width <= 0) {
+        if (initRetryCountRef.current < maxInitRetries) {
+          initRetryCountRef.current += 1;
+          if (animationTimerRef.current) {
+            clearTimeout(animationTimerRef.current);
+          }
+          animationTimerRef.current = setTimeout(() => {
+            if (!isMountedRef.current)
+              return;
+            isInitializingRef.current = false;
+            initializePositions();
+          }, 100);
+        } else {
+          isInitializingRef.current = false;
+        }
+        return;
+      }
+      containerInfoRef.current = {
+        width: scrollView.width,
+        scrollWidth: scrollFields.scrollWidth || scrollView.width
+      };
+      indicatorWidthRef.current = indicator.width;
+      const newCache = /* @__PURE__ */ new Map();
+      registeredTabValues.forEach((value, index) => {
+        const tabRect = tabs[index];
+        if (tabRect && tabRect.width > 0) {
+          newCache.set(value, {
+            left: tabRect.left - wrapper.left,
+            width: tabRect.width
+          });
+        }
+      });
+      if (newCache.size < registeredTabValues.length) {
+        if (initRetryCountRef.current < maxInitRetries) {
+          initRetryCountRef.current += 1;
+          if (animationTimerRef.current) {
+            clearTimeout(animationTimerRef.current);
+          }
+          animationTimerRef.current = setTimeout(() => {
+            if (!isMountedRef.current)
+              return;
+            isInitializingRef.current = false;
+            initializePositions();
+          }, 100);
+        } else {
+          isInitializingRef.current = false;
+        }
+        return;
+      }
+      if (currentVersion !== initVersionRef.current || !isMountedRef.current) {
+        return;
+      }
+      initRetryCountRef.current = 0;
+      positionCacheRef.current = newCache;
+      isInitializedRef.current = true;
+      isInitializingRef.current = false;
+      updateIndicatorPosition();
+    } catch (error) {
+      console.error("[TabIndicator] \u6279\u91CF\u67E5\u8BE2\u5931\u8D25:", error);
+      isInitializingRef.current = false;
+      if (isMountedRef.current && initRetryCountRef.current < maxInitRetries) {
+        initRetryCountRef.current += 1;
+        if (animationTimerRef.current) {
+          clearTimeout(animationTimerRef.current);
+        }
+        animationTimerRef.current = setTimeout(() => {
+          if (!isMountedRef.current)
+            return;
+          initializePositions();
+        }, 100);
+      }
+    }
+  }));
+  (0, import_react.useEffect)(() => {
+    if (registeredTabValues.length === 0) {
+      if (indicatorRef.current) {
+        indicatorRef.current.style.opacity = "0";
+      }
+      return void 0;
+    }
+    initVersionRef.current += 1;
+    if (animationTimerRef.current) {
+      clearTimeout(animationTimerRef.current);
+      animationTimerRef.current = null;
+    }
+    isInitializedRef.current = false;
+    isInitializingRef.current = false;
+    initRetryCountRef.current = 0;
+    import_taro.default.nextTick(() => {
+      if (!isMountedRef.current)
+        return;
+      initializePositions();
+    });
+    return () => {
+      if (animationTimerRef.current) {
+        clearTimeout(animationTimerRef.current);
+        animationTimerRef.current = null;
+      }
+      initVersionRef.current += 1;
+      isInitializingRef.current = false;
+    };
+  }, [registrationVersion, initializePositions]);
+  (0, import_react.useEffect)(() => {
+    if (!isValidTabValue(currentValue)) {
+      if (indicatorRef.current) {
+        indicatorRef.current.style.opacity = "0";
+      }
+      return;
+    }
+    updateIndicatorPosition();
+  }, [currentValue, updateIndicatorPosition]);
+  (0, import_react.useEffect)(() => {
+    var _a, _b;
+    const handleResize = () => {
+      if (!isMountedRef.current)
+        return;
+      initVersionRef.current += 1;
+      isInitializedRef.current = false;
+      isInitializingRef.current = false;
+      initRetryCountRef.current = 0;
+      positionCacheRef.current.clear();
+      if (animationTimerRef.current) {
+        clearTimeout(animationTimerRef.current);
+        animationTimerRef.current = null;
+      }
+      import_taro.default.nextTick(() => {
+        if (!isMountedRef.current)
+          return;
+        initializePositions();
+      });
+    };
+    (_b = (_a = import_taro.default).onWindowResize) == null ? void 0 : _b.call(_a, handleResize);
+    return () => {
+      var _a2, _b2;
+      (_b2 = (_a2 = import_taro.default).offWindowResize) == null ? void 0 : _b2.call(_a2, handleResize);
+    };
+  }, [initializePositions]);
+  (0, import_react.useEffect)(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (animationTimerRef.current) {
+        clearTimeout(animationTimerRef.current);
+        animationTimerRef.current = null;
+      }
+    };
+  }, []);
+  return /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      ref: indicatorRef,
+      id: `${wrapperId}-indicator`,
+      className: (0, import_clsx.default)(import_classes.tabIndicatorClass),
+      style: {
+        transition: "transform 0.3s ease-in-out, opacity 0.3s ease-in-out",
+        transform: "translate(0px, 0px)",
+        opacity: 0
+      }
+    }
+  );
+};
+TabIndicator.displayName = "BuiTabsIndicator";
+var TabIndicator_default = TabIndicator;

package/dist/Tabs/miniapp/Tabs.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { TabsProps } from '../Tabs.types';
+import '../Tabs.less';
+declare const Tabs: React.ForwardRefExoticComponent<Omit<TabsProps<"div", {}>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export default Tabs;

package/dist/Tabs/miniapp/Tabs.js

@@ -0,0 +1,250 @@
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var Tabs_exports = {};
+__export(Tabs_exports, {
+  default: () => Tabs_default
+});
+module.exports = __toCommonJS(Tabs_exports);
+var import_react = __toESM(require("react"));
+var import_clsx = __toESM(require("clsx"));
+var import_taro = __toESM(require("@tarojs/taro"));
+var import_components = require("@tarojs/components");
+var import_utils = require("@bifrostui/utils");
+var import_Tab = __toESM(require("./Tab"));
+var import_TabIndicator = __toESM(require("./TabIndicator"));
+var import_TabMask = __toESM(require("../TabMask"));
+var import_TabsContext = require("./TabsContext");
+var import_classes = require("../classes");
+var import_queryBatch = require("./utils/queryBatch");
+var import_Tabs2 = require("../Tabs.css");
+const Tabs = /* @__PURE__ */ import_react.default.forwardRef((props, ref) => {
+  const {
+    children,
+    className,
+    value,
+    defaultValue,
+    tabs = [],
+    onChange,
+    style
+  } = props;
+  const handleOnChange = (0, import_utils.useEventCallback)(
+    (e, data) => {
+      onChange == null ? void 0 : onChange(e, { index: data.value });
+    }
+  );
+  const [currentValue, triggerValueChange] = (0, import_utils.useValue)({
+    value,
+    defaultValue: defaultValue != null ? defaultValue : "",
+    onChange: handleOnChange,
+    config: {
+      name: "Tabs",
+      state: "value"
+    }
+  });
+  const tabsContainerId = (0, import_react.useMemo)(
+    () => `bui-tabs-${Math.random().toString(36).slice(2, 11)}`,
+    []
+  );
+  const scrollViewId = `${tabsContainerId}-scroll`;
+  const wrapperId = `${tabsContainerId}-wrapper`;
+  const [registeredTabValues, setRegisteredTabValues] = (0, import_react.useState)([]);
+  const [registrationVersion, setRegistrationVersion] = (0, import_react.useState)(0);
+  const [scrollLeft, setScrollLeft] = (0, import_react.useState)(0);
+  const [containerWidth, setContainerWidth] = (0, import_react.useState)(0);
+  const [scrollWidth, setScrollWidth] = (0, import_react.useState)(0);
+  const lastScrollLeftRef = import_react.default.useRef(0);
+  const isFirstScroll = import_react.default.useRef(true);
+  const [scrollWithAnimation, setScrollWithAnimation] = import_react.default.useState(false);
+  const isScrollable = scrollWidth - containerWidth > 1;
+  if (process.env.NODE_ENV !== "production") {
+    if (tabs.length > 0 && import_react.default.Children.count(children) > 0) {
+      console.warn(
+        "BUI Warning: Tabs \u7EC4\u4EF6\u4E0D\u5E94\u8BE5\u540C\u65F6\u4F7F\u7528 tabs \u5C5E\u6027\u548C children\u3002\u8BF7\u53EA\u4F7F\u7528\u5176\u4E2D\u4E00\u79CD\u65B9\u5F0F\u3002\u5F53\u524D\u5C06\u4F18\u5148\u4F7F\u7528 tabs \u5C5E\u6027\uFF0Cchildren \u5C06\u88AB\u5FFD\u7565\u3002"
+      );
+    }
+  }
+  const onRegister = (0, import_utils.useEventCallback)((data) => {
+    if (data.value !== void 0 && data.value !== null) {
+      setRegisteredTabValues((prev) => {
+        if (prev.includes(data.value))
+          return prev;
+        const newValues = [...prev, data.value];
+        return newValues;
+      });
+      setRegistrationVersion((v) => v + 1);
+    }
+  });
+  const onUnregister = (0, import_utils.useEventCallback)((data) => {
+    setRegisteredTabValues((prev) => {
+      const newValues = prev.filter((v) => v !== data.value);
+      return newValues;
+    });
+    setRegistrationVersion((v) => v + 1);
+  });
+  const handleClick = (0, import_utils.useEventCallback)(
+    (e, item) => {
+      const { index, disabled = false } = item;
+      if (disabled || [void 0, null].includes(index))
+        return;
+      if (index !== currentValue) {
+        triggerValueChange(e, index);
+      }
+    }
+  );
+  const handleScroll = (0, import_utils.useEventCallback)(
+    (e) => {
+      const { scrollLeft: newScrollLeft, scrollWidth: newScrollWidth } = e.detail;
+      lastScrollLeftRef.current = newScrollLeft;
+      if (newScrollWidth && newScrollWidth !== scrollWidth) {
+        setScrollWidth(newScrollWidth);
+      }
+    }
+  );
+  import_react.default.useEffect(() => {
+    if (!scrollViewId || registeredTabValues.length === 0)
+      return;
+    import_taro.default.nextTick(() => __async(void 0, null, function* () {
+      const { rect, fields } = yield (0, import_queryBatch.batchQueryContainerSize)(scrollViewId);
+      if (rect) {
+        setContainerWidth(rect.width);
+      }
+      if (fields) {
+        setScrollWidth(fields.scrollWidth || 0);
+      }
+    }));
+  }, [scrollViewId, registrationVersion, registeredTabValues.length]);
+  const centerActiveTab = (0, import_utils.useEventCallback)(() => __async(void 0, null, function* () {
+    if (!currentValue || registeredTabValues.length === 0) {
+      return;
+    }
+    const { scrollView, scrollFields, wrapper, currentTab } = yield (0, import_queryBatch.batchQueryForScroll)({
+      scrollViewId,
+      wrapperId,
+      currentTabValue: currentValue
+    });
+    if (!scrollView || !scrollFields || !wrapper || !currentTab || currentTab.width === 0) {
+      return;
+    }
+    const tabLeftRelativeToWrapper = currentTab.left - wrapper.left;
+    const tabWidth = currentTab.width;
+    const containerViewWidth = scrollView.width;
+    const currentScrollWidth = scrollFields.scrollWidth || scrollView.width;
+    const targetScrollLeft = tabLeftRelativeToWrapper - (containerViewWidth - tabWidth) / 2;
+    const maxScrollDistance = currentScrollWidth - containerViewWidth;
+    const finalScrollLeft = Math.max(
+      0,
+      Math.min(targetScrollLeft, maxScrollDistance)
+    );
+    setScrollLeft(finalScrollLeft);
+    lastScrollLeftRef.current = finalScrollLeft;
+    if (isFirstScroll.current) {
+      import_taro.default.nextTick(() => {
+        setScrollWithAnimation(true);
+      });
+      isFirstScroll.current = false;
+    }
+  }));
+  import_react.default.useEffect(() => {
+    if (!currentValue || registeredTabValues.length === 0) {
+      return;
+    }
+    import_taro.default.nextTick(() => {
+      centerActiveTab();
+    });
+  }, [currentValue, centerActiveTab]);
+  import_react.default.useEffect(() => {
+    if (!currentValue || registeredTabValues.length === 0) {
+      return;
+    }
+    import_taro.default.nextTick(() => {
+      centerActiveTab();
+    });
+  }, [registrationVersion, centerActiveTab]);
+  const contextValue = (0, import_react.useMemo)(
+    () => ({
+      value: currentValue,
+      triggerChange: handleClick,
+      onRegister,
+      onUnregister,
+      tabsContainerId: wrapperId
+    }),
+    [currentValue, handleClick, onRegister, onUnregister, wrapperId]
+  );
+  const renderedTabs = (0, import_react.useMemo)(() => {
+    if (tabs.length > 0) {
+      return tabs.map((item) => /* @__PURE__ */ import_react.default.createElement(import_Tab.default, { key: item.index, index: item == null ? void 0 : item.index, disabled: item == null ? void 0 : item.disabled }, item.title));
+    }
+    return children;
+  }, [tabs, children]);
+  return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_clsx.default)(import_classes.tabsRootClass, className), style, ref }, isScrollable && /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, /* @__PURE__ */ import_react.default.createElement(import_TabMask.default, { position: "left" }), /* @__PURE__ */ import_react.default.createElement(import_TabMask.default, { position: "right" })), /* @__PURE__ */ import_react.default.createElement(
+    import_components.ScrollView,
+    {
+      id: scrollViewId,
+      className: import_classes.tabsScrollClass,
+      scrollX: true,
+      scrollWithAnimation,
+      scrollLeft,
+      onScroll: handleScroll,
+      enhanced: true,
+      showScrollbar: false,
+      enablePassive: true
+    },
+    /* @__PURE__ */ import_react.default.createElement("div", { id: wrapperId, className: import_classes.tabsScrollWrapperClass }, /* @__PURE__ */ import_react.default.createElement(
+      import_TabIndicator.default,
+      {
+        currentValue,
+        registeredTabValues,
+        wrapperId,
+        scrollViewId,
+        registrationVersion
+      }
+    ), /* @__PURE__ */ import_react.default.createElement(import_TabsContext.TabsContextProvider, { value: contextValue }, renderedTabs))
+  ));
+});
+Tabs.displayName = "BuiTabs";
+var Tabs_default = Tabs;

package/dist/Tabs/miniapp/TabsContext.d.ts

@@ -0,0 +1,17 @@
+import { TabChangeEvent } from '../Tabs.types';
+export interface TabRegisterData {
+    value: string;
+}
+export interface TabsContextValueType {
+    value?: string;
+    triggerChange?: TabChangeEvent;
+    onRegister?: (data: TabRegisterData) => void;
+    onUnregister?: (data: {
+        value: string;
+    }) => void;
+    /** 容器的唯一ID，用于生成子元素ID */
+    tabsContainerId?: string;
+}
+declare const TabsContext: import("@bifrostui/utils").Context<TabsContextValueType>;
+export declare const TabsContextProvider: import("react").Provider<TabsContextValueType> & import("react").FC<import("react").ProviderProps<TabsContextValueType>>;
+export default TabsContext;

package/dist/Tabs/miniapp/TabsContext.js

@@ -0,0 +1,39 @@
+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);
+var TabsContext_exports = {};
+__export(TabsContext_exports, {
+  TabsContextProvider: () => TabsContextProvider,
+  default: () => TabsContext_default
+});
+module.exports = __toCommonJS(TabsContext_exports);
+var import_utils = require("@bifrostui/utils");
+const TabsContext = (0, import_utils.createContext)({
+  triggerChange: void 0,
+  onRegister: void 0,
+  onUnregister: void 0,
+  tabsContainerId: void 0
+});
+if (process.env.NODE_ENV !== "production") {
+  TabsContext.displayName = "BuiTabsContext";
+}
+const TabsContextProvider = TabsContext.Provider;
+var TabsContext_default = TabsContext;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TabsContextProvider
+});

package/dist/Tabs/miniapp/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Tab } from './Tab';
+export { default, default as Tabs } from './Tabs';

package/dist/Tabs/miniapp/index.js

@@ -0,0 +1,41 @@
+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);
+var miniapp_exports = {};
+__export(miniapp_exports, {
+  Tab: () => import_Tab.default,
+  Tabs: () => import_Tabs.default,
+  default: () => import_Tabs.default
+});
+module.exports = __toCommonJS(miniapp_exports);
+var import_Tab = __toESM(require("./Tab"));
+var import_Tabs = __toESM(require("./Tabs"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tab,
+  Tabs
+});

package/dist/Tabs/miniapp/scroll.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 小程序版scroll-view滚动到指定位置
+ * 使用scroll-left属性和scroll-with-animation实现平滑滚动
+ */
+interface ScrollToOptions {
+    scrollViewId: string;
+    scrollLeft: number;
+    duration?: number;
+}
+declare const scrollLeftTo: ({ scrollViewId, scrollLeft, duration, }: ScrollToOptions) => Promise<void>;
+/**
+ * 计算将目标元素滚动到视图中心所需的 scrollLeft 值
+ */
+interface CalcCenterScrollOptions {
+    containerWidth: number;
+    targetLeft: number;
+    targetWidth: number;
+    currentScrollLeft?: number;
+}
+export declare const calcCenterScroll: ({ containerWidth, targetLeft, targetWidth, currentScrollLeft, }: CalcCenterScrollOptions) => number;
+export default scrollLeftTo;