@opentui/core 0.1.4 → 0.1.6

package/lib/hast-styled-text.d.ts

@@ -0,0 +1,38 @@
+import type { RGBA } from "../types";
+import { StyledText } from "./styled-text";
+export interface HASTText {
+    type: "text";
+    value: string;
+}
+export interface HASTElement {
+    type: "element";
+    tagName: string;
+    properties?: {
+        className?: string;
+    };
+    children: HASTNode[];
+}
+export type HASTNode = HASTText | HASTElement;
+export interface StyleDefinition {
+    fg?: RGBA;
+    bg?: RGBA;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+}
+interface MergedStyle {
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes: number;
+}
+export declare class SyntaxStyle {
+    private styles;
+    private mergedStyleCache;
+    constructor(styles: Record<string, StyleDefinition>);
+    mergeStyles(...styleNames: string[]): MergedStyle;
+    clearCache(): void;
+    getCacheSize(): number;
+}
+export declare function hastToStyledText(hast: HASTNode, syntaxStyle: SyntaxStyle): StyledText;
+export {};

package/lib/index.d.ts

@@ -2,3 +2,4 @@ export * from "./border";
 export * from "./TrackedNode";
 export * from "./KeyHandler";
 export * from "./ascii.font";
+export * from "./hast-styled-text";

package/lib/styled-text.d.ts

@@ -14,11 +14,13 @@ export interface StyleAttrs {
 }
 export declare class StyledText {
     readonly chunks: TextChunk[];
-    private _length;
     private _plainText;
-    constructor(chunks: TextChunk[], length: number, plainText: string);
+    constructor(chunks: TextChunk[]);
     toString(): string;
-    get length(): number;
+    private _chunksToPlainText;
+    insert(chunk: TextChunk, index?: number): void;
+    remove(chunk: TextChunk): void;
+    replace(chunk: TextChunk, oldChunk: TextChunk): void;
 }
 export declare function stringToStyledText(content: string): StyledText;
 export type StylableInput = string | number | boolean | TextChunk;

package/package.json

@@ -4,12 +4,13 @@
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/sst/opentui"
+    "url": "https://github.com/sst/opentui",
+    "directory": "packages/core"
   },
   "exports": {
     ".": {
@@ -27,16 +28,22 @@
     "jimp": "1.6.0",
     "yoga-layout": "3.2.1"
   },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/three": "^0.177.0",
+    "commander": "^13.1.0",
+    "prettier": "3.6.2"
+  },
   "optionalDependencies": {
     "@dimforge/rapier2d-simd-compat": "^0.17.3",
     "bun-webgpu": "0.1.3",
     "planck": "^1.4.2",
     "three": "0.177.0",
-    "@opentui/core-darwin-x64": "0.1.4",
-    "@opentui/core-darwin-arm64": "0.1.4",
-    "@opentui/core-linux-x64": "0.1.4",
-    "@opentui/core-linux-arm64": "0.1.4",
-    "@opentui/core-win32-x64": "0.1.4",
-    "@opentui/core-win32-arm64": "0.1.4"
+    "@opentui/core-darwin-x64": "0.1.6",
+    "@opentui/core-darwin-arm64": "0.1.6",
+    "@opentui/core-linux-x64": "0.1.6",
+    "@opentui/core-linux-arm64": "0.1.6",
+    "@opentui/core-win32-x64": "0.1.6",
+    "@opentui/core-win32-arm64": "0.1.6"
   }
 }

package/utils.d.ts

@@ -13,7 +13,3 @@ export declare function createTextAttributes({ bold, italic, underline, dim, bli
     hidden?: boolean;
     strikethrough?: boolean;
 }): number;
-export declare function loadTemplate(filePath: string, params: Record<string, string>): Promise<string>;
-export declare function fixPaths<T extends {
-    [key: string]: string;
-}>(paths: T): T;

package/supersampling-jw3fem06.wgsl

