@wzyjs/uis 0.3.28 → 0.3.30

package/dist/advanced/Crud/hooks/useListFilters.js

@@ -0,0 +1,159 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Space } from 'antd';
+import { QuickFilters } from '../components/QuickFilters';
+import { mergeQuery, stringifyQuery } from '../utils/query';
+const hasOwnValue = (value, key) => {
+    return Object.prototype.hasOwnProperty.call(value, key);
+};
+const loadCachedValues = (cacheKey) => {
+    if (!cacheKey || typeof window === 'undefined') {
+        return {};
+    }
+    try {
+        const raw = window.localStorage.getItem(cacheKey);
+        return raw ? JSON.parse(raw) : {};
+    }
+    catch {
+        return {};
+    }
+};
+const saveCachedValues = (cacheKey, values) => {
+    if (!cacheKey || typeof window === 'undefined') {
+        return;
+    }
+    try {
+        window.localStorage.setItem(cacheKey, JSON.stringify(values));
+    }
+    catch {
+        // localStorage can be unavailable in private browsing or restricted embeds.
+    }
+};
+export const useListFilters = ({ list }) => {
+    const listTabs = list?.tabs;
+    const quickFiltersConfig = list?.quickFilters;
+    const quickFilters = React.useMemo(() => quickFiltersConfig?.items || [], [quickFiltersConfig?.items]);
+    const cacheKey = quickFiltersConfig?.cacheKey;
+    const onChangeQueryRef = React.useRef(list?.onChangeQuery);
+    const tableQueryRef = React.useRef({});
+    const extraQueryRef = React.useRef({});
+    const lastExtraQueryKeyRef = React.useRef('');
+    React.useEffect(() => {
+        onChangeQueryRef.current = list?.onChangeQuery;
+    }, [list?.onChangeQuery]);
+    const [activeTabKey, setActiveTabKey] = React.useState(() => {
+        return listTabs?.activeKey ?? listTabs?.defaultActiveKey ?? listTabs?.items?.[0]?.key;
+    });
+    React.useEffect(() => {
+        if (listTabs?.activeKey !== undefined && listTabs.activeKey !== activeTabKey) {
+            setActiveTabKey(listTabs.activeKey);
+        }
+    }, [activeTabKey, listTabs?.activeKey]);
+    const [quickFilterValues, setQuickFilterValues] = React.useState(() => {
+        const cachedValues = loadCachedValues(cacheKey);
+        return quickFilters.reduce((prev, filter) => {
+            if (!hasOwnValue(prev, filter.key)) {
+                prev[filter.key] = filter.defaultValue;
+            }
+            if (hasOwnValue(filter, 'value')) {
+                prev[filter.key] = filter.value;
+            }
+            return prev;
+        }, { ...cachedValues });
+    });
+    React.useEffect(() => {
+        setQuickFilterValues(prev => {
+            let changed = false;
+            const next = { ...prev };
+            quickFilters.forEach((filter) => {
+                if (hasOwnValue(filter, 'value') && next[filter.key] !== filter.value) {
+                    next[filter.key] = filter.value;
+                    changed = true;
+                }
+            });
+            return changed ? next : prev;
+        });
+    }, [quickFilters]);
+    const buildExtraQuery = React.useCallback((tabKey, values = quickFilterValues) => {
+        const tabItem = listTabs?.items?.find(item => item.key === tabKey);
+        const tabQuery = typeof tabItem?.query === 'function'
+            ? tabItem.query(tabItem.key, tabItem)
+            : tabItem?.query;
+        const filterQueries = quickFilters.map((filter) => {
+            const value = values[filter.key];
+            if (filter.getQuery) {
+                return filter.getQuery(value, filter);
+            }
+            if (!filter.field || value === undefined || value === null || value === '') {
+                return undefined;
+            }
+            return {
+                where: {
+                    [filter.field]: { equals: value },
+                },
+            };
+        });
+        return mergeQuery(tabQuery, ...filterQueries);
+    }, [listTabs?.items, quickFilterValues, quickFilters]);
+    const emitQuery = React.useCallback((nextTableQuery, nextExtraQuery) => {
+        tableQueryRef.current = nextTableQuery;
+        extraQueryRef.current = nextExtraQuery;
+        onChangeQueryRef.current?.(mergeQuery(nextTableQuery, nextExtraQuery));
+    }, []);
+    const handleListQueryChange = React.useCallback((nextQuery) => {
+        emitQuery(nextQuery, extraQueryRef.current);
+    }, [emitQuery]);
+    const emitFilterQuery = React.useCallback((nextExtraQuery) => {
+        const nextTableQuery = {
+            ...tableQueryRef.current,
+            skip: 0,
+        };
+        lastExtraQueryKeyRef.current = stringifyQuery(nextExtraQuery);
+        emitQuery(nextTableQuery, nextExtraQuery);
+    }, [emitQuery]);
+    const extraQuery = React.useMemo(() => {
+        return buildExtraQuery(activeTabKey);
+    }, [activeTabKey, buildExtraQuery]);
+    React.useEffect(() => {
+        const extraQueryKey = stringifyQuery(extraQuery);
+        if (lastExtraQueryKeyRef.current === extraQueryKey) {
+            return;
+        }
+        emitFilterQuery(extraQuery);
+    }, [emitFilterQuery, extraQuery]);
+    const handleTabChange = React.useCallback((key) => {
+        setActiveTabKey(key);
+        listTabs?.onChange?.(key);
+        emitFilterQuery(buildExtraQuery(key));
+    }, [buildExtraQuery, emitFilterQuery, listTabs]);
+    const handleQuickFilterChange = React.useCallback((key, value) => {
+        const nextValues = {
+            ...quickFilterValues,
+            [key]: value,
+        };
+        const filter = quickFilters.find(filter => filter.key === key);
+        setQuickFilterValues(nextValues);
+        filter?.onChange?.(value);
+        saveCachedValues(cacheKey, nextValues);
+        emitFilterQuery(buildExtraQuery(activeTabKey, nextValues));
+    }, [activeTabKey, buildExtraQuery, cacheKey, emitFilterQuery, quickFilterValues, quickFilters]);
+    const preparedList = React.useMemo(() => {
+        const { tabs: _tabs, quickFilters: _quickFilters, onChangeQuery: _onChangeQuery, toolbar, ...restList } = list || {};
+        const quickFilterNode = (_jsx(QuickFilters, { filters: quickFilters, values: quickFilterValues, onChange: handleQuickFilterChange }));
+        const toolbarFilter = toolbar?.filter;
+        const filterNode = quickFilters.length > 0 || toolbarFilter ? (_jsxs(Space, { wrap: true, children: [quickFilters.length > 0 ? quickFilterNode : null, toolbarFilter] })) : undefined;
+        return {
+            ...restList,
+            onChangeQuery: handleListQueryChange,
+            toolbar: {
+                ...toolbar,
+                ...(filterNode ? { filter: filterNode } : {}),
+            },
+        };
+    }, [handleListQueryChange, handleQuickFilterChange, list, quickFilterValues, quickFilters]);
+    return {
+        activeTabKey,
+        handleTabChange,
+        preparedList,
+    };
+};

