@strato-admin/faker-ecommerce 0.1.0 → 0.3.0

package/dist/ra-core/src/store/useStore.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Read and write a value from the Store
+ *
+ * useState-like hook using the global Store for persistence.
+ * Each time a store value is changed, all components using this value will be re-rendered.
+ *
+ * @param {string} key Name of the store key. Separate with dots to namespace, e.g. 'posts.list.columns'.
+ * @param {any} defaultValue Default value
+ *
+ * @return {Object} A value and a setter for the value, in an array - just like for useState()
+ *
+ * @example
+ * import { useStore } from 'react-admin';
+ *
+ * const PostList = () => {
+ *     const [density] = useStore('posts.list.density', 'small');
+ *
+ *     return (
+ *         <List>
+ *             <Datagrid size={density}>
+ *                 ...
+ *             </Datagrid>
+ *         </List>
+ *     );
+ * }
+ *
+ * // Clicking on this button will trigger a rerender of the PostList!
+ * const ChangeDensity: FC<any> = () => {
+ *     const [density, setDensity] = useStore('posts.list.density', 'small');
+ *
+ *     const changeDensity = (): void => {
+ *         setDensity(density === 'small' ? 'medium' : 'small');
+ *     };
+ *
+ *     return (
+ *         <Button onClick={changeDensity}>
+ *             {`Change density (current ${density})`}
+ *         </Button>
+ *     );
+ * };
+ */
+declare function useStore<T>(key: string, defaultValue: T): [T, (value: T | ((value: T) => void), defaultValue?: T) => void];
+declare function useStore<T = undefined>(key: string, defaultValue?: T | undefined): [T | undefined, (value: T | ((value: T) => void), defaultValue?: T) => void];
+export type useStoreResult<T = any> = [
+    T,
+    (value: T | ((value: T) => void), defaultValue?: T) => void
+];
+export { useStore };

package/dist/ra-core/src/store/useStore.js

@@ -0,0 +1,32 @@
+import { useState, useEffect } from 'react';
+import isEqual from 'lodash/isEqual.js';
+import { useEvent } from '../util';
+import { useStoreContext } from './useStoreContext';
+function useStore(key, defaultValue) {
+    const { getItem, setItem, subscribe } = useStoreContext();
+    const [value, setValue] = useState(() => getItem(key, defaultValue));
+    // subscribe to changes on this key, and change the state when they happen
+    useEffect(() => {
+        const storedValue = getItem(key, defaultValue);
+        if (!isEqual(value, storedValue)) {
+            setValue(storedValue);
+        }
+        const unsubscribe = subscribe(key, newValue => {
+            setValue(typeof newValue === 'undefined' ? defaultValue : newValue);
+        });
+        return () => unsubscribe();
+    }, [key, subscribe, defaultValue, getItem, value]);
+    const set = useEvent((valueParam, runtimeDefaultValue) => {
+        const newValue = typeof valueParam === 'function' ? valueParam(value) : valueParam;
+        // we only set the value in the Store;
+        // the value in the local state will be updated
+        // by the useEffect during the next render
+        setItem(key, typeof newValue === 'undefined'
+            ? typeof runtimeDefaultValue === 'undefined'
+                ? defaultValue
+                : runtimeDefaultValue
+            : newValue);
+    });
+    return [value, set];
+}
+export { useStore };

package/dist/ra-core/src/store/useStoreContext.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get the Store stored in the StoreContext
+ */
+export declare const useStoreContext: () => unknown;

package/dist/ra-core/src/store/useStoreContext.js

@@ -0,0 +1,6 @@
+import { useContext } from 'react';
+import { StoreContext } from './StoreContext';
+/**
+ * Get the Store stored in the StoreContext
+ */
+export const useStoreContext = () => useContext(StoreContext);

package/dist/ra-core/src/test-ui/defaultI18nProvider.d.ts

@@ -0,0 +1,2 @@
+import { I18nProvider } from '../types';
+export declare const defaultI18nProvider: I18nProvider;

