@pisell/private-materials 6.3.2 → 6.3.4

package/lib/plus/productSelect/components/TabsStructure/hooks.js

@@ -0,0 +1,209 @@
+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/plus/productSelect/components/TabsStructure/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  useSelectionIndicator: () => useSelectionIndicator
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_react = require("react");
+var import_utils = require("./utils");
+function useSelectionIndicator(containerRef, selectedTabId, transition) {
+  const [indicatorStyle, setIndicatorStyle] = (0, import_react.useState)({
+    width: 0,
+    transform: "translateX(0)",
+    transition: "none"
+  });
+  const [selectedTabRef, setSelectedTabRef] = (0, import_react.useState)();
+  const [isFocusVisible, setIsFocusVisible] = (0, import_react.useState)(false);
+  const [focusRingClasses, setFocusRingClasses] = (0, import_react.useState)("");
+  const setSelectedTab = (0, import_react.useCallback)((element) => {
+    setSelectedTabRef(
+      (prevRef) => (prevRef == null ? void 0 : prevRef.current) === element ? prevRef : { current: element }
+    );
+  }, []);
+  const findSelectedTabByAttribute = (0, import_react.useCallback)(() => {
+    if (!containerRef.current) return null;
+    const selectedTab = containerRef.current.querySelector('[role="tab"][aria-selected="true"]');
+    if (selectedTab) {
+      setSelectedTab(selectedTab);
+    }
+    return selectedTab;
+  }, [containerRef, setSelectedTab]);
+  const findSelectedTabById = (0, import_react.useCallback)(() => {
+    if (!selectedTabId || !containerRef.current) return null;
+    const selectedTab = containerRef.current.querySelector(`[id="${selectedTabId}"]`);
+    return selectedTab;
+  }, [containerRef, selectedTabId]);
+  const getTransition = (0, import_react.useCallback)((customTransition) => {
+    return customTransition || "transform 300ms, width 100ms";
+  }, []);
+  const getDirection = (0, import_react.useCallback)(() => {
+    if (!containerRef.current) return "ltr";
+    return window.getComputedStyle(containerRef.current).direction || "ltr";
+  }, [containerRef]);
+  const updateIndicatorPosition = (0, import_react.useCallback)(() => {
+    try {
+      const selectedTab = findSelectedTabByAttribute() || findSelectedTabById();
+      if (!selectedTab || !containerRef.current) {
+        setIndicatorStyle((prev) => ({
+          ...prev,
+          width: 0,
+          transform: "translateX(0)"
+        }));
+        return;
+      }
+      const container = containerRef.current;
+      const offsetParent = selectedTab.offsetParent;
+      if (!offsetParent) {
+        setIndicatorStyle((prev) => ({
+          ...prev,
+          width: 0,
+          transform: "translateX(0)"
+        }));
+        return;
+      }
+      if (!selectedTab.isConnected) {
+        console.warn("useSelectionIndicator: Selected tab is no longer connected to DOM");
+        return;
+      }
+      const direction = getDirection();
+      const width = selectedTab.offsetWidth;
+      if (width <= 0) {
+        setIndicatorStyle((prev) => ({
+          ...prev,
+          width: 0,
+          transform: "translateX(0)"
+        }));
+        return;
+      }
+      let left;
+      if (direction === "rtl") {
+        left = -1 * (offsetParent.clientWidth - selectedTab.offsetLeft - selectedTab.offsetWidth);
+      } else {
+        left = selectedTab.offsetLeft;
+      }
+      const transitionValue = getTransition(transition);
+      setIndicatorStyle({
+        width: `${width}px`,
+        transform: `translateX(${left}px)`,
+        transition: transitionValue
+      });
+    } catch (error) {
+      console.warn("useSelectionIndicator: Error updating indicator position:", error);
+      setIndicatorStyle((prev) => ({
+        ...prev,
+        width: 0,
+        transform: "translateX(0)"
+      }));
+    }
+  }, [containerRef, selectedTabId, transition, findSelectedTabByAttribute, findSelectedTabById, getDirection, getTransition]);
+  const debouncedUpdate = (0, import_react.useMemo)(
+    () => (0, import_utils.debounce)(updateIndicatorPosition, 50),
+    [updateIndicatorPosition]
+  );
+  const handleFocusIn = (0, import_react.useCallback)((event) => {
+    setIsFocusVisible(event.target instanceof HTMLElement && event.target.matches(":focus-visible"));
+    setFocusRingClasses(event.target instanceof HTMLElement && event.target.matches(":focus-visible") ? "focus-visible" : "");
+  }, []);
+  const handleFocusOut = (0, import_react.useCallback)(() => {
+    setIsFocusVisible(false);
+    setFocusRingClasses("");
+  }, []);
+  const handleMouseDown = (0, import_react.useCallback)(() => {
+    setIsFocusVisible(false);
+    setFocusRingClasses("");
+  }, []);
+  (0, import_react.useEffect)(() => {
+    debouncedUpdate();
+  }, [debouncedUpdate, selectedTabId]);
+  (0, import_react.useEffect)(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    let resizeObserver = null;
+    try {
+      resizeObserver = new ResizeObserver((entries) => {
+        try {
+          const validEntries = entries.filter(
+            (entry) => entry.target && entry.target.isConnected
+          );
+          if (validEntries.length > 0) {
+            debouncedUpdate();
+          }
+        } catch (error) {
+          console.warn("useSelectionIndicator: Error in ResizeObserver callback:", error);
+        }
+      });
+      resizeObserver.observe(container);
+      if (selectedTabRef == null ? void 0 : selectedTabRef.current) {
+        resizeObserver.observe(selectedTabRef.current);
+      }
+    } catch (error) {
+      console.warn("useSelectionIndicator: Failed to create ResizeObserver:", error);
+    }
+    return () => {
+      if (resizeObserver) {
+        try {
+          resizeObserver.disconnect();
+        } catch (error) {
+          console.warn("useSelectionIndicator: Error disconnecting ResizeObserver:", error);
+        }
+      }
+    };
+  }, [containerRef, selectedTabRef, debouncedUpdate]);
+  (0, import_react.useEffect)(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const nativeFocusIn = (event) => {
+      const syntheticEvent = {
+        ...event,
+        currentTarget: event.currentTarget,
+        target: event.target
+      };
+      handleFocusIn(syntheticEvent);
+    };
+    container.addEventListener("focusin", nativeFocusIn);
+    container.addEventListener("focusout", handleFocusOut);
+    container.addEventListener("mousedown", handleMouseDown);
+    return () => {
+      container.removeEventListener("focusin", nativeFocusIn);
+      container.removeEventListener("focusout", handleFocusOut);
+      container.removeEventListener("mousedown", handleMouseDown);
+    };
+  }, [containerRef, handleFocusIn, handleFocusOut, handleMouseDown]);
+  return {
+    selectionIndicatorProps: {
+      focusRingClasses,
+      isFocusVisible,
+      style: {
+        ...indicatorStyle,
+        transition: getTransition(transition)
+      }
+    },
+    listContainerProps: {
+      onFocus: handleFocusIn,
+      onBlur: handleFocusOut,
+      onMouseDown: handleMouseDown
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSelectionIndicator
+});

