@01.software/sdk 0.4.2 → 0.4.3-dev.1774320860782

package/dist/ui/flow.js

@@ -40,7 +40,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/ui/Flow/index.tsx
-import React from "react";
+import React2 from "react";
 import {
   ReactFlow,
   ReactFlowProvider,
@@ -116,7 +116,7 @@ function collectionKeys(collection) {
 
 // src/ui/Flow/useFlow.ts
 function toNodeTypeDef(doc) {
-  var _a, _b, _c, _d;
+  var _a, _b, _c, _d, _e, _f;
   return {
     slug: String((_a = doc.slug) != null ? _a : ""),
     name: String((_b = doc.title) != null ? _b : ""),
@@ -126,7 +126,9 @@ function toNodeTypeDef(doc) {
       height: 200
     },
     fields: Array.isArray(doc.fields) ? doc.fields : [],
-    transparentBackground: Boolean(doc.transparentBackground)
+    transparentBackground: Boolean(doc.transparentBackground),
+    template: (_e = doc.template) != null ? _e : null,
+    customCSS: (_f = doc.customCSS) != null ? _f : null
   };
 }
 function toEdgeTypeDef(doc) {
@@ -244,37 +246,57 @@ function useFlowData(options) {
 }
 
 // src/ui/Flow/utils.ts
-function getNodeBounds(nodes, nodeIds) {
+function getNodeSize(node) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  return {
+    width: (_e = (_d = (_c = (_a = node.style) == null ? void 0 : _a.width) != null ? _c : (_b = node.measured) == null ? void 0 : _b.width) != null ? _d : node.width) != null ? _e : 200,
+    height: (_j = (_i = (_h = (_f = node.style) == null ? void 0 : _f.height) != null ? _h : (_g = node.measured) == null ? void 0 : _g.height) != null ? _i : node.height) != null ? _j : 200
+  };
+}
+function getAbsolutePosition(node, nodeMap) {
+  let x = node.position.x;
+  let y = node.position.y;
+  let current = node;
+  const visited = /* @__PURE__ */ new Set([node.id]);
+  while (current.parentId) {
+    const parentId = current.parentId;
+    if (visited.has(parentId)) break;
+    const parent = nodeMap.get(parentId);
+    if (!parent) break;
+    visited.add(parent.id);
+    x += parent.position.x;
+    y += parent.position.y;
+    current = parent;
+  }
+  return { x, y };
+}
+function collectDescendants(nodes, rootId) {
+  const result = /* @__PURE__ */ new Set([rootId]);
+  const queue = [rootId];
+  let i = 0;
+  while (i < queue.length) {
+    const current = queue[i++];
+    for (const n of nodes) {
+      if (n.parentId === current && !result.has(n.id)) {
+        result.add(n.id);
+        queue.push(n.id);
+      }
+    }
+  }
+  return result;
+}
+function getNodeBounds(nodes, nodeIds) {
   const idSet = new Set(nodeIds);
   const targetNodes = nodes.filter((n) => idSet.has(n.id));
   if (targetNodes.length === 0) return void 0;
   const nodeMap = new Map(nodes.map((n) => [n.id, n]));
-  function getAbsolutePosition(node) {
-    let x = node.position.x;
-    let y = node.position.y;
-    let current = node;
-    const visited = /* @__PURE__ */ new Set([node.id]);
-    while (current.parentId) {
-      const parentId = current.parentId;
-      if (visited.has(parentId)) break;
-      const parent = nodeMap.get(parentId);
-      if (!parent) break;
-      visited.add(parent.id);
-      x += parent.position.x;
-      y += parent.position.y;
-      current = parent;
-    }
-    return { x, y };
-  }
   let minX = Infinity;
   let minY = Infinity;
   let maxX = -Infinity;
   let maxY = -Infinity;
   for (const node of targetNodes) {
-    const abs = getAbsolutePosition(node);
-    const w = (_e = (_d = (_c = (_a = node.style) == null ? void 0 : _a.width) != null ? _c : (_b = node.measured) == null ? void 0 : _b.width) != null ? _d : node.width) != null ? _e : 200;
-    const h = (_j = (_i = (_h = (_f = node.style) == null ? void 0 : _f.height) != null ? _h : (_g = node.measured) == null ? void 0 : _g.height) != null ? _i : node.height) != null ? _j : 200;
+    const abs = getAbsolutePosition(node, nodeMap);
+    const { width: w, height: h } = getNodeSize(node);
     minX = Math.min(minX, abs.x);
     minY = Math.min(minY, abs.y);
     maxX = Math.max(maxX, abs.x + w);
@@ -286,32 +308,140 @@ function getFrames(nodes) {
   const frames = nodes.filter((n) => n.type === "frame");
   if (frames.length === 0) return [];
   const nodeMap = new Map(nodes.map((n) => [n.id, n]));
-  function getAbsolutePosition(node) {
-    let x = node.position.x;
-    let y = node.position.y;
-    let current = node;
-    const visited = /* @__PURE__ */ new Set([node.id]);
-    while (current.parentId) {
-      const parentId = current.parentId;
-      if (visited.has(parentId)) break;
-      const parent = nodeMap.get(parentId);
-      if (!parent) break;
-      visited.add(parent.id);
-      x += parent.position.x;
-      y += parent.position.y;
-      current = parent;
-    }
-    return { x, y };
-  }
   return frames.map((f) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+    var _a;
     const data = f.data;
-    const abs = getAbsolutePosition(f);
-    const w = (_e = (_d = (_c = (_a = f.style) == null ? void 0 : _a.width) != null ? _c : (_b = f.measured) == null ? void 0 : _b.width) != null ? _d : f.width) != null ? _e : 200;
-    const h = (_j = (_i = (_h = (_f = f.style) == null ? void 0 : _f.height) != null ? _h : (_g = f.measured) == null ? void 0 : _g.height) != null ? _i : f.height) != null ? _j : 200;
-    return { id: f.id, label: (_k = data.label) != null ? _k : "", bounds: { x: abs.x, y: abs.y, width: w, height: h } };
+    const abs = getAbsolutePosition(f, nodeMap);
+    const { width: w, height: h } = getNodeSize(f);
+    return {
+      id: f.id,
+      label: (_a = data.label) != null ? _a : "",
+      bounds: { x: abs.x, y: abs.y, width: w, height: h }
+    };
   }).sort((a, b) => a.bounds.y - b.bounds.y || a.bounds.x - b.bounds.x);
 }
+function getFrameData(data, frameId) {
+  const frame = data.nodes.find((n) => n.id === frameId);
+  if (!frame || frame.type !== "frame") return void 0;
+  const descendantIds = collectDescendants(data.nodes, frameId);
+  const childNodes = data.nodes.filter((n) => descendantIds.has(n.id)).map((n) => __spreadProps(__spreadValues({}, n), { draggable: false }));
+  const childEdges = data.edges.filter(
+    (e) => descendantIds.has(e.source) && descendantIds.has(e.target)
+  );
+  const frameBounds = getNodeBounds(data.nodes, [frameId]);
+  const { width: w, height: h } = getNodeSize(frame);
+  const clampBounds = frameBounds != null ? frameBounds : {
+    x: frame.position.x,
+    y: frame.position.y,
+    width: w,
+    height: h
+  };
+  const contentNodeIds = childNodes.filter((n) => n.id !== frameId).map((n) => n.id);
+  const contentBounds = contentNodeIds.length > 0 ? getNodeBounds(data.nodes, contentNodeIds) : void 0;
+  const fitBounds = contentBounds != null ? contentBounds : clampBounds;
+  return {
+    data: {
+      nodes: childNodes,
+      edges: childEdges,
+      viewport: data.viewport
+    },
+    fitBounds,
+    clampBounds,
+    bounds: clampBounds
+  };
+}
+
+// src/ui/Flow/template-compiler.ts
+import React from "react";
+import { transform } from "sucrase";
+var MAX_CACHE_SIZE = 100;
+var componentCache = /* @__PURE__ */ new Map();
+function hashCode(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char | 0;
+  }
+  return hash.toString(36);
+}
+var BLOCKED_PATTERNS = [
+  /\bdocument\s*\./,
+  /\bwindow\s*\./,
+  /\bwindow\s*\[/,
+  /\bglobalThis\s*\./,
+  /\bfetch\s*\(/,
+  /\bXMLHttpRequest/,
+  /\beval\s*\(/,
+  /\bFunction\s*\(/,
+  /\bimport\s*\(/,
+  /\blocalStorage/,
+  /\bsessionStorage/,
+  /\bcookie/,
+  /\bpostMessage\s*\(/,
+  /\blocation\s*[.=]/,
+  /\bnavigator\s*\./,
+  /\bsetTimeout\s*\(/,
+  /\bsetInterval\s*\(/,
+  /\bsetImmediate\s*\(/,
+  /\brequire\s*\(/
+];
+function validateTemplateCode(code) {
+  return !BLOCKED_PATTERNS.some((pattern) => pattern.test(code));
+}
+function compileTemplate(code, slug) {
+  const cacheKey = `${slug}:${hashCode(code)}`;
+  if (componentCache.has(cacheKey)) {
+    const cached = componentCache.get(cacheKey);
+    componentCache.delete(cacheKey);
+    componentCache.set(cacheKey, cached);
+    return cached;
+  }
+  if (!validateTemplateCode(code)) {
+    console.warn(`[flow] Template "${slug}" contains blocked patterns`);
+    return null;
+  }
+  try {
+    const { code: jsCode } = transform(code, {
+      transforms: ["typescript", "jsx", "imports"],
+      jsxRuntime: "classic",
+      jsxPragma: "React.createElement",
+      jsxFragmentPragma: "React.Fragment"
+    });
+    const factory = new Function(
+      "React",
+      `
+      var window = undefined;
+      var document = undefined;
+      var globalThis = undefined;
+      var setTimeout = undefined;
+      var setInterval = undefined;
+      var setImmediate = undefined;
+      var fetch = undefined;
+      var XMLHttpRequest = undefined;
+      var navigator = undefined;
+      var location = undefined;
+      var exports = {};
+      var module = { exports: exports };
+      ${jsCode}
+      return module.exports.default || module.exports;
+    `
+    );
+    const Component = factory(React);
+    if (typeof Component !== "function") return null;
+    if (componentCache.size >= MAX_CACHE_SIZE) {
+      const oldestKey = componentCache.keys().next().value;
+      if (oldestKey) componentCache.delete(oldestKey);
+    }
+    componentCache.set(cacheKey, Component);
+    return Component;
+  } catch (e) {
+    console.warn(`[flow] Failed to compile template for "${slug}":`, e);
+    return null;
+  }
+}
+function clearTemplateCache() {
+  componentCache.clear();
+}
 
 // src/ui/Flow/index.tsx
 function sanitizeUrl(url) {
@@ -336,7 +466,7 @@ function renderFieldValue(key, val, fieldDef) {
     const imgUrl = typeof val === "string" ? val : val == null ? void 0 : val.url;
     const safeUrl = sanitizeUrl(imgUrl);
     if (!safeUrl) return null;
-    return /* @__PURE__ */ React.createElement(
+    return /* @__PURE__ */ React2.createElement(
       "img",
       {
         key,
@@ -347,7 +477,7 @@ function renderFieldValue(key, val, fieldDef) {
       }
     );
   }
-  return /* @__PURE__ */ React.createElement(
+  return /* @__PURE__ */ React2.createElement(
     "div",
     {
       key,
@@ -364,7 +494,7 @@ function renderFieldValue(key, val, fieldDef) {
 }
 function DefaultDynamicNode({ data }) {
   const d = data;
-  return /* @__PURE__ */ React.createElement(
+  return /* @__PURE__ */ React2.createElement(
     "div",
     {
       style: {
@@ -377,11 +507,59 @@ function DefaultDynamicNode({ data }) {
     d.fields && Object.entries(d.fields).filter(([, v]) => v != null && v !== "").map(([key, val]) => renderFieldValue(key, val))
   );
 }
+var TemplateErrorBoundary = class extends React2.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidUpdate(prevProps) {
+    if (prevProps.resetKey !== this.props.resetKey && this.state.error) {
+      this.setState({ error: null });
+    }
+  }
+  render() {
+    if (this.state.error) {
+      return /* @__PURE__ */ React2.createElement("div", { style: { padding: 8, fontSize: 11, color: "#ef4444" } }, /* @__PURE__ */ React2.createElement("strong", null, "Render error"), /* @__PURE__ */ React2.createElement("pre", { style: { fontSize: 10, whiteSpace: "pre-wrap" } }, this.state.error.message));
+    }
+    return this.props.children;
+  }
+};
 function EnhancedDynamicNode({
   data,
-  typeDef
+  typeDef,
+  width,
+  height
 }) {
-  return /* @__PURE__ */ React.createElement(
+  if (typeDef.template) {
+    const Component = compileTemplate(typeDef.template, typeDef.slug);
+    if (Component) {
+      return /* @__PURE__ */ React2.createElement(
+        "div",
+        {
+          className: `flow-node flow-node--${typeDef.slug}${typeDef.transparentBackground ? " flow-node--transparent-bg" : ""}`,
+          style: {
+            width: "100%",
+            height: "100%"
+          }
+        },
+        /* @__PURE__ */ React2.createElement(TemplateErrorBoundary, { resetKey: typeDef.template }, /* @__PURE__ */ React2.createElement(
+          Component,
+          {
+            fields: data.fields,
+            label: data.label,
+            color: typeDef.color,
+            nodeTypeSlug: typeDef.slug,
+            width: width != null ? width : typeDef.defaultSize.width,
+            height: height != null ? height : typeDef.defaultSize.height
+          }
+        ))
+      );
+    }
+  }
+  return /* @__PURE__ */ React2.createElement(
     "div",
     {
       style: {
@@ -410,7 +588,7 @@ function DefaultFrameNode({ data }) {
     if (m) return `rgba(${m[1]},${m[2]},${m[3]},${opacity})`;
     return baseColor;
   })();
-  return /* @__PURE__ */ React.createElement(
+  return /* @__PURE__ */ React2.createElement(
     "div",
     {
       style: {
@@ -421,7 +599,7 @@ function DefaultFrameNode({ data }) {
         border: borderStyle === "none" ? "none" : `2px ${borderStyle} rgba(128,128,128,0.3)`
       }
     },
-    /* @__PURE__ */ React.createElement(
+    /* @__PURE__ */ React2.createElement(
       "div",
       {
         style: {
@@ -443,7 +621,7 @@ function createNodeTypes(nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrap
     const CustomRenderer = nodeRenderers == null ? void 0 : nodeRenderers[d.nodeTypeSlug];
     let content;
     if (CustomRenderer) {
-      content = /* @__PURE__ */ React.createElement(
+      content = /* @__PURE__ */ React2.createElement(
         CustomRenderer,
         {
           id: props.id,
@@ -454,9 +632,17 @@ function createNodeTypes(nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrap
         }
       );
     } else if (typeDef) {
-      content = /* @__PURE__ */ React.createElement(EnhancedDynamicNode, { data: d, typeDef });
+      content = /* @__PURE__ */ React2.createElement(
+        EnhancedDynamicNode,
+        {
+          data: d,
+          typeDef,
+          width: props.width,
+          height: props.height
+        }
+      );
     } else {
-      content = /* @__PURE__ */ React.createElement(DefaultDynamicNode, __spreadValues({}, props));
+      content = /* @__PURE__ */ React2.createElement(DefaultDynamicNode, __spreadValues({}, props));
     }
     if (renderNode) {
       const slotProps = {
@@ -471,7 +657,7 @@ function createNodeTypes(nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrap
     }
     if (nodeWrapper) {
       const Wrapper = nodeWrapper;
-      content = /* @__PURE__ */ React.createElement(
+      content = /* @__PURE__ */ React2.createElement(
         Wrapper,
         {
           id: props.id,
@@ -488,7 +674,7 @@ function createNodeTypes(nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrap
   types.frame = frameRenderer ? ((props) => {
     const d = props.data;
     const Renderer = frameRenderer;
-    return /* @__PURE__ */ React.createElement(
+    return /* @__PURE__ */ React2.createElement(
       Renderer,
       {
         id: props.id,
@@ -503,13 +689,14 @@ function createNodeTypes(nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrap
   return types;
 }
 function createEdgeTypes(edgeRenderers, edgeTypeDefsMap) {
-  if (!edgeRenderers || Object.keys(edgeRenderers).length === 0) return void 0;
+  if (!edgeRenderers || Object.keys(edgeRenderers).length === 0)
+    return void 0;
   const types = {};
   for (const [slug, Renderer] of Object.entries(edgeRenderers)) {
     types[slug] = ((props) => {
       var _a;
       const def = edgeTypeDefsMap == null ? void 0 : edgeTypeDefsMap.get(slug);
-      return /* @__PURE__ */ React.createElement(
+      return /* @__PURE__ */ React2.createElement(
         Renderer,
         {
           id: props.id,
@@ -526,20 +713,99 @@ function createEdgeTypes(edgeRenderers, edgeTypeDefsMap) {
   }
   return types;
 }
+function clampViewport(vp, cw, ch, extent) {
+  const left = -vp.x / vp.zoom;
+  const right = (cw - vp.x) / vp.zoom;
+  const top = -vp.y / vp.zoom;
+  const bottom = (ch - vp.y) / vp.zoom;
+  const dx0 = left - extent[0][0];
+  const dx1 = right - extent[1][0];
+  const dy0 = top - extent[0][1];
+  const dy1 = bottom - extent[1][1];
+  const cx = dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1);
+  const cy = dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1);
+  if (cx === 0 && cy === 0) return vp;
+  return { x: vp.x + cx * vp.zoom, y: vp.y + cy * vp.zoom, zoom: vp.zoom };
+}
 function FocusHandler({
   bounds,
   padding,
-  animation
+  animation,
+  mode,
+  responsive,
+  extent
 }) {
-  const { fitBounds } = useReactFlow();
+  const { setViewport } = useReactFlow();
+  const containerRef = React2.useRef(null);
   const boundsKey = `${bounds.x},${bounds.y},${bounds.width},${bounds.height}`;
-  const boundsRef = React.useRef(bounds);
+  const boundsRef = React2.useRef(bounds);
   boundsRef.current = bounds;
-  React.useEffect(() => {
-    const duration = animation === true ? 300 : typeof animation === "number" ? animation : 0;
-    fitBounds(boundsRef.current, { padding, duration });
-  }, [boundsKey, padding, animation, fitBounds]);
-  return null;
+  const [containerSize, setContainerSize] = React2.useState({ w: 0, h: 0 });
+  const prevBoundsKeyRef = React2.useRef(null);
+  const prevSizeRef = React2.useRef({ w: 0, h: 0 });
+  React2.useEffect(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      const { width, height } = entry.contentRect;
+      setContainerSize({ w: width, h: height });
+    });
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, []);
+  React2.useEffect(() => {
+    if (containerSize.w === 0 || containerSize.h === 0) return;
+    const prevKey = prevBoundsKeyRef.current;
+    const prevSize = prevSizeRef.current;
+    prevBoundsKeyRef.current = boundsKey;
+    prevSizeRef.current = { w: containerSize.w, h: containerSize.h };
+    const isBoundsChange = prevKey !== boundsKey;
+    const isResizeOnly = !isBoundsChange && (prevSize.w !== containerSize.w || prevSize.h !== containerSize.h);
+    const isInitial = prevKey === null;
+    if (isResizeOnly && !responsive) return;
+    const duration = isInitial || isBoundsChange ? animation === true ? 300 : typeof animation === "number" ? animation : 0 : 0;
+    const b = boundsRef.current;
+    const padX = padding * b.width;
+    const padY = padding * b.height;
+    const bw = b.width + padX * 2;
+    const bh = b.height + padY * 2;
+    if (bw === 0 || bh === 0) return;
+    const zoomFn = mode === "cover" ? Math.max : Math.min;
+    const zoom = zoomFn(containerSize.w / bw, containerSize.h / bh);
+    const cx = b.x + b.width / 2;
+    const cy = b.y + b.height / 2;
+    const x = containerSize.w / 2 - cx * zoom;
+    const y = containerSize.h / 2 - cy * zoom;
+    let vp = { x, y, zoom };
+    if (extent) {
+      vp = clampViewport(vp, containerSize.w, containerSize.h, extent);
+    }
+    setViewport(vp, { duration });
+  }, [
+    boundsKey,
+    padding,
+    animation,
+    mode,
+    responsive,
+    containerSize.w,
+    containerSize.h,
+    extent,
+    setViewport
+  ]);
+  return /* @__PURE__ */ React2.createElement(
+    "div",
+    {
+      ref: containerRef,
+      style: {
+        position: "absolute",
+        inset: 0,
+        pointerEvents: "none",
+        visibility: "hidden"
+      }
+    }
+  );
 }
 var EDGE_TYPE_MAP = {
   step: "step",
@@ -591,6 +857,10 @@ function FlowRenderer({
   interactive = false,
   fitView = true,
   onNodeClick,
+  onNodeDoubleClick,
+  onNodeContextMenu,
+  onNodeMouseEnter,
+  onNodeMouseLeave,
   onEdgeClick,
   frameRenderer,
   edgeRenderers,
@@ -603,27 +873,41 @@ function FlowRenderer({
   onViewportChange,
   defaultViewport: defaultViewportProp,
   bounds,
+  clampBounds,
   focusPadding,
-  focusAnimation
+  focusAnimation,
+  focusMode = "contain",
+  responsiveFit,
+  translateExtent: translateExtentProp
 }) {
   var _a;
-  const nodeTypeDefsMap = React.useMemo(() => {
+  const nodeTypeDefsMap = React2.useMemo(() => {
     if (!(nodeTypeDefs == null ? void 0 : nodeTypeDefs.length)) return void 0;
     return new Map(nodeTypeDefs.map((d) => [d.slug, d]));
   }, [nodeTypeDefs]);
-  const edgeTypeDefsMap = React.useMemo(() => {
+  const edgeTypeDefsMap = React2.useMemo(() => {
     if (!(edgeTypeDefs == null ? void 0 : edgeTypeDefs.length)) return void 0;
     return new Map(edgeTypeDefs.map((d) => [d.slug, d]));
   }, [edgeTypeDefs]);
-  const nodeTypes = React.useMemo(
-    () => createNodeTypes(nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrapper, renderNode),
+  const nodeTypes = React2.useMemo(
+    () => createNodeTypes(
+      nodeRenderers,
+      nodeTypeDefsMap,
+      frameRenderer,
+      nodeWrapper,
+      renderNode
+    ),
     [nodeRenderers, nodeTypeDefsMap, frameRenderer, nodeWrapper, renderNode]
   );
-  const customEdgeTypes = React.useMemo(
+  const customEdgeTypes = React2.useMemo(
     () => createEdgeTypes(edgeRenderers, edgeTypeDefsMap),
     [edgeRenderers, edgeTypeDefsMap]
   );
-  const styledEdges = React.useMemo(() => {
+  const mergedCSS = React2.useMemo(() => {
+    if (!(nodeTypeDefs == null ? void 0 : nodeTypeDefs.length)) return "";
+    return nodeTypeDefs.filter((d) => d.customCSS).map((d) => d.customCSS).join("\n");
+  }, [nodeTypeDefs]);
+  const styledEdges = React2.useMemo(() => {
     var _a2;
     let edges = applyEdgeStyles((_a2 = data == null ? void 0 : data.edges) != null ? _a2 : [], edgeTypeDefsMap);
     if (edgeRenderers) {
@@ -637,15 +921,29 @@ function FlowRenderer({
     }
     return edges;
   }, [data == null ? void 0 : data.edges, edgeTypeDefsMap, edgeRenderers]);
+  const translateExtent = React2.useMemo(() => {
+    if (translateExtentProp) return translateExtentProp;
+    const es = clampBounds != null ? clampBounds : bounds;
+    if (!es) return void 0;
+    const ep = clampBounds ? 0 : focusPadding != null ? focusPadding : 0.1;
+    return [
+      [es.x - ep * es.width, es.y - ep * es.height],
+      [es.x + es.width * (1 + ep), es.y + es.height * (1 + ep)]
+    ];
+  }, [translateExtentProp, clampBounds, bounds, focusPadding]);
   if (!data) return null;
   const resolvedDefaultViewport = defaultViewportProp != null ? defaultViewportProp : !fitView && data.viewport ? data.viewport : void 0;
-  return /* @__PURE__ */ React.createElement(ReactFlowProvider, null, /* @__PURE__ */ React.createElement(
+  return /* @__PURE__ */ React2.createElement(ReactFlowProvider, null, /* @__PURE__ */ React2.createElement(
     "div",
     {
       className,
-      style: __spreadValues({ width: "100%", height: "100%" }, style)
+      style: __spreadValues({
+        width: "100%",
+        height: "100%",
+        background: "transparent"
+      }, style)
     },
-    /* @__PURE__ */ React.createElement(
+    /* @__PURE__ */ React2.createElement(
       ReactFlow,
       {
         nodes: (_a = data.nodes) != null ? _a : [],
@@ -653,34 +951,44 @@ function FlowRenderer({
         nodeTypes,
         edgeTypes: customEdgeTypes,
         defaultViewport: resolvedDefaultViewport,
-        fitView,
+        fitView: bounds ? false : fitView,
+        translateExtent,
         onNodeClick,
+        onNodeDoubleClick,
+        onNodeContextMenu,
+        onNodeMouseEnter,
+        onNodeMouseLeave,
         onEdgeClick,
         onMoveEnd: onViewportChange ? ((_, vp) => {
           onViewportChange(vp);
         }) : void 0,
-        nodesDraggable: interactive ? void 0 : false,
+        nodesDraggable: interactive,
         nodesConnectable: false,
-        elementsSelectable: interactive || !!onNodeClick || !!onEdgeClick,
+        elementsSelectable: interactive || !!onNodeClick || !!onNodeDoubleClick || !!onEdgeClick,
         panOnDrag: interactive,
         zoomOnScroll: interactive,
         zoomOnPinch: interactive,
-        zoomOnDoubleClick: false
+        zoomOnDoubleClick: false,
+        proOptions: { hideAttribution: true }
       },
-      background && /* @__PURE__ */ React.createElement(Background, null),
-      controls && /* @__PURE__ */ React.createElement(Controls, null),
-      minimap && /* @__PURE__ */ React.createElement(
+      mergedCSS && /* @__PURE__ */ React2.createElement("style", { dangerouslySetInnerHTML: { __html: mergedCSS } }),
+      background && /* @__PURE__ */ React2.createElement(Background, null),
+      controls && /* @__PURE__ */ React2.createElement(Controls, null),
+      minimap && /* @__PURE__ */ React2.createElement(
         MiniMap,
         {
           nodeColor: minimapNodeColor
         }
       ),
-      bounds && /* @__PURE__ */ React.createElement(
+      bounds && /* @__PURE__ */ React2.createElement(
         FocusHandler,
         {
           bounds,
           padding: focusPadding != null ? focusPadding : 0.1,
-          animation: focusAnimation != null ? focusAnimation : true
+          animation: focusAnimation != null ? focusAnimation : true,
+          mode: focusMode,
+          responsive: responsiveFit != null ? responsiveFit : true,
+          extent: translateExtent
         }
       ),
       children
@@ -691,6 +999,9 @@ export {
   BUILT_IN_EDGE_TYPES,
   BUILT_IN_NODE_TYPES,
   FlowRenderer,
+  clearTemplateCache,
+  compileTemplate,
+  getFrameData,
   getFrames,
   getNodeBounds,
   isDynamicNode,