@contentful/field-editor-rich-text 3.4.22 → 3.6.0

package/dist/cjs/plugins/Tracking/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createTrackingPlugin"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/plugins/Tracking/utils.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCharacterCount", {
+    enumerable: true,
+    get: function() {
+        return getCharacterCount;
+    }
+});
+const _contentfulslatejsadapter = _interop_require_wildcard(require("@contentful/contentful-slatejs-adapter"));
+const _richtextplaintextrenderer = require("@contentful/rich-text-plain-text-renderer");
+const _Schema = _interop_require_default(require("../../constants/Schema"));
+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;
+}
+function getCharacterCount(editor) {
+    const document = _contentfulslatejsadapter.toContentfulDocument({
+        document: editor.children,
+        schema: _Schema.default
+    });
+    return (0, _richtextplaintextrenderer.documentToPlainTextString)(document).length;
+}

package/dist/cjs/plugins/TrailingParagraph/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTrailingParagraphPlugin", {
+    enumerable: true,
+    get: function() {
+        return createTrailingParagraphPlugin;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetrailingblock = require("@udecode/plate-trailing-block");
+const createTrailingParagraphPlugin = ()=>{
+    return (0, _platetrailingblock.createTrailingBlockPlugin)({
+        options: {
+            type: _richtexttypes.BLOCKS.PARAGRAPH,
+            level: 0
+        }
+    });
+};

package/dist/cjs/plugins/Voids/createVoidsPlugin.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createVoidsPlugin", {
+    enumerable: true,
+    get: function() {
+        return createVoidsPlugin;
+    }
+});
+const _editor = require("../../helpers/editor");
+const _queries = require("../../internal/queries");
+const createVoidsPlugin = ()=>({
+        key: 'VoidsPlugin',
+        exitBreak: [
+            {
+                hotkey: 'enter',
+                before: true,
+                query: {
+                    filter: ([node, path])=>(0, _editor.isRootLevel)(path) && (0, _queries.isFirstChildPath)(path) && !!node.isVoid
+                }
+            },
+            {
+                hotkey: 'enter',
+                level: -2,
+                query: {
+                    filter: ([node, path])=>!((0, _editor.isRootLevel)(path) && (0, _queries.isFirstChildPath)(path)) && !!node.isVoid
+                }
+            }
+        ]
+    });

package/dist/cjs/plugins/Voids/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createVoidsPlugin"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/plugins/Voids/transformVoid.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "transformVoid", {
+    enumerable: true,
+    get: function() {
+        return transformVoid;
+    }
+});
+const _transforms = require("../../internal/transforms");
+const transformVoid = (editor, [node, path])=>{
+    const validVoid = {
+        ...node,
+        children: [
+            {
+                text: ''
+            }
+        ]
+    };
+    (0, _transforms.removeNodes)(editor, {
+        at: path
+    });
+    (0, _transforms.insertNodes)(editor, [
+        validVoid
+    ], {
+        at: path
+    });
+};

package/dist/cjs/plugins/index.js

