357da321 · permissionBRICK/SillyTavern

.eslintrc.cjs+23 -0 Viewed

         // These rules should eventually be enabled.
         'no-async-promise-executor': 'off',
         'no-inner-declarations': 'off',
 +        'brace-style': 'off',
 +        // Additional formatting rules based on codebase conventions
 +        'array-bracket-spacing': ['error', 'never'],
 +        'computed-property-spacing': ['error', 'never'],
 +        'block-spacing': ['error', 'always'],
 +        'keyword-spacing': ['error', { before: true, after: true }],
 +        'space-before-blocks': ['error', 'always'],
 +        'space-before-function-paren': ['error', { anonymous: 'always', named: 'never', asyncArrow: 'always' }],
 +        'space-in-parens': ['error', 'never'],
 +        'comma-spacing': ['error', { before: false, after: true }],
 +        'key-spacing': ['error', { beforeColon: false, afterColon: true }],
 +        'func-call-spacing': ['error', 'never'],
 +        'no-multiple-empty-lines': ['error', { max: 2, maxEOF: 1, maxBOF: 0 }],
 +        'padded-blocks': ['error', 'never'],
 +        'no-whitespace-before-property': 'error',
 +        'space-unary-ops': ['error', { words: true, nonwords: false }],
 +        'arrow-spacing': ['error', { before: true, after: true }],
 +        'template-curly-spacing': ['error', 'never'],
 +        'rest-spread-spacing': ['error', 'never'],
 +        'generator-star-spacing': ['error', { before: false, after: true }],
 +        'yield-star-spacing': ['error', { before: false, after: true }],
 +        'template-tag-spacing': ['error', 'never'],
 +        'switch-colon-spacing': ['error', { after: true, before: false }],
     },
 };

