@payloadcms/ui 3.0.0-canary.fb81f02 → 3.0.0

package/dist/providers/DocumentInfo/index.js

@@ -1,490 +1,295 @@
 'use client';
+
 import { jsx as _jsx } from "react/jsx-runtime";
-import { notFound } from 'next/navigation.js';
-import { reduceFieldsToValues } from 'payload/shared';
 import * as qs from 'qs-esm';
 import React, { createContext, useCallback, useContext, useEffect, useRef, useState } from 'react';
+import { useAuth } from '../../providers/Auth/index.js';
+import { requests } from '../../utilities/api.js';
 import { formatDocTitle } from '../../utilities/formatDocTitle.js';
-import { getFormState } from '../../utilities/getFormState.js';
-import { hasSavePermission as getHasSavePermission } from '../../utilities/hasSavePermission.js';
-import { isEditing as getIsEditing } from '../../utilities/isEditing.js';
-import { useAuth } from '../Auth/index.js';
 import { useConfig } from '../Config/index.js';
 import { useLocale } from '../Locale/index.js';
 import { usePreferences } from '../Preferences/index.js';
 import { useTranslation } from '../Translation/index.js';
 import { UploadEditsProvider, useUploadEdits } from '../UploadEdits/index.js';
-const Context = /*#__PURE__*/ createContext({});
-export const useDocumentInfo = ()=>useContext(Context);
-const DocumentInfo = ({ children, ...props })=>{
-    const { id, collectionSlug, docPermissions: docPermissionsFromProps, globalSlug, hasPublishPermission: hasPublishPermissionFromProps, hasSavePermission: hasSavePermissionFromProps, initialData: initialDataFromProps, initialState: initialStateFromProps, onLoadError, onSave: onSaveFromProps } = props;
-    const { admin: { dateFormat }, collections, globals, routes: { api }, serverURL } = useConfig();
-    const collectionConfig = collections.find((c)=>c.slug === collectionSlug);
-    const globalConfig = globals.find((g)=>g.slug === globalSlug);
-    const docConfig = collectionConfig || globalConfig;
-    const { i18n } = useTranslation();
-    const { uploadEdits } = useUploadEdits();
-    const [documentTitle, setDocumentTitle] = useState(()=>{
-        if (!initialDataFromProps) return '';
-        return formatDocTitle({
-            collectionConfig,
-            data: {
-                ...initialDataFromProps,
-                id
-            },
-            dateFormat,
-            fallback: id?.toString(),
-            globalConfig,
-            i18n
-        });
-    });
-    const [isLoading, setIsLoading] = useState(false);
-    const [isError, setIsError] = useState(false);
-    const [data, setData] = useState(initialDataFromProps);
-    const [initialState, setInitialState] = useState(initialStateFromProps);
-    const [publishedDoc, setPublishedDoc] = useState(null);
-    const [versions, setVersions] = useState(null);
-    const [docPermissions, setDocPermissions] = useState(docPermissionsFromProps);
-    const [hasSavePermission, setHasSavePermission] = useState(hasSavePermissionFromProps);
-    const [hasPublishPermission, setHasPublishPermission] = useState(hasPublishPermissionFromProps);
-    const isInitializing = initialState === undefined || data === undefined;
-    const [unpublishedVersions, setUnpublishedVersions] = useState(null);
-    const { getPreference, setPreference } = usePreferences();
-    const { permissions } = useAuth();
-    const { code: locale } = useLocale();
-    const prevLocale = useRef(locale);
-    const hasInitializedDocPermissions = useRef(false);
-    // Separate locale cache used for handling permissions
-    const prevLocalePermissions = useRef(locale);
-    const versionsConfig = docConfig?.versions;
-    const baseURL = `${serverURL}${api}`;
-    let slug;
-    let pluralType;
-    let preferencesKey;
-    if (globalSlug) {
-        slug = globalSlug;
-        pluralType = 'globals';
-        preferencesKey = `global-${slug}`;
+import { useGetDocPermissions } from './useGetDocPermissions.js';
+const Context = /*#__PURE__*/createContext({});
+export const useDocumentInfo = () => {
+  return useContext(Context);
+};
+const DocumentInfo = ({
+  children,
+  ...props
+}) => {
+  const {
+    id,
+    collectionSlug,
+    currentEditor: currentEditorFromProps,
+    docPermissions: docPermissionsFromProps,
+    globalSlug,
+    hasPublishedDoc: hasPublishedDocFromProps,
+    hasPublishPermission: hasPublishPermissionFromProps,
+    hasSavePermission: hasSavePermissionFromProps,
+    initialData: data,
+    initialState,
+    isLocked: isLockedFromProps,
+    lastUpdateTime: lastUpdateTimeFromProps,
+    mostRecentVersionIsAutosaved: mostRecentVersionIsAutosavedFromProps,
+    unpublishedVersionCount: unpublishedVersionCountFromProps,
+    versionCount: versionCountFromProps
+  } = props;
+  const [docPermissions, setDocPermissions] = useState(docPermissionsFromProps);
+  const [hasSavePermission, setHasSavePermission] = useState(hasSavePermissionFromProps);
+  const [hasPublishPermission, setHasPublishPermission] = useState(hasPublishPermissionFromProps);
+  const {
+    permissions
+  } = useAuth();
+  const {
+    config: {
+      admin: {
+        dateFormat
+      },
+      routes: {
+        api
+      },
+      serverURL
+    },
+    getEntityConfig
+  } = useConfig();
+  const collectionConfig = getEntityConfig({
+    collectionSlug
+  });
+  const globalConfig = getEntityConfig({
+    globalSlug
+  });
+  const abortControllerRef = useRef(new AbortController());
+  const docConfig = collectionConfig || globalConfig;
+  const {
+    i18n
+  } = useTranslation();
+  const {
+    uploadEdits
+  } = useUploadEdits();
+  const [documentTitle, setDocumentTitle] = useState(() => formatDocTitle({
+    collectionConfig,
+    data: {
+      ...data,
+      id
+    },
+    dateFormat,
+    fallback: id?.toString(),
+    globalConfig,
+    i18n
+  }));
+  const [mostRecentVersionIsAutosaved, setMostRecentVersionIsAutosaved] = useState(mostRecentVersionIsAutosavedFromProps);
+  const [versionCount, setVersionCount] = useState(versionCountFromProps);
+  const [hasPublishedDoc, setHasPublishedDoc] = useState(hasPublishedDocFromProps);
+  const [unpublishedVersionCount, setUnpublishedVersionCount] = useState(unpublishedVersionCountFromProps);
+  const [documentIsLocked, setDocumentIsLocked] = useState(isLockedFromProps);
+  const [currentEditor, setCurrentEditor] = useState(currentEditorFromProps);
+  const [lastUpdateTime, setLastUpdateTime] = useState(lastUpdateTimeFromProps);
+  const isInitializing = initialState === undefined || data === undefined;
+  const {
+    getPreference,
+    setPreference
+  } = usePreferences();
+  const {
+    code: locale
+  } = useLocale();
+  const baseURL = `${serverURL}${api}`;
+  let slug;
+  let pluralType;
+  let preferencesKey;
+  if (globalSlug) {
+    slug = globalSlug;
+    pluralType = 'globals';
+    preferencesKey = `global-${slug}`;
+  }
+  if (collectionSlug) {
+    slug = collectionSlug;
+    pluralType = 'collections';
+    if (id) {
+      preferencesKey = `collection-${slug}-${id}`;
     }
-    if (collectionSlug) {
-        slug = collectionSlug;
-        pluralType = 'collections';
-        if (id) {
-            preferencesKey = `collection-${slug}-${id}`;
-        }
+  }
+  const unlockDocument = useCallback(async (docId, slug_0) => {
+    try {
+      const isGlobal = slug_0 === globalSlug;
+      const query = isGlobal ? `where[globalSlug][equals]=${slug_0}` : `where[document.value][equals]=${docId}&where[document.relationTo][equals]=${slug_0}`;
+      const request = await requests.get(`${serverURL}${api}/payload-locked-documents?${query}`);
+      const {
+        docs
+      } = await request.json();
+      if (docs.length > 0) {
+        const lockId = docs[0].id;
+        await requests.delete(`${serverURL}${api}/payload-locked-documents/${lockId}`, {
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+        setDocumentIsLocked(false);
+      }
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to unlock the document', error);
     }
-    const isEditing = getIsEditing({
-        id,
-        collectionSlug,
-        globalSlug
-    });
-    const operation = isEditing ? 'update' : 'create';
-    const shouldFetchVersions = Boolean(versionsConfig && docPermissions?.readVersions?.permission);
-    const getVersions = useCallback(async ()=>{
-        let versionFetchURL;
-        let publishedFetchURL;
-        let unpublishedVersionJSON = null;
-        let versionJSON = null;
-        let shouldFetch = true;
-        const versionParams = {
-            depth: 0,
-            where: {
-                and: []
-            }
-        };
-        const publishedVersionParams = {
-            depth: 0,
-            locale: locale || undefined,
-            where: {
-                and: [
-                    {
-                        or: [
-                            {
-                                _status: {
-                                    equals: 'published'
-                                }
-                            },
-                            {
-                                _status: {
-                                    exists: false
-                                }
-                            }
-                        ]
-                    }
-                ]
-            }
-        };
-        if (globalSlug) {
-            versionFetchURL = `${baseURL}/globals/${globalSlug}/versions`;
-            publishedFetchURL = `${baseURL}/globals/${globalSlug}?${qs.stringify(publishedVersionParams)}`;
-        }
-        if (collectionSlug) {
-            versionFetchURL = `${baseURL}/${collectionSlug}/versions`;
-            publishedVersionParams.where.and.push({
-                id: {
-                    equals: id
-                }
-            });
-            publishedFetchURL = `${baseURL}/${collectionSlug}?${qs.stringify(publishedVersionParams)}`;
-            if (!id) {
-                shouldFetch = false;
-            }
-            versionParams.where.and.push({
-                parent: {
-                    equals: id
-                }
-            });
-        }
-        if (shouldFetch) {
-            let publishedJSON;
-            if (versionsConfig?.drafts) {
-                publishedJSON = await fetch(publishedFetchURL, {
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language
-                    }
-                }).then((res)=>res.json());
-                if (collectionSlug) {
-                    publishedJSON = publishedJSON?.docs?.[0];
-                }
-            }
-            if (shouldFetchVersions) {
-                versionJSON = await fetch(`${versionFetchURL}?${qs.stringify(versionParams)}`, {
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language
-                    }
-                }).then((res)=>res.json());
-                if (publishedJSON?.updatedAt) {
-                    const newerVersionParams = {
-                        ...versionParams,
-                        where: {
-                            ...versionParams.where,
-                            and: [
-                                ...versionParams.where.and,
-                                {
-                                    updatedAt: {
-                                        greater_than: publishedJSON?.updatedAt
-                                    }
-                                }
-                            ]
-                        }
-                    };
-                    // Get any newer versions available
-                    const newerVersionRes = await fetch(`${versionFetchURL}?${qs.stringify(newerVersionParams)}`, {
-                        credentials: 'include',
-                        headers: {
-                            'Accept-Language': i18n.language
-                        }
-                    });
-                    if (newerVersionRes.status === 200) {
-                        unpublishedVersionJSON = await newerVersionRes.json();
-                    }
-                }
-            }
-            setPublishedDoc(publishedJSON);
-            setVersions(versionJSON);
-            setUnpublishedVersions(unpublishedVersionJSON);
-        }
-    }, [
-        i18n,
-        globalSlug,
-        collectionSlug,
-        id,
-        baseURL,
-        locale,
-        versionsConfig,
-        shouldFetchVersions
-    ]);
-    const getDocPermissions = React.useCallback(async (data)=>{
-        const params = {
-            locale: locale || undefined
+  }, [serverURL, api, globalSlug]);
+  const updateDocumentEditor = useCallback(async (docId_0, slug_1, user) => {
+    try {
+      const isGlobal_0 = slug_1 === globalSlug;
+      const query_0 = isGlobal_0 ? `where[globalSlug][equals]=${slug_1}` : `where[document.value][equals]=${docId_0}&where[document.relationTo][equals]=${slug_1}`;
+      // Check if the document is already locked
+      const request_0 = await requests.get(`${serverURL}${api}/payload-locked-documents?${query_0}`);
+      const {
+        docs: docs_0
+      } = await request_0.json();
+      if (docs_0.length > 0) {
+        const lockId_0 = docs_0[0].id;
+        const userData = typeof user === 'object' ? {
+          relationTo: user.collection,
+          value: user.id
+        } : {
+          relationTo: 'users',
+          value: user
         };
-        const idToUse = data?.id || id;
-        const newIsEditing = getIsEditing({
-            id: idToUse,
-            collectionSlug,
-            globalSlug
+        // Send a patch request to update the _lastEdited info
+        await requests.patch(`${serverURL}${api}/payload-locked-documents/${lockId_0}`, {
+          body: JSON.stringify({
+            user: userData
+          }),
+          headers: {
+            'Content-Type': 'application/json'
+          }
         });
-        if (newIsEditing) {
-            const docAccessURL = collectionSlug ? `/${collectionSlug}/access/${idToUse}` : globalSlug ? `/globals/${globalSlug}/access` : null;
-            if (docAccessURL) {
-                const res = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
-                    body: JSON.stringify(data),
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language,
-                        'Content-Type': 'application/json'
-                    },
-                    method: 'post'
-                });
-                const json = await res.json();
-                const publishedAccessJSON = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
-                    body: JSON.stringify({
-                        ...data || {},
-                        _status: 'published'
-                    }),
-                    credentials: 'include',
-                    headers: {
-                        'Accept-Language': i18n.language,
-                        'Content-Type': 'application/json'
-                    },
-                    method: 'POST'
-                }).then((res)=>res.json());
-                setDocPermissions(json);
-                setHasSavePermission(getHasSavePermission({
-                    collectionSlug,
-                    docPermissions: json,
-                    globalSlug,
-                    isEditing: newIsEditing
-                }));
-                setHasPublishPermission(publishedAccessJSON?.update?.permission);
-            }
-        } else {
-            // when creating new documents, there is no permissions saved for this document yet
-            // use the generic entity permissions instead
-            const newDocPermissions = collectionSlug ? permissions?.collections?.[collectionSlug] : permissions?.globals?.[globalSlug];
-            setDocPermissions(newDocPermissions);
-            setHasSavePermission(getHasSavePermission({
-                collectionSlug,
-                docPermissions: newDocPermissions,
-                globalSlug,
-                isEditing: newIsEditing
-            }));
-        }
-    }, [
-        serverURL,
-        api,
-        id,
-        permissions,
-        i18n.language,
-        locale,
-        collectionSlug,
-        globalSlug
-    ]);
-    const getDocPreferences = useCallback(()=>{
-        return getPreference(preferencesKey);
-    }, [
-        getPreference,
-        preferencesKey
-    ]);
-    const setDocFieldPreferences = useCallback(async (path, fieldPreferences)=>{
-        const allPreferences = await getDocPreferences();
-        if (preferencesKey) {
-            try {
-                await setPreference(preferencesKey, {
-                    ...allPreferences,
-                    fields: {
-                        ...allPreferences?.fields || {},
-                        [path]: {
-                            ...allPreferences?.fields?.[path],
-                            ...fieldPreferences
-                        }
-                    }
-                });
-            } catch (e) {
-                console.error(e) // eslint-disable-line no-console
-                ;
+      }
+    } catch (error_0) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to update the document editor', error_0);
+    }
+  }, [serverURL, api, globalSlug]);
+  const getDocPermissions = useGetDocPermissions({
+    id: id,
+    api,
+    collectionSlug,
+    globalSlug,
+    i18n,
+    locale,
+    permissions,
+    serverURL,
+    setDocPermissions,
+    setHasPublishPermission,
+    setHasSavePermission
+  });
+  const getDocPreferences = useCallback(() => {
+    return getPreference(preferencesKey);
+  }, [getPreference, preferencesKey]);
+  const setDocFieldPreferences = useCallback(async (path, fieldPreferences) => {
+    const allPreferences = await getDocPreferences();
+    if (preferencesKey) {
+      try {
+        await setPreference(preferencesKey, {
+          ...allPreferences,
+          fields: {
+            ...(allPreferences?.fields || {}),
+            [path]: {
+              ...allPreferences?.fields?.[path],
+              ...fieldPreferences
             }
-        }
-    }, [
-        setPreference,
-        preferencesKey,
-        getDocPreferences
-    ]);
-    const onSave = React.useCallback(async (json)=>{
-        if (typeof onSaveFromProps === 'function') {
-            void onSaveFromProps(json);
-        }
-        const docPreferences = await getDocPreferences();
-        const newData = collectionSlug ? json.doc : json.result;
-        const newState = await getFormState({
-            apiRoute: api,
-            body: {
-                id,
-                collectionSlug,
-                data: newData,
-                docPreferences,
-                globalSlug,
-                locale,
-                operation,
-                schemaPath: collectionSlug || globalSlug
-            },
-            serverURL
+          }
         });
-        setInitialState(newState);
-        setData(newData);
-        await getDocPermissions(newData);
-    }, [
-        api,
-        collectionSlug,
-        getDocPreferences,
-        globalSlug,
-        id,
-        operation,
-        locale,
-        onSaveFromProps,
-        serverURL,
-        getDocPermissions
-    ]);
-    useEffect(()=>{
-        const abortController = new AbortController();
-        const localeChanged = locale !== prevLocale.current;
-        if (initialStateFromProps === undefined || initialDataFromProps === undefined || localeChanged) {
-            if (localeChanged) prevLocale.current = locale;
-            const getInitialState = async ()=>{
-                setIsError(false);
-                setIsLoading(true);
-                try {
-                    const result = await getFormState({
-                        apiRoute: api,
-                        body: {
-                            id,
-                            collectionSlug,
-                            globalSlug,
-                            locale,
-                            operation,
-                            schemaPath: collectionSlug || globalSlug
-                        },
-                        onError: onLoadError,
-                        serverURL,
-                        signal: abortController.signal
-                    });
-                    const data = reduceFieldsToValues(result, true);
-                    setData(data);
-                    if (localeChanged) void getDocPermissions(data);
-                    setInitialState(result);
-                } catch (err) {
-                    if (!abortController.signal.aborted) {
-                        if (typeof onLoadError === 'function') {
-                            void onLoadError();
-                        }
-                        setIsError(true);
-                        setIsLoading(false);
-                    }
-                }
-                setIsLoading(false);
-            };
-            void getInitialState();
-        }
-        return ()=>{
-            try {
-                abortController.abort();
-            } catch (error) {
-            // swallow error
-            }
-        };
-    }, [
-        api,
-        operation,
-        collectionSlug,
-        serverURL,
-        id,
-        globalSlug,
-        locale,
-        onLoadError,
-        initialDataFromProps,
-        initialStateFromProps,
-        getDocPermissions
-    ]);
-    useEffect(()=>{
-        void getVersions();
-    }, [
-        getVersions
-    ]);
-    useEffect(()=>{
-        setDocumentTitle(formatDocTitle({
-            collectionConfig,
-            data: {
-                ...data,
-                id
-            },
-            dateFormat,
-            fallback: id?.toString(),
-            globalConfig,
-            i18n
-        }));
-    }, [
-        collectionConfig,
-        data,
-        dateFormat,
-        i18n,
-        id,
-        globalConfig
-    ]);
-    useEffect(()=>{
-        if (data && (collectionSlug || globalSlug)) {
-            if (hasInitializedDocPermissions.current === false && (!docPermissions || hasSavePermission === undefined || hasSavePermission === null || hasPublishPermission === undefined || hasPublishPermission === null)) {
-                hasInitializedDocPermissions.current = true;
-                void getDocPermissions(data);
-            }
+      } catch (e) {
+        console.error(e) // eslint-disable-line no-console
+        ;
+      }
+    }
+  }, [setPreference, preferencesKey, getDocPreferences]);
+  const incrementVersionCount = useCallback(() => {
+    if (collectionConfig && collectionConfig.versions) {
+      setVersionCount(Math.min(versionCount + 1, collectionConfig.versions.maxPerDoc));
+    } else if (globalConfig && globalConfig.versions) {
+      setVersionCount(Math.min(versionCount + 1, globalConfig.versions.max));
+    }
+  }, [collectionConfig, globalConfig, versionCount]);
+  useEffect(() => {
+    setDocumentTitle(formatDocTitle({
+      collectionConfig,
+      data: {
+        ...data,
+        id
+      },
+      dateFormat,
+      fallback: id?.toString(),
+      globalConfig,
+      i18n
+    }));
+  }, [collectionConfig, globalConfig, data, dateFormat, i18n, id]);
+  // clean on unmount
+  useEffect(() => {
+    const re1 = abortControllerRef.current;
+    return () => {
+      if (re1) {
+        try {
+          re1.abort();
+        } catch (_err) {
+          // swallow error
         }
-    }, [
-        getDocPermissions,
-        docPermissionsFromProps,
-        hasSavePermissionFromProps,
-        hasPublishPermissionFromProps,
-        setDocPermissions,
-        collectionSlug,
-        globalSlug,
-        data,
-        docPermissions,
-        hasSavePermission,
-        hasPublishPermission
-    ]);
-    const action = React.useMemo(()=>{
-        const docURL = `${baseURL}${pluralType === 'globals' ? `/globals` : ''}/${slug}${id ? `/${id}` : ''}`;
-        const params = {
-            depth: 0,
-            'fallback-locale': 'null',
-            locale,
-            uploadEdits: uploadEdits || undefined
-        };
-        return `${docURL}${qs.stringify(params, {
-            addQueryPrefix: true
-        })}`;
-    }, [
-        baseURL,
-        locale,
-        pluralType,
-        id,
-        slug,
-        uploadEdits
-    ]);
-    if (isError) notFound();
-    const value = {
-        ...props,
-        action,
-        docConfig,
-        docPermissions,
-        getDocPermissions,
-        getDocPreferences,
-        getVersions,
-        hasPublishPermission,
-        hasSavePermission,
-        initialData: data,
-        initialState,
-        isInitializing,
-        isLoading,
-        onSave,
-        publishedDoc,
-        setDocFieldPreferences,
-        setDocumentTitle,
-        title: documentTitle,
-        unpublishedVersions,
-        versions
+      }
+    };
+  }, []);
+  const action = React.useMemo(() => {
+    const docURL = `${baseURL}${pluralType === 'globals' ? `/globals` : ''}/${slug}${id ? `/${id}` : ''}`;
+    const params = {
+      depth: 0,
+      'fallback-locale': 'null',
+      locale,
+      uploadEdits: uploadEdits || undefined
     };
-    return /*#__PURE__*/ _jsx(Context.Provider, {
-        value: value,
-        children: children
-    });
+    return `${docURL}${qs.stringify(params, {
+      addQueryPrefix: true
+    })}`;
+  }, [baseURL, locale, pluralType, id, slug, uploadEdits]);
+  const value = {
+    ...props,
+    action,
+    currentEditor,
+    docConfig,
+    docPermissions,
+    documentIsLocked,
+    getDocPermissions,
+    getDocPreferences,
+    hasPublishedDoc,
+    hasPublishPermission,
+    hasSavePermission,
+    incrementVersionCount,
+    initialData: data,
+    initialState,
+    isInitializing,
+    lastUpdateTime,
+    mostRecentVersionIsAutosaved,
+    preferencesKey,
+    setCurrentEditor,
+    setDocFieldPreferences,
+    setDocumentIsLocked,
+    setDocumentTitle,
+    setHasPublishedDoc,
+    setLastUpdateTime,
+    setMostRecentVersionIsAutosaved,
+    setUnpublishedVersionCount,
+    title: documentTitle,
+    unlockDocument,
+    unpublishedVersionCount,
+    updateDocumentEditor,
+    versionCount
+  };
+  return /*#__PURE__*/_jsx(Context.Provider, {
+    value: value,
+    children: children
+  });
 };
-export const DocumentInfoProvider = (props)=>{
-    return /*#__PURE__*/ _jsx(UploadEditsProvider, {
-        children: /*#__PURE__*/ _jsx(DocumentInfo, {
-            ...props
-        })
-    });
+export const DocumentInfoProvider = props => {
+  return /*#__PURE__*/_jsx(UploadEditsProvider, {
+    children: /*#__PURE__*/_jsx(DocumentInfo, {
+      ...props
+    })
+  });
 };
-
 //# sourceMappingURL=index.js.map