@dt-dds/react-stepper 1.0.0-beta.46 → 1.0.0-beta.48

package/dist/index.mjs

@@ -1,4 +1,6 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -14,211 +16,516 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
-// src/Stepper.styled.ts
+// src/Stepper.tsx
+import { Children, cloneElement } from "react";
+
+// src/components/Step/Step.styled.ts
 import styled from "@emotion/styled";
-var StepperStyled = styled.ul`
+
+// src/constants/index.ts
+var VERTICAL_TRAIL_LINE_MIN_HEIGHT = 24;
+var HORIZONTAL_TRAIL_LINE_MIN_WIDTH = 80;
+var STEP_MIN_WIDTH = 120;
+var STEP_CONTENT_MAX_WIDTH = 112;
+var VERTICAL_LAST_STEP_INDICATOR_MIN_HEIGHT = 24;
+var VERTICAL_STEP_INDICATOR_MIN_HEIGHT = 56;
+var HORIZONTAL_TRAIL_LINE_START_OFFSET = 20;
+var VERTICAL_TRAIL_LINE_TOP_OFFSET = 32;
+var VERTICAL_TRAIL_LINE_LEFT_OFFSET = 12;
+
+// src/components/Step/Step.styled.ts
+var StepContainer = styled.div`
+  display: flex;
+  position: relative;
+  overflow: visible;
+  gap: 8px;
+
+  ${({ orientation, isLast, isDisabled }) => {
+  if (orientation === "horizontal") {
+    return `
+        flex-direction: column;
+        align-items: center;
+        flex: 1 1 0;
+        min-width: ${STEP_MIN_WIDTH}px;
+      `;
+  }
+  return `
+      flex-direction: row;
+      padding-bottom: ${isLast ? "0" : "8px"};
+      cursor: ${isDisabled ? "not-allowed" : "pointer"};
+    `;
+}}
+`;
+var StepIndicatorWrapper = styled.div`
+  display: flex;
+  position: relative;
+
+  ${({ orientation, isLast }) => {
+  if (orientation === "horizontal") {
+    return `
+        width: 100%;
+        flex-direction: row;
+        justify-content: center;
+      `;
+  }
+  return `
+      flex-direction: column;
+      align-self: flex-start;
+      min-height: ${isLast ? `${VERTICAL_LAST_STEP_INDICATOR_MIN_HEIGHT}px` : `${VERTICAL_STEP_INDICATOR_MIN_HEIGHT}px`};
+    `;
+}}
+`;
+
+// src/components/StepContent/StepContent.tsx
+import { useRef, useEffect, useState } from "react";
+import { Tooltip } from "@dt-dds/react-tooltip";
+
+// src/components/StepContent/StepContent.styled.ts
+import styled2 from "@emotion/styled";
+var StepContentStyled = styled2.div`
   display: flex;
   flex-direction: column;
-  gap: 32px;
-  list-style: none;
+  gap: 4px;
+  max-width: ${STEP_CONTENT_MAX_WIDTH}px;
 
