react-native-tinyui 0.2.0 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # react-native-tinyui
 
-Dependency-free, native iOS `Menu` and `Popover` components for React Native's
+Dependency-free, native iOS `Menu`, `Popover` and `LiquidGlassText` components for React Native's
 New Architecture. The public API follows normal React composition patterns;
 the native UI is implemented with SwiftUI behind Fabric components.
 
@@ -44,8 +44,9 @@ Available components:
 
 - `Menu`
 - `Popover`
+- `LiquidGlassText`
 
-Both components are enabled by default. Use an empty `components` array to
+All components are enabled by default. Use an empty `components` array to
 compile only the TurboModule core. Run `pod install` again whenever this list
 changes. Rendering a component whose native part was not selected throws an
 error that names the missing component.
@@ -55,6 +56,7 @@ Component-specific JavaScript entry points are also available:
 ```tsx
 import { Menu } from 'react-native-tinyui/menu';
 import { Popover } from 'react-native-tinyui/popover';
+import { LiquidGlassText } from 'react-native-tinyui/liquid-glass-text';
 ```
 
 The root `react-native-tinyui` imports remain supported for backwards
@@ -162,6 +164,71 @@ Use `open` with `onOpenChange` for a controlled popover, or `defaultOpen` for an
 uncontrolled one. `contentSize` defaults to 320 × 240 points and can be updated
 while the popover is visible.
 
