voonex 0.1.0

package/dist/core/Cursor.js

@@ -0,0 +1,59 @@
+"use strict";
+// ==========================================
+// CORE: CURSOR MANAGEMENT
+// ==========================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cursor = void 0;
+const readline = __importStar(require("readline"));
+class Cursor {
+    static hide() {
+        process.stdout.write('\x1b[?25l');
+    }
+    static show() {
+        process.stdout.write('\x1b[?25h');
+    }
+    static moveTo(x, y) {
+        readline.cursorTo(process.stdout, x, y);
+    }
+    static clearLine() {
+        readline.clearLine(process.stdout, 0);
+    }
+    static clearScreen() {
+        readline.cursorTo(process.stdout, 0, 0);
+        readline.clearScreenDown(process.stdout);
+    }
+}
+exports.Cursor = Cursor;

package/dist/core/Events.d.ts

@@ -0,0 +1,11 @@
+export type EventHandler = (data?: any) => void;
+export declare class EventManager {
+    private static instance;
+    private listeners;
+    private constructor();
+    static getInstance(): EventManager;
+    on(event: string, handler: EventHandler): void;
+    off(event: string, handler: EventHandler): void;
+    emit(event: string, data?: any): void;
+}
+export declare const Events: EventManager;

package/dist/core/Events.js

@@ -0,0 +1,37 @@
+"use strict";
+// ==========================================
+// CORE: EVENT MANAGER
+// ==========================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = exports.EventManager = void 0;
+class EventManager {
+    constructor() {
+        this.listeners = new Map();
+    }
+    static getInstance() {
+        if (!EventManager.instance) {
+            EventManager.instance = new EventManager();
+        }
+        return EventManager.instance;
+    }
+    on(event, handler) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, []);
+        }
+        this.listeners.get(event).push(handler);
+    }
+    off(event, handler) {
+        if (!this.listeners.has(event))
+            return;
+        const handlers = this.listeners.get(event);
+        this.listeners.set(event, handlers.filter(h => h !== handler));
+    }
+    emit(event, data) {
+        if (!this.listeners.has(event))
+            return;
+        this.listeners.get(event).forEach(handler => handler(data));
+    }
+}
+exports.EventManager = EventManager;
+// Global accessor
+exports.Events = EventManager.getInstance();

package/dist/core/Focus.d.ts

@@ -0,0 +1,16 @@
+import * as readline from 'readline';
+export interface Focusable {
+    id: string;
+    parent?: Focusable;
+    focus(): void;
+    blur(): void;
+    handleKey(key: readline.Key): boolean | void;
+    render(): void;
+}
+export declare class FocusManager {
+    private components;
+    private activeIndex;
+    register(component: Focusable): void;
+    handleKey(key: readline.Key): void;
+    private cycleFocus;
+}

package/dist/core/Focus.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FocusManager = void 0;
+class FocusManager {
+    constructor() {
+        this.components = [];
+        this.activeIndex = 0;
+    }
+    register(component) {
+        this.components.push(component);
+        if (this.components.length === 1) {
+            component.focus();
+            this.activeIndex = 0;
+        }
+    }
+    handleKey(key) {
+        if (this.components.length === 0)
+            return;
+        // === COMPONENT LOGIC ===
+        // Event Bubbling: Child -> Parent -> Root
+        let target = this.components[this.activeIndex];
+        let consumed = false;
+        while (target) {
+            const result = target.handleKey(key);
+            if (result === true) {
+                consumed = true;
+                break;
+            }
+            target = target.parent;
+        }
+        if (consumed) {
+            return;
+        }
+        // === NAVIGATION LOGIC ===
+        // Next: Tab
+        if (key.name === 'tab' && !key.shift) {
+            this.cycleFocus(false);
+            return;
+        }
+        // Fallback: Down/Right for next (if not consumed by component)
+        if (key.name === 'down' || key.name === 'right') {
+            this.cycleFocus(false);
+            return;
+        }
+        // Previous: Shift+Tab
+        if (key.name === 'tab' && key.shift) {
+            this.cycleFocus(true);
+            return;
+        }
+        // Fallback: Up/Left for previous (if not consumed by component)
+        if (key.name === 'up' || key.name === 'left') {
+            this.cycleFocus(true);
+            return;
+        }
+    }
+    cycleFocus(reverse = false) {
+        this.components[this.activeIndex].blur();
+        this.components[this.activeIndex].render();
+        if (reverse) {
+            this.activeIndex = (this.activeIndex - 1 + this.components.length) % this.components.length;
+        }
+        else {
+            this.activeIndex = (this.activeIndex + 1) % this.components.length;
+        }
+        this.components[this.activeIndex].focus();
+        this.components[this.activeIndex].render();
+    }
+}
+exports.FocusManager = FocusManager;

