@laser-ui/components 0.0.1

package/timeline/Timeline.js

@@ -0,0 +1,53 @@
+import { __rest } from "tslib";
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { checkNodeExist } from '@laser-ui/utils';
+import { Fragment } from 'react';
+import { CLASSES } from './vars';
+import { useComponentProps, useStyled } from '../hooks';
+import { mergeCS } from '../utils';
+export function Timeline(props) {
+    const _a = useComponentProps('Timeline', props), { styleOverrides, styleProvider, list, vertical = false, lineSize = 36 } = _a, restProps = __rest(_a, ["styleOverrides", "styleProvider", "list", "vertical", "lineSize"]);
+    const styled = useStyled(CLASSES, { timeline: styleProvider === null || styleProvider === void 0 ? void 0 : styleProvider.timeline }, styleOverrides);
+    const nodeExist = (() => {
+        const hasNode = [false, false];
+        for (const item of list) {
+            if (checkNodeExist(item.content[0])) {
+                hasNode[0] = true;
+            }
+            if (checkNodeExist(item.content[1])) {
+                hasNode[1] = true;
+            }
+        }
+        return hasNode;
+    })();
+    return (_jsx("div", Object.assign({}, restProps, mergeCS(styled('timeline', {
+        'timeline--vertical': vertical,
+    }), {
+        className: restProps.className,
+        style: restProps.style,
+    }), { children: vertical ? (_jsx(_Fragment, { children: list.map((item, index) => {
+                const { state: itemState = 'wait', content: itemContent, color: itemColor, dot: itemDot } = item;
+                return (_jsxs(Fragment, { children: [_jsxs("div", Object.assign({}, styled('timeline__content'), { children: [nodeExist[0] && _jsx("div", Object.assign({}, styled('timeline__text', 'timeline__text--left'), { children: itemContent[0] })), _jsxs("div", Object.assign({}, mergeCS(styled('timeline__track', `timeline__track.is-${itemState}`), {
+                                    style: Object.assign({ '--color': itemColor }, { width: lineSize }),
+                                }), { children: [_jsx("div", Object.assign({}, styled('timeline__separator', {
+                                            'timeline__separator--hidden': index === 0,
+                                        }))), checkNodeExist(itemDot) ? itemDot : _jsx("div", Object.assign({}, styled('timeline__dot'))), _jsx("div", Object.assign({}, styled('timeline__separator', {
+                                            'timeline__separator--hidden': index === list.length - 1,
+                                        })))] })), nodeExist[1] && _jsx("div", Object.assign({}, styled('timeline__text'), { children: itemContent[1] }))] })), index !== list.length - 1 && (_jsxs("div", Object.assign({}, styled('timeline__content', 'timeline__content--gap'), { children: [nodeExist[0] && _jsx("div", Object.assign({}, styled('timeline__text', 'timeline__text--left'))), _jsx("div", Object.assign({}, mergeCS(styled('timeline__track'), { style: { width: lineSize } }), { children: _jsx("div", Object.assign({}, styled('timeline__separator'))) })), nodeExist[1] && _jsx("div", Object.assign({}, styled('timeline__text')))] })))] }, index));
+            }) })) : (_jsxs(_Fragment, { children: [nodeExist[0] && (_jsx("div", Object.assign({}, styled('timeline__text-container'), { children: list.map((item, index) => (_createElement("div", Object.assign({}, styled('timeline__text'), { key: index }), item.content[0]))) }))), _jsx("div", Object.assign({}, mergeCS(styled('timeline__track-container'), {
+                    style: { height: lineSize },
+                }), { children: list.map((item, index) => {
+                        const { state: itemState = 'wait', color: itemColor, dot: itemDot } = item;
+                        return (_createElement("div", Object.assign({}, mergeCS(styled('timeline__track', `timeline__track.is-${itemState}`), {
+                            style: Object.assign({}, { '--color': itemColor }),
+                        }), { key: index }),
+                            _jsx("div", Object.assign({}, styled('timeline__separator', {
+                                'timeline__separator--hidden': index === 0,
+                            }))),
+                            checkNodeExist(itemDot) ? itemDot : _jsx("div", Object.assign({}, styled('timeline__dot'))),
+                            _jsx("div", Object.assign({}, styled('timeline__separator', {
+                                'timeline__separator--hidden': index === list.length - 1,
+                            })))));
+                    }) })), nodeExist[1] && (_jsx("div", Object.assign({}, styled('timeline__text-container'), { children: list.map((item, index) => (_createElement("div", Object.assign({}, styled('timeline__text'), { key: index }), item.content[1]))) })))] })) })));
+}