package/dist/ra-core/src/test-ui/defaultI18nProvider.js

@@ -0,0 +1,10 @@
+export const defaultI18nProvider = {
+    translate: (key, options = {}) => {
+        if (options._) {
+            return options._;
+        }
+        return key;
+    },
+    changeLocale: () => Promise.resolve(),
+    getLocale: () => 'en',
+};

package/dist/ra-core/src/test-ui/index.d.ts

@@ -0,0 +1,21 @@
+export * from './Admin';
+export * from './ArrayInput';
+export * from './AutocompleteArrayInput';
+export * from './AutocompleteInput';
+export * from './BooleanInput';
+export * from './Confirm';
+export * from './CreateButton';
+export * from './DataTable';
+export * from './defaultI18nProvider';
+export * from './DeleteButton';
+export * from './EditButton';
+export * from './Layout';
+export * from './Notification';
+export * from './Pagination';
+export * from './PrevNextButtons';
+export * from './ShowButton';
+export * from './SimpleForm';
+export * from './SimpleFormIterator';
+export * from './SimpleList';
+export * from './SimpleShowLayout';
+export * from './TextInput';

package/dist/ra-core/src/test-ui/index.js

@@ -0,0 +1,21 @@
+export * from './Admin';
+export * from './ArrayInput';
+export * from './AutocompleteArrayInput';
+export * from './AutocompleteInput';
+export * from './BooleanInput';
+export * from './Confirm';
+export * from './CreateButton';
+export * from './DataTable';
+export * from './defaultI18nProvider';
+export * from './DeleteButton';
+export * from './EditButton';
+export * from './Layout';
+export * from './Notification';
+export * from './Pagination';
+export * from './PrevNextButtons';
+export * from './ShowButton';
+export * from './SimpleForm';
+export * from './SimpleFormIterator';
+export * from './SimpleList';
+export * from './SimpleShowLayout';
+export * from './TextInput';

package/dist/ra-core/src/types.d.ts

