@strato-admin/core 0.1.0 → 0.3.0

package/dist/ra-core/src/dataProvider/withLifecycleCallbacks.js

@@ -0,0 +1,377 @@
+/**
+ * Extend a dataProvider to execute callbacks before and after read and write calls.
+ *
+ * @param {DataProvider} dataProvider The dataProvider to wrap
+ * @param {ResourceCallbacks[]} handlers An array of ResourceCallbacks
+ *
+ * @typedef {Object} ResourceCallbacks
+ * @property {string} resource The resource name
+ * @property {AfterCreate} [afterCreate] A callback (or array of callbacks) executed after create
+ * @property {AfterDelete} [afterDelete] A callback (or array of callbacks) executed after delete
+ * @property {AfterDeleteMany} [afterDeleteMany] A callback (or array of callbacks) executed after deleteMany
+ * @property {AfterGetList} [afterGetList] A callback (or array of callbacks) executed after getList
+ * @property {AfterGetMany} [afterGetMany] A callback (or array of callbacks) executed after getMany
+ * @property {AfterGetManyReference} [afterGetManyReference] A callback (or array of callbacks) executed after getManyReference
+ * @property {AfterGetOne} [afterGetOne] A callback (or array of callbacks) executed after getOne
+ * @property {AfterRead} [afterRead] A callback (or array of callbacks) executed after read (getList, getMany, getManyReference, getOne)
+ * @property {AfterSave} [afterSave] A callback (or array of callbacks) executed after save (create, update, updateMany)
+ * @property {AfterUpdate} [afterUpdate] A callback (or array of callbacks) executed after update
+ * @property {AfterUpdateMany} [afterUpdateMany] A callback (or array of callbacks) executed after updateMany
+ * @property {BeforeCreate} [beforeCreate] A callback (or array of callbacks) executed before create
+ * @property {BeforeDelete} [beforeDelete] A callback (or array of callbacks) executed before delete
+ * @property {BeforeDeleteMany} [beforeDeleteMany] A callback (or array of callbacks) executed before deleteMany
+ * @property {BeforeGetList} [beforeGetList] A callback (or array of callbacks) executed before getList
+ * @property {BeforeGetMany} [beforeGetMany] A callback (or array of callbacks) executed before getMany
+ * @property {BeforeGetManyReference} [beforeGetManyReference] A callback (or array of callbacks) executed before getManyReference
+ * @property {BeforeGetOne} [beforeGetOne] A callback (or array of callbacks) executed before getOne
+ * @property {BeforeSave} [beforeSave] A callback (or array of callbacks) executed before save (create, update, updateMany)
+ * @property {BeforeUpdate} [beforeUpdate] A callback (or array of callbacks) executed before update
+ * @property {BeforeUpdateMany} [beforeUpdateMany] A callback (or array of callbacks) executed before updateMany
+ *
+ * Warnings:
+ * - As queries issued in the callbacks are not done through react-query,
+ *   any change in the data will not be automatically reflected in the UI.
+ * - The callbacks are not executed in a transaction. In case of error,
+ *   the backend may be left in an inconsistent state.
+ * - When calling the API directly using fetch or another client,
+ *   the callbacks will not be executed, leaving the backend in a possibly inconsistent state.
+ * - If a callback triggers the query it's listening to, this will lead to a infinite loop.
+ *
+ * @example
+ *
+ * const dataProvider = withLifecycleCallbacks(
+ *   jsonServerProvider("http://localhost:3000"),
+ *   [
+ *     {
+ *       resource: "posts",
+ *       afterRead: async (data, dataProvider, resource) => {
+ *         // rename field to the record
+ *         data.user_id = data.userId;
+ *         return data;
+ *       },
+ *       // executed after create, update and updateMany
+ *       afterSave: async (record, dataProvider, resource) => {
+ *         // update the author's nb_posts
+ *         const { total } = await dataProvider.getList("users", {
+ *           filter: { id: record.user_id },
+ *           pagination: { page: 1, perPage: 1 },
+ *         });
+ *         await dataProvider.update("users", {
+ *           id: user.id,
+ *           data: { nb_posts: total },
+ *           previousData: user,
+ *         });
+ *         return record;
+ *       },
+ *       beforeDelete: async (params, dataProvider, resource) => {
+ *         // delete all comments linked to the post
+ *         const { data: comments } = await dataProvider.getManyReference(
+ *           "comments",
+ *           {
+ *             target: "post_id",
+ *             id: params.id,
+ *           }
+ *         );
+ *         if (comments.length > 0) {
+ *           await dataProvider.deleteMany("comments", {
+ *             ids: comments.map((comment) => comment.id),
+ *           });
+ *         }
+ *         // update the author's nb_posts
+ *         const { data: post } = await dataProvider.getOne("posts", {
+ *           id: params.id,
+ *         });
+ *         const { total } = await dataProvider.getList("users", {
+ *           filter: { id: post.user_id },
+ *           pagination: { page: 1, perPage: 1 },
+ *         });
+ *         await dataProvider.update("users", {
+ *           id: user.id,
+ *           data: { nb_posts: total - 1 },
+ *           previousData: user,
+ *         });
+ *         return params;
+ *       },
+ *     },
+ *   ]
+ * );
+ */
+export const withLifecycleCallbacks = (dataProvider, handlers) => {
+    return {
+        ...dataProvider,
+        getList: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeGetList',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.getList(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterGetList',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            result.data = await Promise.all(result.data.map(record => applyCallbacks({
+                name: 'afterRead',
+                params: record,
+                dataProvider,
+                handlers,
+                resource,
+            })));
+            return result;
+        },
+        getOne: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeGetOne',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.getOne(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterGetOne',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            result.data = await applyCallbacks({
+                name: 'afterRead',
+                params: result.data,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            return result;
+        },
+        getMany: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeGetMany',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.getMany(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterGetMany',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            result.data = await Promise.all(result.data.map(record => applyCallbacks({
+                name: 'afterRead',
+                params: record,
+                dataProvider,
+                handlers,
+                resource,
+            })));
+            return result;
+        },
+        getManyReference: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeGetManyReference',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.getManyReference(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterGetManyReference',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            result.data = await Promise.all(result.data.map(record => applyCallbacks({
+                name: 'afterRead',
+                params: record,
+                dataProvider,
+                handlers,
+                resource,
+            })));
+            return result;
+        },
+        update: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeUpdate',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            newParams.data = await applyCallbacks({
+                name: 'beforeSave',
+                params: newParams.data,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.update(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterUpdate',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            result.data = await applyCallbacks({
+                name: 'afterSave',
+                params: result.data,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            return result;
+        },
+        create: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeCreate',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            newParams.data = await applyCallbacks({
+                name: 'beforeSave',
+                params: newParams.data,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.create(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterCreate',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            result.data = await applyCallbacks({
+                name: 'afterSave',
+                params: result.data,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            return result;
+        },
+        delete: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeDelete',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.delete(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterDelete',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            return result;
+        },
+        updateMany: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeUpdateMany',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            newParams.data = await applyCallbacks({
+                name: 'beforeSave',
+                params: newParams.data,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.updateMany(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterUpdateMany',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            const afterSaveHandlers = handlers.filter(h => (h.resource === resource || h.resource === '*') &&
+                h.afterSave);
+            if (afterSaveHandlers.length > 0) {
+                const { data: records } = await dataProvider.getMany(resource, {
+                    //@ts-ignore
+                    ids: result.data,
+                });
+                await Promise.all(records.map(record => applyCallbacks({
+                    name: 'afterSave',
+                    params: record,
+                    dataProvider,
+                    handlers,
+                    resource,
+                })));
+            }
+            return result;
+        },
+        deleteMany: async function (resource, params) {
+            let newParams = params;
+            newParams = await applyCallbacks({
+                name: 'beforeDeleteMany',
+                params: newParams,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            let result = await dataProvider.deleteMany(resource, newParams);
+            result = await applyCallbacks({
+                name: 'afterDeleteMany',
+                params: result,
+                dataProvider,
+                handlers,
+                resource,
+            });
+            return result;
+        },
+    };
+};
+/**
+ * Apply callbacks to the params for the given resource and hook
+ * @param {DataProvider} dataProvider The dataProvider
+ * @param {ResourceCallbacks[]} handlers An array of ResourceCallbacks
+ * @param {string} resource The resource name
+ * @param {string} hook The hook name (beforeGetList, afterGetOne, etc.)
+ * @param {U} params The params / result to pass to the callbacks
+ * @returns {Promise<U>} The params / result after the callbacks have been applied
+ */
+export const applyCallbacks = async function ({ name, params, dataProvider, handlers, resource, }) {
+    let newParams = params;
+    const handlersToApply = handlers.filter(h => (h.resource === resource || h.resource === '*') && h[name]);
+    for (const handler of handlersToApply) {
+        const callbacksValue = handler[name];
+        if (Array.isArray(callbacksValue)) {
+            for (const callback of callbacksValue ?? []) {
+                newParams = await callback(newParams, dataProvider, resource);
+            }
+        }
+        else {
+            newParams = await callbacksValue(newParams, dataProvider, resource);
+        }
+    }
+    return newParams;
+};

