@buntui/extensions 0.0.0

package/dist/widgets/matrix/matrix-column.js

@@ -0,0 +1,58 @@
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomChar(charset) {
+    return charset[Math.floor(Math.random() * charset.length)];
+}
+export function createColumn(config) {
+    const { maxTrail, speedRange, minTrail, charset, tickIntervalRange } = config;
+    const speed = randomInt(speedRange.min, speedRange.max);
+    const trailLength = randomInt(minTrail, maxTrail);
+    const tickInterval = randomInt(tickIntervalRange.min, tickIntervalRange.max);
+    return {
+        headY: randomInt(-maxTrail, 0),
+        trailLength,
+        speed,
+        active: true,
+        cooldown: 0,
+        chars: Array.from({ length: trailLength }, () => randomChar(charset)),
+        accumulator: randomInt(0, tickInterval),
+        tickInterval,
+    };
+}
+export function tickColumn(col, dt, density, config) {
+    const { charset } = config;
+    if (!col.active) {
+        col.cooldown--;
+        if (col.cooldown <= 0) {
+            if (Math.random() < density) {
+                const restarted = createColumn(config);
+                col.headY = restarted.headY;
+                col.trailLength = restarted.trailLength;
+                col.speed = restarted.speed;
+                col.active = true;
+                col.chars = restarted.chars;
+                col.accumulator = restarted.accumulator;
+                col.tickInterval = restarted.tickInterval;
+            }
+            else {
+                col.cooldown = randomInt(1, 10);
+            }
+        }
+        return;
+    }
+    col.accumulator += dt;
+    if (col.accumulator < col.tickInterval) {
+        return;
+    }
+    col.accumulator -= col.tickInterval;
+    for (let i = 0; i < col.speed; i++) {
+        col.chars.unshift(randomChar(charset));
+    }
+    col.chars.length = col.trailLength;
+    col.headY += col.speed;
+    if (col.headY - col.trailLength > config.maxY) {
+        col.active = false;
+        col.cooldown = randomInt(1, 30);
+    }
+}

package/dist/widgets/matrix/types.d.ts

@@ -0,0 +1,38 @@
+import type { TuiSizeValue } from '@buntui/core';
+export type MatrixColorScheme = {
+    /** RGBA color for the bright lead character (default: bright green) */
+    leadRgba: number;
+    /** RGBA color for the trail characters (default: medium green) */
+    trailRgba: number;
+    /** RGBA background behind everything (default: opaque black) */
+    bgRgba: number;
+};
+export type MatrixSpeedRange = {
+    /** Minimum column speed in cells-per-frame */
+    min: number;
+    /** Maximum column speed in cells-per-frame */
+    max: number;
+};
+export type MatrixWidgetOptions = {
+    x?: TuiSizeValue;
+    y?: TuiSizeValue;
+    width?: TuiSizeValue;
+    height?: TuiSizeValue;
+    /** Color scheme overrides. Partially applied over defaults. */
+    colorScheme?: Partial<MatrixColorScheme>;
+    /** Speed range for column falls (default: {min:1, max:3}) */
+    speedRange?: MatrixSpeedRange;
+    /** Minimum trail length (default: 5) */
+    minTrailLength?: number;
+    /** Maximum trail length (default: 20) */
+    maxTrailLength?: number;
+    /** Character density: 0.0-1.0 fraction of active columns (default: 0.8) */
+    density?: number;
+    /** Custom character set. Array of code points. Overrides built-in sets. */
+    charset?: number[];
+    /** Per-column tick interval range in ms. Lower = faster. (default: {min:60, max:150}) */
+    tickIntervalRange?: {
+        min: number;
+        max: number;
+    };
+};

package/dist/widgets/snake/SnakeWidget.d.ts

@@ -0,0 +1,14 @@
+import { type DrawListBuffer, type TuiWidgetRect, type KeyboardEvent, widgets } from '@buntui/core';
+import type { SnakeWidgetOptions } from './types';
+export declare class SnakeWidget extends widgets.InteractiveWidget {
+    #private;
+    constructor(options?: SnakeWidgetOptions);
+    updateRect(rect: Partial<TuiWidgetRect>): void;
+    containsPoint(x: number, y: number): boolean;
+    get rect(): TuiWidgetRect;
+    handleKey(event: KeyboardEvent): void;
+    update(dt: number): void;
+    emitDrawCommands(buffer: DrawListBuffer): void;
+}
+export declare function createSnakeWidget(options?: SnakeWidgetOptions): SnakeWidget;
+export default SnakeWidget;

