blecsd 0.1.0

package/dist/program-BZaKqDKH.d.ts

@@ -0,0 +1,141 @@
+import { Readable, Writable } from 'node:stream';
+import { z } from 'zod';
+
+/**
+ * Program Module
+ *
+ * Main terminal control interface. Manages input/output streams,
+ * terminal dimensions, cursor position, and event handling.
+ *
+ * @module terminal/program
+ * @internal This module is internal and not exported from the main package.
+ */
+
+/**
+ * Program configuration schema
+ */
+declare const ProgramConfigSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodCustom<Readable, Readable>>;
+    output: z.ZodOptional<z.ZodCustom<Writable, Writable>>;
+    useAlternateScreen: z.ZodDefault<z.ZodBoolean>;
+    hideCursor: z.ZodDefault<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    forceWidth: z.ZodOptional<z.ZodNumber>;
+    forceHeight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type ProgramConfig = z.input<typeof ProgramConfigSchema>;
+/**
+ * Key event data
+ */
+interface KeyEvent {
+    /** Key name or character */
+    name: string;
+    /** Raw key sequence */
+    sequence: string;
+    /** Ctrl key pressed */
+    ctrl: boolean;
+    /** Meta/Alt key pressed */
+    meta: boolean;
+    /** Shift key pressed */
+    shift: boolean;
+}
+/**
+ * Mouse event data
+ */
+interface MouseEvent {
+    /** Mouse X position (1-indexed) */
+    x: number;
+    /** Mouse Y position (1-indexed) */
+    y: number;
+    /** Mouse button (0=left, 1=middle, 2=right) */
+    button: number;
+    /** Event action */
+    action: 'mousedown' | 'mouseup' | 'mousemove' | 'wheel';
+    /** Ctrl key pressed */
+    ctrl: boolean;
+    /** Meta/Alt key pressed */
+    meta: boolean;
+    /** Shift key pressed */
+    shift: boolean;
+}
+/**
+ * Resize event data
+ */
+interface ResizeEvent {
+    /** New width in columns */
+    cols: number;
+    /** New height in rows */
+    rows: number;
+}
+/**
+ * Program event types
+ */
+interface ProgramEvents {
+    key: [event: KeyEvent];
+    mouse: [event: MouseEvent];
+    resize: [event: ResizeEvent];
+    focus: [];
+    blur: [];
+    [key: string]: unknown[];
+}
+/**
+ * Program interface for type-safe access.
+ *
+ * Manages:
+ * - Input/output streams
+ * - Terminal dimensions
+ * - Cursor position
+ * - Buffered output
+ * - Alternate screen buffer
+ * - Event handling (key, mouse, resize)
+ */
+interface Program {
+    readonly input: Readable;
+    readonly output: Writable;
+    readonly cols: number;
+    readonly rows: number;
+    readonly x: number;
+    readonly y: number;
+    readonly initialized: boolean;
+    on<K extends keyof ProgramEvents & string>(event: K, listener: (...args: ProgramEvents[K]) => void): void;
+    off<K extends keyof ProgramEvents & string>(event: K, listener: (...args: ProgramEvents[K]) => void): void;
+    once<K extends keyof ProgramEvents & string>(event: K, listener: (...args: ProgramEvents[K]) => void): void;
+    removeAllListeners<K extends keyof ProgramEvents & string>(event?: K): void;
+    init(): Promise<void>;
+    destroy(): void;
+    write(data: string): void;
+    rawWrite(data: string): void;
+    flush(): void;
+    clear(): void;
+    move(x: number, y: number): void;
+    cursorTo(x: number, y: number): void;
+    showCursor(): void;
+    hideCursor(): void;
+    setTitle(title: string): void;
+    resetStyle(): void;
+}
+/**
+ * Creates a new Program instance.
+ *
+ * @param config - Program configuration
+ * @returns A new Program instance
+ *
+ * @example
+ * ```typescript
+ * const program = createProgram();
+ * await program.init();
+ *
+ * program.on('key', (event) => {
+ *   if (event.name === 'q') {
+ *     program.destroy();
+ *   }
+ * });
+ *
+ * program.move(10, 5);
+ * program.write('Hello, World!');
+ * program.flush();
+ * ```
+ */
+declare function createProgram(config?: ProgramConfig): Program;
+
+export { type KeyEvent as K, type MouseEvent as M, type Program as P, type ResizeEvent as R, type ProgramConfig as a, ProgramConfigSchema as b, createProgram as c };

