@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/solution-tests/use-solution-tests.js

@@ -0,0 +1,81 @@
+"use client";
+import { useLiveQuery } from "@tanstack/react-db";
+import { useMutation } from "@tanstack/react-query";
+import { useSolution } from "@uipath/vs-core";
+import { ENTITY } from "./constants.js";
+import { useSolutionTestsActions, useSolutionTestsConfig } from "./context.js";
+import { useSolutionTestCollection } from "./use-solution-test-collection.js";
+function useSolutionTests() {
+    const collection = useSolutionTestCollection(ENTITY.tests);
+    const { data, isLoading } = useLiveQuery((q)=>q.from({
+            tests: collection
+        }), [
+        collection
+    ]);
+    return {
+        tests: data ?? [],
+        isLoading
+    };
+}
+function useRunTests() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    return useMutation({
+        mutationFn: ({ testIds })=>actions.runTests(testIds),
+        onMutate: ({ testIds, mode })=>track?.("VS.SolutionTest.Run", {
+                mode,
+                testCount: testIds?.length ?? 0
+            })
+    });
+}
+function useCreateTest() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    const testsCollection = useSolutionTestCollection(ENTITY.tests);
+    return useMutation({
+        mutationFn: async (subjectId)=>{
+            await actions.createTest(subjectId);
+            await testsCollection.utils.refetch();
+        },
+        onMutate: (subjectId)=>track?.("VS.SolutionTest.Created", {
+                subjectId
+            })
+    });
+}
+function useToggleTestActive() {
+    const solution = useSolution();
+    const { track } = useSolutionTestsConfig();
+    return useMutation({
+        mutationFn: async ({ testId, isActive })=>{
+            const collection = solution?.api.collections.solutionTests[ENTITY.tests];
+            if (!collection) throw new Error("Solution Tests collection is unavailable.");
+            const transaction = collection.update(testId, (draft)=>{
+                draft.IsActive = isActive;
+            });
+            await transaction.isPersisted.promise;
+        },
+        onMutate: ({ testId, isActive })=>track?.("VS.SolutionTest.ActiveToggled", {
+                testId,
+                isActive
+            })
+    });
+}
+function useDeleteTest() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    const testsCollection = useSolutionTestCollection(ENTITY.tests);
+    const jobsCollection = useSolutionTestCollection(ENTITY.jobs);
+    return useMutation({
+        mutationFn: async (testId)=>{
+            await actions.deleteTest(testId);
+            await Promise.all([
+                testsCollection.utils.refetch(),
+                jobsCollection.utils.refetch()
+            ]);
+        },
+        onMutate: (testId)=>track?.("VS.SolutionTest.Deleted", {
+                testId
+            })
+    });
+}
+export { useCreateTest, useDeleteTest, useRunTests, useSolutionTests, useToggleTestActive };

package/dist/registry/solution-tests/user-messages-view.d.ts

