bizydraft 0.1.29__py3-none-any.whl → 0.2.0__py3-none-any.whl

bizydraft/static/js/hookLoadImage.js

@@ -1,27 +1,50 @@
 import { app } from "../../scripts/app.js";
-import { fileToOss } from "./uploadFile.js";
-import { getCookie, hideWidget } from './tool.js';
+import { getCookie, computeIsLoadNode, computeExt, hideWidget } from './tool.js';
+
 
 app.registerExtension({
     name: "bizyair.image.to.oss",
     async beforeRegisterNodeDef(nodeType, nodeData) {
-        if (nodeData.name === 'LoadImage') {
-            let workflowParams = null
-            document.addEventListener('workflowLoaded', (event) => {
-                workflowParams = event.detail;
+        let workflowParams = null
+        document.addEventListener('workflowLoaded', (event) => {
+            workflowParams = event.detail;
+        })
+        document.addEventListener('drop', (e) => {
+            e.preventDefault();
+            const files = e.dataTransfer.files;
+
+            Array.from(files).forEach((file) => {
+                if (file.type === 'application/json' || file.name.endsWith('.json')) {
+                    const reader = new FileReader();
+                    reader.onload = function(event) {
+                        try {
+                            const jsonContent = JSON.parse(event.target.result);
+                            if (jsonContent && jsonContent.nodes) {
+                                window.currentWorkflowData = jsonContent;
+                            }
+                        } catch (error) {
+                            console.error('解析JSON文件失败:', error);
+                        }
+                    };
+                    reader.readAsText(file);
+                }
             });
+        })
+        if (computeIsLoadNode(nodeData.name)) {
             nodeType.prototype.onNodeCreated = async function() {
-                const image_widget = this.widgets.find(w => w.name === 'image');
-                console.log(image_widget)
-                // const apiHost = 'http://localhost:3000/api'
                 const apiHost = 'https://bizyair.cn/api'
-                const node = this;
+                const image_widget = this.widgets.find(w => {
+                    return w.name === 'image'
+                            || w.name === 'file'
+                            || w.name === 'audio'
+                            || w.name === 'model_file'
+                });
+                let image_name_widget = this.widgets.find(w => w.name === 'image_name');
                 let image_list = []
                 const getData = async () => {
                     const res = await fetch(`${apiHost}/special/community/commit_input_resource?${
                         new URLSearchParams({
-                            url: '',
-                            ext: '',
+                            ext: computeExt(nodeData.name),
                             current: 1,
                             page_size: 100
 
@@ -38,96 +61,113 @@ app.registerExtension({
                     image_list = list.filter(item => item.name).map(item => {
                         return {
                             url: item.url,
+                            id: item.id,
                             name: item.name
                         }
-                        // return item.url
                     })
-                    const image_widget = this.widgets.find(w => w.name === 'image');
-                    
-
-                    let image_path_widget = this.widgets.find(w => w.name === 'image_path');
-                    if (!image_path_widget) {
-                        image_path_widget = this.addWidget("text", "image_path", "", function(){}, {
-                            serialize: true
+                    if (!image_name_widget) {
+                        image_name_widget = this.addWidget("combo", "image_name", "", function(e){
+                            const item = image_list.find(item => item.name === e)
+                            const image_url = decodeURIComponent(item.url);
+                            image_widget.value = image_url;
+                            if (image_widget.callback) {
+                                image_widget.callback(e);
+                            }
+                        }, {
+                            serialize: true,
+                            values: image_list.map(item => item.name)
                         });
-                        image_path_widget.type = "hidden";
-                        // image_path_widget.style = "hidden";
-                        image_path_widget.computeSize = () => [0, 0]; // 隐藏显示
                     }
-                    hideWidget(this, 'image_path')
+                    const val = image_list.find(item => item.url === image_widget.value)?.name || image_widget.value
+                    image_name_widget.label = image_widget.label
+                    image_name_widget.value = val
 
-                    image_widget.options.values = image_list.map(item => item.name);
-                    // console.log(image_widget.value)
-                    // image_widget.value = image_list[0].url;
-                    // image_widget.value = image_list[0];
-                    if (image_list[0] && image_list[0].url) {
-                        image_widget.value = image_list[0].name
-                        const defaultImageUrl = decodeURIComponent(image_list[0].url);
-                        image_path_widget.value = defaultImageUrl;
-                        
-                        previewImage(node, defaultImageUrl)
+                    const currentIndex = this.widgets.indexOf(image_name_widget);
+                    if (currentIndex > 1) {
+                        this.widgets.splice(currentIndex, 1);
+                        this.widgets.splice(1, 0, image_name_widget);
                     }
-                    image_widget.callback = function(e) {
-                        const image_url = decodeURIComponent(image_list.find(item => item.name === e).url);
-                        image_path_widget.value = image_url;
-                        previewImage(node, image_url)
+                    hideWidget(this, image_widget.name)
+                    image_widget.options.values = image_list.map(item => item.name);
+
+                    const callback = image_widget.callback
+                    image_widget.callback = async function(e) {
+                        console.log(e)
+                        if (typeof e == 'string') {
+                            const item = e.includes('http') ?
+                                image_list.find(item => item.url === e) :
+                                image_list.find(item => item.name === e)
+
+                            const image_url = item ? decodeURIComponent(item.url) : e;
+
+                            image_name_widget.value = item ? item.name : e;
+                            image_widget.value = image_url;
+                            console.log('=================image_url=================')
+                            console.log(image_url)
+                            console.log(item)
+                            console.log(await app.graphToPrompt())
+                            callback([image_url])
+                            console.log(await app.graphToPrompt())
+                        } else {
+                            const item = e[0].split('/')
+                            image_name_widget.options.values.pop()
+                            image_name_widget.options.values.push(item[item.length - 1])
+                            image_name_widget.value = item[item.length - 1]
+                            image_list.push({
+                                name: item[item.length - 1],
+                                url: e[0]
+                            })
+                            callback(e)
+                        }
                     }
                     return true
                 }
-                
                 await getData()
 
 
+                function applyWorkflowImageSettings(workflowParams, image_list, image_widget, image_name_widget) {
+                    if (workflowParams && workflowParams.nodes) {
+                        const imageNode = workflowParams.nodes.find(item => computeIsLoadNode(item.type))
+                        if (imageNode && imageNode.widgets_values) {
+                            const item = imageNode.widgets_values[0].split('/')
+                            image_list.push({
+                                name: item[item.length - 1],
+                                url: imageNode.widgets_values[0]
+                            })
+                            image_widget.value = imageNode.widgets_values[0]
 
-                if (workflowParams && workflowParams.json.nodes) {
-                    const imageNode = workflowParams.json.nodes.find(item => item.type === 'LoadImage')
-                    if (imageNode && imageNode.widgets_values && imageNode.widgets_values[2]) {
-                        const temp = {
-                            name: imageNode.widgets_values[0],
-                            url: imageNode.widgets_values[2]
+                            image_widget.options.values = image_list.map(item => item.url)
+                            image_name_widget.options.values = image_list.map(item => item.name)
+                            image_widget.callback(imageNode.widgets_values[0])
                         }
-                        image_list.push(temp)
-                        image_widget.value = temp.name
-                        image_widget.options.values = image_list.map(item => item.name)
-                        previewImage(node, temp.url)
-                        
-                        requestAnimationFrame(() => {
-                            previewImage(node, temp.url)
-                        })
                     }
                 }
-                const upload_widget = this.widgets.find(w => w.name === 'upload');
-                upload_widget.callback = async function() {
-                    const input = document.createElement('input');
-                    input.type = 'file';
-                    input.accept = 'image/*';
-                    input.onchange = async (e) => {
-                        const file = e.target.files[0];
-                        await fileToOss(file);
-
-                        getData()
-                    }
-                    input.click();
+
+                // 如果有存储的工作流数据，应用图像设置
+                if (window.currentWorkflowData) {
+                    applyWorkflowImageSettings(window.currentWorkflowData, image_list, image_widget, image_name_widget);
+                    // 清除存储的数据，避免重复处理
+                    delete window.currentWorkflowData;
+                } else {
+                    // 原有的调用
+                    applyWorkflowImageSettings(workflowParams, image_list, image_widget, image_name_widget);
                 }
+
+
             }
         }
     }
 })
 
-function previewImage(node, image_url) {
-    const img = new Image();
-    img.onload = function() {
-        node.imgs = [img];
-        if (node.graph && node.graph.setDirtyCanvas) {
-            node.graph.setDirtyCanvas(true);
-        } else {
-            console.warn('[BizyAir] 无法访问graph对象进行重绘');
-        }
-        
-        console.log('[BizyAir] 图片预览加载成功');
-    };
-    img.onerror = function(err) {
-        console.error('[BizyAir] 图片加载失败:', image_url, err);
-    };
-    img.src = image_url;
-}
+// app.api.addEventListener('graphChanged', (e) => {
+//     console.log('Graph 发生变化，当前 workflow JSON:', e.detail)
+//     window.parent.postMessage({
+//         type: 'functionResult',
+//         method: 'workflowChanged',
+//         result: e.detail
+//     }, '*');
+
+//     document.dispatchEvent(new CustomEvent('workflowLoaded', {
+//         detail: e.detail
+//     }));
+// })

bizydraft/static/js/hookLoadModel.js

@@ -0,0 +1,152 @@
+import { app } from "../../scripts/app.js";
+import '../BizyAir/bizyair_frontend.js'
+import { hideWidget } from './tool.js'
+const possibleWidgetNames=[
+    "clip_name",
+    "clip_name1",
+    "clip_name2",
+    "ckpt_name",
+    "lora_name",
+    "control_net_name",
+    "ipadapter_file",
+    "unet_name",
+    "vae_name",
+    "model_name",
+    "instantid_file",
+    "pulid_file",
+    "style_model_name",
+]
+
+// 根据节点名称匹配模型类型
+function getModelTypeFromNodeName(nodeName) {
+    if (/bizyair/i.test(nodeName)) {
+        return null;
+    }
+
+    const regex = /^(\w+).*Loader.*/i;
+    const match = nodeName.match(regex);
+    if (match) {
+        return match[1];
+    }
+    return null;
+}
+
+function createSetWidgetCallback(modelType, selectedBaseModels = []) {
+    return function setWidgetCallback() {
+        const targetWidget = this.widgets.find(widget => possibleWidgetNames.includes(widget.name));
+        if (targetWidget) {
+            targetWidget.value = targetWidget.value || "to choose"
+            targetWidget.mouse = function(e, pos, canvas) {
+                try {
+                    if (e.type === "pointerdown" || e.type === "mousedown" || e.type === "click" || e.type === "pointerup") {
+                        e.preventDefault();
+                        e.stopPropagation();
+                        e.widgetClick = true;
+
+                        const currentNode = this.node;
+
+                        if (!currentNode || !currentNode.widgets) {
+                            console.warn("Node or widgets not available");
+                            return false;
+                        }
+
+                        if (typeof bizyAirLib !== 'undefined' && typeof bizyAirLib.showModelSelect === 'function') {
+                            bizyAirLib.showModelSelect({
+                                modelType: [modelType],
+                                selectedBaseModels,
+                                onApply: (version, model) => {
+                                    if (!currentNode || !currentNode.widgets) return;
+
+                                    const currentLora = currentNode.widgets.find(widget => possibleWidgetNames.includes(widget.name));
+                                    const currentModel = currentNode.widgets.find(w => w.name === "model_version_id");
+
+                                    if (model && currentModel && version) {
+                                        currentLora.value = model;
+                                        currentModel.value = version.id;
+                                        currentNode.setDirtyCanvas(true);
+                                    }
+                                }
+                            });
+                        } else {
+                            console.error("bizyAirLib not available");
+                        }
+                        return false;
+                    }
+                } catch (error) {
+                    console.error("Error handling mouse event:", error);
+                }
+            };
+
+            // targetWidget.node = this;
+            targetWidget.options = targetWidget.options || {};
+            targetWidget.options.values = () => [];
+            targetWidget.options.editable = false;
+            targetWidget.clickable = true;
+            targetWidget.processMouse = true;
+        }
+    }
+}
+
+function setupNodeMouseBehavior(node, modelType) {
+    hideWidget(node, "model_version_id");
+
+    // 只设置必要的状态信息，不修改onMouseDown（已在上面的扩展中处理）
+    if (!node._bizyairState) {
+        node._bizyairState = {
+            lastClickTime: 0,
+            DEBOUNCE_DELAY: 300,
+            modelType: modelType
+        };
+    }
+}
+
+app.registerExtension({
+    name: "bizyair.hook.load.model",
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+
+        localStorage.removeItem('workflow')
+        sessionStorage.clear()
+        const interval = setInterval(() => {
+            if (window.switchLanguage) {
+                window.switchLanguage('zh')
+                clearInterval(interval)
+            }
+        }, 100)
+
+        const modelType = getModelTypeFromNodeName(nodeData.name);
+        if (modelType) {
+            const onNodeCreated = nodeType.prototype.onNodeCreated;
+            nodeType.prototype.onNodeCreated = function() {
+                try {
+                    let model_version_id = this.widgets.find(w => w.name === "model_version_id");
+                    if (!model_version_id) {
+                        model_version_id = this.addWidget("hidden", "model_version_id", "", function(e){
+                            console.log(e)
+                        }, {
+                            serialize: true,
+                            values: []
+                        });
+                    }
+                    console.log(model_version_id)
+                    const result = onNodeCreated?.apply(this, arguments);
+                    let selectedBaseModels = [];
+                    // if (modelType === 'Checkpoint') {
+                    //     selectedBaseModels = ['SDXL', 'Pony', 'SD 3.5', 'Illustrious']
+                    // }
+                    createSetWidgetCallback(modelType, selectedBaseModels).call(this);
+                    return result;
+                } catch (error) {
+                    console.error("Error in node creation:", error);
+                }
+            };
+        }
+    },
+
+    async nodeCreated(node) {
+        const modelType = getModelTypeFromNodeName(node?.comfyClass);
+
+        if (modelType) {
+            setupNodeMouseBehavior(node, modelType);
+        }
+    }
+})

bizydraft/static/js/main.js

@@ -1,5 +1,4 @@
 // 主入口文件，导入所有模块
 import "./hookLoadImage.js";
-import "./hookSaveImage.js";
 import "./postEvent.js";
 import "./handleStyle.js";

bizydraft/static/js/nodeFocusHandler.js

@@ -0,0 +1,153 @@
+import { app } from "../../scripts/app.js";
+
+// 全局变量引用（从aiAppHandler.js中引用）
+let freezeOverlay = null;
+let globalEventBlocked = false;
+let keyboardListener = null;
+let contextMenuListener = null;
+
+// 设置全局变量引用
+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);
+
+    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;
+    }
+
+    console.log('[nodeFocusHandler] 找到节点:', node);
+
+    // 临时禁用冻结模式
+    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);
+        }
+    }
+
+    // 只设置节点的 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);
+        }
+    }
+
+    // 恢复冻结模式
+    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;
+}
+
+// 处理画布节点点击事件
+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
+    }, '*');
+}
+
+// 获取鼠标下方的节点
+function getNodeUnderMouse(e) {
+    if (!app || !app.graph) return null;
+
+    // 获取画布位置
+    const canvas = document.querySelector('canvas');
+    if (!canvas) return null;
+
+    // 转换为图形坐标
+    const pos = app.canvas.convertEventToCanvasOffset(e);
+
+    // 检查点击位置是否在某个节点上
+    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] 画布点击事件监听器已设置');
+    }
+}
+
+// 移除画布点击事件监听
+export function removeCanvasClickHandler() {
+    const canvas = document.querySelector('canvas');
+    if (canvas) {
+        canvas.removeEventListener('click', handleCanvasNodeClick);
+        console.log('[nodeFocusHandler] 画布点击事件监听器已移除');
+    }
+}