Merge pull request #2917 from SillyTavern/st-parser-accept-multiple-named STscript allow named arguments to be an array

53424d4c8e5a8ee9b8d53723de27a2500aec6186

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

Signed

Parents: 14b48c5b346fe5d38919c5a5c13410f9cf802935 c3d5fba598ca07a36ff28b3697fd6403c628682e

public/scripts/slash-commands.js+6 -0 Viewed

     const prompts = promptManager.serviceSettings.prompts;
     function parseArgs(arg) {
 +        // Arg is already an array
 +        if (Array.isArray(arg)) {
 +            return arg;
 +        }
         const list = [];
         try {
 +            // Arg is a JSON-stringified array
             const parsedArg = JSON.parse(arg);
             list.push(...Array.isArray(parsedArg) ? parsedArg : [arg]);
         } catch {
 +            // Arg is a string
             list.push(arg);
+        }
         return list;

public/scripts/slash-commands/SlashCommand.js+2 -2 Viewed

  * _abortController:SlashCommandAbortController,
  * _debugController:SlashCommandDebugController,
  * _hasUnnamedArgument:boolean,
  * [id:string]:string|SlashCommandClosure|(string|SlashCommandClosure)[],
  * }} NamedArguments
  */
 /**
  * Alternative object for local JSDocs, where you don't need existing pipe, scope, etc. arguments
  * @typedef {{[id:string]:string|SlashCommandClosure|(string|SlashCommandClosure)[]}} NamedArgumentsCapture
  */
 /**

public/scripts/slash-commands/SlashCommandClosure.js+52 -11 Viewed

 import { delay, escapeRegex, uuidv4 } from '../utils.js';
 import { SlashCommand } from './SlashCommand.js';
 import { SlashCommandAbortController } from './SlashCommandAbortController.js';
 +import { SlashCommandNamedArgument } from './SlashCommandArgument.js';
 import { SlashCommandBreak } from './SlashCommandBreak.js';
 import { SlashCommandBreakController } from './SlashCommandBreakController.js';
 import { SlashCommandBreakPoint } from './SlashCommandBreakPoint.js';

+     *
      * @param {string} text
      * @param {SlashCommandScope} scope
 -     * @returns
 +     * @returns {string|SlashCommandClosure|(string|SlashCommandClosure)[]}
      */
     substituteParams(text, scope = null) {
         let isList = false;

      * @param {import('./SlashCommand.js').NamedArguments} args
      */
     async substituteNamedArguments(executor, args) {
 +        /**
 +         * Handles the assignment of named arguments, considering if they accept multiple values
 +         * @param {string} name The name of the argument, as defined for the command execution
 +         * @param {string|SlashCommandClosure|(string|SlashCommandClosure)[]} value The value to be assigned
 +         */
 +        const assign = (name, value) => {
 +            // If an array is supposed to be assigned, assign it one by one
 +            if (Array.isArray(value)) {
 +                for (const val of value) {
 +                    assign(name, val);
 +                }
 +                return;
 +            }
++
 +            const definition = executor.command.namedArgumentList.find(x => x.name == name);
++
 +            // Prefer definition name if a valid named args defintion is found
 +            name = definition?.name ?? name;
++
 +            // Unescape named argument
 +            if (value && typeof value == 'string') {
 +                value = value
 +                    .replace(/\\\{/g, '{')
 +                    .replace(/\\\}/g, '}');
 +            }
++
 +            // If the named argument accepts multiple values, we have to make sure to build an array correctly
 +            if (definition?.acceptsMultiple) {
 +                if (args[name] !== undefined) {
 +                    // If there already is something for that named arg, make the value is an array and add to it
 +                    let currentValue = args[name];
 +                    if (!Array.isArray(currentValue)) {
 +                        currentValue = [currentValue];
 +                    }
 +                    currentValue.push(value);
 +                    args[name] = currentValue;
 +                } else {
 +                    // If there is nothing in there, we create an array with that singular value
 +                    args[name] = [value];
 +                }
 +            } else {
 +                args[name] !== undefined && console.debug(`Named argument assigned multiple times: ${name}`);
 +                args[name] = value;
 +            }
 +        };
++
         // substitute named arguments
         for (const arg of executor.namedArgumentList) {
             if (arg.value instanceof SlashCommandClosure) {

@@ -390,19 +437,12 @@ export class SlashCommandClosure {
390	437	closure.debugController = this.debugController;
391	438	}
392	439	if (closure.executeNow) {
393	440	args[assign(arg.name] =, (await closure.execute())?.pipe);
394	441	} else {
395	442	args[assign(arg.name] =, closure);
396	443	}
397	444	} else {
398	445	args[assign(arg.name] =, this.substituteParams(arg.value));
399		- }
400		- // unescape named argument
401		- if (typeof args[arg.name] == 'string') {
402		- args[arg.name] = args[arg.name]
403		- ?.replace(/\\\{/g, '{')
404		- ?.replace(/\\\}/g, '}')
405		- ;
406	446	}
407	447	}
408	448	}

         } else {
             value = [];
             for (let i = 0; i < executor.unnamedArgumentList.length; i++) {
 +                /** @type {string|SlashCommandClosure|(string|SlashCommandClosure)[]} */
                 let v = executor.unnamedArgumentList[i].value;
                 if (v instanceof SlashCommandClosure) {
                     /**@type {SlashCommandClosure}*/