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>format</code> argument to change the output format.',
+        helpString: 'Lists all script injections for the current chat. Displays injects in a popup by default. Use the <code>return</code> argument to change the return type.',
         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: 'object',
+                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: 'DEPRECATED - use "return" instead - output 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 ?? 'object', chat_metadata.script_injects, { objectToStringFunc: buildTextValue });
+    return await slashCommandReturnHelper.doReturn(returnType ?? 'popup-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(stringValue, null, { escapeHtml: !shouldHtml }); // Toastr handles HTML conversion internally already
+                if (type.startsWith('toast')) toastr.info(shouldHtml ? makeHtml(stringValue) : escapeHtml(stringValue), null, { escapeHtml: !shouldHtml });
                 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 jsonVariables = [
+    const buildTextValue = (_) => {
-        ...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>format</code> argument to change the output format.',
+        helpString: 'List registered chat variables. Displays variables in a popup by default. Use the <code>return</code> argument to change the return type.',
         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,