ra-core/dist/controller/field/ReferenceOneFieldBase.js

Core components of react-admin, a frontend Framework for building admin applications on top of REST services, using ES6, React

import React, { useMemo } from 'react';
import { useReferenceOneFieldController, } from "./useReferenceOneFieldController.js";
import { useRecordContext, RecordContextProvider } from "../record/index.js";
import { ResourceContextProvider } from "../../core/index.js";
import { ReferenceFieldContextProvider } from "./ReferenceFieldContext.js";
import { useGetPathForRecord } from "../../routing/index.js";
/**
 * Render the related record in a one-to-one relationship
 *
 * Expects a single field as child
 *
 * @example // display the bio of the current author
 * <ReferenceOneFieldBase reference="bios" target="author_id">
 *     <TextField source="body" />
 * </ReferenceOneFieldBase>
 */
export const ReferenceOneFieldBase = (props) => {
    const { children, render, record, reference, source = 'id', target, empty, error, loading, sort, filter, link, offline, queryOptions, } = props;
    const controllerProps = useReferenceOneFieldController({
        record,
        reference,
        source,
        target,
        sort,
        filter,
        queryOptions,
    });
    const path = useGetPathForRecord({
        record: controllerProps.referenceRecord,
        resource: reference,
        link,
    });
    const context = useMemo(() => ({
        ...controllerProps,
        link: path,
    }), [controllerProps, path]);
    if (!render && !children) {
        throw new Error("<ReferenceOneFieldBase> requires either a 'render' prop or 'children' prop");
    }
    const recordFromContext = useRecordContext(props);
    const { error: controllerError, isPending, isPaused, referenceRecord, } = controllerProps;
    const shouldRenderLoading = !isPaused && isPending && loading !== false && loading !== undefined;
    const shouldRenderOffline = isPaused && isPending && offline !== false && offline !== undefined;
    const shouldRenderError = !!controllerError && error !== false && error !== undefined;
    const shouldRenderEmpty = (!recordFromContext ||
        (!isPaused &&
            referenceRecord == null &&
            !controllerError &&
            !isPending)) &&
        empty !== false &&
        empty !== undefined;
    return (React.createElement(ResourceContextProvider, { value: reference },
        React.createElement(ReferenceFieldContextProvider, { value: context },
            React.createElement(RecordContextProvider, { value: referenceRecord }, shouldRenderLoading
                ? loading
                : shouldRenderOffline
                    ? offline
                    : shouldRenderError
                        ? error
                        : shouldRenderEmpty
                            ? empty
                            : render
                                ? render(controllerProps)
                                : children))));
};
//# sourceMappingURL=ReferenceOneFieldBase.js.map