@svelterm/core 0.1.0

package/dist/src/input/hit.js

@@ -0,0 +1,29 @@
+export function hitTest(root, layout, col, row) {
+    return hitTestNode(root, layout, col, row, 0, 0);
+}
+function hitTestNode(node, layout, col, row, scrollX, scrollY) {
+    if (node.nodeType !== 'element')
+        return null;
+    const box = layout.get(node.id);
+    if (!box)
+        return null;
+    // Apply accumulated scroll offset to convert screen coords to layout coords
+    const layoutCol = col + scrollX;
+    const layoutRow = row + scrollY;
+    if (!isInBox(layoutCol, layoutRow, box))
+        return null;
+    // Accumulate this node's scroll offset for children
+    const childScrollX = scrollX + node.scrollLeft;
+    const childScrollY = scrollY + node.scrollTop;
+    // Check children deepest-first (last child = highest z)
+    for (let i = node.children.length - 1; i >= 0; i--) {
+        const hit = hitTestNode(node.children[i], layout, col, row, childScrollX, childScrollY);
+        if (hit)
+            return hit;
+    }
+    return node;
+}
+function isInBox(col, row, box) {
+    return col >= box.x && col < box.x + box.width
+        && row >= box.y && row < box.y + box.height;
+}

package/dist/src/input/keyboard.d.ts

@@ -0,0 +1,9 @@
+export interface KeyEvent {
+    key: string;
+    ctrl: boolean;
+    shift: boolean;
+    meta: boolean;
+}
+/** Check if data contains a bracketed paste sequence. Returns the pasted text or null. */
+export declare function parsePaste(data: Buffer): string | null;
+export declare function parseKeyEvent(data: Buffer): KeyEvent | null;

package/dist/src/input/keyboard.js

@@ -0,0 +1,100 @@
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+/** Check if data contains a bracketed paste sequence. Returns the pasted text or null. */
+export function parsePaste(data) {
+    const str = data.toString();
+    if (str.startsWith(PASTE_START)) {
+        const endIdx = str.indexOf(PASTE_END);
+        if (endIdx !== -1) {
+            return str.substring(PASTE_START.length, endIdx);
+        }
+        // Paste without end marker — take everything after start
+        return str.substring(PASTE_START.length);
+    }
+    return null;
+}
+export function parseKeyEvent(data) {
+    if (data.length === 0)
+        return null;
+    const byte = data[0];
+    // Ctrl+key (0x01-0x1a, except Tab/Enter/Escape)
+    if (byte >= 0x01 && byte <= 0x1a) {
+        if (byte === 0x09)
+            return { key: 'Tab', ctrl: false, shift: false, meta: false };
+        if (byte === 0x0d)
+            return { key: 'Enter', ctrl: false, shift: false, meta: false };
+        if (byte === 0x1b)
+            return parseEscapeSequence(data);
+        const letter = String.fromCharCode(byte + 0x60); // 0x01 -> 'a'
+        return { key: letter, ctrl: true, shift: false, meta: false };
+    }
+    // Backspace
+    if (byte === 0x7f)
+        return { key: 'Backspace', ctrl: false, shift: false, meta: false };
+    // Escape sequence
+    if (byte === 0x1b)
+        return parseEscapeSequence(data);
+    // Regular printable character
+    if (byte >= 0x20 && byte <= 0x7e) {
+        return { key: String.fromCharCode(byte), ctrl: false, shift: false, meta: false };
+    }
+    return null;
+}
+function parseEscapeSequence(data) {
+    // Bare escape
+    if (data.length === 1) {
+        return { key: 'Escape', ctrl: false, shift: false, meta: false };
+    }
+    // CSI sequences: ESC [
+    if (data[1] === 0x5b) {
+        return parseCSI(data);
+    }
+    return { key: 'Escape', ctrl: false, shift: false, meta: false };
+}
+function parseCSI(data) {
+    const base = { ctrl: false, shift: false, meta: false };
+    if (data.length < 3)
+        return { key: 'Escape', ...base };
+    const third = data[2];
+    // Arrow keys: ESC [ A/B/C/D
+    switch (third) {
+        case 0x41: return { key: 'ArrowUp', ...base };
+        case 0x42: return { key: 'ArrowDown', ...base };
+        case 0x43: return { key: 'ArrowRight', ...base };
+        case 0x44: return { key: 'ArrowLeft', ...base };
+        case 0x48: return { key: 'Home', ...base };
+        case 0x46: return { key: 'End', ...base };
+        case 0x5a: return { key: 'Tab', ctrl: false, shift: true, meta: false }; // Shift+Tab (Back Tab)
+    }
+    // Extended keys: ESC [ N ~
+    if (data.length >= 4 && data[3] === 0x7e) {
+        switch (third) {
+            case 0x32: return { key: 'Insert', ...base };
+            case 0x33: return { key: 'Delete', ...base };
+            case 0x35: return { key: 'PageUp', ...base };
+            case 0x36: return { key: 'PageDown', ...base };
+        }
+    }
+    // Modified keys: ESC [ 1 ; modifier X (e.g. Shift+Arrow)
+    if (data.length >= 6 && third === 0x31 && data[3] === 0x3b) {
+        const modifier = data[4] - 0x30;
+        const keyCode = data[5];
+        const mods = parseModifier(modifier);
+        const keyName = CSI_KEYS[keyCode];
+        if (keyName)
+            return { key: keyName, ...mods };
+    }
+    return { key: 'Escape', ...base };
+}
+const CSI_KEYS = {
+    0x41: 'ArrowUp', 0x42: 'ArrowDown', 0x43: 'ArrowRight', 0x44: 'ArrowLeft',
+    0x48: 'Home', 0x46: 'End',
+};
+function parseModifier(mod) {
+    // CSI modifier values: 1=none, 2=Shift, 3=Alt, 4=Shift+Alt, 5=Ctrl, 6=Shift+Ctrl, 7=Alt+Ctrl, 8=Shift+Alt+Ctrl
+    return {
+        shift: (mod & 1) !== 0,
+        meta: (mod & 2) !== 0,
+        ctrl: (mod & 4) !== 0,
+    };
+}

