payload 0.14.22-beta.0 → 0.14.23-beta.0

package/dist/admin/components/elements/Status/index.js

@@ -0,0 +1,107 @@
+import React, { useCallback, useState } from 'react';
+import { useConfig } from '@payloadcms/config-provider';
+import { toast } from 'react-toastify';
+import { Modal, useModal } from '@faceless-ui/modal';
+import { useDocumentInfo } from '../../utilities/DocumentInfo';
+import Button from '../Button';
+import { MinimalTemplate } from '../..';
+import { requests } from '../../../api';
+import { useForm } from '../../forms/Form/context';
+import { useLocale } from '../../utilities/Locale';
+import './index.scss';
+const baseClass = 'status';
+const unPublishModalSlug = 'confirm-un-publish';
+const revertModalSlug = 'confirm-revert';
+const Status = () => {
+    var _a, _b;
+    const { publishedDoc, unpublishedVersions, collection, global, id, getVersions } = useDocumentInfo();
+    const { toggle, closeAll: closeAllModals } = useModal();
+    const { serverURL, routes: { api } } = useConfig();
+    const [processing, setProcessing] = useState(false);
+    const { reset: resetForm } = useForm();
+    const locale = useLocale();
+    let statusToRender;
+    if (((_a = unpublishedVersions === null || unpublishedVersions === void 0 ? void 0 : unpublishedVersions.docs) === null || _a === void 0 ? void 0 : _a.length) > 0 && publishedDoc) {
+        statusToRender = 'Changed';
+    }
+    else if (!publishedDoc) {
+        statusToRender = 'Draft';
+    }
+    else if (publishedDoc && ((_b = unpublishedVersions === null || unpublishedVersions === void 0 ? void 0 : unpublishedVersions.docs) === null || _b === void 0 ? void 0 : _b.length) <= 1) {
+        statusToRender = 'Published';
+    }
+    const performAction = useCallback(async (action) => {
+        let url;
+        let method;
+        let body;
+        setProcessing(true);
+        if (action === 'unpublish') {
+            body = {
+                _status: 'draft',
+            };
+        }
+        if (action === 'revert') {
+            body = publishedDoc;
+        }
+        if (collection) {
+            url = `${serverURL}${api}/${collection.slug}/${id}?depth=0&locale=${locale}&fallback-locale=null`;
+            method = 'put';
+        }
+        if (global) {
+            url = `${serverURL}${api}/globals/${global.slug}?depth=0&locale=${locale}&fallback-locale=null`;
+            method = 'post';
+        }
+        const res = await requests[method](url, {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        if (res.status === 200) {
+            let data;
+            let fields;
+            const json = await res.json();
+            if (global) {
+                data = json.result;
+                fields = global.fields;
+            }
+            if (collection) {
+                data = json.doc;
+                fields = collection.fields;
+            }
+            resetForm(fields, data);
+            toast.success(json.message);
+            getVersions();
+        }
+        else {
+            toast.error('There was a problem while un-publishing this document.');
+        }
+        setProcessing(false);
+        closeAllModals();
+    }, [closeAllModals, collection, global, serverURL, api, resetForm, id, locale, getVersions, publishedDoc]);
+    if (statusToRender) {
+        return (React.createElement("div", { className: baseClass },
+            React.createElement("div", { className: `${baseClass}__value-wrap` },
+                React.createElement("span", { className: `${baseClass}__value` }, statusToRender),
+                statusToRender === 'Published' && (React.createElement(React.Fragment, null,
+                    "\u00A0\u2014\u00A0",
+                    React.createElement(Button, { onClick: () => toggle(unPublishModalSlug), className: `${baseClass}__action`, buttonStyle: "none" }, "Unpublish"),
+                    React.createElement(Modal, { slug: unPublishModalSlug, className: `${baseClass}__modal` },
+                        React.createElement(MinimalTemplate, null,
+                            React.createElement("h1", null, "Confirm unpublish"),
+                            React.createElement("p", null, "You are about to unpublish this document. Are you sure?"),
+                            React.createElement(Button, { buttonStyle: "secondary", type: "button", onClick: processing ? undefined : () => toggle(unPublishModalSlug) }, "Cancel"),
+                            React.createElement(Button, { onClick: processing ? undefined : () => performAction('unpublish') }, processing ? 'Unpublishing...' : 'Confirm'))))),
+                statusToRender === 'Changed' && (React.createElement(React.Fragment, null,
+                    "\u00A0\u2014\u00A0",
+                    React.createElement(Button, { onClick: () => toggle(revertModalSlug), className: `${baseClass}__action`, buttonStyle: "none" }, "Revert to published"),
+                    React.createElement(Modal, { slug: revertModalSlug, className: `${baseClass}__modal` },
+                        React.createElement(MinimalTemplate, null,
+                            React.createElement("h1", null, "Confirm revert to saved"),
+                            React.createElement("p", null, "You are about to revert this document's changes to its published state. Are you sure?"),
+                            React.createElement(Button, { buttonStyle: "secondary", type: "button", onClick: processing ? undefined : () => toggle(revertModalSlug) }, "Cancel"),
+                            React.createElement(Button, { onClick: processing ? undefined : () => performAction('revert') }, processing ? 'Reverting...' : 'Confirm'))))))));
+    }
+    return null;
+};
+export default Status;

package/dist/admin/components/elements/Status/index.scss

@@ -0,0 +1,30 @@
+@import '../../../scss/styles.scss';
+
+.status {
+  &__label {
+    color: gray;
+  }
+
+  &__value {
+    font-weight: 600;
+  }
+
+  &__action {
+    text-decoration: underline;
+  }
+
+  &__modal {
+    @include blur-bg;
+    display: flex;
+    align-items: center;
+    height: 100%;
+
+    &__toggle {
+      @extend %btn-reset;
+    }
+
+    .btn {
+      margin-right: $baseline;
+    }
+  }
+}

package/dist/admin/components/elements/Status/types.d.ts

@@ -0,0 +1 @@
+export declare type Props = {};

package/dist/admin/components/elements/Status/types.js

@@ -0,0 +1 @@
+export {};

package/dist/admin/components/elements/VersionsCount/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { Props } from './types';
+import './index.scss';
+declare const VersionsCount: React.FC<Props>;
+export default VersionsCount;

package/dist/admin/components/elements/VersionsCount/index.js

@@ -0,0 +1,42 @@
+import { useConfig } from '@payloadcms/config-provider';
+import React from 'react';
+import Button from '../Button';
+import { useDocumentInfo } from '../../utilities/DocumentInfo';
+import { shouldIncrementVersionCount } from '../../../../versions/shouldIncrementVersionCount';
+import './index.scss';
+const baseClass = 'versions-count';
+const VersionsCount = ({ collection, global, id }) => {
+    var _a, _b, _c;
+    const { routes: { admin } } = useConfig();
+    const { versions, publishedDoc, unpublishedVersions } = useDocumentInfo();
+    // Doc status could come from three places:
+    // 1. the newest unpublished version (a draft)
+    // 2. the published doc's status, in the event that the doc is published and there are no newer versions
+    // 3. if there is no published doc, it's a draft
+    const docStatus = ((_c = (_b = (_a = unpublishedVersions === null || unpublishedVersions === void 0 ? void 0 : unpublishedVersions.docs) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.version) === null || _c === void 0 ? void 0 : _c._status) || (publishedDoc === null || publishedDoc === void 0 ? void 0 : publishedDoc._status) || 'draft';
+    let versionsURL;
+    let entity;
+    if (collection) {
+        versionsURL = `${admin}/collections/${collection.slug}/${id}/versions`;
+        entity = collection;
+    }
+    if (global) {
+        versionsURL = `${admin}/globals/${global.slug}/versions`;
+        entity = global;
+    }
+    let initialVersionsCount = 0;
+    if (shouldIncrementVersionCount({ entity, versions, docStatus })) {
+        initialVersionsCount = 1;
+    }
+    const versionCount = ((versions === null || versions === void 0 ? void 0 : versions.totalDocs) || 0) + initialVersionsCount;
+    return (React.createElement("div", { className: baseClass },
+        versionCount === 0 && 'No versions found',
+        versionCount > 0 && (React.createElement(Button, { className: `${baseClass}__button`, buttonStyle: "none", el: "link", to: versionsURL },
+            versionCount,
+            ' ',
+            "version",
+            versionCount > 1 && 's',
+            ' ',
+            "found"))));
+};
+export default VersionsCount;

package/dist/admin/components/elements/VersionsCount/index.scss

@@ -0,0 +1,9 @@
+@import '../../../scss/styles.scss';
+
+.versions-count__button {
+  font-weight: 600;
+
+  &:hover {
+    text-decoration: underline;
+  }
+}

package/dist/admin/components/elements/VersionsCount/types.d.ts

@@ -0,0 +1,7 @@
+import { SanitizedCollectionConfig } from '../../../../collections/config/types';
+import { SanitizedGlobalConfig } from '../../../../globals/config/types';
+export declare type Props = {
+    collection?: SanitizedCollectionConfig;
+    global?: SanitizedGlobalConfig;
+    id?: string | number;
+};

package/dist/admin/components/elements/VersionsCount/types.js

@@ -0,0 +1 @@
+export {};

package/dist/admin/components/elements/WhereBuilder/Condition/Relationship/types.d.ts

@@ -1,5 +1,6 @@
 import { RelationshipField } from '../../../../../../fields/config/types';
-import { PaginatedDocs, SanitizedCollectionConfig } from '../../../../../../collections/config/types';
+import { SanitizedCollectionConfig } from '../../../../../../collections/config/types';
+import { PaginatedDocs } from '../../../../../../mongoose/types';
 export declare type Props = {
     onChange: (val: unknown) => void;
     value: unknown;

package/dist/admin/components/forms/Form/getDataByPath.d.ts

@@ -1,3 +1,3 @@
 import { Fields } from './types';
-declare const getDataByPath: (fields: Fields, path: string) => unknown;
+declare const getDataByPath: <T = unknown>(fields: Fields, path: string) => T;
 export default getDataByPath;

package/dist/admin/components/forms/Form/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable jsx-a11y/no-noninteractive-element-interactions */
 import React, { useReducer, useEffect, useRef, useState, useCallback, } from 'react';
 import { serialize } from 'object-to-formdata';
 import { useHistory } from 'react-router-dom';
@@ -15,6 +16,7 @@ import wait from '../../../../utilities/wait';
 import buildInitialState from './buildInitialState';
 import errorMessages from './errorMessages';
 import { SubmittedContext, ProcessingContext, ModifiedContext, FormContext, FormWatchContext } from './context';
+import buildStateFromSchema from './buildStateFromSchema';
 const baseClass = 'form';
 const Form = (props) => {
     const { disabled, onSubmit, method, action, handleResponse, onSuccess, children, className, redirect, disableSuccessStatus, initialState, // fully formed initial field state
@@ -27,6 +29,7 @@ const Form = (props) => {
     const [processing, setProcessing] = useState(false);
     const [submitted, setSubmitted] = useState(false);
     const [formattedInitialData, setFormattedInitialData] = useState(buildInitialState(initialData));
+    const formRef = useRef(null);
     const contextRef = useRef({});
     let initialFieldState = {};
     if (formattedInitialData)
@@ -62,17 +65,22 @@ const Form = (props) => {
         dispatchFields({ type: 'REPLACE_STATE', state: validatedFieldState });
         return isValid;
     }, [contextRef]);
-    const submit = useCallback(async (e) => {
+    const submit = useCallback(async (options = {}, e) => {
+        const { overrides = {}, action: actionToUse = action, method: methodToUse = method, skipValidation, } = options;
         if (disabled) {
-            e.preventDefault();
+            if (e) {
+                e.preventDefault();
+            }
             return;
         }
-        e.stopPropagation();
-        e.preventDefault();
+        if (e) {
+            e.stopPropagation();
+            e.preventDefault();
+        }
         setProcessing(true);
         if (waitForAutocomplete)
             await wait(100);
-        const isValid = await contextRef.current.validateForm();
+        const isValid = skipValidation ? true : await contextRef.current.validateForm();
         setSubmitted(true);
         // If not valid, prevent submission
         if (!isValid) {
@@ -82,12 +90,16 @@ const Form = (props) => {
         }
         // If submit handler comes through via props, run that
         if (onSubmit) {
-            onSubmit(fields, reduceFieldsToValues(fields));
+            const data = {
+                ...reduceFieldsToValues(fields),
+                ...overrides,
+            };
+            onSubmit(fields, data);
             return;
         }
-        const formData = contextRef.current.createFormData();
+        const formData = contextRef.current.createFormData(overrides);
         try {
-            const res = await requests[method.toLowerCase()](action, {
+            const res = await requests[methodToUse.toLowerCase()](actionToUse, {
                 body: formData,
             });
             setModified(false);
@@ -202,20 +214,29 @@ const Form = (props) => {
     const getSiblingData = useCallback((path) => getSiblingDataFunc(contextRef.current.fields, path), [contextRef]);
     const getDataByPath = useCallback((path) => getDataByPathFunc(contextRef.current.fields, path), [contextRef]);
     const getUnflattenedValues = useCallback(() => reduceFieldsToValues(contextRef.current.fields), [contextRef]);
-    const createFormData = useCallback(() => {
+    const createFormData = useCallback((overrides = {}) => {
         const data = reduceFieldsToValues(contextRef.current.fields, true);
         const file = data === null || data === void 0 ? void 0 : data.file;
         if (file) {
             delete data.file;
         }
+        const dataWithOverrides = {
+            ...data,
+            ...overrides,
+        };
         const dataToSerialize = {
-            _payload: JSON.stringify(data),
+            _payload: JSON.stringify(dataWithOverrides),
             file,
         };
         // nullAsUndefineds is important to allow uploads and relationship fields to clear themselves
         const formData = serialize(dataToSerialize, { indices: true, nullsAsUndefineds: false });
         return formData;
     }, [contextRef]);
+    const reset = useCallback(async (fieldSchema, data) => {
+        const state = await buildStateFromSchema(fieldSchema, data);
+        contextRef.current = { ...initContextState };
+        dispatchFields({ type: 'REPLACE_STATE', state });
+    }, []);
     contextRef.current.dispatchFields = dispatchFields;
     contextRef.current.submit = submit;
     contextRef.current.getFields = getFields;
@@ -230,6 +251,8 @@ const Form = (props) => {
     contextRef.current.setProcessing = setProcessing;
     contextRef.current.setSubmitted = setSubmitted;
     contextRef.current.disabled = disabled;
+    contextRef.current.formRef = formRef;
+    contextRef.current.reset = reset;
     useEffect(() => {
         if (initialState) {
             contextRef.current = { ...initContextState };
@@ -259,7 +282,7 @@ const Form = (props) => {
         // eslint-disable-next-line no-console
         console.log(fields);
     }
-    return (React.createElement("form", { noValidate: true, onSubmit: contextRef.current.submit, method: method, action: action, className: classes },
+    return (React.createElement("form", { noValidate: true, onSubmit: (e) => contextRef.current.submit({}, e), method: method, action: action, className: classes, ref: formRef },
         React.createElement(FormContext.Provider, { value: contextRef.current },
             React.createElement(FormWatchContext.Provider, { value: {
                     fields,

package/dist/admin/components/forms/Form/initContextState.js

@@ -7,6 +7,7 @@ const createFormData = () => undefined;
 const setModified = () => undefined;
 const setProcessing = () => undefined;
 const setSubmitted = () => undefined;
+const reset = () => undefined;
 const initialContextState = {
     getFields: () => ({}),
     getField: () => undefined,
@@ -24,5 +25,7 @@ const initialContextState = {
     initialState: {},
     fields: {},
     disabled: false,
+    formRef: null,
+    reset,
 };
 export default initialContextState;

package/dist/admin/components/forms/Form/types.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { Condition } from '../../../../fields/config/types';
+import { Field as FieldConfig, Condition } from '../../../../fields/config/types';
 export declare type Field = {
     value: unknown;
     initialValue: unknown;
@@ -35,19 +35,26 @@ export declare type Props = {
     waitForAutocomplete?: boolean;
     log?: boolean;
 };
+export declare type SubmitOptions = {
+    action?: string;
+    method?: string;
+    overrides?: Record<string, unknown>;
+    skipValidation?: boolean;
+};
 export declare type DispatchFields = React.Dispatch<any>;
-export declare type Submit = (e: React.FormEvent<HTMLFormElement>) => void;
+export declare type Submit = (options?: SubmitOptions, e?: React.FormEvent<HTMLFormElement>) => void;
 export declare type ValidateForm = () => Promise<boolean>;
-export declare type CreateFormData = () => FormData;
+export declare type CreateFormData = (overrides?: any) => FormData;
 export declare type GetFields = () => Fields;
 export declare type GetField = (path: string) => Field;
 export declare type GetData = () => Data;
 export declare type GetSiblingData = (path: string) => Data;
 export declare type GetUnflattenedValues = () => Data;
-export declare type GetDataByPath = (path: string) => unknown;
+export declare type GetDataByPath = <T = unknown>(path: string) => T;
 export declare type SetModified = (modified: boolean) => void;
 export declare type SetSubmitted = (submitted: boolean) => void;
 export declare type SetProcessing = (processing: boolean) => void;
+export declare type Reset = (fieldSchema: FieldConfig[], data: unknown) => Promise<void>;
 export declare type Context = {
     dispatchFields: DispatchFields;
     submit: Submit;
@@ -65,4 +72,6 @@ export declare type Context = {
     setModified: SetModified;
     setProcessing: SetProcessing;
     setSubmitted: SetSubmitted;
+    formRef: React.MutableRefObject<HTMLFormElement>;
+    reset: Reset;
 };

package/dist/admin/components/forms/Submit/index.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="react" />
+import React from 'react';
+import { Props } from '../../elements/Button/types';
 import './index.scss';
-declare const FormSubmit: ({ children }: {
-    children: any;
-}) => JSX.Element;
+declare const FormSubmit: React.FC<Props>;
 export default FormSubmit;

package/dist/admin/components/forms/Submit/index.js

@@ -3,10 +3,11 @@ import { useForm, useFormProcessing } from '../Form/context';
 import Button from '../../elements/Button';
 import './index.scss';
 const baseClass = 'form-submit';
-const FormSubmit = ({ children }) => {
+const FormSubmit = (props) => {
+    const { children, disabled: disabledFromProps, type = 'submit' } = props;
     const processing = useFormProcessing();
     const { disabled } = useForm();
     return (React.createElement("div", { className: baseClass },
-        React.createElement(Button, { type: "submit", disabled: processing || disabled ? true : undefined }, children)));
+        React.createElement(Button, { ...props, type: type, disabled: disabledFromProps || processing || disabled ? true : undefined }, children)));
 };
 export default FormSubmit;

package/dist/admin/components/forms/field-types/Array/Array.js

@@ -77,10 +77,6 @@ const ArrayFieldType = (props) => {
             setDisableFormData(true);
         }
     }, [rows, setValue]);
-    return (React.createElement(RenderArray, { onDragEnd: onDragEnd, label: label, showError: showError, errorMessage: errorMessage, rows: rows, labels: labels, addRow: addRow, removeRow: removeRow, moveRow: moveRow, path: path, name: name, fieldTypes: fieldTypes, fields: fields, permissions: permissions, value: value, readOnly: readOnly, minRows: minRows, maxRows: maxRows, required: required, description: description }));
-};
-const RenderArray = React.memo((props) => {
-    const { onDragEnd, label, showError, errorMessage, rows, labels, addRow, removeRow, moveRow, path, fieldTypes, fields, permissions, value, readOnly, minRows, maxRows, required, description, } = props;
     const hasMaxRows = maxRows && rows.length >= maxRows;
     return (React.createElement(DragDropContext, { onDragEnd: onDragEnd },
         React.createElement("div", { className: baseClass },
@@ -105,5 +101,5 @@ const RenderArray = React.memo((props) => {
                 provided.placeholder))),
             (!readOnly && (!hasMaxRows)) && (React.createElement("div", { className: `${baseClass}__add-button-wrap` },
                 React.createElement(Button, { onClick: () => addRow(value), buttonStyle: "icon-label", icon: "plus", iconStyle: "with-border", iconPosition: "left" }, `Add ${labels.singular}`))))));
-});
+};
 export default withCondition(ArrayFieldType);

package/dist/admin/components/forms/field-types/Array/types.d.ts

@@ -1,33 +1,9 @@
-import { Data } from '../../Form/types';
-import { ArrayField, Labels, Field } from '../../../../../fields/config/types';
+import { ArrayField } from '../../../../../fields/config/types';
 import { FieldTypes } from '..';
 import { FieldPermissions } from '../../../../../auth/types';
-import { Description } from '../../FieldDescription/types';
 export declare type Props = Omit<ArrayField, 'type'> & {
     path?: string;
     fieldTypes: FieldTypes;
     permissions: FieldPermissions;
     label: string | false;
 };
-export declare type RenderArrayProps = {
-    path: string;
-    name: string;
-    fieldTypes: FieldTypes;
-    fields: Field[];
-    permissions: FieldPermissions;
-    onDragEnd: (result: any) => void;
-    label: string | false;
-    value: number;
-    readOnly: boolean;
-    minRows: number;
-    maxRows: number;
-    required: boolean;
-    labels: Labels;
-    addRow: (index: number) => Promise<void>;
-    removeRow: (index: number) => void;
-    moveRow: (fromIndex: number, toIndex: number) => void;
-    showError: boolean;
-    errorMessage: string;
-    rows: Data[];
-    description?: Description;
-};

package/dist/admin/components/forms/field-types/Blocks/Blocks.js

@@ -117,10 +117,6 @@ const Blocks = (props) => {
             setDisableFormData(true);
         }
     }, [rows, setValue]);
-    return (React.createElement(RenderBlocks, { onDragEnd: onDragEnd, label: label, showError: showError, errorMessage: errorMessage, rows: rows, labels: labels, addRow: addRow, removeRow: removeRow, moveRow: moveRow, path: path, name: name, fieldTypes: fieldTypes, setCollapse: setCollapse, permissions: permissions, value: value, blocks: blocks, readOnly: readOnly, minRows: minRows, maxRows: maxRows, required: required, description: description }));
-};
-const RenderBlocks = React.memo((props) => {
-    const { onDragEnd, label, showError, errorMessage, rows, labels, addRow, removeRow, moveRow, path, fieldTypes, permissions, value, setCollapse, blocks, readOnly, minRows, maxRows, required, description, } = props;
     const hasMaxRows = maxRows && rows.length >= maxRows;
     return (React.createElement(DragDropContext, { onDragEnd: onDragEnd },
         React.createElement("div", { className: baseClass },
@@ -153,5 +149,5 @@ const RenderBlocks = React.memo((props) => {
                 provided.placeholder))),
             (!readOnly && (rows.length < maxRows || maxRows === undefined)) && (React.createElement("div", { className: `${baseClass}__add-button-wrap` },
                 React.createElement(Popup, { buttonType: "custom", size: "large", horizontalAlign: "left", button: (React.createElement(Button, { buttonStyle: "icon-label", icon: "plus", iconPosition: "left", iconStyle: "with-border" }, `Add ${labels.singular}`)), render: ({ close }) => (React.createElement(BlockSelector, { blocks: blocks, addRow: addRow, addRowIndex: value, close: close })) }))))));
-});
+};
 export default withCondition(Blocks);

package/dist/admin/components/forms/field-types/Blocks/types.d.ts

@@ -1,33 +1,8 @@
-import { Data } from '../../Form/types';
-import { BlockField, Labels, Block } from '../../../../../fields/config/types';
+import { BlockField } from '../../../../../fields/config/types';
 import { FieldTypes } from '..';
 import { FieldPermissions } from '../../../../../auth/types';
-import { Description } from '../../FieldDescription/types';
 export declare type Props = Omit<BlockField, 'type'> & {
     path?: string;
     fieldTypes: FieldTypes;
     permissions: FieldPermissions;
 };
-export declare type RenderBlockProps = {
-    path: string;
-    name: string;
-    fieldTypes: FieldTypes;
-    permissions: FieldPermissions;
-    onDragEnd: (result: any) => void;
-    label: string | false;
-    value: number;
-    readOnly: boolean;
-    minRows: number;
-    maxRows: number;
-    required: boolean;
-    labels: Labels;
-    addRow: (index: number, blockType: string) => Promise<void>;
-    removeRow: (index: number) => void;
-    moveRow: (fromIndex: number, toIndex: number) => void;
-    showError: boolean;
-    errorMessage: string;
-    rows: Data[];
-    blocks: Block[];
-    setCollapse: (id: string, collapsed: boolean) => void;
-    description?: Description;
-};

package/dist/admin/components/forms/field-types/Relationship/createRelationMap.d.ts

@@ -0,0 +1,10 @@
+declare type RelationMap = {
+    [relation: string]: unknown[];
+};
+declare type CreateRelationMap = (args: {
+    hasMany: boolean;
+    relationTo: string | string[];
+    value: unknown;
+}) => RelationMap;
+export declare const createRelationMap: CreateRelationMap;
+export {};

package/dist/admin/components/forms/field-types/Relationship/createRelationMap.js

@@ -0,0 +1,29 @@
+export const createRelationMap = ({ hasMany, relationTo, value, }) => {
+    const hasMultipleRelations = Array.isArray(relationTo);
+    const relationMap = {};
+    const add = (relation, id) => {
+        if (typeof relationMap[relation] === 'undefined')
+            relationMap[relation] = [];
+        if (id !== 'null' && id !== null) {
+            relationMap[relation].push(id);
+        }
+    };
+    if (hasMany) {
+        (value || []).forEach((val, i) => {
+            if (hasMultipleRelations) {
+                add(value[i].relationTo, value[i].value);
+            }
+            else {
+                add(relationTo, value[i]);
+            }
+        });
+    }
+    else if (hasMultipleRelations) {
+        const valueWithRelation = value;
+        add(valueWithRelation.relationTo, valueWithRelation.value);
+    }
+    else {
+        add(relationTo, value);
+    }
+    return relationMap;
+};