@byline/richtext-lexical 1.11.2 → 1.12.1

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

@@ -1,29 +1,24 @@
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { Fragment as external_react_Fragment, useCallback, useEffect, useState } from "react";
-import { $createCodeNode, $isCodeNode, CODE_LANGUAGE_FRIENDLY_NAME_MAP, CODE_LANGUAGE_MAP, getLanguageFriendlyName } from "@lexical/code";
-import { $isListNode, INSERT_CHECK_LIST_COMMAND, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, ListNode, REMOVE_LIST_COMMAND } from "@lexical/list";
-import { INSERT_EMBED_COMMAND } from "@lexical/react/LexicalAutoEmbedPlugin";
+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 { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { $isDecoratorBlockNode } from "@lexical/react/LexicalDecoratorBlockNode";
-import { INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/react/LexicalHorizontalRuleNode";
+import { useExtensionDependency, useOptionalExtensionDependency } from "@lexical/react/useExtensionComponent";
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode } from "@lexical/rich-text";
 import { $setBlocksType } from "@lexical/selection";
 import { $isTableNode } from "@lexical/table";
 import { $findMatchingParent, $getNearestBlockElementAncestorOrThrow, $getNearestNodeOfType, mergeRegister } from "@lexical/utils";
 import { $createParagraphNode, $getNodeByKey, $getSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, CAN_REDO_COMMAND, CAN_UNDO_COMMAND, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_NORMAL, FORMAT_ELEMENT_COMMAND, FORMAT_TEXT_COMMAND, INDENT_CONTENT_COMMAND, KEY_MODIFIER_COMMAND, OUTDENT_CONTENT_COMMAND, REDO_COMMAND, SELECTION_CHANGE_COMMAND, UNDO_COMMAND } from "lexical";
 import { useEditorConfig } from "../../config/editor-config-context.js";
-import { $isLinkNode, OPEN_LINK_MODAL_COMMAND, TOGGLE_LINK_COMMAND } from "../../nodes/link-nodes/index.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 { IS_APPLE } from "../../shared/environment.js";
-import { useToolbarExtensions } from "../../toolbar-extensions.js";
 import { DropDown, DropDownItem } from "../../ui/dropdown.js";
 import { getSelectedNode } from "../../utils/getSelectedNode.js";
 import { sanitizeUrl } from "../../utils/url.js";
-import { OPEN_ADMONITION_MODAL_COMMAND } from "../admonition-plugin/index.js";
-import { EmbedConfigs } from "../auto-embed-plugin/index.js";
-import { OPEN_INLINE_IMAGE_MODAL_COMMAND } from "../inline-image-plugin/index.js";
-import { OPEN_INSERT_LAYOUT_MODAL_COMMAND } from "../layout-plugin/layout-plugin.js";
-import { OPEN_TABLE_MODAL_COMMAND } from "../table-plugin/index.js";
+import { ToolbarActiveEditorProvider } from "./toolbar-active-editor.js";
 const blockTypeToBlockName = {
     bullet: 'Bulleted List',
     check: 'Check List',
@@ -52,7 +47,12 @@ function dropDownActiveClass(active) {
     return '';
 }
 function BlockFormatDropDown({ editor, blockType, rootType, disabled = false }) {
-    const { config: { options: { checkListPlugin, listPlugin, codeHighlightPlugin } } } = useEditorConfig();
+    const hasList = void 0 !== useOptionalExtensionDependency(ListExtension);
+    const hasCheckList = void 0 !== useOptionalExtensionDependency(CheckListExtension);
+    const [composerEditor] = useLexicalComposerContext();
+    const hasCodeHighlight = composerEditor.hasNodes([
+        CodeNode
+    ]);
     const formatParagraph = ()=>{
         editor.update(()=>{
             const selection = $getSelection();
@@ -178,7 +178,7 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
                     })
                 ]
             }),
-            listPlugin && /*#__PURE__*/ jsxs(Fragment, {
+            hasList && /*#__PURE__*/ jsxs(Fragment, {
                 children: [
                     /*#__PURE__*/ jsxs(DropDownItem, {
                         className: `item ${dropDownActiveClass('bullet' === blockType)}`,
@@ -208,7 +208,7 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
                     })
                 ]
             }),
-            checkListPlugin && /*#__PURE__*/ jsxs(DropDownItem, {
+            hasCheckList && /*#__PURE__*/ jsxs(DropDownItem, {
                 className: `item ${dropDownActiveClass('check' === blockType)}`,
                 onClick: formatCheckList,
                 children: [
@@ -234,7 +234,7 @@ function BlockFormatDropDown({ editor, blockType, rootType, disabled = false })
                     })
                 ]
             }),
-            codeHighlightPlugin && /*#__PURE__*/ jsxs(DropDownItem, {
+            hasCodeHighlight && /*#__PURE__*/ jsxs(DropDownItem, {
                 className: `item ${dropDownActiveClass('code' === blockType)}`,
                 onClick: formatCode,
                 children: [
@@ -275,8 +275,15 @@ function ToolbarPlugin() {
     const [isRTL, _setIsRTL] = useState(false);
     const [codeLanguage, setCodeLanguage] = useState('');
     const [isEditable, setIsEditable] = useState(()=>editor.isEditable());
-    const { items: toolbarExtensionItems } = useToolbarExtensions();
-    const { uuid, config: { options: { textAlignment, tablePlugin, inlineImagePlugin, admonitionPlugin, horizontalRulePlugin, layoutPlugin, autoEmbedPlugin, undoRedo, textStyle, inlineCode, links } } } = useEditorConfig();
+    const { config: toolbarConfig } = useExtensionDependency(BylineToolbarExtension);
+    const insertMenuItems = useMemo(()=>selectToolbarItems(toolbarConfig.items, 'insert-menu'), [
+        toolbarConfig.items
+    ]);
+    const trailingToolbarItems = useMemo(()=>selectToolbarItems(toolbarConfig.items, 'toolbar'), [
+        toolbarConfig.items
+    ]);
+    const hasLinkExtension = void 0 !== useOptionalExtensionDependency(LinkExtension);
+    const { uuid, config: { options: { textAlignment, undoRedo, textStyle, inlineCode } } } = useEditorConfig();
     const $updateToolbar = useCallback(()=>{
         const selection = $getSelection();
         if ($isRangeSelection(selection)) {
@@ -638,7 +645,7 @@ function ToolbarPlugin() {
                             className: "format code"
                         })
                     }),
-                    links && /*#__PURE__*/ jsx("button", {
+                    hasLinkExtension && /*#__PURE__*/ jsx("button", {
                         type: "button",
                         disabled: !isEditable,
                         onClick: insertLink,
@@ -724,113 +731,32 @@ function ToolbarPlugin() {
                             })
                         ]
                     }),
-                    activeEditor === editor && (horizontalRulePlugin || inlineImagePlugin || tablePlugin || admonitionPlugin) && /*#__PURE__*/ jsxs(Fragment, {
+                    activeEditor === editor && insertMenuItems.length > 0 && /*#__PURE__*/ jsxs(Fragment, {
                         children: [
                             /*#__PURE__*/ jsx(Divider, {}),
-                            /*#__PURE__*/ jsxs(DropDown, {
+                            /*#__PURE__*/ jsx(DropDown, {
                                 disabled: !isEditable,
                                 buttonClassName: "toolbar-item spaced",
                                 buttonLabel: "Insert",
                                 buttonAriaLabel: "Insert specialized editor node",
                                 buttonIconClassName: "icon plus",
-                                children: [
-                                    horizontalRulePlugin && /*#__PURE__*/ jsxs(DropDownItem, {
-                                        onClick: ()=>{
-                                            activeEditor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, void 0);
-                                        },
-                                        className: "item",
-                                        children: [
-                                            /*#__PURE__*/ jsx("i", {
-                                                className: "icon horizontal-rule"
-                                            }),
-                                            /*#__PURE__*/ jsx("span", {
-                                                className: "text",
-                                                children: "Horizontal Rule"
-                                            })
-                                        ]
-                                    }),
-                                    layoutPlugin && /*#__PURE__*/ jsxs(DropDownItem, {
-                                        onClick: ()=>{
-                                            activeEditor.dispatchCommand(OPEN_INSERT_LAYOUT_MODAL_COMMAND, null);
-                                        },
-                                        className: "item",
-                                        children: [
-                                            /*#__PURE__*/ jsx("i", {
-                                                className: "icon columns"
-                                            }),
-                                            /*#__PURE__*/ jsx("span", {
-                                                className: "text",
-                                                children: "Columns Layout"
-                                            })
-                                        ]
-                                    }),
-                                    admonitionPlugin && /*#__PURE__*/ jsxs(DropDownItem, {
-                                        onClick: ()=>{
-                                            activeEditor.dispatchCommand(OPEN_ADMONITION_MODAL_COMMAND, null);
-                                        },
-                                        className: "item",
-                                        children: [
-                                            /*#__PURE__*/ jsx("i", {
-                                                className: "icon admonition"
-                                            }),
-                                            /*#__PURE__*/ jsx("span", {
-                                                className: "text",
-                                                children: "Admonition"
-                                            })
-                                        ]
-                                    }),
-                                    inlineImagePlugin && /*#__PURE__*/ jsxs(DropDownItem, {
-                                        onClick: ()=>{
-                                            activeEditor.dispatchCommand(OPEN_INLINE_IMAGE_MODAL_COMMAND, null);
-                                        },
-                                        className: "item",
-                                        children: [
-                                            /*#__PURE__*/ jsx("i", {
-                                                className: "icon image"
-                                            }),
-                                            /*#__PURE__*/ jsx("span", {
-                                                className: "text",
-                                                children: "Inline Image"
-                                            })
-                                        ]
-                                    }),
-                                    tablePlugin && /*#__PURE__*/ jsxs(DropDownItem, {
-                                        onClick: ()=>{
-                                            activeEditor.dispatchCommand(OPEN_TABLE_MODAL_COMMAND, null);
-                                        },
-                                        className: "item",
-                                        children: [
-                                            /*#__PURE__*/ jsx("i", {
-                                                className: "icon table"
-                                            }),
-                                            /*#__PURE__*/ jsx("span", {
-                                                className: "text",
-                                                children: "Table"
-                                            })
-                                        ]
-                                    }),
-                                    autoEmbedPlugin && EmbedConfigs.map((embedConfig)=>/*#__PURE__*/ jsxs(DropDownItem, {
-                                            onClick: ()=>{
-                                                activeEditor.dispatchCommand(INSERT_EMBED_COMMAND, embedConfig.type);
-                                            },
-                                            className: "item",
-                                            children: [
-                                                embedConfig.icon,
-                                                /*#__PURE__*/ jsx("span", {
-                                                    className: "text",
-                                                    children: embedConfig.contentName
-                                                })
-                                            ]
-                                        }, embedConfig.type))
-                                ]
+                                children: /*#__PURE__*/ jsx(ToolbarActiveEditorProvider, {
+                                    editor: activeEditor,
+                                    children: insertMenuItems.map((item)=>/*#__PURE__*/ jsx(external_react_Fragment, {
+                                            children: item.node
+                                        }, item.id))
+                                })
                             })
                         ]
                     })
                 ]
             }),
-            toolbarExtensionItems.slice().sort((a, b)=>(a.order ?? 0) - (b.order ?? 0)).map((item)=>/*#__PURE__*/ jsx(external_react_Fragment, {
-                    children: item.node
-                }, item.id))
+            /*#__PURE__*/ jsx(ToolbarActiveEditorProvider, {
+                editor: activeEditor,
+                children: trailingToolbarItems.map((item)=>/*#__PURE__*/ jsx(external_react_Fragment, {
+                        children: item.node
+                    }, item.id))
+            })
         ]
     });
 }

package/dist/field/plugins/toolbar-plugin/toolbar-active-editor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 * as React from 'react';
+import type { LexicalEditor } from 'lexical';
+/**
+ * Provider used by the toolbar plugin to expose the *active* Lexical
+ * editor (the editor for the current selection — may be a nested
+ * composer's editor) to contributed toolbar items.
+ */
+export declare function ToolbarActiveEditorProvider({ editor, children, }: {
+    editor: LexicalEditor;
+    children: React.ReactNode;
+}): React.JSX.Element;
+/**
+ * Returns the editor a toolbar contribution should dispatch commands on.
+ * Falls back to the root composer editor when called outside the
+ * toolbar's provider, so contributions remain usable in standalone
+ * test/preview contexts.
+ */
+export declare function useToolbarActiveEditor(): LexicalEditor;

package/dist/field/plugins/toolbar-plugin/toolbar-active-editor.js

@@ -0,0 +1,17 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+const ToolbarActiveEditorContext = /*#__PURE__*/ createContext(null);
+function ToolbarActiveEditorProvider({ editor, children }) {
+    return /*#__PURE__*/ jsx(ToolbarActiveEditorContext.Provider, {
+        value: editor,
+        children: children
+    });
+}
+function useToolbarActiveEditor() {
+    const fromToolbar = useContext(ToolbarActiveEditorContext);
+    const [composerEditor] = useLexicalComposerContext();
+    return fromToolbar ?? composerEditor;
+}
+export { ToolbarActiveEditorProvider, useToolbarActiveEditor };

package/dist/field/themes/lexical-editor-theme.css

@@ -94,7 +94,7 @@
   font-weight: 400;
 }
 
-html[data-theme="dark"] .LexicalEditorTheme__textCode {
+html[data-theme="dark"] .LexicalEditorTheme__textCode, .dark .LexicalEditorTheme__textCode {
   color: #f1f5f9;
   background-color: #1e293b;
   border-color: #495362;
@@ -145,11 +145,11 @@ html[data-theme="dark"] .LexicalEditorTheme__textCode {
   left: 0;
 }
 
-html[data-theme="dark"] .LexicalEditorTheme__code {
+html[data-theme="dark"] .LexicalEditorTheme__code, .dark .LexicalEditorTheme__code {
   background-color: #1a1a1a;
 }
 
-html[data-theme="dark"] .LexicalEditorTheme__code:before {
+html[data-theme="dark"] .LexicalEditorTheme__code:before, .dark .LexicalEditorTheme__code:before {
   color: #777;
   background-color: #161616;
   border-right: 1px solid #ccc;
@@ -165,6 +165,16 @@ html[data-theme="dark"] .LexicalEditorTheme__code:before {
   overflow-y: scroll;
 }
 
+.LexicalEditorTheme__tableScrollableWrapper {
+  margin: 30px 0;
+  overflow-x: auto;
+}
+
+.LexicalEditorTheme__tableScrollableWrapper > .LexicalEditorTheme__table {
+  margin-top: 0;
+  margin-bottom: 0;
+}
+
 .LexicalEditorTheme__tableSelected {
   outline: 2px solid #3c84f4;
 }

package/dist/field/themes/lexical-editor-theme.js

@@ -90,6 +90,7 @@ const theme = {
     tableCellSelected: 'LexicalEditorTheme__tableCellSelected',
     tableCellSortedIndicator: 'LexicalEditorTheme__tableCellSortedIndicator',
     tableResizeRuler: 'LexicalEditorTheme__tableCellResizeRuler',
+    tableScrollableWrapper: 'LexicalEditorTheme__tableScrollableWrapper',
     tableSelected: 'LexicalEditorTheme__tableSelected',
     text: {
         bold: 'LexicalEditorTheme__textBold',

package/dist/index.d.ts

@@ -1,11 +1,27 @@
 export type { SerializedEditor, SerializedEditorState, SerializedElementNode, SerializedLexicalNode, SerializedRootNode, SerializedTextNode, } from 'lexical';
 export { defaultEditorConfig } from './field/config/default';
+export { defaultClientEditorConfig, defaultExtensionsArray, defaultExtensionsList, } from './field/config/default-extensions';
+export { ExtensionsList } from './field/config/extensions-list';
 export { EditorField } from './field/editor-field';
+export { AdmonitionExtension } from './field/extensions/admonition/admonition-extension';
+export { AutoEmbedExtension } from './field/extensions/auto-embed/auto-embed-extension';
+export { type BylineFloatingUIConfig, BylineFloatingUIExtension, type BylineFloatingUIItem, type BylineFloatingUIProps, selectFloatingUIItems, } from './field/extensions/byline-floating-ui';
+export { type BylineToolbarConfig, BylineToolbarExtension, type BylineToolbarItem, type BylineToolbarPlacement, selectToolbarItems, } from './field/extensions/byline-toolbar';
+export { CodeHighlightExtension } from './field/extensions/code-highlight/code-highlight-extension';
+export { FloatingTextFormatExtension } from './field/extensions/floating-text-format/floating-text-format-extension';
+export { HorizontalRuleExtension } from './field/extensions/horizontal-rule/horizontal-rule-extension';
+export { type InlineImageConfig, InlineImageExtension, } from './field/extensions/inline-image/inline-image-extension';
+export { LayoutExtension } from './field/extensions/layout/layout-extension';
+export { AutoLinkExtension, LinkExtension } from './field/extensions/link';
+export { TableExtension } from './field/extensions/table/table-extension';
+export { VimeoExtension } from './field/extensions/vimeo/vimeo-extension';
+export { YouTubeExtension } from './field/extensions/youtube/youtube-extension';
 export { Nodes } from './field/nodes';
+export { ToolbarActiveEditorProvider, useToolbarActiveEditor, } from './field/plugins/toolbar-plugin/toolbar-active-editor';
 export { lexicalEditor } from './lexical-editor';
 export { RichTextField } from './richtext-field';
 export { createEmptyEditorState } from './validate/createEmptyEditorState';
 export { hasText } from './validate/hasText';
 export type { EditorConfig, EditorSettings, EditorSettingsOverride } from './field/config/types';
+export type { InlineImageAttributes, Position as InlineImagePosition, SerializedInlineImageNode, } from './field/extensions/inline-image/node-types';
 export type { DocumentRelation } from './field/nodes/document-relation';
-export type { InlineImageAttributes, Position as InlineImagePosition, SerializedInlineImageNode, } from './field/nodes/inline-image-node/types';

package/dist/index.js

@@ -1,6 +1,22 @@
 export { defaultEditorConfig } from "./field/config/default.js";
+export { defaultClientEditorConfig, defaultExtensionsArray, defaultExtensionsList } from "./field/config/default-extensions.js";
+export { ExtensionsList } from "./field/config/extensions-list.js";
 export { EditorField } from "./field/editor-field.js";
+export { AdmonitionExtension } from "./field/extensions/admonition/admonition-extension.js";
+export { AutoEmbedExtension } from "./field/extensions/auto-embed/auto-embed-extension.js";
+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 { FloatingTextFormatExtension } from "./field/extensions/floating-text-format/floating-text-format-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 { 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 { ToolbarActiveEditorProvider, useToolbarActiveEditor } from "./field/plugins/toolbar-plugin/toolbar-active-editor.js";
 export { lexicalEditor } from "./lexical-editor.js";
 export { RichTextField } from "./richtext-field.js";
 export { createEmptyEditorState } from "./validate/createEmptyEditorState.js";

package/dist/lexical-editor.d.ts

@@ -6,30 +6,42 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type { RichTextEditorComponent } from '@byline/core';
+import type { ExtensionsList } from './field/config/extensions-list';
 import type { EditorConfig } from './field/config/types';
 /**
- * Returns a `RichTextEditorComponent` with editor settings baked in. Use this
- * at the registration site in your admin config when you want to
- * customise the editor across the whole installation; per-field overrides
- * via `RichTextField.editorConfig` continue to take precedence at render time.
+ * Inside `lexicalEditor((c) => ...)` the seed always carries an
+ * `ExtensionsList`, so narrow the callback parameter so callers can write
+ * `c.extensions.add(...)` without a non-null assertion.
+ */
+export type LexicalEditorConfigureInput = Omit<EditorConfig, 'extensions'> & {
+    extensions: ExtensionsList;
+};
+/**
+ * Returns a `RichTextEditorComponent` with editor settings baked in. Use
+ * this at the registration site in your admin config when you want to
+ * customise the editor across the whole installation; per-field
+ * overrides via `RichTextField.editorConfig` continue to take precedence
+ * at render time.
  *
- * The `configure` callback receives a deep clone of `defaultEditorConfig` —
- * mutate and return, or return a new object. Mutating the input is safe
- * because the clone is local to this call.
+ * The `configure` callback receives a deep clone of `defaultEditorConfig`
+ * with `extensions` populated from `defaultExtensionsList()`. Mutate the
+ * clone freely — it's local to this call. Use the chainable
+ * `c.extensions.add(...)`, `.remove(...)`, `.replace(...)`, and
+ * `.configure(...)` methods to manipulate the extension graph.
  *
- * Calling `lexicalEditor()` with no argument is equivalent to registering
- * `RichTextField` directly.
+ * Calling `lexicalEditor()` with no argument is equivalent to
+ * registering `RichTextField` directly with the package defaults.
  *
  * @example
  * ```ts
- * import { lexicalEditor } from '@byline/richtext-lexical'
+ * import { lexicalEditor, TableExtension } from '@byline/richtext-lexical'
  *
  * defineClientConfig({
  *   fields: {
  *     richText: {
  *       editor: lexicalEditor((c) => {
- *         c.settings.options.tablePlugin = false
- *         c.settings.options.codeHighlightPlugin = false
+ *         c.extensions.remove(TableExtension)        // drop a built-in
+ *         c.settings.placeholderText = 'Start writing...'
  *         return c
  *       }),
  *     },
@@ -37,4 +49,4 @@ import type { EditorConfig } from './field/config/types';
  * })
  * ```
  */
-export declare function lexicalEditor(configure?: (config: EditorConfig) => EditorConfig): RichTextEditorComponent;
+export declare function lexicalEditor(configure?: (config: LexicalEditorConfigureInput) => LexicalEditorConfigureInput): RichTextEditorComponent;

package/dist/lexical-editor.js

@@ -1,9 +1,17 @@
 import { jsx } from "react/jsx-runtime";
 import { cloneDeep } from "lodash-es";
 import { defaultEditorConfig } from "./field/config/default.js";
+import { defaultExtensionsList } from "./field/config/default-extensions.js";
 import { RichTextField } from "./richtext-field.js";
 function lexicalEditor(configure) {
-    const baked = configure ? configure(cloneDeep(defaultEditorConfig)) : void 0;
+    let baked;
+    if (configure) {
+        const seed = {
+            ...cloneDeep(defaultEditorConfig),
+            extensions: defaultExtensionsList()
+        };
+        baked = configure(seed);
+    }
     const ConfiguredEditor = (props)=>/*#__PURE__*/ jsx(RichTextField, {
             ...props,
             editorConfig: baked

package/dist/richtext-field.js

@@ -2,6 +2,7 @@ import { jsx, jsxs } from "react/jsx-runtime";
 import { ErrorText, Label, LocaleBadge, useFieldError, useFieldValue } from "@byline/ui/react";
 import classnames from "classnames";
 import { defaultEditorConfig } from "./field/config/default.js";
+import { defaultExtensionsList } from "./field/config/default-extensions.js";
 import { EditorField } from "./field/editor-field.js";
 import richtext_field_module from "./richtext-field.module.js";
 const RichTextField = ({ field, value, defaultValue, editorConfig, readonly = false, instanceKey, onChange, path, locale, featureBeforeEditor, featureAfterEditor, featureChildren })=>{
@@ -11,7 +12,11 @@ const RichTextField = ({ field, value, defaultValue, editorConfig, readonly = fa
     const incomingValue = value ?? fieldValue;
     const incomingDefault = defaultValue;
     const fieldId = instanceKey ? `${field.name}-${instanceKey}` : field.name;
-    const baseEditorConfig = field.editorConfig ?? editorConfig ?? defaultEditorConfig;
+    const resolved = field.editorConfig ?? editorConfig ?? defaultEditorConfig;
+    const baseEditorConfig = null != resolved.extensions ? resolved : {
+        ...resolved,
+        extensions: defaultExtensionsList()
+    };
     const resolvedEditorConfig = void 0 === field.embedRelationsOnSave ? baseEditorConfig : {
         ...baseEditorConfig,
         settings: {

package/dist/server.d.ts

@@ -29,8 +29,8 @@ import type { BylineClient } from '@byline/client';
 import type { RichTextPopulateFn } from '@byline/core';
 import { type LexicalNodeVisitor } from './field/lexical-populate-shared';
 export { defaultEditorConfig } from './field/config/default';
-export { inlineImageVisitor } from './field/plugins/inline-image-plugin/populate';
-export { linkVisitor } from './field/plugins/link-plugin/populate';
+export { inlineImageVisitor } from './field/extensions/inline-image/populate';
+export { linkVisitor } from './field/extensions/link/populate';
 export type { EditorConfig, EditorSettings, EditorSettingsOverride } from './field/config/types';
 export type { LexicalNodeLike, LexicalNodeVisitor, PendingHydration, } from './field/lexical-populate-shared';
 export interface LexicalServerOptions {

package/dist/server.js

@@ -1,6 +1,6 @@
+import { inlineImageVisitor } from "./field/extensions/inline-image/populate.js";
+import { linkVisitor } from "./field/extensions/link/populate.js";
 import { runLexicalPopulate } from "./field/lexical-populate-shared.js";
-import { inlineImageVisitor } from "./field/plugins/inline-image-plugin/populate.js";
-import { linkVisitor } from "./field/plugins/link-plugin/populate.js";
 function lexicalEditorServer(options) {
     const visitors = options.visitors ?? [
         inlineImageVisitor,

package/package.json

@@ -3,7 +3,7 @@
   "private": false,
   "type": "module",
   "license": "MPL-2.0",
-  "version": "1.11.2",
+  "version": "1.12.1",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -42,10 +42,6 @@
       "main": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./toolbar-extensions": {
-      "types": "./dist/field/toolbar-extensions.d.ts",
-      "import": "./dist/field/toolbar-extensions.js"
-    },
     "./server": {
       "types": "./dist/server.d.ts",
       "import": "./dist/server.js",
@@ -56,6 +52,7 @@
   "dependencies": {
     "@lexical/clipboard": "0.44.0",
     "@lexical/code": "0.44.0",
+    "@lexical/extension": "0.44.0",
     "@lexical/hashtag": "0.44.0",
     "@lexical/headless": "0.44.0",
     "@lexical/html": "0.44.0",
@@ -75,9 +72,9 @@
     "npm-run-all": "^4.1.5",
     "prism-react-renderer": "^2.4.1",
     "react-error-boundary": "^6.1.1",
-    "@byline/client": "1.11.2",
-    "@byline/ui": "1.11.2",
-    "@byline/core": "1.11.2"
+    "@byline/ui": "1.12.1",
+    "@byline/core": "1.12.1",
+    "@byline/client": "1.12.1"
   },
   "peerDependencies": {
     "react": "^19.0.0",
@@ -113,10 +110,10 @@
     "dev": "run-p dev:*",
     "dev:code": "rslib build --watch",
     "build": "run-s build:*",
-    "build:clean": "rimraf dist build",
+    "build:clean": "node scripts/clean.js dist build",
     "build:code": "rslib build",
     "typecheck": "tsc --noEmit",
-    "clean": "rimraf node_modules dist build types .turbo",
+    "clean": "node scripts/clean.js node_modules dist build types .turbo",
     "lint": "biome check --write --unsafe --diagnostic-level=error",
     "skip:test": "vitest"
   }

package/src/field/apply-value-plugin.tsx

@@ -61,12 +61,12 @@ export function ApplyValuePlugin({
 
     const nextState = editor.parseEditorState(value)
 
-    editor.update(
-      () => {
-        editor.setEditorState(nextState)
-      },
-      { tag: APPLY_VALUE_TAG }
-    )
+    // Must NOT be wrapped in editor.update — setEditorState defers its commit
+    // when called inside an active update, leaving selection/node references
+    // pointing into the pre-swap nodeMap. Surfaces as @lexical/table observer
+    // errors ("Expected node with key N to exist") on the very next selection
+    // change. setEditorState applies the tag itself.
+    editor.setEditorState(nextState, { tag: APPLY_VALUE_TAG })
     lastAppliedHashRef.current = nextRawHash
 
     let cancelled = false