@wzyjs/uis 0.3.28 → 0.3.30

package/dist/advanced/MindMap/hooks/useExpandCollapse.js

@@ -0,0 +1,108 @@
+'use client';
+import { useCallback, useMemo } from 'react';
+const buildChildrenById = (edges) => {
+    const map = new Map();
+    edges.forEach(edge => {
+        const prev = map.get(edge.source) ?? [];
+        map.set(edge.source, [...prev, edge.target]);
+    });
+    return map;
+};
+const getDescendantIdSet = (childrenById, rootId) => {
+    const visited = new Set([rootId]);
+    const result = new Set();
+    const queue = [rootId];
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        if (!currentId) {
+            continue;
+        }
+        const children = childrenById.get(currentId) ?? [];
+        for (const childId of children) {
+            if (visited.has(childId)) {
+                continue;
+            }
+            visited.add(childId);
+            result.add(childId);
+            queue.push(childId);
+        }
+    }
+    return result;
+};
+export const useExpandCollapse = (params) => {
+    const { nodes, edges, onNodesChange, onEdgesChange } = params;
+    const childrenById = useMemo(() => {
+        return buildChildrenById(edges);
+    }, [edges]);
+    const nodeById = useMemo(() => {
+        return new Map(nodes.map(n => [n.id, n]));
+    }, [nodes]);
+    const edgeById = useMemo(() => {
+        return new Map(edges.map(e => [e.id, e]));
+    }, [edges]);
+    const getCounts = useCallback((nodeId) => {
+        const childCount = (childrenById.get(nodeId) ?? []).length;
+        const descendantCount = getDescendantIdSet(childrenById, nodeId).size;
+        return { childCount, descendantCount };
+    }, [childrenById]);
+    const setSubtreeHidden = useCallback((nodeId, hidden) => {
+        const descendantIdSet = getDescendantIdSet(childrenById, nodeId);
+        if (descendantIdSet.size === 0) {
+            return;
+        }
+        if (onNodesChange) {
+            const nodeChanges = [];
+            descendantIdSet.forEach(id => {
+                const node = nodeById.get(id);
+                if (!node) {
+                    return;
+                }
+                if ((node.hidden ?? false) === hidden) {
+                    return;
+                }
+                nodeChanges.push({
+                    type: 'replace',
+                    id,
+                    item: {
+                        ...node,
+                        hidden,
+                        selected: false,
+                    },
+                });
+            });
+            if (nodeChanges.length > 0) {
+                onNodesChange(nodeChanges);
+            }
+        }
+        if (onEdgesChange) {
+            const idSet = new Set([nodeId, ...Array.from(descendantIdSet)]);
+            const edgeChanges = edges
+                .filter(edge => idSet.has(edge.source) && idSet.has(edge.target))
+                .map(edge => edgeById.get(edge.id))
+                .filter((edge) => !!edge)
+                .filter(edge => (edge.hidden ?? false) !== hidden)
+                .map(edge => ({
+                type: 'replace',
+                id: edge.id,
+                item: {
+                    ...edge,
+                    hidden,
+                },
+            }));
+            if (edgeChanges.length > 0) {
+                onEdgesChange(edgeChanges);
+            }
+        }
+    }, [childrenById, edgeById, edges, nodeById, onEdgesChange, onNodesChange]);
+    const expand = useCallback((nodeId) => {
+        setSubtreeHidden(nodeId, false);
+    }, [setSubtreeHidden]);
+    const collapse = useCallback((nodeId) => {
+        setSubtreeHidden(nodeId, true);
+    }, [setSubtreeHidden]);
+    return {
+        getCounts,
+        expand,
+        collapse,
+    };
+};

package/dist/advanced/MindMap/hooks/useMoveDescendants.d.ts

@@ -0,0 +1,12 @@
+import type { Edge, Node, NodeChange } from '@xyflow/react';
+interface UseMoveDescendantsParams<TNodeData extends Record<string, unknown>> {
+    enabled?: boolean;
+    nodes: Array<Node<TNodeData>>;
+    edges: Edge[];
+    onNodesChange?: (changes: Array<NodeChange<Node<TNodeData>>>) => void;
+}
+interface UseMoveDescendantsResult<TNodeData extends Record<string, unknown>> {
+    onNodesChange: (changes: Array<NodeChange<Node<TNodeData>>>) => void;
+}
+export declare const useMoveDescendants: <TNodeData extends Record<string, unknown>>(params: UseMoveDescendantsParams<TNodeData>) => UseMoveDescendantsResult<TNodeData>;
+export {};