package/timeline/index.d.ts

@@ -0,0 +1,2 @@
+export type { TimelineProps } from './types';
+export { Timeline } from './Timeline';

package/timeline/index.js

@@ -0,0 +1 @@
+export { Timeline } from './Timeline';

package/timeline/types.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { CLASSES } from './vars';
+import type { BaseProps } from '../types';
+export {};
+export interface TimelineItem {
+    content: [React.ReactNode, React.ReactNode];
+    state?: 'wait' | 'active' | 'completed' | 'warning' | 'error';
+    color?: string;
+    dot?: React.ReactNode;
+}
+export interface TimelineProps<T extends TimelineItem> extends BaseProps<'timeline', typeof CLASSES>, Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    list: T[];
+    vertical?: boolean;
+    lineSize?: number;
+}

package/timeline/types.js

@@ -0,0 +1 @@
+export {};

package/timeline/vars.d.ts

@@ -0,0 +1,19 @@
+export declare const CLASSES: {
+    timeline: string;
+    'timeline--vertical': string;
+    timeline__content: string;
+    'timeline__content--gap': string;
+    'timeline__text-container': string;
+    timeline__text: string;
+    'timeline__text--left': string;
+    'timeline__track-container': string;
+    timeline__track: string;
+    'timeline__track.is-wait': string;
+    'timeline__track.is-active': string;
+    'timeline__track.is-completed': string;
+    'timeline__track.is-warning': string;
+    'timeline__track.is-error': string;
+    timeline__dot: string;
+    timeline__separator: string;
+    'timeline__separator--hidden': string;
+};

package/timeline/vars.js

@@ -0,0 +1,19 @@
+export const CLASSES = {
+    timeline: '^timeline',
+    'timeline--vertical': '^timeline--vertical',
+    timeline__content: '^timeline__content',
+    'timeline__content--gap': '^timeline__content--gap',
+    'timeline__text-container': '^timeline__text-container',
+    timeline__text: '^timeline__text',
+    'timeline__text--left': '^timeline__text--left',
+    'timeline__track-container': '^timeline__track-container',
+    timeline__track: '^timeline__track',
+    'timeline__track.is-wait': 'is-wait',
+    'timeline__track.is-active': 'is-active',
+    'timeline__track.is-completed': 'is-completed',
+    'timeline__track.is-warning': 'is-warning',
+    'timeline__track.is-error': 'is-error',
+    timeline__dot: '^timeline__dot',
+    timeline__separator: '^timeline__separator',
+    'timeline__separator--hidden': '^timeline__separator--hidden',
+};

package/toast/Toast.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { ToastProps } from './types';
+export declare function Toast(props: ToastProps): JSX.Element | null;

package/toast/Toast.js

