Refactor /listvar, deprecate its "format" arg - Update /listvar - Fix toasts not doing correct HMTL here

697b3b2034c20ea15e48002929b696f85bfb3a64

Wolfsblvt <wolfsblvt@gmail.com>

Parents: 62fd450c592653fd256eaf631372cd05c72745ae

public/scripts/slash-commands.js+4 -5 Viewed

     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'listinjects',
         callback: listInjectsCallback,
         helpString: 'Lists all script injections for the current chat. Displays injects in a popup by default. Use the <code>formatreturn</code> argument to change the outputreturn formattype.',
         returns: 'Optionalls the JSON object of script injections',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({
                 name: 'return',
                 description: 'The way how you want the return value to be provided',
                 typeList: [ARGUMENT_TYPE.STRING],
                 defaultValue: 'objectpopup-html',
                 enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),
                 forceEnum: true,
             }),
             // TODO remove some day
             SlashCommandNamedArgument.fromProps({
                 name: 'format',
                 description: '!!! DEPRECATED - use "return" instead -!!! output format)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,

+    }
     // Now the actual new return type handling
+-
     const buildTextValue = (injects) => {
         const injectsStr = Object.entries(injects)
             .map(([id, inject]) => {

         return `### Script injections:\n${injectsStr}`;
     };
     return await slashCommandReturnHelper.doReturn(returnType ?? 'objectpopup-html', chat_metadata.script_injects, { objectToStringFunc: buildTextValue });
+}
 /**

public/scripts/slash-commands/SlashCommandReturnHelper.js+1 -1 Viewed

                 if (type.startsWith('popup')) await callGenericPopup(shouldHtml ? makeHtml(stringValue) : escapeHtml(stringValue), POPUP_TYPE.TEXT);
                 if (type.startsWith('chat')) sendSystemMessage(system_message_types.GENERIC, shouldHtml ? makeHtml(stringValue) : escapeHtml(stringValue));
                 if (type.startsWith('toast')) toastr.info(shouldHtml ? makeHtml(stringValue) : escapeHtml(stringValue), null, { escapeHtml: !shouldHtml }); // Toastr handles HTML conversion internally already
                 return '';
+            }

public/scripts/variables.js+45 -22 Viewed

 import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { SlashCommandEnumValue, enumTypes } from './slash-commands/SlashCommandEnumValue.js';
 import { PARSER_FLAG, SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 +import { slashCommandReturnHelper } from './slash-commands/SlashCommandReturnHelper.js';
 import { SlashCommandScope } from './slash-commands/SlashCommandScope.js';
 import { isFalseBoolean, convertValueType, isTrueBoolean } from './utils.js';

+}
 async function listVariablesCallback(args) {
 -    const type = String(args?.format || '').toLowerCase().trim() || 'popup';
 +    /** @type {import('./slash-commands/SlashCommandReturnHelper.js').SlashCommandReturnType} */
 +    let returnType = args.return;
++
 +    // Old legacy return type handling
 +    if (args.format) {
 +        toastr.warning(`Legacy argument 'format' with value '${args.format}' is deprecated. Please use 'return' instead. Routing to the correct return type...`, 'Deprecation warning');
 +        const type = String(args?.format).toLowerCase().trim();
 +        if (!chat_metadata.script_injects || !Object.keys(chat_metadata.script_injects).length) {
 +            type !== 'none' && toastr.info('No script injections for the current chat');
 +        }
 +        switch (type) {
 +            case 'none':
 +                returnType = 'none';
 +                break;
 +            case 'chat':
 +                returnType = 'chat-html';
 +                break;
 +            case 'popup':
 +            default:
 +                returnType = 'popup-html';
 +                break;
 +        }
 +    }
++
 +    // Now the actual new return type handling
     const scope = String(args?.scope || '').toLowerCase().trim() || 'all';
     if (!chat_metadata.variables) {
         chat_metadata.variables = {};

     const localVariables = includeLocalVariables ? Object.entries(chat_metadata.variables).map(([name, value]) => `${name}: ${value}`) : [];
     const globalVariables = includeGlobalVariables ? Object.entries(extension_settings.variables.global).map(([name, value]) => `${name}: ${value}`) : [];
     const jsonVariablesbuildTextValue = [(_) => {
 -        ...Object.entries(chat_metadata.variables).map(x => ({ key: x[0], value: x[1], scope: 'local' })),
 -        ...Object.entries(extension_settings.variables.global).map(x => ({ key: x[0], value: x[1], scope: 'global' })),
 -    ];
+-
         const localVariablesString = localVariables.length > 0 ? localVariables.join('\n\n') : 'No local variables';
         const globalVariablesString = globalVariables.length > 0 ? globalVariables.join('\n\n') : 'No global variables';
         const chatName = getCurrentChatId();
 -    const converter = new showdown.Converter();
         const message = [
             includeLocalVariables ? `### Local variables (${chatName}):\n${localVariablesString}` : '',
             includeGlobalVariables ? `### Global variables:\n${globalVariablesString}` : '',
         ].filter(x => x).join('\n\n');
 -    const htmlMessage = DOMPurify.sanitize(converter.makeHtml(message));
 +        return message;
 +    };
 -    switch (type) {
 +    const jsonVariables = [
 -        case 'none':
 +        ...Object.entries(chat_metadata.variables).map(x => ({ key: x[0], value: x[1], scope: 'local' })),
 -            break;
 +        ...Object.entries(extension_settings.variables.global).map(x => ({ key: x[0], value: x[1], scope: 'global' })),
 -        case 'chat':
 +    ];
 -            sendSystemMessage(system_message_types.GENERIC, htmlMessage);
 -            break;
 -        case 'popup':
 -        default:
 -            await callGenericPopup(htmlMessage, POPUP_TYPE.TEXT);
 -            break;
 -    }
 -    return JSON.stringify(jsonVariables);
 +    return await slashCommandReturnHelper.doReturn(returnType ?? 'popup-html', jsonVariables, { objectToStringFunc: buildTextValue });
+}
 /**

         name: 'listvar',
         callback: listVariablesCallback,
         aliases: ['listchatvar'],
         helpString: 'List registered chat variables. Displays variables in a popup by default. Use the <code>formatreturn</code> argument to change the outputreturn formattype.',
         returns: 'JSON list of local variables',
         namedArgumentList: [
             SlashCommandNamedArgument.fromProps({

                 ],
             }),
             SlashCommandNamedArgument.fromProps({
 +                name: 'return',
 +                description: 'The way how you want the return value to be provided',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'popup-html',
 +                enumList: slashCommandReturnHelper.enumList({ allowPipe: false, allowObject: true, allowChat: true, allowPopup: true, allowTextVersion: false }),
 +                forceEnum: true,
 +            }),
 +            // TODO remove some day
 +            SlashCommandNamedArgument.fromProps({
                 name: 'format',
 -                description: 'output format',
 +                description: '!!! DEPRECATED - use "return" instead !!! output format)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
                 forceEnum: true,