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.selectionStart = this.effectiveParserResult.start + this.selectedItem.replacer.length;
+            const effectiveStart = this.effectiveParserResult.start + (this.selectedItem.replacementStartOffset ?? 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/MacroBrowser.js';
+} 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 options = /** @type {EnhancedMacroAutoCompleteOptions} */ (contextOrOptions);
+                this.#options = /** @type {EnhancedMacroAutoCompleteOptions} */ (contextOrOptions);
-                this.#noBraces = options.noBraces ?? false;
+                this.#noBraces = this.#options.noBraces ?? false;
-                this.#paddingAfter = options.paddingAfter ?? '';
+                this.#paddingAfter = this.#options.paddingAfter ?? '';
                 // If noBraces mode with closeWithBraces, complete with name + padding + }}
-                if (options.closeWithBraces) {
+                if (this.#options.closeWithBraces) {
                     this.valueProvider = () => `${macro.name}${this.#paddingAfter}}}`;
                     this.makeSelectable = true;
+                }

@@ -110,6 +116,12 @@ export class EnhancedMacroAutoCompleteOption extends AutoCompleteOption {
110	this.makeSelectable = true; // Required when using valueProvider	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	/** @returns {MacroDefinition} */	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) {
+    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 REPLACES the typed identifier entirely, so return the full closing tag
+        // Includes the target paddingBefore from the opening tag, replacing any user-typed whitespace
         this.valueProvider = () => {
-            // Return full closing tag content (without {{ since that's before the identifier)
+            // Return: paddingBefore + /macroName + paddingAfter + }}
-            return `/${macroName}}}`;
+            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_]/.test(macroText[i + 1])) {
+        if (char === '/' && i + 1 < macroText.length && /[a-zA-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 { MacroRegistry, MacroCategory } from './MacroRegistry.js';
-import { performFuzzySearch } from '../power-user.js';
+import { performFuzzySearch } from '../../power-user.js';
+import { escapeRegex } from '/scripts/utils.js';
-/** @typedef {import('./engine/MacroRegistry.js').MacroDefinition} MacroDefinition */
+/** @typedef {import('./MacroRegistry.js').MacroDefinition} MacroDefinition */
-/** @typedef {import('./engine/MacroRegistry.js').MacroValueType} MacroValueType */
+/** @typedef {import('./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 }>} - Array of unclosed macro info, innermost last.
+     * @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 }>} */
+        /** @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 }>}
+     * @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 }>}
+     * @returns {Array<{ name: string, startOffset: number, endOffset: number, paddingBefore: string, paddingAfter: string }>}
      */
     #findUnclosedScopesRegex(text) {
-        // Simple regex to find macro openings and closings
+        // Regex 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 = /\{\{(\/?)([\w-]+)/g;
+        const macroPattern = /\{\{(\s*)(\/?)([\w-]+)/g;
         const stack = [];
         let match;
         while ((match = macroPattern.exec(text)) !== null) {
-            const isClosing = match[1] === '/';
+            const paddingBefore = match[1];
-            const name = match[2];
+            const isClosing = match[2] === '/';
+            const name = match[3];
             if (isClosing) {
-                // Pop matching opener
+                // Pop matching opener (case-insensitive)
-                if (stack.length > 0 && stack[stack.length - 1].name === name) {
+                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/MacroBrowser.js';
+import { MacroBrowser, getMacrosHelp } from './macros/engine/MacroBrowser.js';
 import { renderTemplateAsync } from './templates.js';
 /** @type {Record<string, ChatMessage>} */