@@ -0,0 +1,123 @@
+import { __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useAsync, useMount } from '@laser-ui/hooks';
+import { checkNodeExist } from '@laser-ui/utils';
+import { ReactComponent as CheckCircleOutlined } from '@material-design-icons/svg/outlined/check_circle.svg';
+import { ReactComponent as CloseOutlined } from '@material-design-icons/svg/outlined/close.svg';
+import { ReactComponent as HighlightOffOutlined } from '@material-design-icons/svg/outlined/highlight_off.svg';
+import { ReactComponent as InfoOutlined } from '@material-design-icons/svg/outlined/info.svg';
+import { ReactComponent as WarningAmberOutlined } from '@material-design-icons/svg/outlined/warning_amber.svg';
+import { isUndefined } from 'lodash';
+import { useId, useRef } from 'react';
+import { CLASSES, TTANSITION_DURING } from './vars';
+import { useComponentProps, useNamespace, useStyled, useTranslation } from '../hooks';
+import { Icon } from '../icon';
+import { Portal } from '../internal/portal';
+import { Transition } from '../internal/transition';
+import { mergeCS } from '../utils';
+export function Toast(props) {
+    const _a = useComponentProps('Toast', props), { children, styleOverrides, styleProvider, visible, type, placement = 'top', duration = 2, icon, closable = false, escClosable = true, skipFirstTransition = true, destroyAfterClose = true, onClose, afterVisibleChange } = _a, restProps = __rest(_a, ["children", "styleOverrides", "styleProvider", "visible", "type", "placement", "duration", "icon", "closable", "escClosable", "skipFirstTransition", "destroyAfterClose", "onClose", "afterVisibleChange"]);
+    const namespace = useNamespace();
+    const styled = useStyled(CLASSES, { toast: styleProvider === null || styleProvider === void 0 ? void 0 : styleProvider.toast }, styleOverrides);
+    const { t } = useTranslation();
+    const async = useAsync();
+    const toastRef = useRef(null);
+    const dataRef = useRef({});
+    const uniqueId = useId();
+    const messageId = `${namespace}-toast-content-${uniqueId}`;
+    useMount(() => {
+        if (duration > 0) {
+            dataRef.current.clearTid = async.setTimeout(() => {
+                onClose === null || onClose === void 0 ? void 0 : onClose();
+            }, duration * 1000);
+        }
+    });
+    return (_jsx(Portal, { selector: () => {
+            const id = placement === 'top' ? `${namespace}-toast-t-root` : `${namespace}-toast-b-root`;
+            let root = document.getElementById(`${namespace}-toast-root`);
+            if (!root) {
+                root = document.createElement('div');
+                root.id = `${namespace}-toast-root`;
+                document.body.appendChild(root);
+            }
+            let el = document.getElementById(id);
+            if (!el) {
+                el = document.createElement('div');
+                el.id = id;
+                root.appendChild(el);
+            }
+            return el;
+        }, children: _jsx(Transition, { enter: visible, during: TTANSITION_DURING, skipFirstTransition: skipFirstTransition, destroyWhenLeaved: destroyAfterClose, afterEnter: () => {
+                afterVisibleChange === null || afterVisibleChange === void 0 ? void 0 : afterVisibleChange(true);
+            }, afterLeave: () => {
+                afterVisibleChange === null || afterVisibleChange === void 0 ? void 0 : afterVisibleChange(false);
+            }, children: (state) => {
+                var _a, _b;
+                let transitionStyle = {};
+                switch (state) {
+                    case 'enter':
+                        transitionStyle = {
+                            transform: placement === 'top' ? 'translate(0, -70%)' : 'translate(0, 70%)',
+                            opacity: 0,
+                        };
+                        break;
+                    case 'entering':
+                        transitionStyle = {
+                            transition: ['transform', 'opacity'].map((attr) => `${attr} ${TTANSITION_DURING.enter}ms ease-out`).join(', '),
+                        };
+                        break;
+                    case 'leave':
+                        if (toastRef.current) {
+                            const height = toastRef.current.offsetHeight;
+                            transitionStyle = { height, overflow: 'hidden' };
+                        }
+                        break;
+                    case 'leaving':
+                        transitionStyle = {
+                            height: 0,
+                            overflow: 'hidden',
+                            paddingTop: 0,
+                            paddingBottom: 0,
+                            marginTop: 0,
+                            marginBottom: 0,
+                            opacity: 0,
+                            transition: ['height', 'padding', 'margin', 'opacity']
+                                .map((attr) => `${attr} ${TTANSITION_DURING.leave}ms ease-in`)
+                                .join(', '),
+                        };
+                        break;
+                    case 'leaved':
+                        transitionStyle = { display: 'none' };
+                        break;
+                    default:
+                        break;
+                }
+                return (_jsxs("div", Object.assign({}, restProps, mergeCS(styled('toast', {
+                    [`toast--${type}`]: type,
+                }), {
+                    className: restProps.className,
+                    style: Object.assign(Object.assign({}, restProps.style), transitionStyle),
+                }), { ref: toastRef, tabIndex: (_a = restProps.tabIndex) !== null && _a !== void 0 ? _a : -1, role: (_b = restProps.role) !== null && _b !== void 0 ? _b : 'alert', "aria-describedby": messageId, onMouseEnter: (e) => {
+                        var _a, _b, _c;
+                        (_a = restProps.onMouseEnter) === null || _a === void 0 ? void 0 : _a.call(restProps, e);
+                        (_c = (_b = dataRef.current).clearTid) === null || _c === void 0 ? void 0 : _c.call(_b);
+                    }, onMouseLeave: (e) => {
+                        var _a;
+                        (_a = restProps.onMouseLeave) === null || _a === void 0 ? void 0 : _a.call(restProps, e);
+                        if (duration > 0) {
+                            dataRef.current.clearTid = async.setTimeout(() => {
+                                onClose === null || onClose === void 0 ? void 0 : onClose();
+                            }, duration * 1000);
+                        }
+                    }, onKeyDown: (e) => {
+                        var _a, _b, _c;
+                        (_a = restProps.onKeyDown) === null || _a === void 0 ? void 0 : _a.call(restProps, e);
+                        if (visible && escClosable && e.code === 'Escape') {
+                            e.stopPropagation();
+                            e.preventDefault();
+                            (_c = (_b = dataRef.current).clearTid) === null || _c === void 0 ? void 0 : _c.call(_b);
+                            onClose === null || onClose === void 0 ? void 0 : onClose();
+                        }
+                    }, children: [icon !== false && (!isUndefined(type) || checkNodeExist(icon)) && (_jsx("div", Object.assign({}, styled('toast__icon'), { children: checkNodeExist(icon) ? (icon) : (_jsx(Icon, { children: type === 'success' ? (_jsx(CheckCircleOutlined, {})) : type === 'warning' ? (_jsx(WarningAmberOutlined, {})) : type === 'error' ? (_jsx(HighlightOffOutlined, {})) : (_jsx(InfoOutlined, {})) })) }))), _jsx("div", Object.assign({}, styled('toast__message'), { id: messageId, children: children })), closable && (_jsx("button", Object.assign({}, styled('toast__close'), { "aria-label": t('Close'), onClick: onClose, children: _jsx(Icon, { children: _jsx(CloseOutlined, {}) }) })))] })));
+            } }) }));
+}

