@pisell/materials 6.3.23 → 6.3.25

package/lib/components/PisellProcedure/hooks/useOverflowActions.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import type { MenuProps } from 'antd';
+/**
+ * useOverflowActions Hook 配置
+ */
+export interface UseOverflowActionsOptions {
+    /** 操作按钮子元素 */
+    children?: React.ReactNode;
+    /** 按钮间距 */
+    gap?: number;
+    /** More 按钮文案 */
+    moreText?: string;
+}
+/**
+ * useOverflowActions Hook 返回值
+ */
+export interface UseOverflowActionsReturn {
+    /** 容器 ref */
+    containerRef: React.RefObject<HTMLDivElement>;
+    /** 测量容器 ref */
+    measureRef: React.RefObject<HTMLDivElement>;
+    /** More 按钮测量 ref */
+    moreButtonRef: React.RefObject<HTMLDivElement>;
+    /** 左侧插槽 ref（用于测量宽度） */
+    leftSlotRef: React.RefObject<HTMLDivElement>;
+    /** 所有操作项 */
+    actionItems: React.ReactNode[];
+    /** 可见的操作项 */
+    visibleActions: React.ReactNode[];
+    /** 溢出的操作项 */
+    overflowActions: React.ReactNode[];
+    /** 是否有溢出 */
+    hasOverflow: boolean;
+    /** More 菜单项 */
+    moreMenuItems: MenuProps['items'];
+    /** 可用宽度（用于调试） */
+    availableWidth: number;
+}
+/**
+ * 溢出收纳 Hook
+ * @description 处理操作按钮的溢出收纳逻辑，支持左侧自定义内容
+ */
+export declare const useOverflowActions: (options: UseOverflowActionsOptions) => UseOverflowActionsReturn;

package/lib/components/PisellProcedure/hooks/useOverflowActions.js