@@ -0,0 +1,78 @@
+"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, {
+    getPlugins: function() {
+        return getPlugins;
+    },
+    disableCorePlugins: function() {
+        return disableCorePlugins;
+    }
+});
+const _platecore = require("@udecode/plate-core");
+const _plateserializerdocx = require("@udecode/plate-serializer-docx");
+const _Break = require("./Break");
+const _CommandPalette = require("./CommandPalette");
+const _useCommands = require("./CommandPalette/useCommands");
+const _DragAndDrop = require("./DragAndDrop");
+const _EmbeddedEntityBlock = require("./EmbeddedEntityBlock");
+const _EmbeddedEntityInline = require("./EmbeddedEntityInline");
+const _EmbeddedResourceBlock = require("./EmbeddedResourceBlock");
+const _Heading = require("./Heading");
+const _Hr = require("./Hr");
+const _Hyperlink = require("./Hyperlink");
+const _List = require("./List");
+const _Marks = require("./Marks");
+const _Normalizer = require("./Normalizer");
+const _Paragraph = require("./Paragraph");
+const _PasteHTML = require("./PasteHTML");
+const _Quote = require("./Quote");
+const _SelectOnBackspace = require("./SelectOnBackspace");
+const _Table = require("./Table");
+const _Text = require("./Text");
+const _Tracking = require("./Tracking");
+const _TrailingParagraph = require("./TrailingParagraph");
+const _Voids = require("./Voids");
+const getPlugins = (sdk, onAction, restrictedMarks)=>[
+        (0, _platecore.createDeserializeHtmlPlugin)(),
+        (0, _platecore.createDeserializeAstPlugin)(),
+        (0, _plateserializerdocx.createDeserializeDocxPlugin)(),
+        (0, _Tracking.createTrackingPlugin)(onAction),
+        (0, _DragAndDrop.createDragAndDropPlugin)(),
+        ...Object.values((0, _useCommands.isCommandPromptPluginEnabled)(sdk)).some(Boolean) ? [
+            (0, _CommandPalette.createCommandPalettePlugin)()
+        ] : [],
+        (0, _Paragraph.createParagraphPlugin)(),
+        (0, _List.createListPlugin)(),
+        (0, _Hr.createHrPlugin)(),
+        (0, _Heading.createHeadingPlugin)(),
+        (0, _Quote.createQuotePlugin)(),
+        (0, _Table.createTablePlugin)(),
+        (0, _EmbeddedEntityBlock.createEmbeddedEntryBlockPlugin)(sdk),
+        (0, _EmbeddedEntityBlock.createEmbeddedAssetBlockPlugin)(sdk),
+        (0, _EmbeddedResourceBlock.createEmbeddedResourceBlockPlugin)(sdk),
+        (0, _Hyperlink.createHyperlinkPlugin)(sdk),
+        (0, _EmbeddedEntityInline.createEmbeddedEntityInlinePlugin)(sdk),
+        (0, _Marks.createMarksPlugin)(),
+        (0, _TrailingParagraph.createTrailingParagraphPlugin)(),
+        (0, _Text.createTextPlugin)(restrictedMarks),
+        (0, _Voids.createVoidsPlugin)(),
+        (0, _SelectOnBackspace.createSelectOnBackspacePlugin)(),
+        (0, _PasteHTML.createPasteHTMLPlugin)(),
+        (0, _Break.createSoftBreakPlugin)(),
+        (0, _Break.createExitBreakPlugin)(),
+        (0, _Break.createResetNodePlugin)(),
+        (0, _Normalizer.createNormalizerPlugin)()
+    ];
+const disableCorePlugins = {
+    deserializeAst: true,
+    deserializeHtml: true,
+    eventEditor: true
+};

package/dist/cjs/plugins/links-tracking.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useLinkTracking", {
+    enumerable: true,
+    get: function() {
+        return useLinkTracking;
+    }
+});
+const _react = require("react");
+const _ContentfulEditorProvider = require("../ContentfulEditorProvider");
+function useLinkTracking() {
+    const editor = (0, _ContentfulEditorProvider.useContentfulEditorRef)();
+    return {
+        onEntityFetchComplete: (0, _react.useCallback)(()=>editor?.tracking.onViewportAction('linkRendered'), [
+            editor
+        ])
+    };
+}

package/dist/cjs/plugins/shared/EmbeddedBlockToolbarIcon.js

