@blotch/angular-lynx 22.2.10 → 22.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotch/angular-lynx",
-  "version": "22.2.10",
+  "version": "22.2.11",
   "description": "Angular renderer for the Lynx cross-platform native UI framework",
   "homepage": "https://github.com/Blotch-Smart-Frames/AngularLynx#readme",
   "bugs": {

package/types/blotch-angular-lynx.d.ts

@@ -4158,6 +4158,18 @@ declare class LayoutTracker {
    */
   observe(observer: (rect: LayoutRect) => void): () => void;
 }
+/**
+ * Gives a new scroll-view or list a `scroll` handler on iOS, so that a
+ * listener added later hears its scroll events. iOS's scroll-view
+ * (LynxUIScroller) and list (LynxUIListScroll) hand their scroll event
+ * manager the element's event set the first time they're told of one, as the
+ * UI is made, and never a later one. So a scroll handler added after that is
+ * never called, even after a flush: an IntersectionObserver with options adds
+ * one once it has measured its element, which is laid out by then. The
+ * handler does nothing; the listeners added later share it (see
+ * #syncNativeHandler), and Android, which reads the set afresh, needs none.
+ */
+declare const listenForScrollsFromTheStart: (element: LynxElement) => void;
 declare class LynxElement implements BaseLynxElement {
   #private;
   get element(): ElementRef;
@@ -4187,11 +4199,34 @@ declare class LynxElement implements BaseLynxElement {
   constructor(element: ElementRef);
   /**
    * Drops this wrapper's current native id from the registry. Called when the
-   * native ref is swapped (recreate-on-remount) for the STALE id, and by the
-   * renderer's destroyNode when Angular tears the element down, so the registry
-   * doesn't retain wrappers for dead native refs.
+   * native ref is swapped (recreate-on-remount) for the STALE id, and when the
+   * element is released after Angular destroyed it (see #release), so the
+   * registry doesn't retain wrappers for dead native refs.
    */
   deregisterNative(): void;
+  /**
+   * @internal Angular destroyed this element: the renderer's destroyNode.
+   *
+   * Angular calls destroyNode only for a destroyed view's top-level nodes.
+   * `destroyLView` walks them with `applyView`, which never descends into an
+   * element's children, and the views nested in it (embedded views, child
+   * components' views) are cleaned up by `destroyViewTree` without the
+   * renderer. So this element releases its whole subtree (see #release),
+   * whatever views the elements under it belong to.
+   *
+   * It waits for the commit at the end of the cycle (see
+   * #commitPendingReleases), when the cycle's moves are done: an element
+   * moved out of the subtree in the meantime, as CDK's DomPortal hands its
+   * element back when it's destroyed, isn't under this one any more and
+   * stays registered. An element still in the tree then (a leave animation
+   * delays Angular's removal) is released when its removal commits.
+   */
+  markDestroyed(): void;
+  /**
+   * @internal The children this element keeps out of `#children`, which a
+   * release must reach too: a list's items (see LynxListElement). None here.
+   */
+  virtualChildren(): LynxElement[];
   /**
    * The document stand-in (see global-events), as a DOM element's is its
    * document. Angular resolves a `document:` or `body:` host listener's
@@ -4370,6 +4405,24 @@ declare class LynxElement implements BaseLynxElement {
    * The box from the element's last layout, or null before the first.
    */
   get layoutRect(): LayoutRect | null;
+  /**
+   * Leaves the element's handler for `eventName` to a main-thread directive
+   * (`[mainThreadBindscroll]` and the like), which registers its own with
+   * `__AddEvent`. Lynx keeps one handler per event name (see nativeEventKey),
+   * so registering the element's own afterwards would replace the
+   * directive's: an IntersectionObserver with options, listening for a
+   * scroll-view's scroll events, would stop the app's main-thread scroll
+   * handler. Until releaseNativeEvent, the element's listeners for the event
+   * aren't registered natively, and don't hear it, as they didn't when the
+   * directive registered after them. Counted, as `mainThreadBindscroll` and
+   * `mainThreadCatchscroll` share one.
+   */
+  holdNativeEvent(eventName: string): void;
+  /**
+   * Hands `eventName` back once the directive has removed its handler, and
+   * registers the element's own for the listeners it has for it.
+   */
+  releaseNativeEvent(eventName: string): void;
 }
 /**
  * Commits all queued genuine element removals — a free-function wrapper over
@@ -5922,6 +5975,12 @@ declare class LynxListElement extends LynxElement {
    * for the general "never key a Set/Map on an element ref" constraint.
    */
   getUIChildren(): ElementRef[];
+  /**
+   * The items, anchors included: they live in this linked list, not in the
+   * `#children` a release walks, and a list in a destroyed view must let
+   * them go too (see LynxElement.virtualChildren).
+   */
+  virtualChildren(): LynxElement[];
   /**
    * The UI children list as of the last _processUpdate() call, pre-filtered
    * and cached — for componentAtIndex/componentAtIndexes (create-list-element.ts)