@vertz/ui 0.2.0 → 0.2.1

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-nmjyj8p9.js

@@ -0,0 +1,290 @@
+import {
+  __classList,
+  __on
+} from "./chunk-v3yyf79g.js";
+import {
+  __append,
+  __element,
+  __enterChildren,
+  __exitChildren,
+  __staticText,
+  getIsHydrating
+} from "./chunk-ryb49346.js";
+import {
+  _tryOnCleanup,
+  createContext,
+  domEffect,
+  popScope,
+  pushScope,
+  runCleanups,
+  signal,
+  untrack,
+  useContext
+} from "./chunk-hrd0mft1.js";
+
+// src/router/link.ts
+function createLink(currentPath, navigate, factoryOptions) {
+  return function Link({
+    href,
+    children,
+    activeClass,
+    className,
+    prefetch
+  }) {
+    const handleClick = (event) => {
+      const mouseEvent = event;
+      if (mouseEvent.ctrlKey || mouseEvent.metaKey || mouseEvent.shiftKey || mouseEvent.altKey) {
+        return;
+      }
+      mouseEvent.preventDefault();
+      navigate(href);
+    };
+    const props = { href };
+    if (className) {
+      props.class = className;
+    }
+    const el = __element("a", props);
+    __on(el, "click", handleClick);
+    __enterChildren(el);
+    if (typeof children === "function") {
+      const result = children();
+      if (typeof result === "string") {
+        __append(el, __staticText(result));
+      } else {
+        __append(el, result);
+      }
+    } else {
+      __append(el, __staticText(children));
+    }
+    __exitChildren();
+    if (activeClass) {
+      __classList(el, {
+        [activeClass]: () => currentPath.value === href
+      });
+    }
+    if (prefetch === "hover" && factoryOptions?.onPrefetch) {
+      let prefetched = false;
+      const triggerPrefetch = () => {
+        if (prefetched)
+          return;
+        prefetched = true;
+        factoryOptions.onPrefetch?.(href);
+      };
+      __on(el, "mouseenter", triggerPrefetch);
+      __on(el, "focus", triggerPrefetch);
+    }
+    return el;
+  };
+}
+
+// src/router/router-context.ts
+var RouterContext = createContext();
+function useRouter() {
+  const router = useContext(RouterContext);
+  if (!router) {
+    throw new Error("useRouter() must be called within RouterContext.Provider");
+  }
+  return router;
+}
+function useParams() {
+  const router = useContext(RouterContext);
+  if (!router) {
+    throw new Error("useParams() must be called within RouterContext.Provider");
+  }
+  return router.current?.params ?? {};
+}
+
+// src/router/outlet.ts
+var OutletContext = createContext();
+function Outlet() {
+  const ctx = useContext(OutletContext);
+  if (!ctx) {
+    return document.createComment("outlet:empty");
+  }
+  const container = __element("div");
+  let childCleanups = [];
+  let renderGen = 0;
+  let isFirstHydrationRender = getIsHydrating();
+  __enterChildren(container);
+  const dispose = domEffect(() => {
+    const factory = ctx.childComponent;
+    untrack(() => {
+      runCleanups(childCleanups);
+      if (isFirstHydrationRender) {
+        isFirstHydrationRender = false;
+      } else {
+        while (container.firstChild) {
+          container.removeChild(container.firstChild);
+        }
+      }
+      const gen = ++renderGen;
+      childCleanups = pushScope();
+      if (factory) {
+        const result = factory();
+        if (result instanceof Promise) {
+          const router = ctx.router;
+          popScope();
+          result.then((mod) => {
+            if (gen !== renderGen)
+              return;
+            childCleanups = pushScope();
+            RouterContext.Provider(router, () => {
+              const node = mod.default();
+              __append(container, node);
+            });
+            popScope();
+          });
+        } else {
+          __append(container, result);
+          popScope();
+        }
+      } else {
+        popScope();
+      }
+    });
+  });
+  __exitChildren();
+  _tryOnCleanup(() => {
+    runCleanups(childCleanups);
+    dispose();
+  });
+  return container;
+}
+
+// src/router/router-view.ts
+function hasViewTransition(doc) {
+  return "startViewTransition" in doc;
+}
+function withTransition(fn) {
+  if (typeof document !== "undefined" && hasViewTransition(document)) {
+    document.startViewTransition(fn);
+  } else {
+    fn();
+  }
+}
+function RouterView({ router, fallback }) {
+  const container = __element("div");
+  let isFirstHydrationRender = getIsHydrating();
+  let renderGen = 0;
+  let pageCleanups = [];
+  let prevLevels = [];
+  __enterChildren(container);
+  const dispose = domEffect(() => {
+    const match = router.current.value;
+    untrack(() => {
+      const gen = ++renderGen;
+      const newMatched = match?.matched ?? [];
+      const minLen = Math.min(prevLevels.length, newMatched.length);
+      let divergeAt = 0;
+      for (divergeAt = 0;divergeAt < minLen; divergeAt++) {
+        if (prevLevels[divergeAt].route !== newMatched[divergeAt].route)
+          break;
+      }
+      if (prevLevels.length > 0 && divergeAt === prevLevels.length && divergeAt === newMatched.length) {
+        return;
+      }
+      if (divergeAt > 0 && newMatched.length > 0) {
+        const newLevels = buildLevels(newMatched);
+        const newChildFactory = buildInsideOutFactory(newMatched, newLevels, divergeAt, router);
+        const parentLevel = prevLevels[divergeAt - 1];
+        if (parentLevel.childSignal) {
+          parentLevel.childSignal.value = newChildFactory;
+        }
+        prevLevels = [...prevLevels.slice(0, divergeAt), ...newLevels.slice(divergeAt)];
+        return;
+      }
+      runCleanups(pageCleanups);
+      const doRender = () => {
+        if (!isFirstHydrationRender) {
+          while (container.firstChild) {
+            container.removeChild(container.firstChild);
+          }
+        }
+        isFirstHydrationRender = false;
+        pageCleanups = pushScope();
+        if (!match) {
+          prevLevels = [];
+          if (fallback) {
+            container.appendChild(fallback());
+          }
+          popScope();
+          return;
+        }
+        const levels = buildLevels(newMatched);
+        const rootFactory = buildInsideOutFactory(newMatched, levels, 0, router);
+        RouterContext.Provider(router, () => {
+          const result = rootFactory();
+          if (result instanceof Promise) {
+            result.then((mod) => {
+              if (gen !== renderGen)
+                return;
+              RouterContext.Provider(router, () => {
+                const node = mod.default();
+                container.appendChild(node);
+              });
+            });
+          } else {
+            __append(container, result);
+          }
+        });
+        prevLevels = levels;
+        popScope();
+      };
+      if (isFirstHydrationRender) {
+        doRender();
+      } else {
+        withTransition(doRender);
+      }
+    });
+  });
+  __exitChildren();
+  _tryOnCleanup(() => {
+    runCleanups(pageCleanups);
+    dispose();
+  });
+  return container;
+}
+function buildLevels(matched) {
+  return matched.map((m, i) => ({
+    childSignal: i < matched.length - 1 ? signal(undefined) : undefined,
+    route: m.route
+  }));
+}
+function buildInsideOutFactory(matched, levels, startAt, router) {
+  let factory = matched[matched.length - 1].route.component;
+  for (let i = matched.length - 2;i >= startAt; i--) {
+    const level = levels[i];
+    const childFactory = factory;
+    level.childSignal.value = childFactory;
+    const parentRoute = level.route;
+    const cs = level.childSignal;
+    factory = () => {
+      let result;
+      OutletContext.Provider({ childComponent: cs, router }, () => {
+        result = parentRoute.component();
+      });
+      return result;
+    };
+  }
+  return factory;
+}
+
+// src/router/search-params.ts
+function parseSearchParams(urlParams, schema) {
+  const raw = {};
+  for (const [key, value] of urlParams.entries()) {
+    raw[key] = value;
+  }
+  if (schema) {
+    const result = schema.parse(raw);
+    if (result.ok)
+      return result.data;
+    return raw;
+  }
+  return raw;
+}
+function useSearchParams(searchSignal) {
+  return searchSignal.value;
+}
+
+export { createLink, RouterContext, useRouter, useParams, OutletContext, Outlet, RouterView, parseSearchParams, useSearchParams };