@byline/richtext-lexical 1.11.2 → 1.12.1

package/src/richtext-field.tsx

@@ -13,6 +13,7 @@ import { ErrorText, Label, LocaleBadge, useFieldError, useFieldValue } from '@by
 import cx from 'classnames'
 
 import { defaultEditorConfig } from './field/config/default'
+import { defaultExtensionsList } from './field/config/default-extensions'
 import { EditorField } from './field/editor-field'
 import styles from './richtext-field.module.css'
 import type { EditorConfig } from './field/config/types'
@@ -74,8 +75,14 @@ export const RichTextField = ({
   //   3. `defaultEditorConfig` — package default.
   // The schema-level value is typed as `unknown` at the `@byline/core` boundary,
   // so the cast lives here where the Lexical config shape is known.
-  const baseEditorConfig: EditorConfig =
+  const resolved: EditorConfig =
     (field.editorConfig as EditorConfig | undefined) ?? editorConfig ?? defaultEditorConfig
+  // Schema-side configs and the server-safe `defaultEditorConfig` carry no
+  // `extensions` field — extension references aren't JSON-safe. Materialise
+  // the package's client-only default list when one isn't already present so
+  // every render has a complete graph to feed `EditorContext`.
+  const baseEditorConfig: EditorConfig =
+    resolved.extensions != null ? resolved : { ...resolved, extensions: defaultExtensionsList() }
 
   // Adapter-agnostic field-level lever — when present, override the resolved
   // editor settings so the inline-image / link modals see this field's policy.

package/src/server.ts

@@ -30,9 +30,9 @@
 import type { BylineClient } from '@byline/client'
 import type { RichTextPopulateContext, RichTextPopulateFn } from '@byline/core'
 
+import { inlineImageVisitor } from './field/extensions/inline-image/populate'
+import { linkVisitor } from './field/extensions/link/populate'
 import { type LexicalNodeVisitor, runLexicalPopulate } from './field/lexical-populate-shared'
-import { inlineImageVisitor } from './field/plugins/inline-image-plugin/populate'
-import { linkVisitor } from './field/plugins/link-plugin/populate'
 
 // ---------------------------------------------------------------------------
 // Schema-data re-exports — data-only Lexical config that's safe to evaluate
@@ -41,8 +41,8 @@ import { linkVisitor } from './field/plugins/link-plugin/populate'
 // their CSS imports; the `/server` subpath stays React-free.
 // ---------------------------------------------------------------------------
 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,

package/dist/field/nodes/link-nodes/index.d.ts

@@ -1,3 +0,0 @@
-export * from './auto-link-node';
-export * from './link-node';
-export * from './types';

package/dist/field/nodes/link-nodes/index.js

@@ -1,3 +0,0 @@
-export * from "./auto-link-node.js";
-export * from "./link-node.js";
-export * from "./types.js";

package/dist/field/plugins/code-highlight-plugin/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-import type * as React from 'react';
-export declare function CodeHighlightPlugin(): React.JSX.Element | null;

package/dist/field/plugins/code-highlight-plugin/index.js

@@ -1,11 +0,0 @@
-import { useEffect } from "react";
-import { registerCodeHighlighting } from "@lexical/code";
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-function CodeHighlightPlugin() {
-    const [editor] = useLexicalComposerContext();
-    useEffect(()=>registerCodeHighlighting(editor), [
-        editor
-    ]);
-    return null;
-}
-export { CodeHighlightPlugin };

package/dist/field/plugins/link-plugin/auto-link/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-import type * as React from 'react';
-export declare function AutoLinkPlugin(): React.JSX.Element;

package/dist/field/plugins/link-plugin/link/index.d.ts

@@ -1 +0,0 @@
-export declare function LinkPlugin(): null;

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

@@ -1,43 +0,0 @@
-"use client";
-import { useEffect } from "react";
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-import { mergeRegister } from "@lexical/utils";
-import { $getSelection, $isElementNode, $isRangeSelection, COMMAND_PRIORITY_LOW, PASTE_COMMAND } from "lexical";
-import { $toggleLink, LinkNode, TOGGLE_LINK_COMMAND } from "../../../nodes/link-nodes/index.js";
-import { validateUrl } from "../../../utils/url.js";
-function LinkPlugin() {
-    const [editor] = useLexicalComposerContext();
-    useEffect(()=>{
-        if (!editor.hasNodes([
-            LinkNode
-        ])) throw new Error('LinkPlugin: LinkNode not registered on editor');
-        return mergeRegister(editor.registerCommand(TOGGLE_LINK_COMMAND, (payload)=>{
-            if (null === payload) {
-                $toggleLink(payload);
-                return true;
-            }
-            if ('custom' === payload.linkType) {
-                const url = payload.url ?? '';
-                if (!url.startsWith('/') && !validateUrl(url)) return false;
-            }
-            $toggleLink(payload);
-            return true;
-        }, COMMAND_PRIORITY_LOW), editor.registerCommand(PASTE_COMMAND, (event)=>{
-            const selection = $getSelection();
-            if (!$isRangeSelection(selection) || selection.isCollapsed() || !(event instanceof ClipboardEvent) || null == event.clipboardData) return false;
-            const clipboardText = event.clipboardData.getData('text');
-            if (!validateUrl(clipboardText)) return false;
-            if (selection.getNodes().some((node)=>$isElementNode(node))) return false;
-            editor.dispatchCommand(TOGGLE_LINK_COMMAND, {
-                linkType: 'custom',
-                url: clipboardText
-            });
-            event.preventDefault();
-            return true;
-        }, COMMAND_PRIORITY_LOW));
-    }, [
-        editor
-    ]);
-    return null;
-}
-export { LinkPlugin };

package/dist/field/plugins/table-action-menu-plugin/index.d.ts

@@ -1,5 +0,0 @@
-import { type ReactPortal } from 'react';
-export declare function TableActionMenuPlugin({ anchorElem, cellMerge, }: {
-    anchorElem?: HTMLElement;
-    cellMerge?: boolean;
-}): null | ReactPortal;

package/dist/field/plugins/vimeo-plugin/index.d.ts

@@ -1,3 +0,0 @@
-import { type LexicalCommand } from 'lexical';
-export declare const INSERT_VIMEO_COMMAND: LexicalCommand<string>;
-export declare function VimeoPlugin(): React.JSX.Element | null;

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

@@ -1,24 +0,0 @@
-"use client";
-import { useEffect } from "react";
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-import { $insertNodeToNearestRoot } from "@lexical/utils";
-import { COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
-import { $createVimeoNode, VimeoNode } from "../../nodes/vimeo-node/index.js";
-const INSERT_VIMEO_COMMAND = createCommand('INSERT_VIMEO_COMMAND');
-function VimeoPlugin() {
-    const [editor] = useLexicalComposerContext();
-    useEffect(()=>{
-        if (!editor.hasNodes([
-            VimeoNode
-        ])) throw new Error('VimeoPlugin: VimeoNode not registered on editor');
-        return editor.registerCommand(INSERT_VIMEO_COMMAND, (payload)=>{
-            const vimeoNode = $createVimeoNode(payload);
-            $insertNodeToNearestRoot(vimeoNode);
-            return true;
-        }, COMMAND_PRIORITY_EDITOR);
-    }, [
-        editor
-    ]);
-    return null;
-}
-export { INSERT_VIMEO_COMMAND, VimeoPlugin };

package/dist/field/plugins/youtube-plugin/index.d.ts

@@ -1,3 +0,0 @@
-import { type LexicalCommand } from 'lexical';
-export declare const INSERT_YOUTUBE_COMMAND: LexicalCommand<string>;
-export declare function YouTubePlugin(): React.JSX.Element | null;

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

@@ -1,24 +0,0 @@
-"use client";
-import { useEffect } from "react";
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-import { $insertNodeToNearestRoot } from "@lexical/utils";
-import { COMMAND_PRIORITY_EDITOR, createCommand } from "lexical";
-import { $createYouTubeNode, YouTubeNode } from "../../nodes/youtube-node/index.js";
-const INSERT_YOUTUBE_COMMAND = createCommand('INSERT_YOUTUBE_COMMAND');
-function YouTubePlugin() {
-    const [editor] = useLexicalComposerContext();
-    useEffect(()=>{
-        if (!editor.hasNodes([
-            YouTubeNode
-        ])) throw new Error('YouTubePlugin: YouTubeNode not registered on editor');
-        return editor.registerCommand(INSERT_YOUTUBE_COMMAND, (payload)=>{
-            const youTubeNode = $createYouTubeNode(payload);
-            $insertNodeToNearestRoot(youTubeNode);
-            return true;
-        }, COMMAND_PRIORITY_EDITOR);
-    }, [
-        editor
-    ]);
-    return null;
-}
-export { INSERT_YOUTUBE_COMMAND, YouTubePlugin };

package/dist/field/toolbar-extensions.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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';
-export type ToolbarExtensionItem = {
-    id: string;
-    order?: number;
-    node: React.ReactNode;
-};
-type ToolbarExtensionsContextType = {
-    items: ToolbarExtensionItem[];
-    register: (item: ToolbarExtensionItem) => () => void;
-    /**
-     * The editor instance for the current selection. This matters when using nested composers.
-     */
-    editor: LexicalEditor;
-    /**
-     * The root editor instance for this composer.
-     */
-    rootEditor: LexicalEditor;
-};
-export declare function ToolbarExtensionsProvider({ children, }: {
-    children: React.ReactNode;
-}): React.JSX.Element;
-export declare function useToolbarExtensions(): ToolbarExtensionsContextType;
-export {};

package/dist/field/toolbar-extensions.js

@@ -1,56 +0,0 @@
-"use client";
-import { jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
-import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-import { COMMAND_PRIORITY_CRITICAL, SELECTION_CHANGE_COMMAND } from "lexical";
-const ToolbarExtensionsContext = /*#__PURE__*/ createContext(null);
-function ToolbarExtensionsProvider({ children }) {
-    const [rootEditor] = useLexicalComposerContext();
-    const [activeEditor, setActiveEditor] = useState(rootEditor);
-    const [itemsById, setItemsById] = useState(()=>new Map());
-    useEffect(()=>rootEditor.registerCommand(SELECTION_CHANGE_COMMAND, (_payload, newEditor)=>{
-            setActiveEditor(newEditor);
-            return false;
-        }, COMMAND_PRIORITY_CRITICAL), [
-        rootEditor
-    ]);
-    const register = useCallback((item)=>{
-        setItemsById((prev)=>{
-            const next = new Map(prev);
-            next.set(item.id, item);
-            return next;
-        });
-        return ()=>{
-            setItemsById((prev)=>{
-                if (!prev.has(item.id)) return prev;
-                const next = new Map(prev);
-                next.delete(item.id);
-                return next;
-            });
-        };
-    }, []);
-    const items = useMemo(()=>Array.from(itemsById.values()), [
-        itemsById
-    ]);
-    const value = useMemo(()=>({
-            items,
-            register,
-            editor: activeEditor,
-            rootEditor
-        }), [
-        items,
-        register,
-        activeEditor,
-        rootEditor
-    ]);
-    return /*#__PURE__*/ jsx(ToolbarExtensionsContext.Provider, {
-        value: value,
-        children: children
-    });
-}
-function useToolbarExtensions() {
-    const context = useContext(ToolbarExtensionsContext);
-    if (null == context) throw new Error('useToolbarExtensions must be used within a ToolbarExtensionsProvider');
-    return context;
-}
-export { ToolbarExtensionsProvider, useToolbarExtensions };

package/src/field/nodes/link-nodes/index.ts

@@ -1,3 +0,0 @@
-export * from './auto-link-node'
-export * from './link-node'
-export * from './types'

package/src/field/plugins/code-highlight-plugin/index.ts

@@ -1,23 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-import type * as React from 'react'
-import { useEffect } from 'react'
-
-import { registerCodeHighlighting } from '@lexical/code'
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'
-
-export function CodeHighlightPlugin(): React.JSX.Element | null {
-  const [editor] = useLexicalComposerContext()
-
-  useEffect(() => {
-    return registerCodeHighlighting(editor)
-  }, [editor])
-
-  return null
-}

package/src/field/plugins/link-plugin/link/index.tsx

@@ -1,99 +0,0 @@
-'use client'
-
-/**
- * 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
- *
- * Portions Copyright (c) Meta Platforms, Inc. and affiliates.
- */
-
-import { useEffect } from 'react'
-
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'
-import { mergeRegister } from '@lexical/utils'
-import {
-  $getSelection,
-  $isElementNode,
-  $isRangeSelection,
-  COMMAND_PRIORITY_LOW,
-  PASTE_COMMAND,
-} from 'lexical'
-
-import {
-  $toggleLink,
-  type LinkAttributes,
-  LinkNode,
-  TOGGLE_LINK_COMMAND,
-} from '../../../nodes/link-nodes'
-import { validateUrl } from '../../../utils/url'
-
-export function LinkPlugin(): null {
-  const [editor] = useLexicalComposerContext()
-
-  useEffect(() => {
-    if (!editor.hasNodes([LinkNode])) {
-      throw new Error('LinkPlugin: LinkNode not registered on editor')
-    }
-
-    return mergeRegister(
-      editor.registerCommand(
-        TOGGLE_LINK_COMMAND,
-        (payload: LinkAttributes | null) => {
-          if (payload === null) {
-            $toggleLink(payload)
-            return true
-          }
-
-          // For custom links, accept either a fully-formed URL or a
-          // root-relative path (starts with `/`). Drop the command when the
-          // URL is unusable so the toolbar doesn't insert garbage.
-          if (payload.linkType === 'custom') {
-            const url = payload.url ?? ''
-            if (!url.startsWith('/') && !validateUrl(url)) {
-              return false
-            }
-          }
-
-          $toggleLink(payload)
-          return true
-        },
-        COMMAND_PRIORITY_LOW
-      ),
-
-      editor.registerCommand(
-        PASTE_COMMAND,
-        (event) => {
-          const selection = $getSelection()
-          if (
-            !$isRangeSelection(selection) ||
-            selection.isCollapsed() ||
-            !(event instanceof ClipboardEvent) ||
-            event.clipboardData == null
-          ) {
-            return false
-          }
-          const clipboardText = event.clipboardData.getData('text')
-          if (!validateUrl(clipboardText)) {
-            return false
-          }
-          // Don't auto-link when the selection spans block-level nodes.
-          if (selection.getNodes().some((node) => $isElementNode(node))) {
-            return false
-          }
-          editor.dispatchCommand(TOGGLE_LINK_COMMAND, {
-            linkType: 'custom',
-            url: clipboardText,
-          })
-          event.preventDefault()
-          return true
-        },
-        COMMAND_PRIORITY_LOW
-      )
-    )
-  }, [editor])
-
-  return null
-}

package/src/field/plugins/vimeo-plugin/index.ts

@@ -1,42 +0,0 @@
-'use client'
-
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-import { useEffect } from 'react'
-
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'
-import { $insertNodeToNearestRoot } from '@lexical/utils'
-import { COMMAND_PRIORITY_EDITOR, createCommand, type LexicalCommand } from 'lexical'
-
-import { $createVimeoNode, VimeoNode } from '../../nodes/vimeo-node'
-
-export const INSERT_VIMEO_COMMAND: LexicalCommand<string> = createCommand('INSERT_VIMEO_COMMAND')
-
-export function VimeoPlugin(): React.JSX.Element | null {
-  const [editor] = useLexicalComposerContext()
-
-  useEffect(() => {
-    if (!editor.hasNodes([VimeoNode])) {
-      throw new Error('VimeoPlugin: VimeoNode not registered on editor')
-    }
-
-    return editor.registerCommand<string>(
-      INSERT_VIMEO_COMMAND,
-      (payload) => {
-        const vimeoNode = $createVimeoNode(payload)
-        $insertNodeToNearestRoot(vimeoNode)
-
-        return true
-      },
-      COMMAND_PRIORITY_EDITOR
-    )
-  }, [editor])
-
-  return null
-}

package/src/field/plugins/youtube-plugin/index.ts

@@ -1,43 +0,0 @@
-'use client'
-
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-import { useEffect } from 'react'
-
-import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext'
-import { $insertNodeToNearestRoot } from '@lexical/utils'
-import { COMMAND_PRIORITY_EDITOR, createCommand, type LexicalCommand } from 'lexical'
-
-import { $createYouTubeNode, YouTubeNode } from '../../nodes/youtube-node'
-
-export const INSERT_YOUTUBE_COMMAND: LexicalCommand<string> =
-  createCommand('INSERT_YOUTUBE_COMMAND')
-
-export function YouTubePlugin(): React.JSX.Element | null {
-  const [editor] = useLexicalComposerContext()
-
-  useEffect(() => {
-    if (!editor.hasNodes([YouTubeNode])) {
-      throw new Error('YouTubePlugin: YouTubeNode not registered on editor')
-    }
-
-    return editor.registerCommand<string>(
-      INSERT_YOUTUBE_COMMAND,
-      (payload) => {
-        const youTubeNode = $createYouTubeNode(payload)
-        $insertNodeToNearestRoot(youTubeNode)
-
-        return true
-      },
-      COMMAND_PRIORITY_EDITOR
-    )
-  }, [editor])
-
-  return null
-}

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

@@ -1,104 +0,0 @@
-'use client'
-export const theme = {
-  blockCursor: 'LexicalEditorTheme__blockCursor',
-  characterLimit: 'LexicalEditorTheme__characterLimit',
-  code: 'LexicalEditorTheme__code',
-  codeHighlight: {
-    atrule: 'LexicalEditorTheme__tokenAttr',
-    attr: 'LexicalEditorTheme__tokenAttr',
-    boolean: 'LexicalEditorTheme__tokenProperty',
-    builtin: 'LexicalEditorTheme__tokenSelector',
-    cdata: 'LexicalEditorTheme__tokenComment',
-    char: 'LexicalEditorTheme__tokenSelector',
-    class: 'LexicalEditorTheme__tokenFunction',
-    'class-name': 'LexicalEditorTheme__tokenFunction',
-    comment: 'LexicalEditorTheme__tokenComment',
-    constant: 'LexicalEditorTheme__tokenProperty',
-    deleted: 'LexicalEditorTheme__tokenProperty',
-    doctype: 'LexicalEditorTheme__tokenComment',
-    entity: 'LexicalEditorTheme__tokenOperator',
-    function: 'LexicalEditorTheme__tokenFunction',
-    important: 'LexicalEditorTheme__tokenVariable',
-    inserted: 'LexicalEditorTheme__tokenSelector',
-    keyword: 'LexicalEditorTheme__tokenAttr',
-    namespace: 'LexicalEditorTheme__tokenVariable',
-    number: 'LexicalEditorTheme__tokenProperty',
-    operator: 'LexicalEditorTheme__tokenOperator',
-    prolog: 'LexicalEditorTheme__tokenComment',
-    property: 'LexicalEditorTheme__tokenProperty',
-    punctuation: 'LexicalEditorTheme__tokenPunctuation',
-    regex: 'LexicalEditorTheme__tokenVariable',
-    selector: 'LexicalEditorTheme__tokenSelector',
-    string: 'LexicalEditorTheme__tokenSelector',
-    symbol: 'LexicalEditorTheme__tokenProperty',
-    tag: 'LexicalEditorTheme__tokenProperty',
-    url: 'LexicalEditorTheme__tokenOperator',
-    variable: 'LexicalEditorTheme__tokenVariable',
-  },
-  embedBlock: {
-    base: 'LexicalEditorTheme__embedBlock',
-    focus: 'LexicalEditorTheme__embedBlockFocus',
-  },
-  hashtag: 'LexicalEditorTheme__hashtag',
-  heading: {
-    h1: 'LexicalEditorTheme__h1',
-    h2: 'LexicalEditorTheme__h2',
-    h3: 'LexicalEditorTheme__h3',
-    h4: 'LexicalEditorTheme__h4',
-    h5: 'LexicalEditorTheme__h5',
-    h6: 'LexicalEditorTheme__h6',
-  },
-  image: 'editor-image',
-  inlineImage: 'LexicalEditor__inline-image',
-  layoutContainer: 'LexicalEditor__layoutContainer',
-  layoutItem: 'LexicalEditor__layoutItem',
-  admonition: 'LexicalEditor__admonition',
-  indent: 'LexicalEditorTheme__indent',
-  link: 'LexicalEditorTheme__link',
-  list: {
-    listitem: 'LexicalEditorTheme__listItem',
-    listitemChecked: 'LexicalEditorTheme__listItemChecked',
-    listitemUnchecked: 'LexicalEditorTheme__listItemUnchecked',
-    nested: {
-      listitem: 'LexicalEditorTheme__nestedListItem',
-    },
-    olDepth: [
-      'LexicalEditorTheme__ol1',
-      'LexicalEditorTheme__ol2',
-      'LexicalEditorTheme__ol3',
-      'LexicalEditorTheme__ol4',
-      'LexicalEditorTheme__ol5',
-    ],
-    ul: 'LexicalEditorTheme__ul',
-  },
-  ltr: 'LexicalEditorTheme__ltr',
-  mark: 'LexicalEditorTheme__mark',
-  markOverlap: 'LexicalEditorTheme__markOverlap',
-  paragraph: 'LexicalEditorTheme__paragraph',
-  quote: 'LexicalEditorTheme__quote',
-  rtl: 'LexicalEditorTheme__rtl',
-  table: 'LexicalEditorTheme__table',
-  tableAddColumns: 'LexicalEditorTheme__tableAddColumns',
-  tableAddRows: 'LexicalEditorTheme__tableAddRows',
-  tableCell: 'LexicalEditorTheme__tableCell',
-  tableCellActionButton: 'LexicalEditorTheme__tableCellActionButton',
-  tableCellActionButtonContainer: 'LexicalEditorTheme__tableCellActionButtonContainer',
-  tableCellEditing: 'LexicalEditorTheme__tableCellEditing',
-  tableCellHeader: 'LexicalEditorTheme__tableCellHeader',
-  tableCellPrimarySelected: 'LexicalEditorTheme__tableCellPrimarySelected',
-  tableCellResizer: 'LexicalEditorTheme__tableCellResizer',
-  tableCellSelected: 'LexicalEditorTheme__tableCellSelected',
-  tableCellSortedIndicator: 'LexicalEditorTheme__tableCellSortedIndicator',
-  tableResizeRuler: 'LexicalEditorTheme__tableCellResizeRuler',
-  tableSelected: 'LexicalEditorTheme__tableSelected',
-  text: {
-    bold: 'LexicalEditorTheme__textBold',
-    code: 'LexicalEditorTheme__textCode',
-    italic: 'LexicalEditorTheme__textItalic',
-    strikethrough: 'LexicalEditorTheme__textStrikethrough',
-    subscript: 'LexicalEditorTheme__textSubscript',
-    superscript: 'LexicalEditorTheme__textSuperscript',
-    underline: 'LexicalEditorTheme__textUnderline',
-    underlineStrikethrough: 'LexicalEditorTheme__textUnderlineStrikethrough',
-  },
-}