@pilotiq/tiptap 3.10.5 → 3.10.6

package/src/PlainTextEditor.ts

@@ -1,229 +0,0 @@
-/**
- * Plain-text editor factory — Tiptap editor config tuned to behave like a
- * native `<input>` (single-line) or `<textarea>` (multi-line), with no marks
- * and a Document schema restricted to paragraph(s) of inline text.
- *
- * Built for `@pilotiq/pilotiq`'s collab-text-field path: when collab is on,
- * the renderer mounts a Tiptap editor instead of a native input so y-prosemirror
- * can anchor selections to Yjs `RelativePosition` items (positional identity).
- * This avoids the cursor-jump + concurrent-insert races inherent to the
- * `Y.Text` + manual `computeDelta` + heuristic `preserveCursor` path.
- *
- * Pure config — no React. Caller passes the returned object to `useEditor` or
- * `new Editor(...)`. Caller is also responsible for passing in the collab
- * extension list (typically `Collaboration` + `CollaborationCursor` from the
- * pilotiq collab adapter); we never import `@tiptap/extension-collaboration`
- * directly so the open-core package stays free of collab peer deps.
- */
-import {
-  Node,
-  Extension,
-  mergeAttributes,
-  type AnyExtension,
-  type EditorOptions,
-  type Editor,
-} from '@tiptap/core'
-import Placeholder from '@tiptap/extension-placeholder'
-
-/** Block separator used by `getText` — newline matches `<textarea>.value`. */
-const BLOCK_SEPARATOR = '\n'
-
-/**
- * Bare paragraph block — the only block the plain-text schema permits.
- * No options, no input rules, no toggles. `inline*` content lets any inline
- * node (today just `text`) appear inside.
- */
-const PlainTextParagraph = Node.create({
-  name: 'paragraph',
-  group: 'block',
-  content: 'inline*',
-  priority: 1000,
-  parseHTML() {
-    return [{ tag: 'p' }]
-  },
-  renderHTML({ HTMLAttributes }) {
-    return ['p', mergeAttributes(HTMLAttributes), 0]
-  },
-})
-
-/** The text node — Tiptap requires this to be defined explicitly. */
-const PlainTextText = Node.create({
-  name: 'text',
-  group: 'inline',
-})
-
-/**
- * Build a Document node with content restricted to either a single paragraph
- * (single-line mode) or one-or-more paragraphs (multi-line mode). The schema
- * itself blocks paste of incompatible content — ProseMirror will coerce or
- * reject non-matching nodes at parse time.
- */
-function makePlainTextDocument(multiline: boolean) {
-  return Node.create({
-    name: 'doc',
-    topNode: true,
-    content: multiline ? 'paragraph+' : 'paragraph',
-  })
-}
-
-/**
- * Single-line Enter handler. Tiptap's default `Enter` keymap splits the
- * paragraph — meaningless when the schema only allows exactly one — so we
- * intercept and either delegate to `onSubmit` (caller-supplied) or blur.
- *
- * Filament's plain-text fields blur on Enter; matching that default.
- */
-function makeSingleLineKeymap(onSubmit: ((editor: Editor) => boolean | void) | undefined) {
-  return Extension.create({
-    name: 'plainTextSingleLineKeymap',
-    addKeyboardShortcuts() {
-      const handleEnter = (): boolean => {
-        const handled = onSubmit?.(this.editor)
-        if (handled === true) return true
-        this.editor.commands.blur()
-        return true
-      }
-      return {
-        Enter:         handleEnter,
-        'Mod-Enter':   () => true,
-        'Shift-Enter': () => true,
-      }
-    },
-  })
-}
-
-export interface PlainTextEditorOptions {
-  /** If true, allow multiple paragraphs (textarea-like). Default `false` (input-like). */
-  multiline?: boolean
-  /** Placeholder text shown while the editor is empty. */
-  placeholder?: string
-  /** Editable / disabled state. Default `true`. */
-  editable?: boolean
-  /**
-   * Initial textual content. Ignored when a Collaboration extension is passed
-   * via `extensions` — Collaboration takes ownership of the document and seeds
-   * from the Yjs fragment instead. Use the caller's own first-load seed (see
-   * `@pilotiq/tiptap` README) when collab is on.
-   */
-  content?: string
-  /**
-   * Extra extensions to merge into the editor — typically the Collaboration +
-   * CollaborationCursor pair from the pilotiq collab adapter. Pass `[]` (or
-   * omit) for the non-collab path.
-   */
-  extensions?: AnyExtension[]
-  /**
-   * Called on every editor update with the editor's plain-text value (blocks
-   * joined by `'\n'`). Use this to mirror the value into form-state for
-   * submission via a hidden `<input>`.
-   */
-  onUpdate?: (text: string, editor: Editor) => void
-  /**
-   * Single-line Enter handler. Return `true` to suppress the default blur
-   * behavior. When omitted, Enter simply blurs the editor.
-   */
-  onSubmit?: (editor: Editor) => boolean | void
-  /**
-   * DOM attributes for the editor's contenteditable wrapper — typically
-   * `{ class: '…tailwind classes…' }` to style the editor like the native
-   * `<input>` / `<textarea>` it replaces.
-   */
-  editorAttributes?: Record<string, string>
-}
-
-/**
- * Read the editor's current value as plain text, with paragraphs joined by
- * `'\n'`. Mirrors the behavior of `<textarea>.value`.
- */
-export function plainTextOf(editor: Editor): string {
-  return editor.getText({ blockSeparator: BLOCK_SEPARATOR })
-}
-
-/**
- * Convert a plain-text string into a Tiptap JSON doc that satisfies the
- * plain-text schema. Multi-line input splits on `'\n'` into separate
- * paragraphs; single-line strips any embedded newlines into a single run.
- * Exported for tests — pure, no editor instance required.
- */
-export function plainTextToDoc(text: string, multiline: boolean): {
-  type: 'doc'
-  content: Array<{ type: 'paragraph'; content?: Array<{ type: 'text'; text: string }> }>
-} {
-  if (!multiline) {
-    const flat = text.replace(/\r?\n/g, '')
-    return {
-      type: 'doc',
-      content: [
-        flat ? { type: 'paragraph', content: [{ type: 'text', text: flat }] }
-             : { type: 'paragraph' },
-      ],
-    }
-  }
-  const lines = text.split(/\r?\n/)
-  return {
-    type: 'doc',
-    content: lines.map((line) =>
-      line ? { type: 'paragraph', content: [{ type: 'text', text: line }] }
-           : { type: 'paragraph' },
-    ),
-  }
-}
-
-/**
- * Build the Tiptap editor config for a plain-text field. Pass the returned
- * object to `useEditor` (React) or `new Editor(...)` (vanilla).
- *
- * The editor schema is deliberately minimal:
- *   - `doc` → `paragraph` (single-line) or `paragraph+` (multi-line)
- *   - `paragraph` → `inline*`
- *   - `text` (inline)
- *
- * No marks, no input rules, no list items, no code blocks — just text. Pasted
- * rich content is stripped to plain text by ProseMirror's schema enforcement.
- */
-export function createPlainTextEditor(
-  options: PlainTextEditorOptions = {},
-): Partial<EditorOptions> {
-  const {
-    multiline = false,
-    placeholder,
-    editable = true,
-    content = '',
-    extensions = [],
-    onUpdate,
-    onSubmit,
-    editorAttributes,
-  } = options
-
-  const schema: AnyExtension[] = [
-    makePlainTextDocument(multiline),
-    PlainTextParagraph,
-    PlainTextText,
-  ]
-
-  const behavior: AnyExtension[] = []
-  if (!multiline) behavior.push(makeSingleLineKeymap(onSubmit))
-  if (placeholder !== undefined) {
-    behavior.push(Placeholder.configure({ placeholder }))
-  }
-
-  const allExtensions: AnyExtension[] = [...schema, ...behavior, ...extensions]
-
-  // When Collaboration owns the doc, an explicit `content` would race the
-  // Yjs sync. Caller is responsible for omitting `content` in that case; we
-  // pass it through verbatim either way.
-  const initialContent = content ? plainTextToDoc(content, multiline) : ''
-
-  const config: Partial<EditorOptions> = {
-    editable,
-    extensions: allExtensions,
-    content: initialContent,
-  }
-  if (onUpdate) {
-    config.onUpdate = ({ editor }) => onUpdate(plainTextOf(editor), editor)
-  }
-  if (editorAttributes) {
-    config.editorProps = { attributes: editorAttributes }
-  }
-  return config
-}

