@strato-admin/core 0.1.0 → 0.3.0

package/dist/ra-core/src/controller/input/ReferenceArrayInputBase.d.ts

@@ -0,0 +1,78 @@
+import * as React from 'react';
+import { InputProps } from '../../form/useInput';
+import { type UseReferenceArrayInputParams } from './useReferenceArrayInputController';
+import { ChoicesContextValue } from '../../form/choices/ChoicesContext';
+import { RaRecord } from '../../types';
+/**
+ * An Input component for fields containing a list of references to another resource.
+ * Useful for 'hasMany' relationship.
+ *
+ * @example
+ * The post object has many tags, so the post resource looks like:
+ * {
+ *    id: 1234,
+ *    tag_ids: [ "1", "23", "4" ]
+ * }
+ *
+ * ReferenceArrayInputBase component fetches the current resources (using
+ * `dataProvider.getMany()`) as well as possible resources (using
+ * `dataProvider.getList()`) in the reference endpoint. It then
+ * delegates rendering to its child component, to which it makes the possible
+ * choices available through the ChoicesContext.
+ *
+ * Use it with a selector component as child, like `<SelectArrayInput>`
+ * or <CheckboxGroupInput>.
+ *
+ * @example
+ * export const PostEdit = () => (
+ *     <Edit>
+ *         <SimpleForm>
+ *             <ReferenceArrayInputBase source="tag_ids" reference="tags">
+ *                 <SelectArrayInput optionText="name" />
+ *             </ReferenceArrayInputBase>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ *
+ * By default, restricts the possible values to 25. You can extend this limit
+ * by setting the `perPage` prop.
+ *
+ * @example
+ * <ReferenceArrayInputBase
+ *      source="tag_ids"
+ *      reference="tags"
+ *      perPage={100}>
+ *     <SelectArrayInput optionText="name" />
+ * </ReferenceArrayInputBase>
+ *
+ * By default, orders the possible values by id desc. You can change this order
+ * by setting the `sort` prop (an object with `field` and `order` properties).
+ *
+ * @example
+ * <ReferenceArrayInputBase
+ *      source="tag_ids"
+ *      reference="tags"
+ *      sort={{ field: 'name', order: 'ASC' }}>
+ *     <SelectArrayInput optionText="name" />
+ * </ReferenceArrayInputBase>
+ *
+ * Also, you can filter the query used to populate the possible values. Use the
+ * `filter` prop for that.
+ *
+ * @example
+ * <ReferenceArrayInputBase
+ *      source="tag_ids"
+ *      reference="tags"
+ *      filter={{ is_public: true }}>
+ *     <SelectArrayInput optionText="name" />
+ * </ReferenceArrayInputBase>
+ *
+ * The enclosed component may filter results. ReferenceArrayInputBase create a ChoicesContext which provides
+ * a `setFilters` function. You can call this function to filter the results.
+ */
+export declare const ReferenceArrayInputBase: <RecordType extends RaRecord = any>(props: ReferenceArrayInputBaseProps<RecordType>) => import("react/jsx-runtime").JSX.Element;
+export interface ReferenceArrayInputBaseProps<RecordType extends RaRecord = any> extends InputProps, UseReferenceArrayInputParams<RecordType> {
+    children?: React.ReactNode;
+    render?: (context: ChoicesContextValue<RecordType>) => React.ReactNode;
+    offline?: React.ReactNode;
+}