@@ -0,0 +1,6 @@
+export declare const UserMessagesView: ({ messages }: {
+    messages: unknown;
+}) => import("react/jsx-runtime").JSX.Element | null;
+export declare const UserMessagesIcon: ({ messages }: {
+    messages: unknown;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/registry/solution-tests/user-messages-view.js

@@ -0,0 +1,67 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { Info } from "lucide-react";
+import { Tooltip, TooltipContent, TooltipTrigger } from "../tooltip/tooltip.js";
+import { categoryBorderStyles, parseUserMessages, severityColors, severityIcons, worstSeverity } from "./user-messages.js";
+const UserMessagesView = ({ messages })=>{
+    const { t } = useVertexTranslation();
+    const parsed = parseUserMessages(messages);
+    if (0 === parsed.length) return null;
+    return /*#__PURE__*/ jsx("div", {
+        className: "flex flex-col gap-2",
+        children: parsed.map((msg)=>{
+            const translated = t(msg.key, msg.details);
+            const displayText = translated === msg.key ? msg.message : translated;
+            return /*#__PURE__*/ jsx("div", {
+                className: `rounded-md border-l-4 p-3 text-sm ${categoryBorderStyles[msg.category] ?? "bg-muted/50"}`,
+                children: displayText
+            }, `${msg.key}-${msg.timestamp}-${msg.message}`);
+        })
+    });
+};
+const UserMessagesIcon = ({ messages })=>{
+    const { t } = useVertexTranslation();
+    const parsed = parseUserMessages(messages);
+    const severity = worstSeverity(parsed);
+    if (!severity) return null;
+    const Icon = severityIcons[severity];
+    const colorClass = severityColors[severity];
+    return /*#__PURE__*/ jsxs(Tooltip, {
+        children: [
+            /*#__PURE__*/ jsx(TooltipTrigger, {
+                type: "button",
+                "aria-label": t("view_messages"),
+                className: "inline-flex items-center",
+                children: /*#__PURE__*/ jsx(Icon, {
+                    className: `size-3.5 ${colorClass}`
+                })
+            }),
+            /*#__PURE__*/ jsx(TooltipContent, {
+                side: "bottom",
+                className: "max-w-sm",
+                children: /*#__PURE__*/ jsx("div", {
+                    className: "flex flex-col gap-1.5",
+                    children: parsed.map((msg)=>{
+                        const translated = t(msg.key, msg.details);
+                        const displayText = translated === msg.key ? msg.message : translated;
+                        const MIcon = severityIcons[msg.category] ?? Info;
+                        return /*#__PURE__*/ jsxs("div", {
+                            className: "flex items-start gap-1.5",
+                            children: [
+                                /*#__PURE__*/ jsx(MIcon, {
+                                    className: `mt-0.5 size-3 shrink-0 ${severityColors[msg.category] ?? ""}`
+                                }),
+                                /*#__PURE__*/ jsx("span", {
+                                    className: "text-xs",
+                                    children: displayText
+                                })
+                            ]
+                        }, `${msg.key}-${msg.timestamp}-${msg.message}`);
+                    })
+                })
+            })
+        ]
+    });
+};
+export { UserMessagesIcon, UserMessagesView };

package/dist/registry/solution-tests/user-messages.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const UserMessageItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    category: z.ZodEnum<{
+        Error: "Error";
+        Info: "Info";
+        Warning: "Warning";
+    }>;
+    details: z.ZodRecord<z.ZodString, z.ZodString>;
+    timestamp: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type UserMessageItem = z.infer<typeof UserMessageItemSchema>;
+export declare function parseUserMessages(messages: unknown): UserMessageItem[];
+export declare function worstSeverity(messages: UserMessageItem[]): UserMessageItem["category"] | null;
+export declare const severityIcons: {
+    readonly Error: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly Warning: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly Info: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+};
+export declare const severityColors: {
+    readonly Error: "text-destructive";
+    readonly Warning: "text-warning";
+    readonly Info: "text-info";
+};
+export declare const categoryBorderStyles: {
+    readonly Error: "border-l-destructive bg-destructive/10 dark:bg-destructive/25 text-foreground";
+    readonly Warning: "border-l-warning bg-warning/15 dark:bg-warning/25 text-foreground";
+    readonly Info: "border-l-info bg-info/15 dark:bg-info/25 text-foreground";
+};

package/dist/registry/solution-tests/user-messages.js

@@ -0,0 +1,55 @@
+import { AlertCircle, AlertTriangle, Info } from "lucide-react";
+import { z } from "zod";
+const UserMessageItemSchema = z.object({
+    key: z.string(),
+    category: z["enum"]([
+        "Error",
+        "Warning",
+        "Info"
+    ]),
+    details: z.record(z.string(), z.string()),
+    timestamp: z.string(),
+    message: z.string()
+});
+function parseUserMessages(messages) {
+    let value = messages;
+    if ("string" == typeof value) try {
+        value = JSON.parse(value);
+    } catch  {
+        return [];
+    }
+    if (!Array.isArray(value)) return [];
+    const items = [];
+    for (const entry of value){
+        const result = UserMessageItemSchema.safeParse(entry);
+        if (result.success) items.push(result.data);
+    }
+    return items;
+}
+const SEVERITY_ORDER = {
+    Error: 2,
+    Warning: 1,
+    Info: 0
+};
+function worstSeverity(messages) {
+    if (0 === messages.length) return null;
+    let worst = messages[0].category;
+    for (const msg of messages)if (SEVERITY_ORDER[msg.category] > SEVERITY_ORDER[worst]) worst = msg.category;
+    return worst;
+}
+const severityIcons = {
+    Error: AlertCircle,
+    Warning: AlertTriangle,
+    Info: Info
+};
+const severityColors = {
+    Error: "text-destructive",
+    Warning: "text-warning",
+    Info: "text-info"
+};
+const categoryBorderStyles = {
+    Error: "border-l-destructive bg-destructive/10 dark:bg-destructive/25 text-foreground",
+    Warning: "border-l-warning bg-warning/15 dark:bg-warning/25 text-foreground",
+    Info: "border-l-info bg-info/15 dark:bg-info/25 text-foreground"
+};
+export { UserMessageItemSchema, categoryBorderStyles, parseUserMessages, severityColors, severityIcons, worstSeverity };

package/dist/registry/solution-tests/utils.d.ts

@@ -0,0 +1,13 @@
+export declare function isRunDone(status: number): boolean;
+/** Compare dot-separated versions by numeric segment: 1 if a>b, -1 if a<b, else
+ *  0. Segments that aren't strictly numeric (e.g. "1-beta") are skipped, so
+ *  annotated/pre-release versions compare equal and show no glyph. */
+export declare function compareVersions(a: string, b: string): number;
+export interface VersionDelta {
+    changed: boolean;
+    /** 0 also covers "can't tell a direction" (non-numeric or missing), so callers
+     *  can treat it as "no arrow to show". */
+    direction: number;
+}
+export declare function versionDelta(baseline?: string | number | null, actual?: string | number | null): VersionDelta;
+export declare function hasAutoPass(evaluatorResults: unknown): boolean;

package/dist/registry/solution-tests/utils.js

@@ -0,0 +1,48 @@
+import { RunStatus } from "./types.js";
+function isRunDone(status) {
+    return status !== RunStatus.Pending && status !== RunStatus.Running;
+}
+function compareVersions(a, b) {
+    const pa = a.split(".");
+    const pb = b.split(".");
+    const len = Math.max(pa.length, pb.length);
+    for(let i = 0; i < len; i++){
+        const na = Number(pa[i] ?? "0");
+        const nb = Number(pb[i] ?? "0");
+        if (!(Number.isNaN(na) || Number.isNaN(nb)) && na !== nb) return na > nb ? 1 : -1;
+    }
+    return 0;
+}
+function isNumericVersion(v) {
+    return v.split(".").every((seg)=>"" !== seg && !Number.isNaN(Number(seg)));
+}
+function versionDelta(baseline, actual) {
+    if (null == baseline || null == actual) return {
+        changed: false,
+        direction: 0
+    };
+    const b = String(baseline);
+    const a = String(actual);
+    if (isNumericVersion(a) && isNumericVersion(b)) {
+        const direction = compareVersions(a, b);
+        return {
+            changed: 0 !== direction,
+            direction
+        };
+    }
+    return {
+        changed: a !== b,
+        direction: 0
+    };
+}
+function hasAutoPass(evaluatorResults) {
+    let parsed = evaluatorResults;
+    if ("string" == typeof parsed) try {
+        parsed = JSON.parse(parsed);
+    } catch  {
+        return false;
+    }
+    if ("object" != typeof parsed || null === parsed) return false;
+    return Object.prototype.hasOwnProperty.call(parsed, "auto_pass");
+}
+export { compareVersions, hasAutoPass, isRunDone, versionDelta };

package/dist/registry/solution-tests/version-delta-glyph.d.ts

@@ -0,0 +1,6 @@
+interface VersionDeltaGlyphProps {
+    direction: number;
+    baseline?: string | null;
+}
+export declare const VersionDeltaGlyph: ({ direction, baseline, }: VersionDeltaGlyphProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/registry/solution-tests/version-delta-glyph.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { Tooltip, TooltipContent, TooltipTrigger } from "../tooltip/tooltip.js";
+const VersionDeltaGlyph = ({ direction, baseline })=>{
+    const { t } = useVertexTranslation();
+    if (0 === direction) return null;
+    const label = t("version_differs_from_baseline");
+    return /*#__PURE__*/ jsxs(Tooltip, {
+        children: [
+            /*#__PURE__*/ jsx(TooltipTrigger, {
+                asChild: true,
+                children: /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    "aria-label": label,
+                    className: "text-foreground",
+                    onClick: (e)=>e.stopPropagation(),
+                    children: direction > 0 ? "▲" : "▼"
+                })
+            }),
+            /*#__PURE__*/ jsx(TooltipContent, {
+                children: baseline ? `${label} (${baseline})` : label
+            })
+        ]
+    });
+};
+export { VersionDeltaGlyph };

package/dist/registry/sonner/sonner.d.ts

@@ -0,0 +1,4 @@
+import { type ToasterProps } from "sonner";
+export declare const apolloToastClassNames: NonNullable<NonNullable<ToasterProps["toastOptions"]>["classNames"]>;
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { Toaster };

package/dist/registry/sonner/sonner.js

@@ -0,0 +1,52 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { CircleCheckIcon, InfoIcon, Loader2Icon, OctagonXIcon, TriangleAlertIcon } from "lucide-react";
+import { useTheme } from "next-themes";
+import { Toaster } from "sonner";
+const iconAlign = "[&>[data-icon]]:!items-start [&>[data-icon]>svg]:!mt-0.5";
+const statusTextClasses = "[&>[data-icon]>svg]:!text-[oklch(0.166_0.0283_203.34)] dark:[&>[data-icon]>svg]:!text-foreground [&_[data-title]]:!text-[oklch(0.166_0.0283_203.34)] dark:[&_[data-title]]:!text-foreground [&_[data-description]]:!text-[oklch(0.166_0.0283_203.34)] dark:[&_[data-description]]:!text-foreground [&_[data-close-button]]:!text-[oklch(0.166_0.0283_203.34)] dark:[&_[data-close-button]]:!text-foreground";
+const apolloToastClassNames = {
+    info: `!border-info !bg-card-foreground dark:!bg-card-foreground [&>[data-icon]>svg]:!text-primary-foreground [&_[data-title]]:!text-primary-foreground [&_[data-description]]:!text-primary-foreground [&_[data-close-button]]:!text-primary-foreground ${iconAlign}`,
+    success: `!border-success !bg-[color-mix(in_srgb,var(--success)_25%,var(--card)_75%)] dark:!bg-[color-mix(in_srgb,var(--success)_25%,var(--popover)_75%)] ${statusTextClasses} ${iconAlign}`,
+    warning: `!border-warning !bg-[color-mix(in_srgb,var(--warning)_60%,var(--card)_40%)] dark:!bg-[color-mix(in_srgb,var(--warning)_60%,var(--popover)_40%)] ${statusTextClasses} ${iconAlign}`,
+    error: `!border-destructive !bg-[color-mix(in_srgb,var(--destructive)_50%,var(--card)_50%)] dark:!bg-[color-mix(in_srgb,var(--destructive)_50%,var(--popover)_50%)] ${statusTextClasses} ${iconAlign}`,
+    closeButton: "!left-auto !right-2 !top-2 !transform-none !border-none !bg-transparent !rounded-sm"
+};
+const sonner_Toaster = ({ ...props })=>{
+    const { theme = "system" } = useTheme();
+    return /*#__PURE__*/ jsx(Toaster, {
+        theme: "light" === theme || "dark" === theme || "system" === theme ? theme : "system",
+        className: "toaster group",
+        position: "top-center",
+        duration: 5000,
+        closeButton: true,
+        icons: {
+            success: /*#__PURE__*/ jsx(CircleCheckIcon, {
+                className: "size-4"
+            }),
+            info: /*#__PURE__*/ jsx(InfoIcon, {
+                className: "size-4"
+            }),
+            warning: /*#__PURE__*/ jsx(TriangleAlertIcon, {
+                className: "size-4"
+            }),
+            error: /*#__PURE__*/ jsx(OctagonXIcon, {
+                className: "size-4"
+            }),
+            loading: /*#__PURE__*/ jsx(Loader2Icon, {
+                className: "size-4 animate-spin"
+            })
+        },
+        style: {
+            "--normal-bg": "var(--popover)",
+            "--normal-text": "var(--popover-foreground)",
+            "--normal-border": "var(--border)",
+            "--border-radius": "var(--radius)"
+        },
+        toastOptions: {
+            classNames: apolloToastClassNames
+        },
+        ...props
+    });
+};
+export { sonner_Toaster as Toaster, apolloToastClassNames };

package/dist/registry/spinner/spinner.d.ts

@@ -0,0 +1,2 @@
+declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): import("react/jsx-runtime").JSX.Element;
+export { Spinner };

