@cccsaurora/clue-ui 1.2.3-dev.266 → 1.2.3-patch.269

package/ClueEnrichContext-KqRuuWNS.js

@@ -0,0 +1,418 @@
+import { jsx as xt } from "react/jsx-runtime";
+import { a as Dt } from "./iconify-BBckr5AQ.js";
+import { b as Et, a as It, p as at, u as ut } from "./useClueTypeConfig-Ct9Ygter.js";
+import { clueDebugLogger as _ } from "./utils/loggerUtil.js";
+import { b as Ct } from "./_baseSlice-M5RKzt1A.js";
+import { t as $t } from "./toFinite-BMy6GObD.js";
+import { d as gt } from "./debounce-DryYcbJ4.js";
+import { g as lt } from "./groupBy-br8xmD2R.js";
+import { b as Ot } from "./_baseIteratee-Dbfsw5z8.js";
+import { b as jt } from "./_baseUniq-BJcj69PL.js";
+import { useContext as Pt, useState as H, useMemo as G, useCallback as $, useRef as Mt, useEffect as b } from "react";
+import { c as qt } from "./index-Dj5C04IX.js";
+import { ClueDatabaseContext as bt } from "./hooks/ClueDatabaseContext.js";
+import At from "./hooks/useClueConfig.js";
+function Bt(s) {
+  var n = $t(s), p = n % 1;
+  return n === n ? p ? n - p : n : 0;
+}
+var Rt = Math.ceil, Vt = Math.max;
+function Ut(s, n, p) {
+  n === void 0 ? n = 1 : n = Vt(Bt(n), 0);
+  var l = s == null ? 0 : s.length;
+  if (!l || n < 1)
+    return [];
+  for (var y = 0, v = 0, O = Array(Rt(l / n)); y < l; )
+    O[v++] = Ct(s, y, y += n);
+  return O;
+}
+function Wt(s, n) {
+  return s && s.length ? jt(s, Ot(n)) : [];
+}
+let J;
+const Ft = new Uint8Array(16);
+function Ht() {
+  if (!J && (J = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !J))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return J(Ft);
+}
+const d = [];
+for (let s = 0; s < 256; ++s)
+  d.push((s + 256).toString(16).slice(1));
+function Jt(s, n = 0) {
+  return d[s[n + 0]] + d[s[n + 1]] + d[s[n + 2]] + d[s[n + 3]] + "-" + d[s[n + 4]] + d[s[n + 5]] + "-" + d[s[n + 6]] + d[s[n + 7]] + "-" + d[s[n + 8]] + d[s[n + 9]] + "-" + d[s[n + 10]] + d[s[n + 11]] + d[s[n + 12]] + d[s[n + 13]] + d[s[n + 14]] + d[s[n + 15]];
+}
+const Qt = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), ft = {
+  randomUUID: Qt
+};
+function g(s, n, p) {
+  if (ft.randomUUID && !s)
+    return ft.randomUUID();
+  s = s || {};
+  const l = s.random || (s.rng || Ht)();
+  return l[6] = l[6] & 15 | 64, l[8] = l[8] & 63 | 128, Jt(l);
+}
+const St = qt(null), ne = ({
+  children: s,
+  classification: n,
+  baseURL: p,
+  getToken: l,
+  onNetworkCall: y,
+  pickSources: v,
+  chunkSize: O = 15,
+  maxRequestCount: Q = 4,
+  defaultTimeout: A = 5,
+  enabled: B = !0,
+  ready: dt = !1,
+  publicIconify: K = !0,
+  skipConfigCall: X = !1,
+  customIconify: R,
+  debugLogging: x = !0
+}) => {
+  var nt, it, rt, ot, ct;
+  const I = At(), e = Pt(bt), [Y, pt] = H(null), w = G(
+    () => {
+      var t, i;
+      return Y ?? n ?? ((i = (t = I.config) == null ? void 0 : t.c12nDef) == null ? void 0 : i.RESTRICTED);
+    },
+    [n, (it = (nt = I.config) == null ? void 0 : nt.c12nDef) == null ? void 0 : it.RESTRICTED, Y]
+  ), Z = $(
+    (t) => {
+      var i;
+      return pt(t((i = I.config) == null ? void 0 : i.c12nDef));
+    },
+    [(rt = I.config) == null ? void 0 : rt.c12nDef]
+  ), [C, mt] = H(dt), j = Mt(0), [D, yt] = H([]), { availableSources: P, typesDetection: V, supportedTypes: z } = Et(
+    B && C,
+    p,
+    x,
+    l,
+    y
+  );
+  b(() => {
+    if (X || !B || !C)
+      return;
+    const t = {}, i = l == null ? void 0 : l();
+    i && (t.Authorization = `Bearer ${i}`);
+    let u = { baseURL: p, headers: t };
+    y && (u = y(u)), It.configs.get(u).then(I.setConfig);
+  }, [p, y, X, C]);
+  const [N, T] = H(R);
+  b(() => {
+    R && T(R);
+  }, [R]), b(() => {
+    if (K)
+      return;
+    let t = N ?? void 0 ?? (p == null ? void 0 : p.replace(/^[^.]+/, "icons"));
+    !t && typeof window < "u" && window && !window.location.origin.includes("localhost") && (t = window.location.protocol + "//" + window.location.origin.replace(/^[^.]+/, "icons")), t && (_(`Using ${t} for iconify`, x), Dt("", {
+      resources: [t]
+    }));
+  }, [p, N, x, K]);
+  const U = $(
+    async (t) => {
+      const i = [];
+      for (const c of t) {
+        const { latency: o, source: f, type: r, value: h, items: a, error: m } = c;
+        m && i.push({
+          id: g(),
+          source: f,
+          type: r,
+          value: h,
+          annotations: [],
+          classification: w,
+          latency: o,
+          count: 0,
+          error: m
+        });
+        for (const E of a) {
+          const { classification: M, count: q, link: F, annotations: wt } = E;
+          await e.selectors.find({ selector: { type: r, value: h, source: f, classification: M } }).incrementalRemove();
+          const S = {
+            id: g(),
+            source: f,
+            type: r,
+            value: h,
+            annotations: wt,
+            classification: M,
+            latency: o,
+            count: q,
+            link: F,
+            error: m
+          };
+          i.some((vt) => vt.id === S.id) && (S.id = g()), i.push(S);
+        }
+      }
+      const u = await e.selectors.bulkInsert(i);
+      u.error.length > 0 && (console.warn("Errors on upsert:"), u.error.forEach((c) => console.warn(c.documentId, c.validationErrors ?? c.status)));
+    },
+    [e, w]
+  ), L = $(
+    async (t, i, u = {}) => {
+      var E, M;
+      if (!t || !i)
+        return console.error(`Type (${t}) or value (${i}) is empty, returning empty response`), {};
+      const c = (v == null ? void 0 : v(D, P, [{ type: t, value: i, classification: u.classification }])) ?? D, o = {
+        timeout: A,
+        force: !1,
+        includeRaw: !1,
+        noCache: !1,
+        classification: w,
+        sources: c,
+        ...u
+      }, f = {}, r = l == null ? void 0 : l();
+      r && (f.Authorization = `Bearer ${r}`);
+      let h = { baseURL: p, headers: f };
+      y && (h = y(h));
+      const a = {
+        type: t,
+        value: i,
+        classification: o.classification
+      };
+      let m = await ((E = e.status) == null ? void 0 : E.findOne({ selector: { ...a } }).exec());
+      m ? await m.incrementalPatch({ status: "in-progress" }) : m = await ((M = e.status) == null ? void 0 : M.insert({
+        id: g(),
+        type: a.type,
+        value: a.value,
+        classification: a.classification ?? w,
+        status: "in-progress"
+      }));
+      try {
+        const q = await at([a], o.sources, o, h), F = Object.values(Object.values(q)[0])[0];
+        return await U(Object.values(F)), F;
+      } catch (q) {
+        return console.error(q), {};
+      } finally {
+        await (m == null ? void 0 : m.incrementalPatch({ status: "complete" }));
+      }
+    },
+    [
+      U,
+      P,
+      p,
+      e,
+      w,
+      A,
+      l,
+      y,
+      v,
+      D
+    ]
+  ), W = $(
+    async (t, i) => {
+      const u = (v == null ? void 0 : v(D, P, t)) ?? D, c = {
+        timeout: A,
+        includeRaw: !1,
+        noCache: !1,
+        classification: w,
+        sources: u,
+        ...i
+      }, o = {}, f = l == null ? void 0 : l();
+      f && (o.Authorization = `Bearer ${f}`);
+      let r = { baseURL: p, headers: o };
+      y && (r = y(r));
+      const h = [];
+      for (const a of t) {
+        const m = { type: a.type, value: a.value, classification: c.classification };
+        let E = await e.status.findOne({
+          selector: m
+        }).incrementalPatch({
+          status: "in-progress"
+        });
+        E || (E = await e.status.insert({
+          id: g(),
+          ...m,
+          status: "in-progress",
+          sources: c.sources
+        })), h.push(E.toMutableJSON());
+      }
+      try {
+        const a = await at(t, c.sources, c, r), m = Object.values(a).flatMap(Object.values).flatMap(Object.values);
+        return await U(m), a;
+      } catch (a) {
+        return console.error(a), {};
+      } finally {
+        e.status.bulkUpsert(
+          Wt(h, (a) => a.id).map((a) => (a.status = "complete", a))
+        );
+      }
+    },
+    [
+      v,
+      D,
+      P,
+      A,
+      w,
+      l,
+      p,
+      y,
+      e,
+      U
+    ]
+  ), k = $(async () => {
+    if (!(e != null && e.selectors) || e.selectors.closed)
+      return;
+    const t = await e.selectors.find({ selector: { error: { $exists: !0 } } }).exec(), i = lt(t, "classification"), u = [];
+    for (const [c, o] of Object.entries(i)) {
+      const f = lt(o, (r) => `${r.type}:${r.value}`);
+      Object.values(f).forEach((r) => {
+        u.push({
+          id: g(),
+          type: r[0].type,
+          value: r[0].value,
+          classification: c,
+          sources: ut(r.map((h) => h.source)).sort(),
+          status: "pending"
+        });
+      });
+    }
+    await e.status.bulkInsert(u), await e.selectors.bulkRemove(t);
+  }, [e]), tt = G(
+    () => gt(
+      async () => {
+        if (e != null && e.status) {
+          if (e.status.closed) {
+            console.warn("Status database is closed, will not enrich");
+            return;
+          }
+        } else return;
+        const t = await e.status.find({ selector: { status: "pending" } }).update({ $set: { status: "in-progress" } });
+        if (t.length < 1)
+          return;
+        const i = Ut(t, O);
+        _(
+          `Enriching ${t.length} selectors in ${i.length} chunks of ${O}.`,
+          x
+        ), await Promise.all(
+          // For performance reasons, we chunk the requests. This will allow us to take advantage of parellelization in the
+          // backend, both on the pod level and kubernetes level
+          i.map(async (u) => {
+            let c = null;
+            if (j.current <= Q)
+              j.current += 1;
+            else {
+              let o = Date.now();
+              await new Promise((f) => {
+                c = setInterval(() => {
+                  _(
+                    `Waiting on ${j.current} existing requests to complete (total delay: ${Date.now() - o}ms)`,
+                    x
+                  ), j.current < Q && f();
+                }, 400);
+              }).finally(() => {
+                j.current += 1, clearInterval(c);
+              });
+            }
+            try {
+              const o = {}, f = ut(u.flatMap((r) => r.sources ?? []));
+              f.length > 0 && (o.sources = f), await W(
+                u.map((r) => r.toSelector()),
+                o
+              ), await e.status.findByIds(u.map((r) => r.id)).update({ $set: { status: "complete" } });
+            } catch (o) {
+              console.error(o);
+            } finally {
+              j.current -= 1, c && clearInterval(c);
+            }
+          })
+        );
+      },
+      200,
+      { maxWait: 500, leading: !1 }
+    ),
+    [W, O, e, x, Q]
+  );
+  b(() => {
+  }, [e, x]), b(() => {
+    if (!B || !C || !(e != null && e.status))
+      return;
+    if (e != null && e.status.closed) {
+      console.warn("Status collection is closed");
+      return;
+    }
+    const t = e.status.find({
+      selector: {
+        status: "pending"
+      }
+    }).$.subscribe(() => tt());
+    return () => {
+      try {
+        t == null || t.unsubscribe();
+      } catch (i) {
+        console.warn(i);
+      }
+    };
+  }, [B, C, e, x, tt, (ot = e == null ? void 0 : e.status) == null ? void 0 : ot.closed]);
+  const et = $(
+    async (t, i, u) => {
+      if (!t)
+        throw new Error("Type cannot be null");
+      if (!i)
+        throw new Error("Value cannot be null");
+      const c = { type: t, value: i, classification: u ?? w };
+      let o = await e.status.findOne({
+        selector: c
+      }).exec();
+      return o || (o = await e.status.queueInsert({
+        id: g(),
+        ...c,
+        status: "pending"
+      })), o;
+    },
+    [w, e]
+  ), st = $(
+    (t) => {
+      var f, r;
+      if (!t)
+        return null;
+      const i = Object.entries(V), u = (f = i.find(([h, a]) => a.exec(t))) == null ? void 0 : f[0];
+      if (u)
+        return u;
+      const c = t.toLowerCase(), o = (r = i.find(([h, a]) => a.exec(c))) == null ? void 0 : r[0];
+      return o || null;
+    },
+    [V]
+  ), ht = G(
+    () => {
+      var t;
+      return {
+        bulkEnrich: W,
+        enrich: L,
+        enrichFailedEnrichments: k,
+        sources: D,
+        setSources: yt,
+        typesDetection: V,
+        supportedTypes: z,
+        availableSources: P,
+        guessType: st,
+        queueEnrich: et,
+        setCustomIconify: T,
+        setDefaultClassification: Z,
+        setReady: mt,
+        defaultClassification: w,
+        ready: C && !!e && !!((t = I.config) != null && t.c12nDef)
+      };
+    },
+    [
+      W,
+      L,
+      k,
+      D,
+      V,
+      z,
+      P,
+      st,
+      et,
+      Z,
+      w,
+      C,
+      e,
+      (ct = I.config) == null ? void 0 : ct.c12nDef
+    ]
+  );
+  return /* @__PURE__ */ xt(St.Provider, { value: ht, children: s });
+};
+export {
+  St as C,
+  ne as a,
+  Wt as u
+};

