aea95adf · 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, 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
  */
 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 '';
+        }

@@ -500,9 +503,9 @@ export function parseBooleanOperands(args) {
500	503	return stringLiteral \|\| '';
501	504	}
502	505
503	506	const left = getOperand(args.a \|\|?? args.left \|\|?? args.first \|\|?? args.x);
504	507	const right = getOperand(args.b \|\|?? args.right \|\|?? args.second \|\|?? args.y);
505	508	const rule = args.rule ?? 'eq';
506	509
507	510	return { a: left, b: right, rule };
508	511	}

  * Evaluates a boolean comparison rule.
  * @param {string} rule Boolean comparison rule
  * @param {string|number} a The left 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) {
 +    let result = false;
 -        toastr.warning('The rule must be specified for the boolean comparison.', 'Invalid command');
++
 -        throw new Error('Invalid command.');
 +    if (b === undefined && rule === 'eq') {
 +        // If right-hand side was not provided, whe just check if the left side is truthy
 +        if (isTrueBoolean(String(a))) return true;
 +        if (isFalseBoolean(String(a))) return false;
 +        return !!a;
+    }
 -    let result = false;
 +    // Restore old behavior, where b cannot be undefined
 +    b = b ?? '';
++
     if (typeof a === 'number' && typeof b === 'number') {
         // only do numeric comparison if both operands are numbers
         const aNumber = Number(a);

@@ -582,7 +591,7 @@ export function evalBoolean(rule, a, b) {
582	591	break;
583	592	default:
584	593	toastr.error('Unknown boolean comparison rule for type string.', 'Invalid /if command');
585	594	throw new Error('InvalidUnknown commandboolean comparison rule for type string.');
586	595	}
587	596	}
588	597

                 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,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'rule',
                 description: 'comparison rule',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequireddefaultValue: true'eq',
                 enumList: [
                     new SlashCommandEnumValue('gt', 'a > b'),
                     new SlashCommandEnumValue('gte', 'a >= b'),

                     new SlashCommandEnumValue('in', 'a includes b'),
                     new SlashCommandEnumValue('nin', 'a not includes b'),
                 ],
 +                forceEnum: true,
             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'else',
                 description: 'command to execute if not true',
                 typeList: [ARGUMENT_TYPE.CLOSURE, ARGUMENT_TYPE.SUBCOMMAND],
 -                isRequired: false,
             }),
         ],
         unnamedArgumentList: [

                 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>.<br />
 +                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>.
 +            </div>
 +            <div>
                 <strong>Available rules:</strong>
                 <ul>
                     <li>gt => a > b</li>

                         <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>
                 </ul>
             </div>
         `,

/if allow "rule" and "right" to be optional