@nativescript-community/ui-label 1.2.27 → 1.3.0

package/label.ios.js

@@ -1,15 +1,39 @@
-var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
 import { createNativeAttributedString, verticalTextAlignmentProperty } from '@nativescript-community/text';
-import { Color, Font, Span, Utils, View } from '@nativescript/core';
+import { Color, Font, Span, Utils, View, profile } from '@nativescript/core';
 import { borderBottomWidthProperty, borderLeftWidthProperty, borderRightWidthProperty, borderTopWidthProperty, fontInternalProperty, paddingBottomProperty, paddingLeftProperty, paddingRightProperty, paddingTopProperty } from '@nativescript/core/ui/styling/style-properties';
 import { formattedTextProperty, letterSpacingProperty, lineHeightProperty, textProperty, whiteSpaceProperty } from '@nativescript/core/ui/text-base';
 import { maxLinesProperty } from '@nativescript/core/ui/text-base/text-base-common';
-import { iOSNativeHelper } from '@nativescript/core/utils';
 import { isNullOrUndefined, isString } from '@nativescript/core/utils/types';
-import { LabelBase, autoFontSizeProperty, htmlProperty, lineBreakProperty, linkColorProperty, linkUnderlineProperty, maxFontSizeProperty, minFontSizeProperty, needFormattedStringComputation, selectableProperty, textShadowProperty } from './label-common';
-export { createNativeAttributedString, enableIOSDTCoreText } from '@nativescript-community/text';
+import { LabelBase, autoFontSizeProperty, htmlProperty, lineBreakProperty, linkColorProperty, linkUnderlineProperty, maxFontSizeProperty, minFontSizeProperty, needSetText, selectableProperty, textShadowProperty } from './label-common';
+export { createNativeAttributedString } from '@nativescript-community/text';
 export * from './label-common';
