@solidtv/renderer 1.0.7 → 1.1.0

package/src/core/text-rendering/TextLayoutEngine.ts

@@ -227,7 +227,9 @@ export const wrapText = (
         : [[['', 0, false, 0, 0]], remainingLines, i < lines.length - 1];
 
     remainingLines--;
-    wrappedLines.push(...wrappedLine);
+    for (let j = 0; j < wrappedLine.length; j++) {
+      wrappedLines.push(wrappedLine[j]!);
+    }
 
     if (hasMaxLines === true && remainingLines <= 0) {
       const lastLine = wrappedLines[wrappedLines.length - 1]!;
@@ -278,44 +280,75 @@ export const wrapLine = (
   let hasRemainingText = true;
 
   const wrapFn = getWrapStrategy(wordBreak);
-  while (words.length > 0 && remainingLines > 0) {
-    let word = words.shift()!;
-    let wordWidth = measureText(word, fontFamily, letterSpacing);
+  let wordIdx = 0;
+  let spaceIdx = 0;
+  let pendingWord = '';
+
+  while (
+    (pendingWord.length > 0 || wordIdx < words.length) &&
+    remainingLines > 0
+  ) {
+    let word: string;
+    let wordWidth: number;
     let remainingWord = '';
 
+    if (pendingWord.length > 0) {
+      word = pendingWord;
+      pendingWord = '';
+    } else {
+      word = words[wordIdx++]!;
+    }
+    wordWidth = measureText(word, fontFamily, letterSpacing);
+
     //handle first word of new line separately to avoid empty line issues
     if (currentLineWidth === 0) {
       // Word doesn't fit on current line
       //if first word doesn't fit on empty line
       if (wordWidth > maxWidth) {
         remainingLines--;
+        const isLastLine = remainingLines === 0;
+        let lineTruncated = isLastLine;
         //truncate word to fit
-        [word, remainingWord, wordWidth] =
-          remainingLines === 0
-            ? truncateWord(
-                measureText,
-                word,
-                wordWidth,
-                maxWidth,
-                fontFamily,
-                letterSpacing,
-                overflowSuffix,
-                overflowWidth,
-              )
-            : splitWord(
-                measureText,
-                word,
-                wordWidth,
-                maxWidth,
-                fontFamily,
-                letterSpacing,
-              );
+        [word, remainingWord, wordWidth] = isLastLine
+          ? truncateWord(
+              measureText,
+              word,
+              wordWidth,
+              maxWidth,
+              fontFamily,
+              letterSpacing,
+              overflowSuffix,
+              overflowWidth,
+            )
+          : splitWord(
+              measureText,
+              word,
+              wordWidth,
+              maxWidth,
+              fontFamily,
+              letterSpacing,
+            );
 
         if (remainingWord.length > 0) {
-          words.unshift(remainingWord);
+          if (word.length === 0) {
+            if (overflowSuffix.length > 0) {
+              word = overflowSuffix;
+              wordWidth = overflowWidth;
+            } else {
+              word = remainingWord.charAt(0);
+              if (word.length === 0) {
+                break;
+              }
+              wordWidth = measureText(word, fontFamily, letterSpacing);
+            }
+            remainingWord = '';
+            remainingLines = 0;
+            lineTruncated = true;
+          }
+          pendingWord = remainingWord;
         }
         // first word doesn't fit on an empty line
-        wrappedLines.push([word, wordWidth, false, 0, 0]);
+        wrappedLines.push([word, wordWidth, lineTruncated, 0, 0]);
       } else if (wordWidth + spaceWidth >= maxWidth) {
         remainingLines--;
         // word with space doesn't fit, but word itself fits - put on new line
@@ -326,7 +359,7 @@ export const wrapLine = (
       }
       continue;
     }
-    const space = spaces.shift() || '';
+    const space = spaces[spaceIdx++] || '';
     // For width calculation, treat ZWSP as having 0 width but regular space functionality
     const effectiveSpaceWidth = space === '\u200B' ? 0 : spaceWidth;
     const totalWidth = currentLineWidth + effectiveSpaceWidth + wordWidth;
@@ -367,7 +400,7 @@ export const wrapLine = (
     );
 
     if (remainingWord.length > 0) {
-      words.unshift(remainingWord);
+      pendingWord = remainingWord;
     }
   }
 

package/src/core/text-rendering/tests/TextLayoutEngine.test.ts

@@ -228,6 +228,26 @@ describe('SDF Text Utils', () => {
       expect(result[0].length).toBeGreaterThan(1);
       expect(result[0][0]?.[0]).toBe('hello world test');
     });
+
+    it('should return non-empty output when maxWidth is smaller than glyph and suffix width', () => {
+      const result = wrapLine(
+        testMeasureText,
+        'hello',
+        'Arial',
+        5,
+        0,
+        10,
+        '...',
+        30,
+        'break-word',
+        1,
+      );
+
+      expect(result[0]).toHaveLength(1);
+      expect(result[0][0]?.[0]).toBe('...');
+      expect(result[0][0]?.[2]).toBe(true);
+      expect(result[1]).toBe(0);
+    });
   });
 
   describe('wrapText', () => {

package/src/main-api/Renderer.ts

@@ -680,8 +680,12 @@ export class RendererMain extends EventEmitter {
    */
   createNode<ShNode extends CoreShaderNode<any>>(
     props: Partial<INodeProps<ShNode>>,
+    resolved = false,
   ): INode<ShNode> {
-    const node = this.stage.createNode(props as Partial<CoreNodeProps>);
+    const node = this.stage.createNode(
+      props as Partial<CoreNodeProps>,
+      resolved,
+    );
 
     if (ENABLE_INSPECTOR && this.inspector) {
       return this.inspector.createNode(node) as unknown as INode<ShNode>;
@@ -690,6 +694,20 @@ export class RendererMain extends EventEmitter {
     return node as unknown as INode<ShNode>;
   }
 
+  /**
+   * Allocate a fully-resolved CoreNodeProps bag — the same shape and
+   * defaults the renderer would otherwise build inside `createNode`.
+   *
+   * Frameworks (e.g. solid-tv) call this once per node at construction
+   * time, fill it in as user props flow in, then pass it back via
+   * `createNode(props, true)`.  The renderer adopts the bag directly:
+   * one allocation instead of two, and a stable hidden class for the
+   * node's lifetime.
+   */
+  createNodeProps(initial?: Partial<CoreNodeProps>): CoreNodeProps {
+    return this.stage.createNodeProps(initial);
+  }
+
   /**
    * Create a new scene graph text node
    *
@@ -704,8 +722,11 @@ export class RendererMain extends EventEmitter {
    * @param props
    * @returns
    */
-  createTextNode(props: Partial<ITextNodeProps>): ITextNode {
-    const textNode = this.stage.createTextNode(props as CoreTextNodeProps);
+  createTextNode(props: Partial<ITextNodeProps>, resolved = false): ITextNode {
+    const textNode = this.stage.createTextNode(
+      props as CoreTextNodeProps,
+      resolved,
+    );
 
     if (ENABLE_INSPECTOR && this.inspector) {
       return this.inspector.createTextNode(textNode) as unknown as ITextNode;
@@ -714,6 +735,14 @@ export class RendererMain extends EventEmitter {
     return textNode as unknown as ITextNode;
   }
 
+  /**
+   * Allocate a fully-resolved CoreTextNodeProps bag.  See
+   * {@link createNodeProps}.
+   */
+  createTextNodeProps(initial?: Partial<CoreTextNodeProps>): CoreTextNodeProps {
+    return this.stage.createTextNodeProps(initial);
+  }
+
   /**
    * Destroy a node
    *