@octane-xplat/nativescript-mason-core 0.0.1 → 1.0.0-beta.0

package/view/index.android.d.ts

@@ -0,0 +1,13 @@
+import { ViewBase } from '../common';
+import { style_ } from '../symbols';
+export declare class View extends ViewBase {
+    [style_]: any;
+    _inBatch: boolean;
+    constructor();
+    get _view(): org.nativescript.mason.masonkit.View;
+    get _styleHelper(): any;
+    createNativeView(): org.nativescript.mason.masonkit.View;
+    get android(): org.nativescript.mason.masonkit.View;
+    _addViewToNativeVisualTree(child: MasonChild, atIndex?: number): boolean;
+    _removeViewFromNativeVisualTree(view: MasonChild): void;
+}

package/view/index.android.js

@@ -0,0 +1,74 @@
+import { CSSType, Utils } from '@nativescript/core';
+import { ViewBase } from '../common';
+import { Tree } from '../tree';
+import { Style } from '../style';
+import { style_, isMasonView_, native_, isPlaceholder_ } from '../symbols';
+let View = class View extends ViewBase {
+    constructor() {
+        super();
+        this._inBatch = false;
+        this[isMasonView_] = true;
+    }
+    get _view() {
+        if (!this[native_]) {
+            const context = Utils.android.getCurrentActivity() || Utils.android.getApplicationContext();
+            const view = Tree.instance.createView(context);
+            this[native_] = view;
+            return view;
+        }
+        return this[native_];
+    }
+    get _styleHelper() {
+        if (this[style_] === undefined) {
+            this[style_] = Style.fromView(this, this._view);
+        }
+        return this[style_];
+    }
+    createNativeView() {
+        return this._view;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    get android() {
+        return this._view;
+    }
+    // @ts-ignore
+    _addViewToNativeVisualTree(child, atIndex = -1) {
+        const nativeView = this._view;
+        if (nativeView && (child.nativeViewProtected || child.android)) {
+            child._hasNativeView = true;
+            // Map the JS index onto the native children list (views attach lazily,
+            // so the raw index can run ahead of native state).
+            const { nativeIndex: index } = this._nativeAttachIndex(child, atIndex);
+            child._isMasonChild = true;
+            if (child[isPlaceholder_]) {
+                nativeView.addChildAt(child.android, index);
+            }
+            else {
+                nativeView.addView(child.nativeViewProtected, index);
+                this._masonAdoptForeign(child);
+            }
+            return true;
+        }
+        return false;
+    }
+    // @ts-ignore
+    _removeViewFromNativeVisualTree(view) {
+        this._invalidateAttachCursor();
+        // Clear the attach flag; `_nativeIndexFor` counts it, so a stale `true` misindexes inserts.
+        view._isMasonChild = false;
+        // detach the Rust node too, since
+        // super only removes the native view.
+        const nativeView = this._view;
+        if (nativeView && view.nativeViewProtected && typeof nativeView.removeView === 'function') {
+            nativeView.removeView(view.nativeViewProtected);
+        }
+        // @ts-ignore
+        super._removeViewFromNativeVisualTree(view);
+    }
+};
+View = __decorate([
+    CSSType('View'),
+    __metadata("design:paramtypes", [])
+], View);
+export { View };

package/view/index.d.ts

@@ -0,0 +1,2 @@
+import { ViewBase } from '../common';
+export class View extends ViewBase {}

package/view/index.ios.d.ts

@@ -0,0 +1,24 @@
+import { ViewBase } from '../common';
+import { Style } from '../style';
+import { style_ } from '../symbols';
+export declare class View extends ViewBase {
+    [style_]: any;
+    constructor();
+    get _view(): MasonUIView;
+    get _styleHelper(): Style;
+    _inBatch: boolean;
+    createNativeView(): MasonUIView;
+    get ios(): MasonUIView;
+    onLayout(left: number, top: number, right: number, bottom: number): void;
+    onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void;
+    _setNativeViewFrame(nativeView: any, frame: CGRect): void;
+    _addViewToNativeVisualTree(child: MasonChild, atIndex?: number): boolean;
+    private _masonInsertNative;
+    /** Child/index pairs queued by `_addViewToNativeVisualTree`, from `_masonPendingHead`. */
+    private _masonPendingAdds;
+    private _masonPendingHead;
+    /** Run the queued inserts in order, through `upTo` (every one when omitted). */
+    _masonFlushNativeAdds(upTo?: any): void;
+    loadView(view: any): void;
+    _removeViewFromNativeVisualTree(view: MasonChild): void;
+}

package/view/index.ios.js

@@ -0,0 +1,157 @@
+import { CSSType } from '@nativescript/core';
+import { ViewBase, setRootNativeViewFrame, setMeasuredFromNative } from '../common';
+import { Style } from '../style';
+import { Tree } from '../tree';
+import { isMasonView_, isPlaceholder_, native_, style_ } from '../symbols';
+/** Views with queued native inserts (see `View._addViewToNativeVisualTree`). */
+let pendingAddHosts = 0;
+function flushNativeAddsDeep(view) {
+    view._masonFlushNativeAdds?.();
+    view.eachChildView?.((child) => {
+        if (child[isMasonView_])
+            flushNativeAddsDeep(child);
+        return true;
+    });
+}
+let View = class View extends ViewBase {
+    constructor() {
+        super();
+        this._inBatch = false;
+        this._masonPendingHead = 0;
+        this[isMasonView_] = true;
+    }
+    get _view() {
+        if (!this[native_]) {
+            const view = Tree.instance.createView();
+            this[native_] = view;
+            return view;
+        }
+        return this[native_];
+    }
+    get _styleHelper() {
+        if (this[style_] === undefined) {
+            this[style_] = Style.fromView(this, this._view);
+        }
+        return this[style_];
+    }
+    createNativeView() {
+        return this._view;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    get ios() {
+        return this._view;
+    }
+    onLayout(left, top, right, bottom) {
+        super.onLayout(left, top, right, bottom);
+        // Mason descendants were placed by the native compute; only a root's
+        // non-Mason views still need core's layout.
+        if (!this._masonPlacedNatively) {
+            this._masonLayoutForeignDescendants();
+        }
+    }
+    onMeasure(widthMeasureSpec, heightMeasureSpec) {
+        const nativeView = this._view;
+        if (nativeView) {
+            const root = !this.parent?.[isMasonView_];
+            if (root && pendingAddHosts > 0)
+                flushNativeAddsDeep(this);
+            // One native call computes a root for the host's specs, or reads a child's placed box.
+            // @ts-ignore
+            setMeasuredFromNative(this, nativeView.mason_measure(widthMeasureSpec, heightMeasureSpec, root, false));
+        }
+    }
+    _setNativeViewFrame(nativeView, frame) {
+        if (this.parent?.[isMasonView_]) {
+            nativeView.frame = frame;
+        }
+        else {
+            setRootNativeViewFrame(this, nativeView, frame);
+        }
+    }
+    // @ts-ignore
+    _addViewToNativeVisualTree(child, atIndex = -1) {
+        const nativeView = this._view;
+        if (nativeView && (child.nativeViewProtected || child.ios)) {
+            child._hasNativeView = true;
+            // Views attach lazily, so the JS index can run ahead of the native children.
+            const { nativeIndex: index } = this._nativeAttachIndex(child, atIndex);
+            child._isMasonChild = true;
+            // Inserted once loaded (see loadView), with its CSS and subtree in place.
+            if (!child.isLoaded) {
+                if (!this._masonPendingAdds) {
+                    this._masonPendingAdds = [];
+                    pendingAddHosts++;
+                }
+                this._masonPendingAdds.push(child, index);
+                return true;
+            }
+            this._masonInsertNative(child, index);
+            return true;
+        }
+        return false;
+    }
+    _masonInsertNative(child, index) {
+        const nativeView = this._view;
+        if (child[isPlaceholder_]) {
+            // @ts-ignore
+            nativeView.mason_addChildAtElement(child.ios, index);
+        }
+        else {
+            nativeView.addViewAt(child.nativeViewProtected, index);
+            this._masonAdoptForeign(child);
+            this._masonMeasureForeign(child);
+        }
+    }
+    /** Run the queued inserts in order, through `upTo` (every one when omitted). */
+    _masonFlushNativeAdds(upTo) {
+        const pending = this._masonPendingAdds;
+        if (!pending)
+            return;
+        let end = pending.length;
+        if (upTo !== undefined) {
+            let i = this._masonPendingHead;
+            while (i < end && pending[i] !== upTo)
+                i += 2;
+            if (i === end)
+                return;
+            end = i + 2;
+        }
+        let i = this._masonPendingHead;
+        // Advance first: an insert can re-enter (a measure) and flush again.
+        this._masonPendingHead = end;
+        if (end === pending.length) {
+            this._masonPendingAdds = undefined;
+            this._masonPendingHead = 0;
+            pendingAddHosts--;
+        }
+        for (; i < end; i += 2)
+            this._masonInsertNative(pending[i], pending[i + 1]);
+    }
+    loadView(view) {
+        super.loadView(view);
+        if (this._masonPendingAdds)
+            this._masonFlushNativeAdds(view);
+    }
+    // @ts-ignore
+    _removeViewFromNativeVisualTree(view) {
+        if (this._masonPendingAdds)
+            this._masonFlushNativeAdds();
+        this._invalidateAttachCursor();
+        // Clear the attach flag; `_nativeIndexFor` counts it, so a stale `true` misindexes inserts.
+        view._isMasonChild = false;
+        // Detach the Rust node too; super only removes the native view.
+        const nativeView = this._view;
+        if (nativeView && view.nativeViewProtected && typeof nativeView.removeView === 'function') {
+            nativeView.removeView(view.nativeViewProtected);
+            this._masonRequestLayoutAfterRemoval();
+        }
+        // @ts-ignore
+        super._removeViewFromNativeVisualTree(view);
+    }
+};
+View = __decorate([
+    CSSType('View'),
+    __metadata("design:paramtypes", [])
+], View);
+export { View };