@contentful/field-editor-reference 5.9.0 → 5.11.0

package/dist/cjs/components/CreateEntryLinkButton/CreateEntryMenuTrigger.spec.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+require("@testing-library/jest-dom/extend-expect");
+const _react1 = require("@testing-library/react");
+const _noop = _interop_require_default(require("lodash/noop"));
+const _fill = _interop_require_default(require("lodash/fill"));
+const _CreateEntryMenuTrigger = require("./CreateEntryMenuTrigger");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+(0, _react1.configure)({
+    testIdAttribute: 'data-test-id'
+});
+const CONTENT_TYPE_1 = {
+    name: 'name-1',
+    sys: {
+        id: 'ID_1'
+    }
+};
+const CONTENT_TYPE_2 = {
+    name: 'name-2',
+    sys: {
+        id: 'ID_2'
+    }
+};
+const CONTENT_TYPE_3 = {
+    name: 'name-3',
+    sys: {
+        id: 'ID_3'
+    }
+};
+describe('CreateEntryMenuTrigger general', ()=>{
+    const props = {
+        contentTypes: [
+            CONTENT_TYPE_1,
+            CONTENT_TYPE_2,
+            CONTENT_TYPE_3
+        ],
+        onSelect: ()=>{
+            return Promise.resolve();
+        }
+    };
+    let stub = jest.fn();
+    beforeEach(()=>{
+        stub = jest.fn().mockImplementation(()=>_react.createElement(_f36components.Button, {
+                testId: "menu-trigger"
+            }));
+    });
+    it('shares the state and functions for the menu', ()=>{
+        const stub = (api)=>{
+            expect(api.isOpen).toBe(false);
+            expect(api.isSelecting).toBe(false);
+            return _react.createElement("span", null);
+        };
+        (0, _react1.render)(_react.createElement(_CreateEntryMenuTrigger.CreateEntryMenuTrigger, props, stub));
+    });
+    it('should set isSelecting to true in case onSelect returns a promise', async ()=>{
+        const selectStub = jest.fn(()=>new Promise((resolve)=>setTimeout(resolve, 1000)));
+        const { getAllByTestId , getByTestId  } = (0, _react1.render)(_react.createElement(_CreateEntryMenuTrigger.CreateEntryMenuTrigger, {
+            ...props,
+            onSelect: selectStub
+        }, stub));
+        (0, _react1.act)(()=>{
+            _react1.fireEvent.click(getByTestId('menu-trigger'));
+        });
+        (0, _react1.act)(()=>{
+            _react1.fireEvent.click(getAllByTestId('contentType')[0]);
+        });
+        expect(selectStub).toHaveBeenCalled();
+    });
+    it('should not set isSelecting to true in case onSelect is sync', async ()=>{
+        const selectStub = jest.fn();
+        const { getAllByTestId , getByTestId  } = (0, _react1.render)(_react.createElement(_CreateEntryMenuTrigger.CreateEntryMenuTrigger, {
+            ...props,
+            onSelect: selectStub
+        }, stub));
+        (0, _react1.act)(()=>{
+            _react1.fireEvent.click(getByTestId('menu-trigger'));
+        });
+        (0, _react1.act)(()=>{
+            _react1.fireEvent.click(getAllByTestId('contentType')[0]);
+        });
+        expect(stub).toHaveBeenLastCalledWith({
+            isOpen: false,
+            isSelecting: false
+        });
+        expect(selectStub).toHaveBeenCalled();
+    });
+    it('renders text input if contentTypes.length > 20', ()=>{
+        const { getByTestId  } = (0, _react1.render)(_react.createElement(_CreateEntryMenuTrigger.CreateEntryMenuTrigger, {
+            ...props,
+            contentTypes: (0, _fill.default)(Array(21), CONTENT_TYPE_3)
+        }, stub));
+        (0, _react1.act)(()=>{
+            _react1.fireEvent.click(getByTestId('menu-trigger'));
+        });
+        expect(getByTestId('add-entry-menu-search')).toBeDefined();
+    });
+    it('shows the search results if typed in input', ()=>{
+        const contentTypes = (0, _fill.default)((0, _fill.default)((0, _fill.default)(Array(21), CONTENT_TYPE_1, 0, 10), CONTENT_TYPE_2, 10, 20), CONTENT_TYPE_3, 20);
+        const { getByTestId , getAllByTestId  } = (0, _react1.render)(_react.createElement(_CreateEntryMenuTrigger.CreateEntryMenuTrigger, {
+            ...props,
+            contentTypes: contentTypes
+        }, stub));
+        (0, _react1.act)(()=>{
+            _react1.fireEvent.click(getByTestId('menu-trigger'));
+        });
+        const input = getByTestId('add-entry-menu-search');
+        _react1.fireEvent.change(input, {
+            target: {
+                value: '1'
+            },
+            preventDefault: _noop.default
+        });
+        expect(getAllByTestId('contentType')).toHaveLength(10);
+        expect(getByTestId('add-entru-menu-search-results').textContent).toBe('10 results');
+        _react1.fireEvent.change(input, {
+            target: {
+                value: '3'
+            },
+            preventDefault: _noop.default
+        });
+        expect(getAllByTestId('contentType')).toHaveLength(1);
+        expect(getByTestId('add-entru-menu-search-results').textContent).toBe('1 result');
+        _react1.fireEvent.change(input, {
+            target: {
+                value: '4'
+            },
+            preventDefault: _noop.default
+        });
+        expect(getByTestId('add-entru-menu-search-results').textContent).toBe('No results found');
+    });
+    it('shows suggestedContentType in the list', ()=>{
+        const { getByTestId  } = (0, _react1.render)(_react.createElement(_CreateEntryMenuTrigger.CreateEntryMenuTrigger, {
+            ...props,
+            suggestedContentTypeId: props.contentTypes[0].sys.id
+        }, stub));
+        (0, _react1.act)(()=>{
+            _react1.fireEvent.click(getByTestId('menu-trigger'));
+        });
+        const suggestedContentType = getByTestId('suggested');
+        expect(suggestedContentType).toBeDefined();
+        expect(suggestedContentType.textContent).toBe(props.contentTypes[0].name);
+    });
+});

