@tiptap/extension-find-and-replace 3.29.0

package/src/utils/getMappedCurrentIndex.ts

@@ -0,0 +1,32 @@
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { FindAndReplacePluginState } from '../plugin/plugin-state.js'
+import type { SearchResult } from '../search/search.js'
+import { findNextIndex } from '../search/search.js'
+
+import { getPreviousCurrentResult } from './getPreviousCurrentResult.js'
+
+export function getMappedCurrentIndex(
+  previousState: FindAndReplacePluginState,
+  results: SearchResult[],
+  docChanged: boolean,
+  mapping: Mapping | undefined,
+): number | null | undefined {
+  if (!docChanged) {
+    return undefined
+  }
+
+  if (!mapping) {
+    return undefined
+  }
+
+  const previousResult = getPreviousCurrentResult(previousState)
+
+  if (!previousResult) {
+    return undefined
+  }
+
+  const mappedFrom = mapping.map(previousResult.from, 1)
+
+  return findNextIndex(results, mappedFrom)
+}

package/src/utils/getMetaCurrentIndex.ts

@@ -0,0 +1,19 @@
+import type { FindAndReplaceMeta } from '../plugin/plugin-state.js'
+
+import { hasCurrentIndex } from './hasCurrentIndex.js'
+import { normalizeCurrentIndex } from './normalizeCurrentIndex.js'
+
+export function getMetaCurrentIndex(
+  meta: FindAndReplaceMeta | undefined,
+  length: number,
+): number | null | undefined {
+  if (!meta) {
+    return undefined
+  }
+
+  if (!hasCurrentIndex(meta)) {
+    return undefined
+  }
+
+  return normalizeCurrentIndex(meta.currentIndex, length)
+}

package/src/utils/getPreviousCurrentResult.ts

@@ -0,0 +1,10 @@
+import type { FindAndReplacePluginState } from '../plugin/plugin-state.js'
+import type { SearchResult } from '../search/search.js'
+
+export function getPreviousCurrentResult(
+  previousState: FindAndReplacePluginState,
+): SearchResult | undefined {
+  return previousState.currentIndex === null
+    ? undefined
+    : previousState.results[previousState.currentIndex]
+}

package/src/utils/getResultsToRefresh.ts

@@ -0,0 +1,22 @@
+import type { SearchResult } from '../search/search.js'
+
+import { shouldRefreshResult } from './shouldRefreshResult.js'
+import type { IndexedResult, TextblockRange } from './types.js'
+
+export function getResultsToRefresh(
+  results: SearchResult[],
+  textblocks: readonly TextblockRange[],
+  previousCurrent: SearchResult | null,
+  currentIndex: number | null,
+): IndexedResult[] {
+  const current = currentIndex === null ? null : (results[currentIndex] ?? null)
+  const refreshedResults: IndexedResult[] = []
+
+  results.forEach((result, index) => {
+    if (shouldRefreshResult(result, textblocks, previousCurrent, current)) {
+      refreshedResults.push({ result, index })
+    }
+  })
+
+  return refreshedResults
+}

package/src/utils/getSearchCurrentIndex.ts

@@ -0,0 +1,24 @@
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { FindAndReplaceMeta, FindAndReplacePluginState } from '../plugin/plugin-state.js'
+import type { SearchResult } from '../search/search.js'
+
+import { getFallbackCurrentIndex } from './getFallbackCurrentIndex.js'
+import { getMappedCurrentIndex } from './getMappedCurrentIndex.js'
+import { isNewSearch } from './isNewSearch.js'
+
+export function getSearchCurrentIndex(
+  previousState: FindAndReplacePluginState,
+  results: SearchResult[],
+  meta: FindAndReplaceMeta | undefined,
+  docChanged: boolean,
+  mapping: Mapping | undefined,
+): number {
+  if (isNewSearch(meta)) {
+    return 0
+  }
+
+  const mappedIndex = getMappedCurrentIndex(previousState, results, docChanged, mapping)
+
+  return mappedIndex ?? getFallbackCurrentIndex(previousState, results.length)
+}

package/src/utils/getTextNodeResult.ts