public/script.js+2 -14 Viewed

  * @returns {JQuery<HTMLElement>} Rendered HTMLElement.
  */
 export function updateMessageElement(mes, { messageId = chat.length - 1, messageElement = messageTemplate.clone(), adjustMediaScroll = SCROLL_BEHAVIOR.NONE } = {}) {
+-
     let avatarImg = getThumbnailUrl('persona', user_avatar);
     //for non-user messages

@@ -3709,9 +3708,9 @@ class StreamingProcessor {
3709	3708	}
3710	3709
3711	3710	/**
3712	3711	* @returns {GeneratorAsyncGenerator<{ text: string, swipes: string[], logprobs: import('./scripts/logprobs.js').TokenLogprobs, toolCalls: any[], state: any }, void, void>}
3713	3712	*/
3714	3713	async* nullStreamingGeneration() {
3715	3714	throw new Error('Generation function for streaming is not hooked up');
3716	3715	}
3717	3716

         // Add quiet generation prompt at depth 0
         if (quiet_prompt && quiet_prompt.length) {
+-
             // here name1 is forced for all quiet prompts..why?
             const name = name1;
             //checks if we are in instruct, if so, formats the chat as such, otherwise just adds the quiet prompt

         if (!isAborted && power_user.auto_swipe && generatedTextFiltered(getMessage)) {
             is_send_press = false;
             return await swipe(null, SWIPE_DIRECTION.RIGHT, { source: SWIPE_SOURCE.AUTO_SWIPE, repeated: true, forceMesId: chat.length - 1 });
+-
+        }
         console.debug('/api/chats/save called by /Generate');

         !fromStreaming && await eventSource.emit(event_types.MESSAGE_RECEIVED, chat_id, type);
         addOneMessage(chat[chat_id], { type: 'swipe' });
         !fromStreaming && await eventSource.emit(event_types.CHARACTER_MESSAGE_RENDERED, chat_id, type);
+-
     } else {
         console.debug('entering chat update routine for non-swipe post');
         const newMessage = {};

@@ -8247,7 +8243,6 @@ export async function getChatsFromFiles(data, isGroupChat) {
8247	8243	currentChat.shift();
8248	8244	}
8249	8245	chat_dict[file_name] = currentChat;
8250		-
8251	8246	} catch (error) {
8252	8247	console.error(error);
8253	8248	}

             select_rm_info('char_create', avatarId, oldSelectedChar);
             crop_data = undefined;
+-
         } catch (error) {
             console.error('Error creating character', error);
             toastr.error(t`Failed to create character`);

             duration: 0, //used to be 100 //Disabled on Cohee's request. https://github.com/SillyTavern/SillyTavern/pull/4610/files#r2408731744
             queue: false,
             progress: function (animation, progress, remainingMs) {
+-
                 if (is_animation_scroll) chatElement.scrollTop(getMessageBottomHeight(thisMesDiv));
             },
             complete: function () {

      * @param {boolean} [skipSwipeOut=false]
      */
     async function animateSwipe(run_generate = false, skipSwipeOut = false) {
+-
         if (!skipSwipeOut) {
             //Swipe out.
             await animateSwipeTransition(mesId, { xEnd: `${swipeRange}px`, duration: swipeDuration });

     //If the swipe is not being deleted.
     if (source != SWIPE_SOURCE.DELETE && source != SWIPE_SOURCE.BACK) {
+-
         // Make sure ad-hoc changes to extras are saved before swiping away
         syncMesToSwipe(mesId);

@@ -10382,7 +10373,6 @@ export async function doNewChat({ deleteCurrentChat = false } = {}) {
10382	10373	await createOrEditCharacter(new CustomEvent('newChat'));
10383	10374	if (deleteCurrentChat) await delChat(chat_file_for_del + '.jsonl');
10384	10375	}
10385		-
10386	10376	}
10387	10377
10388	10378	/**

                 divchat.style.borderRadius = '';
                 divchat.style.backgroundColor = '';
+-
             } else {
+-
                 divchat.style.borderRadius = '10px'; // Adjust the value to control the roundness of the corners
                 divchat.style.backgroundColor = ''; // Set the background color to your preference

public/scripts/BulkEditOverlay.js+0 -0 Viewed

public/scripts/PromptManager.js+0 -2 Viewed

      * @returns {void}
      */
     addPrompt(prompt, identifier) {
+-
         if (typeof prompt !== 'object' || prompt === null) throw new Error('Object is not a prompt');
         const newPrompt = {

             this.updatePromptByIdentifier(identifier, prompt);
             debouncedSaveServiceSettings().then(() => this.render());
         });
+-
+    }
     /**

public/scripts/RossAscends-mods.js+0 -3 Viewed

  * @returns {string} - A human-readable string that represents the time spent generating characters.
  */
 export function humanizeGenTime(total_gen_time) {
+-
     //convert time_spent to humanized format of "_ Hours, _ Minutes, _ Seconds" from milliseconds
     let time_spent = total_gen_time || 0;
     time_spent = Math.floor(time_spent / 1000);

+        }
+-
+-
         if (event.ctrlKey && /^[1-9]$/.test(event.key)) {
             // This will eventually be to trigger quick replies
             // event.preventDefault();

public/scripts/autocomplete/AutoComplete.js+0 -5 Viewed

+    }
+-
+-
     /**
      * @param {HTMLTextAreaElement|HTMLInputElement} textarea The textarea to receive autocomplete.
      * @param {() => boolean} checkIfActivate Function should return true only if under the current conditions, autocomplete should display (e.g., for slash commands: autoComplete.text[0] == '/')

             });
+-
         if (this.isForceHidden) {
             // hidden with escape
             return this.hide();

+    }
+-
     /**
      * Create updated DOM.
      */

+    }
+-
     /**
      * Update position of DOM.
      */

public/scripts/autocomplete/AutoCompleteFuzzyScore.js+0 -3 Viewed

+-
+-
+-
 export class AutoCompleteFuzzyScore {
     /**@type {number}*/ start;
     /**@type {number}*/ longestConsecutive;

public/scripts/autocomplete/AutoCompleteNameResult.js+0 -1 Viewed

 import { AutoCompleteSecondaryNameResult } from './AutoCompleteSecondaryNameResult.js';
+-
 export class AutoCompleteNameResult extends AutoCompleteNameResultBase {
     /**
+     *

public/scripts/autocomplete/AutoCompleteNameResultBase.js+0 -1 Viewed

 import { AutoCompleteOption } from './AutoCompleteOption.js';
+-
 export class AutoCompleteNameResultBase {
     /**@type {string} */ name;
     /**@type {number} */ start;

public/scripts/autocomplete/AutoCompleteOption.js+0 -1 Viewed

 import { AutoCompleteFuzzyScore } from './AutoCompleteFuzzyScore.js';
+-
 export class AutoCompleteOption {
     /** @type {string} */ name;
     /** @type {string} */ typeIcon;

public/scripts/bulk-edit.js+0 -0 Viewed

public/scripts/cfg-scale.js+0 -1 Viewed

         setTimeout(function () {
             $('#cfgConfig').hide();
         }, animation_duration);
+-
+    }
     //duplicate options menu close handler from script.js
     //because this listener takes priority

public/scripts/chat-backups.js+0 -0 Viewed

public/scripts/data-maid.js+0 -1 Viewed

                 categoryElement.remove();
                 this.displayEmptyPlaceholder();
             });
+-
         });
         categoryElement.querySelectorAll('.dataMaidItemDelete').forEach(button => {
             button.addEventListener('click', async () => {

public/scripts/extensions/assets/index.js+0 -1 Viewed

         fetch(url, { cache: 'no-cache' })
             .then(response => response.json())
             .then(async function (json) {
+-
                 availableAssets = {};
                 $('#assets_menu').empty();

public/scripts/extensions/expressions/index.js+0 -2 Viewed

                 });
                 if (apiResult.ok) {
+-
                     const data = await apiResult.json();
                     expressionsList = data.labels;
                     return expressionsList;

@@ -1488,7 +1487,6 @@ function chooseSpriteForExpression(spriteFolderName, expression, { prevExpressio
1488	1487	}
1489	1488
1490	1489	return spriteFile;
1491		-
1492	1490	}
1493	1491
1494	1492	/**

public/scripts/extensions/gallery/index.js+0 -1 Viewed

         const items = await getGalleryItems(url);
         return JSON.stringify(items.map(it => it.src));
+-
     } catch (err) {
         console.error(err);
+    }

public/scripts/extensions/quick-reply/api/QuickReplyApi.js+0 -6 Viewed

     /** @type {SettingsUi} */ settingsUi;
+-
+-
     constructor(/** @type {QuickReplySettings} */settings, /** @type {SettingsUi} */settingsUi) {
         this.settings = settings;
         this.settingsUi = settingsUi;
+    }
+-
+-
     /**
      * @param {QuickReply} qr
      * @returns {QuickReplySet}

@@ -53,8 +49,6 @@ export class QuickReplyApi {
53	49	}
54	50
55	51
56		-
57		-
58	52	/**
59	53	* Executes a quick reply by its index and returns the result.
60	54	*

public/scripts/extensions/quick-reply/index.js+0 -4 Viewed

 export { debounceAsync };
+-
+-
 const _VERBOSE = true;
 export const debug = (...msg) => _VERBOSE ? console.debug('[QR2]', ...msg) : null;
 export const log = (...msg) => _VERBOSE ? console.log('[QR2]', ...msg) : null;

 export let quickReplyApi;
+-
+-
 const loadSets = async () => {
     const response = await fetch('/api/settings/get', {
         method: 'POST',

public/scripts/extensions/quick-reply/src/AutoExecuteHandler.js+0 -4 Viewed

     /** @type {Boolean[]}*/ preventAutoExecuteStack = [];
+-
+-
     constructor(/** @type {QuickReplySettings} */settings) {
         this.settings = settings;
+    }

+    }
+-
+-
     async performAutoExecute(/** @type {QuickReply[]} */qrList) {
         for (const qr of qrList) {
             this.preventAutoExecuteStack.push(qr.preventAutoExecute);

public/scripts/extensions/quick-reply/src/QuickReply.js+0 -10 Viewed

+    }
+-
+-
     /**@type {number}*/ id;
     /**@type {string}*/ icon;
     /**@type {string}*/ label = '';

+    }
+-
+-
     unrender() {
         this.dom?.remove();
         this.dom = null;

+    }
+-
+-
     renderSettings(idx) {
         if (!this.settingsDom) {
             const item = document.createElement('div'); {

+    }
+-
+-
     delete() {
         if (this.onDelete) {
             this.unrender();

+    }
+-
+-
     toJSON() {
         return {
             id: this.id,

public/scripts/extensions/quick-reply/src/QuickReplyConfig.js+0 -8 Viewed

     /**@type {HTMLElement}*/ setListDom;
+-
+-
     static from(props) {
         props.setList = props.setList?.map(it => QuickReplySetLink.from(it))?.filter(it => it.set) ?? [];
         const instance = Object.assign(new this(), props);

@@ -23,8 +21,6 @@ export class QuickReplyConfig {
23	21	}
24	22
25	23
26		-
27		-
28	24	init() {
29	25	this.setList.forEach(it => this.hookQuickReplyLink(it));
30	26	}

+    }
+-
+-
     renderSettingsInto(/**@type {HTMLElement}*/root) {
         /**@type {HTMLElement}*/
         this.setListDom = root.querySelector('.qr--setList');

+    }
+-
+-
     /**
      * @param {QuickReplySetLink} qrl
      */

public/scripts/extensions/quick-reply/src/QuickReplyContextLink.js+0 -2 Viewed

+    }
+-
+-
     /**@type {QuickReplySet}*/ set;
     /**@type {Boolean}*/ isChained = false;

public/scripts/extensions/quick-reply/src/QuickReplySet.js+1 -2 Viewed

     addQuickReply(data = {}) {
         const id = Math.max(this.idIndex, this.qrList.reduce((max, qr) => Math.max(max, qr.id), 0)) + 1;
 -        data.id =
 +        data.id = this.idIndex = id + 1;
 -        this.idIndex = id + 1;
         const qr = QuickReply.from(data);
         this.qrList.push(qr);
         this.hookQuickReply(qr);

public/scripts/extensions/quick-reply/src/QuickReplySetLink.js+0 -8 Viewed

+    }
+-
+-
     /**@type {QuickReplySet}*/ set;
     /**@type {Boolean}*/ isVisible = true;

     /**@type {HTMLElement}*/ settingsDom;
+-
+-
     renderSettings(idx) {
         this.index = idx;
         const item = document.createElement('div'); {

+    }
+-
+-
     update() {
         if (this.onUpdate) {
             this.onUpdate(this);

+    }
+-
+-
     toJSON() {
         return {
             set: this.set.name,

public/scripts/extensions/quick-reply/src/QuickReplySettings.js+0 -6 Viewed

+    }
+-
+-
     /**@type {Boolean}*/ isEnabled = false;
     /**@type {Boolean}*/ isCombined = false;
     /**@type {Boolean}*/ isPopout = false;

     /**@type {Function}*/ onRequestEditSet;
+-
+-
     init() {
         this.hookConfig(this.config);
         this.hookConfig(this.chatConfig);

+    }
+-
+-
     save() {
         extension_settings.quickReplyV2 = this.toJSON();
         saveSettingsDebounced();

public/scripts/extensions/quick-reply/src/SlashCommandHandler.js+0 -8 Viewed

     /** @type {QuickReplyApi} */ api;
+-
+-
     constructor(/** @type {QuickReplyApi} */api) {
         this.api = api;
+    }
+-
+-
     init() {
         function getExecutionIcons(/** @type {QuickReply} */ qr) {
             let icons = '';

+    }
+-
+-
     getSetByName(name) {
         const set = this.api.getSetByName(name);
         if (!set) {

+    }
+-
+-
     async executeQuickReplyByIndex(idx) {
         try {
             return await this.api.executeQuickReplyByIndex(idx);

public/scripts/extensions/quick-reply/src/ui/ButtonUi.js+0 -8 Viewed

     /**@type {HTMLElement}*/ popoutDom;
+-
+-
     constructor(/**@type {QuickReplySettings}*/settings) {
         this.settings = settings;
+    }
+-
+-
     render() {
         if (this.settings.isPopout) {
             return this.renderPopout();

+    }
+-
+-
     renderBar() {
         if (!this.dom) {
             let buttonHolder;

+    }
+-
+-
     renderPopout() {
         if (!this.popoutDom) {
             let buttonHolder;

public/scripts/extensions/quick-reply/src/ui/SettingsUi.js+0 -8 Viewed

     /**@type {HTMLSelectElement}*/ currentSet;
+-
+-
     constructor(/**@type {QuickReplySettings}*/settings) {
         this.settings = settings;
         settings.onRequestEditSet = (qrs) => this.selectQrSet(qrs);
+    }
+-
+-
+-
+-
     rerender() {
         if (!this.dom) return;
         const content = this.dom.querySelector('.inline-drawer-content');

+    }
+-
+-
     async onIsEnabled() {
         this.settings.isEnabled = this.isEnabled.checked;
         this.settings.save();

public/scripts/extensions/quick-reply/src/ui/ctx/ContextMenu.js+0 -4 Viewed

     /**@type {HTMLElement}*/ menu;
+-
+-
     constructor(/**@type {QuickReply}*/qr) {
         // this.itemList = items;
         this.itemList = this.build(qr).children;

+    }
+-
+-
     show({ clientX, clientY }) {
         if (this.isActive) return;
         this.isActive = true;

public/scripts/extensions/quick-reply/src/ui/ctx/MenuItem.js+0 -3 Viewed

     /**@type {function}*/ onExpand;
+-
+-
     /**
+     *
      * @param {?string} icon

@@ -80,7 +78,6 @@ export class MenuItem {
80	78	}
81	79	item.addEventListener('mouseover', () => sub.show(item));
82	80	item.addEventListener('mouseleave', () => sub.hide());
83		-
84	81	}
85	82	}
86	83	}

public/scripts/extensions/quick-reply/src/ui/ctx/SubMenu.js+0 -4 Viewed

     /**@type {HTMLElement}*/ root;
+-
+-
     constructor(/**@type {MenuItem[]}*/items) {
         this.itemList = items;
+    }

+    }
+-
+-
     show(/**@type {HTMLElement}*/parent) {
         if (this.isActive) return;
         this.isActive = true;

public/scripts/extensions/regex/index.js+0 -1 Viewed

         const trailingText = text.substring(lastIndex);
         outputText += trailingText;
         highlightedOutput += escapeHtml(trailingText);
+-
     } catch (e) {
         err = (err ? err + '; ' : '') + `Replace error: ${e.message}`;
         outputText = text; // Fallback

public/scripts/extensions/token-counter/index.js+0 -1 Viewed

         returns: 'number of tokens',
         helpString: 'Counts the number of tokens in the current chat.',
     }));
+-
 });

public/scripts/extensions/tts/alltalk.js+0 -1 Viewed

                 // V2: Combine the endpoint with the relative path
                 return `${this.settings.provider_endpoint}${data.output_file_url}`;
+            }
+-
         } catch (error) {
             console.error('[fetchTtsGeneration] Exception caught:', error);
             throw error;

public/scripts/extensions/tts/chatterbox.js+0 -3 Viewed

+            }
             this.setupEventListeners();
+-
         } catch (error) {
             console.error('Error loading Chatterbox settings:', error);
             this.updateStatus('Offline');

             });
             await audio.play();
+-
         } catch (error) {
             console.error('Error previewing voice:', error);
             this.updateStatus('Ready');

             // Return the response directly - SillyTavern expects a Response object
             return response;
+-
         } catch (error) {
             console.error('Error in generateTts:', error);
             this.updateStatus('Ready');

public/scripts/extensions/tts/coqui.js+0 -1 Viewed

@@ -583,7 +583,6 @@ class CoquiTtsProvider {
583	583	$('#coqui_api_model_install_button').show();
584	584	return;
585	585	}
586		-
587	586	}
588	587
589	588

public/scripts/extensions/tts/cosyvoice.js+0 -6 Viewed

     //#################//
     async getVoice(voiceName) {
+-
+-
+-
         if (this.voices.length == 0) {
             this.voices = await this.fetchTtsVoiceObjects();
+        }
+-
         const match = this.voices.filter(
             v => v.name == voiceName,
         )[0];

+    }
+-
     async generateTts(text, voiceId) {
         const response = await this.fetchTtsGeneration(text, voiceId);
         return response;

+    }
+-
     // Interface not used
     async fetchTtsFromHistory(history_item_id) {
         return Promise.resolve(history_item_id);

public/scripts/extensions/tts/elevenlabs.js+0 -0 Viewed

public/scripts/extensions/tts/google-native.js+0 -2 Viewed

             console.info(`Google TTS: Loaded ${this.voices.length} voices`);
             return this.voices;
+-
         } catch (error) {
             console.error('Failed to fetch Google TTS voices:', error);
             throw error;

             this.audioElement.src = url;
             this.audioElement.play();
             this.audioElement.onended = () => URL.revokeObjectURL(url);
+-
         } catch (error) {
             console.error('TTS Preview Error:', error);
             toastr.error(`Could not generate preview: ${error.message}`);

public/scripts/extensions/tts/gpt-sovits-v2.js+0 -8 Viewed

     //#################//
     async getVoice(voiceName) {
+-
+-
+-
         if (this.voices.length == 0) {
             this.voices = await this.fetchTtsVoiceObjects();
+        }
+-
         const match = this.voices.filter(
             v => v.name == voiceName,
         )[0];

+    }
+-
     async generateTts(text, voiceId) {
         const response = await this.fetchTtsGeneration(text, voiceId);
         return response;

      */
+-
+-
     async fetchTtsGeneration(inputText, voiceId, lang = null, forceNoStreaming = false) {
         console.info(`Generating new TTS for voice_id ${voiceId}`);

+    }
+-
     // Interface not used
     async fetchTtsFromHistory(history_item_id) {
         return Promise.resolve(history_item_id);

public/scripts/extensions/tts/gsvi.js+0 -9 Viewed

+-
 import { saveTtsProviderSettings } from './index.js';
 export { GSVITtsProvider };

         const characterList = await response.json();
         this.characterList = characterList;
         this.voices = Object.keys(characterList);
+-
+    }
+-
     get settingsHtml() {
         let html = `
         <label for="gsvi_api_language">Text Language</label>

         $('#gsvi_batch_size_output').text(this.settings.batch_size);
+-
+-
         // Persist settings changes
         saveTtsProviderSettings();
+-
+    }
     async loadSettings(settings) {

+    }
+-
     // Perform a simple readiness check by trying to fetch voiceIds
     async checkReady() {
         await Promise.allSettled([this.fetchCharacterList()]);

@@ -256,12 +249,10 @@ class GSVITtsProvider {
256	249
257	250
258	251	return `${this.settings.provider_endpoint}/tts?${params.toString()}`;
259		-
260	252	}
261	253
262	254	// Interface not used by GSVI TTS
263	255	async fetchTtsFromHistory(history_item_id) {
264	256	return Promise.resolve(history_item_id);
265	257	}
266		-
267	258	}

public/scripts/extensions/tts/index.js+0 -4 Viewed

             // Pass the full voiceMapKey (e.g., "User ("Quotes")") as well with character name
             await tts(segmentText, voiceId, char, voiceMapKey);
+-
         } catch (error) {
             toastr.error(error.toString());
             console.error(error);

         // Clear current job so the segmented jobs can be processed
         currentTtsJob = null;
+-
     } catch (error) {
         toastr.error(error.toString());
         console.error(error);

@@ -1286,7 +1284,6 @@ export function getCharacters(unrestricted) {
1286	1284	}
1287	1285
1288	1286	return characters;
1289		-
1290	1287	}
1291	1288
1292	1289	export function sanitizeId(input) {

+}
+-
 /**
  * Apply voiceMap based on current voiceMapEntries
  */

public/scripts/extensions/tts/kokoro-worker.js+0 -0 Viewed

public/scripts/extensions/tts/minimax.js+0 -2 Viewed

             // Backend handles all the complex processing and returns audio data directly
             console.debug('MiniMax TTS: Audio response received from backend');
             return response;
+-
         } catch (error) {
             console.error('Error in MiniMax TTS generation:', error);
             throw error;

                 this.audioElement.onended = null;
                 this.audioElement.onerror = null;
             };
+-
         } catch (error) {
             console.error('MiniMax TTS Preview Error:', error);
             toastr.error(`Could not generate preview: ${error.message}`);

public/scripts/extensions/tts/openai.js+0 -1 Viewed

+    }
     populateCharacterInstructions() {
+-
         const currentCharacters = $('.tts_voicemap_block_char span').map((i, el) => $(el).text()).get();
         $('#openai-character-instructions').empty();

public/scripts/extensions/tts/silerotts.js+0 -1 Viewed

@@ -172,5 +172,4 @@ class SileroTtsProvider {
172	172	async fetchTtsFromHistory(history_item_id) {
173	173	return Promise.resolve(history_item_id);
174	174	}
175		-
176	175	}

public/scripts/extensions/tts/xtts.js+0 -1 Viewed

@@ -323,5 +323,4 @@ class XTTSTtsProvider {
323	323	async fetchTtsFromHistory(history_item_id) {
324	324	return Promise.resolve(history_item_id);
325	325	}
326		-
327	326	}

public/scripts/extensions/vectors/index.js+0 -1 Viewed

@@ -1456,7 +1456,6 @@ async function onViewStatsClick() {
1456	1456	messageElement.addClass('vectorized');
1457	1457	}
1458	1458	}
1459		-
1460	1459	}
1461	1460
1462	1461	async function onVectorizeAllFilesClick() {

public/scripts/f-localStorage.js+0 -1 Viewed

 export function LoadLocal(target) {
     console.debug('LoadLocal -- ' + target);
     return localStorage.getItem(target);
+-
+}
 /**
  * @deprecated THIS FUNCTION IS OBSOLETE. DO NOT USE

public/scripts/filters.js+0 -1 Viewed

  * data = filterHelper.applyFilters(data);
  */
 export class FilterHelper {
+-
     /**
      * Cache fuzzy search weighting scores for re-usability, sorting and stuff
+     *

public/scripts/group-chats.js+0 -1 Viewed

         const value = $(this).prop('checked');
         hideMutedSprites = value;
         onHideMutedSpritesClick(value);
+-
     });
     $('#send_textarea').on('keyup', onSendTextareaInput);
     $('#groupCurrentMemberPopoutButton').on('click', doCurMemberListPopout);

public/scripts/input-md-formatting.js+4 -5 Viewed

         let cursorShift = charsToAdd.length;
         let selectedTextandPossibleFormatting = textarea.value.substring(start - possiblePreviousFormattingMargin, end + possiblePreviousFormattingMargin).trim();
         if (isTextSelected) { //if text is selected
 +            //if text is selected
             selectedText = textarea.value.substring(start, end);
             if (selectedTextandPossibleFormatting === charsToAdd + selectedText + charsToAdd) {
                 // If the selected text is already formatted, remove the formatting

                 textarea.focus();
                 document.execCommand('insertText', false, charsToAdd + selectedText + charsToAdd + possibleAddedSpace);
+            }
         } else {// No text is selected
 +            // No text is selected
             //check 1 character before and after the cursor for non-space characters
             if (beforeCaret !== ' ' && afterCaret !== ' ' && afterCaret !== '' && beforeCaret !== '') { //look for caret in the middle of a word

+                }
                 if (charsToAdd + discoveredWord + charsToAdd === discoveredWordWithPossibleFormatting) {
+-
                     // Replace the expanded selection with the original discovered word
                     textarea.focus();
                     document.execCommand('insertText', false, discoveredWord);

                     textarea.focus();
                     document.execCommand('insertText', false, charsToAdd + discoveredWord + charsToAdd);
+                }
+-
+-
             } else { //caret is not inside a word, so just add the formatting
                 textarea.focus();
                 textarea.setSelectionRange(start, end);

public/scripts/instruct-mode.js+0 -1 Viewed

             $('#instruct_system_sequence').prop('readOnly', false);
             $('#instruct_system_suffix').prop('readOnly', false);
+        }
+-
     });
     $('#instruct_enabled').on('change', function () {

public/scripts/openai.js+0 -4 Viewed

@@ -2279,7 +2279,6 @@ function appendElectronHubOptions(model_list, groupModels = false) {
2279	2279	appendOption(model);
2280	2280	});
2281	2281	}
2282		-
2283	2282	}
2284	2283
2285	2284	function electronHubSortBy(data, property = 'alphabetically') {

         option.value = i;
         option.text = item;
         $('#settings_preset_openai').append(option);
+-
     });
     openai_setting_names = settingNames;

     // Return context size if model found, otherwise default to 32k
     return Object.entries(contextMap).find(([key]) => model.includes(key))?.[1] || max_32k;
+-
+}
 /**

         console.log('Claude model changed to', value);
         oai_settings.claude_model = value;
         $('#model_claude_select').val(oai_settings.claude_model);
+-
+    }
     if ($(this).is('#model_openai_select')) {

public/scripts/personas.js+0 -2 Viewed

         highlightPersonas: true,
         targetedChar: getCurrentConnectionObj(),
         shiftClickHandler: (element, ev) => {
+-
             const personaId = $(element).attr('data-pid');
             /** @type {PersonaConnection[]} */

     if (isFalseBoolean(value)) {
         await setPersonaLockState(false, type);
         return 'false';
+-
+    }
     return '';

public/scripts/popup.js+0 -1 Viewed

@@ -478,7 +478,6 @@ export class Popup {
478	478	break;
479	479	}
480	480	}
481		-
482	481	};
483	482	this.dlg.addEventListener('keydown', keyListener.bind(this));
484	483	}

public/scripts/power-user.js+0 -7 Viewed

 var originalSliderValues = [];
 async function switchLabMode({ noReset = false } = {}) {
+-
     /*     if (power_user.enableZenSliders && power_user.enableLabMode) {
             toastr.warning("Can't start Lab Mode while Zen Sliders are active")
             return

         $('#amount_gen').attr('min', '1')
             .attr('max', '99999')
             .attr('step', '1');
+-
+-
     } else if (!noReset) {
         //re apply the original sliders values to each input
         originalSliderValues.forEach(function (slider) {

@@ -628,7 +625,6 @@ async function switchZenSliders() {
628	625	});
629	626	$('div[id$="_zenslider"]').remove();
630	627	}
631		-
632	628	}
633	629	async function CreateZenSliders(elmnt) {
634	630	var originalSlider = elmnt;

     document.documentElement.style.setProperty('--shadowWidth', String(power_user.shadow_width));
     $('#shadow_width_counter').val(power_user.shadow_width);
     $('#shadow_width').val(power_user.shadow_width);
+-
+}
 function applyFontScale(type) {

         } */
     function getAverageRGB(imgEl) {
+-
         var blockSize = 5, // only visit every 5 pixels
             defaultRGB = { r: 0, g: 0, b: 0 }, // for non-supporting envs
             canvas = document.createElement('canvas'),

         rgb.b = ~~(rgb.b / count);
         return rgb;
+-
+    }
     /**

public/scripts/preset-manager.js+0 -1 Viewed

@@ -514,7 +514,6 @@ class PresetManager {
514	514	console.error('Preset could not be renamed', error);
515	515	throw new Error('Preset could not be renamed');
516	516	}
517		-
518	517	}
519	518
520	519	/**

public/scripts/reasoning.js+0 -1 Viewed

     UI.$select.val(foundName).trigger('change');
     !quiet && toastr.success(`Reasoning template "${foundName}" selected`);
     return foundName;
+-
+}
 function registerReasoningSlashCommands() {

public/scripts/samplerSelect.js+0 -1 Viewed

         console.log(samplerName, relatedDOMElement.data(SELECT_SAMPLER.DATA), shouldDisplay);
     });
+-
+}
 function isElementVisibleInDOM(element) {

public/scripts/showdown-underscore.js+0 -0 Viewed

public/scripts/slash-commands.js+0 -2 Viewed

+}
 export async function promptQuietForLoudResponse(who, text) {
+-
     let character_id = getContext().characterId;
     if (who === 'sys') {
         text = 'System: ' + text;

     addOneMessage(message);
     await eventSource.emit(event_types.USER_MESSAGE_RENDERED, (chat.length - 1));
     await saveChatConditional();
+-
+}
 async function sendCommentMessage(args, text) {

public/scripts/slash-commands/SlashCommand.js+0 -3 Viewed

 */
+-
 export class SlashCommand {
     /**
      * Creates a SlashCommand from a properties object.

+    }
+-
+-
     /**@type {string}*/ name;
     /**@type {(namedArguments:NamedArguments, unnamedArguments:UnnamedArguments)=>string|SlashCommandClosure|Promise<string|SlashCommandClosure>}*/ callback;
     /**@type {string}*/ helpString;

public/scripts/slash-commands/SlashCommandArgument.js+0 -1 Viewed

 import { SlashCommandScope } from './SlashCommandScope.js';
+-
 /**@readonly*/
 /**@enum {string}*/
 export const ARGUMENT_TYPE = {

public/scripts/slash-commands/SlashCommandAutoCompleteNameResult.js+0 -0 Viewed

public/scripts/slash-commands/SlashCommandBrowser.js+0 -0 Viewed

public/scripts/slash-commands/SlashCommandClosure.js+0 -0 Viewed

public/scripts/slash-commands/SlashCommandCommandAutoCompleteOption.js+0 -2 Viewed

+    }
+-
+-
     /**
      * @param {SlashCommand} command
      * @param {string} name

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

public/scripts/slash-commands/SlashCommandDebugController.js+0 -5 Viewed

     /** @type {(closure:SlashCommandClosure, executor:SlashCommandExecutor)=>Promise<boolean>} */ onBreakPoint;
+-
+-
     testStepping(closure) {
         return this.stepStack[this.stack.indexOf(closure)];
+    }
+-
+-
     down(closure) {
         this.stack.push(closure);
         if (this.stepStack.length < this.stack.length) {

+    }
+-
     resume() {
         this.continueResolver?.(false);
         this.continuePromise = null;

public/scripts/slash-commands/SlashCommandEnumAutoCompleteOption.js+0 -1 Viewed

     /**@type {SlashCommandEnumValue}*/ enumValue;
+-
     /**
      * @param {SlashCommand} cmd
      * @param {SlashCommandEnumValue} enumValue

public/scripts/slash-commands/SlashCommandExecutionError.js+0 -1 Viewed

+    }
+-
     constructor(cause, message, commandName, start, end, commandText, fullText) {
         super(message, { cause });
         this.commandName = commandName;

public/scripts/slash-commands/SlashCommandExecutor.js+0 -0 Viewed

public/scripts/slash-commands/SlashCommandParser.js+0 -0 Viewed

public/scripts/slash-commands/SlashCommandScope.js+0 -2 Viewed

@@ -109,8 +109,6 @@ export class SlashCommandScope {
109	109	}
110	110
111	111
112		-
113		-
114	112	export class SlashCommandScopeVariableExistsError extends Error {}
115	113
116	114

public/scripts/tags.js+0 -1 Viewed

     // If folder display has changed, we have to redraw the character list, otherwise this folders state would not change
     printCharactersDebounced();
     saveSettingsDebounced();
+-
+}
 function updateDrawTagFolder(element, tag) {

public/scripts/textgen-settings.js+0 -1 Viewed

@@ -802,7 +802,6 @@ async function getStatusTextgen() {
802	802	console.info('Status check aborted.', err.reason);
803	803	} else {
804	804	console.error('Error getting status', err);
805		-
806	805	}
807	806	setOnlineStatus('no_connection');
808	807	}

public/scripts/user.js+0 -4 Viewed

         toastr.success('Name changed successfully', 'Name Changed');
         callback();
+-
     } catch (error) {
         console.error('Error changing name:', error);
+    }

@@ -495,7 +494,6 @@ async function restoreSnapshot(name, callback) {
495	494	} catch (error) {
496	495	console.error('Error restoring snapshot:', error);
497	496	}
498		-
499	497	}
500	498
501	499	/**

@@ -601,7 +599,6 @@ async function viewSettingsSnapshots() {
601	599	const content = await loadSnapshotContent(snapshot.name);
602	600	contentBlock.val(content);
603	601	}
604		-
605	602	});
606	603	template.find('.snapshotList').append(snapshotBlock);
607	604	}

@@ -667,7 +664,6 @@ async function resetEverything(callback) {
667	664	} catch (error) {
668	665	console.error('Error resetting everything:', error);
669	666	}
670		-
671	667	}
672	668
673	669	async function openUserProfile() {

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

                 flags: new RegExp('(?<=\\/)([gimsuy]*)$', 'g'),  // Match trailing flags
                 delimiters: new RegExp('^\\/|(?<![\\\\<])\\/', 'g'),  // Match leading or trailing delimiters
             };
+-
         } catch (error) {
             return {
                 brackets: new RegExp('(\\\\)?\\[.*?\\]', 'g'),  // Non-escaped square brackets

public/scripts/world-info.js+0 -2 Viewed

@@ -675,7 +675,6 @@ class WorldInfoTimedEffects {
675	675	console.log('[WI] Timed effect "delay" applied to entry', entry);
676	676	}
677	677	}
678		-
679	678	}
680	679
681	680	/**

@@ -4495,7 +4494,6 @@ function parseDecorators(content) {
4495	4494	}
4496	4495
4497	4496	return [[], content];
4498		-
4499	4497	}
4500	4498
4501	4499	/**

src/endpoints/assets.js+0 -2 Viewed

     try {
         if (fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory()) {
+-
             ensureFoldersExist(request.user.directories);
             const folders = fs.readdirSync(folderPath, { withFileTypes: true })

     let output = [];
     try {
         if (fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory()) {
+-
             // Live2d assets
             if (category == 'live2d') {
                 const folders = fs.readdirSync(folderPath, { withFileTypes: true });

src/endpoints/backends/text-completions.js+0 -2 Viewed

         console.debug('LlamaCpp props response:', data);
         return response.send(data);
+-
     } catch (error) {
         console.error(error);
         return response.sendStatus(500);

         console.debug('LlamaCpp slots response:', data);
         return response.send(data);
+-
     } catch (error) {
         console.error(error);
         return response.sendStatus(500);

src/endpoints/backups.js+0 -0 Viewed

src/endpoints/characters.js+2 -2 Viewed

@@ -639,7 +639,6 @@ function charaFormatData(data, directories) {
639	639	if (file && file.entries) {
640	640	_.set(char, 'data.character_book', convertWorldInfoToCharacterBook(data.world, file.entries));
641	641	}
642		-
643	642	} catch {
644	643	console.warn(`Failed to read world info file: ${data.world}. Character book will not be available.`);
645	644	}

         let charJSON = JSON.stringify(char);
         const result = await writeCharacterData(DEFAULT_AVATAR_PATH, charJSON, pngName, request);
         return result ? pngName : '';
     } else if (jsonData.char_name !== undefined) {//json Pygmalion notepad
 +        //json Pygmalion notepad
         console.info('Importing from gradio json');
         jsonData.char_name = sanitize(jsonData.char_name);
         if (jsonData.creator_notes) {

src/endpoints/extensions.js+0 -2 Viewed

         const { isUpToDate, remoteUrl } = await checkIfRepoIsUpToDate(extensionPath);
         return response.send({ currentBranchName, currentCommitHash, isUpToDate, remoteUrl });
+-
     } catch (error) {
         console.error('Getting extension version failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);

         console.info(`Extension has been deleted at ${extensionPath}`);
         return response.send(`Extension has been deleted at ${extensionPath}`);
+-
     } catch (error) {
         console.error('Deleting custom content failed', error);
         return response.status(500).send(`Server Error: ${error.message}`);

src/endpoints/groups.js+0 -0 Viewed

src/endpoints/horde.js+0 -2 Viewed

             console.info(status);
             if (status.state === HordeAsyncRequestStates.done) {
+-
                 if (status.forms === undefined) {
                     console.error('Image interrogation request failed: no forms found.');
                     return response.sendStatus(500);

@@ -278,7 +277,6 @@ router.post('/caption-image', async (request, response) => {
278	277	return response.sendStatus(503);
279	278	}
280	279	}
281		-
282	280	} catch (error) {
283	281	console.error(error);
284	282	response.sendStatus(500);

src/endpoints/image-metadata.js+0 -1 Viewed

+        }
         return response.status(400).json({ error: 'Invalid request format.' });
+-
     } catch (error) {
         console.error('[ImageMetadata] API error:', error);
         return response.status(500).json({ error: 'Internal server error.' });

src/endpoints/minimax.js+0 -2 Viewed

                 response.setHeader('Content-Length', audioBytes.length);
                 return response.send(Buffer.from(audioBytes));
+-
             } catch (conversionError) {
                 console.error('MiniMax TTS: Audio conversion error:', conversionError);
                 return response.status(500).json({ error: `Audio data conversion failed: ${conversionError.message}` });

             console.error('MiniMax TTS: No valid audio data in response:', responseData);
             return response.status(500).json({ error: `API Error: ${errorMessage}` });
+        }
+-
     } catch (error) {
         console.error('MiniMax TTS generation failed:', error);
         return response.status(500).json({ error: 'Internal server error' });

src/endpoints/stable-diffusion.js+0 -1 Viewed

         const data = await result.json();
         const names = data.map(x => x.name);
         return response.send(names);
+-
     } catch (error) {
         console.error(error);
         return response.sendStatus(500);

src/endpoints/thumbnails.js+0 -1 Viewed

         // Send a 404 so the frontend can display a placeholder
         return response.sendStatus(404);
+-
     } catch (error) {
         console.error('Failed getting thumbnail', error);
         return response.sendStatus(500);

src/prompt-converters.js+0 -1 Viewed

  * @copyright Prompt Conversion script taken from RisuAI by kwaroran (GPLv3).
  */
 export function convertClaudePrompt(messages, addAssistantPostfix, addAssistantPrefill, withSysPromptSupport, useSystemPrompt, addSysHumanMsg, excludePrefixes) {
+-
     //Prepare messages for claude.
     //When 'Exclude Human/Assistant prefixes' checked, setting messages role to the 'system'(last message is exception).
     if (messages.length > 0) {

src/util.js+0 -1 Viewed

@@ -1012,7 +1012,6 @@ export async function canResolve(name, useIPv6 = true, useIPv4 = true) {
1012	1012	}
1013	1013
1014	1014	return v6Resolved \|\| v4Resolved;
1015		-
1016	1015	} catch (error) {
1017	1016	return false;
1018	1017	}

Chore: Add code formatting conventions as eslint rules (#5158) * Add code formatting conventions as eslint rules * Improve formatting in addQuickReply