@cccsaurora/clue-ui 1.0.0-dev.49 → 1.0.0

package/ClueEnrichContext-CbJVBm4w.js

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

@@ -0,0 +1,54 @@
+import { b as i, r as o } from "./isObjectLike-BatpeCIi.js";
+import { i as c } from "./isObject-B53jY8Qg.js";
+var k = Array.isArray, s = "[object AsyncFunction]", u = "[object Function]", f = "[object GeneratorFunction]", p = "[object Proxy]";
+function y(r) {
+  if (!c(r))
+    return !1;
+  var t = i(r);
+  return t == u || t == f || t == s || t == p;
+}
+var e = o["__core-js_shared__"], a = function() {
+  var r = /[^.]+$/.exec(e && e.keys && e.keys.IE_PROTO || "");
+  return r ? "Symbol(src)_1." + r : "";
+}();
+function g(r) {
+  return !!a && a in r;
+}
+var v = Function.prototype, b = v.toString;
+function l(r) {
+  if (r != null) {
+    try {
+      return b.call(r);
+    } catch {
+    }
+    try {
+      return r + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var j = /[\\^$.*+?()[\]{}|]/g, P = /^\[object .+?Constructor\]$/, T = Function.prototype, $ = Object.prototype, d = T.toString, h = $.hasOwnProperty, O = RegExp(
+  "^" + d.call(h).replace(j, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function S(r) {
+  if (!c(r) || g(r))
+    return !1;
+  var t = y(r) ? O : P;
+  return t.test(l(r));
+}
+function _(r, t) {
+  return r == null ? void 0 : r[t];
+}
+function m(r, t) {
+  var n = _(r, t);
+  return S(n) ? n : void 0;
+}
+var A = m(o, "Map");
+export {
+  A as M,
+  y as a,
+  m as g,
+  k as i,
+  l as t
+};

package/_MapCache-Cu25RRDU.js

@@ -0,0 +1,129 @@
+import { g as p, M as l } from "./_Map-DXNg_Z-q.js";
+function c(t, e) {
+  return t === e || t !== t && e !== e;
+}
+var s = p(Object, "create");
+function u() {
+  this.__data__ = s ? s(null) : {}, this.size = 0;
+}
+function d(t) {
+  var e = this.has(t) && delete this.__data__[t];
+  return this.size -= e ? 1 : 0, e;
+}
+var f = "__lodash_hash_undefined__", v = Object.prototype, g = v.hasOwnProperty;
+function C(t) {
+  var e = this.__data__;
+  if (s) {
+    var a = e[t];
+    return a === f ? void 0 : a;
+  }
+  return g.call(e, t) ? e[t] : void 0;
+}
+var y = Object.prototype, z = y.hasOwnProperty;
+function m(t) {
+  var e = this.__data__;
+  return s ? e[t] !== void 0 : z.call(e, t);
+}
+var w = "__lodash_hash_undefined__";
+function b(t, e) {
+  var a = this.__data__;
+  return this.size += this.has(t) ? 0 : 1, a[t] = s && e === void 0 ? w : e, this;
+}
+function n(t) {
+  var e = -1, a = t == null ? 0 : t.length;
+  for (this.clear(); ++e < a; ) {
+    var r = t[e];
+    this.set(r[0], r[1]);
+  }
+}
+n.prototype.clear = u;
+n.prototype.delete = d;
+n.prototype.get = C;
+n.prototype.has = m;
+n.prototype.set = b;
+function x() {
+  this.__data__ = [], this.size = 0;
+}
+function o(t, e) {
+  for (var a = t.length; a--; )
+    if (c(t[a][0], e))
+      return a;
+  return -1;
+}
+var D = Array.prototype, H = D.splice;
+function O(t) {
+  var e = this.__data__, a = o(e, t);
+  if (a < 0)
+    return !1;
+  var r = e.length - 1;
+  return a == r ? e.pop() : H.call(e, a, 1), --this.size, !0;
+}
+function P(t) {
+  var e = this.__data__, a = o(e, t);
+  return a < 0 ? void 0 : e[a][1];
+}
+function j(t) {
+  return o(this.__data__, t) > -1;
+}
+function M(t, e) {
+  var a = this.__data__, r = o(a, t);
+  return r < 0 ? (++this.size, a.push([t, e])) : a[r][1] = e, this;
+}
+function i(t) {
+  var e = -1, a = t == null ? 0 : t.length;
+  for (this.clear(); ++e < a; ) {
+    var r = t[e];
+    this.set(r[0], r[1]);
+  }
+}
+i.prototype.clear = x;
+i.prototype.delete = O;
+i.prototype.get = P;
+i.prototype.has = j;
+i.prototype.set = M;
+function N() {
+  this.size = 0, this.__data__ = {
+    hash: new n(),
+    map: new (l || i)(),
+    string: new n()
+  };
+}
+function S(t) {
+  var e = typeof t;
+  return e == "string" || e == "number" || e == "symbol" || e == "boolean" ? t !== "__proto__" : t === null;
+}
+function _(t, e) {
+  var a = t.__data__;
+  return S(e) ? a[typeof e == "string" ? "string" : "hash"] : a.map;
+}
+function E(t) {
+  var e = _(this, t).delete(t);
+  return this.size -= e ? 1 : 0, e;
+}
+function I(t) {
+  return _(this, t).get(t);
+}
+function A(t) {
+  return _(this, t).has(t);
+}
+function G(t, e) {
+  var a = _(this, t), r = a.size;
+  return a.set(t, e), this.size += a.size == r ? 0 : 1, this;
+}
+function h(t) {
+  var e = -1, a = t == null ? 0 : t.length;
+  for (this.clear(); ++e < a; ) {
+    var r = t[e];
+    this.set(r[0], r[1]);
+  }
+}
+h.prototype.clear = N;
+h.prototype.delete = E;
+h.prototype.get = I;
+h.prototype.has = A;
+h.prototype.set = G;
+export {
+  i as L,
+  h as M,
+  c as e
+};

package/_Uint8Array-DlJCtTvG.js

@@ -0,0 +1,102 @@
+import { L as _, M as l } from "./_MapCache-Cu25RRDU.js";
+import { i as h, M as y } from "./_Map-DXNg_Z-q.js";
+import { c as d, a as m, b as A, e as g, i as b } from "./_getTag-BV_UoLYG.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 = h(t), s = !r && d(t), a = !r && !s && m(t), i = !r && !s && !a && A(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 b(t) ? E(t) : g(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 M(t) {
+  var e = this.__data__, r = e.delete(t);
+  return this.size = e.size, r;
+}
+function K(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 (!y || s.length < T - 1)
+      return s.push([t, e]), this.size = ++r.size, this;
+    r = this.__data__ = new l(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 = M;
+f.prototype.get = K;
+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, p = Object.getOwnPropertySymbols, $ = p ? function(t) {
+  return t == null ? [] : (t = Object(t), C(p(t), function(e) {
+    return F.call(t, e);
+  }));
+} : k;
+function D(t, e, r) {
+  var s = e(t);
+  return h(t) ? s : P(s, r(t));
+}
+function Z(t) {
+  return D(t, L, $);
+}
+var q = v.Uint8Array;
+export {
+  f as S,
+  q as U,
+  P as a,
+  C as b,
+  E as c,
+  $ as d,
+  D as e,
+  Z as g,
+  S as i,
+  L as k,
+  k as s
+};

package/_baseAssignValue-CUmzp727.js

@@ -0,0 +1,20 @@
+import { g as i } from "./_Map-DXNg_Z-q.js";
+var a = function() {
+  try {
+    var e = i(Object, "defineProperty");
+    return e({}, "", {}), e;
+  } catch {
+  }
+}();
+function o(e, r, t) {
+  r == "__proto__" && a ? a(e, r, {
+    configurable: !0,
+    enumerable: !0,
+    value: t,
+    writable: !0
+  }) : e[r] = t;
+}
+export {
+  o as b,
+  a as d
+};