@996-design/996-ui 0.1.0

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

@@ -0,0 +1,102 @@
+import { type NotificationProps as RcNotificationProps, type StackConfig } from "@rc-component/notification";
+import type { CSSProperties, ElementType, HTMLAttributes, Key, ReactElement, ReactNode } from "react";
+import { type ConfigOptions as MessageConfig, type MessageInstance } from "./Message";
+import type { MessageNoticeType } from "./MessageToast";
+import { type HookModalApi } from "./Modal";
+import { FloatButton } from "./feedback/FloatButton";
+import { Watermark } from "./feedback/Watermark";
+export { FloatButton, Watermark };
+export type { FloatButtonBackTopProps, FloatButtonBadgeProps, FloatButtonElement, FloatButtonGroupProps, FloatButtonGroupTrigger, FloatButtonProps, FloatButtonShape, FloatButtonTooltipProps, FloatButtonType, } from "./feedback/FloatButton";
+export type { WatermarkContent, WatermarkFont, WatermarkProps, WatermarkText, } from "./feedback/Watermark";
+export declare const NotificationPlacements: readonly ["top", "topLeft", "topRight", "bottom", "bottomLeft", "bottomRight"];
+export type NotificationPlacement = (typeof NotificationPlacements)[number];
+export type NotificationType = Exclude<MessageNoticeType, "loading">;
+type NotificationSemanticSlot = "list" | "listContent" | "wrapper" | "root" | "title" | "description" | "actions" | "icon" | "section" | "close" | "progress";
+export type NotificationClassNames = Partial<Record<NotificationSemanticSlot, string>>;
+export type NotificationStyles = Partial<Record<NotificationSemanticSlot, CSSProperties>>;
+export type NotificationClosable = RcNotificationProps["closable"];
+type SemanticValue<Value, Props> = Value | ((info: {
+    readonly props: Props;
+}) => Value);
+interface NotificationDivProps extends HTMLAttributes<HTMLDivElement> {
+    readonly "data-testid"?: string;
+}
+export interface NotificationArgs {
+    readonly actions?: ReactNode;
+    /** @deprecated Use `actions`. */
+    readonly btn?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SemanticValue<NotificationClassNames, NotificationArgs>;
+    readonly closable?: NotificationClosable;
+    readonly closeIcon?: ReactNode;
+    readonly description?: ReactNode;
+    readonly duration?: number | false;
+    readonly icon?: ReactNode;
+    readonly key?: Key;
+    /** @deprecated Use `title`. */
+    readonly message?: ReactNode;
+    readonly onClick?: () => void;
+    readonly onClose?: () => void;
+    readonly pauseOnHover?: boolean;
+    readonly placement?: NotificationPlacement;
+    readonly props?: NotificationDivProps;
+    readonly role?: "alert" | "status";
+    readonly showProgress?: boolean;
+    readonly style?: CSSProperties;
+    readonly styles?: SemanticValue<NotificationStyles, NotificationArgs>;
+    readonly title?: ReactNode;
+    readonly type?: NotificationType;
+}
+type NotificationStaticFn = (args: NotificationArgs) => void;
+export interface NotificationInstance {
+    readonly destroy: (key?: Key) => void;
+    readonly error: NotificationStaticFn;
+    readonly info: NotificationStaticFn;
+    readonly open: NotificationStaticFn;
+    readonly success: NotificationStaticFn;
+    readonly warning: NotificationStaticFn;
+}
+export interface NotificationConfig {
+    readonly bottom?: number;
+    readonly classNames?: SemanticValue<NotificationClassNames, NotificationArgs>;
+    readonly closable?: NotificationClosable;
+    readonly closeIcon?: ReactNode;
+    readonly duration?: number | false;
+    readonly getContainer?: () => HTMLElement | ShadowRoot;
+    readonly maxCount?: number;
+    readonly pauseOnHover?: boolean;
+    readonly placement?: NotificationPlacement;
+    readonly prefixCls?: string;
+    readonly props?: NotificationDivProps;
+    readonly rtl?: boolean;
+    readonly showProgress?: boolean;
+    readonly stack?: boolean | StackConfig;
+    readonly styles?: SemanticValue<NotificationStyles, NotificationArgs>;
+    readonly top?: number;
+}
+export type GlobalConfigProps = NotificationConfig;
+export declare function useNotification(notificationConfig?: NotificationConfig): readonly [NotificationInstance, ReactElement];
+export interface NotificationMethods extends NotificationInstance {
+    readonly config: (config: GlobalConfigProps) => void;
+    readonly useNotification: typeof useNotification;
+}
+export declare const notification: NotificationMethods;
+export interface AppConfig {
+    readonly message?: MessageConfig;
+    readonly notification?: NotificationConfig;
+}
+export interface AppProps extends AppConfig {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly component?: ElementType | false;
+    readonly rootClassName?: string;
+    readonly style?: CSSProperties;
+}
+export interface AppApi {
+    readonly message: MessageInstance;
+    readonly modal: HookModalApi;
+    readonly notification: NotificationInstance;
+}
+export declare const App: import("react").ForwardRefExoticComponent<AppProps & import("react").RefAttributes<HTMLElement>> & {
+    useApp(): AppApi;
+};

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