+## LiquidGlassText
+
+`LiquidGlassText` renders native glass inside the glyph outlines, based on
+[GlassText](https://github.com/ailtonvivaz/GlassText). It supports the reference
+library's text, glass, font and alignment APIs through React props.
+Background image loading is not part of this component.
+
+Building this component requires **Xcode 26+**. Glass is rendered on **iOS 26+**;
+on iOS 17–25 it displays ordinary SwiftUI text using the same font, alignment
+and optional tint. The rest of TinyUI continues to support iOS 17+.
+
+```tsx
+import { LiquidGlassText } from 'react-native-tinyui';
+
+<LiquidGlassText
+  text="Liquid Glass"
+  glass={{ effect: 'regular', tint: '#00BBDD' }}
+  font={{ size: 48, weight: 'bold', design: 'rounded' }}
+/>;
+
+<LiquidGlassText
+  text={'Multi-line\nGlass Text\nEffect'}
+  glass="clear"
+  font="largeTitle"
+  fontWeight="heavy"
+  fontDesign="serif"
+  multilineTextAlignment="center"
+/>;
+```
+
+| Prop                     | Values                                                                                   | Default       |
+| ------------------------ | ---------------------------------------------------------------------------------------- | ------------- |
+| `text`                   | String (including text translated in JavaScript)                                         | Required      |
+| `glass`                  | `'clear'`, `'regular'`, `'identity'`, or `{ effect?, tint?, interactive? }`              | `'clear'`     |
+| `font`                   | A semantic text style, or `{ size, weight?, design?, family? }`                          | `'body'`      |
+| `fontWeight`             | `ultraLight`, `thin`, `light`, `regular`, `medium`, `semibold`, `bold`, `heavy`, `black` | Font's weight |
+| `fontDesign`             | `default`, `serif`, `monospaced`, `rounded`                                              | Font's design |
+| `multilineTextAlignment` | `leading`, `center`, `trailing`                                                          | `leading`     |
+
+Semantic font styles are `largeTitle`, `title`, `title2`, `title3`, `headline`,
+`subheadline`, `body`, `callout`, `footnote`, `caption`, and `caption2`. They
+follow SwiftUI Dynamic Type. Explicit `size` values use fixed point sizes;
+`family` accepts the PostScript name of a font installed in the app.
+`fontWeight` and `fontDesign` override the corresponding system font options.
+A custom font family determines its own design.
+
+Glass options accept `tint` as a React Native `ColorValue`, including
+`PlatformColor` and `DynamicColorIOS`. The object form defaults to the clear
+effect, with no tint or interactivity. `identity` applies no glass effect.
+The component also accepts standard `ViewProps`, including `style`, `testID`,
+accessibility props and a native view ref. The supplied text is used for
+the default accessibility label; pass `accessibilityLabel` to override it.
+
+Native content measurements supply the default width and height. Layout styles
+can override these dimensions, but do not resize the font or wrap text. As in
+GlassText, use explicit `\n` characters for multiple lines. Keep padding on a
+surrounding `View`. Color emoji and other glyphs without vector outlines cannot
+produce a glass shape.
+
+`text` accepts a string. Applications using JavaScript localization can pass
+their translated string directly.
+
+The adapted Core Text outline implementation retains the upstream MIT notice in
+[`ios/LiquidGlassText/GlassText-LICENSE`](ios/LiquidGlassText/GlassText-LICENSE).
+
 ## Contributing
 
 - [Development workflow](CONTRIBUTING.md#development-workflow)

package/Tinyui.podspec

@@ -14,6 +14,11 @@ components = {
     :definition => "TINYUI_FEATURE_POPOVER=1",
     :frameworks => ["UIKit"],
   },
+  "LiquidGlassText" => {
+    :source_files => "ios/LiquidGlassText/**/*.{h,m,mm,swift,cpp}",
+    :definition => "TINYUI_FEATURE_LIQUID_GLASS_TEXT=1",
+    :frameworks => ["UIKit", "SwiftUI", "CoreText"],
+  },
 }
 
 configured_components = nil
@@ -74,7 +79,8 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/luoxuhai/react-native-tinyui.git", :tag => "#{s.version}" }
 
   s.source_files = source_files
-  s.private_header_files = ["ios/Core/**/*.h", "ios/Menu/**/*.h", "ios/Popover/**/*.h"]
+  s.private_header_files = ["ios/Core/**/*.h", "ios/Menu/**/*.h", "ios/Popover/**/*.h", "ios/LiquidGlassText/**/*.h"]
+  s.preserve_paths = "ios/LiquidGlassText/GlassText-LICENSE"
   s.swift_version = "5.0"
   s.frameworks = frameworks unless frameworks.empty?
   s.pod_target_xcconfig = {

package/ios/Core/Tinyui.mm

@@ -13,6 +13,10 @@
   [components addObject:@"Popover"];
 #endif
 
+#if TINYUI_FEATURE_LIQUID_GLASS_TEXT
+  [components addObject:@"LiquidGlassText"];
+#endif
+
   return components;
 }
 

package/ios/Core/TinyuiComponentClasses.mm

@@ -1,27 +1,53 @@
-#import <React/RCTComponentViewProtocol.h>
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/TinyuiSpec/ComponentDescriptors.h>
+
+using namespace facebook::react;
+
+// Newer Codegen providers put every declared component into an NSDictionary
+// using NSClassFromString, which cannot be nil. Keep a lightweight Fabric class
+// for disabled components; the JS availability check prevents rendering them.
+// Their actual UIKit/SwiftUI implementations remain excluded by the podspec.
+#define TINYUI_DISABLED_COMPONENT(ViewClass, DescriptorClass)                 \
+  @interface ViewClass : RCTViewComponentView                                \
+  @end                                                                      \
+  @implementation ViewClass                                                 \
+  + (ComponentDescriptorProvider)componentDescriptorProvider                 \
+  {                                                                         \
+    return concreteComponentDescriptorProvider<DescriptorClass>();          \
+  }                                                                         \
+  @end
 
 #if TINYUI_FEATURE_MENU
 #import "TinyuiMenuView.h"
+#else
+TINYUI_DISABLED_COMPONENT(TinyuiMenuView, TinyuiMenuViewComponentDescriptor)
 #endif
 
 #if TINYUI_FEATURE_POPOVER
 #import "TinyuiPopoverView.h"
+#else
+TINYUI_DISABLED_COMPONENT(TinyuiPopoverView, TinyuiPopoverViewComponentDescriptor)
 #endif
 
+#if TINYUI_FEATURE_LIQUID_GLASS_TEXT
+#import "TinyuiLiquidGlassTextView.h"
+#else
+TINYUI_DISABLED_COMPONENT(TinyuiLiquidGlassTextView, TinyuiLiquidGlassTextViewComponentDescriptor)
+#endif
+
+#undef TINYUI_DISABLED_COMPONENT
+
 Class<RCTComponentViewProtocol> TinyuiMenuViewCls(void)
 {
-#if TINYUI_FEATURE_MENU
   return TinyuiMenuView.class;
-#else
-  return nil;
-#endif
 }
 
 Class<RCTComponentViewProtocol> TinyuiPopoverViewCls(void)
 {
-#if TINYUI_FEATURE_POPOVER
   return TinyuiPopoverView.class;
-#else
-  return nil;
-#endif
+}
+
+Class<RCTComponentViewProtocol> TinyuiLiquidGlassTextViewCls(void)
+{
+  return TinyuiLiquidGlassTextView.class;
 }

package/ios/LiquidGlassText/GlassText-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ailton Vieira
+
+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/ios/LiquidGlassText/TinyuiLiquidGlassTextProvider.swift

@@ -0,0 +1,265 @@
+import CoreText
+import SwiftUI
+import UIKit
+
+private struct LiquidGlassTextConfiguration: Decodable {
+  struct FontConfiguration: Decodable {
+    let style: String?
+    let size: CGFloat?
+    let weight: String?
+    let design: String?
+    let family: String?
+  }
+
+  var text: String?
+  var glass: String?
+  var interactive: Bool?
+  var font: FontConfiguration?
+  var fontWeight: String?
+  var fontDesign: String?
+  var multilineTextAlignment: String?
+
+  var resolvedFont: Font {
+    let design: Font.Design
+    switch fontDesign ?? font?.design {
+    case "serif": design = .serif
+    case "monospaced": design = .monospaced
+    case "rounded": design = .rounded
+    default: design = .default
+    }
+
+    let style: Font.TextStyle
+    switch font?.style {
+    case "largeTitle": style = .largeTitle
+    case "title": style = .title
+    case "title2": style = .title2
+    case "title3": style = .title3
+    case "headline": style = .headline
+    case "subheadline": style = .subheadline
+    case "callout": style = .callout
+    case "footnote": style = .footnote
+    case "caption": style = .caption
+    case "caption2": style = .caption2
+    default: style = .body
+    }
+
+    var result: Font
+    if let size = font?.size, size.isFinite, size > 0 {
+      if let family = font?.family, !family.isEmpty {
+        result = .custom(family, fixedSize: size)
+      } else {
+        result = .system(size: size, design: design)
+      }
+    } else {
+      result = .system(style, design: design)
+    }
+
+    // Preserve a semantic style's default weight (e.g. headline) unless overridden.
+    if let weight = fontWeight ?? font?.weight {
+      switch weight {
+      case "ultraLight": result = result.weight(.ultraLight)
+      case "thin": result = result.weight(.thin)
+      case "light": result = result.weight(.light)
+      case "medium": result = result.weight(.medium)
+      case "semibold": result = result.weight(.semibold)
+      case "bold": result = result.weight(.bold)
+      case "heavy": result = result.weight(.heavy)
+      case "black": result = result.weight(.black)
+      default: result = result.weight(.regular)
+      }
+    }
+    return result
+  }
+
+  var alignment: TextAlignment {
+    switch multilineTextAlignment {
+    case "center": return .center
+    case "trailing": return .trailing
+    default: return .leading
+    }
+  }
+}
+
+private struct LiquidGlassTextContent: View {
+  let configuration: LiquidGlassTextConfiguration
+  let text: String
+  let tintColor: UIColor?
+
+  var body: some View {
+    Group {
+      if #available(iOS 26.0, *) {
+        LiquidGlassTextEffect(
+          text: text,
+          effect: configuration.glass ?? "clear",
+          tintColor: tintColor,
+          interactive: configuration.interactive ?? false
+        )
+      } else {
+        Text(verbatim: text)
+          .foregroundStyle(tintColor.map { Color(uiColor: $0) } ?? .primary)
+      }
+    }
+    .font(configuration.resolvedFont)
+    .multilineTextAlignment(configuration.alignment)
+    .fixedSize()
+    // React Native exposes one accessible text element with the supplied label.
+    .accessibilityHidden(true)
+  }
+}
+
+// Adapted from ailtonvivaz/GlassText (MIT). See GlassText-LICENSE.
+@available(iOS 26.0, *)
+private struct LiquidGlassTextEffect: View {
+  let text: String
+  let effect: String
+  let tintColor: UIColor?
+  let interactive: Bool
+
+  @Environment(\.font) private var font
+  @Environment(\.fontResolutionContext) private var fontResolutionContext
+  @Environment(\.multilineTextAlignment) private var alignment
+
+  private var glass: Glass {
+    var result: Glass
+    switch effect {
+    case "regular": result = .regular
+    case "identity": result = .identity
+    default: result = .clear
+    }
+    if let tintColor {
+      result = result.tint(Color(uiColor: tintColor))
+    }
+    return result.interactive(interactive)
+  }
+
+  var body: some View {
+    let resolved = (font ?? .body).resolve(in: fontResolutionContext)
+    let ctFont = resolved.ctFont
+    let lines = text.components(separatedBy: CharacterSet.newlines)
+    let lineHeight = CTFontGetAscent(ctFont) + CTFontGetDescent(ctFont)
+      + max(CTFontGetLeading(ctFont), resolved.pointSize * 0.2)
+    let width = lines.reduce(CGFloat.zero) { width, line in
+      let attributed = NSAttributedString(
+        string: line,
+        attributes: [kCTFontAttributeName as NSAttributedString.Key: ctFont]
+      )
+      return max(width, CGFloat(CTLineGetTypographicBounds(
+        CTLineCreateWithAttributedString(attributed), nil, nil, nil
+      )))
+    }
+    let shape = TinyuiTextOutlineShape(
+      text: text, ctFont: ctFont, fontSize: resolved.pointSize, alignment: alignment
+    )
+    Rectangle()
+      .fill(.clear)
+      .glassEffect(glass, in: shape)
+      .frame(width: width, height: text.isEmpty ? 0 : lineHeight * CGFloat(lines.count))
+  }
+}
+
+@objc public protocol TinyuiLiquidGlassTextViewDelegate: AnyObject {
+  func onContentSizeChange(width: Double, height: Double, configuration: String)
+}
+
+@objc public class TinyuiLiquidGlassTextProvider: UIView {
+  private weak var delegate: TinyuiLiquidGlassTextViewDelegate?
+  private var hostingController: UIHostingController<LiquidGlassTextContent>?
+  private var configuration = LiquidGlassTextConfiguration()
+  private var configurationJSON = "{}"
+  private var tintColorValue: UIColor?
+  private var lastSize: CGSize?
+
+  @objc public weak var parentViewController: UIViewController? {
+    didSet { setNeedsLayout() }
+  }
+
+  @objc public convenience init(delegate: TinyuiLiquidGlassTextViewDelegate) {
+    self.init(frame: .zero)
+    self.delegate = delegate
+    registerForTraitChanges([UITraitPreferredContentSizeCategory.self]) {
+      (view: TinyuiLiquidGlassTextProvider, _: UITraitCollection) in
+      view.invalidateMeasurement()
+    }
+  }
+
+  @objc public func configure(_ json: String, tintColor: UIColor?) {
+    guard json != configurationJSON || tintColor != tintColorValue else { return }
+    configurationJSON = json
+    configuration = (try? JSONDecoder().decode(
+      LiquidGlassTextConfiguration.self, from: Data(json.utf8)
+    )) ?? LiquidGlassTextConfiguration()
+    tintColorValue = tintColor
+    hostingController?.rootView = content
+    invalidateMeasurement()
+  }
+
+  @objc public func invalidateMeasurement() {
+    lastSize = nil
+    setNeedsLayout()
+  }
+
+  private var content: LiquidGlassTextContent {
+    LiquidGlassTextContent(configuration: configuration, text: configuration.text ?? "", tintColor: tintColorValue)
+  }
+
+  override public func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil {
+      detachController()
+    } else {
+      invalidateMeasurement()
+    }
+  }
+
+  private func detachController() {
+    hostingController?.willMove(toParent: nil)
+    hostingController?.view.removeFromSuperview()
+    hostingController?.removeFromParent()
+    hostingController = nil
+  }
+
+  @objc public func reset() {
+    detachController()
+    parentViewController = nil
+    configurationJSON = "{}"
+    configuration = LiquidGlassTextConfiguration()
+    tintColorValue = nil
+    lastSize = nil
+  }
+
+  override public func layoutSubviews() {
+    super.layoutSubviews()
+    guard window != nil, let parentViewController else { return }
+
+    if hostingController == nil {
+      let controller = UIHostingController(rootView: content)
+      controller.safeAreaRegions = []
+      controller.view.backgroundColor = .clear
+      parentViewController.addChild(controller)
+      addSubview(controller.view)
+      controller.didMove(toParent: parentViewController)
+      hostingController = controller
+    }
+    guard let controller = hostingController else { return }
+    if controller.parent !== parentViewController {
+      controller.willMove(toParent: nil)
+      controller.removeFromParent()
+      parentViewController.addChild(controller)
+      controller.didMove(toParent: parentViewController)
+    }
+    controller.view.frame = bounds
+
+    // GlassText uses explicit newlines and intrinsic sizing, never automatic wrapping.
+    let measured = controller.sizeThatFits(in: CGSize(width: 100_000, height: 100_000))
+    let scale = traitCollection.displayScale > 0 ? traitCollection.displayScale : 1
+    let size = CGSize(
+      width: ceil(measured.width * scale) / scale,
+      height: ceil(measured.height * scale) / scale
+    )
+    guard size.width.isFinite, size.height.isFinite, size != lastSize else { return }
+    lastSize = size
+    delegate?.onContentSizeChange(
+      width: size.width, height: size.height, configuration: configurationJSON
+    )
+  }
+}

