Allow searching on /sendas via tag=

22d8a654d95763213a7d823adc2ae695ce6ca129

Wolfsblvt <wolfsblvt@gmail.com>

Parents: 4594353c72c378777f1ff4e1efb17df7b681b546

public/scripts/slash-commands.js+55 -13 Viewed

             }),
             SlashCommandNamedArgument.fromProps({
                 name: 'avatar',
                 description: 'Optional characterCharacter avatar override (Can be either avatar filename or just the character name to pull the avatar from)',
                 typeList: [ARGUMENT_TYPE.STRING],
                 enumProvider: commonEnumProviders.characters('character'),
             }),
             SlashCommandNamedArgument.fromProps({
 +                name: 'tag',
 +                description: 'Supply one or more tags to filter down to the correct character for the provided name, if multiple characters have the same name. (does not apply to the avatar argument)',
 +                typeList: [ARGUMENT_TYPE.STRING],
 +                enumProvider: commonEnumProviders.tagsForChar('all'),
 +                acceptsMultiple: true,
 +            }),
 +            SlashCommandNamedArgument.fromProps({
                 name: 'compact',
                 description: 'Use compact layout',
                 typeList: [ARGUMENT_TYPE.BOOLEAN],

     return '';
+}
 +/**
 + * Finds a character by name, with optional filtering and precedence for avatars
 + * @param {string} name - The name to search for
 + * @param {object} [options={}] - The options for the search
 + * @param {boolean} [options.allowAvatar=false] - Whether to allow searching by avatar
 + * @param {boolean} [options.insensitive=true] - Whether the search should be case insensitive
 + * @param {string[]?} [options.filteredByTags=null] - Tags to filter characters by
 + * @param {any?} [options.preferCurrentChar=null] - The current character to prefer
 + * @returns {any?} - The found character or null if not found
 + */
 +export function findCharByName(name, { allowAvatar = false, insensitive = true, filteredByTags = null, preferCurrentChar = null } = {}) {
 +    const matches = (char) => (allowAvatar && char.avatar === name) || insensitive ? equalsIgnoreCaseAndAccents(char.name, name) : char.name === name;
++
 +    // If we have a current char and prefer it, return that if it matches - unless tags are provided, they have precedence
 +    if (preferCurrentChar && !filteredByTags && matches(preferCurrentChar)) {
 +        return preferCurrentChar;
 +    }
++
 +    // Filter characters by tags if provided
 +    let filteredCharacters = characters;
 +    if (filteredByTags) {
 +        filteredCharacters = characters.filter(char => filteredByTags.every(tag => char.tags.includes(tag)));
 +    }
++
 +    // If allowAvatar is true, search by avatar first
 +    if (allowAvatar) {
 +        const characterByAvatar = filteredCharacters.find(char => char.avatar === name);
 +        if (characterByAvatar) {
 +            return characterByAvatar;
 +        }
 +    }
++
 +    // Search for a matching character by name
 +    let character = filteredCharacters.find(matches);
++
 +    return character;
 +}
++
 export async function sendMessageAs(args, text) {
     if (!text) {
         return '';

     const chatCharacter = this_chid !== undefined ? characters[this_chid] : null;
     const isNeutralCharacter = !chatCharacter && name2 === neutralCharacterName && name === neutralCharacterName;
     const character = equalsIgnoreCaseAndAccentsfindCharByName(chatCharacter.name, name) ? chatCharacter{ filteredByTags: charactersargs?.find(xtags, =>preferCurrentChar: equalsIgnoreCaseAndAccents(x.name,chatCharacter name)});
 -    let avatarChar = character;
 +    const avatarCharacter = args.avatar ? findCharByName(args.avatar) : character;
     if (args.avatar && !avatarCharacter) {
 -        avatarChar = characters.find(x => x.avatar == args.avatar) ?? characters.find(x => equalsIgnoreCaseAndAccents(x.name, args.avatar));
 +        toastr.warning(`Character for avatar ${args.avatar} not found`);
 -        if (!avatarChar) {
 +        return '';
 -            toastr.warning(`Character for avatar ${args.avatar} not found`);
 -            return '';
 -        }
+    }
     let force_avatar, original_avatar;
     if (chatCharacter === avatarCharavatarCharacter || isNeutralCharacter) {
         // If the targeted character is the currently selected one in a solo chat, we don't need to force any avatars
+    }
     else if (avatarCharavatarCharacter && avatarCharavatarCharacter.avatar !== 'none') {
         force_avatar = getThumbnailUrl('avatar', avatarCharavatarCharacter.avatar);
         original_avatar = avatarCharavatarCharacter.avatar;
+    }
     else {
         force_avatar = default_avatar;

public/scripts/slash-commands/SlashCommandCommonEnumsProvider.js+1 -1 Viewed

         if (charName instanceof SlashCommandClosure) throw new Error('Argument \'name\' does not support closures');
         const key = searchCharByName(substituteParams(charName), { suppressLogging: true });
         const assigned = key ? getTagsList(key) : [];
         return tags.filter(it => !key || mode === 'all' || mode === 'existing' && assigned.includes(it) || mode === 'not-existing' && !assigned.includes(it))
             .map(tag => new SlashCommandEnumValue(tag.name, null, enumTypes.command, enumIcons.tag));
     },