b025765a · permissionBRICK/SillyTavern

 import { SlashCommandEnumValue, enumTypes } from './slash-commands/SlashCommandEnumValue.js';
 import { PARSER_FLAG, SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { SlashCommandScope } from './slash-commands/SlashCommandScope.js';
-import { isFalseBoolean, convertValueType } from './utils.js';
+import { isFalseBoolean, convertValueType, isTrueBoolean } from './utils.js';
 /** @typedef {import('./slash-commands/SlashCommandParser.js').NamedArguments} NamedArguments */
 /** @typedef {import('./slash-commands/SlashCommand.js').UnnamedArguments} UnnamedArguments */

 /**
  * Parses boolean operands from command arguments.
  * @param {object} args Command arguments
- * @returns {{a: string | number, b: string | number, rule: string}} Boolean operands
+ * @returns {{a: string | number, b: string | number?, rule: string}} Boolean operands
  */
 export function parseBooleanOperands(args) {
     // Resolution order: numeric literal, local variable, global variable, string literal

      */
     function getOperand(operand) {
         if (operand === undefined) {
+            return undefined;
+        }
+        if (operand === '') {
             return '';
+        }

         return stringLiteral || '';
+    }
-    const left = getOperand(args.a || args.left || args.first || args.x);
+    const left = getOperand(args.a ?? args.left ?? args.first ?? args.x);
-    const right = getOperand(args.b || args.right || args.second || args.y);
+    const right = getOperand(args.b ?? args.right ?? args.second ?? args.y);
     const rule = args.rule;
     return { a: left, b: right, rule };

 /**
  * Evaluates a boolean comparison rule.
- * @param {string} rule Boolean comparison rule
+ *
+ * @param {string?} rule Boolean comparison rule
  * @param {string|number} a The left operand
- * @param {string|number} b The right operand
+ * @param {string|number?} b The right operand
  * @returns {boolean} True if the rule yields true, false otherwise
  */
 export function evalBoolean(rule, a, b) {
-    if (!rule) {
+    if (a === undefined) {
-        toastr.warning('The rule must be specified for the boolean comparison.', 'Invalid command');
+        throw new Error('Left operand is not provided');
-        throw new Error('Invalid command.');
+    }
+    // If right-hand side was not provided, whe just check if the left side is truthy
+    if (b === undefined) {
+        switch (rule) {
+            case undefined:
+            case 'not': {
+                const resultOnTruthy = rule !== 'not';
+                if (isTrueBoolean(String(a))) return resultOnTruthy;
+                if (isFalseBoolean(String(a))) return !resultOnTruthy;
+                return a ? resultOnTruthy : !resultOnTruthy;
+            }
+            default:
+                throw new Error(`Unknown boolean comparison rule for truthy check. If right operand is not provided, the rule must not provided or be 'not'. Provided: ${rule}`);
+        }
+    }
-    let result = false;
+    // If no rule was provided, we are implicitly using 'eq', as defined for the slash commands
+    rule ??= 'eq';
     if (typeof a === 'number' && typeof b === 'number') {
         // only do numeric comparison if both operands are numbers
         const aNumber = Number(a);
         const bNumber = Number(b);
         switch (rule) {
-            case 'not':
-                result = !aNumber;
-                break;
             case 'gt':
-                result = aNumber > bNumber;
+                return aNumber > bNumber;
-                break;
             case 'gte':
-                result = aNumber >= bNumber;
+                return aNumber >= bNumber;
-                break;
             case 'lt':
-                result = aNumber < bNumber;
+                return aNumber < bNumber;
-                break;
             case 'lte':
-                result = aNumber <= bNumber;
+                return aNumber <= bNumber;
-                break;
             case 'eq':
-                result = aNumber === bNumber;
+                return aNumber === bNumber;
-                break;
             case 'neq':
-                result = aNumber !== bNumber;
+                return aNumber !== bNumber;
-                break;
-            default:
-                toastr.error('Unknown boolean comparison rule for type number.', 'Invalid command');
-                throw new Error('Invalid command.');
-        }
-    } else {
-        // otherwise do case-insensitive string comparsion, stringify non-strings
-        let aString;
-        let bString;
-        if (typeof a == 'string') {
-            aString = a.toLowerCase();
-        } else {
-            aString = JSON.stringify(a).toLowerCase();
-        }
-        if (typeof b == 'string') {
-            bString = b.toLowerCase();
-        } else {
-            bString = JSON.stringify(b).toLowerCase();
-        }
-        switch (rule) {
             case 'in':
-                result = aString.includes(bString);
-                break;
             case 'nin':
-                result = !aString.includes(bString);
+                // Fall through to string comparison. Otherwise you could not check if 12345 contains 45 for example.
-                break;
+                console.debug(`Boolean comparison rule '${rule}' is not supported for type number. Falling back to string comparison.`);
-            case 'eq':
-                result = aString === bString;
-                break;
-            case 'neq':
-                result = aString !== bString;
                 break;
             default:
-                toastr.error('Unknown boolean comparison rule for type string.', 'Invalid /if command');
+                throw new Error(`Unknown boolean comparison rule for type number. Accepted: gt, gte, lt, lte, eq, neq. Provided: ${rule}`);
-                throw new Error('Invalid command.');
+        }
+    }
-    return result;
+    // otherwise do case-insensitive string comparsion, stringify non-strings
+    let aString = (typeof a === 'string') ? a.toLowerCase() : JSON.stringify(a).toLowerCase();
+    let bString = (typeof b === 'string') ? b.toLowerCase() : JSON.stringify(b).toLowerCase();
+    switch (rule) {
+        case 'in':
+            return aString.includes(bString);
+        case 'nin':
+            return !aString.includes(bString);
+        case 'eq':
+            return aString === bString;
+        case 'neq':
+            return aString !== bString;
+        default:
+            throw new Error(`Unknown boolean comparison rule for type number. Accepted: in, nin, eq, neq. Provided: ${rule}`);
+    }
+}
 /**

                 typeList: [ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all'),
-                forceEnum: false,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'right',
                 description: 'right operand',
                 typeList: [ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER],
-                isRequired: true,
                 enumProvider: commonEnumProviders.variables('all'),
-                forceEnum: false,
             }),
-            new SlashCommandNamedArgument(
+            SlashCommandNamedArgument.fromProps({
-                'rule', 'comparison rule', [ARGUMENT_TYPE.STRING], true, false, null, [
+                name: 'rule',
-                new SlashCommandEnumValue('gt', 'a > b'),
+                description: 'comparison rule',
-                new SlashCommandEnumValue('gte', 'a >= b'),
+                typeList: [ARGUMENT_TYPE.STRING],
-                new SlashCommandEnumValue('lt', 'a < b'),
+                defaultValue: 'eq',
-                new SlashCommandEnumValue('lte', 'a <= b'),
+                enumList: [
-                new SlashCommandEnumValue('eq', 'a == b'),
+                    new SlashCommandEnumValue('eq', 'a == b (strings & numbers)'),
-                new SlashCommandEnumValue('neq', 'a !== b'),
+                    new SlashCommandEnumValue('neq', 'a !== b (strings & numbers)'),
-                new SlashCommandEnumValue('not', '!a'),
+                    new SlashCommandEnumValue('in', 'a includes b (strings & numbers as strings)'),
-                new SlashCommandEnumValue('in', 'a includes b'),
+                    new SlashCommandEnumValue('nin', 'a not includes b (strings & numbers as strings)'),
-                new SlashCommandEnumValue('nin', 'a not includes b'),
+                    new SlashCommandEnumValue('gt', 'a > b (numbers)'),
-            ],
+                    new SlashCommandEnumValue('gte', 'a >= b (numbers)'),
-            ),
+                    new SlashCommandEnumValue('lt', 'a < b (numbers)'),
-            new SlashCommandNamedArgument(
+                    new SlashCommandEnumValue('lte', 'a <= b (numbers)'),
-                'else', 'command to execute if not true', [ARGUMENT_TYPE.CLOSURE, ARGUMENT_TYPE.SUBCOMMAND], false,
+                    new SlashCommandEnumValue('not', '!a (truthy)'),
-            ),
+                ],
+                forceEnum: true,
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'else',
+                description: 'command to execute if not true',
+                typeList: [ARGUMENT_TYPE.CLOSURE, ARGUMENT_TYPE.SUBCOMMAND],
+            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

                 Numeric values and string literals for left and right operands supported.
             </div>
             <div>
+                If the rule is not provided, it defaults to <code>eq</code>.
+            </div>
+            <div>
+                If no right operand is provided, it defaults to checking the <code>left</code> value to be truthy.
+                A non-empty string or non-zero number is considered truthy, as is the value <code>true</code> or <code>on</code>.<br />
+                Only acceptable rules for no provided right operand are <code>not</code>, and no provided rule - which default to returning whether it is not or is truthy.
+            </div>
+            <div>
                 <strong>Available rules:</strong>
                 <ul>
-                    <li>gt => a > b</li>
+                    <li><code>eq</code> => a == b <small>(strings & numbers)</small></li>
-                    <li>gte => a >= b</li>
+                    <li><code>neq</code> => a !== b <small>(strings & numbers)</small></li>
-                    <li>lt => a < b</li>
+                    <li><code>in</code> => a includes b <small>(strings & numbers as strings)</small></li>
-                    <li>lte => a <= b</li>
+                    <li><code>nin</code> => a not includes b <small>(strings & numbers as strings)</small></li>
-                    <li>eq => a == b</li>
+                    <li><code>gt</code> => a > b <small>(numbers)</small></li>
-                    <li>neq => a != b</li>
+                    <li><code>gte</code> => a >= b <small>(numbers)</small></li>
-                    <li>not => !a</li>
+                    <li><code>lt</code> => a < b <small>(numbers)</small></li>
-                    <li>in (strings) => a includes b</li>
+                    <li><code>lte</code> => a <= b <small>(numbers)</small></li>
-                    <li>nin (strings) => a not includes b</li>
+                    <li><code>not</code> => !a <small>(truthy)</small></li>
                 </ul>
             </div>
             <div>

                         <pre><code class="language-stscript">/if left=score right=10 rule=gte "/speak You win"</code></pre>
                         triggers a /speak command if the value of "score" is greater or equals 10.
                     </li>
+                    <li>
+                        <pre><code class="language-stscript">/if left={{lastMessage}} rule=in right=surprise {: /echo SURPISE! :}</code></pre>
+                        executes a subcommand defined as a closure if the given value contains a specified word.
+                    <li>
+                        <pre><code class="language-stscript">/if left=myContent {: /echo My content had some content. :}</code></pre>
+                        executes the defined subcommand, if the provided value of left is truthy (contains some kind of contant that is not empty or false)
+                    </li>
+                    <li>
+                        <pre><code class="language-stscript">/if left=tree right={{getvar::object}} {: /echo The object is a tree! :}</code></pre>
+                        executes the defined subcommand, if the left and right values are equals.
+                    </li>
                 </ul>
             </div>
         `,

                 typeList: [ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER],
                 isRequired: true,
                 enumProvider: commonEnumProviders.variables('all'),
-                forceEnum: false,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'right',
                 description: 'right operand',
                 typeList: [ARGUMENT_TYPE.VARIABLE_NAME, ARGUMENT_TYPE.STRING, ARGUMENT_TYPE.NUMBER],
-                isRequired: true,
                 enumProvider: commonEnumProviders.variables('all'),
-                forceEnum: false,
             }),
-            new SlashCommandNamedArgument(
+            SlashCommandNamedArgument.fromProps({
-                'rule', 'comparison rule', [ARGUMENT_TYPE.STRING], true, false, null, [
+                name: 'rule',
-                new SlashCommandEnumValue('gt', 'a > b'),
+                description: 'comparison rule',
-                new SlashCommandEnumValue('gte', 'a >= b'),
+                typeList: [ARGUMENT_TYPE.STRING],
-                new SlashCommandEnumValue('lt', 'a < b'),
+                defaultValue: 'eq',
-                new SlashCommandEnumValue('lte', 'a <= b'),
+                enumList: [
-                new SlashCommandEnumValue('eq', 'a == b'),
+                    new SlashCommandEnumValue('eq', 'a == b (strings & numbers)'),
-                new SlashCommandEnumValue('neq', 'a !== b'),
+                    new SlashCommandEnumValue('neq', 'a !== b (strings & numbers)'),
-                new SlashCommandEnumValue('not', '!a'),
+                    new SlashCommandEnumValue('in', 'a includes b (strings & numbers as strings)'),
-                new SlashCommandEnumValue('in', 'a includes b'),
+                    new SlashCommandEnumValue('nin', 'a not includes b (strings & numbers as strings)'),
-                new SlashCommandEnumValue('nin', 'a not includes b'),
+                    new SlashCommandEnumValue('gt', 'a > b (numbers)'),
-            ],
+                    new SlashCommandEnumValue('gte', 'a >= b (numbers)'),
-            ),
+                    new SlashCommandEnumValue('lt', 'a < b (numbers)'),
-            new SlashCommandNamedArgument(
+                    new SlashCommandEnumValue('lte', 'a <= b (numbers)'),
-                'guard', 'disable loop iteration limit', [ARGUMENT_TYPE.STRING], false, false, null, commonEnumProviders.boolean('onOff')(),
+                    new SlashCommandEnumValue('not', '!a (truthy)'),
-            ),
+                ],
+                forceEnum: true,
+            }),
+            SlashCommandNamedArgument.fromProps({
+                name: 'guard',
+                description: 'disable loop iteration limit',
+                typeList: [ARGUMENT_TYPE.STRING],
+                defaultValue: 'off',
+                enumList: commonEnumProviders.boolean('onOff')(),
+            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

             <div>
                 <strong>Available rules:</strong>
                 <ul>
-                    <li>gt => a > b</li>
+                    <li><code>eq</code> => a == b <small>(strings & numbers)</small></li>
-                    <li>gte => a >= b</li>
+                    <li><code>neq</code> => a !== b <small>(strings & numbers)</small></li>
-                    <li>lt => a < b</li>
+                    <li><code>in</code> => a includes b <small>(strings & numbers as strings)</small></li>
-                    <li>lte => a <= b</li>
+                    <li><code>nin</code> => a not includes b <small>(strings & numbers as strings)</small></li>
-                    <li>eq => a == b</li>
+                    <li><code>gt</code> => a > b <small>(numbers)</small></li>
-                    <li>neq => a != b</li>
+                    <li><code>gte</code> => a >= b <small>(numbers)</small></li>
-                    <li>not => !a</li>
+                    <li><code>lt</code> => a < b <small>(numbers)</small></li>
-                    <li>in (strings) => a includes b</li>
+                    <li><code>lte</code> => a <= b <small>(numbers)</small></li>
-                    <li>nin (strings) => a not includes b</li>
+                    <li><code>not</code> => !a <small>(truthy)</small></li>
                 </ul>
             </div>
             <div>

                         <pre><code class="language-stscript">/setvar key=i 0 | /while left=i right=10 rule=lte "/addvar key=i 1"</code></pre>
                         adds 1 to the value of "i" until it reaches 10.
                     </li>
-                </ul>
+                    <li>
+                        <pre><code class="language-stscript">/while left={{getvar::currentword}} {: /setvar key=currentword {: /do-something-and-return :}() | /echo The current work is "{{getvar::currentword}}" :}</code></pre>
+                        executes the defined subcommand as long as the "currentword" variable is truthy (has any content that is not false/empty)
+                        </ul>
+                        </li>
             </div>
             <div>
                 Loops are limited to 100 iterations by default, pass <code>guard=off</code> to disable.

                 typeList: [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.VARIABLE_NAME],
                 isRequired: true,
                 acceptsMultiple: true,
-                enumProvider: (executor, scope)=>{
+                enumProvider: (executor, scope) => {
                     const vars = commonEnumProviders.variables('all')(executor, scope);
                     vars.push(
                         new SlashCommandEnumValue(

                             null,
                             enumTypes.variable,
                             enumIcons.variable,
-                            (input)=>/^\w*$/.test(input),
+                            (input) => /^\w*$/.test(input),
-                            (input)=>input,
+                            (input) => input,
                         ),
                         new SlashCommandEnumValue(
                             'any number',
                             null,
                             enumTypes.number,
                             enumIcons.number,
-                            (input)=>input == '' || !Number.isNaN(Number(input)),
+                            (input) => input == '' || !Number.isNaN(Number(input)),
-                            (input)=>input,
+                            (input) => input,
                         ),
                     );
                     return vars;

Merge pull request #2891 from SillyTavern/if-command-default-arguments `/if` and `/while` now allow "right" and "rule" to be optional