@byline/richtext-lexical 5.2.0 → 6.0.1

package/src/field/capabilities/registered-node-types.test.tsx

@@ -0,0 +1,29 @@
+import { HeadingNode } from '@lexical/rich-text'
+import { describe, expect, it } from 'vitest'
+
+import { buildFullEditor, buildRestrictedEditor } from '../test-support/build-test-editor'
+import { registeredNodeTypes, supportsNodeType } from './registered-node-types'
+
+describe('registeredNodeTypes', () => {
+  it('always reports the core types', () => {
+    const editor = buildRestrictedEditor()
+    const types = registeredNodeTypes(editor)
+    expect(types.has('root')).toBe(true)
+    expect(types.has('paragraph')).toBe(true)
+    expect(types.has('text')).toBe(true)
+    editor.dispose()
+  })
+
+  it('agrees with hasNode for a class the editor registers', () => {
+    const editor = buildFullEditor()
+    expect(editor.hasNode(HeadingNode)).toBe(supportsNodeType(editor, 'heading'))
+    editor.dispose()
+  })
+
+  it('reports a type as unsupported once its extension is removed', () => {
+    const editor = buildRestrictedEditor()
+    expect(supportsNodeType(editor, 'table')).toBe(false)
+    expect(supportsNodeType(editor, 'link')).toBe(false)
+    editor.dispose()
+  })
+})

package/src/field/capabilities/registered-node-types.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 { LexicalEditor } from 'lexical'
+
+/**
+ * The set of node type strings this editor accepts.
+ *
+ * This is the ONLY place in Byline that reads `editor._nodes`. Lexical
+ * declares the property on the public `LexicalEditor` type but exposes
+ * no way to enumerate registered type strings — `hasNode` answers only
+ * for a class you already hold, while the normalizer works from
+ * serialized JSON where all it has is the type string. Keeping the
+ * access here gives a future Lexical change one site to fix.
+ */
+export function registeredNodeTypes(editor: LexicalEditor): ReadonlySet<string> {
+  return new Set(editor._nodes.keys())
+}
+
+/**
+ * Whether this editor accepts `type`.
+ *
+ * Node registration is what decides whether a structure can exist in the
+ * field at all — it governs the legacy paste path, `parseEditorState`
+ * and every command that creates a node — so this is the honest answer
+ * to "does this field support X", not whether some extension appears in
+ * a configuration list.
+ */
+export function supportsNodeType(editor: LexicalEditor, type: string): boolean {
+  return editor._nodes.has(type)
+}

package/src/field/config/built-in-extension-names.test.node.ts

@@ -8,7 +8,11 @@
 
 import { describe, expect, it } from 'vitest'
 
