@buntui/extensions 0.0.0

package/dist/framerate.d.ts

@@ -0,0 +1,3 @@
+export { FrameRateWatcher, createFrameRateWatcher } from './widgets/framerate/FrameRateWatcher';
+export type { FrameRateWatcherOptions } from './widgets/framerate/FrameRateWatcher';
+export { createFrameRateWatcher as default } from './widgets/framerate/FrameRateWatcher';

package/dist/framerate.js

@@ -0,0 +1,2 @@
+export { FrameRateWatcher, createFrameRateWatcher } from './widgets/framerate/FrameRateWatcher';
+export { createFrameRateWatcher as default } from './widgets/framerate/FrameRateWatcher';

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './matrix';
+export * from './framerate';
+export * from './snake';
+export * from './videoplayer';
+export * from './logger';
+export { EXTENSION_REGISTRY } from './registry';

package/dist/index.js

@@ -0,0 +1,8 @@
+// Barrel re-exports — for deep-import tree-shaking, import from sub-paths:
+//   import {Matrix} from '@buntui/extensions/matrix'
+export * from './matrix';
+export * from './framerate';
+export * from './snake';
+export * from './videoplayer';
+export * from './logger';
+export { EXTENSION_REGISTRY } from './registry';

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+export { LoggerWidget, createLoggerWidget } from './widgets/logger/LoggerWidget';
+export type { LoggerWidgetOptions } from './widgets/logger/LoggerWidget';
+export { createLoggerWidget as default } from './widgets/logger/LoggerWidget';

package/dist/logger.js

@@ -0,0 +1,2 @@
+export { LoggerWidget, createLoggerWidget } from './widgets/logger/LoggerWidget';
+export { createLoggerWidget as default } from './widgets/logger/LoggerWidget';

package/dist/matrix.d.ts

@@ -0,0 +1,3 @@
+export type { MatrixWidgetOptions, MatrixColorScheme, MatrixSpeedRange, } from './widgets/matrix/types';
+export { MatrixWidget, createMatrixWidget } from './widgets/matrix/MatrixWidget';
+export { createMatrixWidget as default } from './widgets/matrix/MatrixWidget';

package/dist/matrix.js

@@ -0,0 +1,4 @@
+export { MatrixWidget, createMatrixWidget } from './widgets/matrix/MatrixWidget';
+// Default export = creator function, for SFC default import usage:
+//   import Matrix from '@buntui/extensions/matrix'
+export { createMatrixWidget as default } from './widgets/matrix/MatrixWidget';

package/dist/registry.d.ts

@@ -0,0 +1,6 @@
+type TuiComponentRegistry = Record<string, {
+    creator: string;
+    module: string;
+}>;
+export declare const EXTENSION_REGISTRY: TuiComponentRegistry;
+export {};

package/dist/registry.js

@@ -0,0 +1,7 @@
+export const EXTENSION_REGISTRY = {
+    FrameRateWatcher: { creator: 'createFrameRateWatcher', module: '@buntui/extensions' },
+    Matrix: { creator: 'createMatrixWidget', module: '@buntui/extensions' },
+    Snake: { creator: 'createSnakeWidget', module: '@buntui/extensions' },
+    VideoPlayer: { creator: 'createVideoPlayerWidget', module: '@buntui/extensions' },
+    Logger: { creator: 'createLoggerWidget', module: '@buntui/extensions' },
+};

package/dist/snake.d.ts

@@ -0,0 +1,3 @@
+export type { SnakeWidgetOptions, SnakeDirection, SnakeGameState, SnakePoint, SnakeColorScheme, } from './widgets/snake/types';
+export { SnakeWidget, createSnakeWidget } from './widgets/snake/SnakeWidget';
+export { createSnakeWidget as default } from './widgets/snake/SnakeWidget';

package/dist/snake.js

@@ -0,0 +1,4 @@
+export { SnakeWidget, createSnakeWidget } from './widgets/snake/SnakeWidget';
+// Default export = creator function, for SFC default import usage:
+//   import Snake from '@buntui/extensions/snake'
+export { createSnakeWidget as default } from './widgets/snake/SnakeWidget';