package/dist/ra-core/src/dataTable/DataTableBase.d.ts

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import { type FC, type ReactNode } from 'react';
+import { type ListControllerResult } from '../controller/list/useListController';
+import { type Identifier, type RaRecord, type SortPayload } from '../types';
+import { type RowClickFunctionBase } from './types';
+export declare const DataTableBase: <RecordType extends RaRecord = any>(props: DataTableBaseProps<RecordType>) => string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null | undefined;
+export interface DataTableBaseProps<RecordType extends RaRecord = any> {
+    children: ReactNode;
+    expand?: ReactNode | FC<{
+        id: Identifier;
+        record: RecordType;
+        resource: string;
+    }>;
+    expandSingle?: boolean;
+    hiddenColumns?: string[];
+    hasBulkActions: boolean;
+    hover?: boolean;
+    empty: ReactNode;
+    isRowExpandable?: (record: RecordType) => boolean;
+    isRowSelectable?: (record: RecordType) => boolean;
+    loading: ReactNode;
+    rowClick?: string | RowClickFunctionBase<RecordType> | false;
+    storeKey?: string;
+    sort?: SortPayload;
+    data?: RecordType[];
+    isLoading?: boolean;
+    isPending?: boolean;
+    onSelect?: ListControllerResult['onSelect'];
+    onSelectAll?: ListControllerResult['onSelectAll'];
+    onToggleItem?: ListControllerResult['onToggleItem'];
+    onUnselectItems?: ListControllerResult['onUnselectItems'];
+    resource?: string;
+    setSort?: ListControllerResult['setSort'];
+    selectedIds?: Identifier[];
+    total?: number;
+}

