Merge pull request #2731 from SillyTavern/fix-pipe-types Add type conversion for /setvar commands with index

ddd5dc1207da2e6fb741291f9fdf5deaedd1a83c

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

Signed

Parents: 9483052b10fd8666b0f0446dad5233c8628d4fc9 011f785a79cab8d2256486005c0735d8b1a39285

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+17 -0 Viewed

     true: '✔️',
     false: '❌',
 +    null: '🚫',
 +    undefined: '❓',
     // Value types
     boolean: '🔲',

                     enumTypes.enum, '💉');
             });
     },
++
 +    /**
 +     * Gets somewhat recognizable STscript types.
 +     *
 +     * @returns {SlashCommandEnumValue[]}
 +     */
 +    types: () => [
 +        new SlashCommandEnumValue('string', null, enumTypes.type, enumIcons.string),
 +        new SlashCommandEnumValue('number', null, enumTypes.type, enumIcons.number),
 +        new SlashCommandEnumValue('boolean', null, enumTypes.type, enumIcons.boolean),
 +        new SlashCommandEnumValue('array', null, enumTypes.type, enumIcons.array),
 +        new SlashCommandEnumValue('object', null, enumTypes.type, enumIcons.dictionary),
 +        new SlashCommandEnumValue('null', null, enumTypes.type, enumIcons.null),
 +        new SlashCommandEnumValue('undefined', null, enumTypes.type, enumIcons.undefined),
 +    ],
 };

public/scripts/slash-commands/SlashCommandScope.js+6 -5 Viewed

 import { SlashCommandClosure } from './SlashCommandClosure.js';
 +import { convertValueType } from '../utils.js';
 export class SlashCommandScope {
     /**@type {string[]}*/ variableNames = [];

         if (this.existsVariableInScope(key)) throw new SlashCommandScopeVariableExistsError(`Variable named "${key}" already exists.`);
         this.variables[key] = value;
+    }
     setVariable(key, value, index = null, type = null) {
         if (this.existsVariableInScope(key)) {
             if (index !== null && index !== undefined) {
                 let v = this.variables[key];

                     v = JSON.parse(v);
                     const numIndex = Number(index);
                     if (Number.isNaN(numIndex)) {
                         v[index] = convertValueType(value, type);
                     } else {
                         v[numIndex] = convertValueType(value, type);
+                    }
                     v = JSON.stringify(v);
                 } catch {
                     v[index] = convertValueType(value, type);
+                }
                 this.variables[key] = v;
             } else {

@@ -78,7 +79,7 @@ export class SlashCommandScope {
78	79	return value;
79	80	}
80	81	if (this.parent) {
81	82	return this.parent.setVariable(key, value, index, type);
82	83	}
83	84	throw new SlashCommandScopeVariableNotFoundError(`No such variable: "${key}"`);
84	85	}

public/scripts/utils.js+69 -0 Viewed

 import { collapseNewlines } from './power-user.js';
 import { debounce_timeout } from './constants.js';
 import { Popup, POPUP_RESULT, POPUP_TYPE } from './popup.js';
 +import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';
 /**
  * Pagination status string template.

+}
 /**
 + * Converts string to a value of a given type. Includes pythonista-friendly aliases.
 + * @param {string|SlashCommandClosure} value String value
 + * @param {string} type Type to convert to
 + * @returns {any} Converted value
 + */
 +export function convertValueType(value, type) {
 +    if (value instanceof SlashCommandClosure || typeof type !== 'string') {
 +        return value;
 +    }
++
 +    switch (type.trim().toLowerCase()) {
 +        case 'string':
 +        case 'str':
 +            return String(value);
++
 +        case 'null':
 +            return null;
++
 +        case 'undefined':
 +        case 'none':
 +            return undefined;
++
 +        case 'number':
 +            return Number(value);
++
 +        case 'int':
 +            return parseInt(value, 10);
++
 +        case 'float':
 +            return parseFloat(value);
++
 +        case 'boolean':
 +        case 'bool':
 +            return isTrueBoolean(value);
++
 +        case 'list':
 +        case 'array':
 +            try {
 +                const parsedArray = JSON.parse(value);
 +                if (Array.isArray(parsedArray)) {
 +                    return parsedArray;
 +                }
 +                // The value is not an array
 +                return [];
 +            } catch {
 +                return [];
 +            }
++
 +        case 'object':
 +        case 'dict':
 +        case 'dictionary':
 +            try {
 +                const parsedObject = JSON.parse(value);
 +                if (typeof parsedObject === 'object') {
 +                    return parsedObject;
 +                }
 +                // The value is not an object
 +                return {};
 +            } catch {
 +                return {};
 +            }
++
 +        default:
 +            return value;
 +    }
 +}
++
 +/**
  * Parses ranges like 10-20 or 10.
  * Range is inclusive. Start must be less than end.
  * Returns null if invalid.

public/scripts/variables.js+60 -19 Viewed

 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';
 /** @typedef {import('./slash-commands/SlashCommandParser.js').NamedArguments} NamedArguments */
 /** @typedef {import('./slash-commands/SlashCommand.js').UnnamedArguments} UnnamedArguments */

@@ -57,12 +57,12 @@ function setLocalVariable(name, value, args = {}) {
57	57	if (localVariable === null) {
58	58	localVariable = {};
59	59	}
60	60	localVariable[args.index] = convertValueType(value, args.as);
61	61	} else {
62	62	if (localVariable === null) {
63	63	localVariable = [];
64	64	}
65	65	localVariable[numIndex] = convertValueType(value, args.as);
66	66	}
67	67	chat_metadata.variables[name] = JSON.stringify(localVariable);
68	68	} catch {

@@ -106,12 +106,12 @@ function setGlobalVariable(name, value, args = {}) {
106	106	if (globalVariable === null) {
107	107	globalVariable = {};
108	108	}
109	109	globalVariable[args.index] = convertValueType(value, args.as);
110	110	} else {
111	111	if (globalVariable === null) {
112	112	globalVariable = [];
113	113	}
114	114	globalVariable[numIndex] = convertValueType(value, args.as);
115	115	}
116	116	extension_settings.variables.global[name] = JSON.stringify(globalVariable);
117	117	} catch {

+}
 function performOperation(value, operation, singleOperand = false, scope = null) {
     iffunction getResult(!value) {
 -        return 0;
 +        if (!value) {
 -    }
 +            return 0;
 +        }
             const array = parseNumericSeries(value, scope);
             if (array.length === 0) {
                     return 0;
+            }
             const result = singleOperand ? operation(array[0]) : operation(array);
             if (isNaN(result) || !isFinite(result)) {
                     return 0;
 +        }
++
 +        return result;
+    }
     returnconst result = getResult();
 +    return String(result);
