@contentful/field-editor-rich-text 3.12.7 → 3.14.0

package/dist/esm/plugins/shared/EmbeddedInlineUtil.js

@@ -1,25 +1,59 @@
 import { INLINES } from '@contentful/rich-text-types';
 import isHotkey from 'is-hotkey';
+import { newEntitySelectorConfigFromRichTextField, newResourceEntitySelectorConfigFromRichTextField } from '../../helpers/config';
 import { focus } from '../../helpers/editor';
-import newEntitySelectorConfigFromRichTextField from '../../helpers/newEntitySelectorConfigFromRichTextField';
 import { watchCurrentSlide } from '../../helpers/sdkNavigatorSlideIn';
 import { insertNodes, select } from '../../internal/transforms';
-export function getWithEmbeddedEntryInlineEvents(sdk) {
+export function getWithEmbeddedEntryInlineEvents(nodeType, sdk) {
     return function withEmbeddedEntryInlineEvents(editor, { options: { hotkey  }  }) {
         return function handleEvent(event) {
             if (!editor) return;
             if (hotkey && isHotkey(hotkey, event)) {
-                selectEntityAndInsert(editor, sdk, editor.tracking.onShortcutAction);
+                if (nodeType === INLINES.EMBEDDED_RESOURCE) {
+                    selectResourceEntityAndInsert(editor, sdk, editor.tracking.onShortcutAction);
+                } else {
+                    selectEntityAndInsert(editor, sdk, editor.tracking.onShortcutAction);
+                }
             }
         };
     };
 }
+const getLink = (nodeType, entity)=>{
+    if (nodeType === INLINES.EMBEDDED_RESOURCE) {
+        return {
+            urn: entity.sys.urn,
+            type: 'ResourceLink',
+            linkType: 'Contentful:Entry'
+        };
+    }
+    return {
+        id: entity.sys.id,
+        type: 'Link',
+        linkType: entity.sys.type
+    };
+};
+const createInlineEntryNode = (nodeType, entity)=>{
+    return {
+        type: nodeType,
+        children: [
+            {
+                text: ''
+            }
+        ],
+        data: {
+            target: {
+                sys: getLink(nodeType, entity)
+            }
+        }
+    };
+};
 export async function selectEntityAndInsert(editor, sdk, logAction) {
+    const nodeType = INLINES.EMBEDDED_ENTRY;
     logAction('openCreateEmbedDialog', {
-        nodeType: INLINES.EMBEDDED_ENTRY
+        nodeType
     });
     const config = {
-        ...newEntitySelectorConfigFromRichTextField(sdk.field, INLINES.EMBEDDED_ENTRY),
+        ...newEntitySelectorConfigFromRichTextField(sdk.field, nodeType),
         withCreate: true
     };
     const { selection  } = editor;
@@ -27,13 +61,13 @@ export async function selectEntityAndInsert(editor, sdk, logAction) {
     const entry = await sdk.dialogs.selectSingleEntry(config);
     if (!entry) {
         logAction('cancelCreateEmbedDialog', {
-            nodeType: INLINES.EMBEDDED_ENTRY
+            nodeType
         });
     } else {
         select(editor, selection);
-        insertNodes(editor, createInlineEntryNode(entry.sys.id));
+        insertNodes(editor, createInlineEntryNode(nodeType, entry));
         logAction('insert', {
-            nodeType: INLINES.EMBEDDED_ENTRY
+            nodeType
         });
     }
     rteSlide.onActive(()=>{
@@ -41,22 +75,27 @@ export async function selectEntityAndInsert(editor, sdk, logAction) {
         focus(editor);
     });
 }
-export function createInlineEntryNode(id) {
-    return {
-        type: INLINES.EMBEDDED_ENTRY,
-        children: [
-            {
-                text: ''
-            }
-        ],
-        data: {
-            target: {
-                sys: {
-                    id,
-                    type: 'Link',
-                    linkType: 'Entry'
-                }
-            }
-        }
+export async function selectResourceEntityAndInsert(editor, sdk, logAction) {
+    const nodeType = INLINES.EMBEDDED_RESOURCE;
+    logAction('openCreateEmbedDialog', {
+        nodeType
+    });
+    const { dialogs , field  } = sdk;
+    const config = {
+        ...newResourceEntitySelectorConfigFromRichTextField(field, nodeType),
+        withCreate: true
     };
+    const { selection  } = editor;
+    const entry = await dialogs.selectSingleResourceEntry(config);
+    if (!entry) {
+        logAction('cancelCreateEmbedDialog', {
+            nodeType
+        });
+    } else {
+        select(editor, selection);
+        insertNodes(editor, createInlineEntryNode(nodeType, entry));
+        logAction('insert', {
+            nodeType
+        });
+    }
 }

package/dist/esm/plugins/shared/ResourceNewBadge.js

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { Badge } from '@contentful/f36-components';
+export const ResourceNewBadge = ()=>{
+    return React.createElement(React.Fragment, null, ' ', "(different space)", ' ', React.createElement(Badge, {
+        variant: "primary-filled",
+        size: "small"
+    }, "new"));
+};

package/dist/esm/test-utils/jsx.js

@@ -19,6 +19,13 @@ const createSysLink = (linkType, id)=>({
             linkType
         }
     });
+const createSysResourceLink = (urn)=>({
+        sys: {
+            urn,
+            type: 'ResourceLink',
+            linkType: 'Contentful:Entry'
+        }
+    });
 const createHyperlink = (_, attrs, children)=>{
     const data = {};
     let type = INLINES.HYPERLINK;
@@ -34,6 +41,10 @@ const createHyperlink = (_, attrs, children)=>{
         type = INLINES.ENTRY_HYPERLINK;
         data.target = createSysLink('Entry', attrs.entry);
     }
+    if (attrs.resource) {
+        type = INLINES.RESOURCE_HYPERLINK;
+        data.target = createSysResourceLink(attrs.resource);
+    }
     children = children.map((child)=>typeof child === 'string' ? {
             text: child
         } : child);

package/dist/types/constants/Schema.d.ts

@@ -96,6 +96,13 @@ declare const _default: {
                 }[];
             }[];
         };
+        "resource-hyperlink": {
+            nodes: {
+                match: {
+                    object: string;
+                }[];
+            }[];
+        };
         "asset-hyperlink": {
             nodes: {
                 match: {
@@ -106,6 +113,9 @@ declare const _default: {
         "embedded-entry-inline": {
             isVoid: boolean;
         };
+        "embedded-resource-inline": {
+            isVoid: boolean;
+        };
     };
 };
 export default _default;

package/dist/types/helpers/config.d.ts

@@ -0,0 +1,33 @@
+import { FieldAPI } from '@contentful/app-sdk';
+/**
+ * Returns a config for the entity selector based on a given rich text field and a
+ * rich text node type that the entity should be picked for. Takes the field
+ * validations for the given node type into account.
+ *
+ * @param {object} field
+ * @param {string} nodeType
+ * @returns {object}
+ */
+type EntitySelectorConfig = {
+    entityType: string;
+    locale: string | null;
+    contentTypes: string[];
+};
+export declare const newEntitySelectorConfigFromRichTextField: (field: FieldAPI, nodeType: any) => EntitySelectorConfig;
+/**
+ * Returns a config for the entity selector based on a given rich text field and a
+ * rich text node type that the entity should be picked for. Takes the field
+ * validations for the given node type into account.
+ *
+ * @param {object} field
+ * @param {string} nodeType
+ * @returns {object}
+ */
+export declare const newResourceEntitySelectorConfigFromRichTextField: (field: any, nodeType: any) => {
+    allowedResources: {
+        type: "Contentful:Entry";
+        source: string;
+        contentTypes: string[];
+    }[];
+};
+export {};

package/dist/types/helpers/editor.d.ts

@@ -17,7 +17,7 @@ export declare function isList(editor?: PlateEditor): boolean;
 export declare function getTableSize(table: Element): Record<'numRows' | 'numColumns', number> | null;
 interface InsertLinkOptions {
     text: string;
-    type: INLINES.HYPERLINK | INLINES.ENTRY_HYPERLINK | INLINES.ASSET_HYPERLINK;
+    type: INLINES.HYPERLINK | INLINES.ENTRY_HYPERLINK | INLINES.RESOURCE_HYPERLINK | INLINES.ASSET_HYPERLINK;
     url?: string;
     target?: Link;
     path?: Path;

package/dist/types/plugins/EmbeddedResourceInline/FetchingWrappedResourceInlineCard.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { ResourceLink } from '@contentful/field-editor-reference';
+import { FieldAppSDK } from '@contentful/field-editor-shared';
+interface FetchingWrappedResourceInlineCardProps {
+    link: ResourceLink['sys'];
+    sdk: FieldAppSDK;
+    isSelected: boolean;
+    isDisabled: boolean;
+    onRemove: (event: React.MouseEvent<Element, MouseEvent>) => void;
+    onEntityFetchComplete?: VoidFunction;
+}
+export declare function FetchingWrappedResourceInlineCard(props: FetchingWrappedResourceInlineCardProps): React.JSX.Element;
+export {};

package/dist/types/plugins/EmbeddedResourceInline/LinkedResourceInline.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { ResourceLink } from '@contentful/field-editor-reference';
+import { Element, RenderElementProps } from '../../internal';
+export type LinkedResourceInlineProps = {
+    element: Element & {
+        data: {
+            target: ResourceLink;
+        };
+    };
+    attributes: Pick<RenderElementProps, 'attributes'>;
+    children: Pick<RenderElementProps, 'children'>;
+};
+export declare function LinkedResourceInline(props: LinkedResourceInlineProps): React.JSX.Element;

package/dist/types/plugins/EmbeddedResourceInline/index.d.ts

@@ -0,0 +1,3 @@
+import { FieldAppSDK } from '@contentful/app-sdk';
+import { PlatePlugin } from '../../internal';
+export declare function createEmbeddedResourceInlinePlugin(sdk: FieldAppSDK): PlatePlugin;

package/dist/types/plugins/Hyperlink/HyperlinkModal.d.ts

@@ -1,13 +1,14 @@
 import * as React from 'react';
 import { Link } from '@contentful/field-editor-reference';
 import { FieldAppSDK } from '@contentful/field-editor-shared';
+import { ResourceLink } from '@contentful/rich-text-types';
 import { PlateEditor, Path } from '../../internal/types';
 import { TrackingPluginActions } from '../../plugins/Tracking';
 interface HyperlinkModalProps {
     linkText?: string;
     linkType?: string;
     linkTarget?: string;
-    linkEntity?: Link;
+    linkEntity?: Link | ResourceLink;
     onClose: (value: unknown) => void;
     sdk: FieldAppSDK;
     readonly: boolean;

package/dist/types/plugins/Hyperlink/components/ResourceHyperlink.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { Link } from '@contentful/app-sdk';
+import { Element, RenderElementProps } from '../../../internal/types';
+export type ResourceHyperlinkProps = {
+    element: Element & {
+        data: {
+            target: {
+                sys: {
+                    urn: string;
+                    linkType: 'Contentful:Entry';
+                    type: 'ResourceLink';
+                };
+            };
+        };
+    };
+    target: Link;
+    attributes: Pick<RenderElementProps, 'attributes'>;
+    children: Pick<RenderElementProps, 'children'>;
+};
+export declare function ResourceHyperlink(props: ResourceHyperlinkProps): React.JSX.Element | null;

package/dist/types/plugins/Hyperlink/useResourceEntityInfo.d.ts

@@ -0,0 +1,7 @@
+import { ResourceLink } from '@contentful/rich-text-types';
+type ResourceEntityInfoProps = {
+    target: ResourceLink;
+    onEntityFetchComplete?: VoidFunction;
+};
+export declare function useResourceEntityInfo({ onEntityFetchComplete, target }: ResourceEntityInfoProps): string;
+export {};

package/dist/types/plugins/Hyperlink/utils.d.ts

@@ -2,4 +2,5 @@ import { NodeEntry } from '../../internal/types';
 import { PlateEditor } from '../../internal/types';
 import { FetchedEntityData } from './useEntityInfo';
 export declare const hasText: (editor: PlateEditor, entry: NodeEntry) => boolean;
+export declare function truncateTitle(str: string, length: number): string;
 export declare function getEntityInfo(data?: FetchedEntityData): string;

package/dist/types/plugins/shared/EmbeddedInlineToolbarIcon.d.ts

@@ -1,7 +1,8 @@
 import * as React from 'react';
 interface EmbeddedInlineToolbarIconProps {
     onClose: () => void;
+    nodeType: string;
     isDisabled: boolean;
 }
-export declare function EmbeddedInlineToolbarIcon(props: EmbeddedInlineToolbarIconProps): React.JSX.Element;
+export declare function EmbeddedInlineToolbarIcon({ onClose, nodeType, isDisabled, }: EmbeddedInlineToolbarIconProps): React.JSX.Element;
 export {};

package/dist/types/plugins/shared/EmbeddedInlineUtil.d.ts

@@ -3,20 +3,6 @@ import { INLINES } from '@contentful/rich-text-types';
 import { HotkeyPlugin } from '@udecode/plate-common';
 import { KeyboardHandler } from '../../internal/types';
 import { TrackingPluginActions } from '../../plugins/Tracking';
-export declare function getWithEmbeddedEntryInlineEvents(sdk: FieldAppSDK): KeyboardHandler<HotkeyPlugin>;
-export declare function selectEntityAndInsert(editor: any, sdk: FieldAppSDK, logAction: TrackingPluginActions['onShortcutAction'] | TrackingPluginActions['onToolbarAction']): Promise<void>;
-export declare function createInlineEntryNode(id: string): {
-    type: INLINES;
-    children: {
-        text: string;
-    }[];
-    data: {
-        target: {
-            sys: {
-                id: string;
-                type: string;
-                linkType: string;
-            };
-        };
-    };
-};
+export declare function getWithEmbeddedEntryInlineEvents(nodeType: INLINES.EMBEDDED_ENTRY | INLINES.EMBEDDED_RESOURCE, sdk: FieldAppSDK): KeyboardHandler<HotkeyPlugin>;
+export declare function selectEntityAndInsert(editor: any, sdk: any, logAction: TrackingPluginActions['onShortcutAction'] | TrackingPluginActions['onToolbarAction']): Promise<void>;
+export declare function selectResourceEntityAndInsert(editor: any, sdk: any, logAction: TrackingPluginActions['onToolbarAction'] | TrackingPluginActions['onShortcutAction']): Promise<void>;

package/dist/types/plugins/shared/ResourceNewBadge.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export declare const ResourceNewBadge: () => React.JSX.Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/field-editor-rich-text",
-  "version": "3.12.7",
+  "version": "3.14.0",
   "source": "./src/index.tsx",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -81,5 +81,5 @@
     "prism-react-renderer": "2.0.5",
     "react": ">=16.14.0"
   },
-  "gitHead": "3ae9c46f02565c17a9323b1d319950bbb5adc900"
+  "gitHead": "5df6fd753ac999a99c4aaaac9fac54336f0c4974"
 }

package/dist/cjs/helpers/newResourceEntitySelectorConfigFromRichTextField.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return newResourceEntitySelectorConfigFromRichTextField;
-    }
-});
-const _getAllowedResourcesForNodeType = _interop_require_default(require("./getAllowedResourcesForNodeType"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function newResourceEntitySelectorConfigFromRichTextField(field, nodeType) {
-    return {
-        allowedResources: (0, _getAllowedResourcesForNodeType.default)(field, nodeType)
-    };
-}

package/dist/esm/helpers/newResourceEntitySelectorConfigFromRichTextField.js

@@ -1,6 +0,0 @@
-import getAllowedResourcesForNodeType from './getAllowedResourcesForNodeType';
-export default function newResourceEntitySelectorConfigFromRichTextField(field, nodeType) {
-    return {
-        allowedResources: getAllowedResourcesForNodeType(field, nodeType)
-    };
-}

package/dist/types/helpers/newEntitySelectorConfigFromRichTextField.d.ts

@@ -1,14 +0,0 @@
-/**
- * Returns a config for the entity selector based on a given rich text field and a
- * rich text node type that the entity should be picked for. Takes the field
- * validations for the given node type into account.
- *
- * @param {object} field
- * @param {string} nodeType
- * @returns {object}
- */
-export default function newEntitySelectorConfigFromRichTextField(field: any, nodeType: any): {
-    entityType: "Entry" | "Asset";
-    locale: any;
-    contentTypes: string[];
-};

package/dist/types/helpers/newResourceEntitySelectorConfigFromRichTextField.d.ts

@@ -1,16 +0,0 @@
-/**
- * Returns a config for the entity selector based on a given rich text field and a
- * rich text node type that the entity should be picked for. Takes the field
- * validations for the given node type into account.
- *
- * @param {object} field
- * @param {string} nodeType
- * @returns {object}
- */
-export default function newResourceEntitySelectorConfigFromRichTextField(field: any, nodeType: any): {
-    allowedResources: {
-        type: "Contentful:Entry";
-        source: string;
-        contentTypes: string[];
-    }[];
-};