@contentful/field-editor-rich-text 3.4.21 → 3.5.0

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

@@ -0,0 +1,112 @@
+import { helpers, BLOCKS } from '@contentful/rich-text-types';
+import { getSchemaWithNodeType } from '@contentful/rich-text-types/dist/schemas';
+import Ajv from 'ajv';
+const ajv = new Ajv({
+    allErrors: true,
+    verbose: true
+});
+export function validateRichTextDocument(document) {
+    const validateRootNode = getValidator(BLOCKS.DOCUMENT);
+    const rootNodeIsValid = validateRootNode(removeGrandChildNodes(document));
+    const errors = [];
+    if (rootNodeIsValid) {
+        validateChildNodes(document, [
+            'content'
+        ], errors);
+    } else {
+        buildSchemaErrors(validateRootNode, [], errors);
+    }
+    return errors;
+}
+function validateChildNodes(node, path, errors) {
+    for(let i = 0; i < node.content.length; i++){
+        validateNode(node.content[i], [
+            ...path,
+            i
+        ], errors);
+    }
+}
+function validateNode(node, path, errors) {
+    const validateSchema = getValidator(node.nodeType);
+    const isValid = validateSchema(removeGrandChildNodes(resetChildNodes(node)));
+    if (!isValid) {
+        buildSchemaErrors(validateSchema, path, errors);
+        return;
+    }
+    if (!isLeafNode(node)) {
+        validateChildNodes(node, [
+            ...path,
+            'content'
+        ], errors);
+    }
+}
+function getValidator(nodeType) {
+    const schema = getSchemaWithNodeType(nodeType);
+    const validate = ajv.compile(schema);
+    const validator = (data)=>{
+        validate(data);
+        validator.errors = removeGrandChildrenMinItemsErrors(validate.errors ?? []);
+        return validator.errors.length === 0;
+    };
+    return validator;
+}
+function buildSchemaErrors(validateSchema, _, errors) {
+    const schemaErrors = validateSchema.errors;
+    const constraintError = schemaErrors.find((e)=>e.keyword === 'enum' || e.keyword === 'anyOf');
+    if (constraintError) {
+        errors.push(constraintError);
+        return;
+    }
+    errors.push(...schemaErrors);
+}
+function resetChildNodes(node) {
+    const { content  } = node;
+    if (isLeafNode(node)) {
+        return node;
+    }
+    return Object.assign({}, node, {
+        content: content.map(resetNode)
+    });
+}
+function resetNode(node) {
+    const { nodeType  } = node;
+    if (helpers.isText(node)) {
+        return {
+            nodeType,
+            data: {},
+            value: '',
+            marks: []
+        };
+    }
+    return {
+        nodeType,
+        data: {},
+        content: []
+    };
+}
+function removeGrandChildNodes(node) {
+    const { content  } = node;
+    if (isLeafNode(node)) {
+        return node;
+    }
+    return Object.assign({}, node, {
+        content: content.map(removeChildNodes)
+    });
+}
+function removeChildNodes(node) {
+    if (helpers.isText(node)) {
+        return node;
+    }
+    return Object.assign({}, node, {
+        content: []
+    });
+}
+function isLeafNode(node) {
+    return helpers.isText(node) || !Array.isArray(node.content);
+}
+function removeGrandChildrenMinItemsErrors(errors) {
+    return errors.filter((error)=>{
+        const level = error.instancePath.split('/').length;
+        return !(level > 3 && error.keyword === 'minItems');
+    });
+}

package/dist/esm/useOnValueChanged.js

@@ -0,0 +1,43 @@
+import { useCallback, useMemo } from 'react';
+import { toContentfulDocument } from '@contentful/contentful-slatejs-adapter';
+import { getPlateSelectors } from '@udecode/plate-core';
+import debounce from 'lodash/debounce';
+import schema from './constants/Schema';
+import { removeInternalMarks } from './helpers/removeInternalMarks';
+const isRelevantOperation = (op)=>{
+    if (op.type === 'set_selection') {
+        return false;
+    }
+    return true;
+};
+export const useOnValueChanged = ({ editorId , handler , skip , onSkip  })=>{
+    const onChange = useMemo(()=>debounce((document)=>{
+            const contentfulDocument = toContentfulDocument({
+                document,
+                schema
+            });
+            const cleanedDocument = removeInternalMarks(contentfulDocument);
+            handler?.(cleanedDocument);
+        }, 500), [
+        handler
+    ]);
+    return useCallback((value)=>{
+        const editor = getPlateSelectors(editorId).editor();
+        if (!editor) {
+            throw new Error('Editor change callback called but editor not defined. Editor id: ' + editorId);
+        }
+        const operations = editor?.operations.filter(isRelevantOperation);
+        if (operations.length > 0) {
+            if (skip) {
+                onSkip?.();
+                return;
+            }
+            onChange(value);
+        }
+    }, [
+        editorId,
+        onChange,
+        skip,
+        onSkip
+    ]);
+};

