@vertz/ui 0.2.0 → 0.2.2

package/dist/shared/chunk-d8h2eh8d.js

@@ -1,141 +0,0 @@
-// src/hydrate/component-registry.ts
-async function resolveComponent(registry, componentId) {
-  const loader = registry[componentId];
-  if (!loader) {
-    throw new TypeError(`[hydrate] Component "${componentId}" not found in registry`);
-  }
-  const mod = await loader();
-  return mod.default;
-}
-
-// src/hydrate/props-deserializer.ts
-function deserializeProps(container) {
-  const script = container.querySelector('script[type="application/json"]');
-  if (!script || !script.textContent) {
-    return {};
-  }
-  try {
-    return JSON.parse(script.textContent);
-  } catch {
-    return {};
-  }
-}
-
-// src/hydrate/strategies.ts
-function eagerStrategy(el, hydrateFn) {
-  hydrateFn();
-}
-function lazyStrategy(el, hydrateFn) {
-  if (typeof IntersectionObserver === "undefined") {
-    hydrateFn();
-    return;
-  }
-  const observer = new IntersectionObserver((entries) => {
-    for (const entry of entries) {
-      if (entry.isIntersecting) {
-        observer.disconnect();
-        hydrateFn();
-        return;
-      }
-    }
-  }, { rootMargin: "200px" });
-  observer.observe(el);
-}
-function interactionStrategy(el, hydrateFn) {
-  const events = ["click", "focus", "pointerenter"];
-  function handler() {
-    for (const event of events) {
-      el.removeEventListener(event, handler);
-    }
-    hydrateFn();
-  }
-  for (const event of events) {
-    el.addEventListener(event, handler);
-  }
-}
-function idleStrategy(el, hydrateFn) {
-  if (typeof requestIdleCallback !== "undefined") {
-    requestIdleCallback(() => hydrateFn());
-  } else {
-    setTimeout(hydrateFn, 0);
-  }
-}
-function mediaStrategy(query) {
-  return (el, hydrateFn) => {
-    const mql = window.matchMedia(query);
-    if (mql.matches) {
-      hydrateFn();
-      return;
-    }
-    function onChange(event) {
-      if (event.matches) {
-        mql.removeEventListener("change", onChange);
-        hydrateFn();
-      }
-    }
-    mql.addEventListener("change", onChange);
-  };
-}
-function visibleStrategy(el, hydrateFn) {
-  if (typeof IntersectionObserver === "undefined") {
-    hydrateFn();
-    return;
-  }
-  const observer = new IntersectionObserver((entries) => {
-    for (const entry of entries) {
-      if (entry.isIntersecting) {
-        observer.disconnect();
-        hydrateFn();
-        return;
-      }
-    }
-  });
-  observer.observe(el);
-}
-
-// src/hydrate/hydrate.ts
-function hydrate(registry) {
-  const elements = document.querySelectorAll("[data-v-id]");
-  for (const el of elements) {
-    if (el.hasAttribute("data-v-hydrated"))
-      continue;
-    const componentId = el.getAttribute("data-v-id");
-    if (!componentId)
-      continue;
-    const strategy = el.getAttribute("hydrate") ?? "lazy";
-    const props = deserializeProps(el);
-    const doHydrate = () => {
-      resolveComponent(registry, componentId).then((component) => {
-        component(props, el);
-        el.setAttribute("data-v-hydrated", "");
-      }).catch((error) => {
-        console.error(`[hydrate] Failed to hydrate component "${componentId}":`, error);
-      });
-    };
-    switch (strategy) {
-      case "eager":
-        eagerStrategy(el, doHydrate);
-        break;
-      case "lazy":
-        lazyStrategy(el, doHydrate);
-        break;
-      case "interaction":
-        interactionStrategy(el, doHydrate);
-        break;
-      case "idle":
-        idleStrategy(el, doHydrate);
-        break;
-      case "media": {
-        const query = el.getAttribute("hydrate-media") ?? "";
-        mediaStrategy(query)(el, doHydrate);
-        break;
-      }
-      case "visible":
-        visibleStrategy(el, doHydrate);
-        break;
-      default:
-        lazyStrategy(el, doHydrate);
-    }
-  }
-}
-export { resolveComponent, deserializeProps, eagerStrategy, lazyStrategy, interactionStrategy, idleStrategy, mediaStrategy, visibleStrategy, hydrate };

package/dist/shared/chunk-tsdpgmks.js

@@ -1,98 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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 };

package/dist/shared/chunk-zbbvx05f.js

