Macros 2.0 [Fix] - Macro display override uses alias name if relevant + preserve whitespaces for autocomplete closing tag (#4953) * Refactor: Move MacroBrowser.js to macros/engine directory and update import paths * Replace macro name with alias in displayOverride for macro browser - Import escapeRegex utility for safe regex pattern creation - Check if macro has aliasOf property when displayOverride is present - Replace all occurrences of the original macro name with the alias name in displayOverride text - Use word boundary regex pattern to match macro names in {{macro}}, {{macro::}}, and {{macro }} contexts * Add whitespace padding preservation for macro closing tag autocomplete - Extract paddingBefore and paddingAfter from opening macro tags in MacroCstWalker - Pass padding info through unclosed scope detection in findUnclosedScopes() and findUnclosedScopesRegex() - Update MacroClosingTagAutoCompleteOption constructor to accept padding options - Apply same whitespace padding to closing tags as their corresponding opening tags - Update regex fallback to capture and preserve whitespace from opening tags * Add replacementStartOffset to AutoCompleteOption for whitespace normalization in closing tags - Add replacementStartOffset property to AutoCompleteOption class with JSDoc documentation - Update AutoComplete.select() to apply per-option replacement offset when calculating effectiveStart - Calculate replacementStartOffset in MacroClosingTagAutoCompleteOption based on currentPadding length - Pass currentPadding from context.paddingBefore to MacroClosingTagAutoCompleteOption in SlashCommandParser * Fix closing tag detection regex to correctly autocomplete // macro * Add flags and fullText to EnhancedMacroAutoCompleteOption context and fix {{//}} autocomplete offset - Add flags, currentFlag, and fullText properties to EnhancedMacroAutoCompleteOptions JSDoc - Store options object as #options field in EnhancedMacroAutoCompleteOption for later access - Pass flags, currentFlag, and fullText from context to macroContext in SlashCommandParser - Fix {{//}} macro autocomplete to adjust replacementStartOffset when typed after single slash to avoid treating it as flag * Add unnamedArgs definition to {{//}} comment macro for better documentation --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

b453fdc5d86898c9e64343c7541be49391b8d0fa

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: cd0627bfec3598ba0b7a8304145e3a746aad75e1

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

      */
     async select() {
         if (this.isReplaceable && this.selectedItem.value !== null) {
 -            this.textarea.value = `${this.text.slice(0, this.effectiveParserResult.start)}${this.selectedItem.replacer}${this.text.slice(this.effectiveParserResult.start + this.effectiveParserResult.name.length + (this.startQuote ? 1 : 0) + (this.endQuote ? 1 : 0))}`;
 +            // Apply per-option replacement offset (e.g., for closing tags that need to replace leading whitespace)
             this.textarea.selectionStartconst effectiveStart = this.effectiveParserResult.start + (this.selectedItem.replacer.lengthreplacementStartOffset ?? 0);
 +            this.textarea.value = `${this.text.slice(0, effectiveStart)}${this.selectedItem.replacer}${this.text.slice(this.effectiveParserResult.start + this.effectiveParserResult.name.length + (this.startQuote ? 1 : 0) + (this.endQuote ? 1 : 0))}`;
 +            this.textarea.selectionStart = effectiveStart + this.selectedItem.replacer.length;
             this.textarea.selectionEnd = this.textarea.selectionStart;
             this.show(false, false, true);
         } else {

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

     /** @type {(input:string)=>boolean} */ matchProvider;
     /** @type {(input:string)=>string} */ valueProvider;
     /** @type {boolean} */ makeSelectable = false;
++
 +    /**
 +     * Offset to adjust the replacement start position.
 +     * Negative values start replacement earlier (e.g., -2 to include 2 chars before normal start).
 +     * Used by closing tag autocomplete to replace leading whitespace.
 +     * @type {number}
 +     */
 +    replacementStartOffset = 0;
++
     /**
      * Priority for sorting. Lower values = higher priority (sorted first).
      * Default is 100 (normal priority). Use lower values for items that should appear at the top.

public/scripts/autocomplete/EnhancedMacroAutoCompleteOption.js+40 -10 Viewed

     createSourceIndicator,
     createAliasIndicator,
     renderMacroDetails,
 } from '../macros/engine/MacroBrowser.js';
 import { enumIcons } from '../slash-commands/SlashCommandCommonEnumsProvider.js';
 import { ValidFlagSymbols } from '../macros/engine/MacroFlags.js';
 import { MACRO_VARIABLE_SHORTHAND_PATTERN } from '../macros/engine/MacroLexer.js';

  * @property {boolean} [noBraces=false] - If true, display without {{ }} braces (for use as values, e.g., in {{if}} conditions).
  * @property {string} [paddingAfter=''] - Whitespace to add before closing }} (for matching opening whitespace style).
  * @property {boolean} [closeWithBraces=false] - If true, the completion will add }} to close the macro.
 + * @property {string[]} [flags=[]] - The currently already written flags for this autocomplete.
 + * @property {string} [currentFlag] - The current flag that is present, if any.
 + * @property {string} [fullText] - The currently written full text.
  */
 export class EnhancedMacroAutoCompleteOption extends AutoCompleteOption {

     /** @type {MacroAutoCompleteContext|null} */
     #context = null;
 +    /** @type {EnhancedMacroAutoCompleteOptions|null} */
 +    #options = null;
++
     /** @type {boolean} */
     #noBraces = false;

         if (contextOrOptions && typeof contextOrOptions === 'object') {
             if ('noBraces' in contextOrOptions || 'paddingAfter' in contextOrOptions || 'closeWithBraces' in contextOrOptions) {
                 // It's an options object
                 const this.#options = /** @type {EnhancedMacroAutoCompleteOptions} */ (contextOrOptions);
                 this.#noBraces = this.#options.noBraces ?? false;
                 this.#paddingAfter = this.#options.paddingAfter ?? '';
                 // If noBraces mode with closeWithBraces, complete with name + padding + }}
                 if (this.#options.closeWithBraces) {
                     this.valueProvider = () => `${macro.name}${this.#paddingAfter}}}`;
                     this.makeSelectable = true;
+                }

@@ -110,6 +116,12 @@ export class EnhancedMacroAutoCompleteOption extends AutoCompleteOption {
110	116	this.makeSelectable = true; // Required when using valueProvider
111	117	}
112	118	}
	119	+
	120	+ // {{//}} needs special handling. If we autocomplete right after one slash is already typed, we need to replace that, as it's treated as a flag otherwise.
	121	+ const fullText = this.#options?.fullText ?? this.#context?.fullText ?? '';
	122	+ if (macro.name === '//' && fullText.endsWith('/')) {
	123	+ this.replacementStartOffset = (this.replacementStartOffset ?? 0) - 1; // Cut the leading slash
	124	+ }
113	125	}
114	126
115	127	/** @returns {MacroDefinition} */

     /** @type {string} */
     #macroName;
 +    /** @type {string} */
 +    #paddingBefore;
++
 +    /** @type {string} */
 +    #paddingAfter;
++
     /**
      * @param {string} macroName - The name of the macro to close.
 +     * @param {Object} [options] - Optional configuration.
 +     * @param {string} [options.paddingBefore=''] - Whitespace after {{ in opening tag (target padding).
 +     * @param {string} [options.paddingAfter=''] - Whitespace before }} in opening tag (target padding).
 +     * @param {string} [options.currentPadding=''] - Whitespace the user has already typed after {{.
      */
     constructor(macroName, options = {}) {
         // The closing tag is what we're suggesting - use /macroName as the name for matching
         const closingTag = `/${macroName}`;
         super(closingTag, '{/');
         this.#macroName = macroName;
 +        this.#paddingBefore = options.paddingBefore ?? '';
 +        this.#paddingAfter = options.paddingAfter ?? '';
++
 +        // Calculate the replacement offset to replace any existing whitespace the user typed
 +        // This allows us to normalize the whitespace to match the opening tag's style
 +        const currentPadding = options.currentPadding ?? '';
 +        // Negative offset to start replacement earlier (eating the user's whitespace)
 +        this.replacementStartOffset = -currentPadding.length;
         // Custom valueProvider to return the correct replacement text
         // Autocomplete REPLACESIncludes the typedtarget identifierpaddingBefore entirely,from sothe returnopening thetag, fullreplacing closingany taguser-typed whitespace
         this.valueProvider = () => {
 -            // Return full closing tag content (without {{ since that's before the identifier)
 +            // Return: paddingBefore + /macroName + paddingAfter + }}
             return `${this.#paddingBefore}/${macroName}${this.#paddingAfter}}}`;
         };
         // Make selectable so TAB completion works (valueProvider alone makes it non-selectable)

     while (i < macroText.length) {
         const char = macroText[i];
         // Check if this looks like a closing tag: `/` followed by an identifier character
         if (char === '/' && i + 1 < macroText.length && /[a-zA-Z_Z/]/.test(macroText[i + 1])) {
             // This is a closing tag identifier, not a flag - stop parsing flags
             break;
+        }

public/scripts/macros/definitions/core-macros.js+7 -0 Viewed

     MacroRegistry.registerMacro('//', {
         aliases: [{ alias: 'comment', visible: false }],
         category: MacroCategory.UTILITY,
 +        unnamedArgs: [
 +            {
 +                name: 'comment',
 +                type: MacroValueType.STRING,
 +                description: 'Any kind of text as comment. If you want multiline comments, consider using a scoped macro like {{//}}First\nSecond{{///}}.',
 +            },
 +        ],
         list: true,         // We consume any arguments as if this is a list, but we'll ignore them in the handler anyway
         strictArgs: false,  // and we also always remove it, even if the parsing might say it's invalid
         description: 'Comment macro that produces an empty string. Can be used for writing into prompt definitions, without being passed to the context.',

public/scripts/macros/MacroBrowser.js → public/scripts/macros/engine/MacroBrowser.js+10 -4 Viewed

  * Similar to SlashCommandBrowser but for the macro system.
  */
 import { MacroRegistry, MacroCategory } from './engine/MacroRegistry.js';
 import { performFuzzySearch } from '../../power-user.js';
 +import { escapeRegex } from '/scripts/utils.js';
 /** @typedef {import('./engine/MacroRegistry.js').MacroDefinition} MacroDefinition */
 /** @typedef {import('./engine/MacroRegistry.js').MacroValueType} MacroValueType */
 /**
  * Category display names and order for documentation.

 export function formatMacroSignature(macro) {
     // Use displayOverride if provided
     if (macro.displayOverride) {
 +        if (macro.aliasOf) {
 +            // Replace all occurrences of the macro name with the alias for this list
 +            const escapedMainName = escapeRegex(macro.aliasOf);
 +            return macro.displayOverride.replace(new RegExp(`(?<=[\\b{\\s])${escapedMainName}(?=[\\b}:\\s])`, 'g'), `${macro.name}`);
 +        }
         return macro.displayOverride;
+    }

public/scripts/macros/engine/MacroCstWalker.js+40 -2 Viewed

      * @param {Object} options
      * @param {string} options.text - The document text.
      * @param {CstNode} options.cst - The parsed CST.
      * @returns {Array<{ name: string, startOffset: number, endOffset: number, paddingBefore: string, paddingAfter: string }>} - Array of unclosed macro info, innermost last.
      */
     findUnclosedScopes(options) {
         const { text, cst } = options;

         // Don't process scoped macros - we want to find the raw opening/closing pairs
         // Just extract macro info and find unmatched openers
         /** @type {Array<{ name: string, startOffset: number, endOffset: number, paddingBefore: string, paddingAfter: string }>} */
         const unclosedStack = [];
         // Extract macro names and closing status

             } else {
                 // Opening tag - check if this macro can accept scoped content
                 if (this.#canAcceptScopedContent(item.node, info.name)) {
 +                    // Extract whitespace padding from the macro
 +                    const { paddingBefore, paddingAfter } = this.#extractMacroPadding(item.node, text);
++
                     unclosedStack.push({
                         name: info.name,
                         startOffset: item.startOffset,
                         endOffset: item.endOffset,
 +                        paddingBefore,
 +                        paddingAfter,
                     });
+                }
+            }

         return unclosedStack;
+    }
 +    /**
 +     * Extracts the whitespace padding from a macro node.
 +     * Returns the whitespace after {{ and before }}.
 +     *
 +     * @param {CstNode} macroNode - The macro CST node.
 +     * @param {string} text - The source text.
 +     * @returns {{ paddingBefore: string, paddingAfter: string }}
 +     */
 +    #extractMacroPadding(macroNode, text) {
 +        const children = macroNode.children || {};
 +        const startToken = /** @type {IToken?} */ ((children['Macro.Start'] || [])[0]);
 +        const endToken = /** @type {IToken?} */ ((children['Macro.End'] || [])[0]);
++
 +        if (!startToken || !endToken) {
 +            return { paddingBefore: '', paddingAfter: '' };
 +        }
++
 +        // Get the raw text inside the macro (between {{ and }})
 +        const innerStart = startToken.endOffset + 1;
 +        const innerEnd = endToken.startOffset;
 +        const innerText = text.slice(innerStart, innerEnd);
++
 +        // Extract leading whitespace (paddingBefore)
 +        const leadingMatch = innerText.match(/^(\s*)/);
 +        const paddingBefore = leadingMatch ? leadingMatch[1] : '';
++
 +        // Extract trailing whitespace (paddingAfter)
 +        const trailingMatch = innerText.match(/(\s*)$/);
 +        const paddingAfter = trailingMatch ? trailingMatch[1] : '';
++
 +        return { paddingBefore, paddingAfter };
 +    }
++
     /** @typedef {{ type: 'plaintext', startOffset: number, endOffset: number, token: IToken }} DocumentItemPlaintext */
     /** @typedef {{ type: 'macro', startOffset: number, endOffset: number, node: CstNode, scopedContent?: { startOffset: number, endOffset: number, closingEndOffset: number }, keepRaw?: boolean }} DocumentItemMacro */
     /** @typedef {DocumentItemPlaintext | DocumentItemMacro} DocumentItem */

public/scripts/slash-commands/SlashCommandParser.js+30 -10 Viewed

         if (unclosedScopes.length > 0) {
             // Suggest closing the innermost (last) unclosed scope first
             const innermostScope = unclosedScopes[unclosedScopes.length - 1];
 -            const closingOption = new MacroClosingTagAutoCompleteOption(innermostScope.name);
 +            // Preserve whitespace padding from the opening tag
 +            // Pass currentPadding so the closing tag can replace user-typed whitespace with the target padding
 +            const closingOption = new MacroClosingTagAutoCompleteOption(innermostScope.name, {
 +                paddingBefore: innermostScope.paddingBefore,
 +                paddingAfter: innermostScope.paddingAfter,
 +                currentPadding: context.paddingBefore,
 +            });
             options.push(closingOption);
             // If inside a scoped {{if}}, also suggest {{else}}

             if (!macroContext) {
                 macroContext = /** @type {EnhancedMacroAutoCompleteOptions} */ ({
                     paddingAfter: context.paddingBefore, // Match whitespace before the macro - will only be used if the macro gets auto-closed
 +                    flags: context.flags,
 +                    currentFlag: context.currentFlag,
 +                    fullText: context.fullText,
                 });
+            }

      * Uses the MacroParser and MacroCstWalker for accurate analysis.
+     *
      * @param {string} textUpToCursor - The document text up to the cursor position.
      * @returns {Array<{ name: string, startOffset: number, endOffset: number, paddingBefore: string, paddingAfter: string }>}
      */
     #findUnclosedScopes(textUpToCursor) {
         if (!textUpToCursor) return [];

      * Used when the parser fails on incomplete input.
+     *
      * @param {string} text - The text to analyze.
      * @returns {Array<{ name: string, startOffset: number, endOffset: number, paddingBefore: string, paddingAfter: string }>}
      */
     #findUnclosedScopesRegex(text) {
         // Simple regexRegex to find macro openings and closings, capturing whitespace padding
 -        // This is a fallback - less accurate but works on partial input
 +        // Group 1: padding after {{, Group 2: optional /, Group 3: macro name
         const macroPattern = /\{\{(\s*)(\/?)([\w-]+)/g;
         const stack = [];
         let match;
         while ((match = macroPattern.exec(text)) !== null) {
             const isClosingpaddingBefore = match[1] === '/';
             const nameisClosing = match[2] === '/';
 +            const name = match[3];
             if (isClosing) {
                 // Pop matching opener (case-insensitive)
                 if (stack.length > 0 && stack[stack.length - 1].name.toLowerCase() === name.toLowerCase()) {
                     stack.pop();
+                }
             } else {
                 // Check if macro can accept scoped content
                 const macroDef = macroSystem.registry.getPrimaryMacro(name);
                 if (macroDef && macroDef.maxArgs > 0) {
 +                    // Try to find closing }} to extract trailing whitespace
 +                    let paddingAfter = '';
 +                    const afterMatch = text.slice(match.index + match[0].length);
 +                    const closingMatch = afterMatch.match(/^[^}]*?(\s*)\}\}/);
 +                    if (closingMatch) {
 +                        paddingAfter = closingMatch[1];
 +                    }
++
                     stack.push({
                         name,
                         startOffset: match.index,
                         endOffset: match.index + match[0].length,
 +                        paddingBefore,
 +                        paddingAfter,
                     });
+                }
+            }

public/scripts/system-messages.js+1 -1 Viewed

 import { getMessageTimeStamp } from './RossAscends-mods.js';
 import { getSlashCommandsHelp } from './slash-commands.js';
 import { SlashCommandBrowser } from './slash-commands/SlashCommandBrowser.js';
 import { MacroBrowser, getMacrosHelp } from './macros/engine/MacroBrowser.js';
 import { renderTemplateAsync } from './templates.js';
 /** @type {Record<string, ChatMessage>} */