@aemonge-dev/pi-stardeck 0.0.0-stage → 0.6.0

package/packages/pi-vim-top-border/types.ts

@@ -0,0 +1,51 @@
+/**
+ * Types and constants for vim-mode extension
+ */
+
+export type Mode = 'normal' | 'insert' | 'visual' | 'visual-line';
+export type CharMotion = 'f' | 'F' | 't' | 'T';
+export type PendingMotion = CharMotion | null;
+export type PendingOperator = 'd' | 'c' | 'y' | null;
+
+export interface LastCharMotion {
+  motion: CharMotion;
+  char: string;
+}
+
+// Normal mode key mappings: key -> escape sequence (or null for mode switch)
+export const NORMAL_KEYS: Record<string, string | null> = {
+  h: '\x1b[D', // left
+  j: '\x1b[B', // down
+  k: '\x1b[A', // up
+  l: '\x1b[C', // right
+  '0': '\x01', // line start
+  $: null, // line end
+  x: null, // delete char (custom clipboard handling)
+  X: null, // delete char before cursor (custom clipboard handling)
+  D: null, // delete to end of line (custom clipboard handling)
+  C: null, // change to end of line (delete to end + insert mode)
+  S: null, // substitute line (delete line content + insert mode)
+  s: null, // substitute char (delete char + insert mode)
+  i: null, // insert mode
+  a: null, // append (insert + right)
+  A: null, // append at end of line
+  I: null, // insert at start of line
+  o: null, // open line below
+  O: null, // open line above
+};
+
+// Character motion keys that wait for a target character
+export const CHAR_MOTION_KEYS = new Set<string>(['f', 'F', 't', 'T']);
+
+// Escape sequences
+export const ESC_LEFT = '\x1b[D';
+export const ESC_RIGHT = '\x1b[C';
+export const CTRL_A = '\x01'; // line start
+export const CTRL_E = '\x05'; // line end
+export const CTRL_K = '\x0b'; // kill to end of line
+export const CTRL_R = '\x12'; // ctrl+r — readline redo trigger in vim layer
+export const CTRL_UNDERSCORE = '\x1f'; // ctrl+_ — readline undo
+export const CTRL_V = '\x16'; // ctrl+v — native clipboard paste (app.clipboard.pasteImage)
+export const NEWLINE = '\n'; // newline character
+export const ESC_UP = '\x1b[A'; // cursor up
+export const ESC_DOWN = '\x1b[B'; // cursor down

package/packages/pi-vim-top-border/visual.ts

@@ -0,0 +1,65 @@
+/**
+ * Visual-mode selection geometry.
+ *
+ * A visual selection is an anchor (where `v`/`V` was pressed) plus the live
+ * cursor. Both ends are inclusive, so the grapheme under the later end belongs
+ * to the selection. Character-wise selections span an absolute text range;
+ * line-wise selections span whole lines and ignore the columns.
+ */
+
+import { getLineGraphemes } from './motions.js';
+import type { Mode } from './types.js';
+
+export type VisualMode = 'visual' | 'visual-line';
+export type VisualPosition = { line: number; col: number };
+
+export function isVisualMode(mode: Mode): mode is VisualMode {
+  return mode === 'visual' || mode === 'visual-line';
+}
+
+/** Negative when `a` precedes `b` in buffer order, positive when it follows. */
+export function compareVisualPositions(a: VisualPosition, b: VisualPosition): number {
+  return a.line !== b.line ? a.line - b.line : a.col - b.col;
+}
+
+/** The two endpoints in buffer order, regardless of which one is the anchor. */
+export function orderVisualEndpoints(
+  anchor: VisualPosition,
+  cursor: VisualPosition,
+): { start: VisualPosition; end: VisualPosition } {
+  return compareVisualPositions(anchor, cursor) <= 0
+    ? { start: anchor, end: cursor }
+    : { start: cursor, end: anchor };
+}
+
+/** Whole lines covered by a line-wise selection. */
+export function getVisualLineRange(
+  anchor: VisualPosition,
+  cursor: VisualPosition,
+): { startLine: number; endLine: number } {
+  return {
+    startLine: Math.min(anchor.line, cursor.line),
+    endLine: Math.max(anchor.line, cursor.line),
+  };
+}
+
+/**
+ * Exclusive end column for an inclusive selection end sitting at `col`.
+ * Grapheme-aware, so a selection ending on an emoji takes the whole cluster.
+ * A column at or past the end of the line yields the line length.
+ */
+export function getInclusiveEndColumn(line: string, col: number): number {
+  if (col >= line.length) return line.length;
+  const segment = getLineGraphemes(line).find((s) => col < s.end);
+  return segment ? segment.end : line.length;
+}
+
+/** Keep a stale anchor inside the buffer after the text changed underneath it. */
+export function clampVisualPosition(
+  position: VisualPosition,
+  lines: string[],
+): VisualPosition {
+  const line = Math.max(0, Math.min(position.line, lines.length - 1));
+  const col = Math.max(0, Math.min(position.col, (lines[line] ?? '').length));
+  return { line, col };
+}

package/packages/pi-vim-top-border/word-boundary-cache.ts

