@qontinui/ui-bridge-native 0.6.15 → 0.6.16

package/dist/react/index.mjs

@@ -311,6 +311,13 @@ function computeVisibility(state, clip) {
   const onScreen = spansOverlap(rect.left, rect.right, clip.left, clip.right) && spansOverlap(rect.top, rect.bottom, clip.top, clip.bottom);
   return onScreen ? { visibility: "visible" } : { visibility: "hidden", visibilityReason: "off-screen" };
 }
+function copyRouteInfo(info) {
+  const copy = { ...info };
+  if (info.params) copy.params = { ...info.params };
+  if (info.queryParams) copy.queryParams = { ...info.queryParams };
+  if (info.routeStack) copy.routeStack = [...info.routeStack];
+  return copy;
+}
 function inferActions(type, scrollAncestorId) {
   const baseActions = scrollAncestorId ? ["focus", "blur", "scrollIntoView"] : ["focus", "blur"];
   switch (type) {
@@ -375,6 +382,16 @@ var NativeUIBridgeRegistry = class {
      * already installs.
      */
     this.routeProvider = null;
+    /**
+     * The route TEMPLATE the app last reported through `useRouteAwareness`
+     * (via {@link setRouteInfo}), emitted on every snapshot as `page.route`.
+     *
+     * Deliberately NOT named `routeInfo`: `createSnapshot`'s parameter of that
+     * name is the CONCRETE `{currentRoute, segments, activeTab}` read from the
+     * route provider. The two must never be confused — the concrete path is
+     * user input, and this slot is the router-asserted template.
+     */
+    this.reportedRoute = void 0;
     /**
      * Device pixel ratio used to project `state.layout` (logical dp) into the
      * physical-pixel `bbox` emitted on each snapshot element. Defaults to `1`
@@ -433,6 +450,22 @@ var NativeUIBridgeRegistry = class {
   getRouteProvider() {
     return this.routeProvider;
   }
+  /**
+   * Set the route info emitted as `page.route` on every snapshot — the
+   * router-asserted TEMPLATE, normally reported by `useRouteAwareness`.
+   * Pass `undefined` to clear it (the hook does so on unmount), after which
+   * snapshots omit `page` again.
+   *
+   * The value is copied, so a later mutation by the caller cannot alter what
+   * is stored or what an already-emitted snapshot holds.
+   */
+  setRouteInfo(info) {
+    this.reportedRoute = info ? copyRouteInfo(info) : void 0;
+  }
+  /** Read-only accessor for the reported route info, if any (a copy). */
+  getRouteInfo() {
+    return this.reportedRoute ? copyRouteInfo(this.reportedRoute) : void 0;
+  }
   /**
    * Resolve the snapshot's `activeTab`: an explicit `getActiveTab()` on the
    * route provider wins, otherwise derive it from the Expo Router segments the
@@ -1273,6 +1306,12 @@ var NativeUIBridgeRegistry = class {
       // hosts that wire no route provider.
       ...resolvedRoute.currentRoute ? { route: resolvedRoute.currentRoute } : {},
       ...resolvedRoute.activeTab ? { activeTab: resolvedRoute.activeTab } : {},
+      // The router-asserted route TEMPLATE, spelled as the web SDK's
+      // `snapshot.page.route`. Emitted on the ONE assembly point both route
+      // branches above share (the explicit-`routeInfo` branch the server's
+      // `getSnapshot` override uses, and the provider fallback). Omitted, not
+      // nulled, when unset — the same convention as the aliases above.
+      ...this.reportedRoute ? { page: { route: copyRouteInfo(this.reportedRoute) } } : {},
       registration: this.getRegistrationCoverage()
     };
     if (this.appInfo) {
@@ -1319,6 +1358,9 @@ var NativeUIBridgeRegistry = class {
           }
         }
       }
+      if (this.reportedRoute) {
+        snapshot.page = { route: copyRouteInfo(this.reportedRoute) };
+      }
     }
     return snapshot;
   }
@@ -4311,7 +4353,7 @@ function createServerHandlers(registry, executor, config) {
       };
       if (config?.appInfo) {
         response.uiBridge = {
-          version: "0.6.15",
+          version: "0.6.16",
           ...config.appInfo,
           capabilities: ["elements", "components", "actions", "design"],
           elementCount: stats.elements,
@@ -7873,7 +7915,75 @@ function State(props) {
 function TransitionTo(props) {
   return /* @__PURE__ */ jsx(Fragment, { children: props.children });
 }
+function effectiveInfo(info, unmatched) {
+  return unmatched ? { ...info, pattern: null, params: void 0 } : info;
+}
+function useRouteAwareness(info, options = {}) {
+  const bridge = useUIBridgeNativeOptional();
+  const unmatched = options.unmatched === true;
+  const infoRef = useRef(info);
+  infoRef.current = info;
+  const pattern = info.pattern;
+  const patternSource = info.patternSource;
+  const paramsKey = info.params ? JSON.stringify(info.params) : "";
+  const queryParamsKey = info.queryParams ? JSON.stringify(info.queryParams) : "";
+  const routeStackKey = info.routeStack?.join(",");
+  useEffect(() => {
+    if (!bridge) return;
+    const registry = bridge.registry;
+    registry.setRouteInfo(effectiveInfo(infoRef.current, unmatched));
+    return () => {
+      registry.setRouteInfo(void 0);
+    };
+  }, [bridge, unmatched, pattern, patternSource, paramsKey, queryParamsKey, routeStackKey]);
+}
+
+// src/react/routePattern.ts
+function focusedIndex(state, routeCount) {
+  if (state.index !== void 0) return state.index;
+  return typeof state.type === "string" && state.type !== "stack" ? 0 : routeCount - 1;
+}
+function isRouteIdentifier(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes("/") && !value.includes("?") && !value.includes("#");
+}
+function isExpoRouterUnmatched(segments) {
+  return segments.some((s) => typeof s === "string" && s.startsWith("+"));
+}
+function expoRouterPattern(segments) {
+  if (!Array.isArray(segments)) return null;
+  for (const segment of segments) {
+    if (!isRouteIdentifier(segment)) return null;
+    if (segment.startsWith("+")) return null;
+  }
+  return "/" + segments.join("/");
+}
+function expoRouterRouteStack(segments) {
+  if (expoRouterPattern(segments) === null) return void 0;
+  const stack = ["/"];
+  for (let depth = 1; depth <= segments.length; depth++) {
+    stack.push("/" + segments.slice(0, depth).join("/"));
+  }
+  return stack;
+}
+function reactNavigationPattern(state, options = {}) {
+  const names = [];
+  let level = state ?? void 0;
+  while (level) {
+    const routes = level.routes;
+    if (!Array.isArray(routes) || routes.length === 0) return null;
+    const index = focusedIndex(level, routes.length);
+    if (!Number.isInteger(index) || index < 0 || index >= routes.length) return null;
+    const route = routes[index];
+    if (!route || !isRouteIdentifier(route.name)) return null;
+    names.push(route.name);
+    level = route.state;
+  }
+  if (names.length === 0) return null;
+  const leaf = names[names.length - 1];
+  if (options.notFoundRouteNames?.includes(leaf)) return null;
+  return "/" + names.join("/");
+}
 
-export { State, TransitionTo, UIBridgeNativeProvider, useAutoRegister, useToastRecorder, useUIBridge, useUIBridgeModal, useUIBridgeNative, useUIBridgeNativeOptional, useUIBridgeNativeRequired, useUIBridgeRequired, useUIBridgeToast, useUIComponent, useUIComponentAction, useUIElement, useUIElementWithProps };
+export { State, TransitionTo, UIBridgeNativeProvider, expoRouterPattern, expoRouterRouteStack, isExpoRouterUnmatched, reactNavigationPattern, useAutoRegister, useRouteAwareness, useToastRecorder, useUIBridge, useUIBridgeModal, useUIBridgeNative, useUIBridgeNativeOptional, useUIBridgeNativeRequired, useUIBridgeRequired, useUIBridgeToast, useUIComponent, useUIComponentAction, useUIElement, useUIElementWithProps };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map