@triniwiz/nativescript-masonkit 1.0.0-beta.95 → 1.0.0-beta.97

package/DOCS.md

@@ -905,38 +905,56 @@ Framework detection is automatic. MasonKit detects which framework is in use and
 
 ### Vue 3 Example
 
+Install the integration in the app entry file, before starting Vue:
+
+```ts
+// app.ts
+import { createApp } from 'nativescript-vue';
+import { installMasonKit } from '@triniwiz/nativescript-masonkit/vue';
+import App from './App.vue';
+
+installMasonKit();
+createApp(App).start();
+```
+
+Then use the elements directly in templates — no `registerElement` calls:
+
 ```vue
 <template>
-  <Div display="flex" flexDirection="column" padding="16">
-    <H1 textContent="Hello from Vue!" />
-    <P textContent="MasonKit works with NativeScript Vue." />
-    <Button textContent="Click Me" @tap="onTap" />
-  </Div>
+  <div class="container">
+    <h1>Hello from Vue!</h1>
+    <p>MasonKit works with NativeScript Vue.</p>
+    <button @tap="onTap">Click Me</button>
+  </div>
 </template>
-
-<script setup>
-function onTap() {
-  console.log('Button tapped!');
-}
-</script>
 ```
 
+See [vue/README.md](vue/README.md) for options (`web`/`mason`) and custom-element
+`masonMeta` usage.
+
 ### Angular Example
 
-```typescript
-import { registerElement } from '@nativescript/angular';
-import { View, Text, Div, H1, P } from '@triniwiz/nativescript-masonkit';
+Call `installMasonKit()` in `main.ts` before the bootstrap:
+
+```ts
+// main.ts
+import { bootstrapApplication, runNativeScriptAngularApp } from '@nativescript/angular';
+import { installMasonKit } from '@triniwiz/nativescript-masonkit/angular';
 
-registerElement('view', () => View);
-registerElement('text', () => Text);
-registerElement('div', () => Div);
-registerElement('h1', () => H1);
-registerElement('p', () => P);
+installMasonKit();
+
+runNativeScriptAngularApp({
+  appModuleBootstrap: () => bootstrapApplication(AppComponent),
+});
 ```
 
+Then use the elements directly in templates — no `registerElement` calls:
+
 ```html
