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

package/dist/types/__fixtures__/locale/index.d.ts

@@ -0,0 +1,42 @@
+import englishDefault from './english_default_locale.json';
+import german from './german_locale.json';
+declare const list: {
+    sys: {
+        type: string;
+    };
+    total: number;
+    skip: number;
+    limit: number;
+    items: {
+        sys: {
+            id: string;
+            type: string;
+            createdAt: string;
+            updatedAt: string;
+            version: number;
+            space: {
+                sys: {
+                    type: string;
+                    linkType: string;
+                    id: string;
+                };
+            };
+            environment: {
+                sys: {
+                    id: string;
+                    type: string;
+                    linkType: string;
+                };
+            };
+        };
+        name: string;
+        code: string;
+        internal_code: string;
+        fallbackCode: null;
+        contentDeliveryApi: boolean;
+        contentManagementApi: boolean;
+        default: boolean;
+        optional: boolean;
+    }[];
+};
+export { englishDefault, german, list };

package/dist/types/__fixtures__/space/index.d.ts

@@ -0,0 +1,2 @@
+import indifferent from './indifferent_space.json';
+export { indifferent };

package/dist/{constants → types/constants}/Schema.d.ts

@@ -1,111 +1,111 @@
-import { BLOCKS, INLINES } from '@contentful/rich-text-types';
-declare const _default: {
-    document: {
-        nodes: {
-            types: {
-                type: import("@contentful/rich-text-types").TopLevelBlockEnum;
-            }[];
-        }[];
-    };
-    blocks: {
-        blockquote: {
-            nodes: {
-                match: {
-                    type: BLOCKS;
-                }[][];
-                min: number;
-            }[];
-            normalize: (editor: any, error: any) => any;
-        };
-        paragraph: {
-            nodes: {
-                match: ({
-                    type: INLINES;
-                } | {
-                    object: string;
-                })[];
-            }[];
-        };
-        "heading-1": {
-            nodes: {
-                match: ({
-                    type: INLINES;
-                } | {
-                    object: string;
-                })[];
-            }[];
-        };
-        "heading-2": {
-            nodes: {
-                match: ({
-                    type: INLINES;
-                } | {
-                    object: string;
-                })[];
-            }[];
-        };
-        "heading-3": {
-            nodes: {
-                match: ({
-                    type: INLINES;
-                } | {
-                    object: string;
-                })[];
-            }[];
-        };
-        "heading-4": {
-            nodes: {
-                match: ({
-                    type: INLINES;
-                } | {
-                    object: string;
-                })[];
-            }[];
-        };
-        "heading-5": {
-            nodes: {
-                match: ({
-                    type: INLINES;
-                } | {
-                    object: string;
-                })[];
-            }[];
-        };
-        "heading-6": {
-            nodes: {
-                match: ({
-                    type: INLINES;
-                } | {
-                    object: string;
-                })[];
-            }[];
-        };
-    };
-    inlines: {
-        hyperlink: {
-            nodes: {
-                match: {
-                    object: string;
-                }[];
-            }[];
-        };
-        "entry-hyperlink": {
-            nodes: {
-                match: {
-                    object: string;
-                }[];
-            }[];
-        };
-        "asset-hyperlink": {
-            nodes: {
-                match: {
-                    object: string;
-                }[];
-            }[];
-        };
-        "embedded-entry-inline": {
-            isVoid: boolean;
-        };
-    };
-};
-export default _default;
+import { BLOCKS, INLINES } from '@contentful/rich-text-types';
+declare const _default: {
+    document: {
+        nodes: {
+            types: {
+                type: import("@contentful/rich-text-types").TopLevelBlockEnum;
+            }[];
+        }[];
+    };
+    blocks: {
+        blockquote: {
+            nodes: {
+                match: {
+                    type: BLOCKS;
+                }[][];
+                min: number;
+            }[];
+            normalize: (editor: any, error: any) => any;
+        };
+        paragraph: {
+            nodes: {
+                match: ({
+                    type: INLINES;
+                } | {
+                    object: string;
+                })[];
+            }[];
+        };
+        "heading-1": {
+            nodes: {
+                match: ({
+                    type: INLINES;
+                } | {
+                    object: string;
+                })[];
+            }[];
+        };
+        "heading-2": {
+            nodes: {
+                match: ({
+                    type: INLINES;
+                } | {
+                    object: string;
+                })[];
+            }[];
+        };
+        "heading-3": {
+            nodes: {
+                match: ({
+                    type: INLINES;
+                } | {
+                    object: string;
+                })[];
+            }[];
+        };
+        "heading-4": {
+            nodes: {
+                match: ({
+                    type: INLINES;
+                } | {
+                    object: string;
+                })[];
+            }[];
+        };
+        "heading-5": {
+            nodes: {
+                match: ({
+                    type: INLINES;
+                } | {
+                    object: string;
+                })[];
+            }[];
+        };
+        "heading-6": {
+            nodes: {
+                match: ({
+                    type: INLINES;
+                } | {
+                    object: string;
+                })[];
+            }[];
+        };
+    };
+    inlines: {
+        hyperlink: {
+            nodes: {
+                match: {
+                    object: string;
+                }[];
+            }[];
+        };
+        "entry-hyperlink": {
+            nodes: {
+                match: {
+                    object: string;
+                }[];
+            }[];
+        };
+        "asset-hyperlink": {
+            nodes: {
+                match: {
+                    object: string;
+                }[];
+            }[];
+        };
+        "embedded-entry-inline": {
+            isVoid: boolean;
+        };
+    };
+};
+export default _default;