package/dist/ra-core/src/controller/input/ReferenceArrayInputBase.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { useReferenceArrayInputController, } from './useReferenceArrayInputController';
+import { ResourceContextProvider } from '../../core/ResourceContextProvider';
+import { ChoicesContextProvider } from '../../form/choices/ChoicesContextProvider';
+/**
+ * An Input component for fields containing a list of references to another resource.
+ * Useful for 'hasMany' relationship.
+ *
+ * @example
+ * The post object has many tags, so the post resource looks like:
+ * {
+ *    id: 1234,
+ *    tag_ids: [ "1", "23", "4" ]
+ * }
+ *
+ * ReferenceArrayInputBase component fetches the current resources (using
+ * `dataProvider.getMany()`) as well as possible resources (using
+ * `dataProvider.getList()`) in the reference endpoint. It then
+ * delegates rendering to its child component, to which it makes the possible
+ * choices available through the ChoicesContext.
+ *
+ * Use it with a selector component as child, like `<SelectArrayInput>`
+ * or <CheckboxGroupInput>.
+ *
+ * @example
+ * export const PostEdit = () => (
+ *     <Edit>
+ *         <SimpleForm>
+ *             <ReferenceArrayInputBase source="tag_ids" reference="tags">
+ *                 <SelectArrayInput optionText="name" />
+ *             </ReferenceArrayInputBase>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ *
+ * By default, restricts the possible values to 25. You can extend this limit
+ * by setting the `perPage` prop.
+ *
+ * @example
+ * <ReferenceArrayInputBase
+ *      source="tag_ids"
+ *      reference="tags"
+ *      perPage={100}>
+ *     <SelectArrayInput optionText="name" />
+ * </ReferenceArrayInputBase>
+ *
+ * By default, orders the possible values by id desc. You can change this order
+ * by setting the `sort` prop (an object with `field` and `order` properties).
+ *
+ * @example
+ * <ReferenceArrayInputBase
+ *      source="tag_ids"
+ *      reference="tags"
+ *      sort={{ field: 'name', order: 'ASC' }}>
+ *     <SelectArrayInput optionText="name" />
+ * </ReferenceArrayInputBase>
+ *
+ * Also, you can filter the query used to populate the possible values. Use the
+ * `filter` prop for that.
+ *
+ * @example
+ * <ReferenceArrayInputBase
+ *      source="tag_ids"
+ *      reference="tags"
+ *      filter={{ is_public: true }}>
+ *     <SelectArrayInput optionText="name" />
+ * </ReferenceArrayInputBase>
+ *
+ * The enclosed component may filter results. ReferenceArrayInputBase create a ChoicesContext which provides
+ * a `setFilters` function. You can call this function to filter the results.
+ */
+export const ReferenceArrayInputBase = (props) => {
+    const { children, filter = defaultFilter, offline, reference, render, sort, } = props;
+    if (children && React.Children.count(children) !== 1) {
+        throw new Error('<ReferenceArrayInputBase> only accepts a single child (like <AutocompleteArrayInput>)');
+    }
+    if (!render && !children) {
+        throw new Error("<ReferenceArrayInputBase> requires either a 'render' prop or 'children' prop");
+    }
+    const controllerProps = useReferenceArrayInputController({
+        ...props,
+        sort,
+        filter,
+    });
+    const { isPaused, isPending } = controllerProps;
+    // isPending is true: there's no cached data and no query attempt was finished yet
+    // isPaused is true: the query was paused (e.g. due to a network issue)
+    // Both true: we're offline and have no data to show
+    const shouldRenderOffline = isPaused && isPending && offline !== undefined && offline !== false;
+    return (_jsx(ResourceContextProvider, { value: reference, children: _jsx(ChoicesContextProvider, { value: controllerProps, children: shouldRenderOffline
+                ? offline
+                : render
+                    ? render(controllerProps)
+                    : children }) }));
+};
+const defaultFilter = {};

package/dist/ra-core/src/controller/input/ReferenceInputBase.d.ts