package/dist/src/input/mouse.d.ts

@@ -0,0 +1,7 @@
+export interface MouseEvent {
+    button: 'left' | 'right' | 'middle' | 'scrollUp' | 'scrollDown' | 'none';
+    type: 'press' | 'release' | 'motion' | 'scroll';
+    col: number;
+    row: number;
+}
+export declare function parseMouseEvent(data: Buffer): MouseEvent | null;

package/dist/src/input/mouse.js

@@ -0,0 +1,35 @@
+const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/;
+export function parseMouseEvent(data) {
+    const str = data.toString();
+    const match = SGR_MOUSE_RE.exec(str);
+    if (!match)
+        return null;
+    const code = parseInt(match[1]);
+    const col = parseInt(match[2]) - 1;
+    const row = parseInt(match[3]) - 1;
+    // Strip modifier bits (shift=4, meta=8, ctrl=16)
+    const base = code & ~(4 | 8 | 16);
+    // Release
+    if (match[4] === 'm') {
+        return { button: pressButton(base & 3), type: 'release', col, row };
+    }
+    // Scroll: codes 64-67
+    if (base >= 64 && base <= 67) {
+        return { button: base === 64 ? 'scrollUp' : 'scrollDown', type: 'scroll', col, row };
+    }
+    // Motion: bit 5 (32)
+    if (base & 32) {
+        const held = base & ~32 & 3;
+        const button = held === 3 ? 'none' : pressButton(held);
+        return { button, type: 'motion', col, row };
+    }
+    // Press
+    return { button: pressButton(base & 3), type: 'press', col, row };
+}
+function pressButton(code) {
+    if (code === 1)
+        return 'middle';
+    if (code === 2)
+        return 'right';
+    return 'left';
+}

package/dist/src/input/scroll.d.ts

@@ -0,0 +1,2 @@
+import { TermNode } from '../renderer/node.js';
+export declare function applyScrollInput(node: TermNode, key: string, contentHeight: number, viewportHeight: number, contentWidth?: number, viewportWidth?: number): void;

package/dist/src/input/scroll.js

@@ -0,0 +1,24 @@
+export function applyScrollInput(node, key, contentHeight, viewportHeight, contentWidth, viewportWidth) {
+    const maxScrollY = Math.max(0, contentHeight - viewportHeight);
+    const maxScrollX = Math.max(0, (contentWidth ?? 0) - (viewportWidth ?? 0));
+    switch (key) {
+        case 'ArrowDown':
+            node.scrollTop = Math.min(node.scrollTop + 1, maxScrollY);
+            break;
+        case 'ArrowUp':
+            node.scrollTop = Math.max(node.scrollTop - 1, 0);
+            break;
+        case 'ArrowRight':
+            node.scrollLeft = Math.min(node.scrollLeft + 1, maxScrollX);
+            break;
+        case 'ArrowLeft':
+            node.scrollLeft = Math.max(node.scrollLeft - 1, 0);
+            break;
+        case 'PageDown':
+            node.scrollTop = Math.min(node.scrollTop + viewportHeight, maxScrollY);
+            break;
+        case 'PageUp':
+            node.scrollTop = Math.max(node.scrollTop - viewportHeight, 0);
+            break;
+    }
+}

package/dist/src/layout/cache.d.ts

@@ -0,0 +1,4 @@
+import { TermNode } from '../renderer/node.js';
+import type { LayoutBox } from './engine.js';
+/** Sync layout boxes from the computed map into each node's cache. */
+export declare function syncLayoutCache(node: TermNode, layout: Map<number, LayoutBox>): void;

package/dist/src/layout/cache.js

@@ -0,0 +1,8 @@
+/** Sync layout boxes from the computed map into each node's cache. */
+export function syncLayoutCache(node, layout) {
+    const box = layout.get(node.id);
+    node.cache.layoutBox = box ?? null;
+    for (const child of node.children) {
+        syncLayoutCache(child, layout);
+    }
+}

package/dist/src/layout/engine.d.ts

@@ -0,0 +1,9 @@
+import { TermNode } from '../renderer/node.js';
+import { ResolvedStyle } from '../css/compute.js';
+export interface LayoutBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function computeLayout(root: TermNode, styles: Map<number, ResolvedStyle>, availWidth: number, availHeight: number): Map<number, LayoutBox>;