@_tc/template-core 0.1.16 → 0.2.0-bate.0

package/model/packages/react/ui/components/Message/MessageManager.d.ts

@@ -0,0 +1,36 @@
+import type { ReactNode } from "react";
+import { type MessageProps, type MessageType } from "./Message";
+type MessageConfig = Omit<MessageProps, 'onClose' | 'children'> & {
+    id: string;
+    content?: ReactNode;
+    onClose?: () => void;
+};
+declare class MessageManagerClass {
+    private messages;
+    private container;
+    private offScreenContainer;
+    private root;
+    private offScreenRoot;
+    private maxCount;
+    private init;
+    private render;
+    show(config: Omit<MessageConfig, 'id'>, type?: MessageType): string;
+    close(id: string): void;
+    closeAll(): void;
+    setMaxCount(count: number): void;
+}
+export declare const messageManager: MessageManagerClass;
+type MessageFN = (content: ReactNode, config?: {
+    duration?: number;
+    onClose?: () => void;
+}) => string;
+export declare const message: {
+    success: MessageFN;
+    error: MessageFN;
+    warning: MessageFN;
+    info: MessageFN;
+    close: (id: string) => void;
+    closeAll: () => void;
+    setMaxCount: (count: number) => void;
+};
+export {};

package/model/packages/react/ui/components/Message/data.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_DURATION = 3000;

package/model/packages/react/ui/components/Message/index.d.ts

@@ -0,0 +1,2 @@
+export type { MessageProps, MessageType } from "./Message";
+export { message } from "./MessageManager";

package/model/packages/react/ui/components/Modal/Modal.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+export type ModalProps = {
+    open?: boolean;
+    onClose?: () => void;
+    title?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    className?: string;
+    contentClassName?: string;
+    mask?: boolean;
+    maskClosable?: boolean;
+    lockScroll?: boolean;
+    closable?: boolean;
+    width?: number | string;
+    centered?: boolean;
+    zIndex?: number;
+    renderNode?: HTMLElement | (() => HTMLElement);
+    keyboard?: boolean;
+};
+export declare function Modal({ open, onClose, title, children, footer, className, contentClassName, mask, maskClosable, lockScroll, closable, width, centered, renderNode, keyboard, zIndex, }: ModalProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Modal/ModalManager.d.ts

@@ -0,0 +1,46 @@
+import type { ReactNode } from "react";
+import { type SubmitButtonProps } from "../Button";
+import { type ModalProps } from "./Modal";
+type ModalConfig = Omit<ModalProps, 'open' | 'onClose' | 'children'> & {
+    id: string;
+    onClose?: () => void;
+    content?: ReactNode;
+};
+declare class ModalManagerClass {
+    private modals;
+    private listeners;
+    private container;
+    private root;
+    private init;
+    private notify;
+    subscribe(listener: () => void): () => void;
+    open(config: Omit<ModalConfig, 'id'>): string;
+    close(id: string): void;
+    closeAll(): void;
+    getModals(): ModalConfig[];
+    private render;
+}
+type OpenModalConfig = Omit<ModalConfig, 'id'>;
+export declare const openConfirmModal: (pConfig: Pick<OpenModalConfig, "content"> & {
+    title?: ReactNode;
+    content: ReactNode;
+    okText?: string;
+    cancelText?: string;
+    onOk?: SubmitButtonProps["onClick"];
+    onCancel?: () => void;
+}) => string;
+export declare const modalManager: ModalManagerClass;
+export declare const modal: {
+    open: (config: OpenModalConfig) => string;
+    confirm: (pConfig: Pick<OpenModalConfig, "content"> & {
+        title?: ReactNode;
+        content: ReactNode;
+        okText?: string;
+        cancelText?: string;
+        onOk?: SubmitButtonProps["onClick"];
+        onCancel?: () => void;
+    }) => string;
+    close: (id: string) => void;
+    closeAll: () => void;
+};
+export {};

package/model/packages/react/ui/components/Modal/index.d.ts

@@ -0,0 +1,3 @@
+export { Modal } from "./Modal";
+export type { ModalProps } from "./Modal";
+export { modal } from "./ModalManager";

package/model/packages/react/ui/components/Notification/Notification.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+export type NotificationType = 'info' | 'success' | 'warning' | 'error';
+export type NotificationProps = {
+    type?: NotificationType;
+    title?: ReactNode;
+    message?: ReactNode;
+    duration?: number;
+    closable?: boolean;
+    onClose?: () => void;
+    className?: string;
+};
+declare const Notification: import("react").ForwardRefExoticComponent<NotificationProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Notification };

package/model/packages/react/ui/components/Notification/index.d.ts

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