+}
 function addValuesCallback(args, value) {

         if (typeof key != 'string') throw new Error('Key must be a string');
         if (args._hasUnnamedArgument) {
             const val = typeof value[0] == 'string' ? value.join(' ') : value[0];
             args._scope.setVariable(key, val, args.index, args.as);
             return val;
         } else {
             return args._scope.getVariable(key, args.index);

     if (typeof key != 'string') throw new Error('Key must be a string');
     if (value.length > 0) {
         const val = typeof value[0] == 'string' ? value.join(' ') : value[0];
         args._scope.setVariable(key, val, args.index, args.as);
         return val;
     } else {
         return args._scope.getVariable(key, args.index);

             new SlashCommandNamedArgument(
                 'index', 'list index', [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING], false,
             ),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'as',
 +                description: 'change the type of the value when used with index',
 +                forceEnum: true,
 +                enumProvider: commonEnumProviders.types,
 +                isRequired: false,
 +                defaultValue: 'string',
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

         helpString: `
             <div>
                 Set a local variable value and pass it down the pipe. The <code>index</code> argument is optional.
 +                To convert the value to a specific JSON type when using <code>index</code>, use the <code>as</code> argument.
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/setvar key=color green</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/setvar key=ages index=John as=number 21</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,

             new SlashCommandNamedArgument(
                 'index', 'list index', [ARGUMENT_TYPE.NUMBER, ARGUMENT_TYPE.STRING], false,
             ),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'as',
 +                description: 'change the type of the value when used with index',
 +                forceEnum: true,
 +                enumProvider: commonEnumProviders.types,
 +                isRequired: false,
 +                defaultValue: 'string',
 +            }),
         ],
         unnamedArgumentList: [
             new SlashCommandArgument(

         helpString: `
             <div>
                 Set a global variable value and pass it down the pipe. The <code>index</code> argument is optional.
 +                To convert the value to a specific JSON type when using <code>index</code>, use the <code>as</code> argument.
             </div>
             <div>
                 <strong>Example:</strong>

                     <li>
                         <pre><code class="language-stscript">/setglobalvar key=color green</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/setglobalvar key=ages index=John as=number 21</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,

                 false, // isRequired
                 false, // acceptsMultiple
             ),
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'as',
 +                description: 'change the type of the value when used with index',
 +                forceEnum: true,
 +                enumProvider: commonEnumProviders.types,
 +                isRequired: false,
 +                defaultValue: 'string',
 +            }),
         ],
         unnamedArgumentList: [
             SlashCommandArgument.fromProps({

         splitUnnamedArgumentCount: 1,
         helpString: `
             <div>
 -                Get or set a variable.
 +                Get or set a variable. Use <code>index</code> to access elements of a JSON-serialized list or dictionary.
 +                To convert the value to a specific JSON type when using with <code>index</code>, use the <code>as</code> argument.
             </div>
             <div>
                 <strong>Examples:</strong>

                     <li>
                         <pre><code class="language-stscript">/let x foo | /var key=x foo bar | /var x | /echo</code></pre>
                     </li>
 +                    <li>
 +                        <pre><code class="language-stscript">/let x {} | /var index=cool as=number x 1337 | /echo {{var::x}}</code></pre>
 +                    </li>
                 </ul>
             </div>
         `,