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+79 -59 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	80	console.debug('Saving metadata...');
62	81	await newContext.saveMetadata();
63	82	console.debug('Saved metadata...');
64	83	}, 1000debounce_timeout.relaxed);
65	84	}
66	85
67	86	/**

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

@@ -115,7 +134,7 @@ class ModuleWorkerWrapper {
115	134	}
116	135	}
117	136
118	137	export const extension_settings = {
119	138	apiUrl: defaultUrl,
120	139	apiKey: '',
121	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	253	const response =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)) {
             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)) {
 -            try {
         const isDisabled = extension_settings.disabledExtensions.includes(name);
 -                const li = document.createElement('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);
+            }
 -                else {
 -                    li.classList.add('disabled');
 -                }
+-
 -                li.id = name;
 -                li.innerText = manifest.display_name;
+-
 -                $('#extensions_list').append(li);
 -            }
             catch (error) {
                 console.error(`'Could not activate extension:', ${name}`);
                 console.error(error);
+            }
+        }

+}
 async function connectClickHandler() {
     const baseUrl = String($('#extensions_url').val());
     extension_settings.apiUrl = String(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();
             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	486	function updateStatus(success) {
467	487	connectedToApi = success;
468	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
  */
 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
  */
 export async function runGenerationInterceptors(chat, contextSize) {
     let aborted = false;
     let exitImmediately = false;