@qontinui/ui-bridge-native 0.6.11 → 0.6.12

package/dist/index.mjs

@@ -560,6 +560,103 @@ var NativeUIBridgeRegistry = class {
       console.log(`[ui-bridge-native] Marked ${cleared} elements offscreen for route: ${route}`);
     }
   }
+  /**
+   * Re-measure every mounted-visible element's geometry via its stored React
+   * ref and write the fresh coordinates into the registry ("measure-on-
+   * snapshot").
+   *
+   * Why: element geometry is otherwise captured ONCE at mount time
+   * (`onLayout` + `measureInWindow` in `useUIElement`) and RN never re-fires
+   * `onLayout` on pure translation — scrolling a virtualized list
+   * (FlashList), recycling a cell, a keyboard shift or an orientation change
+   * all move elements WITHOUT updating the stored `state.layout`. Snapshot
+   * consumers (vision analyzers hit-testing `bbox`, coord-based tap) then
+   * operate on stale positions. Re-measuring at READ time is correct
+   * regardless of what moved the element and needs zero per-consumer wiring:
+   * every registry entry already stores its ref (see `registerElement`).
+   *
+   * Per-element outcomes:
+   *   - non-zero dims → write a fresh full layout (same state shape as the
+   *     mount-time measure loop in `useUIElement`); counted as `measured`.
+   *   - zero dims AND the element previously had a non-null `state.layout` →
+   *     the view collapsed / left the screen; clear to
+   *     `{ visible: false, layout: null }` (same shape `markRouteOffscreen`
+   *     writes); counted as `cleared`.
+   *   - zero dims and it never had a layout → leave state untouched (element
+   *     in the mount→first-onLayout gap; don't demote `likely-visible`);
+   *     counted as `skipped`.
+   *   - no ref / no callable `measureInWindow` (test fixtures, web) → leave
+   *     untouched; counted as `skipped`.
+   *
+   * The whole sweep races an overall timeout (default 250 ms) so a dead ref
+   * whose `measureInWindow` never calls back can never hang a snapshot: the
+   * returned promise resolves at the deadline with whatever counts have
+   * accumulated. Late callbacks may still write state afterwards — harmless,
+   * freshest data wins. Never throws.
+   *
+   * Non-React core module on purpose — `measureInWindow` is duck-typed off
+   * the stored ref rather than imported from `react-native` (see the
+   * `projectBbox` doc comment for why this file must not import RN).
+   */
+  async refreshMeasurements(options) {
+    const timeoutMs = typeof options?.timeoutMs === "number" && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : 250;
+    const counts = { measured: 0, cleared: 0, skipped: 0 };
+    const pending = [];
+    for (const element of this.getMountedVisibleElements()) {
+      const node = element.ref?.current;
+      if (!node || typeof node.measureInWindow !== "function") {
+        counts.skipped++;
+        continue;
+      }
+      const id = element.id;
+      pending.push(
+        new Promise((resolve) => {
+          let settled = false;
+          try {
+            node.measureInWindow((pageX, pageY, w, h) => {
+              if (settled) return;
+              settled = true;
+              try {
+                if (w > 0 && h > 0) {
+                  this.updateElementState(id, {
+                    mounted: true,
+                    visible: true,
+                    enabled: true,
+                    focused: false,
+                    layout: { x: pageX, y: pageY, width: w, height: h, pageX, pageY }
+                  });
+                  counts.measured++;
+                } else if (this.elements.get(id)?.getState().layout != null) {
+                  this.updateElementState(id, { visible: false, layout: null });
+                  counts.cleared++;
+                } else {
+                  counts.skipped++;
+                }
+              } finally {
+                resolve();
+              }
+            });
+          } catch {
+            if (!settled) {
+              settled = true;
+              counts.skipped++;
+              resolve();
+            }
+          }
+        })
+      );
+    }
+    if (pending.length > 0) {
+      await new Promise((resolve) => {
+        const timer = setTimeout(resolve, timeoutMs);
+        void Promise.all(pending).then(() => {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+    return counts;
+  }
   /**
    * Update element state
    */
@@ -2594,6 +2691,7 @@ function createServerHandlers(registry, executor, config) {
   return {
     // Elements
     getElements: async (ctx) => {
+      await registry.refreshMeasurements();
       const visibleOnly = ctx.query?.visibleOnly === "true" || ctx.body?.visibleOnly === true;
       const forRoute = ctx.query?.route || ctx.body?.route;
       let allElements = visibleOnly ? registry.getMountedVisibleElements() : registry.getAllElements();
@@ -2787,6 +2885,7 @@ function createServerHandlers(registry, executor, config) {
       });
     },
     getSnapshot: async (ctx) => {
+      await registry.refreshMeasurements();
       const visibleOnly = ctx.query?.visibleOnly === "true" || ctx.body?.visibleOnly === true;
       const currentRouteOnly = ctx.query?.currentRouteOnly === "true" || ctx.body?.currentRouteOnly === true;
       const snapshot = registry.createSnapshot(void 0, { visibleOnly, currentRouteOnly });
@@ -3102,6 +3201,7 @@ function createServerHandlers(registry, executor, config) {
     // that don't measure (the fallback only matches single-rooted screens but
     // is good enough for the unit suite).
     tapAt: async (ctx) => {
+      await registry.refreshMeasurements();
       const body = ctx.body;
       const x = body?.x;
       const y = body?.y;
@@ -3309,7 +3409,7 @@ function createServerHandlers(registry, executor, config) {
       };
       if (config?.appInfo) {
         response.uiBridge = {
-          version: "0.6.11",
+          version: "0.6.12",
           ...config.appInfo,
           capabilities: ["elements", "components", "actions", "design"],
           elementCount: stats.elements,
@@ -6101,7 +6201,7 @@ function useUIElement(options) {
         unregisterRef.current();
       }
     };
-  }, [autoRegister, bridge]);
+  }, [autoRegister, bridge, id]);
   useEffect(() => {
     if (!bridge || !registered) return;
     const node = ref.current;