chore(wi): Add logSlashCommandWarn utility and integrate into world-info slash commands (#5096)

34688f849345968615e0ea43d298103f65b7feb1

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: 06b77ec94c0b9107bbe4e7e049976083b711c73b

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

+}
 /**
 + * Logs a warning to the console for slash command executions.
 + * Strips internal arguments (starting with '_') from the args object for cleaner logging.
 + * @param {string} message - The warning message to log.
 + * @param {Object} args - The arguments object from the slash command, including named arguments and internal values.
 + * @param {{[unnamedArgName: string]: string}} [valueObj=null] - The user-built object containing context for the warning (e.g., { uid: uid }).
 + * @returns {void}
 + */
 +export function logSlashCommandWarn(message, args, valueObj = null) {
 +    if (valueObj !== null && valueObj !== undefined) {
 +        console.warn(message, valueObj, stripInternalArgs(args));
 +    } else {
 +        console.warn(message, stripInternalArgs(args));
 +    }
 +    return;
 +    function stripInternalArgs(args) {
 +        // strip all args/properties that start with an underscore
 +        const result = {};
 +        for (const [key, value] of Object.entries(args)) {
 +            if (!key.startsWith('_')) {
 +                result[key] = value;
 +            }
 +        }
 +        return result;
 +    }
 +}
