@contentful/field-editor-reference 5.9.0 → 5.11.0

package/dist/cjs/entries/MultipleEntryReferenceEditor.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MultipleEntryReferenceEditor", {
+    enumerable: true,
+    get: function() {
+        return MultipleEntryReferenceEditor;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _MultipleReferenceEditor = require("../common/MultipleReferenceEditor");
+const _SortableLinkList = require("../common/SortableLinkList");
+const _FetchingWrappedEntryCard = require("./WrappedEntryCard/FetchingWrappedEntryCard");
+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 MultipleEntryReferenceEditor(props) {
+    const [indexToUpdate, setIndexToUpdate] = _react.useState(undefined);
+    const updateBeforeSortStart = ({ index  })=>{
+        setIndexToUpdate(index);
+    };
+    return _react.createElement(_MultipleReferenceEditor.MultipleReferenceEditor, {
+        ...props,
+        entityType: "Entry",
+        setIndexToUpdate: setIndexToUpdate
+    }, (childrenProps)=>_react.createElement(_SortableLinkList.SortableLinkList, {
+            ...childrenProps,
+            axis: "y",
+            useDragHandle: true,
+            updateBeforeSortStart: updateBeforeSortStart
+        }, ({ items , item , index , isDisabled , DragHandle  })=>{
+            const lastIndex = items.length - 1;
+            return _react.createElement(_FetchingWrappedEntryCard.FetchingWrappedEntryCard, {
+                ...childrenProps,
+                key: `${item.sys.id}-${index}`,
+                index: index,
+                allContentTypes: childrenProps.allContentTypes,
+                isDisabled: isDisabled,
+                entryId: item.sys.id,
+                onRemove: ()=>{
+                    childrenProps.setValue(items.filter((_value, i)=>i !== index));
+                },
+                onMoveTop: index !== 0 ? ()=>childrenProps.onMove(index, 0) : undefined,
+                onMoveBottom: index !== lastIndex ? ()=>childrenProps.onMove(index, lastIndex) : undefined,
+                renderDragHandle: DragHandle,
+                isBeingDragged: index === indexToUpdate
+            });
+        }));
+}

package/dist/cjs/entries/SingleEntryReferenceEditor.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SingleEntryReferenceEditor", {
+    enumerable: true,
+    get: function() {
+        return SingleEntryReferenceEditor;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _SingleReferenceEditor = require("../common/SingleReferenceEditor");
+const _FetchingWrappedEntryCard = require("./WrappedEntryCard/FetchingWrappedEntryCard");
+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 SingleEntryReferenceEditor(props) {
+    return _react.createElement(_SingleReferenceEditor.SingleReferenceEditor, {
+        ...props,
+        entityType: "Entry"
+    }, ({ allContentTypes , isDisabled , entityId , setValue , renderCustomCard , hasCardRemoveActions , hasCardEditActions  })=>{
+        return _react.createElement(_FetchingWrappedEntryCard.FetchingWrappedEntryCard, {
+            ...props,
+            allContentTypes: allContentTypes,
+            isDisabled: isDisabled,
+            entryId: entityId,
+            renderCustomCard: renderCustomCard,
+            hasCardEditActions: hasCardEditActions,
+            hasCardRemoveActions: hasCardRemoveActions,
+            onRemove: ()=>{
+                setValue(null);
+            }
+        });
+    });
+}
+SingleEntryReferenceEditor.defaultProps = {
+    isInitiallyDisabled: true
+};

package/dist/cjs/entries/WrappedEntryCard/FetchingWrappedEntryCard.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FetchingWrappedEntryCard", {
+    enumerable: true,
+    get: function() {
+        return FetchingWrappedEntryCard;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+const _get = _interop_require_default(require("lodash/get"));
+const _EntityStore = require("../../common/EntityStore");
+const _components = require("../../components");
+const _WrappedEntryCard = require("./WrappedEntryCard");
+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;
+}
+async function openEntry(sdk, entryId, options) {
+    let slide;
+    if (options.bulkEditing) {
+        try {
+            const result = await sdk.navigator.openBulkEditor(sdk.entry.getSys().id, {
+                fieldId: sdk.field.id,
+                locale: sdk.field.locale,
+                index: options.index ?? 0
+            });
+            slide = result.slide;
+            return slide;
+        } catch (e) {}
+    }
+    const result = await sdk.navigator.openEntry(entryId, {
+        slideIn: true
+    });
+    slide = result.slide;
+    return slide;
+}
+function FetchingWrappedEntryCard(props) {
+    const { data: entry , status  } = (0, _EntityStore.useEntity)('Entry', props.entryId);
+    const { getEntityScheduledActions  } = (0, _EntityStore.useEntityLoader)();
+    const loadEntityScheduledActions = _react.useCallback(()=>getEntityScheduledActions('Entry', props.entryId), [
+        getEntityScheduledActions,
+        props.entryId
+    ]);
+    const size = props.viewType === 'link' ? 'small' : 'default';
+    const { getEntity  } = (0, _EntityStore.useEntityLoader)();
+    const getAsset = (assetId)=>getEntity('Asset', assetId);
+    const onEdit = async ()=>{
+        const slide = await openEntry(props.sdk, props.entryId, {
+            bulkEditing: props.parameters.instance.bulkEditing,
+            index: props.index
+        });
+        props.onAction && props.onAction({
+            entity: 'Entry',
+            type: 'edit',
+            id: props.entryId,
+            contentTypeId: (0, _get.default)(entry, 'sys.contentType.sys.id'),
+            slide
+        });
+    };
+    const onRemoveEntry = ()=>{
+        props.onRemove();
+        props.onAction && props.onAction({
+            entity: 'Entry',
+            type: 'delete',
+            id: props.entryId,
+            contentTypeId: (0, _get.default)(entry, 'sys.contentType.sys.id')
+        });
+    };
+    _react.useEffect(()=>{
+        if (entry) {
+            props.onAction && props.onAction({
+                type: 'rendered',
+                entity: 'Entry'
+            });
+        }
+    }, [
+        entry
+    ]);
+    return _react.useMemo(()=>{
+        if (status === 'error') {
+            const card = _react.createElement(_components.MissingEntityCard, {
+                entityType: "Entry",
+                isDisabled: props.isDisabled,
+                onRemove: onRemoveEntry
+            });
+            if (props.renderCustomMissingEntityCard) {
+                return props.renderCustomMissingEntityCard({
+                    defaultCard: card,
+                    entity: {
+                        id: props.entryId,
+                        type: 'Entry'
+                    }
+                });
+            }
+            return card;
+        }
+        if (status === 'loading') {
+            return _react.createElement(_f36components.EntryCard, {
+                size: size,
+                isLoading: true
+            });
+        }
+        const sharedCardProps = {
+            index: props.index,
+            entity: entry,
+            entityUrl: props.getEntityUrl && props.getEntityUrl(entry.sys.id),
+            contentType: props.allContentTypes.find((contentType)=>contentType.sys.id === entry.sys.contentType.sys.id),
+            isDisabled: props.isDisabled,
+            size,
+            localeCode: props.sdk.field.locale,
+            defaultLocaleCode: props.sdk.locales.default,
+            renderDragHandle: props.renderDragHandle,
+            onEdit,
+            onRemove: onRemoveEntry,
+            onMoveTop: props.onMoveTop,
+            onMoveBottom: props.onMoveBottom,
+            isBeingDragged: props.isBeingDragged
+        };
+        const { hasCardEditActions , hasCardMoveActions , hasCardRemoveActions  } = props;
+        function renderDefaultCard(props) {
+            const builtinCardProps = {
+                ...sharedCardProps,
+                ...props,
+                hasCardEditActions,
+                hasCardMoveActions,
+                hasCardRemoveActions,
+                getAsset,
+                getEntityScheduledActions: loadEntityScheduledActions,
+                entry: (props?.entity) || sharedCardProps.entity,
+                entryUrl: props?.entityUrl || sharedCardProps.entityUrl
+            };
+            return _react.createElement(_WrappedEntryCard.WrappedEntryCard, builtinCardProps);
+        }
+        if (props.renderCustomCard) {
+            const renderedCustomCard = props.renderCustomCard(sharedCardProps, {}, renderDefaultCard);
+            if (renderedCustomCard !== false) {
+                return renderedCustomCard;
+            }
+        }
+        return renderDefaultCard();
+    }, [
+        props,
+        status,
+        entry
+    ]);
+}

package/dist/cjs/entries/WrappedEntryCard/WrappedEntryCard.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WrappedEntryCard", {
+    enumerable: true,
+    get: function() {
+        return WrappedEntryCard;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36components = require("@contentful/f36-components");
+const _f36icons = require("@contentful/f36-icons");
+const _f36tokens = _interop_require_default(require("@contentful/f36-tokens"));
+const _fieldeditorshared = require("@contentful/field-editor-shared");
+const _emotion = require("emotion");
+const _components = require("../../components");
+const _SpaceName = require("../../components/SpaceName/SpaceName");
+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 { getEntryTitle , getEntityDescription , getEntryStatus , getEntryImage  } = _fieldeditorshared.entityHelpers;
+const styles = {
+    scheduleIcon: (0, _emotion.css)({
+        marginRight: _f36tokens.default.spacing2Xs
+    })
+};
+const defaultProps = {
+    isClickable: true,
+    hasCardEditActions: true,
+    hasCardMoveActions: true,
+    hasCardRemoveActions: true
+};
+function WrappedEntryCard(props) {
+    const [file, setFile] = _react.useState(null);
+    const { contentType  } = props;
+    _react.useEffect(()=>{
+        if (props.entry) {
+            getEntryImage({
+                entry: props.entry,
+                contentType,
+                localeCode: props.localeCode,
+                defaultLocaleCode: props.defaultLocaleCode
+            }, props.getAsset).then((file)=>{
+                setFile(file);
+            }).catch(()=>{
+                setFile(null);
+            });
+        }
+    }, [
+        props.entry,
+        props.getAsset,
+        contentType,
+        props.localeCode,
+        props.defaultLocaleCode
+    ]);
+    const status = getEntryStatus(props.entry?.sys);
+    if (status === 'deleted') {
+        return _react.createElement(_components.MissingEntityCard, {
+            entityType: "Entry",
+            isDisabled: props.isDisabled,
+            onRemove: props.onRemove
+        });
+    }
+    const title = getEntryTitle({
+        entry: props.entry,
+        contentType,
+        localeCode: props.localeCode,
+        defaultLocaleCode: props.defaultLocaleCode,
+        defaultTitle: 'Untitled'
+    });
+    const description = getEntityDescription({
+        entity: props.entry,
+        contentType,
+        localeCode: props.localeCode,
+        defaultLocaleCode: props.defaultLocaleCode
+    });
+    return _react.createElement(_f36components.EntryCard, {
+        as: props.entryUrl ? 'a' : 'article',
+        href: props.entryUrl,
+        title: title,
+        description: description,
+        contentType: contentType?.name,
+        size: props.size,
+        isSelected: props.isSelected,
+        status: status,
+        icon: props.spaceName ? _react.createElement(_SpaceName.SpaceName, {
+            spaceName: props.spaceName
+        }) : _react.createElement(_components.ScheduledIconWithTooltip, {
+            getEntityScheduledActions: props.getEntityScheduledActions,
+            entityType: "Entry",
+            entityId: props.entry.sys.id
+        }, _react.createElement(_f36icons.ClockIcon, {
+            className: styles.scheduleIcon,
+            size: "small",
+            variant: "muted",
+            testId: "schedule-icon"
+        })),
+        thumbnailElement: file && (0, _fieldeditorshared.isValidImage)(file) ? _react.createElement(_components.AssetThumbnail, {
+            file: file
+        }) : undefined,
+        dragHandleRender: props.renderDragHandle,
+        withDragHandle: !!props.renderDragHandle,
+        actions: props.onEdit || props.onRemove ? [
+            props.hasCardEditActions && props.onEdit ? _react.createElement(_f36components.MenuItem, {
+                key: "edit",
+                testId: "edit",
+                onClick: ()=>{
+                    props.onEdit && props.onEdit();
+                }
+            }, "Edit") : null,
+            props.hasCardRemoveActions && props.onRemove ? _react.createElement(_f36components.MenuItem, {
+                key: "delete",
+                testId: "delete",
+                onClick: ()=>{
+                    props.onRemove && props.onRemove();
+                }
+            }, "Remove") : null,
+            props.hasCardMoveActions && (props.onMoveTop || props.onMoveBottom) ? _react.createElement(_f36components.MenuDivider, {
+                key: "divider"
+            }) : null,
+            props.hasCardMoveActions && props.onMoveTop ? _react.createElement(_f36components.MenuItem, {
+                key: "move-top",
+                onClick: ()=>props.onMoveTop && props.onMoveTop(),
+                testId: "move-top"
+            }, "Move to top") : null,
+            props.hasCardMoveActions && props.onMoveBottom ? _react.createElement(_f36components.MenuItem, {
+                key: "move-bottom",
+                onClick: ()=>props.onMoveBottom && props.onMoveBottom(),
+                testId: "move-bottom"
+            }, "Move to bottom") : null
+        ].filter((item)=>item) : [],
+        onClick: props.isClickable ? (e)=>{
+            e.preventDefault();
+            if (props.onClick) return props.onClick(e);
+            props.onEdit && props.onEdit();
+        } : undefined
+    });
+}
+WrappedEntryCard.defaultProps = defaultProps;

package/dist/cjs/entries/index.js

@@ -0,0 +1,24 @@
+"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, {
+    SingleEntryReferenceEditor: function() {
+        return _SingleEntryReferenceEditor.SingleEntryReferenceEditor;
+    },
+    MultipleEntryReferenceEditor: function() {
+        return _MultipleEntryReferenceEditor.MultipleEntryReferenceEditor;
+    },
+    WrappedEntryCard: function() {
+        return _WrappedEntryCard.WrappedEntryCard;
+    }
+});
+const _SingleEntryReferenceEditor = require("./SingleEntryReferenceEditor");
+const _MultipleEntryReferenceEditor = require("./MultipleEntryReferenceEditor");
+const _WrappedEntryCard = require("./WrappedEntryCard/WrappedEntryCard");

package/dist/cjs/index.js

@@ -0,0 +1,92 @@
+"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, {
+    CreateEntryMenuTrigger: function() {
+        return _components.CreateEntryMenuTrigger;
+    },
+    CreateEntryLinkButton: function() {
+        return _components.CreateEntryLinkButton;
+    },
+    getScheduleTooltipContent: function() {
+        return _components.getScheduleTooltipContent;
+    },
+    ScheduledIconWithTooltip: function() {
+        return _components.ScheduledIconWithTooltip;
+    },
+    AssetThumbnail: function() {
+        return _components.AssetThumbnail;
+    },
+    MissingEntityCard: function() {
+        return _components.MissingEntityCard;
+    },
+    CombinedLinkActions: function() {
+        return _components.CombinedLinkActions;
+    },
+    SingleEntryReferenceEditor: function() {
+        return _entries.SingleEntryReferenceEditor;
+    },
+    MultipleEntryReferenceEditor: function() {
+        return _entries.MultipleEntryReferenceEditor;
+    },
+    WrappedEntryCard: function() {
+        return _entries.WrappedEntryCard;
+    },
+    SingleMediaEditor: function() {
+        return _assets.SingleMediaEditor;
+    },
+    MultipleMediaEditor: function() {
+        return _assets.MultipleMediaEditor;
+    },
+    WrappedAssetCard: function() {
+        return _assets.WrappedAssetCard;
+    },
+    SortableLinkList: function() {
+        return _SortableLinkList.SortableLinkList;
+    },
+    EntityProvider: function() {
+        return _EntityStore.EntityProvider;
+    },
+    useEntityLoader: function() {
+        return _EntityStore.useEntityLoader;
+    },
+    useEntity: function() {
+        return _EntityStore.useEntity;
+    },
+    useResource: function() {
+        return _EntityStore.useResource;
+    },
+    SingleResourceReferenceEditor: function() {
+        return _resources.SingleResourceReferenceEditor;
+    },
+    MultipleResourceReferenceEditor: function() {
+        return _resources.MultipleResourceReferenceEditor;
+    }
+});
+const _components = require("./components");
+const _entries = require("./entries");
+const _assets = require("./assets");
+const _SortableLinkList = require("./common/SortableLinkList");
+const _EntityStore = require("./common/EntityStore");
+const _resources = require("./resources");
+_export_star(require("./types"), 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;
+}