bizydraft 0.2.78.dev20251030100819__py3-none-any.whl → 0.2.82.dev20251209023307__py3-none-any.whl

bizydraft/static/js/hookLoadMedia.js

@@ -1,8 +1,23 @@
 import { app } from "../../scripts/app.js";
-import { getCookie, computeExt, hideWidget } from './tool.js';
-import { getMediaNodeConfig, getMediaInputKeys, possibleMediaWidgetNames, computeIsMediaNode, mediaNodeList, fetchMediaConfigWithCache } from './hookLoad/media.js';
-
-
+import { hideWidget } from './tool.js';
+import {
+    getMediaNodeConfig,
+    getMediaInputKeys,
+    computeIsMediaNode,
+    mediaNodeList,
+    fetchMediaConfigWithCache,
+    findMediaWidget,
+    findMediaWidgets,
+    updateWidgetsOptions,
+    handleNewUploadedFile,
+    extractUrlFromInput,
+    initMaps,
+    createImageNameWidgetCallbackForMediaWidget,
+    createMediaWidgetCallback,
+    setupVaWidgets,
+    applyWorkflowImageSettings,
+    fetchImageList
+} from './hookLoad/media.js';
 
 app.registerExtension({
     name: "bizyair.image.to.oss",
@@ -33,307 +48,99 @@ app.registerExtension({
             });
         })
         nodeType.prototype.onNodeCreated = async function() {
-            if (await computeIsMediaNode(nodeData.name)) {
-                const apiHost = 'https://bizyair.cn/api'
-                // 优先使用 API 的媒体输入键匹配到具体的 widget；若未命中则回退到原有字段集合
-                let media_widget = null;
-                const mediaNodeConfig = await getMediaNodeConfig(nodeData.name);
-                const apiInputKeys = getMediaInputKeys(mediaNodeConfig);
-                if (apiInputKeys && apiInputKeys.length > 0) {
-                    for (const key of apiInputKeys) {
-                        const w = this.widgets.find(x => x.name === key);
-                        if (w) { media_widget = w; break; }
-                    }
-                }
-                if (!media_widget) {
-                    media_widget = this.widgets.find(w => {
-                        return possibleMediaWidgetNames.includes(w.name);
-                    });
-                }
-                // 查找所有name等于接口配置中inputs下的字段的widget（如video、audio等）
-                let va_widgets = [];
-                if (apiInputKeys && apiInputKeys.length > 0) {
-                    for (const key of apiInputKeys) {
-                        const w = this.widgets.find(x => x.name === key);
-                        if (w) {
-                            va_widgets.push(w);
-                        }
-                    }
-                }
-
-                // 如果API配置没有找到，使用回退逻辑查找常见的媒体widget
-                if (va_widgets.length === 0) {
-                    for (const widgetName of possibleMediaWidgetNames) {
-                        const w = this.widgets.find(x => x.name === widgetName);
-                        if (w) {
-                            va_widgets.push(w);
-                        }
-                    }
-                }
-                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({
-                            ext: computeExt(nodeData.name),
-                            current: 1,
-                            page_size: 100
-
-                        }).toString()
-                    }`, {
-                        method: 'GET',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${getCookie('bizy_token')}`
-                        }
-                    })
-                    const {data} = await res.json()
-                    const list = (data && data.data && data.data.data && data.data.data.list) || []
-                    image_list = list.filter(item => item.name).map(item => {
-                        return {
-                            url: item.url,
-                            id: item.id,
-                            name: item.name
-                        }
-                    })
-
-                    // 📊 方案：使用 Map 缓存 URL→Name 映射（O(1) 查找）
-                    const urlToNameMap = new Map();
-                    const nameToItemMap = new Map();
-                    image_list.forEach(item => {
-                        urlToNameMap.set(item.url, item.name);
-                        nameToItemMap.set(item.name, item);
-                    });
-
-                    // 如果找到va_widgets，处理它们
-                    if (va_widgets.length > 0) {
-                        // 标志位：防止批量更新时触发监听
-                        let isBatchUpdating = false;
-
-                        // 创建image_name_widget来替代显示
-                        if (!image_name_widget) {
-                            image_name_widget = this.addWidget("combo", "image_name", "", function(e){
-                                const item = nameToItemMap.get(e);
-                                if (item) {
-                                    const image_url = decodeURIComponent(item.url);
-                                    // 批量更新时跳过监听
-                                    isBatchUpdating = true;
-                                    va_widgets.forEach(va_widget => {
-                                        va_widget.value = image_url;
-                                        if (va_widget.callback) {
-                                            va_widget.callback(image_url);
-                                        }
-                                    });
-                                    isBatchUpdating = false;
-                                }
-                            }, {
-                                serialize: true,
-                                values: image_list.map(item => item.name)
-                            });
-                        }
-
-                        // 隐藏所有va_widgets 并设置监听
-                        va_widgets.forEach(va_widget => {
-                            hideWidget(this, va_widget.name);
-                            let _value = va_widget.value;
-
-                            // 检查并删除现有的 value 属性描述符（如果存在）
-                            const existingDescriptor = Object.getOwnPropertyDescriptor(va_widget, 'value');
-                            if (existingDescriptor && !existingDescriptor.configurable) {
-                                // 如果不可配置，跳过重新定义
-                                return;
-                            }
+            if (!(await computeIsMediaNode(nodeData.name))) {
+                return;
+            }
 
-                            // 删除现有属性（如果存在）
-                            if (existingDescriptor) {
-                                delete va_widget.value;
-                            }
+            const apiHost = 'https://bizyair.cn/api'
+            // const apiHost = 'http://localhost:3000/api'
 
-                            Object.defineProperty(va_widget, 'value', {
-                                get: function() {
-                                    return _value;
-                                },
-                                set: function(newValue) {
-                                    _value = newValue;
+            // 获取 API 配置
+            const mediaNodeConfig = await getMediaNodeConfig(nodeData.name);
+            const apiInputKeys = getMediaInputKeys(mediaNodeConfig);
 
-                                    // 批量更新时跳过监听逻辑
-                                    if (isBatchUpdating) {
-                                        return;
-                                    }
-                                    // 使用 Map 快速查找（O(1)）
-                                    const name = urlToNameMap.get(newValue);
-                                    if (name) {
-                                        image_name_widget.value = name;
-                                    } else {
-                                        // 如果没找到，从URL提取文件名
-                                        const fileName = newValue.split('/').pop();
-                                        image_name_widget.value = fileName;
-                                    }
-                                },
-                                enumerable: true,
-                                configurable: true
-                            });
-                        });
+            // 查找媒体 widget
+            const media_widget = findMediaWidget(this.widgets, apiInputKeys);
+            const va_widgets = findMediaWidgets(this.widgets, apiInputKeys);
+            let image_name_widget = this.widgets.find(w => w.name === 'image_name');
 
+            // 获取文件列表
+            const image_list = await fetchImageList(apiHost, nodeData.name);
 
-                        // 为每个va_widget重写callback
-                        va_widgets.forEach(va_widget => {
-                            // 保存va_widget的原始callback
-                            const originalVaCallback = va_widget.callback;
-                            // 重写va_widget的callback，当被触发时给image_name_widget赋值
-                            va_widget.callback = function(e) {
-                                if (image_name_widget) {
-                                    if (typeof e === 'string') {
-                                        // 使用 Map 快速查找（O(1)）
-                                        const name = urlToNameMap.get(e);
-                                        if (name) {
-                                            image_name_widget.value = name;
-                                        } else {
-                                            // 如果没找到，从URL提取文件名
-                                            const fileName = e.split('/').pop();
-                                            image_name_widget.value = fileName;
-                                        }
-                                    }
-                                }
+            // 初始化 Map 映射
+            const { urlToNameMap, nameToItemMap } = initMaps(image_list);
 
-                                // 调用原始callback
-                                if (originalVaCallback) {
-                                    originalVaCallback(e);
-                                }
-                            };
-                        });
-                    }
+            // 如果找到va_widgets，处理它们
+            if (va_widgets.length > 0) {
+                image_name_widget = setupVaWidgets(this, va_widgets, image_list, urlToNameMap, nameToItemMap, image_name_widget, va_widgets[0]);
+            }
 