package/model/packages/react/ui/components/Overlay/Overlay.d.ts

@@ -0,0 +1,19 @@
+import type { CSSProperties, MouseEvent, ReactNode } from "react";
+export declare const canUseDocument: () => boolean;
+export type OverlayProps = {
+    open?: boolean;
+    visible?: boolean;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    zIndex?: number;
+    mask?: boolean;
+    maskClosable?: boolean;
+    lockScroll?: boolean;
+    keyboard?: boolean;
+    closable?: boolean;
+    onClose?: () => void;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+    renderNode?: HTMLElement | (() => HTMLElement);
+};
+export declare function Overlay({ open, visible, children, className, style, zIndex, mask, maskClosable, lockScroll, keyboard, closable, onClose, onClick, renderNode, }: OverlayProps): import("react").ReactPortal | null;

package/model/packages/react/ui/components/Overlay/index.d.ts

@@ -0,0 +1,2 @@
+export { Overlay, canUseDocument } from "./Overlay";
+export type { OverlayProps } from "./Overlay";

package/model/packages/react/ui/components/Pagination/Pagination.d.ts

@@ -0,0 +1,10 @@
+export interface PaginationProps {
+    current: number;
+    pageSize: number;
+    total: number;
+    onChange: (page: number) => void;
+    onPageSizeChange?: (pageSize: number) => void;
+    pageSizeOptions?: number[];
+    className?: string;
+}
+export declare function Pagination({ current, pageSize, total, onChange, onPageSizeChange, pageSizeOptions, className, }: PaginationProps): import("react/jsx-runtime").JSX.Element | null;

package/model/packages/react/ui/components/Pagination/index.d.ts

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

package/model/packages/react/ui/components/Popup/Popup.d.ts

