bizydraft 0.2.82.dev20251209023307__py3-none-any.whl → 0.2.83__py3-none-any.whl

bizydraft/oss_utils.py

@@ -312,17 +312,9 @@ async def upload_mask(request):
         if "http" in original_subfolder:
             # subfolder 中包含 URL 基础路径
             original_subfolder = original_subfolder[original_subfolder.find("http") :]
-            original_subfolder = unquote(original_subfolder)
-            if "https:/" in original_subfolder and not original_subfolder.startswith(
-                "https://"
-            ):
-                original_subfolder = original_subfolder.replace(
-                    "https:/", "https://", 1
-                )
-            if "http:/" in original_subfolder and not original_subfolder.startswith(
-                "http://"
-            ):
-                original_subfolder = original_subfolder.replace("http:/", "http://", 1)
+            original_subfolder = unquote(original_subfolder).replace(
+                "https:/", "https://"
+            )
             original_url = f"{original_subfolder}/{original_filename}"
         elif original_filename.startswith(http_prefix_options):
             # filename 本身就是完整 URL

bizydraft/static/js/clipspaceToOss.js

@@ -62,7 +62,7 @@ function replaceClipspaceUrl(urlString) {
     });
 
     const originalSetAttribute = HTMLImageElement.prototype.setAttribute;