package/dist/utils/color.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Interpolate between two RGBA colors by factor t (0.0 = from, 1.0 = to).
+ * Both inputs must be 0xAARRGGBB.
+ */
+export declare function lerpRgba(from: number, to: number, t: number): number;
+/**
+ * Build a lookup table of `steps` RGBA colors fading from lead to trail.
+ * Index 0 is the brightest (lead), index steps-1 is the dimmest (near-bg).
+ */
+export declare function buildTrailGradient(leadRgba: number, trailRgba: number, steps: number): number[];

package/dist/utils/color.js

@@ -0,0 +1,35 @@
+import { withAlpha } from '@buntui/core';
+/**
+ * Interpolate between two RGBA colors by factor t (0.0 = from, 1.0 = to).
+ * Both inputs must be 0xAARRGGBB.
+ */
+export function lerpRgba(from, to, t) {
+    const clampT = Math.max(0, Math.min(1, t));
+    const fA = (from >>> 24) & 0xFF;
+    const fR = (from >>> 16) & 0xFF;
+    const fG = (from >>> 8) & 0xFF;
+    const fB = from & 0xFF;
+    const tA = (to >>> 24) & 0xFF;
+    const tR = (to >>> 16) & 0xFF;
+    const tG = (to >>> 8) & 0xFF;
+    const tB = to & 0xFF;
+    const r = Math.round(fR + ((tR - fR) * clampT));
+    const g = Math.round(fG + ((tG - fG) * clampT));
+    const b = Math.round(fB + ((tB - fB) * clampT));
+    const a = Math.round(fA + ((tA - fA) * clampT));
+    return ((a << 24) | (r << 16) | (g << 8) | b) >>> 0;
+}
+/**
+ * Build a lookup table of `steps` RGBA colors fading from lead to trail.
+ * Index 0 is the brightest (lead), index steps-1 is the dimmest (near-bg).
+ */
+export function buildTrailGradient(leadRgba, trailRgba, steps) {
+    const table = [];
+    for (let i = 0; i < steps; i++) {
+        const t = i / Math.max(1, steps - 1);
+        const color = lerpRgba(leadRgba, trailRgba, t);
+        const alpha = Math.round(255 * (1 - (t * 0.7)));
+        table.push(withAlpha(color, alpha));
+    }
+    return table;
+}

package/dist/videoplayer.d.ts

@@ -0,0 +1,3 @@
+export type { VideoPlayerWidgetOptions, VideoPlayerState, VideoPlayerColorScheme, } from './widgets/videoplayer/types';
+export { VideoPlayerWidget, createVideoPlayerWidget } from './widgets/videoplayer/VideoPlayerWidget';
+export { createVideoPlayerWidget as default } from './widgets/videoplayer/VideoPlayerWidget';

package/dist/videoplayer.js

@@ -0,0 +1,4 @@
+export { VideoPlayerWidget, createVideoPlayerWidget } from './widgets/videoplayer/VideoPlayerWidget';
+// Default export = creator function, for SFC default import usage:
+//   import VideoPlayer from '@buntui/extensions/videoplayer'
+export { createVideoPlayerWidget as default } from './widgets/videoplayer/VideoPlayerWidget';

package/dist/widgets/framerate/FrameRateWatcher.d.ts

@@ -0,0 +1,20 @@
+import { type DrawListBuffer, type TuiWidgetRect, type TuiSizeValue, TuiWidgetEntity, type TuiColor } from '@buntui/core';
+export type FrameRateWatcherOptions = {
+    x?: TuiSizeValue;
+    y?: TuiSizeValue;
+    colorFg?: TuiColor;
+    colorBg?: TuiColor;
+};
+export declare class FrameRateWatcher extends TuiWidgetEntity {
+    #private;
+    constructor(options?: FrameRateWatcherOptions);
+    get zIndex(): number;
+    get rect(): TuiWidgetRect;
+    updateRect(rect: Partial<TuiWidgetRect>): void;
+    containsPoint(x: number, y: number): boolean;
+    emitDrawCommands(buf: DrawListBuffer): void;
+    mounted(): void;
+    unmounted(): void;
+}
+export declare function createFrameRateWatcher(options?: Partial<FrameRateWatcherOptions>): FrameRateWatcher;
+export default FrameRateWatcher;

package/dist/widgets/framerate/FrameRateWatcher.js

