@xyo-network/react-node-renderer 2.64.1 → 2.64.4

package/dist/browser/components/module/index.js

@@ -0,0 +1,588 @@
+// src/components/module/CardParser.tsx
+import { asArchivistInstance, isArchivistInstance } from "@xyo-network/archivist-model";
+import { asDivinerInstance, isDivinerInstance } from "@xyo-network/diviner-model";
+import { ArchivistCard } from "@xyo-network/react-archivist";
+import { DivinerCard, ModuleCard } from "@xyo-network/react-module";
+import { jsx } from "react/jsx-runtime";
+var ModuleCardParser = ({ module }) => {
+  switch (true) {
+    case isArchivistInstance(module):
+      return /* @__PURE__ */ jsx(ArchivistCard, { module: asArchivistInstance(module) });
+    case isDivinerInstance(module):
+      return /* @__PURE__ */ jsx(DivinerCard, { module: asDivinerInstance(module) });
+    default:
+      return /* @__PURE__ */ jsx(ModuleCard, { module });
+  }
+};
+
+// src/components/module/graph/GraphFlexBox.tsx
+import { Button as Button2 } from "@mui/material";
+
+// src/contexts/CytoscapeInstance/Context.ts
+import { createContextEx } from "@xyo-network/react-shared";
+var CytoscapeInstanceContext = createContextEx();
+
+// src/contexts/CytoscapeInstance/Provider.tsx
+import { useEffect, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var CytoscapeInstanceProvider = ({ children, defaultInstance }) => {
+  const [cy, setCy] = useState(defaultInstance);
+  useEffect(() => {
+    setCy(defaultInstance);
+  }, [defaultInstance]);
+  return /* @__PURE__ */ jsx2(CytoscapeInstanceContext.Provider, { value: { cy, provided: true, setCy }, children });
+};
+
+// src/contexts/CytoscapeInstance/use.ts
+import { useContextEx } from "@xyo-network/react-shared";
+var useCytoscapeInstance = (required = false) => useContextEx(CytoscapeInstanceContext, "CytoscapeInstance", required);
+
+// src/hooks/cytoscape/useCytoscapeElements.ts
+import { useAsyncEffect } from "@xylabs/react-async-effect";
+import { isNodeInstance as isNodeInstance3 } from "@xyo-network/node-model";
+import { useEffect as useEffect2, useState as useState2 } from "react";
+
+// src/Cytoscape/CytoscapeElements.ts
+import { isNodeInstance as isNodeInstance2 } from "@xyo-network/node-model";
+
+// src/Cytoscape/lib/encodeSvg.ts
+import { renderToStaticMarkup } from "react-dom/server";
+var dataUri = "data:image/svg+xml,";
+var encodeSvg = (reactElement, color) => {
+  const svgString = renderToStaticMarkup(reactElement);
+  const doc = new DOMParser().parseFromString(svgString, "text/html");
+  const svgElement = doc.getElementsByTagName("svg")[0];
+  if (svgElement) {
+    svgElement.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+    svgElement.setAttribute("height", "100");
+    svgElement.style.fill = color ?? "black";
+  }
+  return `${dataUri}${window.encodeURIComponent(svgElement.outerHTML)}`;
+};
+
+// src/Cytoscape/lib/iconMap.ts
+var generateIconMap = () => ({
+  archivist: "",
+  bridge: "",
+  diviner: "",
+  module: "",
+  node: "",
+  sentinel: "",
+  witness: ""
+});
+
+// src/Cytoscape/lib/layout/ColaLayout.ts
+var ColaLayout = {
+  centerGraph: false,
+  convergenceThreshold: 0.01,
+  name: "cola"
+};
+
+// src/Cytoscape/lib/layout/ConcentricLayout.ts
+var ConcentricLayout = {
+  concentric: function(node) {
+    return node.degree();
+  },
+  levelWidth: function() {
+    return 2;
+  },
+  minNodeSpacing: 75,
+  name: "concentric"
+};
+
+// src/Cytoscape/lib/parseModuleType.ts
+import { isArchivistInstance as isArchivistInstance2 } from "@xyo-network/archivist-model";
+import { isBridgeInstance } from "@xyo-network/bridge-model";
+import { isDivinerInstance as isDivinerInstance2 } from "@xyo-network/diviner-model";
+import { isNodeInstance } from "@xyo-network/node-model";
+import { isSentinelInstance } from "@xyo-network/sentinel";
+import { isWitnessModule } from "@xyo-network/witness";
+var parseModuleType = (module) => {
+  let type = "module";
+  if (module) {
+    if (isArchivistInstance2(module)) {
+      type = "archivist";
+    } else if (isBridgeInstance(module)) {
+      type = "bridge";
+    } else if (isDivinerInstance2(module)) {
+      type = "diviner";
+    } else if (isNodeInstance(module)) {
+      type = "node";
+    } else if (isSentinelInstance(module)) {
+      type = "sentinel";
+    } else if (isWitnessModule(module)) {
+      type = "witness";
+    } else {
+      type = "module";
+    }
+  }
+  return type;
+};
+
+// src/Cytoscape/CytoscapeElements.ts
+var CytoscapeElements = class _CytoscapeElements {
+  static MaxNameLength = 20;
+  static buildEdge(rootNode, newNode) {
+    return {
+      data: {
+        id: `${rootNode.data.id}/${newNode.data.id}`,
+        source: rootNode.data.id,
+        target: newNode.data.id
+      }
+    };
+  }
+  static async buildElements(module) {
+    const newRootNode = _CytoscapeElements.buildRootNode(module);
+    const newElements = [newRootNode];
+    try {
+      const childElements = await _CytoscapeElements.recurseNodes(module);
+      childElements?.forEach((module2) => {
+        const newNode = _CytoscapeElements.buildNode(module2, newRootNode.data.id);
+        newElements.push(newNode);
+        const newEdge = _CytoscapeElements.buildEdge(newRootNode, newNode);
+        newElements.push(newEdge);
+      });
+      return newElements;
+    } catch (e) {
+      console.error("error resolving modules", e);
+      return [];
+    }
+  }
+  static buildNode(module, rootNodeId) {
+    const { address, config } = module;
+    const normalizedName = config.name ?? address.substring(0, 8);
+    return {
+      data: {
+        address,
+        id: address,
+        name: normalizedName,
+        rootNodeId,
+        type: parseModuleType(module)
+      }
+    };
+  }
+  static buildRootNode = (module) => {
+    return _CytoscapeElements.buildNode(module);
+  };
+  static normalizeName(name) {
+    if (!name)
+      return;
+    if (name.length > this.MaxNameLength)
+      return `${name.substring(0, 20)}...`;
+    return name;
+  }
+  static async recurseNodes(module, maxTraversals = 1) {
+    let localDepth = 0;
+    const childModules = [];
+    const traverse = async (nestedNode) => {
+      if (localDepth < maxTraversals) {
+        const modules = await nestedNode.resolve(void 0, { direction: "down", maxDepth: 2 });
+        await Promise.all(
+          modules.map(async (child) => {
+            if (child !== nestedNode && isNodeInstance2(child)) {
+              localDepth++;
+              await traverse(child);
+            } else if (child !== module) {
+              childModules.push(child);
+            }
+          })
+        );
+      }
+    };
+    await traverse(module);
+    return childModules;
+  }
+};
+
+// src/Cytoscape/CytoscapeIcons.tsx
+import {
+  BubbleChartRounded as BubbleChartRoundedIcon,
+  Hub as HubIcon,
+  InsertLinkRounded as InsertLinkRoundedIcon,
+  Inventory2Rounded as Inventory2RoundedIcon,
+  QuestionMarkRounded as QuestionMarkRoundedIcon,
+  TimerRounded as TimerRoundedIcon,
+  VisibilityRounded as VisibilityRoundedIcon
+} from "@mui/icons-material";
+var CyIconSet = {
+  archivist: Inventory2RoundedIcon,
+  bridge: InsertLinkRoundedIcon,
+  diviner: BubbleChartRoundedIcon,
+  module: QuestionMarkRoundedIcon,
+  node: HubIcon,
+  sentinel: TimerRoundedIcon,
+  witness: VisibilityRoundedIcon
+};
+
+// src/Cytoscape/CytoscapeStyles.ts
+var NodeIdStyles = (color, outlineColor) => ({
+  selector: "node[name]",
+  style: {
+    color,
+    "font-family": "Lexend Deca, Helvetica, sans-serif",
+    "font-size": 12,
+    "overlay-padding": "6px",
+    "text-halign": "center",
+    "text-outline-color": outlineColor,
+    "text-outline-width": "1px",
+    "text-valign": "top"
+  }
+});
+var NodeStyled = (icons, bgColor, hideLabels = false) => ({
+  selector: "node",
+  style: {
+    "background-color": bgColor,
+    "background-height": "75%",
+    "background-image": (elem) => icons[elem.data("type")],
+    "background-width": "24",
+    label: hideLabels ? void 0 : "data(name)",
+    shape: "round-rectangle"
+  }
+});
+var EdgeStyled = (lineColor, targetArrowColor) => ({
+  selector: "edge",
+  style: {
+    "curve-style": "bezier",
+    "line-color": lineColor,
+    "line-opacity": 0.1,
+    "target-arrow-color": targetArrowColor,
+    "target-arrow-shape": "triangle",
+    width: 3
+  }
+});
+
+// src/hooks/cytoscape/useCytoscapeElements.ts
+var useCytoscapeElements = (module) => {
+  const [elements, setElements] = useState2([]);
+  useAsyncEffect(
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    async () => {
+      if (module) {
+        const newElements = await CytoscapeElements.buildElements(module) ?? [];
+        setElements(newElements);
+      }
+    },
+    [module]
+  );
+  useEffect2(() => {
+    let attachedListener = void 0;
+    let detachedListener = void 0;
+    if (module && isNodeInstance3(module)) {
+      attachedListener = module.on("moduleAttached", async () => {
+        const newElements = await CytoscapeElements.buildElements(module) ?? [];
+        setElements(newElements);
+      });
+      detachedListener = module.on("moduleDetached", async () => {
+        const newElements = await CytoscapeElements.buildElements(module) ?? [];
+        setElements(newElements);
+      });
+    }
+    return () => {
+      attachedListener?.();
+      detachedListener?.();
+    };
+  }, [module]);
+  return elements;
+};
+
+// src/hooks/cytoscape/useCytoscapeOptions.ts
+import { useMemo as useMemo3 } from "react";
+
+// src/hooks/cytoscape/useCytoscapeStyle.tsx
+import { useTheme as useTheme2 } from "@mui/material";
+import { useMemo as useMemo2 } from "react";
+
+// src/hooks/cytoscape/useIcons.tsx
+import { useTheme } from "@mui/material";
+import { useMemo } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var useIcons = () => {
+  const theme = useTheme();
+  const icons = useMemo(() => {
+    const iconMap = generateIconMap();
+    return Object.entries(CyIconSet).reduce((acc, [name, IconComponent]) => {
+      const icon = /* @__PURE__ */ jsx3(IconComponent, { fontSize: "small" });
+      acc[name] = encodeSvg(icon, theme.palette.getContrastText(theme.palette.text.primary));
+      return acc;
+    }, iconMap);
+  }, [theme.palette]);
+  return icons;
+};
+
+// src/hooks/cytoscape/useCytoscapeStyle.tsx
+var useCytoscapeStyle = (hideLabels = false) => {
+  const theme = useTheme2();
+  const icons = useIcons();
+  const style = useMemo2(
+    () => [
+      NodeIdStyles(theme.palette.text.primary, theme.palette.getContrastText(theme.palette.text.primary)),
+      NodeStyled(icons, theme.palette.primary.main, hideLabels),
+      EdgeStyled(theme.palette.divider, theme.palette.divider)
+    ],
+    [icons, hideLabels, theme]
+  );
+  return style;
+};
+
+// src/hooks/cytoscape/useCytoscapeOptions.ts
+var useCytoscapeOptions = (elements, style, layout) => {
+  const defaultStyle = useCytoscapeStyle();
+  const resolvedLayout = layout ?? ConcentricLayout;
+  const resolvedStyle = style ?? defaultStyle;
+  const options = useMemo3(() => {
+    if (elements && resolvedLayout && resolvedStyle) {
+      return {
+        elements,
+        layout: resolvedLayout,
+        style: resolvedStyle
+      };
+    }
+  }, [elements, layout, style]);
+  return options;
+};
+
+// src/hooks/cytoscape/useHoveredNode.tsx
+import { useCallback, useEffect as useEffect3, useState as useState3 } from "react";
+var useHoveredNode = (renderedElements) => {
+  const { cy } = useCytoscapeInstance(true);
+  const [hoveredNode, setHoveredNode] = useState3();
+  const nodeListener = useCallback((node) => {
+    node.on("mouseover tap", () => {
+      setHoveredNode(node);
+    });
+    node.on("mouseout", () => {
+      setHoveredNode(void 0);
+    });
+  }, []);
+  useEffect3(() => {
+    if (renderedElements) {
+      renderedElements.nodes().forEach(nodeListener);
+    }
+  }, [nodeListener, renderedElements]);
+  useEffect3(() => {
+    cy?.ready(() => {
+      cy.nodes().forEach(nodeListener);
+    });
+  }, [cy, nodeListener]);
+  return hoveredNode;
+};
+
+// src/hooks/cytoscape/useNewElements.tsx
+import { useModuleFromNode } from "@xyo-network/react-node";
+import { useEffect as useEffect4 } from "react";
+var useNewElements = (selectedElement) => {
+  const { cy } = useCytoscapeInstance(true);
+  const { address: selectedAddress } = selectedElement?.data() ?? {};
+  const [module] = useModuleFromNode(selectedAddress);
+  const newElements = useCytoscapeElements(module);
+  useEffect4(() => {
+    if (selectedAddress) {
+      const element = cy?.$(`node[id="${selectedAddress}"]`);
+      if (element?.length)
+        cy?.center(element);
+    }
+  }, [cy, selectedAddress]);
+  return newElements;
+};
+
+// src/hooks/cytoscape/useRelationalGraphOptions.tsx
+import { useState as useState4 } from "react";
+var useRelationalGraphOptions = (module) => {
+  const [hideLabels, setHideLabels] = useState4(true);
+  const handleToggleLabels = () => {
+    setHideLabels((oldValue) => !oldValue);
+  };
+  const elements = useCytoscapeElements(module);
+  const style = useCytoscapeStyle(hideLabels);
+  const options = useCytoscapeOptions(elements, style, ConcentricLayout);
+  return { handleToggleLabels, hideLabels, options };
+};
+
+// src/hooks/cytoscape/useRenderNewElements.tsx
+import { useEffect as useEffect5, useState as useState5 } from "react";
+var useRenderNewElements = (newElements = [], hideLabels) => {
+  const { cy } = useCytoscapeInstance(true);
+  const [renderedElements, setRenderedElements] = useState5();
+  useEffect5(() => {
+    if (newElements.length > 1) {
+      const renderedElements2 = cy?.add(newElements);
+      setRenderedElements(renderedElements2);
+      cy?.layout(ColaLayout).run();
+    }
+  }, [cy, hideLabels, newElements]);
+  return renderedElements;
+};
+
+// src/hooks/cytoscape/useSelectedElement.tsx
+import { useEffect as useEffect6, useState as useState6 } from "react";
+var useSelectedElement = () => {
+  const { cy } = useCytoscapeInstance(true);
+  const [selectedElement, setSelectedElement] = useState6();
+  useEffect6(() => {
+    const listener = (event) => {
+      const element = event.target[0];
+      if (element.isNode())
+        setSelectedElement(element);
+    };
+    cy?.on("select", listener);
+    return () => {
+      cy?.off("select", listener);
+    };
+  }, [cy, setSelectedElement]);
+  return selectedElement;
+};
+
+// src/components/cytoscape-extensions/WithExtensions.tsx
+import { use } from "cytoscape";
+import cola from "cytoscape-cola";
+import { useEffect as useEffect7, useState as useState7 } from "react";
+import { Fragment, jsx as jsx4 } from "react/jsx-runtime";
+var WithExtensions = ({ children }) => {
+  const [initialized, setInitialized] = useState7(false);
+  useEffect7(() => {
+    use(cola);
+    setInitialized(true);
+  }, []);
+  return /* @__PURE__ */ jsx4(Fragment, { children: initialized ? children : void 0 });
+};
+
+// src/components/RelationalGraph.tsx
+import { Button, ButtonGroup, styled } from "@mui/material";
+import { FlexCol, FlexRow } from "@xylabs/react-flexbox";
+import { useShareForwardedRef } from "@xyo-network/react-shared";
+import cytoscape from "cytoscape";
+import { forwardRef, useEffect as useEffect8, useState as useState8 } from "react";
+import { Fragment as Fragment2, jsx as jsx5, jsxs } from "react/jsx-runtime";
+var NodeRelationalGraphFlexBox = forwardRef(({ actions, children, options, ...props }, ref) => {
+  const [cy, setCy] = useState8();
+  const { setCy: setCyContext } = useCytoscapeInstance();
+  const sharedRef = useShareForwardedRef(ref);
+  const handleReset = () => {
+    cy?.reset();
+    cy?.fit(void 0, 20);
+  };
+  useEffect8(() => {
+    if (sharedRef) {
+      const newCy = cytoscape({
+        container: sharedRef.current,
+        ...options
+      });
+      setCy(newCy);
+    }
+  }, [options, sharedRef]);
+  useEffect8(() => {
+    setCyContext?.(cy);
+  }, [cy, setCyContext]);
+  return /* @__PURE__ */ jsxs(FlexCol, { ...props, children: [
+    /* @__PURE__ */ jsx5(ActionsContainer, { children: /* @__PURE__ */ jsx5(Fragment2, { children: actions ? /* @__PURE__ */ jsxs(ButtonGroup, { children: [
+      actions,
+      /* @__PURE__ */ jsx5(Button, { size: "small", variant: "contained", onClick: handleReset, children: "Reset" })
+    ] }) : /* @__PURE__ */ jsx5(Button, { size: "small", variant: "contained", onClick: handleReset, children: "Reset" }) }) }),
+    /* @__PURE__ */ jsx5(FlexCol, { alignItems: "stretch", height: "100%", position: "absolute", ref: sharedRef, width: "100%" }),
+    children
+  ] });
+});
+NodeRelationalGraphFlexBox.displayName = "NodeRelationalGraph";
+var ActionsContainer = styled(FlexRow, { name: "ActionsContainer" })(({ theme }) => ({
+  flexWrap: "wrap",
+  gap: theme.spacing(1),
+  position: "absolute",
+  right: "10px",
+  top: "10px",
+  zIndex: 2
+}));
+
+// src/components/module/graph/NodeHover.tsx
+import { FlexCol as FlexCol3 } from "@xylabs/react-flexbox";
+import { useEffect as useEffect9, useLayoutEffect, useRef, useState as useState9 } from "react";
+
+// src/components/module/graph/Popper.tsx
+import { alpha, Chip, Popper, Typography } from "@mui/material";
+import { FlexCol as FlexCol2, FlexRow as FlexRow2 } from "@xylabs/react-flexbox";
+import { Identicon } from "@xylabs/react-identicon";
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var ModuleHoverPopper = ({ address, element, name, ...props }) => {
+  return /* @__PURE__ */ jsx6(Fragment3, { children: element ? /* @__PURE__ */ jsx6(Popper, { anchorEl: element, ...props, children: /* @__PURE__ */ jsxs2(FlexCol2, { gap: 2, p: 2, paper: true, sx: { backgroundColor: (theme) => alpha(theme.palette.background.paper, 0.95) }, children: [
+    /* @__PURE__ */ jsxs2(FlexRow2, { gap: 2, children: [
+      /* @__PURE__ */ jsx6(Identicon, { value: address, size: 24 }),
+      /* @__PURE__ */ jsx6(Typography, { children: name })
+    ] }),
+    /* @__PURE__ */ jsx6(Chip, { label: address, color: "primary" })
+  ] }) }) : null });
+};
+
+// src/components/module/graph/NodeHover.tsx
+import { Fragment as Fragment4, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var ModuleGraphNodeHover = ({ node }) => {
+  const { address, name } = node?.data() ?? {};
+  const [boundingBox, setBoundingBox] = useState9(node?.renderedBoundingBox());
+  const ref = useRef(null);
+  const [currentEl, setCurrentEl] = useState9(null);
+  useEffect9(() => {
+    setCurrentEl(null);
+  }, [node]);
+  useEffect9(() => {
+    if (node) {
+      setBoundingBox(node.renderedBoundingBox());
+    }
+    const listener = () => {
+      setBoundingBox(node?.renderedBoundingBox());
+    };
+    node?.on("position", listener);
+    return () => {
+      node?.off("position", void 0, listener);
+    };
+  }, [node]);
+  useLayoutEffect(() => {
+    setCurrentEl(ref.current);
+  }, [boundingBox]);
+  return /* @__PURE__ */ jsxs3(Fragment4, { children: [
+    /* @__PURE__ */ jsx7(
+      FlexCol3,
+      {
+        ref,
+        sx: {
+          // For easier debugging of the 'ghost' element that matches the hovered cytoscape node
+          // backgroundColor: '#fff',
+          // opacity: 0.25,
+          cursor: "pointer",
+          height: boundingBox?.h,
+          left: boundingBox?.x1,
+          pointerEvents: "none",
+          position: "absolute",
+          top: boundingBox?.y1,
+          width: boundingBox?.w
+        }
+      }
+    ),
+    node ? /* @__PURE__ */ jsx7(Fragment4, { children: /* @__PURE__ */ jsx7(ModuleHoverPopper, { address, element: currentEl, name, placement: "top", open: true }) }) : null
+  ] });
+};
+
+// src/components/module/graph/GraphFlexBox.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var ModuleGraphFlexBox = ({ rootModule, ...props }) => {
+  const { handleToggleLabels, hideLabels, options } = useRelationalGraphOptions(rootModule ?? void 0);
+  const selectedElement = useSelectedElement();
+  const newElements = useNewElements(selectedElement);
+  const renderedElements = useRenderNewElements(newElements, hideLabels);
+  const hoveredNode = useHoveredNode(renderedElements);
+  return /* @__PURE__ */ jsx8(WithExtensions, { children: /* @__PURE__ */ jsx8(
+    NodeRelationalGraphFlexBox,
+    {
+      actions: /* @__PURE__ */ jsx8(Button2, { size: "small", onClick: handleToggleLabels, variant: "contained", children: "Toggle Labels" }),
+      options,
+      ...props,
+      children: /* @__PURE__ */ jsx8(ModuleGraphNodeHover, { node: hoveredNode })
+    }
+  ) });
+};
+var ModuleGraphFlexBoxWithProvider = (props) => {
+  return /* @__PURE__ */ jsx8(CytoscapeInstanceProvider, { children: /* @__PURE__ */ jsx8(ModuleGraphFlexBox, { ...props }) });
+};
+export {
+  ModuleCardParser,
+  ModuleGraphFlexBox,
+  ModuleGraphFlexBoxWithProvider
+};
+//# sourceMappingURL=index.js.map