@vertz/ui 0.2.23 → 0.2.24

package/dist/shared/{chunk-p3fz6qqp.js → chunk-18frwfc4.js}

@@ -1,6 +1,6 @@
 import {
   injectCSS
-} from "./chunk-xhc7arn9.js";
+} from "./chunk-t3rnfxc0.js";
 
 // src/dom/animation.ts
 function onAnimationsComplete(el, callback) {

package/dist/shared/chunk-2eh4p2n7.js

@@ -0,0 +1,39 @@
+import {
+  getSSRContext
+} from "./chunk-656n0x6y.js";
+
+// src/query/invalidate.ts
+var registry = new Set;
+function registerActiveQuery(entityMeta, refetch, clearData) {
+  const registration = { entityMeta, refetch, clearData };
+  registry.add(registration);
+  return () => registry.delete(registration);
+}
+function invalidate(descriptor) {
+  const meta = descriptor._entity;
+  if (!meta)
+    return;
+  if (meta.kind === "get" && !meta.id)
+    return;
+  for (const reg of [...registry]) {
+    if (reg.entityMeta.entityType !== meta.entityType)
+      continue;
+    if (reg.entityMeta.kind !== meta.kind)
+      continue;
+    if (meta.kind === "get" && reg.entityMeta.id !== meta.id)
+      continue;
+    reg.refetch();
+  }
+}
+function invalidateTenantQueries() {
+  if (getSSRContext() !== undefined)
+    return;
+  for (const reg of [...registry]) {
+    if (reg.entityMeta.tenantScoped !== true)
+      continue;
+    reg.clearData?.();
+    reg.refetch();
+  }
+}
+
+export { registerActiveQuery, invalidate, invalidateTenantQueries };

package/dist/shared/{chunk-016m1fq0.js → chunk-2wag9c7v.js}

@@ -1,17 +1,17 @@
 import {
-  __classList,
   __on,
   beginDeferringMounts,
   discardDeferredMounts,
   flushDeferredMounts
-} from "./chunk-2kyhn86t.js";
+} from "./chunk-ge2e6y2s.js";
 import {
   __append,
+  __classList,
   __element,
   __enterChildren,
   __exitChildren,
   __staticText
-} from "./chunk-13tvh4wq.js";
+} from "./chunk-mbnda3pv.js";
 import {
   RouterContext
 } from "./chunk-f4d5nphq.js";
@@ -34,6 +34,64 @@ import {
   useContext
 } from "./chunk-656n0x6y.js";
 
