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

package/symbols.d.ts

@@ -0,0 +1,25 @@
+export declare const native_: unique symbol;
+export declare const style_: unique symbol;
+export declare const isTextChild_: unique symbol;
+export declare const isText_: unique symbol;
+export declare const isMasonView_: unique symbol;
+export declare const text_: unique symbol;
+export declare const isPlaceholder_: unique symbol;
+export declare const textNode_: unique symbol;
+export declare const textNodeIndex_: unique symbol;
+export declare const textNodeProxied_: unique symbol;
+export declare const pseudoStyles_: unique symbol;
+export declare const emptyTextNode_: unique symbol;
+export declare const breakRun_: unique symbol;
+export declare const anonymousText_: unique symbol;
+export declare const runMember_: unique symbol;
+export declare const runsInline_: unique symbol;
+export declare const blockified_: unique symbol;
+export declare const runsSettled_: unique symbol;
+export declare const windowsFontSource_: unique symbol;
+export declare const hostsRuns_: unique symbol;
+export declare const needsAnonymousText_: unique symbol;
+export declare const borderRadiusCorners_: unique symbol;
+export declare const borderSideColors_: unique symbol;
+export declare const eventType_: unique symbol;
+export declare const touchAction_: unique symbol;

package/symbols.js

@@ -0,0 +1,41 @@
+export const native_ = Symbol('[[native]]');
+export const style_ = Symbol('[[style]]');
+export const isTextChild_ = Symbol('[[isTextChild]]');
+export const isText_ = Symbol('[[isText]]');
+export const isMasonView_ = Symbol('[[isMasonView]]');
+export const text_ = Symbol('[[text]]');
+export const isPlaceholder_ = Symbol('[[isPlaceholder]]');
+export const textNode_ = Symbol('[[textNode]]');
+export const textNodeIndex_ = Symbol('[[textNodeIndex]]');
+export const textNodeProxied_ = Symbol('[[textNodeProxied]]');
+export const pseudoStyles_ = Symbol('[[pseudoStyles]]');
+// Cache slot for the synthetic text node `[textProperty.setNative]` uses when
+// no real framework DOM child backs the text (see common.ts) — lets repeat
+// writes reuse/update it instead of allocating a fresh native text run every
+// time.
+export const emptyTextNode_ = Symbol('[[emptyTextNode]]');
+// The break run a Windows `<br>` placeholder becomes inside a text container.
+export const breakRun_ = Symbol('[[breakRun]]');
+// On a child of a Windows container: the anonymous Text drawing it as part of an inline run.
+export const anonymousText_ = Symbol('[[anonymousText]]');
+// How it is held: 'run', 'break', 'text' or 'box', or 'solo' for a lone element laid out directly.
+export const runMember_ = Symbol('[[runMember]]');
+export const runsInline_ = Symbol('[[runsInline]]');
+export const blockified_ = Symbol('[[blockified]]');
+export const runsSettled_ = Symbol('[[runsSettled]]');
+// The resolved Windows font source a container's anonymous Text uses.
+export const windowsFontSource_ = Symbol('[[windowsFontSource]]');
+// Whether a view's Windows native view lays out text runs itself, and whether it is any other
+// panel that needs an anonymous Text for them; fixed once the native view exists.
+export const hostsRuns_ = Symbol('[[hostsRuns]]');
+export const needsAnonymousText_ = Symbol('[[needsAnonymousText]]');
+// Per-corner / per-side caches for the CSS-class border-radius and
+// border-color longhands core's shorthand expansion hands us — see
+// `common.ts`. Kept on the view so each longhand can recompose the shorthand
+// string the native side actually parses.
+export const borderRadiusCorners_ = Symbol('[[borderRadiusCorners]]');
+export const borderSideColors_ = Symbol('[[borderSideColors]]');
+// Overridden `Event.type`, when a host framework's DOM shim relabels the
+// event on its way to JS listeners — see `Event` in `common.ts`.
+export const eventType_ = Symbol('[[eventType]]');
+export const touchAction_ = Symbol('[[touchAction]]');

package/tree/index.android.d.ts

@@ -0,0 +1,11 @@
+export declare class Tree {
+    private _base;
+    private static _tree;
+    constructor(base?: org.nativescript.mason.masonkit.Mason);
+    static get instance(): Tree;
+    get native(): org.nativescript.mason.masonkit.Mason;
+    createView(context: any): org.nativescript.mason.masonkit.View;
+    createScrollView(context: any): org.nativescript.mason.masonkit.Scroll;
+    get preflight(): boolean;
+    set preflight(value: boolean);
+}

package/tree/index.android.js