package/dist/{ContentfulEditorProvider.d.ts → types/ContentfulEditorProvider.d.ts}

@@ -1,9 +1,9 @@
-/// <reference types="react" />
-import { FieldExtensionSDK } from '@contentful/app-sdk';
-import { PlateEditor } from './internal/types';
-export declare function getContentfulEditorId(sdk: FieldExtensionSDK): string;
-export declare const editorContext: import("react").Context<string>;
-export declare const ContentfulEditorIdProvider: import("react").Provider<string>;
-export declare function useContentfulEditorId(id?: string): string;
-export declare function useContentfulEditor(id?: string): PlateEditor | null;
-export declare function useContentfulEditorRef(id?: string): PlateEditor | null;
+/// <reference types="react" />
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+import { PlateEditor } from './internal/types';
+export declare function getContentfulEditorId(sdk: FieldExtensionSDK): string;
+export declare const editorContext: import("react").Context<string>;
+export declare const ContentfulEditorIdProvider: import("react").Provider<string>;
+export declare function useContentfulEditorId(id?: string): string;
+export declare function useContentfulEditor(id?: string): PlateEditor | null;
+export declare function useContentfulEditorRef(id?: string): PlateEditor | null;

package/dist/{RichTextEditor.d.ts → types/RichTextEditor.d.ts}

@@ -1,20 +1,21 @@
-import { FieldExtensionSDK } from '@contentful/app-sdk';
-import * as Contentful from '@contentful/rich-text-types';
-import { RichTextTrackingActionHandler } from './plugins/Tracking';
-declare type ConnectedProps = {
-    sdk: FieldExtensionSDK;
-    onAction?: RichTextTrackingActionHandler;
-    minHeight?: string | number;
-    value?: object;
-    isDisabled?: boolean;
-    onChange?: (doc: Contentful.Document) => unknown;
-    isToolbarHidden?: boolean;
-    actionsDisabled?: boolean;
-    restrictedMarks?: string[];
-};
-export declare const ConnectedRichTextEditor: (props: ConnectedProps) => JSX.Element;
-declare type Props = ConnectedProps & {
-    isInitiallyDisabled: boolean;
-};
-declare const RichTextEditor: (props: Props) => JSX.Element;
-export default RichTextEditor;
+import React from 'react';
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+import * as Contentful from '@contentful/rich-text-types';
+import { RichTextTrackingActionHandler } from './plugins/Tracking';
+type ConnectedProps = {
+    sdk: FieldExtensionSDK;
+    onAction?: RichTextTrackingActionHandler;
+    minHeight?: string | number;
+    value?: object;
+    isDisabled?: boolean;
+    onChange?: (doc: Contentful.Document) => unknown;
+    isToolbarHidden?: boolean;
+    actionsDisabled?: boolean;
+    restrictedMarks?: string[];
+};
+export declare const ConnectedRichTextEditor: (props: ConnectedProps) => React.JSX.Element;
+type Props = ConnectedProps & {
+    isInitiallyDisabled: boolean;
+};
+declare const RichTextEditor: (props: Props) => React.JSX.Element;
+export default RichTextEditor;

package/dist/{RichTextEditor.styles.d.ts → types/RichTextEditor.styles.d.ts}

@@ -1,7 +1,7 @@
-export declare const styles: {
-    root: string;
-    editor: string;
-    hiddenToolbar: string;
-    enabled: string;
-    disabled: string;
-};
+export declare const styles: {
+    root: string;
+    editor: string;
+    hiddenToolbar: string;
+    enabled: string;
+    disabled: string;
+};

package/dist/{SdkProvider.d.ts → types/SdkProvider.d.ts}

@@ -1,7 +1,7 @@
-import * as React from 'react';
-import { FieldExtensionSDK } from '@contentful/app-sdk';
-interface SdkProviderProps {
-    sdk: FieldExtensionSDK;
-}
-export declare const SdkProvider: React.FC<SdkProviderProps>, useSdkContext: () => FieldExtensionSDK;
-export {};
+import * as React from 'react';
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+interface SdkProviderProps {
+    sdk: FieldExtensionSDK;
+}
+export declare const SdkProvider: React.FC<SdkProviderProps>, useSdkContext: () => import("@contentful/app-sdk").FieldAppSDK;
+export {};