@@ -0,0 +1,87 @@
+import { TUI_CONTEXT_INSTANCE, TuiWidgetEntity, getTheme, parseColor, } from '@buntui/core';
+const FPS_BG = 0x1E_1E_2E_DD;
+export class FrameRateWatcher extends TuiWidgetEntity {
+    #x;
+    #y;
+    #latestTick = 0n;
+    #fps = 0;
+    #timer = null;
+    #colorFg;
+    #colorBg;
+    constructor(options = {}) {
+        super();
+        const rect = this.initRect(options.x, options.y);
+        this.#x = rect.x;
+        this.#y = rect.y;
+        const theme = getTheme();
+        this.#colorFg = parseColor(options.colorFg ?? theme.colors.text);
+        this.#colorBg = parseColor(options.colorBg ?? FPS_BG);
+        this.setDraggable(true);
+    }
+    get zIndex() {
+        return 999;
+    }
+    get rect() {
+        const text = `${this.#fps}fps`;
+        return {
+            x: this.#x,
+            y: this.#y,
+            width: text.length,
+            height: 1,
+        };
+    }
+    updateRect(rect) {
+        if (rect.x !== undefined) {
+            this.#x = rect.x;
+        }
+        if (rect.y !== undefined) {
+            this.#y = rect.y;
+        }
+    }
+    containsPoint(x, y) {
+        const text = `${this.#fps}fps`;
+        return x >= this.#x
+            && x < this.#x + text.length
+            && y >= this.#y
+            && y < this.#y + 1;
+    }
+    emitDrawCommands(buf) {
+        const text = `${this.#fps}fps`;
+        const w = text.length;
+        buf.pushClip(this.#x, this.#y, w, 1);
+        buf.drawRect({
+            x: this.#x,
+            y: this.#y,
+            width: w,
+            height: 1,
+            bgRgba: this.#colorBg,
+        });
+        buf.drawText({
+            x: this.#x,
+            y: this.#y,
+            text,
+            fgRgba: this.#colorFg,
+            bgRgba: this.#colorBg,
+        });
+        buf.popClip();
+    }
+    mounted() {
+        super.mounted();
+        this.#timer = setInterval(() => {
+            const currentTick = TUI_CONTEXT_INSTANCE.tick;
+            this.#fps = Number(currentTick - this.#latestTick);
+            this.#latestTick = currentTick;
+        }, 1000);
+    }
+    unmounted() {
+        super.unmounted();
+        if (this.#timer) {
+            clearInterval(this.#timer);
+            this.#timer = null;
+        }
+    }
+}
+export function createFrameRateWatcher(options) {
+    return new FrameRateWatcher(options);
+}
+export default FrameRateWatcher;

package/dist/widgets/logger/LoggerWidget.d.ts

@@ -0,0 +1,33 @@
+import { type TuiColor, TuiWidgetEntity } from '@buntui/core';
+export type LoggerWidgetOptions = {
+    x?: number;
+    y?: number;
+    panelWidth?: number;
+    panelHeight?: number;
+    maxLines?: number;
+    timestamp?: boolean;
+    colorFg?: TuiColor;
+    colorBg?: TuiColor;
+    label?: string;
+    hijack?: boolean;
+};
+export declare class LoggerWidget extends TuiWidgetEntity {
+    #private;
+    constructor(options?: LoggerWidgetOptions);
+    log(message: string): void;
+    clear(): void;
+    toggle(): void;
+    get messages(): readonly string[];
+    get isOpen(): boolean;
+    /**
+     * Replace console.log with a wrapper that sends output to this logger.
+     * Call restoreConsole() to undo.
+     */
+    hijackConsole(): void;
+    restoreConsole(): void;
+    get zIndex(): number;
+    containsPoint(x: number, y: number): boolean;
+    emitDrawCommands(buf: Parameters<TuiWidgetEntity['emitDrawCommands']>[0]): void;
+}
+export declare function createLoggerWidget(options?: Partial<LoggerWidgetOptions>): LoggerWidget;
+export default LoggerWidget;

package/dist/widgets/logger/LoggerWidget.js

