web-core-tcm 0.0.24 → 0.0.26

package/dist/node_modules/alova/dist/alova.esm.js

@@ -0,0 +1,414 @@
+import { newInstance as g, pushItem as v, trueValue as $, createEventManager as Re, undefinedValue as m, createAssert as qe, getConfig as U, isPlainObject as ae, forEach as K, filterItem as k, objectKeys as L, isFn as H, getContextOptions as $e, mapItem as O, isArray as ke, deleteAttr as A, falseValue as W, len as R, promiseThen as P, key as We, promiseCatch as je, promiseFinally as xe, JSONParse as Ge, JSONStringify as Ve, instanceOf as ne, isString as be, noop as Q, PromiseCls as x, getOptions as Je, getMethodInternalKey as ce, getLocalCacheConfigParam as Ye, getContext as re, $self as me, isSpecialRequestBody as ze, sloughFunction as Qe, buildCompletedURL as Xe, promiseReject as Ze, objAssign as Ie, isSSR as et, MEMORY as tt, STORAGE_RESTORE as X, deepClone as st, buildNamespacedCacheKey as ie, getTime as ve, RegExpCls as le } from "../../@alova/shared/dist/alova-shared.esm.js";
+let Ee = {
+  autoHitCache: "global",
+  ssr: et
+};
+const q = "color: black; font-size: 12px; font-weight: bolder";
+var ot = (a, e, t, o) => {
+  const s = console, i = (...l) => console.log(...l), { url: n } = e, c = t === X, h = "\x1B[42m%s\x1B[49m", p = "\x1B[32m%s\x1B[39m", r = ` [HitCache]${n} `, d = () => Array(R(r) + 1).join("^");
+  Ee.ssr ? (i(h, r), i(p, " Cache ", a), i(p, " Mode  ", t), c && i(p, " Tag   ", o), i(p, d())) : (s.groupCollapsed ? s.groupCollapsed("%cHitCache", "padding: 2px 6px; background: #c4fcd3; color: #53b56d;", n) : i(h, r), i("%c[Cache]", q, a), i("%c[Mode]", q, t), c && i("%c[Tag]", q, o), i("%c[Method]", q, e), s.groupEnd ? s.groupEnd() : i(p, d()));
+};
+const Z = (a) => `hss.${a}`, He = "hsr.", I = (a) => He + a, j = "$$hsrs", Me = "__$<>$__", ee = (a, e) => {
+  a[e] = 0;
+}, Y = async (a, e, t, o, s, i, n) => {
+  if (o > ve() && t) {
+    const c = ie(a, e);
+    if (await s.set(c, k([t, o === 1 / 0 ? m : o, n], Boolean)), i) {
+      const h = {}, p = [];
+      K(i, (l) => {
+        const u = ne(l, le), S = u ? l.source + (l.flags ? Me + l.flags : "") : l;
+        S && (u && !h[S] && v(p, S), ee(h, u ? I(S) : Z(S)));
+      });
+      const r = O(L(h), async (l) => {
+        const u = await s.get(l) || {};
+        ee(u, c), await s.set(l, u);
+      }), d = async () => {
+        if (R(p)) {
+          const l = await s.get(j) || [];
+          v(l, ...p), await s.set(j, l);
+        }
+      };
+      await x.all([...r, d()]);
+    }
+  }
+}, at = async (a, e, t) => {
+  const o = ie(a, e);
+  await t.remove(o);
+}, Pe = async (a, e, t, o) => {
+  const s = await t.get(ie(a, e));
+  if (s) {
+    const [i, n, c] = s;
+    if (c === o && (!n || n > ve()))
+      return s;
+    await at(a, e, t);
+  }
+}, nt = async (a, e, t, o) => {
+  const s = await Pe(a, e, t, o);
+  return s ? s[0] : m;
+}, ct = async (a, e, t) => {
+  const o = `${e}`, s = {}, i = Z(a);
+  s[i] = await t.get(i);
+  let n;
+  if (e) {
+    const r = Z(o);
+    s[r] = await t.get(r), n = await t.get(j);
+    const d = [];
+    n && R(n) && (K(n, (l) => {
+      const [u, S] = l.split(Me);
+      g(le, u, S).test(o) && v(d, l);
+    }), await x.all(O(d, async (l) => {
+      const u = I(l);
+      s[u] = await t.get(u);
+    })));
+  }
+  const c = async (r) => {
+    try {
+      await t.remove(r);
+      for (const d in s) {
+        const l = s[d];
+        l && A(l, r);
+      }
+    } catch {
+    }
+  }, h = {};
+  await x.all(O(L(s), async (r) => {
+    const d = s[r];
+    if (d) {
+      const l = [];
+      for (const u in d)
+        h[u] || (ee(h, u), v(l, c(u)));
+      await x.all(l);
+    }
+  }));
+  const p = R(n || []);
+  await x.all(O(L(s), async (r) => {
+    const d = s[r];
+    d && (R(L(d)) ? await t.set(r, d) : (await t.remove(r), r.includes(He) && n && (n = k(n, (l) => I(l) !== r))));
+  })), p !== R(n || []) && await t.set(j, n);
+};
+var rt = (a) => {
+  const { data: e, config: t } = a, o = { ...t }, { headers: s = {}, params: i = {} } = o, n = re(a);
+  o.headers = { ...s }, o.params = be(i) ? i : { ...i };
+  const c = g(y, a.type, n, a.url, o, e);
+  return Ie(c, {
+    ...a,
+    config: o
+  });
+};
+const it = async (a) => {
+  const { autoHitCache: e } = Ee, { l1Cache: t, l2Cache: o } = re(a), s = ce(a), { name: i } = U(a), n = {
+    global: [...se, ...oe],
+    self: [t, o],
+    close: []
+  }[e];
+  n && R(n) && await x.all(O(n, (c) => ct(s, i, c)));
+}, Ce = {};
+function lt(a, e) {
+  let t = $, o;
+  const s = g(x, (n) => {
+    o = n;
+  });
+  return {
+    // request interrupt function
+    abort: () => {
+      P(s, (n) => n && n.abort());
+    },
+    onDownload: (n) => {
+      P(s, (c) => c && c.onDownload && c.onDownload(n));
+    },
+    onUpload: (n) => {
+      P(s, (c) => c && c.onUpload && c.onUpload(n));
+    },
+    response: async () => {
+      const { beforeRequest: n = Q, responded: c, requestAdapter: h, cacheLogger: p } = Je(a), r = ce(a), { s: d, t: l, m: u, e: S } = Ye(a), { id: E, l1Cache: G, l2Cache: ue, snapshots: Ke } = re(a), { cacheFor: pe } = U(a), { hitSource: V } = a;
+      let T = await (H(pe) ? pe() : (
+        // If it is a forced request, skip the step of getting it from the cache
+        // Otherwise, determine whether to use cached data
+        e ? m : nt(E, r, G)
+      ));
+      if (u === X && !T && !e) {
+        const f = await Pe(E, r, ue, l);
+        if (f) {
+          const [w, M] = f;
+          await Y(E, r, w, M, G, V), T = w;
+        }
+      }
+      const C = rt(a);
+      await n(C);
+      const { baseURL: Oe, url: Te, type: De, data: Le } = C, { params: Ue = {}, headers: Ae = {}, transform: _e = me, shareRequest: Be } = U(C), _ = Ce[E] = Ce[E] || {}, de = C.data, ge = ze(de);
+      let D = ge ? m : _[r], B = me, F = m, N = Q;
+      if (H(c))
+        B = c;
+      else if (ae(c)) {
+        const { onSuccess: f, onError: w, onComplete: M } = c;
+        B = H(f) ? f : B, F = H(w) ? w : F, N = H(M) ? M : N;
+      }
+      if (T !== m)
+        return o(), C.fromCache = $, Qe(p, ot)(T, C, u, l), N(C), T;
+      if (t = W, !Be || !D) {
+        const f = h({
+          url: Xe(Oe, Te, Ue),
+          type: De,
+          data: Le,
+          headers: Ae
+        }, C);
+        D = _[r] = f;
+      }
+      o(D);
+      const fe = async (f, w, M = $) => {
+        const Fe = await f, J = await _e(Fe, w || {});
+        Ke.save(a);
+        try {
+          await it(C);
+        } catch {
+        }
+        if ((!de || !ge) && M)
+          try {
+            await x.all([
+              Y(E, r, J, S(tt), G, V),
+              d && Y(E, r, J, S(X), ue, V, l)
+            ]);
+          } catch {
+          }
+        return st(J);
+      };
+      return xe(P(x.all([D.response(), D.headers()]), ([f, w]) => (A(_, r), fe(B(f, C), w)), (f) => (A(_, r), H(F) ? (
+        // When responding to an error, if no error is thrown, the successful response process will be processed, but the data will not be cached.
+        fe(F(f, C), m, W)
+      ) : Ze(f))), () => {
+        N(C);
+      });
+    },
+    fromCache: () => t
+  };
+}
+const ye = (a, e) => () => {
+  const t = e.indexOf(a);
+  t >= 0 && e.splice(t, 1);
+};
+class y {
+  constructor(e, t, o, s, i) {
+    this.dhs = [], this.uhs = [], this.fromCache = m;
+    const n = () => {
+      n.a();
+    };
+    n.a = Q, e = e.toUpperCase();
+    const c = this, h = $e(t);
+    c.abort = n, c.baseURL = h.baseURL || "", c.url = o, c.type = e, c.context = t;
+    const p = {}, r = "cacheFor", d = ae(h[r]) ? h[r][e] : m, l = s && s.hitSource;
+    K(["timeout", "shareRequest"], (u) => {
+      h[u] !== m && (p[u] = h[u]);
+    }), d !== m && (p[r] = d), l && (c.hitSource = O(ke(l) ? l : [l], (u) => ne(u, y) ? ce(u) : u), A(s, "hitSource")), c.config = {
+      ...p,
+      headers: {},
+      params: {},
+      ...s || {}
+    }, c.data = i, c.meta = s ? s.meta : c.meta, c.key = c.generateKey();
+  }
+  /**
+   * Bind download progress callback function
+   * @param progressHandler Download progress callback function
+   * @version 2.17.0
+   * @return unbind function
+   */
+  onDownload(e) {
+    return v(this.dhs, e), ye(e, this.dhs);
+  }
+  /**
+   * Bind upload progress callback function
+   * @param progressHandler Upload progress callback function
+   * @version 2.17.0
+   * @return unbind function
+   */
+  onUpload(e) {
+    return v(this.uhs, e), ye(e, this.uhs);
+  }
+  /**
+   * Send a request through a method instance and return a promise object
+   */
+  send(e = W) {
+    const t = this, { response: o, onDownload: s, onUpload: i, abort: n, fromCache: c } = lt(t, e);
+    return R(t.dhs) > 0 && s((h, p) => K(t.dhs, (r) => r({ loaded: h, total: p }))), R(t.uhs) > 0 && i((h, p) => K(t.uhs, (r) => r({ loaded: h, total: p }))), t.abort.a = n, t.fromCache = m, t.promise = P(o(), (h) => (t.fromCache = c(), h)), t.promise;
+  }
+  /**
+   * Set the method name, if there is already a name it will be overwritten
+   * @param name method name
+   */
+  setName(e) {
+    U(this).name = e;
+  }
+  generateKey() {
+    return We(this);
+  }
+  /**
+   * Bind callbacks for resolve and/or reject Promise
+   * @param onfulfilled The callback to be executed when resolving the Promise
+   * @param onrejected The callback to be executed when the Promise is rejected
+   * @returns Returns a Promise for executing any callbacks
+   */
+  then(e, t) {
+    return P(this.send(), e, t);
+  }
+  /**
+   * Bind a callback only for reject Promise
+   * @param onrejected The callback to be executed when the Promise is rejected
+   * @returns Returns a Promise that completes the callback
+   */
+  catch(e) {
+    return je(this.send(), e);
+  }
+  /**
+   * Bind a callback that is called when the Promise is resolved (resolve or reject)
+   * @param onfinally Callback executed when Promise is resolved (resolve or reject).
+   * @return Returns a Promise that completes the callback.
+   */
+  finally(e) {
+    return xe(this.send(), e);
+  }
+}
+const he = qe(), b = "success", ht = () => {
+  let a = {};
+  const e = Re();
+  return {
+    set(o, s) {
+      a[o] = s, e.emit(b, { type: "set", key: o, value: s, container: a });
+    },
+    get: (o) => {
+      const s = a[o];
+      return e.emit(b, { type: "get", key: o, value: s, container: a }), s;
+    },
+    remove(o) {
+      A(a, o), e.emit(b, { type: "remove", key: o, container: a });
+    },
+    clear: () => {
+      a = {}, e.emit(b, { type: "clear", key: "", container: a });
+    },
+    emitter: e
+  };
+}, ut = () => {
+  const a = Re(), e = localStorage;
+  return {
+    set: (o, s) => {
+      e.setItem(o, Ve(s)), a.emit(b, { type: "set", key: o, value: s, container: e });
+    },
+    get: (o) => {
+      const s = e.getItem(o), i = s && Ge(s);
+      return a.emit(b, { type: "get", key: o, value: i, container: e }), i;
+    },
+    remove: (o) => {
+      e.removeItem(o), a.emit(b, { type: "remove", key: o, container: e });
+    },
+    clear: () => {
+      e.clear(), a.emit(b, { type: "clear", key: "", container: e });
+    },
+    emitter: a
+  };
+}, pt = () => {
+  const a = () => {
+    he(W, "l2Cache is not defined.");
+  };
+  return {
+    set: () => {
+      a();
+    },
+    get: () => (a(), m),
+    remove: () => {
+      a();
+    },
+    clear: () => {
+    }
+  };
+}, Se = Set;
+class dt {
+  constructor(e) {
+    this.records = {}, this.occupy = 0, he(e >= 0, "expected snapshots limit to be >= 0"), this.capacity = e;
+  }
+  /**
+   * Save method instance snapshot
+   * @param methodInstance method instance
+   */
+  save(e) {
+    const { name: t } = U(e), { records: o, occupy: s, capacity: i } = this;
+    t && s < i && ((o[t] = o[t] || g(Se)).add(e), this.occupy += 1);
+  }
+  /**
+   * Get a Method instance snapshot, which will filter out the corresponding Method instance based on the matcher
+   * @param matcher Matching snapshot name, which can be a string or regular expression, or an object with a filter function
+   * @returns Array of matched Method instance snapshots
+   */
+  match(e, t = !0) {
+    let o, s, i, n = e;
+    ae(e) && (n = e.name, i = e.filter), ne(n, le) ? s = n : be(n) && (o = n);
+    const { records: c } = this;
+    let h = g(Se);
+    o ? h = c[o] || h : s && K(k(L(c), (r) => s.test(r)), (r) => {
+      c[r].forEach((d) => h.add(d));
+    });
+    const p = H(i) ? k([...h], i) : [...h];
+    return t ? p : p[0];
+  }
+}
+const te = "GET", gt = "HEAD", ft = "POST", mt = "PUT", Ct = "PATCH", yt = "DELETE", St = "OPTIONS", we = {
+  /**
+   * GET requests are cached for 5 minutes (300000 milliseconds) by default, and other requests are not cached by default.
+   */
+  cacheFor: {
+    [te]: 3e5
+  },
+  /**
+   * Share requests default to true
+   */
+  shareRequest: $,
+  /**
+   * Number of method snapshots, default is 1000
+   */
+  snapshots: 1e3
+};
+let wt = 0;
+class Rt {
+  constructor(e) {
+    var t, o;
+    const s = this;
+    s.id = (e.id || (wt += 1)).toString(), s.l1Cache = e.l1Cache || ht(), s.l2Cache = e.l2Cache || (typeof localStorage < "u" ? ut() : pt()), s.options = {
+      ...we,
+      ...e
+    }, s.snapshots = g(dt, (o = (t = e.snapshots) !== null && t !== void 0 ? t : we.snapshots) !== null && o !== void 0 ? o : 0);
+  }
+  Request(e) {
+    return g(y, e.method || te, this, e.url, e, e.data);
+  }
+  Get(e, t) {
+    return g(y, te, this, e, t);
+  }
+  Post(e, t, o) {
+    return g(y, ft, this, e, o, t);
+  }
+  Delete(e, t, o) {
+    return g(y, yt, this, e, o, t);
+  }
+  Put(e, t, o) {
+    return g(y, mt, this, e, o, t);
+  }
+  Head(e, t) {
+    return g(y, gt, this, e, t);
+  }
+  Patch(e, t, o) {
+    return g(y, Ct, this, e, o, t);
+  }
+  Options(e, t) {
+    return g(y, St, this, e, t);
+  }
+}
+let z = m;
+const se = [], oe = [], vt = (a) => {
+  const e = g(Rt, a), t = e.options.statesHook;
+  z && t && he(z.name === t.name, "expected to use the same `statesHook`"), z = t;
+  const { l1Cache: o, l2Cache: s } = e;
+  return !se.includes(o) && v(se, o), !oe.includes(s) && v(oe, s), e;
+};
+export {
+  y as Method,
+  vt as createAlova,
+  Ee as globalConfigMap,
+  it as hitCacheBySource
+};

