three-text 0.2.17 → 0.2.19

package/dist/index.js

@@ -1,5 +1,5 @@
 /*!
- * three-text v0.2.17
+ * three-text v0.2.19
  * Copyright (C) 2025 Countertype LLC
  * 
  * This program is free software: you can redistribute it and/or modify
@@ -78,7 +78,9 @@ class PerformanceLogger {
         // Find the metric in reverse order (most recent first)
         for (let i = this.metrics.length - 1; i >= 0; i--) {
             const metric = this.metrics[i];
-            if (metric.name === name && metric.startTime === startTime && !metric.endTime) {
+            if (metric.name === name &&
+                metric.startTime === startTime &&
+                !metric.endTime) {
                 metric.endTime = endTime;
                 metric.duration = duration;
                 break;
@@ -466,7 +468,9 @@ class LineBreak {
             const char = chars[i];
             const nextChar = i < chars.length - 1 ? chars[i + 1] : null;
             if (/\s/.test(char)) {
-                const width = widths ? (widths[i] ?? measureText(char)) : measureText(char);
+                const width = widths
+                    ? (widths[i] ?? measureText(char))
+                    : measureText(char);
                 items.push({
                     type: ItemType.GLUE,
                     width,
@@ -839,7 +843,9 @@ class LineBreak {
             if (breaks.length === 0) {
                 // For first emergency attempt, use initialEmergencyStretch
                 // For subsequent iterations (short line detection), progressively increase
-                currentEmergencyStretch = initialEmergencyStretch + (iteration * width * SHORT_LINE_EMERGENCY_STRETCH_INCREMENT);
+                currentEmergencyStretch =
+                    initialEmergencyStretch +
+                        iteration * width * SHORT_LINE_EMERGENCY_STRETCH_INCREMENT;
                 breaks = LineBreak.findBreakpoints(currentItems, width, tolerance, looseness, true, currentEmergencyStretch, context);
             }
             // Last resort: allow higher badness (but not infinite)
@@ -1720,12 +1726,12 @@ class FontMetadataExtractor {
         try {
             if (gsubTableOffset) {
                 const gsubData = this.extractFeatureDataFromTable(view, gsubTableOffset, nameTableOffset);
-                gsubData.features.forEach(f => features.add(f));
+                gsubData.features.forEach((f) => features.add(f));
                 Object.assign(featureNames, gsubData.names);
             }
             if (gposTableOffset) {
                 const gposData = this.extractFeatureDataFromTable(view, gposTableOffset, nameTableOffset);
-                gposData.features.forEach(f => features.add(f));
+                gposData.features.forEach((f) => features.add(f));
                 Object.assign(featureNames, gposData.names);
             }
         }
@@ -2724,7 +2730,9 @@ class Tessellator {
             tessContours = originalContours;
         }
         let extrusionContours = needsExtrusionContours
-            ? originalContours ?? this.pathsToContours(paths)
+            ? needsWindingReversal
+                ? tessContours
+                : (originalContours ?? this.pathsToContours(paths))
             : [];
         if (removeOverlaps) {
             logger.log('Two-pass: boundary extraction then triangulation');
@@ -2746,24 +2754,6 @@ class Tessellator {
         }
         else {
             logger.log(`Single-pass triangulation for ${isCFF ? 'CFF' : 'TTF'}`);
-            // TTF contours may have inconsistent winding; check if we need normalization
-            if (needsExtrusionContours && !isCFF) {
-                const needsNormalization = this.needsWindingNormalization(extrusionContours);
-                if (needsNormalization) {
-                    logger.log('Complex topology detected, running boundary pass for winding normalization');
-                    perfLogger.start('Tessellator.windingNormalization', {
-                        contourCount: extrusionContours.length
-                    });
-                    const boundaryResult = this.performTessellation(extrusionContours, 'boundary');
-                    perfLogger.end('Tessellator.windingNormalization');
-                    if (boundaryResult) {
-                        extrusionContours = this.boundaryToContours(boundaryResult);
-                    }
-                }
-                else {
-                    logger.log('Simple topology, skipping winding normalization');
-                }
-            }
         }
         perfLogger.start('Tessellator.triangulationPass', {
             contourCount: tessContours.length
@@ -2775,7 +2765,10 @@ class Tessellator {
                 ? 'libtess returned empty result from triangulation pass'
                 : 'libtess returned empty result from single-pass triangulation';
             logger.warn(warning);
-            return { triangles: { vertices: [], indices: [] }, contours: extrusionContours };
+            return {
+                triangles: { vertices: [], indices: [] },
+                contours: extrusionContours
+            };
         }
         return {
             triangles: {
@@ -2945,28 +2938,58 @@ class Tessellator {
 
 class Extruder {
     constructor() { }
+    packEdge(a, b) {
+        const lo = a < b ? a : b;
+        const hi = a < b ? b : a;
+        return lo * 0x100000000 + hi;
+    }
     extrude(geometry, depth = 0, unitsPerEm) {
         const points = geometry.triangles.vertices;
         const triangleIndices = geometry.triangles.indices;
         const numPoints = points.length / 2;
-        // Count side-wall segments (4 vertices + 6 indices per segment)
-        let sideSegments = 0;
+        // Count boundary edges for side walls (4 vertices + 6 indices per edge)
+        let boundaryEdges = [];
         if (depth !== 0) {
-            for (const contour of geometry.contours) {
-                // Contours are closed (last point repeats first)
-                const contourPoints = contour.length / 2;
-                if (contourPoints >= 2)
-                    sideSegments += contourPoints - 1;
+            const counts = new Map();
+            const oriented = new Map();
+            for (let i = 0; i < triangleIndices.length; i += 3) {
+                const a = triangleIndices[i];
+                const b = triangleIndices[i + 1];
+                const c = triangleIndices[i + 2];
+                const k0 = this.packEdge(a, b);
+                const n0 = (counts.get(k0) ?? 0) + 1;
+                counts.set(k0, n0);
+                if (n0 === 1)
+                    oriented.set(k0, [a, b]);
+                const k1 = this.packEdge(b, c);
+                const n1 = (counts.get(k1) ?? 0) + 1;
+                counts.set(k1, n1);
+                if (n1 === 1)
+                    oriented.set(k1, [b, c]);
+                const k2 = this.packEdge(c, a);
+                const n2 = (counts.get(k2) ?? 0) + 1;
+                counts.set(k2, n2);
+                if (n2 === 1)
+                    oriented.set(k2, [c, a]);
+            }
+            boundaryEdges = [];
+            for (const [key, count] of counts) {
+                if (count !== 1)
+                    continue;
+                const edge = oriented.get(key);
+                if (edge)
+                    boundaryEdges.push(edge);
             }
         }
-        const sideVertexCount = depth === 0 ? 0 : sideSegments * 4;
+        const sideEdgeCount = depth === 0 ? 0 : boundaryEdges.length;
+        const sideVertexCount = depth === 0 ? 0 : sideEdgeCount * 4;
         const baseVertexCount = depth === 0 ? numPoints : numPoints * 2;
         const vertexCount = baseVertexCount + sideVertexCount;
         const vertices = new Float32Array(vertexCount * 3);
         const normals = new Float32Array(vertexCount * 3);
         const indexCount = depth === 0
             ? triangleIndices.length
-            : triangleIndices.length * 2 + sideSegments * 6;
+            : triangleIndices.length * 2 + sideEdgeCount * 6;
         const indices = new Uint32Array(indexCount);
         if (depth === 0) {
             // Single-sided flat geometry at z=0
@@ -3022,60 +3045,62 @@ class Extruder {
         // Side walls
         let nextVertex = numPoints * 2;
         let idxPos = triangleIndices.length * 2;
-        for (const contour of geometry.contours) {
-            for (let i = 0; i < contour.length - 2; i += 2) {
-                const p0x = contour[i];
-                const p0y = contour[i + 1];
-                const p1x = contour[i + 2];
-                const p1y = contour[i + 3];
-                // Perpendicular normal for this wall segment
-                const ex = p1x - p0x;
-                const ey = p1y - p0y;
-                const lenSq = ex * ex + ey * ey;
-                let nx = 0;
-                let ny = 0;
-                if (lenSq > 0) {
-                    const invLen = 1 / Math.sqrt(lenSq);
-                    nx = ey * invLen;
-                    ny = -ex * invLen;
-                }
-                const baseVertex = nextVertex;
-                const base = baseVertex * 3;
-                // Wall quad: front edge at z=0, back edge at z=depth
-                vertices[base] = p0x;
-                vertices[base + 1] = p0y;
-                vertices[base + 2] = 0;
-                vertices[base + 3] = p1x;
-                vertices[base + 4] = p1y;
-                vertices[base + 5] = 0;
-                vertices[base + 6] = p0x;
-                vertices[base + 7] = p0y;
-                vertices[base + 8] = backZ;
-                vertices[base + 9] = p1x;
-                vertices[base + 10] = p1y;
-                vertices[base + 11] = backZ;
-                // Wall normals point perpendicular to edge
-                normals[base] = nx;
-                normals[base + 1] = ny;
-                normals[base + 2] = 0;
-                normals[base + 3] = nx;
-                normals[base + 4] = ny;
-                normals[base + 5] = 0;
-                normals[base + 6] = nx;
-                normals[base + 7] = ny;
-                normals[base + 8] = 0;
-                normals[base + 9] = nx;
-                normals[base + 10] = ny;
-                normals[base + 11] = 0;
-                // Two triangles per wall segment
-                indices[idxPos++] = baseVertex;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 2;
-                indices[idxPos++] = baseVertex + 1;
-                indices[idxPos++] = baseVertex + 3;
-                indices[idxPos++] = baseVertex + 2;
-                nextVertex += 4;
-            }
+        for (let e = 0; e < boundaryEdges.length; e++) {
+            const [u, v] = boundaryEdges[e];
+            const u2 = u * 2;
+            const v2 = v * 2;
+            const p0x = points[u2];
+            const p0y = points[u2 + 1];
+            const p1x = points[v2];
+            const p1y = points[v2 + 1];
+            // Perpendicular normal for this wall segment
+            // Uses the edge direction from the cap triangulation so winding does not depend on contour direction
+            const ex = p1x - p0x;
+            const ey = p1y - p0y;
+            const lenSq = ex * ex + ey * ey;
+            let nx = 0;
+            let ny = 0;
+            if (lenSq > 0) {
+                const invLen = 1 / Math.sqrt(lenSq);
+                nx = ey * invLen;
+                ny = -ex * invLen;
+            }
+            const baseVertex = nextVertex;
+            const base = baseVertex * 3;
+            // Wall quad: front edge at z=0, back edge at z=depth
+            vertices[base] = p0x;
+            vertices[base + 1] = p0y;
+            vertices[base + 2] = 0;
+            vertices[base + 3] = p1x;
+            vertices[base + 4] = p1y;
+            vertices[base + 5] = 0;
+            vertices[base + 6] = p0x;
+            vertices[base + 7] = p0y;
+            vertices[base + 8] = backZ;
+            vertices[base + 9] = p1x;
+            vertices[base + 10] = p1y;
+            vertices[base + 11] = backZ;
+            // Wall normals point perpendicular to edge
+            normals[base] = nx;
+            normals[base + 1] = ny;
+            normals[base + 2] = 0;
+            normals[base + 3] = nx;
+            normals[base + 4] = ny;
+            normals[base + 5] = 0;
+            normals[base + 6] = nx;
+            normals[base + 7] = ny;
+            normals[base + 8] = 0;
+            normals[base + 9] = nx;
+            normals[base + 10] = ny;
+            normals[base + 11] = 0;
+            // Two triangles per wall segment
+            indices[idxPos++] = baseVertex;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 2;
+            indices[idxPos++] = baseVertex + 1;
+            indices[idxPos++] = baseVertex + 3;
+            indices[idxPos++] = baseVertex + 2;
+            nextVertex += 4;
         }
         return { vertices, normals, indices };
     }
@@ -3400,9 +3425,7 @@ class PathOptimizer {
             const v1LenSq = v1x * v1x + v1y * v1y;
             const v2LenSq = v2x * v2x + v2y * v2y;
             const minLenSq = this.config.minSegmentLength * this.config.minSegmentLength;
-            if (angle > threshold ||
-                v1LenSq < minLenSq ||
-                v2LenSq < minLenSq) {
+            if (angle > threshold || v1LenSq < minLenSq || v2LenSq < minLenSq) {
                 result.push(current);
             }
             else {
@@ -4164,7 +4187,7 @@ class GlyphGeometryBuilder {
                         const relativePositions = cluster.glyphs.map((g) => new Vec3(g.x ?? 0, g.y ?? 0, 0));
                         boundaryGroups = this.clusterer.cluster(clusterGlyphContours, relativePositions);
                         this.clusteringCache.set(cacheKey, {
-                            glyphIds: cluster.glyphs.map(g => g.g),
+                            glyphIds: cluster.glyphs.map((g) => g.g),
                             groups: boundaryGroups
                         });
                     }
@@ -4174,7 +4197,7 @@ class GlyphGeometryBuilder {
                 // Use glyph-level caching when separateGlyphs is set or when cluster contains colored text
                 const forceSeparate = separateGlyphs || clusterHasColoredGlyphs;
                 // Iterate over the geometric groups identified by BoundaryClusterer
-                // logical groups (words) split into geometric sub-groups (e.g. "aa", "XX", "bb")
+                // logical groups (words) split into geometric sub-groups
                 for (const groupIndices of boundaryGroups) {
                     const isOverlappingGroup = groupIndices.length > 1;
                     const shouldCluster = isOverlappingGroup && !forceSeparate;
@@ -4554,7 +4577,8 @@ class TextShaper {
                     if (LineBreak.isCJOpeningPunctuation(currentChar)) {
                         shouldApply = false;
                     }
-                    if (LineBreak.isCJPunctuation(currentChar) && LineBreak.isCJPunctuation(nextChar)) {
+                    if (LineBreak.isCJPunctuation(currentChar) &&
+                        LineBreak.isCJPunctuation(nextChar)) {
                         shouldApply = false;
                     }
                     if (shouldApply) {
@@ -5358,7 +5382,7 @@ class Text {
     // Stringify with sorted keys for cache stability
     static stableStringify(obj) {
         const keys = Object.keys(obj).sort();
-        const pairs = keys.map(k => `${k}:${obj[k]}`);
+        const pairs = keys.map((k) => `${k}:${obj[k]}`);
         return pairs.join(',');
     }
     constructor() {
@@ -5596,7 +5620,9 @@ class Text {
             // to selectively use glyph-level caching (separate vertices) only for clusters containing
             // colored text, while non-colored clusters can still use fast cluster-level merging
             let coloredTextIndices;
-            if (options.color && typeof options.color === 'object' && !Array.isArray(options.color)) {
+            if (options.color &&
+                typeof options.color === 'object' &&
+                !Array.isArray(options.color)) {
                 if (options.color.byText || options.color.byCharRange) {
                     // Build the set manually since glyphs don't exist yet
                     coloredTextIndices = new Set();
@@ -5701,7 +5727,9 @@ class Text {
         const depthScale = this.loadedFont.upem / size;
         const rawDepthInFontUnits = depth * depthScale;
         const minExtrudeDepth = this.loadedFont.upem * 0.000025;
-        const depthInFontUnits = rawDepthInFontUnits <= 0 ? 0 : Math.max(rawDepthInFontUnits, minExtrudeDepth);
+        const depthInFontUnits = rawDepthInFontUnits <= 0
+            ? 0
+            : Math.max(rawDepthInFontUnits, minExtrudeDepth);
         if (!this.textLayout) {
             this.textLayout = new TextLayout(this.loadedFont);
         }
@@ -5873,10 +5901,12 @@ class Text {
         planeBounds.max.z *= finalScale;
         for (let i = 0; i < glyphInfoArray.length; i++) {
             const glyphInfo = glyphInfoArray[i];
-            glyphInfo.bounds.min.x = glyphInfo.bounds.min.x * finalScale + offsetScaled;
+            glyphInfo.bounds.min.x =
+                glyphInfo.bounds.min.x * finalScale + offsetScaled;
             glyphInfo.bounds.min.y *= finalScale;
             glyphInfo.bounds.min.z *= finalScale;
-            glyphInfo.bounds.max.x = glyphInfo.bounds.max.x * finalScale + offsetScaled;
+            glyphInfo.bounds.max.x =
+                glyphInfo.bounds.max.x * finalScale + offsetScaled;
             glyphInfo.bounds.max.y *= finalScale;
             glyphInfo.bounds.max.z *= finalScale;
         }
@@ -5939,13 +5969,11 @@ class Text {
     static registerPattern(language, pattern) {
         Text.patternCache.set(language, pattern);
     }
-    static clearFontCache() {
-        Text.fontCache.clear();
-        Text.fontCacheMemoryBytes = 0;
-    }
     static setMaxFontCacheMemoryMB(limitMB) {
         Text.maxFontCacheMemoryBytes =
-            limitMB === Infinity ? Infinity : Math.max(1, Math.floor(limitMB)) * 1024 * 1024;
+            limitMB === Infinity
+                ? Infinity
+                : Math.max(1, Math.floor(limitMB)) * 1024 * 1024;
         Text.enforceFontCacheMemoryLimit();
     }
     getLoadedFont() {