@hitachivantara/uikit-react-lab 6.1.9 → 6.1.10

package/dist/Flow/DroppableFlow.js

@@ -1,205 +1,140 @@
-import { jsxs, Fragment, jsx } from "react/jsx-runtime";
-import { useState, useRef, useCallback } from "react";
-import { useDroppable, useDndMonitor } from "@dnd-kit/core";
-import { Global } from "@emotion/react";
-import { addEdge, applyNodeChanges, applyEdgeChanges, MarkerType, ReactFlow } from "reactflow";
-import { uid } from "uid";
-import { useUniqueId } from "@hitachivantara/uikit-react-core";
+import { useFlowInstance } from "./hooks/useFlowInstance.js";
+import { useNodeMetaRegistry } from "./FlowContext/NodeMetaContext.js";
 import { flowStyles } from "./base.js";
 import { useClasses } from "./Flow.styles.js";
-import { staticClasses } from "./Flow.styles.js";
-import { useNodeMetaRegistry } from "./FlowContext/NodeMetaContext.js";
-import { useFlowInstance } from "./hooks/useFlowInstance.js";
-const getNode = (nodes, nodeId) => {
-  return nodes.find((n) => n.id === nodeId);
-};
-const validateEdge = (nodes, edges, connection, nodeMetaRegistry) => {
-  const {
-    source: sourceId,
-    sourceHandle,
-    target: targetId,
-    targetHandle
-  } = connection;
-  if (!sourceHandle || !targetHandle || !sourceId || !targetId) return false;
-  const sourceNode = getNode(nodes, sourceId);
-  const targetNode = getNode(nodes, targetId);
-  if (!sourceNode || !targetNode) return false;
-  const sourceType = sourceNode.type;
-  const targetType = targetNode.type;
-  if (!sourceType || !targetType) return false;
-  const inputs = nodeMetaRegistry[targetId]?.inputs || [];
-  const outputs = nodeMetaRegistry[sourceId]?.outputs || [];
-  const source = outputs.flatMap((out) => out.outputs || out).find((out) => out.id === sourceHandle);
-  const target = inputs.flatMap((inp) => inp.inputs || inp).find((inp) => inp.id === targetHandle);
-  const sourceProvides = source?.provides || "";
-  const targetAccepts = target?.accepts || [];
-  const sourceMaxConnections = source?.maxConnections;
-  const targetMaxConnections = target?.maxConnections;
-  let isValid = targetAccepts.length === 0 || targetAccepts.includes(sourceProvides);
-  if (isValid && targetMaxConnections != null) {
-    const targetConnections = edges.filter(
-      (edg) => edg.target === targetId && edg.targetHandle === targetHandle
-    ).length;
-    isValid = targetConnections < targetMaxConnections;
-  }
-  if (isValid && sourceMaxConnections != null) {
-    const sourceConnections = edges.filter(
-      (edg) => edg.source === sourceId && edg.sourceHandle === sourceHandle
-    ).length;
-    isValid = sourceConnections < sourceMaxConnections;
-  }
-  return isValid;
+import { useCallback, useRef, useState } from "react";
+import { useUniqueId } from "@hitachivantara/uikit-react-core";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Global } from "@emotion/react";
+import { MarkerType, ReactFlow, addEdge, applyEdgeChanges, applyNodeChanges } from "reactflow";
+import { uid } from "uid";
+import { useDndMonitor, useDroppable } from "@dnd-kit/core";
+//#region src/Flow/DroppableFlow.tsx
+var getNode = (nodes, nodeId) => {
+	return nodes.find((n) => n.id === nodeId);
 };