-import { builtInExtensions } from './built-in-extension-names'
+import {
+  builtInExtensions,
+  bylineExtensionNames,
+  upstreamExtensionNames,
+} from './built-in-extension-names'
 
 /**
  * Node-safe self-consistency checks for the `builtInExtensions` name map.
@@ -16,29 +20,49 @@ import { builtInExtensions } from './built-in-extension-names'
  * The map deliberately carries strings only (no extension imports), so
  * this test cannot diff against the live `defineExtension({ name })`
  * values without dragging the React-heavy editor graph into a node test.
- * Instead it guards the map's own integrity — the `@byline/richtext-lexical/*`
- * convention, uniqueness, and that each key matches the suffix of its
- * value. Each value must still mirror the corresponding extension's
- * `name`; that mirror is asserted by the editor's jsdom/integration
- * coverage, not here.
+ * Instead it guards the map's own integrity — the naming convention,
+ * uniqueness, and that each key matches the suffix of its value. Each
+ * value must still mirror the corresponding extension's `name`; that
+ * mirror is asserted by the editor's jsdom coverage, not here.
+ *
+ * The convention applies to the names Byline owns. `upstreamExtensionNames`
+ * is a documented exception: those extensions ship from `@lexical/list`,
+ * so Byline cannot namespace them and only guarantees that they are
+ * well-formed and unique.
  */
 describe('builtInExtensions name map', () => {
+  const bylineEntries = Object.entries(bylineExtensionNames)
   const entries = Object.entries(builtInExtensions)
 
-  it('namespaces every value under @byline/richtext-lexical/', () => {
-    for (const [, value] of entries) {
+  it('namespaces every Byline-owned value under @byline/richtext-lexical/', () => {
+    for (const [, value] of bylineEntries) {
       expect(value).toMatch(/^@byline\/richtext-lexical\/[A-Za-z]+$/)
     }
   })
 
-  it('uses each value exactly once', () => {
-    const values = entries.map(([, value]) => value)
-    expect(new Set(values).size).toBe(values.length)
+  it('names each Byline-owned key after the suffix of its value', () => {
+    for (const [key, value] of bylineEntries) {
+      expect(value).toBe(`@byline/richtext-lexical/${key}`)
+    }
   })
 
-  it('names each key after the suffix of its value', () => {
-    for (const [key, value] of entries) {
-      expect(value).toBe(`@byline/richtext-lexical/${key}`)
+  it('keeps upstream-owned values well-formed and namespaced to their package', () => {
+    for (const [, value] of Object.entries(upstreamExtensionNames)) {
+      expect(value).toMatch(/^@lexical\/[a-z-]+\/[A-Za-z]+$/)
     }
   })
+
+  it('exposes both groups through the merged map', () => {
+    for (const key of [
+      ...Object.keys(bylineExtensionNames),
+      ...Object.keys(upstreamExtensionNames),
+    ]) {
+      expect(builtInExtensions).toHaveProperty(key)
+    }
+  })
+
+  it('uses each value exactly once across the merged map', () => {
+    const values = entries.map(([, value]) => value)
+    expect(new Set(values).size).toBe(values.length)
+  })
 })

package/src/field/config/built-in-extension-names.ts

@@ -32,22 +32,50 @@
  * against the live extension `name`s is exercised by the editor's
  * jsdom/integration coverage.
  */
-export const builtInExtensions = {
+export const bylineExtensionNames = {
   Admonition: '@byline/richtext-lexical/Admonition',
   AutoEmbed: '@byline/richtext-lexical/AutoEmbed',
   AutoLink: '@byline/richtext-lexical/AutoLink',
   CodeHighlight: '@byline/richtext-lexical/CodeHighlight',
   FloatingTextFormat: '@byline/richtext-lexical/FloatingTextFormat',
   FloatingUI: '@byline/richtext-lexical/FloatingUI',
+  Heading: '@byline/richtext-lexical/Heading',
   HorizontalRule: '@byline/richtext-lexical/HorizontalRule',
   InlineImage: '@byline/richtext-lexical/InlineImage',
   Layout: '@byline/richtext-lexical/Layout',
   Link: '@byline/richtext-lexical/Link',
+  Quote: '@byline/richtext-lexical/Quote',
   Table: '@byline/richtext-lexical/Table',
   Toolbar: '@byline/richtext-lexical/Toolbar',
   Vimeo: '@byline/richtext-lexical/Vimeo',
   YouTube: '@byline/richtext-lexical/YouTube',
 } as const
 
+/**
+ * Names owned by upstream Lexical packages.
+ *
+ * These deliberately break the `@byline/richtext-lexical/<Key>`
+ * convention because Byline does not own the names — the extensions ship
+ * from `@lexical/list`. They are carried here so a site can remove lists
+ * without importing `@lexical/list` directly and taking a
+ * version-pinned dependency on `lexical` of its own.
+ */
+export const upstreamExtensionNames = {
+  List: '@lexical/list/List',
+  CheckList: '@lexical/list/CheckList',
+} as const
+
+/**
+ * Every extension a site may remove, replace or reorder.
+ *
+ * Note what is absent: `CoreNodesExtension` is injected by the editor
+ * root rather than configured here, because `MarkNode` and
+ * `OverflowNode` belong to no switchable feature.
+ */
+export const builtInExtensions = {
+  ...bylineExtensionNames,
+  ...upstreamExtensionNames,
+} as const
+
 /** Union of the built-in extension `name` strings. */
 export type BuiltInExtensionName = (typeof builtInExtensions)[keyof typeof builtInExtensions]

package/src/field/config/default-extensions.ts

@@ -22,10 +22,12 @@ import { BylineFloatingUIExtension } from '../extensions/byline-floating-ui/byli
 import { BylineToolbarExtension } from '../extensions/byline-toolbar/byline-toolbar-extension'
 import { CodeHighlightExtension } from '../extensions/code-highlight/code-highlight-extension'
 import { FloatingTextFormatExtension } from '../extensions/floating-text-format/floating-text-format-extension'
+import { HeadingExtension } from '../extensions/heading/heading-extension'
 import { HorizontalRuleExtension } from '../extensions/horizontal-rule/horizontal-rule-extension'
 import { InlineImageExtension } from '../extensions/inline-image/inline-image-extension'
 import { LayoutExtension } from '../extensions/layout/layout-extension'
 import { LinkExtension } from '../extensions/link/link-extension'
+import { QuoteExtension } from '../extensions/quote/quote-extension'
 import { TableExtension } from '../extensions/table/table-extension'
 import { VimeoExtension } from '../extensions/vimeo/vimeo-extension'
 import { YouTubeExtension } from '../extensions/youtube/youtube-extension'
@@ -61,6 +63,10 @@ export function defaultExtensionsArray(): AnyLexicalExtensionArgument[] {
     BylineToolbarExtension,
     BylineFloatingUIExtension,
 
+    // Block-level text structures.
+    HeadingExtension,
+    QuoteExtension,
+
     // Block- / list-level features.
     ListExtension,
     CheckListExtension,

package/src/field/config/default.ts

@@ -9,17 +9,17 @@ export const defaultEditorLexicalConfig: LexicalEditorConfig = {
 }
 
 export const DEFAULT_EDITOR_SETTINGS: EditorSettings = {
-  options: {
-    richText: true,
-    showTreeView: false,
+  mode: 'richText',
+  markdownShortcuts: false,
+  controls: {
+    blockFormat: true,
+    inlineCode: true,
+    undoRedo: true,
     textAlignment: true,
-    markdownShortcutPlugin: false,
     markdownToggle: false,
-    undoRedo: true,
-    textStyle: true,
-    inlineCode: true,
-    debug: false,
+    treeView: false,
   },
+  debug: false,
   inlineImageUploadCollection: 'media',
   placeholderText: 'Enter some rich text...',
 }

package/src/field/config/editor-config-context.tsx

@@ -4,20 +4,20 @@ import type * as React from 'react'
 import { createContext, useCallback, useContext, useMemo, useState } from 'react'
 
 import { DEFAULT_EDITOR_SETTINGS } from './default'
-import type { EditorSettings, OptionName } from './types'
+import type { EditorControls, EditorSettings } from './types'
 
 // Should always produce a 20 character pseudo-random string
 function generateQuickGuid(): string {
   return Math.random().toString(36).substring(2, 12) + Math.random().toString(36).substring(2, 12)
 }
 interface ContextType {
-  setOption: (name: OptionName, value: boolean) => void
+  setControl: (name: keyof EditorControls, value: boolean) => void
   config: EditorSettings
   uuid: string
 }
 
 const Context: React.Context<ContextType> = createContext({
-  setOption: (_name: OptionName, _value: boolean) => {},
+  setControl: (_name: keyof EditorControls, _value: boolean) => {},
   config: DEFAULT_EDITOR_SETTINGS,
   uuid: generateQuickGuid(),
 })
@@ -33,14 +33,19 @@ export const EditorConfigContext = ({
   // State to store the UUID
   const [uuid] = useState(() => generateQuickGuid())
 
-  const setOption = useCallback((option: OptionName, value: boolean) => {
-    setConfig((config) => {
-      const options = { ...config.options, [option as string]: value }
-      return { ...config, options }
-    })
+  /**
+   * Toggle one interface control at runtime. Controls hide affordances
+   * only — there is deliberately no equivalent for capabilities, which
+   * are fixed when the editor is built.
+   */
+  const setControl = useCallback((control: keyof EditorControls, value: boolean) => {
+    setConfig((config) => ({
+      ...config,
+      controls: { ...config.controls, [control]: value },
+    }))
   }, [])
 
-  const editorContext = useMemo(() => ({ setOption, config, uuid }), [setOption, config, uuid])
+  const editorContext = useMemo(() => ({ setControl, config, uuid }), [setControl, config, uuid])
 
   return <Context.Provider value={editorContext}>{children}</Context.Provider>
 }

package/src/field/config/list-removal.test.tsx

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+
+import { supportsNodeType } from '../capabilities/registered-node-types'
+import {
+  buildFullEditor,
+  buildRestrictedEditor,
+  parseHtmlToTypes,
+} from '../test-support/build-test-editor'
+import { builtInExtensions } from './built-in-extension-names'
+
+describe('list removal', () => {
+  it('exposes the upstream list names so a site need not import @lexical/list', () => {
+    expect(builtInExtensions.List).toBe('@lexical/list/List')
+    expect(builtInExtensions.CheckList).toBe('@lexical/list/CheckList')
+  })
+
+  it('degrades bullet and check lists to paragraphs', () => {
+    const editor = buildRestrictedEditor([builtInExtensions.List, builtInExtensions.CheckList])
+    expect(supportsNodeType(editor, 'list')).toBe(false)
+    expect(supportsNodeType(editor, 'listitem')).toBe(false)
+
+    const bullet = parseHtmlToTypes(editor, '<ul><li>item one</li><li>item two</li></ul>')
+    expect(bullet.types).toEqual(['paragraph', 'paragraph'])
+    expect(bullet.text).toContain('item one')
+    expect(bullet.text).toContain('item two')
+    editor.dispose()
+  })
+
+  it('keeps bullet lists when only the check-list extension is removed', () => {
+    // CheckListExtension contributes behaviour, not nodes — ListExtension
+    // owns both node classes, so removing the check list must not take
+    // ordinary lists with it.
+    const editor = buildRestrictedEditor([builtInExtensions.CheckList])
+    expect(supportsNodeType(editor, 'list')).toBe(true)
+    expect(parseHtmlToTypes(editor, '<ul><li>one</li></ul>').types).toEqual(['list'])
+    editor.dispose()
+  })
+
+  it('still imports lists with the default configuration', () => {
+    const editor = buildFullEditor()
+    expect(parseHtmlToTypes(editor, '<ul><li>one</li></ul>').types).toEqual(['list'])
+    editor.dispose()
+  })
+})

package/src/field/config/resolve-editor-config.test.node.ts

@@ -32,23 +32,44 @@ describe('resolveEditorConfig', () => {
 
   it('field settings win per-key; unspecified registered settings survive', () => {
     const registered = clone(defaultEditorConfig)
-    registered.settings.options.markdownToggle = true
+    registered.settings.controls.markdownToggle = true
     registered.settings.placeholderText = 'registered placeholder'
 
     const fieldConfig = clone(defaultEditorConfig)
-    fieldConfig.settings.options.textStyle = false
-    fieldConfig.settings.options.undoRedo = false
+    fieldConfig.settings.controls.blockFormat = false
+    fieldConfig.settings.controls.undoRedo = false
 
     const resolved = resolveEditorConfig(fieldConfig, registered)
     // Field's flags applied…
-    expect(resolved.settings.options.textStyle).toBe(false)
-    expect(resolved.settings.options.undoRedo).toBe(false)
+    expect(resolved.settings.controls.blockFormat).toBe(false)
+    expect(resolved.settings.controls.undoRedo).toBe(false)
     // …and since schema-side configs are complete objects, its values win
     // for every key it carries (markdownToggle false from the default seed).
-    expect(resolved.settings.options.markdownToggle).toBe(false)
+    expect(resolved.settings.controls.markdownToggle).toBe(false)
     expect(resolved.settings.placeholderText).toBe(fieldConfig.settings.placeholderText)
   })
 
+  it('merges controls per-key so a partial override keeps the rest', () => {
+    const registered = clone(defaultEditorConfig)
+    const fieldConfig = {
+      settings: { controls: { blockFormat: false } },
+    } as unknown as typeof registered
+
+    const resolved = resolveEditorConfig(fieldConfig, registered)
+    expect(resolved.settings.controls.blockFormat).toBe(false)
+    // Untouched controls keep the registered layer's values rather than
+    // being wiped by a partial object.
+    expect(resolved.settings.controls.undoRedo).toBe(true)
+    expect(resolved.settings.controls.inlineCode).toBe(true)
+    expect(resolved.settings.mode).toBe('richText')
+    expect(resolved.settings.markdownShortcuts).toBe(false)
+  })
+
+  it('no longer carries an options record', () => {
+    const registered = clone(defaultEditorConfig)
+    expect('options' in registered.settings).toBe(false)
+  })
+
   it('REGRESSION: a schema-side settings-only config must not discard the registered extensions graph', () => {
     // Before the merge existed, `field.editorConfig ?? registered` replaced
     // the whole object: a compact/minimal settings preset baked into the

package/src/field/config/resolve-editor-config.ts

@@ -40,9 +40,9 @@ export function resolveEditorConfig(
     settings: {
       ...registeredConfig.settings,
       ...fieldConfig.settings,
-      options: {
-        ...registeredConfig.settings.options,
-        ...fieldConfig.settings?.options,
+      controls: {
+        ...registeredConfig.settings.controls,
+        ...fieldConfig.settings?.controls,
       },
     },
     lexical: fieldConfig.lexical ?? registeredConfig.lexical,

package/src/field/config/root-dependencies.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 { CoreNodesExtension } from '../extensions/core-nodes/core-nodes-extension'
+import type { ExtensionsList } from './extensions-list'
+
+/**
+ * The complete dependency list for an editor root.
+ *
+ * `editorConfig.extensions` carries the OPTIONAL features a site
+ * configures. What an editor actually registers is that list plus
+ * mandatory infrastructure, and `CoreNodesExtension` is injected here
+ * rather than living in the configurable list because `MarkNode` and
+ * `OverflowNode` belong to no switchable feature — `ExtensionsList.remove()`
+ * matches by name and accepts the extension object, so an entry in the
+ * list could be removed by site code.
+ *
+ * Everything that builds an editor goes through this: the live editor,
+ * the test builders, and the capability manifest. A manifest that
+ * disagreed with the runtime about which nodes exist would be worse than
+ * no manifest, and this is the seam that keeps them identical.
+ */
+export function rootDependencies(extensions: ExtensionsList): AnyLexicalExtensionArgument[] {
+  return [CoreNodesExtension, ...extensions.toArray()]
+}

package/src/field/config/types.ts

@@ -3,25 +3,66 @@ import type { EditorConfig as LexicalEditorConfig } from 'lexical'
 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.
+ * Interface preferences — which controls the editing surface shows.
+ *
+ * Every flag here hides an affordance and NOTHING else. None of them
+ * restricts what the field accepts: content still arrives by paste, by
+ * Markdown, and from storage regardless. What a field supports is
+ * decided by its resolved editor — the extensions it is configured with,
+ * everything those pull in transitively, and mandatory core nodes.
+ *
+ * If you want to stop a structure existing in a field, remove the
+ * extension that owns it:
+ * `lexicalEditor((c) => c.extensions.remove(builtInExtensions.Heading))`.
  */
-export type OptionName =
-  | 'richText'
-  | 'showTreeView'
-  | 'textAlignment'
-  | 'markdownShortcutPlugin'
-  | 'markdownToggle'
-  | 'undoRedo'
-  | 'textStyle'
-  | 'inlineCode'
-  | 'debug'
+export interface EditorControls {
+  /**
+   * Show the block-format dropdown. Its entries are further limited to
+   * the formats the editor can actually produce, so this hides a control
+   * that is already capability-aware.
+   */
+  blockFormat: boolean
+  /**
+   * Show the inline-code button.
+   *
+   * This does NOT prevent inline code. Inline code is a `TextNode`
+   * format rather than a node type, so it has no node to unregister and
+   * still arrives by paste. Node-level configuration cannot constrain
+   * it, and neither can this flag.
+   */
+  inlineCode: boolean
+  /** Show the undo and redo buttons. Keyboard undo keeps working either way. */
+  undoRedo: boolean
+  /** Show the text-alignment controls. */
+  textAlignment: boolean
+  /** Show the Markdown source-mode toggle. */
+  markdownToggle: boolean
+  /** Show the Lexical tree view beneath the editor. */
+  treeView: boolean
+}
 
 export interface EditorSettings {
-  options: Record<OptionName, boolean>
+  /**
+   * Which editing surface to mount: `RichTextPlugin` or
+   * `PlainTextPlugin`. Plain-text mode also hides the toolbar.
+   *
+   * This selects the plugin and its input handling — it does NOT change
+   * what the field accepts. Switching to `plainText` unregisters no node
+   * class, so structural content already in a stored value still loads,
+   * and a paste is still governed by the editor's registered nodes. To
+   * stop a structure existing in the field, remove the extension that
+   * owns it.
+   */
+  mode: 'richText' | 'plainText'
+  /**
+   * Enable Markdown input shortcuts (`# `, `- `, `> ` as you type). The
+   * active transformer set follows the editor's registered nodes, so a
+   * shortcut for a structure the field does not support never fires.
+   */
+  markdownShortcuts: boolean
+  controls: EditorControls
+  /** Render debug output and the tree view. */
+  debug: boolean
   /**
    * Upload collection passed to the inline-image picker. Forwarded to
    * `InlineImageExtension`'s config when the extensions list is built;
@@ -33,7 +74,10 @@ export interface EditorSettings {
 }
 
 export interface EditorSettingsOverride {
-  options?: Partial<Record<OptionName, boolean>>
+  mode?: EditorSettings['mode']
+  markdownShortcuts?: boolean
+  controls?: Partial<EditorControls>
+  debug?: boolean
   inlineImageUploadCollection?: string
   placeholderText?: string
 }

package/src/field/editor-component.test.tsx

@@ -17,17 +17,29 @@ vi.mock('@byline/ui/react', () => ({
 }))
 
 import { ApplyValuePlugin } from './apply-value-plugin'
+import { APPLY_VALUE_TAG } from './constants'
 import { hashSerializedState } from './utils/hashSerializedState'
 
 // Enable React act warnings suppression for this environment
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ;(globalThis as any).IS_REACT_ACT_ENVIRONMENT = true
 
-// Mock the Lexical composer context to avoid spinning up a real editor
+// Mock the Lexical composer context to avoid spinning up a real editor.
+//
+// `_nodes` is required because ApplyValuePlugin normalizes the incoming
+// value against the editor's registered node types before applying it.
+// A stub with only the core types means nothing in these fixtures needs
+// converting, so the plugin's apply behaviour is what is under test here
+// rather than normalization (covered in `normalize/`).
 const mockEditor = {
   update: (fn: () => void) => fn(),
   parseEditorState: vi.fn((val) => val),
   setEditorState: vi.fn(),
+  _nodes: new Map<string, unknown>([
+    ['root', {}],
+    ['paragraph', {}],
+    ['text', {}],
+  ]),
 }
 
 vi.mock('@lexical/react/LexicalComposerContext', () => {
@@ -105,7 +117,10 @@ describe('ApplyValuePlugin', () => {
     })
 
     expect(mockEditor.setEditorState).toHaveBeenCalledTimes(1)
-    expect(mockEditor.setEditorState).toHaveBeenLastCalledWith(stateA)
+    // The APPLY_VALUE_TAG argument is not incidental: it is what stops
+    // OnChangePlugin treating an applied value as a user edit, so assert
+    // it rather than the state alone.
+    expect(mockEditor.setEditorState).toHaveBeenLastCalledWith(stateA, { tag: APPLY_VALUE_TAG })
 
     // Re-render with same value -> no new apply
     await act(async () => {
@@ -135,7 +150,7 @@ describe('ApplyValuePlugin', () => {
       )
     })
     expect(mockEditor.setEditorState).toHaveBeenCalledTimes(2)
-    expect(mockEditor.setEditorState).toHaveBeenLastCalledWith(stateB)
+    expect(mockEditor.setEditorState).toHaveBeenLastCalledWith(stateB, { tag: APPLY_VALUE_TAG })
 
     await act(async () => {
       root.unmount()