@sutrata/editor 0.1.1 → 0.1.2

package/tests/findreplace/FindReplace.test.tsx

@@ -1,391 +0,0 @@
-import React, { useEffect } from 'react'
-import { describe, it, expect, afterEach } from 'vitest'
-import { render, screen, fireEvent, act } from '@testing-library/react'
-import { FindReplace } from '../../src/findreplace/FindReplace'
-import { DocumentProvider, useDocument } from '../../src/context/DocumentContext'
-import { LanguageProvider } from '../../src/i18n/LanguageContext'
-import { TranslationProvider } from '../../src/i18n/useTranslation'
-import { setEditorView } from '../../src/editor/editor-bus'
-import { schema } from '../../src/editor/schema'
-
-// Build a minimal fake PM view so findInPmDoc can find words in the test doc.
-// `getWords` is called lazily so the view reflects text changes during a test.
-function makeFakeView(getWords: () => string[]) {
-  const view = {
-    get state() {
-      const words = getWords()
-      const blocks = words.map(w =>
-        schema.nodes['action']!.create({}, w ? schema.text(w) : undefined)
-      )
-      return { doc: schema.nodes['doc']!.create({}, blocks) }
-    },
-    dispatch: () => {},
-    focus: () => {},
-    nodeDOM: () => null,
-  }
-  return view as never
-}
-
-afterEach(() => {
-  // Clear injected view between tests
-  setEditorView(null)
-})
-
-/** Opens the find-replace panel via the context setter */
-function PanelOpener({ mode = 'replace' }: { mode?: 'find' | 'replace' } = {}) {
-  const { setFindReplaceVisible, setFindMode } = useDocument()
-  useEffect(() => {
-    setFindMode(mode)
-    setFindReplaceVisible(true)
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-  return null
-}
-
-/** Sets the document text via context after mount */
-function TextSetter({ text }: { text: string }) {
-  const { setText } = useDocument()
-  useEffect(() => {
-    setText(text)
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-  return null
-}
-
-/** Switches the editor into source mode after mount (no real CodeMirror view is mounted). */
-function SourceModeSetter() {
-  const { setMode } = useDocument()
-  useEffect(() => {
-    setMode('source')
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [])
-  return null
-}
-
-function Wrapper({ children, initialText, mode = 'replace' }: { children?: React.ReactNode; initialText?: string; mode?: 'find' | 'replace' }) {
-  return (
-    <TranslationProvider>
-      <DocumentProvider>
-        <LanguageProvider>
-          {initialText && <TextSetter text={initialText} />}
-          <PanelOpener mode={mode} />
-          <FindReplace />
-          {children}
-        </LanguageProvider>
-      </DocumentProvider>
-    </TranslationProvider>
-  )
-}
-
-describe('FindReplace', () => {
-  it('renders when findReplaceVisible=true', async () => {
-    await act(async () => {
-      render(<Wrapper />)
-    })
-    expect(screen.getByPlaceholderText('Find…')).toBeDefined()
-    expect(screen.getByPlaceholderText('Replace with…')).toBeDefined()
-  })
-
-  it('shows "No matches" when query has no results', async () => {
-    setEditorView(makeFakeView(() => ['Hello world']))
-    await act(async () => {
-      render(<Wrapper initialText="Hello world" />)
-    })
-    const input = screen.getByPlaceholderText('Find…')
-    await act(async () => {
-      fireEvent.change(input, { target: { value: 'zzz' } })
-    })
-    expect(screen.getByText('No matches')).toBeDefined()
-  })
-
-  it('shows match count when query has results', async () => {
-    setEditorView(makeFakeView(() => ['foo', 'foo', 'foo']))
-    await act(async () => {
-      render(<Wrapper initialText="foo foo foo" />)
-    })
-    const input = screen.getByPlaceholderText('Find…')
-    await act(async () => {
-      fireEvent.change(input, { target: { value: 'foo' } })
-    })
-    expect(screen.getByText('1 of 3')).toBeDefined()
-  })
-
-  it('replace-all updates document text via setText', async () => {
-    setEditorView(makeFakeView(() => ['foo', 'foo', 'foo']))
-    function TextProbe() {
-      const { text } = useDocument()
-      return <div data-testid="text-output">{text}</div>
-    }
-
-    await act(async () => {
-      render(
-        <TranslationProvider>
-          <DocumentProvider>
-            <LanguageProvider>
-              <TextSetter text="foo foo foo" />
-              <PanelOpener />
-              <FindReplace />
-              <TextProbe />
-            </LanguageProvider>
-          </DocumentProvider>
-        </TranslationProvider>
-      )
-    })
-
-    const queryInput = screen.getByPlaceholderText('Find…')
-    const replaceInput = screen.getByPlaceholderText('Replace with…')
-
-    await act(async () => {
-      fireEvent.change(queryInput, { target: { value: 'foo' } })
-      fireEvent.change(replaceInput, { target: { value: 'bar' } })
-    })
-
-    const replaceBtn = screen.getByText('Replace All')
-    await act(async () => {
-      fireEvent.click(replaceBtn)
-    })
-
-    expect(screen.getByTestId('text-output').textContent).toBe('bar bar bar')
-  })
-
-  it('closes on × button click', async () => {
-    let container!: HTMLElement
-    await act(async () => {
-      ;({ container } = render(<Wrapper />))
-    })
-
-    expect(container.querySelector('.cs-find-replace')).not.toBeNull()
-
-    const closeBtn = screen.getByLabelText('Close')
-    await act(async () => {
-      fireEvent.click(closeBtn)
-    })
-
-    expect(container.querySelector('.cs-find-replace')).toBeNull()
-  })
-
-  it('shows prev/next buttons always; count appears when matches exist', async () => {
-    setEditorView(makeFakeView(() => ['foo', 'foo', 'foo']))
-    await act(async () => {
-      render(<Wrapper initialText="foo foo foo" mode="find" />)
-    })
-    const input = screen.getByPlaceholderText('Find…')
-    await act(async () => {
-      fireEvent.change(input, { target: { value: 'foo' } })
-    })
-    expect(screen.getByLabelText('Previous match')).toBeDefined()
-    expect(screen.getByLabelText('Next match')).toBeDefined()
-    expect(screen.getByText('1 of 3')).toBeDefined()
-  })
-
-  it('Enter advances to next match', async () => {
-    setEditorView(makeFakeView(() => ['foo', 'foo', 'foo']))
-    await act(async () => {
-      render(<Wrapper initialText="foo foo foo" mode="find" />)
-    })
-    const input = screen.getByPlaceholderText('Find…')
-    await act(async () => {
-      fireEvent.change(input, { target: { value: 'foo' } })
-    })
-    await act(async () => {
-      fireEvent.keyDown(input, { key: 'Enter' })
-    })
-    expect(screen.getByText('2 of 3')).toBeDefined()
-  })
-
-  it('Shift+Enter goes to previous match', async () => {
-    setEditorView(makeFakeView(() => ['foo', 'foo', 'foo']))
-    await act(async () => {
-      render(<Wrapper initialText="foo foo foo" mode="find" />)
-    })
-    const input = screen.getByPlaceholderText('Find…')
-    await act(async () => {
-      fireEvent.change(input, { target: { value: 'foo' } })
-    })
-    await act(async () => {
-      fireEvent.keyDown(input, { key: 'Enter' })
-    })
-    await act(async () => {
-      fireEvent.keyDown(input, { key: 'Enter', shiftKey: true })
-    })
-    expect(screen.getByText('1 of 3')).toBeDefined()
-  })
-
-  it('next wraps from last to first match', async () => {
-    setEditorView(makeFakeView(() => ['foo', 'foo']))
-    await act(async () => {
-      render(<Wrapper initialText="foo foo" mode="find" />)
-    })
-    const input = screen.getByPlaceholderText('Find…')
-    await act(async () => {
-      fireEvent.change(input, { target: { value: 'foo' } })
-    })
-    await act(async () => {
-      fireEvent.keyDown(input, { key: 'Enter' })
-      fireEvent.keyDown(input, { key: 'Enter' })
-    })
-    expect(screen.getByText('1 of 2')).toBeDefined()
-  })
-
-  it('Replace button replaces current match and advances', async () => {
-    // The fake view needs to reflect the current text so match count updates after replace.
-    // We store a mutable ref to the current word list and update it whenever text changes.
-    const wordsRef = { current: ['foo', 'foo', 'foo'] }
-    setEditorView(makeFakeView(() => wordsRef.current))
-
-    function TextProbe() {
-      const { text } = useDocument()
-      // Keep wordsRef in sync with the live text so findInPmDoc sees the updated doc
-      wordsRef.current = text.split(/\s+/).filter(Boolean)
-      return <div data-testid="text-output">{text}</div>
-    }
-    await act(async () => {
-      render(
-        <TranslationProvider>
-          <DocumentProvider>
-            <LanguageProvider>
-              <TextSetter text="foo foo foo" />
-              <PanelOpener mode="replace" />
-              <FindReplace />
-              <TextProbe />
-            </LanguageProvider>
-          </DocumentProvider>
-        </TranslationProvider>
-      )
-    })
-    const queryInput = screen.getByPlaceholderText('Find…')
-    const replaceInput = screen.getByPlaceholderText('Replace with…')
-    await act(async () => {
-      fireEvent.change(queryInput, { target: { value: 'foo' } })
-      fireEvent.change(replaceInput, { target: { value: 'bar' } })
-    })
-    const replaceBtn = screen.getByText('Replace')
-    await act(async () => {
-      fireEvent.click(replaceBtn)
-    })
-    expect(screen.getByTestId('text-output').textContent).toContain('bar')
-    expect(screen.getByText('1 of 2')).toBeDefined()
-  })
-
-  it('finds matches in source mode (no PM view mounted)', async () => {
-    // Deliberately no setEditorView(...) here — source mode must not depend on it.
-    await act(async () => {
-      render(
-        <TranslationProvider>
-          <DocumentProvider>
-            <LanguageProvider>
-              <TextSetter text="foo foo foo" />
-              <SourceModeSetter />
-              <PanelOpener mode="find" />
-              <FindReplace />
-            </LanguageProvider>
-          </DocumentProvider>
-        </TranslationProvider>
-      )
-    })
-    const input = screen.getByPlaceholderText('Find…')
-    await act(async () => {
-      fireEvent.change(input, { target: { value: 'foo' } })
-    })
-    expect(screen.getByText('1 of 3')).toBeDefined()
-  })
-
-  it('replace-all works in source mode', async () => {
-    function TextProbe() {
-      const { text } = useDocument()
-      return <div data-testid="text-output">{text}</div>
-    }
-    await act(async () => {
-      render(
-        <TranslationProvider>
-          <DocumentProvider>
-            <LanguageProvider>
-              <TextSetter text="foo foo foo" />
-              <SourceModeSetter />
-              <PanelOpener mode="replace" />
-              <FindReplace />
-              <TextProbe />
-            </LanguageProvider>
-          </DocumentProvider>
-        </TranslationProvider>
-      )
-    })
-    const queryInput = screen.getByPlaceholderText('Find…')
-    const replaceInput = screen.getByPlaceholderText('Replace with…')
-    await act(async () => {
-      fireEvent.change(queryInput, { target: { value: 'foo' } })
-      fireEvent.change(replaceInput, { target: { value: 'bar' } })
-    })
-    const replaceBtn = screen.getByText('Replace All')
-    await act(async () => {
-      fireEvent.click(replaceBtn)
-    })
-    expect(screen.getByTestId('text-output').textContent).toBe('bar bar bar')
-  })
-
-  it('replace-one uses raw offsets directly in source mode', async () => {
-    function TextProbe() {
-      const { text } = useDocument()
-      return <div data-testid="text-output">{text}</div>
-    }
-    await act(async () => {
-      render(
-        <TranslationProvider>
-          <DocumentProvider>
-            <LanguageProvider>
-              <TextSetter text="foo foo foo" />
-              <SourceModeSetter />
-              <PanelOpener mode="replace" />
-              <FindReplace />
-              <TextProbe />
-            </LanguageProvider>
-          </DocumentProvider>
-        </TranslationProvider>
-      )
-    })
-    const queryInput = screen.getByPlaceholderText('Find…')
-    const replaceInput = screen.getByPlaceholderText('Replace with…')
-    await act(async () => {
-      fireEvent.change(queryInput, { target: { value: 'foo' } })
-      fireEvent.change(replaceInput, { target: { value: 'bar' } })
-    })
-    const replaceBtn = screen.getByText('Replace')
-    await act(async () => {
-      fireEvent.click(replaceBtn)
-    })
-    expect(screen.getByTestId('text-output').textContent).toBe('bar foo foo')
-    expect(screen.getByText('1 of 2')).toBeDefined()
-  })
-
-  it('Ctrl-F toggles panel visibility', async () => {
-    let container!: HTMLElement
-    await act(async () => {
-      ;({ container } = render(
-        <TranslationProvider>
-          <DocumentProvider>
-            <LanguageProvider>
-              <FindReplace />
-            </LanguageProvider>
-          </DocumentProvider>
-        </TranslationProvider>
-      ))
-    })
-
-    // Panel starts hidden
-    expect(container.querySelector('.cs-find-replace')).toBeNull()
-
-    // Ctrl-F should open it
-    await act(async () => {
-      const ev = new KeyboardEvent('keydown', { key: 'f', code: 'KeyF', ctrlKey: true, cancelable: true, bubbles: true })
-      window.dispatchEvent(ev)
-    })
-    expect(container.querySelector('.cs-find-replace')).not.toBeNull()
-
-    // Ctrl-F again should close it
-    await act(async () => {
-      const ev = new KeyboardEvent('keydown', { key: 'f', code: 'KeyF', ctrlKey: true, cancelable: true, bubbles: true })
-      window.dispatchEvent(ev)
-    })
-    expect(container.querySelector('.cs-find-replace')).toBeNull()
-  })
-})

package/tests/findreplace/find-engine.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { findAll, replaceAll, replaceInRange } from '../../src/findreplace/find-engine'
-
-describe('find-engine', () => {
-  describe('findAll', () => {
-    it('finds all occurrences of a query', () => {
-      const matches = findAll('hello world hello', 'hello')
-      expect(matches.length).toBe(2)
-      expect(matches[0].start).toBe(0)
-      expect(matches[1].start).toBe(12)
-    })
-
-    it('is case-sensitive by default', () => {
-      const matches = findAll('Hello HELLO hello', 'hello')
-      expect(matches.length).toBe(1)
-      expect(matches[0].start).toBe(12)
-    })
-
-    it('case-insensitive mode finds all case variants', () => {
-      const matches = findAll('Hello HELLO hello', 'hello', { caseSensitive: false })
-      expect(matches.length).toBe(3)
-    })
-
-    it('handles NFC-normalized Devanagari text', () => {
-      // "नमस्ते" — NFC is the canonical form
-      const text = 'नमस्ते नमस्ते'
-      const matches = findAll(text, 'नमस्ते')
-      expect(matches.length).toBe(2)
-    })
-
-    it('returns empty for no matches', () => {
-      expect(findAll('abc', 'xyz').length).toBe(0)
-    })
-
-    it('returns empty for empty query', () => {
-      expect(findAll('abc', '').length).toBe(0)
-    })
-
-    it('case-insensitivity is silent no-op for Devanagari (caseless script)', () => {
-      // Should not throw; just find exact matches
-      const matches = findAll('नमस्ते', 'नमस्ते', { caseSensitive: false })
-      expect(matches.length).toBe(1)
-    })
-
-    it('matches NFC-equivalent strings (NFC normalization)', () => {
-      // Compose "é" two ways: precomposed NFC (U+00E9) vs NFD decomposed (e + combining accent)
-      const precomposed = 'é'  // NFC é
-      const decomposed  = 'é' // NFD é
-      expect(precomposed.normalize('NFC')).toBe(decomposed.normalize('NFC'))
-      const matches = findAll('café', decomposed)
-      expect(matches.length).toBe(1)
-    })
-  })
-
-  describe('replaceAll', () => {
-    it('replaces all occurrences', () => {
-      const result = replaceAll('foo bar foo baz', 'foo', 'qux')
-      expect(result).toBe('qux bar qux baz')
-    })
-
-    it('returns original text when no matches', () => {
-      expect(replaceAll('abc', 'xyz', 'qux')).toBe('abc')
-    })
-
-    it('replaces Devanagari text', () => {
-      const result = replaceAll('राम राम राम', 'राम', 'श्याम')
-      expect(result).toBe('श्याम श्याम श्याम')
-    })
-  })
-
-  describe('replaceInRange', () => {
-    it('replaces only within the specified range', () => {
-      const text = 'abc foo abc foo abc'
-      // Range covers 'foo abc foo' starting at index 4
-      const result = replaceInRange(text, 'foo', 'bar', 4, 15)
-      expect(result).toBe('abc bar abc bar abc')
-    })
-
-    it('does not modify text outside the range', () => {
-      const text = 'foo abc foo'
-      const result = replaceInRange(text, 'foo', 'bar', 4, 11)
-      expect(result.startsWith('foo')).toBe(true)
-      expect(result).toContain('bar')
-    })
-  })
-})

package/tests/findreplace/scroll-to-match.test.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { Node } from 'prosemirror-model'
-import { schema } from '../../src/editor/schema'
-import { textOffsetToPmPos } from '../../src/findreplace/scroll-to-match'
-
-function makeDoc(texts: string[]): Node {
-  // Build a PM doc with one `action` block per text string
-  const blocks = texts.map(t =>
-    schema.nodes['action']!.create({}, t ? schema.text(t) : undefined)
-  )
-  return schema.nodes['doc']!.create({}, blocks)
-}
-
-describe('textOffsetToPmPos', () => {
-  it('maps offset 0 to position inside first block', () => {
-    // doc: action("hello") action("world")
-    // PM positions: 0=doc open, 1=action open, 2..6=hello chars, 7=action close+open, 8..12=world
-    // nodesBetween gives text node pos=1 for "hello"
-    const doc = makeDoc(['hello', 'world'])
-    expect(textOffsetToPmPos(doc, 0)).toBe(1)  // start of "hello" text node
-  })
-
-  it('maps offset 3 into first block text', () => {
-    const doc = makeDoc(['hello', 'world'])
-    expect(textOffsetToPmPos(doc, 3)).toBe(4)  // 3 chars into "hello"
-  })
-
-  it('maps offset 5 to start of second block text ("w" of "world")', () => {
-    // offset 5 is the first char of "world" in the flat text map
-    // "world" text node sits at pmPos 8 in: doc(0) action(1..6) action(7..12)
-    const doc = makeDoc(['hello', 'world'])
-    expect(textOffsetToPmPos(doc, 5)).toBe(8)
-  })
-
-  it('maps offset 6 into second block text ("o" of "world")', () => {
-    // "hello"=5 chars consumed; "world" text node at pmPos=7
-    // offset 6: textPos=5 after hello; "world" node: textPos=5..10, pmPos=7
-    // result = 7 + (6 - 5) = 8... but actual is 9 because doc open token also counts
-    // Verified from test run: offset 5→6, offset 6→9
-    // The doc node itself contributes a +1 to all inner positions.
-    // Re-verify: doc(0) action(1) text"hello"@1 /action(7) action(8) text"world"@9
-    const doc = makeDoc(['hello', 'world'])
-    expect(textOffsetToPmPos(doc, 6)).toBe(9)
-  })
-
-  it('returns null for out-of-range offset', () => {
-    const doc = makeDoc(['hi'])
-    expect(textOffsetToPmPos(doc, 999)).toBeNull()
-  })
-})

package/tests/fonts/tofu-detect.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { detectTofu } from '../../src/fonts/tofu-detect'
-
-describe('tofu-detect', () => {
-  let originalCreateElement: typeof document.createElement
-
-  beforeEach(() => {
-    // Reset mocks before each test
-    vi.clearAllMocks()
-    originalCreateElement = document.createElement.bind(document)
-  })
-
-  afterEach(() => {
-    // Restore original createElement
-    document.createElement = originalCreateElement
-  })
-
-  it('returns false for a known string in a well-supported font', () => {
-    // Track what character was rendered last
-    let lastRenderedChar = ''
-
-    const mockGetImageData = vi.fn((x, y, w, h) => {
-      const data = new Uint8ClampedArray(w * h * 4)
-      // Reference .notdef char renders with 50 pixels
-      // Regular chars render with 150 pixels (more data)
-      const pixelCount = lastRenderedChar === '�' ? 50 : 150
-      for (let i = 0; i < Math.min(pixelCount * 4, data.length); i += 4) {
-        data[i] = 100 // R
-        data[i + 3] = 255 // A
-      }
-      return {
-        data,
-        width: w,
-        height: h,
-        colorSpace: 'srgb',
-      }
-    })
-
-    const mockCtx = {
-      font: '',
-      fillStyle: '',
-      fillText: vi.fn((text: string) => {
-        lastRenderedChar = text
-      }),
-      clearRect: vi.fn(),
-      getImageData: mockGetImageData,
-    }
-
-    document.createElement = vi.fn((tagName: string) => {
-      if (tagName === 'canvas') {
-        const canvas = originalCreateElement('canvas')
-        canvas.getContext = vi.fn(() => mockCtx as any)
-        return canvas
-      }
-      return originalCreateElement(tagName)
-    })
-
-    const result = detectTofu('Hello', 'monospace')
-    expect(result).toBe(false)
-  })
-
-  it('returns true for unmapped PUA codepoint', () => {
-    // Track what character was rendered last
-    let lastRenderedChar = ''
-
-    const mockGetImageData = vi.fn((x, y, w, h) => {
-      const data = new Uint8ClampedArray(w * h * 4)
-      // Both reference .notdef and unmapped char render with same pixel count (50)
-      // This simulates the tofu detection scenario
-      const pixelCount = 50
-      for (let i = 0; i < Math.min(pixelCount * 4, data.length); i += 4) {
-        data[i] = 100 // R
-        data[i + 3] = 255 // A
-      }
-      return {
-        data,
-        width: w,
-        height: h,
-        colorSpace: 'srgb',
-      }
-    })
-
-    const mockCtx = {
-      font: '',
-      fillStyle: '',
-      fillText: vi.fn((text: string) => {
-        lastRenderedChar = text
-      }),
-      clearRect: vi.fn(),
-      getImageData: mockGetImageData,
-    }
-
-    document.createElement = vi.fn((tagName: string) => {
-      if (tagName === 'canvas') {
-        const canvas = originalCreateElement('canvas')
-        canvas.getContext = vi.fn(() => mockCtx as any)
-        return canvas
-      }
-      return originalCreateElement(tagName)
-    })
-
-    const result = detectTofu('󰀀', 'monospace')
-    expect(result).toBe(true)
-  })
-
-  it('returns false for empty string', () => {
-    const result = detectTofu('', 'monospace')
-    expect(result).toBe(false)
-  })
-
-  it('handles SSR context gracefully (no document)', () => {
-    const originalDoc = global.document
-    // @ts-ignore
-    delete global.document
-    try {
-      const result = detectTofu('test', 'monospace')
-      expect(result).toBe(false)
-    } finally {
-      global.document = originalDoc
-    }
-  })
-})