@bioturing/components 0.13.1

package/dist/components/src/components/Empty/component.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import { type EmptyProps as AntEmptyProps } from "antd/es/empty";
+export interface EmptyProps extends AntEmptyProps {
+    /**
+     * Empty icon size
+     * @default 'medium'
+     */
+    size?: "small" | "medium" | "large";
+}
+export declare const EmptyIcon: React.FC<React.ComponentPropsWithRef<"svg">>;
+export declare const Empty: ({ image, size, className, ...rest }: EmptyProps) => import("react/jsx-runtime").JSX.Element;
+export default Empty;

package/dist/components/src/components/Empty/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Field/component.d.ts

@@ -0,0 +1,41 @@
+import type { InputProps, InputRef, SelectProps } from "antd";
+import { SizeType } from "antd/es/config-provider/SizeContext";
+import { RefSelectProps } from "antd/es/select";
+import { ForwardedRef } from "react";
+export type FieldType = "input" | "select";
+type RefType<T extends FieldType> = T extends "input" ? InputRef : T extends "select" ? RefSelectProps : never;
+interface BaseFieldProps extends React.HTMLAttributes<HTMLDivElement> {
+    label?: React.ReactNode;
+    /**
+     * Block or inline display
+     * @default false
+     */
+    block?: boolean;
+    /**
+     * Size of the field
+     * @default "small"
+     */
+    size?: SizeType;
+    /**
+     * Colon after label
+     * @default true
+     */
+    colon?: boolean;
+}
+type InputFieldProps = BaseFieldProps & {
+    type?: "input";
+    inputProps: InputProps;
+};
+type SelectFieldProps = BaseFieldProps & {
+    type: "select";
+    selectProps: SelectProps;
+};
+export type FieldProps<T extends FieldType = "input"> = T extends "input" ? InputFieldProps : SelectFieldProps;
+/**
+ * Generic Field component that forwards ref to Input or Select
+ */
+declare const FieldInner: <T extends FieldType>({ label, className, size, colon, type, ...rest }: FieldProps<T>, ref: ForwardedRef<RefType<T>>) => import("react/jsx-runtime").JSX.Element;
+export declare const Field: <T extends FieldType>(props: FieldProps<T> & {
+    ref?: ForwardedRef<RefType<T>>;
+}) => ReturnType<typeof FieldInner<T>>;
+export {};

package/dist/components/src/components/Field/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Form/component.d.ts

@@ -0,0 +1,18 @@
+import { FormProps as AntdFormProps, default as AntdInternalForm, useForm, useWatch } from "antd/es/form/Form";
+import useFormInstance from "antd/es/form/hooks/useFormInstance";
+import * as React from "react";
+import { type FormItemProps } from "./item";
+export interface FormProps<Values = any> extends AntdFormProps<Values> {
+}
+interface InternalFormProps<Values = any> extends React.ComponentProps<typeof AntdInternalForm<Values>> {
+}
+export declare const Form: (<Values = any>({ ...rest }: InternalFormProps<Values>) => import("react/jsx-runtime").JSX.Element) & {
+    useForm: typeof useForm;
+    useFormInstance: typeof useFormInstance;
+    useWatch: typeof useWatch;
+    Item: <Values = unknown>({ tooltip, label, optionalMark, ...rest }: FormItemProps<Values>) => import("react/jsx-runtime").JSX.Element;
+    List: React.FC<import("antd/es/form/FormList").FormListProps>;
+    ErrorList: React.FC<import("antd/es/form/ErrorList").ErrorListProps>;
+    Provider: React.FC<import("antd/es/form/context").FormProviderProps>;
+};
+export type { FormItemProps };

package/dist/components/src/components/Form/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Form/item.d.ts