-const HvDroppableFlow = ({
-  id,
-  className,
-  children,
-  onFlowChange,
-  onDndDrop,
-  classes: classesProp,
-  nodes: initialNodes = [],
-  edges: initialEdges = [],
-  onConnect: onConnectProp,
-  onNodesChange: onNodesChangeProp,
-  onEdgesChange: onEdgesChangeProp,
-  defaultEdgeOptions: defaultEdgeOptionsProp,
-  nodeTypes,
-  ...others
-}) => {
-  const { classes, cx } = useClasses(classesProp);
-  const elementId = useUniqueId(id);
-  const reactFlowInstance = useFlowInstance();
-  const [nodes, setNodes] = useState(initialNodes);
-  const [edges, setEdges] = useState(initialEdges);
-  const nodesRef = useRef(initialNodes);
-  const edgesRef = useRef(initialEdges);
-  const updateNodes = (nds) => {
-    setNodes(nds);
-    nodesRef.current = nds;
-  };
-  const updateEdges = (eds) => {
-    setEdges(eds);
-    edgesRef.current = eds;
-  };
-  const { setNodeRef } = useDroppable({
-    id: elementId
-  });
-  const handleDragEnd = useCallback(
-    (event) => {
-      if (event.over?.id !== elementId) return;
-      const hvFlow = event.active.data.current?.hvFlow;
-      const type = hvFlow?.type;
-      if (!type || !nodeTypes?.[type]) {
-        return;
-      }
-      const position = reactFlowInstance.screenToFlowPosition({
-        x: hvFlow?.x || 0,
-        y: hvFlow?.y || 0
-      });
-      const data = {
-        nodeLabel: hvFlow?.label,
-        ...hvFlow?.data
-      };
-      const newNode = {
-        id: uid(),
-        position,
-        data,
-        type
-      };
-      if (onDndDrop) {
-        onDndDrop(event, newNode);
-        return;
-      }
-      updateNodes(nodes.concat(newNode));
-    },
-    [elementId, nodeTypes, nodes, onDndDrop, reactFlowInstance]
-  );
-  useDndMonitor({
-    onDragEnd: handleDragEnd
-  });
-  const handleFlowChange = useCallback(
-    (nds, eds) => {
-      const isDragging = nds.find((node) => node.dragging);
-      if (!isDragging) {
-        onFlowChange?.(nds, eds);
-      }
-    },
-    [onFlowChange]
-  );
-  const handleConnect = useCallback(
-    (connection) => {
-      const eds = addEdge(connection, edgesRef.current);
-      updateEdges(eds);
-      handleFlowChange(nodesRef.current, eds);
-      onConnectProp?.(connection);
-    },
-    [handleFlowChange, onConnectProp]
-  );
-  const handleNodesChange = useCallback(
-    (changes) => {
-      const nds = applyNodeChanges(changes, nodesRef.current);
-      updateNodes(nds);
-      handleFlowChange(nds, edgesRef.current);
-      onNodesChangeProp?.(changes);
-    },
-    [handleFlowChange, onNodesChangeProp]
-  );
-  const handleEdgesChange = useCallback(
-    (changes) => {
-      const eds = applyEdgeChanges(changes, edgesRef.current);
-      updateEdges(eds);
-      handleFlowChange(nodesRef.current, eds);
-      onEdgesChangeProp?.(changes);
-    },
-    [handleFlowChange, onEdgesChangeProp]
-  );
-  const { registry } = useNodeMetaRegistry();
-  const isValidConnection = (connection) => validateEdge(nodes, edges, connection, registry);
-  const defaultEdgeOptions = {
-    markerEnd: {
-      type: MarkerType.ArrowClosed,
-      height: 20,
-      width: 20
-    },
-    type: "smoothstep",
-    pathOptions: {
-      borderRadius: 40
-    },
-    ...defaultEdgeOptionsProp
-  };
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(Global, { styles: flowStyles }),
-    /* @__PURE__ */ jsx(
-      "div",
-      {
-        id: elementId,
-        ref: setNodeRef,
-        className: cx(classes.root, className),
-        children: /* @__PURE__ */ jsx(
-          ReactFlow,
-          {
-            nodes,
-            edges,
-            nodeTypes,
-            onNodesChange: handleNodesChange,
-            onEdgesChange: handleEdgesChange,
-            onConnect: handleConnect,
-            isValidConnection,
-            defaultEdgeOptions,
-            snapGrid: [1, 1],
-            snapToGrid: true,
-            onError: (code, message) => {
-            },
-            ...others,
-            children
-          }
-        )
-      }
-    )
-  ] });
+var validateEdge = (nodes, edges, connection, nodeMetaRegistry) => {
+	const { source: sourceId, sourceHandle, target: targetId, targetHandle } = connection;
+	if (!sourceHandle || !targetHandle || !sourceId || !targetId) return false;
+	const sourceNode = getNode(nodes, sourceId);
+	const targetNode = getNode(nodes, targetId);
+	if (!sourceNode || !targetNode) return false;
+	const sourceType = sourceNode.type;
+	const targetType = targetNode.type;
+	if (!sourceType || !targetType) return false;
+	const inputs = nodeMetaRegistry[targetId]?.inputs || [];
+	const source = (nodeMetaRegistry[sourceId]?.outputs || []).flatMap((out) => out.outputs || out).find((out) => out.id === sourceHandle);
+	const target = inputs.flatMap((inp) => inp.inputs || inp).find((inp) => inp.id === targetHandle);
+	const sourceProvides = source?.provides || "";
+	const targetAccepts = target?.accepts || [];
+	const sourceMaxConnections = source?.maxConnections;
+	const targetMaxConnections = target?.maxConnections;
+	let isValid = targetAccepts.length === 0 || targetAccepts.includes(sourceProvides);
+	if (isValid && targetMaxConnections != null) isValid = edges.filter((edg) => edg.target === targetId && edg.targetHandle === targetHandle).length < targetMaxConnections;
+	if (isValid && sourceMaxConnections != null) isValid = edges.filter((edg) => edg.source === sourceId && edg.sourceHandle === sourceHandle).length < sourceMaxConnections;
+	return isValid;
 };
