@triniwiz/nativescript-masonkit 1.0.0-beta.87 → 1.0.0-beta.89

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

@@ -0,0 +1,496 @@
+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, Text, Scroll, Img, Button, Input, TextArea, Br, Ul, Ol, Li } from '@triniwiz/nativescript-masonkit';
+import * as MasonKitWeb from '@triniwiz/nativescript-masonkit/web';
+
+/**
+ * Index of `child` in the parent's raw `_children` list, or -1.
+ *
+ * Deliberately *not* `parent.getChildIndex()`: that walks `_viewChildren`, which
+ * filters out text nodes and placeholders, so its indices drift from the ones
+ * `insertChild()` splices into as soon as a container mixes views and text. The
+ * only index `insertChild` accepts is a `_children` index, so that is what we
+ * compute. `getChildIndex` stays as the fallback for a container that predates
+ * `_children` or overrides the lookup.
+ */
+function rawChildIndex(parent, child) {
+    if (child == null) {
+        return -1;
+    }
+    const children = parent._children;
+    if (Array.isArray(children)) {
+        return children.indexOf(child);
+    }
+    return typeof parent.getChildIndex === 'function' ? parent.getChildIndex(child) : -1;
+}
+/**
+ * `ViewClassMeta` that routes Angular's visual-tree mutations through MasonKit's
+ * own child bookkeeping.
+ *
+ * ## Why every MasonKit element needs this
+ *
+ * MasonKit's `ViewBase` extends `CustomLayoutView`, **not** `LayoutBase`.
+ * `@nativescript/angular`'s `ViewUtil` branches on `view instanceof LayoutBase`,
+ * so without a meta a MasonKit container falls into the generic fallbacks:
+ *
+ * - `addToVisualTree` → `parent._addChildFromBuilder(name, child)`, which is a
+ *   plain `addChild()` append. The resolved `next` sibling is **discarded**, so
+ *   anything Angular inserts in the middle of a container (`*ngIf` toggling on,
+ *   `*ngFor` reordering, a router swap) lands at the end and the Taffy tree ends
+ *   up in a different order than the template.
+ * - `removeFromVisualTree` → core's `parent._removeView(child)`, which bypasses
+ *   MasonKit's `removeChild()` entirely. The native view detaches but the entry
+ *   stays in `_children`, and since `_children` is what drives native insertion
+ *   indices (`_nativeIndexFor`), every later insert into that container is
+ *   misplaced - the classic "nested components lay out wrong" symptom.
+ *
+ * Routing through `insertChild`/`addChild`/`removeChild` keeps the Taffy tree,
+ * the `_children` bookkeeping and the native view tree in step. This is the same
+ * contract `frameMeta`/`formattedStringMeta` use for their containers.
+ *
+ * ## Why `insertChild` must not throw
+ *
+ * `next` is whatever `ViewUtil.findNextVisual()` resolved to, which is not
+ * guaranteed to be a node MasonKit ever tracked. MasonKit's own `insertBefore()`
+ * throws `NotFoundError` for an unknown reference; thrown from here that would
+ * abort the component's change detection and blank it. An unknown reference
+ * simply degrades to an append, exactly as `insertToLayout` does for classic
+ * layouts.
+ *
+ * Invisible nodes (Angular's `CommentNode`/`TextNode`) are intentionally left to
+ * `ViewUtil`'s default handling: it assigns `parent.text`, which MasonKit's
+ * `textProperty.setNative` already reconciles into real native text nodes.
+ */
+const masonMeta = {
+    insertChild(parent, child, next) {
+        const index = rawChildIndex(parent, next);
+        if (index > -1) {
+            parent.insertChild(child, index);
+        }
+        else {
+            parent.addChild(child);
+        }
+    },
+    removeChild(parent, child) {
+        parent.removeChild(child);
+    },
+};
+
+/**
+ * Internal element name the host container is registered under. Every component
+ * host is created from this entry and then re-stamped with its original tag, so
+ * this name never appears in a template.
+ */
+const COMPONENT_HOST_TAG = 'mason-component-host';
+/**
+ * Framework router outlets, which must stay transparent.
+ *
+ * They host a classic `Frame`/`Page` that fills its parent by classic
+ * measurement. A `ProxyViewContainer` is a logical passthrough - its child is
+ * hoisted into the nearest real native ancestor and measured with an exact,
+ * fill-parent size. A MasonKit host is instead a real Taffy box, and Taffy
+ * *content-sizes* a foreign (non-MasonKit) child, so the `Frame` collapses to
+ * ~0 and nothing from the outlet down renders.
+ *
+ * Most `@nativescript/angular` views (`ActionBar`, `ActionItem`, ...) are
+ * already `registerElement`'d, so only the outlets reach us as unregistered
+ * elements.
+ */
+const DEFAULT_PASSTHROUGH_ELEMENTS = ['page-router-outlet', 'ns-empty-outlet', 'router-outlet'];
+/**
+ * Live configuration, read at element-creation time rather than captured at
+ * install time so a later `installMasonKit()` call can still adjust it.
+ *
+ * `passthrough` is not mirrored here: matchers are compiled straight into
+ * {@link passthroughNames} / {@link passthroughTests} when they arrive.
+ */
+const config = {
+    enabled: true,
+    autoDetectPassthrough: true,
+    rootAsPassthrough: true,
+};
+/** Lowercased string matchers, kept separate for O(1) lookup. */
+const passthroughNames = new Set(DEFAULT_PASSTHROUGH_ELEMENTS);
+/** Regex and predicate matchers. */
+const passthroughTests = [];
+let installed = false;
+let elementsCreated = 0;
+/**
+ * Set while `PageRouterOutlet` is building a routed component, so the host
+ * element it creates can be recognised as a page root at creation time.
+ * See {@link patchPageRouterOutlet}.
+ */
+let creatingPageRoot = false;
+/**
+ * The real native container behind every component host element.
+ *
+ * MasonKit's `View` is a `CustomLayoutView` backed by the Taffy layout engine;
+ * it embeds in classic NativeScript layouts and hosts both MasonKit and classic
+ * NativeScript children. Making a component's host element one of these gives
+ * it the same mental model as the web: the host is a real box in the layout,
+ * with the full style surface, and `flex`/`grid` on a component element does
+ * what it says.
+ */
+class MasonComponentHost extends View {
+    /** The element name from the template, kept for diagnostics and auto-detect. */
+    masonHostElementName;
+    addChild(child) {
+        inspectChild(this, child);
+        super.addChild(child);
+    }
+    insertChild(child, atIndex) {
+        inspectChild(this, child);
+        super.insertChild(child, atIndex);
+    }
+}
+/**
+ * True when `child` cannot lay out under a Taffy box at all, so its host has to
+ * become transparent.
+ *
+ * `Frame` and `Page` fill their parent by classic measurement, and Taffy
+ * content-sizes a foreign (non-MasonKit) child, so under a MasonKit host they
+ * collapse to ~0 and nothing below them renders. No styling an app can apply
+ * works around that, which is what makes forcing a passthrough right.
+ */
+function needsTransparentParent(child) {
+    if (child instanceof Frame || child instanceof Page) {
+        return true;
+    }
+    // A proxy hoists its own children, so look through it for the view it is
+    // standing in for.
+    if (child instanceof ProxyViewContainer) {
+        const count = child.getChildrenCount();
+        for (let i = 0; i < count; i++) {
+            if (needsTransparentParent(child.getChildAt(i))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function inspectChild(host, child) {
+    if (!config.autoDetectPassthrough || !host.masonHostElementName) {
+        return;
+    }
+    if (!(child instanceof View$1)) {
+        return;
+    }
+    // An ActionBar means this component is a page root: its siblings are
+    // page-level content that fills the `Page` by classic measurement, and a
+    // Taffy box between the two content-sizes them away.
+    //
+    // This is the backstop for the outlet hook in `patchPageRouterOutlet()`. If
+    // that hook stops firing - a different routing path, an upstream refactor -
+    // this still catches the case, one render late.
+    if (needsTransparentParent(child) || child instanceof ActionBar) {
+        learnPassthroughElement(host.masonHostElementName);
+    }
+}
+/**
+ * Record an element name as a passthrough after the fact, and say so.
+ *
+ * The host that triggered detection already exists and cannot change class:
+ * Angular's `ViewUtil` holds it in a sibling linked list, so swapping it
+ * mid-render would corrupt that list. Every *later* creation of the element
+ * becomes a proxy, so the second render onwards is correct - and the log names
+ * the selector to put in `passthrough` to fix the first render too.
+ */
+function learnPassthroughElement(elementName) {
+    const name = elementName.toLowerCase();
+    if (passthroughNames.has(name)) {
+        return;
+    }
+    passthroughNames.add(name);
+    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.`);
+}
+function isPassthrough(elementName) {
+    if (passthroughNames.has(elementName.toLowerCase())) {
+        return true;
+    }
+    for (const test of passthroughTests) {
+        if (test instanceof RegExp ? test.test(elementName) : test(elementName)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Recognise routed components at creation time, so the very first render of a
+ * route is correct rather than being repaired afterwards.
+ *
+ * A routed component is a page root: `PageRouterOutlet` creates it, then moves
+ * its host element to be the `Page`'s content. Page-level content (a
+ * fill-parent `ScrollView` or layout) sizes itself against the `Page` by
+ * classic measurement, so a Taffy box in between content-sizes it to nothing -
+ * the ActionBar still renders because it is hoisted onto the `Page`, and
+ * everything below it disappears.
+ *
+ * Detection alone cannot fix that, because by the time a host reports an
+ * ActionBar child the host exists and cannot change class. `activateOnGoForward`
+ * closes the gap: it builds the routed component inside its own call, so the
+ * first unregistered element created while it runs *is* the route's host
+ * element. Bracketing it gives `createView` the one piece of information it was
+ * missing, with no per-app configuration.
+ *
+ * Nothing is lost by making these transparent: a page root is a full-screen
+ * container, not a box anyone styles. Components *below* it stay real MasonKit
+ * hosts, which is where component-host mode earns its keep.
+ */
+function patchPageRouterOutlet() {
+    // `activateOnGoForward` is private on the class, so reach it through an
+    // untyped view of the prototype.
+    const proto = PageRouterOutlet?.prototype;
+    const original = proto?.['activateOnGoForward'];
+    if (!proto || typeof original !== 'function') {
+        // Different version, different internals. The ActionBar backstop in
+        // `inspectChild` still covers it from the second render on.
+        return;
+    }
+    proto['activateOnGoForward'] = function (...args) {
+        creatingPageRoot = true;
+        try {
+            return original.apply(this, args);
+        }
+        finally {
+            creatingPageRoot = false;
+        }
+    };
+}
+function applyOptions(options) {
+    if (options.enabled !== undefined) {
+        config.enabled = options.enabled;
+    }
+    if (options.autoDetectPassthrough !== undefined) {
+        config.autoDetectPassthrough = options.autoDetectPassthrough;
+    }
+    if (options.rootAsPassthrough !== undefined) {
+        config.rootAsPassthrough = options.rootAsPassthrough;
+    }
+    for (const matcher of options.passthrough ?? []) {
+        if (typeof matcher === 'string') {
+            passthroughNames.add(matcher.toLowerCase());
+        }
+        else {
+            passthroughTests.push(matcher);
+        }
+    }
+}
+/**
+ * Turn every Angular component host element into a real MasonKit view.
+ *
+ * Stock `@nativescript/angular` creates a `ProxyViewContainer` for every element
+ * that is not `registerElement`'d - i.e. every Angular component selector. That
+ * container creates no native view, so anything placed on a component element
+ * (`backgroundColor`, `margin`, `class="..."`, host bindings) is set on an
+ * invisible logical wrapper with no visual effect, and the component is
+ * transparent to layout. Nesting components then produces layouts that do not
+ * match the template, because the boxes the template implies do not exist.
+ *
+ * This replaces that fallback with a {@link MasonComponentHost}, so a component
+ * host element is a real box, as on the web.
+ *
+ * Idempotent: repeated calls only update the configuration.
+ *
+ * Trade-off: an unknown element name (a typo, a component that was never
+ * declared) becomes a host instead of throwing "No known component for element
+ * X". Set `enabled: false` to keep the stock behaviour.
+ */
+function enableMasonComponentHosts(options = {}) {
+    applyOptions(options);
+    if (installed) {
+        return;
+    }
+    installed = true;
+    registerElement(COMPONENT_HOST_TAG, () => MasonComponentHost, masonMeta);
+    patchPageRouterOutlet();
+    // Patch point 1 of 2: `ViewUtil.createView` substitutes 'ProxyViewContainer'
+    // for unregistered elements. `ɵViewUtil` is a frozen namespace, but the
+    // `ViewUtil` prototype itself is mutable.
+    const { ViewUtil } = _ViewUtil;
+    const originalCreateView = ViewUtil.prototype.createView;
+    ViewUtil.prototype.createView = function (name) {
+        const isFirstElement = elementsCreated === 0;
+        const unregistered = !isKnownView(name);
+        if (unregistered) {
+            elementsCreated++;
+        }
+        // The first unregistered element created while `PageRouterOutlet` is
+        // building a routed component is that route's host element. Consume the
+        // flag so only that element claims it, and remember the name so later
+        // creations of the same component match without needing the bracket.
+        let isPageRoot = false;
+        if (unregistered && creatingPageRoot) {
+            creatingPageRoot = false;
+            isPageRoot = true;
+            passthroughNames.add(name.toLowerCase());
+        }
+        if (!config.enabled || !unregistered || isPageRoot || isPassthrough(name) || (config.rootAsPassthrough && isFirstElement)) {
+            // Known element, or one we deliberately keep as a transparent
+            // ProxyViewContainer. `originalCreateView` substitutes the proxy for
+            // unregistered names but does not record the original tag (the renderer
+            // normally does that), so stamp it here to keep CSS type selectors and
+            // debugging output working on this path too.
+            const view = originalCreateView.call(this, name);
+            if (unregistered) {
+                view.customCSSName = name;
+            }
+            return view;
+        }
+        const host = originalCreateView.call(this, COMPONENT_HOST_TAG);
+        // Preserve the original tag for CSS type selectors, for debugging, and for
+        // Angular's `rootElement.tagName.toLowerCase()` bootstrap check.
+        host.nodeName = name;
+        host.tagName = name;
+        host.cssType = name;
+        host.customCSSName = name;
+        host.masonHostElementName = name;
+        return host;
+    };
+    // Patch point 2 of 2: `NativeScriptRenderer.createElement` performs the same
+    // 'ProxyViewContainer' substitution *before* delegating to `createView`, so
+    // the patch above would never see the original tag. Route it through the
+    // patched `createView` with the tag intact. The renderer class is not
+    // exported, but `EmulatedRenderer` extends it and delegates via
+    // `super.createElement()`, so patching the shared base prototype covers both.
+    const rendererProto = Object.getPrototypeOf(EmulatedRenderer.prototype);
+    const originalCreateElement = rendererProto.createElement;
+    rendererProto.createElement = function (name, namespace) {
+        if (isKnownView(name)) {
+            // Nothing to intercept - keep the stock path, including its tracing.
+            return originalCreateElement.call(this, name, namespace);
+        }
+        // Unregistered: hand the *original* tag to the patched `createView`, which
+        // decides between a host and a proxy and stamps `customCSSName` either way.
+        return this.viewUtil.createView(name);
+    };
+}
+
+/**
+ * Element names this package has already registered, so a second call (module
+ * re-import, HMR) is a no-op rather than a duplicate registration.
+ */
+const registered = new Set();
+/**
+ * True when the class manages children through MasonKit's own child list, i.e.
+ * when {@link masonMeta} is the right contract for it.
+ *
+ * `Br` is the notable exception: it is a placeholder that extends core's
+ * `ViewBase` and attaches straight to the Mason tree, so it has no child API and
+ * must keep the default meta.
+ */
+function isMasonContainer(cls) {
+    const proto = cls?.prototype;
+    return !!proto && typeof proto.insertChild === 'function' && typeof proto.addChild === 'function' && typeof proto.removeChild === 'function';
+}
+function register(name, cls) {
+    // Compared lowercase: `registerElement` stores every spelling of a name, so
+    // registering `Ul` after `/web` already claimed `ul` would silently overwrite
+    // it. Case-insensitive dedupe is what makes "first registration wins" real.
+    const key = name?.toLowerCase();
+    if (!key || registered.has(key)) {
+        return;
+    }
+    registered.add(key);
+    // `registerElement` also stores the lowercase and kebab-case spellings, so a
+    // single call covers `<View>`, `<view>` and `<text-area>`.
+    registerElement(name, () => cls, isMasonContainer(cls) ? masonMeta : undefined);
+}
+/**
+ * MasonKit's own elements, in the spelling the templates use.
+ *
+ * Registered *after* the `/web` elements on purpose: `/web` also exports `Ul`,
+ * `Ol` and `Li`, and where the two overlap the rule is "the more specific one
+ * wins" - `/web`'s `Li` is an inline `Text` subclass, so `<li>` stays inline,
+ * while `<view>`, `<img>`, `<button>`, `<input>` and `<br>` resolve to the base
+ * package's fully-featured widgets.
+ */
+const MASON_ELEMENTS = [
+    ['View', View],
+    ['Text', Text],
+    ['Scroll', Scroll],
+    ['Img', Img],
+    ['Button', Button],
+    ['Input', Input],
+    ['TextArea', TextArea],
+    ['Br', Br],
+    ['Ul', Ul],
+    ['Ol', Ol],
+    ['Li', Li],
+];
+/**
+ * Register MasonKit's elements with `@nativescript/angular`, each with the child
+ * bookkeeping meta it needs (see {@link masonMeta}).
+ *
+ * Safe to call more than once - later calls skip names already registered here.
+ *
+ * ## Shadowing
+ *
+ * `registerElement` overwrites silently, and `@nativescript/angular` registers
+ * every element under its original, lowercase and kebab spellings. MasonKit's
+ * `Button`, `Img` and `/web`'s `Span` therefore *replace* core's `Button`,
+ * `img` (`Image`) and `Span` for Angular templates. That is the intent - these
+ * are the MasonKit-laid-out equivalents - but it is why `mason`/`web` can each
+ * be turned off if an app wants to keep the classic widgets.
+ */
+function registerMasonKitElements(options = {}) {
+    const { mason = true, web = true } = options;
+    if (web) {
+        for (const exported of Object.values(MasonKitWeb)) {
+            if (typeof exported !== 'function' || !exported.prototype) {
+                continue;
+            }
+            // Every `/web` class carries its tag via `@CSSType('div')`, which the
+            // decorator stamps onto the prototype. Reading it there - rather than
+            // `constructor.name` - survives the demo's `uglify: true` release build,
+            // where class names are mangled to single letters.
+            register(exported.prototype.cssType, exported);
+        }
+    }
+    if (mason) {
+        for (const [name, cls] of MASON_ELEMENTS) {
+            register(name, cls);
+        }
+    }
+}
+
+/**
+ * Install MasonKit's Angular integration.
+ *
+ * Call this in `main.ts` **before** `runNativeScriptAngularApp()`:
+ *
+ * ```ts
+ * import { installMasonKit } from '@triniwiz/nativescript-masonkit/angular';
+ *
+ * installMasonKit();
+ *
+ * runNativeScriptAngularApp({
+ *   appModuleBootstrap: () => platformNativeScript().bootstrapModule(AppModule),
+ * });
+ * ```
+ *
+ * It has to run before the bootstrap, not as part of it: the element map and
+ * the renderer patch must be in place before Angular creates the root
+ * component's host element, and an `NgModule` import or an `APP_INITIALIZER`
+ * would both be too late for some of that. A plain function call at the top of
+ * the entry file is unambiguous about when it happens.
+ *
+ * Idempotent - element registration is deduplicated and the component-host
+ * patches are installed once, then only reconfigured.
+ */
+function installMasonKit(options = {}) {
+    registerMasonKitElements(options);
+    const { componentHosts = true } = options;
+    if (componentHosts === false) {
+        enableMasonComponentHosts({ enabled: false });
+    }
+    else {
+        enableMasonComponentHosts(componentHosts === true ? {} : componentHosts);
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { enableMasonComponentHosts, installMasonKit, masonMeta, registerMasonKitElements };
+//# sourceMappingURL=triniwiz-nativescript-masonkit-angular.mjs.map

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

@@ -0,0 +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   * element before anything in its template, so the first unregistered element\n   * this package is asked to create is the root.\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;\nlet elementsCreated = 0;\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 * 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\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 isFirstElement = elementsCreated === 0;\n    const unregistered = !isKnownView(name);\n    if (unregistered) {\n      elementsCreated++;\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 && isFirstElement)) {\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  };\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 { Br, Button, Img, Input, Li, Ol, Scroll, Text, TextArea, Ul, View } from '@triniwiz/nativescript-masonkit';\nimport * as MasonKitWeb from '@triniwiz/nativescript-masonkit/web';\n\nimport { masonMeta } from './mason-meta';\n\n/** Anything constructible; the element resolvers are all `() => SomeViewClass`. */\ntype ElementClass = { new (...args: any[]): any; prototype: any };\n\nexport interface RegisterElementsOptions {\n  /**\n   * Register MasonKit's own elements: `View`, `Text`, `Scroll`, `Img`, `Button`,\n   * `Input`, `TextArea`, `Br`, `Ul`, `Ol`, `Li`.\n   *\n   * @default true\n   */\n  mason?: boolean;\n  /**\n   * Register the HTML-shaped elements from `@triniwiz/nativescript-masonkit/web`\n   * (`div`, `section`, `p`, `span`, `h1`–`h6`, `blockquote`, `code`, `a`, ...).\n   *\n   * @default true\n   */\n  web?: boolean;\n}\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 * True when the class manages children through MasonKit's own child list, i.e.\n * when {@link masonMeta} is the right contract for it.\n *\n * `Br` is the notable exception: it is a placeholder that extends core's\n * `ViewBase` and attaches straight to the Mason tree, so it has no child API and\n * must keep the default meta.\n */\nfunction isMasonContainer(cls: ElementClass): boolean {\n  const proto = cls?.prototype;\n  return !!proto && typeof proto.insertChild === 'function' && typeof proto.addChild === 'function' && typeof proto.removeChild === 'function';\n}\n\nfunction register(name: string, cls: ElementClass): void {\n  // Compared lowercase: `registerElement` stores every spelling of a name, so\n  // registering `Ul` after `/web` already claimed `ul` would silently overwrite\n  // it. Case-insensitive dedupe is what makes \"first registration wins\" real.\n  const key = name?.toLowerCase();\n  if (!key || registered.has(key)) {\n    return;\n  }\n  registered.add(key);\n  // `registerElement` also stores the lowercase and kebab-case spellings, so a\n  // single call covers `<View>`, `<view>` and `<text-area>`.\n  registerElement(name, () => cls, isMasonContainer(cls) ? masonMeta : undefined);\n}\n\n/**\n * MasonKit's own elements, in the spelling the templates use.\n *\n * Registered *after* the `/web` elements on purpose: `/web` also exports `Ul`,\n * `Ol` and `Li`, and where the two overlap the rule is \"the more specific one\n * wins\" - `/web`'s `Li` is an inline `Text` subclass, so `<li>` stays inline,\n * while `<view>`, `<img>`, `<button>`, `<input>` and `<br>` resolve to the base\n * package's fully-featured widgets.\n */\nconst MASON_ELEMENTS: Array<[string, ElementClass]> = [\n  ['View', View],\n  ['Text', Text],\n  ['Scroll', Scroll],\n  ['Img', Img],\n  ['Button', Button],\n  ['Input', Input],\n  ['TextArea', TextArea],\n  ['Br', Br],\n  ['Ul', Ul],\n  ['Ol', Ol],\n  ['Li', Li],\n];\n\n/**\n * Register MasonKit's elements with `@nativescript/angular`, each with the child\n * bookkeeping meta it needs (see {@link masonMeta}).\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  const { mason = true, web = true } = options;\n\n  if (web) {\n    for (const exported of Object.values(MasonKitWeb) as ElementClass[]) {\n      if (typeof exported !== 'function' || !exported.prototype) {\n        continue;\n      }\n      // Every `/web` class carries its tag via `@CSSType('div')`, which the\n      // decorator stamps onto the prototype. Reading it there - rather than\n      // `constructor.name` - survives the demo's `uglify: true` release build,\n      // where class names are mangled to single letters.\n      register(exported.prototype.cssType, exported);\n    }\n  }\n\n  if (mason) {\n    for (const [name, cls] of MASON_ELEMENTS) {\n      register(name, cls);\n    }\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/angular/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@triniwiz/nativescript-masonkit-angular",
+  "sideEffects": true,
+  "module": "fesm2022/triniwiz-nativescript-masonkit-angular.mjs",
+  "typings": "types/triniwiz-nativescript-masonkit-angular.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/triniwiz-nativescript-masonkit-angular.d.ts",
+      "default": "./fesm2022/triniwiz-nativescript-masonkit-angular.mjs"
+    }
+  },
+  "type": "module",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  }
+}