@contentful/field-editor-reference 5.19.0 → 5.20.0

package/dist/esm/common/EntityStore.js

@@ -12,10 +12,11 @@ function _define_property(obj, key, value) {
     return obj;
 }
 import React, { useCallback, useEffect, useMemo, useRef } from 'react';
-import { QueryCache, QueryClient, QueryClientProvider, useQuery, useQueryClient } from '@tanstack/react-query';
 import constate from 'constate';
 import { createClient } from 'contentful-management';
 import PQueue from 'p-queue';
+import { SharedQueryClientProvider, useQuery, useQueryClient } from './queryClient';
+// global queue for all requests, the actual number is picked without scientific research
 const globalQueue = new PQueue({
     concurrency: 50
 });
@@ -33,7 +34,8 @@ const isEntityQueryKey = (queryKey)=>{
     return Array.isArray(queryKey) && (queryKey[0] === 'Entry' || queryKey[0] === 'Asset') && queryKey.length === 4;
 };
 async function fetchContentfulEntry(params) {
-    const { urn , fetch , options  } = params;
+    const { urn, fetch, options } = params;
+    // TODO use resource-names package EntryResourceName `fromString` method instead when the package becomes public
     const resourceId = urn.split(':', 6)[5];
     const ENTITY_RESOURCE_ID_REGEX = RegExp("^spaces\\/(?<spaceId>[^/]+)(?:\\/environments\\/(?<environmentId>[^/]+))?\\/entries\\/(?<entityId>[^/]+)$");
     const resourceIdMatch = resourceId.match(ENTITY_RESOURCE_ID_REGEX);
@@ -47,7 +49,7 @@ async function fetchContentfulEntry(params) {
         fetch([
             'space',
             spaceId
-        ], ({ cmaClient  })=>cmaClient.space.get({
+        ], ({ cmaClient })=>cmaClient.space.get({
                 spaceId
             }), options),
         fetch([
@@ -55,7 +57,7 @@ async function fetchContentfulEntry(params) {
             spaceId,
             environmentId,
             entryId
-        ], ({ cmaClient  })=>cmaClient.entry.get({
+        ], ({ cmaClient })=>cmaClient.entry.get({
                 spaceId,
                 environmentId,
                 entryId
@@ -68,7 +70,7 @@ async function fetchContentfulEntry(params) {
             spaceId,
             environmentId,
             contentTypeId
-        ], ({ cmaClient  })=>cmaClient.contentType.get({
+        ], ({ cmaClient })=>cmaClient.contentType.get({
                 contentTypeId,
                 spaceId,
                 environmentId
@@ -77,7 +79,7 @@ async function fetchContentfulEntry(params) {
             'defaultLocale',
             spaceId,
             environmentId
-        ], async ({ cmaClient  })=>{
+        ], async ({ cmaClient })=>{
             const locales = await cmaClient.locale.getMany({
                 spaceId,
                 environmentId,
@@ -127,7 +129,7 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
         props.queryConcurrency
     ]);
     const fetch = useCallback(function fetch(queryKey, fn, options = {}) {
-        const { priority , ...queryOptions } = options;
+        const { priority, ...queryOptions } = options;
         return queryClient.fetchQuery(queryKey, ()=>queryQueue.add(()=>fn({
                     cmaClient
                 }), {
@@ -147,7 +149,8 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
             spaceId,
             environmentId
         ];
-        return fetch(queryKey, ({ cmaClient  })=>{
+        return fetch(queryKey, // @ts-expect-error
+        ({ cmaClient })=>{
             if (entityType === 'Entry') {
                 return cmaClient.entry.get({
                     entryId: entityId,
@@ -169,8 +172,18 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
         currentSpaceId,
         currentEnvironmentId
     ]);
-    const getEntityScheduledActions = useCallback(function getEntityScheduledActions(entityType, entityId, options) {
+    /**
+     * Fetch all scheduled actions for a given entity.
+     * This function fetches all schedules for all entries and then returns
+     * a filtered result based on the entityID provided.
+     *
+     * The result is then reused/cached for subsequent calls to this function.
+     */ const getEntityScheduledActions = useCallback(function getEntityScheduledActions(entityType, entityId, options) {
+        // This is fixed to force the cache to reuse previous results
         const fixedEntityCacheId = 'scheduledActionEntityId';
+        // A space+environment combo can only have up to 500 scheduled actions
+        // With this request we fetch all schedules and can reuse the results.
+        // See https://www.contentful.com/developers/docs/references/content-management-api/#/reference/scheduled-actions/limitations
         const maxScheduledActions = 500;
         const spaceId = options?.spaceId ?? currentSpaceId;
         const environmentId = options?.environmentId ?? currentEnvironmentId;
@@ -181,7 +194,8 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
             spaceId,
             environmentId
         ];
-        return fetch(queryKey, async ({ cmaClient  })=>{
+        // Fetch + Filter by entity ID in the end
+        return fetch(queryKey, async ({ cmaClient })=>{
             const response = await cmaClient.scheduledActions.getMany({
                 spaceId,
                 query: {
@@ -225,6 +239,7 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
         currentSpaceId,
         environmentIds
     ]);
+    // @ts-expect-error ...
     const onEntityChanged = props.sdk.space.onEntityChanged;
     const onSlideInNavigation = props.sdk.navigator.onSlideInNavigation;
     useEffect(()=>{
@@ -235,15 +250,16 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
             });
         }
         if (typeof onEntityChanged !== 'function') {
-            return onSlideInNavigation(({ oldSlideLevel , newSlideLevel  })=>{
+            return onSlideInNavigation(({ oldSlideLevel, newSlideLevel })=>{
                 if (oldSlideLevel > newSlideLevel) {
                     findSameSpaceQueries().forEach((query)=>{
+                        // automatically refetches the query
                         void queryClient.invalidateQueries(query.queryKey);
                     });
                 }
             });
         }
-        const subscribeQuery = ({ queryKey , queryHash  })=>{
+        const subscribeQuery = ({ queryKey, queryHash })=>{
             const [entityType, entityId] = queryKey;
             entityChangeUnsubscribers.current[queryHash] = onEntityChanged(entityType, entityId, (data)=>{
                 queryClient.setQueryData(queryKey, data);
@@ -254,8 +270,8 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
             if (!event) {
                 return;
             }
-            const { type , query  } = event;
-            const { queryKey , queryHash  } = query;
+            const { type, query } = event;
+            const { queryKey, queryHash } = query;
             if (!isSameSpaceEntityQueryKey(queryKey)) {
                 return;
             }
@@ -263,6 +279,7 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
                 subscribeQuery(query);
             }
             if (type === 'removed') {
+                // calling unsubscribe
                 entityChangeUnsubscribers.current[queryHash]?.();
             }
         });
@@ -287,24 +304,24 @@ const [InternalServiceProvider, useFetch, useEntityLoader, useCurrentIds] = cons
         getEntity,
         getEntityScheduledActions
     };
-}, ({ fetch  })=>fetch, ({ getResource , getEntity , getEntityScheduledActions  })=>({
+}, ({ fetch })=>fetch, ({ getResource, getEntity, getEntityScheduledActions })=>({
         getResource,
         getEntity,
         getEntityScheduledActions
-    }), ({ ids  })=>({
+    }), ({ ids })=>({
         environment: ids.environmentAlias ?? ids.environment,
         space: ids.space
     }));
 export function useEntity(entityType, entityId, options) {
-    const { space , environment  } = useCurrentIds();
-    const { getEntity  } = useEntityLoader();
+    const { space, environment } = useCurrentIds();
+    const { getEntity } = useEntityLoader();
     const queryKey = [
         entityType,
         entityId,
         options?.spaceId ?? space,
         options?.environmentId ?? environment
     ];
-    const { status , data  } = useQuery(queryKey, ()=>getEntity(entityType, entityId, options), {
+    const { status, data } = useQuery(queryKey, ()=>getEntity(entityType, entityId, options), {
         enabled: options?.enabled
     });
     return {
@@ -318,8 +335,8 @@ export function useResource(resourceType, urn, options) {
         resourceType,
         urn
     ];
-    const { getResource  } = useEntityLoader();
-    const { status , data , error  } = useQuery(queryKey, ()=>getResource(resourceType, urn, options), {
+    const { getResource } = useEntityLoader();
+    const { status, data, error } = useQuery(queryKey, ()=>getResource(resourceType, urn, options), {
         enabled: options?.enabled
     });
     return {
@@ -328,26 +345,7 @@ export function useResource(resourceType, urn, options) {
         error
     };
 }
-function EntityProvider({ children , ...props }) {
-    const reactQueryClient = useMemo(()=>{
-        const queryCache = new QueryCache();
-        const queryClient = new QueryClient({
-            queryCache,
-            defaultOptions: {
-                queries: {
-                    useErrorBoundary: false,
-                    refetchOnWindowFocus: false,
-                    refetchOnReconnect: true,
-                    refetchOnMount: false,
-                    staleTime: Infinity,
-                    retry: false
-                }
-            }
-        });
-        return queryClient;
-    }, []);
-    return React.createElement(QueryClientProvider, {
-        client: reactQueryClient
-    }, React.createElement(InternalServiceProvider, props, children));
+function EntityProvider({ children, ...props }) {
+    return /*#__PURE__*/ React.createElement(SharedQueryClientProvider, null, /*#__PURE__*/ React.createElement(InternalServiceProvider, props, children));
 }
 export { EntityProvider, useEntityLoader };

package/dist/esm/common/MultipleReferenceEditor.js

@@ -25,18 +25,24 @@ const nullableValue = {
     }
 };
 function Editor(props) {
-    const { setValue , entityType , onSortingEnd , setIndexToUpdate  } = props;
+    const { setValue, entityType, onSortingEnd, setIndexToUpdate } = props;
     const editorPermissions = useEditorPermissions(props);
     const items = React.useMemo(()=>{
-        return (props.items || []).map((link)=>link || nullableValue);
+        return (props.items || [])// If null values have found their way into the persisted
+        // value for the multiref field, replace them with an object
+        // that has the shape of a Link to make the missing entry/asset
+        // card render
+        .map((link)=>link || nullableValue);
     }, [
         props.items
     ]);
-    const { rearrangeSortIDs  } = useSortIDs(items);
+    const { rearrangeSortIDs } = useSortIDs(items);
     const onSortStart = useCallback(()=>{
         document.body.classList.add('grabbing');
     }, []);
-    const onSortEnd = useCallback(({ oldIndex , newIndex  })=>{
+    const onSortEnd = useCallback(({ oldIndex, newIndex })=>{
+        // custom callback that is invoked *before* we sort the array
+        // e.g. in Compose we want to sort the references in the referenceMap before re-rendering drag and drop
         onSortingEnd && onSortingEnd({
             oldIndex,
             newIndex
@@ -80,24 +86,25 @@ function Editor(props) {
         onLink,
         itemsLength: items.length
     });
-    const customCardRenderer = useCallback((cardProps, _, renderDefaultCard)=>props.renderCustomCard ? props.renderCustomCard(cardProps, linkActionsProps, renderDefaultCard) : false, [
+    const customCardRenderer = useCallback((cardProps, _, renderDefaultCard)=>props.renderCustomCard ? props.renderCustomCard(cardProps, linkActionsProps, renderDefaultCard) : false, // eslint-disable-next-line react-hooks/exhaustive-deps -- TODO: Evaluate the dependencies
+    [
         linkActionsProps
     ]);
-    return React.createElement(React.Fragment, null, props.children({
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, props.children({
         ...props,
         onSortStart,
         onSortEnd,
         onMove,
         renderCustomCard: props.renderCustomCard && customCardRenderer
-    }), React.createElement(LinkEntityActions, {
+    }), /*#__PURE__*/ React.createElement(LinkEntityActions, {
         renderCustomActions: props.renderCustomActions,
         ...linkActionsProps
     }));
 }
 export function MultipleReferenceEditor(props) {
     const allContentTypes = props.sdk.space.getCachedContentTypes();
-    return React.createElement(ReferenceEditor, props, ({ value , disabled , setValue , externalReset  })=>{
-        return React.createElement(Editor, {
+    return /*#__PURE__*/ React.createElement(ReferenceEditor, props, ({ value, disabled, setValue, externalReset })=>{
+        return /*#__PURE__*/ React.createElement(Editor, {
             ...props,
             items: value || emptyArray,
             isDisabled: disabled,

package/dist/esm/common/ReferenceEditor.js

@@ -3,9 +3,9 @@ import { FieldConnector } from '@contentful/field-editor-shared';
 import deepEqual from 'deep-equal';
 import { EntityProvider } from './EntityStore';
 export function ReferenceEditor(props) {
-    return React.createElement(EntityProvider, {
+    return /*#__PURE__*/ React.createElement(EntityProvider, {
         sdk: props.sdk
-    }, React.createElement(FieldConnector, {
+    }, /*#__PURE__*/ React.createElement(FieldConnector, {
         debounce: 0,
         field: props.sdk.field,
         isInitiallyDisabled: props.isInitiallyDisabled,

package/dist/esm/common/SingleReferenceEditor.js

@@ -5,7 +5,7 @@ import { useLinkActionsProps } from '../components/LinkActions/LinkEntityActions
 import { ReferenceEditor } from './ReferenceEditor';
 import { useEditorPermissions } from './useEditorPermissions';
 function Editor(props) {
-    const { setValue , entityType  } = props;
+    const { setValue, entityType } = props;
     const editorPermissions = useEditorPermissions(props);
     const onCreate = useCallback((id)=>void setValue({
             sys: {
@@ -37,11 +37,13 @@ function Editor(props) {
         onCreate,
         onLink
     });
-    const customCardRenderer = useCallback((cardProps, _, renderDefaultCard)=>props.renderCustomCard ? props.renderCustomCard(cardProps, linkActionsProps, renderDefaultCard) : false, [
+    // Inject card actions props into the given custom card renderer
+    const customCardRenderer = useCallback((cardProps, _, renderDefaultCard)=>props.renderCustomCard ? props.renderCustomCard(cardProps, linkActionsProps, renderDefaultCard) : false, // eslint-disable-next-line react-hooks/exhaustive-deps -- TODO: Evaluate the dependencies
+    [
         linkActionsProps
     ]);
     if (!props.entityId) {
-        return React.createElement(LinkEntityActions, {
+        return /*#__PURE__*/ React.createElement(LinkEntityActions, {
             renderCustomActions: props.renderCustomActions,
             ...linkActionsProps
         });
@@ -53,8 +55,8 @@ function Editor(props) {
 }
 export function SingleReferenceEditor(props) {
     const allContentTypes = props.sdk.space.getCachedContentTypes();
-    return React.createElement(ReferenceEditor, props, ({ value , setValue , disabled , externalReset  })=>{
-        return React.createElement(Editor, {
+    return /*#__PURE__*/ React.createElement(ReferenceEditor, props, ({ value, setValue, disabled, externalReset })=>{
+        return /*#__PURE__*/ React.createElement(Editor, {
             ...props,
             key: `${externalReset}-reference`,
             entityId: value ? value.sys.id : '',

package/dist/esm/common/SortableLinkList.js

@@ -20,8 +20,8 @@ const styles = {
         display: 'flex'
     })
 };
-const SortableLink = ({ id , items , item , isDisabled =false , index , children  })=>{
-    const { listeners , setNodeRef , setActivatorNodeRef , transform , transition , isDragging  } = useSortable({
+const SortableLink = ({ id, items, item, isDisabled = false, index, children })=>{
+    const { listeners, setNodeRef, setActivatorNodeRef, transform, transition, isDragging } = useSortable({
         id
     });
     const style = {
@@ -34,16 +34,16 @@ const SortableLink = ({ id , items , item , isDisabled =false , index , children
     };
     const DragHandle = React.useCallback((props)=>{
         const SortableDragHandle = ()=>props.drag;
-        return React.createElement("div", {
+        return /*#__PURE__*/ React.createElement("div", {
             ref: setActivatorNodeRef,
             className: styles.dragHandle,
             ...listeners
-        }, React.createElement(SortableDragHandle, null));
+        }, /*#__PURE__*/ React.createElement(SortableDragHandle, null));
     }, [
         listeners,
         setActivatorNodeRef
     ]);
-    return React.createElement("div", {
+    return /*#__PURE__*/ React.createElement("div", {
         ref: setNodeRef,
         style: style,
         className: cx(styles.item, {
@@ -57,8 +57,8 @@ const SortableLink = ({ id , items , item , isDisabled =false , index , children
         DragHandle: isDisabled ? undefined : DragHandle
     }));
 };
-export const SortableLinkList = ({ items , isDisabled , className , children , onSortStart , onSortEnd , updateBeforeSortStart , sortingStrategy  })=>{
-    const { sortIDs , rearrangeSortIDs  } = useSortIDs(items);
+export const SortableLinkList = ({ items, isDisabled, className, children, onSortStart, onSortEnd, updateBeforeSortStart, sortingStrategy })=>{
+    const { sortIDs, rearrangeSortIDs } = useSortIDs(items);
     const onSortStartHandler = React.useCallback((event)=>{
         const index = sortIDs.findIndex((item)=>item.id === event.active.id);
         updateBeforeSortStart?.({
@@ -71,7 +71,7 @@ export const SortableLinkList = ({ items , isDisabled , className , children , o
         sortIDs
     ]);
     const onSortEndHandler = React.useCallback((event)=>{
-        const { active , over  } = event;
+        const { active, over } = event;
         if (active && over && active.id !== over.id) {
             const oldIndex = sortIDs.findIndex((item)=>item.id === active.id);
             const newIndex = sortIDs.findIndex((item)=>item.id === over.id);
@@ -86,17 +86,17 @@ export const SortableLinkList = ({ items , isDisabled , className , children , o
         sortIDs,
         rearrangeSortIDs
     ]);
-    return React.createElement(DndContext, {
+    return /*#__PURE__*/ React.createElement(DndContext, {
         onDragStart: onSortStartHandler,
         onDragEnd: onSortEndHandler
-    }, React.createElement(SortableContext, {
+    }, /*#__PURE__*/ React.createElement(SortableContext, {
         items: sortIDs,
         strategy: sortingStrategy
-    }, React.createElement("div", {
+    }, /*#__PURE__*/ React.createElement("div", {
         className: cx(styles.container, className)
     }, items.map((item, index)=>{
         const id = sortIDs[index]?.id;
-        return React.createElement(SortableLink, {
+        return /*#__PURE__*/ React.createElement(SortableLink, {
             key: id,
             id: id,
             items: items,

package/dist/esm/common/queryClient.js

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import { QueryClient, useQuery as useRQ } from '@tanstack/react-query';
+/**
+ * A custom client context ensures zero conflict with host apps also using
+ * React Query.
+ */ const clientContext = /*#__PURE__*/ React.createContext(undefined);
+export function useQueryClient() {
+    const client = React.useContext(clientContext);
+    return React.useMemo(()=>{
+        if (client) {
+            return client;
+        }
+        return new QueryClient({
+            defaultOptions: {
+                queries: {
+                    useErrorBoundary: false,
+                    refetchOnWindowFocus: false,
+                    refetchOnReconnect: true,
+                    refetchOnMount: false,
+                    staleTime: Infinity,
+                    retry: false
+                }
+            }
+        });
+    }, [
+        client
+    ]);
+}
+// @ts-expect-error
+export const useQuery = (key, fn, opt)=>{
+    return useRQ(key, fn, {
+        ...opt,
+        context: clientContext
+    });
+};
+/**
+ * Provides access to a query client either by sharing an existing client or
+ * creating a new one.
+ */ export function SharedQueryClientProvider({ children }) {
+    const client = useQueryClient();
+    return /*#__PURE__*/ React.createElement(clientContext.Provider, {
+        value: client
+    }, children);
+}

package/dist/esm/common/useContentTypePermissions.js

@@ -1,6 +1,7 @@
 import { useEffect, useMemo, useState } from 'react';
 import { useAccessApi } from './useAccessApi';
 async function filter(arr, predicate) {
+    // intentionally parallel as we assume it's cached in the implementation of the access api
     const fail = Symbol();
     const results = await Promise.all(arr.map(async (item)=>await predicate(item) ? item : fail));
     return results.filter((x)=>x !== fail);
@@ -21,7 +22,7 @@ export function useContentTypePermissions(props) {
     ]);
     const [creatableContentTypes, setCreatableContentTypes] = useState(availableContentTypes);
     const [readableContentTypes, setReadableContentTypes] = useState(availableContentTypes);
-    const { canPerformActionOnEntryOfType  } = useAccessApi(props.sdk.access);
+    const { canPerformActionOnEntryOfType } = useAccessApi(props.sdk.access);
     useEffect(()=>{
         function getContentTypes(action) {
             return filter(availableContentTypes, (ct)=>canPerformActionOnEntryOfType(action, ct.sys.id));
@@ -33,6 +34,7 @@ export function useContentTypePermissions(props) {
             setReadableContentTypes(readable);
         }
         void checkContentTypeAccess();
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- TODO: Evaluate the dependencies
     }, [
         availableContentTypes
     ]);

package/dist/esm/common/useEditorPermissions.js

@@ -3,17 +3,17 @@ import { fromFieldValidations } from '../utils/fromFieldValidations';
 import { useAccessApi } from './useAccessApi';
 import { useContentTypePermissions } from './useContentTypePermissions';
 export function useEditorPermissions(props) {
-    const { sdk , entityType , parameters  } = props;
+    const { sdk, entityType, parameters } = props;
     const validations = useMemo(()=>fromFieldValidations(props.sdk.field), [
         props.sdk.field
     ]);
     const [canCreateEntity, setCanCreateEntity] = useState(true);
     const [canLinkEntity, setCanLinkEntity] = useState(true);
-    const { creatableContentTypes , readableContentTypes , availableContentTypes  } = useContentTypePermissions({
+    const { creatableContentTypes, readableContentTypes, availableContentTypes } = useContentTypePermissions({
         ...props,
         validations
     });
-    const { canPerformAction  } = useAccessApi(sdk.access);
+    const { canPerformAction } = useAccessApi(sdk.access);
     useEffect(()=>{
         if (parameters.instance.showCreateEntityAction === false) {
             setCanCreateEntity(false);
@@ -21,15 +21,20 @@ export function useEditorPermissions(props) {
         }
         async function checkCreateAccess() {
             if (entityType === 'Asset') {
+                // Hardcoded `true` value following https://contentful.atlassian.net/browse/DANTE-486
+                // TODO: refine permissions check in order to account for tags in rules
                 const canCreate = await canPerformAction('create', 'Asset') || true;
                 setCanCreateEntity(canCreate);
             }
             if (entityType === 'Entry') {
+                // Hardcoded `true` value following https://contentful.atlassian.net/browse/DANTE-486
+                // TODO: refine permissions check in order to account for tags in rules
                 const canCreate = creatableContentTypes.length > 0 || true;
                 setCanCreateEntity(canCreate);
             }
         }
         void checkCreateAccess();
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- TODO: Evaluate the dependencies
     }, [
         entityType,
         parameters.instance,
@@ -42,15 +47,22 @@ export function useEditorPermissions(props) {
         }
         async function checkLinkAccess() {
             if (entityType === 'Asset') {
+                // Hardcoded `true` value following https://contentful.atlassian.net/browse/DANTE-486
+                // TODO: refine permissions check in order to account for tags in rules
                 const canRead = await canPerformAction('read', 'Asset') || true;
                 setCanLinkEntity(canRead);
             }
             if (entityType === 'Entry') {
+                // Hardcoded `true` value following https://contentful.atlassian.net/browse/DANTE-486
+                // TODO: refine permissions check in order to account for tags in rules
+                // TODO: always show every content type (it's just a filter) to avoid people not seeing
+                // their (partly limited) content types
                 const canRead = true;
                 setCanLinkEntity(canRead);
             }
         }
         void checkLinkAccess();
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- TODO: Evaluate the dependencies
     }, [
         entityType,
         parameters.instance,

package/dist/esm/common/useEditorPermissions.spec.js

@@ -14,7 +14,7 @@ describe('useEditorPermissions', ()=>{
                 id
             }
         });
-    const renderEditorPermissions = async ({ entityType , params ={} , allContentTypes =[] , customizeMock , customizeSdk  })=>{
+    const renderEditorPermissions = async ({ entityType, params = {}, allContentTypes = [], customizeMock, customizeSdk })=>{
         const sdk = makeFieldAppSDK(customizeMock);
         customizeSdk?.(sdk);
         const renderResult = renderHook(()=>useEditorPermissions({
@@ -33,7 +33,7 @@ describe('useEditorPermissions', ()=>{
     };
     describe(`behaviour on Asset`, ()=>{
         it(`wont check access when turned off via instance params`, async ()=>{
-            const { result , sdk  } = await renderEditorPermissions({
+            const { result, sdk } = await renderEditorPermissions({
                 entityType: 'Asset',
                 params: {
                     showCreateEntityAction: false,
@@ -45,20 +45,20 @@ describe('useEditorPermissions', ()=>{
             expect(sdk.access.can).not.toHaveBeenCalledWith();
         });
         it(`checks basic access`, async ()=>{
-            const { sdk  } = await renderEditorPermissions({
+            const { sdk } = await renderEditorPermissions({
                 entityType: 'Asset'
             });
             expect(sdk.access.can).toHaveBeenCalledWith('create', 'Asset');
             expect(sdk.access.can).toHaveBeenCalledWith('read', 'Asset');
         });
         it(`defaults link asset action visibility to true`, async ()=>{
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Asset'
             });
             expect(result.current.canLinkEntity).toBeTruthy();
         });
         it(`returns empty contentTypes`, async ()=>{
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Asset',
                 allContentTypes: [
                     makeContentType('one')
@@ -78,7 +78,7 @@ describe('useEditorPermissions', ()=>{
             });
         };
         it(`wont check access when turned off via instance params`, async ()=>{
-            const { result , sdk  } = await renderEditorPermissions({
+            const { result, sdk } = await renderEditorPermissions({
                 entityType: 'Entry',
                 params: {
                     showCreateEntityAction: false,
@@ -94,7 +94,7 @@ describe('useEditorPermissions', ()=>{
                 makeContentType('one'),
                 makeContentType('two')
             ];
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Entry',
                 allContentTypes,
                 customizeSdk: (sdk)=>{
@@ -108,7 +108,7 @@ describe('useEditorPermissions', ()=>{
                 makeContentType('one'),
                 makeContentType('two')
             ];
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Entry',
                 allContentTypes,
                 customizeSdk: (sdk)=>{
@@ -122,7 +122,7 @@ describe('useEditorPermissions', ()=>{
                 makeContentType('one'),
                 makeContentType('two')
             ];
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Entry',
                 allContentTypes,
                 customizeSdk: (sdk)=>{
@@ -131,12 +131,13 @@ describe('useEditorPermissions', ()=>{
             });
             expect(result.current.canLinkEntity).toBe(true);
         });
+        // eslint-disable-next-line -- TODO: describe this disable  jest/no-test-prefixes
         it.skip(`denies creation when no content-type can be read`, async ()=>{
             const allContentTypes = [
                 makeContentType('one'),
                 makeContentType('two')
             ];
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Entry',
                 allContentTypes,
                 customizeSdk: (sdk)=>{
@@ -150,7 +151,7 @@ describe('useEditorPermissions', ()=>{
                 makeContentType('one'),
                 makeContentType('two')
             ];
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Entry',
                 allContentTypes,
                 customizeMock: (field)=>{
@@ -176,7 +177,7 @@ describe('useEditorPermissions', ()=>{
                 makeContentType('one'),
                 makeContentType('two')
             ];
-            const { result  } = await renderEditorPermissions({
+            const { result } = await renderEditorPermissions({
                 entityType: 'Entry',
                 allContentTypes,
                 customizeMock: (field)=>{

package/dist/esm/components/AssetThumbnail/AssetThumbnail.js

@@ -4,7 +4,7 @@ const dimensions = {
     height: 70
 };
 export function AssetThumbnail(props) {
-    return React.createElement("img", {
+    return /*#__PURE__*/ React.createElement("img", {
         alt: props.file.fileName,
         src: `${props.file.url}?w=${dimensions.width}&h=${dimensions.height}&fit=thumb`,
         height: dimensions.height,