@kodaris/krubble-app-components 1.0.141 → 1.0.143

package/dist/krubble-app.umd.js

@@ -12171,6 +12171,17 @@
       return c > 3 && r && Object.defineProperty(target, key, r), r;
   };
   class KRRouter {
+      /**
+       * The current route's resolved data: everything every matched level's static resolve() returned,
+       * merged with deeper levels winning on a shared key.
+       *
+       * Read it in connectedCallback — the router fills it before any element mounts. A child route gets
+       * what its parent resolved from here, so a tab component needs no resolve() of its own. Use
+       * KRRouter.getParams() for the route's params.
+       */
+      static getData() {
+          return KRRouter.data;
+      }
       static configure(config) {
           KRRouter.base = config.base;
           KRRouter.routes = config.routes;
@@ -12232,40 +12243,61 @@
               }
           }
           const token = ++KRRouter.navToken;
-          // Resolve every route's matching component (screen).
+          // Resolve every route's matching component (screen), keeping each level's resolved data alongside
+          // its element so the whole chain can be merged once they've all settled.
           Promise.all(matched.routes.map(match => {
-              // Reuse the cached element for this url if we have one
+              // Reuse the cached element for this url if we have one. Its data is cached with it — resolve()
+              // doesn't run again, but the level still has to contribute to the merge below.
               const cached = KRRouter.routeCache.get(match.url);
               if (cached) {
-                  return Promise.resolve(cached.el);
+                  return Promise.resolve({
+                      el: cached.el,
+                      data: cached.data,
+                  });
               }
               // Create and cache the screen element
               const el = document.createElement(match.route.component);
-              KRRouter.routeCache.set(match.url, {
+              const entry = {
                   el,
                   scrolls: [],
-              });
-              // If the component class defines a static resolve(params), await it and hand the result to the
-              // element as `routeSnapshot` = { params, data } before it mounts, so it paints with data instead
-              // of flashing empty
+                  data: null,
+              };
+              KRRouter.routeCache.set(match.url, entry);
+              // If the component class defines a static resolve(params), await it. Every level's result is
+              // merged into KRRouter.data below before anything mounts, so a component paints with its data
+              // already in hand instead of flashing empty.
               const constructor = customElements.get(match.route.component);
               if (constructor && typeof constructor.resolve === 'function') {
                   return Promise.resolve(constructor.resolve(KRRouter.getParams())).then(data => {
-                      const routeSnapshot = Object.freeze({
-                          params: match.params,
+                      entry.data = data;
+                      return {
+                          el,
                           data,
-                      });
-                      el.routeSnapshot = routeSnapshot;
-                      return el;
+                      };
                   });
               }
-              return Promise.resolve(el);
+              return Promise.resolve({
+                  el,
+                  data: null,
+              });
           }))
-              .then(elements => {
+              .then(resolved => {
               // A newer navigation started while we were resolving — its elements are the current truth.
               if (token !== KRRouter.navToken) {
                   return;
               }
+              // Merge the whole chain's resolved data into one object, parents first so a deeper route can
+              // override a key it shares with an ancestor. Set BEFORE any element mounts, so every component
+              // — at any depth — reads it with KRRouter.getData() in connectedCallback: a tab component gets
+              // what its parent resolved with no resolve() of its own and no second request. Mirrors
+              // KNNavigator.data() in kodaris-ngx, which searches the Angular route tree by key.
+              KRRouter.data = {};
+              for (const item of resolved) {
+                  if (item.data) {
+                      Object.assign(KRRouter.data, item.data);
+                  }
+              }
+              const elements = resolved.map(item => item.el);
               // ---- PASS 1: deactivate, deepest level first ----
               // Remove screen elements that no longer apply to the new current routes for the current url
               const levels = Array.from(KRRouter.outletContexts.keys()).sort((a, b) => b - a);
@@ -12538,6 +12570,9 @@
   // One token per navigation. A slower navigation that has been superseded must not activate its
   // (stale) elements, so it checks the token before committing anything.
   KRRouter.navToken = 0;
+  // Every matched route level's resolved data, merged into one object for the current navigation. This
+  // is set before anything mounts — see the merge in handleNavigation.
+  KRRouter.data = {};
   exports.RouterOutlet = class KRRouterOutlet extends i$3 {
       constructor() {
           super(...arguments);