@@ -0,0 +1,284 @@
+import { ComponentType, ReactElement, ReactNode } from 'react';
+import { FieldPath } from 'react-hook-form';
+import { WithPermissionsChildrenParams } from './auth/WithPermissions';
+import { AuthActionType } from './auth/types';
+/**
+ * data types
+ */
+export type Identifier = string | number;
+export interface RaRecord<IdentifierType extends Identifier = Identifier> extends Record<string, any> {
+    id: IdentifierType;
+}
+export interface SortPayload {
+    field: string;
+    order: 'ASC' | 'DESC';
+}
+export interface FilterPayload {
+    [k: string]: any;
+}
+export interface PaginationPayload {
+    page: number;
+    perPage: number;
+}
+export type ValidUntil = Date;
+/**
+ * i18nProvider types
+ */
+export declare const I18N_TRANSLATE = "I18N_TRANSLATE";
+export declare const I18N_CHANGE_LOCALE = "I18N_CHANGE_LOCALE";
+export type TranslateFunction = (key: string, options?: any) => string;
+export type Locale = {
+    locale: string;
+    name: string;
+};
+export type I18nProvider = {
+    translate: TranslateFunction;
+    changeLocale: (locale: string, options?: any) => Promise<void>;
+    getLocale: () => string;
+    getLocales?: () => Locale[];
+    [key: string]: any;
+};
+export interface UserIdentity {
+    id: Identifier;
+    fullName?: string;
+    avatar?: string;
+    [key: string]: any;
+}
+/**
+ * authProvider types
+ */
+export type AuthProvider = {
+    login: (params: any) => Promise<{
+        redirectTo?: string | boolean;
+    } | void | any>;
+    logout: (params: any) => Promise<void | false | string>;
+    checkAuth: (params: any & QueryFunctionContext) => Promise<void>;
+    checkError: (error: any) => Promise<void>;
+    getIdentity?: (params?: QueryFunctionContext) => Promise<UserIdentity>;
+    getPermissions?: (params: any & QueryFunctionContext) => Promise<any>;
+    handleCallback?: (params?: QueryFunctionContext) => Promise<AuthRedirectResult | void | any>;
+    canAccess?: <RecordType extends Record<string, any> = Record<string, any>>(params: QueryFunctionContext & {
+        action: string;
+        resource: string;
+        record?: RecordType;
+    }) => Promise<boolean>;
+    [key: string]: any;
+    supportAbortSignal?: boolean;
+};
+export type AuthRedirectResult = {
+    redirectTo?: string | false;
+    logoutOnFailure?: boolean;
+};
+export type LegacyAuthProvider = (type: AuthActionType, params?: any) => Promise<any>;
+/**
+ * dataProvider types
+ */
+export type DataProvider<ResourceType extends string = string> = {
+    getList: <RecordType extends RaRecord = any>(resource: ResourceType, params: GetListParams & QueryFunctionContext) => Promise<GetListResult<RecordType>>;
+    getOne: <RecordType extends RaRecord = any>(resource: ResourceType, params: GetOneParams<RecordType> & QueryFunctionContext) => Promise<GetOneResult<RecordType>>;
+    getMany: <RecordType extends RaRecord = any>(resource: ResourceType, params: GetManyParams<RecordType> & QueryFunctionContext) => Promise<GetManyResult<RecordType>>;
+    getManyReference: <RecordType extends RaRecord = any>(resource: ResourceType, params: GetManyReferenceParams & QueryFunctionContext) => Promise<GetManyReferenceResult<RecordType>>;
+    update: <RecordType extends RaRecord = any>(resource: ResourceType, params: UpdateParams) => Promise<UpdateResult<RecordType>>;
+    updateMany: <RecordType extends RaRecord = any>(resource: ResourceType, params: UpdateManyParams) => Promise<UpdateManyResult<RecordType>>;
+    create: <RecordType extends Omit<RaRecord, 'id'> = any, ResultRecordType extends RaRecord = RecordType & {
+        id: Identifier;
+    }>(resource: ResourceType, params: CreateParams) => Promise<CreateResult<ResultRecordType>>;
+    delete: <RecordType extends RaRecord = any>(resource: ResourceType, params: DeleteParams<RecordType>) => Promise<DeleteResult<RecordType>>;
+    deleteMany: <RecordType extends RaRecord = any>(resource: ResourceType, params: DeleteManyParams<RecordType>) => Promise<DeleteManyResult<RecordType>>;
+    [key: string]: any;
+    supportAbortSignal?: boolean;
+};
+export interface QueryFunctionContext {
+    signal?: AbortSignal;
+}
+export interface GetListParams {
+    pagination?: PaginationPayload;
+    sort?: SortPayload;
+    filter?: any;
+    meta?: any;
+    signal?: AbortSignal;
+}
+export interface GetListResult<RecordType extends RaRecord = any> {
+    data: RecordType[];
+    total?: number;
+    pageInfo?: {
+        hasNextPage?: boolean;
+        hasPreviousPage?: boolean;
+    };
+    meta?: any;
+}
+export interface GetInfiniteListResult<RecordType extends RaRecord = any> extends GetListResult<RecordType> {
+    pageParam: number;
+}
+export interface GetOneParams<RecordType extends RaRecord = any> {
+    id: RecordType['id'];
+    meta?: any;
+    signal?: AbortSignal;
+}
+export interface GetOneResult<RecordType extends RaRecord = any> {
+    data: RecordType;
+    meta?: any;
+}
+export interface GetManyParams<RecordType extends RaRecord = any> {
+    ids: RecordType['id'][];
+    meta?: any;
+    signal?: AbortSignal;
+}
+export interface GetManyResult<RecordType extends RaRecord = any> {
+    data: RecordType[];
+    meta?: any;
+}
+export interface GetManyReferenceParams {
+    target: string;
+    id: Identifier;
+    pagination: PaginationPayload;
+    sort: SortPayload;
+    filter: any;
+    meta?: any;
+    signal?: AbortSignal;
+}
+export interface GetManyReferenceResult<RecordType extends RaRecord = any> {
+    data: RecordType[];
+    total?: number;
+    pageInfo?: {
+        hasNextPage?: boolean;
+        hasPreviousPage?: boolean;
+    };
+    meta?: any;
+}
+export interface UpdateParams<RecordType extends RaRecord = any> {
+    id: RecordType['id'];
+    data: Partial<RecordType>;
+    previousData: RecordType;
+    meta?: any;
+}
+export interface UpdateResult<RecordType extends RaRecord = any> {
+    data: RecordType;
+    meta?: any;
+}
+export interface UpdateManyParams<T = any> {
+    ids: Identifier[];
+    data: Partial<T>;
+    meta?: any;
+}
+export interface UpdateManyResult<RecordType extends RaRecord = any> {
+    data?: RecordType['id'][];
+    meta?: any;
+}
+export interface CreateParams<T = any> {
+    data: Partial<T>;
+    meta?: any;
+}
+export interface CreateResult<RecordType extends RaRecord = any> {
+    data: RecordType;
+    meta?: any;
+}
+export interface DeleteParams<RecordType extends RaRecord = any> {
+    id: RecordType['id'];
+    previousData?: RecordType;
+    meta?: any;
+}
+export interface DeleteResult<RecordType extends RaRecord = any> {
+    data: RecordType;
+    meta?: any;
+}
+export interface DeleteManyParams<RecordType extends RaRecord = any> {
+    ids: RecordType['id'][];
+    meta?: any;
+}
+export interface DeleteManyResult<RecordType extends RaRecord = any> {
+    data?: RecordType['id'][];
+    meta?: any;
+}
+export type DataProviderResult<RecordType extends RaRecord = any> = CreateResult<RecordType> | DeleteResult<RecordType> | DeleteManyResult | GetListResult<RecordType> | GetManyResult<RecordType> | GetManyReferenceResult<RecordType> | GetOneResult<RecordType> | UpdateResult<RecordType> | UpdateManyResult;
+export type MutationMode = 'pessimistic' | 'optimistic' | 'undoable';
+export type OnSuccess = (response?: any, variables?: any, onMutateResult?: any, context?: any) => void;
+export type OnError = (error?: any, variables?: any, onMutateResult?: any, context?: any) => void;
+export type TransformData = (data: any, options?: {
+    previousData: any;
+}) => any | Promise<any>;
+export interface UseDataProviderOptions {
+    action?: string;
+    fetch?: string;
+    meta?: object;
+    mutationMode?: MutationMode;
+    onSuccess?: OnSuccess;
+    onError?: OnError;
+    enabled?: boolean;
+}
+export type LegacyDataProvider = (type: string, resource: string, params: any) => Promise<any>;
+export type RecordToStringFunction = (record: any) => string;
+export interface ResourceDefinition<OptionsType extends ResourceOptions = any> {
+    readonly name: string;
+    readonly options?: OptionsType;
+    readonly hasList?: boolean;
+    readonly hasEdit?: boolean;
+    readonly hasShow?: boolean;
+    readonly hasCreate?: boolean;
+    readonly icon?: any;
+    readonly recordRepresentation?: React.ReactNode | RecordToStringFunction;
+}
+/**
+ * Misc types
+ */
+export type Dispatch<T> = T extends (...args: infer A) => any ? (...args: A) => void : never;
+export type ResourceElement = ReactElement<ResourceProps>;
+export type RenderResourcesFunction = (permissions: any) => ReactNode | Promise<ReactNode> | ResourceElement[] | Promise<ResourceElement[]>;
+export type AdminChildren = RenderResourcesFunction | Iterable<ReactNode | RenderResourcesFunction> | ReactNode;
+export type TitleComponent = string | ReactElement<any>;
+export type CatchAllComponent = ComponentType<{
+    title?: TitleComponent;
+}>;
+export type LoginComponent = ComponentType<{}> | ReactElement<any>;
+export type DashboardComponent = ComponentType<WithPermissionsChildrenParams>;
+export interface CoreLayoutProps {
+    children: ReactNode;
+}
+export type LayoutComponent = ComponentType<CoreLayoutProps>;
+export type LoadingComponent = ComponentType<{
+    loadingPrimary?: string;
+    loadingSecondary?: string;
+}>;
+export interface ResourceComponentInjectedProps {
+    permissions?: any;
+    resource?: string;
+    options?: any;
+    hasList?: boolean;
+    hasEdit?: boolean;
+    hasShow?: boolean;
+    hasCreate?: boolean;
+}
+export interface ResourceOptions {
+    label?: string;
+    [key: string]: any;
+}
+export interface ResourceProps {
+    intent?: 'route' | 'registration';
+    name: string;
+    list?: ComponentType<any> | ReactElement;
+    create?: ComponentType<any> | ReactElement;
+    edit?: ComponentType<any> | ReactElement;
+    show?: ComponentType<any> | ReactElement;
+    hasCreate?: boolean;
+    hasEdit?: boolean;
+    hasShow?: boolean;
+    icon?: ComponentType<any>;
+    recordRepresentation?: React.ReactNode | RecordToStringFunction;
+    options?: ResourceOptions;
+    children?: ReactNode;
+}
+export type Exporter<RecordType extends RaRecord = any> = (data: RecordType[], fetchRelatedRecords: FetchRelatedRecords, dataProvider: DataProvider, resource?: string) => void | Promise<void>;
+export type FetchRelatedRecords = <RecordType = any>(data: any[], field: string, resource: string) => Promise<{
+    [key: Identifier]: RecordType;
+}>;
+export type SetOnSave = (onSave?: (values: object, redirect: any) => void) => void;
+export type FormFunctions = {
+    setOnSave?: SetOnSave;
+};
+export type HintedString<KnownValues extends string> = AnyString | KnownValues;
+export type RecordValues = Record<string, any>;
+export type RecordPath<TRecordValues extends RecordValues> = FieldPath<TRecordValues>;
+export type ExtractRecordPaths<T extends RecordValues> = [
+    T
+] extends [never] ? string : RecordPath<T>;
+export type AnyString = string & {};