package/lib/plus/productSelect/components/TabsStructure/index.d.ts

@@ -0,0 +1,5 @@
+export { default as TabsStructure, TabListContainer, TabItem, Rail, SelectionIndicator, ScrollShadow, ChevronControls, ChevronButton } from './TabsStructure';
+export type { TabsStructureProps, TabListContainerProps, TabItemProps, RailProps, SelectionIndicatorProps, ScrollShadowProps, ChevronControlsProps, ChevronButtonProps, TabContextValue, ScrollLocation, TabWrapperClasses, TabListClasses, TabItemClasses, RailClasses, SelectionClasses, ShadowClasses, ChevronClasses, } from './types';
+export { tabWrapperClasses, tabListClasses, tabItemClasses, railClasses, selectionClasses, shadowClasses, chevronClasses, chevronButtonClasses, tabWrapperClassNames, tabListClassNames, tabItemClassNames, railClassNames, selectionClassNames, shadowClassNames, chevronClassNames } from './styles';
+export { debounce, mergeRefs } from './utils';
+export { useSelectionIndicator, } from './hooks';

package/lib/plus/productSelect/components/TabsStructure/index.js

@@ -0,0 +1,92 @@
+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/plus/productSelect/components/TabsStructure/index.ts
+var TabsStructure_exports = {};
+__export(TabsStructure_exports, {
+  ChevronButton: () => import_TabsStructure.ChevronButton,
+  ChevronControls: () => import_TabsStructure.ChevronControls,
+  Rail: () => import_TabsStructure.Rail,
+  ScrollShadow: () => import_TabsStructure.ScrollShadow,
+  SelectionIndicator: () => import_TabsStructure.SelectionIndicator,
+  TabItem: () => import_TabsStructure.TabItem,
+  TabListContainer: () => import_TabsStructure.TabListContainer,
+  TabsStructure: () => import_TabsStructure.default,
+  chevronButtonClasses: () => import_styles.chevronButtonClasses,
+  chevronClassNames: () => import_styles.chevronClassNames,
+  chevronClasses: () => import_styles.chevronClasses,
+  debounce: () => import_utils.debounce,
+  mergeRefs: () => import_utils.mergeRefs,
+  railClassNames: () => import_styles.railClassNames,
+  railClasses: () => import_styles.railClasses,
+  selectionClassNames: () => import_styles.selectionClassNames,
+  selectionClasses: () => import_styles.selectionClasses,
+  shadowClassNames: () => import_styles.shadowClassNames,
+  shadowClasses: () => import_styles.shadowClasses,
+  tabItemClassNames: () => import_styles.tabItemClassNames,
+  tabItemClasses: () => import_styles.tabItemClasses,
+  tabListClassNames: () => import_styles.tabListClassNames,
+  tabListClasses: () => import_styles.tabListClasses,
+  tabWrapperClassNames: () => import_styles.tabWrapperClassNames,
+  tabWrapperClasses: () => import_styles.tabWrapperClasses,
+  useSelectionIndicator: () => import_hooks.useSelectionIndicator
+});
+module.exports = __toCommonJS(TabsStructure_exports);
+var import_TabsStructure = __toESM(require("./TabsStructure"));
+var import_styles = require("./styles");
+var import_utils = require("./utils");
+var import_hooks = require("./hooks");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChevronButton,
+  ChevronControls,
+  Rail,
+  ScrollShadow,
+  SelectionIndicator,
+  TabItem,
+  TabListContainer,
+  TabsStructure,
+  chevronButtonClasses,
+  chevronClassNames,
+  chevronClasses,
+  debounce,
+  mergeRefs,
+  railClassNames,
+  railClasses,
+  selectionClassNames,
+  selectionClasses,
+  shadowClassNames,
+  shadowClasses,
+  tabItemClassNames,
+  tabItemClasses,
+  tabListClassNames,
+  tabListClasses,
+  tabWrapperClassNames,
+  tabWrapperClasses,
+  useSelectionIndicator
+});