package/dist/renderable-jTMOA-GK.d.ts

@@ -0,0 +1,302 @@
+import { W as World, E as Entity } from './types-BcsvoKzf.js';
+
+/**
+ * Renderable component for visual styling of entities.
+ * @module components/renderable
+ */
+
+/**
+ * Default foreground color (white).
+ */
+declare const DEFAULT_FG: number;
+/**
+ * Default background color (black, fully transparent).
+ */
+declare const DEFAULT_BG: number;
+/**
+ * Renderable component store using SoA (Structure of Arrays) for performance.
+ *
+ * - `visible`: Whether entity should be rendered (0=hidden, 1=visible)
+ * - `dirty`: Whether entity needs redraw (0=clean, 1=dirty)
+ * - `fg`: Foreground color (packed RGBA)
+ * - `bg`: Background color (packed RGBA)
+ * - `bold`, `underline`, `blink`, `inverse`: Text styling flags
+ * - `transparent`: Whether background is transparent
+ *
+ * @example
+ * ```typescript
+ * import { Renderable, setStyle, getStyle, markDirty } from 'blecsd';
+ *
+ * setStyle(world, entity, { fg: '#ff0000', bold: true });
+ * markDirty(world, entity);
+ *
+ * const style = getStyle(world, entity);
+ * console.log(style.bold); // true
+ * ```
+ */
+declare const Renderable: {
+    /** 0 = hidden, 1 = visible */
+    visible: Uint8Array<ArrayBuffer>;
+    /** 0 = clean, 1 = needs redraw */
+    dirty: Uint8Array<ArrayBuffer>;
+    /** Foreground color (packed RGBA) */
+    fg: Uint32Array<ArrayBuffer>;
+    /** Background color (packed RGBA) */
+    bg: Uint32Array<ArrayBuffer>;
+    /** Bold text */
+    bold: Uint8Array<ArrayBuffer>;
+    /** Underlined text */
+    underline: Uint8Array<ArrayBuffer>;
+    /** Blinking text */
+    blink: Uint8Array<ArrayBuffer>;
+    /** Inverse colors */
+    inverse: Uint8Array<ArrayBuffer>;
+    /** Transparent background */
+    transparent: Uint8Array<ArrayBuffer>;
+    /** Opacity for alpha blending (0-255, where 255 = fully opaque) */
+    opacity: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Style options for setStyle.
+ */
+interface StyleOptions {
+    /** Foreground color (hex string or packed number) */
+    fg?: string | number;
+    /** Background color (hex string or packed number) */
+    bg?: string | number;
+    /** Bold text */
+    bold?: boolean;
+    /** Underlined text */
+    underline?: boolean;
+    /** Blinking text */
+    blink?: boolean;
+    /** Inverse colors */
+    inverse?: boolean;
+    /** Transparent background */
+    transparent?: boolean;
+    /** Opacity for alpha blending (0-1, where 1 = fully opaque) */
+    opacity?: number;
+}
+/**
+ * Style data returned by getStyle.
+ */
+interface StyleData {
+    readonly fg: number;
+    readonly bg: number;
+    readonly bold: boolean;
+    readonly underline: boolean;
+    readonly blink: boolean;
+    readonly inverse: boolean;
+    readonly transparent: boolean;
+    /** Opacity value (0-1, where 1 = fully opaque) */
+    readonly opacity: number;
+}
+/**
+ * Renderable data returned by getRenderable.
+ */
+interface RenderableData extends StyleData {
+    readonly visible: boolean;
+    readonly dirty: boolean;
+}
+/**
+ * Sets the visual style of an entity.
+ * Adds the Renderable component if not already present.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param style - Style options to apply
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { createWorld, addEntity } from '../core/ecs';
+ * import { setStyle } from 'blecsd';
+ *
+ * const world = createWorld();
+ * const entity = addEntity(world);
+ *
+ * // Set style with hex colors
+ * setStyle(world, entity, {
+ *   fg: '#ff0000',
+ *   bg: '#000000',
+ *   bold: true,
+ * });
+ *
+ * // Or with packed colors
+ * setStyle(world, entity, { fg: 0xffff0000 });
+ * ```
+ */
+declare function setStyle(world: World, eid: Entity, style: StyleOptions): Entity;
+/**
+ * Gets the style data of an entity.
+ * Returns undefined if the entity doesn't have a Renderable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Style data or undefined
+ *
+ * @example
+ * ```typescript
+ * import { getStyle, colorToHex } from 'blecsd';
+ *
+ * const style = getStyle(world, entity);
+ * if (style) {
+ *   console.log(`FG: ${colorToHex(style.fg)}, Bold: ${style.bold}`);
+ * }
+ * ```
+ */
+declare function getStyle(world: World, eid: Entity): StyleData | undefined;
+/**
+ * Gets the full renderable data of an entity.
+ * Returns undefined if the entity doesn't have a Renderable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns Renderable data or undefined
+ */
+declare function getRenderable(world: World, eid: Entity): RenderableData | undefined;
+/**
+ * Marks an entity as needing redraw.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { markDirty } from 'blecsd';
+ *
+ * // After changing entity state, mark for redraw
+ * markDirty(world, entity);
+ * ```
+ */
+declare function markDirty(world: World, eid: Entity): Entity;
+/**
+ * Marks an entity as clean (no redraw needed).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function markClean(world: World, eid: Entity): Entity;
+/**
+ * Checks if an entity needs redraw.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if dirty, false otherwise
+ */
+declare function isDirty(world: World, eid: Entity): boolean;
+/**
+ * Sets visibility of an entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @param visible - true to show, false to hide
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { setVisible } from 'blecsd';
+ *
+ * setVisible(world, entity, false); // Hide entity
+ * setVisible(world, entity, true);  // Show entity
+ * ```
+ */
+declare function setVisible(world: World, eid: Entity, visible: boolean): Entity;
+/**
+ * Checks if an entity is visible.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if visible, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { isVisible } from 'blecsd';
+ *
+ * if (isVisible(world, entity)) {
+ *   // Render the entity
+ * }
+ * ```
+ */
+declare function isVisible(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity has a Renderable component.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity has Renderable component
+ */
+declare function hasRenderable(world: World, eid: Entity): boolean;
+/**
+ * Shows an entity (sets visible to true).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function show(world: World, eid: Entity): Entity;
+/**
+ * Hides an entity (sets visible to false).
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ */
+declare function hide(world: World, eid: Entity): Entity;
+/**
+ * Toggles an entity's visibility.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns The entity ID for chaining
+ *
+ * @example
+ * ```typescript
+ * import { toggle } from 'blecsd';
+ *
+ * // Toggle visibility on key press
+ * toggle(world, menuEntity);
+ * ```
+ */
+declare function toggle(world: World, eid: Entity): Entity;
+/**
+ * Checks if an entity is effectively visible.
+ * An entity is effectively visible only if it and all its ancestors are visible.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity and all ancestors are visible
+ *
+ * @example
+ * ```typescript
+ * import { isEffectivelyVisible, hide, show } from 'blecsd';
+ *
+ * // Parent is hidden, so child is not effectively visible
+ * hide(world, parentEntity);
+ * show(world, childEntity);
+ * console.log(isEffectivelyVisible(world, childEntity)); // false
+ * ```
+ */
+declare function isEffectivelyVisible(world: World, eid: Entity): boolean;
+/**
+ * Checks if an entity is detached from the root.
+ * An entity is detached if it has a hierarchy but no path to a root entity.
+ *
+ * @param world - The ECS world
+ * @param eid - The entity ID
+ * @returns true if entity is detached from root
+ *
+ * @example
+ * ```typescript
+ * import { isDetached, removeChild } from 'blecsd';
+ *
+ * // After removing from parent, entity may be detached
+ * removeChild(world, parentEntity, childEntity);
+ * console.log(isDetached(world, childEntity)); // true (if no other parent)
+ * ```
+ */
+declare function isDetached(world: World, eid: Entity): boolean;
+
+export { DEFAULT_BG as D, Renderable as R, type StyleData as S, DEFAULT_FG as a, type RenderableData as b, type StyleOptions as c, getStyle as d, hide as e, isDirty as f, getRenderable as g, hasRenderable as h, isDetached as i, isEffectivelyVisible as j, isVisible as k, markDirty as l, markClean as m, setVisible as n, show as o, setStyle as s, toggle as t };

package/dist/scheduler-DcfoFuum.d.ts

@@ -0,0 +1,86 @@
+import { L as LoopPhase, S as System, W as World } from './types-BcsvoKzf.js';
+
+/**
+ * System scheduler for ordered execution.
+ * @module core/scheduler
+ */
+
+/**
+ * Gets the current frame's delta time.
+ * Call this from within a system to get the time elapsed since the last frame.
+ *
+ * @returns Delta time in seconds
+ *
+ * @example
+ * ```typescript
+ * import { getDeltaTime } from 'blecsd';
+ *
+ * const movementSystem: System = (world) => {
+ *   const dt = getDeltaTime();
+ *   // Use dt for frame-rate independent movement
+ *   return world;
+ * };
+ * ```
+ */
+declare function getDeltaTime(): number;
+/**
+ * Scheduler interface for managing and executing systems in order.
+ *
+ * Systems are organized into phases that run in a fixed order.
+ * Within each phase, systems run by priority (lower = earlier).
+ *
+ * The INPUT phase is protected and cannot be modified by users
+ * to ensure input is always processed first.
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ *
+ * scheduler.registerSystem(LoopPhase.UPDATE, movementSystem);
+ * scheduler.registerSystem(LoopPhase.RENDER, renderSystem);
+ *
+ * // In game loop
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+interface Scheduler {
+    registerSystem(phase: LoopPhase, system: System, priority?: number): void;
+    registerInputSystem(system: System, priority?: number): void;
+    unregisterSystem(system: System): void;
+    unregisterInputSystem(system: System): void;
+    run(world: World, deltaTime: number): World;
+    runInputOnly(world: World, deltaTime: number): World;
+    runFixedUpdatePhases(world: World, fixedDeltaTime: number): World;
+    runRenderPhases(world: World, deltaTime: number): World;
+    getSystemsForPhase(phase: LoopPhase): System[];
+    getSystemCount(phase: LoopPhase): number;
+    getTotalSystemCount(): number;
+    hasSystem(system: System): boolean;
+    clearPhase(phase: LoopPhase): void;
+    clearAllSystems(): void;
+}
+/**
+ * Creates a new scheduler instance.
+ *
+ * @returns A new Scheduler instance
+ *
+ * @example
+ * ```typescript
+ * import { createScheduler, LoopPhase } from 'blecsd';
+ *
+ * const scheduler = createScheduler();
+ *
+ * // Register systems
+ * scheduler.registerSystem(LoopPhase.UPDATE, movementSystem);
+ * scheduler.registerSystem(LoopPhase.PHYSICS, physicsSystem);
+ * scheduler.registerSystem(LoopPhase.RENDER, renderSystem);
+ *
+ * // Run in game loop
+ * scheduler.run(world, deltaTime);
+ * ```
+ */
+declare function createScheduler(): Scheduler;
+
+export { type Scheduler as S, createScheduler as c, getDeltaTime as g };