flowbite-svelte 1.20.0 → 1.21.0

package/dist/splitpane/SplitPane.svelte

@@ -0,0 +1,403 @@
+<script lang="ts" module>
+  import { setContext, getContext } from "svelte";
+
+  const SPLIT_PANE_KEY = Symbol("SPLIT_PANE");
+
+  interface SplitPaneContext {
+    registerPane: () => number;
+    getPaneStyle: (index: number) => string;
+    getPaneSize: (index: number) => number;
+    shouldRenderDivider: (index: number) => boolean;
+    getDirection: () => "horizontal" | "vertical";
+    getIsDragging: () => boolean;
+    onMouseDown: (e: MouseEvent, index: number) => void;
+    onKeyDown: (e: KeyboardEvent, index: number) => void;
+  }
+
+  export function setSplitPaneContext(ctx: SplitPaneContext) {
+    setContext(SPLIT_PANE_KEY, ctx);
+  }
+
+  export function getSplitPaneContext(): SplitPaneContext | undefined {
+    return getContext(SPLIT_PANE_KEY);
+  }
+</script>
+
+<script lang="ts">
+  import type { SplitPaneProps } from "../types";
+  import { splitpane } from "./theme";
+  import { getTheme } from "../theme/themeUtils";
+  import clsx from "clsx";
+
+  let {
+    direction = "horizontal",
+    minSize = 100,
+    responsive = true,
+    breakpoint = 768,
+    transition: transitionProp = true,
+    transitionDuration = 150,
+    keyboardStep = 2,
+    initialSizes,
+    onResize,
+    children,
+    class: className = ""
+  }: SplitPaneProps = $props();
+
+  const TOLERANCE = 0.5; // For pixel comparisons (minSize - TOLERANCE)
+  const MIN_CHANGE_THRESHOLD = 0.01; // For percentage changes (size deltas)
+  const MIN_DELTA = 1; // For mouse movement (Math.abs(delta) < MIN_DELTA)
+
+  // Validate numeric props
+  if (minSize <= 0) {
+    console.warn(`minSize must be positive, got ${minSize}. Using default 100.`);
+    minSize = 100;
+  }
+  if (keyboardStep <= 0) {
+    console.warn(`keyboardStep must be positive, got ${keyboardStep}. Using default 2.`);
+    keyboardStep = 2;
+  }
+
+  let transition = $state(transitionProp);
+  $effect(() => {
+    // syncing local transition state with prop changes
+    if (!isDragging) {
+      transition = transitionProp;
+    }
+  });
+  const theme = getTheme("splitpane");
+
+  let isDragging = $state(false);
+  let startPos = $state(0);
+  let sizes = $state<number[]>([]);
+  let container: HTMLDivElement;
+  let currentDirection = $state(direction);
+  let registeredPanes = $state(0);
+
+  // Register panes as they mount
+  function registerPane(): number {
+    const index = registeredPanes;
+    registeredPanes++;
+    return index;
+  }
+
+  function getPaneStyle(index: number): string {
+    if (sizes[index] === undefined) return "";
+
+    const size = `${sizes[index]}%`;
+    const transitionStyle = transition ? `${currentDirection === "horizontal" ? "width" : "height"} ${transitionDuration}ms ease` : "none";
+
+    if (currentDirection === "horizontal") {
+      return `width: ${size}; height: 100%; transition: ${transitionStyle};`;
+    } else {
+      return `height: ${size}; width: 100%; transition: ${transitionStyle};`;
+    }
+  }
+
+  function shouldRenderDivider(paneIndex: number): boolean {
+    return paneIndex < registeredPanes - 1;
+  }
+
+  // Set context for child Pane components
+  setSplitPaneContext({
+    registerPane,
+    getPaneStyle,
+    getPaneSize: (index: number) => sizes[index] ?? (registeredPanes > 0 ? 100 / registeredPanes : 0),
+    shouldRenderDivider,
+    getDirection: () => currentDirection,
+    getIsDragging: () => isDragging,
+    onMouseDown: startResize,
+    onKeyDown: handleKeyResize
+  });
+
+  let containerSize = $state(0);
+
+  // Track container size changes
+  $effect(() => {
+    if (!container) return;
+
+    const updateSize = () => {
+      containerSize = currentDirection === "horizontal" ? container.offsetWidth : container.offsetHeight;
+    };
+
+    updateSize();
+
+    const resizeObserver = new ResizeObserver(updateSize);
+    resizeObserver.observe(container);
+
+    return () => resizeObserver.disconnect();
+  });
+
+  // Initialize and maintain sizes
+  $effect(() => {
+    if (registeredPanes === 0) {
+      sizes = [];
+      return;
+    }
+
+    // If container not ready yet, use equal distribution
+    if (containerSize < 1) {
+      if (sizes.length !== registeredPanes) {
+        const equal = 100 / registeredPanes;
+        sizes = Array.from({ length: registeredPanes }, () => equal);
+      }
+      return;
+    }
+
+    const minPercent = (minSize / containerSize) * 100;
+
+    // Check if minSize is achievable for all panes
+    const totalMinRequired = minPercent * registeredPanes;
+    if (totalMinRequired > 100) {
+      console.error(
+        `Cannot satisfy minSize=${minSize}px for ${registeredPanes} panes in ${containerSize}px container. ` + `Required: ${(minSize * registeredPanes).toFixed(0)}px. Using equal distribution.`
+      );
+      const equal = 100 / registeredPanes;
+      sizes = Array.from({ length: registeredPanes }, () => equal);
+      return;
+    }
+
+    // Check if current sizes violate minSize constraints
+    const currentPixelSizes = sizes.map((s) => (s / 100) * containerSize);
+    const violatesMinSize = currentPixelSizes.some((pixelSize) => pixelSize < minSize - TOLERANCE); // small tolerance
+
+    if (violatesMinSize) {
+      // Recalculate sizes to respect minSize
+      let newSizes = sizes.map((s) => Math.max((s / 100) * containerSize, minSize));
+      const totalPixels = newSizes.reduce((a, b) => a + b, 0);
+
+      // Convert back to percentages
+      if (totalPixels > containerSize) {
+        // If we can't fit all panes at minSize, distribute proportionally
+        newSizes = newSizes.map((s) => (s / totalPixels) * containerSize);
+      }
+
+      sizes = newSizes.map((pixelSize) => (pixelSize / containerSize) * 100);
+    }
+
+    // Handle initialSizes (only on first initialization)
+    if (initialSizes && initialSizes.length === registeredPanes && sizes.length !== registeredPanes) {
+      const hasInvalidValues = initialSizes.some((s) => s < 0 || !isFinite(s));
+
+      if (hasInvalidValues) {
+        console.warn("initialSizes contains invalid values. Using equal distribution.");
+        const equal = Math.max(100 / registeredPanes, minPercent);
+        sizes = Array.from({ length: registeredPanes }, () => equal);
+        return;
+      }
+
+      const sum = initialSizes.reduce((a, b) => a + b, 0);
+
+      if (sum <= 0 || sum < 0.01) {
+        console.warn("initialSizes sum to zero. Using equal distribution.");
+        const equal = Math.max(100 / registeredPanes, minPercent);
+        sizes = Array.from({ length: registeredPanes }, () => equal);
+        return;
+      }
+
+      let normalizedSizes = initialSizes.map((s) => (s / sum) * 100);
+
+      const violatesConstraints = normalizedSizes.some((size) => size < minPercent);
+
+      if (violatesConstraints) {
+        console.warn(
+          `initialSizes [${normalizedSizes.map((s) => s.toFixed(1)).join("%, ")}%] ` +
+            `violate minSize constraint (${minSize}px = ${minPercent.toFixed(1)}%). ` +
+            `Adjusting to respect minimum constraints.`
+        );
+
+        normalizedSizes = normalizedSizes.map((size) => Math.max(size, minPercent));
+        const newSum = normalizedSizes.reduce((a, b) => a + b, 0);
+        normalizedSizes = normalizedSizes.map((size) => (size / newSum) * 100);
+      }
+
+      sizes = normalizedSizes;
+      return;
+    }
+
+    // Default: equal distribution respecting minSize
+    if (sizes.length !== registeredPanes) {
+      const equal = Math.max(100 / registeredPanes, minPercent);
+      sizes = Array.from({ length: registeredPanes }, () => equal);
+    }
+  });
+
+  // Responsive direction handling
+  $effect(() => {
+    if (!responsive) {
+      currentDirection = direction;
+      return;
+    }
+
+    if (typeof window === "undefined") {
+      currentDirection = direction;
+      return;
+    }
+
+    const mq = window.matchMedia(`(max-width: ${breakpoint}px)`);
+
+    const handleResize = () => {
+      // deferring the direction switch until the drag completes
+      if (!isDragging) {
+        currentDirection = mq.matches ? "vertical" : "horizontal";
+      }
+    };
+
+    handleResize();
+    mq.addEventListener("change", handleResize);
+
+    return () => mq.removeEventListener("change", handleResize);
+  });
+
+  // Notify parent of size changes
+  $effect(() => {
+    if (sizes.length > 0 && onResize) {
+      onResize(sizes);
+    }
+  });
+
+  function startResize(e: MouseEvent, index: number) {
+    e.preventDefault();
+    isDragging = true;
+    transition = false;
+    startPos = currentDirection === "horizontal" ? e.clientX : e.clientY;
+
+    const moveHandler = (ev: MouseEvent) => resize(ev, index);
+    const upHandler = () => stopResize(moveHandler, upHandler);
+
+    window.addEventListener("mousemove", moveHandler);
+    window.addEventListener("mouseup", upHandler);
+
+    document.body.style.cursor = currentDirection === "horizontal" ? "col-resize" : "row-resize";
+    document.body.style.userSelect = "none";
+  }
+
+  function stopResize(moveHandler: (e: MouseEvent) => void, upHandler: () => void) {
+    isDragging = false;
+    transition = transitionProp;
+    window.removeEventListener("mousemove", moveHandler);
+    window.removeEventListener("mouseup", upHandler);
+
+    document.body.style.cursor = "";
+    document.body.style.userSelect = "";
+  }
+
+  function resize(e: MouseEvent, index: number) {
+    if (!isDragging || !container) return;
+    if (index < 0 || index + 1 >= sizes.length) return;
+
+    const currentPos = currentDirection === "horizontal" ? e.clientX : e.clientY;
+    const delta = currentPos - startPos;
+
+    if (Math.abs(delta) < MIN_DELTA) return; // Ignore very small movements
+
+    const containerSize = currentDirection === "horizontal" ? container.offsetWidth : container.offsetHeight;
+
+    // Bail out if container has zero or near-zero dimensions
+    if (containerSize < 1) return;
+
+    const deltaPercent = (delta / containerSize) * 100;
+
+    // Calculate min as percentage based on current container size
+    const minPercent = (minSize / containerSize) * 100;
+
+    // Store original sizes
+    const oldSize1 = sizes[index];
+    const oldSize2 = sizes[index + 1];
+    const totalSize = oldSize1 + oldSize2;
+
+    // Calculate desired new sizes
+    let newSize1 = oldSize1 + deltaPercent;
+    let newSize2 = oldSize2 - deltaPercent;
+
+    // Apply minimum constraints - clamp to valid range
+    newSize1 = Math.max(minPercent, newSize1);
+    newSize2 = totalSize - newSize1;
+
+    // Check if second pane violates minimum constraint after first pane clamping
+    if (newSize2 < minPercent) {
+      newSize2 = minPercent;
+      newSize1 = totalSize - newSize2;
+    }
+
+    // Only update if changed significantly
+    if (Math.abs(newSize1 - oldSize1) > MIN_CHANGE_THRESHOLD) {
+      sizes[index] = newSize1;
+      sizes[index + 1] = newSize2;
+      startPos = currentPos;
+    }
+  }
+
+  function handleKeyResize(e: KeyboardEvent, index: number) {
+    if (!container) return;
+    if (index < 0 || index + 1 >= sizes.length) return;
+
+    const step = keyboardStep;
+    let handled = false;
+
+    const isHorizontal = currentDirection === "horizontal";
+    const increaseKeys = isHorizontal ? ["ArrowRight"] : ["ArrowDown"];
+    const decreaseKeys = isHorizontal ? ["ArrowLeft"] : ["ArrowUp"];
+
+    const containerSize = isHorizontal ? container.offsetWidth : container.offsetHeight;
+    // Bail out if container has zero or near-zero dimensions
+    if (containerSize < 1) return;
+
+    const minPercent = (minSize / containerSize) * 100;
+
+    const total = sizes[index] + sizes[index + 1];
+
+    const applyClamp = (target: number) => {
+      let newSize1 = Math.min(total - minPercent, Math.max(minPercent, target));
+      let newSize2 = total - newSize1;
+
+      if (newSize2 < minPercent) {
+        newSize2 = minPercent;
+        newSize1 = total - newSize2;
+      }
+
+      if (Math.abs(newSize1 - sizes[index]) > MIN_CHANGE_THRESHOLD) {
+        sizes[index] = newSize1;
+        sizes[index + 1] = newSize2;
+        handled = true;
+      }
+    };
+
+    if (increaseKeys.includes(e.key)) {
+      applyClamp(sizes[index] + step);
+    } else if (decreaseKeys.includes(e.key)) {
+      applyClamp(sizes[index] - step);
+    } else if (e.key === "Enter" || e.key === " ") {
+      // Reset to equal sizes
+      const equal = 100 / registeredPanes;
+      sizes = sizes.map(() => equal);
+      handled = true;
+    }
+
+    if (handled) {
+      e.preventDefault();
+    }
+  }
+</script>
+
+<div bind:this={container} class={splitpane({ direction: currentDirection, class: clsx(theme, className) })}>
+  {@render children()}
+</div>
+
+<!--
+@component
+[Go to docs](https://flowbite-svelte.com/)
+## Type
+[SplitPaneProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L2125)
+## Props
+@prop direction = "horizontal"
+@prop minSize = 100
+@prop responsive = true
+@prop breakpoint = 768
+@prop transition: transitionProp = true
+@prop transitionDuration = 150
+@prop keyboardStep = 2
+@prop initialSizes
+@prop onResize
+@prop children
+@prop class: className = ""
+-->

package/dist/splitpane/SplitPane.svelte.d.ts

@@ -0,0 +1,33 @@
+interface SplitPaneContext {
+    registerPane: () => number;
+    getPaneStyle: (index: number) => string;
+    getPaneSize: (index: number) => number;
+    shouldRenderDivider: (index: number) => boolean;
+    getDirection: () => "horizontal" | "vertical";
+    getIsDragging: () => boolean;
+    onMouseDown: (e: MouseEvent, index: number) => void;
+    onKeyDown: (e: KeyboardEvent, index: number) => void;
+}
+export declare function setSplitPaneContext(ctx: SplitPaneContext): void;
+export declare function getSplitPaneContext(): SplitPaneContext | undefined;
+import type { SplitPaneProps } from "../types";
+/**
+ * [Go to docs](https://flowbite-svelte.com/)
+ * ## Type
+ * [SplitPaneProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L2125)
+ * ## Props
+ * @prop direction = "horizontal"
+ * @prop minSize = 100
+ * @prop responsive = true
+ * @prop breakpoint = 768
+ * @prop transition: transitionProp = true
+ * @prop transitionDuration = 150
+ * @prop keyboardStep = 2
+ * @prop initialSizes
+ * @prop onResize
+ * @prop children
+ * @prop class: className = ""
+ */
+declare const SplitPane: import("svelte").Component<SplitPaneProps, {}, "">;
+type SplitPane = ReturnType<typeof SplitPane>;
+export default SplitPane;

package/dist/splitpane/index.d.ts

@@ -0,0 +1,4 @@
+export { default as SplitPane } from "./SplitPane.svelte";
+export { default as Pane } from "./Pane.svelte";
+export { default as Divider } from "./Divider.svelte";
+export { splitpane, pane, divider, dividerHitArea } from "./theme";

package/dist/splitpane/index.js

@@ -0,0 +1,4 @@
+export { default as SplitPane } from "./SplitPane.svelte";
+export { default as Pane } from "./Pane.svelte";
+export { default as Divider } from "./Divider.svelte";
+export { splitpane, pane, divider, dividerHitArea } from "./theme";

package/dist/splitpane/theme.d.ts

@@ -0,0 +1,65 @@
+import { type VariantProps } from "tailwind-variants";
+export type SplitPaneVariants = VariantProps<typeof splitpane>;
+export type PaneVariants = VariantProps<typeof pane>;
+export type DividerVariants = VariantProps<typeof divider>;
+export declare const splitpane: import("tailwind-variants").TVReturnType<{
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+}, undefined, "relative flex h-full w-full overflow-hidden select-none", {
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+}, undefined, "relative flex h-full w-full overflow-hidden select-none", unknown, unknown, undefined>>;
+export declare const pane: import("tailwind-variants").TVReturnType<{} | {} | {}, undefined, "flex flex-col relative overflow-hidden shrink-0 min-w-0 min-h-0", {} | {}, undefined, import("tailwind-variants").TVReturnType<unknown, undefined, "flex flex-col relative overflow-hidden shrink-0 min-w-0 min-h-0", unknown, unknown, undefined>>;
+export declare const divider: import("tailwind-variants").TVReturnType<{
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+    isDragging: {
+        true: string;
+        false: string;
+    };
+}, undefined, "bg-gray-300 shrink-0 relative z-10 transition-colors duration-200 hover:bg-gray-400 focus:bg-gray-400 focus:outline focus:outline-2 focus:outline-blue-500 focus:-outline-offset-2", {
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+    isDragging: {
+        true: string;
+        false: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+    isDragging: {
+        true: string;
+        false: string;
+    };
+}, undefined, "bg-gray-300 shrink-0 relative z-10 transition-colors duration-200 hover:bg-gray-400 focus:bg-gray-400 focus:outline focus:outline-2 focus:outline-blue-500 focus:-outline-offset-2", unknown, unknown, undefined>>;
+export declare const dividerHitArea: import("tailwind-variants").TVReturnType<{
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+}, undefined, "absolute bg-transparent", {
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+}, undefined, import("tailwind-variants").TVReturnType<{
+    direction: {
+        horizontal: string;
+        vertical: string;
+    };
+}, undefined, "absolute bg-transparent", unknown, unknown, undefined>>;

package/dist/splitpane/theme.js

@@ -0,0 +1,45 @@
+import { tv } from "tailwind-variants";
+export const splitpane = tv({
+    base: "relative flex h-full w-full overflow-hidden select-none",
+    variants: {
+        direction: {
+            horizontal: "",
+            vertical: "flex-col"
+        }
+    },
+    defaultVariants: {
+        direction: "horizontal"
+    }
+});
+export const pane = tv({
+    base: "flex flex-col relative overflow-hidden shrink-0 min-w-0 min-h-0"
+});
+export const divider = tv({
+    base: "bg-gray-300 shrink-0 relative z-10 transition-colors duration-200 hover:bg-gray-400 focus:bg-gray-400 focus:outline focus:outline-2 focus:outline-blue-500 focus:-outline-offset-2",
+    variants: {
+        direction: {
+            horizontal: "w-1 cursor-col-resize",
+            vertical: "h-1 cursor-row-resize"
+        },
+        isDragging: {
+            true: "bg-blue-500",
+            false: ""
+        }
+    },
+    defaultVariants: {
+        direction: "horizontal",
+        isDragging: false
+    }
+});
+export const dividerHitArea = tv({
+    base: "absolute bg-transparent",
+    variants: {
+        direction: {
+            horizontal: "w-3 h-full -left-1 top-0",
+            vertical: "h-3 w-full -top-1 left-0"
+        }
+    },
+    defaultVariants: {
+        direction: "horizontal"
+    }
+});

package/dist/step-indicator/StepIndicator.svelte

@@ -66,7 +66,7 @@
 @component
 [Go to docs](https://flowbite-svelte.com/)
 ## Type
-[StepIndicatorProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1525)
+[StepIndicatorProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1559)
 ## Props
 @prop steps = ["Step 1", "Step 2", "Step 3", "Step 4", "Step 5"]
 @prop currentStep = 1

package/dist/step-indicator/StepIndicator.svelte.d.ts

@@ -2,7 +2,7 @@ import type { StepIndicatorProps } from "../types";
 /**
  * [Go to docs](https://flowbite-svelte.com/)
  * ## Type
- * [StepIndicatorProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1525)
+ * [StepIndicatorProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1559)
  * ## Props
  * @prop steps = ["Step 1", "Step 2", "Step 3", "Step 4", "Step 5"]
  * @prop currentStep = 1

package/dist/stepper/BreadcrumbStepper.svelte

@@ -55,7 +55,7 @@
 @component
 [Go to docs](https://flowbite-svelte.com/)
 ## Type
-[BreadcrumbStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1605)
+[BreadcrumbStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1639)
 ## Props
 @prop children
 @prop steps = []

package/dist/stepper/BreadcrumbStepper.svelte.d.ts

@@ -2,7 +2,7 @@ import type { BreadcrumbStepperProps } from "../types";
 /**
  * [Go to docs](https://flowbite-svelte.com/)
  * ## Type
- * [BreadcrumbStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1605)
+ * [BreadcrumbStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1639)
  * ## Props
  * @prop children
  * @prop steps = []

package/dist/stepper/DetailedStepper.svelte

@@ -42,7 +42,7 @@
 @component
 [Go to docs](https://flowbite-svelte.com/)
 ## Type
-[DetailedStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1574)
+[DetailedStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1608)
 ## Props
 @prop children
 @prop steps = []

package/dist/stepper/DetailedStepper.svelte.d.ts

@@ -2,7 +2,7 @@ import type { DetailedStepperProps } from "../types";
 /**
  * [Go to docs](https://flowbite-svelte.com/)
  * ## Type
- * [DetailedStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1574)
+ * [DetailedStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1608)
  * ## Props
  * @prop children
  * @prop steps = []

package/dist/stepper/ProgressStepper.svelte

@@ -54,7 +54,7 @@
 @component
 [Go to docs](https://flowbite-svelte.com/)
 ## Type
-[ProgressStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1559)
+[ProgressStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1593)
 ## Props
 @prop children
 @prop steps = []

package/dist/stepper/ProgressStepper.svelte.d.ts

@@ -2,7 +2,7 @@ import type { ProgressStepperProps } from "../types";
 /**
  * [Go to docs](https://flowbite-svelte.com/)
  * ## Type
- * [ProgressStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1559)
+ * [ProgressStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1593)
  * ## Props
  * @prop children
  * @prop steps = []

package/dist/stepper/Stepper.svelte

@@ -58,7 +58,7 @@
 @component
 [Go to docs](https://flowbite-svelte.com/)
 ## Type
-[StepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1547)
+[StepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1581)
 ## Props
 @prop children
 @prop steps = []

package/dist/stepper/Stepper.svelte.d.ts

@@ -2,7 +2,7 @@ import type { StepperProps } from "../types";
 /**
  * [Go to docs](https://flowbite-svelte.com/)
  * ## Type
- * [StepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1547)
+ * [StepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1581)
  * ## Props
  * @prop children
  * @prop steps = []

package/dist/stepper/TimelineStepper.svelte

@@ -54,7 +54,7 @@
 @component
 [Go to docs](https://flowbite-svelte.com/)
 ## Type
-[TimelineStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1619)
+[TimelineStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1653)
 ## Props
 @prop children
 @prop steps = []

package/dist/stepper/TimelineStepper.svelte.d.ts

@@ -2,7 +2,7 @@ import type { TimelineStepperProps } from "../types";
 /**
  * [Go to docs](https://flowbite-svelte.com/)
  * ## Type
- * [TimelineStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1619)
+ * [TimelineStepperProps](https://github.com/themesberg/flowbite-svelte/blob/main/src/lib/types.ts#L1653)
  * ## Props
  * @prop children
  * @prop steps = []