package/dist/advanced/MindMap/hooks/useMoveDescendants.js

@@ -0,0 +1,98 @@
+'use client';
+import { useCallback, useMemo } from 'react';
+const getDescendants = (sourceToTargets, rootId) => {
+    const visited = new Set([rootId]);
+    const result = new Set();
+    const queue = [rootId];
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        if (!currentId) {
+            continue;
+        }
+        const targets = sourceToTargets.get(currentId) ?? [];
+        for (const targetId of targets) {
+            if (visited.has(targetId)) {
+                continue;
+            }
+            visited.add(targetId);
+            result.add(targetId);
+            queue.push(targetId);
+        }
+    }
+    return result;
+};
+export const useMoveDescendants = (params) => {
+    const { enabled = true, nodes, edges, onNodesChange: onNodesChangeExternal } = params;
+    // 用 edge.source -> edge.target 作为父子关系（默认把 source 当作父节点）
+    const sourceToTargets = useMemo(() => {
+        const map = new Map();
+        edges.forEach(edge => {
+            const prev = map.get(edge.source) ?? [];
+            map.set(edge.source, [...prev, edge.target]);
+        });
+        return map;
+    }, [edges]);
+    const onNodesChange = useCallback((changes) => {
+        if (!onNodesChangeExternal) {
+            return;
+        }
+        if (!enabled || edges.length === 0) {
+            onNodesChangeExternal(changes);
+            return;
+        }
+        // 用旧节点位置计算拖拽的 dx/dy，再把位移叠加到后代节点
+        const nodeMap = new Map(nodes.map(node => [node.id, node]));
+        const changedIdSet = new Set(changes.filter(change => change.type === 'position').map(change => change.id));
+        const deltaMap = new Map();
+        changes.forEach(change => {
+            if (change.type !== 'position' || !change.position) {
+                return;
+            }
+            const prev = nodeMap.get(change.id);
+            if (!prev) {
+                return;
+            }
+            const dx = change.position.x - prev.position.x;
+            const dy = change.position.y - prev.position.y;
+            if (dx === 0 && dy === 0) {
+                return;
+            }
+            const dragging = change.dragging === true;
+            // 只影响“未被本次 change 显式更新”的节点，避免和多选拖拽冲突
+            const descendants = getDescendants(sourceToTargets, change.id);
+            descendants.forEach(descId => {
+                if (changedIdSet.has(descId)) {
+                    return;
+                }
+                const prevDelta = deltaMap.get(descId);
+                if (!prevDelta) {
+                    deltaMap.set(descId, { dx, dy, dragging });
+                    return;
+                }
+                deltaMap.set(descId, { dx: prevDelta.dx + dx, dy: prevDelta.dy + dy, dragging: prevDelta.dragging || dragging });
+            });
+        });
+        if (deltaMap.size === 0) {
+            onNodesChangeExternal(changes);
+            return;
+        }
+        const extraChanges = [];
+        deltaMap.forEach((delta, nodeId) => {
+            const node = nodeMap.get(nodeId);
+            if (!node) {
+                return;
+            }
+            extraChanges.push({
+                type: 'position',
+                id: nodeId,
+                position: {
+                    x: node.position.x + delta.dx,
+                    y: node.position.y + delta.dy,
+                },
+                dragging: delta.dragging,
+            });
+        });
+        onNodesChangeExternal([...changes, ...extraChanges]);
+    }, [edges.length, enabled, nodes, onNodesChangeExternal, sourceToTargets]);
+    return { onNodesChange };
+};

package/dist/advanced/MindMap/hooks/useUndoRedo.d.ts

@@ -0,0 +1,14 @@
+import type { Edge, EdgeChange, Node, NodeChange } from '@xyflow/react';
+interface UseUndoRedoParams<TNodeData extends Record<string, unknown>> {
+    enabled?: boolean;
+    nodes: Array<Node<TNodeData>>;
+    edges: Edge[];
+    onNodesChange?: (changes: Array<NodeChange<Node<TNodeData>>>) => void;
+    onEdgesChange?: (changes: Array<EdgeChange<Edge>>) => void;
+}
+interface UseUndoRedoResult<TNodeData extends Record<string, unknown>> {
+    onNodesChange: (changes: Array<NodeChange<Node<TNodeData>>>) => void;
+    onEdgesChange: (changes: Array<EdgeChange<Edge>>) => void;
+}
+export declare const useUndoRedo: <TNodeData extends Record<string, unknown>>(params: UseUndoRedoParams<TNodeData>) => UseUndoRedoResult<TNodeData>;
+export {};

