@vertz/ui 0.2.0

package/dist/shared/chunk-j8vzvne3.js

@@ -0,0 +1,153 @@
+// src/router/matcher.ts
+function splitPath(path) {
+  const trimmed = path.replace(/^\/+|\/+$/g, "");
+  if (trimmed === "")
+    return [];
+  return trimmed.split("/");
+}
+function matchPath(pattern, path) {
+  const patternSegments = splitPath(pattern);
+  const pathSegments = splitPath(path);
+  const params = {};
+  for (let i = 0;i < patternSegments.length; i++) {
+    const seg = patternSegments[i];
+    if (seg === "*") {
+      params["*"] = pathSegments.slice(i).join("/");
+      return { params, path };
+    }
+    if (i >= pathSegments.length) {
+      return null;
+    }
+    const pathSeg = pathSegments[i];
+    if (seg.startsWith(":")) {
+      if (pathSeg === "")
+        return null;
+      params[seg.slice(1)] = pathSeg;
+    } else {
+      if (seg !== pathSeg)
+        return null;
+    }
+  }
+  if (pathSegments.length > patternSegments.length) {
+    return null;
+  }
+  return { params, path };
+}
+
+// src/router/define-routes.ts
+function defineRoutes(map) {
+  const routes = [];
+  for (const [pattern, config] of Object.entries(map)) {
+    const compiled = {
+      component: config.component,
+      errorComponent: config.errorComponent,
+      loader: config.loader,
+      pattern,
+      searchParams: config.searchParams
+    };
+    if (config.children) {
+      compiled.children = defineRoutes(config.children);
+    }
+    routes.push(compiled);
+  }
+  return routes;
+}
+function matchRoute(routes, url) {
+  const [pathname, queryString] = splitUrl(url);
+  const searchParams = new URLSearchParams(queryString);
+  const matched = [];
+  const allParams = {};
+  const leaf = matchRouteRecursive(routes, pathname, matched, allParams);
+  if (!leaf)
+    return null;
+  let search = {};
+  for (const m of matched) {
+    if (m.route.searchParams) {
+      const raw = {};
+      for (const [key, value] of searchParams.entries()) {
+        raw[key] = value;
+      }
+      search = m.route.searchParams.parse(raw);
+      break;
+    }
+  }
+  return {
+    matched,
+    params: allParams,
+    route: leaf,
+    search,
+    searchParams
+  };
+}
+function splitUrl(url) {
+  const qIndex = url.indexOf("?");
+  if (qIndex === -1)
+    return [url, ""];
+  return [url.slice(0, qIndex), url.slice(qIndex + 1)];
+}
+function matchRouteRecursive(routes, pathname, matched, allParams) {
+  for (const route of routes) {
+    if (route.children && route.children.length > 0) {
+      const prefixResult = matchPrefix(route.pattern, pathname);
+      if (prefixResult) {
+        matched.push({ params: prefixResult.params, route });
+        Object.assign(allParams, prefixResult.params);
+        const childResult = matchRouteRecursive(route.children, prefixResult.remaining, matched, allParams);
+        if (childResult)
+          return childResult;
+        matched.pop();
+        for (const key of Object.keys(prefixResult.params)) {
+          delete allParams[key];
+        }
+      }
+    } else {
+      const result = matchPath(route.pattern, pathname);
+      if (result) {
+        matched.push({ params: result.params, route });
+        Object.assign(allParams, result.params);
+        return route;
+      }
+    }
+  }
+  return null;
+}
+function matchPrefix(pattern, pathname) {
+  const patternSegments = splitSegments(pattern);
+  const pathSegments = splitSegments(pathname);
+  if (patternSegments.length > pathSegments.length)
+    return null;
+  const params = {};
+  for (let i = 0;i < patternSegments.length; i++) {
+    const pSeg = patternSegments[i];
+    const uSeg = pathSegments[i];
+    if (pSeg.startsWith(":")) {
+      if (uSeg === "")
+        return null;
+      params[pSeg.slice(1)] = uSeg;
+    } else if (pSeg !== uSeg) {
+      return null;
+    }
+  }
+  const remainingSegments = pathSegments.slice(patternSegments.length);
+  const remaining = `/${remainingSegments.join("/")}`;
+  return { params, remaining };
+}
+function splitSegments(path) {
+  const trimmed = path.replace(/^\/+|\/+$/g, "");
+  if (trimmed === "")
+    return [];
+  return trimmed.split("/");
+}
+
+// src/router/loader.ts
+async function executeLoaders(matched, params, signal) {
+  const loaderSignal = signal ?? new AbortController().signal;
+  const promises = matched.map((m) => {
+    if (!m.route.loader)
+      return Promise.resolve(undefined);
+    return Promise.resolve(m.route.loader({ params, signal: loaderSignal }));
+  });
+  return Promise.all(promises);
+}
+
+export { matchPath, defineRoutes, matchRoute, executeLoaders };

