@byline/richtext-lexical 5.2.0 → 6.0.0

package/dist/field/plugins/toolbar-plugin/index.js

@@ -2,11 +2,11 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Fragment as external_react_Fragment, useCallback, useEffect, useMemo, useState } from "react";
 import { $createCodeNode, $isCodeNode, CODE_LANGUAGE_FRIENDLY_NAME_MAP, CODE_LANGUAGE_MAP, CodeNode, getLanguageFriendlyName } from "@lexical/code";
-import { $isListNode, CheckListExtension, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListExtension, ListNode, REMOVE_LIST_COMMAND } from "@lexical/list";
+import { $isListNode, CheckListExtension, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListItemNode, ListNode, REMOVE_LIST_COMMAND } from "@lexical/list";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { $isDecoratorBlockNode } from "@lexical/react/LexicalDecoratorBlockNode";
 import { useExtensionDependency, useOptionalExtensionDependency } from "@lexical/react/useExtensionComponent";
-import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode } from "@lexical/rich-text";
+import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode } from "@lexical/rich-text";
 import { $setBlocksType } from "@lexical/selection";
 import { $isTableNode } from "@lexical/table";
 import { $findMatchingParent, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, mergeRegister } from "@lexical/utils";
@@ -14,8 +14,8 @@ import { $createParagraphNode, $getNodeByKey, $getSelection, $isRangeSelection,
 import { useEditorConfig } from "../../config/editor-config-context.js";
 import { BylineToolbarExtension, selectToolbarItems } from "../../extensions/byline-toolbar/byline-toolbar-extension.js";
 import { $isLinkNode, LinkExtension, OPEN_LINK_MODAL_COMMAND, TOGGLE_LINK_COMMAND } from "../../extensions/link/index.js";
-import { useMarkdownToggle } from "../../hooks/use-markdown-toggle.js";
-import { IS_APPLE } from "../../shared/environment.js";
+import { canUseMarkdownSourceMode, useMarkdownToggle } from "../../hooks/use-markdown-toggle.js";
+import { useIsApplePlatform } from "../../hooks/use-platform-modifier.js";
 import { DropDown, DropDownItem } from "../../ui/dropdown.js";
 import { getSelectedNode } from "../../utils/getSelectedNode.js";
 import { sanitizeUrl } from "../../utils/url.js";
@@ -47,13 +47,32 @@ function dropDownActiveClass(active) {
     if (active) return 'active dropdown-item-active';
     return '';
 }
+function availableBlockFormats(editor, hasCheckListBehaviour) {
+    const formats = [
+        'paragraph'
+    ];
+    if (editor.hasNodes([
+        HeadingNode
+    ])) formats.push('h1', 'h2', 'h3', 'h4');
+    if (editor.hasNodes([
+        ListNode,
+        ListItemNode
+    ])) {
+        formats.push('bullet', 'number');
+        if (hasCheckListBehaviour) formats.push('check');
+    }
+    if (editor.hasNodes([
+        QuoteNode
+    ])) formats.push('quote');
+    if (editor.hasNodes([
+        CodeNode
+    ])) formats.push('code');
+    return formats;
+}
 function BlockFormatDropDown({ editor, blockType, rootType, disabled = false }) {
-    const hasList = void 0 !== useOptionalExtensionDependency(ListExtension);
-    const hasCheckList = void 0 !== useOptionalExtensionDependency(CheckListExtension);
     const [composerEditor] = useLexicalComposerContext();
-    const hasCodeHighlight = composerEditor.hasNodes([
-        CodeNode
-    ]);
+    const hasCheckListBehaviour = void 0 !== useOptionalExtensionDependency(CheckListExtension);
+    const formats = availableBlockFormats(composerEditor, hasCheckListBehaviour);
     const formatParagraph = ()=>{
         editor.update(()=>{
             const selection = $getSelection();
@@ -99,6 +118,7 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
             }
         });
     };
+    if (1 === formats.length) return null;
     return /*#__PURE__*/ jsxs(DropDown, {
         disabled: disabled,
         buttonClassName: "toolbar-item block-controls",
@@ -119,67 +139,71 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
                     })
                 ]
             }),
