@pilotiq/tiptap 3.10.5 → 3.10.7

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