package/dist/core/Input.d.ts

@@ -0,0 +1,13 @@
+import * as readline from 'readline';
+export type KeyHandler = (key: readline.Key) => boolean | void;
+export declare class Input {
+    private static listeners;
+    private static initialized;
+    static init(): void;
+    static onKey(handler: KeyHandler): void;
+    static offKey(handler: KeyHandler): void;
+    /**
+     * Stops listening and restores stdin.
+     */
+    static reset(): void;
+}

package/dist/core/Input.js

@@ -0,0 +1,88 @@
+"use strict";
+// ==========================================
+// CORE: INPUT MANAGER (The "Controller")
+// ==========================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Input = void 0;
+const readline = __importStar(require("readline"));
+const Screen_1 = require("./Screen");
+class Input {
+    static init() {
+        if (this.initialized)
+            return;
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.on('keypress', (str, key) => {
+            // Handle Ctrl+C globally to prevent trapping the user
+            if (key.ctrl && key.name === 'c') {
+                Screen_1.Screen.leave(); // Restore terminal state
+                process.exit();
+            }
+            // Iterate backwards so newest listeners (e.g. Popups) get first dibs
+            for (let i = this.listeners.length - 1; i >= 0; i--) {
+                const consumed = this.listeners[i](key);
+                if (consumed === true)
+                    break;
+            }
+            // Trigger a render check after input handling
+            Screen_1.Screen.scheduleRender();
+        });
+        this.initialized = true;
+    }
+    static onKey(handler) {
+        this.init();
+        this.listeners.push(handler);
+    }
+    static offKey(handler) {
+        this.listeners = this.listeners.filter(l => l !== handler);
+    }
+    /**
+     * Stops listening and restores stdin.
+     */
+    static reset() {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        this.listeners = [];
+        this.initialized = false;
+    }
+}
+exports.Input = Input;
+Input.listeners = [];
+Input.initialized = false;

package/dist/core/Layout.d.ts

@@ -0,0 +1,18 @@
+import { Rect } from './Screen';
+export { Rect };
+export declare class Layout {
+    /**
+     * Splits a rectangle vertically (into columns).
+     * @param parent The parent rectangle
+     * @param weights Array of weights (e.g. [1, 2] means 1/3 and 2/3) or absolute sizes
+     */
+    static splitVertical(parent: Rect, weights: number[]): Rect[];
+    /**
+     * Splits a rectangle horizontally (into rows).
+     */
+    static splitHorizontal(parent: Rect, weights: number[]): Rect[];
+    /**
+     * Creates a padded inner rectangle.
+     */
+    static pad(rect: Rect, padding: number): Rect;
+}

package/dist/core/Layout.js