@@ -0,0 +1,248 @@
+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/components/PisellProcedure/hooks/useOverflowActions.ts
+var useOverflowActions_exports = {};
+__export(useOverflowActions_exports, {
+  useOverflowActions: () => useOverflowActions
+});
+module.exports = __toCommonJS(useOverflowActions_exports);
+var import_react = require("react");
+var import_extractText = require("../utils/extractText");
+var isButtonElement = (element) => {
+  const props = element.props || {};
+  const className = props.className;
+  if (typeof className === "string" && className.includes("btn")) {
+    return true;
+  }
+  if (Array.isArray(className)) {
+    return className.some((cls) => typeof cls === "string" && cls.includes("btn"));
+  }
+  return false;
+};
+var extractButtons = (node, index = 0) => {
+  const buttons = [];
+  if (!node) {
+    return buttons;
+  }
+  if (Array.isArray(node)) {
+    node.forEach((item, i) => {
+      buttons.push(...extractButtons(item, i));
+    });
+    return buttons;
+  }
+  if ((0, import_react.isValidElement)(node)) {
+    const element = node;
+    if (isButtonElement(element)) {
+      buttons.push(
+        (0, import_react.cloneElement)(element, {
+          key: element.key ?? `btn-${index}`
+        })
+      );
+      return buttons;
+    }
+    if (element.props && element.props.children) {
+      const childButtons = extractButtons(element.props.children, index);
+      buttons.push(...childButtons);
+    }
+  }
+  return buttons;
+};
+var useOverflowActions = (options) => {
+  const { children, gap = 16 } = options;
+  const containerRef = (0, import_react.useRef)(null);
+  const measureRef = (0, import_react.useRef)(null);
+  const moreButtonRef = (0, import_react.useRef)(null);
+  const leftSlotRef = (0, import_react.useRef)(null);
+  const [itemWidths, setItemWidths] = (0, import_react.useState)([]);
+  const [moreButtonWidth, setMoreButtonWidth] = (0, import_react.useState)(80);
+  const [availableWidth, setAvailableWidth] = (0, import_react.useState)(0);
+  const actionItems = (0, import_react.useMemo)(() => {
+    return extractButtons(children);
+  }, [children]);
+  const measureWidths = (0, import_react.useCallback)(() => {
+    if (typeof window === "undefined" || !measureRef.current || !moreButtonRef.current) return;
+    try {
+      const buttons = measureRef.current.querySelectorAll("[data-measure-item]");
+      const widths = [];
+      buttons.forEach((btn) => {
+        const rect = btn.getBoundingClientRect();
+        if (rect) {
+          widths.push(Math.ceil(rect.width));
+        }
+      });
+      setItemWidths(widths);
+      const moreBtnRect = moreButtonRef.current.getBoundingClientRect();
+      if (moreBtnRect) {
+        const moreBtnWidth = Math.ceil(moreBtnRect.width);
+        setMoreButtonWidth(moreBtnWidth);
+      }
+    } catch (error) {
+      console.warn("Failed to measure button widths:", error);
+    }
+  }, []);
+  const updateAvailableWidth = (0, import_react.useCallback)(() => {
+    if (!containerRef.current || typeof window === "undefined") return;
+    const parent = containerRef.current.parentElement;
+    if (!parent) {
+      const containerRect = containerRef.current.getBoundingClientRect();
+      setAvailableWidth(Math.floor(containerRect.width));
+      return;
+    }
+    const parentStyle = window.getComputedStyle(parent);
+    const parentRect = parent.getBoundingClientRect();
+    const scale = parent.offsetWidth > 0 ? parentRect.width / parent.offsetWidth : 1;
+    const paddingLeft = (parseFloat(parentStyle.paddingLeft) || 0) * scale;
+    const paddingRight = (parseFloat(parentStyle.paddingRight) || 0) * scale;
+    const parentGap = (parseFloat(parentStyle.gap) || gap) * scale;
+    let leftSlotWidth = 0;
+    if (leftSlotRef.current) {
+      leftSlotWidth = Math.ceil(leftSlotRef.current.getBoundingClientRect().width);
+      if (leftSlotWidth > 0) {
+        leftSlotWidth += parentGap;
+      }
+    }
+    let otherSiblingWidth = 0;
+    const siblings = parent.children;
+    for (let i = 0; i < siblings.length; i++) {
+      const sibling = siblings[i];
+      if (sibling !== containerRef.current && sibling !== leftSlotRef.current && !sibling.hasAttribute("aria-hidden")) {
+        const siblingWidth = Math.ceil(sibling.getBoundingClientRect().width);
+        if (siblingWidth > 0) {
+          otherSiblingWidth += siblingWidth + parentGap;
+        }
+      }
+    }
+    const totalWidth = parentRect.width - paddingLeft - paddingRight;
+    const width = Math.floor(totalWidth - leftSlotWidth - otherSiblingWidth);
+    setAvailableWidth(Math.max(0, width));
+  }, [gap]);
+  (0, import_react.useEffect)(() => {
+    const rafId = requestAnimationFrame(() => {
+      measureWidths();
+      updateAvailableWidth();
+    });
+    return () => cancelAnimationFrame(rafId);
+  }, [actionItems, measureWidths, updateAvailableWidth]);
+  (0, import_react.useEffect)(() => {
+    var _a;
+    if (typeof window === "undefined") return;
+    const handleResize = () => {
+      measureWidths();
+      updateAvailableWidth();
+    };
+    window.addEventListener("resize", handleResize);
+    const parent = (_a = containerRef.current) == null ? void 0 : _a.parentElement;
+    let resizeObserver = null;
+    if (parent && typeof ResizeObserver !== "undefined") {
+      try {
+        resizeObserver = new ResizeObserver(() => {
+          measureWidths();
+          updateAvailableWidth();
+        });
+        resizeObserver.observe(parent);
+      } catch (error) {
+        console.warn("Failed to create ResizeObserver:", error);
+      }
+    }
+    if (leftSlotRef.current && typeof ResizeObserver !== "undefined") {
+      try {
+        const leftObserver = new ResizeObserver(() => updateAvailableWidth());
+        leftObserver.observe(leftSlotRef.current);
+        return () => {
+          window.removeEventListener("resize", handleResize);
+          resizeObserver == null ? void 0 : resizeObserver.disconnect();
+          leftObserver.disconnect();
+        };
+      } catch (error) {
+        console.warn("Failed to create ResizeObserver for leftSlot:", error);
+      }
+    }
+    return () => {
+      window.removeEventListener("resize", handleResize);
+      resizeObserver == null ? void 0 : resizeObserver.disconnect();
+    };
+  }, [measureWidths, updateAvailableWidth]);
+  const visibleCount = (0, import_react.useMemo)(() => {
+    if (itemWidths.length === 0 || availableWidth === 0) {
+      return actionItems.length;
+    }
+    const totalItems = itemWidths.length;
+    const totalButtonsWidth = itemWidths.reduce((sum, w) => sum + w, 0);
+    const totalGapsWidth = (totalItems - 1) * gap;
+    const allButtonsWidth = totalButtonsWidth + totalGapsWidth;
+    if (allButtonsWidth <= availableWidth) {
+      return totalItems;
+    }
+    const spaceForButtons = availableWidth - moreButtonWidth - gap;
+    if (spaceForButtons <= 0) {
+      return 0;
+    }
+    let usedWidth = 0;
+    let count = 0;
+    for (let i = totalItems - 1; i >= 0; i--) {
+      const itemWidth = itemWidths[i];
+      const gapWidth = count > 0 ? gap : 0;
+      const requiredWidth = itemWidth + gapWidth;
+      if (usedWidth + requiredWidth <= spaceForButtons) {
+        usedWidth += requiredWidth;
+        count++;
+      } else {
+        break;
+      }
+    }
+    return count;
+  }, [itemWidths, availableWidth, gap, moreButtonWidth, actionItems.length]);
+  const overflowCount = Math.max(0, actionItems.length - visibleCount);
+  const overflowActions = actionItems.slice(0, overflowCount);
+  const visibleActions = actionItems.slice(overflowCount);
+  const hasOverflow = overflowCount > 0;
+  const moreMenuItems = (0, import_react.useMemo)(() => {
+    return overflowActions.map((action, index) => {
+      if (!(0, import_react.isValidElement)(action)) return null;
+      const buttonProps = action.props;
+      const label = (0, import_extractText.extractButtonLabel)(buttonProps, `操作 ${index + 1}`);
+      const originalOnClick = buttonProps == null ? void 0 : buttonProps.onClick;
+      return {
+        key: `overflow-${index}`,
+        label,
+        onClick: originalOnClick ? () => originalOnClick({}) : void 0,
+        disabled: (buttonProps == null ? void 0 : buttonProps.disabled) || (buttonProps == null ? void 0 : buttonProps.loading),
+        danger: buttonProps == null ? void 0 : buttonProps.danger,
+        icon: buttonProps == null ? void 0 : buttonProps.icon,
+        title: buttonProps == null ? void 0 : buttonProps.title
+      };
+    }).filter(Boolean);
+  }, [overflowActions]);
+  return {
+    containerRef,
+    measureRef,
+    moreButtonRef,
+    leftSlotRef,
+    actionItems,
+    visibleActions,
+    overflowActions,
+    hasOverflow,
+    moreMenuItems,
+    availableWidth
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useOverflowActions
+});