-<MasonDiv display="flex" flexDirection="column" padding="16">
-  <MasonH1 textContent="Hello from Angular!"></MasonH1>
-  <MasonP textContent="MasonKit works with NativeScript Angular."></MasonP>
-</MasonDiv>
+<div class="container">
+  <h1>Hello from Angular!</h1>
+  <p>MasonKit works with NativeScript Angular.</p>
+</div>
 ```
+
+See [angular/README.md](angular/README.md) for options and component-host support.

package/README.md

@@ -6,6 +6,21 @@ ns plugin add @triniwiz/nativescript-masonkit
 
 ## Usage
 
+## Framework integrations
+
+The main package works with any NativeScript flavour. For Angular and Vue 3,
+dedicated entry points register every MasonKit element for you — including the
+HTML-shaped elements from `/web` — and wire up child-order bookkeeping:
+
+- **Angular** — `@triniwiz/nativescript-masonkit/angular`:
+  call `installMasonKit()` in `main.ts` before bootstrap. See
+  [angular/README.md](angular/README.md).
+- **Vue 3** — `@triniwiz/nativescript-masonkit/vue`:
+  call `installMasonKit()` in the app entry before `createApp(App).start()`.
+  See [vue/README.md](vue/README.md).
+
+Both entry points ship in this package, so no extra dependency is required.
+
 ## Rust
 
 For building the iOS and Android packages the following targets are required

package/angular/fesm2022/triniwiz-nativescript-masonkit-angular.mjs

@@ -1,6 +1,6 @@
 import { Frame, Page, ProxyViewContainer, View as View$1, ActionBar } from '@nativescript/core';
 import { PageRouterOutlet, registerElement, ɵViewUtil as _ViewUtil, isKnownView, EmulatedRenderer } from '@nativescript/angular';
-import { View } from '@triniwiz/nativescript-masonkit';
+import { frameworkRegistry, readLinkedList, View } from '@triniwiz/nativescript-masonkit';
 import { getMasonKitElements } from '@triniwiz/nativescript-masonkit/elements';
 
 /**
@@ -75,6 +75,35 @@ const masonMeta = {
         parent.removeChild(child);
     },
 };
+// ---------------------------------------------------------------------------
+// Framework adapter: Angular's visual tree uses firstChild/nextSibling, but
+// every node has nodeType 1, including invisible TextNode/CommentNode anchors.
+// Registered after the built-in defaults, so it is checked before the generic
+// DOM-shim adapter.
+// ---------------------------------------------------------------------------
+frameworkRegistry.register({
+    name: 'angular-nativescript',
+    getElement(view) {
+        if (view?.firstChild !== undefined && view?.meta?.skipAddToDom !== undefined) {
+            return view;
+        }
+        return null;
+    },
+    getChildren: readLinkedList,
+    classify(node) {
+        if (node.nodeType === 'text' || node.nodeType === 3 || node.nodeName === 'TextNode' || node.constructor?.name === 'TextNode') {
+            return 'text';
+        }
+        if (node.nodeName === 'br') {
+            return 'break';
+        }
+        if (node.nodeName === 'CommentNode' || node.constructor?.name === 'CommentNode' || node.meta?.skipAddToDom) {
+            return 'none';
+        }
+        return 'element';
+    },
+    syntheticTextOnEmpty: false,
+});
 
 /**
  * Internal element name the host container is registered under. Every component

package/angular/fesm2022/triniwiz-nativescript-masonkit-angular.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"triniwiz-nativescript-masonkit-angular.mjs","sources":["../../../../../packages/nativescript-masonkit/angular/src/mason-meta.ts","../../../../../packages/nativescript-masonkit/angular/src/component-host.ts","../../../../../packages/nativescript-masonkit/angular/src/element-registry.ts","../../../../../packages/nativescript-masonkit/angular/src/install.ts","../../../../../packages/nativescript-masonkit/angular/triniwiz-nativescript-masonkit-angular.ts"],"sourcesContent":["import type { ViewClassMeta } from '@nativescript/angular';\n\n/**\n * The subset of MasonKit's `ViewBase` child API this meta drives.\n *\n * Typed structurally rather than against the real class so the meta can also be\n * attached to subclasses declared outside this package (e.g. an app's own\n * `View` subclass) without a nominal dependency.\n */\ninterface MasonChildOps {\n  /**\n   * MasonKit's raw child list. Unlike `_viewChildren` it includes text-node and\n   * placeholder (`<br>`) entries, and it is the list `insertChild` splices into.\n   */\n  _children: unknown[];\n  getChildIndex(child: unknown): number;\n  insertChild(child: unknown, atIndex: number): void;\n  addChild(child: unknown): void;\n  removeChild(child: unknown): void;\n}\n\n/**\n * Index of `child` in the parent's raw `_children` list, or -1.\n *\n * Deliberately *not* `parent.getChildIndex()`: that walks `_viewChildren`, which\n * filters out text nodes and placeholders, so its indices drift from the ones\n * `insertChild()` splices into as soon as a container mixes views and text. The\n * only index `insertChild` accepts is a `_children` index, so that is what we\n * compute. `getChildIndex` stays as the fallback for a container that predates\n * `_children` or overrides the lookup.\n */\nfunction rawChildIndex(parent: MasonChildOps, child: unknown): number {\n  if (child == null) {\n    return -1;\n  }\n  const children = parent._children;\n  if (Array.isArray(children)) {\n    return children.indexOf(child);\n  }\n  return typeof parent.getChildIndex === 'function' ? parent.getChildIndex(child) : -1;\n}\n\n/**\n * `ViewClassMeta` that routes Angular's visual-tree mutations through MasonKit's\n * own child bookkeeping.\n *\n * ## Why every MasonKit element needs this\n *\n * MasonKit's `ViewBase` extends `CustomLayoutView`, **not** `LayoutBase`.\n * `@nativescript/angular`'s `ViewUtil` branches on `view instanceof LayoutBase`,\n * so without a meta a MasonKit container falls into the generic fallbacks:\n *\n * - `addToVisualTree` → `parent._addChildFromBuilder(name, child)`, which is a\n *   plain `addChild()` append. The resolved `next` sibling is **discarded**, so\n *   anything Angular inserts in the middle of a container (`*ngIf` toggling on,\n *   `*ngFor` reordering, a router swap) lands at the end and the Taffy tree ends\n *   up in a different order than the template.\n * - `removeFromVisualTree` → core's `parent._removeView(child)`, which bypasses\n *   MasonKit's `removeChild()` entirely. The native view detaches but the entry\n *   stays in `_children`, and since `_children` is what drives native insertion\n *   indices (`_nativeIndexFor`), every later insert into that container is\n *   misplaced - the classic \"nested components lay out wrong\" symptom.\n *\n * Routing through `insertChild`/`addChild`/`removeChild` keeps the Taffy tree,\n * the `_children` bookkeeping and the native view tree in step. This is the same\n * contract `frameMeta`/`formattedStringMeta` use for their containers.\n *\n * ## Why `insertChild` must not throw\n *\n * `next` is whatever `ViewUtil.findNextVisual()` resolved to, which is not\n * guaranteed to be a node MasonKit ever tracked. MasonKit's own `insertBefore()`\n * throws `NotFoundError` for an unknown reference; thrown from here that would\n * abort the component's change detection and blank it. An unknown reference\n * simply degrades to an append, exactly as `insertToLayout` does for classic\n * layouts.\n *\n * Invisible nodes (Angular's `CommentNode`/`TextNode`) are intentionally left to\n * `ViewUtil`'s default handling: it assigns `parent.text`, which MasonKit's\n * `textProperty.setNative` already reconciles into real native text nodes.\n */\nexport const masonMeta: ViewClassMeta = {\n  insertChild(parent: MasonChildOps, child: unknown, next?: unknown): void {\n    const index = rawChildIndex(parent, next);\n    if (index > -1) {\n      parent.insertChild(child, index);\n    } else {\n      parent.addChild(child);\n    }\n  },\n  removeChild(parent: MasonChildOps, child: unknown): void {\n    parent.removeChild(child);\n  },\n};\n","import { ActionBar, Frame, Page, ProxyViewContainer, View as NSView } from '@nativescript/core';\nimport { EmulatedRenderer, PageRouterOutlet, isKnownView, registerElement, ɵViewUtil } from '@nativescript/angular';\nimport { View } from '@triniwiz/nativescript-masonkit';\n\nimport { masonMeta } from './mason-meta';\n\n/**\n * Internal element name the host container is registered under. Every component\n * host is created from this entry and then re-stamped with its original tag, so\n * this name never appears in a template.\n */\nconst COMPONENT_HOST_TAG = 'mason-component-host';\n\n/** How a passthrough element can be identified. */\nexport type PassthroughMatcher = string | RegExp | ((elementName: string) => boolean);\n\n/**\n * Framework router outlets, which must stay transparent.\n *\n * They host a classic `Frame`/`Page` that fills its parent by classic\n * measurement. A `ProxyViewContainer` is a logical passthrough - its child is\n * hoisted into the nearest real native ancestor and measured with an exact,\n * fill-parent size. A MasonKit host is instead a real Taffy box, and Taffy\n * *content-sizes* a foreign (non-MasonKit) child, so the `Frame` collapses to\n * ~0 and nothing from the outlet down renders.\n *\n * Most `@nativescript/angular` views (`ActionBar`, `ActionItem`, ...) are\n * already `registerElement`'d, so only the outlets reach us as unregistered\n * elements.\n */\nconst DEFAULT_PASSTHROUGH_ELEMENTS = ['page-router-outlet', 'ns-empty-outlet', 'router-outlet'];\n\nexport interface ComponentHostOptions {\n  /**\n   * Turn component-host mode off entirely while keeping element registration.\n   *\n   * @default true\n   */\n  enabled?: boolean;\n  /**\n   * Extra elements to keep as a transparent `ProxyViewContainer`. Strings are\n   * compared case-insensitively; regexes and predicates receive the raw element\n   * name.\n   *\n   * Routed components are handled automatically, so this is only needed for a\n   * component whose template root is a classic fill-parent view that this\n   * cannot see coming - another router outlet, a `Frame`, a `Page`.\n   */\n  passthrough?: PassthroughMatcher[];\n  /**\n   * Recognise page roots automatically: routed components at creation time, and\n   * any host that turns out to hold a `Frame`, `Page` or `ActionBar`.\n   *\n   * @default true\n   */\n  autoDetectPassthrough?: boolean;\n  /**\n   * Keep the Angular root component's host element a `ProxyViewContainer`.\n   *\n   * `AppHostView` only wraps the root in its full-screen root `GridLayout` when\n   * that root *is* a `ProxyViewContainer`, so the root element has to stay a\n   * passthrough for the tree below it to have a viewport-sized ancestor to\n   * resolve `height: 100%` against.\n   *\n   * Detected rather than hardcoded: Angular creates the root component's host\n   * through `NativeScriptRenderer.selectRootElement`, so an element created\n   * while that runs is the root. See {@link patchSelectRootElement}.\n   *\n   * @default true\n   */\n  rootAsPassthrough?: boolean;\n}\n\n/**\n * Live configuration, read at element-creation time rather than captured at\n * install time so a later `installMasonKit()` call can still adjust it.\n *\n * `passthrough` is not mirrored here: matchers are compiled straight into\n * {@link passthroughNames} / {@link passthroughTests} when they arrive.\n */\nconst config = {\n  enabled: true,\n  autoDetectPassthrough: true,\n  rootAsPassthrough: true,\n};\n\n/** Lowercased string matchers, kept separate for O(1) lookup. */\nconst passthroughNames = new Set<string>(DEFAULT_PASSTHROUGH_ELEMENTS);\n/** Regex and predicate matchers. */\nconst passthroughTests: Array<RegExp | ((name: string) => boolean)> = [];\n\nlet installed = false;\n\n/**\n * Set while `PageRouterOutlet` is building a routed component, so the host\n * element it creates can be recognised as a page root at creation time.\n * See {@link patchPageRouterOutlet}.\n */\nlet creatingPageRoot = false;\n\n/**\n * Set while `NativeScriptRenderer.selectRootElement` is creating the Angular\n * root component's host element. See {@link patchSelectRootElement}.\n */\nlet creatingAppRoot = false;\n\n/**\n * The real native container behind every component host element.\n *\n * MasonKit's `View` is a `CustomLayoutView` backed by the Taffy layout engine;\n * it embeds in classic NativeScript layouts and hosts both MasonKit and classic\n * NativeScript children. Making a component's host element one of these gives\n * it the same mental model as the web: the host is a real box in the layout,\n * with the full style surface, and `flex`/`grid` on a component element does\n * what it says.\n */\nclass MasonComponentHost extends View {\n  /** The element name from the template, kept for diagnostics and auto-detect. */\n  masonHostElementName?: string;\n\n  addChild(child: unknown): void {\n    inspectChild(this, child);\n    super.addChild(child);\n  }\n\n  insertChild(child: unknown, atIndex: number): void {\n    inspectChild(this, child);\n    super.insertChild(child, atIndex);\n  }\n}\n\n/**\n * True when `child` cannot lay out under a Taffy box at all, so its host has to\n * become transparent.\n *\n * `Frame` and `Page` fill their parent by classic measurement, and Taffy\n * content-sizes a foreign (non-MasonKit) child, so under a MasonKit host they\n * collapse to ~0 and nothing below them renders. No styling an app can apply\n * works around that, which is what makes forcing a passthrough right.\n */\nfunction needsTransparentParent(child: unknown): boolean {\n  if (child instanceof Frame || child instanceof Page) {\n    return true;\n  }\n  // A proxy hoists its own children, so look through it for the view it is\n  // standing in for.\n  if (child instanceof ProxyViewContainer) {\n    const count = child.getChildrenCount();\n    for (let i = 0; i < count; i++) {\n      if (needsTransparentParent(child.getChildAt(i))) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction inspectChild(host: MasonComponentHost, child: unknown): void {\n  if (!config.autoDetectPassthrough || !host.masonHostElementName) {\n    return;\n  }\n  if (!(child instanceof NSView)) {\n    return;\n  }\n  // An ActionBar means this component is a page root: its siblings are\n  // page-level content that fills the `Page` by classic measurement, and a\n  // Taffy box between the two content-sizes them away.\n  //\n  // This is the backstop for the outlet hook in `patchPageRouterOutlet()`. If\n  // that hook stops firing - a different routing path, an upstream refactor -\n  // this still catches the case, one render late.\n  if (needsTransparentParent(child) || child instanceof ActionBar) {\n    learnPassthroughElement(host.masonHostElementName);\n  }\n}\n\n/**\n * Record an element name as a passthrough after the fact, and say so.\n *\n * The host that triggered detection already exists and cannot change class:\n * Angular's `ViewUtil` holds it in a sibling linked list, so swapping it\n * mid-render would corrupt that list. Every *later* creation of the element\n * becomes a proxy, so the second render onwards is correct - and the log names\n * the selector to put in `passthrough` to fix the first render too.\n */\nfunction learnPassthroughElement(elementName: string): void {\n  const name = elementName.toLowerCase();\n  if (passthroughNames.has(name)) {\n    return;\n  }\n  passthroughNames.add(name);\n  console.log(`[masonkit/angular] <${elementName}> holds a page-level view (Frame, Page or ActionBar) that Taffy cannot size as a Mason box. ` + `It will be created as a transparent ProxyViewContainer from now on. Add '${elementName}' to the ` + `passthrough option to apply this from the first render too.`);\n}\n\nfunction isPassthrough(elementName: string): boolean {\n  if (passthroughNames.has(elementName.toLowerCase())) {\n    return true;\n  }\n  for (const test of passthroughTests) {\n    if (test instanceof RegExp ? test.test(elementName) : test(elementName)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Recognise routed components at creation time, so the very first render of a\n * route is correct rather than being repaired afterwards.\n *\n * A routed component is a page root: `PageRouterOutlet` creates it, then moves\n * its host element to be the `Page`'s content. Page-level content (a\n * fill-parent `ScrollView` or layout) sizes itself against the `Page` by\n * classic measurement, so a Taffy box in between content-sizes it to nothing -\n * the ActionBar still renders because it is hoisted onto the `Page`, and\n * everything below it disappears.\n *\n * Detection alone cannot fix that, because by the time a host reports an\n * ActionBar child the host exists and cannot change class. `activateOnGoForward`\n * closes the gap: it builds the routed component inside its own call, so the\n * first unregistered element created while it runs *is* the route's host\n * element. Bracketing it gives `createView` the one piece of information it was\n * missing, with no per-app configuration.\n *\n * Nothing is lost by making these transparent: a page root is a full-screen\n * container, not a box anyone styles. Components *below* it stay real MasonKit\n * hosts, which is where component-host mode earns its keep.\n */\nfunction patchPageRouterOutlet(): void {\n  // `activateOnGoForward` is private on the class, so reach it through an\n  // untyped view of the prototype.\n  const proto = PageRouterOutlet?.prototype as unknown as undefined | Record<string, unknown>;\n  const original = proto?.['activateOnGoForward'];\n  if (!proto || typeof original !== 'function') {\n    // Different version, different internals. The ActionBar backstop in\n    // `inspectChild` still covers it from the second render on.\n    return;\n  }\n\n  proto['activateOnGoForward'] = function (this: unknown, ...args: unknown[]) {\n    creatingPageRoot = true;\n    try {\n      return original.apply(this, args);\n    } finally {\n      creatingPageRoot = false;\n    }\n  };\n}\n\n/**\n * Recognise the Angular root component's host element at creation time.\n *\n * Angular bootstraps the root component through\n * `renderer.selectRootElement(selector)`, and the NativeScript renderer creates\n * the host element from that selector with `viewUtil.createView`. Bracketing the\n * call marks exactly that element as the root, however many times the app\n * bootstraps in one JS process.\n *\n * This used to be a \"first unregistered element ever created\" counter, which is\n * only right for the first bootstrap. When Android recreates the Activity while\n * the process lives on (tapping the launcher icon after an `ns run` deploy,\n * rotation, a dark-mode switch), `@nativescript/angular` bootstraps the app\n * again and the counter is already past zero, so the root became a real\n * MasonKit box. `AppHostView` then skips its full-screen root `GridLayout`, and\n * Taffy content-sizes the classic view under it to the ActionBar height - the\n * page renders as an empty screen below the toolbar.\n */\nfunction patchSelectRootElement(rendererProto: { selectRootElement?: unknown }): void {\n  const original = rendererProto.selectRootElement;\n  if (typeof original !== 'function') {\n    return;\n  }\n  rendererProto.selectRootElement = function (this: unknown, ...args: unknown[]) {\n    creatingAppRoot = true;\n    try {\n      return original.apply(this, args);\n    } finally {\n      creatingAppRoot = false;\n    }\n  };\n}\n\nfunction applyOptions(options: ComponentHostOptions): void {\n  if (options.enabled !== undefined) {\n    config.enabled = options.enabled;\n  }\n  if (options.autoDetectPassthrough !== undefined) {\n    config.autoDetectPassthrough = options.autoDetectPassthrough;\n  }\n  if (options.rootAsPassthrough !== undefined) {\n    config.rootAsPassthrough = options.rootAsPassthrough;\n  }\n  for (const matcher of options.passthrough ?? []) {\n    if (typeof matcher === 'string') {\n      passthroughNames.add(matcher.toLowerCase());\n    } else {\n      passthroughTests.push(matcher);\n    }\n  }\n}\n\n/**\n * Turn every Angular component host element into a real MasonKit view.\n *\n * Stock `@nativescript/angular` creates a `ProxyViewContainer` for every element\n * that is not `registerElement`'d - i.e. every Angular component selector. That\n * container creates no native view, so anything placed on a component element\n * (`backgroundColor`, `margin`, `class=\"...\"`, host bindings) is set on an\n * invisible logical wrapper with no visual effect, and the component is\n * transparent to layout. Nesting components then produces layouts that do not\n * match the template, because the boxes the template implies do not exist.\n *\n * This replaces that fallback with a {@link MasonComponentHost}, so a component\n * host element is a real box, as on the web.\n *\n * Idempotent: repeated calls only update the configuration.\n *\n * Trade-off: an unknown element name (a typo, a component that was never\n * declared) becomes a host instead of throwing \"No known component for element\n * X\". Set `enabled: false` to keep the stock behaviour.\n */\nexport function enableMasonComponentHosts(options: ComponentHostOptions = {}): void {\n  applyOptions(options);\n\n  if (installed) {\n    return;\n  }\n  installed = true;\n\n  registerElement(COMPONENT_HOST_TAG, () => MasonComponentHost, masonMeta);\n\n  patchPageRouterOutlet();\n\n  // Patch point 1 of 2: `ViewUtil.createView` substitutes 'ProxyViewContainer'\n  // for unregistered elements. `ɵViewUtil` is a frozen namespace, but the\n  // `ViewUtil` prototype itself is mutable.\n  const { ViewUtil } = ɵViewUtil;\n  const originalCreateView = ViewUtil.prototype.createView;\n  ViewUtil.prototype.createView = function (name: string) {\n    const unregistered = !isKnownView(name);\n\n    // The element `selectRootElement` creates is the Angular root component's\n    // host. Consume the flag so only that element claims it.\n    let isAppRoot = false;\n    if (unregistered && creatingAppRoot) {\n      creatingAppRoot = false;\n      isAppRoot = true;\n    }\n\n    // The first unregistered element created while `PageRouterOutlet` is\n    // building a routed component is that route's host element. Consume the\n    // flag so only that element claims it, and remember the name so later\n    // creations of the same component match without needing the bracket.\n    let isPageRoot = false;\n    if (unregistered && creatingPageRoot) {\n      creatingPageRoot = false;\n      isPageRoot = true;\n      passthroughNames.add(name.toLowerCase());\n    }\n\n    if (!config.enabled || !unregistered || isPageRoot || isPassthrough(name) || (config.rootAsPassthrough && isAppRoot)) {\n      // Known element, or one we deliberately keep as a transparent\n      // ProxyViewContainer. `originalCreateView` substitutes the proxy for\n      // unregistered names but does not record the original tag (the renderer\n      // normally does that), so stamp it here to keep CSS type selectors and\n      // debugging output working on this path too.\n      const view = originalCreateView.call(this, name);\n      if (unregistered) {\n        view.customCSSName = name;\n      }\n      return view;\n    }\n\n    const host = originalCreateView.call(this, COMPONENT_HOST_TAG) as MasonComponentHost & { nodeName: string; tagName: string; cssType: string; customCSSName: string };\n    // Preserve the original tag for CSS type selectors, for debugging, and for\n    // Angular's `rootElement.tagName.toLowerCase()` bootstrap check.\n    host.nodeName = name;\n    host.tagName = name;\n    host.cssType = name;\n    host.customCSSName = name;\n    host.masonHostElementName = name;\n    return host;\n  };\n\n  // Patch point 2 of 2: `NativeScriptRenderer.createElement` performs the same\n  // 'ProxyViewContainer' substitution *before* delegating to `createView`, so\n  // the patch above would never see the original tag. Route it through the\n  // patched `createView` with the tag intact. The renderer class is not\n  // exported, but `EmulatedRenderer` extends it and delegates via\n  // `super.createElement()`, so patching the shared base prototype covers both.\n  const rendererProto = Object.getPrototypeOf(EmulatedRenderer.prototype) as {\n    createElement(this: { viewUtil: InstanceType<typeof ViewUtil> }, name: string, namespace?: string): unknown;\n    selectRootElement?: unknown;\n  };\n  patchSelectRootElement(rendererProto);\n\n  const originalCreateElement = rendererProto.createElement;\n  rendererProto.createElement = function (name: string, namespace?: string) {\n    if (isKnownView(name)) {\n      // Nothing to intercept - keep the stock path, including its tracing.\n      return originalCreateElement.call(this, name, namespace);\n    }\n    // Unregistered: hand the *original* tag to the patched `createView`, which\n    // decides between a host and a proxy and stamps `customCSSName` either way.\n    return this.viewUtil.createView(name);\n  };\n}\n","import { registerElement } from '@nativescript/angular';\nimport { getMasonKitElements, type GetMasonKitElementsOptions } from '@triniwiz/nativescript-masonkit/elements';\n\nimport { masonMeta } from './mason-meta';\n\nexport type RegisterElementsOptions = GetMasonKitElementsOptions;\n\n/**\n * Element names this package has already registered, so a second call (module\n * re-import, HMR) is a no-op rather than a duplicate registration.\n */\nconst registered = new Set<string>();\n\n/**\n * Register MasonKit's elements with `@nativescript/angular`, each with the child\n * bookkeeping meta it needs (see {@link masonMeta}) when it manages children\n * through MasonKit's own child list.\n *\n * The tag list itself — including the \"`/web`'s more specific element wins\"\n * de-duplication between `/web` and MasonKit's own widgets — comes from the\n * shared {@link getMasonKitElements}, so it can never drift from what other\n * framework integrations register.\n *\n * Safe to call more than once - later calls skip names already registered here.\n *\n * ## Shadowing\n *\n * `registerElement` overwrites silently, and `@nativescript/angular` registers\n * every element under its original, lowercase and kebab spellings. MasonKit's\n * `Button`, `Img` and `/web`'s `Span` therefore *replace* core's `Button`,\n * `img` (`Image`) and `Span` for Angular templates. That is the intent - these\n * are the MasonKit-laid-out equivalents - but it is why `mason`/`web` can each\n * be turned off if an app wants to keep the classic widgets.\n */\nexport function registerMasonKitElements(options: RegisterElementsOptions = {}): void {\n  for (const { tag, ctor, isContainer } of getMasonKitElements(options)) {\n    // Compared lowercase: `getMasonKitElements` already de-dupes case-\n    // insensitively across `/web` vs MasonKit's own widgets; this `registered`\n    // set only guards against a second *call* to this function re-registering\n    // the same tag.\n    const key = tag.toLowerCase();\n    if (registered.has(key)) {\n      continue;\n    }\n    registered.add(key);\n    // Pass the original casing through: `registerElement` also derives the\n    // lowercase and kebab-case spellings from it, so registering `'TextArea'`\n    // (not `'textarea'`) is what makes `<View>`, `<view>` AND `<text-area>`\n    // all resolve.\n    registerElement(tag, () => ctor, isContainer ? masonMeta : undefined);\n  }\n}\n","import { ComponentHostOptions, enableMasonComponentHosts } from './component-host';\nimport { RegisterElementsOptions, registerMasonKitElements } from './element-registry';\n\nexport interface InstallMasonKitOptions extends RegisterElementsOptions {\n  /**\n   * Component-host mode: make every Angular component host element a real\n   * MasonKit view instead of an invisible `ProxyViewContainer`.\n   *\n   * On by default - installing this is taken as the statement that MasonKit is\n   * how the app lays out. Pass `false`, or an options object with\n   * `enabled: false`, to opt out and keep stock `@nativescript/angular`\n   * behaviour while still getting the element registrations.\n   *\n   * @default true\n   */\n  componentHosts?: boolean | ComponentHostOptions;\n}\n\n/**\n * Install MasonKit's Angular integration.\n *\n * Call this in `main.ts` **before** `runNativeScriptAngularApp()`:\n *\n * ```ts\n * import { installMasonKit } from '@triniwiz/nativescript-masonkit/angular';\n *\n * installMasonKit();\n *\n * runNativeScriptAngularApp({\n *   appModuleBootstrap: () => platformNativeScript().bootstrapModule(AppModule),\n * });\n * ```\n *\n * It has to run before the bootstrap, not as part of it: the element map and\n * the renderer patch must be in place before Angular creates the root\n * component's host element, and an `NgModule` import or an `APP_INITIALIZER`\n * would both be too late for some of that. A plain function call at the top of\n * the entry file is unambiguous about when it happens.\n *\n * Idempotent - element registration is deduplicated and the component-host\n * patches are installed once, then only reconfigured.\n */\nexport function installMasonKit(options: InstallMasonKitOptions = {}): void {\n  registerMasonKitElements(options);\n\n  const { componentHosts = true } = options;\n  if (componentHosts === false) {\n    enableMasonComponentHosts({ enabled: false });\n  } else {\n    enableMasonComponentHosts(componentHosts === true ? {} : componentHosts);\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":["NSView","ɵViewUtil"],"mappings":"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"}
+{"version":3,"file":"triniwiz-nativescript-masonkit-angular.mjs","sources":["../../../../../packages/nativescript-masonkit/angular/src/mason-meta.ts","../../../../../packages/nativescript-masonkit/angular/src/component-host.ts","../../../../../packages/nativescript-masonkit/angular/src/element-registry.ts","../../../../../packages/nativescript-masonkit/angular/src/install.ts","../../../../../packages/nativescript-masonkit/angular/triniwiz-nativescript-masonkit-angular.ts"],"sourcesContent":["import type { ViewClassMeta } from '@nativescript/angular';\nimport { frameworkRegistry, readLinkedList } from '@triniwiz/nativescript-masonkit';\n\n/**\n * The subset of MasonKit's `ViewBase` child API this meta drives.\n *\n * Typed structurally rather than against the real class so the meta can also be\n * attached to subclasses declared outside this package (e.g. an app's own\n * `View` subclass) without a nominal dependency.\n */\ninterface MasonChildOps {\n  /**\n   * MasonKit's raw child list. Unlike `_viewChildren` it includes text-node and\n   * placeholder (`<br>`) entries, and it is the list `insertChild` splices into.\n   */\n  _children: unknown[];\n  getChildIndex(child: unknown): number;\n  insertChild(child: unknown, atIndex: number): void;\n  addChild(child: unknown): void;\n  removeChild(child: unknown): void;\n}\n\n/**\n * Index of `child` in the parent's raw `_children` list, or -1.\n *\n * Deliberately *not* `parent.getChildIndex()`: that walks `_viewChildren`, which\n * filters out text nodes and placeholders, so its indices drift from the ones\n * `insertChild()` splices into as soon as a container mixes views and text. The\n * only index `insertChild` accepts is a `_children` index, so that is what we\n * compute. `getChildIndex` stays as the fallback for a container that predates\n * `_children` or overrides the lookup.\n */\nfunction rawChildIndex(parent: MasonChildOps, child: unknown): number {\n  if (child == null) {\n    return -1;\n  }\n  const children = parent._children;\n  if (Array.isArray(children)) {\n    return children.indexOf(child);\n  }\n  return typeof parent.getChildIndex === 'function' ? parent.getChildIndex(child) : -1;\n}\n\n/**\n * `ViewClassMeta` that routes Angular's visual-tree mutations through MasonKit's\n * own child bookkeeping.\n *\n * ## Why every MasonKit element needs this\n *\n * MasonKit's `ViewBase` extends `CustomLayoutView`, **not** `LayoutBase`.\n * `@nativescript/angular`'s `ViewUtil` branches on `view instanceof LayoutBase`,\n * so without a meta a MasonKit container falls into the generic fallbacks:\n *\n * - `addToVisualTree` → `parent._addChildFromBuilder(name, child)`, which is a\n *   plain `addChild()` append. The resolved `next` sibling is **discarded**, so\n *   anything Angular inserts in the middle of a container (`*ngIf` toggling on,\n *   `*ngFor` reordering, a router swap) lands at the end and the Taffy tree ends\n *   up in a different order than the template.\n * - `removeFromVisualTree` → core's `parent._removeView(child)`, which bypasses\n *   MasonKit's `removeChild()` entirely. The native view detaches but the entry\n *   stays in `_children`, and since `_children` is what drives native insertion\n *   indices (`_nativeIndexFor`), every later insert into that container is\n *   misplaced - the classic \"nested components lay out wrong\" symptom.\n *\n * Routing through `insertChild`/`addChild`/`removeChild` keeps the Taffy tree,\n * the `_children` bookkeeping and the native view tree in step. This is the same\n * contract `frameMeta`/`formattedStringMeta` use for their containers.\n *\n * ## Why `insertChild` must not throw\n *\n * `next` is whatever `ViewUtil.findNextVisual()` resolved to, which is not\n * guaranteed to be a node MasonKit ever tracked. MasonKit's own `insertBefore()`\n * throws `NotFoundError` for an unknown reference; thrown from here that would\n * abort the component's change detection and blank it. An unknown reference\n * simply degrades to an append, exactly as `insertToLayout` does for classic\n * layouts.\n *\n * Invisible nodes (Angular's `CommentNode`/`TextNode`) are intentionally left to\n * `ViewUtil`'s default handling: it assigns `parent.text`, which MasonKit's\n * `textProperty.setNative` already reconciles into real native text nodes.\n */\nexport const masonMeta: ViewClassMeta = {\n  insertChild(parent: MasonChildOps, child: unknown, next?: unknown): void {\n    const index = rawChildIndex(parent, next);\n    if (index > -1) {\n      parent.insertChild(child, index);\n    } else {\n      parent.addChild(child);\n    }\n  },\n  removeChild(parent: MasonChildOps, child: unknown): void {\n    parent.removeChild(child);\n  },\n};\n\n// ---------------------------------------------------------------------------\n// Framework adapter: Angular's visual tree uses firstChild/nextSibling, but\n// every node has nodeType 1, including invisible TextNode/CommentNode anchors.\n// Registered after the built-in defaults, so it is checked before the generic\n// DOM-shim adapter.\n// ---------------------------------------------------------------------------\n\nframeworkRegistry.register({\n  name: 'angular-nativescript',\n  getElement(view) {\n    if (view?.firstChild !== undefined && view?.meta?.skipAddToDom !== undefined) {\n      return view;\n    }\n    return null;\n  },\n  getChildren: readLinkedList,\n  classify(node) {\n    if (node.nodeType === 'text' || node.nodeType === 3 || node.nodeName === 'TextNode' || node.constructor?.name === 'TextNode') {\n      return 'text';\n    }\n    if (node.nodeName === 'br') {\n      return 'break';\n    }\n    if (node.nodeName === 'CommentNode' || node.constructor?.name === 'CommentNode' || node.meta?.skipAddToDom) {\n      return 'none';\n    }\n    return 'element';\n  },\n  syntheticTextOnEmpty: false,\n});\n","import { ActionBar, Frame, Page, ProxyViewContainer, View as NSView } from '@nativescript/core';\nimport { EmulatedRenderer, PageRouterOutlet, isKnownView, registerElement, ɵViewUtil } from '@nativescript/angular';\nimport { View } from '@triniwiz/nativescript-masonkit';\n\nimport { masonMeta } from './mason-meta';\n\n/**\n * Internal element name the host container is registered under. Every component\n * host is created from this entry and then re-stamped with its original tag, so\n * this name never appears in a template.\n */\nconst COMPONENT_HOST_TAG = 'mason-component-host';\n\n/** How a passthrough element can be identified. */\nexport type PassthroughMatcher = string | RegExp | ((elementName: string) => boolean);\n\n/**\n * Framework router outlets, which must stay transparent.\n *\n * They host a classic `Frame`/`Page` that fills its parent by classic\n * measurement. A `ProxyViewContainer` is a logical passthrough - its child is\n * hoisted into the nearest real native ancestor and measured with an exact,\n * fill-parent size. A MasonKit host is instead a real Taffy box, and Taffy\n * *content-sizes* a foreign (non-MasonKit) child, so the `Frame` collapses to\n * ~0 and nothing from the outlet down renders.\n *\n * Most `@nativescript/angular` views (`ActionBar`, `ActionItem`, ...) are\n * already `registerElement`'d, so only the outlets reach us as unregistered\n * elements.\n */\nconst DEFAULT_PASSTHROUGH_ELEMENTS = ['page-router-outlet', 'ns-empty-outlet', 'router-outlet'];\n\nexport interface ComponentHostOptions {\n  /**\n   * Turn component-host mode off entirely while keeping element registration.\n   *\n   * @default true\n   */\n  enabled?: boolean;\n  /**\n   * Extra elements to keep as a transparent `ProxyViewContainer`. Strings are\n   * compared case-insensitively; regexes and predicates receive the raw element\n   * name.\n   *\n   * Routed components are handled automatically, so this is only needed for a\n   * component whose template root is a classic fill-parent view that this\n   * cannot see coming - another router outlet, a `Frame`, a `Page`.\n   */\n  passthrough?: PassthroughMatcher[];\n  /**\n   * Recognise page roots automatically: routed components at creation time, and\n   * any host that turns out to hold a `Frame`, `Page` or `ActionBar`.\n   *\n   * @default true\n   */\n  autoDetectPassthrough?: boolean;\n  /**\n   * Keep the Angular root component's host element a `ProxyViewContainer`.\n   *\n   * `AppHostView` only wraps the root in its full-screen root `GridLayout` when\n   * that root *is* a `ProxyViewContainer`, so the root element has to stay a\n   * passthrough for the tree below it to have a viewport-sized ancestor to\n   * resolve `height: 100%` against.\n   *\n   * Detected rather than hardcoded: Angular creates the root component's host\n   * through `NativeScriptRenderer.selectRootElement`, so an element created\n   * while that runs is the root. See {@link patchSelectRootElement}.\n   *\n   * @default true\n   */\n  rootAsPassthrough?: boolean;\n}\n\n/**\n * Live configuration, read at element-creation time rather than captured at\n * install time so a later `installMasonKit()` call can still adjust it.\n *\n * `passthrough` is not mirrored here: matchers are compiled straight into\n * {@link passthroughNames} / {@link passthroughTests} when they arrive.\n */\nconst config = {\n  enabled: true,\n  autoDetectPassthrough: true,\n  rootAsPassthrough: true,\n};\n\n/** Lowercased string matchers, kept separate for O(1) lookup. */\nconst passthroughNames = new Set<string>(DEFAULT_PASSTHROUGH_ELEMENTS);\n/** Regex and predicate matchers. */\nconst passthroughTests: Array<RegExp | ((name: string) => boolean)> = [];\n\nlet installed = false;\n\n/**\n * Set while `PageRouterOutlet` is building a routed component, so the host\n * element it creates can be recognised as a page root at creation time.\n * See {@link patchPageRouterOutlet}.\n */\nlet creatingPageRoot = false;\n\n/**\n * Set while `NativeScriptRenderer.selectRootElement` is creating the Angular\n * root component's host element. See {@link patchSelectRootElement}.\n */\nlet creatingAppRoot = false;\n\n/**\n * The real native container behind every component host element.\n *\n * MasonKit's `View` is a `CustomLayoutView` backed by the Taffy layout engine;\n * it embeds in classic NativeScript layouts and hosts both MasonKit and classic\n * NativeScript children. Making a component's host element one of these gives\n * it the same mental model as the web: the host is a real box in the layout,\n * with the full style surface, and `flex`/`grid` on a component element does\n * what it says.\n */\nclass MasonComponentHost extends View {\n  /** The element name from the template, kept for diagnostics and auto-detect. */\n  masonHostElementName?: string;\n\n  addChild(child: unknown): void {\n    inspectChild(this, child);\n    super.addChild(child);\n  }\n\n  insertChild(child: unknown, atIndex: number): void {\n    inspectChild(this, child);\n    super.insertChild(child, atIndex);\n  }\n}\n\n/**\n * True when `child` cannot lay out under a Taffy box at all, so its host has to\n * become transparent.\n *\n * `Frame` and `Page` fill their parent by classic measurement, and Taffy\n * content-sizes a foreign (non-MasonKit) child, so under a MasonKit host they\n * collapse to ~0 and nothing below them renders. No styling an app can apply\n * works around that, which is what makes forcing a passthrough right.\n */\nfunction needsTransparentParent(child: unknown): boolean {\n  if (child instanceof Frame || child instanceof Page) {\n    return true;\n  }\n  // A proxy hoists its own children, so look through it for the view it is\n  // standing in for.\n  if (child instanceof ProxyViewContainer) {\n    const count = child.getChildrenCount();\n    for (let i = 0; i < count; i++) {\n      if (needsTransparentParent(child.getChildAt(i))) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction inspectChild(host: MasonComponentHost, child: unknown): void {\n  if (!config.autoDetectPassthrough || !host.masonHostElementName) {\n    return;\n  }\n  if (!(child instanceof NSView)) {\n    return;\n  }\n  // An ActionBar means this component is a page root: its siblings are\n  // page-level content that fills the `Page` by classic measurement, and a\n  // Taffy box between the two content-sizes them away.\n  //\n  // This is the backstop for the outlet hook in `patchPageRouterOutlet()`. If\n  // that hook stops firing - a different routing path, an upstream refactor -\n  // this still catches the case, one render late.\n  if (needsTransparentParent(child) || child instanceof ActionBar) {\n    learnPassthroughElement(host.masonHostElementName);\n  }\n}\n\n/**\n * Record an element name as a passthrough after the fact, and say so.\n *\n * The host that triggered detection already exists and cannot change class:\n * Angular's `ViewUtil` holds it in a sibling linked list, so swapping it\n * mid-render would corrupt that list. Every *later* creation of the element\n * becomes a proxy, so the second render onwards is correct - and the log names\n * the selector to put in `passthrough` to fix the first render too.\n */\nfunction learnPassthroughElement(elementName: string): void {\n  const name = elementName.toLowerCase();\n  if (passthroughNames.has(name)) {\n    return;\n  }\n  passthroughNames.add(name);\n  console.log(`[masonkit/angular] <${elementName}> holds a page-level view (Frame, Page or ActionBar) that Taffy cannot size as a Mason box. ` + `It will be created as a transparent ProxyViewContainer from now on. Add '${elementName}' to the ` + `passthrough option to apply this from the first render too.`);\n}\n\nfunction isPassthrough(elementName: string): boolean {\n  if (passthroughNames.has(elementName.toLowerCase())) {\n    return true;\n  }\n  for (const test of passthroughTests) {\n    if (test instanceof RegExp ? test.test(elementName) : test(elementName)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Recognise routed components at creation time, so the very first render of a\n * route is correct rather than being repaired afterwards.\n *\n * A routed component is a page root: `PageRouterOutlet` creates it, then moves\n * its host element to be the `Page`'s content. Page-level content (a\n * fill-parent `ScrollView` or layout) sizes itself against the `Page` by\n * classic measurement, so a Taffy box in between content-sizes it to nothing -\n * the ActionBar still renders because it is hoisted onto the `Page`, and\n * everything below it disappears.\n *\n * Detection alone cannot fix that, because by the time a host reports an\n * ActionBar child the host exists and cannot change class. `activateOnGoForward`\n * closes the gap: it builds the routed component inside its own call, so the\n * first unregistered element created while it runs *is* the route's host\n * element. Bracketing it gives `createView` the one piece of information it was\n * missing, with no per-app configuration.\n *\n * Nothing is lost by making these transparent: a page root is a full-screen\n * container, not a box anyone styles. Components *below* it stay real MasonKit\n * hosts, which is where component-host mode earns its keep.\n */\nfunction patchPageRouterOutlet(): void {\n  // `activateOnGoForward` is private on the class, so reach it through an\n  // untyped view of the prototype.\n  const proto = PageRouterOutlet?.prototype as unknown as undefined | Record<string, unknown>;\n  const original = proto?.['activateOnGoForward'];\n  if (!proto || typeof original !== 'function') {\n    // Different version, different internals. The ActionBar backstop in\n    // `inspectChild` still covers it from the second render on.\n    return;\n  }\n\n  proto['activateOnGoForward'] = function (this: unknown, ...args: unknown[]) {\n    creatingPageRoot = true;\n    try {\n      return original.apply(this, args);\n    } finally {\n      creatingPageRoot = false;\n    }\n  };\n}\n\n/**\n * Recognise the Angular root component's host element at creation time.\n *\n * Angular bootstraps the root component through\n * `renderer.selectRootElement(selector)`, and the NativeScript renderer creates\n * the host element from that selector with `viewUtil.createView`. Bracketing the\n * call marks exactly that element as the root, however many times the app\n * bootstraps in one JS process.\n *\n * This used to be a \"first unregistered element ever created\" counter, which is\n * only right for the first bootstrap. When Android recreates the Activity while\n * the process lives on (tapping the launcher icon after an `ns run` deploy,\n * rotation, a dark-mode switch), `@nativescript/angular` bootstraps the app\n * again and the counter is already past zero, so the root became a real\n * MasonKit box. `AppHostView` then skips its full-screen root `GridLayout`, and\n * Taffy content-sizes the classic view under it to the ActionBar height - the\n * page renders as an empty screen below the toolbar.\n */\nfunction patchSelectRootElement(rendererProto: { selectRootElement?: unknown }): void {\n  const original = rendererProto.selectRootElement;\n  if (typeof original !== 'function') {\n    return;\n  }\n  rendererProto.selectRootElement = function (this: unknown, ...args: unknown[]) {\n    creatingAppRoot = true;\n    try {\n      return original.apply(this, args);\n    } finally {\n      creatingAppRoot = false;\n    }\n  };\n}\n\nfunction applyOptions(options: ComponentHostOptions): void {\n  if (options.enabled !== undefined) {\n    config.enabled = options.enabled;\n  }\n  if (options.autoDetectPassthrough !== undefined) {\n    config.autoDetectPassthrough = options.autoDetectPassthrough;\n  }\n  if (options.rootAsPassthrough !== undefined) {\n    config.rootAsPassthrough = options.rootAsPassthrough;\n  }\n  for (const matcher of options.passthrough ?? []) {\n    if (typeof matcher === 'string') {\n      passthroughNames.add(matcher.toLowerCase());\n    } else {\n      passthroughTests.push(matcher);\n    }\n  }\n}\n\n/**\n * Turn every Angular component host element into a real MasonKit view.\n *\n * Stock `@nativescript/angular` creates a `ProxyViewContainer` for every element\n * that is not `registerElement`'d - i.e. every Angular component selector. That\n * container creates no native view, so anything placed on a component element\n * (`backgroundColor`, `margin`, `class=\"...\"`, host bindings) is set on an\n * invisible logical wrapper with no visual effect, and the component is\n * transparent to layout. Nesting components then produces layouts that do not\n * match the template, because the boxes the template implies do not exist.\n *\n * This replaces that fallback with a {@link MasonComponentHost}, so a component\n * host element is a real box, as on the web.\n *\n * Idempotent: repeated calls only update the configuration.\n *\n * Trade-off: an unknown element name (a typo, a component that was never\n * declared) becomes a host instead of throwing \"No known component for element\n * X\". Set `enabled: false` to keep the stock behaviour.\n */\nexport function enableMasonComponentHosts(options: ComponentHostOptions = {}): void {\n  applyOptions(options);\n\n  if (installed) {\n    return;\n  }\n  installed = true;\n\n  registerElement(COMPONENT_HOST_TAG, () => MasonComponentHost, masonMeta);\n\n  patchPageRouterOutlet();\n\n  // Patch point 1 of 2: `ViewUtil.createView` substitutes 'ProxyViewContainer'\n  // for unregistered elements. `ɵViewUtil` is a frozen namespace, but the\n  // `ViewUtil` prototype itself is mutable.\n  const { ViewUtil } = ɵViewUtil;\n  const originalCreateView = ViewUtil.prototype.createView;\n  ViewUtil.prototype.createView = function (name: string) {\n    const unregistered = !isKnownView(name);\n\n    // The element `selectRootElement` creates is the Angular root component's\n    // host. Consume the flag so only that element claims it.\n    let isAppRoot = false;\n    if (unregistered && creatingAppRoot) {\n      creatingAppRoot = false;\n      isAppRoot = true;\n    }\n\n    // The first unregistered element created while `PageRouterOutlet` is\n    // building a routed component is that route's host element. Consume the\n    // flag so only that element claims it, and remember the name so later\n    // creations of the same component match without needing the bracket.\n    let isPageRoot = false;\n    if (unregistered && creatingPageRoot) {\n      creatingPageRoot = false;\n      isPageRoot = true;\n      passthroughNames.add(name.toLowerCase());\n    }\n\n    if (!config.enabled || !unregistered || isPageRoot || isPassthrough(name) || (config.rootAsPassthrough && isAppRoot)) {\n      // Known element, or one we deliberately keep as a transparent\n      // ProxyViewContainer. `originalCreateView` substitutes the proxy for\n      // unregistered names but does not record the original tag (the renderer\n      // normally does that), so stamp it here to keep CSS type selectors and\n      // debugging output working on this path too.\n      const view = originalCreateView.call(this, name);\n      if (unregistered) {\n        view.customCSSName = name;\n      }\n      return view;\n    }\n\n    const host = originalCreateView.call(this, COMPONENT_HOST_TAG) as MasonComponentHost & { nodeName: string; tagName: string; cssType: string; customCSSName: string };\n    // Preserve the original tag for CSS type selectors, for debugging, and for\n    // Angular's `rootElement.tagName.toLowerCase()` bootstrap check.\n    host.nodeName = name;\n    host.tagName = name;\n    host.cssType = name;\n    host.customCSSName = name;\n    host.masonHostElementName = name;\n    return host;\n  };\n\n  // Patch point 2 of 2: `NativeScriptRenderer.createElement` performs the same\n  // 'ProxyViewContainer' substitution *before* delegating to `createView`, so\n  // the patch above would never see the original tag. Route it through the\n  // patched `createView` with the tag intact. The renderer class is not\n  // exported, but `EmulatedRenderer` extends it and delegates via\n  // `super.createElement()`, so patching the shared base prototype covers both.\n  const rendererProto = Object.getPrototypeOf(EmulatedRenderer.prototype) as {\n    createElement(this: { viewUtil: InstanceType<typeof ViewUtil> }, name: string, namespace?: string): unknown;\n    selectRootElement?: unknown;\n  };\n  patchSelectRootElement(rendererProto);\n\n  const originalCreateElement = rendererProto.createElement;\n  rendererProto.createElement = function (name: string, namespace?: string) {\n    if (isKnownView(name)) {\n      // Nothing to intercept - keep the stock path, including its tracing.\n      return originalCreateElement.call(this, name, namespace);\n    }\n    // Unregistered: hand the *original* tag to the patched `createView`, which\n    // decides between a host and a proxy and stamps `customCSSName` either way.\n    return this.viewUtil.createView(name);\n  };\n}\n","import { registerElement } from '@nativescript/angular';\nimport { getMasonKitElements, type GetMasonKitElementsOptions } from '@triniwiz/nativescript-masonkit/elements';\n\nimport { masonMeta } from './mason-meta';\n\nexport type RegisterElementsOptions = GetMasonKitElementsOptions;\n\n/**\n * Element names this package has already registered, so a second call (module\n * re-import, HMR) is a no-op rather than a duplicate registration.\n */\nconst registered = new Set<string>();\n\n/**\n * Register MasonKit's elements with `@nativescript/angular`, each with the child\n * bookkeeping meta it needs (see {@link masonMeta}) when it manages children\n * through MasonKit's own child list.\n *\n * The tag list itself — including the \"`/web`'s more specific element wins\"\n * de-duplication between `/web` and MasonKit's own widgets — comes from the\n * shared {@link getMasonKitElements}, so it can never drift from what other\n * framework integrations register.\n *\n * Safe to call more than once - later calls skip names already registered here.\n *\n * ## Shadowing\n *\n * `registerElement` overwrites silently, and `@nativescript/angular` registers\n * every element under its original, lowercase and kebab spellings. MasonKit's\n * `Button`, `Img` and `/web`'s `Span` therefore *replace* core's `Button`,\n * `img` (`Image`) and `Span` for Angular templates. That is the intent - these\n * are the MasonKit-laid-out equivalents - but it is why `mason`/`web` can each\n * be turned off if an app wants to keep the classic widgets.\n */\nexport function registerMasonKitElements(options: RegisterElementsOptions = {}): void {\n  for (const { tag, ctor, isContainer } of getMasonKitElements(options)) {\n    // Compared lowercase: `getMasonKitElements` already de-dupes case-\n    // insensitively across `/web` vs MasonKit's own widgets; this `registered`\n    // set only guards against a second *call* to this function re-registering\n    // the same tag.\n    const key = tag.toLowerCase();\n    if (registered.has(key)) {\n      continue;\n    }\n    registered.add(key);\n    // Pass the original casing through: `registerElement` also derives the\n    // lowercase and kebab-case spellings from it, so registering `'TextArea'`\n    // (not `'textarea'`) is what makes `<View>`, `<view>` AND `<text-area>`\n    // all resolve.\n    registerElement(tag, () => ctor, isContainer ? masonMeta : undefined);\n  }\n}\n","import { ComponentHostOptions, enableMasonComponentHosts } from './component-host';\nimport { RegisterElementsOptions, registerMasonKitElements } from './element-registry';\n\nexport interface InstallMasonKitOptions extends RegisterElementsOptions {\n  /**\n   * Component-host mode: make every Angular component host element a real\n   * MasonKit view instead of an invisible `ProxyViewContainer`.\n   *\n   * On by default - installing this is taken as the statement that MasonKit is\n   * how the app lays out. Pass `false`, or an options object with\n   * `enabled: false`, to opt out and keep stock `@nativescript/angular`\n   * behaviour while still getting the element registrations.\n   *\n   * @default true\n   */\n  componentHosts?: boolean | ComponentHostOptions;\n}\n\n/**\n * Install MasonKit's Angular integration.\n *\n * Call this in `main.ts` **before** `runNativeScriptAngularApp()`:\n *\n * ```ts\n * import { installMasonKit } from '@triniwiz/nativescript-masonkit/angular';\n *\n * installMasonKit();\n *\n * runNativeScriptAngularApp({\n *   appModuleBootstrap: () => platformNativeScript().bootstrapModule(AppModule),\n * });\n * ```\n *\n * It has to run before the bootstrap, not as part of it: the element map and\n * the renderer patch must be in place before Angular creates the root\n * component's host element, and an `NgModule` import or an `APP_INITIALIZER`\n * would both be too late for some of that. A plain function call at the top of\n * the entry file is unambiguous about when it happens.\n *\n * Idempotent - element registration is deduplicated and the component-host\n * patches are installed once, then only reconfigured.\n */\nexport function installMasonKit(options: InstallMasonKitOptions = {}): void {\n  registerMasonKitElements(options);\n\n  const { componentHosts = true } = options;\n  if (componentHosts === false) {\n    enableMasonComponentHosts({ enabled: false });\n  } else {\n    enableMasonComponentHosts(componentHosts === true ? {} : componentHosts);\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":["NSView","ɵViewUtil"],"mappings":"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"}

package/common.js

@@ -14,6 +14,8 @@ import { isMasonView_, isTextChild_, isText_, isPlaceholder_, text_, native_, te
 import { Tree } from './tree';
 import { TextNode } from './text-node';
 import { compile } from './pseudo';
+import { frameworkRegistry } from './framework-registry';
+import { reconcileTextRuns } from './text-runs';
 function getViewStyle(view) {
     const ret = (__ANDROID__ ? view.get() : view.deref());
     return ret._styleHelper;
@@ -84,55 +86,6 @@ function parseBoxShadow(s) {
     }
     return { ox, oy, blur, argb };
 }
-const _frameworkAccessorCache = new WeakMap();
-function getFrameworkElement(view) {
-    const cached = _frameworkAccessorCache.get(view);
-    if (cached === false)
-        return null;
-    if (cached)
-        return cached(view);
-    // First call: detect framework and cache the accessor
-    const symbols = Object.getOwnPropertySymbols(view);
-    // Vue 3 (nativescript-vue): stores ELEMENT_REF symbol on native view
-    for (const sym of symbols) {
-        if (sym.description === 'elementRef' || sym.description === '') {
-            const el = view[sym];
-            if (el && Array.isArray(el.childNodes)) {
-                _frameworkAccessorCache.set(view, (v) => v[sym]);
-                return el;
-            }
-        }
-    }
-    // React (react-nativescript): stores __reactFiber$ symbol on node
-    for (const sym of symbols) {
-        if (sym.description?.startsWith('__reactFiber$')) {
-            if (Array.isArray(view.childNodes)) {
-                _frameworkAccessorCache.set(view, (v) => v);
-                return view;
-            }
-        }
-    }
-    // Svelte (svelte-native): stores __SvelteNativeElement__ on native view
-    if (view.__SvelteNativeElement__) {
-        const el = view.__SvelteNativeElement__;
-        if (Array.isArray(el.childNodes)) {
-            _frameworkAccessorCache.set(view, (v) => v.__SvelteNativeElement__);
-            return el;
-        }
-    }
-    // SolidJS (dominative): the element IS the native view, extended with DOM methods
-    if (view.__dominative_isNative) {
-        _frameworkAccessorCache.set(view, (v) => v);
-        return view;
-    }
-    // Angular (@nativescript/angular): uses firstChild/nextSibling linked list
-    if (view.firstChild !== undefined && view.meta?.skipAddToDom !== undefined) {
-        _frameworkAccessorCache.set(view, (v) => v);
-        return view;
-    }
-    _frameworkAccessorCache.set(view, false);
-    return null;
-}
 function getWeakRefValue(value) {
     if (!value)
         return null;
@@ -149,7 +102,7 @@ function nativeOwnerFor(nativeView) {
     const owner = getWeakRefValue(nativeView.__masonOwner);
     if (owner)
         return owner;
-    return getFrameworkElement(nativeView);
+    return frameworkRegistry.getElement(nativeView);
 }
 function nativeViewFor(owner) {
     return owner?.nativeViewProtected ?? owner?.[native_];
@@ -1063,10 +1016,15 @@ export class ViewBase extends CustomLayoutView {
                 this._nativeReplaceChild(textNode, operation.index);
                 this._setOrPushChild(operation.index, entry);
                 break;
-            case 'insert':
-                this._nativeAddChild(textNode, operation.index);
-                this._spliceOrPushChild(operation.index, entry);
+            case 'insert': {
+                // `operation.index` is a `_children` slot; the native child list can
+                // lag behind it (elements attach lazily on `loaded`), so map it the
+                // same way `insertChild` does or the run lands past the end.
+                const index = Math.max(0, Math.min(operation.index ?? this._children.length, this._children.length));
+                this._nativeAddChild(textNode, this._nativeIndexFor(index));
+                this._spliceOrPushChild(index, entry);
                 break;
+            }
         }
         this._syncTextRunLayout();
     }
@@ -1084,22 +1042,18 @@ export class ViewBase extends CustomLayoutView {
             // empty
         }
     }
-    // -- Text setter with per-view framework detection --
+    // -- Text setter: framework adapter driven --
     [textProperty.setNative](value) {
-        const frameworkEl = getFrameworkElement(this);
-        if (frameworkEl) {
-            // Frameworks with childNodes array (Vue, React, Svelte, SolidJS)
-            if (Array.isArray(frameworkEl.childNodes)) {
-                const rawChildNodes = frameworkEl.childNodes;
-                if (rawChildNodes.length === 0) {
-                    // No framework-tracked DOM child backs this text (e.g. a Label-like
-                    // element with plain `.text` set directly). Without a stable node to
-                    // key the reuse cache on, every write fell through to the "always
-                    // new" `replaceChild` string branch, orphaning a native TextNode
-                    // each call. Cache a synthetic node on `this` instead, so repeat
-                    // writes route through the same update-in-place path a real DOM
-                    // text node gets (and never touch `replaceChild`, which a host
-                    // framework's DOM shim may itself shadow).
+        const adapter = frameworkRegistry.find(this);
+        if (adapter) {
+            const frameworkEl = frameworkRegistry.getElement(this);
+            const nodes = frameworkEl ? adapter.getChildren(frameworkEl) : [];
+            if (nodes.length === 0) {
+                // DOM-shim frameworks with no framework-tracked child (e.g. a Label-like
+                // element with plain `.text` set directly) need a stable synthetic node
+                // to key the reuse cache on. Without it every write falls through to the
+                // "always new" replace path and orphans native TextNodes.
+                if (adapter.syntheticTextOnEmpty) {
                     let node = this[emptyTextNode_];
                     if (!node) {
                         node = {};
@@ -1107,72 +1061,10 @@ export class ViewBase extends CustomLayoutView {
                     }
                     node.text = value;
                     this._updateTextNode(node, { type: this._children.length === 0 ? 'add' : 'replace', index: 0, isBreak: false });
-                    return;
-                }
-                // Deduplicate nodes (some frameworks expose the same nodes via both
-                // `childNodes` array and linked `nextSibling` references). Preserve
-                // original order while skipping duplicate references.
-                const nodes = [];
-                const seen = new Set();
-                for (let n of rawChildNodes) {
-                    if (!seen.has(n)) {
-                        seen.add(n);
-                        nodes.push(n);
-                    }
-                }
-                for (let i = 0; i < nodes.length; i++) {
-                    const node = nodes[i];
-                    const isTextNode = node.nodeType === 'text' || node.nodeType === 3;
-                    if (isTextNode) {
-                        let type = i === 0 && nodes.length === 1 && !this._children.length ? 'add' : 'replace';
-                        if (type === 'replace') {
-                            const toReplace = this._children[i];
-                            // Replace in place only if this slot already holds THIS framework
-                            // node (its native node back-references it via '__raw__'); otherwise
-                            // a different node lives here, so shift via insert instead of
-                            // overwriting it.
-                            if (!toReplace || toReplace[textNode_]?.['__raw__'] !== node) {
-                                type = 'insert';
-                            }
-                        }
-                        this._updateTextNode(node, { type, index: i, isBreak: node.nodeName === 'br' });
-                    }
                 }
                 return;
             }
-            // Frameworks with linked-list traversal (Angular)
-            if ('firstChild' in frameworkEl) {
-                const nodes = [];
-                let child = frameworkEl.firstChild;
-                while (child) {
-                    nodes.push(child);
-                    child = child.nextSibling;
-                }
-                for (let i = 0; i < nodes.length; i++) {
-                    const node = nodes[i];
-                    const isTextNode = node.nodeType === 'text' || node.nodeType === 3 || node.nodeName === 'TextNode' || node.constructor?.name === 'TextNode';
-                    if (isTextNode || node.nodeName === 'br') {
-                        this._updateTextNode(node, { type: 'replace', index: i, isBreak: node.nodeName === 'br' });
-                    }
-                }
-                return;
-            }
-        }
-        // NativeScript Core: linked-list traversal on the view itself
-        if ('firstChild' in this) {
-            const nodes = [];
-            let child = this.firstChild;
-            while (child) {
-                nodes.push(child);
-                child = child.nextSibling;
-            }
-            for (let i = 0; i < nodes.length; i++) {
-                const node = nodes[i];
-                const isTextNode = node.nodeType === 'text' || node.nodeName === 'TextNode' || node.constructor?.name === 'TextNode';
-                if (isTextNode || node.nodeName === 'br') {
-                    this._updateTextNode(node, { type: 'replace', index: i, isBreak: node.nodeName === 'br' });
-                }
-            }
+            reconcileTextRuns(this, nodes, (n) => adapter.classify(n));
             return;
         }
         // Fallback: direct textContent