@996-design/996-ui 0.1.0

package/dist/types/components/ColorPicker.d.ts

@@ -0,0 +1,143 @@
+import { Color as RcColor, type ColorGenInput, type ColorPickerProps as RcColorPickerProps } from "@996-design/996-color-picker";
+import type { CSSProperties, FC, ReactElement, ReactNode, RefAttributes } from "react";
+import { type TooltipPlacement } from "./Tooltip";
+export type { ColorGenInput };
+export declare const FORMAT_HEX = "hex";
+export declare const FORMAT_RGB = "rgb";
+export declare const FORMAT_HSB = "hsb";
+export type ColorFormatType = typeof FORMAT_HEX | typeof FORMAT_RGB | typeof FORMAT_HSB;
+export type ColorPickerSize = "small" | "medium" | "middle" | "large";
+export type ColorPickerTrigger = "click" | "hover";
+export type ModeType = "single" | "gradient";
+export type Colors<T> = {
+    color: ColorGenInput<T>;
+    percent: number;
+}[];
+export type GradientColor = {
+    color: Color;
+    percent: number;
+}[];
+export type SingleValueType = Color | string;
+export type LineGradientType = {
+    color: SingleValueType;
+    percent: number;
+}[];
+export type ColorValueType = ColorGenInput<Color> | null | LineGradientType;
+type InternalColorInput = ColorGenInput<Color | RcColor> | Colors<Color | RcColor> | null | undefined;
+/** AntD-compatible aggregate color backed by the scoped rc color primitive. */
+export declare class Color {
+    private metaColor;
+    private colors;
+    cleared: boolean;
+    constructor(input: InternalColorInput);
+    toHsb(): {
+        b: number;
+        a: number;
+        h: number;
+        s: number;
+    };
+    toHsbString(): string;
+    toHex(): string;
+    toHexString(): string;
+    toRgb(): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    toRgbString(): string;
+    isGradient(): boolean;
+    getColors(): GradientColor;
+    toCssString(): string;
+    equals(color: Color | null): boolean;
+    toRcColor(): RcColor;
+}
+export interface PresetsItem {
+    readonly colors: (string | Color | LineGradientType)[];
+    readonly defaultOpen?: boolean;
+    readonly key?: string | number;
+    readonly label: ReactNode;
+}
+export interface ColorPickerSemanticClassNames {
+    readonly root?: string;
+    readonly body?: string;
+    readonly content?: string;
+    readonly description?: string;
+    readonly popup?: {
+        readonly root?: string;
+    };
+}
+export interface ColorPickerSemanticStyles {
+    readonly root?: CSSProperties;
+    readonly body?: CSSProperties;
+    readonly content?: CSSProperties;
+    readonly description?: CSSProperties;
+    readonly popupOverlayInner?: CSSProperties;
+    readonly popup?: {
+        readonly root?: CSSProperties;
+    };
+}
+export type ColorPickerClassNames = ColorPickerSemanticClassNames | ((info: {
+    props: ColorPickerProps;
+}) => ColorPickerSemanticClassNames);
+export type ColorPickerStyles = ColorPickerSemanticStyles | ((info: {
+    props: ColorPickerProps;
+}) => ColorPickerSemanticStyles);
+export interface ColorPickerProps extends Omit<RcColorPickerProps, "className" | "defaultValue" | "disabled" | "disabledAlpha" | "onChange" | "onChangeComplete" | "panelRender" | "prefixCls" | "style" | "value"> {
+    readonly allowClear?: boolean;
+    readonly arrow?: boolean | {
+        readonly pointAtCenter?: boolean;
+    };
+    readonly autoAdjustOverflow?: boolean;
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: ColorPickerClassNames;
+    readonly defaultFormat?: ColorFormatType;
+    readonly defaultOpen?: boolean;
+    readonly defaultValue?: ColorValueType;
+    readonly destroyOnHidden?: boolean;
+    /** @deprecated Use `destroyOnHidden`. */
+    readonly destroyTooltipOnHide?: boolean;
+    readonly disabled?: boolean;
+    readonly disabledAlpha?: boolean;
+    readonly disabledFormat?: boolean;
+    readonly format?: ColorFormatType;
+    readonly getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    readonly mode?: ModeType | ModeType[];
+    readonly open?: boolean;
+    readonly panelRender?: (panel: ReactNode, extra: {
+        components: {
+            Picker: FC;
+            Presets: FC;
+        };
+    }) => ReactNode;
+    readonly placement?: TooltipPlacement;
+    readonly presets?: PresetsItem[];
+    readonly rootClassName?: string;
+    readonly showText?: boolean | ((color: Color) => ReactNode);
+    readonly size?: ColorPickerSize;
+    readonly style?: CSSProperties;
+    readonly styles?: ColorPickerStyles;
+    readonly trigger?: ColorPickerTrigger;
+    readonly value?: ColorValueType;
+    readonly onChange?: (color: Color, css: string) => void;
+    readonly onChangeComplete?: (color: Color) => void;
+    readonly onClear?: () => void;
+    readonly onFormatChange?: (format?: ColorFormatType) => void;
+    readonly onOpenChange?: (open: boolean) => void;
+    readonly [dataAttribute: `data-${string}`]: string | number | undefined;
+}
+export interface ColorPickerPanelProps extends Omit<ColorPickerProps, "arrow" | "autoAdjustOverflow" | "children" | "classNames" | "defaultOpen" | "destroyOnHidden" | "destroyTooltipOnHide" | "getPopupContainer" | "onOpenChange" | "open" | "placement" | "rootClassName" | "showText" | "size" | "styles" | "trigger"> {
+}
+export interface ColorPickerRef {
+    readonly nativeElement: HTMLElement | null;
+    blur: () => void;
+    focus: (options?: FocusOptions) => void;
+}
+declare const InternalColorPickerPanel: import("react").ForwardRefExoticComponent<ColorPickerPanelProps & RefAttributes<HTMLDivElement>>;
+type ColorPickerComponent = ((props: ColorPickerProps & RefAttributes<ColorPickerRef>) => ReactElement) & {
+    _InternalPanelDoNotUseOrYouWillBeFired: typeof InternalColorPickerPanel;
+    Panel: typeof InternalColorPickerPanel;
+    displayName?: string;
+};
+export declare const ColorPicker: ColorPickerComponent;