package/dist/advanced/Crud/hooks/useOrderable.d.ts

@@ -0,0 +1,15 @@
+import type { CrudProps, ProColumnsPro } from '../types';
+export declare const useOrderable: <T extends Record<string, unknown>>(params: {
+    orderable: CrudProps["orderable"];
+    columns: ProColumnsPro<T>[];
+    crud: CrudProps["crud"];
+    update: CrudProps["update"];
+    readonly?: boolean;
+    cardMode?: boolean;
+}) => {
+    enabledFeature: boolean;
+    tableColumns: ProColumnsPro<T>[];
+    dragSortKey: string;
+    dataSource: T[];
+    onDragSortEnd: (_beforeIndex: number, _afterIndex: number, newDataSource: T[]) => Promise<void>;
+};

package/dist/advanced/Crud/hooks/useOrderable.js

@@ -0,0 +1,75 @@
+import { useEffect, useMemo, useState } from 'react';
+const dragSortKey = '__drag_sort__';
+const getOrderableConfig = (orderable) => {
+    if (orderable && typeof orderable === 'object') {
+        return orderable;
+    }
+    return {};
+};
+const sortByOrderField = (list, orderField) => {
+    const indexed = list.map((item, index) => ({ item, index }));
+    indexed.sort((a, b) => {
+        const av = a.item[orderField];
+        const bv = b.item[orderField];
+        const an = typeof av === 'number' && Number.isFinite(av) ? av : Number.POSITIVE_INFINITY;
+        const bn = typeof bv === 'number' && Number.isFinite(bv) ? bv : Number.POSITIVE_INFINITY;
+        return an - bn;
+    });
+    return indexed.map(i => i.item);
+};
+export const useOrderable = (params) => {
+    const { orderable, columns, crud, update, readonly, cardMode } = params;
+    const enabledFeature = !!orderable && !cardMode;
+    const config = useMemo(() => getOrderableConfig(orderable), [orderable]);
+    const orderField = config.orderField ?? 'sort';
+    const start = config.start ?? 0;
+    const canUpdate = enabledFeature && !readonly && update !== false && !!crud.updateState?.mutateAsync;
+    const [dataSource, setDataSource] = useState([]);
+    useEffect(() => {
+        if (!enabledFeature)
+            return;
+        const list = crud.listState.data || [];
+        setDataSource(sortByOrderField(list, orderField));
+    }, [enabledFeature, crud.listState.data, orderField]);
+    const tableColumns = useMemo(() => {
+        if (!enabledFeature)
+            return columns;
+        return [
+            {
+                title: '',
+                key: dragSortKey,
+                dataIndex: dragSortKey,
+                width: 48,
+                fixed: 'left',
+                hideInSearch: true,
+                hideInForm: true,
+                render: () => null,
+            },
+            ...columns,
+        ];
+    }, [columns, enabledFeature]);
+    const onDragSortEnd = async (_beforeIndex, _afterIndex, newDataSource) => {
+        const next = newDataSource.map((row, index) => ({
+            ...row,
+            [orderField]: start + index,
+        }));
+        setDataSource(next);
+        if (!canUpdate)
+            return;
+        await Promise.allSettled(next.map((row) => {
+            const id = row.id;
+            if (typeof id !== 'string' || !id) {
+                return Promise.resolve();
+            }
+            return crud.updateState.mutateAsync(id, { [orderField]: row[orderField] });
+        }));
+        await crud.listState.refetch();
+    };
+    return {
+        enabledFeature,
+        tableColumns,
+        dragSortKey: enabledFeature ? dragSortKey : undefined,
+        dataSource: enabledFeature ? dataSource : crud.listState.data,
+        onDragSortEnd: enabledFeature ? onDragSortEnd : undefined,
+    };
+};