@@ -0,0 +1,65 @@
+"use strict";
+// ==========================================
+// CORE: LAYOUT ENGINE (The "Architect")
+// ==========================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layout = void 0;
+class Layout {
+    /**
+     * Splits a rectangle vertically (into columns).
+     * @param parent The parent rectangle
+     * @param weights Array of weights (e.g. [1, 2] means 1/3 and 2/3) or absolute sizes
+     */
+    static splitVertical(parent, weights) {
+        const totalWeight = weights.reduce((a, b) => a + b, 0);
+        let currentX = parent.x;
+        return weights.map((w, i) => {
+            // Check if it's the last item to fill remaining space (avoid rounding errors)
+            const isLast = i === weights.length - 1;
+            const width = isLast
+                ? parent.width - (currentX - parent.x)
+                : Math.floor((w / totalWeight) * parent.width);
+            const rect = {
+                x: currentX,
+                y: parent.y,
+                width: width,
+                height: parent.height
+            };
+            currentX += width;
+            return rect;
+        });
+    }
+    /**
+     * Splits a rectangle horizontally (into rows).
+     */
+    static splitHorizontal(parent, weights) {
+        const totalWeight = weights.reduce((a, b) => a + b, 0);
+        let currentY = parent.y;
+        return weights.map((w, i) => {
+            const isLast = i === weights.length - 1;
+            const height = isLast
+                ? parent.height - (currentY - parent.y)
+                : Math.floor((w / totalWeight) * parent.height);
+            const rect = {
+                x: parent.x,
+                y: currentY,
+                width: parent.width,
+                height: height
+            };
+            currentY += height;
+            return rect;
+        });
+    }
+    /**
+     * Creates a padded inner rectangle.
+     */
+    static pad(rect, padding) {
+        return {
+            x: rect.x + padding,
+            y: rect.y + padding,
+            width: Math.max(0, rect.width - (padding * 2)),
+            height: Math.max(0, rect.height - (padding * 2))
+        };
+    }
+}
+exports.Layout = Layout;

package/dist/core/Screen.d.ts

@@ -0,0 +1,78 @@
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class Screen {
+    private static isAlternateBuffer;
+    private static resizeTimeout;
+    private static currentBuffer;
+    private static previousBuffer;
+    private static dirtyRows;
+    private static layerStack;
+    private static isDirty;
+    private static renderScheduled;
+    private static width;
+    private static height;
+    private static renderRoots;
+    /**
+     * Enters the Alternate Screen Buffer (like Vim or Nano).
+     */
+    static enter(): void;
+    /**
+     * Leaves the Alternate Screen Buffer and restores cursor.
+     */
+    static leave(): void;
+    private static resizeBuffers;
+    /**
+     * Schedules a render flush in the next tick.
+     * Call this whenever a component changes state.
+     */
+    static scheduleRender(): void;
+    /**
+     * Writes text at a specific coordinate into the virtual buffer.
+     * Handles ANSI escape codes using a state machine parser.
+     * Supports clipping region and relative positioning.
+     */
+    static write(x: number, y: number, text: string, clipRect?: Rect): void;
+    /**
+     * Pushes the current screen state to a stack.
+     */
+    static pushLayer(): void;
+    /**
+     * Restores the screen state from the stack.
+     */
+    static popLayer(): void;
+    /**
+     * Clears the virtual buffer.
+     */
+    static clear(): void;
+    /**
+     * Registers a root component for the rendering loop (Painter's Algorithm).
+     * @param renderFn The function that renders the component
+     * @param zIndex Priority (higher draws on top)
+     */
+    static mount(renderFn: () => void, zIndex?: number): void;
+    /**
+     * Unregisters a root component from the rendering loop.
+     * @param renderFn The function that renders the component
+     */
+    static unmount(renderFn: () => void): void;
+    /**
+     * Diffs currentBuffer vs previousBuffer and writes changes to stdout.
+     * Optimized with String Batching and Relative Cursor Moves.
+     */
+    static flush(): void;
+    /**
+     * Gets current terminal dimensions.
+     */
+    static get size(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Listens for resize events.
+     */
+    static onResize(callback: () => void): void;
+}