@zentauri-ui/zentauri-components 2.1.6 → 2.1.8

package/src/ui/split-button/split-button-base.tsx

@@ -0,0 +1,232 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { FiChevronDown, FiLoader } from "react-icons/fi";
+
+import {
+  Dropdown,
+  DropdownContent,
+  DropdownItem,
+  DropdownTrigger,
+} from "../dropdown";
+import { buttonVariants } from "../buttons";
+import { cn } from "../../lib/utils";
+
+import type {
+  SplitButtonAppearance,
+  SplitButtonProps,
+  SplitButtonVariant,
+} from "./types";
+import {
+  splitButtonContentVariants,
+  splitButtonDropdownVariants,
+  splitButtonGroupVariants,
+  splitButtonItemDisabledVariants,
+  splitButtonPrimaryVariants,
+  splitButtonRootVariants,
+  splitButtonTriggerVariants,
+} from "./variants";
+
+const variantAppearanceMap = {
+  primary: "default",
+  secondary: "secondary",
+  outline: "outline",
+  ghost: "ghost",
+  danger: "destructive",
+  success: "green",
+} as const satisfies Record<SplitButtonVariant, SplitButtonAppearance>;
+
+function resolveAppearance({
+  appearance,
+  variant,
+}: {
+  appearance?: SplitButtonAppearance;
+  variant?: SplitButtonVariant;
+}) {
+  return appearance ?? (variant ? variantAppearanceMap[variant] : "default");
+}
+
+export function SplitButtonBase({
+  label,
+  onClick,
+  items,
+  disabled = false,
+  loading = false,
+  appearance,
+  variant,
+  size = "md",
+  startIcon,
+  fullWidth = false,
+  open: controlledOpen,
+  defaultOpen = false,
+  onOpenChange,
+  triggerLabel,
+  triggerOn = "click",
+  className,
+  ref,
+  ...rest
+}: SplitButtonProps) {
+  const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen);
+  const isUnavailable = disabled || loading;
+  const resolvedAppearance = resolveAppearance({ appearance, variant });
+  const isControlled = controlledOpen !== undefined;
+  const open = isUnavailable
+    ? false
+    : isControlled
+      ? controlledOpen
+      : uncontrolledOpen;
+
+  const setOpen = (nextOpen: boolean) => {
+    if (isUnavailable && nextOpen) {
+      return;
+    }
+    if (!isControlled) {
+      setUncontrolledOpen(nextOpen);
+    }
+    onOpenChange?.(nextOpen);
+  };
+
+  const fullWidthFlag = fullWidth ? "true" : undefined;
+  const menuLabel = triggerLabel ?? `More ${label} actions`;
+
+  // Shared timeout ref for hover mode: delays close so the cursor can
+  // travel through the mt-2 gap between the button and the menu panel
+  // without dismissing the menu.
+  const hoverCloseRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const scheduleClose = () => {
+    cancelClose();
+    hoverCloseRef.current = setTimeout(() => setOpen(false), 120);
+  };
+
+  const cancelClose = () => {
+    if (hoverCloseRef.current !== null) {
+      clearTimeout(hoverCloseRef.current);
+      hoverCloseRef.current = null;
+    }
+  };
+
+  useEffect(() => cancelClose, []);
+
+  useEffect(() => {
+    if (isUnavailable && !isControlled) {
+      setUncontrolledOpen(false);
+      onOpenChange?.(false);
+    }
+  }, [isUnavailable, onOpenChange, isControlled]);
+
+  const dropdownHoverHandlers =
+    triggerOn === "hover"
+      ? {
+          onMouseEnter: () => {
+            cancelClose();
+            setOpen(true);
+          },
+          onMouseLeave: scheduleClose,
+        }
+      : undefined;
+
+  const contentHoverHandlers =
+    triggerOn === "hover"
+      ? { onMouseEnter: cancelClose, onMouseLeave: scheduleClose }
+      : undefined;
+
+  return (
+    <div
+      ref={ref}
+      data-slot="split-button"
+      data-full-width={fullWidthFlag}
+      className={cn(splitButtonRootVariants({ fullWidth }), className)}
+      {...rest}
+    >
+      <Dropdown
+        open={open}
+        defaultOpen={defaultOpen}
+        onOpenChange={setOpen}
+        data-full-width={fullWidthFlag}
+        className={splitButtonDropdownVariants({ fullWidth })}
+        {...dropdownHoverHandlers}
+      >
+        <div
+          data-slot="split-button-group"
+          data-full-width={fullWidthFlag}
+          className={splitButtonGroupVariants({ fullWidth })}
+        >
+          <button
+            type="button"
+            data-slot="split-button-primary"
+            data-full-width={fullWidthFlag}
+            disabled={isUnavailable}
+            onClick={onClick}
+            className={cn(
+              buttonVariants({ appearance: resolvedAppearance, size }),
+              splitButtonPrimaryVariants(),
+            )}
+          >
+            {loading ? (
+              <FiLoader
+                aria-hidden
+                className="animate-spin"
+                data-slot="split-button-spinner-icon"
+              />
+            ) : (
+              startIcon
+            )}
+            <span>{label}</span>
+            {loading ? (
+              <span className="sr-only" role="status" aria-label="Loading" />
+            ) : null}
+          </button>
+
+          <DropdownTrigger
+            aria-label={menuLabel}
+            disabled={isUnavailable}
+            className={cn(
+              buttonVariants({ appearance: resolvedAppearance, size }),
+              splitButtonTriggerVariants({ size }),
+            )}
+          >
+            <FiChevronDown aria-hidden />
+          </DropdownTrigger>
+        </div>
+
+        <DropdownContent
+          className={splitButtonContentVariants()}
+          placement="bottom"
+          {...contentHoverHandlers}
+        >
+          {items.map((item) => (
+            <DropdownItem
+              key={item.id}
+              leftIcon={item.icon}
+              aria-disabled={item.disabled ? "true" : undefined}
+              className={
+                item.disabled ? splitButtonItemDisabledVariants() : undefined
+              }
+              onClick={(event) => {
+                if (item.disabled) {
+                  event.preventDefault();
+                  event.stopPropagation();
+                }
+              }}
+              onKeyDown={(event) => {
+                if (item.disabled) {
+                  event.preventDefault();
+                  event.stopPropagation();
+                }
+              }}
+              onSelect={() => {
+                setOpen(false);
+                item.onSelect?.();
+              }}
+            >
+              {item.label}
+            </DropdownItem>
+          ))}
+        </DropdownContent>
+      </Dropdown>
+    </div>
+  );
+}
+
+SplitButtonBase.displayName = "SplitButton";

