sibujs 1.3.0 → 1.5.0

package/dist/chunk-BGTHZHJ5.js

@@ -0,0 +1,1016 @@
+import {
+  context
+} from "./chunk-6BMPXPUW.js";
+import {
+  derived
+} from "./chunk-XHK6BDAJ.js";
+import {
+  sanitizeUrl
+} from "./chunk-CMBFNA7L.js";
+import {
+  effect
+} from "./chunk-VQNQZCWJ.js";
+import {
+  batch,
+  signal
+} from "./chunk-NZIIMDWI.js";
+
+// src/data/retry.ts
+function calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter) {
+  let delay;
+  switch (strategy) {
+    case "exponential":
+      delay = baseDelay * 2 ** attempt;
+      break;
+    case "linear":
+      delay = baseDelay * (attempt + 1);
+      break;
+    case "fixed":
+      delay = baseDelay;
+      break;
+  }
+  delay = Math.min(delay, maxDelay);
+  if (jitter > 0) {
+    const jitterRange = delay * jitter;
+    delay += (Math.random() * 2 - 1) * jitterRange;
+  }
+  return Math.max(0, delay);
+}
+async function withRetry(fn, options, onRetry, signal2) {
+  const maxRetries = options?.maxRetries ?? 3;
+  const strategy = options?.strategy ?? "exponential";
+  const baseDelay = options?.baseDelay ?? 1e3;
+  const maxDelay = options?.maxDelay ?? 3e4;
+  const jitter = options?.jitter ?? 0.1;
+  const shouldRetry = options?.shouldRetry ?? (() => true);
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (signal2?.aborted) throw new DOMException("Aborted", "AbortError");
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries || !shouldRetry(error, attempt)) throw error;
+      const delay = calculateDelay(attempt, strategy, baseDelay, maxDelay, jitter);
+      onRetry?.(error, attempt, delay);
+      await new Promise((resolve, reject) => {
+        let onAbort = null;
+        const timer = setTimeout(() => {
+          if (onAbort && signal2) signal2.removeEventListener("abort", onAbort);
+          resolve();
+        }, delay);
+        if (signal2) {
+          onAbort = () => {
+            clearTimeout(timer);
+            reject(new DOMException("Aborted", "AbortError"));
+          };
+          signal2.addEventListener("abort", onAbort, { once: true });
+        }
+      });
+    }
+  }
+  throw lastError;
+}
+
+// src/data/query.ts
+var queryCache = /* @__PURE__ */ new Map();
+function getOrCreateEntry(key, initialData) {
+  let entry = queryCache.get(key);
+  if (!entry) {
+    entry = {
+      data: initialData,
+      error: void 0,
+      dataUpdatedAt: initialData !== void 0 ? Date.now() : 0,
+      subscribers: 0,
+      gcTimer: null,
+      promise: null,
+      listeners: /* @__PURE__ */ new Set(),
+      refetchers: /* @__PURE__ */ new Set()
+    };
+    queryCache.set(key, entry);
+  }
+  return entry;
+}
+function query(key, fetcher, options = {}) {
+  const {
+    staleTime = 0,
+    cacheTime = 3e5,
+    enabled = true,
+    retry: retryOptions,
+    initialData,
+    refetchInterval,
+    refetchOnWindowFocus = false,
+    refetchOnReconnect = false,
+    onSuccess,
+    onError,
+    onSettled,
+    select
+  } = options;
+  const resolveKey = typeof key === "function" ? key : () => key;
+  const [data, setData] = signal(initialData);
+  const [isFetching, setIsFetching] = signal(false);
+  const [error, setError] = signal(void 0);
+  let abortController = null;
+  let disposed = false;
+  let currentKey = null;
+  let intervalTimer = null;
+  const loading = derived(() => isFetching() && data() === void 0);
+  const isStale = derived(() => {
+    data();
+    if (!currentKey) return true;
+    const entry = queryCache.get(currentKey);
+    if (!entry || entry.dataUpdatedAt === 0) return true;
+    return Date.now() - entry.dataUpdatedAt >= staleTime;
+  });
+  async function doFetch() {
+    if (disposed || !currentKey || !enabled) return;
+    const key2 = currentKey;
+    let entry = queryCache.get(key2);
+    if (!entry) {
+      entry = getOrCreateEntry(key2);
+      entry.subscribers++;
+      entry.listeners.add(onCacheUpdate);
+      entry.refetchers.add(doFetch);
+    }
+    if (entry.promise) {
+      setIsFetching(true);
+      try {
+        await entry.promise;
+      } catch {
+      }
+      onCacheUpdate();
+      return;
+    }
+    abortController?.abort();
+    abortController = new AbortController();
+    const signal2 = abortController.signal;
+    setIsFetching(true);
+    const promise = withRetry(() => fetcher({ signal: signal2, key: key2 }), retryOptions, void 0, signal2);
+    entry.promise = promise;
+    try {
+      const result = await promise;
+      entry.promise = null;
+      if (disposed || currentKey !== key2) return;
+      entry.data = result;
+      entry.dataUpdatedAt = Date.now();
+      entry.error = void 0;
+      const selected = select ? select(result) : result;
+      batch(() => {
+        setData(selected);
+        setIsFetching(false);
+        setError(void 0);
+      });
+      for (const listener of entry.listeners) listener();
+      onSuccess?.(result);
+    } catch (err) {
+      entry.promise = null;
+      if (disposed || currentKey !== key2) return;
+      if (err instanceof DOMException && err.name === "AbortError") return;
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      entry.error = errorObj;
+      batch(() => {
+        setError(errorObj);
+        setIsFetching(false);
+      });
+      for (const listener of entry.listeners) listener();
+      onError?.(errorObj);
+    } finally {
+      if (!disposed && currentKey === key2) onSettled?.();
+    }
+  }
+  function onCacheUpdate() {
+    if (disposed || !currentKey) return;
+    const entry = queryCache.get(currentKey);
+    if (!entry) {
+      batch(() => {
+        setData(void 0);
+        setError(void 0);
+        setIsFetching(false);
+      });
+      return;
+    }
+    const raw = entry.data;
+    const selected = raw !== void 0 && select ? select(raw) : raw;
+    batch(() => {
+      setData(selected);
+      setError(entry.error);
+      if (!entry.promise) setIsFetching(false);
+    });
+  }
+  const effectCleanup = effect(() => {
+    const key2 = resolveKey();
+    if (currentKey !== null && currentKey !== key2) {
+      const oldEntry = queryCache.get(currentKey);
+      if (oldEntry) {
+        oldEntry.listeners.delete(onCacheUpdate);
+        oldEntry.refetchers.delete(doFetch);
+        oldEntry.subscribers--;
+        if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
+          const oldKey = currentKey;
+          oldEntry.gcTimer = setTimeout(() => queryCache.delete(oldKey), cacheTime);
+        }
+      }
+    }
+    const keyChanged = currentKey !== key2;
+    currentKey = key2;
+    const entry = getOrCreateEntry(key2, initialData);
+    if (keyChanged || entry.subscribers === 0) entry.subscribers++;
+    if (entry.gcTimer !== null) {
+      clearTimeout(entry.gcTimer);
+      entry.gcTimer = null;
+    }
+    entry.listeners.add(onCacheUpdate);
+    entry.refetchers.add(doFetch);
+    if (entry.data !== void 0) {
+      const raw = entry.data;
+      const selected = select ? select(raw) : raw;
+      batch(() => {
+        setData(selected);
+        setError(entry.error);
+      });
+    }
+    const isDataStale = entry.dataUpdatedAt === 0 || Date.now() - entry.dataUpdatedAt >= staleTime;
+    if (enabled && (entry.data === void 0 || isDataStale)) {
+      doFetch();
+    }
+  });
+  if (refetchInterval && refetchInterval > 0) {
+    intervalTimer = setInterval(() => {
+      if (!disposed && currentKey && enabled) doFetch();
+    }, refetchInterval);
+  }
+  let focusHandler = null;
+  let onlineHandler = null;
+  if (typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function") {
+    if (refetchOnWindowFocus) {
+      focusHandler = () => {
+        if (!disposed && currentKey && enabled) doFetch();
+      };
+      globalThis.addEventListener("focus", focusHandler);
+    }
+    if (refetchOnReconnect) {
+      onlineHandler = () => {
+        if (!disposed && currentKey && enabled) doFetch();
+      };
+      globalThis.addEventListener("online", onlineHandler);
+    }
+  }
+  function dispose() {
+    disposed = true;
+    abortController?.abort();
+    effectCleanup();
+    if (intervalTimer) clearInterval(intervalTimer);
+    if (currentKey) {
+      const entry = queryCache.get(currentKey);
+      if (entry) {
+        entry.listeners.delete(onCacheUpdate);
+        entry.refetchers.delete(doFetch);
+        entry.subscribers--;
+        if (entry.subscribers <= 0 && cacheTime >= 0) {
+          const key2 = currentKey;
+          entry.gcTimer = setTimeout(() => queryCache.delete(key2), cacheTime);
+        }
+      }
+    }
+    if (focusHandler) globalThis.removeEventListener("focus", focusHandler);
+    if (onlineHandler) globalThis.removeEventListener("online", onlineHandler);
+  }
+  return {
+    data,
+    loading,
+    fetching: isFetching,
+    error,
+    isStale,
+    refetch: doFetch,
+    dispose
+  };
+}
+function invalidateQueries(keyOrPredicate) {
+  const predicate = typeof keyOrPredicate === "function" ? keyOrPredicate : (k) => k === keyOrPredicate;
+  for (const [key, entry] of queryCache.entries()) {
+    if (predicate(key)) {
+      entry.dataUpdatedAt = 0;
+      for (const refetcher of entry.refetchers) refetcher();
+    }
+  }
+}
+function getQueryData(key) {
+  return queryCache.get(key)?.data;
+}
+function setQueryData(key, data) {
+  const entry = queryCache.get(key);
+  if (!entry) return;
+  const newData = typeof data === "function" ? data(entry.data) : data;
+  entry.data = newData;
+  entry.dataUpdatedAt = Date.now();
+  for (const listener of entry.listeners) listener();
+}
+function clearQueryCache() {
+  const activeListeners = [];
+  const activeRefetchers = [];
+  for (const entry of queryCache.values()) {
+    if (entry.gcTimer) clearTimeout(entry.gcTimer);
+    if (entry.subscribers > 0) {
+      for (const listener of entry.listeners) activeListeners.push(listener);
+      for (const refetcher of entry.refetchers) activeRefetchers.push(refetcher);
+    }
+  }
+  queryCache.clear();
+  for (const listener of activeListeners) listener();
+  for (const refetcher of activeRefetchers) refetcher();
+}
+
+// src/data/mutation.ts
+function mutation(mutationFn, options = {}) {
+  const [data, setData] = signal(void 0);
+  const [loading, setLoading] = signal(false);
+  const [error, setError] = signal(void 0);
+  const [status, setStatus] = signal("idle");
+  const isSuccess = derived(() => status() === "success");
+  const isIdle = derived(() => status() === "idle");
+  let runId = 0;
+  async function execute(variables) {
+    const myRun = ++runId;
+    let context2;
+    batch(() => {
+      setLoading(true);
+      setError(void 0);
+      setStatus("loading");
+    });
+    try {
+      if (options.onMutate) {
+        context2 = await options.onMutate(variables);
+      }
+      const result = await withRetry(() => mutationFn(variables), options.retry);
+      if (myRun !== runId) return result;
+      batch(() => {
+        setData(result);
+        setLoading(false);
+        setStatus("success");
+      });
+      options.onSuccess?.(result, variables, context2);
+      options.onSettled?.(result, void 0, variables, context2);
+      return result;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      if (myRun !== runId) throw errorObj;
+      batch(() => {
+        setError(errorObj);
+        setLoading(false);
+        setStatus("error");
+      });
+      options.onError?.(errorObj, variables, context2);
+      options.onSettled?.(void 0, errorObj, variables, context2);
+      throw errorObj;
+    }
+  }
+  function reset() {
+    runId++;
+    batch(() => {
+      setData(void 0);
+      setError(void 0);
+      setLoading(false);
+      setStatus("idle");
+    });
+  }
+  return {
+    data,
+    loading,
+    error,
+    isSuccess,
+    isIdle,
+    mutate: (variables) => {
+      execute(variables).catch(() => {
+      });
+    },
+    mutateAsync: execute,
+    reset
+  };
+}
+
+// src/data/infiniteQuery.ts
+function infiniteQuery(key, fetcher, options) {
+  const {
+    getNextPageParam,
+    getPreviousPageParam,
+    initialPageParam = 0,
+    enabled = true,
+    retry: retryOptions,
+    onSuccess,
+    onError
+  } = options;
+  const resolveKey = typeof key === "function" ? key : () => key;
+  const [pages, setPages] = signal([]);
+  const [isFetching, setIsFetching] = signal(false);
+  const [isFetchingNext, setIsFetchingNext] = signal(false);
+  const [isFetchingPrev, setIsFetchingPrev] = signal(false);
+  const [error, setError] = signal(void 0);
+  const [nextPageParam, setNextPageParam] = signal(initialPageParam);
+  const [prevPageParam, setPrevPageParam] = signal(void 0);
+  const data = derived(() => {
+    const p = pages();
+    return p.length > 0 ? p : void 0;
+  });
+  const loading = derived(() => isFetching() && pages().length === 0);
+  const hasNextPage = derived(() => nextPageParam() !== void 0);
+  const hasPreviousPage = derived(() => prevPageParam() !== void 0);
+  let abortController = null;
+  let disposed = false;
+  async function fetchPage(pageParam, direction) {
+    if (disposed) return;
+    abortController?.abort();
+    abortController = new AbortController();
+    const signal2 = abortController.signal;
+    batch(() => {
+      setIsFetching(true);
+      if (direction === "next") setIsFetchingNext(true);
+      if (direction === "prev") setIsFetchingPrev(true);
+      setError(void 0);
+    });
+    try {
+      const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
+      if (disposed) return;
+      const currentPages = pages();
+      let newPages;
+      if (direction === "prev") {
+        newPages = [page, ...currentPages];
+      } else {
+        newPages = [...currentPages, page];
+      }
+      const nextParam = getNextPageParam(page, newPages);
+      const prevParam = getPreviousPageParam?.(newPages[0], newPages);
+      batch(() => {
+        setPages(newPages);
+        setNextPageParam(nextParam);
+        setPrevPageParam(prevParam);
+        setIsFetching(false);
+        setIsFetchingNext(false);
+        setIsFetchingPrev(false);
+      });
+      onSuccess?.(newPages);
+    } catch (err) {
+      if (disposed) return;
+      if (err instanceof DOMException && err.name === "AbortError") return;
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      batch(() => {
+        setError(errorObj);
+        setIsFetching(false);
+        setIsFetchingNext(false);
+        setIsFetchingPrev(false);
+      });
+      onError?.(errorObj);
+    }
+  }
+  const effectCleanup = effect(() => {
+    resolveKey();
+    if (enabled) {
+      setPages([]);
+      setNextPageParam(initialPageParam);
+      setPrevPageParam(void 0);
+      fetchPage(initialPageParam, "initial");
+    }
+  });
+  function fetchNextPage() {
+    const param = nextPageParam();
+    if (param === void 0) return Promise.resolve();
+    return fetchPage(param, "next");
+  }
+  function fetchPreviousPage() {
+    const param = prevPageParam();
+    if (param === void 0) return Promise.resolve();
+    return fetchPage(param, "prev");
+  }
+  async function refetch() {
+    batch(() => {
+      setPages([]);
+      setNextPageParam(initialPageParam);
+      setPrevPageParam(void 0);
+    });
+    await fetchPage(initialPageParam, "initial");
+  }
+  function dispose() {
+    disposed = true;
+    abortController?.abort();
+    effectCleanup();
+  }
+  return {
+    data,
+    pages,
+    loading,
+    fetching: isFetching,
+    fetchingNextPage: isFetchingNext,
+    fetchingPreviousPage: isFetchingPrev,
+    error,
+    hasNextPage,
+    hasPreviousPage,
+    fetchNextPage,
+    fetchPreviousPage,
+    refetch,
+    dispose
+  };
+}
+
+// src/data/previous.ts
+function previous(getter) {
+  const [previous2, setPrevious] = signal(void 0);
+  let current = getter();
+  effect(() => {
+    const next = getter();
+    if (!Object.is(next, current)) {
+      setPrevious(current);
+      current = next;
+    }
+  });
+  return previous2;
+}
+
+// src/data/debounce.ts
+function debounce(getter, delay) {
+  const [debounced, setDebounced] = signal(getter());
+  let timer = null;
+  effect(() => {
+    const value = getter();
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      setDebounced(value);
+      timer = null;
+    }, delay);
+  });
+  return debounced;
+}
+
+// src/data/throttle.ts
+function throttle(getter, interval) {
+  const [throttled, setThrottled] = signal(getter());
+  let cooldown = false;
+  let pending = null;
+  let lastEmitted = getter();
+  effect(() => {
+    const value = getter();
+    if (!cooldown) {
+      if (!Object.is(value, lastEmitted)) {
+        setThrottled(value);
+        lastEmitted = value;
+        cooldown = true;
+        pending = null;
+        setTimeout(() => {
+          cooldown = false;
+          if (pending !== null) {
+            const trailingValue = pending.value;
+            pending = null;
+            setThrottled(trailingValue);
+            lastEmitted = trailingValue;
+          }
+        }, interval);
+      }
+    } else {
+      pending = { value };
+    }
+  });
+  return throttled;
+}
+
+// src/data/resource.ts
+function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
+  let source = null;
+  let fetcher;
+  let options;
+  if (typeof fetcherOrOptions === "function") {
+    source = sourceOrFetcher;
+    fetcher = fetcherOrOptions;
+    options = maybeOptions ?? {};
+  } else {
+    const rawFetcher = sourceOrFetcher;
+    fetcher = (_source, info) => rawFetcher(info);
+    options = fetcherOrOptions ?? {};
+  }
+  const [data, setData] = signal(options.initialValue);
+  const [loading, setLoading] = signal(false);
+  const [error, setError] = signal(void 0);
+  let currentData = options.initialValue;
+  let abortController = null;
+  let disposed = false;
+  let effectCleanup = null;
+  let fetchVersion = 0;
+  async function doFetch(sourceValue) {
+    if (disposed) return;
+    abortController?.abort();
+    abortController = new AbortController();
+    const version = ++fetchVersion;
+    const signal2 = abortController.signal;
+    const prev = currentData;
+    batch(() => {
+      setLoading(true);
+      setError(void 0);
+    });
+    options.onStart?.();
+    try {
+      const result = await withRetry(() => fetcher(sourceValue, { signal: signal2, prev }), options.retry, void 0, signal2);
+      if (version !== fetchVersion || disposed) return;
+      currentData = result;
+      batch(() => {
+        setData(result);
+        setLoading(false);
+      });
+      options.onSuccess?.(result);
+    } catch (err) {
+      if (version !== fetchVersion || disposed) return;
+      if (err instanceof DOMException && err.name === "AbortError") {
+        if (version === fetchVersion) setLoading(false);
+        return;
+      }
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      batch(() => {
+        setError(errorObj);
+        setLoading(false);
+      });
+      options.onError?.(errorObj);
+    } finally {
+      if (version === fetchVersion) {
+        options.onSettled?.();
+      }
+    }
+  }
+  if (source) {
+    effectCleanup = effect(() => {
+      const sourceValue = source();
+      doFetch(sourceValue);
+    });
+  } else if (options.immediate !== false) {
+    doFetch(void 0);
+  }
+  return {
+    data,
+    loading,
+    error,
+    refetch: () => doFetch(source ? source() : void 0),
+    mutate: (value) => {
+      const newValue = typeof value === "function" ? value(currentData) : value;
+      currentData = newValue;
+      setData(newValue);
+    },
+    abort: () => abortController?.abort(),
+    dispose: () => {
+      disposed = true;
+      abortController?.abort();
+      effectCleanup?.();
+    }
+  };
+}
+
+// src/data/offlineStore.ts
+function openDB(name, version, keyPath) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(name, version);
+    request.onerror = () => reject(request.error);
+    request.onsuccess = () => resolve(request.result);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains("items")) {
+        db.createObjectStore("items", { keyPath });
+      }
+      if (!db.objectStoreNames.contains("_changes")) {
+        const changeStore = db.createObjectStore("_changes", { autoIncrement: true });
+        changeStore.createIndex("timestamp", "timestamp");
+      }
+      if (!db.objectStoreNames.contains("_meta")) {
+        db.createObjectStore("_meta");
+      }
+    };
+  });
+}
+function idbGetAll(db, store) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readonly");
+    const req = tx.objectStore(store).getAll();
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbGet(db, store, key) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readonly");
+    const req = tx.objectStore(store).get(key);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbPut(db, store, item) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readwrite");
+    tx.objectStore(store).put(item);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function idbDelete(db, store, key) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readwrite");
+    tx.objectStore(store).delete(key);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+function idbClear(db, store) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readwrite");
+    tx.objectStore(store).clear();
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+}
+async function offlineStore(options) {
+  const { name, version = 1, keyPath = "id", autoSync = true } = options;
+  const db = await openDB(name, version, keyPath);
+  const initialData = await idbGetAll(db, "items");
+  const initialChanges = await idbGetAll(db, "_changes");
+  const savedLastSync = await idbGet(db, "_meta", "lastSynced");
+  const [data, setData] = signal(initialData);
+  const [isSyncing, setIsSyncing] = signal(false);
+  const [lastSynced, setLastSynced] = signal(savedLastSync ?? null);
+  const [pendingCount, setPendingCount] = signal(initialChanges.length);
+  let adapter = options.adapter;
+  async function refreshData() {
+    const items = await idbGetAll(db, "items");
+    setData(items);
+    const changes = await idbGetAll(db, "_changes");
+    setPendingCount(changes.length);
+  }
+  async function put(item) {
+    await idbPut(db, "items", item);
+    await idbPut(db, "_changes", { type: "put", item, timestamp: Date.now() });
+    await refreshData();
+  }
+  async function remove(key) {
+    const existing = await idbGet(db, "items", key);
+    if (existing) {
+      await idbDelete(db, "items", key);
+      await idbPut(db, "_changes", { type: "delete", item: existing, timestamp: Date.now() });
+      await refreshData();
+    }
+  }
+  async function get(key) {
+    return idbGet(db, "items", key);
+  }
+  function query2(filter) {
+    return data().filter(filter);
+  }
+  async function sync() {
+    if (!adapter || isSyncing()) return;
+    setIsSyncing(true);
+    try {
+      const changes = await idbGetAll(db, "_changes");
+      if (changes.length > 0) {
+        const result = await adapter.push(changes);
+        if (result.ok) {
+          await idbClear(db, "_changes");
+        }
+      }
+      const remoteItems = await adapter.pull(lastSynced());
+      for (const item of remoteItems) {
+        await idbPut(db, "items", item);
+      }
+      const now = Date.now();
+      await idbPut(db, "_meta", now);
+      setLastSynced(now);
+      await refreshData();
+    } catch {
+    } finally {
+      setIsSyncing(false);
+    }
+  }
+  function attach(newAdapter) {
+    adapter = newAdapter;
+  }
+  function close() {
+    db.close();
+  }
+  if (autoSync && typeof window !== "undefined") {
+    window.addEventListener("online", () => {
+      sync();
+    });
+  }
+  return {
+    data,
+    get,
+    put,
+    remove,
+    query: query2,
+    isSyncing,
+    lastSynced,
+    sync,
+    attach,
+    pendingCount,
+    close
+  };
+}
+function syncAdapter(config) {
+  return config;
+}
+
+// src/data/routeLoader.ts
+var LoaderContext = context(null);
+function executeLoader(loader, context2, options) {
+  const res = resource(({ signal: signal2 }) => loader(context2, { signal: signal2 }), options);
+  LoaderContext.provide(res);
+  return res;
+}
+function loaderData() {
+  const resource2 = LoaderContext.get();
+  if (!resource2) {
+    throw new Error("loaderData must be used inside a route with a loader");
+  }
+  return {
+    data: resource2.data,
+    loading: resource2.loading,
+    error: resource2.error
+  };
+}
+async function preloadRoute(route, context2) {
+  if (!route.loader) return void 0;
+  const controller = new AbortController();
+  return route.loader(context2, { signal: controller.signal });
+}
+
+// src/ui/socket.ts
+function validateWsUrl(raw) {
+  const trimmed = raw.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
+  if (!trimmed) return null;
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("ws://") || lower.startsWith("wss://")) return trimmed;
+  return null;
+}
+function socket(url, options) {
+  const autoReconnect = options?.autoReconnect ?? false;
+  const reconnectDelay = options?.reconnectDelay ?? 1e3;
+  const maxReconnects = options?.maxReconnects ?? Infinity;
+  const heartbeat = options?.heartbeat;
+  const protocols = options?.protocols;
+  const [data, setData] = signal(null);
+  const [status, setStatus] = signal("closed");
+  let ws = null;
+  let reconnectCount = 0;
+  let reconnectTimer = null;
+  let heartbeatTimer = null;
+  let disposed = false;
+  let manuallyClosed = false;
+  function getUrl() {
+    return typeof url === "function" ? url() : url;
+  }
+  function connect() {
+    if (disposed) return;
+    const safeUrl = validateWsUrl(getUrl());
+    if (safeUrl === null) {
+      setStatus("closed");
+      return;
+    }
+    setStatus("connecting");
+    ws = new WebSocket(safeUrl, protocols);
+    ws.onopen = () => {
+      setStatus("open");
+      reconnectCount = 0;
+      startHeartbeat();
+    };
+    ws.onmessage = (event) => {
+      setData(event.data);
+    };
+    ws.onclose = () => {
+      setStatus("closed");
+      stopHeartbeat();
+      if (autoReconnect && !disposed && !manuallyClosed && reconnectCount < maxReconnects) {
+        reconnectCount++;
+        reconnectTimer = setTimeout(() => {
+          connect();
+        }, reconnectDelay);
+      }
+      manuallyClosed = false;
+    };
+    ws.onerror = () => {
+    };
+  }
+  function startHeartbeat() {
+    if (!heartbeat) return;
+    stopHeartbeat();
+    heartbeatTimer = setInterval(() => {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(heartbeat.message);
+      }
+    }, heartbeat.interval);
+  }
+  function stopHeartbeat() {
+    if (heartbeatTimer !== null) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  }
+  function send(msg) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(msg);
+    }
+  }
+  function close() {
+    manuallyClosed = true;
+    if (reconnectTimer !== null) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    stopHeartbeat();
+    if (ws) {
+      setStatus("closing");
+      ws.close();
+    }
+  }
+  function dispose() {
+    disposed = true;
+    close();
+  }
+  connect();
+  return { data, status, send, close, dispose };
+}
+
+// src/ui/stream.ts
+function validateSseUrl(raw) {
+  const safe = sanitizeUrl(raw);
+  if (!safe) return null;
+  return safe;
+}
+function stream(url, options) {
+  const autoReconnect = options?.autoReconnect ?? false;
+  const [data, setData] = signal(null);
+  const [event, setEvent] = signal(null);
+  const [status, setStatus] = signal("connecting");
+  let source = null;
+  let disposed = false;
+  let reconnectTimer = null;
+  function connect() {
+    if (disposed) return;
+    const safeUrl = validateSseUrl(url);
+    if (safeUrl === null) {
+      setStatus("closed");
+      return;
+    }
+    setStatus("connecting");
+    source = new EventSource(safeUrl, {
+      withCredentials: options?.withCredentials ?? false
+    });
+    source.onopen = () => {
+      setStatus("open");
+    };
+    source.onmessage = (evt) => {
+      setData(evt.data);
+      setEvent(evt.type);
+    };
+    source.onerror = () => {
+      if (source && source.readyState === EventSource.CLOSED) {
+        setStatus("closed");
+        source = null;
+        if (autoReconnect && !disposed) {
+          reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            connect();
+          }, 1e3);
+        }
+      }
+    };
+  }
+  function close() {
+    if (reconnectTimer !== null) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    if (source) {
+      source.close();
+      setStatus("closed");
+      source = null;
+    }
+  }
+  function dispose() {
+    disposed = true;
+    close();
+  }
+  connect();
+  return { data, event, status, close, dispose };
+}
+
+export {
+  calculateDelay,
+  withRetry,
+  query,
+  invalidateQueries,
+  getQueryData,
+  setQueryData,
+  clearQueryCache,
+  mutation,
+  infiniteQuery,
+  previous,
+  debounce,
+  throttle,
+  resource,
+  offlineStore,
+  syncAdapter,
+  executeLoader,
+  loaderData,
+  preloadRoute,
+  socket,
+  stream
+};