sibujs 1.0.2 → 1.0.4

package/dist/chunk-6BDUQJ7K.js

@@ -1,949 +0,0 @@
-import {
-  context
-} from "./chunk-BS5EYKCJ.js";
-import {
-  derived
-} from "./chunk-HGKEBAW3.js";
-import {
-  effect
-} from "./chunk-6DJQF4Z7.js";
-import {
-  batch,
-  signal
-} from "./chunk-K7JUDY3C.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) => {
-        const timer = setTimeout(resolve, delay);
-        if (signal2) {
-          const 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
-  } = 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;
-    const entry = queryCache.get(key2);
-    if (!entry) return;
-    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;
-      batch(() => {
-        setData(result);
-        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) return;
-    batch(() => {
-      if (entry.data !== void 0) setData(entry.data);
-      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);
-        }
-      }
-    }
-    currentKey = key2;
-    const entry = getOrCreateEntry(key2, initialData);
-    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) {
-      batch(() => {
-        setData(entry.data);
-        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() {
-  for (const entry of queryCache.values()) {
-    if (entry.gcTimer) clearTimeout(entry.gcTimer);
-  }
-  queryCache.clear();
-}
-
-// 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");
-  async function execute(variables) {
-    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);
-      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));
-      batch(() => {
-        setError(errorObj);
-        setLoading(false);
-        setStatus("error");
-      });
-      options.onError?.(errorObj, variables, context2);
-      options.onSettled?.(void 0, errorObj, variables, context2);
-      throw errorObj;
-    }
-  }
-  function reset() {
-    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") 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 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;
-  function getUrl() {
-    return typeof url === "function" ? url() : url;
-  }
-  function connect() {
-    if (disposed) return;
-    setStatus("connecting");
-    ws = new WebSocket(getUrl(), protocols);
-    ws.onopen = () => {
-      setStatus("open");
-      reconnectCount = 0;
-      startHeartbeat();
-    };
-    ws.onmessage = (event) => {
-      setData(event.data);
-    };
-    ws.onclose = () => {
-      setStatus("closed");
-      stopHeartbeat();
-      if (autoReconnect && !disposed && reconnectCount < maxReconnects) {
-        reconnectCount++;
-        reconnectTimer = setTimeout(() => {
-          connect();
-        }, reconnectDelay);
-      }
-    };
-    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() {
-    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 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;
-    setStatus("connecting");
-    source = new EventSource(url, {
-      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
-};