package/dist/registry/spinner/spinner.js

@@ -0,0 +1,12 @@
+import { jsx } from "react/jsx-runtime";
+import { Loader2Icon } from "lucide-react";
+import { cn } from "../../lib/utils.js";
+function Spinner({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Loader2Icon, {
+        role: "status",
+        "aria-label": "Loading",
+        className: cn("size-4 animate-spin", className),
+        ...props
+    });
+}
+export { Spinner };

package/dist/registry/stepper/index.d.ts

@@ -0,0 +1,7 @@
+export { Stepper, type StepperProps, stepperVariants } from "./stepper";
+export { StepperContent, StepperDescription, StepperTitle, } from "./stepper-content";
+export type { StepperItemState, StepperOrientation, } from "./stepper-context";
+export { StepperIndicator } from "./stepper-indicator";
+export { StepperItem, type StepperItemProps, stepperItemVariants, } from "./stepper-item";
+export { StepperSeparator } from "./stepper-separator";
+export { StepperTrigger } from "./stepper-trigger";

package/dist/registry/stepper/index.js

@@ -0,0 +1,7 @@
+import { Stepper, stepperVariants } from "./stepper.js";
+import { StepperContent, StepperDescription, StepperTitle } from "./stepper-content.js";
+import { StepperIndicator } from "./stepper-indicator.js";
+import { StepperItem, stepperItemVariants } from "./stepper-item.js";
+import { StepperSeparator } from "./stepper-separator.js";
+import { StepperTrigger } from "./stepper-trigger.js";
+export { Stepper, StepperContent, StepperDescription, StepperIndicator, StepperItem, StepperSeparator, StepperTitle, StepperTrigger, stepperItemVariants, stepperVariants };