package/dist/cjs/components/CreateEntryLinkButton/useGlobalMouseUp.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useGlobalMouseUp", {
+    enumerable: true,
+    get: function() {
+        return useGlobalMouseUp;
+    }
+});
+const _react = require("react");
+const useGlobalMouseUp = (handler)=>{
+    (0, _react.useEffect)(()=>{
+        document.addEventListener('mouseup', handler);
+        return ()=>document.removeEventListener('mouseup', handler);
+    }, [
+        handler
+    ]);
+};

package/dist/cjs/components/LinkActions/CombinedLinkActions.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CombinedLinkActions", {
+    enumerable: true,
+    get: function() {
+        return CombinedLinkActions;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+const _f36icons = require("@contentful/f36-icons");
+const _CreateEntryLinkButton = require("../CreateEntryLinkButton/CreateEntryLinkButton");
+const _LinkActions = require("./LinkActions");
+const _NoLinkPermissionsInfo = require("./NoLinkPermissionsInfo");
+const _redesignStyles = _interop_require_wildcard(require("./redesignStyles"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const testIds = {
+    ..._LinkActions.testIds,
+    actionsWrapper: 'link-actions-menu-trigger'
+};
+function CombinedLinkActions(props) {
+    if (props.isFull) {
+        return null;
+    }
+    const hideEmptyCard = props.entityType === 'Asset' && !props.isEmpty;
+    return _react.createElement("div", {
+        className: hideEmptyCard ? '' : _redesignStyles.container
+    }, !props.canCreateEntity && !props.canLinkEntity && _react.createElement(_NoLinkPermissionsInfo.NoLinkPermissionsInfo, null), props.entityType === 'Entry' && _react.createElement(CombinedEntryLinkActions, props), props.entityType === 'Asset' && _react.createElement(CombinedAssetLinkActions, props));
+}
+function CombinedEntryLinkActions(props) {
+    if (props.canCreateEntity) {
+        return _react.createElement(_CreateEntryLinkButton.CreateEntryLinkButton, {
+            testId: testIds.actionsWrapper,
+            disabled: props.isDisabled,
+            text: props.combinedActionsLabel || 'Add content',
+            contentTypes: props.contentTypes,
+            hasPlusIcon: true,
+            useExperimentalStyles: true,
+            dropdownSettings: {
+                position: 'bottom-left'
+            },
+            onSelect: (contentTypeId)=>{
+                return contentTypeId ? props.onCreate(contentTypeId) : Promise.resolve();
+            },
+            customDropdownItems: props.canLinkEntity ? _react.createElement(_f36components.Menu.Item, {
+                testId: testIds.linkExisting,
+                onClick: ()=>{
+                    props.onLinkExisting();
+                }
+            }, "Add existing content") : undefined
+        });
+    } else if (props.canLinkEntity) {
+        return _react.createElement(_f36components.Button, {
+            isDisabled: props.isDisabled,
+            testId: testIds.linkExisting,
+            className: _redesignStyles.action,
+            onClick: ()=>{
+                props.onLinkExisting();
+            },
+            variant: "secondary",
+            startIcon: _react.createElement(_f36icons.LinkIcon, null),
+            size: "small"
+        }, "Add existing content");
+    }
+    return null;
+}
+function CombinedAssetLinkActions(props) {
+    const [isOpen, setOpen] = _react.useState(false);
+    if (!props.canLinkEntity || !props.canCreateEntity) {
+        if (props.canLinkEntity) {
+            return _react.createElement(_f36components.Button, {
+                isDisabled: props.isDisabled,
+                testId: testIds.linkExisting,
+                className: _redesignStyles.action,
+                onClick: ()=>{
+                    props.onLinkExisting();
+                },
+                variant: "secondary",
+                startIcon: _react.createElement(_f36icons.PlusIcon, null),
+                size: "small"
+            }, "Add existing media");
+        }
+        if (props.canCreateEntity) {
+            return _react.createElement(_f36components.Button, {
+                isDisabled: props.isDisabled,
+                testId: testIds.createAndLink,
+                className: _redesignStyles.action,
+                onClick: ()=>{
+                    props.onCreate();
+                },
+                variant: "secondary",
+                startIcon: _react.createElement(_f36icons.PlusIcon, null),
+                size: "small"
+            }, "Add media");
+        }
+        return null;
+    }
+    return _react.createElement(_f36components.Menu, {
+        isOpen: isOpen,
+        onClose: ()=>{
+            setOpen(false);
+        },
+        onOpen: ()=>{
+            setOpen(true);
+        }
+    }, _react.createElement(_f36components.Menu.Trigger, null, _react.createElement(_f36components.Button, {
+        endIcon: _react.createElement(_f36icons.ChevronDownIcon, null),
+        isDisabled: props.isDisabled,
+        testId: testIds.actionsWrapper,
+        className: _redesignStyles.action,
+        variant: "secondary",
+        startIcon: _react.createElement(_f36icons.PlusIcon, null),
+        size: "small"
+    }, "Add media")), isOpen && _react.createElement(_f36components.Menu.List, {
+        testId: testIds.dropdown
+    }, _react.createElement(_f36components.Menu.Item, {
+        testId: testIds.linkExisting,
+        onClick: ()=>{
+            props.onLinkExisting();
+        }
+    }, "Add existing media"), _react.createElement(_f36components.Menu.Item, {
+        testId: testIds.createAndLink,
+        onClick: ()=>{
+            props.onCreate();
+        }
+    }, "Add new media")));
+}

package/dist/cjs/components/LinkActions/LinkActions.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    testIds: function() {
+        return testIds;
+    },
+    LinkActions: function() {
+        return LinkActions;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+const _f36icons = require("@contentful/f36-icons");
+const _CreateEntryLinkButton = require("../CreateEntryLinkButton/CreateEntryLinkButton");
+const _NoLinkPermissionsInfo = require("./NoLinkPermissionsInfo");
+const _styles = _interop_require_wildcard(require("./styles"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const defaultEntryLabels = {
+    createNew: (props)=>props?.contentType ? `Create new ${props.contentType} and link` : 'Create new entry and link',
+    linkExisting: (props)=>props?.canLinkMultiple ? 'Link existing entries' : 'Link existing entry'
+};
+const defaultAssetLabels = {
+    createNew: ()=>`Create new asset and link`,
+    linkExisting: (props)=>props?.canLinkMultiple ? 'Link existing assets' : 'Link existing asset'
+};
+const testIds = {
+    dropdown: 'linkEditor.dropdown',
+    createAndLink: 'linkEditor.createAndLink',
+    createAndLinkWrapper: 'create-entry-button-menu-trigger',
+    linkExisting: 'linkEditor.linkExisting'
+};
+function LinkActions(props) {
+    if (props.isFull) {
+        return null;
+    }
+    const defaultLabels = props.entityType === 'Entry' ? defaultEntryLabels : defaultAssetLabels;
+    const labels = {
+        ...defaultLabels,
+        ...props.actionLabels
+    };
+    return _react.createElement("div", {
+        className: _styles.container
+    }, props.canCreateEntity && _react.createElement(_react.Fragment, null, props.entityType === 'Entry' && _react.createElement(_CreateEntryLinkButton.CreateEntryLinkButton, {
+        testId: testIds.createAndLink,
+        disabled: props.isDisabled,
+        text: labels.createNew({
+            contentType: props.contentTypes.length === 1 ? props.contentTypes[0].name : undefined
+        }),
+        contentTypes: props.contentTypes,
+        hasPlusIcon: true,
+        onSelect: (contentTypeId)=>{
+            return contentTypeId ? props.onCreate(contentTypeId, props.itemsLength) : Promise.resolve();
+        }
+    }), props.entityType === 'Asset' && _react.createElement(_f36components.Button, {
+        isDisabled: props.isDisabled,
+        testId: testIds.createAndLink,
+        onClick: ()=>{
+            props.onCreate(undefined, props.itemsLength);
+        },
+        variant: "secondary",
+        startIcon: _react.createElement(_f36icons.PlusIcon, null),
+        size: "small"
+    }, labels.createNew()), _react.createElement("span", {
+        className: _styles.separator
+    })), props.canLinkEntity && _react.createElement(_f36components.Button, {
+        isDisabled: props.isDisabled,
+        testId: testIds.linkExisting,
+        onClick: ()=>{
+            props.onLinkExisting();
+        },
+        variant: "secondary",
+        startIcon: _react.createElement(_f36icons.LinkIcon, null),
+        size: "small"
+    }, labels.linkExisting({
+        canLinkMultiple: props.canLinkMultiple
+    })), !props.canCreateEntity && !props.canLinkEntity && _react.createElement(_NoLinkPermissionsInfo.NoLinkPermissionsInfo, null));
+}

package/dist/cjs/components/LinkActions/LinkEntityActions.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useLinkActionsProps: function() {
+        return useLinkActionsProps;
+    },
+    LinkEntityActions: function() {
+        return LinkEntityActions;
+    },
+    CombinedLinkEntityActions: function() {
+        return CombinedLinkEntityActions;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _CombinedLinkActions = require("./CombinedLinkActions");
+const _helpers = require("./helpers");
+const _LinkActions = require("./LinkActions");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function useLinkActionsProps(props) {
+    const { sdk , editorPermissions , entityType , canLinkMultiple , isDisabled , actionLabels , itemsLength  } = props;
+    const maxLinksCount = editorPermissions.validations.numberOfLinks?.max;
+    const value = sdk.field.getValue();
+    const linkCount = Array.isArray(value) ? value.length : value ? 1 : 0;
+    const isFull = !!maxLinksCount && maxLinksCount <= linkCount;
+    const isEmpty = linkCount === 0;
+    const onCreated = _react.useCallback((entity, index = itemsLength, slide)=>{
+        props.onCreate(entity.sys.id, index);
+        props.onAction && props.onAction({
+            type: 'create_and_link',
+            entity: entityType,
+            entityData: entity,
+            slide,
+            index
+        });
+    }, [
+        entityType,
+        props.onCreate,
+        props.onAction
+    ]);
+    const onLinkedExisting = _react.useCallback((entities, index = itemsLength)=>{
+        props.onLink(entities.map((item)=>item.sys.id), index);
+        entities.forEach((entity, i)=>{
+            props.onAction && props.onAction({
+                type: 'select_and_link',
+                entity: entityType,
+                entityData: entity,
+                index: index === undefined ? undefined : index + i
+            });
+        });
+    }, [
+        entityType,
+        props.onLink,
+        props.onAction
+    ]);
+    const onCreate = _react.useCallback(async (contentTypeId, index)=>{
+        const { entity , slide  } = await (0, _helpers.createEntity)({
+            sdk,
+            entityType,
+            contentTypeId
+        });
+        if (!entity) {
+            return;
+        }
+        onCreated(entity, index, slide);
+    }, [
+        sdk,
+        entityType,
+        onCreated
+    ]);
+    const onLinkExisting = _react.useCallback(async (index)=>{
+        const entity = await (0, _helpers.selectSingleEntity)({
+            sdk,
+            entityType,
+            editorPermissions
+        });
+        if (!entity) {
+            return;
+        }
+        onLinkedExisting([
+            entity
+        ], index);
+    }, [
+        sdk,
+        entityType,
+        onLinkedExisting
+    ]);
+    const onLinkSeveralExisting = _react.useCallback(async (index)=>{
+        const entities = await (0, _helpers.selectMultipleEntities)({
+            sdk,
+            entityType,
+            editorPermissions
+        });
+        if (!entities || entities.length === 0) {
+            return;
+        }
+        onLinkedExisting(entities, index);
+    }, [
+        sdk,
+        entityType,
+        onLinkedExisting
+    ]);
+    return (0, _react.useMemo)(()=>({
+            entityType,
+            canLinkMultiple,
+            isDisabled,
+            isEmpty,
+            isFull,
+            canCreateEntity: editorPermissions.canCreateEntity,
+            canLinkEntity: editorPermissions.canLinkEntity,
+            contentTypes: editorPermissions.creatableContentTypes,
+            onCreate,
+            onLinkExisting: canLinkMultiple ? onLinkSeveralExisting : onLinkExisting,
+            actionLabels,
+            onCreated,
+            onLinkedExisting,
+            itemsLength
+        }), [
+        entityType,
+        canLinkMultiple,
+        isDisabled,
+        isEmpty,
+        isFull,
+        editorPermissions.canCreateEntity,
+        editorPermissions.canLinkEntity,
+        actionLabels,
+        editorPermissions.creatableContentTypes.map((ct)=>ct.sys.id).join(':'),
+        onCreate,
+        onLinkExisting,
+        onLinkSeveralExisting,
+        onCreated,
+        onLinkedExisting,
+        itemsLength
+    ]);
+}
+function LinkEntityActions({ renderCustomActions , ...props }) {
+    return renderCustomActions ? renderCustomActions(props) : _react.createElement(_LinkActions.LinkActions, props);
+}
+function CombinedLinkEntityActions({ renderCustomActions , ...props }) {
+    return renderCustomActions ? renderCustomActions(props) : _react.createElement(_CombinedLinkActions.CombinedLinkActions, props);
+}