@vertz/ui 0.2.0 → 0.2.2

package/dist/shared/chunk-0xcmwgdb.js

@@ -0,0 +1,288 @@
+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
+var DANGEROUS_SCHEMES = ["javascript:", "data:", "vbscript:"];
+function isSafeUrl(url) {
+  const normalized = url.replace(/\s/g, "").toLowerCase();
+  if (normalized.startsWith("//"))
+    return false;
+  for (const scheme of DANGEROUS_SCHEMES) {
+    if (normalized.startsWith(scheme))
+      return false;
+  }
+  return true;
+}
+function createLink(currentPath, navigate, factoryOptions) {
+  return function Link({
+    href,
+    children,
+    activeClass,
+    className,
+    prefetch
+  }) {
+    const safeHref = isSafeUrl(href) ? href : "#";
+    const handleClick = (event) => {
+      const mouseEvent = event;
+      if (mouseEvent.ctrlKey || mouseEvent.metaKey || mouseEvent.shiftKey || mouseEvent.altKey) {
+        return;
+      }
+      mouseEvent.preventDefault();
+      navigate(safeHref);
+    };
+    const props = { href: safeHref };
+    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 === safeHref
+      });
+    }
+    if (prefetch === "hover" && factoryOptions?.onPrefetch) {
+      let prefetched = false;
+      const triggerPrefetch = () => {
+        if (prefetched)
+          return;
+        prefetched = true;
+        factoryOptions.onPrefetch?.(safeHref);
+      };
+      __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 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();
+      };
+      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 };

package/dist/shared/{chunk-j8vzvne3.js → chunk-9e92w0wt.js}

@@ -67,7 +67,10 @@ function matchRoute(routes, url) {
       for (const [key, value] of searchParams.entries()) {
         raw[key] = value;
       }
-      search = m.route.searchParams.parse(raw);
+      const parseResult = m.route.searchParams.parse(raw);
+      if (parseResult.ok) {
+        search = parseResult.data;
+      }
       break;
     }
   }

package/dist/shared/chunk-g4rch80a.js

@@ -0,0 +1,33 @@
+// src/dom/dom-adapter.ts
+function createDOMAdapter() {
+  return {
+    createElement: (tag) => document.createElement(tag),
+    createElementNS: (ns, tag) => document.createElementNS(ns, tag),
+    createTextNode: (text) => document.createTextNode(text),
+    createComment: (text) => document.createComment(text),
+    createDocumentFragment: () => document.createDocumentFragment(),
+    isNode: (value) => typeof Node !== "undefined" && value instanceof Node
+  };
+}
+
+// src/dom/adapter.ts
+var RENDER_NODE_BRAND = Symbol.for("vertz:render-node");
+function isRenderNode(value) {
+  if (value == null || typeof value !== "object")
+    return false;
+  if (RENDER_NODE_BRAND in value)
+    return true;
+  return typeof Node !== "undefined" && value instanceof Node;
+}
+var currentAdapter = null;
+function getAdapter() {
+  if (!currentAdapter) {
+    currentAdapter = createDOMAdapter();
+  }
+  return currentAdapter;
+}
+function setAdapter(adapter) {
+  currentAdapter = adapter;
+}
+
+export { createDOMAdapter, RENDER_NODE_BRAND, isRenderNode, getAdapter, setAdapter };