package/dist/ra-core/src/types.js

@@ -0,0 +1,5 @@
+/**
+ * i18nProvider types
+ */
+export const I18N_TRANSLATE = 'I18N_TRANSLATE';
+export const I18N_CHANGE_LOCALE = 'I18N_CHANGE_LOCALE';

package/dist/ra-core/src/util/asyncDebounce.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A version of lodash/debounce that always returns a promise but wait for the debounced function to return to resolve it.
+ * @param func The function to debounce
+ * @param wait The debounce delay
+ * @returns A debounced function that returns a promise
+ */
+export declare function asyncDebounce<FunctionType extends (...args: any[]) => Promise<any>>(func: FunctionType, wait?: number): (...args: Parameters<FunctionType>) => ReturnType<FunctionType>;

package/dist/ra-core/src/util/asyncDebounce.js

@@ -0,0 +1,29 @@
+import debounce from 'lodash/debounce.js';
+/**
+ * A version of lodash/debounce that always returns a promise but wait for the debounced function to return to resolve it.
+ * @param func The function to debounce
+ * @param wait The debounce delay
+ * @returns A debounced function that returns a promise
+ */
+export function asyncDebounce(func, wait) {
+    const resolveSet = new Set();
+    const rejectSet = new Set();
+    const debounced = debounce((args) => {
+        func(...args)
+            .then((...res) => {
+            resolveSet.forEach(resolve => resolve(...res));
+        })
+            .catch((...res) => {
+            rejectSet.forEach(reject => reject(...res));
+        })
+            .finally(() => {
+            resolveSet.clear();
+            rejectSet.clear();
+        });
+    }, wait);
+    return (...args) => new Promise((resolve, reject) => {
+        resolveSet.add(resolve);
+        rejectSet.add(reject);
+        debounced(args);
+    });
+}

