@triniwiz/nativescript-masonkit 1.0.0-beta.106 → 1.0.0-beta.107

package/common.d.ts

@@ -229,8 +229,19 @@ export declare class ViewBase extends CustomLayoutView implements AddChildFromBu
     _unregisterNativeEvent(arg: string, callback: any, thisArg?: any): void;
     initNativeView(): void;
     _setNativeViewFrame(nativeView: any, frame: CGRect): void;
+    /**
+     * iOS: the views in this subtree a root's layout pass must visit (non-Mason children, which core
+     * lays out, and Mason views listening to layoutChanged). The pass skips subtrees where it's 0.
+     */
+    _masonLayoutWork: number;
+    private _masonAddLayoutWork;
+    private _masonListensToLayout;
+    _addViewCore(view: any, atIndex?: number): void;
+    _removeViewCore(view: any): void;
     addEventListener(arg: string, callback: any, thisArg?: any): void;
     removeEventListener(arg: string, callback: any, thisArg?: any): void;
+    private _addEventListener;
+    private _removeEventListener;
     private _applyPseudoClassStyles;
     _hoverHandler(subscribe: boolean): void;
     _handler(subscribe: boolean): void;
@@ -251,9 +262,15 @@ export declare class ViewBase extends CustomLayoutView implements AddChildFromBu
      * it when its native sizing can't express one. `false` when core should handle it.
      */
     _setChildPercentSize(child: any, horizontal: boolean, fraction: number | null): boolean;
+    /**
+     * A native removal relays out natively but runs no core layout pass, so `layoutChanged`
+     * and non-Mason descendants miss it. Ask for one; a subtree being torn down is unloaded.
+     */
+    _masonRequestLayoutAfterRemoval(): void;
     /** Lay out the non-Mason views in this root's subtree from the frames Mason set. */
     _masonLayoutForeignDescendants(): void;
     requestLayout(): void;
+    _parentChanged(oldParent: any): void;
     getMeasuredWidth(): number;
     getMeasuredHeight(): number;
     eachChildView(callback: (child: NSView) => boolean): void;

package/common.js