@@ -0,0 +1,114 @@
+"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, {
+    styles: function() {
+        return styles;
+    },
+    EmbeddedBlockToolbarIcon: function() {
+        return EmbeddedBlockToolbarIcon;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+const _f36icons = require("@contentful/f36-icons");
+const _richtexttypes = require("@contentful/rich-text-types");
+const _emotion = require("emotion");
+const _ContentfulEditorProvider = require("../../ContentfulEditorProvider");
+const _SdkProvider = require("../../SdkProvider");
+const _EmbeddedBlockUtil = require("../shared/EmbeddedBlockUtil");
+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 styles = {
+    icon: (0, _emotion.css)({
+        marginRight: '10px'
+    })
+};
+function EmbeddedBlockToolbarIcon({ isDisabled , nodeType , onClose  }) {
+    const editor = (0, _ContentfulEditorProvider.useContentfulEditor)();
+    const sdk = (0, _SdkProvider.useSdkContext)();
+    const handleClick = async (event)=>{
+        event.preventDefault();
+        if (!editor) {
+            return;
+        }
+        onClose();
+        if (nodeType == _richtexttypes.BLOCKS.EMBEDDED_RESOURCE) {
+            await (0, _EmbeddedBlockUtil.selectResourceEntityAndInsert)(sdk, editor, editor.tracking.onToolbarAction);
+        } else {
+            await (0, _EmbeddedBlockUtil.selectEntityAndInsert)(nodeType, sdk, editor, editor.tracking.onToolbarAction);
+        }
+    };
+    const type = getEntityTypeFromNodeType(nodeType);
+    const baseClass = `rich-text__${nodeType}`;
+    return _react.createElement(_f36components.Menu.Item, {
+        disabled: isDisabled,
+        className: `${baseClass}-list-item`,
+        onClick: handleClick,
+        testId: `toolbar-toggle-${nodeType}`
+    }, _react.createElement(_f36components.Flex, {
+        alignItems: "center",
+        flexDirection: "row"
+    }, _react.createElement(_f36components.Icon, {
+        as: type === 'Asset' ? _f36icons.AssetIcon : _f36icons.EmbeddedEntryBlockIcon,
+        className: `rich-text__embedded-entry-list-icon ${styles.icon}`,
+        variant: "secondary"
+    }), _react.createElement("span", null, type, nodeType == _richtexttypes.BLOCKS.EMBEDDED_RESOURCE && _react.createElement(_react.Fragment, null, ' ', "(different space)", ' ', _react.createElement(_f36components.Badge, {
+        variant: "primary-filled",
+        size: "small"
+    }, "new")))));
+}
+function getEntityTypeFromNodeType(nodeType) {
+    const words = nodeType.toLowerCase().split('-');
+    if (words.includes('entry') || words.includes('resource')) {
+        return 'Entry';
+    }
+    if (words.includes('asset')) {
+        return 'Asset';
+    }
+    throw new Error(`Node type \`${nodeType}\` has no associated \`entityType\``);
+}

package/dist/cjs/plugins/shared/EmbeddedBlockUtil.js

@@ -0,0 +1,170 @@
+"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, {
+    getWithEmbeddedBlockEvents: function() {
+        return getWithEmbeddedBlockEvents;
+    },
+    selectEntityAndInsert: function() {
+        return selectEntityAndInsert;
+    },
+    selectResourceEntityAndInsert: function() {
+        return selectResourceEntityAndInsert;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _ishotkey = _interop_require_default(require("is-hotkey"));
+const _editor = require("../../helpers/editor");
+const _newEntitySelectorConfigFromRichTextField = _interop_require_default(require("../../helpers/newEntitySelectorConfigFromRichTextField"));
+const _newResourceEntitySelectorConfigFromRichTextField = _interop_require_default(require("../../helpers/newResourceEntitySelectorConfigFromRichTextField"));
+const _sdkNavigatorSlideIn = require("../../helpers/sdkNavigatorSlideIn");
+const _internal = require("../../internal");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getWithEmbeddedBlockEvents(nodeType, sdk) {
+    return (editor, { options: { hotkey  }  })=>(event)=>{
+            const [, pathToSelectedElement] = (0, _editor.getNodeEntryFromSelection)(editor, nodeType);
+            if (pathToSelectedElement) {
+                const isDelete = event.key === 'Delete';
+                const isBackspace = event.key === 'Backspace';
+                if (isDelete || isBackspace) {
+                    event.preventDefault();
+                    (0, _internal.removeNodes)(editor, {
+                        at: pathToSelectedElement
+                    });
+                }
+                return;
+            }
+            if (hotkey && (0, _ishotkey.default)(hotkey, event)) {
+                if (nodeType === _richtexttypes.BLOCKS.EMBEDDED_RESOURCE) {
+                    selectResourceEntityAndInsert(sdk, editor, editor.tracking.onShortcutAction);
+                } else {
+                    selectEntityAndInsert(nodeType, sdk, editor, editor.tracking.onShortcutAction);
+                }
+            }
+        };
+}
+async function selectEntityAndInsert(nodeType, sdk, editor, logAction) {
+    logAction('openCreateEmbedDialog', {
+        nodeType
+    });
+    const { field , dialogs  } = sdk;
+    const baseConfig = (0, _newEntitySelectorConfigFromRichTextField.default)(field, nodeType);
+    const selectEntity = baseConfig.entityType === 'Asset' ? dialogs.selectSingleAsset : dialogs.selectSingleEntry;
+    const config = {
+        ...baseConfig,
+        withCreate: true
+    };
+    const { selection  } = editor;
+    const rteSlide = (0, _sdkNavigatorSlideIn.watchCurrentSlide)(sdk.navigator);
+    const entity = await selectEntity(config);
+    if (!entity) {
+        logAction('cancelCreateEmbedDialog', {
+            nodeType
+        });
+    } else {
+        (0, _internal.select)(editor, selection);
+        insertBlock(editor, nodeType, entity);
+        ensureFollowingParagraph(editor, [
+            _richtexttypes.BLOCKS.EMBEDDED_ASSET,
+            _richtexttypes.BLOCKS.EMBEDDED_ENTRY
+        ]);
+        logAction('insert', {
+            nodeType
+        });
+    }
+    rteSlide.onActive(()=>{
+        rteSlide.unwatch();
+        (0, _editor.focus)(editor);
+    });
+}
+async function selectResourceEntityAndInsert(sdk, editor, logAction) {
+    logAction('openCreateEmbedDialog', {
+        nodeType: _richtexttypes.BLOCKS.EMBEDDED_RESOURCE
+    });
+    const { field , dialogs  } = sdk;
+    const config = (0, _newResourceEntitySelectorConfigFromRichTextField.default)(field, _richtexttypes.BLOCKS.EMBEDDED_RESOURCE);
+    const { selection  } = editor;
+    const entity = await dialogs.selectSingleResourceEntry(config);
+    if (!entity) {
+        logAction('cancelCreateEmbedDialog', {
+            nodeType: _richtexttypes.BLOCKS.EMBEDDED_RESOURCE
+        });
+    } else {
+        (0, _internal.select)(editor, selection);
+        insertBlock(editor, _richtexttypes.BLOCKS.EMBEDDED_RESOURCE, entity);
+        ensureFollowingParagraph(editor, [
+            _richtexttypes.BLOCKS.EMBEDDED_RESOURCE
+        ]);
+        logAction('insert', {
+            nodeType: _richtexttypes.BLOCKS.EMBEDDED_RESOURCE
+        });
+    }
+}
+function ensureFollowingParagraph(editor, nodeTypes) {
+    const entityBlock = (0, _internal.getAboveNode)(editor, {
+        match: {
+            type: nodeTypes
+        }
+    });
+    if (!entityBlock) {
+        return;
+    }
+    const level = entityBlock[1].length - 1;
+    const lastNode = (0, _internal.getLastNodeByLevel)(editor, level);
+    const isTextContainer = _richtexttypes.TEXT_CONTAINERS.includes(lastNode?.[0].type ?? '');
+    if (level !== 0 && !isTextContainer) {
+        (0, _editor.insertEmptyParagraph)(editor);
+    }
+    (0, _editor.moveToTheNextChar)(editor);
+}
+const getLink = (nodeType, entity)=>{
+    if (nodeType === _richtexttypes.BLOCKS.EMBEDDED_RESOURCE) {
+        return {
+            urn: entity.sys.urn,
+            type: 'ResourceLink',
+            linkType: 'Contentful:Entry'
+        };
+    }
+    return {
+        id: entity.sys.id,
+        type: 'Link',
+        linkType: entity.sys.type
+    };
+};
+const createNode = (nodeType, entity)=>{
+    return {
+        type: nodeType,
+        data: {
+            target: {
+                sys: getLink(nodeType, entity)
+            }
+        },
+        children: [
+            {
+                text: ''
+            }
+        ],
+        isVoid: true
+    };
+};
+function insertBlock(editor, nodeType, entity) {
+    if (!editor?.selection) return;
+    const linkedEntityBlock = createNode(nodeType, entity);
+    const hasText = editor.selection && !!(0, _internal.getText)(editor, editor.selection.focus.path);
+    if (hasText) {
+        (0, _internal.insertNodes)(editor, linkedEntityBlock);
+    } else {
+        (0, _internal.setNodes)(editor, linkedEntityBlock);
+    }
+}

package/dist/cjs/plugins/shared/FetchingWrappedAssetCard.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FetchingWrappedAssetCard", {
+    enumerable: true,
+    get: function() {
+        return FetchingWrappedAssetCard;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+const _fieldeditorreference = require("@contentful/field-editor-reference");
+const _fastdeepequal = _interop_require_default(require("fast-deep-equal"));
+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;
+}
+const InternalAssetCard = _react.memo((props)=>{
+    if (props.asset === undefined) {
+        return _react.createElement(_f36components.AssetCard, {
+            size: "default",
+            isLoading: true
+        });
+    }
+    if (props.asset === 'failed') {
+        return _react.createElement(_fieldeditorreference.MissingEntityCard, {
+            entityType: "Asset",
+            isDisabled: props.isDisabled,
+            onRemove: props.onRemove
+        });
+    }
+    return _react.createElement(_fieldeditorreference.WrappedAssetCard, {
+        getEntityScheduledActions: props.loadEntityScheduledActions,
+        size: "small",
+        isSelected: props.isSelected,
+        isDisabled: props.isDisabled,
+        localeCode: props.locale,
+        defaultLocaleCode: props.sdk.locales.default,
+        asset: props.asset,
+        onEdit: props.onEdit,
+        onRemove: props.isDisabled ? undefined : props.onRemove,
+        isClickable: false
+    });
+}, _fastdeepequal.default);
+InternalAssetCard.displayName = 'InternalAssetCard';
+function FetchingWrappedAssetCard(props) {
+    const { onEntityFetchComplete  } = props;
+    const { data: asset , status  } = (0, _fieldeditorreference.useEntity)('Asset', props.assetId);
+    const { getEntityScheduledActions  } = (0, _fieldeditorreference.useEntityLoader)();
+    const loadEntityScheduledActions = _react.useCallback(()=>getEntityScheduledActions('Asset', props.assetId), [
+        getEntityScheduledActions,
+        props.assetId
+    ]);
+    _react.useEffect(()=>{
+        if (status === 'success') {
+            onEntityFetchComplete?.();
+        }
+    }, [
+        onEntityFetchComplete,
+        status
+    ]);
+    return _react.createElement(InternalAssetCard, {
+        asset: asset,
+        sdk: props.sdk,
+        isDisabled: props.isDisabled,
+        isSelected: props.isSelected,
+        loadEntityScheduledActions: loadEntityScheduledActions,
+        locale: props.locale,
+        onEdit: props.onEdit,
+        onRemove: props.onRemove
+    });
+}