Refactor and JSDoc extensions.js

126616d5390d751cffe048fd776854025a1a885f

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

Parents: 83965fb611b84e769c62c8428366941b45cda218

.dockerignore+1 -0 Viewed

 /data
 /cache
 .DS_Store
+/public/scripts/extensions/third-party

.npmignore+1 -0 Viewed

 .github
 .vscode
 .git
+/public/scripts/extensions/third-party

public/css/extensions-panel.css+0 -5 Viewed

     opacity: 0.5;
+}
-#extensions_list .disabled {
-    text-decoration: line-through;
-    color: lightgray;
-}
 .update-button {
     margin-right: 10px;
     display: inline-flex;

public/scripts/extensions.js+84 -64 Viewed

 import { getContext } from './st-context.js';
 import { isAdmin } from './user.js';
 import { t } from './i18n.js';
+import { debounce_timeout } from './constants.js';
 export {
     getContext,
     getApiUrl,
-    loadExtensionSettings,
-    runGenerationInterceptors,
-    doExtrasFetch,
-    modules,
-    extension_settings,
-    ModuleWorkerWrapper,
 };
 /** @type {string[]} */
 export let extensionNames = [];
 /**
  * Holds the type of each extension.
  * Don't use this directly, use getExtensionType instead!

  */
 export let extensionTypes = {};
+/**
+ * A list of active modules provided by the Extras API.
+ * @type {string[]}
+ */
+export let modules = [];
+/**
+ * A set of active extensions.
+ * @type {Set<string>}
+ */
+let activeExtensions = new Set();
+const getApiUrl = () => extension_settings.apiUrl;
+let connectedToApi = false;
+/**
+ * Holds manifest data for each extension.
+ * @type {Record<string, object>}
+ */
 let manifests = {};
-const defaultUrl = 'http://localhost:5100';
-let saveMetadataTimeout = null;
+/**
+ * Default URL for the Extras API.
+ */
+const defaultUrl = 'http://localhost:5100';
 let requiresReload = false;
 let stateChanged = false;
+let saveMetadataTimeout = null;
 export function saveMetadataDebounced() {
     const context = getContext();

@@ -59,9 +78,9 @@ export function saveMetadataDebounced() {
59	}	78	}
60		79
61	console.debug('Saving metadata...');	80	console.debug('Saving metadata...');
62	newContext.saveMetadata();	81	await newContext.saveMetadata();
63	console.debug('Saved metadata...');	82	console.debug('Saved metadata...');
64	}, 1000);	83	}, debounce_timeout.relaxed);
65	}	84	}
66		85
67	/**	86	/**

+}
 // Disables parallel updates
-class ModuleWorkerWrapper {
+export class ModuleWorkerWrapper {
     constructor(callback) {
         this.isBusy = false;
         this.callback = callback;

@@ -115,7 +134,7 @@ class ModuleWorkerWrapper {
115	}	134	}
116	}	135	}
117		136
118	const extension_settings = {	137	export const extension_settings = {
119	apiUrl: defaultUrl,	138	apiUrl: defaultUrl,
120	apiKey: '',	139	apiKey: '',
121	autoConnect: false,	140	autoConnect: false,

     disabled_attachments: [],
 };
-let modules = [];
-let activeExtensions = new Set();
-const getApiUrl = () => extension_settings.apiUrl;
-let connectedToApi = false;
 function showHideExtensionsMenu() {
     // Get the number of menu items that are not hidden
     const hasMenuItems = $('#extensionsMenu').children().filter((_, child) => $(child).css('display') !== 'none').length > 0;

     return id ? extensionTypes[id] : '';
+}
-async function doExtrasFetch(endpoint, args) {
+/**
+ * Performs a fetch of the Extras API.
+ * @param {string|URL} endpoint Extras API endpoint
+ * @param {RequestInit} args Request arguments
+ * @returns {Promise<Response>} Response from the fetch
+ */
+export async function doExtrasFetch(endpoint, args = {}) {
     if (!args) {
         args = {};
+    }

@@ -231,8 +250,7 @@ async function doExtrasFetch(endpoint, args) {
231	});	250	});
232	}	251	}
233		252
234	const response = await fetch(endpoint, args);	253	return await fetch(endpoint, args);
235	return response;
236	}	254	}
237		255
238	/**	256	/**

     enableExtension(name, false);
+}
+/**
+ * Enables an extension by name.
+ * @param {string} name Extension name
+ * @param {boolean} [reload=true] If true, reload the page after enabling the extension
+ */
 export async function enableExtension(name, reload = true) {
     extension_settings.disabledExtensions = extension_settings.disabledExtensions.filter(x => x !== name);
     stateChanged = true;

+    }
+}
+/**
+ * Disables an extension by name.
+ * @param {string} name Extension name
+ * @param {boolean} [reload=true] If true, reload the page after disabling the extension
+ */
 export async function disableExtension(name, reload = true) {
     extension_settings.disabledExtensions.push(name);
     stateChanged = true;

+    }
+}
+/**
+ * Loads manifest.json files for extensions.
+ * @param {string[]} names Array of extension names
+ * @returns {Promise<Record<string, object>>} Object with extension names as keys and their manifests as values
+ */
 async function getManifests(names) {
     const obj = {};
     const promises = [];

     return obj;
+}
+/**
+ * Tries to activate all available extensions that are not already active.
+ * @returns {Promise<void>}
+ */
 async function activateExtensions() {
     const extensions = Object.entries(manifests).sort((a, b) => a[1].loading_order - b[1].loading_order);
     const promises = [];

     for (let entry of extensions) {
         const name = entry[0];
         const manifest = entry[1];
-        const elementExists = document.getElementById(name) !== null;
-        if (elementExists || activeExtensions.has(name)) {
+        if (activeExtensions.has(name)) {
             continue;
+        }
-        // all required modules are active (offline extensions require none)
+        const meetsModuleRequirements = !Array.isArray(manifest.requires) || isSubsetOf(modules, manifest.requires);
-        if (isSubsetOf(modules, manifest.requires)) {
+        const isDisabled = extension_settings.disabledExtensions.includes(name);
-            try {
-                const isDisabled = extension_settings.disabledExtensions.includes(name);
-                const li = document.createElement('li');
-                if (!isDisabled) {
-                    const promise = Promise.all([addExtensionScript(name, manifest), addExtensionStyle(name, manifest)]);
-                    await promise
-                        .then(() => activeExtensions.add(name))
-                        .catch(err => console.log('Could not activate extension: ' + name, err));
-                    promises.push(promise);
-                }
-                else {
-                    li.classList.add('disabled');
-                }
-                li.id = name;
-                li.innerText = manifest.display_name;
-                $('#extensions_list').append(li);
+        if (meetsModuleRequirements && !isDisabled) {
+            try {
+                console.debug('Activating extension', name);
+                const promise = Promise.all([addExtensionScript(name, manifest), addExtensionStyle(name, manifest)]);
+                await promise
+                    .then(() => activeExtensions.add(name))
+                    .catch(err => console.log('Could not activate extension', name, err));
+                promises.push(promise);
+            }
             catch (error) {
-                console.error(`Could not activate extension: ${name}`);
+                console.error('Could not activate extension', name);
                 console.error(error);
+            }
+        }

+}
 async function connectClickHandler() {
-    const baseUrl = $('#extensions_url').val();
+    const baseUrl = String($('#extensions_url').val());
-    extension_settings.apiUrl = String(baseUrl);
+    extension_settings.apiUrl = baseUrl;
     const testApiKey = $('#extensions_api_key').val();
     extension_settings.apiKey = String(testApiKey);
     saveSettingsDebounced();

+    }
+}
-/*     $(document).on('click', function (e) {
+/**
-        const target = $(e.target);
+ * Connects to the Extras API.
-        if (target.is(dropdown)) return;
+ * @param {string} baseUrl Extras API base URL
-        if (target.is(button) && dropdown.is(':hidden')) {
+ * @returns {Promise<void>}
-            dropdown.toggle(200);
+ */
-            popper.update();
-        }
-        if (target !== dropdown &&
-            target !== button &&
-            dropdown.is(":visible")) {
-            dropdown.hide(200);
-        }
-    });
-} */
 async function connectToApi(baseUrl) {
     if (!baseUrl) {
         return;

             const data = await getExtensionsResult.json();
             modules = data.modules;
             await activateExtensions();
-            eventSource.emit(event_types.EXTRAS_CONNECTED, modules);
+            await eventSource.emit(event_types.EXTRAS_CONNECTED, modules);
+        }
         updateStatus(getExtensionsResult.ok);

@@ -463,6 +479,10 @@ async function connectToApi(baseUrl) {
463	}	479	}
464	}	480	}
465		481
		482	/**
		483	* Updates the status of Extras API connection.
		484	* @param {boolean} success Whether the connection was successful
		485	*/
466	function updateStatus(success) {	486	function updateStatus(success) {
467	connectedToApi = success;	487	connectedToApi = success;
468	const _text = success ? t`Connected to API` : t`Could not connect to API`;	488	const _text = success ? t`Connected to API` : t`Could not connect to API`;

  * @param {boolean} versionChanged Is this a version change?
  * @param {boolean} enableAutoUpdate Enable auto-update
  */
-async function loadExtensionSettings(settings, versionChanged, enableAutoUpdate) {
+export async function loadExtensionSettings(settings, versionChanged, enableAutoUpdate) {
     if (settings.extension_settings) {
         Object.assign(extension_settings, settings.extension_settings);
+    }

  * @param {number} contextSize Context size
  * @returns {Promise<boolean>} True if generation should be aborted
  */
-async function runGenerationInterceptors(chat, contextSize) {
+export async function runGenerationInterceptors(chat, contextSize) {
     let aborted = false;
     let exitImmediately = false;