@vertz/ui 0.2.23 → 0.2.24

package/dist/shared/{chunk-g6fb5yc2.js → chunk-4gen306a.js}

@@ -5,6 +5,9 @@ import {
   getAdapter,
   isRenderNode
 } from "./chunk-2y9f9j62.js";
+import {
+  registerActiveQuery
+} from "./chunk-2eh4p2n7.js";
 import {
   isBrowser
 } from "./chunk-da2w7j7w.js";
@@ -107,30 +110,6 @@ class MemoryCache {
   }
 }
 
-// src/query/invalidate.ts
-var registry = new Set;
-function registerActiveQuery(entityMeta, refetch) {
-  const registration = { entityMeta, refetch };
-  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();
-  }
-}
-
 // src/query/key-derivation.ts
 function deriveKey(thunk) {
   return `__q:${hashString(thunk.toString())}`;
@@ -231,15 +210,15 @@ var INTERNAL_PROPS = new Set([
 ]);
 
 // src/store/relation-registry.ts
-var registry2 = new Map;
+var registry = new Map;
 function registerRelationSchema(entityType, schema) {
-  registry2.set(entityType, Object.freeze(schema));
+  registry.set(entityType, Object.freeze(schema));
 }
 function getRelationSchema(entityType) {
-  return registry2.get(entityType);
+  return registry.get(entityType);
 }
 function resetRelationSchemas_TEST_ONLY() {
-  registry2.clear();
+  registry.clear();
 }
 
 // src/store/merge.ts
@@ -700,6 +679,9 @@ class QueryEnvelopeStore {
   set(queryKey, envelope) {
     this._envelopes.set(queryKey, envelope);
   }
+  delete(queryKey) {
+    this._envelopes.delete(queryKey);
+  }
   clear() {
     this._envelopes.clear();
   }
@@ -874,11 +856,11 @@ function query(source, options = {}) {
   const {
     initialData,
     debounce: debounceMs,
-    enabled = true,
     key: customKey,
     cache = getDefaultCache(),
-    _entityMeta: entityMeta
+    _entityMeta: optionsEntityMeta
   } = options;
+  let entityMeta = optionsEntityMeta;
   const baseKey = deriveKey(thunk);
   const depHashSignal = signal("");
   const cacheKeyComputed = computed(() => {
@@ -910,9 +892,9 @@ function query(source, options = {}) {
   function callThunkWithCapture() {
     const captured = [];
     const prevCb = setReadValueCallback((v) => captured.push(v));
-    let promise;
+    let result;
     try {
-      promise = thunk();
+      result = thunk();
     } finally {
       setReadValueCallback(prevCb);
     }
@@ -920,12 +902,13 @@ function query(source, options = {}) {
     untrack(() => {
       depHashSignal.value = hashString(serialized);
     });
-    return promise;
+    return result;
   }
   const rawData = signal(initialData);
-  const loading = signal(initialData === undefined && enabled);
+  const loading = signal(initialData === undefined);
   const revalidating = signal(false);
   const error = signal(undefined);
+  const idle = signal(initialData === undefined);
   const entityBacked = signal(false);
   function normalizeToEntityStore(result) {
     if (!entityMeta)
@@ -951,30 +934,31 @@ function query(source, options = {}) {
     }
   }
   const referencedKeys = new Set;
-  const data = entityMeta ? computed(() => {
+  const initialEntityMeta = entityMeta;
+  const data = initialEntityMeta ? computed(() => {
     if (!entityBacked.value)
       return rawData.value;
     const raw = rawData.value;
     const store = getEntityStore();
     const newKeys = new Set;
-    if (entityMeta.kind === "get" && entityMeta.id) {
-      const entity = store.get(entityMeta.entityType, entityMeta.id).value;
+    if (initialEntityMeta.kind === "get" && initialEntityMeta.id) {
+      const entity = store.get(initialEntityMeta.entityType, initialEntityMeta.id).value;
       if (!entity) {
         updateRefCounts(store, referencedKeys, newKeys);
         return;
       }
-      const resolved = resolveReferences(entity, entityMeta.entityType, store, undefined, newKeys);
+      const resolved = resolveReferences(entity, initialEntityMeta.entityType, store, undefined, newKeys);
       updateRefCounts(store, referencedKeys, newKeys);
       return resolved;
     }
-    const queryKey = customKey ?? entityMeta.entityType;
+    const queryKey = customKey ?? initialEntityMeta.entityType;
     const ids = store.queryIndices.get(queryKey);
     if (ids) {
       const items = ids.map((id) => {
-        const entity = store.get(entityMeta.entityType, id).value;
+        const entity = store.get(initialEntityMeta.entityType, id).value;
         if (!entity)
           return null;
-        return resolveReferences(entity, entityMeta.entityType, store, undefined, newKeys);
+        return resolveReferences(entity, initialEntityMeta.entityType, store, undefined, newKeys);
       }).filter((item) => item != null);
       const envelope = getQueryEnvelopeStore().get(queryKey);
       updateRefCounts(store, referencedKeys, newKeys);
@@ -989,37 +973,57 @@ function query(source, options = {}) {
     retainKey(initKey);
   }
   const ssrTimeout = options.ssrTimeout ?? getGlobalSSRTimeout() ?? 300;
-  if (isSSR() && enabled && ssrTimeout !== 0 && initialData === undefined) {
-    const promise = callThunkWithCapture();
-    const key = untrack(() => getCacheKey());
-    const cached = cache.get(key);
-    if (cached !== undefined) {
-      promise.catch(() => {});
-      normalizeToEntityStore(cached);
-      rawData.value = cached;
+  if (isSSR() && ssrTimeout !== 0 && initialData === undefined) {
+    const ssrRaw = callThunkWithCapture();
+    if (ssrRaw === null) {
       loading.value = false;
     } else {
-      promise.catch(() => {});
-      const ctx = getSSRContext();
-      if (ctx) {
-        ctx.queries.push({
-          promise,
-          timeout: ssrTimeout,
-          resolve: (result) => {
-            normalizeToEntityStore(result);
-            rawData.value = result;
-            loading.value = false;
-            cache.set(key, result);
-          },
-          key
+      let ssrPromise;
+      if (isQueryDescriptor(ssrRaw)) {
+        const fetchResult = ssrRaw._fetch();
+        ssrPromise = fetchResult.then((result) => {
+          if (!result.ok)
+            throw result.error;
+          return result.data;
         });
+        if (ssrRaw._entity && !entityMeta) {
+          entityMeta = ssrRaw._entity;
+        }
+      } else {
+        ssrPromise = ssrRaw;
+      }
+      const key = untrack(() => getCacheKey());
+      const cached = cache.get(key);
+      if (cached !== undefined) {
+        ssrPromise.catch(() => {});
+        normalizeToEntityStore(cached);
+        rawData.value = cached;
+        loading.value = false;
+        idle.value = false;
+      } else {
+        ssrPromise.catch(() => {});
+        const ctx = getSSRContext();
+        if (ctx) {
+          ctx.queries.push({
+            promise: ssrPromise,
+            timeout: ssrTimeout,
+            resolve: (result) => {
+              normalizeToEntityStore(result);
+              rawData.value = result;
+              loading.value = false;
+              idle.value = false;
+              cache.set(key, result);
+            },
+            key
+          });
+        }
       }
     }
   }
   let ssrHydrationCleanup = null;
   let ssrHydrated = false;
   let navPrefetchDeferred = false;
-  if (!isSSR() && enabled && initialData === undefined) {
+  if (!isSSR() && initialData === undefined) {
     const hydrationKey = customKey ?? baseKey;
     const isNavigation = isNavPrefetchActive();
     ssrHydrationCleanup = hydrateQueryFromSSR(hydrationKey, (result) => {
@@ -1086,7 +1090,7 @@ function query(source, options = {}) {
     }, ms);
   }
   let visibilityHandler;
-  if (hasInterval && enabled && isBrowser()) {
+  if (hasInterval && isBrowser()) {
     visibilityHandler = () => {
       if (document.visibilityState === "hidden") {
         intervalPaused = true;
@@ -1149,116 +1153,154 @@ function query(source, options = {}) {
     refetchTrigger.value = refetchTrigger.peek() + 1;
   }
   let disposeFn;
-  if (enabled) {
-    let isFirst = true;
-    disposeFn = lifecycleEffect(() => {
-      refetchTrigger.value;
-      if (isFirst && ssrHydrated) {
-        isFirst = false;
-        return;
-      }
-      if (isFirst && navPrefetchDeferred) {
-        if (customKey) {
-          const cached = untrack(() => cache.get(customKey));
-          if (cached !== undefined) {
-            retainKey(customKey);
-            untrack(() => {
-              rawData.value = cached;
-              loading.value = false;
-            });
-            isFirst = false;
-            return;
-          }
-        } else {
-          const trackPromise = callThunkWithCapture();
-          trackPromise.catch(() => {});
-          const derivedKey = untrack(() => getCacheKey());
-          const cached = untrack(() => cache.get(derivedKey));
-          if (cached !== undefined) {
-            retainKey(derivedKey);
-            untrack(() => {
-              rawData.value = cached;
-              loading.value = false;
-            });
-            isFirst = false;
-            return;
-          }
-        }
-        isFirst = false;
-        return;
-      }
+  let isFirst = true;
+  disposeFn = lifecycleEffect(() => {
+    refetchTrigger.value;
+    if (isFirst && ssrHydrated) {
+      isFirst = false;
+      return;
+    }
+    if (isFirst && navPrefetchDeferred) {
       if (customKey) {
-        const existing = untrack(() => getInflight().get(customKey));
-        if (existing) {
-          const id = ++fetchId;
+        const cached = untrack(() => cache.get(customKey));
+        if (cached !== undefined) {
+          retainKey(customKey);
           untrack(() => {
-            if (rawData.value !== undefined) {
-              revalidating.value = true;
-            } else {
-              loading.value = true;
-            }
-            error.value = undefined;
+            rawData.value = cached;
+            loading.value = false;
           });
-          handleFetchPromise(existing, id, customKey);
           isFirst = false;
           return;
         }
-      }
-      const promise = callThunkWithCapture();
-      const key = untrack(() => getCacheKey());
-      if (!customKey) {
-        const existing = untrack(() => getInflight().get(key));
-        if (existing) {
-          promise.catch(() => {});
-          const id = ++fetchId;
-          untrack(() => {
-            if (rawData.value !== undefined) {
-              revalidating.value = true;
-            } else {
-              loading.value = true;
-            }
-            error.value = undefined;
-          });
-          handleFetchPromise(existing, id, key);
+      } else {
+        const trackRaw = callThunkWithCapture();
+        if (trackRaw === null) {
           isFirst = false;
           return;
         }
-      }
-      const isNavigation = ssrHydrationCleanup !== null;
-      const shouldCheckCache = isNavigation || (isFirst ? !!customKey : !customKey);
-      if (shouldCheckCache) {
-        const cached = untrack(() => cache.get(key));
+        if (!isQueryDescriptor(trackRaw)) {
+          trackRaw.catch(() => {});
+        }
+        const derivedKey = untrack(() => getCacheKey());
+        const cached = untrack(() => cache.get(derivedKey));
         if (cached !== undefined) {
-          retainKey(key);
-          promise.catch(() => {});
+          retainKey(derivedKey);
           untrack(() => {
             rawData.value = cached;
             loading.value = false;
-            error.value = undefined;
           });
           isFirst = false;
-          scheduleInterval();
           return;
         }
       }
-      if (isFirst && initialData !== undefined) {
+      isFirst = false;
+      return;
+    }
+    if (customKey) {
+      const existing = untrack(() => getInflight().get(customKey));
+      if (existing) {
+        const id = ++fetchId;
+        untrack(() => {
+          if (rawData.value !== undefined) {
+            revalidating.value = true;
+          } else {
+            loading.value = true;
+          }
+          error.value = undefined;
+        });
+        handleFetchPromise(existing, id, customKey);
+        isFirst = false;
+        return;
+      }
+    }
+    const raw = callThunkWithCapture();
+    if (raw === null) {
+      clearTimeout(debounceTimer);
+      untrack(() => {
+        loading.value = false;
+      });
+      isFirst = false;
+      return;
+    }
+    let promise;
+    let effectKey;
+    let effectEntityMeta;
+    if (isQueryDescriptor(raw)) {
+      effectKey = raw._key;
+      effectEntityMeta = raw._entity;
+      const fetchResult = raw._fetch();
+      promise = fetchResult.then((result) => {
+        if (!result.ok)
+          throw result.error;
+        return result.data;
+      });
+      if (effectEntityMeta && !entityMeta) {
+        entityMeta = effectEntityMeta;
+        if (!isSSR()) {
+          unsubscribeBus = getMutationEventBus().subscribe(entityMeta.entityType, refetch);
+          unregisterFromRegistry = registerActiveQuery(entityMeta, refetch, createClearData(entityMeta));
+        }
+      }
+    } else {
+      promise = raw;
+    }
+    untrack(() => {
+      idle.value = false;
+    });
+    const key = effectKey ?? untrack(() => getCacheKey());
+    if (!customKey && !effectKey) {
+      const existing = untrack(() => getInflight().get(key));
+      if (existing) {
+        promise.catch(() => {});
+        const id = ++fetchId;
+        untrack(() => {
+          if (rawData.value !== undefined) {
+            revalidating.value = true;
+          } else {
+            loading.value = true;
+          }
+          error.value = undefined;
+        });
+        handleFetchPromise(existing, id, key);
+        isFirst = false;
+        return;
+      }
+    }
+    const isNavigation = ssrHydrationCleanup !== null;
+    const shouldCheckCache = effectKey || isNavigation || (isFirst ? !!customKey : !customKey);
+    if (shouldCheckCache) {
+      const cached = untrack(() => cache.get(key));
+      if (cached !== undefined) {
+        retainKey(key);
         promise.catch(() => {});
+        untrack(() => {
+          normalizeToEntityStore(cached);
+          rawData.value = cached;
+          loading.value = false;
+          error.value = undefined;
+        });
         isFirst = false;
         scheduleInterval();
         return;
       }
+    }
+    if (isFirst && initialData !== undefined) {
+      promise.catch(() => {});
       isFirst = false;
-      if (debounceMs !== undefined && debounceMs > 0) {
-        clearTimeout(debounceTimer);
-        promise.catch(() => {});
-        debounceTimer = setTimeout(() => {
-          startFetch(promise, key);
-        }, debounceMs);
-      } else {
+      scheduleInterval();
+      return;
+    }
+    isFirst = false;
+    if (debounceMs !== undefined && debounceMs > 0) {
+      clearTimeout(debounceTimer);
+      promise.catch(() => {});
+      debounceTimer = setTimeout(() => {
         startFetch(promise, key);
-      }
-    });
-  }
+      }, debounceMs);
+    } else {
+      startFetch(promise, key);
+    }
+  });
   function dispose() {
     if (referencedKeys.size > 0) {
       const store = getEntityStore();
@@ -1284,11 +1326,25 @@ function query(source, options = {}) {
     }
     inflightKeys.clear();
   }
+  function createClearData(meta) {
+    return () => {
+      untrack(() => {
+        entityBacked.value = false;
+        rawData.value = undefined;
+        loading.value = true;
+      });
+      const cacheKey = untrack(() => getCacheKey());
+      cache.delete(cacheKey);
+      const queryKey = customKey ?? meta.entityType;
+      getEntityStore().queryIndices.clear(queryKey);
+      getQueryEnvelopeStore().delete(queryKey);
+    };
+  }
   let unsubscribeBus;
   let unregisterFromRegistry;
-  if (entityMeta && enabled && !isSSR()) {
+  if (entityMeta && !isSSR()) {
     unsubscribeBus = getMutationEventBus().subscribe(entityMeta.entityType, refetch);
-    unregisterFromRegistry = registerActiveQuery(entityMeta, refetch);
+    unregisterFromRegistry = registerActiveQuery(entityMeta, refetch, createClearData(entityMeta));
   }
   _tryOnCleanup(dispose);
   return {
@@ -1296,6 +1352,7 @@ function query(source, options = {}) {
     loading,
     revalidating,
     error,
+    idle,
     refetch,
     revalidate: refetch,
     dispose
@@ -1420,4 +1477,4 @@ function queryMatch(queryResult, handlers) {
   return wrapper;
 }
 
-export { MemoryCache, invalidate, deriveKey, FieldSelectionTracker, registerRelationSchema, getRelationSchema, resetRelationSchemas_TEST_ONLY, EntityStore, QueryEnvelopeStore, getEntityStore, getQueryEnvelopeStore, getMutationEventBus, query, queryMatch };
+export { MemoryCache, deriveKey, FieldSelectionTracker, registerRelationSchema, getRelationSchema, resetRelationSchemas_TEST_ONLY, EntityStore, QueryEnvelopeStore, getEntityStore, getQueryEnvelopeStore, getMutationEventBus, query, queryMatch };

package/dist/shared/{chunk-2kyhn86t.js → chunk-ge2e6y2s.js}

@@ -1,9 +1,5 @@
-import {
-  styleObjectToString
-} from "./chunk-4xkw6h1s.js";
 import {
   _tryOnCleanup,
-  deferredDomEffect,
   getSSRContext,
   popScope,
   pushScope,
@@ -95,66 +91,12 @@ function executeOnMount(callback) {
   }
 }
 
-// src/dom/attributes.ts
-function __attr(el, name, fn) {
-  return deferredDomEffect(() => {
-    const value = fn();
-    if (value == null || value === false) {
-      el.removeAttribute(name);
-    } else if (value === true) {
-      el.setAttribute(name, "");
-    } else if (name === "style" && typeof value === "object") {
-      el.setAttribute(name, styleObjectToString(value));
-    } else {
-      el.setAttribute(name, value);
-    }
-  });
-}
-function __prop(el, name, fn) {
-  return deferredDomEffect(() => {
-    const value = fn();
-    if (value == null) {
-      Reflect.set(el, name, typeof Reflect.get(el, name) === "boolean" ? false : "");
-    } else {
-      Reflect.set(el, name, value);
-    }
-    if (name === "selected") {
-      if (value) {
-        el.setAttribute(name, "");
-      } else {
-        el.removeAttribute(name);
-      }
-    }
-  });
-}
-function __show(el, fn) {
-  const originalDisplay = el.style.display;
-  return deferredDomEffect(() => {
-    el.style.display = fn() ? originalDisplay : "none";
-  });
-}
-function __classList(el, classMap) {
-  const disposers = [];
-  for (const [className, fn] of Object.entries(classMap)) {
-    disposers.push(deferredDomEffect(() => {
-      if (fn()) {
-        el.classList.add(className);
-      } else {
-        el.classList.remove(className);
-      }
-    }));
-  }
-  return () => {
-    for (const dispose of disposers) {
-      dispose();
-    }
-  };
-}
-
 // src/dom/events.ts
 function __on(el, event, handler) {
   el.addEventListener(event, handler);
-  return () => el.removeEventListener(event, handler);
+  const cleanup = () => el.removeEventListener(event, handler);
+  _tryOnCleanup(cleanup);
+  return cleanup;
 }
 
-export { __pushMountFrame, __flushMountFrame, __discardMountFrame, beginDeferringMounts, flushDeferredMounts, discardDeferredMounts, onMount, __attr, __prop, __show, __classList, __on };
+export { __pushMountFrame, __flushMountFrame, __discardMountFrame, beginDeferringMounts, flushDeferredMounts, discardDeferredMounts, onMount, __on };

package/dist/shared/{chunk-4xkw6h1s.js → chunk-h1fsr8kv.js}

@@ -1,3 +1,69 @@
+// src/dom/svg-tags.ts
+var SVG_TAGS = new Set([
+  "svg",
+  "path",
+  "circle",
+  "ellipse",
+  "rect",
+  "line",
+  "polyline",
+  "polygon",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "text",
+  "tspan",
+  "image",
+  "foreignObject",
+  "filter",
+  "feGaussianBlur",
+  "feOffset",
+  "feColorMatrix",
+  "feBlend",
+  "feMerge",
+  "feMergeNode",
+  "feComposite",
+  "feFlood",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "pattern",
+  "clipPath",
+  "mask",
+  "animate",
+  "animateTransform",
+  "set",
+  "marker",
+  "desc"
+]);
+var SVG_NS = "http://www.w3.org/2000/svg";
+function isSVGTag(tag) {
+  return SVG_TAGS.has(tag);
+}
+var SVG_ATTR_MAP = {
+  strokeWidth: "stroke-width",
+  strokeLinecap: "stroke-linecap",
+  strokeLinejoin: "stroke-linejoin",
+  strokeDasharray: "stroke-dasharray",
+  strokeDashoffset: "stroke-dashoffset",
+  strokeOpacity: "stroke-opacity",
+  fillOpacity: "fill-opacity",
+  fillRule: "fill-rule",
+  clipRule: "clip-rule",
+  clipPath: "clip-path",
+  stopColor: "stop-color",
+  stopOpacity: "stop-opacity",
+  floodColor: "flood-color",
+  floodOpacity: "flood-opacity",
+  colorInterpolation: "color-interpolation",
+  colorInterpolationFilters: "color-interpolation-filters",
+  viewBox: "viewBox"
+};
+function normalizeSVGAttr(attr) {
+  return SVG_ATTR_MAP[attr] ?? attr;
+}
+
 // src/dom/style.ts
 function camelToKebab(prop) {
   const third = prop[2];
@@ -70,4 +136,4 @@ function styleObjectToString(style) {
   return parts.join("; ");
 }
 
-export { styleObjectToString };
+export { SVG_NS, isSVGTag, normalizeSVGAttr, styleObjectToString };