@zscloud/design 0.2.0

package/dist/components/primitive/select.d.ts

@@ -0,0 +1,74 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const SelectRoot: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * @interface SelectContentProps
+ * @description Select内容组件的属性接口，扩展自Radix UI的Select.Content组件属性
+ * @property {React.ComponentPropsWithoutRef<typeof SelectPrimitive.Portal>} [selectPortalProps] - 传递给SelectPrimitive.Portal组件的属性
+ * @property {boolean} [open] - 是否打开（用于自动 z-index 管理）
+ * @property {number} [zIndex] - 自定义 z-index（覆盖自动计算）
+ * @property {boolean} [disableAutoZIndex] - 是否禁用自动 z-index 管理
+ */
+export interface SelectContentProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content> {
+    selectPortalProps?: React.ComponentPropsWithoutRef<typeof SelectPrimitive.Portal>;
+    open?: boolean;
+    zIndex?: number;
+    disableAutoZIndex?: boolean;
+}
+declare const SelectContent: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface SelectItemProps extends React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> {
+    description?: string;
+}
+declare const SelectItem: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+/**
+ * @interface SelectOptions
+ * @description 定义Select组件的选项结构
+ * @property {React.ReactNode} label - 选项在下拉列表中显示的内容
+ * @property {React.ReactNode} [selectedLabel] - 选项被选中后在Select触发器中显示的内容，如果未提供则使用label
+ * @property {string} [description] - 选项的描述文本，显示在label下方
+ * @property {string} value - 选项的唯一标识值
+ */
+export interface SelectOptions {
+    label: React.ReactNode;
+    selectedLabel?: React.ReactNode;
+    description?: string;
+    value: string;
+}
+/**
+ * @interface SelectProps
+ * @description Select组件的属性接口
+ * @property {SelectOptions[]} options - 可选项数组
+ * @property {string} [defaultValue] - 默认选中的值
+ * @property {string} [value] - 当前选中的值（受控模式）
+ * @property {(value: string) => void} onValueChange - 选中值变化时的回调函数
+ * @property {string} [className] - 应用于Select触发器的自定义CSS类名
+ * @property {string} [placeholder] - 未选择任何选项时显示的占位符文本
+ * @property {string} [emptyPlaceholderText] - 当options为空数组时显示的文本
+ * @property {boolean} [disabled] - 是否禁用Select组件
+ * @property {boolean} [allowClear] - 是否允许清除已选择的值
+ * @property {() => void} [onClear] - 清除值时的回调函数
+ */
+export interface SelectProps {
+    options: SelectOptions[];
+    defaultValue?: string;
+    value?: string;
+    onValueChange: (value: string) => void;
+    className?: string;
+    itemClassName?: string;
+    placeholder?: string;
+    emptyPlaceholderText?: string;
+    disabled?: boolean;
+    allowClear?: boolean;
+    onClear?: () => void;
+    selectPortalProps?: React.ComponentPropsWithoutRef<typeof SelectPrimitive.Portal>;
+    selectContentProps?: React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>;
+}
+declare const Select: (props: SelectProps) => import("react/jsx-runtime").JSX.Element;
+export { Select, SelectRoot, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/components/primitive/selection-cancellation.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface SelectionCancellationProps {
+    selectedCount: number;
+    onCancel: () => void;
+    open: boolean;
+    viewPortClassName?: string;
+}
+export declare const SelectionCancellation: React.FC<SelectionCancellationProps>;
+export {};

package/dist/components/primitive/show.d.ts

@@ -0,0 +1,8 @@
+import { ReactElement } from 'react';
+interface ShowProps<T> {
+    when: T | boolean;
+    fallback?: ReactElement;
+    children: ReactElement;
+}
+export declare const Show: <T>(props: ShowProps<T>) => ReactElement<any, string | import('react').JSXElementConstructor<any>> | null;
+export {};

package/dist/components/primitive/slider.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SliderPrimitive from "@radix-ui/react-slider";
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };

package/dist/components/primitive/spin.d.ts