package/dist/ra-core/src/dataTable/DataTableBase.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import union from 'lodash/union.js';
+import difference from 'lodash/difference.js';
+import { useListContextWithProps } from '../controller/list/useListContextWithProps';
+import { OptionalResourceContextProvider, useResourceContext } from '../core';
+import { useEvent } from '../util';
+import { DataTableCallbacksContext } from './DataTableCallbacksContext';
+import { DataTableConfigContext } from './DataTableConfigContext';
+import { DataTableDataContext } from './DataTableDataContext';
+import { DataTableSelectedIdsContext } from './DataTableSelectedIdsContext';
+import { DataTableSortContext } from './DataTableSortContext';
+import { DataTableStoreContext } from './DataTableStoreContext';
+export const DataTableBase = function DataTable(props) {
+    const resourceFromContext = useResourceContext(props);
+    const { children, empty, expand, hiddenColumns = emptyArray, hasBulkActions, hover, loading, isRowSelectable, isRowExpandable, resource, rowClick, expandSingle = false, } = props;
+    const { sort, data, isPending, onSelect, onToggleItem, selectedIds, setSort, total, } = useListContextWithProps(props);
+    const storeKey = props.storeKey || `${resourceFromContext}.datatable`;
+    const handleSort = useEvent((event) => {
+        event.stopPropagation();
+        if (!setSort)
+            return;
+        const newField = event.currentTarget.dataset.field || 'id';
+        const newOrder = sort?.field === newField
+            ? sort?.order === 'ASC'
+                ? 'DESC'
+                : 'ASC'
+            : event.currentTarget.dataset.order || 'ASC';
+        setSort({ field: newField, order: newOrder });
+    });
+    const lastSelected = useRef(null);
+    useEffect(() => {
+        if (!selectedIds || selectedIds.length === 0) {
+            lastSelected.current = null;
+        }
+    }, [JSON.stringify(selectedIds)]); // eslint-disable-line react-hooks/exhaustive-deps
+    // we manage row selection here instead of in the rows level to allow shift+click to select an array of rows
+    const handleToggleItem = useEvent((id, event) => {
+        if (!data)
+            return;
+        const ids = data.map(record => record.id);
+        const lastSelectedIndex = ids.indexOf(lastSelected.current);
+        if (event.shiftKey && lastSelectedIndex !== -1) {
+            const index = ids.indexOf(id);
+            const idsBetweenSelections = ids.slice(Math.min(lastSelectedIndex, index), Math.max(lastSelectedIndex, index) + 1);
+            const isClickedItemSelected = selectedIds?.includes(id);
+            const newSelectedIds = isClickedItemSelected
+                ? difference(selectedIds, idsBetweenSelections)
+                : union(selectedIds, idsBetweenSelections);
+            onSelect?.(isRowSelectable
+                ? newSelectedIds.filter((id) => isRowSelectable(data.find(record => record.id === id)))
+                : newSelectedIds);
+        }
+        else {
+            onToggleItem?.(id);
+        }
+        lastSelected.current = id;
+    });
+    const storeContextValue = useMemo(() => ({
+        storeKey,
+        defaultHiddenColumns: hiddenColumns,
+    }), [storeKey, hiddenColumns]);
+    const configContextValue = useMemo(() => ({
+        expand,
+        expandSingle,
+        hasBulkActions,
+        hover,
+    }), [expand, expandSingle, hasBulkActions, hover]);
+    const callbacksContextValue = useMemo(() => ({
+        handleSort: setSort ? handleSort : undefined,
+        handleToggleItem: onToggleItem ? handleToggleItem : undefined,
+        isRowExpandable,
+        isRowSelectable,
+        onSelect,
+        rowClick,
+    }), [
+        setSort,
+        handleSort,
+        handleToggleItem,
+        isRowExpandable,
+        isRowSelectable,
+        onSelect,
+        onToggleItem,
+        rowClick,
+    ]);
+    if (isPending === true) {
+        return loading;
+    }
+    /**
+     * Once loaded, the data for the list may be empty. Instead of
+     * displaying the table header with zero data rows,
+     * the DataTable displays the empty component.
+     */
+    if (data == null || data.length === 0 || total === 0) {
+        return empty ?? null;
+    }
+    /**
+     * After the initial load, if the data for the list isn't empty,
+     * and even if the data is refreshing (e.g. after a filter change),
+     * the DataTable displays the current data.
+     */
+    return (_jsx(DataTableStoreContext.Provider, { value: storeContextValue, children: _jsx(DataTableSortContext.Provider, { value: sort, children: _jsx(DataTableSelectedIdsContext.Provider, { value: selectedIds, children: _jsx(DataTableCallbacksContext.Provider, { value: callbacksContextValue, children: _jsx(DataTableConfigContext.Provider, { value: configContextValue, children: _jsx(OptionalResourceContextProvider, { value: resource, children: _jsx(DataTableDataContext.Provider, { value: data, children: children }) }) }) }) }) }) }));
+};
+const emptyArray = [];