package/dist/types/components/DataDisplayPrimitives.d.ts

@@ -0,0 +1,205 @@
+import RcImage, { type ImageProps as RcImagePrimitiveProps } from "@rc-component/image";
+import type { CellRenderInfo, Locale } from "@rc-component/picker/interface";
+import { type QRProps as RcQRCodeProps } from "@rc-component/qrcode";
+import { type TourProps as RcTourPrimitiveProps, type TourStepInfo as RcTourStepInfo } from "@rc-component/tour";
+import RcTree, { type BasicDataNode as RcBasicTreeNode, type DataNode as RcTreeDataNode, type TreeProps as RcTreePrimitiveProps } from "@rc-component/tree";
+import { type Dayjs } from "dayjs";
+import "dayjs/locale/zh-cn";
+import type { CSSProperties, ComponentProps, HTMLAttributes, Key, ReactElement, ReactNode, RefAttributes } from "react";
+import { Button } from "./Button";
+import { type BreakpointValues } from "./Grid";
+import { type StepItem, type StepsProps } from "./Steps";
+export type CalendarMode = "year" | "month";
+export type CalendarValue = Dayjs | Date;
+export interface CalendarSelectInfo {
+    readonly source: "year" | "month" | "date" | "customize";
+}
+export type CalendarCellRenderInfo<DateType extends CalendarValue> = Omit<CellRenderInfo<Dayjs>, "today"> & {
+    readonly today: DateType;
+};
+export type CalendarHeaderRender<DateType extends CalendarValue> = (config: {
+    readonly value: DateType;
+    readonly type: CalendarMode;
+    readonly onChange: (date: DateType) => void;
+    readonly onTypeChange: (type: CalendarMode) => void;
+}) => ReactNode;
+export interface CalendarProps<DateType extends CalendarValue = CalendarValue> extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange" | "onSelect"> {
+    readonly cellRender?: (date: DateType, info: CalendarCellRenderInfo<DateType>) => ReactNode;
+    readonly dateCellRender?: (date: DateType) => ReactNode;
+    readonly dateFullCellRender?: (date: DateType) => ReactNode;
+    readonly defaultValue?: DateType;
+    readonly disabledDate?: (date: DateType) => boolean;
+    readonly fullCellRender?: (date: DateType, info: CalendarCellRenderInfo<DateType>) => ReactNode;
+    readonly fullscreen?: boolean;
+    readonly headerRender?: CalendarHeaderRender<DateType>;
+    readonly locale?: Locale;
+    readonly mode?: CalendarMode;
+    readonly monthCellRender?: (date: DateType) => ReactNode;
+    readonly monthFullCellRender?: (date: DateType) => ReactNode;
+    readonly onChange?: (date: DateType) => void;
+    readonly onPanelChange?: (date: DateType, mode: CalendarMode) => void;
+    readonly onSelect?: (date: DateType, selectInfo: CalendarSelectInfo) => void;
+    readonly rootClassName?: string;
+    readonly showWeek?: boolean;
+    readonly validRange?: readonly [DateType, DateType];
+    readonly value?: DateType;
+}
+export declare function Calendar<DateType extends CalendarValue = CalendarValue>({ cellRender, className, dateCellRender, dateFullCellRender, defaultValue, disabledDate, fullCellRender, fullscreen, headerRender, locale, mode, monthCellRender, monthFullCellRender, onChange, onPanelChange, onSelect, rootClassName, showWeek, validRange, value, ...props }: CalendarProps<DateType>): import("react").JSX.Element;
+type DescriptionSlot = "root" | "header" | "title" | "extra" | "label" | "content";
+export interface DescriptionItem {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: Partial<Record<"label" | "content", string>>;
+    readonly contentStyle?: CSSProperties;
+    readonly key?: Key;
+    readonly label?: ReactNode;
+    readonly labelStyle?: CSSProperties;
+    readonly span?: number | "filled" | BreakpointValues<number>;
+    readonly style?: CSSProperties;
+    readonly styles?: Partial<Record<"label" | "content", CSSProperties>>;
+}
+export interface DescriptionsProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    readonly bordered?: boolean;
+    readonly classNames?: Partial<Record<DescriptionSlot, string>>;
+    readonly colon?: boolean;
+    readonly column?: number | BreakpointValues<number>;
+    readonly contentStyle?: CSSProperties;
+    readonly extra?: ReactNode;
+    readonly items?: readonly DescriptionItem[];
+    readonly labelStyle?: CSSProperties;
+    readonly layout?: "horizontal" | "vertical";
+    readonly rootClassName?: string;
+    readonly size?: "small" | "medium" | "middle" | "large" | "default";
+    readonly styles?: Partial<Record<DescriptionSlot, CSSProperties>>;
+    readonly title?: ReactNode;
+}
+declare function DescriptionsItem(_props: DescriptionItem): null;
+declare namespace DescriptionsItem {
+    var displayName: string;
+}
+declare function InternalDescriptions({ bordered, children, className, column, colon, contentStyle, extra, items, labelStyle, layout, rootClassName, size, style, styles, classNames, title, ...props }: DescriptionsProps): import("react").JSX.Element;
+export declare const Descriptions: typeof InternalDescriptions & {
+    Item: typeof DescriptionsItem;
+};
+export type ImagePreviewConfig = Exclude<RcImagePrimitiveProps["preview"], boolean | undefined>;
+export interface ImageProps extends Omit<RcImagePrimitiveProps, "prefixCls" | "previewPrefixCls"> {
+}
+type RcImagePreviewGroupProps = ComponentProps<typeof RcImage.PreviewGroup>;
+export interface ImagePreviewGroupProps extends Omit<RcImagePreviewGroupProps, "previewPrefixCls"> {
+}
+export declare function ImagePreviewGroup({ children, icons, preview, ...props }: ImagePreviewGroupProps): import("react").JSX.Element;
+declare function InternalImage({ alt, className, preview, ...props }: ImageProps): import("react").JSX.Element;
+export declare const Image: typeof InternalImage & {
+    PreviewGroup: typeof ImagePreviewGroup;
+};
+export type QRCodeStatus = "active" | "expired" | "loading" | "scanned";
+export interface QRCodeLocale {
+    readonly expired: string;
+    readonly refresh: string;
+    readonly scanned: string;
+}
+export interface QRCodeStatusRenderInfo {
+    readonly locale: QRCodeLocale;
+    readonly onRefresh?: () => void;
+    readonly status: Exclude<QRCodeStatus, "active">;
+}
+export interface QRCodeProps extends Omit<RcQRCodeProps, "fgColor" | "imageSettings" | "level" | "style" | "title">, Omit<HTMLAttributes<HTMLDivElement>, "children" | "color"> {
+    readonly bordered?: boolean;
+    readonly classNames?: Partial<Record<"cover" | "root", string>>;
+    readonly color?: string;
+    readonly errorLevel?: "L" | "M" | "Q" | "H";
+    readonly icon?: string;
+    readonly iconSize?: number | {
+        readonly height: number;
+        readonly width: number;
+    };
+    readonly imageSettings?: RcQRCodeProps["imageSettings"];
+    readonly rootClassName?: string;
+    readonly status?: QRCodeStatus;
+    readonly statusRender?: (info: QRCodeStatusRenderInfo) => ReactNode;
+    readonly styles?: Partial<Record<"cover" | "root", CSSProperties>>;
+    readonly type?: "canvas" | "svg";
+    readonly onRefresh?: () => void;
+}
+export declare function QRCode({ bgColor, bordered, boostLevel, className, classNames, color, errorLevel, icon, iconSize, imageSettings, includeMargin, marginSize, minVersion, onRefresh, rootClassName, size, status, statusRender, style, styles, title, type, value, ...props }: QRCodeProps): import("react").JSX.Element | null;
+export type TimelineMode = "left" | "right" | "start" | "end" | "alternate";
+export type TimelineItemPlacement = "start" | "end";
+export interface TimelineItem {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: StepItem["classNames"];
+    readonly color?: "blue" | "green" | "red" | "yellow" | "gray" | (string & {});
+    readonly content?: ReactNode;
+    readonly dot?: ReactNode;
+    readonly icon?: ReactNode;
+    readonly key?: Key;
+    readonly label?: ReactNode;
+    readonly loading?: boolean;
+    readonly placement?: TimelineItemPlacement;
+    readonly position?: "left" | "right" | TimelineItemPlacement;
+    readonly style?: CSSProperties;
+    readonly styles?: StepItem["styles"];
+    readonly title?: ReactNode;
+}
+export interface TimelineProps extends Omit<StepsProps, "current" | "initial" | "items" | "onChange" | "orientation" | "titlePlacement" | "type"> {
+    readonly children?: ReactNode;
+    readonly items?: readonly TimelineItem[];
+    readonly mode?: TimelineMode;
+    readonly orientation?: "horizontal" | "vertical";
+    readonly pending?: ReactNode;
+    readonly pendingDot?: ReactNode;
+    readonly reverse?: boolean;
+    readonly titleSpan?: number | string;
+}
+declare function TimelineItemComponent(_props: TimelineItem): null;
+declare namespace TimelineItemComponent {
+    var displayName: string;
+}
+declare function InternalTimeline({ children, className, items, mode, orientation, pending, pendingDot, reverse, rootClassName, style, titleSpan, variant, ...props }: TimelineProps): import("react").JSX.Element;
+export declare const Timeline: typeof InternalTimeline & {
+    Item: typeof TimelineItemComponent;
+};
+export type TreeNode = RcTreeDataNode;
+export type TreeProps<TreeDataType extends RcBasicTreeNode = TreeNode> = Omit<RcTreePrimitiveProps<TreeDataType>, "prefixCls" | "treeData"> & {
+    readonly blockNode?: boolean;
+    readonly treeData?: readonly TreeDataType[];
+};
+export type TreeRef<TreeDataType extends RcBasicTreeNode = TreeNode> = RcTree<TreeDataType>;
+type TreeComponent = <TreeDataType extends RcBasicTreeNode = TreeNode>(props: TreeProps<TreeDataType> & RefAttributes<TreeRef<TreeDataType>>) => ReactElement;
+export type DirectoryTreeExpandAction = false | "click" | "doubleClick";
+export type DirectoryTreeProps<TreeDataType extends RcBasicTreeNode = TreeNode> = TreeProps<TreeDataType> & {
+    readonly expandAction?: DirectoryTreeExpandAction;
+};
+type DirectoryTreeComponent = <TreeDataType extends RcBasicTreeNode = TreeNode>(props: DirectoryTreeProps<TreeDataType> & RefAttributes<TreeRef<TreeDataType>>) => ReactElement;
+export declare const Tree: TreeComponent & {
+    DirectoryTree: DirectoryTreeComponent;
+    TreeNode: import("react").FC<Readonly<import("@rc-component/tree").TreeNodeProps<RcTreeDataNode>>>;
+};
+export type TourType = "default" | "primary";
+export type TourButtonProps = ComponentProps<typeof Button>;
+export type TourActionsRender = (originNode: ReactNode, info: {
+    readonly current: number;
+    readonly total: number;
+}) => ReactNode;
+export type TourIndicatorsRender = (current: number, total: number) => ReactNode;
+export type TourStep = RcTourStepInfo & {
+    readonly actionsRender?: TourActionsRender;
+    readonly cover?: ReactNode;
+    readonly indicatorsRender?: TourIndicatorsRender;
+    readonly nextButtonProps?: TourButtonProps;
+    readonly prevButtonProps?: TourButtonProps;
+    readonly type?: TourType;
+};
+export type TourProps = Omit<RcTourPrimitiveProps, "prefixCls" | "renderPanel" | "steps"> & {
+    readonly actionsRender?: TourActionsRender;
+    readonly indicatorsRender?: TourIndicatorsRender;
+    readonly renderPanel?: RcTourPrimitiveProps["renderPanel"];
+    readonly steps?: readonly TourStep[];
+    readonly type?: TourType;
+};
+export declare function Tour({ actionsRender, animated, indicatorsRender, renderPanel, steps, type, ...props }: TourProps): import("react").JSX.Element;
+export declare function CheckableTag({ checked, children, className, onChange, ...props }: HTMLAttributes<HTMLButtonElement> & {
+    readonly checked?: boolean;
+    readonly onChange?: (checked: boolean) => void;
+}): import("react").JSX.Element;
+export {};