Macros 2.0 [Fix] - Make macro name matching case-insensitive throughout the macro system (#4942) * Make macro name matching case-insensitive throughout the macro system - Normalize macro names and aliases to lowercase in MacroRegistry storage and lookup - Update MacroCstWalker to use case-insensitive matching for block macro pairing - Normalize dynamic macro keys to lowercase in MacroEnvBuilder - Update MacroEngine to use lowercase keys when checking dynamic macros - Preserve original casing in macro definitions for display purposes - Add comments explaining case-insensitive matching behavior * Make alias validation case-insensitive in MacroRegistry to prevent duplicate names - Prevents registering aliases that differ only in casing from the macro name

dbc4fe611c69244b83258880ac58bd0084ded45d

Wolfsblvt <wolfsblvt@gmail.com>

Signed

public/scripts/macros/engine/MacroCstWalker.js+4 -4 Viewed

             if (!info) continue;
             if (info.isClosing) {
-                // Closing tag - pop matching opener from stack
+                // Closing tag - pop matching opener from stack (case-insensitive match)
-                if (unclosedStack.length > 0 && unclosedStack[unclosedStack.length - 1].name === info.name) {
+                if (unclosedStack.length > 0 && unclosedStack[unclosedStack.length - 1].name.toLowerCase() === info.name.toLowerCase()) {
                     unclosedStack.pop();
+                }
                 // If no matching opener, ignore (orphan closing tag)

         for (let i = openingIdx + 1; i < macroInfos.length; i++) {
             const info = macroInfos[i];
-            // Only consider macros with the same name
+            // Only consider macros with the same name (case-insensitive)
-            if (info.name !== targetName) continue;
+            if (info.name.toLowerCase() !== targetName.toLowerCase()) continue;
             // Skip already matched macros
             if (info.matched) continue;

public/scripts/macros/engine/MacroEngine.js+4 -2 Viewed

         if (!name) return raw;
         // First check if this is a dynamic macro to use. If so, we will create a temporary macro definition for it and use that over any registered macro.
+        // Dynamic macro keys are normalized to lowercase for case-insensitive matching.
         /** @type {MacroDefinition?} */
         let defOverride = null;
-        if (Object.hasOwn(env.dynamicMacros, name)) {
+        const nameLower = name.toLowerCase();
-            const impl = env.dynamicMacros[name];
+        if (Object.hasOwn(env.dynamicMacros, nameLower)) {
+            const impl = env.dynamicMacros[nameLower];
             defOverride = {
                 name,
                 aliases: [],

public/scripts/macros/engine/MacroEnvBuilder.js+4 -1 Viewed

         env.functions.postProcess = typeof ctx.postProcessFn === 'function' ? ctx.postProcessFn : (x) => x;
         // Dynamic, per-call macros that should be visible only for this evaluation run.
+        // Keys are normalized to lowercase for case-insensitive matching.
         if (ctx.dynamicMacros && typeof ctx.dynamicMacros === 'object') {
-            env.dynamicMacros = { ...ctx.dynamicMacros };
+            for (const [key, value] of Object.entries(ctx.dynamicMacros)) {
+                env.dynamicMacros[key.toLowerCase()] = value;
+            }
+        }
         // Let providers augment the env, if any are registered. Apply them in order,

public/scripts/macros/engine/MacroRegistry.js+11 -9 Viewed

                     if (typeof aliasDef.alias !== 'string' || !aliasDef.alias.trim()) throw new Error(`Macro "${name}" options.aliases[${i}].alias must be a non-empty string.`);
                     const aliasName = aliasDef.alias.trim();
                     if (!isIdentifierValid(aliasName)) throw new Error(`Macro "${name}" options.aliases[${i}].alias "${aliasName}" is invalid. Must start with a letter, followed by word chars or hyphens.`);
-                    if (aliasName === name) throw new Error(`Macro "${name}" options.aliases[${i}].alias cannot be the same as the macro name.`);
+                    if (aliasName.toLowerCase() === name.toLowerCase()) throw new Error(`Macro "${name}" options.aliases[${i}].alias cannot be the same as the macro name (insensitive).`);
                     const visible = aliasDef.visible !== false; // Default to true
                     aliases.push({ alias: aliasName, visible });
+                }

@@ -358,7 +358,8 @@ class MacroRegistry {
358	}	358	}
359	}	359	}
360		360
361	if (this.#macros.has(name)) {	361	const nameKey = name.toLowerCase();
		362	if (this.#macros.has(nameKey)) {
362	logMacroRegisterWarning({ macroName: name, message: `Macro "${name}" is already registered and will be overwritten.` });	363	logMacroRegisterWarning({ macroName: name, message: `Macro "${name}" is already registered and will be overwritten.` });
363	}	364	}
364		365

                 aliasVisible: null,
             };
-            this.#macros.set(name, definition);
+            this.#macros.set(nameKey, definition);
             // Register alias entries pointing to the same definition
             for (const { alias, visible } of aliases) {
-                if (this.#macros.has(alias)) {
+                const aliasKey = alias.toLowerCase();
+                if (this.#macros.has(aliasKey)) {
                     logMacroRegisterWarning({ macroName: name, message: `Alias "${alias}" for macro "${name}" overwrites an existing macro.` });
+                }
                 /** @type {MacroDefinition} */
                 const aliasEntry = {
                     ...definition,
-                    name: alias, // The lookup name is the alias
+                    name: alias, // The lookup name is the alias (preserves original casing for display)
                     aliasOf: name,
                     aliasVisible: visible,
                 };
-                this.#macros.set(alias, aliasEntry);
+                this.#macros.set(aliasKey, aliasEntry);
+            }
             return definition;

     unregisterMacro(name) {
         if (typeof name !== 'string' || !name.trim()) throw new Error('Macro name must be a non-empty string');
         name = name.trim();
-        return this.#macros.delete(name);
+        return this.#macros.delete(name.toLowerCase());
+    }
     /**

     hasMacro(name) {
         if (typeof name !== 'string' || !name.trim()) return false;
         name = name.trim();
-        return this.#macros.has(name);
+        return this.#macros.has(name.toLowerCase());
+    }
     /**

     getMacro(name) {
         if (typeof name !== 'string' || !name.trim()) return undefined;
         name = name.trim();
-        return this.#macros.get(name);
+        return this.#macros.get(name.toLowerCase());
+    }
     /**