package/dist/advanced/MindMap/hooks/useUndoRedo.js

@@ -0,0 +1,181 @@
+'use client';
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+const clone = (value) => {
+    const anyGlobal = globalThis;
+    if (typeof anyGlobal.structuredClone === 'function') {
+        return anyGlobal.structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value));
+};
+const isEditableTarget = (target) => {
+    const el = target;
+    if (!el) {
+        return false;
+    }
+    const tag = el.tagName?.toLowerCase();
+    if (tag === 'input' || tag === 'textarea') {
+        return true;
+    }
+    return el.isContentEditable;
+};
+const buildNodeChanges = (current, next) => {
+    const currentById = new Map(current.map(n => [n.id, n]));
+    const nextById = new Map(next.map(n => [n.id, n]));
+    const changes = [];
+    current.forEach(node => {
+        if (!nextById.has(node.id)) {
+            changes.push({ type: 'remove', id: node.id });
+        }
+    });
+    next.forEach(node => {
+        if (!currentById.has(node.id)) {
+            changes.push({ type: 'add', item: clone(node) });
+            return;
+        }
+        changes.push({ type: 'replace', id: node.id, item: clone(node) });
+    });
+    return changes;
+};
+const buildEdgeChanges = (current, next) => {
+    const currentById = new Map(current.map(e => [e.id, e]));
+    const nextById = new Map(next.map(e => [e.id, e]));
+    const changes = [];
+    current.forEach(edge => {
+        if (!nextById.has(edge.id)) {
+            changes.push({ type: 'remove', id: edge.id });
+        }
+    });
+    next.forEach(edge => {
+        if (!currentById.has(edge.id)) {
+            changes.push({ type: 'add', item: clone(edge) });
+            return;
+        }
+        changes.push({ type: 'replace', id: edge.id, item: clone(edge) });
+    });
+    return changes;
+};
+export const useUndoRedo = (params) => {
+    const { enabled = true, nodes, edges, onNodesChange, onEdgesChange } = params;
+    const snapshot = useMemo(() => {
+        return { nodes: clone(nodes), edges: clone(edges) };
+    }, [edges, nodes]);
+    const pastRef = useRef([]);
+    const futureRef = useRef([]);
+    const applyingRef = useRef(false);
+    const commitNextRef = useRef(false);
+    useEffect(() => {
+        if (!enabled) {
+            pastRef.current = [];
+            futureRef.current = [];
+            return;
+        }
+        if (pastRef.current.length === 0) {
+            pastRef.current = [snapshot];
+            futureRef.current = [];
+            return;
+        }
+        if (applyingRef.current) {
+            return;
+        }
+        if (!commitNextRef.current) {
+            return;
+        }
+        commitNextRef.current = false;
+        pastRef.current = [...pastRef.current, snapshot];
+        futureRef.current = [];
+    }, [enabled, snapshot]);
+    const applySnapshot = useCallback((next) => {
+        applyingRef.current = true;
+        commitNextRef.current = false;
+        const nodeChanges = onNodesChange ? buildNodeChanges(nodes, next.nodes) : [];
+        const edgeChanges = onEdgesChange ? buildEdgeChanges(edges, next.edges) : [];
+        if (nodeChanges.length > 0) {
+            onNodesChange?.(nodeChanges);
+        }
+        if (edgeChanges.length > 0) {
+            onEdgesChange?.(edgeChanges);
+        }
+        queueMicrotask(() => {
+            applyingRef.current = false;
+        });
+    }, [edges, nodes, onEdgesChange, onNodesChange]);
+    const undo = useCallback(() => {
+        const past = pastRef.current;
+        const current = past.at(-1);
+        const prev = past.at(-2);
+        if (!current || !prev) {
+            return;
+        }
+        pastRef.current = past.slice(0, -1);
+        futureRef.current = [current, ...futureRef.current];
+        applySnapshot(prev);
+    }, [applySnapshot]);
+    const redo = useCallback(() => {
+        const next = futureRef.current.at(0);
+        if (!next) {
+            return;
+        }
+        futureRef.current = futureRef.current.slice(1);
+        pastRef.current = [...pastRef.current, next];
+        applySnapshot(next);
+    }, [applySnapshot]);
+    const onNodesChangeWrapped = useCallback((changes) => {
+        onNodesChange?.(changes);
+        if (!enabled) {
+            return;
+        }
+        const shouldCommit = changes.some(change => {
+            if (change.type === 'position') {
+                return change.dragging !== true;
+            }
+            return change.type === 'add' || change.type === 'remove';
+        });
+        if (shouldCommit) {
+            commitNextRef.current = true;
+        }
+    }, [enabled, onNodesChange]);
+    const onEdgesChangeWrapped = useCallback((changes) => {
+        onEdgesChange?.(changes);
+        if (!enabled) {
+            return;
+        }
+        const shouldCommit = changes.some(change => {
+            return change.type === 'add' || change.type === 'remove';
+        });
+        if (shouldCommit) {
+            commitNextRef.current = true;
+        }
+    }, [enabled, onEdgesChange]);
+    useEffect(() => {
+        if (!enabled) {
+            return;
+        }
+        const onKeyDown = (event) => {
+            if (isEditableTarget(event.target)) {
+                return;
+            }
+            const isMac = /Mac|iPhone|iPad|iPod/.test(navigator.platform);
+            const mod = isMac ? event.metaKey : event.ctrlKey;
+            if (!mod) {
+                return;
+            }
+            if (event.key.toLowerCase() !== 'z') {
+                return;
+            }
+            event.preventDefault();
+            if (event.shiftKey) {
+                redo();
+                return;
+            }
+            undo();
+        };
+        document.addEventListener('keydown', onKeyDown);
+        return () => {
+            document.removeEventListener('keydown', onKeyDown);
+        };
+    }, [enabled, redo, undo]);
+    return {
+        onNodesChange: onNodesChangeWrapped,
+        onEdgesChange: onEdgesChangeWrapped,
+    };
+};