package/dist/node_modules/alova/dist/clienthook/index.esm.js

@@ -0,0 +1,89 @@
+import { noop as x, $self as F, isFn as u, isPlainObject as O, undefinedValue as R, instanceOf as A, trueValue as d, falseValue as v, len as w, PromiseCls as V, newInstance as L, forEach as P, splice as b, pushItem as h } from "../../../@alova/shared/dist/alova-shared.esm.js";
+const j = {
+  authRole: null
+}, M = {
+  authRole: "login"
+}, p = {
+  authRole: "logout"
+}, G = {
+  authRole: "refreshToken"
+}, C = ({ meta: n }, s) => {
+  if (O(n)) {
+    for (const l in n)
+      if (Object.prototype.hasOwnProperty.call(n, l)) {
+        const e = s[l];
+        if (A(e, RegExp) ? e.test(n[l]) : n[l] === e)
+          return d;
+      }
+  }
+  return v;
+}, Q = (n, s) => L(V, (l) => {
+  h(s, {
+    method: n,
+    resolve: l
+  });
+}), N = (n, s, l, e) => {
+  if (C(n, s?.metaMatches || l))
+    return (u(s) ? s : O(s) && u(s.handler) ? s.handler : x)(e, n);
+}, W = async (n, s, l, e, t, a) => {
+  const o = w(e) >= 2;
+  let E = t?.isExpired(...e);
+  if (A(E, V) && (E = await E), E)
+    try {
+      if (d && (l(d), await t?.handler(...e), l(v), P(s, ({ resolve: i }) => i())), o) {
+        const { config: i } = n, c = i.transform;
+        i.transform = R;
+        const r = await n;
+        return i.transform = c, r;
+      }
+    } finally {
+      l(v), b(s, 0, w(s));
+    }
+}, $ = (n) => {
+  let s = R, l = R, e = R;
+  if (u(n))
+    s = n;
+  else if (O(n)) {
+    const { onSuccess: t, onError: a, onComplete: o } = n;
+    s = u(t) ? t : s, l = u(a) ? a : l, e = u(o) ? o : e;
+  }
+  return {
+    onSuccess: s,
+    onError: l,
+    onComplete: e
+  };
+}, I = ({ visitorMeta: n, login: s, logout: l, refreshToken: e, assignToken: t = x }) => {
+  let a = v;
+  const o = [];
+  return {
+    waitingList: o,
+    onAuthRequired: (i) => async (c) => {
+      const r = C(c, n || j), f = C(c, s?.metaMatches || M);
+      return !r && !f && !C(c, e?.metaMatches || G) && (a && await Q(c, o), await W(c, o, (D) => {
+        a = D;
+      }, [c], e)), !r && !f && await t(c), i?.(c);
+    },
+    onResponseRefreshToken: (i) => {
+      const c = $(i);
+      return {
+        ...c,
+        onSuccess: async (r, f) => (await N(f, s, M, r), await N(f, l, p, r), (c.onSuccess || F)(r, f))
+      };
+    }
+  };
+};
+var U;
+(function(n) {
+  n[n.USE_REQUEST = 1] = "USE_REQUEST", n[n.USE_WATCHER = 2] = "USE_WATCHER", n[n.USE_FETCHER = 3] = "USE_FETCHER";
+})(U || (U = {}));
+var T;
+(function(n) {
+  n[n.CONNECTING = 0] = "CONNECTING", n[n.OPEN = 1] = "OPEN", n[n.CLOSED = 2] = "CLOSED";
+})(T || (T = {}));
+var _;
+(function(n) {
+  n.Open = "open", n.Error = "error", n.Message = "message", n.Close = "close";
+})(_ || (_ = {}));
+export {
+  I as createClientTokenAuthentication
+};