package/dist/shared/chunk-pgymxpn1.js

@@ -0,0 +1,308 @@
+// src/component/context.ts
+var currentScope = null;
+function asKey(ctx) {
+  return ctx;
+}
+function createContext(defaultValue) {
+  const ctx = {
+    Provider(value, fn) {
+      const parentScope = currentScope;
+      const scope = parentScope ? new Map(parentScope) : new Map;
+      scope.set(asKey(ctx), value);
+      ctx._stack.push(value);
+      const prevScope = currentScope;
+      currentScope = scope;
+      try {
+        fn();
+      } finally {
+        ctx._stack.pop();
+        currentScope = prevScope;
+      }
+    },
+    _default: defaultValue,
+    _stack: []
+  };
+  return ctx;
+}
+function useContext(ctx) {
+  if (ctx._stack.length > 0) {
+    return ctx._stack[ctx._stack.length - 1];
+  }
+  const key = asKey(ctx);
+  if (currentScope?.has(key)) {
+    return currentScope.get(key);
+  }
+  return ctx._default;
+}
+function getContextScope() {
+  return currentScope;
+}
+function setContextScope(scope) {
+  const prev = currentScope;
+  currentScope = scope;
+  return prev;
+}
+
+// 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.");
+    this.name = "DisposalScopeError";
+  }
+}
+var cleanupStack = [];
+function onCleanup(fn) {
+  const current = cleanupStack[cleanupStack.length - 1];
+  if (!current) {
+    throw new DisposalScopeError;
+  }
+  current.push(fn);
+}
+function _tryOnCleanup(fn) {
+  const current = cleanupStack[cleanupStack.length - 1];
+  if (current) {
+    current.push(fn);
+  }
+}
+function pushScope() {
+  const scope = [];
+  cleanupStack.push(scope);
+  return scope;
+}
+function popScope() {
+  cleanupStack.pop();
+}
+function runCleanups(cleanups) {
+  for (let i = cleanups.length - 1;i >= 0; i--) {
+    cleanups[i]?.();
+  }
+  cleanups.length = 0;
+}
+
+// src/runtime/scheduler.ts
+var batchDepth = 0;
+var pendingEffects = new Map;
+function scheduleNotify(subscriber) {
+  if (!subscriber._isEffect) {
+    subscriber._notify();
+    return;
+  }
+  if (batchDepth > 0) {
+    pendingEffects.set(subscriber._id, subscriber);
+  } else {
+    subscriber._notify();
+  }
+}
+function flush() {
+  while (pendingEffects.size > 0) {
+    const queue = [...pendingEffects.values()];
+    pendingEffects.clear();
+    for (const sub of queue) {
+      sub._notify();
+    }
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flush();
+    }
+  }
+}
+
+// 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/signal.ts
+var nextId = 0;
+
+class SignalImpl {
+  _value;
+  _subscribers = new Set;
+  constructor(initial) {
+    this._value = initial;
+  }
+  get value() {
+    const sub = getSubscriber();
+    if (sub) {
+      this._subscribers.add(sub);
+      sub._addSource(this);
+      const cb = getReadValueCallback();
+      if (cb)
+        cb(this._value);
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    if (Object.is(this._value, newValue)) {
+      return;
+    }
+    this._value = newValue;
+    this._notifySubscribers();
+  }
+  peek() {
+    return this._value;
+  }
+  notify() {
+    this._notifySubscribers();
+  }
+  _notifySubscribers() {
+    batch(() => {
+      for (const sub of this._subscribers) {
+        scheduleNotify(sub);
+      }
+    });
+  }
+}
+function signal(initial) {
+  return new SignalImpl(initial);
+}
+class ComputedImpl {
+  _id;
+  _isEffect = false;
+  _fn;
+  _cachedValue;
+  _state = 1 /* Dirty */;
+  _subscribers = new Set;
+  _sources = new Set;
+  constructor(fn) {
+    this._id = nextId++;
+    this._fn = fn;
+  }
+  get value() {
+    const sub = getSubscriber();
+    if (sub) {
+      this._subscribers.add(sub);
+      sub._addSource(this);
+    }
+    if (this._state !== 0 /* Clean */) {
+      this._compute();
+    }
+    return this._cachedValue;
+  }
+  peek() {
+    if (this._state !== 0 /* Clean */) {
+      this._compute();
+    }
+    return this._cachedValue;
+  }
+  _addSource(source) {
+    this._sources.add(source);
+  }
+  _compute() {
+    this._state = 2 /* Computing */;
+    this._clearSources();
+    const prev = setSubscriber(this);
+    try {
+      const newValue = this._fn();
+      if (!Object.is(this._cachedValue, newValue)) {
+        this._cachedValue = newValue;
+      }
+    } finally {
+      setSubscriber(prev);
+      this._state = 0 /* Clean */;
+    }
+  }
+  _clearSources() {
+    for (const source of this._sources) {
+      source._subscribers.delete(this);
+    }
+    this._sources.clear();
+  }
+  _notify() {
+    if (this._state === 1 /* Dirty */) {
+      return;
+    }
+    this._state = 1 /* Dirty */;
+    for (const sub of this._subscribers) {
+      scheduleNotify(sub);
+    }
+  }
+}
+function computed(fn) {
+  return new ComputedImpl(fn);
+}
+
+class EffectImpl {
+  _id;
+  _isEffect = true;
+  _fn;
+  _disposed = false;
+  _sources = new Set;
+  _contextScope;
+  constructor(fn) {
+    this._id = nextId++;
+    this._fn = fn;
+    this._contextScope = getContextScope();
+  }
+  _addSource(source) {
+    this._sources.add(source);
+  }
+  _notify() {
+    if (this._disposed) {
+      return;
+    }
+    this._run();
+  }
+  _run() {
+    this._clearSources();
+    const prev = setSubscriber(this);
+    const prevCtx = setContextScope(this._contextScope);
+    try {
+      this._fn();
+    } finally {
+      setContextScope(prevCtx);
+      setSubscriber(prev);
+    }
+  }
+  _clearSources() {
+    for (const source of this._sources) {
+      source._subscribers.delete(this);
+    }
+    this._sources.clear();
+  }
+  _dispose() {
+    this._disposed = true;
+    this._clearSources();
+    this._contextScope = null;
+  }
+}
+function effect(fn) {
+  const eff = new EffectImpl(fn);
+  eff._run();
+  const dispose = () => eff._dispose();
+  _tryOnCleanup(dispose);
+  return dispose;
+}
+
+export { createContext, useContext, DisposalScopeError, onCleanup, _tryOnCleanup, pushScope, popScope, runCleanups, batch, setReadValueCallback, untrack, signal, computed, effect };

package/dist/shared/chunk-tsdpgmks.js

@@ -0,0 +1,98 @@
+import {
+  signal
+} from "./chunk-pgymxpn1.js";
+
+// src/form/form-data.ts
+function formDataToObject(formData, options) {
+  const result = {};
+  const coerce = options?.coerce ?? false;
+  for (const [key, value] of formData.entries()) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    result[key] = coerce ? coerceValue(value) : value;
+  }
+  return result;
+}
+function coerceValue(value) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value !== "" && !Number.isNaN(Number(value))) {
+    return Number(value);
+  }
+  return value;
+}
+
+// src/form/validation.ts
+function validate(schema, data) {
+  try {
+    const parsed = schema.parse(data);
+    return { success: true, data: parsed, errors: {} };
+  } catch (err) {
+    if (err instanceof Error) {
+      const fieldErrors = err.fieldErrors;
+      if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+        return { success: false, data: undefined, errors: fieldErrors };
+      }
+      return { success: false, data: undefined, errors: { _form: err.message } };
+    }
+    return { success: false, data: undefined, errors: { _form: "Validation failed" } };
+  }
+}
+
+// src/form/form.ts
+function form(sdkMethod, options) {
+  const submitting = signal(false);
+  const errors = signal({});
+  return {
+    attrs() {
+      return {
+        action: sdkMethod.url,
+        method: sdkMethod.method
+      };
+    },
+    submitting,
+    handleSubmit(callbacks) {
+      return async (formDataOrEvent) => {
+        let formData;
+        if (formDataOrEvent instanceof Event) {
+          formDataOrEvent.preventDefault();
+          const target = formDataOrEvent.target;
+          formData = new FormData(target);
+        } else {
+          formData = formDataOrEvent;
+        }
+        const data = formDataToObject(formData);
+        const result = validate(options.schema, data);
+        if (!result.success) {
+          errors.value = result.errors;
+          callbacks?.onError?.(result.errors);
+          return;
+        }
+        errors.value = {};
+        submitting.value = true;
+        let response;
+        try {
+          response = await sdkMethod(result.data);
+        } catch (err) {
+          submitting.value = false;
+          const message = err instanceof Error ? err.message : "Submission failed";
+          const serverErrors = { _form: message };
+          errors.value = serverErrors;
+          callbacks?.onError?.(serverErrors);
+          return;
+        }
+        submitting.value = false;
+        callbacks?.onSuccess?.(response);
+      };
+    },
+    error(field) {
+      const currentErrors = errors.value;
+      return currentErrors[field];
+    }
+  };
+}
+
+export { formDataToObject, validate, form };