@@ -0,0 +1,170 @@
+import { BoxWidget, TextWidget, ScrollBoxWidget, TuiWidgetEntity, parseColor, getTheme, } from '@buntui/core';
+export class LoggerWidget extends TuiWidgetEntity {
+    #toggleBtn;
+    #btnLabel;
+    #panel;
+    #messages = [];
+    #maxLines;
+    #showTimestamp;
+    #colorFg;
+    #panelWidth;
+    #panelHeight;
+    #panelVisible = false;
+    #scrollPending = false;
+    #restoreConsole = null;
+    constructor(options = {}) {
+        super();
+        const theme = getTheme();
+        this.#maxLines = options.maxLines ?? 200;
+        this.#showTimestamp = options.timestamp ?? true;
+        this.#colorFg = parseColor(options.colorFg ?? theme.colors.text);
+        this.#panelWidth = options.panelWidth ?? 40;
+        this.#panelHeight = options.panelHeight ?? 15;
+        const colorBg = parseColor(options.colorBg ?? 0x1E_1E_2E_CC);
+        const label = options.label ?? '◉';
+        // Floating toggle button
+        this.#toggleBtn = new BoxWidget({
+            x: options.x ?? 0,
+            y: options.y ?? 0,
+            width: label.length + 2,
+            height: 1,
+            colorBg,
+            border: false,
+            draggable: true,
+            styleZIndex: 999,
+        });
+        this.#btnLabel = new TextWidget({
+            x: options.x ?? 0,
+            y: options.y ?? 0,
+            width: label.length + 2,
+            height: 1,
+            value: ` ${label}`,
+            colorFg: this.#colorFg,
+            colorBg: 0x00_00_00_00,
+        });
+        this.#toggleBtn.addChild(this.#btnLabel);
+        // Log panel
+        this.#panel = new ScrollBoxWidget({
+            x: 0,
+            y: 0,
+            width: this.#panelWidth,
+            height: this.#panelHeight,
+            colorBg: (colorBg & 0xFF_FF_FF_00) | 0xDD,
+            borderTop: true,
+            borderRight: true,
+            borderBottom: true,
+            borderLeft: true,
+            borderStyle: 'solid',
+            borderColor: this.#colorFg,
+        });
+        this.#panel.setVisible(false);
+        this.addChild(this.#toggleBtn);
+        this.addChild(this.#panel);
+        this.#toggleBtn.on('click', () => {
+            this.toggle();
+        });
+        if (options.hijack) {
+            this.hijackConsole();
+        }
+    }
+    // -- Public API --
+    log(message) {
+        const line = this.#showTimestamp ? `[${this.#timestamp()}] ${message}` : message;
+        this.#messages.push(line);
+        if (this.#messages.length > this.#maxLines) {
+            this.#messages.shift();
+        }
+        const textWidget = new TextWidget({
+            x: 0,
+            y: 0,
+            width: this.#panelWidth - 2,
+            height: 1,
+            value: line,
+            colorFg: this.#colorFg,
+            colorBg: 0x00_00_00_00,
+        });
+        this.#panel.addChild(textWidget);
+        this.#scrollPending = true;
+    }
+    clear() {
+        this.#messages.length = 0;
+        const { children } = this.#panel;
+        for (let i = children.length - 1; i >= 0; i--) {
+            // eslint-disable-next-line unicorn/prefer-dom-node-remove
+            this.#panel.removeChild(children[i]);
+        }
+    }
+    toggle() {
+        this.#panelVisible = !this.#panelVisible;
+        this.#panel.setVisible(this.#panelVisible);
+        if (this.#panelVisible) {
+            this.#updatePanelPosition();
+            this.#scrollPending = true;
+        }
+    }
+    get messages() {
+        return this.#messages;
+    }
+    get isOpen() {
+        return this.#panelVisible;
+    }
+    /**
+     * Replace console.log with a wrapper that sends output to this logger.
+     * Call restoreConsole() to undo.
+     */
+    hijackConsole() {
+        const original = console.log;
+        this.#restoreConsole = () => {
+            console.log = original;
+        };
+        console.log = (...args) => {
+            this.log(args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' '));
+        };
+    }
+    restoreConsole() {
+        const restore = this.#restoreConsole;
+        this.#restoreConsole = null;
+        restore?.();
+    }
+    // -- Overrides --
+    // -- Overrides --
+    get zIndex() {
+        return 999;
+    }
+    containsPoint(x, y) {
+        if (this.#toggleBtn.containsPoint(x, y)) {
+            return true;
+        }
+        return this.#panelVisible && this.#panel.containsPoint(x, y);
+    }
+    emitDrawCommands(buf) {
+        this.#toggleBtn.emitDrawCommands(buf);
+        if (this.#panelVisible) {
+            this.#updatePanelPosition();
+            if (this.#scrollPending) {
+                this.#panel.scrollToBottom();
+                this.#scrollPending = false;
+            }
+            this.#panel.emitDrawCommands(buf);
+        }
+    }
+    // -- Private --
+    #updatePanelPosition() {
+        const { x: bx, y: by, height: bh } = this.#toggleBtn.rect;
+        this.#panel.updateRect({
+            x: bx,
+            y: by + bh,
+        });
+    }
+    #timestamp() {
+        const d = new Date();
+        const h = String(d.getHours()).padStart(2, '0');
+        const m = String(d.getMinutes()).padStart(2, '0');
+        const s = String(d.getSeconds()).padStart(2, '0');
+        return `${h}:${m}:${s}`;
+    }
+}
+export function createLoggerWidget(options) {
+    return new LoggerWidget(options);
+}
+export default LoggerWidget;

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