package/dist/node_modules/builder-pattern/dist/index.js

@@ -0,0 +1,22 @@
+function f(r, o, l) {
+  let u, n, e;
+  r instanceof Function ? (u = r, n = o, e = l) : (n = r, e = o);
+  const t = n ? Object.assign({}, n) : {}, c = new Proxy(
+    {},
+    {
+      get(b, s) {
+        if (s === "build")
+          if (e && Object.assign(t, e), u) {
+            const i = new u();
+            return () => Object.assign(i, { ...t });
+          } else
+            return () => t;
+        return (...i) => i.length === 0 ? t[s.toString()] : (t[s.toString()] = i[0], c);
+      }
+    }
+  );
+  return c;
+}
+export {
+  f as Builder
+};

package/dist/node_modules/jwt-decode/build/esm/index.js

@@ -0,0 +1,52 @@
+class o extends Error {
+}
+o.prototype.name = "InvalidTokenError";
+function i(t) {
+  return decodeURIComponent(atob(t).replace(/(.)/g, (e, r) => {
+    let n = r.charCodeAt(0).toString(16).toUpperCase();
+    return n.length < 2 && (n = "0" + n), "%" + n;
+  }));
+}
+function s(t) {
+  let e = t.replace(/-/g, "+").replace(/_/g, "/");
+  switch (e.length % 4) {
+    case 0:
+      break;
+    case 2:
+      e += "==";
+      break;
+    case 3:
+      e += "=";
+      break;
+    default:
+      throw new Error("base64 string is not of the correct length");
+  }
+  try {
+    return i(e);
+  } catch {
+    return atob(e);
+  }
+}
+function d(t, e) {
+  if (typeof t != "string")
+    throw new o("Invalid token specified: must be a string");
+  e || (e = {});
+  const r = e.header === !0 ? 0 : 1, n = t.split(".")[r];
+  if (typeof n != "string")
+    throw new o(`Invalid token specified: missing part #${r + 1}`);
+  let c;
+  try {
+    c = s(n);
+  } catch (a) {
+    throw new o(`Invalid token specified: invalid base64 for part #${r + 1} (${a.message})`);
+  }
+  try {
+    return JSON.parse(c);
+  } catch (a) {
+    throw new o(`Invalid token specified: invalid json for part #${r + 1} (${a.message})`);
+  }
+}
+export {
+  o as InvalidTokenError,
+  d as jwtDecode
+};