package/toast/index.d.ts

@@ -0,0 +1,2 @@
+export type { ToastProps } from './types';
+export { Toast } from './Toast';

package/toast/index.js

@@ -0,0 +1 @@
+export { Toast } from './Toast';

package/toast/types.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import type { CLASSES } from './vars';
+import type { BaseProps } from '../types';
+export {};
+export interface ToastProps extends BaseProps<'toast', typeof CLASSES>, React.HTMLAttributes<HTMLDivElement> {
+    visible: boolean;
+    type?: 'success' | 'warning' | 'error' | 'info';
+    placement?: 'top' | 'bottom';
+    duration?: number;
+    icon?: React.ReactNode;
+    closable?: boolean;
+    escClosable?: boolean;
+    skipFirstTransition?: boolean;
+    destroyAfterClose?: boolean;
+    onClose?: () => void;
+    afterVisibleChange?: (visible: boolean) => void;
+}

package/toast/types.js

@@ -0,0 +1 @@
+export {};

package/toast/vars.d.ts

@@ -0,0 +1,14 @@
+export declare const CLASSES: {
+    toast: string;
+    'toast--success': string;
+    'toast--warning': string;
+    'toast--error': string;
+    'toast--info': string;
+    toast__icon: string;
+    toast__message: string;
+    toast__close: string;
+};
+export declare const TTANSITION_DURING: {
+    enter: number;
+    leave: number;
+};