package/dist/advanced/Crud/hooks/useRequest.d.ts

@@ -0,0 +1,13 @@
+import type { CrudProps, PaginationState } from '../types';
+interface UseRequest {
+    columns: CrudProps['columns'];
+    list: CrudProps['list'];
+}
+export declare const useRequest: ({ columns, list }: UseRequest) => {
+    request: (params: PaginationState, sort: any, filter: any) => Promise<{
+        data: any[];
+        total: number;
+        success: boolean;
+    }>;
+};
+export {};

package/dist/advanced/Crud/hooks/useRequest.js

@@ -0,0 +1,27 @@
+import { transformOrder, transformPagination, transformWhere } from '../utils';
+export const useRequest = ({ columns, list }) => {
+    const request = async (params, sort, filter) => {
+        const { current, pageSize, ...search } = params;
+        // 转换分页参数
+        const pagination = transformPagination({ current, pageSize });
+        // 转换排序参数
+        const orderBy = transformOrder(sort);
+        // 转换过滤参数
+        const where = transformWhere(search, columns);
+        const query = {
+            ...pagination,
+            ...(orderBy && { orderBy }),
+            ...(where && { where }),
+        };
+        console.log(666, 35, params, sort, search, filter, where, query);
+        list?.onChangeQuery?.(query);
+        return {
+            data: [],
+            total: 0,
+            success: true,
+        };
+    };
+    return {
+        request,
+    };
+};

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

@@ -0,0 +1,3 @@
+import type { CrudProps } from './types';
+export type { CrudListTabs, CrudQuickFilter, CrudQuickFilterRadio, CrudQuickFilters, ProColumnsPro } from './types';
+export declare const Crud: (props_: CrudProps) => import("react/jsx-runtime").JSX.Element;

package/dist/advanced/Crud/index.js

