sibujs 1.0.0-beta.1

package/dist/chunk-MQWTY3JY.js

@@ -0,0 +1,944 @@
+import {
+  createContext
+} from "./chunk-D6JD4FDC.js";
+import {
+  sbDerived
+} from "./chunk-A65GFJBL.js";
+import {
+  sbEffect
+} from "./chunk-7JOLTGUH.js";
+import {
+  sbBatch,
+  sbSignal
+} from "./chunk-GBEYQRO2.js";
+
+// src/core/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, signal) {
+  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 (signal?.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 (signal) {
+          const onAbort = () => {
+            clearTimeout(timer);
+            reject(new DOMException("Aborted", "AbortError"));
+          };
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+      });
+    }
+  }
+  throw lastError;
+}
+
+// src/core/data/sbQuery.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 sbQuery(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] = sbSignal(initialData);
+  const [isFetching, setIsFetching] = sbSignal(false);
+  const [error, setError] = sbSignal(void 0);
+  let abortController = null;
+  let disposed = false;
+  let currentKey = null;
+  let intervalTimer = null;
+  const loading = sbDerived(() => isFetching() && data() === void 0);
+  const isStale = sbDerived(() => {
+    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);
+      return;
+    }
+    abortController?.abort();
+    abortController = new AbortController();
+    const signal = abortController.signal;
+    setIsFetching(true);
+    const promise = withRetry(() => fetcher({ signal, key: key2 }), retryOptions, void 0, signal);
+    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;
+      sbBatch(() => {
+        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;
+      sbBatch(() => {
+        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;
+    sbBatch(() => {
+      if (entry.data !== void 0) setData(entry.data);
+      setError(entry.error);
+      if (!entry.promise) setIsFetching(false);
+    });
+  }
+  const effectCleanup = sbEffect(() => {
+    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) {
+      sbBatch(() => {
+        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/core/data/sbMutation.ts
+function sbMutation(mutationFn, options = {}) {
+  const [data, setData] = sbSignal(void 0);
+  const [loading, setLoading] = sbSignal(false);
+  const [error, setError] = sbSignal(void 0);
+  const [status, setStatus] = sbSignal("idle");
+  const isSuccess = sbDerived(() => status() === "success");
+  const isIdle = sbDerived(() => status() === "idle");
+  async function execute(variables) {
+    let context;
+    sbBatch(() => {
+      setLoading(true);
+      setError(void 0);
+      setStatus("loading");
+    });
+    try {
+      if (options.onMutate) {
+        context = await options.onMutate(variables);
+      }
+      const result = await withRetry(() => mutationFn(variables), options.retry);
+      sbBatch(() => {
+        setData(result);
+        setLoading(false);
+        setStatus("success");
+      });
+      options.onSuccess?.(result, variables, context);
+      options.onSettled?.(result, void 0, variables, context);
+      return result;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      sbBatch(() => {
+        setError(errorObj);
+        setLoading(false);
+        setStatus("error");
+      });
+      options.onError?.(errorObj, variables, context);
+      options.onSettled?.(void 0, errorObj, variables, context);
+      throw errorObj;
+    }
+  }
+  function reset() {
+    sbBatch(() => {
+      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/core/data/sbInfiniteQuery.ts
+function sbInfiniteQuery(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] = sbSignal([]);
+  const [isFetching, setIsFetching] = sbSignal(false);
+  const [isFetchingNext, setIsFetchingNext] = sbSignal(false);
+  const [isFetchingPrev, setIsFetchingPrev] = sbSignal(false);
+  const [error, setError] = sbSignal(void 0);
+  const [nextPageParam, setNextPageParam] = sbSignal(initialPageParam);
+  const [prevPageParam, setPrevPageParam] = sbSignal(void 0);
+  const data = sbDerived(() => {
+    const p = pages();
+    return p.length > 0 ? p : void 0;
+  });
+  const loading = sbDerived(() => isFetching() && pages().length === 0);
+  const hasNextPage = sbDerived(() => nextPageParam() !== void 0);
+  const hasPreviousPage = sbDerived(() => prevPageParam() !== void 0);
+  let abortController = null;
+  let disposed = false;
+  async function fetchPage(pageParam, direction) {
+    if (disposed) return;
+    abortController?.abort();
+    abortController = new AbortController();
+    const signal = abortController.signal;
+    sbBatch(() => {
+      setIsFetching(true);
+      if (direction === "next") setIsFetchingNext(true);
+      if (direction === "prev") setIsFetchingPrev(true);
+      setError(void 0);
+    });
+    try {
+      const page = await withRetry(() => fetcher({ signal, pageParam }), retryOptions, void 0, signal);
+      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);
+      sbBatch(() => {
+        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));
+      sbBatch(() => {
+        setError(errorObj);
+        setIsFetching(false);
+        setIsFetchingNext(false);
+        setIsFetchingPrev(false);
+      });
+      onError?.(errorObj);
+    }
+  }
+  const effectCleanup = sbEffect(() => {
+    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() {
+    sbBatch(() => {
+      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/core/data/sbPrevious.ts
+function sbPrevious(getter) {
+  const [previous, setPrevious] = sbSignal(void 0);
+  let current = getter();
+  sbEffect(() => {
+    const next = getter();
+    if (!Object.is(next, current)) {
+      setPrevious(current);
+      current = next;
+    }
+  });
+  return previous;
+}
+
+// src/core/data/sbDebounce.ts
+function sbDebounce(getter, delay) {
+  const [debounced, setDebounced] = sbSignal(getter());
+  let timer = null;
+  sbEffect(() => {
+    const value = getter();
+    if (timer !== null) clearTimeout(timer);
+    timer = setTimeout(() => {
+      setDebounced(value);
+      timer = null;
+    }, delay);
+  });
+  return debounced;
+}
+
+// src/core/data/sbThrottle.ts
+function sbThrottle(getter, interval) {
+  const [throttled, setThrottled] = sbSignal(getter());
+  let cooldown = false;
+  let pending = null;
+  let lastEmitted = getter();
+  sbEffect(() => {
+    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/core/data/createResource.ts
+function createResource(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] = sbSignal(options.initialValue);
+  const [loading, setLoading] = sbSignal(false);
+  const [error, setError] = sbSignal(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 signal = abortController.signal;
+    const prev = currentData;
+    sbBatch(() => {
+      setLoading(true);
+      setError(void 0);
+    });
+    options.onStart?.();
+    try {
+      const result = await withRetry(() => fetcher(sourceValue, { signal, prev }), options.retry, void 0, signal);
+      if (version !== fetchVersion || disposed) return;
+      currentData = result;
+      sbBatch(() => {
+        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));
+      sbBatch(() => {
+        setError(errorObj);
+        setLoading(false);
+      });
+      options.onError?.(errorObj);
+    } finally {
+      if (version === fetchVersion) {
+        options.onSettled?.();
+      }
+    }
+  }
+  if (source) {
+    effectCleanup = sbEffect(() => {
+      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/core/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 sbOfflineStore(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] = sbSignal(initialData);
+  const [isSyncing, setIsSyncing] = sbSignal(false);
+  const [lastSynced, setLastSynced] = sbSignal(savedLastSync ?? null);
+  const [pendingCount, setPendingCount] = sbSignal(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 query(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,
+    isSyncing,
+    lastSynced,
+    sync,
+    attach,
+    pendingCount,
+    close
+  };
+}
+function createSyncAdapter(config) {
+  return config;
+}
+
+// src/core/data/routeLoader.ts
+var LoaderContext = createContext(null);
+function executeLoader(loader, context, options) {
+  const resource = createResource(({ signal }) => loader(context, { signal }), options);
+  LoaderContext.provide(resource);
+  return resource;
+}
+function sbLoaderData() {
+  const resource = LoaderContext.get();
+  if (!resource) {
+    throw new Error("sbLoaderData must be used inside a route with a loader");
+  }
+  return {
+    data: resource.data,
+    loading: resource.loading,
+    error: resource.error
+  };
+}
+async function preloadRoute(route, context) {
+  if (!route.loader) return void 0;
+  const controller = new AbortController();
+  return route.loader(context, { signal: controller.signal });
+}
+
+// src/core/ui/sbSocket.ts
+function sbSocket(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] = sbSignal(null);
+  const [status, setStatus] = sbSignal("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/core/ui/sbStream.ts
+function sbStream(url, options) {
+  const autoReconnect = options?.autoReconnect ?? false;
+  const [data, setData] = sbSignal(null);
+  const [event, setEvent] = sbSignal(null);
+  const [status, setStatus] = sbSignal("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,
+  sbQuery,
+  invalidateQueries,
+  getQueryData,
+  setQueryData,
+  clearQueryCache,
+  sbMutation,
+  sbInfiniteQuery,
+  sbPrevious,
+  sbDebounce,
+  sbThrottle,
+  createResource,
+  sbOfflineStore,
+  createSyncAdapter,
+  executeLoader,
+  sbLoaderData,
+  preloadRoute,
+  sbSocket,
+  sbStream
+};