package/src/ui/split-button/split-button.test.tsx

@@ -0,0 +1,208 @@
+import { createRef } from "react";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { describe, expect, it, vi } from "vitest";
+
+import { SplitButton } from "./split-button";
+
+const items = [
+  { id: "save-as", label: "Save As", onSelect: vi.fn() },
+  { id: "export", label: "Export", onSelect: vi.fn() },
+];
+
+describe("SplitButton", () => {
+  it("should render the primary label and menu trigger", () => {
+    render(<SplitButton label="Save" items={items} />);
+
+    expect(screen.getByRole("button", { name: "Save" })).toBeInTheDocument();
+    expect(
+      screen.getByRole("button", { name: /more save actions/i }),
+    ).toHaveAttribute("aria-haspopup", "menu");
+  });
+
+  it("should call onClick from the primary button", async () => {
+    const user = userEvent.setup();
+    const onClick = vi.fn();
+    render(<SplitButton label="Save" items={items} onClick={onClick} />);
+
+    await user.click(screen.getByRole("button", { name: "Save" }));
+
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+
+  it("should open the menu and call an item onSelect", async () => {
+    const user = userEvent.setup();
+    const handleExport = vi.fn();
+    render(
+      <SplitButton
+        label="Save"
+        items={[
+          { id: "save-as", label: "Save As" },
+          { id: "export", label: "Export", onSelect: handleExport },
+        ]}
+      />,
+    );
+
+    await user.click(
+      screen.getByRole("button", { name: /more save actions/i }),
+    );
+    await user.click(await screen.findByRole("menuitem", { name: "Export" }));
+
+    expect(handleExport).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(screen.queryByRole("menuitem", { name: "Export" })).toBeNull();
+    });
+  });
+
+  it("should not open or call actions while disabled", async () => {
+    const user = userEvent.setup();
+    const onClick = vi.fn();
+    render(
+      <SplitButton
+        disabled
+        label="Save"
+        items={[{ id: "export", label: "Export" }]}
+        onClick={onClick}
+      />,
+    );
+
+    const buttons = screen.getAllByRole("button");
+    expect(buttons).toHaveLength(2);
+    const [primary, trigger] = buttons as [HTMLElement, HTMLElement];
+
+    expect(primary).toBeDisabled();
+    expect(trigger).toBeDisabled();
+    await user.click(primary);
+    await user.click(trigger);
+
+    expect(onClick).not.toHaveBeenCalled();
+    expect(screen.queryByRole("menu")).toBeNull();
+  });
+
+  it("should show a spinner and disable both buttons while loading", async () => {
+    const user = userEvent.setup();
+    render(
+      <SplitButton
+        loading
+        label="Saving"
+        items={[{ id: "export", label: "Export" }]}
+      />,
+    );
+
+    expect(
+      screen.getByRole("status", { name: /loading/i }),
+    ).toBeInTheDocument();
+    for (const button of screen.getAllByRole("button")) {
+      expect(button).toBeDisabled();
+    }
+
+    await user.click(
+      screen.getByRole("button", { name: /more saving actions/i }),
+    );
+    expect(screen.queryByRole("menu")).toBeNull();
+  });
+
+  it("should support controlled open state", () => {
+    const onOpenChange = vi.fn();
+    render(
+      <SplitButton
+        open
+        onOpenChange={onOpenChange}
+        label="Save"
+        items={[{ id: "export", label: "Export" }]}
+      />,
+    );
+
+    expect(screen.getByRole("menuitem", { name: "Export" })).toBeVisible();
+    expect(
+      screen.getByRole("button", { name: /more save actions/i }),
+    ).toHaveAttribute("aria-expanded", "true");
+  });
+
+  it("should render start and item icons", async () => {
+    const user = userEvent.setup();
+    render(
+      <SplitButton
+        label="Save"
+        startIcon={<span data-testid="start-icon" />}
+        items={[
+          {
+            id: "export",
+            label: "Export",
+            icon: <span data-testid="item-icon" />,
+          },
+        ]}
+      />,
+    );
+
+    expect(screen.getByTestId("start-icon")).toBeInTheDocument();
+    await user.click(
+      screen.getByRole("button", { name: /more save actions/i }),
+    );
+    expect(screen.getByTestId("item-icon")).toBeInTheDocument();
+  });
+
+  it("should apply variant aliases and fullWidth layout", () => {
+    render(
+      <SplitButton
+        fullWidth
+        label="Save"
+        variant="danger"
+        items={[{ id: "export", label: "Export" }]}
+      />,
+    );
+
+    expect(document.querySelector('[data-slot="split-button"]')).toHaveClass(
+      "w-full",
+    );
+    expect(screen.getByRole("button", { name: "Save" }).className).toMatch(
+      /destructive/,
+    );
+  });
+
+  it("should forward ref to the root element", () => {
+    const ref = createRef<HTMLDivElement>();
+    render(<SplitButton ref={ref} label="Save" items={items} />);
+
+    expect(ref.current?.getAttribute("data-slot")).toBe("split-button");
+  });
+
+  it("should open the menu on hover and close on mouse leave when triggerOn is hover", async () => {
+    const user = userEvent.setup();
+    render(
+      <SplitButton
+        triggerOn="hover"
+        label="Save"
+        items={[{ id: "export", label: "Export" }]}
+      />,
+    );
+
+    const trigger = screen.getByRole("button", { name: /more save actions/i });
+    await user.hover(trigger);
+    expect(
+      await screen.findByRole("menuitem", { name: "Export" }),
+    ).toBeVisible();
+
+    await user.unhover(trigger);
+    await waitFor(() => {
+      expect(screen.queryByRole("menuitem", { name: "Export" })).toBeNull();
+    });
+  });
+
+  it("should not open on hover when disabled with triggerOn hover", async () => {
+    const user = userEvent.setup();
+    render(
+      <SplitButton
+        triggerOn="hover"
+        disabled
+        label="Save"
+        items={[{ id: "export", label: "Export" }]}
+      />,
+    );
+
+    await user.hover(
+      screen.getByRole("button", { name: /more save actions/i }),
+    );
+    expect(screen.queryByRole("menu")).toBeNull();
+  });
+});

