textmode.js 0.4.0 → 0.6.0-beta.1

package/dist/types/textmode/mixins/AnimationMixin.d.ts

@@ -1,128 +1,8 @@
 import type { Mixin } from './TextmodifierMixin';
-/**
- * Interface for animation capabilities that will be mixed into Textmodifier
- */
-export interface AnimationCapabilities {
-    /**
-     * Set the maximum frame rate. If called without arguments, returns the current measured frame rate.
-     * @param fps The maximum frames per second for rendering.
-     *
-     * @example
-     * ```javascript
-     * // Create a Textmodifier instance
-     * const textmodifier = textmode.create();
-     *
-     * // Set the maximum frame rate to 30 FPS
-     * textmodifier.frameRate(30);
-     * ```
-     */
-    frameRate(fps?: number): number | void;
-    /**
-     * Stop the automatic rendering loop.
-     *
-     * This method pauses the render loop without, allowing
-     * it to be resumed later with {@link loop}. This is useful for temporarily pausing
-     * animation while maintaining the ability to continue it.
-     *
-     * @example
-     * ```javascript
-     * // Create a textmodifier instance in auto mode
-     * const textmodifier = textmode.create();
-     *
-     * // The render loop is running by default
-     * console.log(textmodifier.isLooping()); // true
-     *
-     * // Stop the automatic rendering loop
-     * textmodifier.noLoop();
-     * console.log(textmodifier.isLooping()); // false
-     *
-     * // Resume the rendering loop
-     * textmodifier.loop();
-     * console.log(textmodifier.isLooping()); // true
-     * ```
-     */
-    noLoop(): void;
-    /**
-     * Resume the rendering loop if it was stopped by {@link noLoop}.
-     *
-     * @example
-     * ```javascript
-     * // Create a textmodifier instance
-     * const textmodifier = textmode.create();
-     *
-     * // Stop the loop
-     * textmodifier.noLoop();
-     *
-     * // Resume the loop
-     * textmodifier.loop();
-     *
-     * // You can also use this pattern for conditional animation
-     * if (someCondition) {
-     *   textmodifier.loop();
-     * } else {
-     *   textmodifier.noLoop();
-     * }
-     * ```
-     */
-    loop(): void;
-    /**
-     * Execute the render function a specified number of times.
-     *
-     * This method is useful when the render loop has been stopped with {@link noLoop},
-     * allowing you to trigger rendering on demand.
-     *
-     * @param n The number of times to execute the render function. Defaults to 1.
-     *
-     * @example
-     * ```javascript
-     * // Create a textmodifier instance
-     * const textmodifier = textmode.create();
-     *
-     * // Set up drawing
-     * textmodifier.draw(() => {
-     *   textmodifier.background(0);
-     *
-     *   textmodifier.char("A");
-     *   textmodifier.charColor(255, 0, 0);
-     *   textmodifier.rect(10, 10, 50, 50);
-     * });
-     *
-     * textmodifier.noLoop();
-     * textmodifier.redraw(3); // Render 3 times despite loop being stopped
-     * ```
-     */
-    redraw(n?: number): void;
-    /**
-     * Check whether the textmodifier is currently running the automatic render loop.
-     * @returns True if the render loop is currently active, false otherwise.
-     *
-     * @example
-     * ```javascript
-     * const textmodifier = textmode.create(canvas);
-     *
-     * // Check loop status in different states
-     * console.log(textmodifier.isLooping()); // true (looping)
-     *
-     * textmodifier.noLoop();
-     * console.log(textmodifier.isLooping()); // false (not looping)
-     *
-     * textmodifier.loop();
-     * console.log(textmodifier.isLooping()); // true (alooping)
-     * ```
-     */
-    isLooping(): boolean;
-    /**
-     * Get the current frame count.
-     */
-    get frameCount(): number;
-    /**
-     * Set the current frame count.
-     */
-    set frameCount(value: number);
-}
+import type { IAnimationMixin } from './interfaces/IAnimationMixin';
 /**
  * Mixin that adds animation capabilities to a class
  * @param Base The base class to extend
  * @returns Extended class with animation capabilities
  */
-export declare const AnimationMixin: Mixin<AnimationCapabilities>;
+export declare const AnimationMixin: Mixin<IAnimationMixin>;

package/dist/types/textmode/mixins/FontMixin.d.ts

@@ -1,83 +1,8 @@
 import type { Mixin } from './TextmodifierMixin';