@@ -0,0 +1,46 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Space } from 'antd';
+import { DragSortTable, ProTable } from '@ant-design/pro-components';
+import { CardList, CreateUpdate, ListTabs, Provider } from './components';
+import { useColumns, useList, useListFilters, useOrderable, useRequest } from './hooks';
+export const Crud = (props_) => {
+    const props = { ...props_ };
+    if (props.readonly) {
+        props.create = props.create ?? false;
+        props.update = props.update ?? false;
+        props.remove = props.remove ?? false;
+    }
+    const { crud, columns, list, create, update, remove, orderable } = props;
+    const { activeTabKey, handleTabChange, preparedList } = useListFilters({ list });
+    const { tableColumns, dataSource, dragSortKey, onDragSortEnd } = useOrderable({
+        orderable,
+        columns,
+        crud,
+        update,
+        readonly: props.readonly,
+        cardMode: !!list?.cardConfig,
+    });
+    const { finalColumns } = useColumns({ columns: tableColumns, crud, update, remove });
+    const { finalList } = useList({ list: preparedList });
+    const { request } = useRequest({ list: finalList, columns });
+    const TableComponent = dragSortKey ? DragSortTable : ProTable;
+    return (_jsxs(Provider, { crud: crud, children: [list?.tabs && (_jsx(ListTabs, { tabs: list?.tabs, activeKey: activeTabKey, onChange: handleTabChange })), _jsx(TableComponent, { rowKey: 'id', loading: crud.listState.isLoading, columns: finalColumns, scroll: { x: 'max-content' }, search: {
+                    labelWidth: 'auto',
+                }, dataSource: dataSource, request: request, dragSortKey: dragSortKey, onDragSortEnd: onDragSortEnd, pagination: {
+                    total: crud.countState.data,
+                    showSizeChanger: true,
+                    showQuickJumper: true,
+                    defaultPageSize: 10,
+                    pageSizeOptions: ['10', '15', '20', '30', '50'],
+                    showTotal: (total, range) => `第 ${range[0]}-${range[1]} 条/总共 ${total} 条`,
+                }, toolBarRender: () => [
+                    create !== false ? (_jsx(CreateUpdate, { crud: crud, columns: tableColumns, config: create || {} }, 'create')) : null,
+                ].filter(Boolean), tableRender: list?.cardConfig ? (props, dom, domList) => (_jsxs(Space, { style: { width: '100%' }, children: [domList.toolbar, _jsx(CardList, { crud: crud, columns: columns, list: list, create: create, update: update, remove: remove })] })) : undefined, ...finalList, options: {
+                    ...finalList?.options,
+                    reload: () => {
+                        crud.countState.refetch();
+                        crud.listState.refetch();
+                    },
+                } })] }));
+};

package/dist/advanced/Crud/types/index.d.ts

