@byline/richtext-lexical 1.11.2 → 1.12.0

package/dist/field/apply-value-plugin.js

@@ -27,9 +27,7 @@ function ApplyValuePlugin({ value, incomingHash, lastEmittedHashRef, normalizedI
         }
         hasNormalizedBaselineRef.current = false;
         const nextState = editor.parseEditorState(value);
-        editor.update(()=>{
-            editor.setEditorState(nextState);
-        }, {
+        editor.setEditorState(nextState, {
             tag: APPLY_VALUE_TAG
         });
         lastAppliedHashRef.current = nextRawHash;

package/dist/field/config/default-extensions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { AnyLexicalExtensionArgument } from 'lexical';
+import { ExtensionsList } from './extensions-list';
+import type { EditorConfig } from './types';
+/**
+ * Returns a fresh array of every Byline-built-in Lexical extension in
+ * their canonical order. Includes the `BylineToolbarExtension` registry
+ * itself so contributing extensions can attach their toolbar items via
+ * `peerDependencies`.
+ *
+ * Order matters: stock framework extensions (clear-editor, tab-indent,
+ * auto-focus) come first; toolbar contract sits ahead of any
+ * contributing extension; relation-bearing extensions (link, image)
+ * land near the end.
+ */
+export declare function defaultExtensionsArray(): AnyLexicalExtensionArgument[];
+/** Fresh `ExtensionsList` populated with the built-in extensions. */
+export declare function defaultExtensionsList(): ExtensionsList;
+/**
+ * Client-side default editor config — settings + lexical config + the
+ * full default extensions list. Used by `lexicalEditor((c) => ...)` as
+ * the seed before invoking the configure callback. Server-only modules
+ * (e.g. seeds) must import `defaultEditorConfig` from
+ * `@byline/richtext-lexical/server` instead.
+ */
+export declare const defaultClientEditorConfig: EditorConfig;

package/dist/field/config/default-extensions.js

@@ -0,0 +1,49 @@
+import { AutoFocusExtension, ClearEditorExtension, TabIndentationExtension } from "@lexical/extension";
+import { CheckListExtension, ListExtension } from "@lexical/list";
+import { AdmonitionExtension } from "../extensions/admonition/admonition-extension.js";
+import { AutoEmbedExtension } from "../extensions/auto-embed/auto-embed-extension.js";
+import { BylineFloatingUIExtension } from "../extensions/byline-floating-ui/byline-floating-ui-extension.js";
+import { BylineToolbarExtension } from "../extensions/byline-toolbar/byline-toolbar-extension.js";
+import { CodeHighlightExtension } from "../extensions/code-highlight/code-highlight-extension.js";
+import { FloatingTextFormatExtension } from "../extensions/floating-text-format/floating-text-format-extension.js";
+import { HorizontalRuleExtension } from "../extensions/horizontal-rule/horizontal-rule-extension.js";
+import { InlineImageExtension } from "../extensions/inline-image/inline-image-extension.js";
+import { LayoutExtension } from "../extensions/layout/layout-extension.js";
+import { AutoLinkExtension } from "../extensions/link/auto-link-extension.js";
+import { LinkExtension } from "../extensions/link/link-extension.js";
+import { TableExtension } from "../extensions/table/table-extension.js";
+import { VimeoExtension } from "../extensions/vimeo/vimeo-extension.js";
+import { YouTubeExtension } from "../extensions/youtube/youtube-extension.js";
+import { defaultEditorConfig } from "./default.js";
+import { ExtensionsList } from "./extensions-list.js";
+function defaultExtensionsArray() {
+    return [
+        ClearEditorExtension,
+        TabIndentationExtension,
+        AutoFocusExtension,
+        BylineToolbarExtension,
+        BylineFloatingUIExtension,
+        ListExtension,
+        CheckListExtension,
+        HorizontalRuleExtension,
+        LayoutExtension,
+        AdmonitionExtension,
+        CodeHighlightExtension,
+        TableExtension,
+        LinkExtension,
+        AutoLinkExtension,
+        InlineImageExtension,
+        YouTubeExtension,
+        VimeoExtension,
+        AutoEmbedExtension,
+        FloatingTextFormatExtension
+    ];
+}
+function defaultExtensionsList() {
+    return new ExtensionsList(defaultExtensionsArray());
+}
+const defaultClientEditorConfig = {
+    ...defaultEditorConfig,
+    extensions: defaultExtensionsList()
+};
+export { defaultClientEditorConfig, defaultExtensionsArray, defaultExtensionsList };

package/dist/field/config/default.d.ts

@@ -2,4 +2,12 @@ import type { EditorConfig as LexicalEditorConfig } from 'lexical';
 import type { EditorConfig, EditorSettings } from './types';
 export declare const defaultEditorLexicalConfig: LexicalEditorConfig;
 export declare const DEFAULT_EDITOR_SETTINGS: EditorSettings;
+/**
+ * Server-safe editor config — settings + Lexical core config only. The
+ * `extensions` field is intentionally omitted because extension entries
+ * carry React-bearing decorators that would break tsx-loaded seeds and
+ * other server-side schema consumers. The client-side
+ * `defaultClientEditorConfig` (in `default-extensions.tsx`) layers the
+ * extensions list on top.
+ */
 export declare const defaultEditorConfig: EditorConfig;

package/dist/field/config/default.js

@@ -5,41 +5,13 @@ const defaultEditorLexicalConfig = {
 };
 const DEFAULT_EDITOR_SETTINGS = {
     options: {
-        disableBeforeInput: false,
-        autocomplete: false,
-        charLimit: false,
-        charLimitUtf8: false,
-        collab: false,
-        maxLength: false,
         richText: true,
-        measureTypingPerf: false,
-        showNestedEditorTreeView: false,
-        showTableOfContents: false,
         showTreeView: false,
         textAlignment: true,
-        tablePlugin: true,
-        tableCellBackgroundColor: true,
-        tableCellMerge: true,
-        tableActionMenuPlugin: true,
-        layoutPlugin: true,
-        outputHTML: false,
-        outputMarkdown: false,
-        autoFocusPlugin: false,
-        autoLinkPlugin: false,
-        inlineImagePlugin: true,
-        admonitionPlugin: true,
-        checkListPlugin: true,
-        listPlugin: true,
-        codeHighlightPlugin: true,
-        horizontalRulePlugin: true,
         markdownShortcutPlugin: false,
         undoRedo: true,
         textStyle: true,
         inlineCode: true,
-        links: true,
-        floatingLinkEditorPlugin: true,
-        floatingTextFormatToolbarPlugin: false,
-        autoEmbedPlugin: true,
         debug: false
     },
     inlineImageUploadCollection: 'media',

package/dist/field/config/editor-config-context.js

@@ -1,7 +1,6 @@
 "use client";
 import { jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useMemo, useState } from "react";
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { DEFAULT_EDITOR_SETTINGS } from "./default.js";
 function generateQuickGuid() {
     return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12);
@@ -14,7 +13,6 @@ const Context = /*#__PURE__*/ createContext({
 const EditorConfigContext = ({ children, config: configFromProps })=>{
     const [config, setConfig] = useState(configFromProps ?? DEFAULT_EDITOR_SETTINGS);
     const [uuid] = useState(()=>generateQuickGuid());
-    const [editor] = useLexicalComposerContext();
     const setOption = useCallback((option, value)=>{
         setConfig((config)=>{
             const options = {
@@ -30,13 +28,11 @@ const EditorConfigContext = ({ children, config: configFromProps })=>{
     const editorContext = useMemo(()=>({
             setOption,
             config,
-            uuid,
-            editor
+            uuid
         }), [
         setOption,
         config,
-        uuid,
-        editor
+        uuid
     ]);
     return /*#__PURE__*/ jsx(Context.Provider, {
         value: editorContext,

package/dist/field/config/extensions-list.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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 AnyLexicalExtension, type AnyLexicalExtensionArgument, type LexicalExtensionConfig } from 'lexical';
+/**
+ * Chainable wrapper around an ordered list of Lexical extensions. Used
+ * inside the `lexicalEditor((c) => ...)` configure callback so site
+ * authors can add, remove, configure, or reorder extensions before the
+ * editor is built.
+ *
+ * Comparison is by extension `name` so a bare `LinkExtension` and a
+ * `configExtension(LinkExtension, {...})` tuple are treated as the same
+ * entry.
+ */
+export declare class ExtensionsList {
+    private items;
+    constructor(items?: ReadonlyArray<AnyLexicalExtensionArgument>);
+    /** Append `extension` to the end of the list. */
+    add(extension: AnyLexicalExtensionArgument): this;
+    /**
+     * Remove every entry whose name matches `extension.name`. No-op when
+     * the extension isn't present.
+     */
+    remove(extension: AnyLexicalExtension): this;
+    /** Replace `oldExtension` with `newExtension`, preserving position. */
+    replace(oldExtension: AnyLexicalExtension, newExtension: AnyLexicalExtensionArgument): this;
+    /**
+     * Re-wrap an existing extension entry with a fresh `configExtension`
+     * binding the supplied config. If the extension isn't present, it is
+     * added. If it was already wrapped with `configExtension`, the wrapper
+     * is replaced rather than nested.
+     */
+    configure<Extension extends AnyLexicalExtension>(extension: Extension, config: Partial<LexicalExtensionConfig<Extension>>): this;
+    /** True when an entry with the same `name` is present. */
+    has(extension: AnyLexicalExtension): boolean;
+    /** Independent copy — safe to hand to a configure callback. */
+    clone(): ExtensionsList;
+    /** The list as a plain array, ready for `defineExtension({ dependencies })`. */
+    toArray(): AnyLexicalExtensionArgument[];
+}

package/dist/field/config/extensions-list.js

@@ -0,0 +1,55 @@
+import { configExtension } from "lexical";
+class ExtensionsList {
+    add(extension) {
+        this.items.push(extension);
+        return this;
+    }
+    remove(extension) {
+        const targetName = extension.name;
+        this.items = this.items.filter((item)=>extensionName(item) !== targetName);
+        return this;
+    }
+    replace(oldExtension, newExtension) {
+        const targetName = oldExtension.name;
+        let replaced = false;
+        this.items = this.items.map((item)=>{
+            if (!replaced && extensionName(item) === targetName) {
+                replaced = true;
+                return newExtension;
+            }
+            return item;
+        });
+        if (!replaced) this.items.push(newExtension);
+        return this;
+    }
+    configure(extension, config) {
+        const wrapped = configExtension(extension, config);
+        return this.replace(extension, wrapped);
+    }
+    has(extension) {
+        const targetName = extension.name;
+        return this.items.some((item)=>extensionName(item) === targetName);
+    }
+    clone() {
+        return new ExtensionsList(this.items);
+    }
+    toArray() {
+        return [
+            ...this.items
+        ];
+    }
+    constructor(items = []){
+        this.items = [
+            ...items
+        ];
+    }
+}
+function extensionName(item) {
+    if (Array.isArray(item)) {
+        const head = item[0];
+        if (null != head && 'object' == typeof head && 'name' in head) return head.name;
+        return;
+    }
+    if (null != item && 'object' == typeof item && 'name' in item) return item.name;
+}
+export { ExtensionsList };

package/dist/field/config/types.d.ts

@@ -1,7 +1,21 @@
 import type { EditorConfig as LexicalEditorConfig } from 'lexical';
-export type OptionName = 'disableBeforeInput' | 'autocomplete' | 'charLimit' | 'charLimitUtf8' | 'collab' | 'maxLength' | 'richText' | 'measureTypingPerf' | 'showNestedEditorTreeView' | 'showTableOfContents' | 'showTreeView' | 'textAlignment' | 'tablePlugin' | 'tableCellBackgroundColor' | 'tableCellMerge' | 'tableActionMenuPlugin' | 'layoutPlugin' | 'outputHTML' | 'outputMarkdown' | 'autoFocusPlugin' | 'autoLinkPlugin' | 'inlineImagePlugin' | 'admonitionPlugin' | 'checkListPlugin' | 'listPlugin' | 'codeHighlightPlugin' | 'horizontalRulePlugin' | 'markdownShortcutPlugin' | 'undoRedo' | 'textStyle' | 'inlineCode' | 'links' | 'floatingLinkEditorPlugin' | 'floatingTextFormatToolbarPlugin' | 'autoEmbedPlugin' | 'debug';
+import type { ExtensionsList } from './extensions-list';
+/**
+ * Settings that aren't expressible as "is extension X present in the
+ * extensions list?" — toolbar / UI mode toggles, debug switches, the
+ * inline-image upload target, etc. Everything else now lives on
+ * {@link EditorConfig.extensions} and is manipulated via the chainable
+ * `lexicalEditor((c) => c.extensions.add(...).remove(...))` API.
+ */
+export type OptionName = 'richText' | 'showTreeView' | 'textAlignment' | 'markdownShortcutPlugin' | 'undoRedo' | 'textStyle' | 'inlineCode' | 'debug';
 export interface EditorSettings {
     options: Record<OptionName, boolean>;
+    /**
+     * Upload collection passed to the inline-image picker. Forwarded to
+     * `InlineImageExtension`'s config when the extensions list is built;
+     * setting it here is equivalent to
+     * `c.extensions.configure(InlineImageExtension, { collection })`.
+     */
     inlineImageUploadCollection: string;
     placeholderText: string;
     /**
@@ -24,4 +38,17 @@ export interface EditorSettingsOverride {
 export interface EditorConfig {
     settings: EditorSettings;
     lexical: LexicalEditorConfig;
+    /**
+     * Manipulable list of Lexical extensions wired into the editor. When
+     * omitted (server-safe `defaultEditorConfig` from `/server` does not
+     * carry one), the editor falls back to the package's built-in list at
+     * render time.
+     *
+     * Field-level `RichTextField.editorConfig` should not set this
+     * directly — extension references are not JSON-safe and would break
+     * tsx-loaded seeds. Per-field extension overrides go through a
+     * client-side wrapper component registered via
+     * `FieldAdminConfig.editor` (see `aiRichTextAdmin()` for the pattern).
+     */
+    extensions?: ExtensionsList;
 }

package/dist/field/editor-context.d.ts

@@ -6,7 +6,7 @@
  * Copyright (c) Infonomic Company Limited
  */
 import type * as React from 'react';
-import type { EditorState, LexicalEditor, SerializedEditorState } from 'lexical';
+import { type EditorState, type LexicalEditor, type SerializedEditorState } from 'lexical';
 import type { EditorConfig } from './config/types';
 export declare function EditorContext(props: {
     composerKey: string;

package/dist/field/editor-context.js

@@ -1,57 +1,61 @@
 "use client";
 import { jsx, jsxs } from "react/jsx-runtime";
 import { useMemo } from "react";
-import { LexicalComposer } from "@lexical/react/LexicalComposer";
+import { LexicalExtensionComposer } from "@lexical/react/LexicalExtensionComposer";
+import { defineExtension } from "lexical";
+import { defaultExtensionsList } from "./config/default-extensions.js";
 import { EditorConfigContext } from "./config/editor-config-context.js";
 import { SharedHistoryContext } from "./context/shared-history-context.js";
 import { SharedOnChangeContext } from "./context/shared-on-change-context.js";
 import { Editor } from "./editor.js";
+import { InlineImageExtension } from "./extensions/inline-image/inline-image-extension.js";
 import { Nodes } from "./nodes/index.js";
-import { ToolbarExtensionsProvider } from "./toolbar-extensions.js";
 function EditorContext(props) {
     const { composerKey, editorConfig, onChange, readOnly, value, beforeEditor, afterEditor, children } = props;
-    const initialConfig = useMemo(()=>({
-            editable: true !== readOnly,
-            editorState: null != value ? JSON.stringify(value) : void 0,
+    const editable = true !== readOnly;
+    const rootExtension = useMemo(()=>{
+        const extensionsList = editorConfig.extensions ?? defaultExtensionsList();
+        const dependencies = extensionsList.clone().configure(InlineImageExtension, {
+            collection: editorConfig.settings.inlineImageUploadCollection
+        }).toArray();
+        return defineExtension({
+            name: '[root]',
             namespace: editorConfig.lexical.namespace,
             nodes: [
                 ...Nodes
             ],
+            theme: editorConfig.lexical.theme,
+            editable,
+            $initialEditorState: null != value ? JSON.stringify(value) : void 0,
             onError: (error)=>{
                 throw error;
             },
-            theme: editorConfig.lexical.theme
-        }), [
-        editorConfig,
-        readOnly
-    ]);
-    if (null == initialConfig) return /*#__PURE__*/ jsx("p", {
-        children: "Loading..."
-    });
-    return /*#__PURE__*/ jsx(LexicalComposer, {
-        initialConfig: initialConfig,
-        children: /*#__PURE__*/ jsx(EditorConfigContext, {
-            config: editorConfig.settings,
-            children: /*#__PURE__*/ jsx(SharedOnChangeContext, {
-                onChange: onChange,
-                children: /*#__PURE__*/ jsx(SharedHistoryContext, {
-                    children: /*#__PURE__*/ jsx(ToolbarExtensionsProvider, {
-                        children: /*#__PURE__*/ jsxs("div", {
-                            className: "editor-shell",
-                            children: [
-                                beforeEditor,
-                                /*#__PURE__*/ jsx(Editor, {
-                                    minHeight: props.minHeight,
-                                    maxHeight: props.maxHeight
-                                }),
-                                afterEditor,
-                                children
-                            ]
-                        })
+            dependencies
+        });
+    }, []);
+    return /*#__PURE__*/ jsx(EditorConfigContext, {
+        config: editorConfig.settings,
+        children: /*#__PURE__*/ jsx(SharedOnChangeContext, {
+            onChange: onChange,
+            children: /*#__PURE__*/ jsx(SharedHistoryContext, {
+                children: /*#__PURE__*/ jsx(LexicalExtensionComposer, {
+                    extension: rootExtension,
+                    contentEditable: null,
+                    children: /*#__PURE__*/ jsxs("div", {
+                        className: "editor-shell",
+                        children: [
+                            beforeEditor,
+                            /*#__PURE__*/ jsx(Editor, {
+                                minHeight: props.minHeight,
+                                maxHeight: props.maxHeight
+                            }),
+                            afterEditor,
+                            children
+                        ]
                     })
-                })
+                }, composerKey + editable)
             })
         })
-    }, composerKey + initialConfig.editable);
+    });
 }
 export { EditorContext };

package/dist/field/editor.js

@@ -2,39 +2,23 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { memo, useCallback, useEffect, useMemo, useState } from "react";
 import { TRANSFORMERS } from "@lexical/markdown";
-import { AutoFocusPlugin } from "@lexical/react/LexicalAutoFocusPlugin";
-import { CheckListPlugin } from "@lexical/react/LexicalCheckListPlugin";
-import { ClearEditorPlugin } from "@lexical/react/LexicalClearEditorPlugin";
 import { LexicalErrorBoundary } from "@lexical/react/LexicalErrorBoundary";
 import { HistoryPlugin } from "@lexical/react/LexicalHistoryPlugin";
-import { HorizontalRulePlugin } from "@lexical/react/LexicalHorizontalRulePlugin";
-import { ListPlugin } from "@lexical/react/LexicalListPlugin";
 import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
 import { OnChangePlugin } from "@lexical/react/LexicalOnChangePlugin";
 import { PlainTextPlugin } from "@lexical/react/LexicalPlainTextPlugin";
 import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
-import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin";
-import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
+import { useExtensionDependency, useOptionalExtensionDependency } from "@lexical/react/useExtensionComponent";
 import { useEditorConfig } from "./config/editor-config-context.js";
 import { ContentEditable } from "./content-editable.js";
 import { useSharedHistoryContext } from "./context/shared-history-context.js";
 import { useSharedOnChange } from "./context/shared-on-change-context.js";
 import { Debug } from "./debug.js";
-import { AdmonitionPlugin } from "./plugins/admonition-plugin/index.js";
-import { AutoEmbedPlugin } from "./plugins/auto-embed-plugin/index.js";
-import { CodeHighlightPlugin } from "./plugins/code-highlight-plugin/index.js";
-import { FloatingTextFormatToolbarPlugin } from "./plugins/floating-text-format-toolbar-plugin/index.js";
-import { InlineImagePlugin } from "./plugins/inline-image-plugin/index.js";
-import { LayoutPlugin } from "./plugins/layout-plugin/layout-plugin.js";
-import { AutoLinkPlugin } from "./plugins/link-plugin/auto-link/index.js";
-import { LinkPlugin } from "./plugins/link-plugin/link/index.js";
-import { FloatingLinkEditorPlugin } from "./plugins/link-plugin/link/floating-link-editor.js";
-import { TableActionMenuPlugin } from "./plugins/table-action-menu-plugin/index.js";
-import { TablePlugin as index_js_TablePlugin } from "./plugins/table-plugin/index.js";
+import { BylineFloatingUIExtension, selectFloatingUIItems } from "./extensions/byline-floating-ui/byline-floating-ui-extension.js";
+import { TableExtension } from "./extensions/table/table-extension.js";
+import { TablePlugin } from "./plugins/table-plugin/index.js";
 import { ToolbarPlugin } from "./plugins/toolbar-plugin/index.js";
 import { TreeViewPlugin } from "./plugins/treeview-plugin/index.js";
-import { VimeoPlugin } from "./plugins/vimeo-plugin/index.js";
-import { YouTubePlugin } from "./plugins/youtube-plugin/index.js";
 import { CAN_USE_DOM } from "./shared/canUseDOM.js";
 import { Placeholder } from "./ui/placeholder.js";
 import "./editor.css";
@@ -47,7 +31,9 @@ const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
         }))[0];
     const { onChange } = useSharedOnChange();
     const { historyState } = useSharedHistoryContext();
-    const { config: { options: { debug, richText, showTreeView, autoFocusPlugin, tablePlugin, tableActionMenuPlugin, layoutPlugin, inlineImagePlugin, admonitionPlugin, links, autoLinkPlugin, checkListPlugin, listPlugin, codeHighlightPlugin, horizontalRulePlugin, markdownShortcutPlugin, floatingLinkEditorPlugin, floatingTextFormatToolbarPlugin, autoEmbedPlugin }, placeholderText, inlineImageUploadCollection } } = useEditorConfig();
+    const { config: { options: { debug, richText, showTreeView, markdownShortcutPlugin }, placeholderText } } = useEditorConfig();
+    const hasTableExtension = void 0 !== useOptionalExtensionDependency(TableExtension);
+    const floatingUIItems = selectFloatingUIItems(useExtensionDependency(BylineFloatingUIExtension).config.items);
     const onRef = useCallback((_floatingAnchorElem)=>{
         if (null != _floatingAnchorElem) setFloatingAnchorElem(_floatingAnchorElem);
     }, []);
@@ -96,16 +82,11 @@ const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
     ]);
     const content = /*#__PURE__*/ jsxs(Fragment, {
         children: [
-            tablePlugin && /*#__PURE__*/ jsx(index_js_TablePlugin, {}),
+            hasTableExtension && /*#__PURE__*/ jsx(TablePlugin, {}),
             richText && /*#__PURE__*/ jsx(ToolbarPlugin, {}),
             /*#__PURE__*/ jsxs("div", {
                 className: `editor-container ${showTreeView ? 'tree-view' : ''} ${!richText ? 'plain-text' : ''}`,
                 children: [
-                    autoFocusPlugin && /*#__PURE__*/ jsx(AutoFocusPlugin, {}),
-                    links && /*#__PURE__*/ jsx(LinkPlugin, {}),
-                    autoEmbedPlugin && /*#__PURE__*/ jsx(AutoEmbedPlugin, {}),
-                    /*#__PURE__*/ jsx(TabIndentationPlugin, {}),
-                    autoLinkPlugin && /*#__PURE__*/ jsx(AutoLinkPlugin, {}),
                     /*#__PURE__*/ jsx(OnChangePlugin, {
                         ignoreSelectionChange: true,
                         onChange: (editorState, editor, tags)=>{
@@ -127,38 +108,12 @@ const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
                             /*#__PURE__*/ jsx(HistoryPlugin, {
                                 externalHistoryState: historyState
                             }),
-                            inlineImagePlugin && /*#__PURE__*/ jsx(InlineImagePlugin, {
-                                collection: inlineImageUploadCollection
-                            }),
-                            admonitionPlugin && /*#__PURE__*/ jsx(AdmonitionPlugin, {}),
-                            checkListPlugin && /*#__PURE__*/ jsx(CheckListPlugin, {}),
-                            listPlugin && /*#__PURE__*/ jsx(ListPlugin, {}),
-                            codeHighlightPlugin && /*#__PURE__*/ jsx(CodeHighlightPlugin, {}),
-                            horizontalRulePlugin && /*#__PURE__*/ jsx(HorizontalRulePlugin, {}),
-                            layoutPlugin && /*#__PURE__*/ jsx(LayoutPlugin, {}),
-                            autoEmbedPlugin && /*#__PURE__*/ jsx(YouTubePlugin, {}),
-                            autoEmbedPlugin && /*#__PURE__*/ jsx(VimeoPlugin, {}),
                             markdownShortcutPlugin && /*#__PURE__*/ jsx(MarkdownShortcutPlugin, {
                                 transformers: TRANSFORMERS
                             }),
-                            tablePlugin && /*#__PURE__*/ jsx(TablePlugin, {
-                                hasCellMerge: true,
-                                hasCellBackgroundColor: true
-                            }),
-                            null != floatingAnchorElem && !isSmallWidthViewport && /*#__PURE__*/ jsxs(Fragment, {
-                                children: [
-                                    floatingLinkEditorPlugin && /*#__PURE__*/ jsx(FloatingLinkEditorPlugin, {
-                                        anchorElem: floatingAnchorElem
-                                    }),
-                                    tableActionMenuPlugin && /*#__PURE__*/ jsx(TableActionMenuPlugin, {
-                                        anchorElem: floatingAnchorElem,
-                                        cellMerge: false
-                                    }),
-                                    floatingTextFormatToolbarPlugin && /*#__PURE__*/ jsx(FloatingTextFormatToolbarPlugin, {
-                                        anchorElem: floatingAnchorElem
-                                    })
-                                ]
-                            })
+                            null != floatingAnchorElem && !isSmallWidthViewport && floatingUIItems.map(({ id, Component })=>/*#__PURE__*/ jsx(Component, {
+                                    anchorElem: floatingAnchorElem
+                                }, id))
                         ]
                     }) : /*#__PURE__*/ jsxs(Fragment, {
                         children: [
@@ -174,7 +129,6 @@ const editor_Editor = /*#__PURE__*/ memo(function({ minHeight, maxHeight }) {
                             })
                         ]
                     }),
-                    /*#__PURE__*/ jsx(ClearEditorPlugin, {}),
                     debug && /*#__PURE__*/ jsxs(Fragment, {
                         children: [
                             /*#__PURE__*/ jsx(Debug, {}),

package/dist/field/{plugins/admonition-plugin/index.d.ts → extensions/admonition/admonition-extension.d.ts}

@@ -7,8 +7,9 @@
  */
 import * as React from 'react';
 import { type LexicalCommand } from 'lexical';
-import type { AdmonitionAttributes } from '../../nodes/admonition-node/types';
+import type { AdmonitionAttributes } from './node-types';
 export type InsertAdmonitionPayload = Readonly<AdmonitionAttributes>;
 export declare const OPEN_ADMONITION_MODAL_COMMAND: LexicalCommand<null>;
 export declare const INSERT_ADMONITION_COMMAND: LexicalCommand<AdmonitionAttributes>;
 export declare function AdmonitionPlugin(): React.JSX.Element;
+export declare const AdmonitionExtension: import("lexical").LexicalExtension<import("lexical").ExtensionConfigBase, "@byline/richtext-lexical/Admonition", unknown, unknown>;

package/dist/field/{plugins/admonition-plugin/index.js → extensions/admonition/admonition-extension.js}

@@ -1,10 +1,14 @@
 "use client";
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { ReactExtension } from "@lexical/react/ReactExtension";
 import { $insertNodeToNearestRoot, mergeRegister } from "@lexical/utils";
-import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_NORMAL, createCommand } from "lexical";
-import { $createAdmonitionNode, AdmonitionNode } from "../../nodes/admonition-node/index.js";
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_NORMAL, configExtension, createCommand, declarePeerDependency, defineExtension } from "lexical";
+import { useToolbarActiveEditor } from "../../plugins/toolbar-plugin/toolbar-active-editor.js";
+import { DropDownItem } from "../../ui/dropdown.js";
+import { BylineToolbarExtension } from "../byline-toolbar/byline-toolbar-extension.js";
 import { AdmonitionModal } from "./admonition-modal.js";
+import { $createAdmonitionNode, AdmonitionNode } from "./admonition-node.js";
 import * as __rspack_external_react from "react";
 const OPEN_ADMONITION_MODAL_COMMAND = createCommand('OPEN_ADMONITION_MODAL_COMMAND');
 const INSERT_ADMONITION_COMMAND = createCommand('INSERT_ADMONITION_COMMAND');
@@ -51,4 +55,47 @@ function AdmonitionPlugin() {
         onSubmit: handleInsertAdmonition
     });
 }
-export { AdmonitionPlugin, INSERT_ADMONITION_COMMAND, OPEN_ADMONITION_MODAL_COMMAND };
+function AdmonitionInsertItem() {
+    const editor = useToolbarActiveEditor();
+    return /*#__PURE__*/ jsxs(DropDownItem, {
+        onClick: ()=>{
+            editor.dispatchCommand(OPEN_ADMONITION_MODAL_COMMAND, null);
+        },
+        className: "item",
+        children: [
+            /*#__PURE__*/ jsx("i", {
+                className: "icon admonition"
+            }),
+            /*#__PURE__*/ jsx("span", {
+                className: "text",
+                children: "Admonition"
+            })
+        ]
+    });
+}
+const AdmonitionExtension = defineExtension({
+    name: '@byline/richtext-lexical/Admonition',
+    nodes: ()=>[
+            AdmonitionNode
+        ],
+    dependencies: [
+        configExtension(ReactExtension, {
+            decorators: [
+                /*#__PURE__*/ jsx(AdmonitionPlugin, {}, "d")
+            ]
+        })
+    ],
+    peerDependencies: [
+        declarePeerDependency(BylineToolbarExtension.name, {
+            items: [
+                {
+                    id: '@byline/richtext-lexical/Admonition/insert',
+                    placement: 'insert-menu',
+                    order: 30,
+                    node: /*#__PURE__*/ jsx(AdmonitionInsertItem, {})
+                }
+            ]
+        })
+    ]
+});
+export { AdmonitionExtension, AdmonitionPlugin, INSERT_ADMONITION_COMMAND, OPEN_ADMONITION_MODAL_COMMAND };

package/dist/field/{nodes/admonition-node → extensions/admonition}/admonition-node-component.d.ts

@@ -7,7 +7,7 @@
  */
 import type * as React from 'react';
 import type { LexicalEditor, NodeKey } from 'lexical';
-import type { AdmonitionType } from './types';
+import type { AdmonitionType } from './node-types';
 import './admonition-node-component.css';
 export default function AdmonitionNodeComponent({ admonitionType, title, content, nodeKey, }: {
     admonitionType: AdmonitionType;