-            /*#__PURE__*/ jsxs(DropDownItem, {
-                className: `item ${dropDownActiveClass('h1' === blockType)}`,
-                onClick: ()=>{
-                    formatHeading('h1');
-                },
+            formats.includes('h1') && /*#__PURE__*/ jsxs(Fragment, {
                 children: [
-                    /*#__PURE__*/ jsx("i", {
-                        className: "icon h1"
-                    }),
-                    /*#__PURE__*/ jsx("span", {
-                        className: "text",
-                        children: "Heading 1"
-                    })
-                ]
-            }),
-            /*#__PURE__*/ jsxs(DropDownItem, {
-                className: `item ${dropDownActiveClass('h2' === blockType)}`,
-                onClick: ()=>{
-                    formatHeading('h2');
-                },
-                children: [
-                    /*#__PURE__*/ jsx("i", {
-                        className: "icon h2"
+                    /*#__PURE__*/ jsxs(DropDownItem, {
+                        className: `item ${dropDownActiveClass('h1' === blockType)}`,
+                        onClick: ()=>{
+                            formatHeading('h1');
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx("i", {
+                                className: "icon h1"
+                            }),
+                            /*#__PURE__*/ jsx("span", {
+                                className: "text",
+                                children: "Heading 1"
+                            })
+                        ]
                     }),
-                    /*#__PURE__*/ jsx("span", {
-                        className: "text",
-                        children: "Heading 2"
-                    })
-                ]
-            }),
-            /*#__PURE__*/ jsxs(DropDownItem, {
-                className: `item ${dropDownActiveClass('h3' === blockType)}`,
-                onClick: ()=>{
-                    formatHeading('h3');
-                },
-                children: [
-                    /*#__PURE__*/ jsx("i", {
-                        className: "icon h3"
+                    /*#__PURE__*/ jsxs(DropDownItem, {
+                        className: `item ${dropDownActiveClass('h2' === blockType)}`,
+                        onClick: ()=>{
+                            formatHeading('h2');
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx("i", {
+                                className: "icon h2"
+                            }),
+                            /*#__PURE__*/ jsx("span", {
+                                className: "text",
+                                children: "Heading 2"
+                            })
+                        ]
                     }),
-                    /*#__PURE__*/ jsx("span", {
-                        className: "text",
-                        children: "Heading 3"
-                    })
-                ]
-            }),
-            /*#__PURE__*/ jsxs(DropDownItem, {
-                className: `item ${dropDownActiveClass('h4' === blockType)}`,
-                onClick: ()=>{
-                    formatHeading('h4');
-                },
-                children: [
-                    /*#__PURE__*/ jsx("i", {
-                        className: "icon h4"
+                    /*#__PURE__*/ jsxs(DropDownItem, {
+                        className: `item ${dropDownActiveClass('h3' === blockType)}`,
+                        onClick: ()=>{
+                            formatHeading('h3');
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx("i", {
+                                className: "icon h3"
+                            }),
+                            /*#__PURE__*/ jsx("span", {
+                                className: "text",
+                                children: "Heading 3"
+                            })
+                        ]
                     }),
-                    /*#__PURE__*/ jsx("span", {
-                        className: "text",
-                        children: "Heading 4"
+                    /*#__PURE__*/ jsxs(DropDownItem, {
+                        className: `item ${dropDownActiveClass('h4' === blockType)}`,
+                        onClick: ()=>{
+                            formatHeading('h4');
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx("i", {
+                                className: "icon h4"
+                            }),
+                            /*#__PURE__*/ jsx("span", {
+                                className: "text",
+                                children: "Heading 4"
+                            })
+                        ]
                     })
                 ]
             }),
-            hasList && /*#__PURE__*/ jsxs(Fragment, {
+            formats.includes('bullet') && /*#__PURE__*/ jsxs(Fragment, {
                 children: [
                     /*#__PURE__*/ jsxs(DropDownItem, {
                         className: `item ${dropDownActiveClass('bullet' === blockType)}`,
@@ -209,7 +233,7 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
                     })
                 ]
             }),
-            hasCheckList && /*#__PURE__*/ jsxs(DropDownItem, {
+            formats.includes('check') && /*#__PURE__*/ jsxs(DropDownItem, {
                 className: `item ${dropDownActiveClass('check' === blockType)}`,
                 onClick: formatCheckList,
                 children: [
@@ -222,7 +246,7 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
                     })
                 ]
             }),
-            /*#__PURE__*/ jsxs(DropDownItem, {
+            formats.includes('quote') && /*#__PURE__*/ jsxs(DropDownItem, {
                 className: `item ${dropDownActiveClass('quote' === blockType)}`,
                 onClick: formatQuote,
                 children: [
@@ -235,7 +259,7 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
                     })
                 ]
             }),
-            hasCodeHighlight && /*#__PURE__*/ jsxs(DropDownItem, {
+            formats.includes('code') && /*#__PURE__*/ jsxs(DropDownItem, {
                 className: `item ${dropDownActiveClass('code' === blockType)}`,
                 onClick: formatCode,
                 children: [
@@ -284,8 +308,10 @@ function ToolbarPlugin() {
         toolbarConfig.items
     ]);
     const hasLinkExtension = void 0 !== useOptionalExtensionDependency(LinkExtension);
-    const { uuid, config: { options: { textAlignment, undoRedo, textStyle, inlineCode, markdownToggle } } } = useEditorConfig();
+    const { uuid, config: { controls: { textAlignment, undoRedo, blockFormat, inlineCode, markdownToggle } } } = useEditorConfig();
     const { isMarkdown, toggleMarkdown } = useMarkdownToggle();
+    const isApple = useIsApplePlatform();
+    const canToggleMarkdown = canUseMarkdownSourceMode(editor);
     const $updateToolbar = useCallback(()=>{
         const selection = $getSelection();
         if ($isRangeSelection(selection)) {
@@ -434,7 +460,7 @@ function ToolbarPlugin() {
                         onClick: ()=>{
                             activeEditor.dispatchCommand(UNDO_COMMAND, void 0);
                         },
-                        title: IS_APPLE ? 'Undo (⌘Z)' : 'Undo (Ctrl+Z)',
+                        title: isApple ? 'Undo (⌘Z)' : 'Undo (Ctrl+Z)',
                         type: "button",
                         className: "toolbar-item spaced",
                         "aria-label": "Undo",
@@ -447,7 +473,7 @@ function ToolbarPlugin() {
                         onClick: ()=>{
                             activeEditor.dispatchCommand(REDO_COMMAND, void 0);
                         },
-                        title: IS_APPLE ? 'Redo (⌘Y)' : 'Redo (Ctrl+Y)',
+                        title: isApple ? 'Redo (⌘Y)' : 'Redo (Ctrl+Y)',
                         type: "button",
                         className: "toolbar-item",
                         "aria-label": "Redo",
@@ -460,7 +486,7 @@ function ToolbarPlugin() {
             }),
             blockType in blockTypeToBlockName && activeEditor === editor && /*#__PURE__*/ jsxs(Fragment, {
                 children: [
-                    textStyle && /*#__PURE__*/ jsxs(Fragment, {
+                    blockFormat && /*#__PURE__*/ jsxs(Fragment, {
                         children: [
                             /*#__PURE__*/ jsx(BlockFormatDropDown, {
                                 disabled: !isEditable,
@@ -601,9 +627,9 @@ function ToolbarPlugin() {
                             activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND, 'bold');
                         },
                         className: `toolbar-item spaced ${isBold ? 'active' : ''}`,
-                        title: IS_APPLE ? 'Bold (⌘B)' : 'Bold (Ctrl+B)',
+                        title: isApple ? 'Bold (⌘B)' : 'Bold (Ctrl+B)',
                         type: "button",
-                        "aria-label": `Format text as bold. Shortcut: ${IS_APPLE ? '⌘B' : 'Ctrl+B'}`,
+                        "aria-label": `Format text as bold. Shortcut: ${isApple ? '⌘B' : 'Ctrl+B'}`,
                         children: /*#__PURE__*/ jsx("i", {
                             className: "format bold"
                         })
@@ -614,9 +640,9 @@ function ToolbarPlugin() {
                             activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND, 'italic');
                         },
                         className: `toolbar-item spaced ${isItalic ? 'active' : ''}`,
-                        title: IS_APPLE ? 'Italic (⌘I)' : 'Italic (Ctrl+I)',
+                        title: isApple ? 'Italic (⌘I)' : 'Italic (Ctrl+I)',
                         type: "button",
-                        "aria-label": `Format text as italics. Shortcut: ${IS_APPLE ? '⌘I' : 'Ctrl+I'}`,
+                        "aria-label": `Format text as italics. Shortcut: ${isApple ? '⌘I' : 'Ctrl+I'}`,
                         children: /*#__PURE__*/ jsx("i", {
                             className: "format italic"
                         })
@@ -627,9 +653,9 @@ function ToolbarPlugin() {
                             activeEditor.dispatchCommand(FORMAT_TEXT_COMMAND, 'underline');
                         },
                         className: `toolbar-item spaced ${isUnderline ? 'active' : ''}`,
-                        title: IS_APPLE ? 'Underline (⌘U)' : 'Underline (Ctrl+U)',
+                        title: isApple ? 'Underline (⌘U)' : 'Underline (Ctrl+U)',
                         type: "button",
-                        "aria-label": `Format text to underlined. Shortcut: ${IS_APPLE ? '⌘U' : 'Ctrl+U'}`,
+                        "aria-label": `Format text to underlined. Shortcut: ${isApple ? '⌘U' : 'Ctrl+U'}`,
                         children: /*#__PURE__*/ jsx("i", {
                             className: "format underline"
                         })
@@ -759,7 +785,7 @@ function ToolbarPlugin() {
                         children: item.node
                     }, item.id))
             }),
-            markdownToggle && /*#__PURE__*/ jsxs(Fragment, {
+            markdownToggle && canToggleMarkdown && /*#__PURE__*/ jsxs(Fragment, {
                 children: [
                     /*#__PURE__*/ jsx(Divider, {}),
                     /*#__PURE__*/ jsx("button", {
@@ -780,4 +806,4 @@ function ToolbarPlugin() {
         ]
     });
 }
-export { ToolbarPlugin };
+export { ToolbarPlugin, availableBlockFormats };

package/dist/field/test-support/build-test-editor.js

@@ -0,0 +1,49 @@
+import { buildEditorFromExtensions } from "@lexical/extension";
+import { $generateNodesFromDOM } from "@lexical/html";
+import { ReactPluginHostExtension } from "@lexical/react/ReactPluginHostExtension";
+import { defineExtension } from "lexical";
+import { builtInExtensions } from "../config/built-in-extension-names.js";
+import { defaultExtensionsList } from "../config/default-extensions.js";
+import { rootDependencies } from "../config/root-dependencies.js";
+const NAMESPACE = 'LexicalRichText';
+function build(extensions) {
+    return buildEditorFromExtensions(defineExtension({
+        name: '[test-root]',
+        namespace: NAMESPACE,
+        dependencies: [
+            ReactPluginHostExtension,
+            ...rootDependencies(extensions)
+        ]
+    }));
+}
+function buildFullEditor() {
+    return build(defaultExtensionsList());
+}
+function buildRestrictedEditor(removals) {
+    const names = removals ?? [
+        ...Object.values(builtInExtensions),
+        '@lexical/list/List',
+        '@lexical/list/CheckList'
+    ];
+    const list = defaultExtensionsList();
+    for (const name of names)list.remove(name);
+    return build(list);
+}
+function parseHtmlToTypes(editor, html) {
+    const dom = new DOMParser().parseFromString(html, 'text/html');
+    let result = {
+        types: [],
+        text: ''
+    };
+    editor.update(()=>{
+        const nodes = $generateNodesFromDOM(editor, dom);
+        result = {
+            types: nodes.map((node)=>node.getType()),
+            text: nodes.map((node)=>node.getTextContent()).join('|')
+        };
+    }, {
+        discrete: true
+    });
+    return result;
+}
+export { buildFullEditor, buildRestrictedEditor, parseHtmlToTypes };

package/dist/field/test-support/capture-editor.js

@@ -0,0 +1,7 @@
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+function CaptureEditor({ onEditor }) {
+    const [editor] = useLexicalComposerContext();
+    onEditor(editor);
+    return null;
+}
+export { CaptureEditor };

package/dist/field/test-support/frame-control.js

@@ -0,0 +1,40 @@
+function installFrameControl() {
+    const frameCallbacks = [];
+    const idleCallbacks = [];
+    const originalRaf = globalThis.requestAnimationFrame;
+    const originalCaf = globalThis.cancelAnimationFrame;
+    const originalRic = globalThis.requestIdleCallback;
+    const originalCic = globalThis.cancelIdleCallback;
+    globalThis.requestAnimationFrame = (callback)=>{
+        frameCallbacks.push(callback);
+        return frameCallbacks.length;
+    };
+    globalThis.cancelAnimationFrame = ()=>{};
+    globalThis.requestIdleCallback = (callback)=>{
+        idleCallbacks.push(callback);
+        return idleCallbacks.length;
+    };
+    globalThis.cancelIdleCallback = ()=>{};
+    const flushFrames = async (generations = 1)=>{
+        for(let generation = 0; generation < generations; generation++){
+            await Promise.resolve();
+            for (const callback of frameCallbacks.splice(0))callback(performance.now());
+        }
+        await Promise.resolve();
+    };
+    return {
+        flushFrames,
+        flushIdle: ()=>{
+            for (const callback of idleCallbacks.splice(0))callback();
+        },
+        pendingIdle: ()=>idleCallbacks.length,
+        settleBaseline: ()=>flushFrames(2),
+        restore: ()=>{
+            globalThis.requestAnimationFrame = originalRaf;
+            globalThis.cancelAnimationFrame = originalCaf;
+            globalThis.requestIdleCallback = originalRic;
+            globalThis.cancelIdleCallback = originalCic;
+        }
+    };
+}
+export { installFrameControl };

package/dist/field/test-support/jsdom-setup.js

@@ -0,0 +1,21 @@
+if ("u" > typeof window) {
+    if ('function' != typeof window.matchMedia) Object.defineProperty(window, 'matchMedia', {
+        writable: true,
+        value: (query)=>({
+                matches: false,
+                media: query,
+                onchange: null,
+                addListener: ()=>{},
+                removeListener: ()=>{},
+                addEventListener: ()=>{},
+                removeEventListener: ()=>{},
+                dispatchEvent: ()=>false
+            })
+    });
+    if (void 0 === globalThis.ResizeObserver) globalThis.ResizeObserver = class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+    };
+}
+export { };

package/dist/index.d.ts

@@ -9,20 +9,26 @@ export { AutoEmbedExtension } from './field/extensions/auto-embed/auto-embed-ext
 export { type BylineFloatingUIConfig, BylineFloatingUIExtension, type BylineFloatingUIItem, type BylineFloatingUIProps, selectFloatingUIItems, } from './field/extensions/byline-floating-ui/index.js';
 export { type BylineToolbarConfig, BylineToolbarExtension, type BylineToolbarItem, type BylineToolbarPlacement, selectToolbarItems, } from './field/extensions/byline-toolbar/index.js';
 export { CodeHighlightExtension } from './field/extensions/code-highlight/code-highlight-extension.js';
+export { CoreNodesExtension } from './field/extensions/core-nodes/core-nodes-extension.js';
 export { FloatingTextFormatExtension } from './field/extensions/floating-text-format/floating-text-format-extension.js';
+export { HeadingExtension } from './field/extensions/heading/heading-extension.js';
 export { HorizontalRuleExtension } from './field/extensions/horizontal-rule/horizontal-rule-extension.js';
 export { type InlineImageConfig, InlineImageExtension, } from './field/extensions/inline-image/inline-image-extension.js';
 export { LayoutExtension } from './field/extensions/layout/layout-extension.js';
 export { AutoLinkExtension, LinkExtension } from './field/extensions/link/index.js';
+export { QuoteExtension } from './field/extensions/quote/quote-extension.js';
 export { TableExtension } from './field/extensions/table/table-extension.js';
 export { VimeoExtension } from './field/extensions/vimeo/vimeo-extension.js';
 export { YouTubeExtension } from './field/extensions/youtube/youtube-extension.js';
-export { Nodes } from './field/nodes/index.js';
+export { READABLE_NODES } from './field/nodes/index.js';
 export { ToolbarActiveEditorProvider, useToolbarActiveEditor, } from './field/plugins/toolbar-plugin/toolbar-active-editor.js';
 export { lexicalEditor } from './lexical-editor.js';
 export { RichTextField } from './richtext-field.js';
+export { buildManifest, capabilitiesFor, capabilitiesFromEditor } from './scan/capability-manifest.js';
+export { scanDocument, summarise } from './scan/scan-documents.js';
 export { createEmptyEditorState } from './validate/createEmptyEditorState.js';
 export { hasText } from './validate/hasText.js';
 export type { EditorConfig, EditorSettings, EditorSettingsOverride } from './field/config/types.js';
 export type { InlineImageAttributes, Position as InlineImagePosition, SerializedInlineImageNode, } from './field/extensions/inline-image/node-types.js';
 export type { DocumentRelation } from './field/nodes/document-relation.js';
+export type { CapabilityManifest, FieldCapabilities, ScanFinding } from './scan/types.js';

package/dist/index.js

@@ -8,17 +8,22 @@ export { AutoEmbedExtension } from "./field/extensions/auto-embed/auto-embed-ext
 export { BylineFloatingUIExtension, selectFloatingUIItems } from "./field/extensions/byline-floating-ui/index.js";
 export { BylineToolbarExtension, selectToolbarItems } from "./field/extensions/byline-toolbar/index.js";
 export { CodeHighlightExtension } from "./field/extensions/code-highlight/code-highlight-extension.js";
+export { CoreNodesExtension } from "./field/extensions/core-nodes/core-nodes-extension.js";
 export { FloatingTextFormatExtension } from "./field/extensions/floating-text-format/floating-text-format-extension.js";
+export { HeadingExtension } from "./field/extensions/heading/heading-extension.js";
 export { HorizontalRuleExtension } from "./field/extensions/horizontal-rule/horizontal-rule-extension.js";
 export { InlineImageExtension } from "./field/extensions/inline-image/inline-image-extension.js";
 export { LayoutExtension } from "./field/extensions/layout/layout-extension.js";
 export { AutoLinkExtension, LinkExtension } from "./field/extensions/link/index.js";
+export { QuoteExtension } from "./field/extensions/quote/quote-extension.js";
 export { TableExtension } from "./field/extensions/table/table-extension.js";
 export { VimeoExtension } from "./field/extensions/vimeo/vimeo-extension.js";
 export { YouTubeExtension } from "./field/extensions/youtube/youtube-extension.js";
-export { Nodes } from "./field/nodes/index.js";
+export { READABLE_NODES } from "./field/nodes/index.js";
 export { ToolbarActiveEditorProvider, useToolbarActiveEditor } from "./field/plugins/toolbar-plugin/toolbar-active-editor.js";
 export { lexicalEditor } from "./lexical-editor.js";
 export { RichTextField } from "./richtext-field.js";
+export { buildManifest, capabilitiesFor, capabilitiesFromEditor } from "./scan/capability-manifest.js";
+export { scanDocument, summarise } from "./scan/scan-documents.js";
 export { createEmptyEditorState } from "./validate/createEmptyEditorState.js";
 export { hasText } from "./validate/hasText.js";

package/dist/scan/capability-manifest.d.ts

@@ -0,0 +1,30 @@
+import { registeredNodeTypes } from '../field/capabilities/registered-node-types.js';
+import type { EditorConfig } from '../field/config/types.js';
+import type { CapabilityManifest, FieldCapabilities } from './types.js';
+/**
+ * What one field accepts, measured by BUILDING its editor.
+ *
+ * Deliberately not derived by walking declared `nodes` on the extension
+ * list: that would recreate the resolver — dependency-contributed nodes,
+ * conflicts, replacements and always-on core nodes — and a manifest that
+ * disagrees with the runtime is worse than no manifest. This is the same
+ * construction `EditorContext` performs, so the two cannot drift.
+ *
+ * Requires a DOM and a React-capable module graph, because several
+ * extensions host React decorators. It therefore runs in a browser or
+ * jsdom, never in a plain Node script — which is why the manifest is a
+ * file handed to the scanner rather than something the scanner derives.
+ */
+export declare function capabilitiesFor(collectionPath: string, fieldPath: string, config: Pick<EditorConfig, 'extensions' | 'lexical'>): FieldCapabilities;
+/** Assemble a manifest from per-field capabilities. */
+export declare function buildManifest(fields: FieldCapabilities[]): CapabilityManifest;
+/**
+ * What a live editor accepts.
+ *
+ * `capabilitiesFor` needs a resolved `EditorConfig`, which is not always
+ * reachable: `lexicalEditor()` closes over its configure callback inside
+ * a lazy component, so a site's own preset exposes no config to inspect.
+ * Measuring a mounted editor works for any field however its editor was
+ * registered, which is what a manifest walk over real collections needs.
+ */
+export declare function capabilitiesFromEditor(collectionPath: string, fieldPath: string, editor: Parameters<typeof registeredNodeTypes>[0]): FieldCapabilities;

package/dist/scan/capability-manifest.js

@@ -0,0 +1,43 @@
+"use client";
+import { buildEditorFromExtensions } from "@lexical/extension";
+import { ReactPluginHostExtension } from "@lexical/react/ReactPluginHostExtension";
+import { defineExtension } from "lexical";
+import { registeredNodeTypes } from "../field/capabilities/registered-node-types.js";
+import { defaultExtensionsList } from "../field/config/default-extensions.js";
+import { rootDependencies } from "../field/config/root-dependencies.js";
+function capabilitiesFor(collectionPath, fieldPath, config) {
+    const extensions = config.extensions ?? defaultExtensionsList();
+    const editor = buildEditorFromExtensions(defineExtension({
+        name: '[capability-manifest]',
+        namespace: config.lexical?.namespace ?? 'LexicalRichText',
+        dependencies: [
+            ReactPluginHostExtension,
+            ...rootDependencies(extensions)
+        ]
+    }));
+    const supportedTypes = [
+        ...registeredNodeTypes(editor)
+    ].sort();
+    editor.dispose();
+    return {
+        collectionPath,
+        fieldPath,
+        supportedTypes
+    };
+}
+function buildManifest(fields) {
+    return {
+        generatedAt: new Date().toISOString(),
+        fields
+    };
+}
+function capabilitiesFromEditor(collectionPath, fieldPath, editor) {
+    return {
+        collectionPath,
+        fieldPath,
+        supportedTypes: [
+            ...registeredNodeTypes(editor)
+        ].sort()
+    };
+}
+export { buildManifest, capabilitiesFor, capabilitiesFromEditor };

package/dist/scan/scan-documents.d.ts

@@ -0,0 +1,29 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import type { SerializedEditorState } from 'lexical';
+import type { FieldCapabilities, ScanFinding } from './types.js';
+/**
+ * Report what a field's current configuration will do with one stored
+ * value.
+ *
+ * Runs the same `normalizeValue` the editor runs, rather than a parallel
+ * rule set, so the report cannot drift from the behaviour it predicts.
+ * Pure: no database, no DOM, no editor.
+ */
+export declare function scanDocument(value: SerializedEditorState | null | undefined, capabilities: FieldCapabilities, ids: {
+    documentId: string;
+    versionId: string;
+    locale?: string;
+    instancePath?: string;
+}): ScanFinding | undefined;
+/** Group findings for a report: what will adapt, and what will open read-only. */
+export declare function summarise(findings: ScanFinding[]): {
+    adapted: ScanFinding[];
+    refused: ScanFinding[];
+    unmapped: ScanFinding[];
+};

package/dist/scan/scan-documents.js

@@ -0,0 +1,39 @@
+import { normalizeValue } from "../field/normalize/normalize-value.js";
+function scanDocument(value, capabilities, ids) {
+    if (null == value) return;
+    if (null == capabilities.supportedTypes) {
+        const unmapped = {
+            collectionPath: capabilities.collectionPath,
+            fieldPath: capabilities.fieldPath,
+            documentId: ids.documentId,
+            versionId: ids.versionId,
+            adaptedTypes: [],
+            refusedTypes: [],
+            unmapped: true
+        };
+        if (null != ids.locale) unmapped.locale = ids.locale;
+        if (null != ids.instancePath) unmapped.instancePath = ids.instancePath;
+        return unmapped;
+    }
+    const result = normalizeValue(value, new Set(capabilities.supportedTypes));
+    if ('unchanged' === result.status) return;
+    const finding = {
+        collectionPath: capabilities.collectionPath,
+        fieldPath: capabilities.fieldPath,
+        documentId: ids.documentId,
+        versionId: ids.versionId,
+        adaptedTypes: 'adapted' === result.status ? result.convertedTypes : [],
+        refusedTypes: 'refused' === result.status ? result.unsupportedTypes : []
+    };
+    if (null != ids.locale) finding.locale = ids.locale;
+    if (null != ids.instancePath) finding.instancePath = ids.instancePath;
+    return finding;
+}
+function summarise(findings) {
+    return {
+        adapted: findings.filter((finding)=>true !== finding.unmapped && 0 === finding.refusedTypes.length),
+        refused: findings.filter((finding)=>true !== finding.unmapped && finding.refusedTypes.length > 0),
+        unmapped: findings.filter((finding)=>true === finding.unmapped)
+    };
+}
+export { scanDocument, summarise };