391 lines
14 KiB
TypeScript
391 lines
14 KiB
TypeScript
import { GetCurrentTerminal } from '../app'
|
|
import { Item } from '../fs/Item'
|
|
import type { SimpleStream } from '../utils/SimpleStream'
|
|
import { Program } from './Program'
|
|
|
|
type Viewport = {
|
|
cols: number
|
|
rows: number
|
|
headerRows: number
|
|
footerRows: number
|
|
contentHeight: number
|
|
}
|
|
|
|
type PromptState =
|
|
| { active: false }
|
|
| { active: true; label: string; value: string; handler: (value: string) => Promise<void> }
|
|
|
|
export class Edit extends Program {
|
|
constructor() {
|
|
super()
|
|
}
|
|
|
|
async Exec(stdin: SimpleStream<string>, stdout: SimpleStream<string>, workdir: Item, args: string[]): Promise<number> {
|
|
if (args.length < 2) {
|
|
stdout.emit('edit: error: missing path argument\n')
|
|
return 1
|
|
}
|
|
|
|
const terminal = GetCurrentTerminal()
|
|
const resolvePath = (path: string) => Item.NormalizePath(path.startsWith('/') ? path : `${workdir.GetPath()}/${path}`)
|
|
|
|
let filePath = resolvePath(args[1])
|
|
let file = await Item.open(filePath, '')
|
|
let fileExists = await file.Exists()
|
|
let lines = this.normalizeLines(file.GetData())
|
|
let dirty = false
|
|
|
|
let cursorLine = 0
|
|
let cursorCol = 0
|
|
let preferredCol = 0
|
|
let scrollLine = 0
|
|
let scrollCol = 0
|
|
|
|
let statusMessage = ''
|
|
let exitArmed = false
|
|
|
|
let promptState: PromptState = { active: false }
|
|
|
|
const getViewport = (): Viewport => {
|
|
const cols = Math.max(1, Math.floor(terminal.GetWidthCells()))
|
|
const rows = Math.max(1, Math.floor(terminal.GetHeightCells()))
|
|
const headerRows = rows >= 3 ? 1 : 0
|
|
const footerRows = rows >= 2 ? 1 : 0
|
|
const contentHeight = Math.max(1, rows - headerRows - footerRows)
|
|
return { cols, rows, headerRows, footerRows, contentHeight }
|
|
}
|
|
|
|
const formatLine = (text: string, width: number) => {
|
|
if (text.length > width)
|
|
return text.slice(0, width)
|
|
return text.padEnd(width, ' ')
|
|
}
|
|
|
|
const clampCursor = () => {
|
|
cursorLine = Math.max(0, Math.min(cursorLine, lines.length - 1))
|
|
const lineLength = lines[cursorLine].length
|
|
cursorCol = Math.max(0, Math.min(cursorCol, lineLength))
|
|
preferredCol = cursorCol
|
|
}
|
|
|
|
const ensureCursorVisible = (viewport: Viewport) => {
|
|
if (cursorLine < scrollLine)
|
|
scrollLine = cursorLine
|
|
if (cursorLine >= scrollLine + viewport.contentHeight)
|
|
scrollLine = cursorLine - viewport.contentHeight + 1
|
|
|
|
if (cursorCol < scrollCol)
|
|
scrollCol = cursorCol
|
|
if (cursorCol >= scrollCol + viewport.cols)
|
|
scrollCol = cursorCol - viewport.cols + 1
|
|
|
|
const maxScrollLine = Math.max(0, lines.length - viewport.contentHeight)
|
|
scrollLine = Math.min(scrollLine, maxScrollLine)
|
|
scrollCol = Math.max(0, scrollCol)
|
|
}
|
|
|
|
const setStatus = (message: string) => {
|
|
statusMessage = message
|
|
}
|
|
|
|
const openFile = async (path: string) => {
|
|
try {
|
|
const resolved = resolvePath(path)
|
|
const nextFile = await Item.open(resolved, '')
|
|
const exists = await nextFile.Exists()
|
|
const content = nextFile.GetData()
|
|
|
|
filePath = resolved
|
|
file = nextFile
|
|
fileExists = exists
|
|
lines = this.normalizeLines(content)
|
|
dirty = false
|
|
|
|
cursorLine = 0
|
|
cursorCol = 0
|
|
preferredCol = 0
|
|
scrollLine = 0
|
|
scrollCol = 0
|
|
|
|
setStatus(exists ? `Opened ${filePath}` : `New file ${filePath}`)
|
|
} catch (e) {
|
|
setStatus(`Open failed: ${e instanceof Error ? e.message : String(e)}`)
|
|
}
|
|
}
|
|
|
|
const saveFile = async () => {
|
|
const data = lines.join('\n')
|
|
|
|
try {
|
|
if (fileExists) {
|
|
await file.Write(data)
|
|
} else {
|
|
const created = await Item.open(filePath, data)
|
|
await created.Create()
|
|
file = created
|
|
fileExists = true
|
|
}
|
|
|
|
dirty = false
|
|
exitArmed = false
|
|
setStatus(`Saved ${filePath}`)
|
|
} catch (e) {
|
|
setStatus(`Save failed: ${e instanceof Error ? e.message : String(e)}`)
|
|
}
|
|
}
|
|
|
|
const startPrompt = (label: string, handler: (value: string) => Promise<void>) => {
|
|
promptState = { active: true, label, value: '', handler }
|
|
}
|
|
|
|
const render = () => {
|
|
const viewport = getViewport()
|
|
const footerRow = viewport.headerRows + viewport.contentHeight + (viewport.footerRows ? 1 : 0)
|
|
ensureCursorVisible(viewport)
|
|
|
|
let output = '\x1b[2J'
|
|
|
|
if (viewport.headerRows) {
|
|
const headerText = `EDIT - ${filePath}${dirty ? ' *' : ''}`
|
|
output += `\x1b[1;1H${formatLine(headerText, viewport.cols)}`
|
|
}
|
|
|
|
const contentStartRow = viewport.headerRows + 1
|
|
for (let i = 0; i < viewport.contentHeight; i++) {
|
|
const lineIndex = scrollLine + i
|
|
const lineText = lines[lineIndex] ?? ''
|
|
const visible = lineText.slice(scrollCol, scrollCol + viewport.cols)
|
|
output += `\x1b[${contentStartRow + i};1H${formatLine(visible, viewport.cols)}`
|
|
}
|
|
|
|
if (viewport.footerRows) {
|
|
const positionText = `Ln ${cursorLine + 1}, Col ${cursorCol + 1}`
|
|
const shortcuts = 'F2 Save F3 Open F10 Exit'
|
|
const footerText = promptState.active
|
|
? `${promptState.label}${promptState.value}`
|
|
: `${shortcuts} ${positionText}${statusMessage ? ` ${statusMessage}` : ''}`
|
|
output += `\x1b[${footerRow};1H${formatLine(footerText, viewport.cols)}`
|
|
}
|
|
|
|
if (promptState.active) {
|
|
const cursorRow = footerRow
|
|
const cursorColPos = Math.min(viewport.cols, promptState.label.length + promptState.value.length + 1)
|
|
output += `\x1b[${cursorRow};${cursorColPos}H`
|
|
} else {
|
|
const cursorRow = contentStartRow + (cursorLine - scrollLine)
|
|
const cursorColPos = 1 + (cursorCol - scrollCol)
|
|
output += `\x1b[${cursorRow};${cursorColPos}H`
|
|
}
|
|
|
|
stdout.emit(output)
|
|
}
|
|
|
|
render()
|
|
|
|
while (true) {
|
|
const key = await stdin.wait()
|
|
|
|
if (promptState.active) {
|
|
if (key === 'Escape') {
|
|
promptState = { active: false }
|
|
setStatus('Canceled')
|
|
render()
|
|
continue
|
|
}
|
|
|
|
if (key === 'Enter') {
|
|
const { handler } = promptState
|
|
const value = promptState.value.trim()
|
|
promptState = { active: false }
|
|
|
|
if (value.length > 0) {
|
|
await handler(value)
|
|
} else {
|
|
setStatus('Canceled')
|
|
}
|
|
|
|
render()
|
|
continue
|
|
}
|
|
|
|
if (key === 'Backspace') {
|
|
const nextValue: string = promptState.value.slice(0, -1)
|
|
promptState = {
|
|
active: true,
|
|
label: promptState.label,
|
|
value: nextValue,
|
|
handler: promptState.handler,
|
|
}
|
|
render()
|
|
continue
|
|
}
|
|
|
|
if (key.length === 1) {
|
|
const nextValue: string = promptState.value + key
|
|
promptState = {
|
|
active: true,
|
|
label: promptState.label,
|
|
value: nextValue,
|
|
handler: promptState.handler,
|
|
}
|
|
render()
|
|
}
|
|
|
|
continue
|
|
}
|
|
|
|
if (exitArmed && key !== 'F10')
|
|
exitArmed = false
|
|
|
|
switch (key) {
|
|
case 'F2':
|
|
await saveFile()
|
|
render()
|
|
continue
|
|
case 'F3':
|
|
startPrompt('Open: ', openFile)
|
|
render()
|
|
continue
|
|
case 'F10':
|
|
if (dirty && !exitArmed) {
|
|
exitArmed = true
|
|
setStatus('Unsaved changes. Press F10 again to exit.')
|
|
render()
|
|
continue
|
|
}
|
|
stdout.emit('\x1b[2J\x1b[H')
|
|
return 0
|
|
case 'ArrowLeft':
|
|
if (cursorCol > 0) {
|
|
cursorCol -= 1
|
|
} else if (cursorLine > 0) {
|
|
cursorLine -= 1
|
|
cursorCol = lines[cursorLine].length
|
|
}
|
|
preferredCol = cursorCol
|
|
render()
|
|
continue
|
|
case 'ArrowRight': {
|
|
const lineLength = lines[cursorLine].length
|
|
if (cursorCol < lineLength) {
|
|
cursorCol += 1
|
|
} else if (cursorLine < lines.length - 1) {
|
|
cursorLine += 1
|
|
cursorCol = 0
|
|
}
|
|
preferredCol = cursorCol
|
|
render()
|
|
continue
|
|
}
|
|
case 'ArrowUp':
|
|
cursorLine = Math.max(0, cursorLine - 1)
|
|
cursorCol = Math.min(preferredCol, lines[cursorLine].length)
|
|
render()
|
|
continue
|
|
case 'ArrowDown':
|
|
cursorLine = Math.min(lines.length - 1, cursorLine + 1)
|
|
cursorCol = Math.min(preferredCol, lines[cursorLine].length)
|
|
render()
|
|
continue
|
|
case 'Home':
|
|
cursorCol = 0
|
|
preferredCol = cursorCol
|
|
render()
|
|
continue
|
|
case 'End':
|
|
cursorCol = lines[cursorLine].length
|
|
preferredCol = cursorCol
|
|
render()
|
|
continue
|
|
case 'PageUp': {
|
|
const viewport = getViewport()
|
|
cursorLine = Math.max(0, cursorLine - viewport.contentHeight)
|
|
cursorCol = Math.min(preferredCol, lines[cursorLine].length)
|
|
render()
|
|
continue
|
|
}
|
|
case 'PageDown': {
|
|
const viewport = getViewport()
|
|
cursorLine = Math.min(lines.length - 1, cursorLine + viewport.contentHeight)
|
|
cursorCol = Math.min(preferredCol, lines[cursorLine].length)
|
|
render()
|
|
continue
|
|
}
|
|
case 'Backspace':
|
|
if (cursorCol > 0) {
|
|
const line = lines[cursorLine]
|
|
lines[cursorLine] = line.slice(0, cursorCol - 1) + line.slice(cursorCol)
|
|
cursorCol -= 1
|
|
preferredCol = cursorCol
|
|
dirty = true
|
|
} else if (cursorLine > 0) {
|
|
const current = lines[cursorLine]
|
|
cursorLine -= 1
|
|
cursorCol = lines[cursorLine].length
|
|
lines[cursorLine] += current
|
|
lines.splice(cursorLine + 1, 1)
|
|
preferredCol = cursorCol
|
|
dirty = true
|
|
}
|
|
render()
|
|
continue
|
|
case 'Delete': {
|
|
const line = lines[cursorLine]
|
|
if (cursorCol < line.length) {
|
|
lines[cursorLine] = line.slice(0, cursorCol) + line.slice(cursorCol + 1)
|
|
dirty = true
|
|
} else if (cursorLine < lines.length - 1) {
|
|
lines[cursorLine] = line + lines[cursorLine + 1]
|
|
lines.splice(cursorLine + 1, 1)
|
|
dirty = true
|
|
}
|
|
render()
|
|
continue
|
|
}
|
|
case 'Enter': {
|
|
const line = lines[cursorLine]
|
|
const before = line.slice(0, cursorCol)
|
|
const after = line.slice(cursorCol)
|
|
lines[cursorLine] = before
|
|
lines.splice(cursorLine + 1, 0, after)
|
|
cursorLine += 1
|
|
cursorCol = 0
|
|
preferredCol = 0
|
|
dirty = true
|
|
render()
|
|
continue
|
|
}
|
|
case 'Tab':
|
|
lines[cursorLine] = this.insertText(lines[cursorLine], cursorCol, ' ')
|
|
cursorCol += 4
|
|
preferredCol = cursorCol
|
|
dirty = true
|
|
render()
|
|
continue
|
|
}
|
|
|
|
if (key.length === 1) {
|
|
lines[cursorLine] = this.insertText(lines[cursorLine], cursorCol, key)
|
|
cursorCol += 1
|
|
preferredCol = cursorCol
|
|
dirty = true
|
|
render()
|
|
continue
|
|
}
|
|
|
|
clampCursor()
|
|
render()
|
|
}
|
|
}
|
|
|
|
private normalizeLines(content: string | null): string[] {
|
|
const normalized = (content ?? '').replace(/\r\n/g, '\n').replace(/\r/g, '\n')
|
|
const lines = normalized.split('\n')
|
|
return lines.length === 0 ? [''] : lines
|
|
}
|
|
|
|
private insertText(line: string, index: number, text: string): string {
|
|
return line.slice(0, index) + text + line.slice(index)
|
|
}
|
|
}
|