@vertz/ui 0.2.15 → 0.2.17

package/dist/shared/{chunk-wymw818z.js → chunk-fkbgbf3n.js}

@@ -1,14 +1,17 @@
 import {
   executeLoaders,
   matchRoute
-} from "./chunk-83g4h38e.js";
+} from "./chunk-6wd36w21.js";
 import {
   prefetchNavData
 } from "./chunk-jrtrk5z4.js";
+import {
+  isBrowser
+} from "./chunk-14eqne2a.js";
 import {
   getSSRContext,
   signal
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/router/navigate.ts
 var DEFAULT_NAV_THRESHOLD_MS = 500;
@@ -59,24 +62,34 @@ function buildSearch(search) {
 function buildNavigationUrl(to, options) {
   return `${interpolatePath(to, options?.params)}${buildSearch(options?.search)}`;
 }
-function createRouter(routes, initialUrl, options) {
+function createRouter(routes, initialUrlOrOptions, maybeOptions) {
+  const initialUrl = typeof initialUrlOrOptions === "string" ? initialUrlOrOptions : undefined;
+  const options = typeof initialUrlOrOptions === "object" ? initialUrlOrOptions : maybeOptions;
   const ssrCtx = getSSRContext();
-  const isSSR = ssrCtx !== undefined;
-  if (isSSR || typeof window === "undefined") {
+  if (!isBrowser()) {
+    let registerRoutesForDiscovery = function(ctx) {
+      if (!ctx.discoveredRoutes) {
+        ctx.discoveredRoutes = collectRoutePatterns(routes);
+      }
+    };
     const ssrUrl = initialUrl ?? ssrCtx?.url ?? "/";
     const fallbackMatch = matchRoute(routes, ssrUrl);
     return {
       current: {
         get value() {
           const ctx = getSSRContext();
-          if (ctx)
+          if (ctx) {
+            registerRoutesForDiscovery(ctx);
             return matchRoute(routes, ctx.url);
+          }
           return fallbackMatch;
         },
         peek() {
           const ctx = getSSRContext();
-          if (ctx)
+          if (ctx) {
+            registerRoutesForDiscovery(ctx);
             return matchRoute(routes, ctx.url);
+          }
           return fallbackMatch;
         },
         notify() {}
@@ -129,8 +142,12 @@ function createRouter(routes, initialUrl, options) {
   const current = {
     get value() {
       const ctx = getSSRContext();
-      if (ctx)
+      if (ctx) {
+        if (!ctx.discoveredRoutes) {
+          ctx.discoveredRoutes = collectRoutePatterns(routes);
+        }
         return matchRoute(routes, ctx.url);
+      }
       return _current.value;
     },
     set value(v) {
@@ -138,8 +155,12 @@ function createRouter(routes, initialUrl, options) {
     },
     peek() {
       const ctx = getSSRContext();
-      if (ctx)
+      if (ctx) {
+        if (!ctx.discoveredRoutes) {
+          ctx.discoveredRoutes = collectRoutePatterns(routes);
+        }
         return matchRoute(routes, ctx.url);
+      }
       return _current.peek();
     },
     notify() {
@@ -298,5 +319,23 @@ function createRouter(routes, initialUrl, options) {
     searchParams
   };
 }
+function collectRoutePatterns(routes, prefix = "") {
+  const patterns = [];
+  for (const route of routes) {
+    const fullPattern = joinPatterns(prefix, route.pattern);
+    patterns.push(fullPattern);
+    if (route.children) {
+      patterns.push(...collectRoutePatterns(route.children, fullPattern));
+    }
+  }
+  return patterns;
+}
+function joinPatterns(parent, child) {
+  if (!parent || parent === "/")
+    return child;
+  if (child === "/")
+    return parent;
+  return `${parent.replace(/\/$/, "")}/${child.replace(/^\//, "")}`;
+}
 
 export { createRouter };

package/dist/shared/{chunk-hw67ckr3.js → chunk-fs3eec4b.js}

@@ -4,7 +4,10 @@ import {
 import {
   getAdapter,
   isRenderNode
-} from "./chunk-h89w580h.js";
+} from "./chunk-afawz764.js";
+import {
+  isBrowser
+} from "./chunk-14eqne2a.js";
 import {
   _tryOnCleanup,
   batch,
@@ -18,22 +21,89 @@ import {
   setReadValueCallback,
   signal,
   untrack
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/query/cache.ts
 class MemoryCache {
   _store = new Map;
+  _maxSize;
+  _refs = new Map;
+  _orphans = new Map;
+  constructor(options) {
+    const raw = options?.maxSize ?? 1000;
+    this._maxSize = Number.isNaN(raw) ? 1000 : Math.max(0, raw);
+  }
   get(key) {
-    return this._store.get(key);
+    if (!this._store.has(key))
+      return;
+    const value = this._store.get(key);
+    this._store.delete(key);
+    this._store.set(key, value);
+    return value;
   }
   set(key, value) {
+    if (this._store.has(key))
+      this._store.delete(key);
     this._store.set(key, value);
+    while (this._store.size > this._maxSize) {
+      const orphan = this._orphans.keys().next();
+      if (!orphan.done) {
+        if (this._store.has(orphan.value)) {
+          this._store.delete(orphan.value);
+          this._orphans.delete(orphan.value);
+          this._refs.delete(orphan.value);
+          continue;
+        }
+        this._orphans.delete(orphan.value);
+        this._refs.delete(orphan.value);
+        continue;
+      }
+      let evicted = false;
+      for (const k of this._store.keys()) {
+        if (k !== key && !this._refs.has(k)) {
+          this._store.delete(k);
+          evicted = true;
+          break;
+        }
+      }
+      if (evicted)
+        continue;
+      const oldest = this._store.keys().next();
+      if (oldest.done)
+        break;
+      this._store.delete(oldest.value);
+      this._refs.delete(oldest.value);
+      this._orphans.delete(oldest.value);
+    }
   }
   delete(key) {
     this._store.delete(key);
+    this._refs.delete(key);
+    this._orphans.delete(key);
   }
   clear() {
     this._store.clear();
+    this._refs.clear();
+    this._orphans.clear();
+  }
+  retain(key) {
+    const count = (this._refs.get(key) ?? 0) + 1;
+    this._refs.set(key, count);
+    this._orphans.delete(key);
+  }
+  release(key) {
+    const current = this._refs.get(key);
+    if (current === undefined)
+      return;
+    const count = current - 1;
+    if (count <= 0) {
+      this._refs.delete(key);
+      if (this._store.has(key)) {
+        this._orphans.set(key, true);
+      }
+    } else {
+      this._refs.set(key, count);
+    }
   }
 }
 
@@ -73,6 +143,93 @@ function hashString(str) {
   return (hash >>> 0).toString(36);
 }
 
+// src/store/field-selection-tracker.ts
+class FieldSelectionTracker {
+  _selectInfo = new Map;
+  _warned = new Set;
+  _onMiss;
+  constructor(options) {
+    this._onMiss = options?.onMiss;
+  }
+  registerSelect(type, id, fields, querySource) {
+    const key = `${type}:${id}`;
+    let info = this._selectInfo.get(key);
+    if (!info) {
+      info = { fields: new Set, querySources: new Set, fullFetch: false };
+      this._selectInfo.set(key, info);
+    }
+    for (const field of fields) {
+      info.fields.add(field);
+    }
+    info.querySources.add(querySource);
+  }
+  registerFullFetch(type, id) {
+    const key = `${type}:${id}`;
+    let info = this._selectInfo.get(key);
+    if (!info) {
+      info = { fields: new Set, querySources: new Set, fullFetch: true };
+      this._selectInfo.set(key, info);
+    } else {
+      info.fullFetch = true;
+    }
+  }
+  shouldWarn(type, id, field) {
+    const key = `${type}:${id}`;
+    const info = this._selectInfo.get(key);
+    if (!info || info.fullFetch)
+      return false;
+    return !info.fields.has(field);
+  }
+  removeEntity(type, id) {
+    const key = `${type}:${id}`;
+    this._selectInfo.delete(key);
+    const prefix = `${key}:`;
+    for (const warnKey of this._warned) {
+      if (warnKey.startsWith(prefix)) {
+        this._warned.delete(warnKey);
+      }
+    }
+  }
+  createDevProxy(entity, type, id) {
+    const key = `${type}:${id}`;
+    const info = this._selectInfo.get(key);
+    if (!info || info.fullFetch)
+      return entity;
+    const tracker = this;
+    return new Proxy(entity, {
+      get(target, prop, receiver) {
+        if (typeof prop === "string" && !INTERNAL_PROPS.has(prop) && tracker.shouldWarn(type, id, prop)) {
+          const warnKey = `${key}:${prop}`;
+          if (!tracker._warned.has(warnKey)) {
+            tracker._warned.add(warnKey);
+            const sources = [...info.querySources].join(", ");
+            const selectedFields = [...info.fields].sort().join(", ");
+            console.warn(`[vertz] Field "${prop}" was accessed on ${type}#${id} ` + `but was not in the select set.
+` + `        Query: "${sources}"
+` + `        Selected: ${selectedFields}
+` + `        Fix: use {entity.${prop}} in JSX, ` + "or add // @vertz-select-all above the query.");
+            tracker._onMiss?.(type, id, prop, sources);
+          }
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  }
+  clear() {
+    this._selectInfo.clear();
+    this._warned.clear();
+  }
+}
+var INTERNAL_PROPS = new Set([
+  "then",
+  "toJSON",
+  "toString",
+  "valueOf",
+  "constructor",
+  "$$typeof",
+  "__proto__"
+]);
+
 // src/store/relation-registry.ts
 var registry2 = new Map;
 function registerRelationSchema(entityType, schema) {
@@ -241,10 +398,14 @@ class EntityStore {
   _entities = new Map;
   _typeListeners = new Map;
   _queryIndices = new QueryResultIndex;
+  _fieldTracker = null;
   get queryIndices() {
     return this._queryIndices;
   }
   constructor(options) {
+    if (options?.devMode) {
+      this._fieldTracker = new FieldSelectionTracker;
+    }
     if (options?.initialData) {
       this.hydrate(options.initialData);
     }
@@ -261,7 +422,8 @@ class EntityStore {
       base: {},
       layers: new Map,
       refCount: 0,
-      orphanedAt: null
+      orphanedAt: null,
+      lastPlainVisible: null
     };
     this._getOrCreateTypeMap(type).set(id, newEntry);
     return sig;
@@ -275,6 +437,7 @@ class EntityStore {
       return;
     }
     batch(() => {
+      this.evictOrphans();
       for (const item of items) {
         const { normalized, extracted } = normalizeEntity(type, item);
         for (const [nestedType, nestedItems] of extracted) {
@@ -286,6 +449,15 @@ class EntityStore {
       }
     });
   }
+  mergeWithSelect(type, data, selectOptions) {
+    if (this._fieldTracker) {
+      const items = Array.isArray(data) ? data : [data];
+      for (const item of items) {
+        this._fieldTracker.registerSelect(type, item.id, selectOptions.fields, selectOptions.querySource);
+      }
+    }
+    this.merge(type, data);
+  }
   remove(type, id) {
     const typeMap = this._entities.get(type);
     if (!typeMap?.has(id)) {
@@ -297,6 +469,7 @@ class EntityStore {
     }
     typeMap.delete(id);
     this._queryIndices.removeEntity(id);
+    this._fieldTracker?.removeEntity(type, id);
     this._notifyTypeChange(type);
   }
   onTypeChange(type, callback) {
@@ -368,7 +541,7 @@ class EntityStore {
     if (!entry)
       return;
     entry.layers.set(mutationId, patch);
-    this._recomputeVisible(entry);
+    this._recomputeVisible(entry, type, id);
   }
   addRef(type, id) {
     const entry = this._entities.get(type)?.get(id);
@@ -391,12 +564,13 @@ class EntityStore {
   evictOrphans(maxAge = 300000) {
     const now = Date.now();
     let count = 0;
-    for (const [_type, typeMap] of this._entities) {
+    for (const [type, typeMap] of this._entities) {
       for (const [id, entry] of typeMap) {
         if (entry.refCount === 0 && entry.orphanedAt !== null && now - entry.orphanedAt >= maxAge && entry.layers.size === 0) {
           entry.signal.value = undefined;
           typeMap.delete(id);
           this._queryIndices.removeEntity(id);
+          this._fieldTracker?.removeEntity(type, id);
           count++;
         }
       }
@@ -420,7 +594,7 @@ class EntityStore {
     if (!entry)
       return;
     entry.layers.delete(mutationId);
-    this._recomputeVisible(entry);
+    this._recomputeVisible(entry, type, id);
   }
   removeOptimistic(type, id, _mutationId) {
     this.remove(type, id);
@@ -445,7 +619,7 @@ class EntityStore {
     }
     entry.base = normalized;
     entry.layers.delete(mutationId);
-    this._recomputeVisible(entry);
+    this._recomputeVisible(entry, type, id);
   }
   _mergeOne(type, item) {
     const id = item.id;
@@ -455,33 +629,42 @@ class EntityStore {
       const mergedBase = shallowMerge(entry.base, item);
       if (!shallowEqual(entry.base, mergedBase)) {
         entry.base = mergedBase;
-        this._recomputeVisible(entry);
+        this._recomputeVisible(entry, type, id);
       }
     } else {
-      const newSignal = signal(item);
+      const value = this._wrapWithFieldProxy(item, type, id);
+      const newSignal = signal(value);
       const newEntry = {
         signal: newSignal,
         base: item,
         layers: new Map,
         refCount: 0,
-        orphanedAt: null
+        orphanedAt: null,
+        lastPlainVisible: item
       };
       this._getOrCreateTypeMap(type).set(id, newEntry);
       this._notifyTypeChange(type);
     }
   }
-  _recomputeVisible(entry) {
+  _recomputeVisible(entry, type, id) {
     let visible = { ...entry.base };
     for (const patch of entry.layers.values()) {
       visible = shallowMerge(visible, patch);
     }
-    const current = entry.signal.peek();
-    if (current == null || !shallowEqual(current, visible)) {
+    const lastPlain = entry.lastPlainVisible;
+    if (lastPlain == null || !shallowEqual(lastPlain, visible)) {
+      entry.lastPlainVisible = visible;
+      const wrapped = type && id ? this._wrapWithFieldProxy(visible, type, id) : visible;
       untrack(() => {
-        entry.signal.value = visible;
+        entry.signal.value = wrapped;
       });
     }
   }
+  _wrapWithFieldProxy(entity, type, id) {
+    if (!this._fieldTracker)
+      return entity;
+    return this._fieldTracker.createDevProxy(entity, type, id);
+  }
   _getOrCreateTypeMap(type) {
     let typeMap = this._entities.get(type);
     if (!typeMap) {
@@ -705,6 +888,25 @@ function query(source, options = {}) {
   function getCacheKey() {
     return cacheKeyComputed.value;
   }
+  let currentRetainedKey = null;
+  const retainable = "retain" in cache && "release" in cache;
+  function retainKey(key) {
+    if (!retainable)
+      return;
+    if (currentRetainedKey === key)
+      return;
+    if (currentRetainedKey !== null) {
+      cache.release(currentRetainedKey);
+    }
+    cache.retain(key);
+    currentRetainedKey = key;
+  }
+  function releaseCurrentKey() {
+    if (!retainable || currentRetainedKey === null)
+      return;
+    cache.release(currentRetainedKey);
+    currentRetainedKey = null;
+  }
   function callThunkWithCapture() {
     const captured = [];
     const prevCb = setReadValueCallback((v) => captured.push(v));
@@ -782,7 +984,9 @@ function query(source, options = {}) {
     return raw;
   }) : rawData;
   if (initialData !== undefined) {
-    cache.set(getCacheKey(), initialData);
+    const initKey = getCacheKey();
+    cache.set(initKey, initialData);
+    retainKey(initKey);
   }
   const ssrTimeout = options.ssrTimeout ?? getGlobalSSRTimeout() ?? 300;
   if (isSSR() && enabled && ssrTimeout !== 0 && initialData === undefined) {
@@ -829,6 +1033,7 @@ function query(source, options = {}) {
       if (customKey) {
         const cached = cache.get(customKey);
         if (cached !== undefined) {
+          retainKey(customKey);
           normalizeToEntityStore(cached);
           rawData.value = cached;
           loading.value = false;
@@ -881,7 +1086,7 @@ function query(source, options = {}) {
     }, ms);
   }
   let visibilityHandler;
-  if (hasInterval && enabled && !isSSR() && typeof document !== "undefined") {
+  if (hasInterval && enabled && isBrowser()) {
     visibilityHandler = () => {
       if (document.visibilityState === "hidden") {
         intervalPaused = true;
@@ -900,6 +1105,7 @@ function query(source, options = {}) {
       if (id !== fetchId)
         return;
       cache.set(key, result);
+      retainKey(key);
       normalizeToEntityStore(result);
       rawData.value = result;
       loading.value = false;
@@ -937,6 +1143,7 @@ function query(source, options = {}) {
   }
   function refetch() {
     const key = getCacheKey();
+    currentRetainedKey = null;
     cache.delete(key);
     getInflight().delete(key);
     refetchTrigger.value = refetchTrigger.peek() + 1;
@@ -954,6 +1161,7 @@ function query(source, options = {}) {
         if (customKey) {
           const cached = untrack(() => cache.get(customKey));
           if (cached !== undefined) {
+            retainKey(customKey);
             untrack(() => {
               rawData.value = cached;
               loading.value = false;
@@ -967,6 +1175,7 @@ function query(source, options = {}) {
           const derivedKey = untrack(() => getCacheKey());
           const cached = untrack(() => cache.get(derivedKey));
           if (cached !== undefined) {
+            retainKey(derivedKey);
             untrack(() => {
               rawData.value = cached;
               loading.value = false;
@@ -1020,6 +1229,7 @@ function query(source, options = {}) {
       if (shouldCheckCache) {
         const cached = untrack(() => cache.get(key));
         if (cached !== undefined) {
+          retainKey(key);
           promise.catch(() => {});
           untrack(() => {
             rawData.value = cached;
@@ -1058,13 +1268,14 @@ function query(source, options = {}) {
       }
       referencedKeys.clear();
     }
+    releaseCurrentKey();
     disposeFn?.();
     unsubscribeBus?.();
     unregisterFromRegistry?.();
     ssrHydrationCleanup?.();
     clearTimeout(debounceTimer);
     clearTimeout(intervalTimer);
-    if (visibilityHandler && typeof document !== "undefined") {
+    if (visibilityHandler && isBrowser()) {
       document.removeEventListener("visibilitychange", visibilityHandler);
     }
     fetchId++;
@@ -1209,4 +1420,4 @@ function queryMatch(queryResult, handlers) {
   return wrapper;
 }
 
-export { MemoryCache, invalidate, deriveKey, registerRelationSchema, getRelationSchema, resetRelationSchemas_TEST_ONLY, EntityStore, QueryEnvelopeStore, getEntityStore, getQueryEnvelopeStore, getMutationEventBus, query, queryMatch };
+export { MemoryCache, invalidate, deriveKey, FieldSelectionTracker, registerRelationSchema, getRelationSchema, resetRelationSchemas_TEST_ONLY, EntityStore, QueryEnvelopeStore, getEntityStore, getQueryEnvelopeStore, getMutationEventBus, query, queryMatch };

package/dist/shared/{chunk-5dbq8jp9.js → chunk-j09yyh34.js}

@@ -1,7 +1,7 @@
 import {
   computed,
   signal
-} from "./chunk-8hsz5y4a.js";
+} from "./chunk-4fwcwxn6.js";
 
 // src/form/field-state.ts
 function createFieldState(_name, initialValue) {
@@ -31,14 +31,40 @@ function createFieldState(_name, initialValue) {
 function formDataToObject(formData, options) {
   const result = {};
   const coerce = options?.coerce ?? false;
+  const nested = options?.nested ?? false;
   for (const [key, value] of formData.entries()) {
     if (typeof value !== "string") {
       continue;
     }
-    result[key] = coerce ? coerceValue(value) : value;
+    const coerced = coerce ? coerceValue(value) : value;
+    if (nested && key.includes(".")) {
+      setNestedValue(result, key, coerced);
+    } else {
+      result[key] = coerced;
+    }
   }
   return result;
 }
+var DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function setNestedValue(obj, dotPath, value) {
+  const segments = dotPath.split(".");
+  let current = obj;
+  for (let i = 0;i < segments.length - 1; i++) {
+    const segment = segments[i];
+    if (DANGEROUS_KEYS.has(segment))
+      return;
+    const nextSegment = segments[i + 1];
+    const isNextArray = /^\d+$/.test(nextSegment);
+    if (!(segment in current)) {
+      current[segment] = isNextArray ? [] : {};
+    }
+    current = current[segment];
+  }
+  const lastSegment = segments[segments.length - 1];
+  if (DANGEROUS_KEYS.has(lastSegment))
+    return;
+  current[lastSegment] = value;
+}
 function coerceValue(value) {
   if (value === "true")
     return true;
@@ -79,8 +105,11 @@ function validate(schema, data) {
 }
 
 // src/form/form.ts
+var FIELD_STATE_SIGNALS = new Set(["error", "dirty", "touched", "value"]);
+var FIELD_STATE_METHODS = new Set(["setValue", "reset"]);
 function form(sdkMethod, options) {
   const fieldCache = new Map;
+  const chainProxyCache = new Map;
   const submitting = signal(false);
   const fieldGeneration = signal(0);
   const dirty = computed(() => {
@@ -99,20 +128,57 @@ function form(sdkMethod, options) {
     }
     return true;
   });
+  function resolveNestedInitial(dotPath) {
+    const initialObj = typeof options?.initial === "function" ? options.initial() : options?.initial;
+    if (!initialObj)
+      return;
+    const segments = dotPath.split(".");
+    let current = initialObj;
+    for (const segment of segments) {
+      if (current == null || typeof current !== "object")
+        return;
+      current = current[segment];
+    }
+    return current;
+  }
   function getOrCreateField(name) {
     let field = fieldCache.get(name);
     if (!field) {
-      const initialObj = typeof options?.initial === "function" ? options.initial() : options?.initial;
-      const initialValue = initialObj?.[name];
+      const initialValue = name.includes(".") ? resolveNestedInitial(name) : (() => {
+        const initialObj = typeof options?.initial === "function" ? options.initial() : options?.initial;
+        return initialObj?.[name];
+      })();
       field = createFieldState(name, initialValue);
       fieldCache.set(name, field);
       fieldGeneration.value++;
     }
     return field;
   }
+  function getOrCreateChainProxy(dotPath) {
+    let proxy = chainProxyCache.get(dotPath);
+    if (proxy)
+      return proxy;
+    proxy = new Proxy(Object.create(null), {
+      get(_target, prop) {
+        if (typeof prop === "string") {
+          if (FIELD_STATE_SIGNALS.has(prop)) {
+            return getOrCreateField(dotPath)[prop];
+          }
+          if (FIELD_STATE_METHODS.has(prop)) {
+            return getOrCreateField(dotPath)[prop];
+          }
+          const childPath = `${dotPath}.${prop}`;
+          return getOrCreateChainProxy(childPath);
+        }
+        return;
+      }
+    });
+    chainProxyCache.set(dotPath, proxy);
+    return proxy;
+  }
   const resolvedSchema = options?.schema ?? sdkMethod.meta?.bodySchema;
   async function submitPipeline(formData) {
-    const data = formDataToObject(formData);
+    const data = formDataToObject(formData, { nested: true });
     if (resolvedSchema) {
       const result2 = validate(resolvedSchema, data);
       if (!result2.success) {
@@ -227,7 +293,7 @@ function form(sdkMethod, options) {
         if (knownProperties.has(prop)) {
           return target[prop];
         }
-        return getOrCreateField(prop);
+        return getOrCreateChainProxy(prop);
       }
       return Reflect.get(target, prop, receiver);
     }