@pilotiq/tiptap 3.10.4 → 3.10.6

package/src/MentionProvider.ts

@@ -1,153 +0,0 @@
-/**
- * Static menu item surfaced by a {@link MentionProvider}. `id` is the wire
- * identifier that survives serialization; `label` is what the editor shows
- * after the trigger char (`@Sleman`). `group` is purely cosmetic — the menu
- * uses it to bucket items under headings.
- */
-export interface MentionItem {
-  id:     string
-  label:  string
-  group?: string
-}
-
-/** Wire-side shape of a {@link MentionProvider}. */
-export interface MentionProviderMeta {
-  trigger: string
-  items:   MentionItem[]
-  /** Set when the provider is backed by an `itemsUsing(fn)` resolver — the
-   *  client fetches items from the field's `mentionsUrl` instead of using
-   *  the (empty) inlined list. */
-  async?:  boolean
-}
-
-/**
- * Context handed to `MentionProvider.itemsUsing(fn)` resolvers. Mirrors the
- * subset of {@link RenderContext} the route handler can re-derive at request
- * time — `user` from `Pilotiq.user(req=>…)`, `record` for edit-mode forms,
- * and the raw `request` for adapters that need cookie / header access.
- */
-export interface MentionResolverContext {
-  user?:    unknown
-  record?:  unknown
-  request?: unknown
-}
-
-export type MentionItemsResolver = (
-  query: string,
-  ctx:   MentionResolverContext,
-) => MentionItem[] | Promise<MentionItem[]>
-
-/**
- * Builder for a single mention provider — the trigger character (`@` /
- * `#` / …) and the items the popover offers when the user types it.
- *
- * Two shapes:
- *   - `MentionProvider.make('@').items([...])` — static items declared at
- *     form-build time, inlined into the field meta.
- *   - `MentionProvider.make('@').itemsUsing(async (query, ctx) => […])` —
- *     async resolver. The client fetches every keystroke; the server runs
- *     the user fn and returns the matched items. `items` and `itemsUsing`
- *     are mutually exclusive — last call wins, with a warning when both
- *     have been set.
- *
- * Read-time label resolution still works through `renderRichTextToHtml(
- * content, { resolveMention })` for cases where the cached label has gone
- * stale.
- *
- * @example Static items
- * ```ts
- * MentionProvider.make('@').items([
- *   { id: 'sleman', label: 'Sleman' },
- *   { id: 'alex',   label: 'Alex'   },
- * ])
- * ```
- *
- * @example Async items
- * ```ts
- * MentionProvider.make('@').itemsUsing(async (query) => {
- *   const users = await db.users.search(query, { limit: 10 })
- *   return users.map(u => ({ id: u.id, label: u.name }))
- * })
- * ```
- */
-export class MentionProvider {
-  private _trigger: string
-  private _items:   MentionItem[] = []
-  private _itemsUsing?: MentionItemsResolver
-
-  protected constructor(trigger: string) {
-    if (typeof trigger !== 'string' || trigger.length !== 1) {
-      throw new Error(`MentionProvider trigger must be a single character (got ${JSON.stringify(trigger)})`)
-    }
-    this._trigger = trigger
-  }
-
-  static make(trigger: string): MentionProvider {
-    return new MentionProvider(trigger)
-  }
-
-  /** Replace the static item list. Mutually exclusive with `itemsUsing()`. */
-  items(items: MentionItem[]): this {
-    if (this._itemsUsing !== undefined) {
-      console.warn(
-        `[pilotiq/tiptap] MentionProvider('${this._trigger}'): items() called after ` +
-        `itemsUsing(). The static list now wins; clear itemsUsing first to avoid surprise.`,
-      )
-      delete this._itemsUsing
-    }
-    this._items = items
-    return this
-  }
-
-  /**
-   * Install an async resolver. Called every keystroke with the current
-   * query (the text after the trigger char) and a `MentionResolverContext`.
-   *
-   * Mutually exclusive with `items()` — the last call wins; a warning fires
-   * when the previously-set static items are dropped silently.
-   */
-  itemsUsing(fn: MentionItemsResolver): this {
-    if (this._items.length > 0) {
-      console.warn(
-        `[pilotiq/tiptap] MentionProvider('${this._trigger}'): itemsUsing() called after ` +
-        `items(). The async resolver now wins; the static items array will be ignored.`,
-      )
-      this._items = []
-    }
-    this._itemsUsing = fn
-    return this
-  }
-
-  getTrigger(): string { return this._trigger }
-  getItems():   readonly MentionItem[] { return this._items }
-  isAsync():    boolean { return this._itemsUsing !== undefined }
-
-  /**
-   * Run the resolver — `itemsUsing(fn)` when set, otherwise the cached
-   * static list. Wraps non-array returns in `[]` so a misbehaving
-   * resolver doesn't crash the route handler.
-   *
-   * Synchronous resolvers are awaited the same way as async ones; the
-   * single code path keeps the call-site cheap.
-   */
-  async runResolver(query: string, ctx: MentionResolverContext): Promise<MentionItem[]> {
-    if (this._itemsUsing === undefined) {
-      // Static path mirrors the client-side filter so the server endpoint
-      // would be useful for static providers too — but the client never
-      // calls it for them (no `async: true` flag → no fetch).
-      return [...this._items]
-    }
-    const result = await this._itemsUsing(query, ctx)
-    return Array.isArray(result) ? result : []
-  }
-
-  /** @internal */
-  toMeta(): MentionProviderMeta {
-    if (this._itemsUsing !== undefined) {
-      // Async providers ship empty `items`; the client checks `async: true`
-      // and fetches from the field's `mentionsUrl` per-keystroke instead.
-      return { trigger: this._trigger, items: [], async: true }
-    }
-    return { trigger: this._trigger, items: [...this._items] }
-  }
-}