package/dist/ra-core/src/dataTable/DataTableCallbacksContext.d.ts

@@ -0,0 +1,18 @@
+import { type Identifier } from '../types';
+import { type RowClickFunctionBase } from './types';
+export declare const DataTableCallbacksContext: import("react").Context<{
+    handleSort?: (event: any) => void;
+    handleToggleItem?: (id: Identifier, event: any) => void;
+    isRowExpandable?: (record: any) => boolean;
+    isRowSelectable?: (record: any) => boolean;
+    onSelect?: ((ids: Identifier[]) => void) | undefined;
+    rowClick?: string | RowClickFunctionBase | false;
+}>;
+export declare const useDataTableCallbacksContext: () => {
+    handleSort?: (event: any) => void;
+    handleToggleItem?: (id: Identifier, event: any) => void;
+    isRowExpandable?: (record: any) => boolean;
+    isRowSelectable?: (record: any) => boolean;
+    onSelect?: ((ids: Identifier[]) => void) | undefined;
+    rowClick?: string | RowClickFunctionBase | false;
+};

package/dist/ra-core/src/dataTable/DataTableCallbacksContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const DataTableCallbacksContext = createContext({});
+export const useDataTableCallbacksContext = () => useContext(DataTableCallbacksContext);

package/dist/ra-core/src/dataTable/DataTableColumnFilterContext.d.ts

@@ -0,0 +1,2 @@
+export declare const DataTableColumnFilterContext: import("react").Context<string | undefined>;
+export declare const useDataTableColumnFilterContext: () => string | undefined;

package/dist/ra-core/src/dataTable/DataTableColumnFilterContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const DataTableColumnFilterContext = createContext(undefined);
+export const useDataTableColumnFilterContext = () => useContext(DataTableColumnFilterContext);

package/dist/ra-core/src/dataTable/DataTableColumnRankContext.d.ts

@@ -0,0 +1,2 @@
+export declare const DataTableColumnRankContext: import("react").Context<number | undefined>;
+export declare const useDataTableColumnRankContext: () => number | undefined;

package/dist/ra-core/src/dataTable/DataTableColumnRankContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const DataTableColumnRankContext = createContext(undefined);
+export const useDataTableColumnRankContext = () => useContext(DataTableColumnRankContext);