@@ -0,0 +1,42 @@
+import { Screen, Utils } from '@nativescript/core';
+import { setCssUnitContext } from '../units';
+import { refreshViewportUnits } from '../style';
+import { setDisplayDensity } from '../display-density';
+export class Tree {
+    constructor(base) {
+        this._base = base ?? new org.nativescript.mason.masonkit.Mason();
+    }
+    static get instance() {
+        if (!Tree._tree) {
+            Tree._tree = new Tree(org.nativescript.mason.masonkit.Mason.getShared());
+            const base = Tree._tree._base;
+            base.setDeviceScale(Screen.mainScreen.scale);
+            // `vw`/`vh` have nothing to resolve against until the viewport is known, and follow rotation and resizes.
+            setCssUnitContext({ viewportWidth: Screen.mainScreen.widthDIPs, viewportHeight: Screen.mainScreen.heightDIPs });
+            base.setViewportListener(new org.nativescript.mason.masonkit.Mason.ViewportListener({
+                onViewportChanged(width, height) {
+                    setDisplayDensity(base.getScale());
+                    setCssUnitContext({ viewportWidth: width, viewportHeight: height });
+                    refreshViewportUnits();
+                },
+            }));
+            base.watchViewport(Utils.android.getApplicationContext());
+        }
+        return Tree._tree;
+    }
+    get native() {
+        return this._base;
+    }
+    createView(context) {
+        return this.native.createView(context);
+    }
+    createScrollView(context) {
+        return this.native.createScrollView(context);
+    }
+    get preflight() {
+        return this.native.getPreflight();
+    }
+    set preflight(value) {
+        this.native.setPreflight(value);
+    }
+}

package/tree/index.d.ts

@@ -0,0 +1,15 @@
+
+
+export class Tree {
+  static readonly instance: Tree;
+
+  constructor();
+
+  readonly native: org.nativescript.mason.masonkit.Mason | NSCMason;
+
+  createView(context?): org.nativescript.mason.masonkit.View | MasonView;
+
+  createScrollView(context?): org.nativescript.mason.masonkit.Scroll | MasonScroll;
+
+  preflight: boolean;
+}

package/tree/index.ios.d.ts

@@ -0,0 +1,26 @@
+export declare class Tree {
+    private _base;
+    private static _tree;
+    constructor(base?: NSCMason);
+    static get instance(): Tree;
+    get native(): NSCMason;
+    createView(): MasonUIView;
+    createScrollView(): MasonScroll;
+    /**
+     * Enable or disable CSS Preflight (web-normalised / Tailwind-like) defaults.
+     *
+     * When `true` every element starts from a clean, browser-normalised slate:
+     *  - `box-sizing: border-box`
+     *  - `margin: 0`, `padding: 0`, `border-width: 0`
+     *  - `background: transparent`
+     *  - `list-style: none` on lists
+     *  - `display: block` on `<img>`
+     *
+     * Set this **before** creating views for the cleanest result.  Changing it
+     * afterwards re-seeds the arena so that unstyled nodes immediately pick up
+     * the new defaults; nodes that were already individually styled are
+     * not affected.
+     */
+    get preflight(): boolean;
+    set preflight(value: boolean);
+}

package/tree/index.ios.js

@@ -0,0 +1,53 @@
+import { Screen } from '@nativescript/core';
+import { setViewportProvider } from '../units';
+import { refreshViewportUnits } from '../style';
+export class Tree {
+    constructor(base) {
+        this._base = base ?? NSCMason.new();
+    }
+    static get instance() {
+        if (!Tree._tree) {
+            Tree._tree = new Tree(NSCMason.shared);
+            // `vw`/`vh` follow the key window, so rotation and resizing reach new style writes.
+            setViewportProvider(() => {
+                const size = NSCMason.viewportSize;
+                if (size && size.width > 0 && size.height > 0)
+                    return { width: size.width, height: size.height };
+                return { width: Screen.mainScreen.widthDIPs, height: Screen.mainScreen.heightDIPs };
+            });
+            // A rotation or window resize writes the values that used them again.
+            NSCMason.setViewportListener(() => refreshViewportUnits());
+        }
+        return Tree._tree;
+    }
+    get native() {
+        return this._base;
+    }
+    createView() {
+        return this.native.createView();
+    }
+    createScrollView() {
+        return this.native.createScrollView();
+    }
+    /**
+     * Enable or disable CSS Preflight (web-normalised / Tailwind-like) defaults.
+     *
+     * When `true` every element starts from a clean, browser-normalised slate:
+     *  - `box-sizing: border-box`
+     *  - `margin: 0`, `padding: 0`, `border-width: 0`
+     *  - `background: transparent`
+     *  - `list-style: none` on lists
+     *  - `display: block` on `<img>`
+     *
+     * Set this **before** creating views for the cleanest result.  Changing it
+     * afterwards re-seeds the arena so that unstyled nodes immediately pick up
+     * the new defaults; nodes that were already individually styled are
+     * not affected.
+     */
+    get preflight() {
+        return this.native.preflight;
+    }
+    set preflight(value) {
+        this.native.preflight = value;
+    }
+}

package/typings/android-declarations.d.ts

@@ -0,0 +1,4 @@
+declare module androidNative {	export class Array<T> {	constructor(); length: number; [index: number]: T; } }
+
+import globalAndroid = android;
+