+// src/component/error-boundary-context.ts
+var handlerStack = [];
+function pushErrorHandler(handler) {
+  handlerStack.push(handler);
+}
+function popErrorHandler() {
+  handlerStack.pop();
+}
+function getCurrentErrorHandler() {
+  if (handlerStack.length === 0) {
+    return;
+  }
+  return handlerStack[handlerStack.length - 1];
+}
+
+// src/component/error-boundary.ts
+function toError(value) {
+  if (value instanceof Error) {
+    return value;
+  }
+  return new Error(String(value));
+}
+function ErrorBoundary(props) {
+  function handleAsyncError(error, placeholder) {
+    const fallbackNode = props.fallback(error, retry);
+    function retry() {
+      try {
+        const retryResult = props.children();
+        if (fallbackNode.parentNode) {
+          fallbackNode.parentNode.replaceChild(retryResult, fallbackNode);
+        }
+      } catch (_retryThrown) {}
+    }
+    if (placeholder.parentNode) {
+      placeholder.parentNode.replaceChild(fallbackNode, placeholder);
+    }
+  }
+  try {
+    pushErrorHandler(handleAsyncError);
+    const result = props.children();
+    popErrorHandler();
+    return result;
+  } catch (thrown) {
+    let retry = function() {
+      try {
+        const retryResult = props.children();
+        if (fallbackNode.parentNode) {
+          fallbackNode.parentNode.replaceChild(retryResult, fallbackNode);
+        }
+      } catch (_retryThrown) {}
+    };
+    popErrorHandler();
+    const error = toError(thrown);
+    const fallbackNode = props.fallback(error, retry);
+    return fallbackNode;
+  }
+}
+
 // src/router/link.ts
 var DANGEROUS_SCHEMES = ["javascript:", "data:", "vbscript:"];
 function isSafeUrl(url) {
@@ -256,12 +314,13 @@ function Outlet() {
 }
 
 // src/router/router-view.ts
-function RouterView({ router, fallback }) {
+function RouterView({ router, fallback, errorFallback }) {
   const container = __element("div");
   let isFirstHydrationRender = getIsHydrating();
   let renderGen = 0;
   let pageCleanups = [];
   let prevLevels = [];
+  let prevParamsKey;
   __enterChildren(container);
   const dispose = domEffect(() => {
     const match = router.current.value;
@@ -274,17 +333,23 @@ function RouterView({ router, fallback }) {
         if (prevLevels[divergeAt].route !== newMatched[divergeAt].route)
           break;
       }
-      if (prevLevels.length > 0 && divergeAt === prevLevels.length && divergeAt === newMatched.length) {
+      const currentParamsKey = match ? JSON.stringify(match.params) : undefined;
+      const chainIdentical = prevLevels.length > 0 && divergeAt === prevLevels.length && divergeAt === newMatched.length;
+      if (chainIdentical && prevParamsKey === currentParamsKey) {
         return;
       }
+      if (chainIdentical) {
+        divergeAt = 0;
+      }
       if (divergeAt > 0 && newMatched.length > 0) {
         const newLevels = buildLevels(newMatched);
-        const newChildFactory = buildInsideOutFactory(newMatched, newLevels, divergeAt, router);
+        const newChildFactory = buildInsideOutFactory(newMatched, newLevels, divergeAt, router, errorFallback);
         const parentLevel = prevLevels[divergeAt - 1];
         if (parentLevel.childSignal) {
           parentLevel.childSignal.value = newChildFactory;
         }
         prevLevels = [...prevLevels.slice(0, divergeAt), ...newLevels.slice(divergeAt)];
+        prevParamsKey = currentParamsKey;
         return;
       }
       runCleanups(pageCleanups);
@@ -299,6 +364,7 @@ function RouterView({ router, fallback }) {
         pageCleanups = pushScope();
         if (!match) {
           prevLevels = [];
+          prevParamsKey = undefined;
           if (fallback) {
             container.appendChild(fallback());
           }
@@ -306,7 +372,8 @@ function RouterView({ router, fallback }) {
           return;
         }
         const levels = buildLevels(newMatched);
-        const rootFactory = buildInsideOutFactory(newMatched, levels, 0, router);
+        const rootFactory = buildInsideOutFactory(newMatched, levels, 0, router, errorFallback);
+        const lazyFallback = match ? match.route.errorComponent ?? errorFallback : undefined;
         let asyncRoute = false;
         RouterContext.Provider(router, () => {
           const result = rootFactory();
@@ -352,11 +419,35 @@ function RouterView({ router, fallback }) {
                     container.appendChild(node);
                   });
                 }
+              } catch (thrown) {
+                if (lazyFallback) {
+                  const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+                  while (container.firstChild) {
+                    container.removeChild(container.firstChild);
+                  }
+                  const fallbackNode = lazyFallback({
+                    error,
+                    retry: () => {
+                      try {
+                        const retryNode = mod.default();
+                        if (fallbackNode.parentNode) {
+                          fallbackNode.parentNode.replaceChild(retryNode, fallbackNode);
+                        }
+                      } catch {}
+                    }
+                  });
+                  container.appendChild(fallbackNode);
+                } else {
+                  throw thrown;
+                }
               } finally {
                 popScope();
               }
             });
           } else {
+            if (gen !== renderGen) {
+              return;
+            }
             __append(container, result);
             if (getIsHydrating() && !container.contains(result)) {
               while (container.firstChild) {
@@ -366,7 +457,10 @@ function RouterView({ router, fallback }) {
             }
           }
         });
-        prevLevels = levels;
+        if (gen === renderGen) {
+          prevLevels = levels;
+          prevParamsKey = currentParamsKey;
+        }
         if (!asyncRoute) {
           popScope();
         }
@@ -387,7 +481,7 @@ function buildLevels(matched) {
     route: m.route
   }));
 }
-function buildInsideOutFactory(matched, levels, startAt, router) {
+function buildInsideOutFactory(matched, levels, startAt, router, errorFallback) {
   const ssrCtx = getSSRContext();
   const wrapForSSR = (route, routeIndex) => {
     if (!ssrCtx)
@@ -415,12 +509,22 @@ function buildInsideOutFactory(matched, levels, startAt, router) {
       return result;
     };
   };
-  let factory = wrapForSSR(matched[matched.length - 1].route, matched.length - 1);
+  const resolveFallback = (route) => route.errorComponent ?? errorFallback;
+  const maybeWrapInBoundary = (componentFn, fb) => {
+    if (!fb)
+      return componentFn;
+    return () => ErrorBoundary({
+      children: componentFn,
+      fallback: (error, retry) => fb({ error, retry })
+    });
+  };
+  const leafRoute = matched[matched.length - 1].route;
+  let factory = maybeWrapInBoundary(wrapForSSR(leafRoute, matched.length - 1), resolveFallback(leafRoute));
   for (let i = matched.length - 2;i >= startAt; i--) {
     const level = levels[i];
     const childFactory = factory;
     level.childSignal.value = childFactory;
-    const parentComponent = wrapForSSR(level.route, i);
+    const parentComponent = maybeWrapInBoundary(wrapForSSR(level.route, i), resolveFallback(level.route));
     const cs = level.childSignal;
     factory = () => {
       let result;
@@ -451,4 +555,4 @@ function useSearchParams(searchSignal) {
   return searchSignal.value;
 }
 
-export { createLink, Link, OutletContext, Outlet, RouterView, parseSearchParams, useSearchParams };
+export { getCurrentErrorHandler, ErrorBoundary, createLink, Link, OutletContext, Outlet, RouterView, parseSearchParams, useSearchParams };