Add /extension-toggle

a6445aee1b1399d0f0de27b0d0cff1037e236cdb

Wolfsblvt <wolfsblvt@gmail.com>

Parents: eda7493a33785e949b7e04b40512515269a8defd

public/scripts/extensions.js+86 -11 Viewed

 import { enumTypes, SlashCommandEnumValue } from './slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { renderTemplate, renderTemplateAsync } from './templates.js';
 import { equalsIgnoreCaseAndAccents, isFalseBoolean, isSubsetOf, isTrueBoolean, setValueByPath } from './utils.js';
 export {
     getContext,
     getApiUrl,

+}
 /**
  * @param {boolean'enable' | 'disable' | 'toggle'} enableaction - WhetherThe toaction enableto orperform disableon the extension
  * @returns {(args: {[key: string]: string | SlashCommandClosure}, extensionName: string | SlashCommandClosure) => Promise<string>}
  */
 function getExtensionToggleCallbackgetExtensionActionCallback(enableaction) {
     return async (args, extensionName) => {
         if (args?.reload instanceof SlashCommandClosure) throw new Error('\'reload\' argument cannot be a closure.');
         if (typeof extensionName !== 'string') throw new Error('Extension name does only support string. Closures or arrays are not allowed.');
         if (!extensionName) {
             toastr.warning(`Extension name must be provided as an argument to ${enable ? 'enable' : 'disable'action} this extension.`);
             return '';
+        }
         const reload = isTrueBoolean(args?.reload);
+-
         const internalExtensionName = extensionNames.find(x => equalsIgnoreCaseAndAccents(x, extensionName));
         if (!internalExtensionName) {
             toastr.warning(`Extension ${extensionName} does not exist.`);
             return '';
+        }
 -        if (enable === !extension_settings.disabledExtensions.includes(internalExtensionName)) {
++
 -            toastr.info(`Extension ${extensionName} is already ${enable ? 'enabled' : 'disabled'}.`);
 +        const isEnabled = !extension_settings.disabledExtensions.includes(internalExtensionName);
++
 +        if (action === 'enable' && isEnabled) {
 +            toastr.info(`Extension ${extensionName} is already enabled.`);
             return internalExtensionName;
+        }
 -        reload && toastr.info(`${enable ? 'Enabling' : 'Disabling'} extension ${extensionName} and reloading...`);
 +        if (action === 'disable' && !isEnabled) {
 +            toastr.info(`Extension ${extensionName} is already disabled.`);
 +            return internalExtensionName;
 +        }
++
 +        if (action === 'toggle') {
 +            action = isEnabled ? 'disable' : 'enable';
 +        }
++
 +        reload && toastr.info(`${action.charAt(0).toUpperCase() + action.slice(1)}ing extension ${extensionName} and reloading...`);
++
 +        if (action === 'enable') {
             await enableExtension(internalExtensionName, reload);
 -        toastr.success(`Extension ${extensionName} ${enable ? 'enabled' : 'disabled'}.`);
 +        } else {
 +            await disableExtension(internalExtensionName, reload);
 +        }
++
 +        toastr.success(`Extension ${extensionName} ${action}d.`);
         return internalExtensionName;
     };

 function registerExtensionSlashCommands() {
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'extension-enable',
         callback: getExtensionToggleCallbackgetExtensionActionCallback(true'enable'),
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'reload',

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'extension-disable',
         callback: getExtensionToggleCallbackgetExtensionActionCallback(false'enable'),
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'reload',

             </div>
         `,
     }));
 +    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
 +        name: 'extension-toggle',
 +        callback: async (args, extensionName) => {
 +            if (args?.state instanceof SlashCommandClosure) throw new Error('\'state\' argument cannot be a closure.');
 +            if (typeof extensionName !== 'string') throw new Error('Extension name does only support string. Closures or arrays are not allowed.');
++
 +            const action = isTrueBoolean(args?.state) ? 'enable' :
 +                isFalseBoolean(args?.state) ? 'disable' :
 +                    'toggle';
++
 +            return await getExtensionActionCallback(action)(args, extensionName);
 +        },
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'reload',
 +                description: 'Whether to reload the page after toggling the extension',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                defaultValue: 'true',
 +                enumList: commonEnumProviders.boolean('trueFalse')(),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'state',
 +                description: 'Explicitly set the state of the extension (true to enable, false to disable). If not provided, the state will be toggled to the opposite of the current state.',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                enumList: commonEnumProviders.boolean('trueFalse')(),
 +            }),
 +        ],
 +        unnamedArgumentList: [
 +            SlashCommandArgument.fromProps({
 +                description: 'Extension name',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                isRequired: true,
 +                enumProvider: () => extensionNames.map(name => new SlashCommandEnumValue(name)),
 +                forceEnum: true,
 +            }),
 +        ],
 +        helpString: `
 +            <div>
 +                Toggles the state of a specified extension.
 +            </div>
 +            <div>
 +                By default, the page will be reloaded automatically, stopping any further commands.<br />
 +                If <code>reload=false</code> named argument is passed, the page will not be reloaded, and the extension will stay in its current state until refreshed.
 +                The page either needs to be refreshed, or <code>/reload-page</code> has to be called.
 +            </div>
 +            <div>
 +                <strong>Example:</strong>
 +                <ul>
 +                    <li>
 +                        <pre><code class="language-stscript">/extension-toggle Summarize</code></pre>
 +                    </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/extension-toggle Summarize state=true</code></pre>
 +                    </li>
 +                </ul>
 +            </div>
 +        `,
 +    }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'reload-page',