package/dist/shared/chunk-xd9d7q5p.js

@@ -0,0 +1,115 @@
+import {
+  executeLoaders,
+  matchRoute
+} from "./chunk-j8vzvne3.js";
+import {
+  signal
+} from "./chunk-pgymxpn1.js";
+
+// src/router/navigate.ts
+function createRouter(routes, initialUrl) {
+  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);
+  const current = signal(initialMatch);
+  const loaderData = signal([]);
+  const loaderError = signal(null);
+  const searchParams = signal(initialMatch?.search ?? {});
+  let navigationGen = 0;
+  let currentAbort = null;
+  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) {
+      searchParams.value = match.search;
+      await runLoaders(match, gen, abort.signal);
+    } else {
+      searchParams.value = {};
+      if (gen === navigationGen) {
+        loaderData.value = [];
+        loaderError.value = null;
+      }
+    }
+  }
+  async function navigate(url2, options) {
+    if (!isSSR) {
+      if (options?.replace) {
+        window.history.replaceState(null, "", url2);
+      } else {
+        window.history.pushState(null, "", url2);
+      }
+    }
+    await applyNavigation(url2);
+  }
+  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 url2 = window.location.pathname + window.location.search;
+      applyNavigation(url2).catch(() => {});
+    };
+    window.addEventListener("popstate", onPopState);
+  }
+  function dispose() {
+    if (onPopState) {
+      window.removeEventListener("popstate", onPopState);
+    }
+    if (currentAbort) {
+      currentAbort.abort();
+    }
+  }
+  return {
+    current,
+    dispose,
+    loaderData,
+    loaderError,
+    navigate,
+    revalidate,
+    searchParams
+  };
+}
+
+export { createRouter };