package/toast/vars.js

@@ -0,0 +1,11 @@
+export const CLASSES = {
+    toast: '^toast',
+    'toast--success': '^toast--success',
+    'toast--warning': '^toast--warning',
+    'toast--error': '^toast--error',
+    'toast--info': '^toast--info',
+    toast__icon: '^toast__icon',
+    toast__message: '^toast__message',
+    toast__close: '^toast__close',
+};
+export const TTANSITION_DURING = { enter: 133, leave: 166 };

package/tooltip/Tooltip.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { TooltipProps, TooltipRef } from './types';
+export declare const Tooltip: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<TooltipRef>>;

package/tooltip/Tooltip.js

@@ -0,0 +1,113 @@
+import { __rest } from "tslib";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEventCallback, useRefExtra } from '@laser-ui/hooks';
+import { isFunction, isUndefined } from 'lodash';
+import { cloneElement, forwardRef, useId, useImperativeHandle, useRef, useState } from 'react';
+import { CLASSES, TTANSITION_DURING } from './vars';
+import { useComponentProps, useControlled, useMaxIndex, useNamespace, useStyled } from '../hooks';
+import { Popup } from '../internal/popup';
+import { Portal } from '../internal/portal';
+import { Transition } from '../internal/transition';
+import { getPopupPosition, mergeCS } from '../utils';
+export const Tooltip = forwardRef((props, ref) => {
+    var _a;
+    const _b = useComponentProps('Tooltip', props), { children, styleOverrides, styleProvider, title, visible: visibleProp, defaultVisible, trigger = 'hover', placement: placementProp = 'top', placementFixed = false, arrow = true, escClosable = true, gap = 10, inWindow = false, mouseEnterDelay = 150, mouseLeaveDelay = 200, skipFirstTransition = true, destroyAfterClose = true, zIndex: zIndexProp, scrolling, onVisibleChange, afterVisibleChange } = _b, restProps = __rest(_b, ["children", "styleOverrides", "styleProvider", "title", "visible", "defaultVisible", "trigger", "placement", "placementFixed", "arrow", "escClosable", "gap", "inWindow", "mouseEnterDelay", "mouseLeaveDelay", "skipFirstTransition", "destroyAfterClose", "zIndex", "scrolling", "onVisibleChange", "afterVisibleChange"]);
+    const namespace = useNamespace();
+    const styled = useStyled(CLASSES, { tooltip: styleProvider === null || styleProvider === void 0 ? void 0 : styleProvider.tooltip }, styleOverrides);
+    const uniqueId = useId();
+    const id = (_a = restProps.id) !== null && _a !== void 0 ? _a : `${namespace}-tooltip-${uniqueId}`;
+    const triggerRef = useRefExtra(() => document.querySelector(`[aria-describedby="${id}"]`));
+    const popupRef = useRef(null);
+    const scrollingRef = useRefExtra(scrolling);
+    const [visible, changeVisible] = useControlled(defaultVisible !== null && defaultVisible !== void 0 ? defaultVisible : false, visibleProp, onVisibleChange);
+    const maxZIndex = useMaxIndex(visible);
+    const zIndex = !isUndefined(zIndexProp) ? zIndexProp : `calc(var(--${namespace}-zindex-fixed) + ${maxZIndex})`;
+    const [popupPositionStyle, setPopupPositionStyle] = useState({
+        top: '-200vh',
+        left: '-200vw',
+    });
+    const [transformOrigin, setTransformOrigin] = useState();
+    const [placement, setPlacement] = useState(placementProp);
+    const updatePosition = useEventCallback(() => {
+        if (visible && triggerRef.current && popupRef.current) {
+            const position = getPopupPosition(triggerRef.current, { width: popupRef.current.offsetWidth, height: popupRef.current.offsetHeight }, {
+                placement: placementProp,
+                placementFallback: placement,
+                placementFixed,
+                gap,
+                inWindow,
+            });
+            setPopupPositionStyle({
+                top: position.top,
+                left: position.left,
+            });
+            setTransformOrigin(position.transformOrigin);
+            setPlacement(position.placement);
+        }
+    });
+    useImperativeHandle(ref, () => ({
+        updatePosition,
+    }), [updatePosition]);
+    return (_jsx(Popup, { visible: visible, trigger: trigger, mouseEnterDelay: mouseEnterDelay, mouseLeaveDelay: mouseLeaveDelay, updatePosition: {
+            fn: updatePosition,
+            triggerRef,
+            popupRef,
+            containerRefs: [scrollingRef],
+        }, onVisibleChange: changeVisible, children: ({ renderTrigger, renderPopup }) => {
+            const render = (el) => renderTrigger(cloneElement(el, {
+                'aria-describedby': id,
+                onKeyDown: (e) => {
+                    var _a, _b;
+                    (_b = (_a = el.props).onKeyDown) === null || _b === void 0 ? void 0 : _b.call(_a, e);
+                    if (visible && escClosable && e.code === 'Escape') {
+                        e.stopPropagation();
+                        e.preventDefault();
+                        changeVisible(false);
+                    }
+                },
+            }));
+            return (_jsxs(_Fragment, { children: [isFunction(children) ? children(render) : render(children), _jsx(Portal, { selector: () => {
+                            let el = document.getElementById(`${namespace}-tooltip-root`);
+                            if (!el) {
+                                el = document.createElement('div');
+                                el.id = `${namespace}-tooltip-root`;
+                                document.body.appendChild(el);
+                            }
+                            return el;
+                        }, children: _jsx(Transition, { enter: visible, during: TTANSITION_DURING, skipFirstTransition: skipFirstTransition, destroyWhenLeaved: destroyAfterClose, afterRender: updatePosition, afterEnter: () => {
+                                afterVisibleChange === null || afterVisibleChange === void 0 ? void 0 : afterVisibleChange(true);
+                            }, afterLeave: () => {
+                                afterVisibleChange === null || afterVisibleChange === void 0 ? void 0 : afterVisibleChange(false);
+                            }, children: (state) => {
+                                let transitionStyle = {};
+                                switch (state) {
+                                    case 'enter':
+                                        transitionStyle = { transform: 'scale(0.3)', opacity: 0 };
+                                        break;
+                                    case 'entering':
+                                        transitionStyle = {
+                                            transition: ['transform', 'opacity'].map((attr) => `${attr} ${TTANSITION_DURING.enter}ms ease-out`).join(', '),
+                                            transformOrigin,
+                                        };
+                                        break;
+                                    case 'leaving':
+                                        transitionStyle = {
+                                            transform: 'scale(0.3)',
+                                            opacity: 0,
+                                            transition: ['transform', 'opacity'].map((attr) => `${attr} ${TTANSITION_DURING.leave}ms ease-in`).join(', '),
+                                            transformOrigin,
+                                        };
+                                        break;
+                                    case 'leaved':
+                                        transitionStyle = { display: 'none' };
+                                        break;
+                                    default:
+                                        break;
+                                }
+                                return renderPopup(_jsxs("div", Object.assign({}, restProps, mergeCS(styled('tooltip', `tooltip--${placement}`), {
+                                    className: restProps.className,
+                                    style: Object.assign(Object.assign(Object.assign(Object.assign({}, restProps.style), { zIndex }), popupPositionStyle), transitionStyle),
+                                }), { ref: popupRef, id: id, role: "tooltip", children: [arrow && _jsx("div", Object.assign({}, styled('tooltip__arrow'))), title] })));
+                            } }) })] }));
+        } }));
+});

