@cccsaurora/clue-ui 0.15.0 → 1.0.0-dev.48

package/hooks/selectors.d.ts

@@ -0,0 +1,10 @@
+import { ClueActionContextType } from './ClueActionContext';
+import { ClueComponentContextType } from './ClueComponentContext';
+import { ClueEnrichContextType } from './ClueEnrichContextType';
+import { ClueFetcherContextType } from './ClueFetcherContext';
+
+export declare const useClueFetcherSelector: <Selected>(selector: (value: ClueFetcherContextType) => Selected) => Selected;
+export declare const useClueActionsSelector: <Selected>(selector: (value: ClueActionContextType) => Selected) => Selected;
+export declare const useClueEnrichSelector: <Selected>(selector: (value: ClueEnrichContextType) => Selected) => Selected;
+export declare const useClueComponentSelector: <Selected>(selector: (value: ClueComponentContextType) => Selected) => Selected;
+export default useClueEnrichSelector;

package/hooks/selectors.js

@@ -0,0 +1,24 @@
+import { u as useContextSelector } from "../index-BDVjGvMI.js";
+import { a as ClueActionContext } from "../ActionForm-c5hLIfQ-.js";
+import { ClueComponentContext } from "./ClueComponentContext.js";
+import { C as ClueEnrichContext } from "../ClueEnrichContext-m-4vn9rz.js";
+import { ClueFetcherContext } from "./ClueFetcherContext.js";
+const useClueFetcherSelector = (selector) => {
+  return useContextSelector(ClueFetcherContext, selector);
+};
+const useClueActionsSelector = (selector) => {
+  return useContextSelector(ClueActionContext, selector);
+};
+const useClueEnrichSelector = (selector) => {
+  return useContextSelector(ClueEnrichContext, selector);
+};
+const useClueComponentSelector = (selector) => {
+  return useContextSelector(ClueComponentContext, selector);
+};
+export {
+  useClueEnrichSelector as default,
+  useClueActionsSelector,
+  useClueComponentSelector,
+  useClueEnrichSelector,
+  useClueFetcherSelector
+};

package/hooks/useAnnotations.d.ts

@@ -0,0 +1,24 @@
+import { Annotation, WithExtra } from "../types/lookup";
+
+interface AnnotationOptions {
+    skipEnrichment?: boolean;
+}
+/**
+ * Custom hook to manage and retrieve annotations for a specific type, value, and classification.
+ *
+ * This hook interacts with the Clue database to:
+ * 1. Track the loading state of annotations.
+ * 2. Automatically queue enrichment tasks if required.
+ * 3. Retrieve and update annotations in real-time using RxDB observables.
+ *
+ * @param type - The type of the annotation (e.g., entity type).
+ * @param value - The value to search for annotations.
+ * @param classification - The classification of the annotation.
+ * @param options - Additional options:
+ *   - skipEnrichment: If true, skips the enrichment process.
+ * @returns A tuple containing:
+ *   - An array of annotations with extra metadata.
+ *   - A boolean indicating the loading state.
+ */
+declare const useAnnotations: (type: string, value: string, _classification?: string, { skipEnrichment }?: AnnotationOptions) => [WithExtra<Annotation>[], boolean];
+export default useAnnotations;

package/hooks/useAnnotations.js

@@ -0,0 +1,69 @@
+import { b as baseIteratee } from "../_baseIteratee-p6Nj07-n.js";
+import { b as baseUniq } from "../_baseUniq-CpupKWcL.js";
+import { useContext, useMemo, useState, useEffect } from "react";
+import { ClueDatabaseContext } from "./ClueDatabaseContext.js";
+import { useClueEnrichSelector } from "./selectors.js";
+function uniqBy(array, iteratee) {
+  return array && array.length ? baseUniq(array, baseIteratee(iteratee)) : [];
+}
+const useAnnotations = (type, value, _classification, { skipEnrichment } = { skipEnrichment: false }) => {
+  const database = useContext(ClueDatabaseContext);
+  const defaultClassification = useClueEnrichSelector((ctx) => ctx.defaultClassification);
+  const enrichReady = useClueEnrichSelector((ctx) => ctx.ready);
+  const availableSources = useClueEnrichSelector((ctx) => ctx.availableSources);
+  const queueEnrich = useClueEnrichSelector((state) => state.queueEnrich);
+  const classification = useMemo(
+    () => _classification ?? defaultClassification,
+    [_classification, defaultClassification]
+  );
+  const [loading, setLoading] = useState(false);
+  const [annotations, setAnnotations] = useState([]);
+  const ready = useMemo(
+    () => enrichReady && !!type && !!value && !!classification,
+    [classification, enrichReady, type, value]
+  );
+  useEffect(() => {
+    if (!ready || !(database == null ? void 0 : database.status)) {
+      return;
+    }
+    const observable = database.status.count({ selector: { type, value, classification, status: "in-progress" } }).$.subscribe((_count) => setLoading(_count > 0));
+    return () => {
+      observable == null ? void 0 : observable.unsubscribe();
+    };
+  }, [classification, database, ready, type, value]);
+  useEffect(() => {
+    if (skipEnrichment || availableSources.length < 1 || !ready) {
+      return;
+    }
+    queueEnrich(type, value, classification);
+  }, [availableSources.length, classification, queueEnrich, ready, skipEnrichment, type, value]);
+  useEffect(() => {
+    if (!ready) {
+      return;
+    }
+    const observable = database.selectors.find({
+      selector: {
+        // Use regex instead of exact value for case-insensitivity
+        value: { $regex: `^${value}$`, $options: "i" }
+      }
+    }).$.subscribe(
+      (result) => setAnnotations(
+        uniqBy(
+          result.flatMap((entry) => entry.getAnnotations()),
+          JSON.stringify
+        )
+      )
+    );
+    return () => {
+      try {
+        observable.unsubscribe();
+      } catch (e) {
+        console.warn(e);
+      }
+    };
+  }, [database, ready, value]);
+  return [annotations, loading];
+};
+export {
+  useAnnotations as default
+};