@@ -0,0 +1,25 @@
+import type { CSSProperties, ReactNode, RefObject } from "react";
+import { type DropdownPlacement, type DropdownPosition, type DropdownPositioningStrategy, type UseDropdownPositioningResult } from "../hooks/useDropdownPositioning";
+export interface PopupProps {
+    open: boolean;
+    anchorRef: RefObject<HTMLElement | null>;
+    children: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    placement?: DropdownPlacement;
+    offset?: number;
+    keepMounted?: boolean;
+    closeOnClickOutside?: boolean;
+    closeOnEscape?: boolean;
+    matchAnchorWidth?: boolean;
+    position?: DropdownPosition;
+    positioning?: UseDropdownPositioningResult;
+    strategy?: DropdownPositioningStrategy;
+    contentRef?: RefObject<HTMLDivElement | null>;
+    container?: HTMLElement;
+    positionMode?: "fixed" | "absolute";
+    hoverBridge?: number;
+    hoverBridgePlacement?: "auto" | "horizontal";
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function Popup({ open, anchorRef, children, className, style, placement, offset, keepMounted, closeOnClickOutside, closeOnEscape, matchAnchorWidth, position, positioning, strategy, contentRef, container, positionMode, hoverBridge, hoverBridgePlacement, onOpenChange, }: PopupProps): import("react").ReactPortal | null;

package/model/packages/react/ui/components/Popup/index.d.ts

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

package/model/packages/react/ui/components/Radio/Radio.d.ts

@@ -0,0 +1,8 @@
+import type { InputHTMLAttributes, ReactNode } from "react";
+export type RadioProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'children'> & {
+    label?: ReactNode;
+};
+declare const Radio: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "type"> & {
+    label?: ReactNode;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export { Radio };

package/model/packages/react/ui/components/Radio/RadioGroup.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react";
+export type RadioGroupProps = {
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    direction?: 'horizontal' | 'vertical';
+    children?: ReactNode;
+    className?: string;
+};
+type RadioGroupContextValue = {
+    name?: string;
+    selectedValue?: string;
+    onSelect?: (value: string) => void;
+};
+export declare function useRadioGroupContext(): RadioGroupContextValue;
+declare const RadioGroup: import("react").ForwardRefExoticComponent<RadioGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+export { RadioGroup };

package/model/packages/react/ui/components/Radio/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Radio";
+export * from "./RadioGroup";

package/model/packages/react/ui/components/Search/Search.d.ts

@@ -0,0 +1,13 @@
+import type { MOmit } from "../../../../../../fe/packages/react/ui/types/index";
+import type { FormInstance } from "rc-field-form";
+import type { ReactNode } from "react";
+import { type FormFieldSchema } from "../Form";
+export type SearchProps<T> = {
+    defaultValue?: T;
+    schemas: MOmit<FormFieldSchema<T>, 'rules' | 'required'>[];
+    children?: ReactNode;
+    getForm?: (form: FormInstance<T>) => void;
+    btnsClassName?: string;
+};
+declare const Search: <T extends object>(props: SearchProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default Search;

package/model/packages/react/ui/components/Search/index.d.ts

@@ -0,0 +1 @@
+export { default as Search } from "./Search";

package/model/packages/react/ui/components/Select/Select.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+export type SelectOption = {
+    label: React.ReactNode;
+    value: string | number;
+    searchText?: string;
+};
+export type SelectProps = {
+    options: SelectOption[];
+    value?: string | number;
+    defaultValue?: string | number;
+    placeholder?: string;
+    onChange?: (value: string | number | undefined) => void;
+    loading?: boolean;
+    className?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    searchable?: boolean;
+    getPopupContainer?: 'parent' | (() => HTMLElement);
+};
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLDivElement>>;
+export { Select };

package/model/packages/react/ui/components/Select/dropdownPositioning.d.ts

@@ -0,0 +1,2 @@
+import type { DropdownPositioningStrategy } from "../hooks/useDropdownPositioning";
+export declare const getSelectDropdownPosition: DropdownPositioningStrategy;

package/model/packages/react/ui/components/Select/index.d.ts

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

package/model/packages/react/ui/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes } from "react";
+export type SkeletonMode = 'pageloading' | 'tableloading' | 'componentsloading';
+export interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    mode?: SkeletonMode;
+    rows?: number;
+    showTitle?: boolean;
+    showActions?: boolean;
+}
+export declare const Skeleton: {
+    ({ mode, className, rows, showTitle, showActions, ...props }: SkeletonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/model/packages/react/ui/components/Skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { Skeleton } from "./Skeleton";
+export type { SkeletonProps, SkeletonMode } from "./Skeleton";

package/model/packages/react/ui/components/Switch/Switch.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export type SwitchProps = {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+};
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/model/packages/react/ui/components/Switch/index.d.ts

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

package/model/packages/react/ui/components/TableSearch/TableSearch.d.ts

@@ -0,0 +1,30 @@
+import { ExportType } from "../../../../../../fe/packages/react/ui/lib/export";
+import type { MOmit } from "../../../../../../fe/packages/react/ui/types/index";
+import { type ReactNode } from "react";
+import { type DropdownItem } from "../Dropdown";
+import type { FormFieldSchema } from "../Form";
+import type { SearchProps } from "../Search/Search";
+export type TableSearchSchema<T> = MOmit<FormFieldSchema<T>, 'rules' | 'required'> & {
+    isPermanent?: boolean;
+};
+type TableSearchProps<T> = MOmit<SearchProps<T>, 'children' | 'schemas'> & {
+    onSearch?: (values: T) => void;
+    onReset?: () => void;
+    renderActionBtnArea?: () => ReactNode;
+    schemas: TableSearchSchema<T>[];
+    exportMenuItems?: DropdownItem[];
+    btnConfig?: Partial<{
+        export?: ReactNode;
+        collapse?: ReactNode;
+        expandIcon?: ReactNode;
+        expand?: ReactNode;
+        reset?: ReactNode;
+        search?: ReactNode;
+    }>;
+    expandBoundaries?: number;
+    onExport?: (exportType: ExportType, searchData: T) => void;
+    additionalButtons?: ReactNode;
+    defaultExpand?: boolean;
+};
+declare const TableSearch: <T extends object>(props: TableSearchProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default TableSearch;

package/model/packages/react/ui/components/TableSearch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TableSearch } from "./TableSearch";
+export type { TableSearchSchema } from "./TableSearch";

package/model/packages/react/ui/components/TableSearch/lang.d.ts

@@ -0,0 +1,14 @@
+export interface TableSearchLocaleConfig {
+    reset: string;
+    search: string;
+    export: string;
+    expand: string;
+    collapse: string;
+    exportCurrentPage: string;
+    exportCurrentQuery: string;
+}
+export declare const zhCNLocale: TableSearchLocaleConfig;
+export declare const enUSLocale: TableSearchLocaleConfig;
+export declare const defaultLocale: TableSearchLocaleConfig;
+export declare const btnConfig: TableSearchLocaleConfig;
+export declare const updateBtnConfig: (config: Partial<TableSearchLocaleConfig>) => void;

package/model/packages/react/ui/components/TableSearch/tableSearchLocaleStore.d.ts

@@ -0,0 +1,8 @@
+import { type TableSearchLocaleConfig } from "./lang";
+type TableSearchLocaleState = {
+    locale: TableSearchLocaleConfig;
+    replaceLocale: (nextLocale: TableSearchLocaleConfig) => void;
+    resetLocale: () => void;
+};
+export declare const useTableSearchLocaleStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TableSearchLocaleState>>;
+export {};

package/model/packages/react/ui/components/Tabs/Tabs.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+export type TabItem = {
+    key: string;
+    label: ReactNode;
+    disabled?: boolean;
+};
+export type TabsProps = {
+    items: TabItem[];
+    activeKey?: string;
+    defaultActiveKey?: string;
+    onChange?: (key: string) => void;
+    className?: string;
+};
+declare const Tabs: import("react").ForwardRefExoticComponent<TabsProps & import("react").RefAttributes<HTMLDivElement>>;
+export { Tabs };

package/model/packages/react/ui/components/Tabs/index.d.ts

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

package/model/packages/react/ui/components/Textarea/Textarea.d.ts

@@ -0,0 +1,20 @@
+import type { ChangeEvent, TextareaHTMLAttributes } from "react";
+export type TextareaProps = Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "onChange" | "defaultValue"> & {
+    value?: string;
+    onChange?: (v: string, e: ChangeEvent<HTMLTextAreaElement>) => void;
+    defaultValue?: string;
+    maxLength?: number;
+    showCount?: boolean;
+    placeholder?: string;
+    textareaClassName?: string;
+};
+declare const Textarea: import("react").ForwardRefExoticComponent<Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "value" | "defaultValue" | "onChange"> & {
+    value?: string;
+    onChange?: (v: string, e: ChangeEvent<HTMLTextAreaElement>) => void;
+    defaultValue?: string;
+    maxLength?: number;
+    showCount?: boolean;
+    placeholder?: string;
+    textareaClassName?: string;
+} & import("react").RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/model/packages/react/ui/components/Textarea/index.d.ts

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

package/model/packages/react/ui/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,8 @@
+export interface TooltipProps {
+    content: React.ReactNode;
+    children: React.ReactElement;
+    placement?: "top" | "bottom" | "left" | "right";
+    visible?: boolean;
+    className?: string;
+}
+export declare function Tooltip({ content, children, placement, visible, className, }: TooltipProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Tooltip/index.d.ts

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

package/model/packages/react/ui/components/TreeSelect/TreeSelect.d.ts

@@ -0,0 +1,18 @@
+export interface TreeNode {
+    id: string | number;
+    name: string;
+    desctext?: string;
+    children?: TreeNode[];
+}
+export interface TreeSelectProps {
+    data: TreeNode[];
+    value?: (string | number)[];
+    onChange?: (keys: {
+        checked: (string | number)[];
+        indeterminate: (string | number)[];
+    }) => void;
+    labelField?: 'name' | 'desctext';
+    checkable?: boolean;
+    className?: string;
+}
+export declare function TreeSelect({ data, value, onChange, labelField, checkable, className, }: TreeSelectProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/TreeSelect/index.d.ts

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

package/model/packages/react/ui/components/Upload/ImageUpload.d.ts

@@ -0,0 +1,8 @@
+export interface ImageUploadProps {
+    accept?: string;
+    maxCount?: number;
+    value?: string[];
+    onChange?: (urls: string[]) => void;
+    beforeChange?: (file: File) => boolean | void;
+}
+export declare function ImageUpload({ accept, maxCount, value, onChange, beforeChange }: ImageUploadProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Upload/Upload.d.ts

@@ -0,0 +1,13 @@
+import type { ChangeEvent, ReactNode, RefObject } from "react";
+export interface FileUploadProps {
+    inputRef?: RefObject<HTMLInputElement | null>;
+    accept?: string;
+    multiple?: boolean;
+    onChange?: (event: ChangeEvent<HTMLInputElement>) => void;
+    selectLabel: ReactNode;
+    labelClassName?: string;
+    showClear?: boolean;
+    onClear?: () => void;
+    clearLabel?: ReactNode;
+}
+export declare function FileUpload({ inputRef, accept, multiple, onChange, selectLabel, labelClassName, showClear, onClear, clearLabel, }: FileUploadProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/Upload/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ImageUpload";
+export * from "./Upload";

package/model/packages/react/ui/components/breadcrumb/breadcrumb.d.ts

@@ -0,0 +1,34 @@
+declare const Breadcrumb: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & {
+    separator?: React.ReactNode;
+} & import("react").RefAttributes<HTMLElement>>;
+declare const BreadcrumbList: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & import("react").RefAttributes<HTMLOListElement>>;
+declare const BreadcrumbItem: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & import("react").RefAttributes<HTMLLIElement>>;
+declare const BreadcrumbLink: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & import("react").RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbPage: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    active?: boolean;
+    onClose?: () => void;
+    closable?: boolean;
+} & import("react").RefAttributes<HTMLSpanElement>>;
+declare const BreadcrumbSeparator: {
+    ({ children, className, ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const BreadcrumbEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, };
+export interface BreadcrumbItemData {
+    label: string;
+    desctext?: string;
+    id: string | number;
+    path?: string;
+    active?: boolean;
+    closable?: boolean;
+}
+export interface SimpleBreadcrumbProps {
+    className?: string;
+}
+export declare function SimpleBreadcrumb({ className }: SimpleBreadcrumbProps): import("react/jsx-runtime").JSX.Element;

package/model/packages/react/ui/components/breadcrumb/index.d.ts

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

package/model/packages/react/ui/components/hooks/useDropdownPositioning.d.ts

@@ -0,0 +1,42 @@
+import type { RefObject } from "react";
+export type DropdownPlacement = "bottom-end" | "bottom-start" | "left-start" | "top-end" | "top-start" | "right-start" | "right-end";
+export type DropdownPosition = {
+    top: number;
+    left?: number;
+    right?: number;
+    width?: number;
+};
+export type DropdownPositioningContext = {
+    anchorRect: DOMRect;
+    contentRect?: DOMRect;
+    containerRect?: DOMRect;
+    viewportWidth: number;
+    viewportHeight: number;
+    placement: DropdownPlacement;
+    offset: number;
+    matchAnchorWidth: boolean;
+};
+export type DropdownPositioningStrategy = (context: DropdownPositioningContext) => DropdownPosition;
+export type UseDropdownPositioningOptions = {
+    open: boolean;
+    anchorRef: RefObject<HTMLElement | null>;
+    contentRef: RefObject<HTMLElement | null>;
+    placement?: DropdownPlacement;
+    offset?: number;
+    matchAnchorWidth?: boolean;
+    strategy?: DropdownPositioningStrategy;
+    estimateSize?: () => {
+        width?: number;
+        height?: number;
+    };
+    watchDeps?: readonly unknown[];
+    containerRef?: RefObject<HTMLElement | null>;
+    positionMode?: "fixed" | "absolute";
+};
+export type UseDropdownPositioningResult = {
+    position: DropdownPosition;
+    ready: boolean;
+    updatePosition: () => void;
+};
+export declare const getDefaultDropdownPosition: DropdownPositioningStrategy;
+export declare function useDropdownPositioning({ open, anchorRef, contentRef, placement, offset, matchAnchorWidth, strategy, estimateSize, watchDeps, containerRef, positionMode, }: UseDropdownPositioningOptions): UseDropdownPositioningResult;

package/model/packages/react/ui/components/hooks/useInputController.d.ts

@@ -0,0 +1,20 @@
+interface IParams<T> {
+    ref: React.ForwardedRef<T>;
+    defaultValue?: string;
+    controlledValue?: string;
+    disabled?: boolean;
+}
+export declare const useInputController: <T>(params: IParams<T>) => {
+    setRefs: (node: T | null) => void;
+    setIsFocused: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    setInternalValue: import("react").Dispatch<import("react").SetStateAction<string>>;
+    controllerRef: import("react").RefObject<T | null>;
+    isControlledRef: import("react").RefObject<boolean>;
+    isControlled: boolean;
+    isFocused: boolean;
+    currentLength: number;
+    hasValue: boolean;
+    internalValue: string;
+    value: string | undefined;
+};
+export {};

package/model/packages/react/ui/components/index.d.ts

@@ -0,0 +1,35 @@
+export * from "./breadcrumb";
+export * from "./Button";
+export * from "./Card";
+export * from "./Checkbox";
+export * from "./ConfirmDialog";
+export * from "./DataTable";
+export * from "./Drawer";
+export * from "./Dropdown";
+export * from "./Popup";
+export * from "./Form";
+export * from "./hooks/useDropdownPositioning";
+export * from "./ImagePreview";
+export * from "./Input";
+export * from "./InputNumber";
+export * from "./Label";
+export * from "./Layout";
+export * from "./Loading";
+export * from "./Menu";
+export * from "./Message";
+export * from "./Modal";
+export * from "./Notification";
+export * from "./Overlay";
+export * from "./Pagination";
+export * from "./Radio";
+export * from "./Search";
+export * from "./Select";
+export * from "./Skeleton";
+export * from "./Switch";
+export * from "./table";
+export * from "./TableSearch";
+export * from "./Tabs";
+export * from "./Textarea";
+export * from "./Tooltip";
+export * from "./TreeSelect";
+export * from "./Upload";

package/model/packages/react/ui/components/table/index.d.ts

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