package/lib/plus/productSelect/components/TabsStructure/styles.d.ts

@@ -0,0 +1,47 @@
+/**
+ * CSS Classes mapping for TabComponent
+ */
+import { TabWrapperClasses, TabListClasses, TabItemClasses, RailClasses, SelectionClasses, ShadowClasses, ChevronClasses } from './types';
+export declare const tabWrapperClasses: TabWrapperClasses;
+export declare const tabListClasses: TabListClasses;
+export declare const tabItemClasses: TabItemClasses;
+export declare const railClasses: RailClasses;
+export declare const selectionClasses: SelectionClasses;
+export declare const shadowClasses: ShadowClasses;
+export declare const chevronClasses: ChevronClasses;
+export declare const chevronButtonClasses: {
+    button: string;
+    disabled: string;
+    prev: string;
+    next: string;
+};
+export declare const tabWrapperClassNames: {
+    wrapper: string;
+};
+export declare const tabListClassNames: {
+    list: string;
+};
+export declare const tabItemClassNames: {
+    item: string;
+    selected: string;
+    disabled: string;
+};
+export declare const railClassNames: {
+    rail: string;
+};
+export declare const selectionClassNames: {
+    selection: string;
+    position: string;
+    focused: string;
+};
+export declare const shadowClassNames: {
+    shadow: string;
+    isVisible: string;
+    locationStart: string;
+    locationEnd: string;
+};
+export declare const chevronClassNames: {
+    controls: string;
+    button: string;
+    disabled: string;
+};

package/lib/plus/productSelect/components/TabsStructure/styles.js

