Macros 2.0 - `list`-supported Macros Autocomplete Improvements (#5135) * fix(macros): prevent list-arg macros from accepting scoped content List-arg macros now correctly reject scoped content since they only accept arbitrary inline arguments. Updated validation logic in autocomplete, scope detection, and CST walker to check for `list === null` before allowing scopes. Also improved list item hint display to show total count when typing additional items. * feat(macros): display min/max constraints for list arguments in autocomplete hints Add visual indication of list argument constraints by showing min/max values in autocomplete hints. List items now display "(list, min: X, max: Y)" or "(variable-length list)" when no constraints exist. Includes new CSS styling for smaller, dimmed hint text. * feat(macros): validate list argument min/max constraints and improve warning display Add validation for list argument constraints (min/max) with specific error messages when too few or too many list items are provided. Continue highlighting current argument position even when warnings are present (except where semantically invalid), allowing users to navigate back to valid arguments while seeing "too many arguments" warnings.

953d9f34cbdc33ba062b01baa90dfb7f4c1bce45

Wolfsblvt <wolfsblvt@gmail.com>

Signed

public/css/macros.css+5 -0 Viewed

     font-size: 0.8em;
+}
+.macro-ac-arg-hint .macro-ac-arg-hint-small {
+    font-size: 0.85em;
+    opacity: 0.8;
+}
 .macro-ac-hint-type {
     font-family: var(--monoFontFamily);
     font-size: 0.85em;

public/scripts/autocomplete/EnhancedMacroAutoCompleteOption.js+44 -7 Viewed

         // Determine current argument index for highlighting
         const currentArgIndex = this.#context?.currentArgIndex ?? -1;
-        // Render argument hint banner if we're typing an argument (and no warning)
+        // For most warnings, we can still highlight which argument we are currently at.
-        if (!warning && currentArgIndex >= 0) {
+        // This even goes for "too many arguments" when navigating the cursor back to
+        // a valid argument.
+        // Extend this in the future, if *some* warnings don't make sense to still highlight args.
+        const hightlightArgsHint = currentArgIndex >= 0;
+        // Render argument hint banner if we're typing an argument
+        if (hightlightArgsHint && currentArgIndex >= 0) {
             const hint = this.#renderArgumentHint();
             if (hint) frag.append(hint);
+        }
         // Reuse MacroBrowser's renderMacroDetails with options
-        // Don't highlight args if there's a warning
+        const details = renderMacroDetails(this.#macro, { currentArgIndex: hightlightArgsHint ? currentArgIndex : -1 });
-        const details = renderMacroDetails(this.#macro, { currentArgIndex: warning ? -1 : currentArgIndex });
         // Add class for autocomplete-specific styling overrides
         details.classList.add('macro-ac-details');

         // Space-separated syntax provides 1 arg; with scoped content you can provide a 2nd arg
         // So it's valid for macros with maxArgs <= 2 (or with list args)
         if (this.#context.hasSpaceArgContent) {
-            if (maxArgs === 0) {
+            if (maxArgs === 0 && !hasList) {
                 return 'This macro does not accept any arguments. Remove the space or use a different macro.';
+            }
             if (!hasList && maxArgs > 2) {

+        }
         // Check if trying to add args to a no-arg macro via ::
-        if (this.#context.separatorCount > 0 && maxArgs === 0) {
+        // List-arg macros can accept args even if maxArgs === 0
+        if (this.#context.separatorCount > 0 && maxArgs === 0 && !hasList) {
             return 'This macro does not accept any arguments.';
+        }
+        // Check list bounds (min/max) if the macro has a list with constraints
+        if (hasList && typeof this.#macro.list === 'object') {
+            const listItemCount = Math.max(0, argCount - maxArgs);
+            const listMin = this.#macro.list.min ?? 0;
+            const listMax = this.#macro.list.max ?? null;
+            if (listItemCount < listMin) {
+                const needed = listMin - listItemCount;
+                return `Not enough list items yet: this macro requires at least ${listMin} item${listMin === 1 ? '' : 's'}, but only ${listItemCount} provided. Add ${needed} more.`;
+            }
+            if (listMax !== null && listItemCount > listMax) {
+                return `Too many list items: this macro accepts at most ${listMax} item${listMax === 1 ? '' : 's'}, but ${listItemCount} provided.`;
+            }
+        }
         return null;
+    }

         if (isListArg) {
             // List argument hint
             const listIndex = argIndex - this.#macro.maxArgs + 1;
+            const totalListItems = this.#context.args.length - this.#macro.maxArgs;
             const text = document.createElement('span');
-            text.innerHTML = `<strong>List item ${listIndex}</strong>`;
+            text.innerHTML = `<strong>List item ${listIndex}</strong>${(listIndex < totalListItems ? ` (of ${totalListItems})` : '')}`;
+            const listInfo = document.createElement('span');
+            listInfo.classList.add('macro-ac-arg-hint-small');
+            const minMax = [];
+            if (this.#macro.list.min > 0) minMax.push(`min: ${this.#macro.list.min}`);
+            if (this.#macro.list.max !== null) minMax.push(`max: ${this.#macro.list.max}`);
+            if (minMax.length > 0) {
+                listInfo.textContent = ` (list, ${minMax.join(', ')})`;
+            } else {
+                listInfo.textContent = ' (variable-length list)';
+            }
+            text.appendChild(listInfo);
             hint.append(text);
         } else {
             // Unnamed argument hint (required or optional)

public/scripts/autocomplete/MacroAutoCompleteHelper.js+2 -1 Viewed

+            }
         } else {
             // Check if macro can accept scoped content
+            // List-arg macros don't support scopes - they accept arbitrary inline args instead
             const macroDef = macroSystem.registry.getPrimaryMacro(name);
-            if (macroDef && macroDef.maxArgs > 0) {
+            if (macroDef && macroDef.maxArgs > 0 && macroDef.list === null) {
                 // Try to find closing }} to extract trailing whitespace
                 let paddingAfter = '';
                 const afterMatch = text.slice(match.index + match[0].length);

public/scripts/macros/engine/MacroCstWalker.js+5 -7 Viewed

         const argumentNodes = /** @type {CstNode[]} */ (argumentsNode?.children?.argument || []);
         const currentArgCount = argumentNodes.length;
-        // Check if adding 1 more argument (scoped content) would be valid
+        // List-arg macros don't support scoped content - they accept arbitrary inline args instead
-        const newArgCount = currentArgCount + 1;
-        // Macro must accept at least newArgCount arguments
-        // For macros with list args, they can accept unlimited after maxArgs
         if (def.list) {
-            // With list: valid if newArgCount >= minArgs (list can absorb extra)
+            return false;
-            return newArgCount >= def.minArgs;
+        }
+        // Check if adding 1 more argument (scoped content) would be valid
+        const newArgCount = currentArgCount + 1;
         // Without list: newArgCount must be between minArgs and maxArgs
         return newArgCount >= def.minArgs && newArgCount <= def.maxArgs;
+    }