package/dist/advanced/MindMap/index.d.ts

@@ -0,0 +1,29 @@
+import type { ReactElement } from 'react';
+import { type Edge, type EdgeChange, type EdgeTypes, type Node, type NodeChange, type NodeTypes } from '@xyflow/react';
+import '@xyflow/react/dist/style.css';
+import { useExpandCollapse } from './hooks/useExpandCollapse';
+import { useMindMapDndState } from './context';
+export interface MindMapNodeData extends Record<string, unknown> {
+    label: string;
+}
+export { useMindMapDndState, useExpandCollapse };
+interface MindMapProps {
+    className?: string;
+    enableSnap?: boolean;
+    moveDescendants?: boolean;
+    enableDropToNode?: boolean;
+    enableCopyPaste?: boolean;
+    enableUndoRedo?: boolean;
+    dropHighlightClassName?: string;
+    canDropOnNode?: (params: {
+        draggingNode: Node<MindMapNodeData>;
+        targetNode: Node<MindMapNodeData>;
+    }) => boolean;
+    nodeTypes?: NodeTypes;
+    edgeTypes?: EdgeTypes;
+    nodes: Array<Node<MindMapNodeData>>;
+    edges?: Edge[];
+    onNodesChange?: (changes: Array<NodeChange<Node<MindMapNodeData>>>) => void;
+    onEdgesChange?: (changes: Array<EdgeChange<Edge>>) => void;
+}
+export declare const MindMap: (props: MindMapProps) => ReactElement;

package/dist/advanced/MindMap/index.js