@@ -0,0 +1,65 @@
+import { type ReactNode } from 'react';
+import type { InputProps } from '../../form/useInput';
+import { type UseReferenceInputControllerParams } from './useReferenceInputController';
+/**
+ * An Input component for choosing a reference record. Useful for foreign keys.
+ *
+ * This component fetches the possible values in the reference resource
+ * (using `dataProvider.getList()`), and renders the child you passed
+ * to which it passes the possible choices via a `ChoicesContext`.
+ *
+ * You must pass a child selection component to customize the way the reference
+ * selector is displayed (e.g. using `<SelectInput>` or `<RadioButtonGroupInput>`
+ * instead of `<AutocompleteInput>` ).
+ *
+ * Note that the child component should handle the error and loading cases as this base component does not.
+ *
+ * @example // using a SelectInput as selector
+ * export const CommentEdit = () => (
+ *     <Edit>
+ *         <SimpleForm>
+ *             <ReferenceInputBase label="Post" source="post_id" reference="posts">
+ *                 <SelectInput optionText="title" />
+ *             </ReferenceInputBase>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ *
+ * By default, restricts the possible values to 25. You can extend this limit
+ * by setting the `perPage` prop.
+ *
+ * @example
+ * <ReferenceInputBase source="post_id" reference="posts" perPage={100}/>
+ *
+ * By default, orders the possible values by id desc. You can change this order
+ * by setting the `sort` prop (an object with `field` and `order` properties).
+ *
+ * @example
+ * <ReferenceInputBase
+ *      source="post_id"
+ *      reference="posts"
+ *      sort={{ field: 'title', order: 'ASC' }}
+ * >
+ *     <SelectInput optionText="title" />
+ * </ReferenceInputBase>
+ *
+ * Also, you can filter the query used to populate the possible values. Use the
+ * `filter` prop for that.
+ *
+ * @example
+ * <ReferenceInputBase
+ *      source="post_id"
+ *      reference="posts"
+ *      filter={{ is_published: true }}
+ * >
+ *      <SelectInput optionText="title" />
+ * </ReferenceInputBase>
+ *
+ * The enclosed component may filter results. ReferenceInputBase create a ChoicesContext which provides
+ * a `setFilters` function. You can call this function to filter the results.
+ */
+export declare const ReferenceInputBase: (props: ReferenceInputBaseProps) => import("react/jsx-runtime").JSX.Element;
+export interface ReferenceInputBaseProps extends InputProps, UseReferenceInputControllerParams {
+    children?: ReactNode;
+    offline?: ReactNode;
+}