@@ -0,0 +1,13 @@
+import { type DrawListBuffer, type TuiWidgetRect, TuiWidgetEntity } from '@buntui/core';
+import type { MatrixWidgetOptions } from './types';
+export declare class MatrixWidget extends TuiWidgetEntity {
+    #private;
+    constructor(options?: MatrixWidgetOptions);
+    updateRect(rect: Partial<TuiWidgetRect>): void;
+    containsPoint(x: number, y: number): boolean;
+    update(dt: number): void;
+    emitDrawCommands(buffer: DrawListBuffer): void;
+    get rect(): TuiWidgetRect;
+}
+export declare function createMatrixWidget(options?: MatrixWidgetOptions): MatrixWidget;
+export default MatrixWidget;

package/dist/widgets/matrix/MatrixWidget.js

@@ -0,0 +1,139 @@
+import { TuiWidgetEntity, } from '@buntui/core';
+import { buildTrailGradient } from '../../utils/color';
+import { MATRIX_CHARSET } from './charset';
+import { DEFAULT_MATRIX_COLOR_SCHEME, DEFAULT_MATRIX_OPTIONS } from './defaults';
+import { createColumn, tickColumn, } from './matrix-column';
+export class MatrixWidget extends TuiWidgetEntity {
+    #x;
+    #y;
+    #width;
+    #height;
+    #colorScheme;
+    #speedRange;
+    #minTrailLength;
+    #maxTrailLength;
+    #density;
+    #charset;
+    #tickIntervalRange;
+    #columns = [];
+    #gradientLut = [];
+    #initialized = false;
+    constructor(options = {}) {
+        super();
+        const resolved = { ...DEFAULT_MATRIX_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 = {
+            leadRgba: schemeOverride.leadRgba ?? DEFAULT_MATRIX_COLOR_SCHEME.leadRgba,
+            trailRgba: schemeOverride.trailRgba ?? DEFAULT_MATRIX_COLOR_SCHEME.trailRgba,
+            bgRgba: schemeOverride.bgRgba ?? DEFAULT_MATRIX_COLOR_SCHEME.bgRgba,
+        };
+        this.#speedRange = resolved.speedRange ?? { min: 1, max: 3 };
+        this.#minTrailLength = resolved.minTrailLength ?? 5;
+        this.#maxTrailLength = resolved.maxTrailLength ?? 20;
+        this.#density = resolved.density ?? 0.8;
+        this.#charset = resolved.charset ?? MATRIX_CHARSET;
+        this.#tickIntervalRange = resolved.tickIntervalRange ?? { min: 60, max: 150 };
+        this.#rebuildGradient();
+    }
+    updateRect(rect) {
+        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;
+    }
+    update(dt) {
+        this.#ensureColumns(this.#width, this.#height);
+        const config = this.#columnConfig(this.#height);
+        for (const col of this.#columns) {
+            tickColumn(col, dt, this.#density, config);
+        }
+    }
+    emitDrawCommands(buffer) {
+        const w = this.#width;
+        const h = this.#height;
+        if (w <= 0 || h <= 0) {
+            return;
+        }
+        this.#ensureColumns(w, h);
+        const absX = this.#x;
+        const absY = this.#y;
+        const maxLength = this.#maxTrailLength;
+        buffer.pushClip(absX, absY, w, h);
+        for (let col = 0; col < this.#columns.length; col++) {
+            const column = this.#columns[col];
+            if (!column.active) {
+                continue;
+            }
+            const cx = absX + col;
+            const { headY } = column;
+            const { trailLength } = column;
+            const { chars } = column;
+            for (let t = 0; t < trailLength; t++) {
+                const cy = absY + headY - t;
+                if (cy < absY || cy >= absY + h) {
+                    continue;
+                }
+                const isLead = t === 0;
+                const fgRgba = isLead
+                    ? this.#colorScheme.leadRgba
+                    : (this.#gradientLut[Math.min(t, maxLength - 1)] ?? this.#colorScheme.trailRgba);
+                buffer.drawChar({
+                    x: cx,
+                    y: cy,
+                    char: chars[t] ?? this.#charset[0],
+                    fgRgba,
+                    bgRgba: this.#colorScheme.bgRgba,
+                });
+            }
+        }
+        buffer.popClip();
+    }
+    get rect() {
+        return {
+            x: this.#x,
+            y: this.#y,
+            width: this.#width,
+            height: this.#height,
+        };
+    }
+    #rebuildGradient() {
+        this.#gradientLut = buildTrailGradient(this.#colorScheme.leadRgba, this.#colorScheme.trailRgba, this.#maxTrailLength);
+    }
+    #columnConfig(maxY) {
+        return {
+            maxY,
+            speedRange: this.#speedRange,
+            minTrail: this.#minTrailLength,
+            maxTrail: this.#maxTrailLength,
+            charset: this.#charset,
+            tickIntervalRange: this.#tickIntervalRange,
+        };
+    }
+    #ensureColumns(width, height) {
+        if (this.#columns.length === width && this.#initialized) {
+            return;
+        }
+        this.#columns = [];
+        for (let x = 0; x < width; x++) {
+            this.#columns.push(createColumn(this.#columnConfig(height)));
+        }
+        this.#initialized = true;
+    }
+}
+export function createMatrixWidget(options) {
+    return new MatrixWidget(options);
+}
+export default MatrixWidget;

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