-export {
-  HvDroppableFlow,
-  staticClasses as flowClasses,
-  getNode
+var HvDroppableFlow = ({ id, className, children, onFlowChange, onDndDrop, classes: classesProp, nodes: initialNodes = [], edges: initialEdges = [], onConnect: onConnectProp, onNodesChange: onNodesChangeProp, onEdgesChange: onEdgesChangeProp, defaultEdgeOptions: defaultEdgeOptionsProp, nodeTypes, ...others }) => {
+	const { classes, cx } = useClasses(classesProp);
+	const elementId = useUniqueId(id);
+	const reactFlowInstance = useFlowInstance();
+	const [nodes, setNodes] = useState(initialNodes);
+	const [edges, setEdges] = useState(initialEdges);
+	const nodesRef = useRef(initialNodes);
+	const edgesRef = useRef(initialEdges);
+	const updateNodes = (nds) => {
+		setNodes(nds);
+		nodesRef.current = nds;
+	};
+	const updateEdges = (eds) => {
+		setEdges(eds);
+		edgesRef.current = eds;
+	};
+	const { setNodeRef } = useDroppable({ id: elementId });
+	useDndMonitor({ onDragEnd: useCallback((event) => {
+		if (event.over?.id !== elementId) return;
+		const hvFlow = event.active.data.current?.hvFlow;
+		const type = hvFlow?.type;
+		if (!type || !nodeTypes?.[type]) return;
+		const position = reactFlowInstance.screenToFlowPosition({
+			x: hvFlow?.x || 0,
+			y: hvFlow?.y || 0
+		});
+		const data = {
+			nodeLabel: hvFlow?.label,
+			...hvFlow?.data
+		};
+		const newNode = {
+			id: uid(),
+			position,
+			data,
+			type
+		};
+		if (onDndDrop) {
+			onDndDrop(event, newNode);
+			return;
+		}
+		updateNodes(nodes.concat(newNode));
+	}, [
+		elementId,
+		nodeTypes,
+		nodes,
+		onDndDrop,
+		reactFlowInstance
+	]) });
+	const handleFlowChange = useCallback((nds, eds) => {
+		if (!nds.find((node) => node.dragging)) onFlowChange?.(nds, eds);
+	}, [onFlowChange]);
+	const handleConnect = useCallback((connection) => {
+		const eds = addEdge(connection, edgesRef.current);
+		updateEdges(eds);
+		handleFlowChange(nodesRef.current, eds);
+		onConnectProp?.(connection);
+	}, [handleFlowChange, onConnectProp]);
+	const handleNodesChange = useCallback((changes) => {
+		const nds = applyNodeChanges(changes, nodesRef.current);
+		updateNodes(nds);
+		handleFlowChange(nds, edgesRef.current);
+		onNodesChangeProp?.(changes);
+	}, [handleFlowChange, onNodesChangeProp]);
+	const handleEdgesChange = useCallback((changes) => {
+		const eds = applyEdgeChanges(changes, edgesRef.current);
+		updateEdges(eds);
+		handleFlowChange(nodesRef.current, eds);
+		onEdgesChangeProp?.(changes);
+	}, [handleFlowChange, onEdgesChangeProp]);
+	const { registry } = useNodeMetaRegistry();
+	const isValidConnection = (connection) => validateEdge(nodes, edges, connection, registry);
+	const defaultEdgeOptions = {
+		markerEnd: {
+			type: MarkerType.ArrowClosed,
+			height: 20,
+			width: 20
+		},
+		type: "smoothstep",
+		pathOptions: { borderRadius: 40 },
+		...defaultEdgeOptionsProp
+	};
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Global, { styles: flowStyles }), /* @__PURE__ */ jsx("div", {
+		id: elementId,
+		ref: setNodeRef,
+		className: cx(classes.root, className),
+		children: /* @__PURE__ */ jsx(ReactFlow, {
+			nodes,
+			edges,
+			nodeTypes,
+			onNodesChange: handleNodesChange,
+			onEdgesChange: handleEdgesChange,
+			onConnect: handleConnect,
+			isValidConnection,
+			defaultEdgeOptions,
+			snapGrid: [1, 1],
+			snapToGrid: true,
+			onError: (code, message) => {},
+			...others,
+			children
+		})
+	})] });
 };
