Merge pull request #3776 from SillyTavern/fix/raw-quotes Add opt-in for rawQuotes in SlashCommand registration

2271d7a22082dc6fa9fa9bc4069c62e49d0ebece

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

Signed

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

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'sendas',
+        rawQuotes: true,
         callback: sendMessageAs,
         returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'sys',
+        rawQuotes: true,
         callback: sendNarratorMessage,
         aliases: ['nar'],
         returns: 'Optionally the text of the sent message, if specified in the "return" argument',

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'comment',
+        rawQuotes: true,
         callback: sendCommentMessage,
         returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'send',
+        rawQuotes: true,
         callback: sendUserMessageCallback,
         returns: 'Optionally the text of the sent message, if specified in the "return" argument',
         namedArgumentList: [

     }));
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'echo',
+        rawQuotes: true,
         callback: echoCallback,
         returns: 'the text',
         namedArgumentList: [

public/scripts/slash-commands/SlashCommand.js+12 -0 Viewed

 import { hljs } from '../../lib.js';
+import { t } from '../i18n.js';
 import { SlashCommandAbortController } from './SlashCommandAbortController.js';
 import { SlashCommandArgument, SlashCommandNamedArgument } from './SlashCommandArgument.js';
 import { SlashCommandClosure } from './SlashCommandClosure.js';

      * @param {string} [props.helpString]
      * @param {boolean} [props.splitUnnamedArgument]
      * @param {Number} [props.splitUnnamedArgumentCount]
+     * @param {boolean} [props.rawQuotes] If set to true, does not remove wrapping quotes from the unnamed argument.
      * @param {string[]} [props.aliases]
      * @param {string} [props.returns]
      * @param {SlashCommandNamedArgument[]} [props.namedArgumentList]

     /**@type {string}*/ helpString;
     /**@type {boolean}*/ splitUnnamedArgument = false;
     /**@type {Number}*/ splitUnnamedArgumentCount;
+    /** @type {boolean} */ rawQuotes = false;
     /**@type {string[]}*/ aliases = [];
     /**@type {string}*/ returns;
     /**@type {SlashCommandNamedArgument[]}*/ namedArgumentList = [];

                         ].filter(it=>it).join('\n');
                         head.append(src);
+                    }
+                    if (this.rawQuotes) {
+                        const rawQuotes = document.createElement('div'); {
+                            rawQuotes.classList.add('rawQuotes');
+                            rawQuotes.classList.add('fa-solid');
+                            rawQuotes.classList.add('fa-quote-left');
+                            rawQuotes.title = t`Does not alter quoted literal unnamed arguments`;
+                            head.append(rawQuotes);
+                        }
+                    }
                     specs.append(head);
+                }
                 const body = document.createElement('div'); {

public/scripts/slash-commands/SlashCommandParser.js+3 -3 Viewed

         cmd.startUnnamedArgs = this.index - (/\s(\s*)$/s.exec(this.behind)?.[1]?.length ?? 0);
         cmd.endUnnamedArgs = this.index;
         if (this.testUnnamedArgument()) {
-            cmd.unnamedArgumentList = this.parseUnnamedArgument(cmd.command?.unnamedArgumentList?.length && cmd?.command?.splitUnnamedArgument, cmd?.command?.splitUnnamedArgumentCount);
+            cmd.unnamedArgumentList = this.parseUnnamedArgument(cmd.command?.unnamedArgumentList?.length && cmd?.command?.splitUnnamedArgument, cmd?.command?.splitUnnamedArgumentCount, cmd?.command?.rawQuotes);
             cmd.endUnnamedArgs = this.index;
             if (cmd.name == 'let') {
                 const keyArg = cmd.namedArgumentList.find(it=>it.name == 'key');

     testUnnamedArgumentEnd() {
         return this.testCommandEnd();
+    }
-    parseUnnamedArgument(split, splitCount = null) {
+    parseUnnamedArgument(split, splitCount = null, rawQuotes = false) {
         const wasSplit = split;
         /**@type {SlashCommandClosure|String}*/
         let value = this.jumpedEscapeSequence ? this.take() : ''; // take the first, already tested, char if it is an escaped one

         /**@type {SlashCommandUnnamedArgumentAssignment}*/
         let assignment = new SlashCommandUnnamedArgumentAssignment();
         assignment.start = this.index;
-        if (!split && this.testQuotedValue()) {
+        if (!split && !rawQuotes && this.testQuotedValue()) {
             // if the next bit is a quoted value, take the whole value and gather contents as a list
             assignment.value = this.parseQuotedValue();
             assignment.end = this.index;

public/style.css+9 -0 Viewed

+            }
+        }
+        >.head>.rawQuotes {
+            padding: 0 0.5em;
+            cursor: help;
+            &:hover {
+                text-decoration: 1px dotted underline;
+            }
+        }
         >.head>.source {
             padding: 0 0.5em;
             cursor: help;