package/dist/ra-core/src/controller/input/ReferenceInputBase.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ResourceContextProvider } from '../../core';
+import { ChoicesContextProvider } from '../../form/choices/ChoicesContextProvider';
+import { useReferenceInputController, } from './useReferenceInputController';
+/**
+ * An Input component for choosing a reference record. Useful for foreign keys.
+ *
+ * This component fetches the possible values in the reference resource
+ * (using `dataProvider.getList()`), and renders the child you passed
+ * to which it passes the possible choices via a `ChoicesContext`.
+ *
+ * You must pass a child selection component to customize the way the reference
+ * selector is displayed (e.g. using `<SelectInput>` or `<RadioButtonGroupInput>`
+ * instead of `<AutocompleteInput>` ).
+ *
+ * Note that the child component should handle the error and loading cases as this base component does not.
+ *
+ * @example // using a SelectInput as selector
+ * export const CommentEdit = () => (
+ *     <Edit>
+ *         <SimpleForm>
+ *             <ReferenceInputBase label="Post" source="post_id" reference="posts">
+ *                 <SelectInput optionText="title" />
+ *             </ReferenceInputBase>
+ *         </SimpleForm>
+ *     </Edit>
+ * );
+ *
+ * By default, restricts the possible values to 25. You can extend this limit
+ * by setting the `perPage` prop.
+ *
+ * @example
+ * <ReferenceInputBase source="post_id" reference="posts" perPage={100}/>
+ *
+ * By default, orders the possible values by id desc. You can change this order
+ * by setting the `sort` prop (an object with `field` and `order` properties).
+ *
+ * @example
+ * <ReferenceInputBase
+ *      source="post_id"
+ *      reference="posts"
+ *      sort={{ field: 'title', order: 'ASC' }}
+ * >
+ *     <SelectInput optionText="title" />
+ * </ReferenceInputBase>
+ *
+ * Also, you can filter the query used to populate the possible values. Use the
+ * `filter` prop for that.
+ *
+ * @example
+ * <ReferenceInputBase
+ *      source="post_id"
+ *      reference="posts"
+ *      filter={{ is_published: true }}
+ * >
+ *      <SelectInput optionText="title" />
+ * </ReferenceInputBase>
+ *
+ * The enclosed component may filter results. ReferenceInputBase create a ChoicesContext which provides
+ * a `setFilters` function. You can call this function to filter the results.
+ */
+export const ReferenceInputBase = (props) => {
+    const { children, filter = {}, offline, reference, sort = { field: 'id', order: 'DESC' }, } = props;
+    const controllerProps = useReferenceInputController({
+        ...props,
+        sort,
+        filter,
+    });
+    const { isPaused, isPending } = controllerProps;
+    // isPending is true: there's no cached data and no query attempt was finished yet
+    // isPaused is true: the query was paused (e.g. due to a network issue)
+    // Both true: we're offline and have no data to show
+    const shouldRenderOffline = isPaused && isPending && offline !== undefined && offline !== false;
+    return (_jsx(ResourceContextProvider, { value: reference, children: _jsx(ChoicesContextProvider, { value: controllerProps, children: shouldRenderOffline ? offline : children }) }));
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorBase.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from 'react';
+import { type UseFieldArrayReturn } from 'react-hook-form';
+import type { RaRecord } from '../../types';
+export declare const SimpleFormIteratorBase: (props: SimpleFormIteratorBaseProps) => import("react/jsx-runtime").JSX.Element | null;
+export interface SimpleFormIteratorBaseProps extends Partial<UseFieldArrayReturn> {
+    children: ReactNode;
+    inline?: boolean;
+    meta?: {
+        error?: any;
+        submitFailed?: boolean;
+    };
+    getItemDefaults?: (item: any) => any;
+    record?: RaRecord;
+    resource?: string;
+    source?: string;
+    disableAutoFocus?: boolean;
+}

package/dist/ra-core/src/controller/input/SimpleFormIteratorBase.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useFormContext } from 'react-hook-form';
+import { useWrappedSource } from '../../core/useWrappedSource';
+import { useEvent } from '../../util';
+import { useArrayInput } from './useArrayInput';
+import { SimpleFormIteratorContext } from './SimpleFormIteratorContext';
+const DefaultGetItemDefaults = item => item;
+export const SimpleFormIteratorBase = (props) => {
+    const { children, getItemDefaults: getItemDefaultsProp = DefaultGetItemDefaults, disableAutoFocus = false, } = props;
+    const getItemDefaults = useEvent(getItemDefaultsProp);
+    const finalSource = useWrappedSource('');
+    if (!finalSource) {
+        throw new Error('SimpleFormIterator can only be called within an iterator input like ArrayInput');
+    }
+    const { append, fields, move, remove } = useArrayInput(props);
+    const { trigger, getValues } = useFormContext();
+    const removeField = useEvent((index) => {
+        remove(index);
+        const isScalarArray = getValues(finalSource).every((value) => typeof value !== 'object');
+        if (isScalarArray) {
+            // Trigger validation on the Array to avoid ghost errors.
+            // Otherwise, validation errors on removed fields might still be displayed
+            trigger(finalSource);
+        }
+    });
+    const addField = useEvent((item = undefined) => {
+        append(getItemDefaults(item), { shouldFocus: !disableAutoFocus });
+    });
+    const handleReorder = useEvent((origin, destination) => {
+        move(origin, destination);
+    });
+    const handleArrayClear = useEvent(() => {
+        remove();
+    });
+    const context = useMemo(() => ({
+        total: fields.length,
+        add: addField,
+        clear: handleArrayClear,
+        remove: removeField,
+        reOrder: handleReorder,
+        source: finalSource,
+    }), [
+        addField,
+        fields.length,
+        handleArrayClear,
+        handleReorder,
+        removeField,
+        finalSource,
+    ]);
+    if (!fields) {
+        return null;
+    }
+    return (_jsx(SimpleFormIteratorContext.Provider, { value: context, children: children }));
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A React context that provides access to a SimpleFormIterator data (the total number of items) and mutators (add, reorder and remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export declare const SimpleFormIteratorContext: import("react").Context<SimpleFormIteratorContextValue | undefined>;
+export type SimpleFormIteratorContextValue = {
+    add: (item?: any) => void;
+    clear: () => void;
+    remove: (index: number) => void;
+    reOrder: (index: number, newIndex: number) => void;
+    source: string;
+    total: number;
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorContext.js

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+/**
+ * A React context that provides access to a SimpleFormIterator data (the total number of items) and mutators (add, reorder and remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export const SimpleFormIteratorContext = createContext(undefined);

package/dist/ra-core/src/controller/input/SimpleFormIteratorItemBase.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import type { RaRecord } from '../../types';
+import type { ArrayInputContextValue } from './ArrayInputContext';
+export declare const SimpleFormIteratorItemBase: (props: SimpleFormIteratorItemBaseProps) => import("react/jsx-runtime").JSX.Element;
+export type SimpleFormIteratorDisableRemoveFunction = (record: RaRecord) => boolean;
+export type SimpleFormIteratorItemBaseProps = Partial<ArrayInputContextValue> & {
+    children?: ReactNode;
+    index: number;
+    record?: RaRecord;
+    resource?: string;
+    source?: string;
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorItemBase.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { SourceContextProvider, useResourceContext, useSourceContext, } from '../../core';
+import { useSimpleFormIterator } from './useSimpleFormIterator';
+import { SimpleFormIteratorItemContext, } from './SimpleFormIteratorItemContext';
+export const SimpleFormIteratorItemBase = (props) => {
+    const { children, index } = props;
+    const resource = useResourceContext(props);
+    if (!resource) {
+        throw new Error('SimpleFormIteratorItem must be used in a ResourceContextProvider or be passed a resource prop.');
+    }
+    const { total, reOrder, remove } = useSimpleFormIterator();
+    const context = useMemo(() => ({
+        index,
+        total,
+        reOrder: newIndex => reOrder(index, newIndex),
+        remove: () => remove(index),
+    }), [index, total, reOrder, remove]);
+    const parentSourceContext = useSourceContext();
+    const sourceContext = useMemo(() => ({
+        getSource: (source) => {
+            if (!source) {
+                // source can be empty for scalar values, e.g.
+                // <ArrayInput source="tags" /> => SourceContext is "tags"
+                //   <SimpleFormIterator> => SourceContext is "tags.0"
+                //      <TextInput /> => use its parent's getSource so finalSource = "tags.0"
+                //   </SimpleFormIterator>
+                // </ArrayInput>
+                return parentSourceContext.getSource(`${index}`);
+            }
+            else {
+                // Normal input with source, e.g.
+                // <ArrayInput source="orders" /> => SourceContext is "orders"
+                //   <SimpleFormIterator> => SourceContext is "orders.0"
+                //      <DateInput source="date" /> => use its parent's getSource so finalSource = "orders.0.date"
+                //   </SimpleFormIterator>
+                // </ArrayInput>
+                return parentSourceContext.getSource(`${index}.${source}`);
+            }
+        },
+        getLabel: (source) => {
+            // <ArrayInput source="orders" /> => LabelContext is "orders"
+            //   <SimpleFormIterator> => LabelContext is ALSO "orders"
+            //      <DateInput source="date" /> => use its parent's getLabel so finalLabel = "orders.date"
+            //   </SimpleFormIterator>
+            // </ArrayInput>
+            //
+            // we don't prefix with the index to avoid that translation keys contain it
+            return parentSourceContext.getLabel(source);
+        },
+    }), [index, parentSourceContext]);
+    return (_jsx(SimpleFormIteratorItemContext.Provider, { value: context, children: _jsx(SourceContextProvider, { value: sourceContext, children: children }) }));
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorItemContext.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A React context that provides access to a SimpleFormIterator item meta (its index and the total number of items) and mutators (reorder and remove this remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export declare const SimpleFormIteratorItemContext: import("react").Context<SimpleFormIteratorItemContextValue | undefined>;
+export type SimpleFormIteratorItemContextValue = {
+    index: number;
+    total: number;
+    remove: () => void;
+    reOrder: (newIndex: number) => void;
+};

package/dist/ra-core/src/controller/input/SimpleFormIteratorItemContext.js

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+/**
+ * A React context that provides access to a SimpleFormIterator item meta (its index and the total number of items) and mutators (reorder and remove this remove).
+ * Useful to create custom array input iterators.
+ * @see {SimpleFormIterator}
+ * @see {ArrayInput}
+ */
+export const SimpleFormIteratorItemContext = createContext(undefined);

package/dist/ra-core/src/controller/input/index.d.ts

@@ -0,0 +1,17 @@
+export * from './referenceDataStatus';
+export * from './useReferenceArrayInputController';
+export * from './useReferenceInputController';
+export * from './ReferenceInputBase';
+export * from './ReferenceArrayInputBase';
+export * from './ArrayInputBase';
+export * from './ArrayInputContext';
+export * from './SimpleFormIteratorBase';
+export * from './SimpleFormIteratorItemBase';
+export * from './useArrayInput';
+export * from './sanitizeInputRestProps';
+export * from './SimpleFormIteratorContext';
+export * from './SimpleFormIteratorItemContext';
+export * from './useSimpleFormIterator';
+export * from './useSimpleFormIteratorItem';
+export * from './useGetArrayInputNewItemDefaults';
+export * from './useSupportCreateSuggestion';

package/dist/ra-core/src/controller/input/index.js

@@ -0,0 +1,17 @@
+export * from './referenceDataStatus';
+export * from './useReferenceArrayInputController';
+export * from './useReferenceInputController';
+export * from './ReferenceInputBase';
+export * from './ReferenceArrayInputBase';
+export * from './ArrayInputBase';
+export * from './ArrayInputContext';
+export * from './SimpleFormIteratorBase';
+export * from './SimpleFormIteratorItemBase';
+export * from './useArrayInput';
+export * from './sanitizeInputRestProps';
+export * from './SimpleFormIteratorContext';
+export * from './SimpleFormIteratorItemContext';
+export * from './useSimpleFormIterator';
+export * from './useSimpleFormIteratorItem';
+export * from './useGetArrayInputNewItemDefaults';
+export * from './useSupportCreateSuggestion';

package/dist/ra-core/src/controller/input/referenceDataStatus.d.ts

@@ -0,0 +1,32 @@
+import { RaRecord, TranslateFunction } from '../../types';
+import { MatchingReferencesError } from './types';
+import { ControllerRenderProps } from 'react-hook-form';
+interface GetStatusForInputParams<RecordType extends RaRecord = RaRecord> {
+    field: Pick<ControllerRenderProps, 'value'>;
+    matchingReferences: RecordType[] | MatchingReferencesError;
+    referenceRecord: RecordType;
+    translate: TranslateFunction;
+}
+export declare const getStatusForInput: <RecordType extends RaRecord = RaRecord>({ field, matchingReferences, referenceRecord, translate, }: GetStatusForInputParams<RecordType>) => {
+    waiting: any;
+    error: string | null;
+    warning: string | null;
+    choices: RecordType[];
+};
+export declare const REFERENCES_STATUS_READY = "REFERENCES_STATUS_READY";
+export declare const REFERENCES_STATUS_INCOMPLETE = "REFERENCES_STATUS_INCOMPLETE";
+export declare const REFERENCES_STATUS_EMPTY = "REFERENCES_STATUS_EMPTY";
+export declare const getSelectedReferencesStatus: <RecordType extends RaRecord = any>(field: Pick<ControllerRenderProps, "value">, referenceRecords: RecordType[]) => "REFERENCES_STATUS_READY" | "REFERENCES_STATUS_INCOMPLETE" | "REFERENCES_STATUS_EMPTY";
+interface GetStatusForArrayInputParams<RecordType extends RaRecord = any> {
+    field: ControllerRenderProps;
+    matchingReferences: RecordType[] | MatchingReferencesError;
+    referenceRecords: RecordType[];
+    translate: TranslateFunction;
+}
+export declare const getStatusForArrayInput: <RecordType extends RaRecord = any>({ field, matchingReferences, referenceRecords, translate, }: GetStatusForArrayInputParams<RecordType>) => {
+    waiting: boolean;
+    error: string | null;
+    warning: string | null;
+    choices: RecordType[];
+};
+export {};

package/dist/ra-core/src/controller/input/referenceDataStatus.js

@@ -0,0 +1,74 @@
+const isMatchingReferencesError = (matchingReferences) => matchingReferences && matchingReferences.error !== undefined;
+export const getStatusForInput = ({ field, matchingReferences, referenceRecord, translate = x => x, }) => {
+    const matchingReferencesError = isMatchingReferencesError(matchingReferences)
+        ? translate(matchingReferences.error, {
+            _: matchingReferences.error,
+        })
+        : null;
+    const selectedReferenceError = field.value && !referenceRecord
+        ? translate("strato.input.references.single_missing', {
+            _: "strato.input.references.single_missing',
+        })
+        : null;
+    return {
+        waiting: (field.value && selectedReferenceError && !matchingReferences) ||
+            (!field.value && !matchingReferences),
+        error: (field.value &&
+            selectedReferenceError &&
+            matchingReferencesError) ||
+            (!field.value && matchingReferencesError)
+            ? field.value
+                ? selectedReferenceError
+                : matchingReferencesError
+            : null,
+        warning: selectedReferenceError || matchingReferencesError,
+        choices: Array.isArray(matchingReferences)
+            ? matchingReferences
+            : [referenceRecord].filter(choice => choice),
+    };
+};
+export const REFERENCES_STATUS_READY = 'REFERENCES_STATUS_READY';
+export const REFERENCES_STATUS_INCOMPLETE = 'REFERENCES_STATUS_INCOMPLETE';
+export const REFERENCES_STATUS_EMPTY = 'REFERENCES_STATUS_EMPTY';
+export const getSelectedReferencesStatus = (field, referenceRecords) => !field.value || field.value.length === referenceRecords.length
+    ? REFERENCES_STATUS_READY
+    : referenceRecords.length > 0
+        ? REFERENCES_STATUS_INCOMPLETE
+        : REFERENCES_STATUS_EMPTY;
+export const getStatusForArrayInput = ({ field, matchingReferences, referenceRecords, translate = x => x, }) => {
+    // selectedReferencesDataStatus can be "empty" (no data was found for references from input.value)
+    // or "incomplete" (Not all of the reference data was found)
+    // or "ready" (all references data was found or there is no references from input.value)
+    const selectedReferencesDataStatus = getSelectedReferencesStatus(field, referenceRecords);
+    const matchingReferencesError = isMatchingReferencesError(matchingReferences)
+        ? translate(matchingReferences.error, {
+            _: matchingReferences.error,
+        })
+        : null;
+    const choices = Array.isArray(matchingReferences)
+        ? referenceRecords.concat(matchingReferences.filter(choice => referenceRecords.findIndex(c => c.id === choice.id) === -1))
+        : referenceRecords;
+    return {
+        waiting: (!matchingReferences &&
+            field.value &&
+            selectedReferencesDataStatus === REFERENCES_STATUS_EMPTY) ||
+            (!matchingReferences && !field.value),
+        error: matchingReferencesError &&
+            (!field.value ||
+                (field.value &&
+                    selectedReferencesDataStatus === REFERENCES_STATUS_EMPTY))
+            ? translate("strato.input.references.all_missing', {
+                _: "strato.input.references.all_missing',
+            })
+            : null,
+        warning: matchingReferencesError ||
+            (field.value &&
+                selectedReferencesDataStatus !== REFERENCES_STATUS_READY)
+            ? matchingReferencesError ||
+                translate("strato.input.references.many_missing', {
+                    _: "strato.input.references.many_missing',
+                })
+            : null,
+        choices,
+    };
+};

package/dist/ra-core/src/controller/input/sanitizeInputRestProps.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeInputRestProps: ({ afterSubmit, allowNull, alwaysOn, beforeSubmit, component, data, defaultValue, error, format, formatOnBlur, initializeForm, input, isEqual, isRequired, label, limitChoicesToValue, locale, meta, multiple, name, options, optionText, optionValue, parse, record, ref, refetch, render, resource, setFilter, setPagination, setSort, shouldUnregister, source, submitError, subscription, textAlign, translate, translateChoice, validate, validateFields, value, ...rest }: any) => any;

package/dist/ra-core/src/controller/input/sanitizeInputRestProps.js

@@ -0,0 +1 @@
+export const sanitizeInputRestProps = ({ afterSubmit, allowNull, alwaysOn, beforeSubmit, component, data, defaultValue, error, format, formatOnBlur, initializeForm, input, isEqual, isRequired, label, limitChoicesToValue, locale, meta, multiple, name, options, optionText, optionValue, parse, record, ref, refetch, render, resource, setFilter, setPagination, setSort, shouldUnregister, source, submitError, subscription, textAlign, translate, translateChoice, validate, validateFields, value, ...rest }) => rest;