opencode-vim 0.0.23 → 0.0.24

package/src/modules/vim/map.ts

@@ -1,90 +0,0 @@
-import type { CursorPosition } from "@vimee/core"
-import { createGraphemeCodec } from "./graphemes"
-
-const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" })
-
-function graphemeWidth(value: string) {
-    // Textarea offsets count newlines as one position; Bun.stringWidth counts them as zero.
-    // OpenTUI's edit buffer gives tabs a fixed two-column width by default.
-    if (value === "\t") return 2
-    return value === "\n" ? 1 : Bun.stringWidth(value)
-}
-
-export function charToDisplay(text: string, charIndex: number): number {
-    let width = 0
-    const limit = Math.max(0, Math.min(charIndex, text.length))
-    for (const part of graphemes.segment(text)) {
-        if (part.index + part.segment.length > limit) break
-        width += graphemeWidth(part.segment)
-    }
-    return width
-}
-
-export function displayToChar(text: string, displayOffset: number): number {
-    let width = 0
-    for (const part of graphemes.segment(text)) {
-        const next = width + graphemeWidth(part.segment)
-        if (next > displayOffset) return part.index
-        width = next
-    }
-    return text.length
-}
-
-export function displayWidth(text: string): number {
-    return charToDisplay(text, text.length)
-}
-
-export type PromptMap = {
-    hostText: string
-    vimText: string
-    hostToVim: number[]
-    vimToHost: number[]
-}
-
-export function createPromptMap(hostText: string, codec = createGraphemeCodec()): PromptMap {
-    const hostToVim: number[] = []
-    const vimToHost: number[] = []
-    let vimText = ""
-    let vimOffset = 0
-
-    for (const { index: hostOffset, segment } of graphemes.segment(hostText)) {
-        for (let index = hostOffset; index < hostOffset + segment.length; index++) hostToVim[index] = vimOffset
-        vimText += codec.encode(segment)
-        vimToHost[vimOffset] = hostOffset
-        vimOffset++
-    }
-
-    hostToVim[hostText.length] = vimOffset
-    vimToHost[vimOffset] = hostText.length
-    return { hostText, vimText, hostToVim, vimToHost }
-}
-
-export function hostPosition(map: PromptMap, hostDisplayOffset: number): CursorPosition {
-    const charIdx = displayToChar(map.hostText, hostDisplayOffset)
-    return positionFromOffset(map.vimText, map.hostToVim[clamp(charIdx, 0, map.hostText.length)])
-}
-
-export function hostOffset(map: PromptMap, position: CursorPosition) {
-    return hostFromVimOffset(map, offsetFromPosition(map.vimText, position))
-}
-
-export function hostFromVimOffset(map: PromptMap, offset: number) {
-    return charToDisplay(map.hostText, map.vimToHost[clamp(offset, 0, map.vimText.length)])
-}
-
-function positionFromOffset(text: string, offset: number): CursorPosition {
-    const lines = text.slice(0, offset).split("\n")
-    return { line: lines.length - 1, col: lines[lines.length - 1]?.length ?? 0 }
-}
-
-function offsetFromPosition(text: string, position: CursorPosition) {
-    const lines = text.split("\n")
-    const line = clamp(position.line, 0, Math.max(0, lines.length - 1))
-    let offset = 0
-    for (let index = 0; index < line; index++) offset += lines[index].length + 1
-    return offset + clamp(position.col, 0, lines[line]?.length ?? 0)
-}
-
-function clamp(value: number, min: number, max: number) {
-    return Math.max(min, Math.min(max, value))
-}

package/src/modules/vim/state.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createVimState } from "./state"
-
-describe("vim state", () => {
-    test("isolates listener errors", () => {
-        const events: string[] = []
-        const state = createVimState("normal", (event) => events.push(event))
-        state.subscribe(() => {
-            throw new Error("stale renderable")
-        })
-        state.subscribe(() => events.push("listener.complete"))
-
-        expect(() => state.setMode("insert")).not.toThrow()
-        expect(state.mode()).toBe("insert")
-        expect(events).toContain("state.listener.error")
-        expect(events).toContain("listener.complete")
-    })
-})

package/src/modules/vim/state.tsx