package/lib/components/PisellProcedure/hooks/useResponsiveClass.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 使用响应式类名的 Hook
+ *
+ * @description 根据容器宽度计算响应式类名，延迟应用以避免宽度抖动
+ */
+export declare const useResponsiveClass: (containerWidth: number) => string;

package/lib/components/PisellProcedure/hooks/useResponsiveClass.js

@@ -0,0 +1,58 @@
+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/components/PisellProcedure/hooks/useResponsiveClass.ts
+var useResponsiveClass_exports = {};
+__export(useResponsiveClass_exports, {
+  useResponsiveClass: () => useResponsiveClass
+});
+module.exports = __toCommonJS(useResponsiveClass_exports);
+var RESPONSIVE_BREAKPOINTS = {
+  lg: 1133,
+  // ≥1133px: 默认样式（405px）
+  md: 960,
+  // 960px-1133px: 376px ~ 405px 线性插值
+  sm: 744
+  // 744px-960px: 290px ~ 376px 线性插值
+};
+var RESPONSIVE_CLASSES = {
+  md: "pisell-procedure-sidebar--responsive-md",
+  sm: "pisell-procedure-sidebar--responsive-sm",
+  xs: "pisell-procedure-sidebar--responsive-xs"
+  // 最小宽度（< 744px）
+};
+var getResponsiveClass = (width) => {
+  if (width === 0 || !width) return "";
+  if (width >= RESPONSIVE_BREAKPOINTS.lg) {
+    return "";
+  }
+  if (width >= RESPONSIVE_BREAKPOINTS.md) {
+    return RESPONSIVE_CLASSES.md;
+  }
+  if (width >= RESPONSIVE_BREAKPOINTS.sm) {
+    return RESPONSIVE_CLASSES.sm;
+  }
+  return RESPONSIVE_CLASSES.xs;
+};
+var useResponsiveClass = (containerWidth) => {
+  return getResponsiveClass(containerWidth);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useResponsiveClass
+});