+//#endregion
+export { HvDroppableFlow };

package/dist/Flow/Empty/Empty.js

@@ -1,12 +1,15 @@
+import { useClasses } from "./Empty.styles.js";
+import { HvEmptyState } from "@hitachivantara/uikit-react-core";
 import { jsx } from "react/jsx-runtime";
 import { useNodes } from "reactflow";
-import { HvEmptyState } from "@hitachivantara/uikit-react-core";
-import { useClasses } from "./Empty.styles.js";
-const HvFlowEmpty = ({ className, ...others }) => {
-  const { classes, cx } = useClasses();
-  const nodes = useNodes();
-  return !nodes || (nodes.length === 0 ? /* @__PURE__ */ jsx(HvEmptyState, { className: cx(classes.root, className), ...others }) : null);
-};
-export {
-  HvFlowEmpty
+//#region src/Flow/Empty/Empty.tsx
+var HvFlowEmpty = ({ className, ...others }) => {
+	const { classes, cx } = useClasses();
+	const nodes = useNodes();
+	return !nodes || (nodes.length === 0 ? /* @__PURE__ */ jsx(HvEmptyState, {
+		className: cx(classes.root, className),
+		...others
+	}) : null);
 };
+//#endregion
+export { HvFlowEmpty };

package/dist/Flow/Empty/Empty.styles.js

@@ -1,16 +1,13 @@
 import { createClasses, theme } from "@hitachivantara/uikit-react-core";
-const { staticClasses, useClasses } = createClasses("HvFlowEmpty", {
-  root: {
-    width: "100%",
-    height: "100%",
-    alignItems: "center",
-    justifyContent: "center",
-    backgroundColor: theme.colors.bgPage,
-    position: "absolute",
-    zIndex: theme.zIndices.popover
-  }
-});
-export {
-  staticClasses,
-  useClasses
-};
+//#region src/Flow/Empty/Empty.styles.tsx
+var { staticClasses, useClasses } = createClasses("HvFlowEmpty", { root: {
+	width: "100%",
+	height: "100%",
+	alignItems: "center",
+	justifyContent: "center",
+	backgroundColor: theme.colors.bgPage,
+	position: "absolute",
+	zIndex: theme.zIndices.popover
+} });
+//#endregion
+export { useClasses };

package/dist/Flow/Flow.js

@@ -1,33 +1,31 @@
+import { HvFlowProvider } from "./FlowContext/FlowContext.js";
+import { HvDroppableFlow } from "./DroppableFlow.js";
 import { jsx, jsxs } from "react/jsx-runtime";
-import { useSensors, useSensor, PointerSensor, KeyboardSensor, DndContext } from "@dnd-kit/core";
-import { restrictToWindowEdges } from "@dnd-kit/modifiers";
 import { ReactFlowProvider } from "reactflow";
-import { HvDroppableFlow } from "./DroppableFlow.js";
-import { HvFlowProvider } from "./FlowContext/FlowContext.js";
-const HvFlow = ({
-  nodeGroups,
-  sidebar,
-  defaultActions,
-  dndContextProps,
-  ...others
-}) => {
-  const sensors = useSensors(
-    useSensor(PointerSensor),
-    useSensor(KeyboardSensor)
-  );
-  return /* @__PURE__ */ jsx(ReactFlowProvider, { children: /* @__PURE__ */ jsx(HvFlowProvider, { nodeGroups, defaultActions, children: /* @__PURE__ */ jsxs(
-    DndContext,
-    {
-      sensors,
-      modifiers: [restrictToWindowEdges],
-      ...dndContextProps,
-      children: [
-        /* @__PURE__ */ jsx(HvDroppableFlow, { ...others }),
-        sidebar
-      ]
-    }
-  ) }) });
-};
-export {
-  HvFlow
+import { DndContext, KeyboardSensor, PointerSensor, useSensor, useSensors } from "@dnd-kit/core";
+import { restrictToWindowEdges } from "@dnd-kit/modifiers";
+//#region src/Flow/Flow.tsx
+/**
+* Flow component to build interactive node-based UIs.
+*
+* This implementation leverages [React Flow](https://reactflow.dev).
+* The drag and drop functionality leverages [Dnd Kit](https://docs.dndkit.com)
+*
+* Take a look at the [usage page](https://lumada-design.github.io/uikit/master/?path=/docs/lab-flow-usage--docs) to learn more about this component.
+*
+* DISCLAIMER: This component is a work in progress and there might be breaking changes.
+*/
+var HvFlow = ({ nodeGroups, sidebar, defaultActions, dndContextProps, ...others }) => {
+	return /* @__PURE__ */ jsx(ReactFlowProvider, { children: /* @__PURE__ */ jsx(HvFlowProvider, {
+		nodeGroups,
+		defaultActions,
+		children: /* @__PURE__ */ jsxs(DndContext, {
+			sensors: useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor)),
+			modifiers: [restrictToWindowEdges],
+			...dndContextProps,
+			children: [/* @__PURE__ */ jsx(HvDroppableFlow, { ...others }), sidebar]
+		})
+	}) });
 };
