@openviking/react 0.1.2 → 0.1.4

package/dist/o~0.js

@@ -0,0 +1,106 @@
+import { useEffect, useLayoutEffect, useState } from "react";
+const usePositionEffect = "u" < typeof window ? useEffect : useLayoutEffect;
+const OVERLAY_OFFSET = 6;
+const VIEWPORT_MARGIN = 8;
+const OPPOSITE = {
+    top: 'bottom',
+    bottom: 'top',
+    left: 'right',
+    right: 'left'
+};
+function resolvePosition(trigger, surface, placement, alignment = 'center') {
+    const viewportWidth = window.innerWidth;
+    const viewportHeight = window.innerHeight;
+    const fits = (side)=>{
+        if ('top' === side) return trigger.top - surface.height - OVERLAY_OFFSET >= VIEWPORT_MARGIN;
+        if ('bottom' === side) return trigger.bottom + surface.height + OVERLAY_OFFSET <= viewportHeight - VIEWPORT_MARGIN;
+        if ('left' === side) return trigger.left - surface.width - OVERLAY_OFFSET >= VIEWPORT_MARGIN;
+        return trigger.right + surface.width + OVERLAY_OFFSET <= viewportWidth - VIEWPORT_MARGIN;
+    };
+    const side = fits(placement) || !fits(OPPOSITE[placement]) ? placement : OPPOSITE[placement];
+    const clamp = (value, size, limit)=>Math.min(Math.max(value, VIEWPORT_MARGIN), limit - size - VIEWPORT_MARGIN);
+    if ('top' === side || 'bottom' === side) {
+        const top = 'top' === side ? trigger.top - surface.height - OVERLAY_OFFSET : trigger.bottom + OVERLAY_OFFSET;
+        const left = 'end' === alignment ? trigger.right - surface.width : trigger.left + trigger.width / 2 - surface.width / 2;
+        return {
+            top: clamp(top, surface.height, viewportHeight),
+            left: clamp(left, surface.width, viewportWidth),
+            placement: side
+        };
+    }
+    const left = 'left' === side ? trigger.left - surface.width - OVERLAY_OFFSET : trigger.right + OVERLAY_OFFSET;
+    const top = trigger.top + trigger.height / 2 - surface.height / 2;
+    return {
+        top: clamp(top, surface.height, viewportHeight),
+        left: clamp(left, surface.width, viewportWidth),
+        placement: side
+    };
+}
+function useOverlayPosition(open, triggerRef, surface, placement, alignment = 'center') {
+    const [position, setPosition] = useState({
+        top: 0,
+        left: 0,
+        placement
+    });
+    usePositionEffect(()=>{
+        if (!open) return;
+        const trigger = triggerRef.current;
+        if (!trigger || !surface) return;
+        const written = new Set();
+        const syncTheme = ()=>{
+            const triggerStyle = window.getComputedStyle(trigger);
+            const seen = new Set();
+            for (const name of Array.from(triggerStyle)){
+                if (!name.startsWith('--ov-ui-color-')) continue;
+                const value = triggerStyle.getPropertyValue(name).trim();
+                if (value) {
+                    seen.add(name);
+                    surface.style.setProperty(name, value);
+                }
+            }
+            for (const name of written)if (!seen.has(name)) surface.style.removeProperty(name);
+            written.clear();
+            seen.forEach((name)=>written.add(name));
+        };
+        syncTheme();
+        const themeObserver = new MutationObserver(syncTheme);
+        const observerOptions = {
+            attributes: true,
+            attributeFilter: [
+                'class',
+                'style',
+                'data-theme'
+            ]
+        };
+        for(let node = trigger; node; node = node.parentElement)themeObserver.observe(node, observerOptions);
+        const update = ()=>{
+            const triggerRect = trigger.getBoundingClientRect();
+            const surfaceRect = surface.getBoundingClientRect();
+            const next = resolvePosition(triggerRect, {
+                width: surfaceRect.width,
+                height: surfaceRect.height
+            }, placement, alignment);
+            setPosition((previous)=>previous.top === next.top && previous.left === next.left && previous.placement === next.placement ? previous : next);
+        };
+        update();
+        const observer = new ResizeObserver(update);
+        observer.observe(surface);
+        window.addEventListener('scroll', update, true);
+        window.addEventListener('resize', update);
+        return ()=>{
+            observer.disconnect();
+            themeObserver.disconnect();
+            written.forEach((name)=>surface.style.removeProperty(name));
+            window.removeEventListener('scroll', update, true);
+            window.removeEventListener('resize', update);
+        };
+    }, [
+        open,
+        placement,
+        surface,
+        triggerRef,
+        alignment
+    ]);
+    return position;
+}
+export { useOverlayPosition };

