web-core-tcm 0.0.25 → 0.0.26

package/dist/node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js

@@ -0,0 +1,556 @@
+import { hasChanged as M, extend as nt, isObject as O, toRawType as st, isSymbol as E, hasOwn as L, isArray as b, isIntegerKey as D, makeMap as it, isMap as A } from "../../shared/dist/shared.esm-bundler.js";
+let ot, Q = 0, j;
+function F() {
+  Q++;
+}
+function G() {
+  if (--Q > 0)
+    return;
+  let t;
+  for (; j; ) {
+    let e = j;
+    for (j = void 0; e; ) {
+      const n = e.next;
+      if (e.next = void 0, e.flags &= -9, e.flags & 1)
+        try {
+          e.trigger();
+        } catch (c) {
+          t || (t = c);
+        }
+      e = n;
+    }
+  }
+  if (t) throw t;
+}
+let y = !0;
+const U = [];
+function ct() {
+  U.push(y), y = !1;
+}
+function at() {
+  const t = U.pop();
+  y = t === void 0 ? !0 : t;
+}
+class V {
+  // TODO isolatedDeclarations "__v_skip"
+  constructor(e) {
+    this.computed = e, this.version = 0, this.activeLink = void 0, this.subs = void 0, this.map = void 0, this.key = void 0, this.sc = 0, this.__v_skip = !0;
+  }
+  track(e) {
+  }
+  trigger(e) {
+    this.version++, this.notify(e);
+  }
+  notify(e) {
+    F();
+    try {
+      for (let n = this.subs; n; n = n.prevSub)
+        n.sub.notify() && n.sub.dep.notify();
+    } finally {
+      G();
+    }
+  }
+}
+const Y = /* @__PURE__ */ new WeakMap(), m = Symbol(
+  ""
+), N = Symbol(
+  ""
+), T = Symbol(
+  ""
+);
+function d(t, e, n) {
+  if (y && ot) {
+    let c = Y.get(t);
+    c || Y.set(t, c = /* @__PURE__ */ new Map());
+    let r = c.get(n);
+    r || (c.set(n, r = new V()), r.map = c, r.key = n), r.track();
+  }
+}
+function w(t, e, n, c, r, s) {
+  const i = Y.get(t);
+  if (!i)
+    return;
+  const o = (a) => {
+    a && a.trigger();
+  };
+  if (F(), e === "clear")
+    i.forEach(o);
+  else {
+    const a = b(t), l = a && D(n);
+    if (a && n === "length") {
+      const _ = Number(c);
+      i.forEach((f, p) => {
+        (p === "length" || p === T || !E(p) && p >= _) && o(f);
+      });
+    } else
+      switch ((n !== void 0 || i.has(void 0)) && o(i.get(n)), l && o(i.get(T)), e) {
+        case "add":
+          a ? l && o(i.get("length")) : (o(i.get(m)), A(t) && o(i.get(N)));
+          break;
+        case "delete":
+          a || (o(i.get(m)), A(t) && o(i.get(N)));
+          break;
+        case "set":
+          A(t) && o(i.get(m));
+          break;
+      }
+  }
+  G();
+}
+function R(t) {
+  const e = u(t);
+  return e === t ? e : (d(e, "iterate", T), v(t) ? e : e.map(h));
+}
+function q(t) {
+  return d(t = u(t), "iterate", T), t;
+}
+const ut = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return W(this, Symbol.iterator, h);
+  },
+  concat(...t) {
+    return R(this).concat(
+      ...t.map((e) => b(e) ? R(e) : e)
+    );
+  },
+  entries() {
+    return W(this, "entries", (t) => (t[1] = h(t[1]), t));
+  },
+  every(t, e) {
+    return g(this, "every", t, e, void 0, arguments);
+  },
+  filter(t, e) {
+    return g(this, "filter", t, e, (n) => n.map(h), arguments);
+  },
+  find(t, e) {
+    return g(this, "find", t, e, h, arguments);
+  },
+  findIndex(t, e) {
+    return g(this, "findIndex", t, e, void 0, arguments);
+  },
+  findLast(t, e) {
+    return g(this, "findLast", t, e, h, arguments);
+  },
+  findLastIndex(t, e) {
+    return g(this, "findLastIndex", t, e, void 0, arguments);
+  },
+  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+  forEach(t, e) {
+    return g(this, "forEach", t, e, void 0, arguments);
+  },
+  includes(...t) {
+    return H(this, "includes", t);
+  },
+  indexOf(...t) {
+    return H(this, "indexOf", t);
+  },
+  join(t) {
+    return R(this).join(t);
+  },
+  // keys() iterator only reads `length`, no optimization required
+  lastIndexOf(...t) {
+    return H(this, "lastIndexOf", t);
+  },
+  map(t, e) {
+    return g(this, "map", t, e, void 0, arguments);
+  },
+  pop() {
+    return I(this, "pop");
+  },
+  push(...t) {
+    return I(this, "push", t);
+  },
+  reduce(t, ...e) {
+    return J(this, "reduce", t, e);
+  },
+  reduceRight(t, ...e) {
+    return J(this, "reduceRight", t, e);
+  },
+  shift() {
+    return I(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(t, e) {
+    return g(this, "some", t, e, void 0, arguments);
+  },
+  splice(...t) {
+    return I(this, "splice", t);
+  },
+  toReversed() {
+    return R(this).toReversed();
+  },
+  toSorted(t) {
+    return R(this).toSorted(t);
+  },
+  toSpliced(...t) {
+    return R(this).toSpliced(...t);
+  },
+  unshift(...t) {
+    return I(this, "unshift", t);
+  },
+  values() {
+    return W(this, "values", h);
+  }
+};
+function W(t, e, n) {
+  const c = q(t), r = c[e]();
+  return c !== t && !v(t) && (r._next = r.next, r.next = () => {
+    const s = r._next();
+    return s.done || (s.value = n(s.value)), s;
+  }), r;
+}
+const lt = Array.prototype;
+function g(t, e, n, c, r, s) {
+  const i = q(t), o = i !== t && !v(t), a = i[e];
+  if (a !== lt[e]) {
+    const f = a.apply(t, s);
+    return o ? h(f) : f;
+  }
+  let l = n;
+  i !== t && (o ? l = function(f, p) {
+    return n.call(this, h(f), p, t);
+  } : n.length > 2 && (l = function(f, p) {
+    return n.call(this, f, p, t);
+  }));
+  const _ = a.call(i, l, c);
+  return o && r ? r(_) : _;
+}
+function J(t, e, n, c) {
+  const r = q(t);
+  let s = n;
+  return r !== t && (v(t) ? n.length > 3 && (s = function(i, o, a) {
+    return n.call(this, i, o, a, t);
+  }) : s = function(i, o, a) {
+    return n.call(this, i, h(o), a, t);
+  }), r[e](s, ...c);
+}
+function H(t, e, n) {
+  const c = u(t);
+  d(c, "iterate", T);
+  const r = c[e](...n);
+  return (r === -1 || r === !1) && Mt(n[0]) ? (n[0] = u(n[0]), c[e](...n)) : r;
+}
+function I(t, e, n = []) {
+  ct(), F();
+  const c = u(t)[e].apply(t, n);
+  return G(), at(), c;
+}
+const ft = /* @__PURE__ */ it("__proto__,__v_isRef,__isVue"), X = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((t) => t !== "arguments" && t !== "caller").map((t) => Symbol[t]).filter(E)
+);
+function ht(t) {
+  E(t) || (t = String(t));
+  const e = u(this);
+  return d(e, "has", t), e.hasOwnProperty(t);
+}
+class Z {
+  constructor(e = !1, n = !1) {
+    this._isReadonly = e, this._isShallow = n;
+  }
+  get(e, n, c) {
+    if (n === "__v_skip") return e.__v_skip;
+    const r = this._isReadonly, s = this._isShallow;
+    if (n === "__v_isReactive")
+      return !r;
+    if (n === "__v_isReadonly")
+      return r;
+    if (n === "__v_isShallow")
+      return s;
+    if (n === "__v_raw")
+      return c === (r ? s ? St : tt : s ? bt : k).get(e) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the receiver is a user proxy of the reactive proxy
+      Object.getPrototypeOf(e) === Object.getPrototypeOf(c) ? e : void 0;
+    const i = b(e);
+    if (!r) {
+      let a;
+      if (i && (a = ut[n]))
+        return a;
+      if (n === "hasOwnProperty")
+        return ht;
+    }
+    const o = Reflect.get(
+      e,
+      n,
+      // if this is a proxy wrapping a ref, return methods using the raw ref
+      // as receiver so that we don't have to call `toRaw` on the ref in all
+      // its class methods
+      S(e) ? e : c
+    );
+    if ((E(n) ? X.has(n) : ft(n)) || (r || d(e, "get", n), s))
+      return o;
+    if (S(o)) {
+      const a = i && D(n) ? o : o.value;
+      return r && O(a) ? B(a) : a;
+    }
+    return O(o) ? r ? B(o) : et(o) : o;
+  }
+}
+class dt extends Z {
+  constructor(e = !1) {
+    super(!1, e);
+  }
+  set(e, n, c, r) {
+    let s = e[n];
+    if (!this._isShallow) {
+      const a = x(s);
+      if (!v(c) && !x(c) && (s = u(s), c = u(c)), !b(e) && S(s) && !S(c))
+        return a || (s.value = c), !0;
+    }
+    const i = b(e) && D(n) ? Number(n) < e.length : L(e, n), o = Reflect.set(
+      e,
+      n,
+      c,
+      S(e) ? e : r
+    );
+    return e === u(r) && (i ? M(c, s) && w(e, "set", n, c) : w(e, "add", n, c)), o;
+  }
+  deleteProperty(e, n) {
+    const c = L(e, n);
+    e[n];
+    const r = Reflect.deleteProperty(e, n);
+    return r && c && w(e, "delete", n, void 0), r;
+  }
+  has(e, n) {
+    const c = Reflect.has(e, n);
+    return (!E(n) || !X.has(n)) && d(e, "has", n), c;
+  }
+  ownKeys(e) {
+    return d(
+      e,
+      "iterate",
+      b(e) ? "length" : m
+    ), Reflect.ownKeys(e);
+  }
+}
+class _t extends Z {
+  constructor(e = !1) {
+    super(!0, e);
+  }
+  set(e, n) {
+    return !0;
+  }
+  deleteProperty(e, n) {
+    return !0;
+  }
+}
+const pt = /* @__PURE__ */ new dt(), gt = /* @__PURE__ */ new _t(), z = (t) => t, P = (t) => Reflect.getPrototypeOf(t);
+function wt(t, e, n) {
+  return function(...c) {
+    const r = this.__v_raw, s = u(r), i = A(s), o = t === "entries" || t === Symbol.iterator && i, a = t === "keys" && i, l = r[t](...c), _ = n ? z : e ? C : h;
+    return !e && d(
+      s,
+      "iterate",
+      a ? N : m
+    ), {
+      // iterator protocol
+      next() {
+        const { value: f, done: p } = l.next();
+        return p ? { value: f, done: p } : {
+          value: o ? [_(f[0]), _(f[1])] : _(f),
+          done: p
+        };
+      },
+      // iterable protocol
+      [Symbol.iterator]() {
+        return this;
+      }
+    };
+  };
+}
+function K(t) {
+  return function(...e) {
+    return t === "delete" ? !1 : t === "clear" ? void 0 : this;
+  };
+}
+function vt(t, e) {
+  const n = {
+    get(r) {
+      const s = this.__v_raw, i = u(s), o = u(r);
+      t || (M(r, o) && d(i, "get", r), d(i, "get", o));
+      const { has: a } = P(i), l = e ? z : t ? C : h;
+      if (a.call(i, r))
+        return l(s.get(r));
+      if (a.call(i, o))
+        return l(s.get(o));
+      s !== i && s.get(r);
+    },
+    get size() {
+      const r = this.__v_raw;
+      return !t && d(u(r), "iterate", m), r.size;
+    },
+    has(r) {
+      const s = this.__v_raw, i = u(s), o = u(r);
+      return t || (M(r, o) && d(i, "has", r), d(i, "has", o)), r === o ? s.has(r) : s.has(r) || s.has(o);
+    },
+    forEach(r, s) {
+      const i = this, o = i.__v_raw, a = u(o), l = e ? z : t ? C : h;
+      return !t && d(a, "iterate", m), o.forEach((_, f) => r.call(s, l(_), l(f), i));
+    }
+  };
+  return nt(
+    n,
+    t ? {
+      add: K("add"),
+      set: K("set"),
+      delete: K("delete"),
+      clear: K("clear")
+    } : {
+      add(r) {
+        !e && !v(r) && !x(r) && (r = u(r));
+        const s = u(this);
+        return P(s).has.call(s, r) || (s.add(r), w(s, "add", r, r)), this;
+      },
+      set(r, s) {
+        !e && !v(s) && !x(s) && (s = u(s));
+        const i = u(this), { has: o, get: a } = P(i);
+        let l = o.call(i, r);
+        l || (r = u(r), l = o.call(i, r));
+        const _ = a.call(i, r);
+        return i.set(r, s), l ? M(s, _) && w(i, "set", r, s) : w(i, "add", r, s), this;
+      },
+      delete(r) {
+        const s = u(this), { has: i, get: o } = P(s);
+        let a = i.call(s, r);
+        a || (r = u(r), a = i.call(s, r)), o && o.call(s, r);
+        const l = s.delete(r);
+        return a && w(s, "delete", r, void 0), l;
+      },
+      clear() {
+        const r = u(this), s = r.size !== 0, i = r.clear();
+        return s && w(
+          r,
+          "clear",
+          void 0,
+          void 0
+        ), i;
+      }
+    }
+  ), [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ].forEach((r) => {
+    n[r] = wt(r, t, e);
+  }), n;
+}
+function $(t, e) {
+  const n = vt(t, e);
+  return (c, r, s) => r === "__v_isReactive" ? !t : r === "__v_isReadonly" ? t : r === "__v_raw" ? c : Reflect.get(
+    L(n, r) && r in c ? n : c,
+    r,
+    s
+  );
+}
+const mt = {
+  get: /* @__PURE__ */ $(!1, !1)
+}, Rt = {
+  get: /* @__PURE__ */ $(!0, !1)
+}, k = /* @__PURE__ */ new WeakMap(), bt = /* @__PURE__ */ new WeakMap(), tt = /* @__PURE__ */ new WeakMap(), St = /* @__PURE__ */ new WeakMap();
+function xt(t) {
+  switch (t) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function It(t) {
+  return t.__v_skip || !Object.isExtensible(t) ? 0 : xt(st(t));
+}
+function et(t) {
+  return x(t) ? t : rt(
+    t,
+    !1,
+    pt,
+    mt,
+    k
+  );
+}
+function B(t) {
+  return rt(
+    t,
+    !0,
+    gt,
+    Rt,
+    tt
+  );
+}
+function rt(t, e, n, c, r) {
+  if (!O(t) || t.__v_raw && !(e && t.__v_isReactive))
+    return t;
+  const s = It(t);
+  if (s === 0)
+    return t;
+  const i = r.get(t);
+  if (i)
+    return i;
+  const o = new Proxy(
+    t,
+    s === 2 ? c : n
+  );
+  return r.set(t, o), o;
+}
+function x(t) {
+  return !!(t && t.__v_isReadonly);
+}
+function v(t) {
+  return !!(t && t.__v_isShallow);
+}
+function Mt(t) {
+  return t ? !!t.__v_raw : !1;
+}
+function u(t) {
+  const e = t && t.__v_raw;
+  return e ? u(e) : t;
+}
+const h = (t) => O(t) ? et(t) : t, C = (t) => O(t) ? B(t) : t;
+function S(t) {
+  return t ? t.__v_isRef === !0 : !1;
+}
+function Pt(t) {
+  return Ot(t, !1);
+}
+function Ot(t, e) {
+  return S(t) ? t : new Tt(t, e);
+}
+class Tt {
+  constructor(e, n) {
+    this.dep = new V(), this.__v_isRef = !0, this.__v_isShallow = !1, this._rawValue = n ? e : u(e), this._value = n ? e : h(e), this.__v_isShallow = n;
+  }
+  get value() {
+    return this.dep.track(), this._value;
+  }
+  set value(e) {
+    const n = this._rawValue, c = this.__v_isShallow || v(e) || x(e);
+    e = c ? e : u(e), M(e, n) && (this._rawValue = e, this._value = c ? e : h(e), this.dep.trigger());
+  }
+}
+export {
+  T as ARRAY_ITERATE_KEY,
+  m as ITERATE_KEY,
+  N as MAP_KEY_ITERATE_KEY,
+  Mt as isProxy,
+  x as isReadonly,
+  S as isRef,
+  v as isShallow,
+  ct as pauseTracking,
+  et as reactive,
+  R as reactiveReadArray,
+  B as readonly,
+  Pt as ref,
+  at as resetTracking,
+  q as shallowReadArray,
+  u as toRaw,
+  h as toReactive,
+  C as toReadonly,
+  d as track,
+  w as trigger
+};

package/dist/node_modules/@vue/runtime-core/dist/runtime-core.esm-bundler.js

@@ -0,0 +1,36 @@
+import { getGlobalThis as s, isFunction as a } from "../../shared/dist/shared.esm-bundler.js";
+let u = null;
+s().requestIdleCallback;
+s().cancelIdleCallback;
+let p = null;
+function f(n, l, r = !1) {
+  const e = _();
+  if (e || p) {
+    let t = e ? e.parent == null || e.ce ? e.vnode.appContext && e.vnode.appContext.provides : e.parent.provides : void 0;
+    if (t && n in t)
+      return t[n];
+    if (arguments.length > 1)
+      return r && a() ? l.call(e && e.proxy) : l;
+  }
+}
+let c = null;
+const _ = () => c || u;
+{
+  const n = s(), l = (r, e) => {
+    let t;
+    return (t = n[r]) || (t = n[r] = []), t.push(e), (o) => {
+      t.length > 1 ? t.forEach((i) => i(o)) : t[0](o);
+    };
+  };
+  l(
+    "__VUE_INSTANCE_SETTERS__",
+    (r) => c = r
+  ), l(
+    "__VUE_SSR_SETTERS__",
+    (r) => r
+  );
+}
+export {
+  _ as getCurrentInstance,
+  f as inject
+};

package/dist/node_modules/@vue/shared/dist/shared.esm-bundler.js

@@ -0,0 +1,26 @@
+// @__NO_SIDE_EFFECTS__
+function l(t) {
+  const n = /* @__PURE__ */ Object.create(null);
+  for (const o of t.split(",")) n[o] = 1;
+  return (o) => o in n;
+}
+const a = Object.assign, c = Object.prototype.hasOwnProperty, p = (t, n) => c.call(t, n), f = Array.isArray, b = (t) => s(t) === "[object Map]", y = (t) => !1, i = (t) => typeof t == "string", d = (t) => typeof t == "symbol", g = (t) => t !== null && typeof t == "object", r = Object.prototype.toString, s = (t) => r.call(t), u = (t) => s(t).slice(8, -1), h = (t) => i(t) && t !== "NaN" && t[0] !== "-" && "" + parseInt(t, 10) === t, j = (t, n) => !Object.is(t, n);
+let e;
+const O = () => e || (e = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : typeof global < "u" ? global : {});
+export {
+  a as extend,
+  O as getGlobalThis,
+  j as hasChanged,
+  p as hasOwn,
+  f as isArray,
+  y as isFunction,
+  h as isIntegerKey,
+  b as isMap,
+  g as isObject,
+  i as isString,
+  d as isSymbol,
+  l as makeMap,
+  r as objectToString,
+  u as toRawType,
+  s as toTypeString
+};

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

@@ -0,0 +1,55 @@
+import { ObjectCls as A, JSONStringify as x, isString as R, isSpecialRequestBody as U, setTimeoutFn as V, clearTimeoutTimer as b, undefinedValue as k, promiseReject as v, falseValue as T, newInstance as B, trueValue as w } from "../../../@alova/shared/dist/alova-shared.esm.js";
+const E = (t) => R(t) || U(t);
+function L() {
+  return (t, C) => {
+    const c = C.config, l = c.timeout || 0, r = new AbortController(), { data: o, headers: d } = t, S = /content-type/i.test(A.keys(d).join()), j = o && o.toString() === "[object FormData]";
+    !S && !j && (d["Content-Type"] = "application/json;charset=UTF-8");
+    const n = fetch(t.url, {
+      ...c,
+      method: t.type,
+      signal: r.signal,
+      body: E(o) ? o : x(o)
+    });
+    let a, p = T;
+    return l > 0 && (a = V(() => {
+      p = w, r.abort();
+    }, l)), {
+      response: () => n.then((e) => (b(a), e.clone()), (e) => v(p ? B(Error, "fetchError: network timeout") : e)),
+      // The then in the Headers function needs to catch exceptions, otherwise the correct error object will not be obtained internally.
+      headers: () => n.then(({ headers: e }) => e, () => ({})),
+      // Due to limitations of the node fetch library, this code cannot be unit tested, but it has passed the test in the browser.
+      /* c8 ignore start */
+      onDownload: async (e) => {
+        let s = T;
+        const u = await n.catch(() => {
+          s = w;
+        });
+        if (!u)
+          return;
+        const { headers: h, body: f } = u.clone(), g = f ? f.getReader() : k, m = Number(h.get("Content-Length") || h.get("content-length") || 0);
+        if (m <= 0)
+          return;
+        let i = 0;
+        if (g) {
+          const y = () => g.read().then(({ done: D, value: F = new Uint8Array() }) => {
+            if (D || s)
+              s && e(i, 0);
+            else
+              return i += F.byteLength, e(i, m), y();
+          });
+          y();
+        }
+      },
+      onUpload() {
+        console.error("fetch API does'nt support uploading progress. please consider to change `@alova/adapter-xhr` or `@alova/adapter-axios`");
+      },
+      /* c8 ignore stop */
+      abort: () => {
+        r.abort(), b(a);
+      }
+    };
+  };
+}
+export {
+  L as default
+};