@@ -212,6 +212,19 @@ function clearWindowsActive(view) {
 const TEARDOWN_SLICE_MS = 8;
 // Reading the clock costs more than a teardown on some devices.
 const TEARDOWNS_PER_CLOCK_READ = 16;
+// Mason roots whose requestLayout already climbed to the page in this turn.
+let climbedRoots = null;
+function markClimbed(root) {
+    if (!climbedRoots) {
+        climbedRoots = new Set();
+        queueMicrotask(() => (climbedRoots = null));
+    }
+    climbedRoots.add(root);
+}
+// A layout in between clears core's flag, so the next request climbs again.
+function climbedThisTurn(root) {
+    return !!climbedRoots?.has(root) && !!root.isLayoutRequested;
+}
 export class ViewBase extends CustomLayoutView {
     _tearDownUI(force) {
         if ((__ANDROID__ || __APPLE__ || __WINDOWS__) && !force && !this.reusable && this._context && this.nativeViewProtected) {
@@ -314,6 +327,11 @@ export class ViewBase extends CustomLayoutView {
         this[_c] = false;
         this[_d] = {};
         this._pendingEventsRegistration = [];
+        /**
+         * iOS: the views in this subtree a root's layout pass must visit (non-Mason children, which core
+         * lays out, and Mason views listening to layoutChanged). The pass skips subtrees where it's 0.
+         */
+        this._masonLayoutWork = 0;
         // `width`/`height` are core CssAnimationProperties whose stylesheet accessor
         // is non-configurable, so units Mason understands but core does not (`vh`,
         // `rem`, `pt`, …) have to be resolved on this view's own Style object.
@@ -530,7 +548,50 @@ export class ViewBase extends CustomLayoutView {
     _setNativeViewFrame(nativeView, frame) {
         // nativeView.frame = frame;
     }
+    _masonAddLayoutWork(delta) {
+        // Up to the root: a non-Mason parent is laid out by core and its Mason roots keep their own count.
+        let view = this;
+        while (view?.[isMasonView_]) {
+            view._masonLayoutWork += delta;
+            view = view.parent;
+        }
+    }
+    _masonListensToLayout() {
+        return this.hasListeners(NSView.layoutChangedEvent);
+    }
+    _addViewCore(view, atIndex) {
+        // Before setup: listeners the child gains while loading add themselves through `parent`.
+        if (__APPLE__) {
+            const work = view?.[isMasonView_] ? view._masonLayoutWork : 1;
+            if (work)
+                this._masonAddLayoutWork(work);
+        }
+        // @ts-ignore
+        super._addViewCore(view, atIndex);
+    }
+    _removeViewCore(view) {
+        // @ts-ignore
+        super._removeViewCore(view);
+        // After teardown: listeners removed while unloading already subtracted themselves.
+        if (__APPLE__) {
+            const work = view?.[isMasonView_] ? view._masonLayoutWork : 1;
+            if (work)
+                this._masonAddLayoutWork(-work);
+        }
+    }
     addEventListener(arg, callback, thisArg) {
+        const listened = __APPLE__ && this._masonListensToLayout();
+        this._addEventListener(arg, callback, thisArg);
+        if (__APPLE__ && !listened && this._masonListensToLayout())
+            this._masonAddLayoutWork(1);
+    }
+    removeEventListener(arg, callback, thisArg) {
+        const listened = __APPLE__ && this._masonListensToLayout();
+        this._removeEventListener(arg, callback, thisArg);
+        if (__APPLE__ && listened && !this._masonListensToLayout())
+            this._masonAddLayoutWork(-1);
+    }
+    _addEventListener(arg, callback, thisArg) {
         if (typeof thisArg === 'boolean') {
             thisArg = {
                 capture: thisArg,
@@ -548,7 +609,7 @@ export class ViewBase extends CustomLayoutView {
         }
         super.addEventListener(arg, callback, thisArg);
     }
-    removeEventListener(arg, callback, thisArg) {
+    _removeEventListener(arg, callback, thisArg) {
         if (typeof thisArg === 'boolean') {
             thisArg = {
                 capture: thisArg,
@@ -714,6 +775,14 @@ export class ViewBase extends CustomLayoutView {
         }
         return true;
     }
+    /**
+     * A native removal relays out natively but runs no core layout pass, so `layoutChanged`
+     * and non-Mason descendants miss it. Ask for one; a subtree being torn down is unloaded.
+     */
+    _masonRequestLayoutAfterRemoval() {
+        if (__APPLE__ && this.isLoaded)
+            this.requestLayout();
+    }
     /** Lay out the non-Mason views in this root's subtree from the frames Mason set. */
     _masonLayoutForeignDescendants() {
         if (!__APPLE__)
@@ -721,6 +790,8 @@ export class ViewBase extends CustomLayoutView {
         const visit = (view) => {
             view.eachChildView((child) => {
                 if (child[isMasonView_]) {
+                    if (!(child._masonLayoutWork > 0))
+                        return true;
                     // Keep `layoutChanged` working for the few views that listen to it.
                     if (child.hasListeners?.(NSView.layoutChangedEvent)) {
                         const b = child._getCurrentLayoutBounds();
@@ -749,10 +820,21 @@ export class ViewBase extends CustomLayoutView {
             let root = this.parent;
             while (root?.parent?.[isMasonView_])
                 root = root.parent;
+            if (root && climbedThisTurn(root))
+                return;
             root?.requestLayout();
             return;
         }
+        // Core climbs on every call, once per changed property; once per turn is enough.
+        if (__APPLE__ && climbedThisTurn(this))
+            return;
         super.requestLayout();
+        if (__APPLE__)
+            markClimbed(this);
+    }
+    _parentChanged(oldParent) {
+        climbedRoots?.delete(this);
+        super._parentChanged(oldParent);
     }
     getMeasuredWidth() {
         if (this._masonPlacedNatively && this.nativeViewProtected) {
@@ -1582,7 +1664,7 @@ export class ViewBase extends CustomLayoutView {
     _nativeBorderRadiusCorners() {
         // @ts-ignore
         const style = this._styleHelper;
-        if (__ANDROID__ && style && !style.hasBorderRadius()) {
+        if ((__ANDROID__ || __APPLE__) && style && !style.hasBorderRadius()) {
             return borderRadiusCorners('0');
         }
         const native = String(style?.borderRadius ?? '').trim();
@@ -1606,13 +1688,18 @@ export class ViewBase extends CustomLayoutView {
         const css = lengthToCssString(masonLength(value));
         const radius = (corners[corner] = /\s/.test(css) ? parseCornerRadius(css) : [css, css]);
         const shorthand = composeBorderRadius(corners);
-        if (__ANDROID__ && style._writeCornerRadius(corner, radius, shorthand)) {
+        if ((__ANDROID__ || __APPLE__) && style._writeCornerRadius(corner, radius, shorthand)) {
             return;
         }
         // @ts-ignore
         style.borderRadius = shorthand;
     }
     _nativeCornerRadius(corner) {
+        // @ts-ignore
+        const style = this._styleHelper;
+        if ((__ANDROID__ || __APPLE__) && style && !style.hasBorderRadius()) {
+            return '0';
+        }
         const [h, v] = this._nativeBorderRadiusCorners()[corner];
         return h === v ? h : `${h} ${v}`;
     }
@@ -1641,7 +1728,7 @@ export class ViewBase extends CustomLayoutView {
         this._borderRadiusCorner(3, value);
     }
     _borderSideColor(side, value) {
-        if (__ANDROID__) {
+        if (__ANDROID__ || __APPLE__) {
             const s = this._styleHelper;
             if (s) {
                 s.setBorderSideColor(side === 't' ? 'top' : side === 'r' ? 'right' : side === 'b' ? 'bottom' : 'left', value);
@@ -1854,8 +1941,12 @@ export class ViewBase extends CustomLayoutView {
                 nodeHelper().setBorderColor(this.nativeView, String(value));
         }
         else if (__APPLE__) {
+            const s = this._styleHelper;
+            if (s)
+                s.setBorderColor(String(value));
             // @ts-ignore
-            this.nativeView.style.setBorderColor(String(value));
+            else
+                this.nativeView.style.setBorderColor(String(value));
         }
         else if (__WINDOWS__) {
             // @ts-ignore