package/src/PlainTextEditor.dom.test.ts

@@ -1,111 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import { Editor } from '@tiptap/core'
-
-import { createPlainTextEditor, plainTextOf } from './PlainTextEditor.js'
-
-/**
- * Phase 6e proof-of-concept — mount a real Tiptap `Editor` against the
- * jsdom DOM that `src/test/setup.ts` boots, exercise typing through the
- * ProseMirror transaction API, and assert via the public surface.
- *
- * The pure-config tests in `PlainTextEditor.test.ts` cover schema-shape
- * fixtures (`plainTextToDoc`); this file proves the config actually
- * behaves correctly when mounted into the editor's lifecycle —
- * `setContent` → `getJSON` → `plainTextOf` round-trip, multi-line
- * separator handling, document constraint enforcement. Component-level
- * coverage that previously lived only in the playground now has a
- * fast in-process test.
- */
-describe('createPlainTextEditor (DOM)', () => {
-  function mountInDom(multiline: boolean): { editor: Editor; el: HTMLDivElement } {
-    const el = document.createElement('div')
-    document.body.appendChild(el)
-    const editor = new Editor({
-      ...createPlainTextEditor({ multiline, content: '' }),
-      element: el,
-    })
-    return { editor, el }
-  }
-
-  it('single-line: setContent + plainTextOf round-trips one paragraph', () => {
-    const { editor } = mountInDom(false)
-    try {
-      editor.commands.setContent('hello world')
-      assert.equal(plainTextOf(editor), 'hello world')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('single-line: schema rejects multi-paragraph content (collapses to one)', () => {
-    const { editor } = mountInDom(false)
-    try {
-      // ProseMirror enforces the doc schema; PlainTextDocument's content
-      // expression is `paragraph` (a SINGLE paragraph) in single-line
-      // mode. Passing a multi-paragraph JSON tree should be coerced to
-      // one paragraph by Tiptap's repair pass rather than throwing.
-      editor.commands.setContent({
-        type: 'doc',
-        content: [
-          { type: 'paragraph', content: [{ type: 'text', text: 'line one' }] },
-          { type: 'paragraph', content: [{ type: 'text', text: 'line two' }] },
-        ],
-      })
-      // The exact repair behavior is "keep what fits, drop the rest" —
-      // we don't assert the specific outcome (`line one` only vs the
-      // two joined), only that the result is single-paragraph and
-      // non-empty. Future Tiptap version bumps that change the repair
-      // strategy won't break this test.
-      const json = editor.getJSON()
-      assert.equal(json.content?.length, 1, 'single paragraph after repair')
-      assert.ok(plainTextOf(editor).length > 0, 'non-empty after repair')
-      assert.ok(!plainTextOf(editor).includes('\n'), 'no newline in single-line mode')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('multi-line: setContent across paragraphs serializes with \\n separators', () => {
-    const { editor } = mountInDom(true)
-    try {
-      editor.commands.setContent({
-        type: 'doc',
-        content: [
-          { type: 'paragraph', content: [{ type: 'text', text: 'first' }] },
-          { type: 'paragraph', content: [{ type: 'text', text: 'second' }] },
-          { type: 'paragraph', content: [{ type: 'text', text: 'third' }] },
-        ],
-      })
-      assert.equal(plainTextOf(editor), 'first\nsecond\nthird')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('multi-line: empty document returns empty string', () => {
-    const { editor } = mountInDom(true)
-    try {
-      assert.equal(plainTextOf(editor), '')
-    } finally {
-      editor.destroy()
-    }
-  })
-
-  it('typing via commands.insertContent updates the visible DOM', () => {
-    const { editor, el } = mountInDom(false)
-    try {
-      editor.commands.focus()
-      editor.commands.insertContent('typed via command')
-      assert.equal(plainTextOf(editor), 'typed via command')
-      // The ProseMirror view renders `.ProseMirror` inside the mount
-      // element; verify the text is in the visible DOM too (this is
-      // the assertion that pure-data fixtures can't make).
-      const pm = el.querySelector('.ProseMirror')
-      assert.ok(pm, 'ProseMirror view mounted')
-      assert.ok(pm!.textContent?.includes('typed via command'), 'text rendered in DOM')
-    } finally {
-      editor.destroy()
-    }
-  })
-})

package/src/PlainTextEditor.test.ts

@@ -1,158 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  createPlainTextEditor,
-  plainTextToDoc,
-  type PlainTextEditorOptions,
-} from './PlainTextEditor.js'
-
-describe('plainTextToDoc — single-line', () => {
-  it('empty string yields one empty paragraph', () => {
-    assert.deepEqual(plainTextToDoc('', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph' }],
-    })
-  })
-
-  it('wraps a single run of text in one paragraph', () => {
-    assert.deepEqual(plainTextToDoc('hello', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'hello' }] }],
-    })
-  })
-
-  it('strips embedded newlines (LF and CRLF) — single-line schema permits one paragraph only', () => {
-    assert.deepEqual(plainTextToDoc('a\nb', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'ab' }] }],
-    })
-    assert.deepEqual(plainTextToDoc('a\r\nb', false), {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'ab' }] }],
-    })
-  })
-})
-
-describe('plainTextToDoc — multi-line', () => {
-  it('empty string yields one empty paragraph', () => {
-    assert.deepEqual(plainTextToDoc('', true), {
-      type: 'doc',
-      content: [{ type: 'paragraph' }],
-    })
-  })
-
-  it('splits LF-separated lines into separate paragraphs', () => {
-    assert.deepEqual(plainTextToDoc('a\nb', true), {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-
-  it('preserves empty lines as empty paragraphs', () => {
-    assert.deepEqual(plainTextToDoc('a\n\nb', true), {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph' },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-
-  it('normalises CRLF to single paragraph splits', () => {
-    assert.deepEqual(plainTextToDoc('a\r\nb', true), {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-})
-
-describe('createPlainTextEditor — config shape', () => {
-  function names(extensions: ReadonlyArray<{ name: string }>): string[] {
-    return extensions.map((e) => e.name)
-  }
-
-  it('default config: single-line, editable, schema + single-line keymap only', () => {
-    const cfg = createPlainTextEditor()
-    assert.equal(cfg.editable, true)
-    assert.equal(cfg.content, '')
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.deepEqual(names(exts), ['doc', 'paragraph', 'text', 'plainTextSingleLineKeymap'])
-    assert.equal(cfg.editorProps, undefined)
-    assert.equal(cfg.onUpdate, undefined)
-  })
-
-  it('multiline mode drops the single-line keymap', () => {
-    const cfg = createPlainTextEditor({ multiline: true })
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.deepEqual(names(exts), ['doc', 'paragraph', 'text'])
-  })
-
-  it('placeholder appends the Placeholder extension', () => {
-    const cfg = createPlainTextEditor({ placeholder: 'Type here…' })
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.ok(exts.some((e) => e.name === 'placeholder'),
-      `expected placeholder extension, got ${names(exts).join(',')}`)
-  })
-
-  it('caller-supplied extensions land after schema + behavior', () => {
-    const fakeExt = { name: 'fake-collab' } as unknown as Parameters<typeof createPlainTextEditor>[0] extends infer T
-      ? T extends { extensions?: Array<infer E> } ? E : never : never
-    const cfg = createPlainTextEditor({ extensions: [fakeExt] })
-    const exts = (cfg.extensions ?? []) as Array<{ name: string }>
-    assert.equal(exts[exts.length - 1]?.name, 'fake-collab')
-  })
-
-  it('editable can be turned off', () => {
-    const cfg = createPlainTextEditor({ editable: false })
-    assert.equal(cfg.editable, false)
-  })
-
-  it('seeds content as a doc JSON when text provided (single-line)', () => {
-    const cfg = createPlainTextEditor({ content: 'hello' })
-    assert.deepEqual(cfg.content, {
-      type: 'doc',
-      content: [{ type: 'paragraph', content: [{ type: 'text', text: 'hello' }] }],
-    })
-  })
-
-  it('seeds content as multi-paragraph doc JSON when multiline + text provided', () => {
-    const cfg = createPlainTextEditor({ multiline: true, content: 'a\nb' })
-    assert.deepEqual(cfg.content, {
-      type: 'doc',
-      content: [
-        { type: 'paragraph', content: [{ type: 'text', text: 'a' }] },
-        { type: 'paragraph', content: [{ type: 'text', text: 'b' }] },
-      ],
-    })
-  })
-
-  it('empty content stays an empty string sentinel — Collaboration-friendly', () => {
-    // When collab is on, callers pass content omitted/'' so Collaboration's
-    // y-prosemirror binding takes ownership of the doc without a seed race.
-    const cfg = createPlainTextEditor({ content: '' })
-    assert.equal(cfg.content, '')
-  })
-
-  it('editorAttributes plumb into editorProps.attributes verbatim', () => {
-    const attrs = { class: 'foo bar', 'aria-label': 'Name' }
-    const cfg = createPlainTextEditor({ editorAttributes: attrs })
-    assert.deepEqual(cfg.editorProps, { attributes: attrs })
-  })
-
-  it('onUpdate is wired only when caller provides it', () => {
-    const withCb: PlainTextEditorOptions = { onUpdate: () => {} }
-    const cfgA = createPlainTextEditor(withCb)
-    assert.equal(typeof cfgA.onUpdate, 'function')
-
-    const cfgB = createPlainTextEditor()
-    assert.equal(cfgB.onUpdate, undefined)
-  })
-})

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
-}