package/hooks/useClue.d.ts

@@ -0,0 +1,4 @@
+import { ClueEnrichContextType } from './ClueEnrichContextType';
+
+declare const useClue: () => ClueEnrichContextType;
+export default useClue;

package/hooks/useClue.js

@@ -0,0 +1,8 @@
+import { a as useContext } from "../index-BDVjGvMI.js";
+import { C as ClueEnrichContext } from "../ClueEnrichContext-m-4vn9rz.js";
+const useClue = () => {
+  return useContext(ClueEnrichContext);
+};
+export {
+  useClue as default
+};

package/hooks/useClueActions.d.ts

@@ -0,0 +1,4 @@
+import { ClueActionContextType } from './ClueActionContext';
+
+declare const useClueActions: () => ClueActionContextType;
+export default useClueActions;

package/hooks/useClueActions.js

@@ -0,0 +1,5 @@
+import "../index-BDVjGvMI.js";
+import { u } from "../ActionForm-c5hLIfQ-.js";
+export {
+  u as default
+};

package/hooks/useClueConfig.d.ts

@@ -0,0 +1 @@
+export default function useClueConfig(): import("../hooks/ClueConfigProvider").ClueConfigContextType;

package/hooks/useClueConfig.js

@@ -0,0 +1,8 @@
+import { ClueConfigContext } from "./ClueConfigProvider.js";
+import { useContext } from "react";
+function useClueConfig() {
+  return useContext(ClueConfigContext);
+}
+export {
+  useClueConfig as default
+};

package/hooks/useClueTypeConfig.d.ts

@@ -0,0 +1,17 @@
+import { AxiosRequestConfig } from 'axios';
+
+/**
+ * Hook to populate and provide the types detection and the available sources.
+ * @param ready         Flag to signify if clue is ready to populate the types and sources.
+ * @param baseURL       The base URL of the clue enrichment API.
+ * @param debugLogging  Flag to toggle debug logging.
+ * @param getToken      Callback to fetch the Bearer token.
+ * @param onNetworkCall Callback to configure Axios requests.
+ * @returns             An object containing the available sources and the types detection.
+ */
+export default function useClueTypeConfig(ready: boolean, baseURL: string, debugLogging: boolean, getToken?: () => string, onNetworkCall?: (config: AxiosRequestConfig) => AxiosRequestConfig): {
+    availableSources: Array<string>;
+    typesDetection: {
+        [type: string]: RegExp;
+    };
+};

package/hooks/useClueTypeConfig.js

@@ -0,0 +1,7 @@
+import { u } from "../useClueTypeConfig-D4zcy8Gr.js";
+import "../utils/loggerUtil.js";
+import "react";
+import "../isEmpty-BQkZubqU.js";
+export {
+  u as default
+};

package/hooks/useComparator.d.ts

@@ -0,0 +1,16 @@
+import { BaseComparator, EdgeStyler, NodeStyler } from "../types/graph";
+import { CSSProperties } from 'react';
+
+declare const useComparator: () => {
+    runComparators: (comparators: (NodeStyler | EdgeStyler)[], nodeOrSource: {
+        [index: string]: any;
+    }, target?: {
+        [index: string]: any;
+    }) => CSSProperties;
+    runComparator: (comparator: BaseComparator | NodeStyler | EdgeStyler, nodeOrSource: {
+        [index: string]: any;
+    }, target?: {
+        [index: string]: any;
+    }) => CSSProperties | boolean;
+};
+export default useComparator;