package/dist/types/Toolbar/_tests_/toolbar.test.d.ts

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

package/dist/{Toolbar → types/Toolbar}/components/EmbedEntityWidget.d.ts

@@ -1,5 +1,6 @@
-export interface EmbedEntityWidgetProps {
-    isDisabled?: boolean;
-    canInsertBlocks?: boolean;
-}
-export declare const EmbedEntityWidget: ({ isDisabled, canInsertBlocks }: EmbedEntityWidgetProps) => JSX.Element | null;
+import React from 'react';
+export interface EmbedEntityWidgetProps {
+    isDisabled?: boolean;
+    canInsertBlocks?: boolean;
+}
+export declare const EmbedEntityWidget: ({ isDisabled, canInsertBlocks }: EmbedEntityWidgetProps) => React.JSX.Element | null;

package/dist/{Toolbar → types/Toolbar}/components/EmbeddedEntityDropdownButton.d.ts

@@ -1,9 +1,9 @@
-import * as React from 'react';
-export interface EmbeddedEntityDropdownButtonProps {
-    children: React.ReactNode;
-    isDisabled: boolean | undefined;
-    isOpen: boolean;
-    onClose: () => void;
-    onToggle: () => void;
-}
-export declare function EmbeddedEntityDropdownButton({ children, isDisabled, isOpen, onClose, onToggle, }: EmbeddedEntityDropdownButtonProps): JSX.Element;
+import * as React from 'react';
+export interface EmbeddedEntityDropdownButtonProps {
+    children: React.ReactNode;
+    isDisabled: boolean | undefined;
+    isOpen: boolean;
+    onClose: () => void;
+    onToggle: () => void;
+}
+export declare function EmbeddedEntityDropdownButton({ children, isDisabled, isOpen, onClose, onToggle, }: EmbeddedEntityDropdownButtonProps): React.JSX.Element;

package/dist/{Toolbar → types/Toolbar}/components/StickyToolbarWrapper.d.ts

@@ -1,7 +1,7 @@
-import { ReactNode } from 'react';
-declare type StickyToolbarProps = {
-    isDisabled?: boolean;
-    children: ReactNode;
-};
-declare const StickyToolbarWrapper: ({ isDisabled, children }: StickyToolbarProps) => JSX.Element;
-export default StickyToolbarWrapper;
+import React, { ReactNode } from 'react';
+type StickyToolbarProps = {
+    isDisabled?: boolean;
+    children: ReactNode;
+};
+declare const StickyToolbarWrapper: ({ isDisabled, children }: StickyToolbarProps) => React.JSX.Element;
+export default StickyToolbarWrapper;

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

@@ -0,0 +1,6 @@
+import * as React from 'react';
+type ToolbarProps = {
+    isDisabled?: boolean;
+};
+declare const Toolbar: ({ isDisabled }: ToolbarProps) => React.JSX.Element;
+export default Toolbar;

package/dist/types/__fixtures__/FakeSdk.d.ts

@@ -0,0 +1,8 @@
+import { FieldExtensionSDK } from '@contentful/app-sdk';
+import { Emitter } from 'mitt';
+export type ReferenceEditorSdkProps = {
+    initialValue?: any;
+    validations?: any;
+    fetchDelay?: number;
+};
+export declare function newReferenceEditorFakeSdk(props?: ReferenceEditorSdkProps): [FieldExtensionSDK, Emitter];

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

@@ -0,0 +1,6 @@
+import changed from './changed_asset.json';
+import created from './created_asset.json';
+import empty from './empty_asset.json';
+import invalid from './invalid_asset.json';
+import published from './published_asset.json';
+export { changed, empty, published, invalid, created };

package/dist/types/__fixtures__/content-type/index.d.ts

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

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

@@ -0,0 +1,5 @@
+import changed from './changed_entry.json';
+import empty from './empty_entry.json';
+import invalid from './invalid_entry.json';
+import published from './published_entry.json';
+export { changed, empty, published, invalid };

package/dist/types/__fixtures__/fixtures.d.ts

@@ -0,0 +1,6 @@
+import * as assets from './asset';
+import * as contentTypes from './content-type';
+import * as entries from './entry';
+import * as locales from './locale';
+import * as spaces from './space';
+export { assets, contentTypes, entries, locales, spaces };

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;