@vertz/ui 0.2.0 → 0.2.2

package/dist/shared/{chunk-pgymxpn1.js → chunk-hrd0mft1.js}

@@ -1,11 +1,76 @@
 // src/component/context.ts
 var currentScope = null;
+function isSignalLike(value) {
+  return value != null && typeof value === "object" && "peek" in value && typeof value.peek === "function";
+}
+function wrapSignalProps(value) {
+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const source = value;
+  const keys = Object.keys(source);
+  let hasSignal = false;
+  for (const key of keys) {
+    if (isSignalLike(source[key])) {
+      hasSignal = true;
+      break;
+    }
+  }
+  if (!hasSignal)
+    return value;
+  const wrapped = {};
+  for (const key of keys) {
+    const propValue = source[key];
+    if (isSignalLike(propValue)) {
+      Object.defineProperty(wrapped, key, {
+        get() {
+          return propValue.value;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    } else {
+      wrapped[key] = propValue;
+    }
+  }
+  return wrapped;
+}
 function asKey(ctx) {
   return ctx;
 }
-function createContext(defaultValue) {
+var REGISTRY_KEY = "__VERTZ_CTX_REG__";
+var contextRegistry = globalThis[REGISTRY_KEY] ?? (() => {
+  const m = new Map;
+  globalThis[REGISTRY_KEY] = m;
+  return m;
+})();
+function createContext(defaultValue, __stableId) {
+  if (__stableId) {
+    const existing = contextRegistry.get(__stableId);
+    if (existing)
+      return existing;
+  }
   const ctx = {
-    Provider(value, fn) {
+    Provider(valueOrProps, fn) {
+      if (fn !== undefined) {
+        const value2 = wrapSignalProps(valueOrProps);
+        const parentScope2 = currentScope;
+        const scope2 = parentScope2 ? new Map(parentScope2) : new Map;
+        scope2.set(asKey(ctx), value2);
+        ctx._stack.push(value2);
+        const prevScope2 = currentScope;
+        currentScope = scope2;
+        try {
+          fn();
+        } finally {
+          ctx._stack.pop();
+          currentScope = prevScope2;
+        }
+        return;
+      }
+      const props = valueOrProps;
+      const { value: rawValue, children } = props;
+      const value = wrapSignalProps(rawValue);
       const parentScope = currentScope;
       const scope = parentScope ? new Map(parentScope) : new Map;
       scope.set(asKey(ctx), value);
@@ -13,7 +78,11 @@ function createContext(defaultValue) {
       const prevScope = currentScope;
       currentScope = scope;
       try {
-        fn();
+        const result = typeof children === "function" ? children() : children;
+        if (typeof process !== "undefined" && true && Array.isArray(result)) {
+          throw new Error("Context.Provider JSX children must have a single root element. " + "Wrap multiple children in a fragment: <><Child1 /><Child2 /></>");
+        }
+        return result;
       } finally {
         ctx._stack.pop();
         currentScope = prevScope;
@@ -22,6 +91,9 @@ function createContext(defaultValue) {
     _default: defaultValue,
     _stack: []
   };
+  if (__stableId) {
+    contextRegistry.set(__stableId, ctx);
+  }
   return ctx;
 }
 function useContext(ctx) {
@@ -46,7 +118,7 @@ function setContextScope(scope) {
 // src/runtime/disposal.ts
 class DisposalScopeError extends Error {
   constructor() {
-    super("onCleanup() must be called within a disposal scope (e.g., inside effect(), watch(), onMount(), or a pushScope()/popScope() block). " + "Called outside a scope, the cleanup callback would be silently discarded.");
+    super("onCleanup() must be called within a disposal scope (e.g., inside domEffect(), lifecycleEffect(), onMount(), or a pushScope()/popScope() block). " + "Called outside a scope, the cleanup callback would be silently discarded.");
     this.name = "DisposalScopeError";
   }
 }
@@ -79,6 +151,35 @@ function runCleanups(cleanups) {
   cleanups.length = 0;
 }
 
+// src/runtime/tracking.ts
+var currentSubscriber = null;
+var readValueCallback = null;
+function getSubscriber() {
+  return currentSubscriber;
+}
+function setSubscriber(sub) {
+  const prev = currentSubscriber;
+  currentSubscriber = sub;
+  return prev;
+}
+function getReadValueCallback() {
+  return readValueCallback;
+}
+function setReadValueCallback(cb) {
+  const prev = readValueCallback;
+  readValueCallback = cb;
+  return prev;
+}
+function untrack(fn) {
+  const prev = currentSubscriber;
+  currentSubscriber = null;
+  try {
+    return fn();
+  } finally {
+    currentSubscriber = prev;
+  }
+}
+
 // src/runtime/scheduler.ts
 var batchDepth = 0;
 var pendingEffects = new Map;
@@ -114,36 +215,18 @@ function batch(fn) {
   }
 }
 
-// src/runtime/tracking.ts
-var currentSubscriber = null;
-var readValueCallback = null;
-function getSubscriber() {
-  return currentSubscriber;
-}
-function setSubscriber(sub) {
-  const prev = currentSubscriber;
-  currentSubscriber = sub;
-  return prev;
+// src/runtime/signal.ts
+function isSSR() {
+  const check = typeof globalThis !== "undefined" && globalThis.__VERTZ_IS_SSR__;
+  return typeof check === "function" ? check() : false;
 }
-function getReadValueCallback() {
-  return readValueCallback;
+var signalCollectorStack = [];
+function startSignalCollection() {
+  signalCollectorStack.push([]);
 }
-function setReadValueCallback(cb) {
-  const prev = readValueCallback;
-  readValueCallback = cb;
-  return prev;
-}
-function untrack(fn) {
-  const prev = currentSubscriber;
-  currentSubscriber = null;
-  try {
-    return fn();
-  } finally {
-    currentSubscriber = prev;
-  }
+function stopSignalCollection() {
+  return signalCollectorStack.pop() ?? [];
 }
-
-// src/runtime/signal.ts
 var nextId = 0;
 
 class SignalImpl {
@@ -185,7 +268,12 @@ class SignalImpl {
   }
 }
 function signal(initial) {
-  return new SignalImpl(initial);
+  const s = new SignalImpl(initial);
+  const collector = signalCollectorStack[signalCollectorStack.length - 1];
+  if (collector) {
+    collector.push(s);
+  }
+  return s;
 }
 class ComputedImpl {
   _id;
@@ -297,7 +385,21 @@ class EffectImpl {
     this._contextScope = null;
   }
 }
-function effect(fn) {
+function domEffect(fn) {
+  if (isSSR()) {
+    fn();
+    return () => {};
+  }
+  const eff = new EffectImpl(fn);
+  eff._run();
+  const dispose = () => eff._dispose();
+  _tryOnCleanup(dispose);
+  return dispose;
+}
+function lifecycleEffect(fn) {
+  if (isSSR()) {
+    return () => {};
+  }
   const eff = new EffectImpl(fn);
   eff._run();
   const dispose = () => eff._dispose();
@@ -305,4 +407,4 @@ function effect(fn) {
   return dispose;
 }
 
-export { createContext, useContext, DisposalScopeError, onCleanup, _tryOnCleanup, pushScope, popScope, runCleanups, batch, setReadValueCallback, untrack, signal, computed, effect };
+export { createContext, useContext, getContextScope, setContextScope, DisposalScopeError, onCleanup, _tryOnCleanup, pushScope, popScope, runCleanups, setReadValueCallback, untrack, batch, startSignalCollection, stopSignalCollection, signal, computed, domEffect, lifecycleEffect };

package/dist/shared/chunk-jrtrk5z4.js

@@ -0,0 +1,125 @@
+// src/router/server-nav.ts
+function parseSSE(buffer) {
+  const events = [];
+  const blocks = buffer.split(`
+
+`);
+  const remaining = blocks.pop() ?? "";
+  for (const block of blocks) {
+    if (block.trim() === "")
+      continue;
+    let type = "";
+    let data = "";
+    for (const line of block.split(`
+`)) {
+      if (line.startsWith("event: ")) {
+        type = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        data = line.slice(6);
+      }
+    }
+    if (type) {
+      events.push({ type, data });
+    }
+  }
+  return { events, remaining };
+}
+function ensureSSRDataBus() {
+  const g = globalThis;
+  g.__VERTZ_SSR_DATA__ = [];
+  g.__VERTZ_SSR_PUSH__ = (key, data) => {
+    g.__VERTZ_SSR_DATA__.push({ key, data });
+    document.dispatchEvent(new CustomEvent("vertz:ssr-data", { detail: { key, data } }));
+  };
+}
+function pushNavData(key, data) {
+  const push = globalThis.__VERTZ_SSR_PUSH__;
+  if (typeof push === "function") {
+    push(key, data);
+  }
+}
+function isNavPrefetchActive() {
+  return globalThis.__VERTZ_NAV_PREFETCH_ACTIVE__ === true;
+}
+function setNavPrefetchActive(active) {
+  globalThis.__VERTZ_NAV_PREFETCH_ACTIVE__ = active;
+}
+function dispatchPrefetchDone() {
+  setNavPrefetchActive(false);
+  document.dispatchEvent(new CustomEvent("vertz:nav-prefetch-done"));
+}
+var prefetchGen = 0;
+function prefetchNavData(url, options) {
+  const controller = new AbortController;
+  const timeout = options?.timeout ?? 5000;
+  const gen = ++prefetchGen;
+  ensureSSRDataBus();
+  setNavPrefetchActive(true);
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  let resolveFirstEvent = null;
+  const firstEvent = new Promise((r) => {
+    resolveFirstEvent = r;
+  });
+  function onFirstEvent() {
+    if (resolveFirstEvent) {
+      resolveFirstEvent();
+      resolveFirstEvent = null;
+    }
+  }
+  function finishIfCurrent() {
+    if (gen === prefetchGen) {
+      dispatchPrefetchDone();
+    }
+  }
+  const done = fetch(url, {
+    headers: { "X-Vertz-Nav": "1" },
+    signal: controller.signal
+  }).then(async (response) => {
+    if (!response.body) {
+      onFirstEvent();
+      finishIfCurrent();
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    while (true) {
+      const { done: streamDone, value } = await reader.read();
+      if (streamDone)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const parsed = parseSSE(buffer);
+      buffer = parsed.remaining;
+      for (const event of parsed.events) {
+        onFirstEvent();
+        if (event.type === "data") {
+          try {
+            const { key, data } = JSON.parse(event.data);
+            pushNavData(key, data);
+          } catch {}
+        } else if (event.type === "done") {
+          finishIfCurrent();
+          clearTimeout(timeoutId);
+          return;
+        }
+      }
+    }
+    onFirstEvent();
+    finishIfCurrent();
+  }).catch(() => {
+    onFirstEvent();
+    finishIfCurrent();
+  }).finally(() => {
+    clearTimeout(timeoutId);
+  });
+  return {
+    abort: () => {
+      controller.abort();
+      clearTimeout(timeoutId);
+    },
+    done,
+    firstEvent
+  };
+}
+
+export { isNavPrefetchActive, prefetchNavData };

package/dist/shared/chunk-ka5ked7n.js

@@ -0,0 +1,188 @@
+import {
+  executeLoaders,
+  matchRoute
+} from "./chunk-9e92w0wt.js";
+import {
+  prefetchNavData
+} from "./chunk-jrtrk5z4.js";
+import {
+  signal
+} from "./chunk-hrd0mft1.js";
+
+// src/router/navigate.ts
+var DEFAULT_NAV_THRESHOLD_MS = 500;
+function createRouter(routes, initialUrl, options) {
+  const isSSR = typeof window === "undefined" || typeof globalThis.__SSR_URL__ !== "undefined";
+  let url;
+  if (initialUrl) {
+    url = initialUrl;
+  } else if (isSSR) {
+    url = globalThis.__SSR_URL__ || "/";
+  } else {
+    url = window.location.pathname + window.location.search;
+  }
+  const initialMatch = matchRoute(routes, url);
+  function normalizeUrl(rawUrl) {
+    const qIdx = rawUrl.indexOf("?");
+    if (qIdx === -1)
+      return rawUrl;
+    const pathname = rawUrl.slice(0, qIdx);
+    const params = new URLSearchParams(rawUrl.slice(qIdx + 1));
+    params.sort();
+    const sorted = params.toString();
+    return sorted ? `${pathname}?${sorted}` : pathname;
+  }
+  const visitedUrls = new Set;
+  if (initialMatch)
+    visitedUrls.add(normalizeUrl(url));
+  const current = signal(initialMatch);
+  const loaderData = signal([]);
+  const loaderError = signal(null);
+  const searchParams = signal(initialMatch?.search ?? {});
+  let navigationGen = 0;
+  let navigateGen = 0;
+  let currentAbort = null;
+  const serverNavEnabled = !!options?.serverNav;
+  const serverNavTimeout = typeof options?.serverNav === "object" ? options.serverNav.timeout : undefined;
+  const prefetchFn = options?._prefetchNavData ?? (serverNavEnabled ? prefetchNavData : null);
+  let activePrefetch = null;
+  let activePrefetchUrl = null;
+  function startPrefetch(navUrl) {
+    if (!serverNavEnabled || !prefetchFn)
+      return null;
+    const normalized = normalizeUrl(navUrl);
+    if (activePrefetch && activePrefetchUrl === normalized) {
+      return activePrefetch;
+    }
+    if (activePrefetch) {
+      activePrefetch.abort();
+    }
+    const prefetchOpts = {};
+    if (serverNavTimeout !== undefined) {
+      prefetchOpts.timeout = serverNavTimeout;
+    }
+    activePrefetch = prefetchFn(navUrl, prefetchOpts);
+    activePrefetchUrl = normalized;
+    return activePrefetch;
+  }
+  async function awaitPrefetch(handle) {
+    const target = handle?.firstEvent ?? handle?.done;
+    if (!target)
+      return;
+    await Promise.race([target, new Promise((r) => setTimeout(r, DEFAULT_NAV_THRESHOLD_MS))]);
+  }
+  if (isSSR) {
+    const g = globalThis;
+    const prev = g.__VERTZ_SSR_SYNC_ROUTER__;
+    g.__VERTZ_SSR_SYNC_ROUTER__ = (ssrUrl) => {
+      if (typeof prev === "function")
+        prev(ssrUrl);
+      const match = matchRoute(routes, ssrUrl);
+      current.value = match;
+      searchParams.value = match?.search ?? {};
+    };
+  }
+  if (initialMatch) {
+    const gen = ++navigationGen;
+    const abort = new AbortController;
+    currentAbort = abort;
+    runLoaders(initialMatch, gen, abort.signal).catch(() => {});
+  }
+  async function runLoaders(match, gen, abortSignal) {
+    try {
+      loaderError.value = null;
+      const results = await executeLoaders(match.matched, match.params, abortSignal);
+      if (gen === navigationGen) {
+        loaderData.value = results;
+      }
+    } catch (err) {
+      if (gen === navigationGen) {
+        loaderError.value = err instanceof Error ? err : new Error(String(err));
+      }
+    }
+  }
+  async function applyNavigation(url2) {
+    if (currentAbort) {
+      currentAbort.abort();
+    }
+    const gen = ++navigationGen;
+    const abort = new AbortController;
+    currentAbort = abort;
+    const match = matchRoute(routes, url2);
+    current.value = match;
+    if (match) {
+      visitedUrls.add(normalizeUrl(url2));
+      searchParams.value = match.search;
+      await runLoaders(match, gen, abort.signal);
+    } else {
+      searchParams.value = {};
+      if (gen === navigationGen) {
+        loaderData.value = [];
+        loaderError.value = null;
+      }
+    }
+  }
+  async function navigate(navUrl, navOptions) {
+    const gen = ++navigateGen;
+    const handle = startPrefetch(navUrl);
+    if (!isSSR) {
+      if (navOptions?.replace) {
+        window.history.replaceState(null, "", navUrl);
+      } else {
+        window.history.pushState(null, "", navUrl);
+      }
+    }
+    const isCachedNav = visitedUrls.has(normalizeUrl(navUrl));
+    if (!isCachedNav && (handle?.firstEvent || handle?.done)) {
+      await awaitPrefetch(handle);
+    }
+    if (gen !== navigateGen)
+      return;
+    await applyNavigation(navUrl);
+  }
+  async function revalidate() {
+    const match = current.value;
+    if (match) {
+      if (currentAbort) {
+        currentAbort.abort();
+      }
+      const gen = ++navigationGen;
+      const abort = new AbortController;
+      currentAbort = abort;
+      await runLoaders(match, gen, abort.signal);
+    }
+  }
+  let onPopState = null;
+  if (!isSSR) {
+    onPopState = () => {
+      const popUrl = window.location.pathname + window.location.search;
+      startPrefetch(popUrl);
+      applyNavigation(popUrl).catch(() => {});
+    };
+    window.addEventListener("popstate", onPopState);
+  }
+  function dispose() {
+    if (onPopState) {
+      window.removeEventListener("popstate", onPopState);
+    }
+    if (currentAbort) {
+      currentAbort.abort();
+    }
+    if (activePrefetch) {
+      activePrefetch.abort();
+      activePrefetch = null;
+      activePrefetchUrl = null;
+    }
+  }
+  return {
+    current,
+    dispose,
+    loaderData,
+    loaderError,
+    navigate,
+    revalidate,
+    searchParams
+  };
+}
+
+export { createRouter };