package/lib/components/PisellProcedure/hooks/useSidebarHeight.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 尺寸值接口
+ */
+interface SizeValues {
+    containerSelector?: string;
+    containerHeight?: number;
+    headerHeight?: number;
+    footerHeight: number;
+}
+/**
+ * 使用 Sidebar 高度的 Hook
+ *
+ * @description 计算并管理 Sidebar 的高度，确保在尺寸稳定后才应用
+ */
+export declare const useSidebarHeight: (isSizeStable: boolean, sizeValues: SizeValues) => number | undefined;
+export {};

package/lib/components/PisellProcedure/hooks/useSidebarHeight.js

@@ -0,0 +1,120 @@
+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/components/PisellProcedure/hooks/useSidebarHeight.ts
+var useSidebarHeight_exports = {};
+__export(useSidebarHeight_exports, {
+  useSidebarHeight: () => useSidebarHeight
+});
+module.exports = __toCommonJS(useSidebarHeight_exports);
+var import_react = require("react");
+var useSidebarHeight = (isSizeStable, sizeValues) => {
+  const [siderHeight, setSiderHeight] = (0, import_react.useState)(void 0);
+  const hasInitializedRef = (0, import_react.useRef)(false);
+  const rafIdRef = (0, import_react.useRef)(null);
+  const stableCheckCountRef = (0, import_react.useRef)(0);
+  const previousSiderHeightRef = (0, import_react.useRef)(void 0);
+  const sizeValuesRef = (0, import_react.useRef)(sizeValues);
+  (0, import_react.useEffect)(() => {
+    sizeValuesRef.current = sizeValues;
+  }, [sizeValues]);
+  const getBodyScaleY = (0, import_react.useCallback)(() => {
+    try {
+      if (typeof window === "undefined" || typeof document === "undefined") {
+        return 1;
+      }
+      const bodyTransform = getComputedStyle(document.body).transform;
+      let scaleY = 1;
+      if (bodyTransform !== "none") {
+        const matrix = new DOMMatrix(bodyTransform);
+        scaleY = matrix.d;
+      }
+      return scaleY;
+    } catch (error) {
+      return 1;
+    }
+  }, []);
+  const calculateHeight = (0, import_react.useCallback)(() => {
+    const { containerSelector, containerHeight, headerHeight, footerHeight } = sizeValuesRef.current;
+    let baseHeight;
+    if (containerSelector && containerSelector.trim() && containerHeight && containerHeight > 0) {
+      baseHeight = containerHeight;
+    } else {
+      baseHeight = typeof window !== "undefined" ? window.innerHeight : 0;
+    }
+    const bodyPadding = 16 * 2;
+    const headerHeightValue = headerHeight || 0;
+    const calculatedHeight = baseHeight - headerHeightValue - footerHeight - bodyPadding;
+    const scaleY = getBodyScaleY();
+    const scaledHeight = calculatedHeight / scaleY;
+    return Math.round(scaledHeight * 100) / 100;
+  }, [sizeValuesRef.current, getBodyScaleY]);
+  (0, import_react.useEffect)(() => {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return;
+    }
+    if (!isSizeStable) {
+      hasInitializedRef.current = false;
+      stableCheckCountRef.current = 0;
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = null;
+      }
+      return;
+    }
+    if (rafIdRef.current !== null) {
+      cancelAnimationFrame(rafIdRef.current);
+    }
+    const checkStability = () => {
+      if (!isSizeStable) {
+        stableCheckCountRef.current = 0;
+        return;
+      }
+      const calculatedHeight = calculateHeight();
+      if (calculatedHeight <= 0) {
+        stableCheckCountRef.current = 0;
+        return;
+      }
+      const previousHeight = previousSiderHeightRef.current;
+      if (hasInitializedRef.current && previousHeight !== void 0 && Math.abs(calculatedHeight - previousHeight) < 10) {
+        return;
+      }
+      stableCheckCountRef.current += 1;
+      if (stableCheckCountRef.current >= 3) {
+        previousSiderHeightRef.current = calculatedHeight;
+        setSiderHeight(calculatedHeight);
+        hasInitializedRef.current = true;
+        stableCheckCountRef.current = 0;
+      } else {
+        rafIdRef.current = requestAnimationFrame(checkStability);
+      }
+    };
+    rafIdRef.current = requestAnimationFrame(checkStability);
+    return () => {
+      if (rafIdRef.current !== null) {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = null;
+      }
+    };
+  }, [isSizeStable, calculateHeight]);
+  return siderHeight;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useSidebarHeight
+});

