@vielzeug/fetchit 1.0.3 → 1.1.1

package/dist/fetchit.js

@@ -1,186 +1,366 @@
-import { Logit as p } from "./logit/dist/logit.js";
-class y extends Error {
+import "./toolkit/dist/logit/dist/logit.js";
+import { retry as q } from "./toolkit/dist/async/retry.js";
+const M = 0, Q = 5 * 6e4, W = 3e4, K = 3, x = !0, z = "application/json", G = "content-type";
+class _ extends Error {
   url;
   method;
   status;
-  originalError;
-  constructor(e, r, n, o, a) {
-    super(e), this.name = "HttpError", this.url = r, this.method = n, this.status = o, this.originalError = a;
+  original;
+  constructor(c, p, a, h, i) {
+    super(c), this.name = "HttpError", this.url = p, this.method = a, this.status = h, this.original = i;
   }
 }
-const C = 5e3, R = 12e4, j = {
-  ABORTED: 499,
-  BAD_REQUEST: 400,
-  CONFLICT: 409,
-  FORBIDDEN: 403,
-  NOT_ALLOWED: 405,
-  NOT_FOUND: 404,
-  PRE_CONDITION: 412,
-  TIMEOUT: 408,
-  UNAUTHORIZED: 401
-}, u = {
-  ERROR: "ERROR",
-  PENDING: "PENDING",
-  SUCCESS: "SUCCESS"
-}, i = /* @__PURE__ */ new Map();
-function T(t, e) {
-  if (e.id) return e.id;
-  const { method: r = "GET", body: n, headers: o } = e;
-  return JSON.stringify({ body: n, headers: o, method: r, url: t });
+function k(t) {
+  return t instanceof Error ? t : new Error(String(t));
 }
-function f(t, e, r, n, o) {
-  const a = Date.now() - o, s = t.toLowerCase(), c = r.method?.toUpperCase() ?? "GET", l = O(e), h = t === "SUCCESS" ? "✓" : "✕";
-  p[s](`HTTP::${c}(…/${l}) ${h} ${a}ms`, {
-    req: r,
-    res: n,
-    url: e
-  });
+function X(t, c, p) {
+  const a = (t || "").replace(/\/+$/, ""), h = c.replace(/^\/+/, ""), i = a ? `${a}/${h}` : h;
+  if (!p) return i;
+  const y = Object.entries(p).filter(([, g]) => g !== void 0).map(([g, S]) => `${encodeURIComponent(g)}=${encodeURIComponent(String(S))}`).join("&");
+  return y ? `${i}${i.includes("?") ? "&" : "?"}${y}` : i;
 }
-function O(t) {
-  return t.replace(/^https?:\/\/[^/]+\//, "");
+function Z(t) {
+  return typeof FormData < "u" && t instanceof FormData || typeof Blob < "u" && t instanceof Blob || typeof URLSearchParams < "u" && t instanceof URLSearchParams || typeof t == "string" || t instanceof ArrayBuffer || t && typeof t == "object" && Object.prototype.toString.call(t) === "[object ArrayBuffer]" ? !0 : !!ArrayBuffer.isView?.(t);
 }
-async function E(t, e, { id: r, retries: n = 2 }) {
-  const o = Date.now(), a = e.method?.toUpperCase() ?? "GET";
+function j(t) {
+  return t === null ? "null" : t === void 0 ? "undefined" : typeof t != "object" ? JSON.stringify(t) : Array.isArray(t) ? `[${t.map((a) => j(a)).join(",")}]` : `{${Object.keys(t).sort().map((a) => `${JSON.stringify(a)}:${j(t[a])}`).join(",")}}`;
+}
+function tt(t) {
+  if (t == null)
+    return "null";
+  if (typeof FormData < "u" && t instanceof FormData)
+    return "[FormData]";
+  if (typeof Blob < "u" && t instanceof Blob)
+    return `[Blob:${t.size}:${t.type}]`;
+  if (typeof URLSearchParams < "u" && t instanceof URLSearchParams)
+    return `[URLSearchParams:${t.toString()}]`;
+  if (t instanceof ArrayBuffer)
+    return `[ArrayBuffer:${t.byteLength}]`;
+  if (ArrayBuffer.isView?.(t))
+    return `[ArrayBufferView:${t.byteLength}]`;
+  if (typeof t == "string")
+    return t;
+  if (typeof t == "object")
+    try {
+      return j(t);
+    } catch {
+      return "[Object]";
+    }
   try {
-    const s = await fetch(t, e), c = await S(s);
-    return f("SUCCESS", t, e, c, o), d(r, u.SUCCESS), { data: c, ok: s.ok, status: s.status };
-  } catch (s) {
-    if (f("ERROR", t, e, s, o), d(r, u.ERROR), n > 0 && s instanceof TypeError)
-      return E(t, e, { id: r, retries: n - 1 });
-    throw new y(s instanceof Error ? s.message : "Request failed", t, a, void 0, s);
-  } finally {
-    r && e.method !== "GET" && i.delete(r);
+    return JSON.stringify(t);
+  } catch {
+    return "[Unknown]";
   }
 }
-async function S(t) {
-  if (t.status === 204 || t.headers.get("content-length") === "0")
-    return;
-  const e = t.headers.get("content-type") ?? "";
-  return e.includes("application/json") ? t.json() : e.includes("text") ? t.text() : t.blob();
-}
-function d(t, e) {
-  const r = t ? i.get(t) : void 0;
-  r && (r.status = e);
-}
-async function b(t, e, r) {
-  const n = T(t, e);
-  let o = i.get(n);
-  if (o && m(e, o) && (o.controller.abort("Request aborted"), i.delete(n), o = void 0), o && U(o))
-    return o.request;
-  const a = new AbortController(), s = D(t, r), c = N(e, r, a), l = E(s, c, { id: n });
-  return i.set(n, {
-    controller: a,
-    expiresIn: Date.now() + (r?.expiresIn ?? R),
-    request: l,
-    status: u.PENDING
-  }), l;
-}
-function m(t, e) {
-  return t.invalidate ? !0 : e ? t.cancelable && e.status === u.PENDING || e.status === u.ERROR : !1;
-}
-function U(t) {
-  return Date.now() <= t.expiresIn;
-}
-function D(t, e) {
-  if (!e?.url) return t;
-  const r = e.url.replace(/\/+$/, ""), n = t.replace(/^\/+/, "");
-  return `${r}/${n}`;
-}
-function I(t) {
-  return t instanceof FormData || t instanceof Blob || t instanceof ArrayBuffer || t instanceof URLSearchParams || typeof t == "string";
-}
-function N(t, e, r) {
-  const n = e?.timeout ?? C, o = AbortSignal.any([r.signal, AbortSignal.timeout(n)]);
-  let a;
-  const s = {};
-  return t.body !== void 0 && (I(t.body) ? a = t.body : (a = JSON.stringify(t.body), s["Content-Type"] = "application/json")), {
-    ...t,
-    body: a,
-    headers: w(e?.headers, t.headers, s),
-    signal: o
+function et(t, c) {
+  if (t === 0 || t === Number.POSITIVE_INFINITY) {
+    if (c)
+      return {
+        clear: () => {
+        },
+        signal: c
+      };
+    const i = new AbortController();
+    return {
+      clear: () => {
+      },
+      signal: i.signal
+    };
+  }
+  if (typeof AbortSignal < "u" && "timeout" in AbortSignal && !c) {
+    const i = AbortSignal.timeout(t);
+    return {
+      clear: () => {
+      },
+      // No cleanup needed for native timeout
+      signal: i
+    };
+  }
+  const p = new AbortController(), a = () => p.abort();
+  c && (c.aborted ? p.abort() : c.addEventListener("abort", a, { once: !0 }));
+  const h = setTimeout(() => p.abort(), t);
+  return {
+    clear: () => {
+      clearTimeout(h), c && c.removeEventListener("abort", a);
+    },
+    signal: p.signal
   };
 }
-function g(t) {
-  const e = {};
-  if (t instanceof Headers)
-    t.forEach((r, n) => {
-      e[n] = r;
-    });
-  else if (Array.isArray(t))
-    for (const [r, n] of t)
-      e[r] = n;
-  else
-    for (const [r, n] of Object.entries(t))
-      e[r] = n;
-  return e;
-}
-function w(t, e, r) {
-  const n = {};
-  if (t)
-    for (const [o, a] of Object.entries(t))
-      a !== void 0 && (n[o] = a);
-  return e && Object.assign(n, g(e)), r && Object.assign(n, r), n;
-}
-function P(t, e) {
-  if (!e || Object.keys(e).length === 0)
-    return t;
-  const r = new URL(t);
-  for (const [n, o] of Object.entries(e))
-    o !== void 0 && r.searchParams.append(n, String(o));
-  return r.toString();
+async function rt(t) {
+  if (t.status === 204)
+    return;
+  const c = t.headers.get(G) ?? "";
+  if (c.includes(z))
+    return await t.json();
+  if (c.startsWith("text/"))
+    return await t.text();
+  try {
+    return await t.blob();
+  } catch {
+    return await t.text();
+  }
 }
-function v(t = { url: "" }) {
-  const e = (r) => (n, o = {}) => b(n, { ...o, method: r }, t);
+function st(t = {}) {
+  const {
+    baseUrl: c = "",
+    headers: p = {},
+    timeout: a = W,
+    dedupe: h = x,
+    logger: i
+  } = t;
+  let y = { ...p };
+  const g = /* @__PURE__ */ new Map();
+  function S(f, d, C) {
+    i && i(f, d, C);
+  }
+  async function A(f, d, C = {}) {
+    const T = X(c, d, C.params), E = (f || "GET").toUpperCase(), { body: w, headers: F, dedupe: R, signal: B, ...N } = C, $ = R !== !1 && h, e = $ ? JSON.stringify({
+      body: tt(w),
+      full: T,
+      m: E
+    }) : "";
+    if ($ && g.has(e))
+      return g.get(e);
+    const { signal: n, clear: r } = et(a, B ?? null), s = {
+      method: E,
+      ...N,
+      headers: { ...y, ...F },
+      signal: n
+    };
+    w !== void 0 && !Z(w) ? (s.body = JSON.stringify(w), s.headers = { [G]: z, ...s.headers }) : w !== void 0 && (s.body = w);
+    const m = (async () => {
+      const l = Date.now();
+      try {
+        const u = await fetch(T, s), b = await rt(u);
+        if (S("info", `${E} ${T} - ${u.status} (${Date.now() - l}ms)`, { req: s, res: b }), !u.ok) throw new _("Non-OK response", T, E, u.status, b);
+        return b;
+      } catch (u) {
+        throw S("error", `${E} ${T} - ERROR`, u), u instanceof _ ? u : new _(k(u).message, T, E, void 0, u);
+      } finally {
+        r(), $ && g.delete(e);
+      }
+    })();
+    return $ && g.set(e, m), m;
+  }
   return {
-    /**
-     * Cleans up expired cache entries.
-     * Returns the number of entries removed.
-     */
-    cleanupCache() {
-      const r = Date.now(), n = Array.from(i.entries()).filter(([, o]) => r > o.expiresIn).map(([o]) => o);
-      for (const o of n)
-        i.delete(o);
-      return n.length;
-    },
-    /**
-     * Clears all cached requests.
-     */
-    clearCache() {
-      i.clear();
-    },
-    delete: e("DELETE"),
-    get: e("GET"),
-    /**
-     * Returns the number of cached requests.
-     */
-    getCacheSize() {
-      return i.size;
-    },
-    /**
-     * Invalidates a specific cache entry by id or URL.
-     */
-    invalidateCache(r) {
-      return i.delete(r);
-    },
-    patch: e("PATCH"),
-    post: e("POST"),
-    put: e("PUT"),
-    /**
-     * Updates the service headers.
-     * Headers with undefined values will be removed.
-     */
-    setHeaders(r) {
-      t.headers = Object.fromEntries(
-        Object.entries({ ...t.headers, ...r }).filter(([, n]) => n !== void 0)
+    delete: (f, d) => A("DELETE", f, d),
+    get: (f, d) => A("GET", f, d),
+    getHeaders: () => ({ ...y }),
+    patch: (f, d) => A("PATCH", f, d),
+    post: (f, d) => A("POST", f, d),
+    put: (f, d) => A("PUT", f, d),
+    request: A,
+    setHeaders(f) {
+      y = Object.fromEntries(
+        Object.entries({ ...y, ...f }).filter(([, d]) => d !== void 0)
       );
     }
   };
 }
+function at(t) {
+  const c = t?.cache?.staleTime ?? t?.staleTime ?? M, p = t?.cache?.gcTime ?? t?.gcTime ?? Q, a = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map();
+  function i(e) {
+    return j(e);
+  }
+  function y(e) {
+    const n = i(e);
+    let r = a.get(n);
+    return r || (r = {
+      abortController: null,
+      data: void 0,
+      dataUpdatedAt: 0,
+      error: null,
+      errorUpdatedAt: 0,
+      fetchedAt: 0,
+      gcTimer: null,
+      observers: /* @__PURE__ */ new Set(),
+      promise: null,
+      status: "idle"
+    }, a.set(n, r), h.set(n, n)), r;
+  }
+  function g(e) {
+    const n = {
+      data: e.data,
+      dataUpdatedAt: e.dataUpdatedAt,
+      error: e.error,
+      errorUpdatedAt: e.errorUpdatedAt,
+      fetchedAt: e.fetchedAt,
+      isError: e.status === "error",
+      isIdle: e.status === "idle",
+      isLoading: e.status === "pending",
+      isSuccess: e.status === "success",
+      status: e.status
+    };
+    e.observers.forEach((r) => {
+      try {
+        r(n);
+      } catch {
+      }
+    });
+  }
+  function S(e, n, r) {
+    n.gcTimer && (clearTimeout(n.gcTimer), n.gcTimer = null), r > 0 && (n.gcTimer = setTimeout(() => {
+      a.delete(e), h.delete(e);
+    }, r));
+  }
+  function A(e) {
+    e.abortController?.abort(), e.gcTimer && (clearTimeout(e.gcTimer), e.gcTimer = null);
+  }
+  function f(e, n, r = K) {
+    const s = e === !1 ? 1 : (e ?? r) + 1;
+    let m, l;
+    return typeof n == "function" ? (m = void 0, l = (u) => n(u - 1)) : typeof n == "number" ? (m = n, l = void 0) : (m = 1e3, l = (u, b) => Math.min(b * 2, 3e4)), { backoff: l, delay: m, times: s };
+  }
+  async function d(e) {
+    const {
+      queryKey: n,
+      queryFn: r,
+      staleTime: s = c,
+      gcTime: m = p,
+      enabled: l = !0,
+      retry: u = K,
+      retryDelay: b,
+      onSuccess: L,
+      onError: P
+    } = e;
+    if (!l) throw new Error("Query disabled");
+    const I = i(n), o = y(n);
+    if (o.status === "success" && Date.now() - o.dataUpdatedAt < s)
+      return o.data;
+    if (o.promise) return o.promise;
+    const U = new AbortController();
+    o.abortController = U, o.status = "pending", g(o);
+    const { times: V, delay: Y, backoff: v } = f(u, b), H = (async () => {
+      try {
+        const O = await q(() => r(), { backoff: v, delay: Y, signal: U.signal, times: V }), D = Date.now();
+        o.data = O, o.status = "success", o.dataUpdatedAt = D, o.fetchedAt = D, o.error = null, o.promise = null, o.abortController = null, S(I, o, m);
+        try {
+          L?.(O);
+        } catch {
+        }
+        return g(o), O;
+      } catch (O) {
+        const D = k(O), J = U.signal.aborted || D.name === "AbortError";
+        J ? (o.status = "idle", o.error = null) : (o.status = "error", o.error = D, o.errorUpdatedAt = Date.now()), o.promise = null, o.abortController = null;
+        try {
+          J || P?.(D);
+        } catch {
+        }
+        throw g(o), D;
+      }
+    })();
+    return o.promise = H, H;
+  }
+  async function C(e) {
+    return d({ ...e, enabled: !0 }).catch(() => {
+    });
+  }
+  function T(e) {
+    const n = i(e), r = a.get(n);
+    if (r) {
+      A(r), a.delete(n), h.delete(n);
+      return;
+    }
+    const s = [], m = n.slice(0, -1);
+    for (const [l, u] of h.entries())
+      if (u === n || // Exact match
+      u.startsWith(`${m},`)) {
+        const L = a.get(l);
+        L && A(L), s.push(l);
+      }
+    for (const l of s)
+      a.delete(l), h.delete(l);
+  }
+  function E() {
+    a.forEach(A), a.clear(), h.clear();
+  }
+  function w(e, n) {
+    const r = i(e), s = y(e);
+    s.data = typeof n == "function" ? n(s.data) : n, s.dataUpdatedAt = Date.now(), s.fetchedAt = s.fetchedAt || Date.now(), s.status = "success", S(r, s, p), g(s);
+  }
+  function F(e) {
+    const n = i(e);
+    return a.get(n)?.data ?? void 0;
+  }
+  function R(e) {
+    const n = i(e), r = a.get(n);
+    return r ? {
+      data: r.data,
+      dataUpdatedAt: r.dataUpdatedAt,
+      error: r.error,
+      errorUpdatedAt: r.errorUpdatedAt,
+      fetchedAt: r.fetchedAt,
+      isError: r.status === "error",
+      isIdle: r.status === "idle",
+      isLoading: r.status === "pending",
+      isSuccess: r.status === "success",
+      status: r.status
+    } : null;
+  }
+  function B(e, n) {
+    const r = y(e);
+    r.observers.add(n);
+    const s = {
+      data: r.data,
+      dataUpdatedAt: r.dataUpdatedAt,
+      error: r.error,
+      errorUpdatedAt: r.errorUpdatedAt,
+      fetchedAt: r.fetchedAt,
+      isError: r.status === "error",
+      isIdle: r.status === "idle",
+      isLoading: r.status === "pending",
+      isSuccess: r.status === "success",
+      status: r.status
+    };
+    return n(s), () => r.observers.delete(n);
+  }
+  function N(e, n) {
+    const r = i(e), s = a.get(r);
+    s && s.observers.delete(n);
+  }
+  async function $(e, n) {
+    const { mutationFn: r, onSuccess: s, onError: m, onSettled: l, retry: u = !1, retryDelay: b } = e, { times: L, delay: P, backoff: I } = f(u, b, 0);
+    try {
+      const o = await q(() => r(n), { backoff: I, delay: P, times: L });
+      try {
+        s?.(o, n);
+      } catch {
+      }
+      try {
+        l?.(o, null, n);
+      } catch {
+      }
+      return o;
+    } catch (o) {
+      const U = k(o);
+      try {
+        m?.(U, n);
+      } catch {
+      }
+      try {
+        l?.(void 0, U, n);
+      } catch {
+      }
+      throw U;
+    }
+  }
+  return {
+    clearCache: E,
+    fetch: d,
+    getCacheSize: () => a.size,
+    getData: F,
+    getState: R,
+    invalidate: T,
+    mutate: $,
+    prefetch: C,
+    setData: w,
+    subscribe: B,
+    unsubscribe: N
+  };
+}
 export {
-  y as HttpError,
-  j as RequestErrorType,
-  u as RequestStatus,
-  P as buildUrl,
-  v as createHttpClient
+  _ as HttpError,
+  st as createHttpClient,
+  at as createQueryClient
 };
 //# sourceMappingURL=fetchit.js.map