Await for profiles loading before continuing

10ddf77948e0d93af1f14a8ea9801ce8a4b5d397

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

public/script.js+1 -0 Viewed

     LLM_FUNCTION_TOOL_CALL: 'llm_function_tool_call',
     ONLINE_STATUS_CHANGED: 'online_status_changed',
     IMAGE_SWIPED: 'image_swiped',
 +    CONNECTION_PROFILE_LOADED: 'connection_profile_loaded',
 };
 export const eventSource = new EventEmitter();

public/scripts/extensions/connection-manager/index.js+32 -7 Viewed

 import { event_types, eventSource, main_api, saveSettingsDebounced } from '../../../script.js';
 import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';
 import { callGenericPopup, Popup, POPUP_TYPE } from '../../popup.js';
 import { executeSlashCommandsWithOptions } from '../../slash-commands.js';
 import { SlashCommand } from '../../slash-commands/SlashCommand.js';
 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from '../../slash-commands/SlashCommandArgument.js';
 import { commonEnumProviders, enumIcons } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 import { enumTypes, SlashCommandEnumValue } from '../../slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
 import { collapseSpaces, getUniqueName, isFalseBoolean, uuidv4 } from '../../utils.js';
 const MODULE_NAME = 'connection-manager';
 const NONE = '<None>';

 /** @type {() => SlashCommandEnumValue[]} */
 const profilesProvider = () => [
     new SlashCommandEnumValue(NONE, NONE),
     ...extension_settings.connectionManager.profiles.map(p => new SlashCommandEnumValue(p.name, null, enumTypes.name, enumIcons.server)),
 ];

@@ -155,7 +155,7 @@ async function createConnectionProfile(forceName = null) {
155	155	return null;
156	156	}
157	157
158	158	if (isNameTaken(name) \|\| name === NONE) {
159	159	toastr.error('A profile with the same name already exists.');
160	160	return null;
161	161	}

     profiles.addEventListener('change', async function () {
         const selectedProfile = profiles.selectedOptions[0];
         if (!selectedProfile) {
 +            // Safety net for preventing the command getting stuck
 +            await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
             return;
+        }

         // None option selected
         if (!profileId) {
 +            await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
             return;
+        }

+        }
         await applyConnectionProfile(profile);
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
     });
     const reloadButton = document.getElementById('reload_connection_profile');

+        }
         await applyConnectionProfile(profile);
         await renderDetailsContent(details, detailsContent);
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
         toastr.success('Connection profile reloaded', '', { timeOut: 1500 });
     });

         saveSettingsDebounced();
         renderConnectionProfiles(profiles);
         await renderDetailsContent(details, detailsContent);
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
     });
     const updateButton = document.getElementById('update_connection_profile');

         await updateConnectionProfile(profile);
         await renderDetailsContent(details, detailsContent);
         saveSettingsDebounced();
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
         toastr.success('Connection profile updated', '', { timeOut: 1500 });
     });

         await deleteConnectionProfile();
         renderConnectionProfiles(profiles);
         await renderDetailsContent(details, detailsContent);
 +        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
     });
     /** @type {HTMLDetailsElement} */

                 isRequired: false,
             }),
         ],
 -        callback: async (_args, value) => {
 +        namedArgumentList: [
 +            SlashCommandNamedArgument.fromProps({
 +                name: 'await',
 +                description: 'Wait for the connection profile to be applied before returning.',
 +                isRequired: false,
 +                typeList: [ARGUMENT_TYPE.BOOLEAN],
 +                defaultValue: 'true',
 +                enumList: commonEnumProviders.boolean('trueFalse')(),
 +            }),
 +        ],
 +        callback: async (args, value) => {
             if (!value || typeof value !== 'string') {
                 const selectedProfile = extension_settings.connectionManager.selectedProfile;
                 const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);

                 return '';
+            }
 +            const shouldAwait = !isFalseBoolean(String(args?.await));
 +            const awaitPromise = new Promise((resolve) => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
++
             profiles.selectedIndex = Array.from(profiles.options).findIndex(o => o.value === profile.id);
             profiles.dispatchEvent(new Event('change'));
 +            if (shouldAwait) {
 +                await awaitPromise;
 +            }
++
             return profile.name;
         },
     }));