package/lib/components/PisellProcedure/hooks/useStepManager.d.ts

@@ -0,0 +1,50 @@
+import type { StepChangeResult } from '../types';
+import type { PisellStepsProps } from '../../PisellSteps/types';
+/**
+ * useStepManager Hook 配置
+ */
+export interface UseStepManagerOptions {
+    /** 步骤条配置 */
+    stepsProps?: PisellStepsProps;
+    /** 初始步骤索引 */
+    defaultCurrent?: number;
+    /** 上一步事件回调 */
+    onPrev?: (current: number) => boolean | void;
+    /** 下一步事件回调 */
+    onNext?: (current: number) => boolean | void;
+    /** 步骤变化回调 */
+    onStepsChange?: (result: StepChangeResult) => void;
+    /** 跳转到指定步骤 */
+    goToStep?: (step: number) => void;
+}
+/**
+ * useStepManager Hook 返回值
+ */
+export interface UseStepManagerReturn {
+    /** 当前步骤索引 */
+    currentStep: number;
+    /** 步骤列表 */
+    items: any[];
+    /** 步骤总数 */
+    totalSteps: number;
+    /** 上一步 */
+    goPrev: () => StepChangeResult | null;
+    /** 下一步 */
+    goNext: () => StepChangeResult | null;
+    /** 跳转到指定步骤 */
+    goToStep: (step: number) => StepChangeResult | null;
+}
+/**
+ * 步骤管理 Hook
+ *
+ * @description 管理多步骤流程的状态和操作
+ * @example
+ * const { currentStep, goPrev, goNext } = useStepManager({
+ *   stepsProps: { items: [...] },
+ *   defaultCurrent: 0,
+ *   onPrev: (current) => { ... },
+ *   onNext: (current) => { ... },
+ *   onStepsChange: (result) => { ... },
+ * });
+ */
+export declare const useStepManager: ({ stepsProps, defaultCurrent, onPrev, onNext, onStepsChange, }: UseStepManagerOptions) => UseStepManagerReturn;