@@ -0,0 +1,21 @@
+import type { EditorState } from '@tiptap/pm/state'
+
+import type { SearchResult } from '../search/search.js'
+
+export interface TextNodeResult {
+  from: number
+  text: string
+}
+
+export function getTextNodeResult(state: EditorState, result: SearchResult): TextNodeResult | null {
+  const $from = state.doc.resolve(result.from)
+  const node = $from.parent.child($from.index())
+
+  if (!node.isText || !node.text) {
+    return null
+  }
+
+  const from = result.from - $from.textOffset
+
+  return result.to <= from + node.nodeSize ? { from, text: node.text } : null
+}

package/src/utils/groupResults.ts

@@ -0,0 +1,68 @@
+import type { EditorState } from '@tiptap/pm/state'
+
+import type { SearchResult } from '../search/search.js'
+import type { TextNodeResult } from './getTextNodeResult.js'
+import { getTextNodeResult } from './getTextNodeResult.js'
+
+export interface ResultGroup {
+  from: number
+  text: string | null
+  results: SearchResult[]
+}
+
+function shouldMergeResult(
+  group: ResultGroup | undefined,
+  textNode: TextNodeResult | null,
+): boolean {
+  if (!group || !textNode) {
+    return false
+  }
+
+  return group.from === textNode.from && group.text !== null
+}
+
+function createTextResultGroup(result: SearchResult, textNode: TextNodeResult): ResultGroup {
+  return {
+    from: textNode.from,
+    text: textNode.text,
+    results: [result],
+  }
+}
+
+function createResultGroup(result: SearchResult): ResultGroup {
+  return {
+    from: result.from,
+    text: null,
+    results: [result],
+  }
+}
+
+function appendResult(
+  groups: ResultGroup[],
+  result: SearchResult,
+  textNode: TextNodeResult | null,
+): void {
+  const group = groups.at(-1)
+
+  if (shouldMergeResult(group, textNode)) {
+    group!.results.push(result)
+    return
+  }
+
+  if (textNode) {
+    groups.push(createTextResultGroup(result, textNode))
+    return
+  }
+
+  groups.push(createResultGroup(result))
+}
+
+export function groupResults(state: EditorState, results: SearchResult[]): ResultGroup[] {
+  const groups: ResultGroup[] = []
+
+  for (const result of results) {
+    appendResult(groups, result, getTextNodeResult(state, result))
+  }
+
+  return groups
+}

package/src/utils/hasCurrentIndex.ts