package/src/ui/split-button/split-button.tsx

@@ -0,0 +1,9 @@
+// split-button.tsx — default static entry (no framer-motion)
+import { SplitButtonBase } from "./split-button-base";
+import type { SplitButtonProps } from "./types";
+
+export const SplitButton = (props: SplitButtonProps) => {
+  return <SplitButtonBase {...props} />;
+};
+
+SplitButton.displayName = "SplitButton";

package/src/ui/split-button/types.ts

@@ -0,0 +1,46 @@
+import type {
+  ComponentPropsWithRef,
+  MouseEventHandler,
+  ReactNode,
+} from "react";
+
+import type { ButtonSharedStatic } from "../buttons";
+
+export type SplitButtonAppearance = ButtonSharedStatic["appearance"];
+export type SplitButtonSize = Extract<ButtonSharedStatic["size"], string>;
+export type SplitButtonVariant =
+  | "primary"
+  | "secondary"
+  | "outline"
+  | "ghost"
+  | "danger"
+  | "success";
+
+export interface SplitButtonItem {
+  id: string;
+  label: string;
+  icon?: ReactNode;
+  disabled?: boolean;
+  onSelect?: () => void;
+}
+
+export interface SplitButtonProps extends Omit<
+  ComponentPropsWithRef<"div">,
+  "children" | "onClick"
+> {
+  label: string;
+  onClick?: MouseEventHandler<HTMLButtonElement>;
+  items: SplitButtonItem[];
+  disabled?: boolean;
+  loading?: boolean;
+  appearance?: SplitButtonAppearance;
+  variant?: SplitButtonVariant;
+  size?: SplitButtonSize;
+  startIcon?: ReactNode;
+  fullWidth?: boolean;
+  open?: boolean;
+  defaultOpen?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  triggerLabel?: string;
+  triggerOn?: "click" | "hover";
+}