-  ${({ theme, orientation = "vertical" }) => `
-    @media only screen and (min-width: ${theme.breakpoints.mq3d}px) {
-      flex-direction: ${orientation === "horizontal" ? "row" : "column"}
-    }
-  `}
+  & > * {
+    min-width: 0;
+    max-width: 100%;
+  }
+
+  ${({ orientation }) => orientation === "horizontal" ? `
+        align-items: center;
+        text-align: center;
+      ` : `
+        align-items: flex-start;
+        text-align: left;
+        padding-top: 4px;
+      `}
+`;
+var StepTitleStyled = styled2.span`
+  ${({ theme, state, isActive }) => {
+  const getColor = () => {
+    if (state === "disabled") return theme.palette.content.light;
+    if (state === "error") return theme.palette.error.default;
+    return theme.palette.content.dark;
+  };
+  return `
+      ${isActive ? theme.fontStyles.bodyMdBold : theme.fontStyles.bodyMdRegular}
+      color: ${getColor()};
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    `;
+}}
+`;
+var StepDescriptionStyled = styled2.span`
+  ${({ theme, state }) => {
+  const getColor = () => {
+    if (state === "disabled") return theme.palette.content.light;
+    if (state === "error") return theme.palette.error.default;
+    if (state === "warning") return theme.palette.content.default;
+    return theme.palette.primary.medium;
+  };
+  return `
+      ${theme.fontStyles.bodySmRegular}
+      color: ${getColor()};
+      display: -webkit-box;
+      -webkit-line-clamp: 2;
+      -webkit-box-orient: vertical;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    `;
+}}
 `;
 
-// src/Stepper.tsx
-import { jsx } from "react/jsx-runtime";
-var Stepper = ({
-  children,
-  dataTestId,
+// src/components/StepContent/StepContent.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var StepContent = ({
+  title,
+  description,
+  state,
+  isActive,
   orientation
 }) => {
-  const testId = dataTestId != null ? dataTestId : "default";
-  return /* @__PURE__ */ jsx(StepperStyled, { "data-testid": `${testId}-stepper`, orientation, children });
+  const titleRef = useRef(null);
+  const descRef = useRef(null);
+  const [showTitleTooltip, setShowTitleTooltip] = useState(false);
+  const [showDescTooltip, setShowDescTooltip] = useState(false);
+  useEffect(() => {
+    if (titleRef.current && title) {
+      const element = titleRef.current;
+      setShowTitleTooltip(element.scrollWidth > element.clientWidth);
+    }
+    if (descRef.current && description) {
+      const element = descRef.current;
+      setShowDescTooltip(element.scrollHeight > element.clientHeight);
+    }
+  }, [title, description, orientation]);
+  if (!title && !description) {
+    return null;
+  }
+  const renderContent = (content, ref, showTooltip, Component, componentProps) => {
+    if (!content) {
+      return null;
+    }
+    const element = /* @__PURE__ */ jsx(Component, __spreadProps(__spreadValues({}, componentProps), { ref, children: content }));
+    if (showTooltip) {
+      return /* @__PURE__ */ jsxs(Tooltip, { children: [
+        element,
+        /* @__PURE__ */ jsx(Tooltip.Content, { direction: "right", children: content })
+      ] });
+    }
+    return element;
+  };
+  return /* @__PURE__ */ jsxs(StepContentStyled, { orientation, children: [
+    renderContent(title, titleRef, showTitleTooltip, StepTitleStyled, {
+      state,
+      isActive
+    }),
+    renderContent(
+      description,
+      descRef,
+      showDescTooltip,
+      StepDescriptionStyled,
+      { state }
+    )
+  ] });
 };
 
-// src/components/Step/Step.tsx
-import { Children, cloneElement, useMemo } from "react";
+// src/components/StepIndicator/StepIndicator.tsx
 import { useTheme } from "@emotion/react";
 import { Icon } from "@dt-dds/react-icon";
-import { Typography } from "@dt-dds/react-typography";
 
-// src/components/Counter/Counter.styled.ts
-import styled2 from "@emotion/styled";
-var CounterStyled = styled2.span`
-  ${({ theme, color, outlined, isLarge }) => `
-    ${theme.fontStyles.bodySmRegular}
-    color: ${theme.palette.content.contrast};
-    border: ${theme.spacing.spacing_0};
-    align-items: center;
-    justify-content: center;
-    display: flex;
-    width: ${isLarge ? "24px" : "16px"};
-    height: ${isLarge ? "24px" : "16px"};
-    border-radius: 50%;
-    background-color: ${color === "disabled" ? theme.palette.content.default : theme.palette[color].default};
-
-    ${outlined && `
-        border: 2px solid ${color === "disabled" ? theme.palette.content.light : theme.palette[color].default};
-        color: ${color === "disabled" ? theme.palette.content.light : theme.palette[color].default};
-        background-color: ${theme.palette.surface.contrast}
-      `};
-  `}
+// src/components/StepIndicator/StepIndicator.styled.ts
+import styled3 from "@emotion/styled";
+var StepIndicatorStyled = styled3.div`
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  flex-shrink: 0;
+  transition: transform 0.2s ease;
+
+  ${({ theme, state, isActive, variant }) => {
+  const activeBgColor = isActive ? theme.palette.primary.light : theme.palette.content.contrast;
+  const colorMap = {
+    completed: {
+      bg: theme.palette.primary.default,
+      border: theme.palette.primary.default
+    },
+    warning: {
+      bg: theme.palette.warning.default,
+      border: "transparent"
+    },
+    error: {
+      bg: theme.palette.error.default,
+      border: "transparent"
+    },
+    disabled: {
+      bg: theme.palette.content.contrast,
+      border: theme.palette.border.medium,
+      text: theme.palette.content.light
+    },
+    incomplete: {
+      bg: activeBgColor,
+      border: theme.palette.primary.default,
+      text: theme.palette.primary.default
+    }
+  };
+  const colors = colorMap[state] || colorMap.incomplete;
+  const disabledBorderColor = state === "disabled" ? theme.palette.border.medium : theme.palette.primary.default;
+  if (variant === "bullet" && (state === "incomplete" || state === "disabled")) {
+    return `
+        background-color: ${activeBgColor};
+        border: 1px solid ${disabledBorderColor};
+        
+        &::after {
+          content: '';
+          width: 10px;
+          height: 10px;
+          border-radius: 50%;
+          background-color: ${state === "disabled" ? theme.palette.content.light : theme.palette.primary.default};
+        }
+      `;
+  }
+  if (variant === "icon" && state === "disabled") {
+    return `
+        border: 1px solid ${disabledBorderColor};
+        
+        > i {
+          color: ${theme.palette.content.light};
+        }
+      `;
+  }
+  return `
+      background-color: ${colors.bg};
+      border: 1px solid ${colors.border};
+      color: ${colors.text};
+      ${theme.fontStyles.bodySmBold}
+    `;
+}}
 `;
 
