@vertz/ui 0.2.23 → 0.2.25

package/dist/shared/chunk-09ntccdx.js

@@ -0,0 +1,39 @@
+import {
+  getSSRContext
+} from "./chunk-ppr06jgn.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-g6fb5yc2.js → chunk-1jgws7rs.js}

@@ -2,26 +2,21 @@ import {
   isNavPrefetchActive
 } from "./chunk-jrtrk5z4.js";
 import {
-  getAdapter,
-  isRenderNode
-} from "./chunk-2y9f9j62.js";
+  registerActiveQuery
+} from "./chunk-09ntccdx.js";
 import {
   isBrowser
-} from "./chunk-da2w7j7w.js";
+} from "./chunk-xs5s8gqe.js";
 import {
   _tryOnCleanup,
   batch,
   computed,
-  domEffect,
   getSSRContext,
   lifecycleEffect,
-  popScope,
-  pushScope,
-  runCleanups,
   setReadValueCallback,
   signal,
   untrack
-} from "./chunk-656n0x6y.js";
+} from "./chunk-ppr06jgn.js";
 
 // src/query/cache.ts
 class MemoryCache {
@@ -107,30 +102,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 +202,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 +671,9 @@ class QueryEnvelopeStore {
   set(queryKey, envelope) {
     this._envelopes.set(queryKey, envelope);
   }
+  delete(queryKey) {
+    this._envelopes.delete(queryKey);
+  }
   clear() {
     this._envelopes.clear();
   }
@@ -874,11 +848,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 +884,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 +894,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 +926,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 +965,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 +1082,7 @@ function query(source, options = {}) {
     }, ms);
   }
   let visibilityHandler;
-  if (hasInterval && enabled && isBrowser()) {
+  if (hasInterval && isBrowser()) {
     visibilityHandler = () => {
       if (document.visibilityState === "hidden") {
         intervalPaused = true;
@@ -1149,116 +1145,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 +1318,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 +1344,7 @@ function query(source, options = {}) {
     loading,
     revalidating,
     error,
+    idle,
     refetch,
     revalidate: refetch,
     dispose
@@ -1323,101 +1372,4 @@ function splitRefKey(key) {
   return [key.slice(0, idx), key.slice(idx + 1)];
 }
 
-// src/query/query-match.ts
-var cache = new WeakMap;
-function queryMatch(queryResult, handlers) {
-  const key = queryResult;
-  const existing = cache.get(key);
-  if (existing && !existing.disposed) {
-    existing.handlers = handlers;
-    return existing.wrapper;
-  }
-  if (existing) {
-    cache.delete(key);
-  }
-  const wrapper = getAdapter().createElement("span");
-  wrapper.style.display = "contents";
-  const entry = { wrapper, handlers, disposed: false };
-  cache.set(key, entry);
-  let currentBranch = null;
-  let branchCleanups = [];
-  const outerScope = pushScope();
-  domEffect(() => {
-    const isLoading = queryResult.loading.value;
-    const err = queryResult.error.value;
-    const dataValue = queryResult.data.value;
-    let branch;
-    if (isLoading || err === undefined && dataValue === undefined) {
-      branch = "loading";
-    } else if (err !== undefined) {
-      branch = "error";
-    } else {
-      branch = "data";
-    }
-    if (branch === currentBranch) {
-      return;
-    }
-    runCleanups(branchCleanups);
-    while (wrapper.firstChild) {
-      wrapper.removeChild(wrapper.firstChild);
-    }
-    currentBranch = branch;
-    const scope = pushScope();
-    let branchResult = null;
-    if (branch === "loading") {
-      branchResult = entry.handlers.loading();
-    } else if (branch === "error") {
-      branchResult = entry.handlers.error(err);
-    } else {
-      const dataSignal = queryResult.data;
-      const dataProxy = new Proxy({}, {
-        get(_target, prop, receiver) {
-          const current = dataSignal.value;
-          if (current == null)
-            return;
-          const value = Reflect.get(current, prop, receiver);
-          if (typeof value === "function") {
-            return value.bind(current);
-          }
-          return value;
-        },
-        has(_target, prop) {
-          const current = dataSignal.value;
-          if (current == null)
-            return false;
-          return Reflect.has(current, prop);
-        },
-        ownKeys() {
-          const current = dataSignal.value;
-          if (current == null)
-            return [];
-          return Reflect.ownKeys(current);
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-          const current = dataSignal.value;
-          if (current == null)
-            return;
-          return Reflect.getOwnPropertyDescriptor(current, prop);
-        }
-      });
-      branchResult = entry.handlers.data(dataProxy);
-    }
-    popScope();
-    branchCleanups = scope;
-    if (branchResult != null && isRenderNode(branchResult)) {
-      wrapper.appendChild(branchResult);
-    }
-  });
-  popScope();
-  const dispose = () => {
-    entry.disposed = true;
-    runCleanups(branchCleanups);
-    runCleanups(outerScope);
-    cache.delete(key);
-  };
-  wrapper.dispose = dispose;
-  _tryOnCleanup(dispose);
-  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 };