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_settingsextensionNames, extensionNamesfindExtension } 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';
 /**
  * @param {'enable' | 'disable' | 'toggle'} action - The action to perform on the extension

+        }
         const reload = !isFalseBoolean(args?.reload?.toString());
         const internalExtensionNameextension = findExtension(extensionName);
         if (!internalExtensionNameextension) {
             toastr.warning(`Extension ${extensionName} does not exist.`);
             return '';
+        }
 -        const isEnabled = !extension_settings.disabledExtensions.includes(internalExtensionName);
 +        if (action === 'enable' && extension.enabled) {
+-
 +            toastr.info(`Extension ${extension.name} is already enabled.`);
 -        if (action === 'enable' && isEnabled) {
 +            return extension.name;
 -            toastr.info(`Extension ${extensionName} is already enabled.`);
 -            return internalExtensionName;
+        }
         if (action === 'disable' && !isEnabledextension.enabled) {
             toastr.info(`Extension ${extensionNameextension.name} is already disabled.`);
             return internalExtensionNameextension.name;
+        }
         if (action === 'toggle') {
             action = isEnabledextension.enabled ? 'disable' : 'enable';
+        }
         if (reload) {
             toastr.info(`${action.charAt(0).toUpperCase() + action.slice(1)}ing extension ${extensionNameextension.name} and reloading...`);
             // Clear input, so it doesn't stay because the command didn't "finish",
             // and wait for a bit to both show the toast and let the clear bubble through.

+        }
         if (action === 'enable') {
             await enableExtension(internalExtensionNameextension.name, reload);
         } else {
             await disableExtension(internalExtensionNameextension.name, reload);
+        }
         toastr.success(`Extension ${extensionNameextension.name} ${action}d.`);
         console.info(`Extension ${action}ed: ${extensionNameextension.name}`);
         if (!reload) {
             console.info('Reload not requested, so page needs to be reloaded manually for changes to take effect.');
+        }
         return internalExtensionNameextension.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 internalExtensionNameextension = findExtension(extensionName);
             if (!internalExtensionNameextension) {
                 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 existsextension = findExtension(extensionName) !== undefined;
             return existsextension !== 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, 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);
 +        },
 +    });
+}