-// src/components/Counter/Counter.tsx
+// src/components/StepIndicator/StepIndicator.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
-var Counter = ({
-  children,
-  color = "informative",
-  dataTestId,
-  style,
-  outlined = false,
-  isLarge = false
+var StepIndicator = ({
+  index,
+  state,
+  variant,
+  isActive,
+  icon
 }) => {
+  const theme = useTheme();
+  const getIndicatorContent = () => {
+    const iconMap = {
+      completed: "check",
+      warning: "warning",
+      error: "error"
+    };
+    if (iconMap[state]) {
+      return /* @__PURE__ */ jsx2(
+        Icon,
+        {
+          code: iconMap[state],
+          color: theme.palette.content.contrast,
+          size: "small"
+        }
+      );
+    }
+    if (variant === "bullet") {
+      return null;
+    }
+    if (variant === "icon" && icon) {
+      return icon;
+    }
+    return index + 1;
+  };
   return /* @__PURE__ */ jsx2(
-    CounterStyled,
+    StepIndicatorStyled,
     {
-      color,
-      "data-testid": dataTestId != null ? dataTestId : "counter",
-      isLarge,
-      outlined,
-      style,
-      children
+      "data-testid": "step-indicator",
+      isActive,
+      state,
+      variant,
+      children: getIndicatorContent()
     }
   );
 };
 
-// src/components/Step/Step.styled.ts
-import styled3 from "@emotion/styled";
-var StepStyled = styled3.li`
-  display: flex;
-  gap: 12px;
-  align-items: center;
-`;
-var LabelStyled = styled3.span`
-  ${({ theme, color }) => `
-    ${theme.fontStyles.bodyMdRegularSmall};
-    color: ${color === "disabled" ? theme.palette.content.light : theme.palette[color].default};
-  `}
+// src/components/TrailLine/TrailLine.styled.ts
+import styled4 from "@emotion/styled";
+var TrailLineStyled = styled4.span`
+  position: absolute;
+  transition: background-color 0.3s ease;
+
+  ${({ state, orientation, theme }) => {
+  const color = state === "completed" ? `${theme.palette.primary.default}` : `${theme.palette.primary.light}`;
+  if (orientation === "horizontal") {
+    return `
+        top: 50%;
+        transform: translateY(-50%);
+        left: calc(50% + ${HORIZONTAL_TRAIL_LINE_START_OFFSET}px);
+        right: calc(-50% + ${HORIZONTAL_TRAIL_LINE_START_OFFSET}px);
+        min-width: ${HORIZONTAL_TRAIL_LINE_MIN_WIDTH}px;
+        height: ${state === "completed" ? "2px" : "1px"};
+        background-color: ${color};
+      `;
+  }
+  return `
+      top: ${VERTICAL_TRAIL_LINE_TOP_OFFSET}px;
+      left: ${VERTICAL_TRAIL_LINE_LEFT_OFFSET}px;
+      width: ${state === "completed" ? "2px" : "1px"};
+      min-height: ${VERTICAL_TRAIL_LINE_MIN_HEIGHT}px;
+      background-color: ${color};
+    `;
+}}
 `;
 
-// src/components/Step/Step.tsx
+// src/components/TrailLine/TrailLine.tsx
 import { jsx as jsx3 } from "react/jsx-runtime";
-var Step = ({
-  children,
-  isActive = false,
-  isCompleted = false,
-  isDisabled = false,
-  isError = false
-}) => {
-  const clonedChildren = useMemo(
-    () => Children.map(children, (child) => {
-      return child && cloneElement(child, __spreadValues({
-        isActive,
-        isCompleted,
-        isDisabled,
-        isError
-      }, child.props));
-    }),
-    [children, isActive, isCompleted, isDisabled, isError]
+var TrailLine = ({ state, orientation }) => {
+  return /* @__PURE__ */ jsx3(
+    TrailLineStyled,
+    {
+      "data-testid": "trail-line",
+      orientation,
+      state
+    }
   );
-  return /* @__PURE__ */ jsx3(StepStyled, { children: clonedChildren });
 };
-var StepCounter = ({
-  children,
+
+// src/components/Step/Step.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var Step = ({
+  index = 0,
+  title,
+  description,
+  state = "incomplete",
   isActive = false,
-  isCompleted = false,
-  isDisabled = false,
-  isError = false
+  variant = "number",
+  icon,
+  isLast = false,
+  orientation,
+  dataTestId
 }) => {
-  const theme = useTheme();
-  const color = isError ? "error" : isDisabled ? "disabled" : "primary";
-  const bgColor = isError ? theme.palette.error.light : theme.palette.primary.light;
-  return /* @__PURE__ */ jsx3(
-    Counter,
+  return /* @__PURE__ */ jsxs2(
+    StepContainer,
     {
-      color,
-      isLarge: true,
-      outlined: !isCompleted,
-      style: __spreadValues({
-        borderWidth: 1
-      }, isActive && { backgroundColor: bgColor }),
-      children: isCompleted ? /* @__PURE__ */ jsx3(Icon, { code: "check", color: theme.palette.surface.light, size: "small" }) : /* @__PURE__ */ jsx3(
-        Typography,
-        {
-          color: color === "disabled" ? "content.light" : `${color}.default`,
-          element: "span",
-          fontStyles: "bodyXsBold",
-          style: {
-            width: 24,
-            height: 24,
-            display: "flex",
-            alignItems: "center",
-            justifyContent: "center"
-          },
-          children
-        }
-      )
+      isDisabled: state === "disabled",
+      isLast,
+      orientation,
+      children: [
+        /* @__PURE__ */ jsxs2(
+          StepIndicatorWrapper,
+          {
+            "data-testid": dataTestId != null ? dataTestId : `step-${index}`,
+            isLast,
+            orientation,
+            children: [
+              /* @__PURE__ */ jsx4(
+                StepIndicator,
+                {
+                  icon,
+                  index,
+                  isActive,
+                  state,
+                  variant
+                }
+              ),
+              !isLast && /* @__PURE__ */ jsx4(TrailLine, { orientation, state })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          StepContent,
+          {
+            description,
+            isActive,
+            orientation,
+            state,
+            title
+          }
+        )
+      ]
     }
   );
 };
-Step.Counter = StepCounter;
-var labelColor = ({
-  isActive,
-  isError,
-  isDisabled,
-  isCompleted
-}) => {
-  if (isError) {
-    return "error";
-  } else if (isActive || isCompleted) {
-    return "primary";
-  } else if (isDisabled) {
-    return "disabled";
-  } else {
-    return "secondary";
-  }
-};
-Step.Label = ({
+
+// src/Stepper.styled.ts
+import styled5 from "@emotion/styled";
+var StepperStyled = styled5.div`
+  display: flex;
+
+  ${({ orientation = "vertical" }) => `
+    flex-direction: ${orientation === "horizontal" ? "row" : "column"};
+    width: ${orientation === "horizontal" ? "100%" : "fit-content"};
+    align-items: stretch;
+  `}
+`;
+
+// src/Stepper.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+var Stepper = ({
   children,
-  isActive = false,
-  isCompleted = false,
-  isDisabled = false,
-  isError = false
+  orientation = "vertical",
+  variant = "number",
+  activeStep,
+  dataTestId
 }) => {
-  const color = labelColor({ isActive, isError, isDisabled, isCompleted });
-  return /* @__PURE__ */ jsx3(LabelStyled, { color, children });
+  const childrenArray = Children.toArray(children);
+  const enhancedChildren = childrenArray.map((child, index) => {
+    var _a;
+    if (child.type !== Step) {
+      return child;
+    }
+    return cloneElement(child, __spreadProps(__spreadValues({}, child.props), {
+      index,
+      variant,
+      orientation,
+      isLast: index === childrenArray.length - 1,
+      isActive: (_a = child.props.isActive) != null ? _a : activeStep === index
+    }));
+  });
+  return /* @__PURE__ */ jsx5(
+    StepperStyled,
+    {
+      "data-testid": dataTestId != null ? dataTestId : "stepper",
+      orientation,
+      children: enhancedChildren
+    }
+  );
 };
-var Step_default = Step;
+Stepper.Step = Step;
 
 // src/hooks/useStepper.ts
-import { useCallback, useState } from "react";
-var useStepper = () => {
-  const [activeStep, setActiveStep] = useState(0);
-  const handleNext = () => {
-    setActiveStep((activeStep2) => activeStep2 + 1);
-  };
-  const handleBack = () => {
-    setActiveStep((activeStep2) => activeStep2 - 1);
-  };
-  const handleChangeStep = useCallback((step) => {
-    setActiveStep(step);
+import { useCallback, useState as useState2 } from "react";
+var useStepper = (options) => {
+  const { initialStep = 0, totalSteps } = options || {};
+  const [activeStep, setActiveStep] = useState2(initialStep);
+  const [completedSteps, setCompletedSteps] = useState2(/* @__PURE__ */ new Set());
+  const isFirstStep = activeStep === 0;
+  const isLastStep = totalSteps !== void 0 ? activeStep === totalSteps - 1 : false;
+  const canGoNext = totalSteps !== void 0 ? activeStep < totalSteps - 1 : true;
+  const canGoBack = activeStep > 0;
+  const handleNext = useCallback(() => {
+    if (canGoNext) {
+      setActiveStep((prev) => prev + 1);
+    }
+  }, [canGoNext]);
+  const handleBack = useCallback(() => {
+    if (canGoBack) {
+      setActiveStep((prev) => prev - 1);
+    }
+  }, [canGoBack]);
+  const handleChangeStep = useCallback(
+    (step) => {
+      const isValidStep = step >= 0 && (totalSteps === void 0 || step < totalSteps);
+      if (isValidStep) {
+        setActiveStep(step);
+      }
+    },
+    [totalSteps]
+  );
+  const handleReset = useCallback(() => {
+    setActiveStep(initialStep);
+    setCompletedSteps(/* @__PURE__ */ new Set());
+  }, [initialStep]);
+  const markStepComplete = useCallback((step) => {
+    setCompletedSteps((prev) => new Set(prev).add(step));
+  }, []);
+  const markStepIncomplete = useCallback((step) => {
+    setCompletedSteps((prev) => {
+      const newSet = new Set(prev);
+      newSet.delete(step);
+      return newSet;
+    });
   }, []);
+  const isStepComplete = useCallback(
+    (step) => completedSteps.has(step),
+    [completedSteps]
+  );
   return {
     activeStep,
-    handleChangeStep,
+    isFirstStep,
+    isLastStep,
+    canGoNext,
+    canGoBack,
+    completedSteps,
     handleNext,
-    handleBack
+    handleBack,
+    handleChangeStep,
+    handleReset,
+    markStepComplete,
+    markStepIncomplete,
+    isStepComplete
   };
 };
 export {
-  Counter,
-  Step_default as Step,
+  Step,
   Stepper,
   useStepper
 };