+//#endregion
+export { HvFlow };

package/dist/Flow/Flow.styles.js

@@ -1,19 +1,13 @@
-import { createClasses, theme } from "@hitachivantara/uikit-react-core";
 import { staticClasses as staticClasses$1 } from "./Node/BaseNode.styles.js";
-import "react/jsx-runtime";
-import "reactflow";
-import "@hitachivantara/uikit-react-utils";
-const { staticClasses, useClasses } = createClasses("HvFlow", {
-  root: {
-    height: "100%",
-    [`& .selected > .${staticClasses$1.root}`]: {
-      border: `1px solid ${theme.colors.textDisabled}`,
-      borderRadius: theme.radii.round,
-      boxSizing: "border-box"
-    }
-  }
-});
-export {
-  staticClasses,
-  useClasses
-};
+import { createClasses, theme } from "@hitachivantara/uikit-react-core";
+//#region src/Flow/Flow.styles.tsx
+var { staticClasses, useClasses } = createClasses("HvFlow", { root: {
+	height: "100%",
+	[`& .selected > .${staticClasses$1.root}`]: {
+		border: `1px solid ${theme.colors.textDisabled}`,
+		borderRadius: theme.radii.round,
+		boxSizing: "border-box"
+	}
+} });
+//#endregion
+export { staticClasses, useClasses };