package/FlexOne-BXWFOd1T.js

@@ -0,0 +1,6 @@
+import { jsx as o } from "react/jsx-runtime";
+import { memo as r } from "react";
+const t = ({ children: e = null }) => /* @__PURE__ */ o("div", { style: { flex: 1 }, children: e }), n = r(t);
+export {
+  n as F
+};

package/_MapCache-BiTi0iqu.js

@@ -0,0 +1,180 @@
+import { b as d, r as _ } from "./isObjectLike-BatpeCIi.js";
+import { i as l } from "./isObject-B53jY8Qg.js";
+var ht = Array.isArray, v = "[object AsyncFunction]", g = "[object Function]", y = "[object GeneratorFunction]", b = "[object Proxy]";
+function C(t) {
+  if (!l(t))
+    return !1;
+  var e = d(t);
+  return e == g || e == y || e == v || e == b;
+}
+var u = _["__core-js_shared__"], p = function() {
+  var t = /[^.]+$/.exec(u && u.keys && u.keys.IE_PROTO || "");
+  return t ? "Symbol(src)_1." + t : "";
+}();
+function m(t) {
+  return !!p && p in t;
+}
+var O = Function.prototype, P = O.toString;
+function w(t) {
+  if (t != null) {
+    try {
+      return P.call(t);
+    } catch {
+    }
+    try {
+      return t + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var x = /[\\^$.*+?()[\]{}|]/g, j = /^\[object .+?Constructor\]$/, $ = Function.prototype, z = Object.prototype, S = $.toString, D = z.hasOwnProperty, H = RegExp(
+  "^" + S.call(D).replace(x, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function F(t) {
+  if (!l(t) || m(t))
+    return !1;
+  var e = C(t) ? H : j;
+  return e.test(w(t));
+}
+function I(t, e) {
+  return t == null ? void 0 : t[e];
+}
+function f(t, e) {
+  var r = I(t, e);
+  return F(r) ? r : void 0;
+}
+function T(t, e) {
+  return t === e || t !== t && e !== e;
+}
+var i = f(Object, "create");
+function A() {
+  this.__data__ = i ? i(null) : {}, this.size = 0;
+}
+function E(t) {
+  var e = this.has(t) && delete this.__data__[t];
+  return this.size -= e ? 1 : 0, e;
+}
+var N = "__lodash_hash_undefined__", M = Object.prototype, G = M.hasOwnProperty;
+function R(t) {
+  var e = this.__data__;
+  if (i) {
+    var r = e[t];
+    return r === N ? void 0 : r;
+  }
+  return G.call(e, t) ? e[t] : void 0;
+}
+var K = Object.prototype, L = K.hasOwnProperty;
+function U(t) {
+  var e = this.__data__;
+  return i ? e[t] !== void 0 : L.call(e, t);
+}
+var q = "__lodash_hash_undefined__";
+function J(t, e) {
+  var r = this.__data__;
+  return this.size += this.has(t) ? 0 : 1, r[t] = i && e === void 0 ? q : e, this;
+}
+function n(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var a = t[e];
+    this.set(a[0], a[1]);
+  }
+}
+n.prototype.clear = A;
+n.prototype.delete = E;
+n.prototype.get = R;
+n.prototype.has = U;
+n.prototype.set = J;
+function V() {
+  this.__data__ = [], this.size = 0;
+}
+function h(t, e) {
+  for (var r = t.length; r--; )
+    if (T(t[r][0], e))
+      return r;
+  return -1;
+}
+var B = Array.prototype, Q = B.splice;
+function W(t) {
+  var e = this.__data__, r = h(e, t);
+  if (r < 0)
+    return !1;
+  var a = e.length - 1;
+  return r == a ? e.pop() : Q.call(e, r, 1), --this.size, !0;
+}
+function X(t) {
+  var e = this.__data__, r = h(e, t);
+  return r < 0 ? void 0 : e[r][1];
+}
+function Y(t) {
+  return h(this.__data__, t) > -1;
+}
+function Z(t, e) {
+  var r = this.__data__, a = h(r, t);
+  return a < 0 ? (++this.size, r.push([t, e])) : r[a][1] = e, this;
+}
+function o(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var a = t[e];
+    this.set(a[0], a[1]);
+  }
+}
+o.prototype.clear = V;
+o.prototype.delete = W;
+o.prototype.get = X;
+o.prototype.has = Y;
+o.prototype.set = Z;
+var k = f(_, "Map");
+function tt() {
+  this.size = 0, this.__data__ = {
+    hash: new n(),
+    map: new (k || o)(),
+    string: new n()
+  };
+}
+function et(t) {
+  var e = typeof t;
+  return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? t !== "__proto__" : t === null;
+}
+function c(t, e) {
+  var r = t.__data__;
+  return et(e) ? r[typeof e == "string" ? "string" : "hash"] : r.map;
+}
+function rt(t) {
+  var e = c(this, t).delete(t);
+  return this.size -= e ? 1 : 0, e;
+}
+function at(t) {
+  return c(this, t).get(t);
+}
+function nt(t) {
+  return c(this, t).has(t);
+}
+function ot(t, e) {
+  var r = c(this, t), a = r.size;
+  return r.set(t, e), this.size += r.size == a ? 0 : 1, this;
+}
+function s(t) {
+  var e = -1, r = t == null ? 0 : t.length;
+  for (this.clear(); ++e < r; ) {
+    var a = t[e];
+    this.set(a[0], a[1]);
+  }
+}
+s.prototype.clear = tt;
+s.prototype.delete = rt;
+s.prototype.get = at;
+s.prototype.has = nt;
+s.prototype.set = ot;
+export {
+  o as L,
+  s as M,
+  k as a,
+  C as b,
+  T as e,
+  f as g,
+  ht as i,
+  w as t
+};

package/_Uint8Array-BQNOM9Rr.js

@@ -0,0 +1,101 @@
+import { i as p, L as _, a as l, M as d } from "./_MapCache-BiTi0iqu.js";
+import { d as y, a as A, c as g, i as m, f as b } from "./_getTag-CK2Sffaq.js";
+import { r as v } from "./isObjectLike-BatpeCIi.js";
+var w = 9007199254740991, z = /^(?:0|[1-9]\d*)$/;
+function S(t, e) {
+  var r = typeof t;
+  return e = e ?? w, !!e && (r == "number" || r != "symbol" && z.test(t)) && t > -1 && t % 1 == 0 && t < e;
+}
+function I(t, e) {
+  for (var r = -1, s = Array(t); ++r < t; )
+    s[r] = e(r);
+  return s;
+}
+var O = Object.prototype, x = O.hasOwnProperty;
+function E(t, e) {
+  var r = p(t), s = !r && y(t), a = !r && !s && A(t), i = !r && !s && !a && g(t), o = r || s || a || i, u = o ? I(t.length, String) : [], c = u.length;
+  for (var n in t)
+    (e || x.call(t, n)) && !(o && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (n == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    a && (n == "offset" || n == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    i && (n == "buffer" || n == "byteLength" || n == "byteOffset") || // Skip index properties.
+    S(n, c))) && u.push(n);
+  return u;
+}
+function L(t) {
+  return m(t) ? E(t) : b(t);
+}
+function P(t, e) {
+  for (var r = -1, s = e.length, a = t.length; ++r < s; )
+    t[a + r] = e[r];
+  return t;
+}
+function G() {
+  this.__data__ = new _(), this.size = 0;
+}
+function K(t) {
+  var e = this.__data__, r = e.delete(t);
+  return this.size = e.size, r;
+}
+function M(t) {
+  return this.__data__.get(t);
+}
+function R(t) {
+  return this.__data__.has(t);
+}
+var T = 200;
+function U(t, e) {
+  var r = this.__data__;
+  if (r instanceof _) {
+    var s = r.__data__;
+    if (!l || s.length < T - 1)
+      return s.push([t, e]), this.size = ++r.size, this;
+    r = this.__data__ = new d(s);
+  }
+  return r.set(t, e), this.size = r.size, this;
+}
+function f(t) {
+  var e = this.__data__ = new _(t);
+  this.size = e.size;
+}
+f.prototype.clear = G;
+f.prototype.delete = K;
+f.prototype.get = M;
+f.prototype.has = R;
+f.prototype.set = U;
+function C(t, e) {
+  for (var r = -1, s = t == null ? 0 : t.length, a = 0, i = []; ++r < s; ) {
+    var o = t[r];
+    e(o, r, t) && (i[a++] = o);
+  }
+  return i;
+}
+function k() {
+  return [];
+}
+var B = Object.prototype, F = B.propertyIsEnumerable, h = Object.getOwnPropertySymbols, $ = h ? function(t) {
+  return t == null ? [] : (t = Object(t), C(h(t), function(e) {
+    return F.call(t, e);
+  }));
+} : k;
+function D(t, e, r) {
+  var s = e(t);
+  return p(t) ? s : P(s, r(t));
+}
+function Y(t) {
+  return D(t, L, $);
+}
+var Z = v.Uint8Array;
+export {
+  f as S,
+  Z as U,
+  P as a,
+  C as b,
+  E as c,
+  $ as d,
+  D as e,
+  Y as g,
+  S as i,
+  L as k,
+  k as s
+};