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

package/hooks/useErrors.js

@@ -1,35 +1,31 @@
-import { useContext, useState, useEffect } from "react";
-import { ClueDatabaseContext } from "./ClueDatabaseContext.js";
-import { useClueEnrichSelector } from "./selectors.js";
-const useErrors = (value) => {
-  const database = useContext(ClueDatabaseContext);
-  const ready = useClueEnrichSelector((ctx) => ctx.ready);
-  const [errors, setErrors] = useState([]);
-  useEffect(() => {
-    if (!ready || !value) {
+import { useContext as a, useState as i, useEffect as b } from "react";
+import { ClueDatabaseContext as f } from "./ClueDatabaseContext.js";
+import { useClueEnrichSelector as m } from "./selectors.js";
+const x = (r) => {
+  const t = a(f), o = m((e) => e.ready), [n, u] = i([]);
+  return b(() => {
+    if (!o || !r)
       return;
-    }
-    const observable = database.selectors.find({ selector: { value, error: { $exists: true } } }).$.subscribe(
-      (records) => (
+    const e = t.selectors.find({ selector: { value: r, error: { $exists: !0 } } }).$.subscribe(
+      (s) => (
         // Transform database records into simplified error objects
-        setErrors(
-          records.map((record) => ({
-            source: record.source,
-            message: record.error
+        u(
+          s.map((c) => ({
+            source: c.source,
+            message: c.error
           }))
         )
       )
     );
     return () => {
       try {
-        observable.unsubscribe();
-      } catch (e) {
-        console.warn(e);
+        e.unsubscribe();
+      } catch (s) {
+        console.warn(s);
       }
     };
-  }, [database, ready, value]);
-  return errors;
+  }, [t, o, r]), n;
 };
 export {
-  useErrors as default
+  x as default
 };

package/hooks/useMyHighlights.js

@@ -1,74 +1,44 @@
-import { getSubGraphNodeSet } from "../utils/graph.js";
-import { safeAddEventListener } from "../utils/window.js";
-import { useMemo, useState, useCallback, useEffect } from "react";
-const useMyHighlights = (graph, onNodeSelectionChanged) => {
-  const data = useMemo(() => graph == null ? void 0 : graph.data, [graph]);
-  const [hoveredNode, setHoveredNode] = useState();
-  const [highlightedNodes, setHighlightedNodes] = useState(/* @__PURE__ */ new Set());
-  const [highlightedPath, setHighlightedPath] = useState(/* @__PURE__ */ new Set());
-  const [ctrlKeyDown, setCtrlKeyDown] = useState();
-  const onKeyPressed = useCallback((ev) => {
-    setCtrlKeyDown(ev.ctrlKey);
+import { getSubGraphNodeSet as H } from "../utils/graph.js";
+import { safeAddEventListener as S } from "../utils/window.js";
+import { useMemo as P, useState as h, useCallback as i, useEffect as w } from "react";
+const z = (n, c) => {
+  const u = P(() => n == null ? void 0 : n.data, [n]), [o, f] = h(), [t, g] = h(/* @__PURE__ */ new Set()), [d, p] = h(/* @__PURE__ */ new Set()), [y, a] = h(), K = i((e) => {
+    a(e.ctrlKey);
+  }, []), m = i((e) => {
+    a(e.ctrlKey);
   }, []);
-  const onKeyUnpressed = useCallback((ev) => {
-    setCtrlKeyDown(ev.ctrlKey);
-  }, []);
-  useEffect(() => {
-    return safeAddEventListener("keydown", onKeyPressed);
-  }, [onKeyPressed]);
-  useEffect(() => {
-    return safeAddEventListener("keyup", onKeyUnpressed);
-  }, [onKeyUnpressed]);
-  const onNodeHoveredChanged = useCallback((nodeId, isHovered) => {
-    if (isHovered) {
-      setHoveredNode(nodeId);
-    } else {
-      setHoveredNode("");
-    }
-  }, []);
-  const onNodeClicked = useCallback(
-    (nodeId, isSelected, event) => {
-      let newHighlightedNodes = /* @__PURE__ */ new Set();
-      if (isSelected) {
-        newHighlightedNodes = new Set(event.ctrlKey ? [...highlightedNodes, nodeId] : [nodeId]);
-      } else {
-        newHighlightedNodes = event.ctrlKey ? /* @__PURE__ */ new Set([...highlightedNodes]) : /* @__PURE__ */ new Set();
-        newHighlightedNodes.delete(nodeId);
-      }
-      setHighlightedNodes(newHighlightedNodes);
-      onNodeSelectionChanged == null ? void 0 : onNodeSelectionChanged([...newHighlightedNodes]);
+  w(() => S("keydown", K), [K]), w(() => S("keyup", m), [m]);
+  const N = i((e, s) => {
+    f(s ? e : "");
+  }, []), b = i(
+    (e, s, l) => {
+      let r = /* @__PURE__ */ new Set();
+      s ? r = new Set(l.ctrlKey ? [...t, e] : [e]) : (r = l.ctrlKey ? /* @__PURE__ */ new Set([...t]) : /* @__PURE__ */ new Set(), r.delete(e)), g(r), c == null || c([...r]);
     },
-    [highlightedNodes, onNodeSelectionChanged]
+    [t, c]
+  ), k = i(
+    (e) => d.size === 0 || d.has(e) ? 1 : 0.2,
+    [d]
   );
-  const nodeOpacities = useCallback(
-    (nodeId) => {
-      return highlightedPath.size === 0 || highlightedPath.has(nodeId) ? 1 : 0.2;
-    },
-    [highlightedPath]
-  );
-  useEffect(() => {
-    let newHighlightedPath = /* @__PURE__ */ new Set();
-    if (hoveredNode) {
-      const subGraphNodes = getSubGraphNodeSet(hoveredNode, data);
-      newHighlightedPath = /* @__PURE__ */ new Set([...newHighlightedPath, ...subGraphNodes]);
-    }
-    if (highlightedNodes.size && (ctrlKeyDown || !hoveredNode)) {
-      highlightedNodes.forEach((highlightedNode) => {
-        const subGraphNodes = getSubGraphNodeSet(highlightedNode, data);
-        newHighlightedPath = /* @__PURE__ */ new Set([...newHighlightedPath, ...subGraphNodes]);
-      });
+  return w(() => {
+    let e = /* @__PURE__ */ new Set();
+    if (o) {
+      const s = H(o, u);
+      e = /* @__PURE__ */ new Set([...e, ...s]);
     }
-    setHighlightedPath(newHighlightedPath);
-  }, [hoveredNode, highlightedNodes, ctrlKeyDown, data]);
-  return {
-    onNodeHoveredChanged,
-    onNodeClicked,
-    nodeOpacities,
-    highlightedPath,
-    highlightedNodes,
-    hoveredNode
+    t.size && (y || !o) && t.forEach((s) => {
+      const l = H(s, u);
+      e = /* @__PURE__ */ new Set([...e, ...l]);
+    }), p(e);
+  }, [o, t, y, u]), {
+    onNodeHoveredChanged: N,
+    onNodeClicked: b,
+    nodeOpacities: k,
+    highlightedPath: d,
+    highlightedNodes: t,
+    hoveredNode: o
   };
 };
 export {
-  useMyHighlights as default
+  z as default
 };

package/hooks/useMyLocalStorage.js

@@ -1,80 +1,60 @@
-import { useCallback, useMemo, useState, useEffect, createContext, useContext } from "react";
-import { i as isNull, a as isUndefined } from "../isUndefined-CE8h73dH.js";
+import { useCallback as c, useMemo as g, useState as L, useEffect as v, createContext as I, useContext as d } from "react";
+import { i as O, a as p } from "../isUndefined-DiNCDKoz.js";
 import "react/jsx-runtime";
-import { MY_LOCAL_STORAGE_PREFIX } from "../utils/constants.js";
-function useLocalStorage(prefix) {
-  const _buildKey = useCallback((name) => `${prefix}.${name}`, [prefix]);
-  const get = useCallback((key) => JSON.parse(localStorage.getItem(_buildKey(key))), [_buildKey]);
-  const set = useCallback(
-    (key, value) => localStorage.setItem(_buildKey(key), JSON.stringify(value)),
-    [_buildKey]
-  );
-  const remove = useCallback(
-    (key, withPrefix = false) => localStorage.removeItem(withPrefix ? key : _buildKey(key)),
-    [_buildKey]
-  );
-  const has = useCallback((key) => get(key) !== null, [get]);
-  const keys = useCallback(() => Object.keys(localStorage), []);
-  const items = useCallback(() => keys().map((k) => ({ key: k, value: JSON.parse(localStorage.getItem(k)) })), [keys]);
-  const clear = useCallback(
-    () => keys().forEach((key) => {
-      if (key.startsWith(prefix)) {
-        remove(key, true);
-      }
+import { MY_LOCAL_STORAGE_PREFIX as S } from "../utils/constants.js";
+function i(o) {
+  const e = c((t) => `${o}.${t}`, [o]), a = c((t) => JSON.parse(localStorage.getItem(e(t))), [e]), m = c(
+    (t, l) => localStorage.setItem(e(t), JSON.stringify(l)),
+    [e]
+  ), r = c(
+    (t, l = !1) => localStorage.removeItem(l ? t : e(t)),
+    [e]
+  ), n = c((t) => a(t) !== null, [a]), s = c(() => Object.keys(localStorage), []), u = c(() => s().map((t) => ({ key: t, value: JSON.parse(localStorage.getItem(t)) })), [s]), f = c(
+    () => s().forEach((t) => {
+      t.startsWith(o) && r(t, !0);
     }),
-    [prefix, remove, keys]
+    [o, r, s]
   );
-  return useMemo(
+  return g(
     () => ({
-      get,
-      set,
-      remove,
-      has,
-      keys,
-      items,
-      clear
+      get: a,
+      set: m,
+      remove: r,
+      has: n,
+      keys: s,
+      items: u,
+      clear: f
     }),
-    [get, set, remove, has, keys, items, clear]
+    [a, m, r, n, s, u, f]
   );
 }
-function useLocalStorageItem(key, initialValue, prefix) {
-  const { get, set, has, remove } = useLocalStorage(prefix);
-  const [value, setValue] = useState(get(key) ?? initialValue);
-  useEffect(() => {
-    if (initialValue !== null && initialValue !== void 0 && !has(key)) {
-      set(key, initialValue);
-    }
-  }, [key, initialValue, has, set]);
-  return useMemo(
+function C(o, e, a) {
+  const { get: m, set: r, has: n, remove: s } = i(a), [u, f] = L(m(o) ?? e);
+  return v(() => {
+    e != null && !n(o) && r(o, e);
+  }, [o, e, n, r]), g(
     () => [
-      value,
-      (newValue, save = true) => {
-        if (save) {
-          if (!isNull(newValue) && !isUndefined(newValue)) {
-            set(key, newValue);
-          } else {
-            remove(key);
-          }
-        }
-        setValue(newValue);
+      u,
+      (t, l = !0) => {
+        l && (!O(t) && !p(t) ? r(o, t) : s(o)), f(t);
       },
-      () => remove(key)
+      () => s(o)
     ],
-    [key, value, set, remove]
+    [o, u, r, s]
   );
 }
-const LocalStorageContext = createContext(null);
-function useMyLocalStorage() {
-  return useLocalStorage(MY_LOCAL_STORAGE_PREFIX);
+const M = I(null);
+function b() {
+  return i(S);
 }
-function useMyLocalStorageItem(key, initialValue) {
-  return useLocalStorageItem(key, initialValue, MY_LOCAL_STORAGE_PREFIX);
+function J(o, e) {
+  return C(o, e, S);
 }
-function useMyLocalStorageProvider() {
-  return useContext(LocalStorageContext);
+function A() {
+  return d(M);
 }
 export {
-  useMyLocalStorage as default,
-  useMyLocalStorageItem,
-  useMyLocalStorageProvider
+  b as default,
+  J as useMyLocalStorageItem,
+  A as useMyLocalStorageProvider
 };