@vertz/ui 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/ui",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "license": "MIT",
   "description": "Vertz UI framework — signals, components, JSX runtime",
@@ -58,19 +58,24 @@
   ],
   "scripts": {
     "build": "bunup",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
     "typecheck": "tsc --noEmit"
   },
+  "dependencies": {
+    "@vertz/fetch": "0.2.1"
+  },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.0.18",
+    "@happy-dom/global-registrator": "^20.7.0",
+    "@vertz/schema": "0.2.1",
     "bunup": "latest",
-    "happy-dom": "^18.0.1",
-    "typescript": "^5.7.0",
-    "vitest": "^4.0.18"
+    "happy-dom": "^20.7.0",
+    "typescript": "^5.7.0"
   },
   "engines": {
     "node": ">=22"
   },
-  "sideEffects": false
+  "sideEffects": [
+    "dist/shared/*.js"
+  ]
 }

package/dist/shared/chunk-bp3v6s9j.js

@@ -1,62 +0,0 @@
-import {
-  effect,
-  useContext
-} from "./chunk-pgymxpn1.js";
-
-// src/router/link.ts
-function createLink(currentPath, navigate) {
-  return function Link(props) {
-    const el = document.createElement("a");
-    el.setAttribute("href", props.href);
-    el.textContent = props.children;
-    if (props.className) {
-      el.classList.add(props.className);
-    }
-    if (props.activeClass) {
-      const activeClass = props.activeClass;
-      effect(() => {
-        if (currentPath.value === props.href) {
-          el.classList.add(activeClass);
-        } else {
-          el.classList.remove(activeClass);
-        }
-      });
-    }
-    el.addEventListener("click", (event) => {
-      if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
-        return;
-      }
-      event.preventDefault();
-      navigate(props.href);
-    });
-    return el;
-  };
-}
-
-// src/router/outlet.ts
-function createOutlet(outletCtx) {
-  return function Outlet() {
-    const ctx = useContext(outletCtx);
-    if (!ctx || !ctx.childComponent) {
-      return document.createComment("outlet:empty");
-    }
-    return ctx.childComponent();
-  };
-}
-
-// src/router/search-params.ts
-function parseSearchParams(urlParams, schema) {
-  const raw = {};
-  for (const [key, value] of urlParams.entries()) {
-    raw[key] = value;
-  }
-  if (schema) {
-    return schema.parse(raw);
-  }
-  return raw;
-}
-function useSearchParams(searchSignal) {
-  return searchSignal.value;
-}
-
-export { createLink, createOutlet, parseSearchParams, useSearchParams };

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-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 };