listpage-next 0.0.169 → 0.0.171

package/dist/features/ChatClient/ui/ConversationList/index.js

@@ -0,0 +1,85 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Avatar, Button, Dropdown, Typography } from "antd";
+import { ListContainer, ListItemContainer, ListText } from "./styles.js";
+import { MessageOutlined, MoreOutlined } from "@ant-design/icons";
+import { InfiniteList } from "../../../../components/InfiniteList/index.js";
+const ConversationList = (props)=>{
+    const { ref, rowKey, request, menus = [], defaultActiveKey, onSelectConversation, onDeleteConversation, onRenameConversation } = props;
+    const [activeKey, setActiveKey] = useState(defaultActiveKey);
+    return /*#__PURE__*/ jsx(ListContainer, {
+        children: /*#__PURE__*/ jsx(InfiniteList, {
+            pageSize: 10,
+            rowKey: rowKey,
+            ref: ref,
+            request: request,
+            renderItem: (item, index, actions)=>{
+                const key = item[rowKey];
+                const items = [
+                    ...menus.map((menu)=>({
+                            ...menu,
+                            onClick: ()=>menu.onClick?.(item, index, actions)
+                        })),
+                    onRenameConversation && {
+                        key: 'rename',
+                        label: '重命名',
+                        onClick: async ()=>{
+                            const newItem = await onRenameConversation?.(item);
+                            if (!newItem) return;
+                            actions.updateItem(key, newItem);
+                        }
+                    },
+                    onDeleteConversation && {
+                        key: 'delete',
+                        danger: true,
+                        label: '删除',
+                        onClick: async ()=>{
+                            await onDeleteConversation?.(item);
+                            setActiveKey('');
+                            actions.deleteItem(key);
+                        }
+                    }
+                ].filter(Boolean);
+                return /*#__PURE__*/ jsxs(ListItemContainer, {
+                    isHover: activeKey === key ? true : void 0,
+                    onClick: ()=>{
+                        if (activeKey === key) return;
+                        setActiveKey?.(key);
+                        onSelectConversation?.(item);
+                    },
+                    children: [
+                        /*#__PURE__*/ jsx(Avatar, {
+                            size: 20,
+                            icon: item.icon || /*#__PURE__*/ jsx(MessageOutlined, {})
+                        }),
+                        /*#__PURE__*/ jsx(ListText, {
+                            children: /*#__PURE__*/ jsx(Typography.Text, {
+                                ellipsis: {
+                                    tooltip: {
+                                        title: item.title,
+                                        placement: 'right'
+                                    }
+                                },
+                                children: item.title
+                            })
+                        }),
+                        /*#__PURE__*/ jsx("div", {
+                            onClick: (e)=>e.stopPropagation(),
+                            children: /*#__PURE__*/ jsx(Dropdown, {
+                                menu: {
+                                    items
+                                },
+                                children: /*#__PURE__*/ jsx(Button, {
+                                    type: "text",
+                                    size: "small",
+                                    icon: /*#__PURE__*/ jsx(MoreOutlined, {})
+                                })
+                            })
+                        })
+                    ]
+                });
+            }
+        })
+    });
+};
+export { ConversationList };

package/dist/features/ChatClient/ui/ConversationList/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const ListContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const ListItemContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    isHover?: boolean;
+}>> & string;
+export declare const ListText: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/features/ChatClient/ui/ConversationList/styles.js

@@ -0,0 +1,30 @@
+import styled_components from "styled-components";
+const ListContainer = styled_components.div`
+  flex: 1;
+  overflow: hidden;
+  padding: 0 2px;
+`;
+const ListItemContainer = styled_components.div`
+  display: flex;
+  align-items: center;
+  padding: 8px 4px;
+  border-radius: 8px;
+  cursor: pointer;
+  gap: 4px;
+
+  background-color: ${(props)=>props.isHover ? '#0000000a' : 'transparent'};
+
+  &:hover {
+    background-color: #0000000a;
+  }
+`;
+const ListText = styled_components.div`
+  flex: 1;
+
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  word-break: break-all;
+  word-wrap: break-word;
+`;
+export { ListContainer, ListItemContainer, ListText };

package/dist/features/ChatClient/ui/index.d.ts

@@ -2,3 +2,4 @@ export * from './Bubble';
 export * from './ChatSplitter';
 export * from './ChatDialog';
 export * from './EditorContent';
+export * from './ConversationList';