-/**
- * Interface for font capabilities that will be mixed into Textmodifier
- */
-export interface FontCapabilities {
-    /**
-     * Update the font used for rendering.
-     * @param fontSource The URL of the font to load.
-     *
-     * @example
-     * ```javascript
-     * // Create a Textmodifier instance
-     * const textmodifier = textmode.create();
-     *
-     * // Load a custom font from a URL
-     * await textmodifier.loadFont('https://example.com/fonts/myfont.ttf');
-     *
-     * // Local font example
-     * // await textmodifier.loadFont('./fonts/myfont.ttf');
-     * ```
-     */
-    loadFont(fontSource: string): Promise<void>;
-    /**
-     * Set the font size used for rendering.
-     * @param size The font size to set.
-     *
-     * @example
-     * ```javascript
-     * // Create a Textmodifier instance
-     * const textmodifier = textmode.create();
-     *
-     * // Set the font size to 32
-     * textmodifier.fontSize(32);
-     * ```
-     */
-    fontSize(size: number): void;
-    /**
-     * Get the RGB shader color of a specific character in the current font.
-     *
-     * Useful for custom shaders to control the character to render.
-     *
-     * @param char The character to get the color for.
-     * @returns An array representing the RGB color, or null if the character is not found.
-     * @example
-     * ```javascript
-     * // Create a Textmodifier instance
-     * const textmodifier = textmode.create();
-     *
-     * // Get the color of the character 'A'
-     * textmodifier.setup(() => {
-     *   const color = textmodifier.glyphColor('A');
-     *   console.log(color); // e.g., [1, 0, 0] for red
-     * });
-     * ```
-     */
-    glyphColor(char: string): [number, number, number] | null;
-    /**
-     * Get the RGB shader colors of all characters in a string for the current font.
-     *
-     * Useful for custom shaders to control the characters to render.
-     *
-     * @param str The string to get the colors for.
-     * @returns An array of RGB color arrays, or null if a character is not found.
-     * @example
-     * ```javascript
-     * // Create a Textmodifier instance
-     * const textmodifier = textmode.create();
-     *
-     * // Get the colors of the string 'Hello'
-     * textmodifier.setup(() => {
-     *   const colors = textmodifier.glyphColors('Hello');
-     *   console.log(colors); // e.g., [[0.1, 0, 0], ...]
-     * });
-     * ```
-     */
-    glyphColors(str: string): ([number, number, number] | null)[];
-}
+import type { IFontMixin } from './interfaces/IFontMixin';
 /**
  * Mixin that adds font capabilities to a class
  * @param Base The base class to extend
  * @returns Extended class with font capabilities
  */
-export declare const FontMixin: Mixin<FontCapabilities>;
+export declare const FontMixin: Mixin<IFontMixin>;

package/dist/types/textmode/mixins/KeyboardMixin.d.ts

@@ -1,95 +1,13 @@
 import type { Mixin } from './TextmodifierMixin';
-import type { KeyboardEventHandler } from '../managers/KeyboardManager';
-/**
- * Capabilities provided by the KeyboardMixin
- */
-export interface KeyboardCapabilities {
-    /**
-     * Check if a specific key is currently being pressed.
-     *
-     * @param key The key to check (e.g., 'a', 'Enter', 'ArrowLeft')
-     * @returns true if the key is currently pressed, false otherwise
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * let playerX = 0;
-     * let playerY = 0;
-     *
-     * t.draw(() => {
-     *   t.background(0);
-     *
-     *   // Check for arrow keys to move a character
-     *   if (t.isKeyPressed('ArrowUp')) {
-     *     playerY -= 1;
-     *   }
-     *   if (t.isKeyPressed('ArrowDown')) {
-     *     playerY += 1;
-     *   }
-     *   if (t.isKeyPressed('ArrowLeft')) {
-     *     playerX -= 1;
-     *   }
-     *   if (t.isKeyPressed('ArrowRight')) {
-     *     playerX += 1;
-     *   }
-     *
-     *   // Draw player character
-     *   t.char('@');
-     *   t.charColor(255, 255, 0);
-     *   t.point(playerX, playerY);
-     * });
-     * ```
-     */
-    isKeyPressed(key: string): boolean;
-    /**
-     * Set a callback function that will be called when a key is pressed down.
-     *
-     * @param callback The function to call when a key is pressed
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.keyPressed((data) => {
-     *   console.log(`Key pressed: ${data.key}`);
-     *   if (data.key === 'Enter') {
-     *     console.log('Enter key was pressed!');
-     *   }
-     *   if (data.ctrlKey && data.key === 's') {
-     *     console.log('Ctrl+S was pressed!');
-     *   }
-     * });
-     * ```
-     */
-    keyPressed(callback: KeyboardEventHandler): void;
-    /**
-     * Set a callback function that will be called when a key is released.
-     *
-     * @param callback The function to call when a key is released
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.keyReleased((data) => {
-     *   console.log(`Key released: ${data.key}`);
-     *   if (data.key === ' ') {
-     *     console.log('Spacebar was released!');
-     *   }
-     * });
-     * ```
-     */
-    keyReleased(callback: KeyboardEventHandler): void;
-}
+import type { IKeyboardMixin } from './interfaces/IKeyboardMixin';
 /**
  * Mixin that adds keyboard interaction capabilities to Textmodifier.
  *
  * This is a thin wrapper around KeyboardManager that provides the public API
  * for keyboard interaction. All the actual implementation is handled by the
- * KeyboardManager instance in the TextmodifierContext.
+ * KeyboardManager instance in the ITextmodifier.
  *
  * Provides p5.js-like keyboard functionality including key state tracking,
  * event callbacks, and special key handling.
  */