@@ -1,201 +0,0 @@
-struct CellResult {
-    bg: vec4<f32>,      // Background RGBA (16 bytes)
-    fg: vec4<f32>,      // Foreground RGBA (16 bytes)
-    char: u32,          // Unicode character code (4 bytes)
-    _padding1: u32,     // Padding (4 bytes)
-    _padding2: u32,     // Extra padding (4 bytes) 
-    _padding3: u32,     // Extra padding (4 bytes) - total now 48 bytes (16-byte aligned)
-};
-
-struct CellBuffer {
-    cells: array<CellResult>
-};
-
-struct SuperSamplingParams {
-    width: u32,              // Canvas width in pixels
-    height: u32,             // Canvas height in pixels  
-    sampleAlgo: u32,         // 0 = standard 2x2, 1 = pre-squeezed horizontal blend
-    _padding: u32,           // Padding for 16-byte alignment
-};
-
-@group(0) @binding(0) var inputTexture: texture_2d<f32>;
-@group(0) @binding(1) var<storage, read_write> output: CellBuffer;
-@group(0) @binding(2) var<uniform> params: SuperSamplingParams;
-
-// Quadrant character lookup table (same as Zig implementation)
-const quadrantChars = array<u32, 16>(
-    32u,      // ' '  - 0000
-    0x2597u,  // ▗   - 0001 BR
-    0x2596u,  // ▖   - 0010 BL  
-    0x2584u,  // ▄   - 0011 Lower Half Block
-    0x259Du,  // ▝   - 0100 TR
-    0x2590u,  // ▐   - 0101 Right Half Block
-    0x259Eu,  // ▞   - 0110 TR+BL
-    0x259Fu,  // ▟   - 0111 TR+BL+BR
-    0x2598u,  // ▘   - 1000 TL
-    0x259Au,  // ▚   - 1001 TL+BR
-    0x258Cu,  // ▌   - 1010 Left Half Block
-    0x2599u,  // ▙   - 1011 TL+BL+BR
-    0x2580u,  // ▀   - 1100 Upper Half Block
-    0x259Cu,  // ▜   - 1101 TL+TR+BR
-    0x259Bu,  // ▛   - 1110 TL+TR+BL
-    0x2588u   // █   - 1111 Full Block
-);
-
-const inv_255: f32 = 1.0 / 255.0;
-
-fn getPixelColor(pixelX: u32, pixelY: u32) -> vec4<f32> {
-    if (pixelX >= params.width || pixelY >= params.height) {
-        return vec4<f32>(0.0, 0.0, 0.0, 1.0); // Black for out-of-bounds
-    }
-    
-    // textureLoad automatically handles format conversion to RGBA
-    return textureLoad(inputTexture, vec2<i32>(i32(pixelX), i32(pixelY)), 0);
-}
-
-fn colorDistance(a: vec4<f32>, b: vec4<f32>) -> f32 {
-    let diff = a.rgb - b.rgb;
-    return dot(diff, diff);
-}
-
-fn luminance(color: vec4<f32>) -> f32 {
-    return 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
-}
-
-fn closestColorIndex(pixel: vec4<f32>, candA: vec4<f32>, candB: vec4<f32>) -> u32 {
-    return select(1u, 0u, colorDistance(pixel, candA) <= colorDistance(pixel, candB));
-}
-
-fn averageColor(pixels: array<vec4<f32>, 4>) -> vec4<f32> {
-    return (pixels[0] + pixels[1] + pixels[2] + pixels[3]) * 0.25;
-}
-
-fn blendColors(color1: vec4<f32>, color2: vec4<f32>) -> vec4<f32> {
-    let a1 = color1.a;
-    let a2 = color2.a;
-    
-    if (a1 == 0.0 && a2 == 0.0) {
-        return vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    }
-    
-    let outAlpha = a1 + a2 - a1 * a2;
-    if (outAlpha == 0.0) {
-        return vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    }
-    
-    let rgb = (color1.rgb * a1 + color2.rgb * a2 * (1.0 - a1)) / outAlpha;
-    
-    return vec4<f32>(rgb, outAlpha);
-}
-
-fn averageColorsWithAlpha(pixels: array<vec4<f32>, 4>) -> vec4<f32> {
-    let blend1 = blendColors(pixels[0], pixels[1]);
-    let blend2 = blendColors(pixels[2], pixels[3]);
-    
-    return blendColors(blend1, blend2);
-}
-
-fn renderQuadrantBlock(pixels: array<vec4<f32>, 4>) -> CellResult {
-    var maxDist: f32 = colorDistance(pixels[0], pixels[1]);
-    var pIdxA: u32 = 0u;
-    var pIdxB: u32 = 1u;
-    
-    for (var i: u32 = 0u; i < 4u; i++) {
-        for (var j: u32 = i + 1u; j < 4u; j++) {
-            let dist = colorDistance(pixels[i], pixels[j]);
-            if (dist > maxDist) {
-                pIdxA = i;
-                pIdxB = j;
-                maxDist = dist;
-            }
-        }
-    }
-    
-    let pCandA = pixels[pIdxA];
-    let pCandB = pixels[pIdxB];
-    
-    var chosenDarkColor: vec4<f32>;
-    var chosenLightColor: vec4<f32>;
-    
-    if (luminance(pCandA) <= luminance(pCandB)) {
-        chosenDarkColor = pCandA;
-        chosenLightColor = pCandB;
-    } else {
-        chosenDarkColor = pCandB;
-        chosenLightColor = pCandA;
-    }
-    
-    var quadrantBits: u32 = 0u;
-    let bitValues = array<u32, 4>(8u, 4u, 2u, 1u); // TL, TR, BL, BR
-    
-    for (var i: u32 = 0u; i < 4u; i++) {
-        if (closestColorIndex(pixels[i], chosenDarkColor, chosenLightColor) == 0u) {
-            quadrantBits |= bitValues[i];
-        }
-    }
-    
-    // Construct result
-    var result: CellResult;
-    
-    if (quadrantBits == 0u) { // All light
-        result.char = 32u; // Space character
-        result.fg = chosenDarkColor;
-        result.bg = averageColorsWithAlpha(pixels);
-    } else if (quadrantBits == 15u) { // All dark  
-        result.char = quadrantChars[15]; // Full block
-        result.fg = averageColorsWithAlpha(pixels);
-        result.bg = chosenLightColor;
-    } else { // Mixed pattern
-        result.char = quadrantChars[quadrantBits];
-        result.fg = chosenDarkColor;
-        result.bg = chosenLightColor;
-    }
-    result._padding1 = 0u;
-    result._padding2 = 0u;
-    result._padding3 = 0u;
-    
-    return result;
-}
-
-@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
-fn main(@builtin(global_invocation_id) id: vec3<u32>) {
-    let cellX = id.x;
-    let cellY = id.y;
-    let bufferWidthCells = (params.width + 1u) / 2u;
-    let bufferHeightCells = (params.height + 1u) / 2u;
-    
-    if (cellX >= bufferWidthCells || cellY >= bufferHeightCells) {
-        return;
-    }
-    
-    let renderX = cellX * 2u;
-    let renderY = cellY * 2u;
-    
-    var pixelsRgba: array<vec4<f32>, 4>;
-    
-    if (params.sampleAlgo == 1u) {
-        let topColor = getPixelColor(renderX, renderY);
-        let topColor2 = getPixelColor(renderX + 1u, renderY);
-        
-        let blendedTop = blendColors(topColor, topColor2);
-        
-        let bottomColor = getPixelColor(renderX, renderY + 1u);
-        let bottomColor2 = getPixelColor(renderX + 1u, renderY + 1u);
-        let blendedBottom = blendColors(bottomColor, bottomColor2);
-        
-        pixelsRgba[0] = blendedTop;      // TL
-        pixelsRgba[1] = blendedTop;      // TR  
-        pixelsRgba[2] = blendedBottom;   // BL
-        pixelsRgba[3] = blendedBottom;   // BR
-    } else {
-        pixelsRgba[0] = getPixelColor(renderX, renderY);         // TL
-        pixelsRgba[1] = getPixelColor(renderX + 1u, renderY);   // TR  
-        pixelsRgba[2] = getPixelColor(renderX, renderY + 1u);   // BL
-        pixelsRgba[3] = getPixelColor(renderX + 1u, renderY + 1u); // BR
-    }
-    
-    let cellResult = renderQuadrantBlock(pixelsRgba);
-    
-    let outputIndex = cellY * bufferWidthCells + cellX;
-    output.cells[outputIndex] = cellResult;
-}