-    HTMLImageElement.prototype.setAttribute = function (name, value) {
+    HTMLImageElement.prototype.setAttribute = function(name, value) {
         if (name === 'src') {
             const modifiedValue = replaceClipspaceUrl(value);
             return originalSetAttribute.call(this, name, modifiedValue);
@@ -75,11 +75,11 @@ function replaceClipspaceUrl(urlString) {
 // 拦截上传响应，保存映射并篡改返回值
 // ═══════════════════════════════════════════════════════════════════════════
 const originalFetchApi = api.fetchApi;
-api.fetchApi = async function (url, options) {
+api.fetchApi = async function(url, options) {
     const response = await originalFetchApi.call(this, url, options);
 
     const isUploadApi = url === '/upload/image' || url === '/upload/mask'
-        || url === '/api/upload/image' || url === '/api/upload/mask';
+                     || url === '/api/upload/image' || url === '/api/upload/mask';
 
     if (!isUploadApi || !response.ok) {
         return response;
@@ -89,7 +89,7 @@ api.fetchApi = async function (url, options) {
 
         // 检查是否是 OSS 上传响应
         const isOssUpload = data.subfolder?.includes('http://') || data.subfolder?.includes('https://')
-            || data.name?.startsWith('http://') || data.name?.startsWith('https://');
+                         || data.name?.startsWith('http://') || data.name?.startsWith('https://');
 
         if (!isOssUpload) return response;
 
@@ -118,7 +118,7 @@ api.fetchApi = async function (url, options) {
                         finalUrl = ossUrl;
 
                         [`clipspace-mask-${baseId}.png`, `clipspace-paint-${baseId}.png`,
-                        `clipspace-painted-${baseId}.png`, `clipspace-painted-masked-${baseId}.png`
+                         `clipspace-painted-${baseId}.png`, `clipspace-painted-masked-${baseId}.png`
                         ].forEach(v => window.CLIPSPACE_TO_OSS_MAP[v] = ossUrl);
 
                     } else {
@@ -204,29 +204,16 @@ function convertClipspacePathsInPrompt(prompt) {
 
         for (const [inputKey, inputValue] of Object.entries(node.inputs)) {
             if (typeof inputValue === 'string' && inputValue.includes('clipspace')) {
-                // 1) 特殊情况：clipspace/https://... 或 clipspace/http://...
-                const ossUrlMatch = inputValue.match(/clipspace\/(https?:\/\/[^\s]+)/i);
-                if (ossUrlMatch) {
-                    // 移除可能的 [input] 或 [output] 后缀
-                    let cleanUrl = ossUrlMatch[1].replace(/\s*\[(input|output)\]$/i, '');
-                    node.inputs[inputKey] = cleanUrl;
-
-                    if (inputKey === 'image' && node.inputs['image_name']) {
-                        node.inputs['image_name'] = cleanUrl.split('/').pop();
-                    }
-                } else {
-                    // 2) 常规情况：clipspace/xxx.png
-                    const match = inputValue.match(/clipspace\/([\w-]+\.(?:png|jpg|jpeg|webp|gif))/i);
-                    if (match) {
-                        const filename = match[1];
-                        const ossUrl = findOssUrl(filename);
+                const match = inputValue.match(/clipspace\/([\w-]+\.(?:png|jpg|jpeg|webp|gif))/i);
+                if (match) {
+                    const filename = match[1];
+                    const ossUrl = findOssUrl(filename);
 
-                        if (ossUrl) {
-                            node.inputs[inputKey] = ossUrl;
+                    if (ossUrl) {
+                        node.inputs[inputKey] = ossUrl;
 
-                            if (inputKey === 'image' && node.inputs['image_name']) {
-                                node.inputs['image_name'] = ossUrl.split('/').pop();
-                            }
+                        if (inputKey === 'image' && node.inputs['image_name']) {
+                            node.inputs['image_name'] = ossUrl.split('/').pop();
                         }
                     }
                 }
@@ -245,7 +232,7 @@ function interceptPasteFromClipspace() {
     if (!ComfyApp || !ComfyApp.pasteFromClipspace) return;
 
     const originalPasteFromClipspace = ComfyApp.pasteFromClipspace;
-    ComfyApp.pasteFromClipspace = function (node) {
+    ComfyApp.pasteFromClipspace = function(node) {
         // 调用原始函数
         originalPasteFromClipspace.call(this, node);
 
@@ -257,23 +244,14 @@ function interceptPasteFromClipspace() {
 
                 // 1) 如果是 clipspace 路径格式，替换为 OSS URL
                 if (value.includes('clipspace/')) {
-                    // 1.1) 特殊情况：clipspace/https://... 或 clipspace/http://...
-                    //      这种情况是 OSS URL 被错误地加了 clipspace/ 前缀，直接移除前缀
-                    const ossUrlMatch = value.match(/clipspace\/(https?:\/\/[^\s]+)/i);
-                    if (ossUrlMatch) {
-                        // 移除可能的 [input] 或 [output] 后缀
-                        let cleanUrl = ossUrlMatch[1].replace(/\s*\[(input|output)\]$/i, '');
-                        imageWidget.value = cleanUrl;
-                    } else {
-                        // 1.2) 常规情况：clipspace/xxx.png，提取文件名并查找映射
-                        const match = value.match(/clipspace\/([\w-]+\.(?:png|jpg|jpeg|webp|gif))(\s\[(input|output)\])?/i);
-                        if (match) {
-                            const filename = match[1];
-                            const ossUrl = findOssUrl(filename);
-
-                            if (ossUrl) {
-                                imageWidget.value = ossUrl;
-                            }
+                    // 提取文件名
+                    const match = value.match(/clipspace\/([\w-]+\.(?:png|jpg|jpeg|webp|gif))(\s\[(input|output)\])?/i);
+                    if (match) {
+                        const filename = match[1];
+                        const ossUrl = findOssUrl(filename);
+
+                        if (ossUrl) {
+                            imageWidget.value = ossUrl;
                         }
                     }
                 }
@@ -295,31 +273,22 @@ app.registerExtension({
     async setup() {
         const originalGraphToPrompt = app.graphToPrompt;
 
-        // 在构建 Prompt 之前，先清理所有 widget 的值，去掉多余的后缀和错误的 clipspace 前缀
+        // 在构建 Prompt 之前，先清理所有 widget 的值，去掉多余的后缀
         function sanitizeGraphWidgets(graph) {
             const nodes = graph?._nodes || [];
             for (const node of nodes) {
                 if (!node?.widgets) continue;
                 for (const widget of node.widgets) {
                     if (typeof widget?.value === 'string') {
-                        let value = widget.value;
-                        // 先处理 clipspace/https://... 格式
-                        if (value.includes('clipspace/')) {
-                            const ossUrlMatch = value.match(/clipspace\/(https?:\/\/[^\s]+)/i);
-                            if (ossUrlMatch) {
-                                value = ossUrlMatch[1];
-                            }
-                        }
-                        // 再移除类型后缀
-                        widget.value = stripTypeSuffix(value);
+                        widget.value = stripTypeSuffix(widget.value);
                     }
                 }
             }
         }
 
-        app.graphToPrompt = async function (...args) {
+        app.graphToPrompt = async function(...args) {
             // 预清理，避免 workflow.widgets_values 和 prompt 输入里包含 [input]/[output]
-            try { sanitizeGraphWidgets(app.graph); } catch (e) { }
+            try { sanitizeGraphWidgets(app.graph); } catch (e) {}
 
             const result = await originalGraphToPrompt.apply(this, args);
 

bizydraft/static/js/main.js

@@ -1,9 +1,6 @@
 // 主入口文件，导入所有模块
 import "./disableComfyWebSocket.js";
-import "./hookLoadImage.js";
+import "./hookLoadMedia.js";
 import "./postEvent.js";
 import "./handleStyle.js";
 import "./clipspaceToOss.js";
-import "./aspectRatio.js";
-import "./imageUpload.js";
-import "./limitTimeRange.js";

bizydraft/static/js/tool.js

@@ -17,9 +17,13 @@ const extMap = {
     "VHS_LoadVideo": '.mp4,.mov,.avi,.mkv,.webm,.flv,.wmv,.m4v',
 }
 export function getCookie(name) {
-    const value = `; ${document.cookie}`;
-    const parts = value.split(`; ${name}=`);
-    if (parts.length === 2) return parts.pop().split(';').shift();
+    const cookies = document.cookie.split(';');
+    for (let cookie of cookies) {
+        const [key, value] = cookie.trim().split('=');
+        if (key === name) {
+            return value;
+        }
+    }
     return null;
 }
 export const hideWidget = (node, widget_name) => {

{bizydraft-0.2.82.dev20251209023307.dist-info → bizydraft-0.2.83.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bizydraft
-Version: 0.2.82.dev20251209023307
+Version: 0.2.83
 Summary: bizydraft
 Requires-Dist: loguru
 Requires-Dist: aiohttp

{bizydraft-0.2.82.dev20251209023307.dist-info → bizydraft-0.2.83.dist-info}/RECORD

@@ -3,7 +3,7 @@ bizydraft/block_nodes.py,sha256=Lqn3oSCaGDHR2OICc8a2iRoRCVVK9v1-9MM3r-qIZgA,1092
 bizydraft/env.py,sha256=VFmGopVL2TGWA6hwxyFhIglCEcQxy6iVvL_raMNd6u4,407
 bizydraft/hijack_nodes.py,sha256=riHsp4DhU60E60bfXUl8kVqjs1QvQWmx_FsgQAdWTa4,4197
 bizydraft/hijack_routes.py,sha256=j7i9xAfaWvcu-mSoDISQyEwdERd0y-GFhvY2To7MRTU,5015
-bizydraft/oss_utils.py,sha256=_UzbS4e_MW5UynkQd2JI6edfdWxStm-Kbt6k7CvJJGA,16663
+bizydraft/oss_utils.py,sha256=IjWKFZ98KNvLw7bmFuqux5mEG36B8c9eQbQmL_gZo0M,16254
 bizydraft/patch_handlers.py,sha256=cP6gIYBYghWXI72hBbz3BbQHP1O5IvslS8iNK29MEbI,14159
 bizydraft/postload.py,sha256=XFElKcmCajT_oO7SVJJBaN04XcWro54N5HB5cSCxfvI,1308
 bizydraft/prestartup_patch.py,sha256=4FGjmRcDHELjtlQOrfTfk2Un5OS89QIqfq-gEcB9WDs,998
@@ -11,27 +11,24 @@ bizydraft/resp.py,sha256=8INvKOe5Dgai3peKfqKjrhUoYeuXWXn358w30-_cY-A,369
 bizydraft/server.py,sha256=L2zoJgOisr65IRphOyko74AdsLel59gh55peyMaUrO8,2102
 bizydraft/workflow_io.py,sha256=MYhJbpgkv8hrA5k_aolijOTrWpTtu62nzRznA4hv8JE,4298
 bizydraft/static/js/aiAppHandler.js,sha256=OQRhhoqvc8iZeCvHTtdaD2VTYBGzkeAGdCk1UMO2RZs,17525
-bizydraft/static/js/aspectRatio.js,sha256=p--C62sTd2QLywa0KpB4T0QI-n7FXv8dO_6Tkl8vtdk,27943
-bizydraft/static/js/clipspaceToOss.js,sha256=zTXYzop4Gx0k0NA1MiWUA_J4RKq75tA_wQSroBASCyg,16177
+bizydraft/static/js/clipspaceToOss.js,sha256=brfEPs71Tky5Dnc47UXNEFeFlESDE3kQvUH8ducpIew,14265
 bizydraft/static/js/disableComfyWebSocket.js,sha256=ZDOVlU3v3EvWpMRkD8s_AnO43vuWojVLLjkF2pNEVrA,1957
 bizydraft/static/js/freezeModeHandler.js,sha256=SjpHD2nYymR-E13B0YcqkA6e4WycZOVI3c48Ts9qvWE,18027
 bizydraft/static/js/handleStyle.js,sha256=GPshFVoa70UxLwFQB-kXZldVREE0cEF-BxxIM44ngkc,5436
 bizydraft/static/js/hookLoadMedia.js,sha256=EYDuitzOFvlNzM_e4IdE0-wXHQfnyCx7KrwzoxVTdr0,6363
 bizydraft/static/js/hookLoadModel.js,sha256=gY4D77DqVDzpuQZlqgqcUrL0Yho3koyR_lOHLyiqGfc,8204
-bizydraft/static/js/imageUpload.js,sha256=S7YY4jaaZq83epWyT5_s4GOCa2vC_-4MwWMg3HVHyCU,4178
-bizydraft/static/js/limitTimeRange.js,sha256=Bz-qHOfqUZk0zr8HYfuR3AzCYjUJHUvp8CdYLu0o6Ic,4619
-bizydraft/static/js/main.js,sha256=LaIbmXPOsKrXzwsQRaXE7HXXyw_q0FcXX492ik-f0F0,272
+bizydraft/static/js/main.js,sha256=-pMeAG8vkKO6yq9zXCeHI78KezGn0r9AhYm65DuZrVI,188
 bizydraft/static/js/nodeFocusHandler.js,sha256=24xXbS4Q-GjJdRqf11i-1pBo8MkOJ24F7MHFV44EG6Q,4683
 bizydraft/static/js/nodeParamsFilter.js,sha256=H7lBB0G8HNqoGhOCH1hNXqPU-rPlrFyTxg_f_JgLEMk,4168
 bizydraft/static/js/postEvent.js,sha256=_EyA71m5DwGbhHsuf1amKhpLUBxfBWZaMMxViNhuYzU,43481
 bizydraft/static/js/socket.js,sha256=VE3fTAgEfM0FZhL526Skt7OCRokOa3mzTCAjAomI_tE,2432
-bizydraft/static/js/tool.js,sha256=2Hhv2J18OaFZRWmHIlseahjd5Ot7ZVxUPb5z46YeXIo,2928
+bizydraft/static/js/tool.js,sha256=LD7rijhv_gMRsyKiL5Cz1fgUkfAlPu8j4t_BQxkMm80,2981
 bizydraft/static/js/uploadFile.js,sha256=WvglKzHMeOzDhOH3P-fLcPHxCLbKOJpo4DntoRxeJtI,4908
 bizydraft/static/js/workflow_io.js,sha256=FWAjncvWhvy-3nN_legD2fpRwgnIncpRLHU5X016a-U,5236
 bizydraft/static/js/hookLoad/configLoader.js,sha256=R1k0GKdEmv4IIxdT2F-oOI9X9I19ECe77P_1tO3XxgY,2525
 bizydraft/static/js/hookLoad/media.js,sha256=iX_zoZ0OzLAdYZ3bn5GpzpnwU-YjcBuEozQt-MwNuwk,17936
 bizydraft/static/js/hookLoad/model.js,sha256=aHvEPt9k3CcrawHSYnQYcvbtTRwIztk-XDRA3lvgXvA,9890
-bizydraft-0.2.82.dev20251209023307.dist-info/METADATA,sha256=aD-Dv6wd_rBGaWBYs62q5ts7qtZad8PV0I9dh1k_tik,180
-bizydraft-0.2.82.dev20251209023307.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bizydraft-0.2.82.dev20251209023307.dist-info/top_level.txt,sha256=XtoBq6hjZhXIM7aas4GtPDtAiKo8FdLzMABXW8qqQ8M,10
-bizydraft-0.2.82.dev20251209023307.dist-info/RECORD,,
+bizydraft-0.2.83.dist-info/METADATA,sha256=QC6ISi0gY7fml1L4fyoaPJzj7U8L1PCnsnrnEZbhtnI,162
+bizydraft-0.2.83.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bizydraft-0.2.83.dist-info/top_level.txt,sha256=XtoBq6hjZhXIM7aas4GtPDtAiKo8FdLzMABXW8qqQ8M,10
+bizydraft-0.2.83.dist-info/RECORD,,

bizydraft/static/js/aspectRatio.js

@@ -1,751 +0,0 @@
-import { app } from "../../scripts/app.js";
-
-// Seedream 4.5 节点的宽高比和总像素限制
-const MIN_ASPECT_RATIO = 1 / 16; // 1/16
-const MAX_ASPECT_RATIO = 16; // 16
-const MIN_TOTAL_PIXELS = 2560 * 1440; // 3686400
-const MAX_TOTAL_PIXELS = 4096 * 4096; // 16777216
-
-/**
- * 验证所有约束是否满足
- * @param {number} width - 宽度
- * @param {number} height - 高度
- * @returns {boolean} 是否满足所有约束
- */
-function satisfiesAllConstraints(width, height) {
-  const totalPixels = width * height;
-  const aspectRatio = width / height;
-
-  return (
-    totalPixels >= MIN_TOTAL_PIXELS &&
-    totalPixels <= MAX_TOTAL_PIXELS &&
-    aspectRatio >= MIN_ASPECT_RATIO &&
-    aspectRatio <= MAX_ASPECT_RATIO &&
-    width >= 480 &&
-    width <= 4096 &&
-    height >= 480 &&
-    height <= 4096
-  );
-}
-
-/**
- * 计算给定宽度时，高度的合法范围
- * @param {number} width - 宽度
- * @returns {{min: number, max: number}} 高度的最小值和最大值
- */
-function calculateHeightRange(width) {
-  // 来自总像素的限制
-  const minHeightByPixel = MIN_TOTAL_PIXELS / width;
-  const maxHeightByPixel = MAX_TOTAL_PIXELS / width;
-
-  // 来自宽高比的限制
-  // width/height <= 16 => height >= width/16
-  // width/height >= 1/16 => height <= width*16
-  const minHeightByRatio = width / MAX_ASPECT_RATIO;
-  const maxHeightByRatio = width * MAX_ASPECT_RATIO;
-
-  // 取交集：下限取最大值（最严格），上限取最小值（最严格）
-  const minHeight = Math.max(
-    Math.max(minHeightByPixel, minHeightByRatio),
-    480 // 单边最小值
-  );
-  const maxHeight = Math.min(
-    Math.min(maxHeightByPixel, maxHeightByRatio),
-    4096 // 单边最大值
-  );
-
-  return { min: minHeight, max: maxHeight };
-}
-
-/**
- * 计算给定高度时，宽度的合法范围
- * @param {number} height - 高度
- * @returns {{min: number, max: number}} 宽度的最小值和最大值
- */
-function calculateWidthRange(height) {
-  // 来自总像素的限制
-  const minWidthByPixel = MIN_TOTAL_PIXELS / height;
-  const maxWidthByPixel = MAX_TOTAL_PIXELS / height;
-
-  // 来自宽高比的限制
-  // width/height >= 1/16 => width >= height/16
-  // width/height <= 16 => width <= height*16
-  const minWidthByRatio = height * MIN_ASPECT_RATIO;
-  const maxWidthByRatio = height * MAX_ASPECT_RATIO;
-
-  // 取交集
-  const minWidth = Math.max(Math.max(minWidthByPixel, minWidthByRatio), 480);
-  const maxWidth = Math.min(Math.min(maxWidthByPixel, maxWidthByRatio), 4096);
-
-  return { min: minWidth, max: maxWidth };
-}
-
-/**
- * 根据改变的维度和当前另一个维度，计算满足所有约束的新尺寸
- * 使用橡皮筋算法（Clamp Algorithm）：尽量保持原宽高比，超出范围则截断
- * @param {number} changedValue - 改变的维度值（宽或高）
- * @param {number} otherValue - 另一个维度的当前值
- * @param {boolean} isWidthChanged - 是否是宽度改变
- * @param {number} oldValue - 改变前的维度值（用于计算宽高比），如果未提供则使用 otherValue 作为参考
- * @returns {{width: number, height: number}} 计算后的宽高值
- */
-function calculateNewDimensions(
-  changedValue,
-  otherValue,
-  isWidthChanged,
-  oldValue = null
-) {
-  // 如果另一个值为0或无效，使用默认值
-  if (!otherValue || otherValue === 0) {
-    otherValue = changedValue;
-  }
-
-  // 第一步：先限制改变的维度本身在合法范围内
-  let newWidth, newHeight;
-  if (isWidthChanged) {
-    // 宽度改变，先限制宽度在合法范围内
-    newWidth = Math.max(480, Math.min(4096, changedValue));
-
-    // 计算高度的合法范围
-    const heightRange = calculateHeightRange(newWidth);
-
-    // 如果合法范围无效（下限大于上限），说明宽度本身不合法，需要调整宽度
-    if (heightRange.min > heightRange.max) {
-      // 宽度太极端，无法找到匹配的高度
-      // 尝试调整宽度到合理范围
-      // 计算宽度的合法范围（基于一个合理的高度值，比如2048）
-      const tempHeight = 2048;
-      const widthRange = calculateWidthRange(tempHeight);
-      newWidth = Math.max(widthRange.min, Math.min(widthRange.max, newWidth));
-
-      // 重新计算高度范围
-      const newHeightRange = calculateHeightRange(newWidth);
-      if (newHeightRange.min > newHeightRange.max) {
-        // 仍然无效，使用默认值
-        newWidth = 2048;
-        newHeight = 2048;
-        return { width: Math.round(newWidth), height: Math.round(newHeight) };
-      }
-    }
-
-    // 第二步：计算理想高度（保持原宽高比）
-    // 如果提供了旧宽度，使用旧宽高比：idealHeight = newWidth * (oldHeight / oldWidth)
-    // 如果没有提供旧宽度，假设用户希望保持 newWidth/otherValue 的比例（即高度不变）
-    let idealHeight;
-    if (oldValue !== null && oldValue > 0 && otherValue > 0) {
-      // 使用旧宽高比计算理想高度
-      const oldRatio = oldValue / otherValue;
-      idealHeight = newWidth / oldRatio;
-    } else {
-      // 没有旧值，假设保持当前高度（即比例 = newWidth / otherValue）
-      idealHeight = otherValue;
-    }
-
-    // 第三步：将理想高度"截断"到合法范围（橡皮筋逻辑）
-    newHeight = Math.max(
-      heightRange.min,
-      Math.min(heightRange.max, idealHeight)
-    );
-    newHeight = Math.round(newHeight);
-
-    // 第四步：如果高度被截断，可能需要微调宽度以更好地满足约束
-    // 但为了保持"尽量不动a"的原则，这里只做轻微调整
-    // 重新计算宽度范围（基于调整后的高度）
-    const finalWidthRange = calculateWidthRange(newHeight);
-    newWidth = Math.max(
-      finalWidthRange.min,
-      Math.min(finalWidthRange.max, newWidth)
-    );
-    newWidth = Math.round(newWidth);
-  } else {
-    // 高度改变，先限制高度在合法范围内
-    newHeight = Math.max(480, Math.min(4096, changedValue));
-
-    // 计算宽度的合法范围
-    const widthRange = calculateWidthRange(newHeight);
-
-    // 如果合法范围无效，需要调整高度
-    if (widthRange.min > widthRange.max) {
-      const tempWidth = 2048;
-      const heightRange = calculateHeightRange(tempWidth);
-      newHeight = Math.max(
-        heightRange.min,
-        Math.min(heightRange.max, newHeight)
-      );
-
-      const newWidthRange = calculateWidthRange(newHeight);
-      if (newWidthRange.min > newWidthRange.max) {
-        newWidth = 2048;
-        newHeight = 2048;
-        return { width: Math.round(newWidth), height: Math.round(newHeight) };
-      }
-    }
-
-    // 计算理想宽度（保持原宽高比）
-    // 如果提供了旧高度，使用旧宽高比：idealWidth = newHeight * (oldWidth / oldHeight)
-    // 如果没有提供旧高度，假设用户希望保持 otherValue/newHeight 的比例（即宽度不变）
-    let idealWidth;
-    if (oldValue !== null && oldValue > 0 && otherValue > 0) {
-      // 使用旧宽高比计算理想宽度
-      const oldRatio = otherValue / oldValue;
-      idealWidth = newHeight * oldRatio;
-    } else {
-      // 没有旧值，假设保持当前宽度（即比例 = otherValue / newHeight）
-      idealWidth = otherValue;
-    }
-
-    // 将理想宽度截断到合法范围
-    newWidth = Math.max(widthRange.min, Math.min(widthRange.max, idealWidth));
-    newWidth = Math.round(newWidth);
-
-    // 微调高度
-    const finalHeightRange = calculateHeightRange(newWidth);
-    newHeight = Math.max(
-      finalHeightRange.min,
-      Math.min(finalHeightRange.max, newHeight)
-    );
-    newHeight = Math.round(newHeight);
-  }
-
-  // 最终确保在合理范围内（双重保险）
-  newWidth = Math.max(480, Math.min(4096, newWidth));
-  newHeight = Math.max(480, Math.min(4096, newHeight));
-
-  return { width: newWidth, height: newHeight };
-}
-
-/**
- * 验证并调整宽高值，确保满足所有约束（用于size切换到Custom时的验证）
- * 使用橡皮筋算法：尽量保持原宽高比，超出范围则截断
- * @param {number} width - 宽度
- * @param {number} height - 高度
- * @returns {{width: number, height: number}} 调整后的宽高
- */
-function validateAndAdjustDimensions(width, height) {
-  // 如果已经满足所有约束，直接返回
-  if (satisfiesAllConstraints(width, height)) {
-    return { width: Math.round(width), height: Math.round(height) };
-  }
-
-  // 保存原始宽高比（尽量保持）
-  const originalRatio = width / height;
-
-  // 第一步：限制单边尺寸范围（480-4096）
-  width = Math.max(480, Math.min(4096, width));
-  height = Math.max(480, Math.min(4096, height));
-
-  // 第二步：调整宽高比到合法范围（如果超出）
-  let aspectRatio = width / height;
-  if (aspectRatio < MIN_ASPECT_RATIO) {
-    // 宽高比太小，调整宽度
-    width = Math.round(height * MIN_ASPECT_RATIO);
-    width = Math.max(480, Math.min(4096, width));
-  } else if (aspectRatio > MAX_ASPECT_RATIO) {
-    // 宽高比太大，调整宽度
-    width = Math.round(height * MAX_ASPECT_RATIO);
-    width = Math.max(480, Math.min(4096, width));
-  }
-
-  // 第三步：调整总像素到合法范围（保持当前宽高比）
-  let totalPixels = width * height;
-  if (totalPixels < MIN_TOTAL_PIXELS) {
-    // 总像素太小，按比例放大
-    const scale = Math.sqrt(MIN_TOTAL_PIXELS / totalPixels);
-    const newWidth = Math.round(width * scale);
-    const newHeight = Math.round(height * scale);
-
-    // 检查放大后是否超出单边限制
-    if (newWidth <= 4096 && newHeight <= 4096) {
-      width = newWidth;
-      height = newHeight;
-    } else {
-      // 超出限制，调整到最大可能的尺寸（保持宽高比）
-      aspectRatio = width / height;
-      if (aspectRatio >= MIN_ASPECT_RATIO && aspectRatio <= MAX_ASPECT_RATIO) {
-        if (width > height) {
-          width = 4096;
-          height = Math.round(4096 / aspectRatio);
-          height = Math.max(480, Math.min(4096, height));
-        } else {
-          height = 4096;
-          width = Math.round(4096 * aspectRatio);
-          width = Math.max(480, Math.min(4096, width));
-        }
-      }
-    }
-  } else if (totalPixels > MAX_TOTAL_PIXELS) {
-    // 总像素太大，按比例缩小
-    const scale = Math.sqrt(MAX_TOTAL_PIXELS / totalPixels);
-    width = Math.round(width * scale);
-    height = Math.round(height * scale);
-  }
-
-  // 第四步：最终验证和微调（最多一次回退检查）
-  // 重新计算当前值
-  width = Math.max(480, Math.min(4096, width));
-  height = Math.max(480, Math.min(4096, height));
-  aspectRatio = width / height;
-  totalPixels = width * height;
-
-  // 如果宽高比仍然不合法，强制调整
-  if (aspectRatio < MIN_ASPECT_RATIO) {
-    width = Math.round(height * MIN_ASPECT_RATIO);
-    if (width > 4096) {
-      width = 4096;
-      height = Math.round(4096 / MIN_ASPECT_RATIO);
-      if (height > 4096) {
-        height = 4096;
-        width = Math.round(4096 * MIN_ASPECT_RATIO);
-      }
-    }
-    totalPixels = width * height;
-    if (totalPixels > MAX_TOTAL_PIXELS) {
-      const scale = Math.sqrt(MAX_TOTAL_PIXELS / totalPixels);
-      width = Math.round(width * scale);
-      height = Math.round(height * scale);
-    }
-  } else if (aspectRatio > MAX_ASPECT_RATIO) {
-    width = Math.round(height * MAX_ASPECT_RATIO);
-    if (width > 4096) {
-      width = 4096;
-      height = Math.round(4096 / MAX_ASPECT_RATIO);
-      if (height > 4096) {
-        height = 4096;
-        width = Math.round(4096 * MAX_ASPECT_RATIO);
-      }
-    }
-    totalPixels = width * height;
-    if (totalPixels > MAX_TOTAL_PIXELS) {
-      const scale = Math.sqrt(MAX_TOTAL_PIXELS / totalPixels);
-      width = Math.round(width * scale);
-      height = Math.round(height * scale);
-    }
-  }
-
-  // 最终确保在合理范围内
-  width = Math.max(480, Math.min(4096, width));
-  height = Math.max(480, Math.min(4096, height));
-
-  return { width: Math.round(width), height: Math.round(height) };
-}
-
-// 简单的链式callback实现（类似useChainCallback）
-function chainCallback(originalCallback, newCallback) {
-  return function (...args) {
-    if (originalCallback) {
-      originalCallback.apply(this, args);
-    }
-    newCallback.apply(this, args);
-  };
-}
-
-app.registerExtension({
-  name: "bizyair.seedream45.aspectRatio",
-  nodeCreated(node, app) {
-    // 只处理 Seedream 4.5 节点
-    if (node.title !== "☁️BizyAir Seedream 4.5") {
-      return;
-    }
-
-    // 延迟执行，确保widget完全初始化，并且ComfyUI的setupNodeWidgetCallbacks已经执行
-    setTimeout(() => {
-      try {
-        // 查找 width、height 和 size widget
-        const widthWidget = node.widgets?.find(
-          (w) => w.name === "custom_width"
-        );
-        const heightWidget = node.widgets?.find(
-          (w) => w.name === "custom_height"
-        );
-        const sizeWidget = node.widgets?.find((w) => w.name === "size");
-
-        if (!widthWidget || !heightWidget) {
-          console.warn(
-            "[Seedream4.5] 未找到 custom_width 或 custom_height widget"
-          );
-          return;
-        }
-
-        console.log("[Seedream4.5] 节点创建，开始设置宽高比联动", {
-          nodeId: node.id,
-          nodeType: node.type,
-          sizeWidget: sizeWidget,
-          sizeValue: sizeWidget?.value,
-          sizeType: sizeWidget?.type,
-          sizeOptions: sizeWidget?.options,
-          sizeOptionsValues: sizeWidget?.options?.values,
-          widthValue: widthWidget.value,
-          heightValue: heightWidget.value,
-          widthCallback: widthWidget.callback,
-          heightCallback: heightWidget.callback,
-        });
-
-        // 标记是否正在更新，避免循环触发
-        let isUpdating = false;
-
-        // 保存当前的 callback（可能已经被ComfyUI包装过）
-        const currentWidthCallback = widthWidget.callback;
-        const currentHeightCallback = heightWidget.callback;
-
-        // 检查 size 是否为 "Custom"，只有 Custom 模式才需要联动
-        // 实时获取size widget的值，而不是在闭包中捕获
-        const isCustomSize = () => {
-          if (!sizeWidget) {
-            console.log("[Seedream4.5] sizeWidget不存在");
-            return false;
-          }
-          const sizeValue = sizeWidget.value;
-
-          // 获取size widget的所有选项值
-          const sizeOptions = sizeWidget.options?.values || [];
-          const hasCustomOption = sizeOptions.some((opt) => {
-            const optValue = typeof opt === "string" ? opt : opt?.value || opt;
-            return (
-              optValue === "Custom" ||
-              optValue === "custom" ||
-              optValue === "CUSTOM"
-            );
-          });
-
-          // 打印sizeOptions的详细信息
-          const sizeOptionsDetails = sizeOptions.map((opt, idx) => {
-            const optValue = typeof opt === "string" ? opt : opt?.value || opt;
-            const optLabel =
-              typeof opt === "string" ? opt : opt?.label || opt?.value || opt;
-            return { index: idx, value: optValue, label: optLabel, raw: opt };
-          });
-
-          // 查找Custom选项的实际值
-          let customOptionValue = null;
-          sizeOptions.forEach((opt) => {
-            const optValue = typeof opt === "string" ? opt : opt?.value || opt;
-            const optLabel =
-              typeof opt === "string" ? opt : opt?.label || opt?.value || opt;
-            if (
-              optValue === "Custom" ||
-              optValue === "custom" ||
-              optValue === "CUSTOM" ||
-              optLabel === "Custom" ||
-              optLabel === "custom" ||
-              optLabel === "CUSTOM" ||
-              String(optValue).toLowerCase().includes("custom") ||
-              String(optLabel).toLowerCase().includes("custom")
-            ) {
-              customOptionValue = optValue;
-            }
-          });
-
-          console.log("[Seedream4.5] 检查isCustomSize", {
-            sizeValue,
-            type: typeof sizeValue,
-            sizeOptions: sizeOptions,
-            sizeOptionsDetails: sizeOptionsDetails,
-            customOptionValue: customOptionValue,
-            hasCustomOption,
-            equalsCustom:
-              sizeValue === "Custom" ||
-              sizeValue === "custom" ||
-              sizeValue === "CUSTOM" ||
-              sizeValue === customOptionValue,
-            sizeWidget: sizeWidget,
-          });
-
-          // 检查多种可能的"Custom"值
-          // 如果size widget有Custom选项，检查当前值是否等于Custom（包括找到的实际值）
-          if (hasCustomOption) {
-            const isCustom =
-              sizeValue === "Custom" ||
-              sizeValue === "custom" ||
-              sizeValue === "CUSTOM" ||
-              (customOptionValue && sizeValue === customOptionValue);
-
-            console.log("[Seedream4.5] Custom检查结果", {
-              sizeValue,
-              customOptionValue,
-              isCustom,
-              checks: {
-                equalsCustom: sizeValue === "Custom",
-                equalsLowercase: sizeValue === "custom",
-                equalsUppercase: sizeValue === "CUSTOM",
-                equalsFoundValue:
-                  customOptionValue && sizeValue === customOptionValue,
-              },
-            });
-
-            return isCustom;
-          }
-
-          // 如果没有Custom选项，但当前值不在预设选项中，也认为是Custom模式
-          // 这适用于动态选项的情况
-          const isPresetValue = sizeOptions.some((opt) => {
-            const optValue = typeof opt === "string" ? opt : opt?.value || opt;
-            return optValue === sizeValue;
-          });
-
-          return !isPresetValue;
-        };
-
-        // 处理宽度变化的函数
-        const handleWidthChange = (newValue) => {
-          const customSize = isCustomSize();
-          console.log("[Seedream4.5] handleWidthChange 被调用", {
-            newValue,
-            isCustomSize: customSize,
-            isUpdating,
-            sizeWidgetValue: sizeWidget?.value,
-            sizeWidgetExists: !!sizeWidget,
-          });
-
-          if (!customSize || isUpdating) {
-            console.log("[Seedream4.5] 跳过处理", {
-              reason: !customSize ? "size不是Custom" : "正在更新中",
-            });
-            return;
-          }
-
-          isUpdating = true;
-          try {
-            const numValue = Number(newValue);
-            if (isNaN(numValue)) {
-              return;
-            }
-
-            const currentHeight = Number(heightWidget.value) || 2048;
-            // 获取旧宽度：在回调触发时，widthWidget.value 可能还是旧值（ComfyUI通常在callback中先调用callback再更新value）
-            // 但如果已经更新了，我们使用传入的 value 作为新值，尝试从 widget.value 获取旧值
-            // 如果 widget.value 等于新值，说明已经更新了，我们无法获取真正的旧值，使用新值作为参考
-            let oldWidth = Number(widthWidget.value) || 2048;
-            if (Math.abs(oldWidth - numValue) < 0.5) {
-              // widget.value 已经等于新值，说明值已经更新
-              // 在这种情况下，我们无法获取真正的旧值，使用新值作为参考（会假设保持当前比例）
-              oldWidth = numValue;
-            }
-            // 使用新的计算函数，同时考虑总像素和宽高比约束
-            // 传入旧宽度以正确计算宽高比
-            const adjusted = calculateNewDimensions(
-              numValue,
-              currentHeight,
-              true,
-              oldWidth
-            );
-
-            console.log("[Seedream4.5] 计算完成", {
-              width: numValue,
-              currentHeight,
-              adjustedHeight: adjusted.height,
-              adjusted,
-              heightDiff: Math.abs(adjusted.height - currentHeight),
-              widthDiff: Math.abs(adjusted.width - numValue),
-              willUpdateHeight: Math.abs(adjusted.height - currentHeight) > 0.5,
-              willUpdateWidth: Math.abs(adjusted.width - numValue) > 0.5,
-            });
-
-            if (Math.abs(adjusted.height - currentHeight) > 0.5) {
-              console.log("[Seedream4.5] 更新高度", {
-                from: currentHeight,
-                to: adjusted.height,
-                beforeUpdate: heightWidget.value,
-              });
-              // 直接设置值并调用callback
-              heightWidget.value = adjusted.height;
-              console.log("[Seedream4.5] 高度值已更新", {
-                afterUpdate: heightWidget.value,
-              });
-              if (currentHeightCallback) {
-                currentHeightCallback.call(heightWidget, adjusted.height);
-                console.log("[Seedream4.5] 高度callback已调用");
-              }
-            } else {
-              console.log("[Seedream4.5] 跳过高度更新", {
-                reason: "高度差值太小",
-                currentHeight,
-                adjustedHeight: adjusted.height,
-                diff: Math.abs(adjusted.height - currentHeight),
-              });
-            }
-
-            if (Math.abs(adjusted.width - numValue) > 0.5) {
-              console.log("[Seedream4.5] 更新宽度", {
-                from: numValue,
-                to: adjusted.width,
-                beforeUpdate: widthWidget.value,
-              });
-              widthWidget.value = adjusted.width;
-              console.log("[Seedream4.5] 宽度值已更新", {
-                afterUpdate: widthWidget.value,
-              });
-              if (currentWidthCallback) {
-                currentWidthCallback.call(widthWidget, adjusted.width);
-                console.log("[Seedream4.5] 宽度callback已调用");
-              }
-            } else {
-              console.log("[Seedream4.5] 跳过宽度更新", {
-                reason: "宽度差值太小",
-                numValue,
-                adjustedWidth: adjusted.width,
-                diff: Math.abs(adjusted.width - numValue),
-              });
-            }
-
-            if (node && node.setDirtyCanvas) {
-              node.setDirtyCanvas(true, true);
-            }
-          } catch (error) {
-            console.error("[Seedream4.5] 更新宽度时出错:", error);
-          } finally {
-            isUpdating = false;
-          }
-        };
-
-        // 处理高度变化的函数
-        const handleHeightChange = (newValue) => {
-          const customSize = isCustomSize();
-          console.log("[Seedream4.5] handleHeightChange 被调用", {
-            newValue,
-            isCustomSize: customSize,
-            isUpdating,
-            sizeWidgetValue: sizeWidget?.value,
-            sizeWidgetExists: !!sizeWidget,
-          });
-
-          if (!customSize || isUpdating) {
-            console.log("[Seedream4.5] 跳过处理", {
-              reason: !customSize ? "size不是Custom" : "正在更新中",
-            });
-            return;
-          }
-
-          isUpdating = true;
-          try {
-            const numValue = Number(newValue);
-            if (isNaN(numValue)) {
-              return;
-            }
-
-            const currentWidth = Number(widthWidget.value) || 2048;
-            // 获取旧高度：类似宽度的处理
-            let oldHeight = Number(heightWidget.value) || 2048;
-            if (Math.abs(oldHeight - numValue) < 0.5) {
-              // widget.value 已经等于新值，说明值已经更新
-              // 使用新值作为参考（会假设保持当前比例）
-              oldHeight = numValue;
-            }
-            // 使用新的计算函数，同时考虑总像素和宽高比约束
-            // 传入旧高度以正确计算宽高比
-            const adjusted = calculateNewDimensions(
-              numValue,
-              currentWidth,
-              false,
-              oldHeight
-            );
-
-            console.log("[Seedream4.5] 计算完成", {
-              height: numValue,
-              currentWidth,
-              adjustedWidth: adjusted.width,
-              adjusted,
-            });
-
-            if (Math.abs(adjusted.width - currentWidth) > 0.5) {
-              console.log("[Seedream4.5] 更新宽度", {
-                from: currentWidth,
-                to: adjusted.width,
-              });
-              widthWidget.value = adjusted.width;
-              if (currentWidthCallback) {
-                currentWidthCallback.call(widthWidget, adjusted.width);
-              }
-            }
-
-            if (Math.abs(adjusted.height - numValue) > 0.5) {
-              console.log("[Seedream4.5] 更新高度", {
-                from: numValue,
-                to: adjusted.height,
-              });
-              heightWidget.value = adjusted.height;
-              if (currentHeightCallback) {
-                currentHeightCallback.call(heightWidget, adjusted.height);
-              }
-            }
-
-            if (node && node.setDirtyCanvas) {
-              node.setDirtyCanvas(true, true);
-            }
-          } catch (error) {
-            console.error("[Seedream4.5] 更新高度时出错:", error);
-          } finally {
-            isUpdating = false;
-          }
-        };
-
-        // 使用链式callback包装width widget的callback
-        widthWidget.callback = chainCallback(
-          currentWidthCallback,
-          function (value) {
-            console.log("[Seedream4.5] width callback 被调用", {
-              value,
-              widgetValue: widthWidget.value,
-            });
-            // 在回调中，value 是新值，widthWidget.value 可能还是旧值（取决于ComfyUI的实现）
-            // 为了安全，我们使用 value 作为新值，widthWidget.value 作为旧值的参考
-            handleWidthChange(value);
-          }
-        );
-
-        // 使用链式callback包装height widget的callback
-        heightWidget.callback = chainCallback(
-          currentHeightCallback,
-          function (value) {
-            console.log("[Seedream4.5] height callback 被调用", {
-              value,
-              widgetValue: heightWidget.value,
-            });
-            handleHeightChange(value);
-          }
-        );
-
-        // 监听 size widget 的变化，当切换到 Custom 时，重新验证宽高
-        if (sizeWidget) {
-          const originalSizeCallback = sizeWidget.callback;
-          sizeWidget.callback = chainCallback(
-            originalSizeCallback,
-            function (value) {
-              if (value === "Custom") {
-                const currentWidth = Number(widthWidget.value) || 2048;
-                const currentHeight = Number(heightWidget.value) || 2048;
-                const adjusted = validateAndAdjustDimensions(
-                  currentWidth,
-                  currentHeight
-                );
-
-                if (
-                  Math.abs(adjusted.width - currentWidth) > 0.5 ||
-                  Math.abs(adjusted.height - currentHeight) > 0.5
-                ) {
-                  isUpdating = true;
-                  try {
-                    widthWidget.value = adjusted.width;
-                    heightWidget.value = adjusted.height;
-                    if (currentWidthCallback) {
-                      currentWidthCallback.call(widthWidget, adjusted.width);
-                    }
-                    if (currentHeightCallback) {
-                      currentHeightCallback.call(heightWidget, adjusted.height);
-                    }
-                    if (node && node.setDirtyCanvas) {
-                      node.setDirtyCanvas(true, true);
-                    }
-                  } finally {
-                    isUpdating = false;
-                  }
-                }
-              }
-            }
-          );
-        }
-      } catch (error) {
-        console.error("[Seedream4.5] 初始化宽高比联动失败:", error);
-      }
-    }, 200); // 增加延迟，确保ComfyUI的setupNodeWidgetCallbacks已经执行
-  },
-});

bizydraft/static/js/imageUpload.js

@@ -1,146 +0,0 @@
-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);
-  },
-});

bizydraft/static/js/limitTimeRange.js

@@ -1,129 +0,0 @@
-import { app } from "../../../scripts/app.js";
-
-// 简单的链式callback实现（类似useChainCallback）
-function chainCallback(originalCallback, newCallback) {
-  return function (...args) {
-    if (originalCallback) {
-      originalCallback.apply(this, args);
-    }
-    newCallback.apply(this, args);
-  };
-}
-
-app.registerExtension({
-  name: "bizyair.hailuo.limitTimeRange",
-  nodeCreated(node, app) {
-    console.log(node.title);
-    // 只处理 BizyAir_Hailuo2_3_T2V 节点
-    if (
-      node.title !== "☁️BizyAir Hailuo2.3 Image To Video" &&
-      node.title !== "☁️BizyAir Hailuo2.3 Text To Video"
-    ) {
-      return;
-    }
-    console.log(node.title , `开始处理`);
-    // 延迟执行，确保 widget 完全初始化
-    setTimeout(() => {
-      try {
-        const resolutionWidget = node.widgets?.find(
-          (w) => w.name === "resolution"
-        );
-        const durationWidget = node.widgets?.find((w) => w.name === "duration");
-
-        if (!resolutionWidget || !durationWidget) {
-          console.warn("[Hailuo2_3_T2V] 未找到 resolution 或 duration widget");
-          return;
-        }
-
-        // 保存 duration widget 的原始选项值
-        const originalDurationValues = durationWidget.options?.values
-          ? Array.isArray(durationWidget.options.values)
-            ? [...durationWidget.options.values]
-            : typeof durationWidget.options.values === "function"
-            ? durationWidget.options.values()
-            : []
-          : [];
-
-        // 如果没有原始值，无法继续
-        if (!originalDurationValues || originalDurationValues.length === 0) {
-          console.warn("[Hailuo2_3_T2V] duration widget 没有可用的选项值");
-          return;
-        }
-
-        // 更新 duration 选项的函数
-        const updateDurationOptions = () => {
-          const resolutionValue = resolutionWidget.value;
-          // 支持 "1080p"、"1080P" 等大小写变体
-          const is1080p =
-            resolutionValue === "1080p" ||
-            resolutionValue === "1080P" ||
-            String(resolutionValue).toUpperCase() === "1080P";
-
-          // 直接修改 widget.options.values 数组
-          if (!durationWidget.options) {
-            durationWidget.options = {};
-          }
-
-          if (is1080p) {
-            // 如果是 1080p，从 values 数组中删除 10
-            if (Array.isArray(durationWidget.options.values)) {
-              // 找到 10 的索引并删除
-              const index = durationWidget.options.values.indexOf(10);
-              if (index !== -1) {
-                durationWidget.options.values.splice(index, 1);
-              }
-            } else {
-              // 如果不是数组，重新创建数组并过滤掉 10
-              durationWidget.options.values = originalDurationValues.filter(
-                (val) => val !== 10
-              );
-            }
-          } else {
-            // 如果不是 1080p，恢复原始值（包括 10）
-            durationWidget.options.values = [...originalDurationValues];
-          }
-
-          // 检查当前值是否在新的 values 中，如果不在则调整为第一个可用值
-          const currentValue = durationWidget.value;
-          const valuesArray = Array.isArray(durationWidget.options.values)
-            ? durationWidget.options.values
-            : [];
-
-          if (valuesArray.length > 0 && !valuesArray.includes(currentValue)) {
-            const newValue = valuesArray[0];
-            durationWidget.value = newValue;
-            // 触发 callback
-            if (durationWidget.callback) {
-              durationWidget.callback.call(durationWidget, newValue);
-            }
-          }
-
-          // 触发节点和画布更新，确保 UI 刷新
-          if (node.setDirtyCanvas) {
-            node.setDirtyCanvas(true, true);
-          }
-          if (node.graph && node.graph.setDirtyCanvas) {
-            node.graph.setDirtyCanvas(true, true);
-          }
-        };
-
-        // 保存原始的 resolution callback
-        const originalResolutionCallback = resolutionWidget.callback;
-
-        // 使用 chainCallback 包装 resolution callback，监听变化
-        resolutionWidget.callback = chainCallback(
-          originalResolutionCallback,
-          function (value) {
-            // 更新 duration 选项
-            updateDurationOptions();
-          }
-        );
-
-        // 初始化时执行一次，确保选项正确
-        updateDurationOptions();
-      } catch (error) {
-        console.error("[Hailuo2_3_T2V] 初始化时间范围限制失败:", error);
-      }
-    }, 200);
-  },
-});