package/dist/features/ChatClient/ui/index.js

@@ -2,3 +2,4 @@ export * from "./Bubble/index.js";
 export * from "./ChatSplitter/index.js";
 export * from "./ChatDialog/index.js";
 export * from "./EditorContent/index.js";
+export * from "./ConversationList/index.js";

package/dist/features/ListPage/components/DataTable/index.d.ts

@@ -0,0 +1,4 @@
+import { DataTableProps } from './types';
+export declare const DataTable: (<FilterValue = any, RecordValue extends Record<string, any> = any>(props: DataTableProps<FilterValue, RecordValue>) => import("react/jsx-runtime").JSX.Element) & {
+    displayName: string;
+};

package/dist/{components/Page/components/ListPage/DataTable.js → features/ListPage/components/DataTable/index.js}

@@ -1,13 +1,13 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Card, Table } from "antd";
 import { observer } from "mobx-react-lite";
-import { useListPageStore } from "../../context/listpage.js";
-import { TableContainer } from "../../../DataTable/index.js";
+import { useListPageStore } from "../../context/index.js";
 import { usePagination } from "../../hooks/usePagination.js";
 import { useColumns } from "../../hooks/useColumns.js";
 import { useSelectionTools } from "../../hooks/useSelectionTools.js";
+import { TableContainer } from "../../styles.js";
 const DataTable = observer((props)=>{
-    const { title, extra, columns, rowTitleKey, rowSelectionType, tableProps } = props;
+    const { title, extra, columns = [], rowTitleKey, rowSelectionType, tableProps } = props;
     const store = useListPageStore();
     const paginationEle = usePagination(tableProps?.pagination);
     const newColumns = useColumns(columns);

package/dist/features/ListPage/components/DataTable/renders/index.d.ts

@@ -0,0 +1,7 @@
+export declare const renders: {
+    link: import("../types").ColumnRender<"link">;
+    text: import("../types").ColumnRender<"text">;
+    tag: import("../types").ColumnRender<"tag">;
+    switch: import("../types").ColumnRender<"switch">;
+    time: import("../types").ColumnRender<"time">;
+};

package/dist/features/ListPage/components/DataTable/renders/index.js

@@ -0,0 +1,13 @@
+import { linkRender } from "./link.js";
+import { switchRender } from "./switch.js";
+import { tagRender } from "./tag.js";
+import { textRender } from "./text.js";
+import { timeRender } from "./time.js";
+const renders = {
+    link: linkRender,
+    text: textRender,
+    tag: tagRender,
+    switch: switchRender,
+    time: timeRender
+};
+export { renders };

package/dist/features/ListPage/components/DataTable/renders/link.d.ts

@@ -0,0 +1,2 @@
+import { ColumnRender } from '../types';
+export declare const linkRender: ColumnRender<'link'>;

package/dist/features/ListPage/components/DataTable/renders/link.js

@@ -0,0 +1,27 @@
+import { jsx } from "react/jsx-runtime";
+import { styled } from "styled-components";
+const LinkStyle = styled.a`
+  color: #1677ff;
+  &:hover {
+    color: #69b1ff;
+  }
+  outline: 0;
+  text-decoration: none;
+  transition: color 0.3s;
+  background-color: transparent;
+  cursor: pointer;
+`;
+const getPropName = (propName, record)=>{
+    if ('function' == typeof propName) return propName(record);
+    return record[propName];
+};
+const linkRender = (value, record, index, props)=>{
+    const title = getPropName(props?.titlePropName || 'title', record);
+    const href = getPropName(props?.hrefPropName || 'href', record);
+    return /*#__PURE__*/ jsx(LinkStyle, {
+        href: href,
+        target: props?.target,
+        children: title
+    });
+};
+export { linkRender };

package/dist/features/ListPage/components/DataTable/renders/switch.d.ts

@@ -0,0 +1,2 @@
+import { ColumnRender } from '../types';
+export declare const switchRender: ColumnRender<'switch'>;

package/dist/features/ListPage/components/DataTable/renders/switch.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { AsyncSwitch } from "../../../../../components/AsyncSwitch/index.js";
+const switchRender = (value, record, index, props)=>/*#__PURE__*/ jsx(AsyncSwitch, {
+        defaultValue: value,
+        ...props,
+        syncChange: async (checked)=>{
+            await props?.syncChange?.(checked, record);
+        }
+    });
+export { switchRender };

package/dist/features/ListPage/components/DataTable/renders/tag.d.ts

@@ -0,0 +1,2 @@
+import { ColumnRender } from '../types';
+export declare const tagRender: ColumnRender<'tag'>;

package/dist/features/ListPage/components/DataTable/renders/tag.js

@@ -0,0 +1,7 @@
+import { jsx } from "react/jsx-runtime";
+import { Tag } from "antd";
+const tagRender = (value, record, index, props)=>/*#__PURE__*/ jsx(Tag, {
+        ...props,
+        children: value
+    });
+export { tagRender };

package/dist/features/ListPage/components/DataTable/renders/text.d.ts

@@ -0,0 +1,2 @@
+import { ColumnRender } from '../types';
+export declare const textRender: ColumnRender<'text'>;

package/dist/features/ListPage/components/DataTable/renders/text.js

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { Typography } from "antd";
+const textRender = (value, record, index, props)=>/*#__PURE__*/ jsx(Typography.Text, {
+        ellipsis: {
+            tooltip: true
+        },
+        ...props,
+        children: value
+    });
+export { textRender };

package/dist/features/ListPage/components/DataTable/renders/time.d.ts

@@ -0,0 +1,2 @@
+import { ColumnRender } from '../types';
+export declare const timeRender: ColumnRender<'time'>;

package/dist/features/ListPage/components/DataTable/renders/time.js

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import dayjs from "dayjs";
+const timeRender = (value, record, index, props)=>{
+    try {
+        const time = value ? dayjs(value).format(props?.format) : '-';
+        return /*#__PURE__*/ jsx("span", {
+            children: time
+        });
+    } catch  {
+        return /*#__PURE__*/ jsx("span", {
+            children: "-"
+        });
+    }
+};
+export { timeRender };

package/dist/features/ListPage/components/DataTable/types.d.ts

@@ -0,0 +1,34 @@
+import { TableProps, TagProps, TypographyProps } from 'antd';
+import { ColumnType } from 'antd/es/table';
+import { HTMLAttributeAnchorTarget, ReactNode } from 'react';
+import { ListPageStore } from '../../context';
+export type ComponentType = 'text' | 'time' | 'tag' | 'link' | 'switch';
+export type ComponentProps<RecordValue extends Record<string, any> = any> = {
+    text: TypographyProps['Text'];
+    time: {
+        format?: string;
+    };
+    tag: TagProps;
+    link: {
+        titlePropName?: string | ((record: RecordValue) => string);
+        hrefPropName?: string | ((record: RecordValue) => string);
+        target?: HTMLAttributeAnchorTarget;
+    };
+    switch: {
+        syncChange?: (value: boolean, record: RecordValue) => Promise<void>;
+    };
+};
+export type CustomColumnRender<RecordValue extends Record<string, any> = any, Context = any> = (value: RecordValue[keyof RecordValue], record: RecordValue, index: number, ctx: Context) => ReactNode;
+export interface ListPageTableColumn<FilterValue = any, RecordValue extends Record<string, any> = any> extends ColumnType<RecordValue> {
+    component?: ComponentType | CustomColumnRender<RecordValue, ListPageStore<FilterValue, RecordValue>>;
+    props?: this['component'] extends ComponentType ? ComponentProps<RecordValue>[this['component']] : unknown;
+}
+export interface DataTableProps<FilterValue = any, RecordValue extends Record<string, any> = any> {
+    title?: ReactNode;
+    extra?: React.ReactNode | ((ctx: ListPageStore<FilterValue, RecordValue>) => React.ReactNode);
+    rowSelectionType?: 'checkbox' | 'radio';
+    rowTitleKey?: string;
+    columns?: ListPageTableColumn<FilterValue, RecordValue>[];
+    tableProps?: Omit<TableProps<RecordValue>, 'dataSource' | 'title' | 'columns'>;
+}
+export type ColumnRender<Type extends ComponentType, R extends Record<string, any> = any, K extends string = any> = (value: R[K], record: R, index: number, props: ComponentProps<R>[Type]) => ReactNode;

package/dist/features/ListPage/components/DataTable/utils/render.d.ts

@@ -0,0 +1,2 @@
+import { ComponentType } from '../types';
+export declare function createColumnRender<RecordValue extends Record<string, any> = any, FilterValue = any>(component?: ComponentType, props?: any): ((value: any, record: RecordValue, index: number) => import("react").ReactNode) | undefined;

package/dist/features/ListPage/components/DataTable/utils/render.js

@@ -0,0 +1,25 @@
+import { textRender } from "../renders/text.js";
+import { timeRender } from "../renders/time.js";
+import { tagRender } from "../renders/tag.js";
+import { linkRender } from "../renders/link.js";
+import { switchRender } from "../renders/switch.js";
+function createColumnRender(component, props) {
+    if (component) {
+        if ('text' === component) return function(value, record, index) {
+            return textRender(value, record, index, props);
+        };
+        if ('time' === component) return function(value, record, index) {
+            return timeRender(value, record, index, props);
+        };
+        if ('tag' === component) return function(value, record, index) {
+            return tagRender(value, record, index, props);
+        };
+        if ('link' === component) return function(value, record, index) {
+            return linkRender(value, record, index, props);
+        };
+        if ('switch' === component) return function(value, record, index) {
+            return switchRender(value, record, index, props);
+        };
+    }
+}
+export { createColumnRender };

package/dist/features/ListPage/components/ListPageContainer/index.d.ts

@@ -0,0 +1,17 @@
+import { ListPageFilterProps, ListPageFloatProps, ListPageHeaderProps, ListPageRequest, ListPageToolbarProps, StateValue } from '../../types';
+import { DataTableProps } from '../DataTable/types';
+export interface ListPageProps<FilterValue = any, RecordValue extends Record<string, any> = any> {
+    styles?: {
+        page?: React.CSSProperties;
+    };
+    request: ListPageRequest<FilterValue, RecordValue>;
+    storageKey?: string;
+    initialValues?: StateValue<FilterValue>;
+    state?: StateValue<FilterValue>;
+    header?: ListPageHeaderProps;
+    floats?: ListPageFloatProps[];
+    filter?: ListPageFilterProps<FilterValue>;
+    toolbar?: ListPageToolbarProps<FilterValue, RecordValue>;
+    table: DataTableProps<FilterValue, RecordValue>;
+}
+export declare const ListPage: (props: ListPageProps) => import("react/jsx-runtime").JSX.Element;

package/dist/{components/Page/components/ListPage/v2.js → features/ListPage/components/ListPageContainer/index.js}

@@ -1,31 +1,17 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { useImperativeHandle } from "react";
 import { observer } from "mobx-react-lite";
-import { useMount, useUpdateEffect } from "ahooks";
-import { toJS } from "mobx";
-import { ListPageProvider, useListPageStore } from "../../context/listpage.js";
-import { FilterSection, ListPageContainer, ToolbarSection } from "./styles.js";
-import { FilterForm } from "../../../FilterGroup/index.js";
+import { FilterForm } from "../../../../components/FilterGroup/index.js";
+import { ListPageProvider, useListPageStore } from "../../context/index.js";
 import { useFloat } from "../../hooks/useFloat.js";
-import { DataTable } from "./DataTable.js";
 import { useHeader } from "../../hooks/useHeader.js";
-const PureListPage = observer((props)=>{
-    const { header, filter, toolbar, table, styles, pageRef } = props;
+import { FilterSection, ListPageWrapper, ToolbarSection } from "../../styles.js";
+import { DataTable } from "../DataTable/index.js";
+const ListPageContainerComponent = observer((props)=>{
+    const { styles, header, filter, toolbar, table } = props;
     const store = useListPageStore();
-    const floatEle = useFloat();
     const headerEle = useHeader(header);
-    useMount(()=>{
-        store.refreshTable();
-    });
-    useUpdateEffect(()=>{
-        filter?.onChange?.(toJS(store.filters));
-    }, [
-        store.filters
-    ]);
-    useImperativeHandle(pageRef, ()=>store, [
-        store
-    ]);
-    return /*#__PURE__*/ jsxs(ListPageContainer, {
+    const floatEle = useFloat();
+    return /*#__PURE__*/ jsxs(ListPageWrapper, {
         style: styles?.page,
         children: [
             headerEle,
@@ -54,8 +40,8 @@ const ListPage = (props)=>/*#__PURE__*/ jsx(ListPageProvider, {
         floats: props.floats,
         initialValues: props.initialValues,
         state: props.state,
-        children: /*#__PURE__*/ jsx(PureListPage, {
+        children: /*#__PURE__*/ jsx(ListPageContainerComponent, {
             ...props
         })
     });
-export { ListPage, PureListPage };
+export { ListPage };

package/dist/features/ListPage/context/context.d.ts

@@ -0,0 +1,4 @@
+import { ListPageStore } from './store';
+import { ListPageProviderProps } from './types';
+export declare const ListPageProvider: (props: ListPageProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare function useListPageStore<FilterValue = any, RecordValue extends Record<string, any> = any>(): ListPageStore<FilterValue, RecordValue>;

package/dist/features/ListPage/context/context.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from "react";
+import { ListPageStore } from "./store.js";
+const ListPageContext = /*#__PURE__*/ createContext({});
+const ListPageProvider = (props)=>{
+    const { state, request, children, initialValues, storageKey, floats } = props;
+    const store = useMemo(()=>new ListPageStore({
+            state,
+            initialValues,
+            request,
+            floats,
+            storageKey
+        }), []);
+    return /*#__PURE__*/ jsx(ListPageContext.Provider, {
+        value: store,
+        children: children
+    });
+};
+function useListPageStore() {
+    return useContext(ListPageContext);
+}
+export { ListPageProvider, useListPageStore };

package/dist/features/ListPage/context/index.d.ts

@@ -0,0 +1,2 @@
+export { ListPageProvider, useListPageStore } from './context';
+export { ListPageStore } from './store';

package/dist/features/ListPage/context/index.js

@@ -0,0 +1,3 @@
+import { ListPageProvider, useListPageStore } from "./context.js";
+import { ListPageStore } from "./store.js";
+export { ListPageProvider, ListPageStore, useListPageStore };

package/dist/features/ListPage/context/store.d.ts

@@ -0,0 +1,37 @@
+import { Key } from 'react';
+import { ListPageFloatProps, ListPageRequest } from '../types';
+import { ListPageStorageOption } from './types';
+export declare class ListPageStore<FilterValue = any, RecordValue extends Record<string, any> = any> {
+    storageKey?: string;
+    filters: FilterValue;
+    tableDataRequest: ListPageRequest<FilterValue, RecordValue>;
+    floats: ListPageFloatProps[];
+    visibleFloat?: {
+        key: string;
+        record: RecordValue;
+        onCloseCallback?: true | (() => void);
+    };
+    loadingData: boolean;
+    dataSource: RecordValue[];
+    pagination: {
+        current: number;
+        pageSize: number;
+        total: number;
+    };
+    selection: {
+        selectedRowKeys: Key[];
+        selectedRows: RecordValue[];
+    };
+    listeners: Record<string, Function>;
+    constructor(options: ListPageStorageOption<FilterValue, RecordValue>);
+    submitFiltersChange(value?: FilterValue): void;
+    showFloat(key: string, record: any, onCloseCallback?: true | (() => void)): void;
+    hideFloat(): void;
+    updatePage(page: number, pageSize: number): void;
+    fetchTableData(): Promise<void>;
+    onSelectChange: (selectedRowKeys: Key[], selectedRows: RecordValue[]) => void;
+    clearSelection(): void;
+    refreshTable(): void;
+    listen(name: string, callback: (data: any) => void): void;
+    emit(name: string, data: any): void;
+}

package/dist/{components/Page/context/listpage.js → features/ListPage/context/store.js}

@@ -1,6 +1,5 @@
-import { jsx } from "react/jsx-runtime";
 import { makeAutoObservable, runInAction } from "mobx";
-import { createContext, useContext, useMemo } from "react";
+import { getDefaultValue, setDefaultValue } from "../utils/index.js";
 class ListPageStore {
     storageKey;
     filters = {};
@@ -96,43 +95,4 @@ class ListPageStore {
         this.listeners[name]?.(data);
     }
 }
-const ListPageContext = /*#__PURE__*/ createContext({});
-const ListPageProvider = ({ children, initialValues, state, request, storageKey, floats = [] })=>{
-    const store = useMemo(()=>new ListPageStore({
-            state,
-            initialValues,
-            request,
-            floats,
-            storageKey
-        }), []);
-    return /*#__PURE__*/ jsx(ListPageContext.Provider, {
-        value: store,
-        children: children
-    });
-};
-function useListPageStore() {
-    return useContext(ListPageContext);
-}
-const getDefaultValue = (STORAGE_KEY)=>{
-    if (!STORAGE_KEY) return {
-        currentPage: 1,
-        pageSize: 10,
-        filterValues: void 0
-    };
-    const storageValue = localStorage.getItem(STORAGE_KEY);
-    const value = JSON.parse(storageValue ?? '{}');
-    return {
-        currentPage: value.currentPage || 1,
-        pageSize: value.pageSize || 10,
-        filterValues: value.filterValues || void 0
-    };
-};
-const setDefaultValue = (STORAGE_KEY, value)=>{
-    if (!STORAGE_KEY) return;
-    const defaultValue = getDefaultValue(STORAGE_KEY);
-    localStorage.setItem(STORAGE_KEY, JSON.stringify({
-        ...defaultValue,
-        ...value
-    }));
-};
-export { ListPageProvider, ListPageStore, useListPageStore };
+export { ListPageStore };

package/dist/features/ListPage/context/types.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import { ListPageFloatProps, ListPageRequest, StateValue } from '../types';
+export type ListPageStorageOption<FilterValue = any, RecordValue extends Record<string, any> = any> = {
+    storageKey?: string;
+    initialValues?: StateValue<FilterValue>;
+    state?: StateValue<FilterValue>;
+    request: ListPageRequest<FilterValue, RecordValue>;
+    floats?: ListPageFloatProps[];
+};
+export type ListPageProviderProps = ListPageStorageOption & {
+    children: ReactNode;
+};

package/dist/features/ListPage/hooks/useColumns.d.ts

@@ -0,0 +1,3 @@
+import { ColumnType } from 'antd/es/table';
+import { ListPageTableColumn } from '../components/DataTable/types';
+export declare function useColumns<FilterValue = any, RecordValue extends Record<string, any> = any>(columns: ListPageTableColumn<FilterValue, RecordValue>[]): ColumnType<RecordValue>[];

package/dist/features/ListPage/hooks/useColumns.js

@@ -0,0 +1,20 @@
+import { useListPageStore } from "../context/index.js";
+import { renders } from "../components/DataTable/renders/index.js";
+function useColumns(columns) {
+    const ctx = useListPageStore();
+    return columns.map((column)=>{
+        if (!column.render && column.component) column.render = createColumnRender(column.component, column.props, ctx);
+        return column;
+    });
+}
+function createColumnRender(component, props, ctx) {
+    if ('string' == typeof component) {
+        const render = renders[component];
+        if (render) return (value, record, index)=>render(value, record, index, props);
+    }
+    if ('function' == typeof component) return (value, record, index)=>{
+        const render = component;
+        return render(value, record, index, ctx);
+    };
+}
+export { useColumns };

package/dist/{components/Page → features/ListPage}/hooks/useFloat.js

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { useMemo } from "react";
-import { useListPageStore } from "../context/listpage.js";
+import { useListPageStore } from "../context/index.js";
 function useFloat() {
     const store = useListPageStore();
     const visibleFloat = store.visibleFloat;

package/dist/features/ListPage/hooks/useHeader.d.ts

@@ -0,0 +1,2 @@
+import { ListPageHeaderProps } from '../types';
+export declare function useHeader(props?: ListPageHeaderProps): false | import("react/jsx-runtime").JSX.Element;

package/dist/{components/Page → features/ListPage}/hooks/useHeader.js

@@ -1,6 +1,6 @@
 import { jsx, jsxs } from "react/jsx-runtime";
-import { HeaderSection, Title } from "../components/ListPage/styles.js";
-import { useListPageStore } from "../context/listpage.js";
+import { useListPageStore } from "../context/index.js";
+import { HeaderSection, Title } from "../styles.js";
 function useHeader(props) {
     const store = useListPageStore();
     if (!props) return false;

package/dist/{components/Page → features/ListPage}/hooks/usePagination.js

@@ -1,7 +1,7 @@
 import { jsx } from "react/jsx-runtime";
 import { Pagination } from "antd";
-import { useListPageStore } from "../context/listpage.js";
-import { PaginationContainer } from "../../DataTable/index.js";
+import { useListPageStore } from "../context/index.js";
+import { PaginationContainer } from "../styles.js";
 function usePagination(props) {
     const store = useListPageStore();
     const ele = false === props ? null : /*#__PURE__*/ jsx(PaginationContainer, {

package/dist/{components/Page → features/ListPage}/hooks/useSelectionTools.js

@@ -1,7 +1,7 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { Button, Tooltip } from "antd";
-import { useListPageStore } from "../context/listpage.js";
 import styled_components from "styled-components";
+import { useListPageStore } from "../context/index.js";
 function useSelectionTools(rowTitleKey) {
     const store = useListPageStore();
     const { selectedRowKeys, selectedRows } = store.selection;