package/dist/ra-core/src/util/escapePath.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Escape special characters in path so that react-router Route does not do any special treatment
+ *
+ * @see https://github.com/ReactTraining/react-router/blob/v3/docs/guides/RouteMatching.md#path-syntax
+ *
+ * @example
+ *
+ * escapePath('/foo(bar)') => 'foo\(bar\)'
+ */
+declare const _default: (url: any) => any;
+export default _default;

package/dist/ra-core/src/util/escapePath.js

@@ -0,0 +1,10 @@
+/**
+ * Escape special characters in path so that react-router Route does not do any special treatment
+ *
+ * @see https://github.com/ReactTraining/react-router/blob/v3/docs/guides/RouteMatching.md#path-syntax
+ *
+ * @example
+ *
+ * escapePath('/foo(bar)') => 'foo\(bar\)'
+ */
+export default url => url.replace(/(\(|\))/g, '\\$1');

package/dist/ra-core/src/util/genericMemo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A version of React.memo that preserves the original component type allowing it to accept generics.
+ * See {@link https://stackoverflow.com/a/70890101}
+ */
+export declare const genericMemo: <T>(component: T) => T;

package/dist/ra-core/src/util/genericMemo.js

@@ -0,0 +1,14 @@
+import { memo } from 'react';
+/**
+ * A version of React.memo that preserves the original component type allowing it to accept generics.
+ * See {@link https://stackoverflow.com/a/70890101}
+ */
+export const genericMemo = (component) => {
+    const result = memo(component);
+    // We have to set the displayName on both the field implementation and the memoized version.
+    // On the implementation so that the memoized version can pick them up and users may reference the defaultProps in their components.
+    // On the memoized version so that components that inspect their children props may read them.
+    // @ts-ignore
+    result.displayName = component.displayName?.replace('Impl', '');
+    return result;
+};

package/dist/ra-core/src/util/getFieldLabelTranslationArgs.d.ts

@@ -0,0 +1,22 @@
+interface Args {
+    label?: string;
+    defaultLabel?: string;
+    resource?: string;
+    resourceFromContext?: string;
+    source?: string;
+}
+type TranslationArguments = [string, any?];
+/**
+ * Returns an array of arguments to use with the translate function for the label of a field.
+ * The label will be computed from the resource and source props.
+ *
+ * Usage:
+ *  <span>
+ *      {translate(...getFieldLabelTranslationArgs({ label, resource, source }))}
+ *  </span>
+ *
+ * @see useTranslateLabel for a ready-to-use hook
+ */
+export declare const getFieldLabelTranslationArgs: (options?: Args) => TranslationArguments;
+export default getFieldLabelTranslationArgs;
+export declare const getResourceFieldLabelKey: (resource: string, source: string) => string;

package/dist/ra-core/src/util/getFieldLabelTranslationArgs.js

@@ -0,0 +1,73 @@
+import { transform } from 'inflection';
+/**
+ * Returns an array of arguments to use with the translate function for the label of a field.
+ * The label will be computed from the resource and source props.
+ *
+ * Usage:
+ *  <span>
+ *      {translate(...getFieldLabelTranslationArgs({ label, resource, source }))}
+ *  </span>
+ *
+ * @see useTranslateLabel for a ready-to-use hook
+ */
+export const getFieldLabelTranslationArgs = (options) => {
+    if (!options)
+        return [''];
+    const { label, defaultLabel, resource, resourceFromContext, source } = options;
+    if (typeof label !== 'undefined')
+        return [label, { _: label }];
+    if (typeof source === 'undefined')
+        return [''];
+    const { sourceWithoutDigits, sourceSuffix } = getSourceParts(source);
+    const defaultLabelTranslation = transform(sourceSuffix.replace(/\./g, ' '), ['underscore', 'humanize']);
+    if (resource) {
+        return [
+            getResourceFieldLabelKey(resource, sourceWithoutDigits),
+            { _: defaultLabelTranslation },
+        ];
+    }
+    if (defaultLabel) {
+        return [defaultLabel, { _: defaultLabelTranslation }];
+    }
+    return [
+        getResourceFieldLabelKey(resourceFromContext || 'undefined', sourceWithoutDigits),
+        { _: defaultLabelTranslation },
+    ];
+};
+export default getFieldLabelTranslationArgs;
+export const getResourceFieldLabelKey = (resource, source) => `resources.${resource}.fields.${source}`;
+/**
+ * Uses the source string to guess a translation message and a default label.
+ *
+ * @example
+ * getSourceParts('pictures') // { sourceWithoutDigits: 'pictures', sourceSuffix: 'pictures' }
+ * getSourceParts('pictures.url') // { sourceWithoutDigits: 'pictures.url', sourceSuffix: 'pictures.url' }
+ * getSourceParts('pictures.0.url') // { sourceWithoutDigits: 'pictures.url', sourceSuffix: 'url' }
+ * getSourceParts('pictures.12.urls.5.protocol') // { sourceWithoutDigits: 'pictures.urls.protocol', sourceSuffix: 'protocol' }
+ */
+const getSourceParts = (source) => {
+    // remove digits, e.g. 'book.authors.2.categories.3.identifier.name' => 'book.authors.categories.identifier.name'
+    const sourceWithoutDigits = source.replace(/\.\d+\./g, '.');
+    // get final part, e.g. 'book.authors.2.categories.3.identifier.name' => 'identifier.name'
+    // we're not using a regexp here to avoid code scanning alert "Polynomial regular expression used on uncontrolled data"
+    const parts = source.split('.');
+    let lastPartWithDigits;
+    parts.forEach((part, index) => {
+        if (onlyDigits(part)) {
+            lastPartWithDigits = index;
+        }
+    });
+    const sourceSuffix = lastPartWithDigits != null
+        ? parts.slice(lastPartWithDigits + 1).join('.')
+        : source;
+    return { sourceWithoutDigits, sourceSuffix };
+};
+// 48 and 57 are the char codes for "0" and "9", respectively
+const onlyDigits = s => {
+    for (let i = s.length - 1; i >= 0; i--) {
+        const d = s.charCodeAt(i);
+        if (d < 48 || d > 57)
+            return false;
+    }
+    return true;
+};

package/dist/ra-core/src/util/getMutationMode.d.ts

@@ -0,0 +1 @@
+export declare const getMutationMode: (mutationMode: any, undoable: any) => any;

package/dist/ra-core/src/util/getMutationMode.js

@@ -0,0 +1,13 @@
+export const getMutationMode = (mutationMode, undoable) => {
+    if (mutationMode) {
+        return mutationMode;
+    }
+    switch (undoable) {
+        case true:
+            return 'undoable';
+        case false:
+            return 'pessimistic';
+        default:
+            return 'undoable';
+    }
+};

package/dist/ra-core/src/util/hooks.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @deprecated use `useState` instead, since React no longer
+ * issues warnings when calling setState on unmounted components.
+ */
+export declare function useSafeSetState<T>(initialState?: T | (() => T)): [T | undefined, React.Dispatch<React.SetStateAction<T>>];
+export declare function usePrevious<T>(value: T): T;
+export declare function useDeepCompareEffect(callback: any, inputs: any): void;
+/**
+ * A hook that returns true once a delay has expired.
+ * @param ms The delay in milliseconds
+ * @param key A key that can be used to reset the timer
+ * @returns true if the delay has expired, false otherwise
+ */
+export declare function useTimeout(ms?: number, key?: string): boolean;
+export declare function useIsMounted(): import("react").RefObject<boolean>;