-                    // 如果va_widgets没有创建image_name_widget，使用原有逻辑创建
-                    if (!image_name_widget && media_widget) {
-                        image_name_widget = this.addWidget("combo", "image_name", "", function(e){
-                            const item = nameToItemMap.get(e);
-                            if (item) {
-                                const image_url = decodeURIComponent(item.url);
-                                media_widget.value = image_url;
-                                if (media_widget.callback) {
-                                    media_widget.callback(image_url);
-                                }
-                            }
-                        }, {
-                            serialize: true,
-                            values: image_list.map(item => item.name)
-                        });
+            // 如果va_widgets没有创建image_name_widget，使用原有逻辑创建
+            if (!image_name_widget && media_widget) {
+                image_name_widget = this.addWidget("combo", "image_name", "",
+                    createImageNameWidgetCallbackForMediaWidget(nameToItemMap, media_widget),
+                    {
+                        serialize: true,
+                        values: image_list.map(item => item.name)
                     }
+                );
+            }
 
-                    // 如果进入了va_widgets分支，使用va_widgets中第一个作为media_widget的替代
-                    const actualMediaWidget = va_widgets.length > 0 ? va_widgets[0] : media_widget;
-
-                    if (image_name_widget && actualMediaWidget) {
-                        const val = urlToNameMap.get(actualMediaWidget.value) || actualMediaWidget.value
-                        image_name_widget.label = actualMediaWidget.label
-                        image_name_widget.value = val
-
-                        const currentIndex = this.widgets.indexOf(image_name_widget);
-                        if (currentIndex > 1) {
-                            this.widgets.splice(currentIndex, 1);
-                            this.widgets.splice(1, 0, image_name_widget);
-                        }
-
-                        // 如果没有进入va_widgets分支，才隐藏media_widget
-                        if (va_widgets.length === 0) {
-                            hideWidget(this, media_widget.name)
-                        }
-
-                        actualMediaWidget.options.values = image_list.map(item => item.name);
-
-                        // 对于va_widgets的情况，callback已经在上面重写过了，不需要再次重写
-                        if (va_widgets.length === 0 && media_widget) {
-                            const callback = media_widget.callback
-                            media_widget.callback = function(e) {
-                                if (typeof e == 'string') {
-                                    // 使用 Map 快速查找（O(1)）
-                                    const item = e.includes('http') ?
-                                        (urlToNameMap.has(e) ? {url: e, name: urlToNameMap.get(e)} : null) :
-                                        (nameToItemMap ? nameToItemMap.get(e) : null);
+            // 如果进入了va_widgets分支，使用va_widgets中第一个作为media_widget的替代
+            const actualMediaWidget = va_widgets.length > 0 ? va_widgets[0] : media_widget;
 
-                                    const image_url = item ? decodeURIComponent(item.url) : e;
+            if (image_name_widget && actualMediaWidget) {
+                const val = urlToNameMap.get(actualMediaWidget.value) || actualMediaWidget.value;
+                image_name_widget.label = actualMediaWidget.label;
+                image_name_widget.value = val;
 
-                                    image_name_widget.value = item ? item.name : e;
-                                    media_widget.value = image_url;
-                                    if (callback) {
-                                        callback([image_url])
-                                    }
-                                } else {
-                                    const item = e[0].split('/')
-                                    const fileName = item[item.length - 1];
-                                    image_name_widget.options.values.pop()
-                                    image_name_widget.options.values.push(fileName)
-                                    image_name_widget.value = fileName
-                                    image_list.push({
-                                        name: fileName,
-                                        url: e[0]
-                                    })
-                                    // 同步更新 Map
-                                    urlToNameMap.set(e[0], fileName);
-                                    if (nameToItemMap) {
-                                        nameToItemMap.set(fileName, {url: e[0], name: fileName});
-                                    }
-                                    if (callback) {
-                                        callback(e)
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    return true
+                // 调整 widget 顺序
+                const currentIndex = this.widgets.indexOf(image_name_widget);
+                if (currentIndex > 1) {
+                    this.widgets.splice(currentIndex, 1);
+                    this.widgets.splice(1, 0, image_name_widget);
                 }
-                await getData()
-
-
-                async function applyWorkflowImageSettings(workflowParams, image_list, media_widget, image_name_widget, currentNodeId) {
-                    if (workflowParams && workflowParams.nodes) {
-                        // 先获取配置，然后将 mediaNodeList 和配置的 keys 合并
-                        const config = await fetchMediaConfigWithCache();
-                        const allMediaNodeTypes = new Set(mediaNodeList);
-                        if (config) {
-                            // 将配置中的 keys 添加到集合中
-                            for (const key of Object.keys(config)) {
-                                allMediaNodeTypes.add(key);
-                            }
-                        }
-
-                        // 使用同步的 includes 查找匹配的节点（完全避免循环中的异步）
-                        const imageNode = workflowParams.nodes.find(item =>
-                            item.id === currentNodeId && allMediaNodeTypes.has(item.type)
-                        )
 
-                        if (imageNode && imageNode.widgets_values && imageNode.widgets_values[0]) {
-                            const item = imageNode.widgets_values[0].split('/')
-                            image_list.push({
-                                name: item[item.length - 1],
-                                url: imageNode.widgets_values[0]
-                            })
-                            media_widget.value = imageNode.widgets_values[0]
+                // 如果没有进入va_widgets分支，才隐藏media_widget
+                if (va_widgets.length === 0) {
+                    hideWidget(this, media_widget.name);
+                }
 
-                            media_widget.options.values = image_list.map(item => item.url)
-                            image_name_widget.options.values = image_list.map(item => item.name)
-                            media_widget.callback(imageNode.widgets_values[0])
-                        }
-                    }
+                // 更新 widget 选项列表
+                updateWidgetsOptions([actualMediaWidget], image_list);
+
+                // 对于va_widgets的情况，callback已经在上面重写过了，不需要再次重写
+                if (va_widgets.length === 0 && media_widget) {
+                    const callback = media_widget.callback;
+                    media_widget.callback = createMediaWidgetCallback(
+                        media_widget,
+                        urlToNameMap,
+                        nameToItemMap,
+                        image_list,
+                        image_name_widget,
+                        actualMediaWidget,
+                        callback
+                    );
                 }
+            }
 
-                // 如果有存储的工作流数据，应用图像设置
+            // 应用工作流设置
+            const workflowData = window.currentWorkflowData || workflowParams;
+            if (workflowData) {
+                await applyWorkflowImageSettings(workflowData, image_list, media_widget, image_name_widget, this.id, va_widgets, actualMediaWidget);
                 if (window.currentWorkflowData) {
-                    await applyWorkflowImageSettings(window.currentWorkflowData, image_list, media_widget, image_name_widget, this.id);
-                    // 清除存储的数据，避免重复处理
                     delete window.currentWorkflowData;
-                } else {
-                    // 原有的调用
-                    await applyWorkflowImageSettings(workflowParams, image_list, media_widget, image_name_widget, this.id);
                 }
-                //在这里发个postmessage
-                window.parent.postMessage({
-                    type: 'functionResult',
-                    method: 'hookLoadImageCompleted',
-                    params: {}
-                }, '*');
+            } else {
+                await applyWorkflowImageSettings(workflowParams, image_list, media_widget, image_name_widget, this.id, va_widgets, actualMediaWidget);
             }
+
+            // 发送完成消息
+            window.parent.postMessage({
+                type: 'functionResult',
+                method: 'hookLoadImageCompleted',
+                params: {}
+            }, '*');
         }
     }
 })

bizydraft/static/js/hookLoadModel.js

@@ -29,9 +29,9 @@ app.registerExtension({
 
         // 异步获取节点配置
         const onNodeCreated = nodeType.prototype.onNodeCreated;
-        nodeType.prototype.onNodeCreated = async function() {
-            const nodeConfig = await getNodeConfig(nodeData.name);
-            if (nodeConfig) {
+        const nodeConfig = await getNodeConfig(nodeData.name);
+        if (nodeConfig) {
+            nodeType.prototype.onNodeCreated = function() {
                 try {
                     const inputs = nodeConfig.config.inputs;
                     const inputKeys = Object.keys(inputs);
@@ -140,5 +140,51 @@ app.registerExtension({
         if (nodeConfig) {
             setupNodeMouseBehavior(node, nodeConfig);
         }
+    },
+    async setup() {
+        const app = document.querySelector('#vue-app').__vue_app__
+        const pinia = app.config.globalProperties.$pinia
+        const settingStore = pinia._s.get('setting')
+        await settingStore.set('Comfy.Workflow.ShowMissingModelsWarning', false)
+
+
+
+
+        // 获取 toastStore
+        const toastStore = pinia._s.get('toast');
+
+        // 保存原始的 add 方法
+        const originalAdd = toastStore.add;
+
+        // 重写 add 方法，添加过滤逻辑
+        toastStore.add = function(message) {
+            const detail = (message.detail || '').toLowerCase();
+            const summary = (message.summary || '').toLowerCase();
+            const text = `${summary} ${detail}`;
+
+            // 检查是否包含阻止的关键词
+            const blockedKeywords = [
+                'missing dependencies',
+                'comfyui logs',
+                'comfyullogs',
+                'refer to the comfyui',
+                'you may be missing'
+            ];
+
+            const shouldBlock = blockedKeywords.some(keyword =>
+                text.includes(keyword.toLowerCase())
+            );
+
+            // 如果包含阻止的关键词，则不添加 toast
+            if (shouldBlock) {
+                console.log('Blocked toast:', message);
+                return;
+            }
+
+            // 否则正常添加
+            return originalAdd.call(this, message);
+        };
+
+        console.log('Toast blocker activated!');
     }
 })

bizydraft/static/js/imageUpload.js

@@ -0,0 +1,146 @@
+import { app } from "../../../scripts/app.js";
+
+// 简单的链式callback实现
+function chainCallback(originalCallback, newCallback) {
+  return function (...args) {
+    if (originalCallback) {
+      originalCallback.apply(this, args);
+    }
+    newCallback.apply(this, args);
+  };
+}
+
+// 统一的函数：初始化动态输入相关的 widgets
+function initializeDynamicInputs(node) {
+  // 只处理目标节点类型
+  if (
+    node.type !== "BizyAir_Seedream4_5" &&
+    node.type !== "BizyAir_NanoBananaPro" &&
+    node.type !== "BizyAir_NanoBananaProOfficial"
+  ) {
+    return;
+  }
+
+  node._type = "IMAGE";
+
+  if (!node.inputs) {
+    node.inputs = [];
+  }
+
+  // 先检查是否存在 inputcount widget
+  let inputCountWidget = node.widgets?.find(
+    (w) => w.name === "inputcount"
+  );
+
+  // 如果不存在，先创建 inputcount widget（在按钮之前创建，确保显示顺序）
+  if (!inputCountWidget) {
+    // 计算当前 IMAGE 类型输入数量
+    const currentImageInputs = node.inputs.filter(
+      (input) => input.type === node._type
+    ).length;
+    // 创建 inputcount widget，默认值为当前输入数量或1
+    // 使用 precision: 0 确保是整数类型
+    inputCountWidget = node.addWidget(
+      "number",
+      "inputcount",
+      currentImageInputs || 1,
+      null,
+      {
+        min: 1,
+        max: 10,
+        step: 10, // 旧参数（兼容性），是 step2 的 10 倍
+        step2: 1, // 新参数，实际的步长
+        precision: 0, // 设置为 0 表示整数
+      }
+    );
+  }
+
+  // 检查是否已经存在 "Update inputs" 按钮，避免重复添加
+  const updateButton = node.widgets?.find(
+    (w) => w.name === "Update inputs"
+  );
+  if (updateButton) {
+    return; // 已经存在，不需要重复添加
+  }
+
+  // 然后添加 "Update inputs" 按钮（会在 inputcount 之后显示）
+  node.addWidget("button", "Update inputs", null, () => {
+    if (!node.inputs) {
+      node.inputs = [];
+    }
+
+    // 查找 inputcount widget
+    const inputCountWidget = node.widgets?.find(
+      (w) => w.name === "inputcount"
+    );
+
+    // 如果仍然找不到，创建它
+    if (!inputCountWidget) {
+      const currentImageInputs = node.inputs.filter(
+        (input) => input.type === node._type
+      ).length;
+      node.addWidget(
+        "number",
+        "inputcount",
+        currentImageInputs || 1,
+        null,
+        {
+          min: 1,
+          max: 10,
+          step: 10, // 旧参数（兼容性），是 step2 的 10 倍
+          step2: 1, // 新参数，实际的步长
+          precision: 0, // 设置为 0 表示整数
+        }
+      );
+      return;
+    }
+
+    const target_number_of_inputs = inputCountWidget.value || 1;
+    const num_inputs = node.inputs.filter(
+      (input) => input.type === node._type
+    ).length;
+
+    if (target_number_of_inputs === num_inputs) {
+      return; // already set, do nothing
+    }
+
+    if (target_number_of_inputs < num_inputs) {
+      const inputs_to_remove = num_inputs - target_number_of_inputs;
+      for (let i = 0; i < inputs_to_remove; i++) {
+        node.removeInput(node.inputs.length - 1);
+      }
+    } else {
+      for (let i = num_inputs + 1; i <= target_number_of_inputs; ++i) {
+        node.addInput(`image_${i}`, node._type, { shape: 7 });
+      }
+    }
+  });
+}
+
+app.registerExtension({
+  name: "bizyair.dynamicImageInputs",
+  async beforeRegisterNodeDef(nodeType, nodeData, app) {
+    // 只处理目标节点类型
+    if (
+      nodeData.name !== "BizyAir_Seedream4_5" &&
+      nodeData.name !== "BizyAir_NanoBananaPro" &&
+      nodeData.name !== "BizyAir_NanoBananaProOfficial"
+    ) {
+      return;
+    }
+
+    // 使用 chainCallback 设置 onConfigure，确保在节点配置完成后也初始化 widgets
+    const originalOnConfigure = nodeType.prototype.onConfigure;
+    nodeType.prototype.onConfigure = chainCallback(
+      originalOnConfigure,
+      function (info) {
+        // 在 configure 完成后初始化 widgets
+        initializeDynamicInputs(this);
+      }
+    );
+  },
+  nodeCreated(node) {
+    // 在节点创建时也初始化 widgets（用于首次创建节点时）
+    initializeDynamicInputs(node);
+  },
+});