@@ -1,202 +0,0 @@
-import {
-  computed,
-  effect,
-  setReadValueCallback,
-  signal,
-  untrack
-} from "./chunk-pgymxpn1.js";
-
-// src/query/cache.ts
-class MemoryCache {
-  _store = new Map;
-  get(key) {
-    return this._store.get(key);
-  }
-  set(key, value) {
-    this._store.set(key, value);
-  }
-  delete(key) {
-    this._store.delete(key);
-  }
-}
-
-// src/query/key-derivation.ts
-function deriveKey(thunk) {
-  return `__q:${hashString(thunk.toString())}`;
-}
-function hashString(str) {
-  let hash = 5381;
-  for (let i = 0;i < str.length; i++) {
-    hash = hash * 33 ^ str.charCodeAt(i);
-  }
-  return (hash >>> 0).toString(36);
-}
-
-// src/query/query.ts
-var defaultCache = new MemoryCache;
-var inflight = new Map;
-function query(thunk, options = {}) {
-  const {
-    initialData,
-    debounce: debounceMs,
-    enabled = true,
-    key: customKey,
-    cache = defaultCache
-  } = options;
-  const baseKey = deriveKey(thunk);
-  const depHashSignal = signal("");
-  const cacheKeyComputed = computed(() => {
-    const dh = depHashSignal.value;
-    return customKey ?? (dh ? `${baseKey}:${dh}` : `${baseKey}:init`);
-  });
-  function getCacheKey() {
-    return cacheKeyComputed.value;
-  }
-  function callThunkWithCapture() {
-    const captured = [];
-    const prevCb = setReadValueCallback((v) => captured.push(v));
-    let promise;
-    try {
-      promise = thunk();
-    } finally {
-      setReadValueCallback(prevCb);
-    }
-    const serialized = captured.map((v) => JSON.stringify(v)).join("|");
-    untrack(() => {
-      depHashSignal.value = hashString(serialized);
-    });
-    return promise;
-  }
-  const data = signal(initialData);
-  const loading = signal(initialData === undefined && enabled);
-  const error = signal(undefined);
-  if (initialData !== undefined) {
-    cache.set(getCacheKey(), initialData);
-  }
-  let fetchId = 0;
-  let debounceTimer;
-  const inflightKeys = new Set;
-  const refetchTrigger = signal(0);
-  function handleFetchPromise(promise, id, key) {
-    promise.then((result) => {
-      inflight.delete(key);
-      inflightKeys.delete(key);
-      if (id !== fetchId)
-        return;
-      cache.set(key, result);
-      data.value = result;
-      loading.value = false;
-    }, (err) => {
-      inflight.delete(key);
-      inflightKeys.delete(key);
-      if (id !== fetchId)
-        return;
-      error.value = err;
-      loading.value = false;
-    });
-  }
-  function startFetch(fetchPromise, key) {
-    const id = ++fetchId;
-    untrack(() => {
-      loading.value = true;
-      error.value = undefined;
-    });
-    const existing = inflight.get(key);
-    if (existing) {
-      handleFetchPromise(existing, id, key);
-      return;
-    }
-    inflight.set(key, fetchPromise);
-    inflightKeys.add(key);
-    handleFetchPromise(fetchPromise, id, key);
-  }
-  function refetch() {
-    const key = getCacheKey();
-    cache.delete(key);
-    inflight.delete(key);
-    refetchTrigger.value = refetchTrigger.peek() + 1;
-  }
-  let disposeFn;
-  if (enabled) {
-    let isFirst = true;
-    disposeFn = effect(() => {
-      refetchTrigger.value;
-      if (customKey) {
-        const existing = untrack(() => inflight.get(customKey));
-        if (existing) {
-          const id = ++fetchId;
-          untrack(() => {
-            loading.value = true;
-            error.value = undefined;
-          });
-          handleFetchPromise(existing, id, customKey);
-          isFirst = false;
-          return;
-        }
-      }
-      const promise = callThunkWithCapture();
-      const key = untrack(() => getCacheKey());
-      if (!customKey) {
-        const existing = untrack(() => inflight.get(key));
-        if (existing) {
-          promise.catch(() => {});
-          const id = ++fetchId;
-          untrack(() => {
-            loading.value = true;
-            error.value = undefined;
-          });
-          handleFetchPromise(existing, id, key);
-          isFirst = false;
-          return;
-        }
-      }
-      if (!isFirst && !customKey) {
-        const cached = untrack(() => cache.get(key));
-        if (cached !== undefined) {
-          promise.catch(() => {});
-          untrack(() => {
-            data.value = cached;
-            loading.value = false;
-            error.value = undefined;
-          });
-          isFirst = false;
-          return;
-        }
-      }
-      if (isFirst && initialData !== undefined) {
-        promise.catch(() => {});
-        isFirst = false;
-        return;
-      }
-      isFirst = false;
-      if (debounceMs !== undefined && debounceMs > 0) {
-        clearTimeout(debounceTimer);
-        promise.catch(() => {});
-        debounceTimer = setTimeout(() => {
-          startFetch(promise, key);
-        }, debounceMs);
-      } else {
-        startFetch(promise, key);
-      }
-    });
-  }
-  function dispose() {
-    disposeFn?.();
-    clearTimeout(debounceTimer);
-    fetchId++;
-    for (const key of inflightKeys) {
-      inflight.delete(key);
-    }
-    inflightKeys.clear();
-  }
-  return {
-    data,
-    loading,
-    error,
-    refetch,
-    revalidate: refetch,
-    dispose
-  };
-}
-
-export { MemoryCache, deriveKey, query };