package/ios/LiquidGlassText/TinyuiLiquidGlassTextView.h

@@ -0,0 +1,12 @@
+#if TINYUI_FEATURE_LIQUID_GLASS_TEXT
+
+#import <React/RCTViewComponentView.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface TinyuiLiquidGlassTextView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/LiquidGlassText/TinyuiLiquidGlassTextView.mm

@@ -0,0 +1,84 @@
+#if TINYUI_FEATURE_LIQUID_GLASS_TEXT
+
+#import "TinyuiLiquidGlassTextView.h"
+
+#import <React/RCTConversions.h>
+#import <React/UIView+React.h>
+#import <react/renderer/components/TinyuiSpec/ComponentDescriptors.h>
+#import <react/renderer/components/TinyuiSpec/EventEmitters.h>
+#import <react/renderer/components/TinyuiSpec/Props.h>
+#import <react/renderer/components/TinyuiSpec/RCTComponentViewHelpers.h>
+#import "RCTFabricComponentsPlugins.h"
+#import "Tinyui-Swift.h"
+
+using namespace facebook::react;
+
+@interface TinyuiLiquidGlassTextView () <RCTTinyuiLiquidGlassTextViewViewProtocol,
+                                        TinyuiLiquidGlassTextViewDelegate>
+@end
+
+@implementation TinyuiLiquidGlassTextView {
+  TinyuiLiquidGlassTextProvider *_provider;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+  return concreteComponentDescriptorProvider<TinyuiLiquidGlassTextViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const TinyuiLiquidGlassTextViewProps>();
+    _props = defaultProps;
+    _provider = [[TinyuiLiquidGlassTextProvider alloc] initWithDelegate:self];
+    self.contentView = _provider;
+  }
+  return self;
+}
+
+- (void)didMoveToWindow
+{
+  [super didMoveToWindow];
+  if (self.window != nil) {
+    _provider.parentViewController = [self reactViewController];
+  }
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+  const auto &newProps = *std::static_pointer_cast<TinyuiLiquidGlassTextViewProps const>(props);
+  [_provider configure:RCTNSStringFromString(newProps.configuration)
+             tintColor:RCTUIColorFromSharedColor(newProps.tintColor)];
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateEventEmitter:(EventEmitter::Shared const &)eventEmitter
+{
+  [super updateEventEmitter:eventEmitter];
+  [_provider invalidateMeasurement];
+}
+
+- (void)onContentSizeChangeWithWidth:(double)width
+                            height:(double)height
+                     configuration:(NSString *)configuration
+{
+  if (_eventEmitter == nullptr) {
+    return;
+  }
+  std::static_pointer_cast<const TinyuiLiquidGlassTextViewEventEmitter>(_eventEmitter)
+      ->onContentSizeChange(TinyuiLiquidGlassTextViewEventEmitter::OnContentSizeChange{
+          .width = width,
+          .height = height,
+          .configuration = RCTStringFromNSString(configuration)});
+}
+
+- (void)prepareForRecycle
+{
+  [_provider reset];
+  [super prepareForRecycle];
+}
+
+@end
+
+#endif

package/ios/LiquidGlassText/TinyuiTextOutlineShape.swift

@@ -0,0 +1,113 @@
+// Adapted from ailtonvivaz/GlassText (MIT). See GlassText-LICENSE.
+//
+//  TextOutlineShape.swift
+//  GlassText
+//
+//  Created by Ailton Vieira on 17/08/25.
+//
+
+import CoreGraphics
+@preconcurrency import CoreText
+import SwiftUI
+
+/// A SwiftUI Shape that creates text outline paths for glass morphism effects
+struct TinyuiTextOutlineShape: Shape {
+    var text: String
+    var ctFont: CTFont
+    var fontSize: CGFloat
+    var alignment: TextAlignment = .center
+
+    func path(in rect: CGRect) -> Path {
+        // Split into explicit lines (no wrapping here)
+        let rawLines = text.components(separatedBy: CharacterSet.newlines)
+
+        // Pre-create CTLine objects to leverage CoreText shaping for complex scripts
+        var ctLines: [CTLine] = []
+        ctLines.reserveCapacity(rawLines.count)
+
+        let attrKey = kCTFontAttributeName as NSAttributedString.Key
+        for l in rawLines {
+            let attr = [attrKey: ctFont]
+            let astr = NSAttributedString(string: l, attributes: attr)
+            let line = CTLineCreateWithAttributedString(astr)
+            ctLines.append(line)
+        }
+
+        // Metrics (we still stack lines with a uniform height derived from base font)
+        let ascent = CTFontGetAscent(ctFont)
+        let descent = CTFontGetDescent(ctFont)
+        let leading = CTFontGetLeading(ctFont)
+        let lineHeight = ascent + descent + max(leading, CTFontGetSize(ctFont) * 0.2)
+
+        // Determine widths using typographic bounds for each CTLine (better for scripts & ligatures)
+        var lineWidths: [CGFloat] = []
+        var maxWidth: CGFloat = 0
+        for line in ctLines {
+            let w = CGFloat(CTLineGetTypographicBounds(line, nil, nil, nil))
+            lineWidths.append(w)
+            maxWidth = max(maxWidth, w)
+        }
+
+        // Build combined path aggregating each run's glyphs & positions
+        let combined = CGMutablePath()
+        for (idx, line) in ctLines.enumerated() {
+            // Position baseline for this line (stack downward later flipped)
+            let penY = -CGFloat(idx) * lineHeight
+            let lineWidth = lineWidths[idx]
+
+            // Alignment offset
+            let startX: CGFloat
+            switch alignment {
+                case .leading: startX = 0
+                case .center: startX = (maxWidth - lineWidth) / 2
+                case .trailing: startX = maxWidth - lineWidth
+            }
+
+            // Iterate glyph runs (handles complex scripts, clusters & ligatures)
+            let runs = CTLineGetGlyphRuns(line) as NSArray
+            for runObj in runs {
+                let run = runObj as! CTRun // Safe cast (CoreFoundation bridging)
+                let glyphCount = CTRunGetGlyphCount(run)
+                if glyphCount == 0 { continue }
+
+                // Extract glyphs & positions
+                var glyphs = Array(repeating: CGGlyph(), count: glyphCount)
+                var positions = Array(repeating: CGPoint.zero, count: glyphCount)
+                CTRunGetGlyphs(run, CFRange(location: 0, length: 0), &glyphs)
+                CTRunGetPositions(run, CFRange(location: 0, length: 0), &positions)
+
+                // Run font (may differ due to fallback)
+                let attrs = CTRunGetAttributes(run) as NSDictionary
+                let runFont = (attrs[kCTFontAttributeName] as! CTFont)
+
+                for i in 0 ..< glyphCount {
+                    let g = glyphs[i]
+                    guard let gPath = CTFontCreatePathForGlyph(runFont, g, nil) else { continue }
+                    var t = CGAffineTransform(
+                        translationX: startX + positions[i].x,
+                        y: penY + positions[i].y
+                    )
+                    if let shifted = gPath.copy(using: &t) {
+                        combined.addPath(shifted)
+                    }
+                }
+            }
+        }
+
+        if combined.isEmpty { return Path() }
+
+        // Normalize & center similar to previous approach
+        let bbox = combined.boundingBoxOfPath
+        var toOrigin = CGAffineTransform(translationX: -bbox.minX, y: -bbox.minY)
+        let norm = combined.copy(using: &toOrigin) ?? combined
+        var flip = CGAffineTransform(scaleX: 1, y: -1)
+        let flipped = norm.copy(using: &flip) ?? norm
+        let finalBBox = flipped.boundingBoxOfPath
+        var centerT = CGAffineTransform(
+            translationX: rect.midX - finalBBox.midX,
+            y: rect.midY - finalBBox.midY
+        )
+        let finalCG = flipped.copy(using: &centerT) ?? flipped
+        return Path(finalCG)
+    }
+}