-const majorVersion = iOSNativeHelper.MajorVersion;
+var UILabelLinkHandlerTapDelegateImpl = /** @class */ (function (_super) {
+    __extends(UILabelLinkHandlerTapDelegateImpl, _super);
+    function UILabelLinkHandlerTapDelegateImpl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UILabelLinkHandlerTapDelegateImpl.initWithOwner = function (owner) {
+        var handler = UILabelLinkHandlerTapDelegateImpl.new();
+        handler.mOwner = owner;
+        return handler;
+    };
+    UILabelLinkHandlerTapDelegateImpl.prototype.onLinkTapped = function (value) {
+        var _a;
+        var owner = (_a = this.mOwner) === null || _a === void 0 ? void 0 : _a.deref();
+        if (owner) {
+            var formattedText = owner.formattedText;
+            if (formattedText && typeof value === 'number' && value < formattedText.spans.length) {
+                formattedText.spans.getItem(value)._emit(Span.linkTapEvent);
+            }
+            else {
+                owner.notify({ eventName: 'linkTap', link: value });
+            }
+        }
+    };
+    UILabelLinkHandlerTapDelegateImpl.ObjCProtocols = [UILabelLinkHandlerTapDelegate];
+    return UILabelLinkHandlerTapDelegateImpl;
+}(NSObject));
 const AttributeOriginalFontSize = 'OriginalFontSize';
 var FixedSize;
 (function (FixedSize) {
@@ -59,6 +83,14 @@ function whiteSpaceToLineBreakMode(value) {
             return 4 /* NSLineBreakMode.ByTruncatingTail */;
     }
 }
+export const needUpdateVerticalAlignment = function (target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = function (...args) {
+        const result = originalMethod.apply(this, args);
+        this.updateVerticalAlignment();
+        return result;
+    };
+};
 export const needAutoFontSizeComputation = function (target, propertyKey, descriptor) {
     const originalMethod = descriptor.value;
     descriptor.value = function (...args) {
@@ -106,13 +138,11 @@ var LabelObserverClass = /** @class */ (function (_super) {
     function LabelObserverClass() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    // NOTE: Refactor this - use Typescript property instead of strings....
     LabelObserverClass.prototype.observeValueForKeyPathOfObjectChangeContext = function (path, tv) {
-        if (path === 'contentSize') {
-            var owner = this._owner && this._owner.get();
-            if (owner) {
-                owner.updateTextContainerInset();
-            }
+        var _a;
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.get();
+        if (owner) {
+            owner.updateVerticalAlignment();
         }
     };
     return LabelObserverClass;
@@ -121,70 +151,53 @@ export class Label extends LabelBase {
     constructor() {
         super(...arguments);
         this.fontSizeRatio = 1;
+        this.isUsingUITextView = false;
         this.mCanUpdateAutoFontSize = true;
+        this.mCanUpdateVerticalAlignment = true;
         this.mNeedAutoFontSizeComputation = false;
+        this.mNeedUpdateVerticalAlignment = false;
     }
-    // constructor() {
-    // super();
-    // if (iOSUseDTCoreText && !Label.DTCORETEXT_INIT) {
-    //     Label.DTCORETEXT_INIT = true;
-    //     DTCoreTextFontDescriptor.asyncPreloadFontLookupTable();
-    // }
-    // }
     createNativeView() {
-        const view = UITextView.new();
-        if (!view.font) {
-            view.font = UIFont.systemFontOfSize(12);
-        }
-        view.linkTextAttributes = NSDictionary.new();
-        view.scrollEnabled = false;
-        view.editable = false;
-        view.selectable = false;
-        view.backgroundColor = UIColor.clearColor;
-        view.userInteractionEnabled = true;
-        view.dataDetectorTypes = -1 /* UIDataDetectorTypes.All */;
-        view.textContainerInset = UIEdgeInsetsZero;
-        view.textContainer.lineFragmentPadding = 0;
-        // ignore font leading just like UILabel does
-        view.layoutManager.usesFontLeading = false;
-        // view.textContainer.lineBreakMode = NSLineBreakMode.ByCharWrapping;
-        return view;
+        if (this.selectable) {
+            this.isUsingUITextView = true;
+            return NSTextView.new();
+        }
+        return NSLabel.new();
     }
     initNativeView() {
         super.initNativeView();
-        this.mDelegate = LabelUITextViewDelegateImpl.initWithOwner(new WeakRef(this));
-        this.mObserver = LabelObserverClass.alloc().init();
-        this.mObserver['_owner'] = new WeakRef(this);
-        this.nativeViewProtected.addObserverForKeyPathOptionsContext(this.mObserver, 'contentSize', 1 /* NSKeyValueObservingOptions.New */, null);
-        this.nativeViewProtected.attributedText = this.attributedString;
+        const nativeView = this.nativeTextViewProtected;
+        if (this.isUsingUITextView) {
+            this.mObserver = LabelObserverClass.alloc().init();
+            this.mObserver._owner = new WeakRef(this);
+            this.mDelegate = LabelUITextViewDelegateImpl.initWithOwner(new WeakRef(this));
+            nativeView.delegate = this.mDelegate;
+            nativeView.addObserverForKeyPathOptionsContext(this.mObserver, 'contentSize', 1 /* NSKeyValueObservingOptions.New */, null);
+        }
     }
     disposeNativeView() {
         this.mDelegate = null;
-        this.nativeTextViewProtected.delegate = null;
+        const nativeView = this.nativeTextViewProtected;
+        if (this.isUsingUITextView) {
+            nativeView.delegate = null;
+        }
+        if (this.mTapGestureRecognizer) {
+            this.nativeViewProtected.removeGestureRecognizer(this.mTapGestureRecognizer);
+            this.mTapGestureRecognizer = null;
+        }
+        this.mTapDelegate = null;
         super.disposeNativeView();
-        // if (this._htmlTapGestureRecognizer) {
-        //     this.nativeViewProtected.removeGestureRecognizer(this._htmlTapGestureRecognizer);
-        //     this._htmlTapGestureRecognizer = null;
-        // }
         if (this.mObserver) {
-            this.nativeViewProtected.removeObserverForKeyPath(this.mObserver, 'contentSize');
+            const nativeView = this.nativeTextViewProtected;
+            if (this.isUsingUITextView) {
+                nativeView.removeObserverForKeyPath(this.mObserver, 'contentSize');
+            }
             this.mObserver = null;
         }
     }
-    onLoaded() {
-        super.onLoaded();
-        if (this.nativeTextViewProtected) {
-            this.nativeTextViewProtected.delegate = this.mDelegate;
-        }
-    }
-    onUnloaded() {
-        if (this.nativeTextViewProtected) {
-            this.nativeTextViewProtected.delegate = null;
-        }
-        super.onUnloaded();
-    }
     onResumeNativeUpdates() {
         // {N} suspends properties update on `_suspendNativeUpdates`. So we only need to do this in onResumeNativeUpdates
+        this.mCanUpdateVerticalAlignment = false;
         this.mCanUpdateAutoFontSize = false;
         super.onResumeNativeUpdates();
         this.mCanUpdateAutoFontSize = true;
@@ -194,9 +207,13 @@ export class Label extends LabelBase {
                 this.updateAutoFontSize({ textView: this.nativeTextViewProtected, force: true });
             }
         }
+        this.mCanUpdateVerticalAlignment = true;
+        if (this.mNeedUpdateVerticalAlignment) {
+            this.mNeedUpdateVerticalAlignment = false;
+            this.updateVerticalAlignment();
+        }
     }
-    computeTextHeight(size) {
-        const tv = this.nativeTextViewProtected;
+    computeTextHeight(tv, size) {
         const oldtextContainerInset = tv.textContainerInset;
         tv.textContainerInset = UIEdgeInsetsZero;
         // if (tv.attributedText) {
@@ -211,8 +228,24 @@ export class Label extends LabelBase {
         tv.textContainerInset = oldtextContainerInset;
         return result.height;
     }
-    updateTextContainerInset(applyVerticalTextAlignment = true) {
-        const tv = this.nativeTextViewProtected;
+    updateVerticalAlignment(applyVerticalTextAlignment = true) {
+        const nativeView = this.nativeTextViewProtected;
+        if (!this.mCanUpdateVerticalAlignment) {
+            this.mNeedUpdateVerticalAlignment = true;
+            return;
+        }
+        if (!this.isUsingUITextView && !this.isLayoutValid) {
+            return;
+        }
+        const result = this.updateTextContainerInset(nativeView, applyVerticalTextAlignment);
+        nativeView.textContainerInset = result;
+        if (this.isUsingUITextView) {
+            nativeView.contentInset = UIEdgeInsetsZero;
+        }
+        // this.requestLayout();
+    }
+    updateTextContainerInset(tv, applyVerticalTextAlignment = true) {
+        let inset;
         const top = Utils.layout.toDeviceIndependentPixels(this.effectivePaddingTop + this.effectiveBorderTopWidth);
         const right = Utils.layout.toDeviceIndependentPixels(this.effectivePaddingRight + this.effectiveBorderRightWidth);
         const bottom = Utils.layout.toDeviceIndependentPixels(this.effectivePaddingBottom + this.effectiveBorderBottomWidth);
@@ -220,42 +253,65 @@ export class Label extends LabelBase {
         if (!applyVerticalTextAlignment ||
             !this.verticalTextAlignment ||
             (tv.text?.length === 0 && tv.attributedText?.length === 0)) {
-            tv.textContainerInset = {
+            inset = {
                 top,
                 left,
                 bottom,
                 right
             };
-            return;
+            return inset;
         }
         switch (this.verticalTextAlignment) {
             case 'initial': // not supported
             case 'top':
-                tv.textContainerInset = {
-                    top,
-                    left,
-                    bottom,
-                    right
-                };
+                if (this.isUsingUITextView) {
+                    inset = {
+                        top,
+                        left,
+                        bottom,
+                        right
+                    };
+                }
+                else {
+                    const height = this.computeTextHeight(tv, CGSizeMake(tv.bounds.size.width, Number.MAX_SAFE_INTEGER));
+                    let topCorrect = tv.bounds.size.height - top - bottom - height * tv.zoomScale;
+                    topCorrect = topCorrect < 0.0 ? 0.0 : topCorrect;
+                    inset = {
+                        top,
+                        left,
+                        bottom: bottom + topCorrect,
+                        right
+                    };
+                }
                 break;
             case 'middle':
             case 'center': {
-                const height = this.computeTextHeight(CGSizeMake(tv.bounds.size.width, Number.MAX_SAFE_INTEGER));
-                let topCorrect = (tv.bounds.size.height - top - bottom - height * tv.zoomScale) / 2.0;
-                topCorrect = topCorrect < 0.0 ? 0.0 : topCorrect;
-                tv.textContainerInset = {
-                    top: top + topCorrect,
-                    left,
-                    bottom,
-                    right
-                };
+                if (this.isUsingUITextView) {
+                    const height = this.computeTextHeight(tv, CGSizeMake(tv.bounds.size.width, Number.MAX_SAFE_INTEGER));
+                    let topCorrect = (tv.bounds.size.height - top - bottom - height * tv.zoomScale) / 2.0;
+                    topCorrect = topCorrect < 0.0 ? 0.0 : topCorrect;
+                    inset = {
+                        top: top + topCorrect,
+                        left,
+                        bottom,
+                        right
+                    };
+                }
+                else {
+                    inset = {
+                        top,
+                        left,
+                        bottom,
+                        right
+                    };
+                }
                 break;
             }
             case 'bottom': {
-                const height = this.computeTextHeight(CGSizeMake(tv.bounds.size.width, Number.MAX_SAFE_INTEGER));
+                const height = this.computeTextHeight(tv, CGSizeMake(tv.bounds.size.width, Number.MAX_SAFE_INTEGER));
                 let bottomCorrect = tv.bounds.size.height - top - bottom - height * tv.zoomScale;
                 bottomCorrect = bottomCorrect < 0.0 ? 0.0 : bottomCorrect;
-                tv.textContainerInset = {
+                inset = {
                     top: top + bottomCorrect,
                     left,
                     bottom,
@@ -264,6 +320,7 @@ export class Label extends LabelBase {
                 break;
             }
         }
+        return inset;
     }
     _requestLayoutOnTextChanged() {
         if (this.mFixedSize === FixedSize.BOTH) {
@@ -275,6 +332,17 @@ export class Label extends LabelBase {
         }
         super._requestLayoutOnTextChanged();
     }
+    _measureNativeView(width, widthMode, height, heightMode) {
+        const view = this.nativeTextViewProtected;
+        const nativeSize = view.textRectForBoundsLimitedToNumberOfLines(CGRectMake(0, 0, widthMode === 0 /* layout.UNSPECIFIED */
+            ? Number.POSITIVE_INFINITY
+            : Utils.layout.toDeviceIndependentPixels(width), heightMode === 0 /* layout.UNSPECIFIED */
+            ? Number.POSITIVE_INFINITY
+            : Utils.layout.toDeviceIndependentPixels(height)), view.numberOfLines).size;
+        nativeSize.width = Utils.layout.round(Utils.layout.toDevicePixels(nativeSize.width));
+        nativeSize.height = Utils.layout.round(Utils.layout.toDevicePixels(nativeSize.height));
+        return nativeSize;
+    }
     onMeasure(widthMeasureSpec, heightMeasureSpec) {
         const nativeView = this.nativeTextViewProtected;
         if (nativeView) {
@@ -296,7 +364,10 @@ export class Label extends LabelBase {
                 }
             }
             const desiredSize = Utils.layout.measureNativeView(nativeView, width, widthMode, height, heightMode);
-            if (!this.formattedText && !this.html && resetFont) {
+            // if (this.isUsingUITextView) {
+            // desiredSize.height += nativeView.textContainerInset.top + nativeView.textContainerInset.bottom;
+            // }
+            if (resetFont && !this.formattedText && !this.html) {
                 nativeView.font = resetFont;
             }
             const labelWidth = widthMode === Utils.layout.AT_MOST ? Math.min(desiredSize.width, width) : desiredSize.width;
@@ -310,16 +381,36 @@ export class Label extends LabelBase {
     }
     _onSizeChanged() {
         super._onSizeChanged();
+        this.updateVerticalAlignment();
         if (this.autoFontSize) {
             this.updateAutoFontSize({ textView: this.nativeTextViewProtected });
         }
     }
+    // _htmlTappable = false;
+    // _htmlTapGestureRecognizer;
+    updateInteractionState(hasLink = false) {
+        this.nativeTextViewProtected.userInteractionEnabled = this._tappable || this.selectable || hasLink;
+    }
     _setTappableState(tappable) {
         if (this._tappable !== tappable) {
             this._tappable = tappable;
-            // we dont want the label gesture recognizer for linkTap
-            // so we override
+            if (this.isUsingUITextView) {
+                // we dont want the label gesture recognizer for linkTap
+                // so we override
+            }
+            else {
+                if (this._tappable && !this.mTapGestureRecognizer) {
+                    this.mTapDelegate = UILabelLinkHandlerTapDelegateImpl.initWithOwner(new WeakRef(this));
+                    // associate handler with menuItem or it will get collected by JSC.
+                    this.mTapGestureRecognizer = LabelLinkGestureRecognizer.alloc().initWithDelegate(this.mTapDelegate);
+                    this.nativeViewProtected.addGestureRecognizer(this.mTapGestureRecognizer);
+                }
+                else if (this.mTapGestureRecognizer) {
+                    this.nativeViewProtected.removeGestureRecognizer(this.mTapGestureRecognizer);
+                }
+            }
         }
+        this.updateInteractionState();
     }
     textViewShouldInteractWithURLInRangeInteraction(textView, url, characterRange, interaction) {
         if (!this.formattedText?.spans) {
@@ -349,18 +440,24 @@ export class Label extends LabelBase {
         return false;
     }
     _updateHTMLString(fontSize) {
+        const nativeView = this.nativeTextViewProtected;
         if (!this.html) {
-            this.nativeTextViewProtected.selectable = this.selectable === true;
+            if (this.isUsingUITextView) {
+                nativeView.selectable = this.selectable === true;
+            }
             this.attributedString = null;
         }
         else {
-            const font = this.nativeViewProtected.font;
+            const font = nativeView.font;
+            const style = this.style;
             if (!fontSize) {
                 fontSize = this.fontSize || font?.pointSize || 17;
             }
-            const fontWeight = this.style.fontWeight;
-            const familyName = this.style.fontFamily || (this.style.fontInternal && this.style.fontInternal.fontFamily) || undefined;
-            const result = createNativeAttributedString({
+            const fontWeight = style.fontWeight;
+            const familyName = style.fontFamily || (style.fontInternal && style.fontInternal.fontFamily) || undefined;
+            // we need to pass color because initWithDataOptionsDocumentAttributesError
+            // will set a default color preventing the UITextView from applying its color
+            const params = {
                 text: this.html,
                 fontSize,
                 familyName,
@@ -368,22 +465,30 @@ export class Label extends LabelBase {
                 color: this.color,
                 letterSpacing: this.letterSpacing,
                 lineHeight: this.lineHeight,
-                textAlignment: this.nativeTextViewProtected.textAlignment
-            }, this, this.autoFontSize, this.fontSizeRatio);
+                textAlignment: nativeView.textAlignment
+            };
+            if (!this.isUsingUITextView) {
+                Object.assign(params, {
+                    useCustomLinkTag: true,
+                    lineBreak: nativeView.lineBreakMode,
+                    linkDecoration: this.linkUnderline ? 'underline' : undefined,
+                    linkColor: this.linkColor
+                });
+            }
+            const result = createNativeAttributedString(params, this, this.autoFontSize, this.fontSizeRatio);
             let hasLink = false;
             if (result) {
-                result.enumerateAttributeInRangeOptionsUsingBlock(NSLinkAttributeName, { location: 0, length: result.length }, 0, (value, range, stop) => {
-                    hasLink = hasLink || (!!value && range.length > 0);
-                    if (hasLink) {
-                        stop[0] = true;
-                    }
-                });
+                hasLink = result.hasAttribute('CustomLinkAttribute');
+            }
+            this._setTappableState(hasLink);
+            this.updateInteractionState(hasLink);
+            if (this.isUsingUITextView) {
+                nativeView.selectable = this.selectable === true || hasLink;
             }
-            this.nativeTextViewProtected.selectable = this.selectable === true || hasLink;
             this.attributedString = result;
         }
-        if (this.nativeViewProtected) {
-            this.nativeViewProtected.attributedText = this.attributedString;
+        if (nativeView) {
+            nativeView.attributedText = this.attributedString;
             this._requestLayoutOnTextChanged();
         }
     }
@@ -406,12 +511,7 @@ export class Label extends LabelBase {
         }
         else {
             if (this.formattedText || this.html) {
-                if (this.html) {
-                    this.updateHTMLString();
-                }
-                else {
-                    super._setNativeText();
-                }
+                this._setNativeText();
             }
             else {
                 this.nativeTextViewProtected.textColor = color;
@@ -419,62 +519,74 @@ export class Label extends LabelBase {
         }
     }
     updateLinkTextAttributes() {
-        const color = !this.linkColor || this.linkColor instanceof Color ? this.linkColor : new Color(this.linkColor);
-        const nativeView = this.nativeTextViewProtected;
-        let attributes = nativeView.linkTextAttributes;
-        if (!(attributes instanceof NSMutableDictionary)) {
-            this.defaultLinkTextAttributes = attributes;
-            attributes = NSMutableDictionary.new();
-        }
-        if (color) {
-            attributes.setValueForKey(color.ios, NSForegroundColorAttributeName);
-            if (this.linkUnderline !== false) {
-                attributes.setValueForKey(color.ios, NSUnderlineColorAttributeName);
+        if (this.isUsingUITextView) {
+            const color = !this.linkColor || this.linkColor instanceof Color ? this.linkColor : new Color(this.linkColor);
+            const nativeView = this.nativeTextViewProtected;
+            let attributes = this.isUsingUITextView ? nativeView.linkTextAttributes : null;
+            if (!(attributes instanceof NSMutableDictionary)) {
+                this.defaultLinkTextAttributes = attributes;
+                attributes = NSMutableDictionary.new();
+            }
+            if (color) {
+                attributes.setValueForKey(color.ios, NSForegroundColorAttributeName);
+                if (this.linkUnderline !== false) {
+                    attributes.setValueForKey(color.ios, NSUnderlineColorAttributeName);
+                }
+                else {
+                    attributes.setValueForKey(UIColor.clearColor, NSUnderlineColorAttributeName);
+                }
+            }
+            else if (this.defaultLinkTextAttributes) {
+                attributes.setValueForKey(this.defaultLinkTextAttributes.objectForKey(NSForegroundColorAttributeName), NSForegroundColorAttributeName);
+                if (this.linkUnderline !== false) {
+                    attributes.setValueForKey(this.defaultLinkTextAttributes.objectForKey(NSUnderlineColorAttributeName), NSUnderlineColorAttributeName);
+                }
+                else {
+                    attributes.setValueForKey(UIColor.clearColor, NSUnderlineColorAttributeName);
+                }
             }
             else {
-                attributes.setValueForKey(UIColor.clearColor, NSUnderlineColorAttributeName);
+                if (this.linkUnderline === false) {
+                    attributes.setValueForKey(UIColor.clearColor, NSUnderlineColorAttributeName);
+                }
             }
+            nativeView.linkTextAttributes = attributes;
         }
         else {
-            attributes.setValueForKey(this.defaultLinkTextAttributes.objectForKey(NSForegroundColorAttributeName), NSForegroundColorAttributeName);
-            if (this.linkUnderline !== false) {
-                attributes.setValueForKey(this.defaultLinkTextAttributes.objectForKey(NSUnderlineColorAttributeName), NSUnderlineColorAttributeName);
-            }
-            else {
-                attributes.setValueForKey(UIColor.clearColor, NSUnderlineColorAttributeName);
-            }
+            this._setNativeText();
         }
-        nativeView.linkTextAttributes = attributes;
     }
-    [linkColorProperty.setNative](value) {
+    [_a = linkColorProperty.setNative](value) {
         this.updateLinkTextAttributes();
     }
     [selectableProperty.setNative](value) {
-        this.nativeTextViewProtected.selectable = value;
+        const nativeView = this.nativeTextViewProtected;
+        if (this.isUsingUITextView) {
+            nativeView.selectable = value;
+        }
+        this.updateInteractionState();
     }
-    [linkUnderlineProperty.setNative](value) {
+    [_b = linkUnderlineProperty.setNative](value) {
         this.updateLinkTextAttributes();
     }
-    [_a = htmlProperty.setNative](value) {
-        this.updateHTMLString();
-    }
-    [_b = formattedTextProperty.setNative](value) {
+    [_c = htmlProperty.setNative](value) { }
+    [_d = formattedTextProperty.setNative](value) {
         super[formattedTextProperty.setNative](value);
     }
-    [_c = textProperty.setNative](value) {
+    [_e = textProperty.setNative](value) {
         super[textProperty.setNative](value);
     }
-    [_d = letterSpacingProperty.setNative](value) {
+    [_f = letterSpacingProperty.setNative](value) {
         super[letterSpacingProperty.setNative](value);
     }
-    [_e = lineHeightProperty.setNative](value) {
+    [_g = lineHeightProperty.setNative](value) {
         super[lineHeightProperty.setNative](value);
     }
-    // @needFormattedStringComputation
+    // @needSetText
     // [colorProperty.setNative](value: number) {
     //     super[colorProperty.setNative](value);
     // }
-    [_f = fontInternalProperty.setNative](value) {
+    [_h = fontInternalProperty.setNative](value) {
         const nativeView = this.nativeTextViewProtected;
         const newFont = value instanceof Font ? value.getUIFont(nativeView.font) : value;
         if (!this.formattedText && !this.html) {
@@ -482,7 +594,7 @@ export class Label extends LabelBase {
         }
         else if (newFont) {
             if (!this.mCanChangeText) {
-                this.mNeedFormattedStringComputation = true;
+                this.mNeedSetText = true;
                 return;
             }
             this._setNativeText();
@@ -498,211 +610,146 @@ export class Label extends LabelBase {
             this.updateAutoFontSize({ textView: this.nativeTextViewProtected, force: true });
         }
     }
-    _setSpannablesFontSizeWithRatio(ratio) {
-        const nativeView = this.nativeTextViewProtected;
-        const toChange = nativeView.attributedText instanceof NSMutableAttributedString
-            ? nativeView.attributedText
-            : NSMutableAttributedString.alloc().initWithAttributedString(nativeView.attributedText);
-        let found = false;
-        toChange.enumerateAttributeInRangeOptionsUsingBlock(AttributeOriginalFontSize, { location: 0, length: nativeView.attributedText.length }, 0, (value, range, stop) => {
-            if (!value) {
-                return;
-            }
-            toChange.enumerateAttributeInRangeOptionsUsingBlock(NSFontAttributeName, range, 0, (value2, range, stop) => {
-                if (value2 && value * ratio !== value2.pointSize) {
-                    const newFont = value2.fontWithSize(Math.round(value * ratio));
-                    if (newFont) {
-                        found = true;
-                        toChange.removeAttributeRange(NSFontAttributeName, range);
-                        toChange.addAttributeValueRange(NSFontAttributeName, newFont, range);
-                    }
-                }
-            });
-        });
-        if (found) {
-            nativeView.attributedText = toChange;
-        }
-    }
     _setNativeText() {
+        if (!this.mCanChangeText) {
+            this.mNeedSetText = true;
+            return;
+        }
+        // reset the fontSizeRatio or it could break attributedString sizes in collectionview
+        this.fontSizeRatio = 1;
         if (this.html) {
             this.updateHTMLString();
         }
         else {
             super._setNativeText();
         }
-        if (this.color) {
-            const color = this.color instanceof Color ? this.color.ios : this.color;
-            this._setColor(color);
+        this.updateVerticalAlignment();
+        if (this.autoFontSize) {
+            this.updateAutoFontSize({ textView: this.nativeTextViewProtected, force: true });
         }
-        this.updateTextContainerInset();
         this._requestLayoutOnTextChanged();
     }
     setTextDecorationAndTransform() {
         const style = this.style;
-        const dict = new Map();
-        switch (style.textDecoration) {
-            case 'none':
-                break;
-            case 'underline':
-                dict.set(NSUnderlineStyleAttributeName, 1 /* Single */);
-                break;
-            case 'line-through':
-                dict.set(NSStrikethroughStyleAttributeName, 1 /* Single */);
-                break;
-            case 'underline line-through':
-                dict.set(NSUnderlineStyleAttributeName, 1 /* Single */);
-                dict.set(NSStrikethroughStyleAttributeName, 1 /* Single */);
-                break;
-            default:
-                throw new Error(`Invalid text decoration value: ${style.textDecoration}. Valid values are: 'none', 'underline', 'line-through', 'underline line-through'.`);
-        }
-        let paragraphStyle;
-        const createParagraphStyle = () => {
-            if (!paragraphStyle) {
-                paragraphStyle = NSMutableParagraphStyle.alloc().init();
-                paragraphStyle.alignment = this.nativeTextViewProtected.textAlignment;
-                // make sure a possible previously set text alignment setting is not lost when line height is specified
-                dict.set(NSParagraphStyleAttributeName, paragraphStyle);
-            }
-        };
-        if (style.letterSpacing !== 0 && this.nativeTextViewProtected.font) {
-            const kern = style.letterSpacing * this.nativeTextViewProtected.font.pointSize;
-            dict.set(NSKernAttributeName, kern);
-            createParagraphStyle();
-        }
-        // const isTextView = false;
-        if (style.lineHeight !== undefined) {
-            let lineHeight = style.lineHeight;
-            if (lineHeight === 0) {
-                lineHeight = 0.00001;
-            }
-            createParagraphStyle();
-            paragraphStyle.minimumLineHeight = lineHeight;
-            paragraphStyle.maximumLineHeight = lineHeight;
-            // } else if (isTextView) {
-            // createParagraphStyle();
-        }
-        const source = getTransformedText(isNullOrUndefined(this.text) ? '' : `${this.text}`, this.textTransform);
-        if (dict.size > 0) {
-            if (this.nativeTextViewProtected.font) {
-                dict.set(NSFontAttributeName, this.nativeTextViewProtected.font);
-            }
-            if (style.color) {
-                const color = !style.color || style.color instanceof Color ? style.color : new Color(style.color);
-                if (color) {
-                    dict.set(NSForegroundColorAttributeName, color.ios);
-                }
+        const letterSpacing = style.letterSpacing ?? 0;
+        const lineHeight = style.lineHeight ?? -1;
+        let uiColor;
+        if (style.color) {
+            const color = !style.color || style.color instanceof Color ? style.color : new Color(style.color);
+            if (color) {
+                uiColor = color.ios;
             }
-            const result = NSMutableAttributedString.alloc().initWithString(source);
-            result.setAttributesRange(dict, {
-                location: 0,
-                length: source.length
-            });
-            this.nativeTextViewProtected.attributedText = result;
-        }
-        else {
-            // Clear attributedText or text won't be affected.
-            this.nativeTextViewProtected.attributedText = undefined;
-            this.nativeTextViewProtected.text = source;
-        }
-        if (!style.color && majorVersion >= 13 && UIColor.labelColor) {
-            this._setColor(UIColor.labelColor);
         }
+        const text = getTransformedText(isNullOrUndefined(this.text) ? '' : `${this.text}`, this.textTransform);
+        NSLabelUtils.setTextDecorationAndTransformOnViewTextTextDecorationLetterSpacingLineHeightColor(this.nativeTextViewProtected, text, this.style.textDecoration || '', letterSpacing, lineHeight, uiColor);
     }
     createFormattedTextNative(value) {
         return createNativeAttributedString(value, this, this.autoFontSize, this.fontSizeRatio);
     }
     setFormattedTextDecorationAndTransform() {
+        const nativeView = this.nativeTextViewProtected;
         const attrText = this.createFormattedTextNative(this.formattedText);
         // we override parent class behavior because we apply letterSpacing and lineHeight on a per Span basis
-        if (majorVersion >= 13 && UIColor.labelColor) {
-            this.nativeTextViewProtected.textColor = UIColor.labelColor;
+        // if (majorVersion >= 13 && UIColor.labelColor) {
+        //     this.nativeTextViewProtected.textColor = UIColor.labelColor;
+        // }
+        nativeView.attributedText = attrText;
+    }
+    updateTextViewContentInset(data) {
+        // const nativeView = this.nativeTextViewProtected as NSTextView;
+        // const contentInset = nativeView.contentInset;
+        // nativeView.contentInset = Object.assign(
+        //     {
+        //         top: contentInset.top,
+        //         right: contentInset.right,
+        //         bottom: contentInset.bottom,
+        //         left: contentInset.left
+        //     },
+        //     data
+        // );
+    }
+    [_j = paddingTopProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ top: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingTop) });
+        }
+        else {
+            super[paddingTopProperty.setNative](value);
+        }
+    }
+    [_k = paddingRightProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ right: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingRight) });
+        }
+        else {
+            super[paddingRightProperty.setNative](value);
         }
-        this.nativeTextViewProtected.attributedText = attrText;
     }
-    [_g = paddingTopProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
+    [_l = paddingBottomProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ bottom: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingBottom) });
+        }
+        else {
+            super[paddingBottomProperty.setNative](value);
+        }
+    }
+    [_m = paddingLeftProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ left: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingLeft) });
+        }
+        else {
+            super[paddingLeftProperty.setNative](value);
+        }
     }
-    [_h = paddingTopProperty.setNative](value) {
-        this.updateTextContainerInset();
+    [_o = borderTopWidthProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ left: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingLeft) });
+        }
+        else {
+            super[borderTopWidthProperty.setNative](value);
+        }
     }
-    [_j = paddingRightProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
+    [_p = borderRightWidthProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ left: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingLeft) });
+        }
+        else {
+            super[borderRightWidthProperty.setNative](value);
+        }
     }
-    [_k = paddingRightProperty.setNative](value) {
-        this.updateTextContainerInset();
-    }
-    [_l = paddingBottomProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
-    }
-    [_m = paddingBottomProperty.setNative](value) {
-        this.updateTextContainerInset();
-    }
-    [_o = paddingLeftProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
-    }
-    [paddingLeftProperty.setNative](value) {
-        this.updateTextContainerInset();
-    }
-    [borderTopWidthProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
-    }
-    [borderTopWidthProperty.setNative](value) {
-        this.updateTextContainerInset();
-    }
-    [borderRightWidthProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
-    }
-    [borderRightWidthProperty.setNative](value) {
-        this.updateTextContainerInset();
-    }
-    [borderBottomWidthProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
-    }
-    [borderBottomWidthProperty.setNative](value) {
-        this.updateTextContainerInset();
-    }
-    [borderLeftWidthProperty.getDefault]() {
-        return {
-            value: 0,
-            unit: 'px'
-        };
-    }
-    [borderLeftWidthProperty.setNative](value) {
-        this.updateTextContainerInset();
-    }
-    [_p = maxLinesProperty.setNative](value) {
-        if (!value || value === 'none') {
-            this.nativeViewProtected.textContainer.maximumNumberOfLines = 0;
+    [_q = borderBottomWidthProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ left: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingLeft) });
         }
         else {
-            this.nativeViewProtected.textContainer.maximumNumberOfLines = typeof value === 'string' ? parseInt(value, 10) : value;
+            super[borderBottomWidthProperty.setNative](value);
         }
     }
-    [_q = lineBreakProperty.setNative](value) {
+    [_r = borderLeftWidthProperty.setNative](value) {
+        if (this.isUsingUITextView) {
+            // this.updateTextViewContentInset({ left: Utils.layout.toDeviceIndependentPixels(this.effectivePaddingLeft) });
+        }
+        else {
+            super[borderLeftWidthProperty.setNative](value);
+        }
+    }
+    [_s = maxLinesProperty.setNative](value) {
+        const numberLines = !value || value === 'none' ? 0 : typeof value === 'string' ? parseInt(value, 10) : value;
         const nativeView = this.nativeTextViewProtected;
-        nativeView.textContainer.lineBreakMode = lineBreakToLineBreakMode(value);
+        if (this.isUsingUITextView) {
+            nativeView.textContainer.maximumNumberOfLines = numberLines;
+        }
+        else {
+            nativeView.numberOfLines = numberLines;
+        }
+    }
+    [_t = lineBreakProperty.setNative](value) {
+        const nativeView = this.nativeTextViewProtected;
+        if (this.isUsingUITextView) {
+            nativeView.textContainer.lineBreakMode = lineBreakToLineBreakMode(value);
+        }
+        else {
+            nativeView.lineBreakMode = lineBreakToLineBreakMode(value);
+        }
     }
     [textShadowProperty.setNative](value) {
         this.nativeTextViewProtected.layer.shadowOpacity = 1;
@@ -712,29 +759,45 @@ export class Label extends LabelBase {
         this.nativeTextViewProtected.layer.shouldRasterize = true;
         this.nativeTextViewProtected.layer.masksToBounds = false;
     }
-    [_r = whiteSpaceProperty.setNative](value) {
+    [_u = whiteSpaceProperty.setNative](value) {
         const nativeView = this.nativeTextViewProtected;
         // only if no lineBreak
-        if (!this.lineBreak) {
+        // if (!this.lineBreak) {
+        if (this.isUsingUITextView) {
             nativeView.textContainer.lineBreakMode = whiteSpaceToLineBreakMode(value);
             if (!this.maxLines) {
                 if (value === 'normal') {
-                    this.nativeViewProtected.textContainer.maximumNumberOfLines = 0;
+                    nativeView.textContainer.maximumNumberOfLines = 0;
+                }
+                else {
+                    nativeView.textContainer.maximumNumberOfLines = 1;
+                }
+            }
+        }
+        else {
+            nativeView.lineBreakMode = whiteSpaceToLineBreakMode(value);
+            if (!this.maxLines) {
+                if (value === 'normal') {
+                    nativeView.numberOfLines = 0;
                 }
                 else {
-                    this.nativeViewProtected.textContainer.maximumNumberOfLines = 1;
+                    nativeView.numberOfLines = 1;
                 }
             }
         }
+        // }
     }
     updateAutoFontSize({ textView, width, height, force = false, onlyMeasure = false }) {
+        if (!this.mCanUpdateAutoFontSize) {
+            this.mNeedAutoFontSizeComputation = true;
+        }
         let currentFont;
         if (textView && this.autoFontSize) {
             if ((!textView.attributedText && !textView.text) ||
                 (width === undefined && height === undefined && CGSizeEqualToSize(textView.bounds.size, CGSizeZero))) {
                 return currentFont;
             }
-            const textViewSize = textView.frame.size;
+            const textViewSize = NSLabelUtils.insetWithRectUIEdgeInsets(textView.bounds, textView.padding).size;
             const fixedWidth = Math.floor(width !== undefined ? width : textViewSize.width);
             const fixedHeight = Math.floor(height !== undefined ? height : textViewSize.height);
             if (fixedWidth === 0 || fixedHeight === 0) {
@@ -750,14 +813,14 @@ export class Label extends LabelBase {
             }
             currentFont = textView.font;
             this.mLastAutoSizeKey = autoSizeKey;
-            const nbLines = textView.textContainer.maximumNumberOfLines;
+            const nbLines = textView instanceof UITextView ? textView.textContainer?.maximumNumberOfLines : textView.numberOfLines;
             // we need to reset verticalTextAlignment or computation will be wrong
-            this.updateTextContainerInset(false);
+            // this.updateVerticalAlignment(false);
             let expectSize;
             const stepSize = this.autoFontSizeStep || 2;
             const updateFontSize = (font) => {
                 if (this.formattedText || this.html) {
-                    this._setSpannablesFontSizeWithRatio(font.pointSize / fontSize);
+                    NSLabelUtils.updateFontRatioRatio(textView, font.pointSize / fontSize);
                 }
                 else {
                     textView.font = font;
@@ -794,7 +857,7 @@ export class Label extends LabelBase {
             }
             else {
                 const maxFontSize = this.maxFontSize || 200;
-                while (expectSize.height < fixedHeight && expectSize.width < fixedWidth && expectFont.pointSize < maxFontSize) {
+                while ((expectSize.height < fixedHeight || expectSize.width < fixedWidth) && expectFont.pointSize < maxFontSize) {
                     const newFont = expectFont.fontWithSize(expectFont.pointSize + stepSize);
                     updateFontSize(newFont);
                     size();
@@ -802,9 +865,8 @@ export class Label extends LabelBase {
                         expectFont = newFont;
                     }
                     else {
-                        if (!this.formattedText && !this.html) {
-                            textView.font = expectFont;
-                        }
+                        // we need to restore old font
+                        updateFontSize(expectFont);
                         break;
                     }
                 }
@@ -812,7 +874,7 @@ export class Label extends LabelBase {
             if (!onlyMeasure) {
                 this.fontSizeRatio = expectFont.pointSize / fontSize;
             }
-            this.updateTextContainerInset();
+            this.updateVerticalAlignment();
         }
         return currentFont;
     }
@@ -831,60 +893,87 @@ export class Label extends LabelBase {
         }
     }
     [verticalTextAlignmentProperty.setNative](value) {
-        this.updateTextContainerInset();
+        // this.nativeTextViewProtected.verticalTextAlignment = value;
+        this.updateVerticalAlignment();
     }
 }
 Label.DTCORETEXT_INIT = false;
 __decorate([
-    needFormattedStringComputation,
-    needAutoFontSizeComputation
+    profile
+], Label.prototype, "createNativeView", null);
+__decorate([
+    profile
+], Label.prototype, "initNativeView", null);
+__decorate([
+    needSetText
 ], Label.prototype, _a, null);
 __decorate([
-    needFormattedStringComputation,
-    needAutoFontSizeComputation
+    needSetText
 ], Label.prototype, _b, null);
 __decorate([
+    needSetText,
     needAutoFontSizeComputation
 ], Label.prototype, _c, null);
 __decorate([
-    needFormattedStringComputation,
+    needSetText,
     needAutoFontSizeComputation
 ], Label.prototype, _d, null);
 __decorate([
-    needFormattedStringComputation,
-    needAutoFontSizeComputation
+    needSetText
 ], Label.prototype, _e, null);
 __decorate([
+    needSetText,
     needAutoFontSizeComputation
 ], Label.prototype, _f, null);
 __decorate([
+    needSetText,
     needAutoFontSizeComputation
 ], Label.prototype, _g, null);
 __decorate([
     needAutoFontSizeComputation
 ], Label.prototype, _h, null);
 __decorate([
-    needAutoFontSizeComputation
+    profile
+], Label.prototype, "_setNativeText", null);
+__decorate([
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _j, null);
 __decorate([
-    needAutoFontSizeComputation
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _k, null);
 __decorate([
-    needAutoFontSizeComputation
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _l, null);
 __decorate([
-    needAutoFontSizeComputation
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _m, null);
 __decorate([
-    needAutoFontSizeComputation
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _o, null);
 __decorate([
-    needAutoFontSizeComputation
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _p, null);
 __decorate([
-    needAutoFontSizeComputation
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _q, null);
 __decorate([
-    needAutoFontSizeComputation
+    needAutoFontSizeComputation,
+    needUpdateVerticalAlignment
 ], Label.prototype, _r, null);
+__decorate([
+    needAutoFontSizeComputation
+], Label.prototype, _s, null);
+__decorate([
+    needAutoFontSizeComputation
+], Label.prototype, _t, null);
+__decorate([
+    needAutoFontSizeComputation
+], Label.prototype, _u, null);
 //# sourceMappingURL=label.ios.js.map