@@ -0,0 +1,52 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ReactFlow } from '@xyflow/react';
+import '@xyflow/react/dist/style.css';
+import { useAlignmentSnap } from './hooks/useAlignmentSnap';
+import { useMoveDescendants } from './hooks/useMoveDescendants';
+import { useDropToReparent } from './hooks/useDropToReparent';
+import { useCopyPaste } from './hooks/useCopyPaste';
+import { useUndoRedo } from './hooks/useUndoRedo';
+import { useExpandCollapse } from './hooks/useExpandCollapse';
+import { MindMapDndProvider, useMindMapDndState } from './context';
+export { useMindMapDndState, useExpandCollapse };
+export const MindMap = (props) => {
+    const { nodes, edges = [], onNodesChange, onEdgesChange, enableSnap = false, moveDescendants = true, enableDropToNode = true, enableCopyPaste = true, enableUndoRedo = true, dropHighlightClassName, canDropOnNode, nodeTypes, edgeTypes, className = 'w-full h-full', } = props;
+    // 先把“联动后代移动”合并进节点变更回调，后续其它能力（如吸附）再基于它叠加
+    const { onNodesChange: onNodesChangeWithDescendants } = useMoveDescendants({
+        enabled: moveDescendants,
+        nodes,
+        edges,
+        onNodesChange,
+    });
+    // 在节点变更回调上叠加对齐线与吸附逻辑，并由 hook 直接给出对齐线元素
+    const { helperLines, onMove, onNodesChange: onNodesChangeWithSnap } = useAlignmentSnap({
+        enabled: enableSnap,
+        nodes,
+        onNodesChange: onNodesChangeWithDescendants,
+    });
+    const { onNodesChange: onNodesChangeWithUndoRedo, onEdgesChange: onEdgesChangeWithUndoRedo } = useUndoRedo({
+        enabled: enableUndoRedo,
+        nodes,
+        edges,
+        onNodesChange: onNodesChangeWithSnap,
+        onEdgesChange,
+    });
+    const { onNodeDrag, onNodeDragStop, draggingNodeId, dropTargetNodeId } = useDropToReparent({
+        enabled: enableDropToNode,
+        nodes,
+        edges,
+        dropHighlightClassName,
+        canDropOnNode,
+        onNodesChange: onNodesChangeWithUndoRedo,
+        onEdgesChange: onEdgesChangeWithUndoRedo,
+    });
+    useCopyPaste({
+        enabled: enableCopyPaste,
+        nodes,
+        edges,
+        onNodesChange: onNodesChangeWithUndoRedo,
+        onEdgesChange: onEdgesChangeWithUndoRedo,
+    });
+    return (_jsx(MindMapDndProvider, { value: { draggingNodeId, dropTargetNodeId }, children: _jsxs("div", { className: `relative ${className}`, children: [_jsx(ReactFlow, { fitView: true, nodes: nodes, edges: edges, nodeTypes: nodeTypes, edgeTypes: edgeTypes, onNodesChange: onNodesChangeWithUndoRedo, onEdgesChange: onEdgesChangeWithUndoRedo, onMove: enableSnap ? onMove : undefined, onNodeDrag: onNodeDrag, onNodeDragStop: onNodeDragStop }), helperLines] }) }));
+};

package/dist/advanced/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Crud';
+export * from './Crud/components';
+export * from './MindMap';
+export * from './Com2Canvas';
+export { default as ReactEchart } from 'echarts-for-react';

package/dist/advanced/index.js

@@ -0,0 +1,5 @@
+export * from './Crud';
+export * from './Crud/components';
+export * from './MindMap';
+export * from './Com2Canvas';
+export { default as ReactEchart } from 'echarts-for-react';

package/dist/antd/index.d.ts

@@ -0,0 +1,6 @@
+export * from 'antd';
+export { default as zh_CN } from 'antd/locale/zh_CN';
+export { AntdRegistry } from '@ant-design/nextjs-registry';
+export * from '@ant-design/icons';
+export { PageLoading, PageHeader, ProCard, ProList, ProTable, ProDescriptions, ProForm, ProFormList, ProFormText, ProFormCaptcha, ProFormCheckbox, ProFormSelect, ProFormUploadButton, LoginForm, BetaSchemaForm, StepsForm, CheckCard, EditableProTable, DragSortTable, ProProvider, } from '@ant-design/pro-components';
+export type { ProTableProps, ProFormProps, ProColumns, ProLayoutProps, ProFormInstance, ActionType, ProFormColumnsType, } from '@ant-design/pro-components';

package/dist/antd/index.js

@@ -0,0 +1,5 @@
+export * from 'antd';
+export { default as zh_CN } from 'antd/locale/zh_CN';
+export { AntdRegistry } from '@ant-design/nextjs-registry';
+export * from '@ant-design/icons';
+export { PageLoading, PageHeader, ProCard, ProList, ProTable, ProDescriptions, ProForm, ProFormList, ProFormText, ProFormCaptcha, ProFormCheckbox, ProFormSelect, ProFormUploadButton, LoginForm, BetaSchemaForm, StepsForm, CheckCard, EditableProTable, DragSortTable, ProProvider, } from '@ant-design/pro-components';