package/lib/components/PisellProcedure/hooks/useStepManager.js

@@ -0,0 +1,90 @@
+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/components/PisellProcedure/hooks/useStepManager.ts
+var useStepManager_exports = {};
+__export(useStepManager_exports, {
+  useStepManager: () => useStepManager
+});
+module.exports = __toCommonJS(useStepManager_exports);
+var import_react = require("react");
+var useStepManager = ({
+  stepsProps,
+  defaultCurrent = 0,
+  onPrev,
+  onNext,
+  onStepsChange
+}) => {
+  const items = Array.isArray(stepsProps == null ? void 0 : stepsProps.items) ? stepsProps.items : [];
+  const totalSteps = items.length > 0 ? items.length : 1;
+  const safeDefaultCurrent = (0, import_react.useMemo)(() => {
+    const num = Number(defaultCurrent);
+    if (isNaN(num) || num < 0) return 0;
+    if (num >= totalSteps) return Math.max(0, totalSteps - 1);
+    return num;
+  }, [defaultCurrent, totalSteps]);
+  const [currentStep, setCurrentStep] = (0, import_react.useState)(safeDefaultCurrent);
+  (0, import_react.useEffect)(() => {
+    if (currentStep >= totalSteps) {
+      setCurrentStep(Math.max(0, totalSteps - 1));
+    }
+  }, [totalSteps, currentStep]);
+  const updateStep = (0, import_react.useCallback)((step) => {
+    const safeStep = Math.max(0, Math.min(totalSteps - 1, step));
+    setCurrentStep(safeStep);
+    const result = {
+      success: true,
+      currentStep: safeStep,
+      currentItem: items[safeStep] || null
+    };
+    onStepsChange == null ? void 0 : onStepsChange(result);
+    return result;
+  }, [items, totalSteps, onStepsChange]);
+  const goPrev = (0, import_react.useCallback)(() => {
+    if (currentStep <= 0 || totalSteps === 0) return null;
+    const preventUpdate = onPrev == null ? void 0 : onPrev(currentStep);
+    if (preventUpdate === false) return null;
+    const newStep = Math.max(0, currentStep - 1);
+    return updateStep(newStep);
+  }, [currentStep, totalSteps, onPrev, updateStep]);
+  const goNext = (0, import_react.useCallback)(() => {
+    if (currentStep >= totalSteps - 1 || totalSteps === 0) return null;
+    const preventUpdate = onNext == null ? void 0 : onNext(currentStep);
+    if (preventUpdate === false) return null;
+    const newStep = Math.min(totalSteps - 1, currentStep + 1);
+    return updateStep(newStep);
+  }, [currentStep, totalSteps, onNext, updateStep]);
+  const goToStep = (0, import_react.useCallback)((step) => {
+    if (totalSteps === 0) return null;
+    if (step < 0 || step >= totalSteps) return null;
+    if (step === currentStep) return null;
+    return updateStep(step);
+  }, [currentStep, totalSteps, updateStep]);
+  return {
+    currentStep,
+    items,
+    totalSteps,
+    goPrev,
+    goNext,
+    goToStep
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useStepManager
+});

package/lib/components/PisellProcedure/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * PisellProcedure 组件导出
+ */
+export { default } from './PisellProcedure';
+export type { PisellProcedureProps, PisellProcedureRef, ProcedureHeaderProps, ProcedureBodyProps, ProcedureFooterProps, FooterPositionMode, BackConfirmModalConfig, BodyLayoutMode, BodyLayoutRatio, BodyDirection, StepItem, StepChangeResult, } from './types';

package/lib/components/PisellProcedure/index.js

@@ -0,0 +1,35 @@
+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/components/PisellProcedure/index.tsx
+var PisellProcedure_exports = {};
+__export(PisellProcedure_exports, {
+  default: () => import_PisellProcedure.default
+});
+module.exports = __toCommonJS(PisellProcedure_exports);
+var import_PisellProcedure = __toESM(require("./PisellProcedure"));