@opentui/core 0.1.4 → 0.1.6

package/3d.js

@@ -19581,16 +19581,6 @@ function parseColor(color) {
   }
   return color;
 }
-async function loadTemplate(filePath, params) {
-  const template = await Bun.file(filePath).text();
-  return template.replace(/\${(\w+)}/g, (match, key) => params[key] || match);
-}
-function fixPaths(paths) {
-  if (process.env.BUN_PACKER_BUNDLE) {
-    return Object.fromEntries(Object.entries(paths).map(([key, value]) => [key, value.replace("../", "")]));
-  }
-  return paths;
-}
 
 // src/types.ts
 class RGBA {
@@ -31407,16 +31397,211 @@ var Jimp = createJimp({
 });
 
 // src/3d/shaders/supersampling.wgsl
-var supersampling_default = "./supersampling-jw3fem06.wgsl";
+var supersampling_default = `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,  // \u2597   - 0001 BR
+    0x2596u,  // \u2596   - 0010 BL  
+    0x2584u,  // \u2584   - 0011 Lower Half Block
+    0x259Du,  // \u259D   - 0100 TR
+    0x2590u,  // \u2590   - 0101 Right Half Block
+    0x259Eu,  // \u259E   - 0110 TR+BL
+    0x259Fu,  // \u259F   - 0111 TR+BL+BR
+    0x2598u,  // \u2598   - 1000 TL
+    0x259Au,  // \u259A   - 1001 TL+BR
+    0x258Cu,  // \u258C   - 1010 Left Half Block
+    0x2599u,  // \u2599   - 1011 TL+BL+BR
+    0x2580u,  // \u2580   - 1100 Upper Half Block
+    0x259Cu,  // \u259C   - 1101 TL+TR+BR
+    0x259Bu,  // \u259B   - 1110 TL+TR+BL
+    0x2588u   // \u2588   - 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;
+}`;
 
 // src/3d/canvas.ts
-var filePaths = fixPaths({
-  shaderPath: supersampling_default
-});
 var WORKGROUP_SIZE = 4;
-var SUPERSAMPLING_COMPUTE_SHADER = await loadTemplate(filePaths.shaderPath, {
-  WORKGROUP_SIZE: WORKGROUP_SIZE.toString()
-});
+var SUPERSAMPLING_COMPUTE_SHADER = supersampling_default.replace(/\${WORKGROUP_SIZE}/g, WORKGROUP_SIZE.toString());
 var SuperSampleAlgorithm;
 ((SuperSampleAlgorithm2) => {
   SuperSampleAlgorithm2[SuperSampleAlgorithm2["STANDARD"] = 0] = "STANDARD";
@@ -33791,6 +33976,18 @@ function parseJustify(value) {
       return Justify.FlexStart;
   }
 }
+function parsePositionType(value) {
+  switch (value.toLowerCase()) {
+    case "static":
+      return PositionType.Static;
+    case "relative":
+      return PositionType.Relative;
+    case "absolute":
+      return PositionType.Absolute;
+    default:
+      return PositionType.Static;
+  }
+}
 
 // src/Renderable.ts
 var renderableNumber = 1;
@@ -34101,8 +34298,8 @@ class Renderable extends EventEmitter3 {
       this.layoutNode.setHeight(options.height);
     }
     this._positionType = options.position ?? "relative";
-    if (this._positionType === "absolute") {
-      node.setPositionType(PositionType.Absolute);
+    if (this._positionType !== "relative") {
+      node.setPositionType(parsePositionType(this._positionType));
     }
     const hasPositionProps = options.top !== undefined || options.right !== undefined || options.bottom !== undefined || options.left !== undefined;
     if (hasPositionProps) {
@@ -34161,6 +34358,14 @@ class Renderable extends EventEmitter3 {
       node.setPadding(Edge2.Left, options.paddingLeft);
     }
   }
+  set position(positionType) {
+    if (this._positionType === positionType)
+      return;
+    this._positionType = positionType;
+    this.layoutNode.yogaNode.setPositionType(parsePositionType(positionType));
+    this.needsUpdate();
+    this._yogaPerformancePositionUpdated = true;
+  }
   setPosition(position) {
     this._position = { ...this._position, ...position };
     this.updateYogaPosition(position);
@@ -35368,6 +35573,77 @@ var BorderCharArrays = {
   rounded: borderCharsToArray(BorderChars.rounded),
   heavy: borderCharsToArray(BorderChars.heavy)
 };
+// src/lib/styled-text.ts
+var textEncoder = new TextEncoder;
+
+class StyledText {
+  chunks;
+  _plainText = "";
+  constructor(chunks) {
+    this.chunks = chunks;
+    for (let i = 0;i < chunks.length; i++) {
+      this._plainText += chunks[i].plainText;
+    }
+  }
+  toString() {
+    return this._plainText;
+  }
+  _chunksToPlainText() {
+    this._plainText = "";
+    for (const chunk of this.chunks) {
+      this._plainText += chunk.plainText;
+    }
+  }
+  insert(chunk, index) {
+    const originalLength = this.chunks.length;
+    if (index === undefined) {
+      this.chunks.push(chunk);
+    } else {
+      this.chunks.splice(index, 0, chunk);
+    }
+    if (index === undefined || index === originalLength) {
+      this._plainText += chunk.plainText;
+    } else {
+      this._chunksToPlainText();
+    }
+  }
+  remove(chunk) {
+    const originalLength = this.chunks.length;
+    const index = this.chunks.indexOf(chunk);
+    if (index === -1)
+      return;
+    this.chunks.splice(index, 1);
+    if (index === originalLength - 1) {
+      this._plainText = this._plainText.slice(0, this._plainText.length - chunk.plainText.length);
+    } else {
+      this._chunksToPlainText();
+    }
+  }
+  replace(chunk, oldChunk) {
+    const index = this.chunks.indexOf(oldChunk);
+    if (index === -1)
+      return;
+    this.chunks.splice(index, 1, chunk);
+    if (index === this.chunks.length - 1) {
+      this._plainText = this._plainText.slice(0, this._plainText.length - oldChunk.plainText.length) + chunk.plainText;
+    } else {
+      this._chunksToPlainText();
+    }
+  }
+}
+function stringToStyledText(content) {
+  const textEncoder2 = new TextEncoder;
+  const chunk = {
+    __isChunk: true,
+    text: textEncoder2.encode(content),
+    plainText: content
+  };
+  return new StyledText([chunk]);
+}
+var templateCache = new WeakMap;
+
+// src/lib/hast-styled-text.ts
+var textEncoder2 = new TextEncoder;
 // src/buffer.ts
 var fbIdCounter = 0;
 function isRGBAWithAlpha(color) {
@@ -35748,35 +36024,6 @@ class TimelineEngine {
   }
 }
 var engine = new TimelineEngine;
-// src/lib/styled-text.ts
-var textEncoder = new TextEncoder;
-
-class StyledText {
-  chunks;
-  _length;
-  _plainText;
-  constructor(chunks, length, plainText) {
-    this.chunks = chunks;
-    this._length = length;
-    this._plainText = plainText;
-  }
-  toString() {
-    return this._plainText;
-  }
-  get length() {
-    return this._length;
-  }
-}
-function stringToStyledText(content) {
-  const textEncoder2 = new TextEncoder;
-  const chunk = {
-    __isChunk: true,
-    text: textEncoder2.encode(content),
-    plainText: content
-  };
-  return new StyledText([chunk], content.length, content);
-}
-var templateCache = new WeakMap;
 // src/lib/selection.ts
 class Selection {
   _anchor;
@@ -37681,8 +37928,6 @@ class TextRenderable extends Renderable {
   set content(value) {
     this._text = typeof value === "string" ? stringToStyledText(value) : value;
     this.updateTextInfo();
-    this.setupMeasureFunc();
-    this.needsUpdate();
   }
   get fg() {
     return this._defaultFg;

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 opentui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Renderable.d.ts

@@ -126,6 +126,7 @@ export declare abstract class Renderable extends EventEmitter {
     private ensureZIndexSorted;
     private setupYogaProperties;
     private setupMarginAndPadding;
+    set position(positionType: PositionTypeString);
     setPosition(position: Position): void;
     private updateYogaPosition;
     set flexGrow(grow: number);

package/index.d.ts

@@ -12,3 +12,4 @@ export * from "./lib/selection";
 export * from "./renderer";
 export * from "./renderables";
 export * from "./zig";
+export * from "./console";