@@ -0,0 +1 @@
+export declare const MATRIX_CHARSET: number[];

package/dist/widgets/matrix/charset.js

@@ -0,0 +1,11 @@
+function range(start, end) {
+    const result = [];
+    for (let i = start; i <= end; i++) {
+        result.push(i);
+    }
+    return result;
+}
+export const MATRIX_CHARSET = [
+    ...range(0x41, 0x5A), // A-Z
+    ...range(0x61, 0x7A), // A-Za-z
+];

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

@@ -0,0 +1,3 @@
+import type { MatrixColorScheme, MatrixWidgetOptions } from './types';
+export declare const DEFAULT_MATRIX_COLOR_SCHEME: MatrixColorScheme;
+export declare const DEFAULT_MATRIX_OPTIONS: MatrixWidgetOptions;

package/dist/widgets/matrix/defaults.js

@@ -0,0 +1,17 @@
+import { rgbToRgba } from '@buntui/core';
+export const DEFAULT_MATRIX_COLOR_SCHEME = {
+    leadRgba: rgbToRgba(0x57, 0xFF, 0x57), // Bright green
+    trailRgba: rgbToRgba(0x00, 0x8F, 0x11), // Medium green
+    bgRgba: rgbToRgba(0x00, 0x00, 0x00), // Black background
+};
+export const DEFAULT_MATRIX_OPTIONS = {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0,
+    colorScheme: DEFAULT_MATRIX_COLOR_SCHEME,
+    speedRange: { min: 1, max: 3 },
+    minTrailLength: 5,
+    maxTrailLength: 20,
+    density: 0.8,
+};

package/dist/widgets/matrix/matrix-column.d.ts

@@ -0,0 +1,24 @@
+import type { MatrixSpeedRange } from './types';
+export type MatrixColumnState = {
+    headY: number;
+    trailLength: number;
+    speed: number;
+    active: boolean;
+    cooldown: number;
+    chars: number[];
+    accumulator: number;
+    tickInterval: number;
+};
+export type MatrixColumnConfig = {
+    maxY: number;
+    speedRange: MatrixSpeedRange;
+    minTrail: number;
+    maxTrail: number;
+    charset: number[];
+    tickIntervalRange: {
+        min: number;
+        max: number;
+    };
+};
+export declare function createColumn(config: MatrixColumnConfig): MatrixColumnState;
+export declare function tickColumn(col: MatrixColumnState, dt: number, density: number, config: MatrixColumnConfig): void;