package/dist/widgets/snake/SnakeWidget.js

@@ -0,0 +1,384 @@
+import { rgbToRgba, widgets, } from '@buntui/core';
+import { DEFAULT_SNAKE_COLOR_SCHEME, DEFAULT_SNAKE_OPTIONS } from './defaults';
+const CHAR_HEAD = 0x00_40; // '@'
+const CHAR_BODY = 0x25_88; // '█'
+const CHAR_FOOD = 0x26_05; // '★'
+const MIN_TICK_INTERVAL = 50;
+const OPPOSITE = {
+    up: 'down',
+    down: 'up',
+    left: 'right',
+    right: 'left',
+};
+export class SnakeWidget extends widgets.InteractiveWidget {
+    #x;
+    #y;
+    #width;
+    #height;
+    #colorScheme;
+    #tickInterval;
+    #initialSpeed;
+    #speedIncrement;
+    #accumulator = 0;
+    #state = 'idle';
+    #direction = 'right';
+    #nextDirection = 'right';
+    #snake = [];
+    #food = { x: 0, y: 0 };
+    #score = 0;
+    #highScore = 0;
+    #initialized = false;
+    constructor(options = {}) {
+        super();
+        const resolved = { ...DEFAULT_SNAKE_OPTIONS, ...options };
+        const rect = this.initRect(resolved.x, resolved.y, resolved.width, resolved.height);
+        this.#x = rect.x;
+        this.#y = rect.y;
+        this.#width = rect.width;
+        this.#height = rect.height;
+        const schemeOverride = resolved.colorScheme ?? {};
+        this.#colorScheme = {
+            headRgba: schemeOverride.headRgba ?? DEFAULT_SNAKE_COLOR_SCHEME.headRgba,
+            bodyRgba: schemeOverride.bodyRgba ?? DEFAULT_SNAKE_COLOR_SCHEME.bodyRgba,
+            foodRgba: schemeOverride.foodRgba ?? DEFAULT_SNAKE_COLOR_SCHEME.foodRgba,
+            borderRgba: schemeOverride.borderRgba ?? DEFAULT_SNAKE_COLOR_SCHEME.borderRgba,
+            bgRgba: schemeOverride.bgRgba ?? DEFAULT_SNAKE_COLOR_SCHEME.bgRgba,
+            textRgba: schemeOverride.textRgba ?? DEFAULT_SNAKE_COLOR_SCHEME.textRgba,
+            scoreTextRgba: schemeOverride.scoreTextRgba ?? DEFAULT_SNAKE_COLOR_SCHEME.scoreTextRgba,
+        };
+        this.#tickInterval = resolved.tickInterval ?? 150;
+        this.#initialSpeed = this.#tickInterval;
+        this.#speedIncrement = resolved.speedIncrement ?? 5;
+    }
+    updateRect(rect) {
+        if (rect.x !== undefined) {
+            this.#x = rect.x;
+        }
+        if (rect.y !== undefined) {
+            this.#y = rect.y;
+        }
+        if (rect.width !== undefined) {
+            this.#width = rect.width;
+        }
+        if (rect.height !== undefined) {
+            this.#height = rect.height;
+        }
+    }
+    containsPoint(x, y) {
+        return x >= this.#x
+            && x < this.#x + this.#width
+            && y >= this.#y
+            && y < this.#y + this.#height;
+    }
+    get rect() {
+        return {
+            x: this.#x, y: this.#y, width: this.#width, height: this.#height,
+        };
+    }
+    handleKey(event) {
+        const { key } = event;
+        if (!key) {
+            return;
+        }
+        if (this.#state === 'idle') {
+            if (key === ' ') {
+                this.#startGame();
+            }
+            return;
+        }
+        if (this.#state === 'playing') {
+            if (key === 'Escape') {
+                this.#resetToIdle();
+                return;
+            }
+            this.#handleDirection(key);
+            return;
+        }
+        // Gameover
+        if (key === ' ') {
+            this.#startGame();
+        }
+        else if (key === 'Escape') {
+            this.#resetToIdle();
+        }
+    }
+    update(dt) {
+        if (this.#state !== 'playing') {
+            return;
+        }
+        this.#accumulator += dt;
+        if (this.#accumulator >= this.#tickInterval) {
+            this.#accumulator -= this.#tickInterval;
+            this.#direction = this.#nextDirection;
+            this.#tick(this.#width - 2, this.#height - 2);
+        }
+    }
+    emitDrawCommands(buffer) {
+        const w = this.#width;
+        const h = this.#height;
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        const gridW = w - 2;
+        const gridH = h - 2;
+        if (gridW < 2 || gridH < 2) {
+            buffer.pushClip(this.#x, this.#y, w, h);
+            buffer.drawText({
+                x: this.#x,
+                y: this.#y,
+                text: 'Too small',
+                fgRgba: this.#colorScheme.textRgba,
+                bgRgba: this.#colorScheme.bgRgba,
+            });
+            buffer.popClip();
+            return;
+        }
+        this.#ensureInitialized(gridW, gridH);
+        const absX = this.#x;
+        const absY = this.#y;
+        buffer.pushClip(absX, absY, w, h);
+        // Background
+        buffer.drawRect({
+            x: absX, y: absY, width: w, height: h, bgRgba: this.#colorScheme.bgRgba,
+        });
+        // Border
+        buffer.drawBorder({
+            x: absX,
+            y: absY,
+            width: w,
+            height: h,
+            colorRgba: this.#colorScheme.borderRgba,
+            style: 1,
+            sides: 0b1111,
+        });
+        // Snake body (tail to head so head draws on top)
+        const { bgRgba } = this.#colorScheme;
+        for (let i = this.#snake.length - 1; i >= 0; i--) {
+            const seg = this.#snake[i];
+            const isHead = i === 0;
+            buffer.drawChar({
+                x: absX + 1 + seg.x,
+                y: absY + 1 + seg.y,
+                char: isHead ? CHAR_HEAD : CHAR_BODY,
+                fgRgba: isHead ? this.#colorScheme.headRgba : this.#colorScheme.bodyRgba,
+                bgRgba,
+            });
+        }
+        // Food
+        if (this.#state !== 'idle') {
+            buffer.drawChar({
+                x: absX + 1 + this.#food.x,
+                y: absY + 1 + this.#food.y,
+                char: CHAR_FOOD,
+                fgRgba: this.#colorScheme.foodRgba,
+                bgRgba,
+            });
+        }
+        // Score (on top border row)
+        const scoreText = ` Score: ${this.#score} `;
+        buffer.drawText({
+            x: absX + 1,
+            y: absY,
+            text: scoreText,
+            fgRgba: this.#colorScheme.scoreTextRgba,
+            bgRgba: this.#colorScheme.borderRgba,
+        });
+        // High score
+        if (this.#highScore > 0) {
+            const hiText = `Hi: ${this.#highScore} `;
+            const hiX = absX + w - 1 - hiText.length;
+            if (hiX > absX + scoreText.length) {
+                buffer.drawText({
+                    x: hiX,
+                    y: absY,
+                    text: hiText,
+                    fgRgba: this.#colorScheme.textRgba,
+                    bgRgba: this.#colorScheme.borderRgba,
+                });
+            }
+        }
+        // State messages
+        const midY = absY + 1 + Math.floor(gridH / 2);
+        if (this.#state === 'idle') {
+            const message = 'Press SPACE to start';
+            buffer.drawText({
+                x: absX + 1 + Math.floor((gridW - message.length) / 2),
+                y: midY,
+                text: message,
+                fgRgba: this.#colorScheme.textRgba,
+                bgRgba,
+            });
+            const hint = 'Arrow keys to move';
+            buffer.drawText({
+                x: absX + 1 + Math.floor((gridW - hint.length) / 2),
+                y: midY + 1,
+                text: hint,
+                fgRgba: rgbToRgba(0x88, 0x88, 0x88),
+                bgRgba,
+            });
+        }
+        else if (this.#state === 'gameover') {
+            const message = 'GAME OVER';
+            buffer.drawText({
+                x: absX + 1 + Math.floor((gridW - message.length) / 2),
+                y: midY - 1,
+                text: message,
+                fgRgba: rgbToRgba(0xFF, 0x00, 0x00),
+                bgRgba,
+            });
+            const scoreMessage = `Final Score: ${this.#score}`;
+            buffer.drawText({
+                x: absX + 1 + Math.floor((gridW - scoreMessage.length) / 2),
+                y: midY,
+                text: scoreMessage,
+                fgRgba: this.#colorScheme.scoreTextRgba,
+                bgRgba,
+            });
+            const restart = 'SPACE to restart / ESC to menu';
+            buffer.drawText({
+                x: absX + 1 + Math.floor((gridW - restart.length) / 2),
+                y: midY + 1,
+                text: restart,
+                fgRgba: rgbToRgba(0x88, 0x88, 0x88),
+                bgRgba,
+            });
+        }
+        buffer.popClip();
+    }
+    #handleDirection(key) {
+        let dir;
+        switch (key) {
+            case 'ArrowUp': {
+                dir = 'up';
+                break;
+            }
+            case 'ArrowDown': {
+                dir = 'down';
+                break;
+            }
+            case 'ArrowLeft': {
+                dir = 'left';
+                break;
+            }
+            case 'ArrowRight': {
+                dir = 'right';
+                break;
+            }
+            default: {
+                return;
+            }
+        }
+        if (dir !== OPPOSITE[this.#direction]) {
+            this.#nextDirection = dir;
+        }
+    }
+    #ensureInitialized(gridW, gridH) {
+        if (this.#initialized) {
+            return;
+        }
+        this.#initialized = true;
+        const startX = Math.floor(gridW / 2);
+        const startY = Math.floor(gridH / 2);
+        this.#snake = [
+            { x: startX, y: startY },
+            { x: startX - 1, y: startY },
+            { x: startX - 2, y: startY },
+        ];
+        this.#spawnFood(gridW, gridH);
+    }
+    #startGame() {
+        const gridW = this.#width - 2;
+        const gridH = this.#height - 2;
+        const startX = Math.floor(gridW / 2);
+        const startY = Math.floor(gridH / 2);
+        this.#snake = [
+            { x: startX, y: startY },
+            { x: startX - 1, y: startY },
+            { x: startX - 2, y: startY },
+        ];
+        this.#direction = 'right';
+        this.#nextDirection = 'right';
+        this.#score = 0;
+        this.#tickInterval = this.#initialSpeed;
+        this.#state = 'playing';
+        this.#accumulator = 0;
+        this.#spawnFood(gridW, gridH);
+    }
+    #resetToIdle() {
+        this.#state = 'idle';
+        this.#score = 0;
+        this.#snake = [];
+        this.#initialized = false;
+    }
+    #tick(gridW, gridH) {
+        const head = this.#snake[0];
+        let newX = head.x;
+        let newY = head.y;
+        switch (this.#direction) {
+            case 'up': {
+                newY--;
+                break;
+            }
+            case 'down': {
+                newY++;
+                break;
+            }
+            case 'left': {
+                newX--;
+                break;
+            }
+            case 'right': {
+                newX++;
+                break;
+            }
+        }
+        // Wall collision
+        if (newX < 0 || newX >= gridW || newY < 0 || newY >= gridH) {
+            this.#endGame();
+            return;
+        }
+        // Self collision
+        for (const seg of this.#snake) {
+            if (seg.x === newX && seg.y === newY) {
+                this.#endGame();
+                return;
+            }
+        }
+        // Move
+        this.#snake.unshift({ x: newX, y: newY });
+        // Food check
+        if (newX === this.#food.x && newY === this.#food.y) {
+            this.#score++;
+            this.#tickInterval = Math.max(MIN_TICK_INTERVAL, this.#tickInterval - this.#speedIncrement);
+            this.#spawnFood(gridW, gridH);
+        }
+        else {
+            this.#snake.pop();
+        }
+    }
+    #endGame() {
+        this.#state = 'gameover';
+        if (this.#score > this.#highScore) {
+            this.#highScore = this.#score;
+        }
+    }
+    #spawnFood(gridW, gridH) {
+        const snakeSet = new Set(this.#snake.map(p => `${p.x},${p.y}`));
+        let attempts = 0;
+        while (attempts < 1000) {
+            const fx = Math.floor(Math.random() * gridW);
+            const fy = Math.floor(Math.random() * gridH);
+            if (!snakeSet.has(`${fx},${fy}`)) {
+                this.#food = { x: fx, y: fy };
+                return;
+            }
+            attempts++;
+        }
+        // Fallback: just pick any position
+        this.#food = { x: 0, y: 0 };
+    }
+}
+export function createSnakeWidget(options) {
+    return new SnakeWidget(options);
+}
+export default SnakeWidget;