++
 +/**
  * Sets up the scroll-to-top button functionality.
  * @param {object} params Parameters object
  * @param {string} params.scrollContainerId Scrollable container element ID

public/scripts/world-info.js+25 -6 Viewed

 import { Fuse } from '../lib.js';
 import { saveSettings, substituteParams, getRequestHeaders, chat_metadata, this_chid, characters, saveCharacterDebounced, menu_type, eventSource, event_types, getExtensionPromptByName, saveMetadata, getCurrentChatId, extension_prompt_roles, create_save, createOrEditCharacter, name1 } from '../script.js';
 import { download, debounce, initScrollHeight, resetScrollHeight, parseJsonFile, extractDataFromPng, getFileBuffer, getCharaFilename, getSortableDelay, escapeRegex, PAGINATION_TEMPLATE, navigation_option, waitUntilCondition, isTrueBoolean, setValueByPath, flashHighlight, select2ModifyOptions, getSelect2OptionId, dynamicSelect2DataViaAjax, highlightRegex, select2ChoiceClickSubscribe, isFalseBoolean, getSanitizedFilename, checkOverwriteExistingData, getStringHash, parseStringArray, cancelDebounce, findChar, onlyUnique, equalsIgnoreCaseAndAccents, uuidv4, normalizeArray, getUniqueName, logSlashCommandWarn } from './utils.js';
 import { extension_settings, getContext } from './extensions.js';
 import { NOTE_MODULE_NAME, metadata_keys, shouldWIAddPrompt } from './authors-note.js';
 import { isMobile } from './RossAscends-mods.js';

@@ -1059,9 +1059,10 @@ function registerWorldInfoSlashCommands() {
1059	1059	return getContext().chat.filter(x => !x.is_system).map(x => x.mes);
1060	1060	}
1061	1061
1062		- async function getEntriesFromFile(file) {
	1062	+ async function getEntriesFromFile(file, { args = {}, unnamed = null, callbackName = 'getEntriesFromFile' } = {}) {
1063	1063	if (!file \|\| !world_names.includes(file)) {
1064	1064	toastr.warning(t`Valid World Info file name is required`);
	1065	+ logSlashCommandWarn(`${callbackName}: Valid World Info file name is required`, args, unnamed);
1065	1066	return '';
1066	1067	}
1067	1068

         if (!data || !('entries' in data)) {
             toastr.warning(t`World Info file has an invalid format`);
 +            logSlashCommandWarn(`${callbackName}: World Info file has an invalid format`, args, unnamed);
             return '';
+        }

         if (!entries || entries.length === 0) {
             toastr.warning(t`World Info file has no entries`);
 +            logSlashCommandWarn(`${callbackName}: World Info file has no entries`, args, unnamed);
             return '';
+        }

         const character = findChar({ name: characterIdentifier });
         if (!character) {
             toastr.error(t`Character not found.`);
 +            logSlashCommandWarn('getCharBookCallback: Character not found', { type, name, create }, { characterIdentifier });
             return '';
+        }
         const books = [];

         if (!chatId) {
             toastr.warning(t`Open a chat to get a name of the chat-bound lorebook`);
 +            logSlashCommandWarn('getChatBookCallback: Open a chat to get a name of the chat-bound lorebook', args);
             return '';
+        }

         const file = args.file;
         const field = args.field || 'key';
         const entries = await getEntriesFromFile(file, { args, unnamed: { value }, callbackName: 'findBookEntryCallback' });
         if (!entries) {
             return '';

         const field = args.field || 'content';
         const tags = getContext().tags;
         const entries = await getEntriesFromFile(file, { args, unnamed: { uid }, callbackName: 'getEntryFieldCallback' });
         if (!entries) {
             return '';

         if (!entry) {
             toastr.warning('Valid UID is required');
 +            logSlashCommandWarn('getEntryFieldCallback: Valid UID is required', args, { uid });
 +            console.warn();
             return '';
+        }
         if (!Object.hasOwn(newWorldInfoEntryDefinition, field)) {
             toastr.warning('Valid field name is required');
 +            logSlashCommandWarn('getEntryFieldCallback: Valid field name is required', args, { uid });
             return '';
+        }

         if (!data || !('entries' in data)) {
             toastr.warning('Valid World Info file name is required');
 +            logSlashCommandWarn('createEntryCallback: Valid World Info file name is required', args);
             return '';
+        }

         if (value === undefined) {
             toastr.warning('Value is required');
 +            logSlashCommandWarn('setEntryFieldCallback: Value is required', args, { value });
             return '';
+        }

         if (!data || !('entries' in data)) {
             toastr.warning('Valid World Info file name is required');
 +            logSlashCommandWarn('setEntryFieldCallback: Valid World Info file name is required', args, { value });
             return '';
+        }

         if (!entry) {
             toastr.warning('Valid UID is required');
 +            logSlashCommandWarn('setEntryFieldCallback: Valid UID is required', args, { value });
             return '';
+        }
         if (!Object.hasOwn(newWorldInfoEntryDefinition, field)) {
             toastr.warning('Valid field name is required');
 +            logSlashCommandWarn('setEntryFieldCallback: Valid field name is required', args, { value });
             return '';
+        }

         const uid = value;
         const effect = args.effect;
         const entries = await getEntriesFromFile(file, { args, unnamed: { uid }, callbackName: 'getTimedEffectCallback' });
         if (!entries) {
             return '';

         if (!entry) {
             toastr.warning('Valid UID is required');
 +            logSlashCommandWarn('getTimedEffectCallback: Valid UID is required', args, { uid });
             return '';
+        }

         if (!timedEffects.isValidEffectType(effect)) {
             toastr.warning('Valid effect type is required');
 +            logSlashCommandWarn('getTimedEffectCallback: Valid effect type is required', args, { uid });
             return '';
+        }

         if (value === undefined) {
             toastr.warning('New state is required');
 +            logSlashCommandWarn('setTimedEffectCallback: New state is required', args, { value });
             return '';
+        }
         const entries = await getEntriesFromFile(file, { args, unnamed: { value }, callbackName: 'setTimedEffectCallback' });
         if (!entries) {
             return '';

         if (!entry) {
             toastr.warning('Valid UID is required');
 +            logSlashCommandWarn('setTimedEffectCallback: Valid UID is required', args, { value });
             return '';
+        }

         if (!timedEffects.isValidEffectType(effect)) {
             toastr.warning('Valid effect type is required');
 +            logSlashCommandWarn('setTimedEffectCallback: Valid effect type is required', args, { value });
             return '';
+        }
         if (!entry[effect]) {
             toastr.warning('This entry does not have the selected effect. Configure it in the editor first.');
 +            logSlashCommandWarn('setTimedEffectCallback: This entry does not have the selected effect', args, { value });
             return '';
+        }