@@ -0,0 +1,176 @@
+import type { ReactNode } from 'react';
+import type { ButtonProps } from 'antd';
+import type { ProTableProps, ProFormProps, ProColumns } from '@ant-design/pro-components';
+export type ProColumnsPro<T = any> = Omit<ProColumns<T>, 'valueType'> & {
+    valueType?: ProColumns<T>['valueType'] | 'tags' | 'enabled';
+};
+export interface PaginationState {
+    current: number;
+    pageSize: number;
+}
+export interface Crud {
+    listState: {
+        data?: any[];
+        isLoading?: boolean;
+        error?: any;
+        refetch: () => any;
+    };
+    countState: {
+        data?: any;
+        isLoading?: boolean;
+        error?: any;
+        refetch: () => any;
+    };
+    createState: {
+        mutate: (data: any) => void;
+        mutateAsync: (data: any) => Promise<any>;
+        isLoading?: boolean;
+        error?: any;
+    };
+    updateState: {
+        mutate: (id: string, data: any) => void;
+        mutateAsync: (id: string, data: any) => Promise<any>;
+        isLoading?: boolean;
+        error?: any;
+    };
+    removeState: {
+        mutate: (id: string) => void;
+        mutateAsync: (id: string) => Promise<any>;
+        isLoading?: boolean;
+        error?: any;
+    };
+    deleteState: {
+        mutate: (id: string) => void;
+        mutateAsync: (id: string) => Promise<any>;
+        isLoading?: boolean;
+        error?: any;
+    };
+}
+export type CardFieldValue = string | ReactNode;
+export interface CardItem {
+    title?: CardFieldValue;
+    extra?: CardFieldValue;
+    content?: CardFieldValue;
+    cover?: CardFieldValue;
+    actions?: CardFieldValue[];
+    meta?: {
+        title?: CardFieldValue;
+        description?: CardFieldValue;
+        avatar?: CardFieldValue;
+    };
+    props?: any;
+}
+export interface CardConfig {
+    gutter?: [number, number];
+    col?: {
+        xs?: number;
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+        xxl?: number;
+    };
+    height?: string;
+    render?: (record: any, index: number, defaultActions: ReactNode[]) => ReactNode;
+    card: CardItem | ((record: any, index: number) => CardItem);
+}
+type CrudQuery = Record<string, any>;
+export interface CrudListTabItem {
+    key: string;
+    label: ReactNode;
+    disabled?: boolean;
+    query?: CrudQuery | ((key: string, item: CrudListTabItem) => CrudQuery | undefined);
+}
+export interface CrudListTabs {
+    activeKey?: string;
+    defaultActiveKey?: string;
+    type?: 'line' | 'card' | 'editable-card';
+    items: CrudListTabItem[];
+    onChange?: (key: string) => void;
+}
+export interface CrudQuickFilterOption<V = any> {
+    label: string;
+    value: V;
+}
+export interface CrudQuickFilterRadio<V = any> {
+    type: 'radio';
+    key: string;
+    label?: ReactNode;
+    value?: V;
+    defaultValue?: V;
+    options: CrudQuickFilterOption<V>[] | string[];
+    buttonStyle?: 'outline' | 'solid';
+    field?: string;
+    onChange?: (value: V) => void;
+    getQuery?: (value: V, filter: CrudQuickFilterRadio<V>) => CrudQuery | undefined;
+}
+export type CrudQuickFilter = CrudQuickFilterRadio;
+export interface CrudQuickFilters {
+    cacheKey?: string;
+    items: CrudQuickFilter[];
+}
+export interface List extends Omit<ProTableProps<any, any>, 'columns' | 'dataSource' | 'loading'> {
+    onChangeQuery?: (query: any) => void;
+    cardConfig?: CardConfig;
+    tabs?: CrudListTabs;
+    quickFilters?: CrudQuickFilters;
+}
+export interface Create {
+    mode?: 'modal' | 'drawer';
+    buttonProps?: ButtonProps;
+    formProps?: ProFormProps;
+    transformData?: (values: Record<string, unknown>) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    coverData?: (record: any) => Record<string, unknown>;
+    title?: string;
+    width?: number | string;
+}
+export interface Update {
+    mode?: 'modal' | 'drawer';
+    buttonProps?: ButtonProps;
+    formProps?: ProFormProps;
+    transformData?: (values: Record<string, unknown>, record: any) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    coverData?: (record: any) => Record<string, unknown>;
+    title?: string;
+    width?: number | string;
+}
+export interface Remove {
+    confirm?: boolean;
+    buttonProps?: ButtonProps;
+    title?: string;
+    content?: string;
+}
+export interface Orderable {
+    orderField?: string;
+    start?: number;
+    label?: string;
+}
+export interface CrudProps {
+    crud: Crud;
+    columns: ProColumnsPro[];
+    list?: List;
+    create?: false | Create;
+    update?: false | Update;
+    remove?: false | Remove;
+    orderable?: boolean | Orderable;
+    readonly?: boolean;
+}
+export interface ListProps {
+    crud: Crud;
+    columns: ProColumnsPro[];
+    list: List;
+    create?: false | Create;
+    update?: false | Update;
+    remove?: false | Remove;
+}
+export interface RemoveProps {
+    crud: Crud;
+    config: Remove;
+    record: any;
+}
+export interface CreateUpdateProps {
+    crud: Crud;
+    columns: ProColumnsPro[];
+    config: Create | Update;
+    record?: any;
+}
+export {};

package/dist/advanced/Crud/types/index.js

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

package/dist/advanced/Crud/utils/index.d.ts

@@ -0,0 +1,7 @@
+import type { PaginationState, ProColumnsPro } from '../types';
+export declare const transformPagination: (pagination: PaginationState) => {
+    skip: number;
+    take: number;
+};
+export declare const transformOrder: (sort: Record<string, "ascend" | "descend">) => Record<string, "desc" | "asc">[];
+export declare const transformWhere: (filter: Record<string, (string | number)[] | null>, columns: ProColumnsPro[]) => Record<string, any>;