@@ -0,0 +1,67 @@
+import { FormProvider, useForm as useRcForm, useWatch } from "@rc-component/form";
+import type { FieldProps, FormInstance, FormRef, Meta, NamePath, FormProps as RcFormProps, Store, StoreValue, ValidatorRule } from "@rc-component/form";
+import type { HTMLAttributes, ReactElement, ReactNode, RefAttributes } from "react";
+import { useFormItemStatus } from "./form/statusContext";
+import type { FormItemStatus } from "./form/statusContext";
+export type { FormControlStatus, FormItemStatus, FormItemUseStatusResult, } from "./form/statusContext";
+export interface FormProps<Values = Store> extends RcFormProps<Values> {
+    readonly disabled?: boolean;
+    readonly layout?: "horizontal" | "vertical" | "inline";
+}
+type FormItemChildren<Values> = ReactNode | ((form: FormInstance<Values>) => ReactNode);
+export interface FormItemProps<Values = Store> extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onReset">, Omit<FieldProps<Values>, "children"> {
+    readonly children?: FormItemChildren<Values>;
+    readonly help?: ReactNode;
+    readonly htmlFor?: string | null;
+    readonly label?: ReactNode;
+    readonly noStyle?: boolean;
+    readonly required?: boolean;
+    readonly status?: FormItemStatus;
+    readonly validateStatus?: FormItemStatus;
+}
+export interface ErrorListProps {
+    readonly className?: string;
+    readonly errors?: readonly ReactNode[];
+    readonly fieldId?: string;
+    readonly help?: ReactNode;
+    readonly helpStatus?: FormItemStatus;
+    readonly onVisibleChanged?: (visible: boolean) => void;
+    readonly warnings?: readonly ReactNode[];
+}
+export interface FormListFieldData {
+    readonly fieldKey: number;
+    readonly isListField: boolean;
+    readonly key: number;
+    readonly name: number;
+}
+export interface FormListOperation {
+    readonly add: (defaultValue?: StoreValue, insertIndex?: number) => void;
+    readonly move: (from: number, to: number) => void;
+    readonly remove: (index: number | number[]) => void;
+}
+export interface FormListProps<Values = Store> {
+    readonly children: (fields: FormListFieldData[], operation: FormListOperation, meta: Pick<Meta, "errors" | "warnings">) => ReactNode;
+    readonly initialValue?: StoreValue[];
+    readonly name: NamePath<Values>;
+    readonly rules?: ValidatorRule[];
+    readonly validateTrigger?: string | string[] | false;
+}
+declare const FormRoot: <Values = Store>(props: FormProps<Values> & RefAttributes<FormRef<Values>>) => ReactElement;
+declare function useFormInstance<Values = Store>(): FormInstance<Values>;
+export declare function ErrorList({ className, errors, fieldId, help, helpStatus, onVisibleChanged, warnings, }: ErrorListProps): import("react").JSX.Element | null;
+declare function Item<Values = Store>({ children, className, dependencies, getValueFromEvent, getValueProps, help, hidden, htmlFor, initialValue, isList, isListField, label, messageVariables, name, noStyle, normalize, onMetaChange, onReset, preserve, required, rules, shouldUpdate, status, trigger, validateDebounce, validateFirst, validateStatus, validateTrigger, valuePropName, ...itemProps }: FormItemProps<Values>): import("react").JSX.Element;
+type FormItemComponent = typeof Item & {
+    readonly useStatus: typeof useFormItemStatus;
+};
+declare const FormItem: FormItemComponent;
+declare function FormList<Values = Store>({ children, ...props }: FormListProps<Values>): import("react").JSX.Element;
+type FormComponent = typeof FormRoot & {
+    readonly ErrorList: typeof ErrorList;
+    readonly Item: typeof FormItem;
+    readonly List: typeof FormList;
+    readonly Provider: typeof FormProvider;
+    readonly useForm: typeof useRcForm;
+    readonly useFormInstance: typeof useFormInstance;
+    readonly useWatch: typeof useWatch;
+};
+export declare const Form: FormComponent;

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