@@ -1,46 +0,0 @@
-// Keep this module as TSX so OpenCode's plugin loader rewrites its Solid import
-// to the host runtime shared by the footer and cursor effects.
-import { createSignal } from "solid-js"
-import type { VimLog } from "./log"
-
-export type VimMode = "normal" | "insert" | "visual" | "visual-line"
-export type VimStateListener = () => void
-
-export function createVimState(defaultMode: VimMode, log: VimLog = () => {}) {
-    const [mode, setMode] = createSignal<VimMode>(defaultMode)
-    const [pending, setPending] = createSignal("")
-    const listeners = new Set<VimStateListener>()
-
-    log("state.init", { mode: defaultMode })
-
-    return {
-        mode,
-        setMode(next: VimMode) {
-            const changed = mode() !== next
-            if (changed) log("state.mode", { from: mode(), to: next })
-            setMode(next)
-            if (changed) notify()
-        },
-        pending,
-        setPending(next: string) {
-            const changed = pending() !== next
-            if (changed) log("state.pending", { from: pending(), to: next })
-            setPending(next)
-            if (changed) notify()
-        },
-        subscribe(listener: VimStateListener) {
-            listeners.add(listener)
-            return () => listeners.delete(listener)
-        },
-    }
-
-    function notify() {
-        for (const listener of listeners) {
-            try {
-                listener()
-            } catch (error) {
-                log("state.listener.error", { error: error instanceof Error ? error.message : String(error) })
-            }
-        }
-    }
-}

package/src/modules/vim/view.tsx

@@ -1,130 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import type { TextRenderable } from "@opentui/core"
-import { onCleanup } from "solid-js"
-import type { Accessor } from "solid-js"
-import type { PromptContext } from "../../prompt/types"
-import type { VimLog } from "./log"
-import type { VimMode, VimStateListener } from "./state"
-
-const STATUS_SYNC_MS = 50
-
-type VimStatusProps = {
-    mode: Accessor<VimMode>
-    pending: Accessor<string | undefined>
-    subscribe: (listener: VimStateListener) => () => void
-    enabled: Accessor<boolean>
-    theme: PromptContext["api"]["theme"]["current"]
-    pendingDisplayDelay?: number
-    disabled?: boolean
-    log?: VimLog
-    requestRender?: () => void
-}
-
-export function VimStatus(props: VimStatusProps) {
-    let modeText: TextRenderable | undefined
-    let pendingText: TextRenderable | undefined
-    let displayedMode = props.mode()
-    let displayedPending: string | undefined
-    let displayedEnabled = props.enabled()
-    let pendingTimer: ReturnType<typeof setTimeout> | undefined
-    let scheduledPending: string | undefined
-
-    const sync = () => {
-        const nextMode = props.mode()
-        const nextPending = props.pending()
-        let changed = false
-
-        if (displayedMode !== nextMode) {
-            props.log?.("status.sync", { fromMode: displayedMode, toMode: nextMode, fromPending: displayedPending, toPending: displayedPending })
-            displayedMode = nextMode
-            changed = true
-        }
-
-        const nextEnabled = props.enabled()
-        if (displayedEnabled !== nextEnabled) {
-            props.log?.("status.enabled", { from: displayedEnabled, to: nextEnabled })
-            displayedEnabled = nextEnabled
-            changed = true
-        }
-
-        if (changed) updateModeText()
-        syncPending(nextPending)
-        if (changed) props.requestRender?.()
-    }
-
-    const unsubscribe = props.subscribe(sync)
-    const timer = setInterval(sync, STATUS_SYNC_MS)
-    onCleanup(() => {
-        unsubscribe()
-        clearInterval(timer)
-        if (pendingTimer) clearTimeout(pendingTimer)
-        modeText = undefined
-        pendingText = undefined
-    })
-
-    return (
-        <box paddingLeft={1} paddingRight={1} flexDirection="row">
-            <text ref={(ref: TextRenderable) => { pendingText = ref; updatePendingText() }} fg={props.theme.info}>{displayedPending ? `${displayedPending} ` : ""}</text>
-            <text ref={(ref: TextRenderable) => { modeText = ref; updateModeText() }} fg={modeColor(displayedMode, displayedEnabled, props.theme, props.disabled)}>{displayedEnabled ? modeLabel(displayedMode) : ""}</text>
-        </box>
-    )
-
-    function updateModeText() {
-        if (!modeText) return
-        modeText.content = displayedEnabled ? modeLabel(displayedMode) : ""
-        modeText.fg = modeColor(displayedMode, displayedEnabled, props.theme, props.disabled)
-    }
-
-    function updatePendingText() {
-        if (!pendingText) return
-        pendingText.content = displayedEnabled && displayedPending ? `${displayedPending} ` : ""
-    }
-
-    function syncPending(nextPending: string | undefined) {
-        if (!nextPending) {
-            if (pendingTimer) clearTimeout(pendingTimer)
-            pendingTimer = undefined
-            scheduledPending = undefined
-            setDisplayedPending(undefined)
-            return
-        }
-
-        if (displayedPending === nextPending) return
-        if (scheduledPending === nextPending) return
-
-        if (pendingTimer) clearTimeout(pendingTimer)
-        scheduledPending = nextPending
-        const delay = props.pendingDisplayDelay ?? 120
-        if (delay <= 0) {
-            scheduledPending = undefined
-            setDisplayedPending(nextPending)
-            return
-        }
-
-        pendingTimer = setTimeout(() => {
-            pendingTimer = undefined
-            scheduledPending = undefined
-            if (props.pending() === nextPending) setDisplayedPending(nextPending)
-        }, delay)
-    }
-
-    function setDisplayedPending(nextPending: string | undefined) {
-        if (displayedPending === nextPending) return
-        props.log?.("status.sync", { fromMode: displayedMode, toMode: displayedMode, fromPending: displayedPending, toPending: nextPending })
-        displayedPending = nextPending
-        updatePendingText()
-        props.requestRender?.()
-    }
-}
-
-function modeColor(mode: VimMode, enabled: boolean, theme: PromptContext["api"]["theme"]["current"], disabled?: boolean) {
-    if (!enabled) return undefined
-    if (disabled) return theme.textMuted
-    return mode === "insert" ? theme.success : theme.warning
-}
-
-function modeLabel(mode: VimMode) {
-    if (mode === "visual") return "VISUAL"
-    if (mode === "visual-line") return "VISUAL LINE"
-    return mode === "normal" ? "NORMAL" : "INSERT"
-}