package/dist/widgets/snake/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { SnakeColorScheme, SnakeWidgetOptions } from './types';
+export declare const DEFAULT_SNAKE_COLOR_SCHEME: SnakeColorScheme;
+export declare const DEFAULT_SNAKE_OPTIONS: SnakeWidgetOptions;

package/dist/widgets/snake/defaults.js

@@ -0,0 +1,19 @@
+import { rgbToRgba } from '@buntui/core';
+export const DEFAULT_SNAKE_COLOR_SCHEME = {
+    headRgba: rgbToRgba(0x00, 0xFF, 0x00),
+    bodyRgba: rgbToRgba(0x00, 0xAA, 0x00),
+    foodRgba: rgbToRgba(0xFF, 0x55, 0x00),
+    borderRgba: rgbToRgba(0x55, 0x55, 0x55),
+    bgRgba: rgbToRgba(0x00, 0x00, 0x00),
+    textRgba: rgbToRgba(0xFF, 0xFF, 0xFF),
+    scoreTextRgba: rgbToRgba(0xFF, 0xFF, 0x00),
+};
+export const DEFAULT_SNAKE_OPTIONS = {
+    x: 0,
+    y: 0,
+    width: '100%',
+    height: '100%',
+    colorScheme: DEFAULT_SNAKE_COLOR_SCHEME,
+    tickInterval: 150,
+    speedIncrement: 5,
+};