package/src/RichTextField.test.ts

@@ -1,447 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { TextField, TextareaField } from '@pilotiq/pilotiq'
-
-import {
-  RichTextField,
-  DEFAULT_TOOLBAR_GROUPS,
-  DEFAULT_TEXT_COLORS,
-  DEFAULT_HIGHLIGHT_COLORS,
-} from './RichTextField.js'
-import { Block } from './Block.js'
-import { MentionProvider } from './MentionProvider.js'
-
-describe('RichTextField.toMeta', () => {
-  it('emits fieldType=richtext with empty defaults', () => {
-    const meta = RichTextField.make('body').toMeta()
-    assert.equal(meta.fieldType, 'richtext')
-    assert.equal(meta.name, 'body')
-    assert.deepEqual(meta.blocks, [])
-    assert.equal(meta.slashCommand, true)
-    assert.equal(meta.floatingToolbar, true)
-    assert.equal(meta.storage, 'json')
-    assert.deepEqual(meta.toolbarGroups, DEFAULT_TOOLBAR_GROUPS)
-  })
-
-  it('serializes blocks via Block.toMeta()', () => {
-    const meta = RichTextField.make('body').blocks([
-      Block.make('callout').label('Callout').icon('💡').schema([
-        TextField.make('title'),
-        TextareaField.make('content').required(),
-      ]),
-    ]).toMeta()
-
-    assert.equal(meta.blocks.length, 1)
-    const block = meta.blocks[0]!
-    assert.equal(block.name, 'callout')
-    assert.equal(block.label, 'Callout')
-    assert.equal(block.icon, '💡')
-    assert.equal(block.schema.length, 2)
-    assert.equal(block.schema[0]!.name, 'title')
-    assert.equal(block.schema[0]!.fieldType, 'text')
-    assert.equal(block.schema[1]!.name, 'content')
-    assert.equal(block.schema[1]!.fieldType, 'textarea')
-    assert.equal(block.schema[1]!.required, true)
-  })
-
-  it('honors slashCommand(false)', () => {
-    const meta = RichTextField.make('body').slashCommand(false).toMeta()
-    assert.equal(meta.slashCommand, false)
-  })
-
-  it('inherits required + placeholder from base Field', () => {
-    const meta = RichTextField.make('body')
-      .label('Article body')
-      .placeholder('Start writing…')
-      .required()
-      .toMeta()
-
-    assert.equal(meta.label, 'Article body')
-    assert.equal(meta.placeholder, 'Start writing…')
-    assert.equal(meta.required, true)
-  })
-})
-
-describe('RichTextField toolbar API', () => {
-  it('toolbar(false) hides the top-level toolbar', () => {
-    const meta = RichTextField.make('body').toolbar(false).toMeta()
-    assert.equal(meta.toolbarGroups, null)
-  })
-
-  it('toolbar(true) restores the default after toolbar(false)', () => {
-    const meta = RichTextField.make('body').toolbar(false).toolbar(true).toMeta()
-    assert.deepEqual(meta.toolbarGroups, DEFAULT_TOOLBAR_GROUPS)
-  })
-
-  it('floatingToolbar(false) toggles the selection toolbar', () => {
-    const meta = RichTextField.make('body').floatingToolbar(false).toMeta()
-    assert.equal(meta.floatingToolbar, false)
-  })
-
-  it('toolbarButtons([groups]) replaces the default layout', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([
-        ['bold', 'italic'],
-        ['undo', 'redo'],
-      ])
-      .toMeta()
-    assert.deepEqual(meta.toolbarGroups, [
-      ['bold', 'italic'],
-      ['undo', 'redo'],
-    ])
-  })
-
-  it('toolbarButtons(null) hides the toolbar', () => {
-    const meta = RichTextField.make('body').toolbarButtons(null).toMeta()
-    assert.equal(meta.toolbarGroups, null)
-  })
-
-  it('disableToolbarButtons removes ids from every group', () => {
-    const meta = RichTextField.make('body')
-      .disableToolbarButtons(['italic', 'undo', 'redo'])
-      .toMeta()
-    const flat = (meta.toolbarGroups ?? []).flat()
-    assert.equal(flat.includes('italic'), false)
-    assert.equal(flat.includes('undo'), false)
-    assert.equal(flat.includes('redo'), false)
-    assert.equal(flat.includes('bold'), true)
-  })
-
-  it('disableToolbarButtons drops a group when it empties out', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([
-        ['bold'],
-        ['italic'],
-      ])
-      .disableToolbarButtons(['italic'])
-      .toMeta()
-    assert.deepEqual(meta.toolbarGroups, [['bold']])
-  })
-
-  it('enableToolbarButtons appends to the last group', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([
-        ['bold', 'italic'],
-        ['undo', 'redo'],
-      ])
-      .enableToolbarButtons(['horizontalRule'])
-      .toMeta()
-    assert.deepEqual(meta.toolbarGroups, [
-      ['bold', 'italic'],
-      ['undo', 'redo', 'horizontalRule'],
-    ])
-  })
-
-  it('enableToolbarButtons obeys disable list', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([['bold']])
-      .enableToolbarButtons(['italic', 'underline'])
-      .disableToolbarButtons(['underline'])
-      .toMeta()
-    assert.deepEqual(meta.toolbarGroups, [['bold', 'italic']])
-  })
-
-  it('accepts lead + small in custom toolbar groups', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([
-        ['bold', 'italic'],
-        ['lead', 'small'],
-      ])
-      .toMeta()
-    assert.deepEqual(meta.toolbarGroups, [
-      ['bold', 'italic'],
-      ['lead', 'small'],
-    ])
-  })
-})
-
-describe('RichTextField color palettes', () => {
-  it('defaults to the bundled text-color palette', () => {
-    const meta = RichTextField.make('body').toMeta()
-    assert.deepEqual(meta.textColors, DEFAULT_TEXT_COLORS)
-    assert.deepEqual(meta.highlightColors, DEFAULT_HIGHLIGHT_COLORS)
-    assert.equal(meta.customTextColors, false)
-  })
-
-  it('textColors([...]) replaces the palette', () => {
-    const palette = [
-      { value: '#1e293b', label: 'Slate' },
-      { value: '#dc2626', label: 'Red',   dark: '#fca5a5' },
-    ]
-    const meta = RichTextField.make('body').textColors(palette).toMeta()
-    assert.deepEqual(meta.textColors, palette)
-  })
-
-  it('customTextColors() opts in to the free-form picker', () => {
-    const meta = RichTextField.make('body').customTextColors().toMeta()
-    assert.equal(meta.customTextColors, true)
-  })
-
-  it('highlightColors([...]) replaces the highlight palette', () => {
-    const palette = [{ value: '#fef08a', label: 'Yellow' }]
-    const meta = RichTextField.make('body').highlightColors(palette).toMeta()
-    assert.deepEqual(meta.highlightColors, palette)
-  })
-
-  it('passing null restores the defaults', () => {
-    const meta = RichTextField.make('body')
-      .textColors([{ value: '#000', label: 'Black' }])
-      .textColors(null)
-      .toMeta()
-    assert.deepEqual(meta.textColors, DEFAULT_TEXT_COLORS)
-  })
-})
-
-describe('RichTextField file attachments', () => {
-  it('defaults: resizableImages=false; no attachment options; toolbar strips attachFiles when no adapter', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([['bold', 'attachFiles']])
-      .toMeta()
-    assert.equal(meta.resizableImages, false)
-    assert.equal('fileAttachmentsAcceptedFileTypes' in meta, false)
-    assert.equal('fileAttachmentsMaxSize'            in meta, false)
-    assert.equal('fileAttachmentsDirectory'          in meta, false)
-    assert.equal('fileAttachmentsVisibility'         in meta, false)
-    assert.equal('uploadUrl'                         in meta, false)
-    // attachFiles stripped from the resolved groups when no adapter is wired.
-    assert.deepEqual(meta.toolbarGroups, [['bold']])
-  })
-
-  it('preserves attachFiles + stamps uploadUrl when adapter is wired', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([['bold', 'attachFiles']])
-      .toMeta({ uploadUrl: '/admin/_uploads', hasUploadAdapter: true })
-    assert.deepEqual(meta.toolbarGroups, [['bold', 'attachFiles']])
-    assert.equal(meta.uploadUrl, '/admin/_uploads')
-  })
-
-  it('drops a toolbar group entirely when attachFiles was its only button', () => {
-    const meta = RichTextField.make('body')
-      .toolbarButtons([['bold'], ['attachFiles']])
-      .toMeta()
-    assert.deepEqual(meta.toolbarGroups, [['bold']])
-  })
-
-  it('exposes resize + size + accept + directory + visibility', () => {
-    const meta = RichTextField.make('body')
-      .resizableImages()
-      .fileAttachmentsAcceptedFileTypes(['image/*'])
-      .fileAttachmentsMaxSize(2_000_000)
-      .fileAttachmentsDirectory('articles')
-      .fileAttachmentsVisibility('private')
-      .toMeta()
-    assert.equal(meta.resizableImages, true)
-    assert.deepEqual(meta.fileAttachmentsAcceptedFileTypes, ['image/*'])
-    assert.equal(meta.fileAttachmentsMaxSize, 2_000_000)
-    assert.equal(meta.fileAttachmentsDirectory, 'articles')
-    assert.equal(meta.fileAttachmentsVisibility, 'private')
-  })
-})
-
-describe('RichTextField merge tags + mentions', () => {
-  it('mergeTags + mentions default to empty arrays', () => {
-    const meta = RichTextField.make('body').toMeta()
-    assert.deepEqual(meta.mergeTags, [])
-    assert.deepEqual(meta.mentions,  [])
-  })
-
-  it('mergeTags([...]) round-trips through meta', () => {
-    const meta = RichTextField.make('body')
-      .mergeTags(['firstName', 'company'])
-      .toMeta()
-    assert.deepEqual(meta.mergeTags, ['firstName', 'company'])
-  })
-
-  it('mentions([...]) serializes each provider via toMeta()', () => {
-    const meta = RichTextField.make('body')
-      .mentions([
-        MentionProvider.make('@').items([
-          { id: 'sleman', label: 'Sleman' },
-          { id: 'alex',   label: 'Alex', group: 'Team' },
-        ]),
-        MentionProvider.make('#').items([
-          { id: 'general', label: 'general' },
-        ]),
-      ])
-      .toMeta()
-    assert.equal(meta.mentions.length, 2)
-    assert.equal(meta.mentions[0]!.trigger, '@')
-    assert.equal(meta.mentions[0]!.items.length, 2)
-    assert.equal(meta.mentions[0]!.items[0]!.id, 'sleman')
-    assert.equal(meta.mentions[0]!.items[1]!.group, 'Team')
-    assert.equal(meta.mentions[1]!.trigger, '#')
-  })
-})
-
-describe('MentionProvider', () => {
-  it('rejects non-single-character triggers', () => {
-    assert.throws(() => MentionProvider.make(''),  /single character/)
-    assert.throws(() => MentionProvider.make('@@'), /single character/)
-  })
-
-  it('items() replaces the static list', () => {
-    const p = MentionProvider.make('@').items([{ id: 'a', label: 'A' }])
-    assert.equal(p.getTrigger(), '@')
-    assert.equal(p.getItems().length, 1)
-    assert.equal(p.getItems()[0]!.id, 'a')
-  })
-
-  it('toMeta() copies the items array (snapshot, not reference)', () => {
-    const items = [{ id: 'a', label: 'A' }]
-    const meta = MentionProvider.make('@').items(items).toMeta()
-    items.push({ id: 'b', label: 'B' })
-    assert.equal(meta.items.length, 1)
-  })
-
-  it('static providers report isAsync=false and emit no async flag', () => {
-    const p = MentionProvider.make('@').items([{ id: 'a', label: 'A' }])
-    assert.equal(p.isAsync(), false)
-    const meta = p.toMeta()
-    assert.equal('async' in meta, false)
-  })
-
-  it('itemsUsing(fn) flips isAsync=true and empties the inlined items', () => {
-    const p = MentionProvider.make('@').itemsUsing(async () => [{ id: 'a', label: 'A' }])
-    assert.equal(p.isAsync(), true)
-    const meta = p.toMeta()
-    assert.equal(meta.async, true)
-    assert.deepEqual(meta.items, [])
-  })
-
-  it('runResolver runs the static list when no async fn is set', async () => {
-    const p = MentionProvider.make('@').items([
-      { id: 'sleman', label: 'Sleman' },
-      { id: 'alex',   label: 'Alex'   },
-    ])
-    const items = await p.runResolver('al', { user: null })
-    // Returns the full list — filtering is the menu's job.
-    assert.equal(items.length, 2)
-  })
-
-  it('runResolver awaits an async resolver and forwards query + ctx', async () => {
-    let seenQuery: string | undefined
-    let seenUser:  unknown
-    const p = MentionProvider.make('@').itemsUsing(async (query, ctx) => {
-      seenQuery = query
-      seenUser  = ctx.user
-      return [{ id: query, label: `Hit: ${query}` }]
-    })
-    const items = await p.runResolver('alex', { user: { id: 1 } })
-    assert.equal(seenQuery, 'alex')
-    assert.deepEqual(seenUser, { id: 1 })
-    assert.equal(items.length, 1)
-    assert.equal(items[0]!.id,    'alex')
-    assert.equal(items[0]!.label, 'Hit: alex')
-  })
-
-  it('runResolver coerces non-array returns to []', async () => {
-    const p = MentionProvider.make('@').itemsUsing((async () => null) as never)
-    const items = await p.runResolver('q', {})
-    assert.deepEqual(items, [])
-  })
-
-  it('items() after itemsUsing() warns and switches to static (last call wins)', () => {
-    const orig = console.warn
-    const warnings: string[] = []
-    console.warn = (...args: unknown[]) => warnings.push(String(args[0]))
-    try {
-      const p = MentionProvider.make('@')
-        .itemsUsing(async () => [{ id: 'x', label: 'X' }])
-        .items([{ id: 'a', label: 'A' }])
-      assert.equal(p.isAsync(), false)
-      assert.equal(warnings.length, 1)
-      assert.match(warnings[0]!, /MentionProvider.*items\(\) called after.*itemsUsing/)
-    } finally {
-      console.warn = orig
-    }
-  })
-
-  it('itemsUsing() after items() warns and clears the static list', () => {
-    const orig = console.warn
-    const warnings: string[] = []
-    console.warn = (...args: unknown[]) => warnings.push(String(args[0]))
-    try {
-      const p = MentionProvider.make('@')
-        .items([{ id: 'a', label: 'A' }])
-        .itemsUsing(async () => [{ id: 'x', label: 'X' }])
-      assert.equal(p.isAsync(), true)
-      assert.equal(warnings.length, 1)
-      assert.match(warnings[0]!, /MentionProvider.*itemsUsing\(\) called after.*items\(\)/)
-    } finally {
-      console.warn = orig
-    }
-  })
-})
-
-describe('RichTextField mention resolution', () => {
-  it('hasAsyncMentions() is false when every provider is static', () => {
-    const f = RichTextField.make('body').mentions([
-      MentionProvider.make('@').items([{ id: 'a', label: 'A' }]),
-    ])
-    assert.equal(f.hasAsyncMentions(), false)
-  })
-
-  it('hasAsyncMentions() is true when at least one provider is async', () => {
-    const f = RichTextField.make('body').mentions([
-      MentionProvider.make('@').items([{ id: 'a', label: 'A' }]),
-      MentionProvider.make('#').itemsUsing(async () => []),
-    ])
-    assert.equal(f.hasAsyncMentions(), true)
-  })
-
-  it('resolveMention dispatches by trigger char', async () => {
-    const f = RichTextField.make('body').mentions([
-      MentionProvider.make('@').itemsUsing(async (q) => [{ id: q, label: `User:${q}` }]),
-      MentionProvider.make('#').itemsUsing(async (q) => [{ id: q, label: `Channel:${q}` }]),
-    ])
-    const userHits = await f.resolveMention('@', 'sleman', {})
-    const chanHits = await f.resolveMention('#', 'general', {})
-    assert.equal(userHits?.[0]?.label, 'User:sleman')
-    assert.equal(chanHits?.[0]?.label, 'Channel:general')
-  })
-
-  it('resolveMention returns null for unknown triggers', async () => {
-    const f = RichTextField.make('body').mentions([
-      MentionProvider.make('@').itemsUsing(async () => []),
-    ])
-    const items = await f.resolveMention('!', 'q', {})
-    assert.equal(items, null)
-  })
-
-  it('mentionsUrl is omitted from meta until withMentionsUrl stamps it', () => {
-    const f = RichTextField.make('body').mentions([
-      MentionProvider.make('@').itemsUsing(async () => []),
-    ])
-    assert.equal('mentionsUrl' in f.toMeta(), false)
-    f.withMentionsUrl('/admin/articles/_form/article-form/mentions')
-    assert.equal(f.toMeta().mentionsUrl, '/admin/articles/_form/article-form/mentions')
-  })
-})
-
-describe('RichTextField storage', () => {
-  it('defaults to json', () => {
-    const meta = RichTextField.make('body').toMeta()
-    assert.equal(meta.storage, 'json')
-  })
-
-  it('storage("html") opts into HTML serialization', () => {
-    const meta = RichTextField.make('body').storage('html').toMeta()
-    assert.equal(meta.storage, 'html')
-  })
-})
-
-describe('Block.toMeta', () => {
-  it('uses block name as label fallback', () => {
-    const meta = Block.make('hero').toMeta()
-    assert.equal(meta.name, 'hero')
-    assert.equal(meta.label, 'hero')
-    assert.equal(meta.icon, undefined)
-    assert.deepEqual(meta.schema, [])
-  })
-
-  it('preserves icon and label when set', () => {
-    const meta = Block.make('callout').label('Callout block').icon('💡').toMeta()
-    assert.equal(meta.label, 'Callout block')
-    assert.equal(meta.icon, '💡')
-  })
-})