sibujs 1.0.0-beta.1

package/dist/data.cjs

@@ -0,0 +1,1373 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// data.ts
+var data_exports = {};
+__export(data_exports, {
+  calculateDelay: () => calculateDelay,
+  clearQueryCache: () => clearQueryCache,
+  debounce: () => debounce,
+  executeLoader: () => executeLoader,
+  getQueryData: () => getQueryData,
+  infiniteQuery: () => infiniteQuery,
+  invalidateQueries: () => invalidateQueries,
+  loaderData: () => loaderData,
+  mutation: () => mutation,
+  offlineStore: () => offlineStore,
+  preloadRoute: () => preloadRoute,
+  previous: () => previous,
+  query: () => query,
+  resource: () => resource,
+  setQueryData: () => setQueryData,
+  socket: () => socket,
+  stream: () => stream,
+  syncAdapter: () => syncAdapter,
+  throttle: () => throttle,
+  withRetry: () => withRetry
+});
+module.exports = __toCommonJS(data_exports);
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  subscriberStack.push(subscriber);
+  currentSubscriber = subscriber;
+  effectFn();
+  subscriberStack.pop();
+  currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function queueSignalNotification(signal2) {
+  const subs = signal2[SUBS];
+  if (!subs) return;
+  for (const sub of subs) {
+    if (sub._c) {
+      propagateDirty(sub);
+    } else if (!pendingSet.has(sub)) {
+      pendingSet.add(sub);
+      pendingQueue.push(sub);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i = 0;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s = sig;
+      s._d = false;
+      s._v = s._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        pendingQueue[i]();
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          pendingQueue[i2]();
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const deps = subscriber._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal2 of deps) {
+    const subs = signal2[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal2.__f === subscriber) {
+        signal2.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : true;
+}
+function devAssert(condition, message) {
+  if (isDev() && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+
+// src/core/signals/derived.ts
+function derived(getter, options) {
+  devAssert(typeof getter === "function", "derived: argument must be a getter function.");
+  const debugName = options?.name;
+  const cs = {};
+  cs._d = false;
+  cs._g = getter;
+  const markDirty = () => {
+    if (cs._d) return;
+    cs._d = true;
+  };
+  markDirty._c = 1;
+  markDirty._sig = cs;
+  track(() => {
+    cs._d = false;
+    cs._v = getter();
+  }, markDirty);
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  function computedGetter() {
+    if (trackingSuspended) {
+      if (cs._d) {
+        cs._d = false;
+        cs._v = getter();
+      }
+      return cs._v;
+    }
+    recordDependency(cs);
+    if (cs._d) {
+      const oldValue = cs._v;
+      cs._d = false;
+      suspendTracking();
+      try {
+        cs._v = getter();
+      } finally {
+        resumeTracking();
+      }
+      if (hook && oldValue !== cs._v) {
+        hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
+      }
+    }
+    return cs._v;
+  }
+  if (debugName) {
+    computedGetter.__name = debugName;
+    cs.__name = debugName;
+  }
+  computedGetter.__signal = cs;
+  if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
+  return computedGetter;
+}
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+
+// src/core/signals/effect.ts
+function effect(effectFn) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  let runCount = 0;
+  let cleanupHandle = () => {
+  };
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  const subscriber = () => {
+    cleanupHandle();
+    runCount++;
+    if (hook) hook.emit("effect:run", { effectFn, runCount });
+    cleanupHandle = track(effectFn, subscriber);
+  };
+  cleanupHandle = track(effectFn, subscriber);
+  runCount = 1;
+  if (hook) hook.emit("effect:create", { effectFn });
+  return () => {
+    if (hook) hook.emit("effect:destroy", { effectFn });
+    cleanupHandle();
+  };
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function flushBatch() {
+  const signals = Array.from(pendingSignals);
+  pendingSignals.clear();
+  for (const signal2 of signals) {
+    queueSignalNotification(signal2);
+  }
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// 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);
+      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/core/rendering/context.ts
+function context(defaultValue) {
+  const [getValue, setValue] = signal(defaultValue);
+  return {
+    provide(value) {
+      setValue(value);
+    },
+    use() {
+      return getValue;
+    },
+    get() {
+      return getValue();
+    },
+    set(value) {
+      setValue(value);
+    }
+  };
+}
+
+// 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 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateDelay,
+  clearQueryCache,
+  debounce,
+  executeLoader,
+  getQueryData,
+  infiniteQuery,
+  invalidateQueries,
+  loaderData,
+  mutation,
+  offlineStore,
+  preloadRoute,
+  previous,
+  query,
+  resource,
+  setQueryData,
+  socket,
+  stream,
+  syncAdapter,
+  throttle,
+  withRetry
+});