Merge pull request #3651 from SillyTavern/input-handling-args Add `/input` arguments to execute closures on success and on cancel

64206d6f47a13c79b6f82e3bb796b742ed83a98c

Cohee <18619528+Cohee1207@users.noreply.github.com>

Signed

Parents: d4f6373bbcf4e5b5401f92183240415a338fab0e fc1c76728060746f87de64d88dbc7330b3ec63fc

public/scripts/slash-commands.js+66 -19 Viewed

 import { SlashCommandAbortController } from './slash-commands/SlashCommandAbortController.js';
 import { SlashCommandNamedArgumentAssignment } from './slash-commands/SlashCommandNamedArgumentAssignment.js';
 import { SlashCommandEnumValue, enumTypes } from './slash-commands/SlashCommandEnumValue.js';
 import { POPUP_RESULT, POPUP_TYPE, Popup, callGenericPopup } from './popup.js';
 import { commonEnumProviders, enumIcons } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { SlashCommandBreakController } from './slash-commands/SlashCommandBreakController.js';
 import { SlashCommandExecutionError } from './slash-commands/SlashCommandExecutionError.js';

         callback: inputCallback,
         returns: 'user input',
         namedArgumentList: [
             new SlashCommandNamedArgument.fromProps({
 -                'default', 'default value of the input field', [ARGUMENT_TYPE.STRING], false, false, '"string"',
 +                name: 'default',
 -            ),
 +                description: 'default value of the input field',
 -            new SlashCommandNamedArgument(
 +                typeList: [ARGUMENT_TYPE.STRING],
 -                'large', 'show large input field', [ARGUMENT_TYPE.BOOLEAN], false, false, 'off', commonEnumProviders.boolean('onOff')(),
 +            }),
 -            ),
 +            SlashCommandNamedArgument.fromProps({
 -            new SlashCommandNamedArgument(
 +                name: 'large',
 -                'wide', 'show wide input field', [ARGUMENT_TYPE.BOOLEAN], false, false, 'off', commonEnumProviders.boolean('onOff')(),
 +                description: 'show large input field',
 -            ),
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 -            new SlashCommandNamedArgument(
 +                defaultValue: 'off',
 -                'okButton', 'text for the ok button', [ARGUMENT_TYPE.STRING], false,
 +                enumList: commonEnumProviders.boolean('onOff')(),
             }),
             new SlashCommandNamedArgument.fromProps({
 -                'rows', 'number of rows for the input field', [ARGUMENT_TYPE.NUMBER], false,
 +                name: 'wide',
 -            ),
 +                description: 'show wide input field',
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                defaultValue: 'off',
 +                enumList: commonEnumProviders.boolean('onOff')(),
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'okButton',
 +                description: 'text for the ok button',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                defaultValue: 'Ok',
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'rows',
 +                description: 'number of rows for the input field',
 +                typeList: [ARGUMENT_TYPE.NUMBER],
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'onSuccess',
 +                description: 'closure to execute when the ok button is clicked or the input is closed as successful (via Enter, etc)',
 +                typeList: [ARGUMENT_TYPE.CLOSURE],
 +            }),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'onCancel',
 +                description: 'closure to execute when the cancel button is clicked or the input is closed as cancelled (via Escape, etc)',
 +                typeList: [ARGUMENT_TYPE.CLOSURE],
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument.fromProps({
                 description: 'text to display', [ARGUMENT_TYPE.STRING], false,
 -            ),
 +                typeList: [ARGUMENT_TYPE.STRING],
 +            }),
         ],
         helpString: `
         <div>

     return '';
+}
++
 async function inputCallback(args, prompt) {
     const safeValue = DOMPurify.sanitize(prompt || '');
     const defaultInput = args?.default !== undefined && typeof args?.default === 'string' ? args.default : '';

     await delay(1);
     const result = await callGenericPopup(safeValue, POPUP_TYPE.INPUT, defaultInput, popupOptions);
     await delay(1);
++
 +    // Input will return null on nothing entered, and false on cancel clicked
 +    if (result === null || result === false) {
 +        // Veryify if a cancel handler exists and it is valid
 +        if (args?.onCancel) {
 +            if (!(args.onCancel instanceof SlashCommandClosure)) {
 +                throw new Error('argument \'onCancel\' must be a closure for command /input');
 +            }
 +            await args.onCancel.execute();
 +        }
 +    } else {
 +        // Verify if an ok handler exists and it is valid
 +        if (args?.onSuccess) {
 +            if (!(args.onSuccess instanceof SlashCommandClosure)) {
 +                throw new Error('argument \'onSuccess\' must be a closure for command /input');
 +            }
 +            await args.onSuccess.execute();
 +        }
 +    }
++
     return String(result || '');
+}