@@ -0,0 +1,122 @@
+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/plus/productSelect/components/TabsStructure/styles.ts
+var styles_exports = {};
+__export(styles_exports, {
+  chevronButtonClasses: () => chevronButtonClasses,
+  chevronClassNames: () => chevronClassNames,
+  chevronClasses: () => chevronClasses,
+  railClassNames: () => railClassNames,
+  railClasses: () => railClasses,
+  selectionClassNames: () => selectionClassNames,
+  selectionClasses: () => selectionClasses,
+  shadowClassNames: () => shadowClassNames,
+  shadowClasses: () => shadowClasses,
+  tabItemClassNames: () => tabItemClassNames,
+  tabItemClasses: () => tabItemClasses,
+  tabListClassNames: () => tabListClassNames,
+  tabListClasses: () => tabListClasses,
+  tabWrapperClassNames: () => tabWrapperClassNames,
+  tabWrapperClasses: () => tabWrapperClasses
+});
+module.exports = __toCommonJS(styles_exports);
+var tabWrapperClasses = {
+  wrapper: "pisell-tabstruct-wrapper"
+};
+var tabListClasses = {
+  list: "pisell-tabstruct-list"
+};
+var tabItemClasses = {
+  item: "pisell-tabstruct-item",
+  selected: "pisell-tabstruct-item--selected",
+  disabled: "pisell-tabstruct-item--disabled"
+};
+var railClasses = {
+  rail: "pisell-tabstruct-rail"
+};
+var selectionClasses = {
+  selection: "pisell-tabstruct-selection",
+  position: "pisell-tabstruct-selection--positioned",
+  focused: "pisell-tabstruct-selection--focused"
+};
+var shadowClasses = {
+  shadow: "pisell-tabstruct-shadow",
+  isVisible: "pisell-tabstruct-shadow--visible",
+  locationStart: "pisell-tabstruct-shadow--start",
+  locationEnd: "pisell-tabstruct-shadow--end"
+};
+var chevronClasses = {
+  controls: "pisell-tabstruct-chevron-controls",
+  button: "pisell-tabstruct-chevron-button",
+  disabled: "pisell-tabstruct-chevron-button--disabled"
+};
+var chevronButtonClasses = {
+  button: "pisell-tabstruct-chevron-button",
+  disabled: "pisell-tabstruct-chevron-button--disabled",
+  prev: "pisell-tabstruct-chevron-button--prev",
+  next: "pisell-tabstruct-chevron-button--next"
+};
+var tabWrapperClassNames = {
+  wrapper: tabWrapperClasses.wrapper
+};
+var tabListClassNames = {
+  list: tabListClasses.list
+};
+var tabItemClassNames = {
+  item: tabItemClasses.item,
+  selected: tabItemClasses.selected,
+  disabled: tabItemClasses.disabled
+};
+var railClassNames = {
+  rail: railClasses.rail
+};
+var selectionClassNames = {
+  selection: selectionClasses.selection,
+  position: selectionClasses.position,
+  focused: selectionClasses.focused
+};
+var shadowClassNames = {
+  shadow: shadowClasses.shadow,
+  isVisible: shadowClasses.isVisible,
+  locationStart: shadowClasses.locationStart,
+  locationEnd: shadowClasses.locationEnd
+};
+var chevronClassNames = {
+  controls: chevronClasses.controls,
+  button: chevronClasses.button,
+  disabled: chevronClasses.disabled
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chevronButtonClasses,
+  chevronClassNames,
+  chevronClasses,
+  railClassNames,
+  railClasses,
+  selectionClassNames,
+  selectionClasses,
+  shadowClassNames,
+  shadowClasses,
+  tabItemClassNames,
+  tabItemClasses,
+  tabListClassNames,
+  tabListClasses,
+  tabWrapperClassNames,
+  tabWrapperClasses
+});

package/lib/plus/productSelect/components/TabsStructure/types.d.ts