package/src/ui/split-button/variants.ts

@@ -0,0 +1,46 @@
+import { cva } from "class-variance-authority";
+
+import {
+  zuiSplitButtonContent,
+  zuiSplitButtonDropdown,
+  zuiSplitButtonFullWidth,
+  zuiSplitButtonGroup,
+  zuiSplitButtonItemDisabled,
+  zuiSplitButtonPrimary,
+  zuiSplitButtonRoot,
+  zuiSplitButtonTrigger,
+  zuiSplitButtonTriggerSizes,
+} from "../../design-system";
+
+export const splitButtonRootVariants = cva(zuiSplitButtonRoot, {
+  variants: {
+    fullWidth: {
+      true: zuiSplitButtonFullWidth,
+    },
+  },
+});
+export const splitButtonDropdownVariants = cva(zuiSplitButtonDropdown, {
+  variants: {
+    fullWidth: {
+      true: zuiSplitButtonFullWidth,
+    },
+  },
+});
+export const splitButtonGroupVariants = cva(zuiSplitButtonGroup, {
+  variants: {
+    fullWidth: {
+      true: zuiSplitButtonFullWidth,
+    },
+  },
+});
+export const splitButtonPrimaryVariants = cva(zuiSplitButtonPrimary);
+export const splitButtonTriggerVariants = cva(zuiSplitButtonTrigger, {
+  variants: {
+    size: zuiSplitButtonTriggerSizes,
+  },
+  defaultVariants: {
+    size: "md",
+  },
+});
+export const splitButtonContentVariants = cva(zuiSplitButtonContent);
+export const splitButtonItemDisabledVariants = cva(zuiSplitButtonItemDisabled);

package/dist/chunk-3W2UUKWP.js

@@ -1,19 +0,0 @@
-'use strict';
-
-var chunkVA6SB6NN_js = require('./chunk-VA6SB6NN.js');
-var classVarianceAuthority = require('class-variance-authority');
-
-var buttonVariants = classVarianceAuthority.cva(chunkVA6SB6NN_js.zuiButtonBase, {
-  variants: {
-    appearance: chunkVA6SB6NN_js.zuiButtonAppearances,
-    size: chunkVA6SB6NN_js.zuiButtonSizes
-  },
-  defaultVariants: {
-    appearance: "default",
-    size: "md"
-  }
-});
-
-exports.buttonVariants = buttonVariants;
-//# sourceMappingURL=chunk-3W2UUKWP.js.map
-//# sourceMappingURL=chunk-3W2UUKWP.js.map