@@ -0,0 +1,8 @@
+interface GameCoverProps {
+    readonly alt?: string;
+    readonly className?: string;
+    readonly fallback: string;
+    readonly src?: string;
+}
+export declare function GameCover({ alt, className, fallback, src }: GameCoverProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,50 @@
+import type { CSSProperties, HTMLAttributes, ReactNode } from "react";
+export type Breakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl";
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export type BreakpointValues<T> = Partial<Record<Breakpoint, T>>;
+export declare function useBreakpoint(): ScreenMap;
+export declare function useBreakpointValue<T>(values: BreakpointValues<T>, defaultValue?: T): T | undefined;
+export interface GridProps extends HTMLAttributes<HTMLElement> {
+    readonly as?: "div" | "section";
+    readonly children?: ReactNode;
+    readonly columns?: 2 | 3 | 4;
+    readonly gap?: "sm" | "md";
+}
+export type GutterUnit = number | string;
+export type Gutter = GutterUnit | BreakpointValues<GutterUnit> | undefined;
+export type RowAlign = "top" | "middle" | "bottom" | "stretch";
+export type RowJustify = "start" | "end" | "center" | "space-around" | "space-between" | "space-evenly";
+export interface RowProps extends HTMLAttributes<HTMLDivElement> {
+    readonly align?: RowAlign | BreakpointValues<RowAlign>;
+    readonly gutter?: Gutter | readonly [Gutter, Gutter];
+    readonly justify?: RowJustify | BreakpointValues<RowJustify>;
+    readonly prefixCls?: string;
+    readonly wrap?: boolean;
+}
+export declare const Row: import("react").ForwardRefExoticComponent<RowProps & import("react").RefAttributes<HTMLDivElement>>;
+export type ColSpanType = number | string;
+export type FlexType = NonNullable<CSSProperties["flex"]>;
+export interface ColSize {
+    readonly flex?: FlexType;
+    readonly offset?: ColSpanType;
+    readonly order?: ColSpanType;
+    readonly pull?: ColSpanType;
+    readonly push?: ColSpanType;
+    readonly span?: ColSpanType;
+}
+export interface ColProps extends HTMLAttributes<HTMLDivElement>, Partial<Record<Breakpoint, ColSpanType | ColSize>> {
+    readonly flex?: FlexType;
+    readonly offset?: ColSpanType;
+    readonly order?: ColSpanType;
+    readonly prefixCls?: string;
+    readonly pull?: ColSpanType;
+    readonly push?: ColSpanType;
+    readonly span?: ColSpanType;
+}
+export declare const Col: import("react").ForwardRefExoticComponent<ColProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const Grid: import("react").ForwardRefExoticComponent<GridProps & import("react").RefAttributes<HTMLElement>> & {
+    Col: import("react").ForwardRefExoticComponent<ColProps & import("react").RefAttributes<HTMLDivElement>>;
+    Row: import("react").ForwardRefExoticComponent<RowProps & import("react").RefAttributes<HTMLDivElement>>;
+    useBreakpoint: typeof useBreakpoint;
+    useBreakpointValue: typeof useBreakpointValue;
+};

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

@@ -0,0 +1,13 @@
+import type { SVGAttributes } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type IconName = "back" | "bars" | "bell" | "calendar" | "cart" | "check" | "chevron-down" | "chevron-right" | "close" | "copy" | "document" | "download" | "eye" | "flame" | "gamepad" | "gift" | "lock" | "minus" | "plus" | "refresh" | "rocket" | "search" | "shield" | "star" | "tag" | "thumb-up" | "user" | "warning";
+type IconSlot = "root";
+export interface IconProps extends Omit<SVGAttributes<SVGSVGElement>, "children"> {
+    readonly classNames?: SlotClassNames<IconSlot>;
+    readonly name: IconName;
+    readonly size?: 16 | 20 | 22 | 24 | number;
+    readonly strokeWidth?: number;
+    readonly styles?: SlotStyles<IconSlot>;
+}
+export declare function Icon({ className, classNames, name, size, strokeWidth, style, styles, ...props }: IconProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import type { ButtonHTMLAttributes, ReactNode } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type IconButtonTone = "default" | "primary" | "ghost" | "selected";
+export type IconButtonSize = "xs" | "sm" | "md";
+type IconButtonSlot = "root" | "content";
+export interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    readonly children: ReactNode;
+    readonly classNames?: SlotClassNames<IconButtonSlot>;
+    readonly styles?: SlotStyles<IconButtonSlot>;
+    readonly tone?: IconButtonTone;
+    readonly size?: IconButtonSize;
+}
+export declare function IconButton({ children, className, classNames, size, style, styles, tone, type, ...props }: IconButtonProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,110 @@
+import type { InputProps as RcInputProps, InputRef as RcInputRef, TextAreaProps as RcTextAreaProps, TextAreaRef as RcTextAreaRef } from "@rc-component/input";
+import type { InputFocusOptions } from "@rc-component/util";
+import type { ChangeEvent, FocusEvent, HTMLAttributes, InputHTMLAttributes, KeyboardEvent, MouseEvent, ReactElement, ReactNode, RefAttributes } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+import type { FormControlStatus } from "./form/statusContext";
+export type { InputFocusOptions };
+export type InputRef = RcInputRef;
+export type InputStatus = FormControlStatus;
+export type AntdInputSize = "small" | "medium" | "middle" | "large";
+export type InputSize = AntdInputSize | "sm" | "md" | "lg";
+export type AntdInputVariant = "outlined" | "borderless" | "filled" | "underlined";
+export type InputVariant = AntdInputVariant | "default" | "active";
+export type InputVisualSize = "sm" | "md" | "lg";
+type InputSlot = "group" | "root" | "wrapper" | "input" | "prefix" | "suffix" | "clear" | "count" | "addonBefore" | "addonAfter";
+export interface InputProps extends Omit<RcInputProps, "classNames" | "prefixCls" | "styles"> {
+    /** @deprecated Use variant instead. */
+    readonly bordered?: boolean;
+    readonly classNames?: SlotClassNames<InputSlot>;
+    readonly rootClassName?: string;
+    readonly size?: InputSize;
+    readonly status?: InputStatus;
+    readonly styles?: SlotStyles<InputSlot>;
+    readonly variant?: InputVariant;
+}
+export declare function normalizeInputSize(size: InputSize | undefined, fallback?: InputVisualSize): InputVisualSize;
+declare const InternalInput: import("react").ForwardRefExoticComponent<InputProps & RefAttributes<RcInputRef>>;
+export interface GroupProps extends HTMLAttributes<HTMLSpanElement> {
+    readonly compact?: boolean;
+    readonly rootClassName?: string;
+    readonly size?: InputSize;
+}
+declare const InputGroup: import("react").ForwardRefExoticComponent<GroupProps & RefAttributes<HTMLSpanElement>>;
+type SearchSlot = InputSlot | "button";
+export interface SearchProps extends Omit<InputProps, "classNames" | "styles" | "type"> {
+    readonly classNames?: SlotClassNames<SearchSlot>;
+    readonly enterButton?: ReactNode;
+    readonly loading?: boolean;
+    readonly searchIcon?: ReactNode;
+    readonly styles?: SlotStyles<SearchSlot>;
+    readonly onSearch?: (value: string, event?: ChangeEvent<HTMLInputElement> | MouseEvent<HTMLElement> | KeyboardEvent<HTMLInputElement>, info?: {
+        readonly source?: "clear" | "input";
+    }) => void;
+}
+declare const InputSearch: import("react").ForwardRefExoticComponent<SearchProps & RefAttributes<RcInputRef>>;
+export interface PasswordVisibilityToggle {
+    readonly tabIndex?: number;
+    readonly visible?: boolean;
+    readonly onVisibleChange?: (visible: boolean) => void;
+}
+export interface PasswordProps extends InputProps {
+    readonly action?: "click" | "hover";
+    readonly iconRender?: (visible: boolean) => ReactNode;
+    readonly visibilityToggle?: boolean | PasswordVisibilityToggle;
+}
+declare const InputPassword: import("react").ForwardRefExoticComponent<PasswordProps & RefAttributes<RcInputRef>>;
+type TextAreaSlot = "root" | "textarea" | "clear" | "count";
+export interface TextAreaProps extends Omit<RcTextAreaProps, "classNames" | "prefixCls" | "styles" | "suffix"> {
+    /** @deprecated Use variant instead. */
+    readonly bordered?: boolean;
+    readonly classNames?: SlotClassNames<TextAreaSlot>;
+    readonly rootClassName?: string;
+    readonly size?: InputSize;
+    readonly status?: InputStatus;
+    readonly styles?: SlotStyles<TextAreaSlot>;
+    readonly variant?: InputVariant;
+}
+export interface TextAreaRef {
+    readonly nativeElement: HTMLElement | null;
+    readonly resizableTextArea?: RcTextAreaRef["resizableTextArea"];
+    readonly blur: () => void;
+    readonly focus: (options?: InputFocusOptions) => void;
+}
+declare const InputTextArea: import("react").ForwardRefExoticComponent<TextAreaProps & RefAttributes<TextAreaRef>>;
+type OTPSlot = "root" | "input" | "separator";
+export interface OTPProps extends Omit<HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange" | "onFocus" | "onInput"> {
+    readonly autoComplete?: string;
+    readonly classNames?: SlotClassNames<OTPSlot>;
+    readonly defaultValue?: string;
+    readonly disabled?: boolean;
+    readonly formatter?: (value: string) => string;
+    readonly inputMode?: InputHTMLAttributes<HTMLInputElement>["inputMode"];
+    readonly length?: number;
+    readonly mask?: boolean | string;
+    readonly rootClassName?: string;
+    readonly separator?: ReactNode | ((index: number) => ReactNode);
+    readonly size?: InputSize;
+    readonly status?: InputStatus;
+    readonly styles?: SlotStyles<OTPSlot>;
+    readonly type?: InputHTMLAttributes<HTMLInputElement>["type"];
+    readonly value?: string;
+    readonly variant?: InputVariant;
+    readonly onChange?: (value: string) => void;
+    readonly onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
+    readonly onInput?: (value: string[]) => void;
+}
+export interface OTPRef {
+    readonly nativeElement: HTMLDivElement;
+    readonly blur: () => void;
+    readonly focus: () => void;
+}
+declare const InputOTP: import("react").ForwardRefExoticComponent<OTPProps & RefAttributes<OTPRef>>;
+type CompoundedInput = typeof InternalInput & {
+    Group: typeof InputGroup;
+    OTP: typeof InputOTP;
+    Password: typeof InputPassword;
+    Search: typeof InputSearch;
+    TextArea: typeof InputTextArea;
+};
+export declare const Input: CompoundedInput;
+export type InputComponent = (props: InputProps & RefAttributes<InputRef>) => ReactElement | null;

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

@@ -0,0 +1,29 @@
+import type { InputNumberProps as RcInputNumberProps, InputNumberRef as RcInputNumberRef, ValueType } from "@rc-component/input-number";
+import type { CSSProperties, ReactElement, ReactNode, RefAttributes } from "react";
+import { type InputSize, type InputStatus, type InputVariant } from "./Input";
+export type InputNumberRef = RcInputNumberRef;
+export type InputNumberValue = ValueType;
+type InputNumberSlot = "group" | "root" | "prefix" | "suffix" | "input" | "actions" | "action" | "addonBefore" | "addonAfter";
+export type InputNumberClassNames = Partial<Record<InputNumberSlot, string>>;
+export type InputNumberStyles = Partial<Record<InputNumberSlot, CSSProperties>>;
+export interface InputNumberControls {
+    readonly downIcon?: ReactNode;
+    readonly upIcon?: ReactNode;
+}
+export interface InputNumberProps<T extends ValueType = ValueType> extends Omit<RcInputNumberProps<T>, "className" | "classNames" | "controls" | "prefixCls" | "size" | "style" | "styles"> {
+    readonly addonAfter?: ReactNode;
+    readonly addonBefore?: ReactNode;
+    /** @deprecated Use variant instead. */
+    readonly bordered?: boolean;
+    readonly className?: string;
+    readonly classNames?: InputNumberClassNames;
+    readonly controls?: boolean | InputNumberControls;
+    readonly rootClassName?: string;
+    readonly size?: InputSize;
+    readonly status?: InputStatus;
+    readonly style?: CSSProperties;
+    readonly styles?: InputNumberStyles;
+    readonly variant?: InputVariant;
+}
+export declare const InputNumber: <T extends ValueType = ValueType>(props: InputNumberProps<T> & RefAttributes<InputNumberRef>) => ReactElement | null;
+export {};

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

@@ -0,0 +1,130 @@
+import type { CSSProperties, ElementType, HTMLAttributes, ReactNode } from "react";
+import type { DirectionType, Variant } from "../ConfigProvider";
+export type NativeGapSize = "small" | "medium" | "middle" | "large";
+export type LegacyGapSize = "xs" | "sm" | "md" | "lg" | "xl";
+export type GapSize = NativeGapSize | LegacyGapSize | NonNullable<CSSProperties["gap"]>;
+export type Orientation = "horizontal" | "vertical";
+type SemanticConfig<Slot extends string, Value, Props> = Partial<Record<Slot, Value>> | ((info: {
+    readonly props: Props;
+}) => Partial<Record<Slot, Value>>);
+export interface FlexProps extends HTMLAttributes<HTMLElement> {
+    readonly align?: CSSProperties["alignItems"];
+    readonly component?: ElementType;
+    readonly flex?: CSSProperties["flex"];
+    readonly gap?: GapSize;
+    readonly justify?: CSSProperties["justifyContent"];
+    readonly orientation?: Orientation;
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+    readonly vertical?: boolean;
+    readonly wrap?: boolean | CSSProperties["flexWrap"];
+}
+export declare const Flex: import("react").ForwardRefExoticComponent<FlexProps & import("react").RefAttributes<HTMLElement>>;
+export interface SpaceProps extends HTMLAttributes<HTMLDivElement> {
+    readonly align?: CSSProperties["alignItems"];
+    readonly classNames?: SpaceClassNames;
+    readonly direction?: Orientation;
+    readonly orientation?: Orientation;
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+    readonly separator?: ReactNode;
+    readonly size?: GapSize | readonly [GapSize, GapSize];
+    readonly split?: ReactNode;
+    readonly styles?: SpaceStyles;
+    readonly vertical?: boolean;
+    readonly wrap?: boolean;
+}
+export type SpaceSemanticSlot = "root" | "item" | "separator";
+export type SpaceClassNames = SemanticConfig<SpaceSemanticSlot, string, SpaceProps>;
+export type SpaceStyles = SemanticConfig<SpaceSemanticSlot, CSSProperties, SpaceProps>;
+export type SpaceCompactSize = NativeGapSize | "sm" | "md" | "lg";
+export interface SpaceCompactItemContextValue {
+    readonly compactDirection?: Orientation;
+    readonly compactSize?: SpaceCompactSize;
+    readonly isFirstItem?: boolean;
+    readonly isLastItem?: boolean;
+}
+export declare const SpaceCompactItemContext: import("react").Context<SpaceCompactItemContextValue | null>;
+export declare function useCompactItemContext(prefixCls: string, direction?: DirectionType): {
+    compactDirection: Orientation | undefined;
+    compactItemClassnames: string;
+    compactSize: SpaceCompactSize | undefined;
+};
+export declare function NoCompactStyle({ children }: Readonly<{
+    children?: ReactNode;
+}>): import("react").JSX.Element;
+export type SpaceAddonStatus = "" | "error" | "success" | "validating" | "warning";
+export interface SpaceAddonProps extends HTMLAttributes<HTMLDivElement> {
+    readonly children: ReactNode;
+    readonly disabled?: boolean;
+    readonly prefixCls?: string;
+    readonly status?: SpaceAddonStatus;
+    readonly variant?: Variant;
+}
+export type SpaceCompactCellProps = SpaceAddonProps;
+export declare const SpaceAddon: import("react").ForwardRefExoticComponent<SpaceAddonProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface SpaceCompactProps extends HTMLAttributes<HTMLDivElement> {
+    readonly block?: boolean;
+    readonly direction?: Orientation;
+    readonly orientation?: Orientation;
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+    readonly size?: SpaceCompactSize;
+    readonly vertical?: boolean;
+}
+export declare const SpaceCompact: import("react").ForwardRefExoticComponent<SpaceCompactProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare const Space: import("react").ForwardRefExoticComponent<SpaceProps & import("react").RefAttributes<HTMLDivElement>> & {
+    Addon: import("react").ForwardRefExoticComponent<SpaceAddonProps & import("react").RefAttributes<HTMLDivElement>>;
+    Compact: import("react").ForwardRefExoticComponent<SpaceCompactProps & import("react").RefAttributes<HTMLDivElement>>;
+};
+export interface LayoutProps extends HTMLAttributes<HTMLDivElement> {
+    readonly hasSider?: boolean;
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+}
+interface BasicLayoutSectionProps extends HTMLAttributes<HTMLElement> {
+    readonly prefixCls?: string;
+    readonly rootClassName?: string;
+}
+export type LayoutHeaderProps = BasicLayoutSectionProps;
+export type LayoutFooterProps = BasicLayoutSectionProps;
+export type LayoutContentProps = BasicLayoutSectionProps;
+export declare const LayoutHeader: import("react").ForwardRefExoticComponent<BasicLayoutSectionProps & import("react").RefAttributes<HTMLElement>>;
+export declare const LayoutFooter: import("react").ForwardRefExoticComponent<BasicLayoutSectionProps & import("react").RefAttributes<HTMLElement>>;
+export declare const LayoutContent: import("react").ForwardRefExoticComponent<BasicLayoutSectionProps & import("react").RefAttributes<HTMLElement>>;
+export type Breakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl";
+export type CollapseType = "clickTrigger" | "responsive";
+export type SiderTheme = "light" | "dark";
+export interface SiderContextValue {
+    readonly siderCollapsed?: boolean;
+}
+export declare const SiderContext: import("react").Context<SiderContextValue>;
+export interface SiderProps extends HTMLAttributes<HTMLElement> {
+    readonly breakpoint?: Breakpoint;
+    readonly classNames?: SiderClassNames;
+    readonly collapsible?: boolean;
+    readonly collapsed?: boolean;
+    readonly collapsedWidth?: number | string;
+    readonly defaultCollapsed?: boolean;
+    readonly onBreakpoint?: (broken: boolean) => void;
+    readonly onCollapse?: (collapsed: boolean, type: CollapseType) => void;
+    readonly prefixCls?: string;
+    readonly reverseArrow?: boolean;
+    readonly rootClassName?: string;
+    readonly styles?: SiderStyles;
+    readonly theme?: SiderTheme;
+    readonly trigger?: ReactNode;
+    readonly width?: number | string;
+    readonly zeroWidthTriggerStyle?: CSSProperties;
+}
+export type SiderSemanticSlot = "root" | "body";
+export type SiderClassNames = SemanticConfig<SiderSemanticSlot, string, SiderProps>;
+export type SiderStyles = SemanticConfig<SiderSemanticSlot, CSSProperties, SiderProps>;
+export declare const Layout: import("react").ForwardRefExoticComponent<LayoutProps & import("react").RefAttributes<HTMLDivElement>> & {
+    Content: import("react").ForwardRefExoticComponent<BasicLayoutSectionProps & import("react").RefAttributes<HTMLElement>>;
+    Footer: import("react").ForwardRefExoticComponent<BasicLayoutSectionProps & import("react").RefAttributes<HTMLElement>>;
+    Header: import("react").ForwardRefExoticComponent<BasicLayoutSectionProps & import("react").RefAttributes<HTMLElement>>;
+    Sider: import("react").ForwardRefExoticComponent<SiderProps & import("react").RefAttributes<HTMLElement>>;
+    _InternalSiderContext: import("react").Context<SiderContextValue>;
+};
+export {};

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

@@ -0,0 +1,64 @@
+import type { CSSProperties, HTMLAttributes, Key, ReactElement, ReactNode, RefAttributes } from "react";
+import { type PaginationProps } from "./Pagination";
+import { type SpinProps } from "./Spin";
+export type ListSize = "small" | "default" | "large";
+export type ListItemLayout = "horizontal" | "vertical";
+export type ListBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl";
+export type ListGutter = number | string | Partial<Record<ListBreakpoint, number>> | undefined;
+export interface ListGridType {
+    readonly column?: number;
+    readonly gutter?: ListGutter | readonly [ListGutter, ListGutter];
+    readonly lg?: number;
+    readonly md?: number;
+    readonly sm?: number;
+    readonly xl?: number;
+    readonly xs?: number;
+    readonly xxl?: number;
+    readonly xxxl?: number;
+}
+export type ListPaginationConfig = Omit<PaginationProps, "total"> & {
+    readonly align?: "start" | "center" | "end";
+    readonly position?: "top" | "bottom" | "both";
+    readonly total?: number;
+};
+export interface ListProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    readonly bordered?: boolean;
+    readonly children?: ReactNode;
+    readonly dataSource?: readonly T[];
+    readonly extra?: ReactNode;
+    readonly footer?: ReactNode;
+    readonly grid?: ListGridType;
+    readonly header?: ReactNode;
+    readonly itemLayout?: ListItemLayout;
+    readonly loading?: boolean | SpinProps;
+    readonly loadMore?: ReactNode;
+    readonly locale?: {
+        readonly emptyText?: ReactNode;
+    };
+    readonly pagination?: ListPaginationConfig | false;
+    readonly rootClassName?: string;
+    readonly rowKey?: ((item: T) => Key) | keyof T;
+    readonly size?: ListSize;
+    readonly split?: boolean;
+    readonly renderItem?: (item: T, index: number) => ReactNode;
+}
+export interface ListItemProps extends HTMLAttributes<HTMLDivElement> {
+    readonly actions?: readonly ReactNode[];
+    readonly classNames?: Partial<Record<"actions" | "extra", string>>;
+    readonly colStyle?: CSSProperties;
+    readonly extra?: ReactNode;
+    readonly styles?: Partial<Record<"actions" | "extra", CSSProperties>>;
+}
+export interface ListItemMetaProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    readonly avatar?: ReactNode;
+    readonly description?: ReactNode;
+    readonly title?: ReactNode;
+}
+declare function ListItemMeta({ avatar, children, className, description, title, ...props }: ListItemMetaProps): import("react").JSX.Element;
+type ListComponent = <T>(props: ListProps<T> & RefAttributes<HTMLDivElement>) => ReactElement;
+export declare const List: ListComponent & {
+    Item: import("react").ForwardRefExoticComponent<ListItemProps & RefAttributes<HTMLDivElement>> & {
+        Meta: typeof ListItemMeta;
+    };
+};
+export {};

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

