@contentful/field-editor-reference 5.10.0 → 5.12.0

package/dist/cjs/components/MissingEntityCard/MissingEntityCard.js

@@ -54,7 +54,8 @@ function _interop_require_wildcard(obj, nodeInterop) {
 function MissingEntityCard(props) {
     return _react.createElement(_f36components.Card, {
         className: _styles.card,
-        testId: "cf-ui-missing-entry-card"
+        testId: "cf-ui-missing-entry-card",
+        isSelected: props.isSelected
     }, _react.createElement(_f36components.Flex, {
         alignItems: "center",
         justifyContent: "space-between"

package/dist/cjs/components/ResourceEntityErrorCard/ResourceEntityErrorCard.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ResourceEntityErrorCard", {
+    enumerable: true,
+    get: function() {
+        return ResourceEntityErrorCard;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _EntityStore = require("../../common/EntityStore");
+const _MissingEntityCard = require("../MissingEntityCard/MissingEntityCard");
+const _UnsupportedEntityCard = require("./UnsupportedEntityCard");
+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 ResourceEntityErrorCard(props) {
+    if ((0, _EntityStore.isUnsupportedError)(props.error)) {
+        return _react.createElement(_UnsupportedEntityCard.UnsupportedEntityCard, {
+            linkType: props.linkType,
+            isSelected: props.isSelected
+        });
+    }
+    return _react.createElement(_MissingEntityCard.MissingEntityCard, {
+        entityType: "Entry",
+        isDisabled: props.isDisabled,
+        isSelected: props.isSelected,
+        onRemove: props.onRemove
+    });
+}

package/dist/cjs/{resources/Cards → components/ResourceEntityErrorCard}/UnsupportedEntityCard.js

@@ -57,8 +57,9 @@ const styles = {
 };
 function UnsupportedEntityCard(props) {
     return _react.createElement(_f36components.Card, {
-        className: styles.card
+        className: styles.card,
+        isSelected: props.isSelected
     }, _react.createElement(_f36components.SectionHeading, {
         marginBottom: "none"
-    }, "Resource type ", props.entityType, " is currently not supported"));
+    }, "Resource type ", props.linkType, " is currently not supported"));
 }

package/dist/cjs/components/index.js

@@ -32,6 +32,9 @@ _export(exports, {
     },
     AssetThumbnail: function() {
         return _AssetThumbnail.AssetThumbnail;
+    },
+    ResourceEntityErrorCard: function() {
+        return _ResourceEntityErrorCard.ResourceEntityErrorCard;
     }
 });
 const _CombinedLinkActions = require("./LinkActions/CombinedLinkActions");
@@ -42,3 +45,4 @@ const _CreateEntryMenuTrigger = require("./CreateEntryLinkButton/CreateEntryMenu
 const _ScheduledIconWithTooltip = require("./ScheduledIconWithTooltip/ScheduledIconWithTooltip");
 const _ScheduleTooltip = require("./ScheduledIconWithTooltip/ScheduleTooltip");
 const _AssetThumbnail = require("./AssetThumbnail/AssetThumbnail");
+const _ResourceEntityErrorCard = require("./ResourceEntityErrorCard/ResourceEntityErrorCard");

package/dist/cjs/index.js

@@ -24,6 +24,9 @@ _export(exports, {
     AssetThumbnail: function() {
         return _components.AssetThumbnail;
     },
+    ResourceEntityErrorCard: function() {
+        return _components.ResourceEntityErrorCard;
+    },
     MissingEntityCard: function() {
         return _components.MissingEntityCard;
     },

package/dist/cjs/resources/Cards/ResourceCard.js

@@ -14,7 +14,6 @@ const _f36components = require("@contentful/f36-components");
 const _EntityStore = require("../../common/EntityStore");
 const _components = require("../../components");
 const _ContentfulEntryCard = require("./ContentfulEntryCard");
-const _UnsupportedEntityCard = require("./UnsupportedEntityCard");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -76,13 +75,9 @@ function ExistingResourceCard(props) {
             ...props
         });
     }
-    if ((0, _EntityStore.isUnsupportedError)(error)) {
-        return _react.createElement(_UnsupportedEntityCard.UnsupportedEntityCard, {
-            entityType: resourceLink.sys.linkType
-        });
-    }
-    return _react.createElement(_components.MissingEntityCard, {
-        entityType: "Entry",
+    return _react.createElement(_components.ResourceEntityErrorCard, {
+        linkType: resourceLink.sys.linkType,
+        error: error,
         isDisabled: props.isDisabled,
         onRemove: props.onRemove
     });

package/dist/cjs/resources/Cards/ResourceCard.spec.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _react = _interop_require_wildcard(require("react"));
+require("@testing-library/jest-dom");
+const _fieldeditortestutils = require("@contentful/field-editor-test-utils");
+const _react1 = require("@testing-library/react");
+const _published_content_typejson = _interop_require_default(require("../../__fixtures__/content-type/published_content_type.json"));
+const _published_entryjson = _interop_require_default(require("../../__fixtures__/entry/published_entry.json"));
+const _indifferent_spacejson = _interop_require_default(require("../../__fixtures__/space/indifferent_space.json"));
+const _EntityStore = require("../../common/EntityStore");
+const _ResourceCard = require("./ResourceCard");
+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'
+});
+jest.mock('react-intersection-observer', ()=>({
+        useInView: jest.fn().mockReturnValue({})
+    }));
+const resolvableEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/linked-entry-urn';
+const unknownEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/unknown-entry-urn';
+const sdk = {
+    locales: {
+        default: 'en-US'
+    },
+    cmaAdapter: (0, _fieldeditortestutils.createFakeCMAAdapter)({
+        ContentType: {
+            get: jest.fn().mockReturnValue(_published_content_typejson.default)
+        },
+        Entry: {
+            get: jest.fn().mockImplementation(({ entryId  })=>{
+                if (entryId === 'linked-entry-urn') {
+                    return Promise.resolve(_published_entryjson.default);
+                }
+                return Promise.reject(new Error());
+            })
+        },
+        Locale: {
+            getMany: jest.fn().mockResolvedValue({
+                items: [
+                    {
+                        default: true,
+                        code: 'en'
+                    }
+                ]
+            })
+        },
+        ScheduledAction: {
+            getMany: jest.fn().mockResolvedValue({
+                items: [],
+                total: 0
+            })
+        },
+        Space: {
+            get: jest.fn().mockResolvedValue(_indifferent_spacejson.default)
+        }
+    }),
+    space: {
+        onEntityChanged: jest.fn()
+    },
+    navigator: {},
+    ids: {
+        space: 'space-id',
+        environment: 'environment-id'
+    }
+};
+function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvableEntryUrn  } = {}) {
+    return (0, _react1.render)(_react.createElement(_EntityStore.EntityProvider, {
+        sdk: sdk
+    }, _react.createElement(_ResourceCard.ResourceCard, {
+        isDisabled: false,
+        getEntryRouteHref: ()=>'',
+        resourceLink: {
+            sys: {
+                type: 'ResourceLink',
+                linkType: linkType,
+                urn: entryUrn
+            }
+        }
+    })));
+}
+describe('ResourceCard', ()=>{
+    it('renders entry card', async ()=>{
+        const { getByTestId , getByText  } = renderResourceCard();
+        await (0, _react1.waitFor)(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
+        expect(getByText(_published_entryjson.default.fields.exField['en-US'])).toBeDefined();
+        expect(getByText(_indifferent_spacejson.default.name)).toBeDefined();
+    });
+    it('renders skeleton when no data is provided', ()=>{
+        const { getByTestId  } = renderResourceCard();
+        expect(getByTestId('cf-ui-skeleton-form')).toBeDefined();
+    });
+    it('renders unsupported entity card when unsupported link is passed', async ()=>{
+        const { getByText  } = renderResourceCard({
+            linkType: 'Contentful:UnsupportedLink'
+        });
+        await (0, _react1.waitFor)(()=>expect(getByText('Resource type Contentful:UnsupportedLink is currently not supported')).toBeDefined());
+    });
+    it('renders missing entity card when unknown error is returned', async ()=>{
+        const { getByTestId  } = renderResourceCard({
+            entryUrn: unknownEntryUrn
+        });
+        await (0, _react1.waitFor)(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
+    });
+});

package/dist/esm/components/MissingEntityCard/MissingEntityCard.js

@@ -5,7 +5,8 @@ import * as styles from './styles';
 export function MissingEntityCard(props) {
     return React.createElement(Card, {
         className: styles.card,
-        testId: "cf-ui-missing-entry-card"
+        testId: "cf-ui-missing-entry-card",
+        isSelected: props.isSelected
     }, React.createElement(Flex, {
         alignItems: "center",
         justifyContent: "space-between"

package/dist/esm/components/ResourceEntityErrorCard/ResourceEntityErrorCard.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { isUnsupportedError } from '../../common/EntityStore';
+import { MissingEntityCard } from '../MissingEntityCard/MissingEntityCard';
+import { UnsupportedEntityCard } from './UnsupportedEntityCard';
+export function ResourceEntityErrorCard(props) {
+    if (isUnsupportedError(props.error)) {
+        return React.createElement(UnsupportedEntityCard, {
+            linkType: props.linkType,
+            isSelected: props.isSelected
+        });
+    }
+    return React.createElement(MissingEntityCard, {
+        entityType: "Entry",
+        isDisabled: props.isDisabled,
+        isSelected: props.isSelected,
+        onRemove: props.onRemove
+    });
+}

package/dist/esm/{resources/Cards → components/ResourceEntityErrorCard}/UnsupportedEntityCard.js

@@ -8,8 +8,9 @@ const styles = {
 };
 export function UnsupportedEntityCard(props) {
     return React.createElement(Card, {
-        className: styles.card
+        className: styles.card,
+        isSelected: props.isSelected
     }, React.createElement(SectionHeading, {
         marginBottom: "none"
-    }, "Resource type ", props.entityType, " is currently not supported"));
+    }, "Resource type ", props.linkType, " is currently not supported"));
 }

package/dist/esm/components/index.js

@@ -6,3 +6,4 @@ export { CreateEntryMenuTrigger } from './CreateEntryLinkButton/CreateEntryMenuT
 export { ScheduledIconWithTooltip } from './ScheduledIconWithTooltip/ScheduledIconWithTooltip';
 export { getScheduleTooltipContent } from './ScheduledIconWithTooltip/ScheduleTooltip';
 export { AssetThumbnail } from './AssetThumbnail/AssetThumbnail';
+export { ResourceEntityErrorCard } from './ResourceEntityErrorCard/ResourceEntityErrorCard';

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-export { CreateEntryMenuTrigger, CreateEntryLinkButton, getScheduleTooltipContent, ScheduledIconWithTooltip, AssetThumbnail, MissingEntityCard, CombinedLinkActions } from './components';
+export { CreateEntryMenuTrigger, CreateEntryLinkButton, getScheduleTooltipContent, ScheduledIconWithTooltip, AssetThumbnail, ResourceEntityErrorCard, MissingEntityCard, CombinedLinkActions } from './components';
 export { SingleEntryReferenceEditor, MultipleEntryReferenceEditor, WrappedEntryCard } from './entries';
 export { SingleMediaEditor, MultipleMediaEditor, WrappedAssetCard } from './assets';
 export { SortableLinkList } from './common/SortableLinkList';

package/dist/esm/resources/Cards/ResourceCard.js

@@ -1,10 +1,9 @@
 import * as React from 'react';
 import { useInView } from 'react-intersection-observer';
 import { EntryCard } from '@contentful/f36-components';
-import { isUnsupportedError, useResource } from '../../common/EntityStore';
-import { MissingEntityCard } from '../../components';
+import { useResource } from '../../common/EntityStore';
+import { ResourceEntityErrorCard } from '../../components';
 import { ContentfulEntryCard } from './ContentfulEntryCard';
-import { UnsupportedEntityCard } from './UnsupportedEntityCard';
 function ResourceCardSkeleton() {
     return React.createElement(EntryCard, {
         size: "small",
@@ -27,13 +26,9 @@ function ExistingResourceCard(props) {
             ...props
         });
     }
-    if (isUnsupportedError(error)) {
-        return React.createElement(UnsupportedEntityCard, {
-            entityType: resourceLink.sys.linkType
-        });
-    }
-    return React.createElement(MissingEntityCard, {
-        entityType: "Entry",
+    return React.createElement(ResourceEntityErrorCard, {
+        linkType: resourceLink.sys.linkType,
+        error: error,
         isDisabled: props.isDisabled,
         onRemove: props.onRemove
     });

package/dist/esm/resources/Cards/ResourceCard.spec.js

@@ -0,0 +1,101 @@
+import * as React from 'react';
+import '@testing-library/jest-dom';
+import { createFakeCMAAdapter } from '@contentful/field-editor-test-utils';
+import { configure, render, waitFor } from '@testing-library/react';
+import publishedCT from '../../__fixtures__/content-type/published_content_type.json';
+import publishedEntry from '../../__fixtures__/entry/published_entry.json';
+import space from '../../__fixtures__/space/indifferent_space.json';
+import { EntityProvider } from '../../common/EntityStore';
+import { ResourceCard } from './ResourceCard';
+configure({
+    testIdAttribute: 'data-test-id'
+});
+jest.mock('react-intersection-observer', ()=>({
+        useInView: jest.fn().mockReturnValue({})
+    }));
+const resolvableEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/linked-entry-urn';
+const unknownEntryUrn = 'crn:contentful:::content:spaces/space-id/entries/unknown-entry-urn';
+const sdk = {
+    locales: {
+        default: 'en-US'
+    },
+    cmaAdapter: createFakeCMAAdapter({
+        ContentType: {
+            get: jest.fn().mockReturnValue(publishedCT)
+        },
+        Entry: {
+            get: jest.fn().mockImplementation(({ entryId  })=>{
+                if (entryId === 'linked-entry-urn') {
+                    return Promise.resolve(publishedEntry);
+                }
+                return Promise.reject(new Error());
+            })
+        },
+        Locale: {
+            getMany: jest.fn().mockResolvedValue({
+                items: [
+                    {
+                        default: true,
+                        code: 'en'
+                    }
+                ]
+            })
+        },
+        ScheduledAction: {
+            getMany: jest.fn().mockResolvedValue({
+                items: [],
+                total: 0
+            })
+        },
+        Space: {
+            get: jest.fn().mockResolvedValue(space)
+        }
+    }),
+    space: {
+        onEntityChanged: jest.fn()
+    },
+    navigator: {},
+    ids: {
+        space: 'space-id',
+        environment: 'environment-id'
+    }
+};
+function renderResourceCard({ linkType ='Contentful:Entry' , entryUrn =resolvableEntryUrn  } = {}) {
+    return render(React.createElement(EntityProvider, {
+        sdk: sdk
+    }, React.createElement(ResourceCard, {
+        isDisabled: false,
+        getEntryRouteHref: ()=>'',
+        resourceLink: {
+            sys: {
+                type: 'ResourceLink',
+                linkType: linkType,
+                urn: entryUrn
+            }
+        }
+    })));
+}
+describe('ResourceCard', ()=>{
+    it('renders entry card', async ()=>{
+        const { getByTestId , getByText  } = renderResourceCard();
+        await waitFor(()=>expect(getByTestId('cf-ui-entry-card')).toBeDefined());
+        expect(getByText(publishedEntry.fields.exField['en-US'])).toBeDefined();
+        expect(getByText(space.name)).toBeDefined();
+    });
+    it('renders skeleton when no data is provided', ()=>{
+        const { getByTestId  } = renderResourceCard();
+        expect(getByTestId('cf-ui-skeleton-form')).toBeDefined();
+    });
+    it('renders unsupported entity card when unsupported link is passed', async ()=>{
+        const { getByText  } = renderResourceCard({
+            linkType: 'Contentful:UnsupportedLink'
+        });
+        await waitFor(()=>expect(getByText('Resource type Contentful:UnsupportedLink is currently not supported')).toBeDefined());
+    });
+    it('renders missing entity card when unknown error is returned', async ()=>{
+        const { getByTestId  } = renderResourceCard({
+            entryUrn: unknownEntryUrn
+        });
+        await waitFor(()=>expect(getByTestId('cf-ui-missing-entry-card')).toBeDefined());
+    });
+});

package/dist/types/components/MissingEntityCard/MissingEntityCard.d.ts

@@ -3,6 +3,7 @@ import { ContentEntityType } from '../../types';
 export declare function MissingEntityCard(props: {
     entityType: ContentEntityType;
     asSquare?: boolean;
+    isSelected?: boolean;
     isDisabled: boolean;
     onRemove?: Function;
 }): React.JSX.Element;

package/dist/types/components/ResourceEntityErrorCard/ResourceEntityErrorCard.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export declare function ResourceEntityErrorCard(props: {
+    linkType: string;
+    error: unknown;
+    isSelected?: boolean;
+    isDisabled: boolean;
+    onRemove?: Function;
+}): React.JSX.Element;

package/dist/types/{resources/Cards → components/ResourceEntityErrorCard}/UnsupportedEntityCard.d.ts

@@ -1,4 +1,5 @@
 import * as React from 'react';
 export declare function UnsupportedEntityCard(props: {
-    entityType: string;
+    linkType: string;
+    isSelected?: boolean;
 }): React.JSX.Element;

package/dist/types/components/index.d.ts

@@ -7,3 +7,4 @@ export { CreateEntryMenuTrigger } from './CreateEntryLinkButton/CreateEntryMenuT
 export { ScheduledIconWithTooltip } from './ScheduledIconWithTooltip/ScheduledIconWithTooltip';
 export { getScheduleTooltipContent } from './ScheduledIconWithTooltip/ScheduleTooltip';
 export { AssetThumbnail } from './AssetThumbnail/AssetThumbnail';
+export { ResourceEntityErrorCard } from './ResourceEntityErrorCard/ResourceEntityErrorCard';

package/dist/types/index.d.ts

@@ -1,9 +1,10 @@
-export { CreateEntryMenuTrigger, CreateEntryLinkButton, getScheduleTooltipContent, ScheduledIconWithTooltip, AssetThumbnail, MissingEntityCard, CombinedLinkActions, } from './components';
+export { CreateEntryMenuTrigger, CreateEntryLinkButton, getScheduleTooltipContent, ScheduledIconWithTooltip, AssetThumbnail, ResourceEntityErrorCard, MissingEntityCard, CombinedLinkActions, } from './components';
 export { SingleEntryReferenceEditor, MultipleEntryReferenceEditor, WrappedEntryCard, } from './entries';
 export { SingleMediaEditor, MultipleMediaEditor, WrappedAssetCard } from './assets';
 export type { CustomActionProps } from './common/ReferenceEditor';
 export type { CustomEntityCardProps, DefaultCardRenderer, MissingEntityCardProps, RenderCustomMissingEntityCard, } from './common/customCardTypes';
 export { SortableLinkList } from './common/SortableLinkList';
 export { EntityProvider, useEntityLoader, useEntity, useResource } from './common/EntityStore';
+export type { ResourceInfo } from './common/EntityStore';
 export { SingleResourceReferenceEditor, MultipleResourceReferenceEditor } from './resources';
 export * from './types';

package/dist/types/resources/Cards/ResourceCard.spec.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/field-editor-reference",
-  "version": "5.10.0",
+  "version": "5.12.0",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",
@@ -64,5 +64,5 @@
     "@contentful/app-sdk": "^4.2.0",
     "react": ">=16.8.0"
   },
-  "gitHead": "543e02672a8dd4edc810f9f3568d6b69c454e1f9"
+  "gitHead": "667723f7f4c7fa168ad233f26e353108851fa4e0"
 }