package/dist/p~0.js

@@ -0,0 +1,27 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+const SvgSearch = (props)=>/*#__PURE__*/ jsx("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: 16,
+        height: 16,
+        fill: "none",
+        viewBox: "0 0 16 16",
+        ...props,
+        children: /*#__PURE__*/ jsxs("g", {
+            stroke: "currentColor",
+            strokeWidth: 1.2,
+            children: [
+                /*#__PURE__*/ jsx("circle", {
+                    cx: 7.167,
+                    cy: 7.167,
+                    r: 4.667
+                }),
+                /*#__PURE__*/ jsx("path", {
+                    strokeLinecap: "round",
+                    d: "m10.667 10.667 3 3"
+                })
+            ]
+        })
+    });
+const searchreact = SvgSearch;
+export { searchreact };

package/dist/rslib-runtime~0.js

@@ -0,0 +1,42 @@
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+export { __webpack_require__ };

package/dist/r~0.js

@@ -0,0 +1,152 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { cloneElement, useCallback, useEffect, useId, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import { useOverlayPosition } from "./o~0.js";
+const DEFAULT_LABELS = {
+    close: 'Close'
+};
+function useMergedRef(ref, target) {
+    const merged = useCallback((node)=>{
+        target.current = node;
+        if ('function' == typeof ref) ref(node);
+        else if (ref) ref.current = node;
+    }, [
+        ref,
+        target
+    ]);
+    return merged;
+}
+function Tooltip({ children, content, placement = 'top', trigger = 'hover', delay = 300, disabled = false, className, style, onOpenChange, labels }) {
+    const text = {
+        ...DEFAULT_LABELS,
+        ...labels
+    };
+    const [open, setOpen] = useState(false);
+    const triggerRef = useRef(null);
+    const timerRef = useRef(void 0);
+    const [surfaceNode, setSurfaceNode] = useState(null);
+    const id = useId();
+    const position = useOverlayPosition(open, triggerRef, surfaceNode, placement);
+    const change = useCallback((next)=>{
+        setOpen(next);
+        onOpenChange?.(next);
+    }, [
+        onOpenChange
+    ]);
+    const clearTimer = useCallback(()=>{
+        if (void 0 !== timerRef.current) {
+            window.clearTimeout(timerRef.current);
+            timerRef.current = void 0;
+        }
+    }, []);
+    useEffect(()=>clearTimer, [
+        clearTimer
+    ]);
+    useEffect(()=>{
+        if (disabled) {
+            clearTimer();
+            setOpen(false);
+        }
+    }, [
+        disabled,
+        clearTimer
+    ]);
+    useEffect(()=>{
+        if (!open) return;
+        const onPointerDown = (event)=>{
+            const target = event.target;
+            if (surfaceNode?.contains(target) || triggerRef.current?.contains(target)) return;
+            change(false);
+        };
+        const onKeyDown = (event)=>{
+            if ('Escape' === event.key) {
+                clearTimer();
+                change(false);
+            }
+        };
+        if ('click' === trigger) document.addEventListener('mousedown', onPointerDown);
+        document.addEventListener('keydown', onKeyDown);
+        return ()=>{
+            if ('click' === trigger) document.removeEventListener('mousedown', onPointerDown);
+            document.removeEventListener('keydown', onKeyDown);
+        };
+    }, [
+        change,
+        clearTimer,
+        open,
+        surfaceNode,
+        trigger
+    ]);
+    const show = ()=>{
+        if (disabled) return;
+        if ('click' === trigger) return void change(!open);
+        clearTimer();
+        timerRef.current = window.setTimeout(()=>{
+            change(true);
+            timerRef.current = void 0;
+        }, delay);
+    };
+    const hide = ()=>{
+        if ('click' === trigger) return;
+        clearTimer();
+        timerRef.current = window.setTimeout(()=>{
+            change(false);
+            timerRef.current = void 0;
+        }, 120);
+    };
+    const child = children;
+    const childProps = child.props;
+    const childRef = child.ref;
+    const mergedRef = useMergedRef(childRef, triggerRef);
+    const triggerElement = /*#__PURE__*/ cloneElement(child, {
+        ref: mergedRef,
+        'aria-describedby': open && 'hover' === trigger ? id : void 0,
+        'aria-expanded': 'click' === trigger ? open : childProps['aria-expanded'],
+        onMouseEnter: (event)=>{
+            childProps.onMouseEnter?.(event);
+            if ('hover' === trigger) show();
+        },
+        onMouseLeave: (event)=>{
+            childProps.onMouseLeave?.(event);
+            if ('hover' === trigger) hide();
+        },
+        onFocus: (event)=>{
+            childProps.onFocus?.(event);
+            if ('hover' === trigger) show();
+        },
+        onBlur: (event)=>{
+            childProps.onBlur?.(event);
+            hide();
+        },
+        onClick: (event)=>{
+            childProps.onClick?.(event);
+            if ('click' === trigger) show();
+        }
+    });
+    const surface = open ? /*#__PURE__*/ createPortal(/*#__PURE__*/ jsx("div", {
+        ref: setSurfaceNode,
+        id: id,
+        role: 'hover' === trigger ? 'tooltip' : 'dialog',
+        "aria-label": 'click' === trigger ? text.close : void 0,
+        className: [
+            'ov-tooltip',
+            className
+        ].filter(Boolean).join(' '),
+        "data-placement": position.placement,
+        style: {
+            top: position.top,
+            left: position.left,
+            ...style
+        },
+        onMouseEnter: 'hover' === trigger ? clearTimer : void 0,
+        onMouseLeave: 'hover' === trigger ? hide : void 0,
+        children: content
+    }), document.body) : null;
+    return /*#__PURE__*/ jsxs(Fragment, {
+        children: [
+            triggerElement,
+            surface
+        ]
+    });
+}
+export { Tooltip };

package/dist/shared/components/divider/divider.d.ts

@@ -0,0 +1,18 @@
+import type { DividerProps } from './types.js';
+export type { DividerOrientation, DividerProps } from './types.js';
+/**
+ * 一条分隔线。并排的控件之间用竖线，堆叠的分组之间用横线。
+ *
+ * 尺寸用内联样式给：`length` 与 `thickness` 都是运行时值，写进类名只能固定成
+ * 几个预设，而调用方要的往往是「和旁边按钮一样高」这种随上下文变化的长度。
+ * 颜色默认取主题基线的边框色，宿主换主题时自动跟随。
+ *
+ * A single divider: vertical between side-by-side controls, horizontal between
+ * stacked groups.
+ *
+ * Sizing is inline because `length` and `thickness` are runtime values; baking them
+ * into class names would fix them to a few presets, while a caller usually wants a
+ * length that follows its context, such as "as tall as the button beside it". The
+ * colour defaults to the baseline border, so it follows a host theme change.
+ */
+export declare function Divider({ orientation, length, thickness, color, className, style, ...rest }: DividerProps): import("react").JSX.Element;

package/dist/shared/components/divider/index.d.ts

@@ -0,0 +1 @@
+export * from './divider.js';

package/dist/shared/components/divider/types.d.ts

@@ -0,0 +1,35 @@
+import type { CSSProperties, HTMLAttributes } from 'react';
+/**
+ * 分隔线的方向。竖线用于并排的控件之间，横线用于堆叠的分组之间。
+ * Direction of the divider: vertical between side-by-side controls, horizontal
+ * between stacked groups.
+ */
+export type DividerOrientation = 'vertical' | 'horizontal';
+/**
+ * 分隔线的属性。
+ *
+ * 它只是一个 `role="separator"` 的元素，不占交互焦点，也不读屏幕阅读器以外的
+ * 内容。长度由 `length` 决定，颜色默认取主题基线里的边框色。
+ *
+ * Props of the divider.
+ *
+ * It is just a `role="separator"` element: not focusable, and it carries no content
+ * for a screen reader. `length` sets its extent, and the colour defaults to the
+ * baseline border.
+ */
+export interface DividerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** 方向，默认竖线。Orientation; vertical by default. */
+    orientation?: DividerOrientation;
+    /**
+     * 线的长度：竖线是高度，横线是宽度。省略时由父级布局决定，横线默认铺满。
+     * Extent of the line: height for a vertical one, width for a horizontal one.
+     * Omitted leaves it to the parent layout; a horizontal one fills by default.
+     */
+    length?: number | string;
+    /** 线的粗细，缺省为 1px。Thickness, 1px by default. */
+    thickness?: number | string;
+    /** 线的颜色，缺省取主题基线的边框色。Colour; defaults to the baseline border. */
+    color?: string;
+    /** 内联样式，可覆盖上面的值。Inline styles, overriding the values above. */
+    style?: CSSProperties;
+}

