@contentful/field-editor-rich-text 3.16.8 → 3.16.10

package/dist/esm/dialogs/HypelinkDialog/HyperlinkDialog.js

@@ -28,7 +28,7 @@ function isFeaturingEntitySelector(entitySelectorConfigs = {}) {
     return !!entitySelectorConfigs.Entry || !!entitySelectorConfigs.Asset;
 }
 function entityToLink(entity) {
-    const { id, type } = entity.sys;
+    const { id , type  } = entity.sys;
     return {
         sys: {
             id,
@@ -48,7 +48,7 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             }));
     }
     getValue() {
-        const { text, type, uri } = this.state;
+        const { text , type , uri  } = this.state;
         const value = {
             type
         };
@@ -63,7 +63,7 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         return value;
     }
     isLinkComplete() {
-        const { text, type, uri, target } = this.getValue();
+        const { text , type , uri , target  } = this.getValue();
         const requiresText = !this.props.hideText;
         if (requiresText && !text) {
             return false;
@@ -71,16 +71,16 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         return type === LINK_TYPES.URI && uri || target;
     }
     render() {
-        const { labels } = this.props;
-        return /*#__PURE__*/ React.createElement(EntityProvider, {
+        const { labels  } = this.props;
+        return React.createElement(EntityProvider, {
             sdk: this.props.sdk
-        }, /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(ModalContent, null, this.renderFields()), /*#__PURE__*/ React.createElement(ModalControls, null, /*#__PURE__*/ React.createElement(Button, {
+        }, React.createElement(React.Fragment, null, React.createElement(ModalContent, null, this.renderFields()), React.createElement(ModalControls, null, React.createElement(Button, {
             type: "button",
             onClick: ()=>this.props.onClose(null),
             variant: "secondary",
             testId: "cancel-cta",
             size: "small"
-        }, "Cancel"), /*#__PURE__*/ React.createElement(Button, {
+        }, "Cancel"), React.createElement(Button, {
             type: "submit",
             variant: "positive",
             onClick: this.handleSubmit,
@@ -90,40 +90,39 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         }, labels.confirm))));
     }
     renderFields() {
-        const { hideText, allowedHyperlinkTypes, entitySelectorConfigs } = this.props;
-        const { uri, text, type } = this.state;
+        const { hideText , allowedHyperlinkTypes , entitySelectorConfigs  } = this.props;
+        const { uri , text , type  } = this.state;
         const isUriInputAutoFocused = type === LINK_TYPES.URI && (hideText || !!text);
-        return /*#__PURE__*/ React.createElement(Form, null, hideText ? null : /*#__PURE__*/ React.createElement(FormControl, {
+        return React.createElement(Form, null, hideText ? null : React.createElement(FormControl, {
             id: "link-text",
             isRequired: true
-        }, /*#__PURE__*/ React.createElement(FormControl.Label, null, "Link text"), /*#__PURE__*/ React.createElement(TextInput, {
+        }, React.createElement(FormControl.Label, null, "Link text"), React.createElement(TextInput, {
             testId: "link-text-input",
             name: "link-text",
             value: text || '',
             onChange: (e)=>this.setState({
                     text: e.target.value
                 }),
-            // eslint-disable-next-line -- TODO: describe this disable  jsx-a11y/no-autofocus
             autoFocus: !isUriInputAutoFocused
-        })), isFeaturingEntitySelector(entitySelectorConfigs) && /*#__PURE__*/ React.createElement(FormControl, {
+        })), isFeaturingEntitySelector(entitySelectorConfigs) && React.createElement(FormControl, {
             id: "link-type",
             name: "link-type"
-        }, /*#__PURE__*/ React.createElement(FormControl.Label, null, "Link type"), /*#__PURE__*/ React.createElement(Select, {
+        }, React.createElement(FormControl.Label, null, "Link type"), React.createElement(Select, {
             value: type,
             onChange: (e)=>this.setState({
                     type: e.target.value
                 }),
             testId: "link-type-select"
-        }, allowedHyperlinkTypes.includes(LINK_TYPES.URI) || type === LINK_TYPES.URI ? /*#__PURE__*/ React.createElement(Select.Option, {
+        }, allowedHyperlinkTypes.includes(LINK_TYPES.URI) || type === LINK_TYPES.URI ? React.createElement(Select.Option, {
             value: LINK_TYPES.URI
-        }, "URL") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ENTRY) || type === LINK_TYPES.ENTRY ? /*#__PURE__*/ React.createElement(Select.Option, {
+        }, "URL") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ENTRY) || type === LINK_TYPES.ENTRY ? React.createElement(Select.Option, {
             value: LINK_TYPES.ENTRY
-        }, "Entry") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ASSET) || type === LINK_TYPES.ASSET ? /*#__PURE__*/ React.createElement(Select.Option, {
+        }, "Entry") : null, allowedHyperlinkTypes.includes(LINK_TYPES.ASSET) || type === LINK_TYPES.ASSET ? React.createElement(Select.Option, {
             value: LINK_TYPES.ASSET
-        }, "Asset") : null)), type === LINK_TYPES.URI ? /*#__PURE__*/ React.createElement(FormControl, {
+        }, "Asset") : null)), type === LINK_TYPES.URI ? React.createElement(FormControl, {
             id: "link-uri",
             isRequired: true
-        }, /*#__PURE__*/ React.createElement(FormControl.Label, null, "Link target"), /*#__PURE__*/ React.createElement(TextInput, {
+        }, React.createElement(FormControl.Label, null, "Link target"), React.createElement(TextInput, {
             testId: "link-target-input",
             name: "link-uri",
             value: uri || '',
@@ -131,31 +130,30 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             onChange: (e)=>this.setState({
                     uri: e.target.value
                 }),
-            // eslint-disable-next-line -- TODO: describe this disable  jsx-a11y/no-autofocus
             autoFocus: isUriInputAutoFocused
-        }), /*#__PURE__*/ React.createElement(FormControl.HelpText, null, "A protocol may be required, e.g. https://")) : this.renderEntityField());
+        }), React.createElement(FormControl.HelpText, null, "A protocol may be required, e.g. https://")) : this.renderEntityField());
     }
     renderEntityField() {
-        const { type, entityLinks } = this.state;
+        const { type , entityLinks  } = this.state;
         const resetEntity = ()=>this.setTargetEntity(type, null);
         const entityLink = entityLinks[type];
         const isEntitySelectorVisible = !entityLink;
-        return /*#__PURE__*/ React.createElement("div", null, /*#__PURE__*/ React.createElement(FormLabel, {
+        return React.createElement("div", null, React.createElement(FormLabel, {
             required: true,
             htmlFor: ""
-        }, "Link target"), !isEntitySelectorVisible && /*#__PURE__*/ React.createElement(TextLink, {
+        }, "Link target"), !isEntitySelectorVisible && React.createElement(TextLink, {
             as: "button",
             className: css({
                 marginLeft: tokens.spacingS
             }),
             onClick: resetEntity
-        }, "Remove selection"), entityLink && /*#__PURE__*/ React.createElement("div", null, type === LINK_TYPES.ENTRY && /*#__PURE__*/ React.createElement(FetchingWrappedEntryCard, {
+        }, "Remove selection"), entityLink && React.createElement("div", null, type === LINK_TYPES.ENTRY && React.createElement(FetchingWrappedEntryCard, {
             sdk: this.props.sdk,
             locale: this.props.entitySelectorConfigs.Entry.locale,
             entryId: entityLink.sys.id,
             isDisabled: true,
             isSelected: false
-        }), type == LINK_TYPES.ASSET && /*#__PURE__*/ React.createElement(FetchingWrappedAssetCard, {
+        }), type == LINK_TYPES.ASSET && React.createElement(FetchingWrappedAssetCard, {
             sdk: this.props.sdk,
             locale: this.props.entitySelectorConfigs.Asset.locale,
             assetId: entityLink.sys.id,
@@ -164,14 +162,14 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
         })), isEntitySelectorVisible && this.renderEntitySelector(type, isEntitySelectorVisible));
     }
     renderEntitySelector(type) {
-        return /*#__PURE__*/ React.createElement("div", {
+        return React.createElement("div", {
             className: css({
                 marginTop: tokens.spacingS
             })
-        }, type === LINK_TYPES.ENTRY && /*#__PURE__*/ React.createElement(TextLink, {
+        }, type === LINK_TYPES.ENTRY && React.createElement(TextLink, {
             as: "button",
             onClick: this.selectEntry
-        }, "Select entry"), type === LINK_TYPES.ASSET && /*#__PURE__*/ React.createElement(TextLink, {
+        }, "Select entry"), type === LINK_TYPES.ASSET && React.createElement(TextLink, {
             as: "button",
             onClick: this.selectAsset
         }, "Select asset"));
@@ -183,7 +181,7 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             this.props.onClose(this.getValue());
         });
         _define_property(this, "selectEntry", async ()=>{
-            const { locale, contentTypes } = this.props.entitySelectorConfigs.Entry;
+            const { locale , contentTypes  } = this.props.entitySelectorConfigs.Entry;
             const entry = await this.props.sdk.dialogs.selectSingleEntry({
                 locale,
                 contentTypes
@@ -191,13 +189,13 @@ export class HyperlinkDialog extends (_React_Component = React.Component) {
             this.setTargetEntity(LINK_TYPES.ENTRY, entry);
         });
         _define_property(this, "selectAsset", async ()=>{
-            const { locale } = this.props.entitySelectorConfigs.Asset;
+            const { locale  } = this.props.entitySelectorConfigs.Asset;
             const asset = await this.props.sdk.dialogs.selectSingleAsset({
                 locale
             });
             this.setTargetEntity(LINK_TYPES.ASSET, asset);
         });
-        const { text, type, uri, target } = props.value;
+        const { text , type , uri , target  } = props.value;
         const isEntityLink = Boolean(target);
         const entityLinks = {
             [LINK_TYPES.ENTRY]: null,
@@ -230,7 +228,6 @@ _define_property(HyperlinkDialog, "propTypes", {
         text: PropTypes.string,
         uri: PropTypes.string,
         target: PropTypes.object,
-        // Will be overwritten accordingly if `uri` or `target.sys.linkType` are set.
         type: PropTypes.oneOf([
             'uri',
             'Entry',
@@ -260,7 +257,7 @@ _define_property(HyperlinkDialog, "defaultProps", {
         LINK_TYPES.URI
     ]
 });
-export const openHyperlinkDialog = (dialogs, { value, showTextInput, allowedHyperlinkTypes, entitySelectorConfigs })=>{
+export const openHyperlinkDialog = (dialogs, { value , showTextInput , allowedHyperlinkTypes , entitySelectorConfigs  })=>{
     const isNew = !(value.uri || value.target);
     const props = {
         labels: {

package/dist/esm/dialogs/openRichTextDialog.js

@@ -3,8 +3,8 @@ import { ModalDialogLauncher } from '@contentful/field-editor-shared';
 import { HyperlinkDialog } from './HypelinkDialog/HyperlinkDialog';
 export const openRichTextDialog = (sdk)=>(options)=>{
         if (options.parameters?.type === 'rich-text-hyperlink-dialog') {
-            return ModalDialogLauncher.openDialog(options, ({ onClose })=>{
-                return /*#__PURE__*/ React.createElement(HyperlinkDialog, {
+            return ModalDialogLauncher.openDialog(options, ({ onClose  })=>{
+                return React.createElement(HyperlinkDialog, {
                     ...options.parameters,
                     onClose: onClose,
                     sdk: sdk

package/dist/esm/dialogs/renderRichTextDialog.js

@@ -4,11 +4,11 @@ export const renderRichTextDialog = (sdk)=>{
     const parameters = sdk.parameters.invocation;
     if (parameters?.type === 'rich-text-hyperlink-dialog') {
         sdk.window.startAutoResizer();
-        return /*#__PURE__*/ React.createElement(HyperlinkDialog, {
+        return React.createElement(HyperlinkDialog, {
             ...parameters,
             onClose: sdk.close,
             sdk: sdk
         });
     }
-    return /*#__PURE__*/ React.createElement("div", null);
+    return React.createElement("div", null);
 };

package/dist/esm/helpers/__tests__/removeInternalMarks.test.js

@@ -1,4 +1,4 @@
-/* eslint-disable react/no-unknown-property */ /** @jsx jsx */ import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
+import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
 import { COMMAND_PROMPT } from '../../plugins/CommandPalette/constants';
 import { jsx } from '../../test-utils';
 import { removeInternalMarks } from '../removeInternalMarks';
@@ -8,54 +8,54 @@ describe('internal mark', ()=>{
             {
                 title: 'Paragraph mark is removed',
                 input: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
+                    document: jsx("editor", null, jsx("hp", null, jsx("htext", {
                         [COMMAND_PROMPT]: true
                     }))).children
                 }),
                 expected: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", null))).children
+                    document: jsx("editor", null, jsx("hp", null, jsx("htext", null))).children
                 })
             },
             {
                 title: 'Heading mark is removed',
                 input: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hh1", null, /*#__PURE__*/ jsx("htext", {
+                    document: jsx("editor", null, jsx("hh1", null, jsx("htext", {
                         [COMMAND_PROMPT]: true
                     }))).children
                 }),
                 expected: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hh1", null, /*#__PURE__*/ jsx("htext", null))).children
+                    document: jsx("editor", null, jsx("hh1", null, jsx("htext", null))).children
                 })
             },
             {
                 title: 'Block quote mark is removed',
                 input: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
+                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", {
                         [COMMAND_PROMPT]: true
                     })))).children
                 }),
                 expected: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", null)))).children
+                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", null)))).children
                 })
             },
             {
                 title: 'Other marks are not removed',
                 input: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
+                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", {
                         bold: true,
                         underline: true,
                         [COMMAND_PROMPT]: true
                     })))).children
                 }),
                 expected: toContentfulDocument({
-                    document: /*#__PURE__*/ jsx("editor", null, /*#__PURE__*/ jsx("hquote", null, /*#__PURE__*/ jsx("hp", null, /*#__PURE__*/ jsx("htext", {
+                    document: jsx("editor", null, jsx("hquote", null, jsx("hp", null, jsx("htext", {
                         bold: true,
                         underline: true
                     })))).children
                 })
             }
         ];
-        for (const { input, expected, title } of data){
+        for (const { input , expected , title  } of data){
             it(`${title}`, ()=>{
                 expect(removeInternalMarks(input)).toEqual(expected);
             });

package/dist/esm/helpers/callbacks.js

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */ import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
+import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
 import debounce from 'lodash/debounce';
 import schema from '../constants/Schema';
 import { removeInternalMarks } from './removeInternalMarks';

package/dist/esm/helpers/config.js

@@ -17,15 +17,7 @@ function getEntityTypeFromRichTextNode(nodeType) {
     }
     throw new Error(`RichText node type \`${nodeType}\` has no associated \`entityType\``);
 }
-/**
- * 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 const newResourceEntitySelectorConfigFromRichTextField = (field, nodeType)=>{
+export const newResourceEntitySelectorConfigFromRichTextField = (field, nodeType)=>{
     return {
         allowedResources: getAllowedResourcesForNodeType(field, nodeType)
     };

package/dist/esm/helpers/editor.js

@@ -67,11 +67,7 @@ export function insertEmptyParagraph(editor, options) {
 export function getElementFromCurrentSelection(editor) {
     if (!editor.selection) return [];
     return Array.from(getNodeEntries(editor, {
-        /**
-       * editor.select is a Range, which includes anchor and focus, the beginning and the end of a selection
-       * when using only editor.selection.focus, we might get only the end of the selection, or where the text cursor is
-       * and in some cases getting the next element instead of the one we want
-       **/ at: editor.selection,
+        at: editor.selection,
         match: (node)=>isElement(node)
     })).flat();
 }
@@ -92,13 +88,11 @@ export function getTableSize(table) {
         numColumns
     };
 }
-// TODO: move to hyperlink plugin
 export function insertLink(editor, options) {
     if (editor.selection) {
         wrapLink(editor, options);
     }
 }
-// TODO: move to hyperlink plugin
 export function isLinkActive(editor) {
     if (!editor) {
         return false;
@@ -108,18 +102,16 @@ export function isLinkActive(editor) {
     }));
     return !!link;
 }
-// TODO: move to hyperlink plugin
 export function unwrapLink(editor) {
     unwrapNodes(editor, {
         match: (node)=>!isEditor(node) && isElement(node) && LINK_TYPES.includes(node.type)
     });
 }
-// TODO: move to hyperlink plugin
-export function wrapLink(editor, { text, url, target, type, path }) {
+export function wrapLink(editor, { text , url , target , type , path  }) {
     if (isLinkActive(editor) && !path) {
         unwrapLink(editor);
     }
-    const { selection } = editor;
+    const { selection  } = editor;
     const isCollapsed = selection && isSelectionCollapsed(selection);
     const link = {
         type,
@@ -140,7 +132,6 @@ export function wrapLink(editor, { text, url, target, type, path }) {
             target
         };
     }
-    // TODO: always set the selection to the end of the inserted link
     if (path) {
         setNodes(editor, link, {
             at: path
@@ -167,19 +158,15 @@ export function getAncestorPathFromSelection(editor) {
     return getPathLevels(editor.selection.focus.path).find((level)=>level.length === 1);
 }
 export const isAtEndOfTextSelection = (editor)=>editor.selection?.focus.offset === getText(editor, editor.selection?.focus.path).length;
-/**
- * This traversal strategy is unfortunately necessary because Slate doesn't
- * expose something like Node.next(editor).
- */ export function getNextNode(editor) {
+export function getNextNode(editor) {
     if (!editor.selection) {
         return null;
     }
     const descendants = getNodeDescendants(editor, {
         from: editor.selection.focus.path
     });
-    // eslint-disable-next-line no-constant-condition -- TODO: explain this disable
     while(true){
-        const { done, value } = descendants.next();
+        const { done , value  } = descendants.next();
         if (done) {
             return null;
         }
@@ -192,23 +179,20 @@ export const isAtEndOfTextSelection = (editor)=>editor.selection?.focus.offset =
 }
 export const INLINE_TYPES = Object.values(INLINES);
 export const isInlineOrText = (node)=>{
-    // either text or inline elements
     return isText(node) || isElement(node) && INLINE_TYPES.includes(node.type);
 };
 export const focus = (editor)=>{
     const x = window.scrollX;
     const y = window.scrollY;
     focusEditor(editor);
-    // Safari has issues with `editor.focus({ preventScroll: true })`, it ignores the option `preventScroll`
     if (IS_SAFARI) {
         setTimeout(function() {
-            window.scrollTo(x, y); // restore position
+            window.scrollTo(x, y);
         }, 0);
     }
 };
 export function toggleElement(editor, options, editorOptions) {
     toggleNodeType(editor, options, editorOptions);
-    // We must reset `data` from one element to another
     setNodes(editor, {
         data: {}
     });

package/dist/esm/helpers/extractNodes.js

@@ -7,9 +7,7 @@ function extractNodes(editor, path, match) {
         mode: 'lowest'
     })).map(([node])=>node);
 }
-/**
- * It filters out all paragraphs and headings from a path and convert them into paragraphs.
- */ export function extractParagraphs(editor, path) {
+export function extractParagraphs(editor, path) {
     return extractNodes(editor, path, {
         type: TEXT_CONTAINERS
     }).map((node)=>({

package/dist/esm/helpers/formatDateAndTime.js

@@ -1,9 +1,5 @@
-// eslint-disable-next-line no-restricted-imports -- TODO: explain this disable
 import moment from 'moment';
-/**
- * @param {Date|string} date A valid constructor argument for moment()
- * @param {boolean=} short Render only Today/Tomorrow/Yesterday if valid. Defaults to false
- */ export const formatDate = (date, short)=>{
+export const formatDate = (date, short)=>{
     switch(moment().startOf('day').diff(moment(date).startOf('day'), 'days')){
         case 0:
             return short ? 'Today' : `Today, ${moment(date).format('DD MMM YYYY')}`;
@@ -15,12 +11,7 @@ import moment from 'moment';
             return moment(date).format('ddd, DD MMM YYYY');
     }
 };
-/**
- * Returns the time portion of a date in the local time in the format H:MM AM/PM
- *
- * == Examples
- * * `T15:36:45.000Z` => 3:36 PM (if in +0:00 offset)
- */ export const formatTime = (date)=>{
+export const formatTime = (date)=>{
     return moment.utc(date).local().format('h:mm A');
 };
 export const formatDateAndTime = (date, short)=>{

package/dist/esm/helpers/getAllowedResourcesForNodeType.js

@@ -1,24 +1,7 @@
-/* eslint-disable you-dont-need-lodash-underscore/find */ import find from 'lodash/find';
+import find from 'lodash/find';
 import flow from 'lodash/flow';
 import get from 'lodash/get';
-/**
- * Given a field object and a rich text node type, return a list of allowed
- * resources associated with the node type, based on that node type's
- * `allowedResources` property.
- *
- * The navigation here is explained by the `nodes` validation having signature:
- * { nodes: { [nodeType]: { allowedResources: AllowedResource[] } } }
- *
- * We defensively navigate through this object because
- * 1) the field may not have a `validations` array,
- * 2) the `validations` array may be empty,
- * 3) the `validations` array may not have a `nodes` validation, and
- * 4) the `nodes` validation may not validate the `nodeType`.
- *
- * @param {object} field
- * @param {string} nodeType
- * @returns {AllowedResource[]}
- */ export default function getAllowedResourcesForNodeType(field, nodeType) {
+export default function getAllowedResourcesForNodeType(field, nodeType) {
     return flow((validations)=>find(validations, 'nodes'), (validations)=>get(validations, [
             'nodes',
             nodeType,

package/dist/esm/helpers/getLinkedContentTypeIdsForNodeType.js

@@ -1,31 +1,7 @@
-/* eslint-disable you-dont-need-lodash-underscore/find */ import find from 'lodash/find';
+import find from 'lodash/find';
 import flow from 'lodash/flow';
 import get from 'lodash/get';
-/**
- * Given a field object and a rich text node type, return a list of valid
- * content type IDs associated with the node type, based on that node type's
- * `linkContentType` validation.
- *
- * If there is no such validation or the validation is empty, return an empty
- * array.
- *
- * The navigation here is explained by the `nodes` validation having signature:
- * { nodes: { [nodeType]: validationObject[] } }
- *
- * We defensively navigate through this object because
- * 1) the field may not have a `validations` array,
- * 2) the `validations` array may be empty,
- * 3) the `validations` array may not have a `nodes` validation,
- * 4) the `nodes` validation may not validate the `nodeType`, and
- * 5) the `nodeType` validations may not have a `linkContentType` validation.
- *
- * Note that passing an empty array will result in all possible content types
- * being whitelisted.
- *
- * @param {object} field
- * @param {string} nodeType
- * @returns {string[]}
- */ export default function getLinkedContentTypeIdsForNodeType(field, nodeType) {
+export default function getLinkedContentTypeIdsForNodeType(field, nodeType) {
     return flow((v)=>find(v, 'nodes'), (v)=>get(v, [
             'nodes',
             nodeType

package/dist/esm/helpers/sdkNavigatorSlideIn.js

@@ -1,11 +1,5 @@
 import noop from 'lodash/noop';
-/**
- * Allows to observe when the current slide-in navigation slide gets e.g.
- * re-activated after opening another slide on top. This is useful as the sdk
- * does not give full insights into e.g. whether sdk.dialogs.selectSingleEntry()
- * with `withCreate: true` option opens the slide-in navigation to edit the
- * created entry after returning it.
- */ export function watchCurrentSlide(navigator) {
+export function watchCurrentSlide(navigator) {
     const onActiveCallbacks = new Set();
     let wasSlideClosed = false;
     let initialSlideLevel;
@@ -14,34 +8,26 @@ import noop from 'lodash/noop';
             wasClosed: wasSlideClosed,
             isActive: !wasSlideClosed && lastSlideLevel === initialSlideLevel
         });
-    const off = navigator.onSlideInNavigation(({ oldSlideLevel, newSlideLevel })=>{
+    const off = navigator.onSlideInNavigation(({ oldSlideLevel , newSlideLevel  })=>{
         if (initialSlideLevel === undefined) {
             initialSlideLevel = oldSlideLevel;
         }
         lastSlideLevel = newSlideLevel;
         if (newSlideLevel < initialSlideLevel) {
             wasSlideClosed = true;
-            off(); // No more point in watching, slide got closed.
+            off();
             onActiveCallbacks.clear();
         }
         if (status().isActive && newSlideLevel !== oldSlideLevel) {
             onActiveCallbacks.forEach((cb)=>cb());
         }
     });
-    /**
-   * Call to unsubscribe from navigator events when the watcher is no longer
-   * needed.
-   */ function unwatch() {
+    function unwatch() {
         off();
         onActiveCallbacks.clear();
     }
-    /**
-   * Fires immediately when the slide is currently active, or at the point when
-   * it becomes active again, if there are slides on top that get closed. Does not
-   * fire when the observed slide gets closed, and then re-opened through browser
-   * back, as this technically opens a new slide and editor instance.
-   */ function onActive(cb) {
-        if (wasSlideClosed) return noop; // Can't re-activate already closed slide.
+    function onActive(cb) {
+        if (wasSlideClosed) return noop;
         if (status().isActive) {
             cb();
         }

package/dist/esm/helpers/sdkNavigatorSlideIn.spec.js

@@ -195,7 +195,6 @@ describe('watchCurrentSlide().unwatch()', ()=>{
             newSlideLevel: 0
         });
         expect(spy).toHaveBeenCalledTimes(0);
-        // Demonstrate that normally this would fire an event if it wasn't for the unwatch()
         expect(spy2).toHaveBeenCalledTimes(1);
     });
 });

package/dist/esm/helpers/toSlateValue.js

@@ -2,10 +2,7 @@ import { toSlatejsDocument } from '@contentful/contentful-slatejs-adapter';
 import { EMPTY_DOCUMENT } from '@contentful/rich-text-types';
 import schema from '../constants/Schema';
 const isTextElement = (node)=>'text' in node;
-/**
- * Ensures all nodes have a child leaf text element. This should be handled by
- * Slate but its behavior has proven to be buggy and unpredictable.
- */ function sanitizeIncomingSlateDoc(nodes = []) {
+function sanitizeIncomingSlateDoc(nodes = []) {
     return nodes.map((node)=>{
         if (isTextElement(node)) {
             return node;
@@ -27,23 +24,12 @@ const isTextElement = (node)=>'text' in node;
         };
     });
 }
-/**
- * Converts a Contentful rich text document to the corresponding slate editor
- * value
- */ export const toSlateValue = (doc)=>{
-    /**
-   * For legacy reasons, a document may not have any content at all
-   * e.g:
-   *
-   * {nodeType: document, data: {}, content: []}
-   *
-   * Rendering such document will break the Slate editor
-   */ const hasContent = (doc)=>{
+export const toSlateValue = (doc)=>{
+    const hasContent = (doc)=>{
         return (doc?.content || []).length > 0;
     };
     const slateDoc = toSlatejsDocument({
         document: doc && hasContent(doc) ? doc : EMPTY_DOCUMENT,
-        // TODO: get rid of schema, https://github.com/contentful/field-editors/pull/1065#discussion_r826723248
         schema
     });
     return sanitizeIncomingSlateDoc(slateDoc);

package/dist/esm/helpers/validations.js

@@ -1,8 +1,7 @@
-/* eslint-disable you-dont-need-lodash-underscore/find */ import { BLOCKS, INLINES, TOP_LEVEL_BLOCKS } from '@contentful/rich-text-types';
+import { BLOCKS, INLINES, TOP_LEVEL_BLOCKS } from '@contentful/rich-text-types';
 import find from 'lodash/find';
 import flow from 'lodash/flow';
 import get from 'lodash/get';
-// TODO: Move these into separate package (maybe rich-text-types) and share with FE.
 export const VALIDATIONS = {
     ENABLED_MARKS: 'enabledMarks',
     ENABLED_NODE_TYPES: 'enabledNodeTypes'
@@ -13,12 +12,9 @@ export const DEFAULT_ENABLED_NODE_TYPES = [
     'text'
 ];
 export const VALIDATABLE_NODE_TYPES = [].concat(TOP_LEVEL_BLOCKS).filter((type)=>type !== BLOCKS.PARAGRAPH).concat(Object.values(INLINES));
-// TODO: Memoize
 const getRichTextValidation = (field, validationType)=>flow((v)=>find(v, validationType), (v)=>get(v, validationType))(field.validations);
 const isFormattingOptionEnabled = (field, validationType, nodeTypeOrMark)=>{
     const enabledFormattings = getRichTextValidation(field, validationType);
-    // TODO: In the future, validations will always be opt-in. In that case
-    // we don't need this step.
     if (enabledFormattings === undefined) {
         return true;
     }