Macros 2.0 - Improve Autocomplete edge cases on completing macros (#5093) * fix(autocomplete): handle nested macros in :: separator parsing Track nesting depth when parsing macro parts to avoid treating :: inside nested macros as separators. Increment depth on {{ and decrement on }}, only recognizing :: as a separator when nestedDepth is 0. * chore(autocomplete): add missing properties for non-variable macros Add `variableNameEnd` and `variableOperatorEnd` fields to track end positions of variable components in macro parsing context. * fix(autocomplete): stop macro parsing at newlines before first :: separator Prevent newlines before the first :: separator from being included in macro identifier/space-arg parsing. Track separator state and break early when encountering newlines at depth 0 before any :: is seen. Only include the last part if cursor is within its bounds to avoid extending macro context across line breaks. * fix(autocomplete): handle cursor position after closing braces in macro detection Skip closing }} when searching backwards if cursor is immediately after them, treating them as the target macro's closing braces rather than nested braces. Skip forward search entirely when cursor is after }}, using cursor position as closePos directly. * fix(autocomplete): show macro details when typing closing brace and add no-match indicator Track `isTypingClosingBrace` state when cursor is after a single `}` on standalone macros (no separators/args). Strip trailing `}` from identifier in this case. Show matching macro details when typing closing brace, same as when typing args. Add "no match" error option when typing args/closing brace but identifier doesn't match any macro. Extract `AnyMacroAutoCompleteOption` typedef for cleaner type annotations * fix(autocomplete): show variable context when typing closing brace on shorthand macros Detect `isTypingClosingBrace` state for variable shorthands (e.g., `{{.Lila}`, `{{.Lila+=4}`). Parse value before brace detection to check for trailing `}`. Show non-selectable context options (variable name, operator, value) when typing closing brace instead of operator/value suggestions. Strip trailing `}` from value when detected. Set `resultStart` to cursor position when typing closing brace to avoid replacement * fix(autocomplete): stop flag parsing at newlines and show context when typing closing brace on variable shorthands Skip newlines (not just all whitespace) between flags to prevent extending macro context across line breaks. Show variable context (name, operator, value) when typing closing brace on shorthand macros by excluding `isTypingClosingBrace` from the value-typing check. * Fix highlight of value autocomplete option * Rename permanentMatch to forceFullNameMatch --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

06b77ec94c0b9107bbe4e7e049976083b711c73b

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: 2fda8ca003acf048707ae442ef0eb7caf9dce23b

public/scripts/autocomplete/AutoComplete.js+4 -0 Viewed

      */
     updateName(item) {
         const chars = Array.from(item.dom.querySelector('.name').children);
+        if (item.forceFullNameMatch) {
+            chars.forEach(c => c.classList.toggle('matched', true));
+            return;
+        }
         switch (this.matchType) {
             case 'strict': {
                 chars.forEach((it, idx) => {

public/scripts/autocomplete/AutoCompleteOption.js+1 -0 Viewed

     /** @type {(input:string)=>boolean} */ matchProvider;
     /** @type {(input:string)=>string} */ valueProvider;
     /** @type {boolean} */ makeSelectable = false;
+    /** @type {boolean} */ forceFullNameMatch = false;
     /**
      * Offset to adjust the replacement start position.

public/scripts/autocomplete/EnhancedMacroAutoCompleteOption.js+91 -8 Viewed

  * @property {string[]} args - Array of arguments typed so far.
  * @property {number} currentArgIndex - Index of the argument being typed (-1 if on identifier).
  * @property {boolean} isTypingSeparator - Whether cursor is on a partial separator (single ':').
+ * @property {boolean} isTypingClosingBrace - Whether cursor is typing the first closing brace on a standalone macro.
  * @property {boolean} hasSpaceAfterIdentifier - Whether there's a space after the identifier (for space-separated args).
  * @property {boolean} hasSpaceArgContent - Whether there's actual content after the space (not just whitespace).
  * @property {number} separatorCount - Number of '::' separators found.

         super('value', '📝');
         this.#operatorDef = operatorDef;
         this.#currentValue = currentValue;
+        this.forceFullNameMatch = true;
+    }
     /** @returns {{ symbol: string, name: string, description: string, needsValue: boolean }} */

 export function parseMacroContext(macroText, cursorOffset) {
     let i = 0;
-    // Skip leading whitespace
+    // Skip leading whitespace (but NOT newlines - those stop macro parsing for autocomplete)
-    while (i < macroText.length && /\s/.test(macroText[i])) {
+    while (i < macroText.length && /[ \t]/.test(macroText[i])) {
         i++;
+    }

             flags.push(char);
             i++;
             flagEndPositions.push(i); // Position right after this flag
-            // Skip whitespace between flags
+            // Skip whitespace between flags (but NOT newlines - those stop macro parsing for autocomplete)
-            while (i < macroText.length && /\s/.test(macroText[i])) {
+            while (i < macroText.length && /[ \t]/.test(macroText[i])) {
                 i++;
+            }
         } else {

         const operatorNeedsValue = operatorDef?.needsValue ?? false;
         // If operator requires a value, parse the value
+        // Do this BEFORE isTypingClosingBrace detection so we can check for } in value area
+        // let valueStartPos = i;
         if (operatorNeedsValue) {
             // Skip whitespace after operator
             while (i < macroText.length && /\s/.test(macroText[i])) {
                 i++;
+            }
+            // valueStartPos = i;
             variableValue = macroText.slice(i).trimEnd();
+        }
+        // Detect if typing first closing brace on a variable shorthand
+        // This happens when operatorText is just "}" or when cursor is beyond content (after }})
+        let isTypingClosingBrace = false;
+        if (operatorText.startsWith('}') && !variableOperator) {
+            // Typing first } on a standalone variable shorthand like {{.Lila}
+            isTypingClosingBrace = true;
+        } else if (cursorOffset > macroText.length && !variableOperator) {
+            // Cursor is after }} on a standalone variable shorthand like {{.Lila}}|
+            isTypingClosingBrace = true;
+        } else if (cursorOffset > macroText.length && variableOperator) {
+            // Cursor is after }} on any operator shorthand like {{.Lila++}}| or {{.Lila+=4}}|
+            isTypingClosingBrace = true;
+        } else if (cursorOffset >= macroText.length && variableOperator && !operatorNeedsValue) {
+            // Cursor at end of complete operator (++ or --) like {{.Lila++ or {{.Lila++  (with trailing space)
+            isTypingClosingBrace = true;
+        } else if (cursorOffset >= macroText.length && !variableOperator && variableName.length > 0) {
+            // Cursor at end of standalone variable (with or without trailing whitespace) like {{.Lila or {{ .Lila
+            isTypingClosingBrace = true;
+        } else if (operatorNeedsValue && variableValue.length > 0 && variableValue.endsWith('}')) {
+            // Typing first } after a value like {{.Lila+=4}
+            isTypingClosingBrace = true;
+            // Strip the } from the value
+            variableValue = variableValue.slice(0, -1);
+        } else if (operatorNeedsValue && cursorOffset >= macroText.length && variableValue.length > 0) {
+            // Cursor at end after typing a value (including trailing whitespace) like {{.Lila+=4
+            // This means the shorthand is "complete" and ready to close
+            isTypingClosingBrace = true;
+        }
         // Determine cursor position context for autocomplete
+        // Note: isTypingClosingBrace takes precedence - if we're typing a closing brace,
+        // we don't want to show operator suggestions, just the current state
         const prefixEnd = (macroText.indexOf(variablePrefix) ?? 0) + 1;
         if (cursorOffset < prefixEnd) {
             // Cursor is before the prefix - still in flags area conceptually

         } else if (cursorOffset <= variableNameEnd) {
             // Cursor is in the variable name area (including at the end)
             isTypingVariableName = true;
-        } else if (variableName.length > 0 && !variableOperator && !hasInvalidTrailingChars) {
+        } else if (variableName.length > 0 && !variableOperator && !hasInvalidTrailingChars && !isTypingClosingBrace) {
             // Cursor is after variable name but no operator yet (and no invalid chars)
             // This includes partial operator prefixes like '+', '-', '|', '?', '>', '<'
+            // But NOT when typing a closing brace - that takes precedence
             isTypingOperator = true;
         } else if (variableName.length > 0 && variableOperator && isShortOperatorPrefix(variableOperator) && cursorOffset <= variableOperatorEnd) {
             // Short operator that could be prefix of longer one (e.g., > could become >=)

             args: [],
             currentArgIndex: -1,
             isTypingSeparator: false,
+            isTypingClosingBrace,
             hasSpaceAfterIdentifier: false,
             hasSpaceArgContent: false,
             separatorCount: 0,

     let partStart = i;
     let j = 0;
+    // Track nesting depth to skip :: inside nested macros
+    let nestedDepth = 0;
+    // Track if we've seen a :: separator - newlines before first :: should stop parsing
+    let hasSeenSeparator = false;
+    // Track if we broke early (e.g., at a newline)
+    let brokeEarly = false;
     while (j < remainingText.length) {
-        if (remainingText[j] === ':' && remainingText[j + 1] === ':') {
+        // Before the first :: separator, newlines should stop parsing
+        // This prevents text on the next line from being considered part of the identifier/space-arg
+        if (!hasSeenSeparator && nestedDepth === 0 && (remainingText[j] === '\n' || remainingText[j] === '\r')) {
+            // Stop parsing here - don't include the newline or anything after
+            brokeEarly = true;
+            break;
+        }
+        // Track nested macro braces
+        if (remainingText[j] === '{' && remainingText[j + 1] === '{') {
+            nestedDepth++;
+            currentPart += '{{';
+            j += 2;
+            continue;
+        }
+        if (remainingText[j] === '}' && remainingText[j + 1] === '}') {
+            nestedDepth = Math.max(0, nestedDepth - 1);
+            currentPart += '}}';
+            j += 2;
+            continue;
+        }
+        // Only count :: as separator when not inside nested macros
+        if (nestedDepth === 0 && remainingText[j] === ':' && remainingText[j + 1] === ':') {
             parts.push({ text: currentPart, start: partStart, end: i + j });
             separatorPositions.push({ start: i + j, end: i + j + 2 });
             currentPart = '';
             j += 2;
             partStart = i + j;
+            hasSeenSeparator = true;
         } else {
             currentPart += remainingText[j];
             j++;
+        }
+    }
-    // Push the last part
+    // Push the last part - use correct end position if we broke early.
-    parts.push({ text: currentPart, start: partStart, end: macroText.length });
+    // If we broke early (at a newline) AND cursor is past that point, don't push -
+    // this filters out text on the next line from being considered part of this macro.
+    // But if we didn't break early (cursor at end of closed macro), always push.
+    const lastPartEnd = brokeEarly ? i + j : macroText.length;
+    const shouldPushLastPart = !brokeEarly || cursorOffset <= lastPartEnd;
+    if (shouldPushLastPart) {
+        parts.push({ text: currentPart, start: partStart, end: lastPartEnd });
+    }
     // Determine if cursor is in the flags area (at or before identifier starts)
     const identifierStartPos = parts[0]?.start ?? i;

+    }
     // Clean identifier: strip trailing colons (for partial :: typing)
+    // Also strip trailing single } (for partial }} typing) - but only if no separators/args
     let cleanIdentifier = identifierOnly.replace(/:+$/, '');
+    let isTypingClosingBrace = false;
+    if (separatorPositions.length === 0 && !hasSpaceAfterIdentifier && cleanIdentifier.endsWith('}')) {
+        // Typing first closing brace on a standalone macro like {{char}
+        cleanIdentifier = cleanIdentifier.slice(0, -1);
+        isTypingClosingBrace = true;
+    }
     // Build args array - include space-separated arg if present
     // Trim args like the macro engine does

         args,
         currentArgIndex,
         isTypingSeparator,
+        isTypingClosingBrace,
         hasSpaceAfterIdentifier,
         hasSpaceArgContent: spaceArgText.length > 0,
         separatorCount: separatorPositions.length,

         isVariableShorthand: false,
         variablePrefix: null,
         variableName: '',
+        variableNameEnd: null,
         variableOperator: null,
+        variableOperatorEnd: null,
         variableValue: '',
         isTypingVariableName: false,
         isTypingOperator: false,

public/scripts/autocomplete/MacroAutoCompleteHelper.js+118 -27 Viewed

  * @property {UnclosedScope[]|null} [unclosedScopes=null] - Pre-computed unclosed scopes
  */
+/** @typedef {(EnhancedMacroAutoCompleteOption|MacroFlagAutoCompleteOption|MacroClosingTagAutoCompleteOption|VariableShorthandAutoCompleteOption|VariableNameAutoCompleteOption|VariableOperatorAutoCompleteOption|VariableValueContextAutoCompleteOption|SimpleAutoCompleteOption)} AnyMacroAutoCompleteOption */
 /**
  * Finds unclosed scoped macros in the text up to cursor position.
  * Uses the MacroParser and MacroCstWalker for accurate analysis.

  * @param {Object} [opts] - Optional configuration.
  * @param {boolean} [opts.forIfCondition=false] - If true, options are for {{if}} condition (closes with }}).
  * @param {string} [opts.paddingAfter=''] - Whitespace to add before closing }}.
- * @returns {(EnhancedMacroAutoCompleteOption|MacroFlagAutoCompleteOption|MacroClosingTagAutoCompleteOption|VariableShorthandAutoCompleteOption|VariableNameAutoCompleteOption|VariableOperatorAutoCompleteOption)[]}
+ * @returns {AnyMacroAutoCompleteOption[]}
  */
 export function buildVariableShorthandOptions(context, opts = {}) {
     const { forIfCondition = false, paddingAfter = '' } = opts;
-    /** @type {(VariableShorthandAutoCompleteOption|VariableNameAutoCompleteOption|VariableOperatorAutoCompleteOption|VariableValueContextAutoCompleteOption)[]} */
+    /** @type {AnyMacroAutoCompleteOption[]} */
     const options = [];
     const isLocal = context.variablePrefix === '.';

     // If typing value (after = or +=), no autocomplete needed - freeform text
     // But we show the current context for reference (greyed out, non-selectable)
-    if (context.isTypingValue && !context.isTypingOperator) {
+    if (context.isTypingValue && !context.isTypingOperator && !context.isTypingClosingBrace) {
         // Show the current variable name as context (non-selectable)
         const varNameOption = new VariableNameAutoCompleteOption(context.variableName, scope, false);
         varNameOption.valueProvider = () => ''; // Context only

+        }
+    }
+    // If typing closing brace on a variable shorthand (without operator), show the current state
+    // This handles cases like {{.Lila} or {{.Lila}}| where we want to show what was typed
+    if (context.isTypingClosingBrace && !context.isOperatorComplete && !context.isTypingOperator && !context.isTypingValue) {
+        // Show the current variable name as context (non-selectable)
+        const varNameOption = new VariableNameAutoCompleteOption(context.variableName, scope, false);
+        varNameOption.valueProvider = () => ''; // Context only
+        varNameOption.makeSelectable = false;
+        varNameOption.sortPriority = 2;
+        varNameOption.matchProvider = () => true; // Always show
+        options.push(varNameOption);
+    }
+    // If typing closing brace after a value operator (like {{.Lila+=4}} or {{.Lila+=4}),
+    // show the full context (variable + operator + value)
+    if (context.isTypingClosingBrace && context.variableOperator && context.isTypingValue) {
+        // Show the current variable name as context (non-selectable)
+        const varNameOption = new VariableNameAutoCompleteOption(context.variableName, scope, false);
+        varNameOption.valueProvider = () => ''; // Context only
+        varNameOption.makeSelectable = false;
+        varNameOption.sortPriority = 2;
+        varNameOption.matchProvider = () => true; // Always show
+        options.push(varNameOption);
+        // Show the operator that was used (non-selectable)
+        const opDef = VariableOperatorDefinitions.get(context.variableOperator);
+        if (opDef) {
+            const opOption = new VariableOperatorAutoCompleteOption(opDef);
+            opOption.valueProvider = () => ''; // Already typed
+            opOption.makeSelectable = false;
+            opOption.sortPriority = 3;
+            opOption.matchProvider = () => true; // Always show
+            options.push(opOption);
+            // Show value context info (non-selectable)
+            const valueOption = new VariableValueContextAutoCompleteOption(opDef, context.variableValue);
+            valueOption.valueProvider = () => ''; // Context only
+            valueOption.makeSelectable = false;
+            valueOption.sortPriority = 4;
+            valueOption.matchProvider = () => true; // Always show
+            options.push(valueOption);
+        }
+    }
     return options;
+}

  * When typing arguments (after ::), prioritizes the exact macro match.
  * @param {MacroAutoCompleteContext} context
  * @param {string} [textUpToCursor] - Full document text up to cursor, for unclosed scope detection.
- * @returns {(EnhancedMacroAutoCompleteOption|MacroFlagAutoCompleteOption|MacroClosingTagAutoCompleteOption|VariableShorthandAutoCompleteOption|VariableNameAutoCompleteOption|VariableOperatorAutoCompleteOption)[]}
+ * @returns {AnyMacroAutoCompleteOption[]}
  */
 export function buildEnhancedMacroOptions(context, textUpToCursor) {
-    /** @type {(EnhancedMacroAutoCompleteOption|MacroFlagAutoCompleteOption|MacroClosingTagAutoCompleteOption|VariableShorthandAutoCompleteOption|VariableNameAutoCompleteOption|VariableOperatorAutoCompleteOption)[]} */
+    /** @type {AnyMacroAutoCompleteOption[]} */
     const options = [];
     if (context.isVariableShorthand) {

     const allMacros = macroSystem.registry.getAllMacros({ excludeHiddenAliases: true });
     // If we're typing arguments (after ::), only show the context to the matching macro
+    // Also treat typing closing brace the same way - show details for matching macro
     const isTypingArgs = context.currentArgIndex >= 0;
+    const isTypingClosingBrace = context.isTypingClosingBrace ?? false;
+    const shouldShowMatchingMacroDetails = isTypingArgs || isTypingClosingBrace;
     // Check if we're inside a scoped {{if}} for {{else}} selectability
     const isInsideScopedIf = unclosedScopes.some(scope => scope.name === 'if');
+    // Track if any macro matches the identifier (for "no match" message)
+    let hasMatchingMacro = false;
     for (const macro of allMacros) {
         // Check if this macro matches the typed identifier
         const isExactMatch = macro.name === context.identifier;
         const isAliasMatch = macro.aliasOf === context.identifier;
+        if (isExactMatch || isAliasMatch) {
+            hasMatchingMacro = true;
+        }
         // Only pass context to the macro that matches the identifier being typed
         // This ensures argument hints only show for the relevant macro
         /** @type {MacroAutoCompleteContext|EnhancedMacroAutoCompleteOptions|null} */

             option.makeSelectable = false;
+        }
-        // When typing arguments, prioritize exact matches by putting them first
+        // When typing arguments or closing brace, prioritize exact matches by putting them first
-        if (isTypingArgs && (isExactMatch || isAliasMatch)) {
+        if (shouldShowMatchingMacroDetails && (isExactMatch || isAliasMatch)) {
             options.unshift(option);
         } else {
             options.push(option);
+        }
+    }
+    // If typing args/closing brace but no macro matches, add a "no match" indicator
+    if (shouldShowMatchingMacroDetails && !hasMatchingMacro && context.identifier.length > 0) {
+        const noMatchOption = new SimpleAutoCompleteOption({
+            name: context.identifier,
+            symbol: '❌',
+            description: `No macro found: "${context.identifier}"`,
+            detailedDescription: `The macro name <code>${context.identifier}</code> does not exist.<br><br>Check spelling or use a different macro name.`,
+            type: 'error',
+        });
+        noMatchOption.valueProvider = () => '';
+        noMatchOption.makeSelectable = false;
+        noMatchOption.matchProvider = () => true; // Always show
+        noMatchOption.sortPriority = 0; // Top priority
+        options.unshift(noMatchOption);
+    }
     return options;
+}

     // Search backwards for opening {{ while tracking nesting depth for nested macros
     let openPos = -1;
     let depth = 0;
-    for (let i = cursorPos - 1; i >= 0; i--) {
+    // If cursor is right after }}, those are the closing braces of the macro we're looking for,
+    // not nested braces. Skip them by starting the search before them.
+    let searchStart = cursorPos - 1;
+    let cursorAfterClosingBraces = false;
+    if (cursorPos >= 2 && text[cursorPos - 1] === '}' && text[cursorPos - 2] === '}') {
+        searchStart = cursorPos - 3; // Start before the }}
+        cursorAfterClosingBraces = true;
+    }
+    for (let i = searchStart; i >= 0; i--) {
         if (text[i] === '}' && i > 0 && text[i - 1] === '}') {
             // Found }}, going backwards means we're entering a nested macro
             depth++;

     // Search forwards for closing }} while tracking nesting depth
     let closePos = -1;
-    depth = 0;
-    for (let i = cursorPos; i < text.length - 1; i++) {
+    // If cursor is right after }}, we already know where the closing braces are
-        if (text[i] === '{' && text[i + 1] === '{') {
+    if (cursorAfterClosingBraces) {
-            // Found {{, entering a nested macro
+        closePos = cursorPos;
-            depth++;
+    } else {
-            i++; // Skip the other brace
+        depth = 0;
-            continue;
+        for (let i = cursorPos; i < text.length - 1; i++) {
-        }
+            if (text[i] === '{' && text[i + 1] === '{') {
-        if (text[i] === '}' && text[i + 1] === '}') {
+                // Found {{, entering a nested macro
-            if (depth > 0) {
+                depth++;
-                // This }} closes a nested macro
-                depth--;
                 i++; // Skip the other brace
                 continue;
+            }
-            // Found our closing }} at depth 0
+            if (text[i] === '}' && text[i + 1] === '}') {
-            closePos = i + 2;
+                if (depth > 0) {
-            break;
+                    // This }} closes a nested macro
+                    depth--;
+                    i++; // Skip the other brace
+                    continue;
+                }
+                // Found our closing }} at depth 0
+                closePos = i + 2;
+                break;
+            }
+        }
-    }
-    if (closePos === -1) {
+        if (closePos === -1) {
-        closePos = text.length;
+            closePos = text.length;
+        }
+    }
     const hasClosingBraces = closePos <= text.length && text.slice(closePos - 2, closePos) === '}}';

             resultIdentifier = context.invalidTrailingChars || '';
             // Use actual variableNameEnd position from parsing
             resultStart = macro.start + 2 + context.variableNameEnd;
-        } else if (context.isTypingValue) {
+        } else if (context.isTypingValue && !context.isTypingClosingBrace) {
             // Typing value: identifier = value being typed, start = after operator
             resultIdentifier = context.variableValue;
             // Use actual operatorEnd position from parsing (accounts for whitespace)

             makeNoMatchText = () => `Type any value you want to ${context.variableOperator == '+=' ? `add to the variable '${context.variableName}'` : `set the variable '${context.variableName}' to`}.`;
             makeNoOptionsText = () => 'Enter a variable value';
+        } else if (context.isTypingClosingBrace) {
+            // Typing closing brace on variable shorthand - show context, no replacement needed
+            resultIdentifier = '';
+            resultStart = cursorPos;
         } else {
             // Fallback: use variable name
             resultIdentifier = context.variableName;