package/dist/{dialogs → types/dialogs}/HypelinkDialog/HyperlinkDialog.d.ts

@@ -1,54 +1,63 @@
-export namespace LINK_TYPES {
-    const URI: string;
-    const ENTRY: string;
-    const ASSET: string;
-}
-export class HyperlinkDialog extends React.Component<any, any, any> {
-    static propTypes: {
-        sdk: PropTypes.Validator<object>;
-        labels: PropTypes.Requireable<PropTypes.InferProps<{
-            title: PropTypes.Requireable<string>;
-            confirm: PropTypes.Requireable<string>;
-        }>>;
-        value: PropTypes.Requireable<PropTypes.InferProps<{
-            text: PropTypes.Requireable<string>;
-            uri: PropTypes.Requireable<string>;
-            target: PropTypes.Requireable<object>;
-            type: PropTypes.Requireable<string>;
-        }>>;
-        entitySelectorConfigs: PropTypes.Requireable<object>;
-        allowedHyperlinkTypes: PropTypes.Requireable<(string | null | undefined)[]>;
-        hideText: PropTypes.Requireable<boolean>;
-        onClose: PropTypes.Validator<(...args: any[]) => any>;
-    };
-    static defaultProps: {
-        labels: {
-            title: string;
-            confirm: string;
-        };
-        value: {};
-        hideText: boolean;
-        entitySelectorConfigs: {};
-        allowedHyperlinkTypes: string[];
-    };
-    constructor(props: any);
-    setTargetEntity(type: any, entity: any): void;
-    getValue(): {
-        type: any;
-    };
-    isLinkComplete(): any;
-    handleSubmit: (event: any) => void;
-    selectEntry: () => Promise<void>;
-    selectAsset: () => Promise<void>;
-    renderFields(): JSX.Element;
-    renderEntityField(): JSX.Element;
-    renderEntitySelector(type: any): JSX.Element;
-}
-export function openHyperlinkDialog(dialogs: any, { value, showTextInput, allowedHyperlinkTypes, entitySelectorConfigs }: {
-    value: any;
-    showTextInput: any;
-    allowedHyperlinkTypes: any;
-    entitySelectorConfigs: any;
-}): any;
-import React from "react";
-import PropTypes from "prop-types";
+export namespace LINK_TYPES {
+    let URI: string;
+    let ENTRY: string;
+    let ASSET: string;
+}
+export class HyperlinkDialog extends React.Component<any, any, any> {
+    static propTypes: {
+        sdk: PropTypes.Validator<object>;
+        labels: PropTypes.Requireable<PropTypes.InferProps<{
+            title: PropTypes.Requireable<string>;
+            confirm: PropTypes.Requireable<string>;
+        }>>;
+        value: PropTypes.Requireable<PropTypes.InferProps<{
+            text: PropTypes.Requireable<string>;
+            uri: PropTypes.Requireable<string>;
+            target: PropTypes.Requireable<object>;
+            type: PropTypes.Requireable<string>;
+        }>>;
+        entitySelectorConfigs: PropTypes.Requireable<object>;
+        allowedHyperlinkTypes: PropTypes.Requireable<(string | null | undefined)[]>;
+        hideText: PropTypes.Requireable<boolean>;
+        onClose: PropTypes.Validator<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        labels: {
+            title: string;
+            confirm: string;
+        };
+        value: {};
+        hideText: boolean;
+        entitySelectorConfigs: {};
+        allowedHyperlinkTypes: string[];
+    };
+    constructor(props: any);
+    state: {
+        text: any;
+        uri: any;
+        entityLinks: {
+            [x: string]: null;
+        };
+        type: any;
+    };
+    setTargetEntity(type: any, entity: any): void;
+    getValue(): {
+        type: any;
+    };
+    isLinkComplete(): any;
+    handleSubmit: (event: any) => void;
+    selectEntry: () => Promise<void>;
+    selectAsset: () => Promise<void>;
+    render(): React.JSX.Element;
+    renderFields(): React.JSX.Element;
+    renderEntityField(): React.JSX.Element;
+    renderEntitySelector(type: any): React.JSX.Element;
+}
+export function openHyperlinkDialog(dialogs: any, { value, showTextInput, allowedHyperlinkTypes, entitySelectorConfigs }: {
+    value: any;
+    showTextInput: any;
+    allowedHyperlinkTypes: any;
+    entitySelectorConfigs: any;
+}): any;
+import * as React from 'react';
+import PropTypes from 'prop-types';