-export declare const KeyboardMixin: Mixin<KeyboardCapabilities>;
+export declare const KeyboardMixin: Mixin<IKeyboardMixin>;

package/dist/types/textmode/mixins/MouseMixin.d.ts

@@ -1,137 +1,10 @@
 import type { Mixin } from './TextmodifierMixin';
-import type { MouseEventHandler, MousePosition } from '../managers/MouseManager';
-/**
- * Capabilities provided by the MouseMixin
- */
-export interface MouseCapabilities {
-    /**
-     * Set a callback function that will be called when the mouse is clicked.
-     *
-     * @param callback The function to call when the mouse is clicked
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.mouseClicked((data) => {
-     *   console.log(`Clicked at grid position: ${data.position.x}, ${data.position.y}`);
-     *   console.log(`Button: ${data.button}`); // 0=left, 1=middle, 2=right
-     * });
-     * ```
-     */
-    mouseClicked(callback: MouseEventHandler): void;
-    /**
-     * Set a callback function that will be called when the mouse is pressed down.
-     *
-     * @param callback The function to call when the mouse is pressed
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.mousePressed((data) => {
-     *   console.log(`Mouse pressed at: ${data.position.x}, ${data.position.y}`);
-     * });
-     * ```
-     */
-    mousePressed(callback: MouseEventHandler): void;
-    /**
-     * Set a callback function that will be called when the mouse is released.
-     *
-     * @param callback The function to call when the mouse is released
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.mouseReleased((data) => {
-     *   console.log(`Mouse released at: ${data.position.x}, ${data.position.y}`);
-     * });
-     * ```
-     */
-    mouseReleased(callback: MouseEventHandler): void;
-    /**
-     * Set a callback function that will be called when the mouse moves.
-     *
-     * @param callback The function to call when the mouse moves
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.mouseMoved((data) => {
-     *   if (data.position.x !== -1 && data.position.y !== -1) {
-     *     console.log(`Mouse moved to: ${data.position.x}, ${data.position.y}`);
-     *     console.log(`Previous position: ${data.previousPosition.x}, ${data.previousPosition.y}`);
-     *   }
-     * });
-     * ```
-     */
-    mouseMoved(callback: MouseEventHandler): void;
-    /**
-     * Set a callback function that will be called when the mouse wheel is scrolled.
-     *
-     * @param callback The function to call when the mouse wheel is scrolled
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.mouseScrolled((data) => {
-     *   console.log(`Mouse scrolled at: ${data.position.x}, ${data.position.y}`);
-     *   console.log(`Scroll delta: ${data.delta?.x}, ${data.delta?.y}`);
-     * });
-     * ```
-     */
-    mouseScrolled(callback: MouseEventHandler): void;
-    /**
-     * Get the current mouse position in grid coordinates.
-     *
-     * Returns the mouse position as grid cell coordinates *(column, row)*.
-     *
-     * If the mouse is outside the grid or the instance is not ready,
-     * it returns `{ x: -1, y: -1 }`.
-     *
-     * @example
-     * ```javascript
-     * const t = textmode.create({ width: 800, height: 600 });
-     *
-     * t.draw(() => {
-     *   const mousePos = t.mouse;
-     *
-     *   if (mousePos.x !== -1 && mousePos.y !== -1) {
-     *     // Mouse is over the grid
-     *     t.char('*');
-     *     t.charColor(255, 0, 0);
-     *     t.point(mousePos.x, mousePos.y);
-     *   }
-     * });
-     * ```
-     */
-    get mouse(): MousePosition;
-    /**
-     * Set the mouse cursor for the textmode canvas.
-     *
-     * Provide any valid CSS cursor value (e.g. 'default', 'pointer', 'crosshair', 'move', 'text', 'grab', 'grabbing',
-     * 'none', 'zoom-in', 'zoom-out', 'ns-resize', 'ew-resize', 'nwse-resize', 'nesw-resize', etc.),
-     * or a CSS `url(...)` cursor. Call with no argument or an empty string to reset to default.
-     *
-     * See MDN for all options: https://developer.mozilla.org/en-US/docs/Web/CSS/cursor
-     *
-     * @example
-     * ```javascript
-     * t.cursor('crosshair');
-     * // ... later, reset:
-     * t.cursor();
-     * ```
-     */
-    cursor(cursor?: string): void;
-}
+import type { IMouseMixin } from './interfaces/IMouseMixin';
 /**
  * Mixin that adds mouse tracking capabilities to Textmodifier.
  *
  * This is a thin wrapper around MouseManager that provides the public API
  * for mouse interaction. All the actual implementation is handled by the
- * MouseManager instance in the TextmodifierContext.
+ * MouseManager instance in the ITextmodifier.
  */
-export declare const MouseMixin: Mixin<MouseCapabilities>;
+export declare const MouseMixin: Mixin<IMouseMixin>;