package/dist/widgets/snake/types.d.ts

@@ -0,0 +1,25 @@
+import type { TuiSizeValue } from '@buntui/core';
+export type SnakeDirection = 'up' | 'down' | 'left' | 'right';
+export type SnakeGameState = 'idle' | 'playing' | 'gameover';
+export type SnakePoint = {
+    readonly x: number;
+    readonly y: number;
+};
+export type SnakeColorScheme = {
+    headRgba: number;
+    bodyRgba: number;
+    foodRgba: number;
+    borderRgba: number;
+    bgRgba: number;
+    textRgba: number;
+    scoreTextRgba: number;
+};
+export type SnakeWidgetOptions = {
+    x?: TuiSizeValue;
+    y?: TuiSizeValue;
+    width?: TuiSizeValue;
+    height?: TuiSizeValue;
+    colorScheme?: Partial<SnakeColorScheme>;
+    tickInterval?: number;
+    speedIncrement?: number;
+};

package/dist/widgets/videoplayer/VideoPlayerWidget.d.ts

@@ -0,0 +1,16 @@
+import { type DrawListBuffer, type KeyboardEvent, type TuiWidgetRect, widgets } from '@buntui/core';
+import type { VideoPlayerWidgetOptions } from './types';
+export declare class VideoPlayerWidget extends widgets.InteractiveWidget {
+    #private;
+    constructor(options?: VideoPlayerWidgetOptions);
+    mounted(): void;
+    unmounted(): void;
+    updateRect(rect: Partial<TuiWidgetRect>): void;
+    containsPoint(x: number, y: number): boolean;
+    get rect(): TuiWidgetRect;
+    handleKey(event: KeyboardEvent): void;
+    update(dt: number): void;
+    emitDrawCommands(buffer: DrawListBuffer): void;
+}
+export declare function createVideoPlayerWidget(options?: VideoPlayerWidgetOptions): VideoPlayerWidget;
+export default VideoPlayerWidget;