@net-vert/core 0.5.1 → 1.2.0

package/dist/index.js

@@ -1,338 +1,698 @@
-import E from "localforage";
-import { TaskQueue as j } from "id-queue";
-const k = {
-  get: (t, e) => ({
-    url: t,
-    method: "get",
-    ...e,
-    params: e == null ? void 0 : e.params
-  }),
-  post: (t, e, r) => ({
-    url: t,
-    method: "post",
-    data: e,
-    headers: { "Content-Type": "application/json", ...r == null ? void 0 : r.headers },
-    ...r
-  }),
-  delete: (t, e) => ({
-    url: t,
-    method: "delete",
-    ...e
-  }),
-  put: (t, e, r) => ({
-    url: t,
-    method: "put",
-    data: e,
-    headers: { "Content-Type": "application/json", ...r == null ? void 0 : r.headers },
-    ...r
-  }),
-  request: (t) => t
+var D = Object.defineProperty;
+var F = (r, e, t) => e in r ? D(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var l = (r, e, t) => F(r, typeof e != "symbol" ? e + "" : e, t);
+import { TaskQueue as $ } from "id-queue";
+var w = /* @__PURE__ */ ((r) => (r.GET = "get", r.POST = "post", r.PUT = "put", r.DELETE = "delete", r))(w || {}), y = /* @__PURE__ */ ((r) => (r.CACHE = "cache", r.RETRY = "retry", r.IDEMPOTENT = "idempotent", r.CONCURRENT = "concurrent", r.SYNC = "sync", r))(y || {});
+const v = "default", E = {
+  retries: 3,
+  delay: 0,
+  retryCondition: () => !0
+}, T = (r) => {
+  const e = { ...E, ...r };
+  return Object.assign(async ({ config: n, next: s }) => {
+    let o = 0, i;
+    for (; o <= e.retries; )
+      try {
+        return await s();
+      } catch (a) {
+        if (i = a, o === e.retries)
+          throw a;
+        const c = {
+          config: n,
+          lastResponse: a,
+          attempt: o
+        };
+        if (!e.retryCondition(c))
+          throw a;
+        o++;
+        const u = typeof e.delay == "function" ? e.delay(c) : e.delay;
+        u > 0 && await new Promise((h) => setTimeout(h, u));
+      }
+    throw i;
+  }, { __middlewareType: y.RETRY });
+}, q = () => {
+  const r = /* @__PURE__ */ new Map();
+  return { getPromise: (o) => r.get(o), setPromise: (o, i) => {
+    r.set(o, i), i.finally(() => r.delete(o));
+  }, delPromise: (o) => r.delete(o), clearCache: () => r.clear() };
+}, R = (r) => {
+  const { config: e } = r, { method: t, url: n, data: s } = e;
+  return [t, n, JSON.stringify(s)].join("|");
+}, B = {
+  key: R
+}, _ = (r) => {
+  const e = { ...B, ...r }, t = q();
+  return Object.assign(({ config: s, next: o }) => {
+    const i = e.key({ config: s }), a = t.getPromise(i);
+    if (a)
+      return a;
+    const c = o();
+    return t.setPromise(i, c), c;
+  }, {
+    __middlewareType: y.IDEMPOTENT,
+    promiseCache: t
+  });
 };
-function T(t) {
-  const e = {};
-  return Object.keys(k).forEach(
-    (r) => {
-      e[r] = (...o) => {
-        const n = k[r](...o);
-        return t(n);
-      };
+class K {
+  constructor(e = 4) {
+    l(this, "parallelCount");
+    l(this, "tasks");
+    l(this, "runningCount");
+    this.parallelCount = e, this.tasks = new $(), this.runningCount = 0;
+  }
+  // 加入
+  add(e, t) {
+    return new Promise((n, s) => {
+      this.tasks.enqueue(e, {
+        task: t,
+        resolve: n,
+        reject: s
+      }), this._run();
+    });
+  }
+  // 删除
+  remove(e) {
+    this.tasks.remove(e);
+  }
+  execute(e) {
+    const { task: t, resolve: n, reject: s } = e;
+    return t().then(n).catch(s).finally(() => {
+      this.runningCount--, this._run();
+    });
+  }
+  _run() {
+    for (; this.runningCount < this.parallelCount && this.tasks.size > 0; ) {
+      const e = this.tasks.dequeue();
+      this.runningCount++, this.execute(e);
     }
-  ), e;
+  }
 }
-const M = "default", z = () => `${Date.now()}_${Math.random().toString().slice(2, 8)}`, I = /* @__PURE__ */ new Map(), Z = (t, e = M) => {
-  I.set(e, T(t));
-}, v = (t = M) => {
-  const e = I.get(t);
-  if (!e) throw new Error(`Requestor实例 ${t} 未注册`);
-  return e;
+let A = 0;
+const J = {
+  parallelCount: 4,
+  createId: () => A++
+}, z = (r) => {
+  const { parallelCount: e, createId: t } = { ...J, ...r }, n = new K(e);
+  return Object.assign(({ config: o, next: i }) => {
+    const a = t({ config: o });
+    return n.add(a, () => i());
+  }, { __middlewareType: y.CONCURRENT, pool: n });
+}, b = /* @__PURE__ */ new Map(), g = (r, e) => {
+  b.set(e, r);
 };
-class O {
-  has(e) {
-    return !!this.get(e);
-  }
-  // 获取缓存
-  get(e) {
-    const r = localStorage.getItem(e);
-    if (r)
+function G(r) {
+  const e = b.get(r);
+  if (!e)
+    throw new Error(`Store实例 ${String(r)} 未注册`);
+  return e;
+}
+class U {
+  constructor() {
+    l(this, "store", /* @__PURE__ */ new Map());
+  }
+  getItem(e) {
+    return this.store.get(e);
+  }
+  setItem(e, t) {
+    return this.store.set(e, t), t;
+  }
+  removeItem(e) {
+    this.store.delete(e);
+  }
+  clear() {
+    this.store.clear();
+  }
+  length() {
+    return this.store.size;
+  }
+  key(e) {
+    return Array.from(this.store.keys())[e];
+  }
+  keys() {
+    return Array.from(this.store.keys());
+  }
+  iterate(e) {
+    let t = 0;
+    for (const [n, s] of this.store.entries())
+      e(s, n, t), t++;
+  }
+}
+const Y = (r) => !!r && (typeof r == "object" || typeof r == "function") && typeof r.then == "function", N = (r) => typeof window < "u" ? r() : {
+  getItem() {
+    return null;
+  },
+  setItem() {
+  },
+  removeItem() {
+  },
+  clear() {
+  },
+  key() {
+    return null;
+  },
+  get length() {
+    return 0;
+  }
+}, d = N(() => window.localStorage);
+class M {
+  constructor() {
+  }
+  getItem(e) {
+    const t = String(e), n = d.getItem(t);
+    if (n !== null)
       try {
-        return JSON.parse(r);
-      } catch (o) {
-        console.error("Error parsing cached data", o);
+        return JSON.parse(n);
+      } catch (s) {
+        console.error(`Failed to parse value for key: ${t}`, s);
         return;
       }
   }
-  // 设置缓存
-  set(e, r) {
+  setItem(e, t) {
+    const n = String(e);
     try {
-      const o = JSON.stringify(r);
-      localStorage.setItem(e, o);
-    } catch (o) {
-      console.error("Error saving data to localStorage", o);
+      d.setItem(n, JSON.stringify(t));
+    } catch (s) {
+      throw console.error(`Failed to set value for key: ${n}`, s), s;
     }
-    return r;
+    return t;
   }
-  // 删除缓存
-  remove(e) {
-    localStorage.removeItem(e);
+  removeItem(e) {
+    const t = String(e);
+    d.removeItem(t);
   }
-  // 清空所有缓存
   clear() {
-    localStorage.clear();
+    d.clear();
   }
-}
-const H = new O(), U = ({ persist: t, name: e, sync: r }) => {
-  if (t && r)
-    return H;
-  if (t) {
-    const o = E.createInstance({
-      name: e
-      // driver: sync
-      // ?undefined
-      // :localforage.LOCALSTORAGE,
-    });
-    return {
-      has: (n) => o.keys().then((s) => s.includes(n)),
-      get: (n) => o.getItem(n),
-      set: (n, s) => o.setItem(n, s),
-      remove: (n) => o.removeItem(n),
-      clear: () => o.clear()
-    };
-  } else {
-    const o = /* @__PURE__ */ new Map();
-    return {
-      has: (n) => o.has(n),
-      get: (n) => o.get(n),
-      set: (n, s) => o.set(n, s),
-      remove: (n) => o.delete(n),
-      clear: () => o.clear()
-    };
-  }
-}, _ = () => {
-  const t = /* @__PURE__ */ new Map();
-  return {
-    getPromise: (s) => t.get(s),
-    setPromise: (s, u) => {
-      t.set(s, u);
-    },
-    delPromise: (s) => {
-      t.delete(s);
-    },
-    clearCache: () => {
-      t.clear();
+  length() {
+    return d.length;
+  }
+  key(e) {
+    return d.key(e);
+  }
+  keys() {
+    const e = [];
+    for (let t = 0; t < d.length; t++) {
+      const n = d.key(t);
+      n && e.push(n);
     }
-  };
-}, A = (t, e) => ({
-  value: t,
-  expiresAt: Date.now() + e
-}), x = (t) => t.expiresAt > Date.now(), J = {
-  key: (t) => t.url,
-  persist: !1,
-  duration: 1 / 0,
-  sync: !1
-}, S = (t) => {
-  const e = { ...J, ...t }, { name: r, persist: o, sync: n } = e, s = U({ persist: o, name: r, sync: n }), { getPromise: u, setPromise: P, delPromise: g } = _();
-  function l(a, h) {
-    const { isValid: i } = e, f = s.get(a);
-    let C = !1;
-    if (f && x(f)) {
+    return e;
+  }
+  iterate(e) {
+    this.keys().forEach((t, n) => {
+      const s = this.getItem(t);
+      s !== void 0 && e(s, t, n);
+    });
+  }
+}
+const m = N(() => window.sessionStorage);
+class X {
+  constructor() {
+  }
+  getItem(e) {
+    const t = String(e), n = m.getItem(t);
+    if (n !== null)
       try {
-        C = (i == null ? void 0 : i({
-          key: a,
-          config: h,
-          cachedData: f
-        })) ?? !0;
-      } catch (c) {
-        console.error(`校验异常 ${a}`, c);
+        return JSON.parse(n);
+      } catch (s) {
+        console.error(`Failed to parse value for key: ${t}`, s);
+        return;
       }
-      !C && s.remove(a);
+  }
+  setItem(e, t) {
+    const n = String(e);
+    try {
+      m.setItem(n, JSON.stringify(t));
+    } catch (s) {
+      throw console.error(`Failed to set value for key: ${n}`, s), s;
     }
-    return { shouldUseCache: C, cachedData: f };
+    return t;
   }
-  async function d(a, h) {
-    const { isValid: i } = e, f = await s.get(a);
-    let C = !1;
-    if (f && x(f)) {
-      try {
-        C = await (i == null ? void 0 : i({
-          key: a,
-          config: h,
-          cachedData: f
-        })) ?? !0;
-      } catch (c) {
-        console.error(`校验异常 ${a}`, c);
-      }
-      !C && s.remove(a);
+  removeItem(e) {
+    const t = String(e);
+    m.removeItem(t);
+  }
+  clear() {
+    m.clear();
+  }
+  length() {
+    return m.length;
+  }
+  key(e) {
+    return m.key(e);
+  }
+  keys() {
+    const e = [];
+    for (let t = 0; t < m.length; t++) {
+      const n = m.key(t);
+      n && e.push(n);
     }
-    return { shouldUseCache: C, cachedData: f };
-  }
-  const p = {
-    get(a, h) {
-      function i(c, y, ...m) {
-        const q = Reflect.apply(a[h], a, m).then(async (w) => {
-          const R = typeof e.duration == "number" ? e.duration : e.duration({
-            key: c,
-            config: y,
-            response: w
-          });
-          return s.set(c, A(w, R)), w;
-        }).finally(() => {
-          g(c);
-        });
-        return P(c, q), q;
-      }
-      return n ? (...c) => {
-        const y = k[h](...c), m = e.key(y), q = u(m);
-        if (q)
-          return q;
-        const { shouldUseCache: w, cachedData: R } = l(m, y);
-        return w ? R.value : i(m, y, ...c);
-      } : (...c) => {
-        const y = k[h](...c), m = e.key(y), q = u(m);
-        if (q)
-          return q;
-        const w = (async () => {
-          try {
-            const { shouldUseCache: R, cachedData: D } = await d(m, y);
-            return R ? D.value : await i(m, y, ...c);
-          } finally {
-            g(m);
-          }
-        })();
-        return P(m, w), w;
-      };
+    return e;
+  }
+  iterate(e) {
+    this.keys().forEach((t, n) => {
+      const s = this.getItem(t);
+      s !== void 0 && e(s, t, n);
+    });
+  }
+}
+class Z {
+  constructor(e, t) {
+    l(this, "dbName");
+    l(this, "storeName");
+    l(this, "dbPromise", null);
+    l(this, "DB_VERSION", 1);
+    this.dbName = e, this.storeName = t, this.initDB();
+  }
+  /**
+   * 初始化数据库连接
+   */
+  initDB() {
+    if (typeof window > "u" || !window.indexedDB) {
+      console.warn("IndexedDB is not available");
+      return;
     }
-  };
-  return {
-    requestor: new Proxy(v(), p),
-    store: s
-  };
-}, N = (t) => {
-  const { method: e, url: r, params: o, data: n } = t;
-  return [e, r, JSON.stringify(o), JSON.stringify(n)].join("|");
-}, b = {
-  key: N,
-  duration: 1e3
-}, F = (t) => {
-  const e = { ...b, ...t }, {
-    requestor: r,
-    store: o
-  } = S({
-    ...e,
-    persist: !1
-  });
-  return {
-    requestor: r,
-    store: o
-  };
-}, L = {
-  retries: 3,
-  delay: 0,
-  retryCondition: () => !0
-}, $ = (t) => {
-  const { retries: e, delay: r, retryCondition: o } = { ...L, ...t }, n = {
-    get(s, u) {
-      return (...g) => {
-        let l = 0;
-        const d = () => Reflect.apply(s[u], s, g).catch((p) => {
-          if (l < e && o(p)) {
-            l++;
-            const a = typeof r == "function" ? r(l) : r;
-            return new Promise((h) => {
-              setTimeout(() => h(d()), a);
-            });
-          }
-          return Promise.reject(p);
-        });
-        return d();
+    this.dbPromise = new Promise((e, t) => {
+      const n = indexedDB.open(this.dbName, this.DB_VERSION);
+      n.onerror = () => {
+        t(new Error(`Failed to open database: ${this.dbName}`));
+      }, n.onsuccess = () => {
+        e(n.result);
+      }, n.onupgradeneeded = (s) => {
+        const o = s.target.result;
+        o.objectStoreNames.contains(this.storeName) || o.createObjectStore(this.storeName);
+      };
+    });
+  }
+  /**
+   * 获取数据库实例
+   */
+  async getDB() {
+    if (!this.dbPromise)
+      throw new Error("IndexedDB is not initialized");
+    return this.dbPromise;
+  }
+  /**
+   * 执行事务
+   */
+  async withStore(e, t) {
+    const n = await this.getDB();
+    return new Promise((s, o) => {
+      const i = n.transaction([this.storeName], e).objectStore(this.storeName), a = t(i);
+      a.onsuccess = () => {
+        s(a.result);
+      }, a.onerror = () => {
+        o(a.error);
       };
+    });
+  }
+  async getItem(e) {
+    try {
+      const t = await this.withStore("readonly", (n) => n.get(String(e)));
+      return t === void 0 ? void 0 : t;
+    } catch (t) {
+      console.error(`Failed to get value for key: ${String(e)}`, t);
+      return;
     }
-  };
+  }
+  async setItem(e, t) {
+    try {
+      return await this.withStore("readwrite", (n) => n.put(t, String(e))), t;
+    } catch (n) {
+      throw console.error(`Failed to set value for key: ${String(e)}`, n), n;
+    }
+  }
+  async removeItem(e) {
+    try {
+      await this.withStore("readwrite", (t) => t.delete(String(e)));
+    } catch (t) {
+      throw console.error(`Failed to remove value for key: ${String(e)}`, t), t;
+    }
+  }
+  async clear() {
+    try {
+      await this.withStore("readwrite", (e) => e.clear());
+    } catch (e) {
+      throw console.error("Failed to clear storage", e), e;
+    }
+  }
+  async length() {
+    try {
+      return await this.withStore("readonly", (e) => e.count());
+    } catch (e) {
+      return console.error("Failed to get storage length", e), 0;
+    }
+  }
+  async key(e) {
+    try {
+      return (await this.withStore("readonly", (t) => t.getAllKeys()))[e];
+    } catch (t) {
+      console.error("Failed to get key", t);
+      return;
+    }
+  }
+  async keys() {
+    try {
+      return await this.withStore("readonly", (e) => e.getAllKeys());
+    } catch (e) {
+      return console.error("Failed to get all keys", e), [];
+    }
+  }
+  async iterate(e) {
+    try {
+      const t = (await this.getDB()).transaction([this.storeName], "readonly").objectStore(this.storeName).openCursor();
+      return new Promise((n, s) => {
+        let o = 0;
+        t.onsuccess = (i) => {
+          const a = i.target.result;
+          if (a) {
+            const c = a.key, u = a.value;
+            e(u, c, o), o++, a.continue();
+          } else
+            n();
+        }, t.onerror = () => {
+          s(t.error);
+        };
+      });
+    } catch (t) {
+      console.error("Failed to iterate storage", t);
+    }
+  }
+}
+const f = {
+  memory: "memory",
+  local: "local",
+  session: "session",
+  indexeddb: "indexeddb"
+};
+function x(r, e) {
+  Object.assign(r, e);
+}
+function H(r) {
+  return x(r, {
+    async getItemOrDefault(e, t) {
+      const n = await this.getItem(e);
+      return n !== null ? n : t;
+    },
+    async hasItem(e) {
+      return await this.getItem(e) !== null;
+    },
+    async removeItems(e) {
+      await Promise.all(e.map((t) => this.removeItem(t)));
+    },
+    async getItems(e) {
+      return await Promise.all(e.map((t) => this.getItem(t)));
+    }
+  }), r;
+}
+function L(r) {
+  return x(r, {
+    getItemOrDefault(e, t) {
+      const n = this.getItem(e);
+      return n !== null ? n : t;
+    },
+    hasItem(e) {
+      return this.getItem(e) !== null;
+    },
+    removeItems(e) {
+      e.forEach((t) => this.removeItem(t));
+    },
+    getItems(e) {
+      return e.map((t) => this.getItem(t));
+    }
+  }), r;
+}
+function Q(r) {
+  const e = r.getItem("");
+  return Y(e) ? H(r) : L(r);
+}
+function p(r, ...e) {
+  const t = G(r);
+  let n;
+  try {
+    n = new t(...e);
+  } catch {
+    n = t(...e);
+  }
+  return Q(n);
+}
+g(U, f.memory);
+g(M, f.local);
+g(X, f.session);
+g(Z, f.indexeddb);
+function I(r, e) {
   return {
-    requestor: new Proxy(v(), n)
+    value: r,
+    expireAt: Date.now() + e
   };
+}
+function k(r, e = Date.now()) {
+  return r.expireAt <= e;
+}
+function P(r, e = Date.now()) {
+  return k(r, e) ? void 0 : r.value;
+}
+const W = (r) => {
+  const { config: e } = r, { method: t, url: n, data: s } = e;
+  return [t, n, JSON.stringify(s)].join("|");
+}, ee = () => !0, S = 24 * 60 * 60 * 1e3, te = {
+  key: W,
+  duration: S,
+  isValid: ee,
+  store: f.memory
+  // 默认不持久化，使用内存存储
 };
-class Q {
-  constructor(e = 4) {
-    this.parallelCount = e, this.tasks = new j(), this.runningCount = 0;
-  }
-  // 加入
-  add(e, r) {
-    return new Promise((o, n) => {
-      this.tasks.enqueue(e, {
-        task: r,
-        resolve: o,
-        reject: n
-      }), this._run();
+let re = class {
+  constructor(e) {
+    l(this, "store");
+    return typeof e == "string" ? this.store = p(e) : (g(e.factory, e.key), this.store = p(e.key)), new Proxy(this, {
+      get(t, n) {
+        if (n in t)
+          return t[n];
+        const s = t.store[n];
+        return typeof s == "function" ? s.bind(t.store) : s;
+      }
     });
   }
-  // 删除
-  remove(e) {
-    this.tasks.remove(e);
+  /**
+   * 设置缓存（自动包装成 ExpirableValue）
+   * @param key 缓存 key
+   * @param value 要缓存的值
+   * @param duration 过期时长（毫秒），默认 24 小时
+   */
+  setCache(e, t, n = S) {
+    const s = I(t, n);
+    this.store.setItem(e, s);
   }
-  execute(e) {
-    const { task: r, resolve: o, reject: n } = e;
-    return r().then(o).catch(n).finally(() => {
-      this.runningCount--, this._run();
-    });
+  /**
+   * 获取缓存值（检查过期，如果过期返回 undefined）
+   * @param key 缓存 key
+   * @returns 未过期返回值，已过期返回 undefined
+   */
+  async getCache(e) {
+    const t = await this.store.getItem(e);
+    if (t)
+      return P(t);
   }
-  _run() {
-    for (; this.runningCount < this.parallelCount && this.tasks.size > 0; ) {
-      const e = this.tasks.dequeue();
-      this.runningCount++, this.execute(e);
+  /**
+   * 检查是否有有效的缓存（未过期）
+   * @param key 缓存 key
+   * @returns true 表示有有效缓存，false 表示无缓存或已过期
+   */
+  async hasValidCache(e) {
+    const t = await this.store.getItem(e);
+    return t ? !k(t) : !1;
+  }
+};
+const ne = re, se = (r) => {
+  const e = { ...te, ...r }, t = new ne(e.store), n = (o) => typeof e.duration == "function" ? e.duration(o) : e.duration;
+  return Object.assign(async ({ config: o, next: i }) => {
+    const a = e.key({ config: o }), c = await t.getCache(a);
+    if (c) {
+      if (await e.isValid({
+        key: a,
+        config: o,
+        cachedData: c
+      })) return c;
+      t.removeItem(a);
     }
+    const u = await i(), h = n({ key: a, config: o, cachedData: c, response: u }), C = I(u, h);
+    return t.setItem(a, C), u;
+  }, {
+    __middlewareType: y.CACHE,
+    storage: t
+  });
+};
+class oe {
+  constructor(e) {
+    l(this, "store");
+    return typeof e == "string" ? this.store = p(e) : (g(e.factory, e.key), this.store = p(e.key)), new Proxy(this, {
+      get(t, n) {
+        if (n in t)
+          return t[n];
+        const s = t.store[n];
+        return typeof s == "function" ? s.bind(t.store) : s;
+      }
+    });
+  }
+  /**
+   * 设置缓存（自动包装成 ExpirableValue）
+   * @param key 缓存 key
+   * @param value 要缓存的值
+   * @param duration 过期时长（毫秒），默认 24 小时
+   */
+  setCache(e, t, n = S) {
+    const s = I(t, n);
+    this.store.setItem(e, s);
+  }
+  /**
+   * 获取缓存值（检查过期，如果过期返回 undefined）
+   * @param key 缓存 key
+   * @returns 未过期返回值，已过期返回 undefined
+   */
+  getCache(e) {
+    const t = this.store.getItem(e);
+    if (t)
+      return P(t);
+  }
+  /**
+   * 检查是否有有效的缓存（未过期）
+   * @param key 缓存 key
+   * @returns true 表示有有效缓存，false 表示无缓存或已过期
+   */
+  hasValidCache(e) {
+    const t = this.store.getItem(e);
+    return t ? !k(t) : !1;
   }
 }
-const W = {
-  parallelCount: 4,
-  retries: 0,
-  createId: () => z()
-}, Y = (t) => {
-  const e = { ...W, ...t }, { parallelCount: r, createId: o, ...n } = e, s = new Q(r), { requestor: u = null } = n.retries > 0 ? $(n) : {}, P = {
-    get(g, l) {
-      return (...p) => {
-        const a = k[l](...p), h = o(a), i = () => u ? Reflect.apply(u[l], u, p) : Reflect.apply(g[l], g, p);
-        return s.add(h, i);
-      };
+const ae = oe, ie = (r) => {
+  const { config: e } = r, { method: t, url: n } = e;
+  return [t, n].join("|");
+}, ce = {
+  suspense: !0,
+  key: ie,
+  duration: 24 * 60 * 60 * 1e3,
+  isValid: () => !0,
+  store: f.memory
+};
+function we(r) {
+  const e = { ...ce, ...r }, t = new ae(e.store), n = (o) => typeof e.duration == "function" ? e.duration(o) : e.duration;
+  return Object.assign(({ config: o, next: i }) => {
+    const a = e.key({ config: o }), c = t.getCache(a);
+    if (c) {
+      if (e.isValid({
+        key: a,
+        config: o,
+        cachedData: c
+      })) return c;
+      t.removeItem(a);
     }
+    if (e.suspense)
+      throw (e.wrapSuspense ? e.wrapSuspense({ key: a, config: o, p: i() }) : i()).then((h) => {
+        const C = n({ key: a, config: o, cachedData: c, response: h });
+        return t.setCache(a, h, C), h;
+      });
+    return i().then((u) => {
+      const h = n({ key: a, config: o, cachedData: c, response: u });
+      return t.setCache(a, u, h), u;
+    });
+  }, { __middlewareType: y.SYNC });
+}
+const V = /* @__PURE__ */ new Map(), pe = (r, e = v) => {
+  V.set(e, r);
+}, ue = (r = v) => {
+  const e = V.get(r);
+  if (!e) throw new Error(`Requestor实例 ${String(r)} 未注册`);
+  return e;
+}, O = {
+  get: (r, e) => ({
+    url: r,
+    method: w.GET,
+    ...e,
+    params: e == null ? void 0 : e.params
+  }),
+  post: (r, e, t) => ({
+    url: r,
+    method: w.POST,
+    data: e,
+    ...t
+  }),
+  delete: (r, e) => ({
+    url: r,
+    method: w.DELETE,
+    ...e
+  }),
+  put: (r, e, t) => ({
+    url: r,
+    method: w.PUT,
+    data: e,
+    ...t
+  }),
+  request: (r) => r
+}, le = Object.keys(O);
+function he(r, e, t) {
+  const n = {}, s = (o) => {
+    if (o === e.length)
+      return t(r);
+    const i = e[o];
+    return i({
+      config: r,
+      ctx: n,
+      next: () => s(o + 1)
+    });
   };
-  return {
-    requestor: new Proxy(v(), P),
-    concurrentPool: s
-  };
-}, B = {
-  persist: !1,
-  sync: !0
-}, G = (t) => {
-  const e = { ...B, ...t }, { ...r } = e, {
-    requestor: o,
-    store: n
-  } = S(r), s = {
-    get(u, P) {
-      return (...l) => {
-        try {
-          const d = Reflect.apply(u[P], u, l);
-          if (d instanceof Promise)
-            throw d;
-          return d;
-        } catch (d) {
-          throw d;
-        }
+  return s(0);
+}
+function de(r, e) {
+  const t = {}, n = e ?? [];
+  return le.forEach(
+    (s) => {
+      t[s] = (...o) => {
+        const i = O[s](...o);
+        return he(
+          i,
+          n,
+          r
+        );
       };
     }
-  };
-  return {
-    requestor: new Proxy(o, s),
-    store: n
-  };
-}, K = {
-  cacheRequestor: S,
-  idempotencyRequestor: F,
-  retryRequestor: $,
-  concurrentPoolRequestor: Y,
-  syncRequestor: G
-};
+  ), t;
+}
+function j(r) {
+  const { extensions: e, instanceKey: t } = r ?? {}, n = ue(t);
+  return de(
+    n,
+    e
+  );
+}
+function Ce(r) {
+  const { instanceKey: e, key: t, duration: n, isValid: s, store: o, ...i } = r;
+  return j({
+    instanceKey: e,
+    extensions: [
+      _(i),
+      se({ key: t, duration: n, isValid: s, store: o })
+    ]
+  });
+}
+function Ie(r) {
+  const { instanceKey: e, parallelCount: t, createId: n, retries: s, delay: o, retryCondition: i } = r;
+  return j({
+    instanceKey: e,
+    extensions: [
+      z({ parallelCount: t, createId: n }),
+      T({ retries: s, delay: o, retryCondition: i })
+    ]
+  });
+}
 export {
-  Z as inject,
-  K as requestExtender,
-  v as useRequestor
+  se as cache,
+  z as concurrent,
+  Ce as createCachedIdempotentRequestor,
+  Ie as createConcurrentRetryRequestor,
+  j as createRequestor,
+  _ as idempotent,
+  pe as inject,
+  T as retry,
+  we as sync,
+  ue as useRequestor
 };