Add WanVideo Lora Select node and related functionality. Fixes #266

- Implemented the WanVideo Lora Select node in Python with input handling for low memory loading and LORA syntax processing.
- Updated the JavaScript side to register the new node and manage its widget interactions.
- Enhanced constants files to include the new node type and its corresponding ID.
- Modified existing Lora Loader and Stacker references to accommodate the new node in various workflows and UI components.
- Added example workflow JSON for the new node to demonstrate its usage.

web/comfyui/lora_loader.js

@@ -76,7 +76,9 @@ app.registerExtension({
         
         // Standard mode - update a specific node
         const node = app.graph.getNodeById(+id);
-        if (!node || (node.comfyClass !== "Lora Loader (LoraManager)" && node.comfyClass !== "Lora Stacker (LoraManager)")) {
+        if (!node || (node.comfyClass !== "Lora Loader (LoraManager)" && 
+                node.comfyClass !== "Lora Stacker (LoraManager)" && 
+                node.comfyClass !== "WanVideo Lora Select (LoraManager)")) {
             console.warn("Node not found or not a LoraLoader:", id);
             return;
         }
@@ -87,7 +89,7 @@ app.registerExtension({
     // Helper method to update a single node's lora code
     updateNodeLoraCode(node, loraCode, mode) {
         // Update the input widget with new lora code
-        const inputWidget = node.widgets[0];
+        const inputWidget = node.inputWidget;
         if (!inputWidget) return;
         
         // Get the current lora code
@@ -182,6 +184,7 @@ app.registerExtension({
 
             // Update input widget callback
             const inputWidget = this.widgets[0];
+            this.inputWidget = inputWidget;
             inputWidget.callback = (value) => {
               if (isUpdating) return;
               isUpdating = true;

web/comfyui/lora_stacker.js

@@ -105,6 +105,7 @@ app.registerExtension({
 
                 // Update input widget callback
                 const inputWidget = this.widgets[0];
+                this.inputWidget = inputWidget;
                 inputWidget.callback = (value) => {
                     if (isUpdating) return;
                     isUpdating = true;

web/comfyui/usage_stats.js

@@ -52,7 +52,9 @@ app.registerExtension({
             // Find all Lora nodes
             const loraNodes = [];
             for (const node of workflow.nodes.values()) {
-                if (node.type === "Lora Loader (LoraManager)" || node.type === "Lora Stacker (LoraManager)") {
+                if (node.type === "Lora Loader (LoraManager)" || 
+                    node.type === "Lora Stacker (LoraManager)" || 
+                    node.type === "WanVideo Lora Select (LoraManager)") {
                     loraNodes.push({
                         node_id: node.id,
                         bgcolor: node.bgcolor || null,

web/comfyui/wanvideo_lora_select.js

@@ -0,0 +1,131 @@
+import { app } from "../../scripts/app.js";
+import { 
+    LORA_PATTERN, 
+    getActiveLorasFromNode,
+    collectActiveLorasFromChain,
+    updateConnectedTriggerWords,
+    chainCallback
+} from "./utils.js";
+import { addLorasWidget } from "./loras_widget.js";
+
+function mergeLoras(lorasText, lorasArr) {
+    const result = [];
+    let match;
+
+    // Reset pattern index before using
+    LORA_PATTERN.lastIndex = 0;
+    
+    // Parse text input and create initial entries
+    while ((match = LORA_PATTERN.exec(lorasText)) !== null) {
+        const name = match[1];
+        const modelStrength = Number(match[2]);
+        // Extract clip strength if provided, otherwise use model strength
+        const clipStrength = match[3] ? Number(match[3]) : modelStrength;
+        
+        // Find if this lora exists in the array data
+        const existingLora = lorasArr.find(l => l.name === name);
+        
+        result.push({
+            name: name,
+            // Use existing strength if available, otherwise use input strength
+            strength: existingLora ? existingLora.strength : modelStrength,
+            active: existingLora ? existingLora.active : true,
+            clipStrength: existingLora ? existingLora.clipStrength : clipStrength,
+        });
+    }
+
+    return result;
+}
+
+app.registerExtension({
+    name: "LoraManager.WanVideoLoraSelect",
+    
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        if (nodeType.comfyClass === "WanVideo Lora Select (LoraManager)") {
+            chainCallback(nodeType.prototype, "onNodeCreated", async function() {
+                // Enable widget serialization
+                this.serialize_widgets = true;
+
+                // Add optional inputs
+                this.addInput("prev_lora", 'WANVIDLORA', {
+                    "shape": 7  // 7 is the shape of the optional input
+                });
+                
+                this.addInput("blocks", 'SELECTEDBLOCKS', {
+                    "shape": 7  // 7 is the shape of the optional input
+                });
+
+                // Restore saved value if exists
+                let existingLoras = [];
+                if (this.widgets_values && this.widgets_values.length > 0) {
+                    // 0 for low_mem_load, 1 for text widget, 2 for loras widget
+                    const savedValue = this.widgets_values[2];
+                    existingLoras = savedValue || [];
+                }
+                // Merge the loras data
+                const mergedLoras = mergeLoras(this.widgets[1].value, existingLoras);
+                
+                // Add flag to prevent callback loops
+                let isUpdating = false;
+                 
+                const result = addLorasWidget(this, "loras", {
+                    defaultVal: mergedLoras  // Pass object directly
+                }, (value) => {
+                    // Prevent recursive calls
+                    if (isUpdating) return;
+                    isUpdating = true;
+                    
+                    try {
+                        // Remove loras that are not in the value array
+                        const inputWidget = this.widgets[1];
+                        const currentLoras = value.map(l => l.name);
+                        
+                        // Use the constant pattern here as well
+                        let newText = inputWidget.value.replace(LORA_PATTERN, (match, name, strength) => {
+                            return currentLoras.includes(name) ? match : '';
+                        });
+                        
+                        // Clean up multiple spaces and trim
+                        newText = newText.replace(/\s+/g, ' ').trim();
+                        
+                        inputWidget.value = newText;
+                        
+                        // Update this node's direct trigger toggles with its own active loras
+                        const activeLoraNames = new Set();
+                        value.forEach(lora => {
+                            if (lora.active) {
+                                activeLoraNames.add(lora.name);
+                            }
+                        });
+                        updateConnectedTriggerWords(this, activeLoraNames);
+                    } finally {
+                        isUpdating = false;
+                    }
+                });
+                
+                this.lorasWidget = result.widget;
+
+                // Update input widget callback
+                const inputWidget = this.widgets[1];
+                this.inputWidget = inputWidget;
+                inputWidget.callback = (value) => {
+                    if (isUpdating) return;
+                    isUpdating = true;
+                    
+                    try {
+                        const currentLoras = this.lorasWidget.value || [];
+                        const mergedLoras = mergeLoras(value, currentLoras);
+                        
+                        this.lorasWidget.value = mergedLoras;
+                        
+                        // Update this node's direct trigger toggles with its own active loras
+                        const activeLoraNames = getActiveLorasFromNode(this);
+                        updateConnectedTriggerWords(this, activeLoraNames);
+                    } finally {
+                        isUpdating = false;
+                    }
+                };
+            });
+        }
+    },
+});