package/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export type { TooltipRef, TooltipProps } from './types';
+export { Tooltip } from './Tooltip';

package/tooltip/index.js

@@ -0,0 +1 @@
+export { Tooltip } from './Tooltip';

package/tooltip/types.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import type { CLASSES } from './vars';
+import type { BaseProps, CloneHTMLElement, PopupPlacement } from '../types';
+import type { RefExtra } from '@laser-ui/hooks/useRefExtra';
+export {};
+export interface TooltipRef {
+    updatePosition: () => void;
+}
+export interface TooltipProps extends BaseProps<'tooltip', typeof CLASSES>, Omit<React.HTMLAttributes<HTMLDivElement>, 'children' | 'title'> {
+    children: React.ReactElement | ((render: CloneHTMLElement) => JSX.Element | null);
+    title: React.ReactNode;
+    visible?: boolean;
+    defaultVisible?: boolean;
+    trigger?: 'hover' | 'click';
+    placement?: PopupPlacement;
+    placementFixed?: boolean;
+    arrow?: boolean;
+    escClosable?: boolean;
+    gap?: number;
+    inWindow?: number | false;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+    skipFirstTransition?: boolean;
+    destroyAfterClose?: boolean;
+    zIndex?: number | string;
+    scrolling?: RefExtra;
+    onVisibleChange?: (visible: boolean) => void;
+    afterVisibleChange?: (visible: boolean) => void;
+}