@@ -0,0 +1,105 @@
+import React from 'react';
+export declare type ScrollLocation = 'start' | 'end';
+export interface TabContextValue {
+    selectedTab?: string;
+    onTabChange?: (tabId: string) => void;
+    registerTab?: (tabId: string, element: HTMLElement) => void;
+    unregisterTab?: (tabId: string) => void;
+    railRef?: React.RefObject<HTMLDivElement>;
+}
+export interface TabsStructureProps {
+    children?: React.ReactNode;
+    className?: string;
+    /** 当前选中的tab */
+    selectedTab?: string;
+    /** tab变更回调 */
+    onTabChange?: (tabId: string) => void;
+    /** 是否启用自动滚动到选中tab */
+    autoScrollToSelected?: boolean;
+    /** Rail组件的ref，用于手动控制滚动等操作 */
+    railRef?: React.RefObject<HTMLDivElement>;
+    [key: string]: any;
+}
+export interface TabListContainerProps {
+    children?: React.ReactNode;
+    className?: string;
+    [key: string]: any;
+}
+export interface TabItemProps {
+    children?: React.ReactNode;
+    isSelected?: boolean;
+    isDisabled?: boolean;
+    className?: string;
+    onClick?: (key?: string) => void;
+    /** Tab的唯一标识符 */
+    tabId?: string;
+    /** 是否自动注册到上下文 */
+    autoRegister?: boolean;
+    [key: string]: any;
+}
+export interface RailProps {
+    children?: React.ReactNode;
+    className?: string;
+    [key: string]: any;
+}
+export interface SelectionIndicatorProps {
+    focusRingClasses?: string;
+    isFocusVisible?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+    [key: string]: any;
+}
+export interface ScrollShadowProps {
+    location: ScrollLocation;
+    visible: boolean;
+    className?: string;
+    [key: string]: any;
+}
+export interface ChevronButtonProps {
+    direction: 'prev' | 'next';
+    disabled?: boolean;
+    onClick?: () => void;
+    className?: string;
+    'aria-label'?: string;
+    [key: string]: any;
+}
+export interface ChevronControlsProps {
+    isPrevDisabled?: boolean;
+    isNextDisabled?: boolean;
+    onPrevClick?: () => void;
+    onNextClick?: () => void;
+    className?: string;
+    prevAction?: () => void;
+    nextAction?: () => void;
+    [key: string]: any;
+}
+export interface TabWrapperClasses {
+    wrapper: string;
+}
+export interface TabListClasses {
+    list: string;
+}
+export interface TabItemClasses {
+    item: string;
+    selected: string;
+    disabled: string;
+}
+export interface RailClasses {
+    rail: string;
+}
+export interface SelectionClasses {
+    selection: string;
+    position: string;
+    focused: string;
+}
+export interface ShadowClasses {
+    shadow: string;
+    isVisible: string;
+    locationStart: string;
+    locationEnd: string;
+}
+export interface ChevronClasses {
+    controls: string;
+    button: string;
+    disabled: string;
+}

package/lib/plus/productSelect/components/TabsStructure/types.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/plus/productSelect/components/TabsStructure/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/plus/productSelect/components/TabsStructure/utils.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+export declare function mergeRefs<T>(...refs: (React.Ref<T> | undefined)[]): React.RefCallback<T>;
+/**
+ * 安全的滚动函数，包含错误处理和边界检查
+ * @param element - 要滚动的元素
+ * @param options - 滚动选项
+ */
+export declare function safeScrollTo(element: HTMLElement | null, options: {
+    left?: number;
+    behavior?: ScrollBehavior;
+}): boolean;

package/lib/plus/productSelect/components/TabsStructure/utils.js

@@ -0,0 +1,72 @@
+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/plus/productSelect/components/TabsStructure/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  debounce: () => debounce,
+  mergeRefs: () => mergeRefs,
+  safeScrollTo: () => safeScrollTo
+});
+module.exports = __toCommonJS(utils_exports);
+function debounce(func, wait) {
+  let timeout = null;
+  return (...args) => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      func(...args);
+    }, wait);
+  };
+}
+function mergeRefs(...refs) {
+  return (value) => {
+    refs.forEach((ref) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref && typeof ref === "object") {
+        ref.current = value;
+      }
+    });
+  };
+}
+function safeScrollTo(element, options) {
+  try {
+    if (!element || !element.scrollTo) {
+      return false;
+    }
+    const { left = 0, behavior = "smooth" } = options;
+    const maxScrollLeft = Math.max(0, element.scrollWidth - element.clientWidth);
+    const safeLeft = Math.max(0, Math.min(left, maxScrollLeft));
+    element.scrollTo({
+      left: safeLeft,
+      behavior
+    });
+    return true;
+  } catch (error) {
+    console.warn("Failed to scroll element:", error);
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debounce,
+  mergeRefs,
+  safeScrollTo
+});