Macros 2.0 [➕Macros] - Add `{{hasExtension}}` macro, and refactor extension lookup logic (#4948) * Add {{hasExtension}} macro and refactor extension lookup logic - Move findExtension() from extensions-slashcommands.js to extensions.js and export it - Update findExtension() to return object with name and enabled properties instead of just name string - Add {{hasExtension}} macro to check if an extension is enabled - Update /extension-state and /extension-exists commands to use refactored findExtension() - Remove duplicate findExtension() implementation from extensions-slashcommands.js * Refactor extension action callbacks to use extension object instead of separate name and enabled properties * fix eslint

cd0627bfec3598ba0b7a8304145e3a746aad75e1

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: e6ce84d72619bed45806710f88c4c63caa6fdf79

public/scripts/extensions-slashcommands.js+22 -37 Viewed

-import { disableExtension, enableExtension, extension_settings, extensionNames } from './extensions.js';
+import { disableExtension, enableExtension, extensionNames, findExtension } from './extensions.js';
 import { SlashCommand } from './slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';
 import { commonEnumProviders } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { enumTypes, SlashCommandEnumValue } from './slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
-import { equalsIgnoreCaseAndAccents, isFalseBoolean, isTrueBoolean } from './utils.js';
+import { isFalseBoolean, isTrueBoolean } from './utils.js';
 /**
  * @param {'enable' | 'disable' | 'toggle'} action - The action to perform on the extension

@@ -22,30 +22,28 @@ function getExtensionActionCallback(action) {
22	}	22	}
23		23
24	const reload = !isFalseBoolean(args?.reload?.toString());	24	const reload = !isFalseBoolean(args?.reload?.toString());
25	const internalExtensionName = findExtension(extensionName);	25	const extension = findExtension(extensionName);
26	if (!internalExtensionName) {	26	if (!extension) {
27	toastr.warning(`Extension ${extensionName} does not exist.`);	27	toastr.warning(`Extension ${extensionName} does not exist.`);
28	return '';	28	return '';
29	}	29	}
30		30
31	const isEnabled = !extension_settings.disabledExtensions.includes(internalExtensionName);	31	if (action === 'enable' && extension.enabled) {
32		32	toastr.info(`Extension ${extension.name} is already enabled.`);
33	if (action === 'enable' && isEnabled) {	33	return extension.name;
34	toastr.info(`Extension ${extensionName} is already enabled.`);
35	return internalExtensionName;
36	}	34	}
37		35
38	if (action === 'disable' && !isEnabled) {	36	if (action === 'disable' && !extension.enabled) {
39	toastr.info(`Extension ${extensionName} is already disabled.`);	37	toastr.info(`Extension ${extension.name} is already disabled.`);
40	return internalExtensionName;	38	return extension.name;
41	}	39	}
42		40
43	if (action === 'toggle') {	41	if (action === 'toggle') {
44	action = isEnabled ? 'disable' : 'enable';	42	action = extension.enabled ? 'disable' : 'enable';
45	}	43	}
46		44
47	if (reload) {	45	if (reload) {
48	toastr.info(`${action.charAt(0).toUpperCase() + action.slice(1)}ing extension ${extensionName} and reloading...`);	46	toastr.info(`${action.charAt(0).toUpperCase() + action.slice(1)}ing extension ${extension.name} and reloading...`);
49		47
50	// Clear input, so it doesn't stay because the command didn't "finish",	48	// Clear input, so it doesn't stay because the command didn't "finish",
51	// and wait for a bit to both show the toast and let the clear bubble through.	49	// and wait for a bit to both show the toast and let the clear bubble through.

+        }
         if (action === 'enable') {
-            await enableExtension(internalExtensionName, reload);
+            await enableExtension(extension.name, reload);
         } else {
-            await disableExtension(internalExtensionName, reload);
+            await disableExtension(extension.name, reload);
+        }
-        toastr.success(`Extension ${extensionName} ${action}d.`);
+        toastr.success(`Extension ${extension.name} ${action}d.`);
-        console.info(`Extension ${action}ed: ${extensionName}`);
+        console.info(`Extension ${action}ed: ${extension.name}`);
         if (!reload) {
             console.info('Reload not requested, so page needs to be reloaded manually for changes to take effect.');
+        }
-        return internalExtensionName;
+        return extension.name;
     };
+}
 /**
- * Finds an extension by name, allowing omission of the "third-party/" prefix.
- *
- * @param {string} name - The name of the extension to find
- * @returns {string?} - The matched extension name or undefined if not found
- */
-function findExtension(name) {
-    return extensionNames.find(extName => {
-        return equalsIgnoreCaseAndAccents(extName, name) || equalsIgnoreCaseAndAccents(extName, `third-party/${name}`);
-    });
-}
-/**
  * Provides an array of SlashCommandEnumValue objects based on the extension names.
  * Each object contains the name of the extension and a description indicating if it is a third-party extension.
+ *

         name: 'extension-state',
         callback: async (_, extensionName) => {
             if (typeof extensionName !== 'string') throw new Error('Extension name must be a string. Closures or arrays are not allowed.');
-            const internalExtensionName = findExtension(extensionName);
+            const extension = findExtension(extensionName);
-            if (!internalExtensionName) {
+            if (!extension) {
                 toastr.warning(`Extension ${extensionName} does not exist.`);
                 return '';
+            }
-            const isEnabled = !extension_settings.disabledExtensions.includes(internalExtensionName);
+            return String(extension.enabled);
-            return String(isEnabled);
         },
         returns: 'The state of the extension, whether it is enabled.',
         unnamedArgumentList: [

         aliases: ['extension-installed'],
         callback: async (_, extensionName) => {
             if (typeof extensionName !== 'string') throw new Error('Extension name must be a string. Closures or arrays are not allowed.');
-            const exists = findExtension(extensionName) !== undefined;
+            const extension = findExtension(extensionName);
-            return exists ? 'true' : 'false';
+            return extension !== null ? 'true' : 'false';
         },
         returns: 'Whether the extension exists and is installed.',
         unnamedArgumentList: [

public/scripts/extensions.js+16 -1 Viewed

 import { showLoader } from './loader.js';
 import { POPUP_RESULT, POPUP_TYPE, Popup, callGenericPopup } from './popup.js';
 import { renderTemplate, renderTemplateAsync } from './templates.js';
-import { delay, isSubsetOf, sanitizeSelector, setValueByPath, versionCompare } from './utils.js';
+import { delay, equalsIgnoreCaseAndAccents, isSubsetOf, sanitizeSelector, setValueByPath, versionCompare } from './utils.js';
 import { getContext } from './st-context.js';
 import { isAdmin } from './user.js';
 import { addLocaleData, getCurrentLocale, t } from './i18n.js';

+}
 /**
+ * Finds an extension by name, allowing omission of the "third-party/" prefix.
+ *
+ * @param {string} name - The name of the extension to find
+ * @returns {{name: string, enabled: boolean}|null} Object with name and enabled properties, or null if not found
+ */
+export function findExtension(name) {
+    const internalExtensionName = extensionNames.find(extName => {
+        return equalsIgnoreCaseAndAccents(extName, name) || equalsIgnoreCaseAndAccents(extName, `third-party/${name}`);
+    });
+    if (!internalExtensionName) return null;
+    const isEnabled = !extension_settings.disabledExtensions.includes(internalExtensionName);
+    return { name: internalExtensionName, enabled: isEnabled };
+}
+/**
  * Loads manifest.json files for extensions.
  * @param {string[]} names Array of extension names
  * @returns {Promise<Record<string, object>>} Object with extension names as keys and their manifests as values

public/scripts/macros/definitions/state-macros.js+17 -0 Viewed

 import { MacroRegistry, MacroCategory } from '../engine/MacroRegistry.js';
 import { eventSource, event_types } from '../../events.js';
+import { findExtension } from '/scripts/extensions.js';
 let lastGenerationTypeValue = '';
 let lastGenerationTypeTrackingInitialized = false;

         returns: 'Type of the last queued generation request.',
         handler: () => lastGenerationTypeValue,
     });
+    // Macro that checks if an extension is enabled
+    MacroRegistry.registerMacro('hasExtension', {
+        category: MacroCategory.STATE,
+        unnamedArgs: [{
+            name: 'extensionName',
+            type: 'string',
+            description: 'The name of the extension to check',
+        }],
+        description: 'Checks if a specific extension is enabled. If the extension does not exist, returns false.',
+        returns: 'true if the extension is enabled, false otherwise.',
+        handler: ({ unnamedArgs: [extensionName] }) => {
+            const extension = findExtension(extensionName);
+            return String(extension?.enabled ?? false);
+        },
+    });
+}