package/dist/{dialogs → types/dialogs}/openRichTextDialog.d.ts

@@ -1,2 +1,2 @@
-import { DialogExtensionSDK } from '@contentful/app-sdk';
-export declare const openRichTextDialog: (sdk: DialogExtensionSDK) => (options: any) => Promise<unknown>;
+import { DialogExtensionSDK } from '@contentful/app-sdk';
+export declare const openRichTextDialog: (sdk: DialogExtensionSDK) => (options: any) => Promise<unknown>;

package/dist/{dialogs → types/dialogs}/renderRichTextDialog.d.ts

@@ -1,2 +1,3 @@
-import { DialogExtensionSDK } from '@contentful/app-sdk';
-export declare const renderRichTextDialog: (sdk: DialogExtensionSDK) => JSX.Element;
+import * as React from 'react';
+import { DialogExtensionSDK } from '@contentful/app-sdk';
+export declare const renderRichTextDialog: (sdk: DialogExtensionSDK) => React.JSX.Element;

package/dist/types/helpers/__tests__/extractNodes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/helpers/__tests__/removeInternalMarks.test.d.ts

@@ -0,0 +1,2 @@
+/** @jsx jsx */
+export {};

package/dist/types/helpers/__tests__/validations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{helpers → types/helpers}/editor.d.ts

@@ -1,40 +1,40 @@
-import { Link } from '@contentful/field-editor-reference/dist/types';
-import { BLOCKS, INLINES } from '@contentful/rich-text-types';
-import { EditorNodesOptions, ToggleNodeTypeOptions, Node, Path } from '../internal/types';
-import { Element, PlateEditor } from '../internal/types';
-export declare const LINK_TYPES: INLINES[];
-export declare function isBlockSelected(editor: PlateEditor, type: string): boolean;
-export declare function isRootLevel(path: Path): boolean;
-declare type NodeEntry = [Element, Path];
-declare type NodeType = BLOCKS | INLINES;
-export declare function getNodeEntryFromSelection(editor: PlateEditor, nodeTypeOrTypes: NodeType | NodeType[], path?: Path): NodeEntry | [];
-export declare function isNodeTypeSelected(editor: PlateEditor | null, nodeType: BLOCKS | INLINES): boolean;
-export declare function moveToTheNextLine(editor: PlateEditor): void;
-export declare function moveToTheNextChar(editor: PlateEditor): void;
-export declare function insertEmptyParagraph(editor: PlateEditor, options?: any): void;
-export declare function getElementFromCurrentSelection(editor: PlateEditor): (import("@udecode/plate-core").ENode<import("@udecode/plate-core").Value> | import("slate").Path)[];
-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;
-    url?: string;
-    target?: Link;
-    path?: Path;
-}
-export declare function insertLink(editor: any, options: InsertLinkOptions): void;
-export declare function isLinkActive(editor?: PlateEditor | null): boolean;
-export declare function unwrapLink(editor: any): void;
-export declare function wrapLink(editor: any, { text, url, target, type, path }: InsertLinkOptions): void;
-export declare function getAncestorPathFromSelection(editor: PlateEditor): import("slate").Path | undefined;
-export declare const isAtEndOfTextSelection: (editor: PlateEditor) => boolean;
-/**
- * This traversal strategy is unfortunately necessary because Slate doesn't
- * expose something like Node.next(editor).
- */
-export declare function getNextNode(editor: PlateEditor): Element | null;
-export declare const INLINE_TYPES: string[];
-export declare const isInlineOrText: (node: Node) => boolean;
-export declare const focus: (editor: PlateEditor) => void;
-export declare function toggleElement(editor: PlateEditor, options: ToggleNodeTypeOptions, editorOptions?: EditorNodesOptions): void;
-export {};
+import { Link } from '@contentful/field-editor-reference';
+import { BLOCKS, INLINES } from '@contentful/rich-text-types';
+import { EditorNodesOptions, ToggleNodeTypeOptions, Node, Path } from '../internal/types';
+import { Element, PlateEditor } from '../internal/types';
+export declare const LINK_TYPES: INLINES[];
+export declare function isBlockSelected(editor: PlateEditor, type: string): boolean;
+export declare function isRootLevel(path: Path): boolean;
+type NodeEntry = [Element, Path];
+type NodeType = BLOCKS | INLINES;
+export declare function getNodeEntryFromSelection(editor: PlateEditor, nodeTypeOrTypes: NodeType | NodeType[], path?: Path): NodeEntry | [];
+export declare function isNodeTypeSelected(editor: PlateEditor | null, nodeType: BLOCKS | INLINES): boolean;
+export declare function moveToTheNextLine(editor: PlateEditor): void;
+export declare function moveToTheNextChar(editor: PlateEditor): void;
+export declare function insertEmptyParagraph(editor: PlateEditor, options?: any): void;
+export declare function getElementFromCurrentSelection(editor: PlateEditor): (import("slate").Path | import("@udecode/plate-core").ENode<import("@udecode/plate-core").Value>)[];
+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;
+    url?: string;
+    target?: Link;
+    path?: Path;
+}
+export declare function insertLink(editor: any, options: InsertLinkOptions): void;
+export declare function isLinkActive(editor?: PlateEditor | null): boolean;
+export declare function unwrapLink(editor: any): void;
+export declare function wrapLink(editor: any, { text, url, target, type, path }: InsertLinkOptions): void;
+export declare function getAncestorPathFromSelection(editor: PlateEditor): import("slate").Path | undefined;
+export declare const isAtEndOfTextSelection: (editor: PlateEditor) => boolean;
+/**
+ * This traversal strategy is unfortunately necessary because Slate doesn't
+ * expose something like Node.next(editor).
+ */
+export declare function getNextNode(editor: PlateEditor): Element | null;
+export declare const INLINE_TYPES: string[];
+export declare const isInlineOrText: (node: Node) => boolean;
+export declare const focus: (editor: PlateEditor) => void;
+export declare function toggleElement(editor: PlateEditor, options: ToggleNodeTypeOptions, editorOptions?: EditorNodesOptions): void;
+export {};