package/dist/ra-core/src/dataTable/DataTableConfigContext.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode, type FC } from 'react';
+import { type Identifier } from '../types';
+export declare const DataTableConfigContext: import("react").Context<{
+    expand?: ReactNode | FC<{
+        id: Identifier;
+        record: any;
+        resource: string;
+    }>;
+    expandSingle: boolean;
+    hasBulkActions: boolean;
+    hover?: boolean;
+}>;
+export declare const useDataTableConfigContext: () => {
+    expand?: ReactNode | FC<{
+        id: Identifier;
+        record: any;
+        resource: string;
+    }>;
+    expandSingle: boolean;
+    hasBulkActions: boolean;
+    hover?: boolean;
+};

package/dist/ra-core/src/dataTable/DataTableConfigContext.js

@@ -0,0 +1,7 @@
+import { createContext, useContext } from 'react';
+export const DataTableConfigContext = createContext({
+    expandSingle: false,
+    hover: true,
+    hasBulkActions: false,
+});
+export const useDataTableConfigContext = () => useContext(DataTableConfigContext);

package/dist/ra-core/src/dataTable/DataTableDataContext.d.ts

@@ -0,0 +1,4 @@
+import { type RaRecord } from '../types';
+export type DataTableDataContextProps<RecordType extends RaRecord = any> = RecordType[] | undefined;
+export declare const DataTableDataContext: import("react").Context<DataTableDataContextProps<any>>;
+export declare const useDataTableDataContext: <RecordType extends RaRecord = any>() => DataTableDataContextProps<RecordType>;

package/dist/ra-core/src/dataTable/DataTableDataContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const DataTableDataContext = createContext(undefined);
+export const useDataTableDataContext = () => useContext(DataTableDataContext);

package/dist/ra-core/src/dataTable/DataTableRenderContext.d.ts

@@ -0,0 +1,3 @@
+export type RenderContextType = 'data' | 'header' | 'footer' | 'columnsSelector';
+export declare const DataTableRenderContext: import("react").Context<RenderContextType>;
+export declare const useDataTableRenderContext: () => RenderContextType;

package/dist/ra-core/src/dataTable/DataTableRenderContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const DataTableRenderContext = createContext('data');
+export const useDataTableRenderContext = () => useContext(DataTableRenderContext);

package/dist/ra-core/src/dataTable/DataTableSelectedIdsContext.d.ts

@@ -0,0 +1,3 @@
+import { type Identifier } from '../types';
+export declare const DataTableSelectedIdsContext: import("react").Context<Identifier[] | undefined>;
+export declare const useDataTableSelectedIdsContext: () => Identifier[] | undefined;

package/dist/ra-core/src/dataTable/DataTableSelectedIdsContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const DataTableSelectedIdsContext = createContext(undefined);
+export const useDataTableSelectedIdsContext = () => useContext(DataTableSelectedIdsContext);

package/dist/ra-core/src/dataTable/DataTableSortContext.d.ts

@@ -0,0 +1,3 @@
+import { type SortPayload } from '../types';
+export declare const DataTableSortContext: import("react").Context<SortPayload | undefined>;
+export declare const useDataTableSortContext: () => SortPayload | undefined;

package/dist/ra-core/src/dataTable/DataTableSortContext.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from 'react';
+export const DataTableSortContext = createContext(undefined);
+export const useDataTableSortContext = () => useContext(DataTableSortContext);

package/dist/ra-core/src/dataTable/DataTableStoreContext.d.ts

@@ -0,0 +1,8 @@
+export declare const DataTableStoreContext: import("react").Context<{
+    storeKey: string;
+    defaultHiddenColumns: string[];
+}>;
+export declare const useDataTableStoreContext: () => {
+    storeKey: string;
+    defaultHiddenColumns: string[];
+};

package/dist/ra-core/src/dataTable/DataTableStoreContext.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+export const DataTableStoreContext = createContext({
+    storeKey: '',
+    defaultHiddenColumns: [],
+});
+export const useDataTableStoreContext = () => useContext(DataTableStoreContext);

package/dist/ra-core/src/dataTable/index.d.ts

@@ -0,0 +1,11 @@
+export * from './DataTableBase';
+export * from './DataTableCallbacksContext';
+export * from './DataTableColumnRankContext';
+export * from './DataTableColumnFilterContext';
+export * from './DataTableConfigContext';
+export * from './DataTableDataContext';
+export * from './DataTableRenderContext';
+export * from './DataTableSelectedIdsContext';
+export * from './DataTableSortContext';
+export * from './DataTableStoreContext';
+export * from './types';