@@ -0,0 +1,52 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const spinContainerVariants: (props?: ({
+    fullscreen?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const spinIndicatorVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface SpinProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof spinIndicatorVariants> {
+    /**
+     * 是否为加载中状态
+     * @default true
+     */
+    spinning?: boolean;
+    /**
+     * 延迟显示加载效果的时间（防止闪烁，单位：毫秒）
+     * @default 0
+     */
+    delay?: number;
+    /**
+     * 自定义加载指示器
+     */
+    indicator?: React.ReactNode;
+    /**
+     * 当作为包裹元素时，可以自定义描述文案
+     */
+    tip?: React.ReactNode;
+    /**
+     * 组件大小
+     * @default "medium"
+     */
+    size?: "small" | "medium" | "large";
+    /**
+     * 包裹的内容
+     */
+    children?: React.ReactNode;
+    /**
+     * 是否全屏显示
+     * @default true
+     */
+    fullscreen?: boolean;
+    /**
+     * 自定义加载指示器的类名
+     */
+    indicatorClassName?: string;
+    /**
+     * 自定义 tip 的类名
+     */
+    tipClassName?: string;
+}
+declare const Spin: React.ForwardRefExoticComponent<SpinProps & React.RefAttributes<HTMLDivElement>>;
+export { Spin, spinIndicatorVariants, spinContainerVariants };

package/dist/components/primitive/status-badge.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { VariantProps } from 'class-variance-authority';
+declare const statusBadgeVariants: (props?: ({
+    status?: "danger" | "alert" | "positive" | "pending" | "neutral" | "inprogress" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface StatusBadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof statusBadgeVariants> {
+    /**
+     * 状态类型
+     * - pending: 队列/更新 (紫色)
+     * - inprogress: 进行中 (蓝色)
+     * - positive: 成功/正常/启用 (绿色)
+     * - danger: 错误/危险 (红色)
+     * - alert: 警告/异常 (橙色)
+     * - neutral: 系统/停止/不可用 (灰色)
+     */
+    status?: "pending" | "inprogress" | "positive" | "danger" | "alert" | "neutral";
+}
+export declare const StatusBadge: ({ children, className, status, ...rest }: StatusBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/primitive/steps.d.ts

@@ -0,0 +1,75 @@
+import { default as React } from 'react';
+export interface StepItem {
+    /**
+     * 步骤标题
+     */
+    title: React.ReactNode;
+    /**
+     * 步骤描述（可选）
+     */
+    description?: React.ReactNode;
+    /**
+     * 是否禁用点击
+     */
+    disabled?: boolean;
+    /**
+     * 步骤图标（可选，仅在非 progressDot 模式下生效）
+     */
+    icon?: React.ReactNode;
+}
+export interface StepsProps {
+    /**
+     * 步骤配置项
+     */
+    items: StepItem[];
+    /**
+     * 当前步骤索引，从 0 开始
+     * @default 0
+     */
+    current?: number;
+    /**
+     * 步骤条方向
+     * @default "horizontal"
+     */
+    direction?: "horizontal" | "vertical";
+    /**
+     * 是否使用点状步骤条
+     * @default false
+     */
+    progressDot?: boolean;
+    /**
+     * 点击步骤时的回调
+     */
+    onChange?: (current: number) => void;
+    /**
+     * 自定义类名
+     */
+    className?: string;
+    /**
+     * 自定义样式
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * Steps 步骤条组件
+ *
+ * 引导用户按照流程完成任务的导航条。
+ *
+ * @example
+ * ```tsx
+ * <Steps
+ *   current={1}
+ *   progressDot
+ *   direction="vertical"
+ *   items={[
+ *     { title: "基础配置" },
+ *     { title: "资源配置" },
+ *     { title: "系统配置" },
+ *     { title: "预览" },
+ *   ]}
+ *   onChange={(current) => console.log(current)}
+ * />
+ * ```
+ */
+export declare const Steps: React.FC<StepsProps>;
+export default Steps;

package/dist/components/primitive/switch.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/components/primitive/tabs/hooks/use-persist-tab-store.d.ts

@@ -0,0 +1,4 @@
+export declare const usePersistTabState: (contentId: string | number, tabList: any[], routerTabTarget?: string, skip?: boolean) => {
+    onChange: (key: string) => void;
+    activeKey: any;
+};

package/dist/components/primitive/tabs/interface/tab-memo.d.ts

@@ -0,0 +1,5 @@
+export interface ITabMemo {
+    [key: string]: {
+        [key: string]: string;
+    };
+}

package/dist/components/primitive/tabs/store/page-state-store.d.ts

@@ -0,0 +1,17 @@
+import { ITabMemo } from '../interface/tab-memo';
+interface IPageStateStore {
+    tabMemo: ITabMemo;
+    setTabMemo: (tabMemo: ITabMemo) => void;
+}
+export declare const usePageStateStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<IPageStateStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<IPageStateStore, IPageStateStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: IPageStateStore) => void) => () => void;
+        onFinishHydration: (fn: (state: IPageStateStore) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<IPageStateStore, IPageStateStore>>;
+    };
+}>;
+export {};

package/dist/components/primitive/tabs/tabs.d.ts

@@ -0,0 +1,40 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const tabsListVariants: (props?: ({
+    variant?: "outline" | "line" | "card" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const tabsTriggerVariants: (props?: ({
+    variant?: "outline" | "line" | "card" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const TabsRoot: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+export interface TabsListProps extends React.ComponentPropsWithoutRef<typeof TabsPrimitive.List>, VariantProps<typeof tabsListVariants> {
+    children: React.ReactNode;
+}
+declare const TabsList: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
+export interface TabsTriggerProps extends React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>, VariantProps<typeof tabsTriggerVariants> {
+    value: string;
+    label?: React.ReactNode;
+}
+declare const TabsTrigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export type TabsListItem = {
+    value: string;
+    label?: React.ReactNode;
+    content?: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+};
+export interface TabsPrimitiveProps extends VariantProps<typeof tabsListVariants>, React.ComponentPropsWithoutRef<typeof TabsPrimitive.Root> {
+}
+export interface TabsProps extends TabsPrimitiveProps {
+    tabsList: Array<TabsListItem>;
+    forceMount?: true;
+    listClassName?: string;
+    rootClassName?: string;
+    contentClassName?: string;
+    contentId?: string;
+    routerTarget?: string;
+}
+declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsRoot, TabsList, TabsTrigger, TabsContent };

package/dist/components/primitive/tabs/use-persist.d.ts

@@ -0,0 +1,4 @@
+export declare function useTabPersist(contentId: string): {
+    getValue: () => string;
+    onChange: (value: string) => void;
+};

package/dist/components/primitive/tabs/use-store.d.ts

@@ -0,0 +1,25 @@
+export type State = {
+    tabStore: {
+        [pathname: string]: {
+            [contentId: string]: string | undefined;
+        };
+    };
+};
+export type Action = {
+    setTabStore: (pathname: string, contentId?: string, value?: string) => void;
+};
+export declare const useTabStore: import('zustand').UseBoundStore<Omit<Omit<import('zustand').StoreApi<State & Action>, "setState"> & {
+    setState<A extends string | {
+        type: string;
+    }>(partial: (State & Action) | Partial<State & Action> | ((state: State & Action) => (State & Action) | Partial<State & Action>), replace?: boolean | undefined, action?: A | undefined): void;
+}, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<State & Action, State & Action>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: State & Action) => void) => () => void;
+        onFinishHydration: (fn: (state: State & Action) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<State & Action, State & Action>>;
+    };
+}>;

package/dist/components/primitive/tag-list.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { TagProps } from './tag.tsx';
+interface TagItem extends TagProps {
+    label: string;
+    id: string;
+    onClick?: (e: React.MouseEvent) => void;
+}
+interface TagListProps {
+    tags: TagItem[];
+    className?: string;
+    /** 容器宽度，如果不提供则自动计算 */
+    containerWidth?: number;
+}
+/**
+ * TagList 组件 - 用于在表格单元格中展示标签列表
+ * 特点：
+ * 1. 自动处理标签溢出显示 +n
+ * 2. 支持动态列宽调整
+ * 3. 适配虚拟滚动
+ */
+export declare const TagList: React.FC<TagListProps>;
+export {};

package/dist/components/primitive/tag.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { VariantProps } from 'class-variance-authority';
+declare const tagVariants: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    theme?: "blue" | "green" | "lime" | "purple" | "red" | "teal" | "violet" | "yellow" | null | undefined;
+    level?: "base" | "strong" | "weak" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export interface TagProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof tagVariants> {
+    round?: boolean;
+    closable?: boolean;
+    color?: string;
+    onClose?: (event?: React.MouseEvent<Element>) => void;
+    autoOverflowEllipsis?: boolean;
+    disableTooltip?: boolean;
+}
+export declare const Tag: (props: TagProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/primitive/text.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+export interface TextProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Disable automatic tooltip on overflow */
+    disableTooltip?: boolean;
+    /**
+     * Ellipsis mode for text truncation
+     * - 'end': Standard CSS text-overflow: ellipsisMode (default)
+     * - 'middle': JavaScript-based middle truncation (even split: front half + ... + back half)
+     * - 'middle-start': Preserves more of the front, fixed back chars (e.g., "longtext..._id")
+     * - 'middle-end': Preserves more of the back, fixed front chars (e.g., "pre..._longsuffix")
+     */
+    ellipsisMode?: "end" | "middle" | "middle-start" | "middle-end";
+    /**
+     * Maximum character length before truncation (only for middle modes)
+     * @default 35
+     */
+    maxLength?: number;
+    /**
+     * For 'middle-start': chars to preserve at the end (default 9)
+     * For 'middle-end': chars to preserve at the start (default 9)
+     */
+    fixedChars?: number;
+}
+export declare const Text: {
+    ({ className, children, disableTooltip, ellipsisMode, maxLength, fixedChars, ...props }: TextProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/components/primitive/textarea.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    value: string | undefined;
+    showCount?: boolean;
+    maxLength?: number;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/components/primitive/time-picker.d.ts

@@ -0,0 +1,41 @@
+import { PopoverPortal } from '@radix-ui/react-popover';
+import * as React from "react";
+export interface TimeValue {
+    hour: number;
+    minute: number;
+    second: number;
+}
+export interface TimePickerProps {
+    /** 当前值 — 支持原生 Date 或任何包含 hour()/minute()/second() 的类 Moment 对象 */
+    value?: unknown;
+    /**
+     * 值变更回调。
+     * 如果传入的 value 是 Moment-like（有 clone/hour 方法），回调也返回同类型对象。
+     * 否则返回原生 Date。
+     */
+    onChange?: (date: unknown) => void;
+    /**
+     * 当 value 为空（首次选择）时，用来创建初始值的工厂函数。
+     * 例如传入 `() => moment()` 即可让首次返回值也是 Moment 对象。
+     * 如果不传，首次返回 `new Date()`。
+     */
+    createValue?: () => unknown;
+    /** 时间格式。支持 "HH:mm:ss" | "HH:mm"，默认 "HH:mm:ss" */
+    format?: "HH:mm:ss" | "HH:mm";
+    /** 占位文本 */
+    placeholder?: string;
+    /** 在 onChange 之后调用，常用于表单校验（如 FormList 内去重校验） */
+    onAfterChange?: () => void;
+    /** 禁用 */
+    disabled?: boolean;
+    /** 自定义 className（作用于最外层 trigger） */
+    className?: string;
+    /** 组件 id（透传到 trigger） */
+    id?: string;
+    /** Popover portal props */
+    popoverPortalProps?: React.ComponentPropsWithoutRef<typeof PopoverPortal>;
+}
+export declare function TimePicker({ value, onChange, createValue, format, placeholder, onAfterChange, disabled, className, id, popoverPortalProps, }: TimePickerProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace TimePicker {
+    var displayName: string;
+}

package/dist/components/primitive/toast/toast.d.ts

@@ -0,0 +1,17 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+import * as ToastPrimitives from "@radix-ui/react-toast";
+declare const ToastProvider: React.FC<ToastPrimitives.ToastProviderProps>;
+declare const ToastViewport: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastViewportProps & React.RefAttributes<HTMLOListElement>, "ref"> & VariantProps<(props?: ({
+    position?: "fixed" | "absolute" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLOListElement>>;
+declare const Toast: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastProps & React.RefAttributes<HTMLLIElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string> & React.RefAttributes<HTMLLIElement>>;
+declare const ToastAction: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastClose: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const ToastTitle: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastTitleProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ToastDescription: React.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastDescriptionProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>;
+type ToastActionElement = React.ReactElement<typeof ToastAction>;
+export { type ToastProps, type ToastActionElement, ToastProvider, ToastViewport, Toast, ToastTitle, ToastDescription, ToastClose, ToastAction, };

package/dist/components/primitive/toast/toaster.d.ts

@@ -0,0 +1 @@
+export declare function Toaster(): import("react/jsx-runtime").JSX.Element;

package/dist/components/primitive/toast/use-toast.d.ts

@@ -0,0 +1,45 @@
+import { ToastActionElement, ToastProps } from './toast';
+import * as React from "react";
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: ToastActionElement;
+    indicator?: "success";
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType["ADD_TOAST"];
+    toast: ToasterToast;
+} | {
+    type: ActionType["UPDATE_TOAST"];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType["DISMISS_TOAST"];
+    toastId?: ToasterToast["id"];
+} | {
+    type: ActionType["REMOVE_TOAST"];
+    toastId?: ToasterToast["id"];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, "id">;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+export { useToast, toast };

package/dist/components/primitive/tooltip/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Tooltip 组件
+ *
+ * @description 提示组件，用于在用户 hover 或 focus 时显示额外信息
+ *
+ * @param className - 添加到 TooltipContent 的自定义样式类
+ * @param title - 提示内容
+ * @param placement - 提示内容显示方向
+ * @param delayDuration - 提示显示延迟，默认 0 毫秒
+ * @param disappearOnClick - 点击时是否消失，默认 true
+ * @param arrowClassName - 箭头自定义样式类
+ * @param zIndex - 自定义 z-index，不传则自动计算
+ */
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+interface TooltipContentProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {
+    /** 自定义 z-index */
+    zIndex?: number;
+}
+/** 提示内容组件 */
+declare const TooltipContent: React.ForwardRefExoticComponent<TooltipContentProps & React.RefAttributes<HTMLDivElement>>;
+/** 箭头组件 */
+declare const TooltipArrow: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>, "ref"> & React.RefAttributes<SVGSVGElement>>;
+export interface TooltipProps extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Root> {
+    className?: string;
+    title: React.ReactNode;
+    placement?: "topLeft" | "top" | "topRight" | "leftTop" | "left" | "leftBottom" | "rightTop" | "right" | "rightBottom" | "bottomLeft" | "bottom" | "bottomRight";
+    disappearOnClick?: boolean;
+    arrowClassName?: string;
+    /** 自定义 z-index，不传则自动计算 */
+    zIndex?: number;
+}
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipPortal: React.FC<TooltipPrimitive.TooltipPortalProps>;
+declare const TooltipRoot: React.FC<TooltipPrimitive.TooltipProps>;
+declare const Tooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipArrow, TooltipContent, TooltipPortal, TooltipTrigger, TooltipProvider, TooltipRoot, };

package/dist/components/primitive/tooltip/use-placement.d.ts

@@ -0,0 +1,4 @@
+export declare function usePlacement(placement?: string): {
+    titleSide: "top" | "bottom" | "left" | "right" | undefined;
+    titleAlign: "start" | "center" | "end" | undefined;
+};

package/dist/components/primitive/tree/index.d.ts

@@ -0,0 +1,5 @@
+export { Tree } from './tree';
+export type { TreeRef } from './tree';
+export { TreeSelect } from './tree-select';
+export { DefaultTreeNode } from './tree-node';
+export type { TreeNode, TreeProps, TreeSelectProps, TreeMoveEvent, NodeApi, NodeRendererProps, } from './types';

package/dist/components/primitive/tree/tree-node.d.ts

@@ -0,0 +1,17 @@
+import { NodeRendererProps, TreeNode } from './types';
+import * as React from "react";
+export interface DefaultTreeNodeProps<T = unknown> extends NodeRendererProps<TreeNode<T>> {
+    /** 是否显示展开/折叠图标 */
+    showToggle?: boolean;
+    /** 是否显示拖拽手柄 */
+    showDragHandle?: boolean;
+    /** 自定义图标 */
+    icon?: React.ReactNode;
+    /** 自定义额外内容（右侧） */
+    extra?: React.ReactNode;
+}
+/**
+ * 默认的树节点渲染组件
+ */
+export declare function DefaultTreeNode<T = unknown>({ node, style, dragHandle, showToggle, icon, extra, }: DefaultTreeNodeProps<T>): import("react/jsx-runtime").JSX.Element;
+export default DefaultTreeNode;

package/dist/components/primitive/tree/tree-select.d.ts

@@ -0,0 +1,21 @@
+import { TreeSelectProps } from './types';
+/**
+ * TreeSelect 组件
+ *
+ * 带下拉面板的树选择器，支持：
+ * - 搜索过滤
+ * - 虚拟滚动
+ * - 自定义节点渲染
+ *
+ * @example
+ * ```tsx
+ * <TreeSelect
+ *   value={selectedId}
+ *   onChange={(value, node) => setSelectedId(value)}
+ *   data={treeData}
+ *   placeholder="请选择"
+ * />
+ * ```
+ */
+export declare function TreeSelect<T = unknown>({ value, onChange, data, placeholder, disabled, width, dropdownWidth, treeHeight, showSearch, searchPlaceholder, className, emptyText, allowClear, onClear, indent, rowHeight, openByDefault, renderValue, renderNode, portalContainer, }: TreeSelectProps<T>): import("react/jsx-runtime").JSX.Element;
+export default TreeSelect;