@@ -0,0 +1,196 @@
+/**
+ * Line-local cache for Vim word motion boundaries.
+ *
+ * Keyed by semantic class + exact line content to avoid stale boundary reuse.
+ */
+
+import type { WordMotionClass } from './motions.js';
+
+export type WordMotionDirection = 'forward' | 'backward';
+export type WordMotionTarget = 'start' | 'end';
+
+enum CharType {
+  Space = 0,
+  Word = 1,
+  Other = 2,
+}
+
+export interface WordBoundaryData {
+  readonly length: number;
+  readonly charTypes: Uint8Array;
+  readonly runStartByIndex: Int32Array;
+  readonly runEndByIndex: Int32Array;
+  readonly nextNonSpaceAtOrAfter: Int32Array;
+  readonly prevNonSpaceAtOrBefore: Int32Array;
+}
+
+function getCharType(
+  ch: string | undefined,
+  semanticClass: WordMotionClass = 'word',
+): CharType {
+  if (!ch || /\s/.test(ch)) return CharType.Space;
+  if (semanticClass === 'WORD') return CharType.Word;
+  if (/\w/.test(ch)) return CharType.Word;
+  return CharType.Other;
+}
+
+function buildWordBoundaryData(
+  line: string,
+  semanticClass: WordMotionClass = 'word',
+): WordBoundaryData {
+  const len = line.length;
+  const charTypes = new Uint8Array(len);
+  const runStartByIndex = new Int32Array(len);
+  const runEndByIndex = new Int32Array(len);
+  const nextNonSpaceAtOrAfter = new Int32Array(len + 1);
+  const prevNonSpaceAtOrBefore = new Int32Array(len);
+
+  nextNonSpaceAtOrAfter.fill(-1);
+  prevNonSpaceAtOrBefore.fill(-1);
+
+  for (let i = 0; i < len; i++) {
+    charTypes[i] = getCharType(line[i], semanticClass);
+  }
+
+  for (let runStart = 0; runStart < len; ) {
+    const runType = charTypes[runStart] ?? CharType.Space;
+    let runEnd = runStart;
+    while (runEnd + 1 < len && charTypes[runEnd + 1] === runType) {
+      runEnd++;
+    }
+
+    for (let i = runStart; i <= runEnd; i++) {
+      runStartByIndex[i] = runStart;
+      runEndByIndex[i] = runEnd;
+    }
+
+    runStart = runEnd + 1;
+  }
+
+  let nextNonSpace = -1;
+  for (let i = len - 1; i >= 0; i--) {
+    if (charTypes[i] !== CharType.Space) {
+      nextNonSpace = i;
+    }
+    nextNonSpaceAtOrAfter[i] = nextNonSpace;
+  }
+
+  let prevNonSpace = -1;
+  for (let i = 0; i < len; i++) {
+    if (charTypes[i] !== CharType.Space) {
+      prevNonSpace = i;
+    }
+    prevNonSpaceAtOrBefore[i] = prevNonSpace;
+  }
+
+  return {
+    length: len,
+    charTypes,
+    runStartByIndex,
+    runEndByIndex,
+    nextNonSpaceAtOrAfter,
+    prevNonSpaceAtOrBefore,
+  };
+}
+
+function findTargetInLine(
+  data: WordBoundaryData,
+  col: number,
+  direction: WordMotionDirection,
+  target: WordMotionTarget,
+): number {
+  const len = data.length;
+  if (len === 0) return 0;
+
+  let i = Math.max(0, Math.min(col, len));
+
+  if (direction === 'forward') {
+    if (i >= len) return len;
+
+    if (target === 'start') {
+      if (data.charTypes[i] !== CharType.Space) {
+        i = (data.runEndByIndex[i] ?? i) + 1;
+      }
+
+      if (i >= len) return len;
+
+      if (data.charTypes[i] === CharType.Space) {
+        const next = data.nextNonSpaceAtOrAfter[i] ?? -1;
+        return next === -1 ? len : next;
+      }
+
+      return i;
+    }
+
+    if (i < len - 1) i++;
+
+    if (i >= len) return len;
+
+    if (data.charTypes[i] === CharType.Space) {
+      const next = data.nextNonSpaceAtOrAfter[i] ?? -1;
+      if (next === -1) return len;
+      i = next;
+    }
+
+    return data.runEndByIndex[i] ?? i;
+  }
+
+  if (i >= len) i = len - 1;
+  if (i > 0) i--;
+
+  if (data.charTypes[i] === CharType.Space) {
+    const prev = data.prevNonSpaceAtOrBefore[i] ?? -1;
+    if (prev !== -1) i = prev;
+  }
+
+  return data.runStartByIndex[i] ?? i;
+}
+
+const DEFAULT_MAX_CACHE_ENTRIES = 256;
+
+export class WordBoundaryCache {
+  private readonly entries = new Map<string, WordBoundaryData>();
+  private readonly maxEntries: number;
+
+  constructor(maxEntries: number = DEFAULT_MAX_CACHE_ENTRIES) {
+    this.maxEntries =
+      Number.isInteger(maxEntries) && maxEntries > 0
+        ? maxEntries
+        : DEFAULT_MAX_CACHE_ENTRIES;
+  }
+
+  private makeCacheKey(line: string, semanticClass: WordMotionClass): string {
+    return `${semanticClass}\u0000${line}`;
+  }
+
+  get(line: string, semanticClass: WordMotionClass = 'word'): WordBoundaryData {
+    const key = this.makeCacheKey(line, semanticClass);
+    const cached = this.entries.get(key);
+    if (cached) return cached;
+
+    const built = buildWordBoundaryData(line, semanticClass);
+
+    if (this.entries.size >= this.maxEntries) {
+      const oldestKey = this.entries.keys().next().value;
+      if (oldestKey !== undefined) {
+        this.entries.delete(oldestKey);
+      }
+    }
+
+    this.entries.set(key, built);
+    return built;
+  }
+
+  tryFindTarget(
+    line: string,
+    col: number,
+    direction: WordMotionDirection,
+    target: WordMotionTarget,
+    semanticClass: WordMotionClass = 'word',
+  ): number | null {
+    if (!Number.isInteger(col) || col < 0) return null;
+
+    const boundaries = this.get(line, semanticClass);
+    return findTargetInLine(boundaries, col, direction, target);
+  }
+}