yzcode-cli 1.0.2 → 1.0.4

package/vim/operators.ts

@@ -0,0 +1,556 @@
+/**
+ * Vim Operator Functions
+ *
+ * Pure functions for executing vim operators (delete, change, yank, etc.)
+ */
+
+import { Cursor } from '../utils/Cursor.ts'
+import { firstGrapheme, lastGrapheme } from '../utils/intl.ts'
+import { countCharInString } from '../utils/stringUtils.ts'
+import {
+  isInclusiveMotion,
+  isLinewiseMotion,
+  resolveMotion,
+} from './motions.ts'
+import { findTextObject } from './textObjects.ts'
+import type {
+  FindType,
+  Operator,
+  RecordedChange,
+  TextObjScope,
+} from './types.ts'
+
+/**
+ * Context for operator execution.
+ */
+export type OperatorContext = {
+  cursor: Cursor
+  text: string
+  setText: (text: string) => void
+  setOffset: (offset: number) => void
+  enterInsert: (offset: number) => void
+  getRegister: () => string
+  setRegister: (content: string, linewise: boolean) => void
+  getLastFind: () => { type: FindType; char: string } | null
+  setLastFind: (type: FindType, char: string) => void
+  recordChange: (change: RecordedChange) => void
+}
+
+/**
+ * Execute an operator with a simple motion.
+ */
+export function executeOperatorMotion(
+  op: Operator,
+  motion: string,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  const target = resolveMotion(motion, ctx.cursor, count)
+  if (target.equals(ctx.cursor)) return
+
+  const range = getOperatorRange(ctx.cursor, target, motion, op, count)
+  applyOperator(op, range.from, range.to, ctx, range.linewise)
+  ctx.recordChange({ type: 'operator', op, motion, count })
+}
+
+/**
+ * Execute an operator with a find motion.
+ */
+export function executeOperatorFind(
+  op: Operator,
+  findType: FindType,
+  char: string,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  const targetOffset = ctx.cursor.findCharacter(char, findType, count)
+  if (targetOffset === null) return
+
+  const target = new Cursor(ctx.cursor.measuredText, targetOffset)
+  const range = getOperatorRangeForFind(ctx.cursor, target, findType)
+
+  applyOperator(op, range.from, range.to, ctx)
+  ctx.setLastFind(findType, char)
+  ctx.recordChange({ type: 'operatorFind', op, find: findType, char, count })
+}
+
+/**
+ * Execute an operator with a text object.
+ */
+export function executeOperatorTextObj(
+  op: Operator,
+  scope: TextObjScope,
+  objType: string,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  const range = findTextObject(
+    ctx.text,
+    ctx.cursor.offset,
+    objType,
+    scope === 'inner',
+  )
+  if (!range) return
+
+  applyOperator(op, range.start, range.end, ctx)
+  ctx.recordChange({ type: 'operatorTextObj', op, objType, scope, count })
+}
+
+/**
+ * Execute a line operation (dd, cc, yy).
+ */
+export function executeLineOp(
+  op: Operator,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  const text = ctx.text
+  const lines = text.split('\n')
+  // Calculate logical line by counting newlines before cursor offset
+  // (cursor.getPosition() returns wrapped line which is wrong for this)
+  const currentLine = countCharInString(text.slice(0, ctx.cursor.offset), '\n')
+  const linesToAffect = Math.min(count, lines.length - currentLine)
+  const lineStart = ctx.cursor.startOfLogicalLine().offset
+  let lineEnd = lineStart
+  for (let i = 0; i < linesToAffect; i++) {
+    const nextNewline = text.indexOf('\n', lineEnd)
+    lineEnd = nextNewline === -1 ? text.length : nextNewline + 1
+  }
+
+  let content = text.slice(lineStart, lineEnd)
+  // Ensure linewise content ends with newline for paste detection
+  if (!content.endsWith('\n')) {
+    content = content + '\n'
+  }
+  ctx.setRegister(content, true)
+
+  if (op === 'yank') {
+    ctx.setOffset(lineStart)
+  } else if (op === 'delete') {
+    let deleteStart = lineStart
+    const deleteEnd = lineEnd
+
+    // If deleting to end of file and there's a preceding newline, include it
+    // This ensures deleting the last line doesn't leave a trailing newline
+    if (
+      deleteEnd === text.length &&
+      deleteStart > 0 &&
+      text[deleteStart - 1] === '\n'
+    ) {
+      deleteStart -= 1
+    }
+
+    const newText = text.slice(0, deleteStart) + text.slice(deleteEnd)
+    ctx.setText(newText || '')
+    const maxOff = Math.max(
+      0,
+      newText.length - (lastGrapheme(newText).length || 1),
+    )
+    ctx.setOffset(Math.min(deleteStart, maxOff))
+  } else if (op === 'change') {
+    // For single line, just clear it
+    if (lines.length === 1) {
+      ctx.setText('')
+      ctx.enterInsert(0)
+    } else {
+      // Delete all affected lines, replace with single empty line, enter insert
+      const beforeLines = lines.slice(0, currentLine)
+      const afterLines = lines.slice(currentLine + linesToAffect)
+      const newText = [...beforeLines, '', ...afterLines].join('\n')
+      ctx.setText(newText)
+      ctx.enterInsert(lineStart)
+    }
+  }
+
+  ctx.recordChange({ type: 'operator', op, motion: op[0]!, count })
+}
+
+/**
+ * Execute delete character (x command).
+ */
+export function executeX(count: number, ctx: OperatorContext): void {
+  const from = ctx.cursor.offset
+
+  if (from >= ctx.text.length) return
+
+  // Advance by graphemes, not code units
+  let endCursor = ctx.cursor
+  for (let i = 0; i < count && !endCursor.isAtEnd(); i++) {
+    endCursor = endCursor.right()
+  }
+  const to = endCursor.offset
+
+  const deleted = ctx.text.slice(from, to)
+  const newText = ctx.text.slice(0, from) + ctx.text.slice(to)
+
+  ctx.setRegister(deleted, false)
+  ctx.setText(newText)
+  const maxOff = Math.max(
+    0,
+    newText.length - (lastGrapheme(newText).length || 1),
+  )
+  ctx.setOffset(Math.min(from, maxOff))
+  ctx.recordChange({ type: 'x', count })
+}
+
+/**
+ * Execute replace character (r command).
+ */
+export function executeReplace(
+  char: string,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  let offset = ctx.cursor.offset
+  let newText = ctx.text
+
+  for (let i = 0; i < count && offset < newText.length; i++) {
+    const graphemeLen = firstGrapheme(newText.slice(offset)).length || 1
+    newText =
+      newText.slice(0, offset) + char + newText.slice(offset + graphemeLen)
+    offset += char.length
+  }
+
+  ctx.setText(newText)
+  ctx.setOffset(Math.max(0, offset - char.length))
+  ctx.recordChange({ type: 'replace', char, count })
+}
+
+/**
+ * Execute toggle case (~ command).
+ */
+export function executeToggleCase(count: number, ctx: OperatorContext): void {
+  const startOffset = ctx.cursor.offset
+
+  if (startOffset >= ctx.text.length) return
+
+  let newText = ctx.text
+  let offset = startOffset
+  let toggled = 0
+
+  while (offset < newText.length && toggled < count) {
+    const grapheme = firstGrapheme(newText.slice(offset))
+    const graphemeLen = grapheme.length
+
+    const toggledGrapheme =
+      grapheme === grapheme.toUpperCase()
+        ? grapheme.toLowerCase()
+        : grapheme.toUpperCase()
+
+    newText =
+      newText.slice(0, offset) +
+      toggledGrapheme +
+      newText.slice(offset + graphemeLen)
+    offset += toggledGrapheme.length
+    toggled++
+  }
+
+  ctx.setText(newText)
+  // Cursor moves to position after the last toggled character
+  // At end of line, cursor can be at the "end" position
+  ctx.setOffset(offset)
+  ctx.recordChange({ type: 'toggleCase', count })
+}
+
+/**
+ * Execute join lines (J command).
+ */
+export function executeJoin(count: number, ctx: OperatorContext): void {
+  const text = ctx.text
+  const lines = text.split('\n')
+  const { line: currentLine } = ctx.cursor.getPosition()
+
+  if (currentLine >= lines.length - 1) return
+
+  const linesToJoin = Math.min(count, lines.length - currentLine - 1)
+  let joinedLine = lines[currentLine]!
+  const cursorPos = joinedLine.length
+
+  for (let i = 1; i <= linesToJoin; i++) {
+    const nextLine = (lines[currentLine + i] ?? '').trimStart()
+    if (nextLine.length > 0) {
+      if (!joinedLine.endsWith(' ') && joinedLine.length > 0) {
+        joinedLine += ' '
+      }
+      joinedLine += nextLine
+    }
+  }
+
+  const newLines = [
+    ...lines.slice(0, currentLine),
+    joinedLine,
+    ...lines.slice(currentLine + linesToJoin + 1),
+  ]
+
+  const newText = newLines.join('\n')
+  ctx.setText(newText)
+  ctx.setOffset(getLineStartOffset(newLines, currentLine) + cursorPos)
+  ctx.recordChange({ type: 'join', count })
+}
+
+/**
+ * Execute paste (p/P command).
+ */
+export function executePaste(
+  after: boolean,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  const register = ctx.getRegister()
+  if (!register) return
+
+  const isLinewise = register.endsWith('\n')
+  const content = isLinewise ? register.slice(0, -1) : register
+
+  if (isLinewise) {
+    const text = ctx.text
+    const lines = text.split('\n')
+    const { line: currentLine } = ctx.cursor.getPosition()
+
+    const insertLine = after ? currentLine + 1 : currentLine
+    const contentLines = content.split('\n')
+    const repeatedLines: string[] = []
+    for (let i = 0; i < count; i++) {
+      repeatedLines.push(...contentLines)
+    }
+
+    const newLines = [
+      ...lines.slice(0, insertLine),
+      ...repeatedLines,
+      ...lines.slice(insertLine),
+    ]
+
+    const newText = newLines.join('\n')
+    ctx.setText(newText)
+    ctx.setOffset(getLineStartOffset(newLines, insertLine))
+  } else {
+    const textToInsert = content.repeat(count)
+    const insertPoint =
+      after && ctx.cursor.offset < ctx.text.length
+        ? ctx.cursor.measuredText.nextOffset(ctx.cursor.offset)
+        : ctx.cursor.offset
+
+    const newText =
+      ctx.text.slice(0, insertPoint) +
+      textToInsert +
+      ctx.text.slice(insertPoint)
+    const lastGr = lastGrapheme(textToInsert)
+    const newOffset = insertPoint + textToInsert.length - (lastGr.length || 1)
+
+    ctx.setText(newText)
+    ctx.setOffset(Math.max(insertPoint, newOffset))
+  }
+}
+
+/**
+ * Execute indent (>> command).
+ */
+export function executeIndent(
+  dir: '>' | '<',
+  count: number,
+  ctx: OperatorContext,
+): void {
+  const text = ctx.text
+  const lines = text.split('\n')
+  const { line: currentLine } = ctx.cursor.getPosition()
+  const linesToAffect = Math.min(count, lines.length - currentLine)
+  const indent = '  ' // Two spaces
+
+  for (let i = 0; i < linesToAffect; i++) {
+    const lineIdx = currentLine + i
+    const line = lines[lineIdx] ?? ''
+
+    if (dir === '>') {
+      lines[lineIdx] = indent + line
+    } else if (line.startsWith(indent)) {
+      lines[lineIdx] = line.slice(indent.length)
+    } else if (line.startsWith('\t')) {
+      lines[lineIdx] = line.slice(1)
+    } else {
+      // Remove as much leading whitespace as possible up to indent length
+      let removed = 0
+      let idx = 0
+      while (
+        idx < line.length &&
+        removed < indent.length &&
+        /\s/.test(line[idx]!)
+      ) {
+        removed++
+        idx++
+      }
+      lines[lineIdx] = line.slice(idx)
+    }
+  }
+
+  const newText = lines.join('\n')
+  const currentLineText = lines[currentLine] ?? ''
+  const firstNonBlank = (currentLineText.match(/^\s*/)?.[0] ?? '').length
+
+  ctx.setText(newText)
+  ctx.setOffset(getLineStartOffset(lines, currentLine) + firstNonBlank)
+  ctx.recordChange({ type: 'indent', dir, count })
+}
+
+/**
+ * Execute open line (o/O command).
+ */
+export function executeOpenLine(
+  direction: 'above' | 'below',
+  ctx: OperatorContext,
+): void {
+  const text = ctx.text
+  const lines = text.split('\n')
+  const { line: currentLine } = ctx.cursor.getPosition()
+
+  const insertLine = direction === 'below' ? currentLine + 1 : currentLine
+  const newLines = [
+    ...lines.slice(0, insertLine),
+    '',
+    ...lines.slice(insertLine),
+  ]
+
+  const newText = newLines.join('\n')
+  ctx.setText(newText)
+  ctx.enterInsert(getLineStartOffset(newLines, insertLine))
+  ctx.recordChange({ type: 'openLine', direction })
+}
+
+// ============================================================================
+// Internal Helpers
+// ============================================================================
+
+/**
+ * Calculate the offset of a line's start position.
+ */
+function getLineStartOffset(lines: string[], lineIndex: number): number {
+  return lines.slice(0, lineIndex).join('\n').length + (lineIndex > 0 ? 1 : 0)
+}
+
+function getOperatorRange(
+  cursor: Cursor,
+  target: Cursor,
+  motion: string,
+  op: Operator,
+  count: number,
+): { from: number; to: number; linewise: boolean } {
+  let from = Math.min(cursor.offset, target.offset)
+  let to = Math.max(cursor.offset, target.offset)
+  let linewise = false
+
+  // Special case: cw/cW changes to end of word, not start of next word
+  if (op === 'change' && (motion === 'w' || motion === 'W')) {
+    // For cw with count, move forward (count-1) words, then find end of that word
+    let wordCursor = cursor
+    for (let i = 0; i < count - 1; i++) {
+      wordCursor =
+        motion === 'w' ? wordCursor.nextVimWord() : wordCursor.nextWORD()
+    }
+    const wordEnd =
+      motion === 'w' ? wordCursor.endOfVimWord() : wordCursor.endOfWORD()
+    to = cursor.measuredText.nextOffset(wordEnd.offset)
+  } else if (isLinewiseMotion(motion)) {
+    // Linewise motions extend to include entire lines
+    linewise = true
+    const text = cursor.text
+    const nextNewline = text.indexOf('\n', to)
+    if (nextNewline === -1) {
+      // Deleting to end of file - include the preceding newline if exists
+      to = text.length
+      if (from > 0 && text[from - 1] === '\n') {
+        from -= 1
+      }
+    } else {
+      to = nextNewline + 1
+    }
+  } else if (isInclusiveMotion(motion) && cursor.offset <= target.offset) {
+    to = cursor.measuredText.nextOffset(to)
+  }
+
+  // Word motions can land inside an [Image #N] chip; extend the range to
+  // cover the whole chip so dw/cw/yw never leave a partial placeholder.
+  from = cursor.snapOutOfImageRef(from, 'start')
+  to = cursor.snapOutOfImageRef(to, 'end')
+
+  return { from, to, linewise }
+}
+
+/**
+ * Get the range for a find-based operator.
+ * Note: _findType is unused because Cursor.findCharacter already adjusts
+ * the offset for t/T motions. All find types are treated as inclusive here.
+ */
+function getOperatorRangeForFind(
+  cursor: Cursor,
+  target: Cursor,
+  _findType: FindType,
+): { from: number; to: number } {
+  const from = Math.min(cursor.offset, target.offset)
+  const maxOffset = Math.max(cursor.offset, target.offset)
+  const to = cursor.measuredText.nextOffset(maxOffset)
+  return { from, to }
+}
+
+function applyOperator(
+  op: Operator,
+  from: number,
+  to: number,
+  ctx: OperatorContext,
+  linewise: boolean = false,
+): void {
+  let content = ctx.text.slice(from, to)
+  // Ensure linewise content ends with newline for paste detection
+  if (linewise && !content.endsWith('\n')) {
+    content = content + '\n'
+  }
+  ctx.setRegister(content, linewise)
+
+  if (op === 'yank') {
+    ctx.setOffset(from)
+  } else if (op === 'delete') {
+    const newText = ctx.text.slice(0, from) + ctx.text.slice(to)
+    ctx.setText(newText)
+    const maxOff = Math.max(
+      0,
+      newText.length - (lastGrapheme(newText).length || 1),
+    )
+    ctx.setOffset(Math.min(from, maxOff))
+  } else if (op === 'change') {
+    const newText = ctx.text.slice(0, from) + ctx.text.slice(to)
+    ctx.setText(newText)
+    ctx.enterInsert(from)
+  }
+}
+
+export function executeOperatorG(
+  op: Operator,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  // count=1 means no count given, target = end of file
+  // otherwise target = line N
+  const target =
+    count === 1 ? ctx.cursor.startOfLastLine() : ctx.cursor.goToLine(count)
+
+  if (target.equals(ctx.cursor)) return
+
+  const range = getOperatorRange(ctx.cursor, target, 'G', op, count)
+  applyOperator(op, range.from, range.to, ctx, range.linewise)
+  ctx.recordChange({ type: 'operator', op, motion: 'G', count })
+}
+
+export function executeOperatorGg(
+  op: Operator,
+  count: number,
+  ctx: OperatorContext,
+): void {
+  // count=1 means no count given, target = first line
+  // otherwise target = line N
+  const target =
+    count === 1 ? ctx.cursor.startOfFirstLine() : ctx.cursor.goToLine(count)
+
+  if (target.equals(ctx.cursor)) return
+
+  const range = getOperatorRange(ctx.cursor, target, 'gg', op, count)
+  applyOperator(op, range.from, range.to, ctx, range.linewise)
+  ctx.recordChange({ type: 'operator', op, motion: 'gg', count })
+}