package/src/modules/vim/vimee.test.ts

@@ -1,211 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { KeyEvent } from "@opentui/core"
-import type { PromptContext } from "./actions"
-import { createVimConfig } from "./config"
-import type { VimLog } from "./log"
-import { createVimState, type VimMode } from "./state"
-import { createVimeeAdapter } from "./vimee"
-
-describe("vim command keymaps", () => {
-    test("does not restore stale cursor state after a normal command", () => {
-        const fixture = createFixture("normal", "command:test.run")
-        fixture.dispatch = () => {
-            fixture.input.plainText = "updated"
-            fixture.input.cursorOffset = 7
-        }
-
-        expect(fixture.handle()).toBe(true)
-        expect(fixture.commands).toEqual(["test.run"])
-        expect(fixture.input.cursorOffset).toBe(7)
-    })
-
-    test("uses the host history boundary and restores display width", () => {
-        const fixture = createFixture("normal", "command:prompt.history.next", "中")
-        let boundary = -1
-        fixture.dispatch = () => {
-            boundary = fixture.input.cursorOffset
-            fixture.input.plainText = "中中"
-            fixture.input.cursorOffset = 2
-        }
-
-        expect(fixture.handle()).toBe(true)
-        expect(boundary).toBe(1)
-        expect(fixture.input.cursorOffset).toBe(4)
-    })
-
-    test("dispatches commands in insert mode", () => {
-        const fixture = createFixture("insert", "command:test.run")
-
-        expect(fixture.handle()).toBe(true)
-        expect(fixture.commands).toEqual(["test.run"])
-    })
-
-    test("rejects an empty command name", () => {
-        const logs: Array<[string, unknown]> = []
-        createFixture("normal", "command:   ", "", (event, data) => logs.push([event, data]))
-
-        expect(logs.some(([event]) => event === "vimee.keymap.invalid")).toBe(true)
-    })
-})
-
-describe("vim enter keymaps", () => {
-    test("submits unmapped Enter in normal mode without moving the cursor", () => {
-        const fixture = createFixture("normal", undefined, "中")
-        fixture.input.cursorOffset = 2
-
-        expect(fixture.handle("<CR>")).toBe(true)
-        expect(fixture.submissions).toHaveLength(1)
-        expect(fixture.input.cursorOffset).toBe(2)
-    })
-
-    test("passes unmapped Enter through in insert mode", () => {
-        const fixture = createFixture("insert", undefined)
-
-        expect(fixture.handle("<CR>")).toBe(false)
-        expect(fixture.submissions).toHaveLength(0)
-    })
-
-    test("does not submit a matched mapping with no immediate actions", () => {
-        const fixture = createFixture("normal", "d", "text", () => {}, "<CR>")
-
-        expect(fixture.handle("<CR>")).toBe(true)
-        expect(fixture.submissions).toHaveLength(0)
-    })
-
-    test("runs an Enter command mapping", () => {
-        const fixture = createFixture("normal", "command:test.run", "", () => {}, "<CR>")
-
-        expect(fixture.handle("<CR>")).toBe(true)
-        expect(fixture.commands).toEqual(["test.run"])
-        expect(fixture.submissions).toHaveLength(0)
-    })
-
-    test("applies mode and submit mappings", () => {
-        const normal = createFixture("normal", "insert", "", () => {}, "<CR>")
-        const insert = createFixture("insert", "submit", "", () => {}, "<CR>")
-
-        expect(normal.handle("<CR>")).toBe(true)
-        expect(normal.handle("a")).toBe(false)
-        expect(insert.handle("<CR>")).toBe(true)
-        expect(insert.submissions).toHaveLength(1)
-    })
-
-    test("allows Enter to finish a multi-key mapping", () => {
-        const fixture = createFixture("normal", "command:test.run", "", () => {}, "g<CR>")
-
-        expect(fixture.handle("g")).toBe(true)
-        expect(fixture.handle("<CR>")).toBe(true)
-        expect(fixture.commands).toEqual(["test.run"])
-        expect(fixture.submissions).toHaveLength(0)
-    })
-
-    test("rejects mappings that defer Enter", () => {
-        const logs: Array<[string, unknown]> = []
-        const fixture = createFixture("normal", "command:test.run", "", (event, data) => logs.push([event, data]), "<CR>x")
-
-        expect(fixture.handle("<CR>")).toBe(true)
-        expect(fixture.submissions).toHaveLength(1)
-        expect(logs.some(([event]) => event === "vimee.keymap.invalid")).toBe(true)
-    })
-})
-
-describe("vim prompt history", () => {
-    test("starts from an empty prompt and continues through history", () => {
-        const fixture = createFixture("normal", undefined, "")
-        const entries = ["newest", "older", ""]
-        fixture.dispatch = (command) => {
-            fixture.input.plainText = entries.shift() ?? ""
-            fixture.input.cursorOffset = command === "prompt.history.previous" ? 0 : fixture.input.plainText.length
-        }
-
-        expect(fixture.handle("k")).toBe(true)
-        expect(fixture.handle("k")).toBe(true)
-        expect(fixture.handle("j")).toBe(true)
-        expect(fixture.commands).toEqual([
-            "prompt.history.previous",
-            "prompt.history.previous",
-            "prompt.history.next",
-        ])
-    })
-
-    test("keeps normal movement for a nonempty prompt", () => {
-        const fixture = createFixture("normal", undefined, "text")
-
-        expect(fixture.handle("k")).toBe(true)
-        expect(fixture.handle("j")).toBe(true)
-        expect(fixture.commands).toEqual([])
-    })
-
-    test("stops history navigation after another normal key", () => {
-        const fixture = createFixture("normal", undefined, "")
-        fixture.dispatch = () => {
-            fixture.input.plainText = "recalled"
-        }
-
-        expect(fixture.handle("k")).toBe(true)
-        expect(fixture.handle("h")).toBe(true)
-        expect(fixture.handle("k")).toBe(true)
-        expect(fixture.commands).toEqual(["prompt.history.previous"])
-    })
-
-    test("prefers configured keymaps", () => {
-        const fixture = createFixture("normal", "command:test.run", "", () => {}, "k")
-
-        expect(fixture.handle()).toBe(true)
-        expect(fixture.commands).toEqual(["test.run"])
-    })
-
-    test("completes a pending keymap before history navigation", () => {
-        const fixture = createFixture("normal", "command:test.run", "", () => {}, "gk")
-
-        expect(fixture.handle("g")).toBe(true)
-        expect(fixture.handle("k")).toBe(true)
-        expect(fixture.commands).toEqual(["test.run"])
-    })
-})
-
-function createFixture(mode: VimMode, action: string | undefined, text = "text", log: VimLog = () => {}, mappedKey = "Q") {
-    const input = {
-        plainText: text,
-        cursorOffset: 0,
-        visualCursor: { visualRow: 0, visualCol: 0, offset: 0 },
-        moveCursorLeft: () => false,
-    }
-    const commands: string[] = []
-    const submissions: true[] = []
-    const prompt = {
-        current: { input: text, mode: "normal", parts: [] },
-        set() {},
-        submit() {
-            submissions.push(true)
-        },
-        blur() {},
-    }
-    const fixture = {
-        input,
-        commands,
-        submissions,
-        dispatch: (_command: string) => {},
-        handle: (key = mappedKey) => adapter.handle({ name: key } as KeyEvent, key, ctx),
-    }
-    const ctx = {
-        api: {
-            renderer: { currentFocusedRenderable: input },
-            keymap: {
-                dispatchCommand(command: string) {
-                    commands.push(command)
-                    fixture.dispatch(command)
-                    return { ok: true as const }
-                },
-            },
-        },
-        prompt: () => prompt,
-        requestRender() {},
-    } as unknown as PromptContext
-    const config = createVimConfig({
-        defaultMode: mode,
-        keymaps: action ? { [mode]: { [mappedKey]: action } } : undefined,
-    })
-    const adapter = createVimeeAdapter(createVimState(mode), config, log)
-    return fixture
-}