@strato-admin/faker-ecommerce 0.1.1 → 0.3.0

package/dist/ra-core/src/dataProvider/withLifecycleCallbacks.d.ts

@@ -0,0 +1,162 @@
+import { CreateParams, CreateResult, DataProvider, DeleteManyParams, DeleteManyResult, DeleteParams, DeleteResult, GetListParams, GetListResult, GetManyParams, GetManyReferenceParams, GetManyReferenceResult, GetManyResult, GetOneParams, GetOneResult, RaRecord, UpdateManyParams, UpdateManyResult, UpdateParams, UpdateResult } from '../types';
+/**
+ * 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 declare const withLifecycleCallbacks: (dataProvider: DataProvider, handlers: ResourceCallbacks[]) => DataProvider;
+/**
+ * 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 declare const applyCallbacks: <U>({ name, params, dataProvider, handlers, resource, }: {
+    name: string;
+    params: U;
+    dataProvider: DataProvider;
+    handlers: ResourceCallbacks[];
+    resource: string;
+}) => Promise<U>;
+export type ResourceCallback<U> = {
+    (params: U, dataProvider: DataProvider, resource: string): Promise<U>;
+};
+export type ResourceCallbacksValue<V> = ResourceCallback<V> | ResourceCallback<V>[];
+export type ResourceCallbacks<T extends RaRecord = any> = {
+    resource: string;
+    afterCreate?: ResourceCallbacksValue<CreateResult<T>>;
+    afterDelete?: ResourceCallbacksValue<DeleteResult<T>>;
+    afterDeleteMany?: ResourceCallbacksValue<DeleteManyResult<T>>;
+    afterGetList?: ResourceCallbacksValue<GetListResult<T>>;
+    afterGetMany?: ResourceCallbacksValue<GetManyResult<T>>;
+    afterGetManyReference?: ResourceCallbacksValue<GetManyReferenceResult<T>>;
+    afterGetOne?: ResourceCallbacksValue<GetOneResult<T>>;
+    afterUpdate?: ResourceCallbacksValue<UpdateResult<T>>;
+    afterUpdateMany?: ResourceCallbacksValue<UpdateManyResult<T>>;
+    beforeCreate?: ResourceCallbacksValue<CreateParams<T>>;
+    beforeDelete?: ResourceCallbacksValue<DeleteParams<T>>;
+    beforeDeleteMany?: ResourceCallbacksValue<DeleteManyParams<T>>;
+    beforeGetList?: ResourceCallbacksValue<GetListParams>;
+    beforeGetMany?: ResourceCallbacksValue<GetManyParams>;
+    beforeGetManyReference?: ResourceCallbacksValue<GetManyReferenceParams>;
+    beforeGetOne?: ResourceCallbacksValue<GetOneParams<T>>;
+    beforeUpdate?: ResourceCallbacksValue<UpdateParams<T>>;
+    beforeUpdateMany?: ResourceCallbacksValue<UpdateManyParams<T>>;
+    /**
+     * Modify the data before it is sent to the dataProvider.
+     *
+     * Used in create, update, and updateMany
+     *
+     * Note: This callback doesn't modify the record itself, but the data argument
+     * (which may be a diff, especially when called with updateMany).
+     */
+    beforeSave?: ResourceCallbacksValue<T>;
+    /**
+     * Update a record after it has been read from the dataProvider
+     *
+     * Used in getOne, getList, getMany, and getManyReference
+     */
+    afterRead?: ResourceCallbacksValue<T>;
+    /**
+     * Use the record after it is returned by the dataProvider.
+     *
+     * Used in create, update, and updateMany
+     */
+    afterSave?: ResourceCallbacksValue<T>;
+};

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/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);