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

package/pseudo.d.ts

@@ -0,0 +1,9 @@
+import { View } from '@nativescript/core';
+type PseudoStyleMap = Record<string, Record<string, any>>;
+/**
+ * Safely extract all pseudo styles for a view without touching live UI.
+ * Leverages the internal matching engine to handle hierarchy,
+ * specificity sorting, and media queries automatically.
+ */
+export declare function compile(view: View): PseudoStyleMap;
+export {};

package/pseudo.js

@@ -0,0 +1,57 @@
+/**
+ * Safely extract all pseudo styles for a view without touching live UI.
+ * Leverages the internal matching engine to handle hierarchy,
+ * specificity sorting, and media queries automatically.
+ */
+export function compile(view) {
+    const pseudos = {};
+    const styleScope = view._styleScope;
+    if (!styleScope)
+        return pseudos;
+    // `matchSelectors` filters out selectors that don't match the view statically.
+    // Dynamic parts (like :hover, :active) always return true for `mayMatch`,
+    // so they are safely returned here without needing the live UI to be in that state!
+    //@ts-ignore
+    const match = styleScope.matchSelectors(view);
+    if (!match || !match.selectors)
+        return pseudos;
+    // Helper to extract pseudo-classes recursively.
+    // NativeScript stores them in `PseudoClassSelector` or nested in `ComplexSelector` / `SimpleSelectorSequence`
+    const getPseudoClasses = (sel) => {
+        const classes = [];
+        // Base case: it's a PseudoClassSelector
+        if (sel.cssPseudoClass) {
+            classes.push(sel.cssPseudoClass);
+        }
+        // Recursive case: it's a ComplexSelector or SimpleSelectorSequence
+        if (Array.isArray(sel.selectors)) {
+            for (const s of sel.selectors) {
+                classes.push(...getPseudoClasses(s));
+            }
+        }
+        return classes;
+    };
+    // Note: match.selectors is already sorted by CSS specificity internally!
+    // So as we build our `pseudos` object, heavier overrides are correctly applied last.
+    for (const selector of match.selectors) {
+        // Optimization: skip strictly static selectors (like standard `.btn` or `#myId`)
+        if (!selector.dynamic)
+            continue;
+        const ruleset = selector.ruleset;
+        if (!ruleset || !ruleset.declarations)
+            continue;
+        const states = getPseudoClasses(selector);
+        if (states.length === 0)
+            continue;
+        // Apply declarations for every pseudo-state found on this selector
+        for (const state of states) {
+            if (!pseudos[state]) {
+                pseudos[state] = {};
+            }
+            for (const decl of ruleset.declarations) {
+                pseudos[state][decl.property] = decl.value;
+            }
+        }
+    }
+    return pseudos;
+}

package/scroll/index.android.d.ts

@@ -0,0 +1,15 @@
+import { ViewBase } from '../common';
+import { style_ } from '../symbols';
+export declare class Scroll extends ViewBase {
+    [style_]: any;
+    _inBatch: boolean;
+    constructor();
+    /** `<scroll>` treats default `visible` Y overflow as `auto`; HTML block elements opt out. */
+    get _visibleOverflowScrolls(): boolean;
+    get _view(): org.nativescript.mason.masonkit.Scroll;
+    get _styleHelper(): any;
+    createNativeView(): org.nativescript.mason.masonkit.Scroll;
+    get android(): org.nativescript.mason.masonkit.Scroll;
+    _addViewToNativeVisualTree(child: MasonChild, atIndex?: number): boolean;
+    _removeViewFromNativeVisualTree(view: MasonChild): void;
+}

package/scroll/index.android.js