package/tooltip/types.js

@@ -0,0 +1 @@
+export {};

package/tooltip/vars.d.ts

@@ -0,0 +1,20 @@
+export declare const CLASSES: {
+    tooltip: string;
+    'tooltip--top': string;
+    'tooltip--top-left': string;
+    'tooltip--top-right': string;
+    'tooltip--right': string;
+    'tooltip--right-top': string;
+    'tooltip--right-bottom': string;
+    'tooltip--bottom': string;
+    'tooltip--bottom-left': string;
+    'tooltip--bottom-right': string;
+    'tooltip--left': string;
+    'tooltip--left-top': string;
+    'tooltip--left-bottom': string;
+    tooltip__arrow: string;
+};
+export declare const TTANSITION_DURING: {
+    enter: number;
+    leave: number;
+};

package/tooltip/vars.js

@@ -0,0 +1,17 @@
+export const CLASSES = {
+    tooltip: '^tooltip',
+    'tooltip--top': '^tooltip--top',
+    'tooltip--top-left': '^tooltip--top-left',
+    'tooltip--top-right': '^tooltip--top-right',
+    'tooltip--right': '^tooltip--right',
+    'tooltip--right-top': '^tooltip--right-top',
+    'tooltip--right-bottom': '^tooltip--right-bottom',
+    'tooltip--bottom': '^tooltip--bottom',
+    'tooltip--bottom-left': '^tooltip--bottom-left',
+    'tooltip--bottom-right': '^tooltip--bottom-right',
+    'tooltip--left': '^tooltip--left',
+    'tooltip--left-top': '^tooltip--left-top',
+    'tooltip--left-bottom': '^tooltip--left-bottom',
+    tooltip__arrow: '^tooltip__arrow',
+};
+export const TTANSITION_DURING = { enter: 86, leave: 100 };

package/transfer/Transfer.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { TransferItem, TransferProps } from './types';
+export declare function Transfer<V extends React.Key, T extends TransferItem<V>>(props: TransferProps<V, T>): JSX.Element | null;