package/dist/advanced/Crud/utils/index.js

@@ -0,0 +1,80 @@
+export const transformPagination = (pagination) => {
+    return {
+        skip: (pagination.current - 1) * pagination.pageSize,
+        take: pagination.pageSize,
+    };
+};
+export const transformOrder = (sort) => {
+    const orderByFields = [];
+    Object.keys(sort).forEach((key) => {
+        if (sort[key]) {
+            orderByFields.push({
+                [key]: sort[key] === 'ascend' ? 'asc' : 'desc',
+            });
+        }
+    });
+    // 始终返回数组格式以支持多重排序
+    return orderByFields.length > 0 ? orderByFields : undefined;
+};
+export const transformWhere = (filter, columns) => {
+    const where = {};
+    Object.keys(filter).forEach((key) => {
+        const value = filter[key];
+        if (value !== null && value !== undefined) {
+            const column = columns.find(col => col.dataIndex === key);
+            // 根据字段类型转换过滤条件
+            if (column) {
+                switch (column.valueType) {
+                    case 'text':
+                    case 'textarea':
+                        // 文本类型使用 contains 搜索
+                        if (typeof value === 'string') {
+                            where[key] = { contains: value };
+                        }
+                        break;
+                    case 'select':
+                    case 'option':
+                        if (column?.fieldProps?.multiple) {
+                            where[key] = { in: value };
+                        }
+                        else {
+                            where[key] = { equals: value };
+                        }
+                        break;
+                    case 'dateRange':
+                    case 'dateTimeRange':
+                        // 日期范围搜索
+                        if (value.length >= 2) {
+                            where[key] = {
+                                gte: value[0],
+                                lte: value[1],
+                            };
+                        }
+                        break;
+                    case 'digit':
+                    case 'money':
+                        // 数字类型
+                        if (typeof value === 'number') {
+                            where[key] = { equals: value };
+                        }
+                        break;
+                    case 'switch':
+                        // 布尔类型
+                        if (typeof value === 'boolean') {
+                            where[key] = { equals: value };
+                        }
+                        break;
+                    case 'tags':
+                        where[key] = { equals: value };
+                        break;
+                    default:
+                        where[key] = { equals: value };
+                }
+            }
+            else {
+                where[key] = { equals: value };
+            }
+        }
+    });
+    return Object.keys(where).length > 0 ? where : undefined;
+};

package/dist/advanced/Crud/utils/query.d.ts

@@ -0,0 +1,3 @@
+export type Query = Record<string, any>;
+export declare const mergeQuery: (...queries: Array<Query | undefined>) => Query;
+export declare const stringifyQuery: (query: Query) => string;

package/dist/advanced/Crud/utils/query.js

@@ -0,0 +1,34 @@
+const isPlainObject = (value) => {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+};
+export const mergeQuery = (...queries) => {
+    const result = {};
+    queries.forEach((query) => {
+        if (!query) {
+            return;
+        }
+        Object.keys(query).forEach((key) => {
+            const value = query[key];
+            if (value === undefined) {
+                return;
+            }
+            if (key === 'where' && isPlainObject(value) && isPlainObject(result.where)) {
+                result.where = {
+                    ...result.where,
+                    ...value,
+                };
+                return;
+            }
+            result[key] = value;
+        });
+    });
+    return result;
+};
+export const stringifyQuery = (query) => {
+    try {
+        return JSON.stringify(query);
+    }
+    catch {
+        return String(Date.now());
+    }
+};

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

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+export interface MindMapDndState {
+    draggingNodeId: string | null;
+    dropTargetNodeId: string | null;
+}
+interface MindMapDndProviderProps {
+    value: MindMapDndState;
+    children: ReactNode;
+}
+export declare const MindMapDndProvider: (props: MindMapDndProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useMindMapDndState: () => MindMapDndState;
+export {};

package/dist/advanced/MindMap/context.js

@@ -0,0 +1,12 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const MindMapDndContext = createContext(null);
+export const MindMapDndProvider = (props) => {
+    const { value, children } = props;
+    return (_jsx(MindMapDndContext.Provider, { value: value, children: children }));
+};
+export const useMindMapDndState = () => {
+    const value = useContext(MindMapDndContext);
+    return value ?? { draggingNodeId: null, dropTargetNodeId: null };
+};