@@ -0,0 +1,72 @@
+import { CSSType, Utils } from '@nativescript/core';
+import { ViewBase } from '../common';
+import { Style } from '../style';
+import { Tree } from '../tree';
+import { style_, isMasonView_, native_, isPlaceholder_ } from '../symbols';
+let Scroll = class Scroll extends ViewBase {
+    constructor() {
+        super();
+        this._inBatch = false;
+        this[isMasonView_] = true;
+    }
+    /** `<scroll>` treats default `visible` Y overflow as `auto`; HTML block elements opt out. */
+    get _visibleOverflowScrolls() {
+        return true;
+    }
+    get _view() {
+        if (!this[native_]) {
+            const context = Utils.android.getCurrentActivity() || Utils.android.getApplicationContext();
+            const view = Tree.instance.createScrollView(context);
+            // Native default is true.
+            if (!this._visibleOverflowScrolls)
+                view.setVisibleOverflowScrolls(false);
+            this[native_] = 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();
+        // @ts-ignore
+        super._removeViewFromNativeVisualTree(view);
+    }
+};
+Scroll = __decorate([
+    CSSType('Scroll'),
+    __metadata("design:paramtypes", [])
+], Scroll);
+export { Scroll };

package/scroll/index.d.ts

@@ -0,0 +1,5 @@
+import { ViewBase } from '../common';
+
+export class Scroll extends ViewBase {
+  get _visibleOverflowScrolls(): boolean;
+}

package/scroll/index.ios.d.ts

@@ -0,0 +1,18 @@
+import { ViewBase } from '../common';
+import { style_ } from '../symbols';
+export declare class Scroll extends ViewBase {
+    [style_]: any;
+    constructor();
+    /** `<scroll>` treats default `visible` Y overflow as `auto`; HTML block elements opt out. */
+    get _visibleOverflowScrolls(): boolean;
+    get _view(): MasonUIView;
+    get _styleHelper(): any;
+    _inBatch: boolean;
+    createNativeView(): MasonUIView;
+    get ios(): MasonUIView;
+    onLayout(left: number, top: number, right: number, bottom: number): void;
+    onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void;
+    _addViewToNativeVisualTree(child: MasonChild, atIndex?: number): boolean;
+    _setNativeViewFrame(nativeView: any, frame: CGRect): void;
+    _removeViewFromNativeVisualTree(view: MasonChild): void;
+}

package/scroll/index.ios.js

@@ -0,0 +1,106 @@
+import { CSSType } from '@nativescript/core';
+import { ViewBase, setRootNativeViewFrame, setMeasuredFromNative } from '../common';
+import { Style } from '../style';
+import { Tree } from '../tree';
+import { style_, isMasonView_, native_, isPlaceholder_ } from '../symbols';
+let Scroll = class Scroll extends ViewBase {
+    constructor() {
+        super();
+        this._inBatch = false;
+        this[isMasonView_] = true;
+    }
+    /** `<scroll>` treats default `visible` Y overflow as `auto`; HTML block elements opt out. */
+    get _visibleOverflowScrolls() {
+        return true;
+    }
+    get _view() {
+        if (!this[native_]) {
+            // MasonUIView has its own scroll handling; UIScrollView breaks when nested.
+            const view = Tree.instance.createView();
+            // Native default is false; most block elements keep it.
+            if (this._visibleOverflowScrolls)
+                view.isScrollContainer = true;
+            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) {
+            // As a root, the box is the viewport: clamped to the specs so the content overflows it and scrolls.
+            // @ts-ignore
+            setMeasuredFromNative(this, nativeView.mason_measure(widthMeasureSpec, heightMeasureSpec, !!this.parent && !this.parent[isMasonView_], true));
+        }
+    }
+    // @ts-ignore
+    _addViewToNativeVisualTree(child, atIndex = -1) {
+        const nativeView = this._view;
+        if (nativeView && (child.nativeViewProtected || child.ios)) {
+            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_]) {
+                // @ts-ignore
+                nativeView.mason_addChildAtElement(child.ios, index);
+            }
+            else {
+                nativeView.addViewAt(child.nativeViewProtected, index);
+                this._masonAdoptForeign(child);
+                this._masonMeasureForeign(child);
+            }
+            return true;
+        }
+        return false;
+    }
+    _setNativeViewFrame(nativeView, frame) {
+        if (this.parent?.[isMasonView_]) {
+            nativeView.frame = frame;
+        }
+        else {
+            setRootNativeViewFrame(this, nativeView, frame);
+        }
+    }
+    // @ts-ignore
+    _removeViewFromNativeVisualTree(view) {
+        this._invalidateAttachCursor();
+        // Inverse of `_addViewToNativeVisualTree` — unlink the mason node so
+        // removal detaches the Rust node + native view rather than orphaning it.
+        const nativeView = this._view;
+        if (nativeView && view.nativeViewProtected && typeof nativeView.removeView === 'function') {
+            nativeView.removeView(view.nativeViewProtected);
+            this._masonRequestLayoutAfterRemoval();
+        }
+        // @ts-ignore
+        super._removeViewFromNativeVisualTree(view);
+    }
+};
+Scroll = __decorate([
+    CSSType('Scroll'),
+    __metadata("design:paramtypes", [])
+], Scroll);
+export { Scroll };