@@ -0,0 +1,5 @@
+import type { FindAndReplaceMeta } from '../plugin/plugin-state.js'
+
+export function hasCurrentIndex(meta: FindAndReplaceMeta | undefined): boolean {
+  return !!meta && 'currentIndex' in meta
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export { createState } from './createState.js'
+export { updateState } from './updateState.js'

package/src/utils/isCurrentResult.ts

@@ -0,0 +1,7 @@
+import type { SearchResult } from '../search/search.js'
+
+import { sameResult } from './sameResult.js'
+
+export function isCurrentResult(result: SearchResult, current: SearchResult | null): boolean {
+  return current !== null && sameResult(result, current)
+}

package/src/utils/isNewSearch.ts

@@ -0,0 +1,5 @@
+import type { FindAndReplaceMeta } from '../plugin/plugin-state.js'
+
+export function isNewSearch(meta: FindAndReplaceMeta | undefined): boolean {
+  return !!meta && 'searchTerm' in meta
+}

package/src/utils/mapResult.ts

@@ -0,0 +1,10 @@
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { SearchResult } from '../search/search.js'
+
+export function mapResult(result: SearchResult, mapping: Mapping): SearchResult | null {
+  const from = mapping.map(result.from, 1)
+  const to = mapping.map(result.to, -1)
+
+  return from < to ? { from, to } : null
+}

package/src/utils/mapResults.ts

@@ -0,0 +1,19 @@
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { SearchResult } from '../search/search.js'
+
+import { mapResult } from './mapResult.js'
+
+export function mapResults(results: SearchResult[], mapping: Mapping): SearchResult[] {
+  const mappedResults: SearchResult[] = []
+
+  results.forEach(result => {
+    const mapped = mapResult(result, mapping)
+
+    if (mapped) {
+      mappedResults.push(mapped)
+    }
+  })
+
+  return mappedResults
+}

package/src/utils/mergeResults.ts

@@ -0,0 +1,18 @@
+import type { SearchResult } from '../search/search.js'
+
+export function mergeResults(first: SearchResult[], second: SearchResult[]): SearchResult[] {
+  const results: SearchResult[] = []
+  let firstIndex = 0
+  let secondIndex = 0
+
+  while (firstIndex < first.length && secondIndex < second.length) {
+    if (first[firstIndex].from < second[secondIndex].from) {
+      results.push(first[firstIndex++])
+      continue
+    }
+
+    results.push(second[secondIndex++])
+  }
+
+  return results.concat(first.slice(firstIndex), second.slice(secondIndex))
+}

package/src/utils/normalizeCurrentIndex.ts

@@ -0,0 +1,10 @@
+export function normalizeCurrentIndex(
+  currentIndex: number | null | undefined,
+  length: number,
+): number | null {
+  if (currentIndex === undefined || currentIndex === null || length === 0) {
+    return null
+  }
+
+  return Math.max(0, Math.min(currentIndex, length - 1))
+}

package/src/utils/refreshCurrentIndexState.ts

@@ -0,0 +1,30 @@
+import type { Node } from '@tiptap/pm/model'
+
+import type { FindAndReplaceMeta, FindAndReplacePluginState } from '../plugin/plugin-state.js'
+
+import { refreshDecorations } from './refreshDecorations.js'
+import { resolveCurrentIndex } from './resolveCurrentIndex.js'
+
+export function refreshCurrentIndexState(
+  previousState: FindAndReplacePluginState,
+  state: FindAndReplacePluginState,
+  doc: Node,
+  meta: FindAndReplaceMeta | undefined,
+): FindAndReplacePluginState {
+  const currentIndex = resolveCurrentIndex(previousState, state.results, meta, false, undefined)
+  const previousCurrent =
+    previousState.currentIndex === null ? null : previousState.results[previousState.currentIndex]
+
+  return {
+    ...state,
+    currentIndex,
+    decorations: refreshDecorations(
+      previousState.decorations,
+      doc,
+      state.results,
+      currentIndex,
+      [],
+      previousCurrent,
+    ),
+  }
+}

package/src/utils/refreshDecorations.ts

@@ -0,0 +1,28 @@
+import type { Node } from '@tiptap/pm/model'
+import { DecorationSet } from '@tiptap/pm/view'
+
+import type { SearchResult } from '../search/search.js'
+
+import { createDecoration } from './createDecoration.js'
+import { findDecorations } from './findDecorations.js'
+import { getResultsToRefresh } from './getResultsToRefresh.js'
+import type { TextblockRange } from './types.js'
+
+export function refreshDecorations(
+  decorations: DecorationSet,
+  doc: Node,
+  results: SearchResult[],
+  currentIndex: number | null,
+  textblocks: readonly TextblockRange[],
+  previousCurrent: SearchResult | null,
+): DecorationSet {
+  const resultsToRefresh = getResultsToRefresh(results, textblocks, previousCurrent, currentIndex)
+  const refreshedResults = resultsToRefresh.map(({ result }) => result)
+  const staleResults = previousCurrent ? [...refreshedResults, previousCurrent] : refreshedResults
+  const decorationsToRemove = findDecorations(decorations, staleResults, textblocks)
+  const decorationsToAdd = resultsToRefresh.map(({ result, index }) => {
+    return createDecoration(result, currentIndex, index)
+  })
+
+  return decorations.remove(decorationsToRemove).add(doc, decorationsToAdd)
+}

package/src/utils/refreshDocumentState.ts

@@ -0,0 +1,47 @@
+import type { Node } from '@tiptap/pm/model'
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { FindAndReplaceMeta, FindAndReplacePluginState } from '../plugin/plugin-state.js'
+import { searchTextblocks } from '../search/search.js'
+
+import { getChangedTextblocks } from './getChangedTextblocks.js'
+import { mapResult } from './mapResult.js'
+import { mapResults } from './mapResults.js'
+import { mergeResults } from './mergeResults.js'
+import { refreshDecorations } from './refreshDecorations.js'
+import { resolveCurrentIndex } from './resolveCurrentIndex.js'
+import { resultInTextblocks } from './resultInTextblocks.js'
+
+export function refreshDocumentState(
+  previousState: FindAndReplacePluginState,
+  state: FindAndReplacePluginState,
+  doc: Node,
+  meta: FindAndReplaceMeta | undefined,
+  mapping: Mapping,
+): FindAndReplacePluginState {
+  const textblocks = getChangedTextblocks(doc, mapping)
+  const mappedResults = mapResults(previousState.results, mapping)
+  const unaffectedResults = mappedResults.filter(result => !resultInTextblocks(result, textblocks))
+  const changedResults = searchTextblocks(textblocks, state.searchTerm, state)
+  const results = mergeResults(unaffectedResults, changedResults)
+  const currentIndex = resolveCurrentIndex(previousState, results, meta, true, mapping)
+  const previousCurrent =
+    previousState.currentIndex === null
+      ? null
+      : mapResult(previousState.results[previousState.currentIndex], mapping)
+  const decorations = previousState.decorations.map(mapping, doc)
+
+  return {
+    ...state,
+    results,
+    currentIndex,
+    decorations: refreshDecorations(
+      decorations,
+      doc,
+      results,
+      currentIndex,
+      textblocks,
+      previousCurrent,
+    ),
+  }
+}

package/src/utils/refreshState.ts

@@ -0,0 +1,27 @@
+import type { Node } from '@tiptap/pm/model'
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { FindAndReplaceMeta, FindAndReplacePluginState } from '../plugin/plugin-state.js'
+import { searchDocument } from '../search/search.js'
+
+import { createDecorations } from './createDecorations.js'
+import { resolveCurrentIndex } from './resolveCurrentIndex.js'
+
+export function refreshState(
+  previousState: FindAndReplacePluginState,
+  state: FindAndReplacePluginState,
+  doc: Node,
+  meta: FindAndReplaceMeta | undefined,
+  docChanged: boolean,
+  mapping: Mapping | undefined,
+): FindAndReplacePluginState {
+  const results = searchDocument(doc, state.searchTerm, state)
+  const currentIndex = resolveCurrentIndex(previousState, results, meta, docChanged, mapping)
+
+  return {
+    ...state,
+    results,
+    currentIndex,
+    decorations: createDecorations(doc, results, currentIndex),
+  }
+}

package/src/utils/replaceAllResults.ts

@@ -0,0 +1,18 @@
+import type { EditorState, Transaction } from '@tiptap/pm/state'
+
+import type { SearchResult } from '../search/search.js'
+import { groupResults } from './groupResults.js'
+import { replaceGroup } from './replaceGroup.js'
+
+export function replaceAllResults(
+  tr: Transaction,
+  state: EditorState,
+  results: SearchResult[],
+  replaceTerm: string,
+): void {
+  const groups = groupResults(state, results)
+
+  for (const group of groups.reverse()) {
+    replaceGroup(tr, group, replaceTerm)
+  }
+}

package/src/utils/replaceGroup.ts

@@ -0,0 +1,54 @@
+import type { Transaction } from '@tiptap/pm/state'
+
+import type { SearchResult } from '../search/search.js'
+import type { ResultGroup } from './groupResults.js'
+
+function replaceSeparateResults(
+  tr: Transaction,
+  results: SearchResult[],
+  replaceTerm: string,
+): void {
+  for (const result of [...results].reverse()) {
+    tr.insertText(replaceTerm, result.from, result.to)
+  }
+}
+
+function createReplacement(
+  group: ResultGroup,
+  text: string,
+  firstResult: SearchResult,
+  replaceTerm: string,
+): string {
+  let offset = firstResult.from - group.from
+  const replacement: string[] = []
+
+  for (const result of group.results) {
+    const from = result.from - group.from
+    const to = result.to - group.from
+
+    replacement.push(text.slice(offset, from), replaceTerm)
+    offset = to
+  }
+
+  return replacement.join('')
+}
+
+export function replaceGroup(tr: Transaction, group: ResultGroup, replaceTerm: string): void {
+  const firstResult = group.results[0]
+  const lastResult = group.results.at(-1)
+
+  if (!lastResult) {
+    return
+  }
+
+  if (group.text === null) {
+    replaceSeparateResults(tr, group.results, replaceTerm)
+    return
+  }
+
+  tr.insertText(
+    createReplacement(group, group.text, firstResult, replaceTerm),
+    firstResult.from,
+    lastResult.to,
+  )
+}

package/src/utils/resolveCurrentIndex.ts

@@ -0,0 +1,27 @@
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { FindAndReplaceMeta, FindAndReplacePluginState } from '../plugin/plugin-state.js'
+import type { SearchResult } from '../search/search.js'
+
+import { getMetaCurrentIndex } from './getMetaCurrentIndex.js'
+import { getSearchCurrentIndex } from './getSearchCurrentIndex.js'
+
+export function resolveCurrentIndex(
+  previousState: FindAndReplacePluginState,
+  results: SearchResult[],
+  meta: FindAndReplaceMeta | undefined,
+  docChanged: boolean,
+  mapping: Mapping | undefined,
+): number | null {
+  if (results.length === 0) {
+    return null
+  }
+
+  const metaIndex = getMetaCurrentIndex(meta, results.length)
+
+  if (metaIndex !== undefined) {
+    return metaIndex
+  }
+
+  return getSearchCurrentIndex(previousState, results, meta, docChanged, mapping)
+}

package/src/utils/resultInTextblocks.ts

@@ -0,0 +1,30 @@
+import type { SearchResult } from '../search/search.js'
+
+import type { TextblockRange } from './types.js'
+
+export function resultInTextblocks(
+  result: SearchResult,
+  textblocks: readonly TextblockRange[],
+): boolean {
+  let start = 0
+  let end = textblocks.length - 1
+
+  while (start <= end) {
+    const index = Math.floor((start + end) / 2)
+    const textblock = textblocks[index]
+
+    if (result.from < textblock.from) {
+      end = index - 1
+      continue
+    }
+
+    if (result.to > textblock.to) {
+      start = index + 1
+      continue
+    }
+
+    return true
+  }
+
+  return false
+}

package/src/utils/sameResult.ts

@@ -0,0 +1,5 @@
+import type { SearchResult } from '../search/search.js'
+
+export function sameResult(first: SearchResult, second: SearchResult): boolean {
+  return first.from === second.from && first.to === second.to
+}

package/src/utils/shouldRefreshResult.ts

@@ -0,0 +1,18 @@
+import type { SearchResult } from '../search/search.js'
+
+import { isCurrentResult } from './isCurrentResult.js'
+import { resultInTextblocks } from './resultInTextblocks.js'
+import type { TextblockRange } from './types.js'
+
+export function shouldRefreshResult(
+  result: SearchResult,
+  textblocks: readonly TextblockRange[],
+  previousCurrent: SearchResult | null,
+  current: SearchResult | null,
+): boolean {
+  return (
+    resultInTextblocks(result, textblocks) ||
+    isCurrentResult(result, previousCurrent) ||
+    isCurrentResult(result, current)
+  )
+}

package/src/utils/touchesSearch.ts

@@ -0,0 +1,7 @@
+import type { FindAndReplaceMeta } from '../plugin/plugin-state.js'
+
+const searchKeys = ['searchTerm', 'caseSensitive', 'useRegex', 'wholeWord'] as const
+
+export function touchesSearch(meta: FindAndReplaceMeta | undefined): boolean {
+  return !!meta && searchKeys.some(key => key in meta)
+}

package/src/utils/types.ts

@@ -0,0 +1,11 @@
+import type { TextblockSearchTarget } from '../search/search.js'
+
+export interface TextblockRange extends TextblockSearchTarget {
+  from: number
+  to: number
+}
+
+export interface IndexedResult {
+  result: import('../search/search.js').SearchResult
+  index: number
+}

package/src/utils/updateState.ts

@@ -0,0 +1,33 @@
+import type { Node } from '@tiptap/pm/model'
+import type { Mapping } from '@tiptap/pm/transform'
+
+import type { FindAndReplaceMeta, FindAndReplacePluginState } from '../plugin/plugin-state.js'
+
+import { hasCurrentIndex } from './hasCurrentIndex.js'
+import { refreshCurrentIndexState } from './refreshCurrentIndexState.js'
+import { refreshDocumentState } from './refreshDocumentState.js'
+import { refreshState } from './refreshState.js'
+import { touchesSearch } from './touchesSearch.js'
+
+export function updateState(
+  previousState: FindAndReplacePluginState,
+  state: FindAndReplacePluginState,
+  doc: Node,
+  meta: FindAndReplaceMeta | undefined,
+  docChanged: boolean,
+  mapping: Mapping,
+): FindAndReplacePluginState {
+  if (touchesSearch(meta)) {
+    return refreshState(previousState, state, doc, meta, docChanged, mapping)
+  }
+
+  if (docChanged) {
+    return refreshDocumentState(previousState, state, doc, meta, mapping)
+  }
+
+  if (hasCurrentIndex(meta)) {
+    return refreshCurrentIndexState(previousState, state, doc, meta)
+  }
+
+  return state
+}