bizydraft 0.2.49__py3-none-any.whl → 0.2.87__py3-none-any.whl

bizydraft/static/js/nodeFocusHandler.js

@@ -7,147 +7,159 @@ let keyboardListener = null;
 let contextMenuListener = null;
 
 // 设置全局变量引用
-export function setGlobalReferences(overlay, eventBlocked, kListener, cListener) {
-    freezeOverlay = overlay;
-    globalEventBlocked = eventBlocked;
-    keyboardListener = kListener;
-    contextMenuListener = cListener;
+export function setGlobalReferences(
+  overlay,
+  eventBlocked,
+  kListener,
+  cListener
+) {
+  freezeOverlay = overlay;
+  globalEventBlocked = eventBlocked;
+  keyboardListener = kListener;
+  contextMenuListener = cListener;
 }
 
 // 只聚焦节点，不高亮
 export function focusNodeOnly(nodeId) {
-    console.log('[nodeFocusHandler] focusNodeOnly called with nodeId:', nodeId);
+  console.log("[nodeFocusHandler] focusNodeOnly called with nodeId:", nodeId);
 
-    if (!app || !app.graph) {
-        console.error('[nodeFocusHandler] app or app.graph not available');
-        return false;
-    }
+  if (!app || !app.graph) {
+    console.error("[nodeFocusHandler] app or app.graph not available");
+    return false;
+  }
 
-    const node = app.graph.getNodeById(parseInt(nodeId, 10));
-    if (!node) {
-        console.error('[nodeFocusHandler] 找不到节点:', nodeId);
-        return false;
-    }
+  const node = app.graph.getNodeById(parseInt(nodeId, 10));
+  if (!node) {
+    console.error("[nodeFocusHandler] 找不到节点:", nodeId);
+    return false;
+  }
 
-    console.log('[nodeFocusHandler] 找到节点:', node);
+  console.log("[nodeFocusHandler] 找到节点:", node);
 
-    // 临时禁用冻结模式
-    const wasFreezed = !!freezeOverlay;
-    let originalOverlayDisplay = null;
+  // 临时禁用冻结模式
+  const wasFreezed = !!freezeOverlay;
+  let originalOverlayDisplay = null;
 
-    if (wasFreezed && freezeOverlay) {
-        originalOverlayDisplay = freezeOverlay.style.display;
-        freezeOverlay.style.display = 'none';
-
-        // 临时解除事件阻止
-        if (globalEventBlocked) {
-            document.removeEventListener('keydown', keyboardListener, true);
-            document.removeEventListener('contextmenu', contextMenuListener, true);
-        }
-    }
+  if (wasFreezed && freezeOverlay) {
+    originalOverlayDisplay = freezeOverlay.style.display;
+    freezeOverlay.style.display = "none";
 
-    // 只设置节点的 selected 属性，不改变颜色
-    for (const n of app.graph._nodes) {
-        n.selected = n.id === node.id;
+    // 临时解除事件阻止
+    if (globalEventBlocked) {
+      document.removeEventListener("keydown", keyboardListener, true);
+      document.removeEventListener("contextmenu", contextMenuListener, true);
     }
-
-    // 设置 selected_nodes
-    if (app.canvas) {
-        app.canvas.selected_nodes = [node];
+  }
+
+  // 只设置节点的 selected 属性，不改变颜色
+  for (const n of app.graph._nodes) {
+    n.selected = n.id === node.id;
+  }
+
+  // 设置 selected_nodes
+  if (app.canvas) {
+    app.canvas.selected_nodes = [node];
+  }
+
+  // 聚焦到节点 - 使用与selectNodeAndFocus相同的方法
+  if (app.canvas && typeof app.canvas.centerOnNode === "function") {
+    console.log("[nodeFocusHandler] 使用 centerOnNode 方法聚焦节点");
+    app.canvas.centerOnNode(node);
+  }
+
+  // 刷新画布
+  if (app.canvas) {
+    app.canvas.setDirty(true, true);
+    if (typeof app.canvas.draw === "function") {
+      app.canvas.draw(true, true);
     }
+  }
 
-    // 聚焦到节点 - 使用与selectNodeAndFocus相同的方法
-    if (app.canvas && typeof app.canvas.centerOnNode === 'function') {
-        console.log('[nodeFocusHandler] 使用 centerOnNode 方法聚焦节点');
-        app.canvas.centerOnNode(node);
+  // 恢复冻结模式
+  setTimeout(() => {
+    if (wasFreezed && freezeOverlay) {
+      freezeOverlay.style.display = originalOverlayDisplay;
+
+      // 恢复事件阻止
+      if (globalEventBlocked) {
+        document.addEventListener("keydown", keyboardListener, true);
+        document.addEventListener("contextmenu", contextMenuListener, true);
+      }
     }
 
-    // 刷新画布
+    // 再次刷新画布
     if (app.canvas) {
-        app.canvas.setDirty(true, true);
-        if (typeof app.canvas.draw === 'function') {
-            app.canvas.draw(true, true);
-        }
+      app.canvas.setDirty(true, true);
+      if (typeof app.canvas.draw === "function") {
+        app.canvas.draw(true, true);
+      }
     }
+  }, 100);
 
-    // 恢复冻结模式
-    setTimeout(() => {
-        if (wasFreezed && freezeOverlay) {
-            freezeOverlay.style.display = originalOverlayDisplay;
-
-            // 恢复事件阻止
-            if (globalEventBlocked) {
-                document.addEventListener('keydown', keyboardListener, true);
-                document.addEventListener('contextmenu', contextMenuListener, true);
-            }
-        }
-
-        // 再次刷新画布
-        if (app.canvas) {
-            app.canvas.setDirty(true, true);
-            if (typeof app.canvas.draw === 'function') {
-                app.canvas.draw(true, true);
-            }
-        }
-    }, 100);
-
-    console.log('[nodeFocusHandler] focusNodeOnly 完成');
-    return true;
+  console.log("[nodeFocusHandler] focusNodeOnly 完成");
+  return true;
 }
 
 // 处理画布节点点击事件
 export function handleCanvasNodeClick(e) {
-    if (!app || !app.graph) return;
-
-    // 获取点击的节点
-    const nodeUnderMouse = getNodeUnderMouse(e);
-    if (!nodeUnderMouse) return;
-
-    console.log('[nodeFocusHandler] 画布点击节点:', nodeUnderMouse.id, nodeUnderMouse.title);
-
-    // 发送消息到前端，通知节点被点击
-    window.parent.postMessage({
-        type: 'CANVAS_NODE_CLICKED',
-        nodeId: nodeUnderMouse.id,
-        nodeTitle: nodeUnderMouse.title,
-        nodeType: nodeUnderMouse.type
-    }, '*');
+  if (!app || !app.graph) return;
+
+  // 获取点击的节点
+  const nodeUnderMouse = getNodeUnderMouse(e);
+  if (!nodeUnderMouse) return;
+
+  console.log(
+    "[nodeFocusHandler] 画布点击节点:",
+    nodeUnderMouse.id,
+    nodeUnderMouse.title
+  );
+
+  // 发送消息到前端，通知节点被点击
+  window.parent.postMessage(
+    {
+      type: "CANVAS_NODE_CLICKED",
+      nodeId: nodeUnderMouse.id,
+      nodeTitle: nodeUnderMouse.title,
+      nodeType: nodeUnderMouse.type,
+    },
+    "*"
+  );
 }
 
 // 获取鼠标下方的节点
 function getNodeUnderMouse(e) {
-    if (!app || !app.graph) return null;
+  if (!app || !app.graph) return null;
 
-    // 获取画布位置
-    const canvas = document.querySelector('canvas');
-    if (!canvas) return null;
+  // 获取画布位置
+  const canvas = document.querySelector("canvas");
+  if (!canvas) return null;
 
-    // 转换为图形坐标
-    const pos = app.canvas.convertEventToCanvasOffset(e);
+  // 转换为图形坐标
+  const pos = app.canvas.convertEventToCanvasOffset(e);
 
-    // 检查点击位置是否在某个节点上
-    const node = app.graph.getNodeOnPos(pos[0], pos[1]);
-    return node;
+  // 检查点击位置是否在某个节点上
+  const node = app.graph.getNodeOnPos(pos[0], pos[1]);
+  return node;
 }
 
 // 设置画布点击事件监听
 export function setupCanvasClickHandler() {
-    // 移除现有的事件监听器
-    removeCanvasClickHandler();
-
-    // 添加画布点击事件监听
-    const canvas = document.querySelector('canvas');
-    if (canvas) {
-        canvas.addEventListener('click', handleCanvasNodeClick);
-        console.log('[nodeFocusHandler] 画布点击事件监听器已设置');
-    }
+  // 移除现有的事件监听器
+  removeCanvasClickHandler();
+
+  // 添加画布点击事件监听
+  const canvas = document.querySelector("canvas");
+  if (canvas) {
+    canvas.addEventListener("click", handleCanvasNodeClick);
+    console.log("[nodeFocusHandler] 画布点击事件监听器已设置");
+  }
 }
 
 // 移除画布点击事件监听
 export function removeCanvasClickHandler() {
-    const canvas = document.querySelector('canvas');
-    if (canvas) {
-        canvas.removeEventListener('click', handleCanvasNodeClick);
-        console.log('[nodeFocusHandler] 画布点击事件监听器已移除');
-    }
+  const canvas = document.querySelector("canvas");
+  if (canvas) {
+    canvas.removeEventListener("click", handleCanvasNodeClick);
+    console.log("[nodeFocusHandler] 画布点击事件监听器已移除");
+  }
 }

bizydraft/static/js/nodeParamsFilter.js

@@ -11,29 +11,29 @@ let nodeParamsMap = new Map();
  * @param {Array} inputsData - 服务端返回的inputs数组
  */
 function setNodeParams(inputsData) {
-    if (!Array.isArray(inputsData)) {
-        console.error('Invalid inputs data format:', inputsData);
-        return;
+  if (!Array.isArray(inputsData)) {
+    console.error("Invalid inputs data format:", inputsData);
+    return;
+  }
+
+  // 清空现有映射
+  nodeParamsMap.clear();
+
+  // 构建新的映射
+  inputsData.forEach((nodeInfo) => {
+    if (nodeInfo && nodeInfo.nodeId && Array.isArray(nodeInfo.params)) {
+      // 以nodeId为键，存储参数信息
+      const paramNames = nodeInfo.params.map((param) => param.name);
+      nodeParamsMap.set(nodeInfo.nodeId, {
+        name: nodeInfo.name,
+        displayName: nodeInfo.displayName,
+        paramNames: paramNames,
+        params: nodeInfo.params,
+      });
     }
+  });
 
-    // 清空现有映射
-    nodeParamsMap.clear();
-
-    // 构建新的映射
-    inputsData.forEach(nodeInfo => {
-        if (nodeInfo && nodeInfo.nodeId && Array.isArray(nodeInfo.params)) {
-            // 以nodeId为键，存储参数信息
-            const paramNames = nodeInfo.params.map(param => param.name);
-            nodeParamsMap.set(nodeInfo.nodeId, {
-                name: nodeInfo.name,
-                displayName: nodeInfo.displayName,
-                paramNames: paramNames,
-                params: nodeInfo.params
-            });
-        }
-    });
-
-    console.log('节点参数映射已更新:', nodeParamsMap);
+  console.log("节点参数映射已更新:", nodeParamsMap);
 }
 
 /**
@@ -42,71 +42,73 @@ function setNodeParams(inputsData) {
  * @returns {Object|null} - 过滤后的节点信息，如果节点不符合条件则返回null
  */
 function filterNodeWidgets(node) {
-    if (!node || !node.id) return null;
-
-    // 如果节点ID不在参数映射中，则不是可配置节点
-    if (!nodeParamsMap.has(String(node.id))) {
-        console.log(`节点 ${node.id} 不在可配置列表中`);
-        return null;
-    }
+  if (!node || !node.id) return null;
+
+  // 如果节点ID不在参数映射中，则不是可配置节点
+  if (!nodeParamsMap.has(String(node.id))) {
+    console.log(`节点 ${node.id} 不在可配置列表中`);
+    return null;
+  }
+
+  // 获取节点的允许参数列表
+  const nodeParamsInfo = nodeParamsMap.get(String(node.id));
+  const allowedParamNames = nodeParamsInfo.paramNames;
+
+  // 提取节点信息
+  const nodeInfo = {
+    id: node.id,
+    type: node.type,
+    comfyClass: node.comfyClass,
+    title: node.title || nodeParamsInfo.displayName,
+    widgets: [],
+  };
+
+  // 过滤widgets，只保留在allowedParamNames中的widget
+  if (node.widgets && node.widgets.length > 0) {
+    nodeInfo.widgets = node.widgets
+      .filter((widget) => {
+        return (
+          widget.type !== "hidden" &&
+          !widget.disabled &&
+          allowedParamNames.includes(String(widget.name))
+        );
+      })
+      .map((widget) => {
+        const widgetInfo = {
+          name: String(widget.name || ""),
+          value: widget.value != null ? widget.value : "",
+          type: String(widget.type || ""),
+        };
+
+        // 处理options属性
+        if (widget.options && widget.options.values) {
+          widgetInfo.options = { values: [] };
+
+          if (Array.isArray(widget.options.values)) {
+            widgetInfo.options.values = [...widget.options.values];
+          } else if (typeof widget.options.values === "function") {
+            try {
+              const values = widget.options.values();
+              if (Array.isArray(values)) {
+                widgetInfo.options.values = [...values];
+              }
+            } catch (e) {
+              // 忽略错误
+            }
+          }
+        }
 
-    // 获取节点的允许参数列表
-    const nodeParamsInfo = nodeParamsMap.get(String(node.id));
-    const allowedParamNames = nodeParamsInfo.paramNames;
-
-    // 提取节点信息
-    const nodeInfo = {
-        id: node.id,
-        type: node.type,
-        comfyClass: node.comfyClass,
-        title: node.title || nodeParamsInfo.displayName,
-        widgets: []
-    };
-
-    // 过滤widgets，只保留在allowedParamNames中的widget
-    if (node.widgets && node.widgets.length > 0) {
-        nodeInfo.widgets = node.widgets
-            .filter(widget => {
-                return widget.type !== "hidden" &&
-                       !widget.disabled &&
-                       allowedParamNames.includes(String(widget.name));
-            })
-            .map(widget => {
-                const widgetInfo = {
-                    name: String(widget.name || ""),
-                    value: widget.value != null ? widget.value : "",
-                    type: String(widget.type || "")
-                };
-
-                // 处理options属性
-                if (widget.options && widget.options.values) {
-                    widgetInfo.options = { values: [] };
-
-                    if (Array.isArray(widget.options.values)) {
-                        widgetInfo.options.values = [...widget.options.values];
-                    } else if (typeof widget.options.values === 'function') {
-                        try {
-                            const values = widget.options.values();
-                            if (Array.isArray(values)) {
-                                widgetInfo.options.values = [...values];
-                            }
-                        } catch (e) {
-                            // 忽略错误
-                        }
-                    }
-                }
-
-                return widgetInfo;
-            });
-    }
+        return widgetInfo;
+      });
+  }
 
-    // 如果过滤后没有可配置的参数，则不符合条件
-    if (nodeInfo.widgets.length === 0) {
-        console.log(`节点 ${node.id} 没有可配置的参数`);
-        return null;
-    }
+  // 如果过滤后没有可配置的参数，则不符合条件
+  if (nodeInfo.widgets.length === 0) {
+    console.log(`节点 ${node.id} 没有可配置的参数`);
+    return null;
+  }
 
-    return nodeInfo;
+  return nodeInfo;
 }
 
 /**
@@ -115,7 +117,7 @@ function filterNodeWidgets(node) {
  * @returns {boolean} - 节点是否可配置
  */
 function isConfigurableNode(nodeId) {
-    return nodeParamsMap.has(String(nodeId));
+  return nodeParamsMap.has(String(nodeId));
 }
 
 /**
@@ -124,13 +126,13 @@ function isConfigurableNode(nodeId) {
  * @returns {Object|null} - 节点参数信息
  */
 function getNodeParamsInfo(nodeId) {
-    return nodeParamsMap.get(String(nodeId)) || null;
+  return nodeParamsMap.get(String(nodeId)) || null;
 }
 
 // 导出模块
 export {
-    setNodeParams,
-    filterNodeWidgets,
-    isConfigurableNode,
-    getNodeParamsInfo
+  setNodeParams,
+  filterNodeWidgets,
+  isConfigurableNode,
+  getNodeParamsInfo,
 };