package/dist/shared/components/drawer/drawer.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode, RefObject } from 'react';
+export interface DrawerProps {
+    id: string;
+    open: boolean;
+    title: string;
+    closeLabel: string;
+    triggerRef: RefObject<HTMLElement | null>;
+    children: ReactNode;
+    className?: string;
+    lang?: string;
+    onClose: () => void;
+}
+export declare function Drawer({ id, open, title, closeLabel, triggerRef, children, className, lang, onClose, }: DrawerProps): import("react").ReactPortal | null;

package/dist/shared/components/drawer/index.d.ts

@@ -0,0 +1 @@
+export * from './drawer.js';

package/dist/shared/components/overlay/types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 浮层相对触发元素的方位。空间不足时会自动翻到对侧。
+ *
+ * Where the surface sits relative to its trigger. It flips to the opposite side
+ * when there is not enough room.
+ */
+export type OverlayPlacement = 'top' | 'bottom' | 'left' | 'right';

package/dist/shared/components/{tooltip/use-tooltip-position.d.ts → overlay/use-overlay-position.d.ts}

@@ -1,11 +1,11 @@
-import type { TooltipPlacement } from './types.js';
+import type { OverlayPlacement } from './types.js';
 /** 浮层与触发元素之间的间隙。 Gap between the surface and its trigger. */