package/dist/Flow/FlowContext/FlowContext.js

@@ -1,25 +1,24 @@
-import { jsx } from "react/jsx-runtime";
-import { useState, useMemo, createContext } from "react";
 import { HvFlowNodeMetaProvider } from "./NodeMetaContext.js";
-const HvFlowContext = createContext({});
-const HvFlowProvider = ({
-  nodeGroups,
-  defaultActions,
-  children
-}) => {
-  const [expandedNodeGroups, setExpandedNodeGroups] = useState([]);
-  const value = useMemo(
-    () => ({
-      nodeGroups,
-      defaultActions,
-      expandedNodeGroups,
-      setExpandedNodeGroups
-    }),
-    [nodeGroups, defaultActions, expandedNodeGroups]
-  );
-  return /* @__PURE__ */ jsx(HvFlowNodeMetaProvider, { children: /* @__PURE__ */ jsx(HvFlowContext.Provider, { value, children }) });
-};
-export {
-  HvFlowContext,
-  HvFlowProvider
+import { createContext, useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/Flow/FlowContext/FlowContext.tsx
+var HvFlowContext = createContext({});
+var HvFlowProvider = ({ nodeGroups, defaultActions, children }) => {
+	const [expandedNodeGroups, setExpandedNodeGroups] = useState([]);
+	const value = useMemo(() => ({
+		nodeGroups,
+		defaultActions,
+		expandedNodeGroups,
+		setExpandedNodeGroups
+	}), [
+		nodeGroups,
+		defaultActions,
+		expandedNodeGroups
+	]);
+	return /* @__PURE__ */ jsx(HvFlowNodeMetaProvider, { children: /* @__PURE__ */ jsx(HvFlowContext.Provider, {
+		value,
+		children
+	}) });
 };
+//#endregion
+export { HvFlowContext, HvFlowProvider };

package/dist/Flow/FlowContext/NodeMetaContext.js

@@ -1,43 +1,40 @@
+import { createContext, useCallback, useContext, useMemo, useRef } from "react";
 import { jsx } from "react/jsx-runtime";
-import { useContext, createContext, useRef, useCallback, useMemo } from "react";
-const HvFlowNodeMetaContext = createContext(void 0);
-const HvFlowNodeMetaProvider = ({
-  children
-}) => {
-  const registryRef = useRef({});
-  const registerNode = useCallback((id, nodeInfo) => {
-    registryRef.current[id] = nodeInfo;
-  }, []);
-  const unregisterNode = useCallback((id) => {
-    delete registryRef.current[id];
-  }, []);
-  const getRegistry = useCallback(() => {
-    return registryRef.current;
-  }, []);
-  const value = useMemo(
-    () => ({
-      registerNode,
-      unregisterNode,
-      getRegistry
-    }),
-    [registerNode, unregisterNode, getRegistry]
-  );
-  return /* @__PURE__ */ jsx(HvFlowNodeMetaContext.Provider, { value, children });
+//#region src/Flow/FlowContext/NodeMetaContext.tsx
+var HvFlowNodeMetaContext = createContext(void 0);
+var HvFlowNodeMetaProvider = ({ children }) => {
+	const registryRef = useRef({});
+	const registerNode = useCallback((id, nodeInfo) => {
+		registryRef.current[id] = nodeInfo;
+	}, []);
+	const unregisterNode = useCallback((id) => {
+		delete registryRef.current[id];
+	}, []);
+	const getRegistry = useCallback(() => {
+		return registryRef.current;
+	}, []);
+	const value = useMemo(() => ({
+		registerNode,
+		unregisterNode,
+		getRegistry
+	}), [
+		registerNode,
+		unregisterNode,
+		getRegistry
+	]);
+	return /* @__PURE__ */ jsx(HvFlowNodeMetaContext.Provider, {
+		value,
+		children
+	});
 };
 function useNodeMetaRegistry() {
-  const context = useContext(HvFlowNodeMetaContext);
-  if (context === void 0) {
-    throw new Error(
-      "useNodeRegistry must be used within a HvFlowNodeMetaProvider"
-    );
-  }
-  return {
-    registerNode: context.registerNode,
-    unregisterNode: context.unregisterNode,
-    registry: context.getRegistry()
-  };
+	const context = useContext(HvFlowNodeMetaContext);
+	if (context === void 0) throw new Error("useNodeRegistry must be used within a HvFlowNodeMetaProvider");
+	return {
+		registerNode: context.registerNode,
+		unregisterNode: context.unregisterNode,
+		registry: context.getRegistry()
+	};
 }
-export {
-  HvFlowNodeMetaProvider,
-  useNodeMetaRegistry
-};
+//#endregion
+export { HvFlowNodeMetaProvider, useNodeMetaRegistry };

package/dist/Flow/Minimap/Minimap.js

@@ -1,31 +1,18 @@
+import { useClasses } from "./Minimap.styles.js";
+import { getColor } from "@hitachivantara/uikit-styles";
 import { jsx } from "react/jsx-runtime";
 import { MiniMap } from "reactflow";
-import { getColor } from "@hitachivantara/uikit-styles";
-import { useClasses } from "./Minimap.styles.js";
-import { staticClasses } from "./Minimap.styles.js";
-const HvFlowMinimap = ({
-  nodeColor = "border",
-  maskColor = "borderSubtle",
-  maskStrokeColor = "borderSubtle",
-  nodeStrokeColor = "border",
-  classes: classesProp,
-  className,
-  ...others
-}) => {
-  const { classes, cx } = useClasses(classesProp);
-  return /* @__PURE__ */ jsx(
-    MiniMap,
-    {
-      className: cx(classes.root, className),
-      nodeColor: typeof nodeColor === "string" ? getColor(nodeColor, "border") : nodeColor,
-      nodeStrokeColor: typeof nodeStrokeColor === "string" ? getColor(nodeStrokeColor, "border") : nodeStrokeColor,
-      maskColor: getColor(maskColor, "borderSubtle"),
-      maskStrokeColor: getColor(maskStrokeColor, "borderSubtle"),
-      ...others
-    }
-  );
-};
-export {
-  HvFlowMinimap,
-  staticClasses as flowMinimapClasses
+//#region src/Flow/Minimap/Minimap.tsx
+var HvFlowMinimap = ({ nodeColor = "border", maskColor = "borderSubtle", maskStrokeColor = "borderSubtle", nodeStrokeColor = "border", classes: classesProp, className, ...others }) => {
+	const { classes, cx } = useClasses(classesProp);
+	return /* @__PURE__ */ jsx(MiniMap, {
+		className: cx(classes.root, className),
+		nodeColor: typeof nodeColor === "string" ? getColor(nodeColor, "border") : nodeColor,
+		nodeStrokeColor: typeof nodeStrokeColor === "string" ? getColor(nodeStrokeColor, "border") : nodeStrokeColor,
+		maskColor: getColor(maskColor, "borderSubtle"),
+		maskStrokeColor: getColor(maskStrokeColor, "borderSubtle"),
+		...others
+	});
 };
+//#endregion
+export { HvFlowMinimap };