@cccsaurora/clue-ui 1.2.4 → 1.2.5-dev.298

package/ClueEnrichContext-CJEJxrgs.js

@@ -0,0 +1,541 @@
+import { jsx } from "react/jsx-runtime";
+import { a as addAPIProvider } from "./iconify-CXMreGTg.js";
+import { b as useClueTypeConfig, a as api, p as post, u as uniq } from "./useClueTypeConfig-Z1LFp01b.js";
+import { clueDebugLogger } from "./utils/loggerUtil.js";
+import { b as baseSlice } from "./_baseSlice-GAv_YFTT.js";
+import { t as toFinite } from "./toFinite-Bc55msYj.js";
+import { d as debounce } from "./debounce-bV0h5FC5.js";
+import { g as groupBy } from "./groupBy-xqz-n0Vd.js";
+import { b as baseIteratee } from "./_baseIteratee-avi7MX2o.js";
+import { b as baseUniq } from "./_baseUniq-BI9GIHMF.js";
+import { useContext, useState, useMemo, useCallback, useRef, useEffect } from "react";
+import { c as createContext } from "./index-AMfoEg_6.js";
+import { ClueDatabaseContext } from "./hooks/ClueDatabaseContext.js";
+import useClueConfig from "./hooks/useClueConfig.js";
+function toInteger(value) {
+  var result = toFinite(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var nativeCeil = Math.ceil, nativeMax = Math.max;
+function chunk(array, size, guard) {
+  if (size === void 0) {
+    size = 1;
+  } else {
+    size = nativeMax(toInteger(size), 0);
+  }
+  var length = array == null ? 0 : array.length;
+  if (!length || size < 1) {
+    return [];
+  }
+  var index = 0, resIndex = 0, result = Array(nativeCeil(length / size));
+  while (index < length) {
+    result[resIndex++] = baseSlice(array, index, index += size);
+  }
+  return result;
+}
+function uniqBy(array, iteratee) {
+  return array && array.length ? baseUniq(array, baseIteratee(iteratee)) : [];
+}
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+  if (!getRandomValues) {
+    getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+    if (!getRandomValues) {
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    }
+  }
+  return getRandomValues(rnds8);
+}
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const native = {
+  randomUUID
+};
+function v4(options, buf, offset) {
+  if (native.randomUUID && true && !options) {
+    return native.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  return unsafeStringify(rnds);
+}
+const ClueEnrichContext = createContext(null);
+const ClueEnrichProvider = ({
+  children,
+  classification: _defaultClassification,
+  baseURL,
+  getToken,
+  onNetworkCall,
+  pickSources,
+  chunkSize = 15,
+  maxRequestCount = 4,
+  defaultTimeout = 5,
+  enabled = true,
+  ready = false,
+  publicIconify = true,
+  skipConfigCall = false,
+  customIconify: _customIconify,
+  debugLogging = true
+}) => {
+  var _a, _b, _c, _d, _e;
+  const clueConfig = useClueConfig();
+  const database = useContext(ClueDatabaseContext);
+  const [configuredDefaultClassification, setConfiguredDefaultClassification] = useState(null);
+  const defaultClassification = useMemo(
+    () => {
+      var _a2, _b2;
+      return configuredDefaultClassification ?? _defaultClassification ?? ((_b2 = (_a2 = clueConfig.config) == null ? void 0 : _a2.c12nDef) == null ? void 0 : _b2.RESTRICTED);
+    },
+    [_defaultClassification, (_b = (_a = clueConfig.config) == null ? void 0 : _a.c12nDef) == null ? void 0 : _b.RESTRICTED, configuredDefaultClassification]
+  );
+  const setDefaultClassification = useCallback(
+    (func) => {
+      var _a2;
+      return setConfiguredDefaultClassification(func((_a2 = clueConfig.config) == null ? void 0 : _a2.c12nDef));
+    },
+    [(_c = clueConfig.config) == null ? void 0 : _c.c12nDef]
+  );
+  const [isReady, setIsReady] = useState(ready);
+  const runningRequestCount = useRef(0);
+  const [sources, setSources] = useState([]);
+  const { availableSources, typesDetection, supportedTypes } = useClueTypeConfig(
+    enabled && isReady,
+    baseURL,
+    debugLogging,
+    getToken,
+    onNetworkCall
+  );
+  useEffect(() => {
+    if (skipConfigCall || !enabled || !isReady) {
+      return;
+    }
+    const headers = {};
+    const token = getToken == null ? void 0 : getToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    let requestConfig = { baseURL, headers };
+    if (onNetworkCall) {
+      requestConfig = onNetworkCall(requestConfig);
+    }
+    api.configs.get(requestConfig).then(clueConfig.setConfig);
+  }, [baseURL, onNetworkCall, skipConfigCall, isReady]);
+  const [customIconify, setCustomIconify] = useState(_customIconify);
+  useEffect(() => {
+    if (_customIconify) {
+      setCustomIconify(_customIconify);
+    }
+  }, [_customIconify]);
+  useEffect(() => {
+    if (publicIconify) {
+      return;
+    }
+    let iconURL = customIconify ?? void 0 ?? (baseURL == null ? void 0 : baseURL.replace(/^[^.]+/, "icons"));
+    if (!iconURL && typeof window !== "undefined" && !!window && !window.location.origin.includes("localhost")) {
+      iconURL = window.location.protocol + "//" + window.location.origin.replace(/^[^.]+/, "icons");
+    }
+    if (iconURL) {
+      clueDebugLogger(`Using ${iconURL} for iconify`, debugLogging);
+      addAPIProvider("", {
+        resources: [iconURL]
+      });
+    }
+  }, [baseURL, customIconify, debugLogging, publicIconify]);
+  const _addEntries = useCallback(
+    async (entries) => {
+      const newRecords = [];
+      for (const entry of entries) {
+        const { latency, source, type, value: value2, items, error } = entry;
+        if (error) {
+          newRecords.push({
+            id: v4(),
+            source,
+            type,
+            value: value2,
+            annotations: [],
+            classification: defaultClassification,
+            latency,
+            count: 0,
+            error
+          });
+        }
+        for (const item of items) {
+          const { classification, count, link, annotations } = item;
+          await database.selectors.find({ selector: { type, value: value2, source, classification } }).incrementalRemove();
+          const record = {
+            id: v4(),
+            source,
+            type,
+            value: value2,
+            annotations,
+            classification,
+            latency,
+            count,
+            link,
+            error
+          };
+          if (newRecords.some((_entry) => _entry.id === record.id)) {
+            record.id = v4();
+          }
+          newRecords.push(record);
+        }
+      }
+      const result = await database.selectors.bulkInsert(newRecords);
+      if (result.error.length > 0) {
+        console.warn("Errors on upsert:");
+        result.error.forEach((err) => console.warn(err.documentId, err.validationErrors ?? err.status));
+      }
+    },
+    [database, defaultClassification]
+  );
+  const enrich = useCallback(
+    async (type, value2, _options = {}) => {
+      var _a2, _b2;
+      if (!type || !value2) {
+        console.error(`Type (${type}) or value (${value2}) is empty, returning empty response`);
+        return {};
+      }
+      const _sources = (pickSources == null ? void 0 : pickSources(sources, availableSources, [{ type, value: value2, classification: _options.classification }])) ?? sources;
+      const options = {
+        timeout: defaultTimeout,
+        force: false,
+        includeRaw: false,
+        noCache: false,
+        classification: defaultClassification,
+        sources: _sources,
+        ..._options
+      };
+      const headers = {};
+      const token = getToken == null ? void 0 : getToken();
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+      let requestConfig = { baseURL, headers };
+      if (onNetworkCall) {
+        requestConfig = onNetworkCall(requestConfig);
+      }
+      const selector = {
+        type,
+        value: value2,
+        classification: options.classification
+      };
+      let statusRecord = await ((_a2 = database.status) == null ? void 0 : _a2.findOne({ selector: { ...selector } }).exec());
+      if (!statusRecord) {
+        statusRecord = await ((_b2 = database.status) == null ? void 0 : _b2.insert({
+          id: v4(),
+          type: selector.type,
+          value: selector.value,
+          classification: selector.classification ?? defaultClassification,
+          status: "in-progress"
+        }));
+      } else {
+        await statusRecord.incrementalPatch({ status: "in-progress" });
+      }
+      try {
+        const enrichmentResult = await post([selector], options.sources, options, requestConfig);
+        const enrichData = Object.values(Object.values(enrichmentResult)[0])[0];
+        await _addEntries(Object.values(enrichData));
+        return enrichData;
+      } catch (e) {
+        console.error(e);
+        return {};
+      } finally {
+        await (statusRecord == null ? void 0 : statusRecord.incrementalPatch({ status: "complete" }));
+      }
+    },
+    [
+      _addEntries,
+      availableSources,
+      baseURL,
+      database,
+      defaultClassification,
+      defaultTimeout,
+      getToken,
+      onNetworkCall,
+      pickSources,
+      sources
+    ]
+  );
+  const bulkEnrich = useCallback(
+    async (bulkRequest, _options) => {
+      const _sources = (pickSources == null ? void 0 : pickSources(sources, availableSources, bulkRequest)) ?? sources;
+      const options = {
+        timeout: defaultTimeout,
+        includeRaw: false,
+        noCache: false,
+        classification: defaultClassification,
+        sources: _sources,
+        ..._options
+      };
+      const headers = {};
+      const token = getToken == null ? void 0 : getToken();
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+      let requestConfig = { baseURL, headers };
+      if (onNetworkCall) {
+        requestConfig = onNetworkCall(requestConfig);
+      }
+      const statuses = [];
+      for (const selector of bulkRequest) {
+        const query = { type: selector.type, value: selector.value, classification: options.classification };
+        let statusRecord = await database.status.findOne({
+          selector: query
+        }).incrementalPatch({
+          status: "in-progress"
+        });
+        if (!statusRecord) {
+          statusRecord = await database.status.insert({
+            id: v4(),
+            ...query,
+            status: "in-progress",
+            sources: options.sources
+          });
+        }
+        statuses.push(statusRecord.toMutableJSON());
+      }
+      try {
+        const result = await post(bulkRequest, options.sources, options, requestConfig);
+        const entries = Object.values(result).flatMap(Object.values).flatMap(Object.values);
+        await _addEntries(entries);
+        return result;
+      } catch (e) {
+        console.error(e);
+        return {};
+      } finally {
+        database.status.bulkUpsert(
+          uniqBy(statuses, (_record) => _record.id).map((record) => {
+            record.status = "complete";
+            return record;
+          })
+        );
+      }
+    },
+    [
+      pickSources,
+      sources,
+      availableSources,
+      defaultTimeout,
+      defaultClassification,
+      getToken,
+      baseURL,
+      onNetworkCall,
+      database,
+      _addEntries
+    ]
+  );
+  const enrichFailedEnrichments = useCallback(async () => {
+    if (!(database == null ? void 0 : database.selectors) || database.selectors.closed) {
+      return;
+    }
+    const failedEnrichments = await database.selectors.find({ selector: { error: { $exists: true } } }).exec();
+    const byClassification = groupBy(failedEnrichments, "classification");
+    const newRequests = [];
+    for (const [classification, selectors] of Object.entries(byClassification)) {
+      const bySelector = groupBy(selectors, (_selector) => `${_selector.type}:${_selector.value}`);
+      Object.values(bySelector).forEach((records) => {
+        newRequests.push({
+          id: v4(),
+          type: records[0].type,
+          value: records[0].value,
+          classification,
+          sources: uniq(records.map((_record) => _record.source)).sort(),
+          status: "pending"
+        });
+      });
+    }
+    await database.status.bulkInsert(newRequests);
+    await database.selectors.bulkRemove(failedEnrichments);
+  }, [database]);
+  const enrichQueued = useMemo(
+    () => debounce(
+      async () => {
+        if (!(database == null ? void 0 : database.status)) {
+          return;
+        } else if (database.status.closed) {
+          console.warn("Status database is closed, will not enrich");
+          return;
+        }
+        const selectors = await database.status.find({ selector: { status: "pending" } }).update({ $set: { status: "in-progress" } });
+        if (selectors.length < 1) {
+          return;
+        }
+        const chunks = chunk(selectors, chunkSize);
+        clueDebugLogger(
+          `Enriching ${selectors.length} selectors in ${chunks.length} chunks of ${chunkSize}.`,
+          debugLogging
+        );
+        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
+          chunks.map(async (reqsChunk) => {
+            let _interval = null;
+            if (runningRequestCount.current <= maxRequestCount) {
+              runningRequestCount.current += 1;
+            } else {
+              let startOfWait = Date.now();
+              await new Promise((res) => {
+                _interval = setInterval(() => {
+                  clueDebugLogger(
+                    `Waiting on ${runningRequestCount.current} existing requests to complete (total delay: ${Date.now() - startOfWait}ms)`,
+                    debugLogging
+                  );
+                  if (runningRequestCount.current < maxRequestCount) {
+                    res();
+                  }
+                }, 400);
+              }).finally(() => {
+                runningRequestCount.current += 1;
+                clearInterval(_interval);
+              });
+            }
+            try {
+              const options = {};
+              const _sources = uniq(reqsChunk.flatMap((record) => record.sources ?? []));
+              if (_sources.length > 0) {
+                options.sources = _sources;
+              }
+              await bulkEnrich(
+                reqsChunk.map((record) => record.toSelector()),
+                options
+              );
+              await database.status.findByIds(reqsChunk.map((selector) => selector.id)).update({ $set: { status: "complete" } });
+            } catch (e) {
+              console.error(e);
+            } finally {
+              runningRequestCount.current -= 1;
+              if (_interval) {
+                clearInterval(_interval);
+              }
+            }
+          })
+        );
+      },
+      200,
+      { maxWait: 500, leading: false }
+    ),
+    [bulkEnrich, chunkSize, database, debugLogging, maxRequestCount]
+  );
+  useEffect(() => {
+    {
+      return;
+    }
+  }, [database, debugLogging]);
+  useEffect(() => {
+    if (!enabled || !isReady || !(database == null ? void 0 : database.status)) {
+      return;
+    }
+    if (database == null ? void 0 : database.status.closed) {
+      console.warn("Status collection is closed");
+      return;
+    }
+    const observer = database.status.find({
+      selector: {
+        status: "pending"
+      }
+    }).$.subscribe(() => enrichQueued());
+    return () => {
+      try {
+        observer == null ? void 0 : observer.unsubscribe();
+      } catch (e) {
+        console.warn(e);
+      }
+    };
+  }, [enabled, isReady, database, debugLogging, enrichQueued, (_d = database == null ? void 0 : database.status) == null ? void 0 : _d.closed]);
+  const queueEnrich = useCallback(
+    async (type, value2, classification) => {
+      if (!type) {
+        throw new Error("Type cannot be null");
+      }
+      if (!value2) {
+        throw new Error("Value cannot be null");
+      }
+      const query = { type, value: value2, classification: classification ?? defaultClassification };
+      let statusRecord = await database.status.findOne({
+        selector: query
+      }).exec();
+      if (!statusRecord) {
+        statusRecord = await database.status.queueInsert({
+          id: v4(),
+          ...query,
+          status: "pending"
+        });
+      }
+      return statusRecord;
+    },
+    [defaultClassification, database]
+  );
+  const guessType = useCallback(
+    (value2) => {
+      var _a2, _b2;
+      if (!value2) {
+        return null;
+      }
+      const types = Object.entries(typesDetection);
+      const regularCheck = (_a2 = types.find(([_type, _regexp]) => _regexp.exec(value2))) == null ? void 0 : _a2[0];
+      if (regularCheck) {
+        return regularCheck;
+      }
+      const lowercased = value2.toLowerCase();
+      const lowercaseCheck = (_b2 = types.find(([_type, _regexp]) => _regexp.exec(lowercased))) == null ? void 0 : _b2[0];
+      if (lowercaseCheck) {
+        return lowercaseCheck;
+      }
+      return null;
+    },
+    [typesDetection]
+  );
+  const value = useMemo(
+    () => {
+      var _a2;
+      return {
+        bulkEnrich,
+        enrich,
+        enrichFailedEnrichments,
+        sources,
+        setSources,
+        typesDetection,
+        supportedTypes,
+        availableSources,
+        guessType,
+        queueEnrich,
+        setCustomIconify,
+        setDefaultClassification,
+        setReady: setIsReady,
+        defaultClassification,
+        ready: isReady && !!database && !!((_a2 = clueConfig.config) == null ? void 0 : _a2.c12nDef)
+      };
+    },
+    [
+      bulkEnrich,
+      enrich,
+      enrichFailedEnrichments,
+      sources,
+      typesDetection,
+      supportedTypes,
+      availableSources,
+      guessType,
+      queueEnrich,
+      setDefaultClassification,
+      defaultClassification,
+      isReady,
+      database,
+      (_e = clueConfig.config) == null ? void 0 : _e.c12nDef
+    ]
+  );
+  return /* @__PURE__ */ jsx(ClueEnrichContext.Provider, { value, children });
+};
+export {
+  ClueEnrichContext as C,
+  ClueEnrichProvider as a,
+  uniqBy as u
+};

package/FlexOne-BSYAhhtG.js

@@ -0,0 +1,9 @@
+import { jsx } from "react/jsx-runtime";
+import { memo } from "react";
+const FlexOne = ({ children = null }) => {
+  return /* @__PURE__ */ jsx("div", { style: { flex: 1 }, children });
+};
+const FlexOne$1 = memo(FlexOne);
+export {
+  FlexOne$1 as F
+};