-export declare const OFFSET = 6;
-export interface TooltipPosition {
+export declare const OVERLAY_OFFSET = 6;
+export interface OverlayPosition {
     top: number;
     left: number;
     /** 实际采用的方位，可能与请求的不同。 The placement actually used. */
-    placement: TooltipPlacement;
+    placement: OverlayPlacement;
 }
 /**
  * 按触发元素与浮层尺寸算出一个视口坐标。空间不足时翻到对侧，仍放不下就
@@ -18,7 +18,7 @@ export interface TooltipPosition {
 export declare function resolvePosition(trigger: DOMRect, surface: {
     width: number;
     height: number;
-}, placement: TooltipPlacement): TooltipPosition;
+}, placement: OverlayPlacement, alignment?: 'center' | 'end'): OverlayPosition;
 /**
  * 跟踪浮层的视口坐标。
  *
@@ -35,4 +35,4 @@ export declare function resolvePosition(trigger: DOMRect, surface: {
  * that is derivable during render. Scroll is captured so inner scroll containers
  * count too; listeners are removed on close or unmount.
  */
-export declare function useTooltipPosition(open: boolean, triggerRef: React.RefObject<HTMLElement | null>, surface: HTMLElement | null, placement: TooltipPlacement): TooltipPosition;
+export declare function useOverlayPosition(open: boolean, triggerRef: React.RefObject<HTMLElement | null>, surface: HTMLElement | null, placement: OverlayPlacement, alignment?: 'center' | 'end'): OverlayPosition;

package/dist/shared/components/popover/index.d.ts

@@ -0,0 +1 @@
+export * from './popover.js';

package/dist/shared/components/popover/popover.d.ts

@@ -0,0 +1,23 @@
+import type { PopoverProps } from './types.js';
+export type { PopoverPlacement, PopoverProps, PopoverTrigger, } from './types.js';
+/**
+ * 弹出层：挂一段结构化信息或一小块可交互内容。
+ *
+ * 渲染到 `document.body`，因此不会被祖先的 `overflow: hidden` 裁掉——文件树的
+ * 行就处在这样的容器里。定位用 fixed 视口坐标，空间不足时翻到对侧。
+ *
+ * 与 `Tooltip` 分开，是因为两者视觉与语义都不同：提示是深色的一句话，弹出层是
+ * 白底卡片。共用的部分（portal、定位、主题变量同步）留在 `overlay/`。
+ *
+ * A surface holding structured information or a small piece of interactive
+ * content.
+ *
+ * It renders into `document.body`, so an ancestor's `overflow: hidden` cannot clip
+ * it — the file tree's rows sit inside exactly such a container. Positioning uses
+ * fixed viewport coordinates and flips sides when space runs out.
+ *
+ * It is separate from `Tooltip` because the two differ in look and semantics: a
+ * tooltip is one dark line, a popover is a white card. What they share — the
+ * portal, positioning and theme-variable syncing — lives in `overlay/`.
+ */
+export declare function Popover({ children, content, placement, trigger, delay, disabled, className, style, onOpenChange, }: PopoverProps): import("react").JSX.Element;

package/dist/shared/components/popover/types.d.ts

@@ -0,0 +1,50 @@
+import type { OverlayPlacement } from '../overlay/types.js';
+import type { CSSProperties, ReactElement, ReactNode } from 'react';
+/**
+ * 弹出层的方位，与提示共用一套取值。空间不足时自动翻到对侧。
+ * Where the popover sits relative to its trigger, sharing the tooltip's values.
+ * It flips to the opposite side when there is not enough room.
+ */
+export type PopoverPlacement = OverlayPlacement;
+/**
+ * 触发方式。`hover` 悬停与聚焦都展示，适合展示型内容；`click` 点击切换，适合
+ * 放按钮、菜单这类可交互的内容。
+ *
+ * How the popover opens. `hover` shows it on hover and focus, for display
+ * content; `click` toggles it, for interactive content such as buttons or menus.
+ */
+export type PopoverTrigger = 'hover' | 'click';
+/**
+ * 弹出层的属性。
+ *
+ * 与提示的区别是视觉与语义：提示是深色底的一句话，弹出层是白底卡片，用来放
+ * 结构化信息或可交互内容。两者共用同一套 portal 与定位，触发元素都必须是能
+ * 接受 `ref` 的单个元素。
+ *
+ * Props of the popover.
+ *
+ * It differs from the tooltip in look and semantics: a tooltip is one dark line,
+ * a popover is a white card for structured or interactive content. Both share the
+ * same portal and positioning, and the trigger must be a single element that
+ * accepts a `ref`.
+ */
+export interface PopoverProps {
+    /** 触发元素，必须是能接受 ref 的单个元素。 The trigger; a single element that accepts a ref. */
+    children: ReactElement;
+    /** 浮层内容。 Surface content. */
+    content: ReactNode;
+    /** 方位，默认 `right`——内容在行尾展开，不遮挡左侧。 Placement, `right` by default. */
+    placement?: PopoverPlacement;
+    /** 触发方式，默认 `hover`。 Trigger mode, `hover` by default. */
+    trigger?: PopoverTrigger;
+    /** 悬停后多久展示，单位毫秒。延迟只作用于 `hover`。 Hover delay in ms; `hover` only. */
+    delay?: number;
+    /** 为真时不展示浮层。 Suppresses the surface; the trigger still renders. */
+    disabled?: boolean;
+    /** 浮层容器的额外类名。 Extra class names for the surface. */
+    className?: string;
+    /** 浮层容器的内联样式，可覆盖定位以外的样式。 Inline styles for the surface. */
+    style?: CSSProperties;
+    /** 展示状态变化时触发。 Fires when the surface opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+}

package/dist/shared/components/resizable/clamp.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 把宽度夹到 `[min, max]` 之间，并取整。
+ *
+ * 上限可能小于下限——容器被压得很窄时就会这样。此时以下限为准：面板宁可把
+ * 邻居挤小，也不该缩到看不见内容。
+ *
+ * Clamps a width into `[min, max]` and rounds it.
+ *
+ * The maximum can fall below the minimum when the container is squeezed hard. The
+ * minimum wins then: a panel may crowd its neighbour rather than shrink until
+ * nothing is readable.
+ */
+export declare function clampResizableWidth(width: number, min: number, max: number): number;

package/dist/shared/components/resizable/index.d.ts

@@ -0,0 +1,2 @@
+export { ResizableHandle, clampResizableWidth } from './resizable-handle.js';
+export type { ResizableHandleProps, ResizeDirection, } from './resizable-handle.js';

package/dist/shared/components/resizable/resizable-handle.d.ts

@@ -0,0 +1,25 @@
+import type { ResizableHandleProps } from './types.js';
+export type { ResizableHandleProps, ResizeDirection } from './types.js';
+export { clampResizableWidth } from './clamp.js';
+/**
+ * 一条可拖拽的分隔条，用来改相邻面板的宽度。
+ *
+ * 宽度是受控的：组件只上报夹取后的新值，面板多宽由调用方决定。拖动期间用
+ * 指针捕获接住后续事件，因此不需要往 `window` 上挂监听，也不留全局副作用
+ * ——`preventDefault` 已经挡住拖动引起的文字选中。方向键同样能改宽，键盘用户
+ * 不必依赖指针。
+ *
+ * 省略 `onResize` 时退化成一根装饰线：不可拖动、不可聚焦，也不播报宽度。
+ *
+ * A draggable divider that resizes the neighbouring panel.
+ *
+ * The width is controlled: this only reports a clamped new value and the caller
+ * decides how wide the panel is. Pointer capture receives the rest of the drag, so
+ * nothing is bound to `window` and no global state is touched — `preventDefault`
+ * already stops the drag from selecting text. The arrow keys resize too, so a
+ * keyboard user never needs a pointer.
+ *
+ * Without `onResize` it degrades to a decorative rule: not draggable, not
+ * focusable, and it announces no width.
+ */
+export declare function ResizableHandle({ label, min, max, value, step, direction, onResize, className, ...rest }: ResizableHandleProps): import("react").JSX.Element;

package/dist/shared/components/resizable/types.d.ts

@@ -0,0 +1,48 @@
+import type { HTMLAttributes } from 'react';
+/**
+ * 拖动方向：向右拖动让面板变宽为 `1`，变窄为 `-1`。
+ *
+ * 面板在分隔条左侧时用 `1`，在右侧时用 `-1`，否则往右拖反而变小。
+ *
+ * Drag direction: `1` widens the panel as the pointer moves right, `-1` narrows
+ * it. A panel left of the divider uses `1`, one on its right uses `-1`; the
+ * wrong sign makes a rightward drag shrink the panel.
+ */
+export type ResizeDirection = 1 | -1;
+/**
+ * 分隔条的属性。
+ *
+ * 它是一个 `role="separator"` 的可聚焦控件：拖动改宽，左右方向键也能改，屏幕
+ * 阅读器通过 `aria-valuenow` 读到当前宽度。宽度本身由调用方持有，这里只上报
+ * 夹取后的新值——面板多宽属于布局，不属于分隔条。
+ *
+ * Props of the divider.
+ *
+ * It is a focusable `role="separator"` control: drag to resize, or use the left
+ * and right arrow keys, with a screen reader reading the current width from
+ * `aria-valuenow`. The width itself belongs to the caller; this only reports the
+ * clamped new value, because how wide a panel is is layout, not a divider's own
+ * state.
+ */
+export interface ResizableHandleProps extends Omit<HTMLAttributes<HTMLDivElement>, 'role' | 'children' | 'defaultValue'> {
+    /** 无障碍名称，例如「调整目录树宽度」。 Accessible name, such as "Resize the directory tree". */
+    label: string;
+    /** 最小宽度，单位像素。 Minimum width in pixels. */
+    min: number;
+    /** 最大宽度，单位像素。 Maximum width in pixels. */
+    max: number;
+    /** 当前宽度，单位像素。 Current width in pixels. */
+    value: number;
+    /** 方向键每次调整的像素数，缺省 16。 Pixels per arrow-key press, 16 by default. */
+    step?: number;
+    /** 拖动方向，缺省 `1`。 Drag direction, `1` by default. */
+    direction?: ResizeDirection;
+    /**
+     * 拖动或按键产生新宽度时触发，参数已夹到 `[min, max]`。省略时分隔条只作为
+     * 装饰线存在，不可拖动也不可聚焦。
+     *
+     * Fires with a new width already clamped to `[min, max]`. Omitting it leaves the
+     * divider as a decorative rule: not draggable and not focusable.
+     */
+    onResize?: (width: number) => void;
+}

package/dist/shared/components/tooltip/types.d.ts

@@ -1,11 +1,11 @@
 import type { CSSProperties, ReactElement, ReactNode } from 'react';
+import type { OverlayPlacement } from '../overlay/types.js';
 /**
- * 浮层相对触发元素的方位。空间不足时会自动翻到对侧。
- *
- * Where the surface sits relative to its trigger. It flips to the opposite side
- * when there is not enough room.
+ * 提示相对触发元素的方位，与浮层共用一套取值。空间不足时自动翻到对侧。
+ * Where the hint sits relative to its trigger, sharing the overlay's values. It
+ * flips to the opposite side when there is not enough room.
  */
-export type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+export type TooltipPlacement = OverlayPlacement;
 /**
  * 触发方式。`hover` 悬停与聚焦都展示，适合按钮提示；`click` 点击切换，
  * 适合放可交互的内容。

package/dist/shared/components/tooltip/use-portal-theme.d.ts

@@ -0,0 +1,3 @@
+import type { RefObject } from 'react';
+/** Keep a body portal in sync with the host's scoped public theme overrides. */
+export declare function usePortalTheme(open: boolean, triggerRef: RefObject<HTMLElement | null>, surface: HTMLElement | null): void;

package/dist/shared/locale.d.ts

@@ -0,0 +1,6 @@
+/** Internal language resources shared by components and modules. */
+export type Locale = 'en-US' | 'zh-CN';
+export type LocaleMessages<T> = Record<Locale, T>;
+/** Missing overrides inherit the selected language; empty strings stay explicit. */
+export declare function mergeLabels<T extends object>(defaults: T, overrides?: Partial<T>): T;
+export declare function resolveLocale<T extends object>(messages: LocaleMessages<T>, locale?: Locale, overrides?: Partial<T>): T;