@@ -0,0 +1,5 @@
+import { type FormItemProps as AntdFormItemProps } from "antd/es/form/FormItem";
+export interface FormItemProps<Values = unknown> extends AntdFormItemProps<Values> {
+    optionalMark?: boolean | React.ReactNode;
+}
+export declare const FormItem: <Values = unknown>({ tooltip, label, optionalMark, ...rest }: FormItemProps<Values>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/src/components/IconButton/component.d.ts

@@ -0,0 +1,29 @@
+import React, { type ElementType, type ComponentPropsWithoutRef, type ReactElement, type AnchorHTMLAttributes, ComponentPropsWithRef } from "react";
+import { Tooltip } from "antd";
+type IconButtonBaseProps = {
+    label?: React.ReactNode;
+    size?: "small" | "medium";
+    negativeMargin?: boolean;
+    tooltipProps?: React.ComponentProps<typeof Tooltip>;
+};
+type AnchorSpecificProps = Pick<AnchorHTMLAttributes<HTMLAnchorElement>, "target" | "rel" | "download" | "hrefLang" | "referrerPolicy">;
+type WithHrefProps<E extends ElementType = "a"> = IconButtonBaseProps & {
+    href: string;
+    as?: E;
+} & AnchorSpecificProps;
+type WithoutHrefProps<E extends ElementType = "button"> = IconButtonBaseProps & {
+    href?: undefined;
+    as?: E;
+} & {
+    [K in keyof AnchorSpecificProps]?: never;
+};
+type IconButtonOwnProps<E extends ElementType = ElementType> = WithHrefProps<E> | WithoutHrefProps<E>;
+export type IconButtonProps<E extends ElementType = "button"> = IconButtonOwnProps<E> & Omit<ComponentPropsWithoutRef<E>, keyof IconButtonOwnProps<E>>;
+/**
+ * Type for wrapping the forwardRef implementation
+ */
+type IconButtonComponent = <E extends ElementType = "button">(props: IconButtonProps<E> & {
+    ref?: ComponentPropsWithRef<E>["ref"];
+}) => ReactElement;
+export declare const IconButton: IconButtonComponent;
+export default IconButton;

package/dist/components/src/components/IconButton/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Input/component.d.ts

@@ -0,0 +1,30 @@
+import { type InputProps as AntInputProps, type InputRef } from "antd";
+import { type PasswordProps as AntPasswordProps } from "antd/es/input";
+import { type SearchProps as AntSearchProps } from "antd/es/input";
+import { type TextAreaProps as AntTextAreaProps } from "antd/es/input";
+export interface InputProps extends AntInputProps {
+}
+export interface PasswordProps extends AntPasswordProps {
+}
+export interface TextAreaProps extends AntTextAreaProps {
+}
+export interface SearchProps extends AntSearchProps {
+}
+declare const MainInputInner: (props: InputProps, ref: React.Ref<InputRef>) => import("react/jsx-runtime").JSX.Element;
+declare const PasswordInner: (props: PasswordProps, ref: React.Ref<InputRef>) => import("react/jsx-runtime").JSX.Element;
+declare const SearchInner: (props: SearchProps, ref: React.Ref<InputRef>) => import("react/jsx-runtime").JSX.Element;
+declare const TextAreaInner: (props: TextAreaProps, ref: React.Ref<HTMLTextAreaElement>) => import("react/jsx-runtime").JSX.Element;
+export declare const Input: ((props: InputProps & {
+    ref?: React.ForwardedRef<InputRef>;
+}) => ReturnType<typeof MainInputInner>) & {
+    Password: (props: PasswordProps & {
+        ref?: React.ForwardedRef<InputRef>;
+    }) => ReturnType<typeof PasswordInner>;
+    Search: (props: SearchProps & {
+        ref?: React.ForwardedRef<InputRef>;
+    }) => ReturnType<typeof SearchInner>;
+    TextArea: (props: TextAreaProps & {
+        ref?: React.ForwardedRef<HTMLTextAreaElement>;
+    }) => ReturnType<typeof TextAreaInner>;
+};
+export {};

package/dist/components/src/components/Input/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Modal/Modal.d.ts

@@ -0,0 +1,69 @@
+import { type ModalProps as AntModalProps } from "antd/es/modal";
+import React from "react";
+import { ModalType } from "./functions";
+export interface ModalProps extends Omit<AntModalProps, "centered"> {
+    /**
+     * Predefined sizes for the modal
+     * - xsmall: 400px
+     * - small: 520px
+     * - medium: 640px (default)
+     * - large: 840px
+     * - xlarge: 1024px
+     * - fullscreen: 100vw (takes full screen width with margins)
+     * @default "medium" for default type, "xsmall" for other types
+     */
+    size?: "xsmall" | "small" | "medium" | "large" | "xlarge" | "xxlarge" | "fullscreen";
+    /**
+     * Mark modal as loading
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Hide Ok button
+     * @default false
+     */
+    hideOkButton?: boolean;
+    /**
+     * Hide Cancel button
+     * @default false
+     */
+    hideCancelButton?: boolean;
+    /**
+     * Custom Content Padding
+     * @default "24px"
+     */
+    contentPadding?: number | string | boolean;
+    /**
+     * Add more content below the title
+     */
+    afterTitle?: React.ReactNode;
+    /**
+     * Add more actions before close button
+     */
+    beforeCloseButton?: React.ReactNode;
+    /**
+     * Add more actions after close button
+     */
+    afterCloseButton?: React.ReactNode;
+    /**
+     * Set header and footer to fixed position
+     * @default false
+     */
+    defaultFixedHeaderFooter?: boolean;
+    /**
+     * Centered Modal
+     * @default true
+     */
+    centered?: boolean;
+    /**
+     * Modal type
+     * @default "default"
+     */
+    type?: ModalType;
+    /**
+     * Default open state for uncontrolled modal
+     * @default true
+     */
+    defaultOpen?: boolean;
+}
+export declare const Modal: ({ open: externalOpen, closeIcon, children, size, footer, width, style, styles, classNames, okButtonProps, cancelButtonProps, loading, onOk, onCancel, onClose, okText, okType, confirmLoading, cancelText, hideOkButton, hideCancelButton, contentPadding, title, afterTitle, beforeCloseButton, afterCloseButton, defaultFixedHeaderFooter, centered, type, defaultOpen, ...rest }: ModalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/src/components/Modal/ModalProvider.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export interface ModalProviderProps {
+    children?: React.ReactNode;
+}
+export declare const ModalProvider: React.FC<ModalProviderProps>;

package/dist/components/src/components/Modal/ModalService.d.ts

@@ -0,0 +1,33 @@
+import type { ModalFuncProps } from "./functions";
+export type ModalConfig = ModalFuncProps & {
+    id: string;
+    trigger?: HTMLElement;
+};
+export type UpdateConfig = Partial<ModalFuncProps> | ((prev: ModalFuncProps) => ModalFuncProps);
+export type ModalEvent = {
+    type: "add";
+    payload: ModalConfig;
+} | {
+    type: "update";
+    payload: {
+        id: string;
+        config: UpdateConfig;
+    };
+} | {
+    type: "destroy";
+    payload: {
+        id: string;
+    };
+} | {
+    type: "destroyAll";
+};
+type Listener = (event: ModalEvent) => void;
+declare class ModalManager {
+    private listeners;
+    private counter;
+    subscribe(listener: Listener): () => void;
+    emit(event: ModalEvent): void;
+    generateId(): string;
+}
+export declare const modalManager: ModalManager;
+export {};

package/dist/components/src/components/Modal/constants.d.ts

@@ -0,0 +1,9 @@
+export declare enum ModalSize {
+    xsmall = "400px",
+    small = "520px",
+    medium = "640px",
+    large = "840px",
+    xlarge = "1024px",
+    xxlarge = "1280px",
+    fullscreen = "100%"
+}

package/dist/components/src/components/Modal/functions.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import type { ModalFuncProps as AntModalFuncProps } from "antd";
+import { ModalProps } from "./Modal";
+export type ModalType = NonNullable<AntModalFuncProps["type"]> | "default";
+export type ModalFuncProps = ModalProps & {
+    /**
+     * Content to be displayed in the modal
+     * Similar to children prop in Modal component
+     * Keep this to be compatible with antd ModalFuncProps
+     */
+    content?: React.ReactNode;
+};
+export type ModalUpdateConfig = Partial<ModalFuncProps> | ((prev: ModalFuncProps) => ModalFuncProps);
+export interface ModalRef {
+    update: (config: ModalUpdateConfig) => void;
+    destroy: () => void;
+}
+export declare const confirm: (config: ModalFuncProps) => ModalRef;
+export declare const info: (config: ModalFuncProps) => ModalRef;
+export declare const success: (config: ModalFuncProps) => ModalRef;
+export declare const error: (config: ModalFuncProps) => ModalRef;
+export declare const warning: (config: ModalFuncProps) => ModalRef;
+/**
+ * Open a default (normal) modal
+ */
+export declare const open: (config: ModalFuncProps) => ModalRef;
+export declare const destroyAll: () => void;

package/dist/components/src/components/Modal/index.d.ts

@@ -0,0 +1,14 @@
+import { type ModalFuncProps } from "./functions";
+import { type ModalProviderProps } from "./ModalProvider";
+export declare const Modal: (({ open: externalOpen, closeIcon, children, size, footer, width, style, styles, classNames, okButtonProps, cancelButtonProps, loading, onOk, onCancel, onClose, okText, okType, confirmLoading, cancelText, hideOkButton, hideCancelButton, contentPadding, title, afterTitle, beforeCloseButton, afterCloseButton, defaultFixedHeaderFooter, centered, type, defaultOpen, ...rest }: import("./Modal").ModalProps) => import("react/jsx-runtime").JSX.Element) & {
+    Provider: import("react").FC<ModalProviderProps>;
+    open: (config: ModalFuncProps) => import("./functions").ModalRef;
+    info: (config: ModalFuncProps) => import("./functions").ModalRef;
+    success: (config: ModalFuncProps) => import("./functions").ModalRef;
+    error: (config: ModalFuncProps) => import("./functions").ModalRef;
+    warning: (config: ModalFuncProps) => import("./functions").ModalRef;
+    confirm: (config: ModalFuncProps) => import("./functions").ModalRef;
+    destroyAll: () => void;
+    useModal: () => import("antd/es/modal/useModal").HookAPI;
+};
+export { ModalFuncProps, ModalProviderProps };

package/dist/components/src/components/Popover/component.d.ts

@@ -0,0 +1,9 @@
+import { type PopoverProps as AntPopoverProps } from "antd/es/popover";
+export interface PopoverProps extends AntPopoverProps {
+    /**
+     * Arrow config for of the popover
+     * @default false
+     */
+    arrow?: AntPopoverProps["arrow"];
+}
+export declare const Popover: ({ className, style, arrow, ...rest }: PopoverProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/src/components/Popover/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Radio/component.d.ts

@@ -0,0 +1,7 @@
+import type { RadioGroupProps } from "./interface";
+export declare const Radio: import("react").ForwardRefExoticComponent<import("antd/es/radio").RadioProps & import("react").RefAttributes<import("antd/es/radio").RadioRef>> & {
+    Group: (props: RadioGroupProps & {
+        ref?: React.Ref<HTMLDivElement>;
+    }) => import("react/jsx-runtime").JSX.Element;
+    Button: import("react").ForwardRefExoticComponent<import("antd/es/radio").RadioProps & import("react").RefAttributes<import("antd/es/radio").RadioRef>>;
+};

package/dist/components/src/components/Radio/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./component";
+export * from "./interface";

package/dist/components/src/components/Radio/interface.d.ts

@@ -0,0 +1,5 @@
+import type { RadioProps as AntdRadioProps, RadioRef as AntdRadioRef, RadioGroupProps as AntdRadioGroupProps, RadioChangeEvent as AntdRadioChangeEvent } from "antd/es/radio";
+export type RadioProps = AntdRadioProps;
+export type RadioRef = AntdRadioRef;
+export type RadioGroupProps = AntdRadioGroupProps;
+export type RadioChangeEvent = AntdRadioChangeEvent;

package/dist/components/src/components/ScrollArea/component.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+export interface ScrollAreaProps {
+    children: ReactNode;
+    className?: string;
+    viewportClassName?: string;
+    scrollbarClassName?: string;
+    thumbClassName?: string;
+    orientation?: "vertical" | "horizontal";
+}
+export declare const ScrollArea: ({ children, className, viewportClassName, thumbClassName, scrollbarClassName, orientation, }: ScrollAreaProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/src/components/ScrollArea/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Segmented/component.d.ts

@@ -0,0 +1,9 @@
+import { default as AntSegmented, type SegmentedProps as AntSegmentedProps } from "antd/es/segmented";
+export type RcSegmentedValue = string | number;
+export interface SegmentedProps<T = RcSegmentedValue> extends AntSegmentedProps<T> {
+}
+declare const MainSegmentedInner: <T>({ className, ...rest }: SegmentedProps<T>, ref: React.Ref<React.ComponentRef<typeof AntSegmented>>) => import("react/jsx-runtime").JSX.Element;
+export declare const Segmented: <T = RcSegmentedValue>(props: SegmentedProps<T> & {
+    ref?: React.Ref<React.ComponentRef<typeof AntSegmented>>;
+}) => ReturnType<typeof MainSegmentedInner>;
+export {};

package/dist/components/src/components/Segmented/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Select/component.d.ts

@@ -0,0 +1,11 @@
+import { default as AntSelect, type BaseOptionType, type DefaultOptionType, type SelectProps as AntSelectProps } from "antd/es/select";
+export interface SelectProps<ValueType = unknown, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType> extends AntSelectProps<ValueType, OptionType> {
+}
+export type { BaseOptionType as SelectBaseOptionType, DefaultOptionType as SelectDefaultOptionType, };
+declare const MainSelectInner: <ValueType = unknown, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>({ mode, className, popupClassName, ...rest }: SelectProps<ValueType, OptionType>, ref: React.Ref<React.ComponentRef<typeof AntSelect>>) => import("react/jsx-runtime").JSX.Element;
+export declare const Select: (<ValueType = unknown, OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType>(props: SelectProps<ValueType, OptionType> & {
+    ref?: React.ForwardedRef<React.ComponentRef<typeof AntSelect>>;
+}) => ReturnType<typeof MainSelectInner>) & {
+    Option: import("rc-select/lib/Option").OptionFC;
+    OptGroup: import("rc-select/lib/OptGroup").OptionGroupFC;
+};

package/dist/components/src/components/Select/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Slider/component.d.ts

@@ -0,0 +1,5 @@
+import { type SliderSingleProps, type SliderRangeProps } from "antd/es/slider";
+export type SliderProps = SliderSingleProps | SliderRangeProps;
+export type { SliderSingleProps, SliderRangeProps };
+declare const Slider: ({ className, tooltip, style, ...rest }: SliderProps) => import("react/jsx-runtime").JSX.Element;
+export { Slider };

package/dist/components/src/components/Slider/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Spin/component.d.ts

@@ -0,0 +1,3 @@
+import { SpinProps as AntdSpinProps } from "antd/es/spin";
+export type SpinProps = AntdSpinProps;
+export declare const Spin: ({ indicator, ...rest }: SpinProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/src/components/Spin/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Splitter/component.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { SplitterProps as AntdSplitterProps, PanelProps as AntdSplitterPanelProps } from "antd/es/splitter/interface";
+export type SplitterProps = React.PropsWithChildren<AntdSplitterProps> & {
+    showSplitBar?: boolean;
+};
+export type SplitterPanelProps = React.PropsWithChildren<AntdSplitterPanelProps>;
+export declare const Splitter: React.FC<SplitterProps> & {
+    Panel: React.FC<SplitterPanelProps>;
+};
+export declare const Split: React.FC<SplitterProps> & {
+    Panel: React.FC<SplitterPanelProps>;
+};

package/dist/components/src/components/Splitter/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Switch/component.d.ts

@@ -0,0 +1,8 @@
+import { default as AntSwitch, type SwitchProps as AntSwitchProps } from "antd/es/switch";
+export interface SwitchProps extends AntSwitchProps {
+}
+declare const MainSwitchInner: ({ ...rest }: SwitchProps, ref: React.Ref<React.ComponentRef<typeof AntSwitch>>) => import("react/jsx-runtime").JSX.Element;
+export declare const Switch: (props: SwitchProps & {
+    ref?: React.ForwardedRef<React.ComponentRef<typeof AntSwitch>>;
+}) => ReturnType<typeof MainSwitchInner>;
+export {};

package/dist/components/src/components/Switch/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Table/component.d.ts

@@ -0,0 +1,19 @@
+import { default as AntTable, type TableProps as AntTableProps } from "antd/es/table";
+export interface TableProps<RecordType extends object = object> extends AntTableProps<RecordType> {
+    /**
+     * Add empty description for the table
+     */
+    emptyDescription?: React.ReactNode;
+}
+declare const InternalTable: <RecordType extends object = object>({ columns, locale, emptyDescription, loading, ...rest }: TableProps<RecordType>) => import("react/jsx-runtime").JSX.Element;
+export declare const Table: typeof InternalTable & {
+    Column: typeof AntTable.Column;
+    ColumnGroup: typeof AntTable.ColumnGroup;
+    SELECTION_COLUMN: typeof AntTable.SELECTION_COLUMN;
+    EXPAND_COLUMN: typeof AntTable.EXPAND_COLUMN;
+    SELECTION_ALL: typeof AntTable.SELECTION_ALL;
+    SELECTION_INVERT: typeof AntTable.SELECTION_INVERT;
+    SELECTION_NONE: typeof AntTable.SELECTION_NONE;
+    Summary: typeof AntTable.Summary;
+};
+export default Table;

package/dist/components/src/components/Table/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Tag/component.d.ts

@@ -0,0 +1,11 @@
+import { type TagProps as AntTagProps } from "antd/es/tag";
+export interface TagProps extends AntTagProps {
+    /**
+     * Indicates if the tag is active
+     * @default false
+     */
+    active?: boolean;
+}
+export declare const Tag: (({ className, active, color, style, closeIcon, closable, ...rest }: TagProps) => import("react/jsx-runtime").JSX.Element) & {
+    CheckableTag: import("react").ForwardRefExoticComponent<import("antd/es/tag").CheckableTagProps & import("react").RefAttributes<HTMLSpanElement>>;
+};

package/dist/components/src/components/Tag/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/ThemeProvider/component.d.ts

@@ -0,0 +1,6 @@
+import { type ConfigProviderProps } from "antd/es/config-provider";
+export interface ThemeProviderProps extends Omit<ConfigProviderProps, "theme" | "prefixCls"> {
+    theme: "light" | "dark";
+    appendClassesTo?: string | HTMLElement;
+}
+export declare const ThemeProvider: ({ theme, appendClassesTo, children, }: ThemeProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/src/components/ThemeProvider/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Toast/component.d.ts

@@ -0,0 +1,14 @@
+import { Toast as BaseToast } from "@base-ui-components/react";
+import { ToastData } from "./types";
+declare function InnerToast({ toast, }: {
+    toast: BaseToast.Root.ToastObject<ToastData>;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ToastList({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare function ToastProvider(props: BaseToast.Provider.Props): import("react/jsx-runtime").JSX.Element;
+export declare const Toast: typeof InnerToast & {
+    List: typeof ToastList;
+    Provider: typeof ToastProvider;
+};
+export {};

package/dist/components/src/components/Toast/function.d.ts

@@ -0,0 +1,10 @@
+import { Toast as BaseToast } from "@base-ui-components/react";
+import type { ToastData } from "./types";
+export declare const toastManager: BaseToast.createToastManager.ToastManager;
+export declare const toast: ((message: string, options?: Omit<BaseToast.useToastManager.AddOptions<ToastData>, "data" | "description">) => string) & {
+    info: (message: string, options?: Omit<BaseToast.useToastManager.AddOptions<ToastData>, "data" | "description">) => string;
+    success: (message: string, options?: Omit<BaseToast.useToastManager.AddOptions<ToastData>, "data" | "description">) => string;
+    error: (message: string, options?: Omit<BaseToast.useToastManager.AddOptions<ToastData>, "data" | "description">) => string;
+    warning: (message: string, options?: Omit<BaseToast.useToastManager.AddOptions<ToastData>, "data" | "description">) => string;
+    progress: (message: string, options?: Omit<BaseToast.useToastManager.AddOptions<ToastData>, "data" | "description">) => string;
+};

package/dist/components/src/components/Toast/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./component";
+export * from "./types";
+export * from "./function";

package/dist/components/src/components/Toast/types.d.ts

@@ -0,0 +1,3 @@
+export type ToastData = {
+    type: "info" | "success" | "error" | "warning" | "progress";
+};

package/dist/components/src/components/Tooltip/component.d.ts

@@ -0,0 +1,9 @@
+import { type TooltipProps as AntTooltipProps } from "antd/es/tooltip";
+export type TooltipProps = AntTooltipProps & {
+    /**
+     * Arrow config for of the tooltip
+     * @default false
+     */
+    arrow?: AntTooltipProps["arrow"];
+};
+export declare const Tooltip: ({ className, style, arrow, ...rest }: TooltipProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/src/components/Tooltip/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Tour/component.d.ts

@@ -0,0 +1,7 @@
+import { type TourProps as AntTourProps, type TourStepProps as AntTourStepProps } from "antd/es/tour/interface";
+export interface TourProps extends AntTourProps {
+}
+export interface TourStepProps extends AntTourStepProps {
+}
+declare const Tour: ({ indicatorsRender, ...rest }: TourProps) => import("react/jsx-runtime").JSX.Element;
+export { Tour };

package/dist/components/src/components/Tour/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Transition/component.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from "react";
+import { useRender } from "@base-ui-components/react/use-render";
+export interface TransitionProps extends Omit<useRender.ComponentProps<"div">, "render" | "children"> {
+    /** Whether the component should be shown */
+    show?: boolean;
+    /** CSS classes to apply when the component is opened */
+    starting?: string | CSSProperties;
+    /** CSS classes to apply when the component is closed */
+    ending?: string | CSSProperties;
+    /** CSS classes to apply to the component */
+    className?: string;
+    /** Child component to render */
+    children: useRender.ComponentProps<"div">["render"];
+    /** Keep mounted */
+    keepMounted?: boolean;
+}
+export declare const Transition: (props: TransitionProps) => import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;

package/dist/components/src/components/Transition/index.d.ts

@@ -0,0 +1 @@
+export * from "./component";

package/dist/components/src/components/Tree/components.d.ts

@@ -0,0 +1,13 @@
+import { default as AntTree, type DataNode as AntTreeDataNode } from "antd/es/tree";
+import type { TreeDataNode, TreeProps, DirectoryTreeProps } from "./types";
+declare const MainTreeInner: <T extends AntTreeDataNode = AntTreeDataNode>(props: TreeProps<T>, ref: React.Ref<React.ComponentRef<typeof AntTree<T>>>) => import("react/jsx-runtime").JSX.Element;
+declare const DirectoryTreeInner: <T extends AntTreeDataNode = AntTreeDataNode>(props: DirectoryTreeProps<T>, ref: React.Ref<React.ComponentRef<typeof AntTree<T>>>) => import("react/jsx-runtime").JSX.Element;
+export declare const Tree: (<T extends AntTreeDataNode = AntTreeDataNode>(props: TreeProps<T> & {
+    ref?: React.ForwardedRef<React.ComponentRef<typeof AntTree<T>>>;
+}) => ReturnType<typeof MainTreeInner<T>>) & {
+    DirectoryTree: <T extends AntTreeDataNode = AntTreeDataNode>(props: DirectoryTreeProps<T> & {
+        ref?: React.ForwardedRef<React.ComponentRef<typeof AntTree<T>>>;
+    }) => ReturnType<typeof DirectoryTreeInner<T>>;
+    TreeNode: import("react").FC<Readonly<import("rc-tree").TreeNodeProps<AntTreeDataNode>>>;
+};
+export {};

package/dist/components/src/components/Tree/helpers.d.ts

@@ -0,0 +1,4 @@
+import { type Key } from "react";
+import { type DataNode as AntTreeDataNode } from "antd/es/tree";
+export declare const getUniqueKeysFromOriginals: (nodes: AntTreeDataNode[] | undefined, originalKeysToFind: Set<Key>, map: Map<Key, Key>) => Key[];
+export declare const processTreeData: <T extends AntTreeDataNode = AntTreeDataNode>(nodes: T[] | undefined, expandedOriginalKeys: Set<Key>, parentKeyPrefix: string, keyMap: Map<Key, Key>) => T[] | undefined;

package/dist/components/src/components/Tree/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./useUniqueKeysTree";
+export * from "./helpers";
+export * from "./components";