STscript allow named arguments to be an array - Use named args definition and "acceptsMultiple" to build arrays of values, if provided - Add a debug warning if non-multiple named args are provided multiple times

2444e9be43fe2824423716e9ae5c9a34174d70c0

Wolfsblvt <wolfsblvt@gmail.com>

Parents: c47e19866420b9d67239312d47beea072850800c

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

  * _abortController:SlashCommandAbortController,
  * _debugController:SlashCommandDebugController,
  * _hasUnnamedArgument:boolean,
- * [id:string]:string|SlashCommandClosure,
+ * [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}} NamedArgumentsCapture
+ * @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, just assign it as singular value, until multiple values are found
+                    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	closure.debugController = this.debugController;	437	closure.debugController = this.debugController;
391	}	438	}
392	if (closure.executeNow) {	439	if (closure.executeNow) {
393	args[arg.name] = (await closure.execute())?.pipe;	440	assign(arg.name, (await closure.execute())?.pipe);
394	} else {	441	} else {
395	args[arg.name] = closure;	442	assign(arg.name, closure);
396	}	443	}
397	} else {	444	} else {
398	args[arg.name] = this.substituteParams(arg.value);	445	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}*/