package/dist/{helpers → types/helpers}/environment.d.ts

@@ -1,2 +1,2 @@
-export declare const IS_SAFARI: boolean;
-export declare const IS_CHROME: boolean;
+export declare const IS_SAFARI: boolean;
+export declare const IS_CHROME: boolean;

package/dist/{helpers → types/helpers}/extractNodes.d.ts

@@ -1,5 +1,5 @@
-import { PlateEditor, Node, Path } from '../internal/types';
-/**
- * It filters out all paragraphs and headings from a path and convert them into paragraphs.
- */
-export declare function extractParagraphs(editor: PlateEditor, path: Path): Node[];
+import { PlateEditor, Node, Path } from '../internal/types';
+/**
+ * It filters out all paragraphs and headings from a path and convert them into paragraphs.
+ */
+export declare function extractParagraphs(editor: PlateEditor, path: Path): Node[];

package/dist/{helpers → types/helpers}/formatDateAndTime.d.ts

@@ -1,15 +1,15 @@
-declare type DateFormatFn = (date: Date | string, short?: boolean) => string;
-/**
- * @param {Date|string} date A valid constructor argument for moment()
- * @param {boolean=} short Render only Today/Tomorrow/Yesterday if valid. Defaults to false
- */
-export declare const formatDate: DateFormatFn;
-/**
- * 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 declare const formatTime: DateFormatFn;
-export declare const formatDateAndTime: DateFormatFn;
-export {};
+type DateFormatFn = (date: Date | string, short?: boolean) => string;
+/**
+ * @param {Date|string} date A valid constructor argument for moment()
+ * @param {boolean=} short Render only Today/Tomorrow/Yesterday if valid. Defaults to false
+ */
+export declare const formatDate: DateFormatFn;
+/**
+ * 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 declare const formatTime: DateFormatFn;
+export declare const formatDateAndTime: DateFormatFn;
+export {};

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

@@ -0,0 +1,25 @@
+type AllowedResource = {
+    type: 'Contentful:Entry';
+    source: string;
+    contentTypes: string[];
+};
+/**
+ * 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: any, nodeType: any): AllowedResource[];
+export {};

package/dist/{helpers → types/helpers}/getLinkedContentTypeIdsForNodeType.d.ts

@@ -1,26 +1,26 @@
-/**
- * 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: any, nodeType: any): string[];
+/**
+ * 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: any, nodeType: any): string[];

package/dist/{helpers → types/helpers}/newEntitySelectorConfigFromRichTextField.d.ts

@@ -1,14 +1,14 @@
-/**
- * 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[];
-};
+/**
+ * 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[];
+};