package/dist/registry/stepper/stepper-content.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentProps } from "react";
+declare function StepperContent({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function StepperTitle({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function StepperDescription({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { StepperContent, StepperDescription, StepperTitle };

package/dist/registry/stepper/stepper-content.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../lib/utils.js";
+import { useStepperItemContext } from "./stepper-context.js";
+function StepperContent({ className, ...props }) {
+    return /*#__PURE__*/ jsx("span", {
+        "data-slot": "stepper-content",
+        className: cn("flex flex-col gap-0.5", className),
+        ...props
+    });
+}
+function StepperTitle({ className, ...props }) {
+    const { state } = useStepperItemContext();
+    return /*#__PURE__*/ jsx("span", {
+        "data-slot": "stepper-title",
+        "data-state": state,
+        className: cn("text-sm font-medium leading-snug", "data-[state=inactive]:text-muted-foreground", className),
+        ...props
+    });
+}
+function StepperDescription({ className, ...props }) {
+    return /*#__PURE__*/ jsx("span", {
+        "data-slot": "stepper-description",
+        className: cn("text-muted-foreground text-xs leading-normal", className),
+        ...props
+    });
+}
+export { StepperContent, StepperDescription, StepperTitle };

package/dist/registry/stepper/stepper-context.d.ts

@@ -0,0 +1,16 @@
+type StepperOrientation = "horizontal" | "vertical";
+type StepperItemState = "active" | "completed" | "inactive";
+interface StepperContextValue {
+    activeStep: number;
+    orientation: StepperOrientation;
+}
+declare const StepperContext: import("react").Context<StepperContextValue | null>;
+declare function useStepperContext(): StepperContextValue;
+interface StepperItemContextValue {
+    step: number;
+    state: StepperItemState;
+}
+declare const StepperItemContext: import("react").Context<StepperItemContextValue | null>;
+declare function useStepperItemContext(): StepperItemContextValue;
+export { StepperContext, StepperItemContext, useStepperContext, useStepperItemContext, };
+export type { StepperContextValue, StepperItemContextValue, StepperItemState, StepperOrientation, };

package/dist/registry/stepper/stepper-context.js

@@ -0,0 +1,15 @@
+"use client";
+import { createContext, useContext } from "react";
+const StepperContext = createContext(null);
+function useStepperContext() {
+    const context = useContext(StepperContext);
+    if (!context) throw new Error("Stepper components must be used within a <Stepper>.");
+    return context;
+}
+const StepperItemContext = createContext(null);
+function useStepperItemContext() {
+    const context = useContext(StepperItemContext);
+    if (!context) throw new Error("Stepper item parts must be used within a <StepperItem>.");
+    return context;
+}
+export { StepperContext, StepperItemContext, useStepperContext, useStepperItemContext };

package/dist/registry/stepper/stepper-indicator.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentProps } from "react";
+declare function StepperIndicator({ className, children, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { StepperIndicator };

package/dist/registry/stepper/stepper-indicator.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { CheckIcon } from "lucide-react";
+import { cn } from "../../lib/utils.js";
+import { useStepperItemContext } from "./stepper-context.js";
+function StepperIndicator({ className, children, ...props }) {
+    const { step, state } = useStepperItemContext();
+    return /*#__PURE__*/ jsx("span", {
+        "data-slot": "stepper-indicator",
+        "data-state": state,
+        className: cn("flex size-8 shrink-0 items-center justify-center rounded-full border text-sm font-medium transition-colors", "data-[state=inactive]:border-border data-[state=inactive]:text-muted-foreground", "data-[state=active]:border-primary data-[state=active]:bg-primary data-[state=active]:text-primary-foreground", "data-[state=completed]:border-primary data-[state=completed]:bg-primary data-[state=completed]:text-primary-foreground", className),
+        ...props,
+        children: "completed" === state ? /*#__PURE__*/ jsx(CheckIcon, {
+            className: "size-4"
+        }) : children ?? step + 1
+    });
+}
+export { StepperIndicator };

package/dist/registry/stepper/stepper-item.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentProps } from "react";
+declare const stepperItemVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface StepperItemProps extends ComponentProps<"li"> {
+    step: number;
+    completed?: boolean;
+}
+declare function StepperItem({ className, step, completed, ...props }: StepperItemProps): import("react/jsx-runtime").JSX.Element;
+export { StepperItem, stepperItemVariants };
+export type { StepperItemProps };

package/dist/registry/stepper/stepper-item.js

@@ -0,0 +1,41 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+import { useMemo } from "react";
+import { cn } from "../../lib/utils.js";
+import { StepperItemContext, useStepperContext } from "./stepper-context.js";
+const stepperItemVariants = cva("group/stepper-item flex", {
+    variants: {
+        orientation: {
+            horizontal: "flex-1 items-center gap-3 last:flex-none",
+            vertical: "flex-col gap-2"
+        }
+    },
+    defaultVariants: {
+        orientation: "horizontal"
+    }
+});
+function StepperItem({ className, step, completed, ...props }) {
+    const { activeStep, orientation } = useStepperContext();
+    const isCompleted = completed ?? step < activeStep;
+    const state = isCompleted ? "completed" : step === activeStep ? "active" : "inactive";
+    const value = useMemo(()=>({
+            step,
+            state
+        }), [
+        step,
+        state
+    ]);
+    return /*#__PURE__*/ jsx(StepperItemContext.Provider, {
+        value: value,
+        children: /*#__PURE__*/ jsx("li", {
+            "data-slot": "stepper-item",
+            "data-state": state,
+            className: cn(stepperItemVariants({
+                orientation
+            }), className),
+            ...props
+        })
+    });
+}
+export { StepperItem, stepperItemVariants };

package/dist/registry/stepper/stepper-separator.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentProps } from "react";
+declare function StepperSeparator({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+export { StepperSeparator };

package/dist/registry/stepper/stepper-separator.js

@@ -0,0 +1,15 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../lib/utils.js";
+import { useStepperContext, useStepperItemContext } from "./stepper-context.js";
+function StepperSeparator({ className, ...props }) {
+    const { orientation } = useStepperContext();
+    const { state } = useStepperItemContext();
+    return /*#__PURE__*/ jsx("span", {
+        "data-slot": "stepper-separator",
+        "data-state": state,
+        className: cn("bg-border transition-colors data-[state=completed]:bg-primary", "horizontal" === orientation ? "h-px flex-1" : "ms-4 w-px flex-1 self-stretch", className),
+        ...props
+    });
+}
+export { StepperSeparator };

package/dist/registry/stepper/stepper-trigger.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentProps } from "react";
+declare function StepperTrigger({ className, onClick, disabled, children, ...props }: ComponentProps<"button">): import("react/jsx-runtime").JSX.Element;
+export { StepperTrigger };

package/dist/registry/stepper/stepper-trigger.js

@@ -0,0 +1,21 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../lib/utils.js";
+function StepperTrigger({ className, onClick, disabled, children, ...props }) {
+    const interactive = Boolean(onClick) && !disabled;
+    return /*#__PURE__*/ jsx("button", {
+        ...props,
+        ...interactive ? {
+            onClick
+        } : {
+            "aria-disabled": true,
+            tabIndex: -1
+        },
+        type: "button",
+        "data-slot": "stepper-trigger",
+        disabled: disabled,
+        className: cn("flex items-center gap-3 rounded-md text-left outline-none focus-visible:ring-ring/50 focus-visible:ring-[3px]", interactive ? "cursor-pointer" : "cursor-default", className),
+        children: children
+    });
+}
+export { StepperTrigger };