@@ -0,0 +1,43 @@
+import type { CSSProperties, Key, ReactNode, RefAttributes } from "react";
+import type { SlotClassNames, SlotStyles } from "../utils/slots";
+export type MasonryBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export type MasonryResponsiveValue<T> = T | Partial<Record<MasonryBreakpoint, T>>;
+export type MasonryGutter = MasonryResponsiveValue<number> | readonly [MasonryResponsiveValue<number>, MasonryResponsiveValue<number>];
+export type MasonryGap = "xs" | "sm" | "md" | "lg" | "xl" | number;
+export interface MasonryItem<T = unknown> {
+    readonly children?: ReactNode;
+    readonly column?: number;
+    readonly data: T;
+    readonly height?: number;
+    readonly key: Key;
+}
+type MasonrySlot = "root" | "item";
+export interface MasonryProps<T = unknown> {
+    readonly children?: ReactNode;
+    readonly className?: string;
+    readonly classNames?: SlotClassNames<MasonrySlot>;
+    readonly columns?: MasonryResponsiveValue<number>;
+    readonly fresh?: boolean;
+    readonly gap?: MasonryGap;
+    readonly gutter?: MasonryGutter;
+    readonly itemRender?: (item: MasonryItem<T> & {
+        readonly column: number;
+        readonly index: number;
+    }) => ReactNode;
+    readonly items?: readonly MasonryItem<T>[];
+    readonly rootClassName?: string;
+    readonly style?: CSSProperties;
+    readonly styles?: SlotStyles<MasonrySlot>;
+    readonly onLayoutChange?: (sortInfo: {
+        readonly column: number;
+        readonly key: Key;
+    }[]) => void;
+}
+export interface MasonryRef {
+    readonly nativeElement: HTMLDivElement;
+}
+declare const InternalMasonry: import("react").ForwardRefExoticComponent<MasonryProps<unknown> & RefAttributes<MasonryRef>>;
+export declare const Masonry: (<T = unknown>(props: MasonryProps<T> & RefAttributes<MasonryRef>) => ReturnType<typeof InternalMasonry>) & {
+    displayName?: string;
+};
+export {};