package/dist/buttons/ButtonGroup/index.d.ts

@@ -0,0 +1,8 @@
+import { ConfirmButtonProps } from '../ConfirmButton';
+export interface ButtonGroupProps {
+    list?: (ConfirmButtonProps & {
+        visible?: boolean;
+        title?: string;
+    })[];
+}
+export declare const ButtonGroup: (props: ButtonGroupProps) => import("react/jsx-runtime").JSX.Element;

package/dist/buttons/ButtonGroup/index.js

@@ -0,0 +1,13 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment } from 'react';
+import { Space } from 'antd';
+import { ConfirmButton } from '../ConfirmButton';
+// 1. 按钮组
+export const ButtonGroup = (props) => {
+    const { list = [] } = props;
+    if (!list?.length) {
+        return null;
+    }
+    return (_jsx(Space.Compact, { children: list.filter(item => item.visible).map((item, index) => (_jsx(Fragment, { children: _jsx(ConfirmButton, { ...item, children: item.title }) }, index))) }));
+};

package/dist/buttons/ConfirmButton/index.d.ts

@@ -0,0 +1,5 @@
+import { PopconfirmProps, ButtonProps } from 'antd';
+export interface ConfirmButtonProps extends PopconfirmProps {
+    btnProps?: ButtonProps;
+}
+export declare const ConfirmButton: (props: ConfirmButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/buttons/ConfirmButton/index.js

@@ -0,0 +1,9 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { _ } from '@wzyjs/utils/web';
+import { Button, Popconfirm } from 'antd';
+// 1. 给按钮增加了确认功能
+export const ConfirmButton = (props) => {
+    const { children, btnProps } = props;
+    return (_jsx(Popconfirm, { okText: '\u662F', cancelText: '\u5426', ..._.omit(props, ['children', 'btnProps']), children: _jsx(Button, { type: 'link', ...btnProps, children: children }) }));
+};

package/dist/buttons/CopyButton/index.d.ts

@@ -0,0 +1,6 @@
+import { ButtonProps } from 'antd';
+export interface CopyButtonProps extends ButtonProps {
+    value?: string;
+    canPaste?: boolean;
+}
+export declare const CopyButton: (props: CopyButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/buttons/CopyButton/index.js

@@ -0,0 +1,26 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { App, Button } from 'antd';
+import { CheckOutlined } from '@ant-design/icons';
+import { copy, readClipboard } from '@wzyjs/utils/web';
+import { useControllableValue } from '@wzyjs/hooks/web';
+export const CopyButton = (props) => {
+    const [icon, setIcon] = useState(null);
+    const { message } = App.useApp();
+    const [value, setValue] = useControllableValue(props, {
+        defaultValue: props.value,
+    });
+    const onContextMenu = async () => {
+        setValue(await readClipboard());
+    };
+    return (_jsx(Button, { ...props, icon: icon, onContextMenu: props.canPaste ? onContextMenu : undefined, children: props.children || value || '记录', onClick: (ev) => {
+            props.onClick?.(ev);
+            copy(value);
+            message.success('复制成功');
+            setIcon(_jsx(CheckOutlined, {}));
+            setTimeout(() => {
+                setIcon(null);
+            }, 1000);
+        } }));
+};

package/dist/buttons/DrawerButton/index.d.ts

@@ -0,0 +1,6 @@
+import { DrawerProps as AntdDrawerProps, ButtonProps } from 'antd';
+export interface DrawerButtonProps extends AntdDrawerProps {
+    btnProps?: ButtonProps;
+    defaultOpen?: boolean;
+}
+export declare const DrawerButton: (props: DrawerButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/buttons/DrawerButton/index.js

@@ -0,0 +1,13 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { _ } from '@wzyjs/utils/web';
+import { Button, Drawer as AntdDrawer } from 'antd';
+export const DrawerButton = (props) => {
+    const { children, defaultOpen, btnProps } = props;
+    const [open, setOpen] = useState(defaultOpen ?? false);
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { type: 'link', ...btnProps, onClick: ev => {
+                    btnProps?.onClick?.(ev);
+                    setOpen(true);
+                } }), _jsx(AntdDrawer, { title: btnProps?.children, open: open, onClose: () => setOpen(false), destroyOnHidden: true, ..._.omit(props, ['children', 'btnProps']), children: children })] }));
+};