@cccsaurora/clue-ui 1.0.1 → 1.1.0-dev.10

package/AnnotationPreview-DiQDjt9s.js

@@ -0,0 +1,188 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { I as Icon } from "./iconify-CXMreGTg.js";
+import { useTheme, Popper, Fade, Paper, Stack, Typography, Divider } from "@mui/material";
+import AnnotationDetailPopover from "./components/AnnotationDetailPopover.js";
+import useAnnotations from "./hooks/useAnnotations.js";
+import { t as twitterShort } from "./utils-Dr4wbKBZ.js";
+import { useState, useRef, useCallback, useEffect, useMemo } from "react";
+import { c as createContext, u as useContextSelector } from "./index-BDVjGvMI.js";
+import { SHOW_EVENT_ID, HIDE_EVENT_ID } from "./data/event.js";
+import { safeDispatchEvent, safeAddEventListener } from "./utils/window.js";
+import { i as isNull } from "./AnnotationDetails-YAPoqw3R.js";
+const CluePopupContext = createContext(null);
+const CluePopupProvider = ({ children }) => {
+  const [popupType, setPopupType] = useState(null);
+  const [detailsAnchorEl, setDetailsAnchorEl] = useState(null);
+  const [detailsData, setDetailsData] = useState(null);
+  const [detailsContent, setDetailsContent] = useState(null);
+  const [popoverProps, setPopoverProps] = useState({});
+  const externalOnClose = useRef(null);
+  const showInfo = useCallback((type, anchorEl, value, options) => {
+    safeDispatchEvent(
+      new CustomEvent(SHOW_EVENT_ID, {
+        detail: {
+          type,
+          anchorEl,
+          value,
+          options
+        }
+      })
+    );
+  }, []);
+  const closeInfo = useCallback(
+    (type, value) => {
+      safeDispatchEvent(
+        new CustomEvent(HIDE_EVENT_ID, {
+          detail: {
+            type,
+            value
+          }
+        })
+      );
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const handleShowPopup = useCallback((event) => {
+    const { detail } = event;
+    setPopupType(detail.type);
+    setDetailsData(detail.value);
+    if (detail.options) {
+      if (detail.options.content) {
+        setDetailsContent(detail.options.content);
+      }
+      if (detail.options.onClose) {
+        externalOnClose.current = detail.options.onClose;
+      }
+      if (detail.options.popoverProps) {
+        setPopoverProps(detail.options.popoverProps);
+      }
+    }
+    setDetailsAnchorEl(detail.anchorEl);
+  }, []);
+  const handleHidePopup = useCallback(
+    (event) => {
+      const { detail } = event;
+      if (detailsData && (detail.type !== popupType || detailsData.type !== detail.value.type || detailsData.value !== detail.value.value)) {
+        return;
+      }
+      setPopupType(null);
+      setDetailsAnchorEl(null);
+      setDetailsData(null);
+      setDetailsContent(null);
+      setPopoverProps({});
+      externalOnClose.current = null;
+    },
+    [detailsData, popupType]
+  );
+  useEffect(() => {
+    const cleanupShow = safeAddEventListener(SHOW_EVENT_ID, handleShowPopup);
+    const cleanupHide = safeAddEventListener(HIDE_EVENT_ID, handleHidePopup);
+    return () => {
+      cleanupShow();
+      cleanupHide();
+    };
+  }, [handleShowPopup, handleHidePopup]);
+  const context = useMemo(
+    () => ({
+      showInfo,
+      closeInfo,
+      __detailsContent: detailsContent
+    }),
+    [closeInfo, detailsContent, showInfo]
+  );
+  return /* @__PURE__ */ jsxs(CluePopupContext.Provider, { value: context, children: [
+    children,
+    /* @__PURE__ */ jsx(
+      AnnotationDetailPopover,
+      {
+        ...popoverProps,
+        anchorEl: detailsAnchorEl,
+        open: !!detailsAnchorEl && popupType === "details",
+        enrichRequest: detailsData,
+        onClose: () => {
+          if (externalOnClose.current) {
+            externalOnClose.current();
+          } else {
+            closeInfo("details", detailsData);
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      AnnotationPreview,
+      {
+        ...popoverProps,
+        anchorEl: detailsAnchorEl,
+        open: !!detailsAnchorEl && !isNull(popupType) && popupType !== "details",
+        annotationType: popupType,
+        enrichRequest: detailsData
+      }
+    )
+  ] });
+};
+const AnnotationPreview = ({ annotationType, anchorEl, enrichRequest, open, ...otherProps }) => {
+  const theme = useTheme();
+  const _detailsContent = useContextSelector(CluePopupContext, (state) => state.__detailsContent);
+  const [annotations] = useAnnotations(enrichRequest == null ? void 0 : enrichRequest.type, enrichRequest == null ? void 0 : enrichRequest.value, enrichRequest == null ? void 0 : enrichRequest.classification);
+  const filteredAnnotations = useMemo(
+    () => annotationType === "actionResults" ? [] : annotations.filter((annotation) => annotation.type === annotationType),
+    [annotationType, annotations]
+  );
+  const getZIndex = useCallback((_anchorEl) => {
+    try {
+      const zIndex = parseInt(window.getComputedStyle(_anchorEl, null).getPropertyValue("z-index"));
+      if (isNaN(zIndex)) {
+        return getZIndex(_anchorEl.parentElement);
+      }
+      return (zIndex + 2).toString();
+    } catch {
+      return "2";
+    }
+  }, []);
+  if (!filteredAnnotations.length && !_detailsContent) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    Popper,
+    {
+      ...otherProps,
+      open,
+      anchorEl,
+      placement: "bottom-start",
+      sx: [{ zIndex: getZIndex(anchorEl) }, ...Array.isArray(otherProps.sx) ? otherProps.sx : [otherProps.sx]],
+      children: /* @__PURE__ */ jsx(Fade, { in: !!anchorEl, children: /* @__PURE__ */ jsx(Paper, { sx: { overflowY: "auto", maxWidth: "500px", boxShadow: theme.shadows[2] }, children: /* @__PURE__ */ jsx(Stack, { direction: "column", sx: { p: 1 }, spacing: 1, divider: /* @__PURE__ */ jsx(Divider, { orientation: "horizontal" }), children: _detailsContent ?? filteredAnnotations.map((annotation) => /* @__PURE__ */ jsxs(
+        Stack,
+        {
+          direction: "column",
+          spacing: 1,
+          children: [
+            /* @__PURE__ */ jsxs(Stack, { direction: "row", spacing: 1, alignItems: "center", children: [
+              annotation.analytic_icon && /* @__PURE__ */ jsx(
+                Icon,
+                {
+                  icon: annotation.analytic_icon,
+                  style: { filter: "drop-shadow(0px 0px 1px rgb(0 0 0 / 0.4))" }
+                }
+              ),
+              /* @__PURE__ */ jsx(Typography, { variant: "body1", sx: { textTransform: "capitalize" }, children: annotation.analytic ?? annotation.author }),
+              /* @__PURE__ */ jsxs(Typography, { variant: "caption", color: "text.secondary", children: [
+                "(",
+                twitterShort(annotation.timestamp),
+                ")"
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx(Typography, { variant: "body2", children: annotation.summary }),
+            /* @__PURE__ */ jsx(Typography, { variant: "caption", color: "text.secondary", children: annotation.value })
+          ]
+        },
+        annotation.analytic + annotation.author + annotation.value + annotation.link + annotation.summary + annotation.timestamp
+      )) }) }) })
+    }
+  );
+};
+export {
+  AnnotationPreview as A,
+  CluePopupContext as C,
+  CluePopupProvider as a
+};

package/ClueEnrichContext-DIn6g8tw.js

@@ -0,0 +1,522 @@
+import { jsx } from "react/jsx-runtime";
+import { a as addAPIProvider } from "./iconify-CXMreGTg.js";
+import { u as useClueTypeConfig, a as api, p as post } from "./useClueTypeConfig-CH-nGq6a.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-DC2oOuBN.js";
+import { b as baseUniq } from "./_baseUniq-CpupKWcL.js";
+import { b as baseIteratee } from "./_baseIteratee-p6Nj07-n.js";
+import { useContext, useMemo, useState, useRef, useEffect, useCallback } from "react";
+import { c as createContext } from "./index-BDVjGvMI.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 uniq(array) {
+  return array && array.length ? baseUniq(array) : [];
+}
+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;
+  const clueConfig = useClueConfig();
+  const database = useContext(ClueDatabaseContext);
+  const defaultClassification = useMemo(() => {
+    var _a2, _b;
+    return (_b = (_a2 = clueConfig.config) == null ? void 0 : _a2.c12nDef) == null ? void 0 : _b.UNRESTRICTED;
+  }, [clueConfig.config]);
+  const [isReady, setIsReady] = useState(ready);
+  const runningRequestCount = useRef(0);
+  const [sources, setSources] = useState([]);
+  const { availableSources, typesDetection } = 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, _b;
+      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 ((_b = database.status) == null ? void 0 : _b.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 (statusRecord == null ? void 0 : statusRecord.incrementalPatch({ status: "complete" }));
+        await _addEntries(Object.values(enrichData));
+        return enrichData;
+      } catch (e) {
+        console.error(e);
+        return {};
+      }
+    },
+    [
+      _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 () => {
+    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;
+    }
+    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]);
+  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, _b;
+      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 = (_b = types.find(([_type, _regexp]) => _regexp.exec(lowercased))) == null ? void 0 : _b[0];
+      if (lowercaseCheck) {
+        return lowercaseCheck;
+      }
+      return null;
+    },
+    [typesDetection]
+  );
+  const value = useMemo(
+    () => {
+      var _a2;
+      return {
+        bulkEnrich,
+        enrich,
+        enrichFailedEnrichments,
+        sources,
+        setSources,
+        typesDetection,
+        availableSources,
+        guessType,
+        queueEnrich,
+        setCustomIconify,
+        setReady: setIsReady,
+        defaultClassification,
+        ready: isReady && !!database && !!((_a2 = clueConfig.config) == null ? void 0 : _a2.c12nDef)
+      };
+    },
+    [
+      bulkEnrich,
+      enrich,
+      enrichFailedEnrichments,
+      sources,
+      typesDetection,
+      availableSources,
+      guessType,
+      queueEnrich,
+      defaultClassification,
+      isReady,
+      database,
+      (_a = clueConfig.config) == null ? void 0 : _a.c12nDef
+    ]
+  );
+  return /* @__PURE__ */ jsx(ClueEnrichContext.Provider, { value, children });
+};
+export {
+  ClueEnrichContext as C,
+  ClueEnrichProvider as a,
+  uniqBy as b,
+  uniq as u
+};