Regex: Code clean-up (#4628) * Add confirmation for bulk move, add UNKNOWN type, improve JSDoc * Fix toggle all bulk move visibility * Improve function documentation * Refactor currentChatId check and improve JSDoc for getScriptDecorators function * Check against known values in moveRegexScript * Fix console warning spam * Simplify currentChatId check * Prevent moving scripts into the void * Make texts translatable

9dddbbb04a95422e693ab663f0fa6cd9d770743d

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

Signed

Parents: f15c91fa8ed34b30fdf981757d7def2e9c4e28bb

public/scripts/extensions/regex/engine.js+24 -15 Viewed

 import { characters, substituteParams, substituteParamsExtended, this_chid } from '../../../script.js';
 import { extension_settings } from '../../extensions.js';
 import { regexFromString } from '../../utils.js';
-export {
-    regex_placement,
-    getRegexedString,
-    runRegexScript,
-};
 /**
  * @enum {number} Regex scripts types
+ * @readonly
  */
 export const SCRIPT_TYPES = {
+    UNKNOWN: -1,
     GLOBAL: 0,
     SCOPED: 1,
 };

 /**
  * @typedef {object} GetRegexScriptsOptions
- * @property {boolean} allowedOnly only return allowed scripts
+ * @property {boolean} allowedOnly Only return allowed scripts
+ */
+/**
+ * @type {Readonly<GetRegexScriptsOptions>}
  */
-const DEFAULT_GET_REGEX_SCRIPTS_OPTIONS = { allowedOnly: false };
+const DEFAULT_GET_REGEX_SCRIPTS_OPTIONS = Object.freeze({ allowedOnly: false });
 /**
  * Retrieves the list of regex scripts by combining the scripts from the extension settings and the character data
+ *
- * @param {GetRegexScriptsOptions} option
+ * @param {GetRegexScriptsOptions} options Options for retrieving the regex scripts
  * @returns {RegexScript[]} An array of regex scripts, where each script is an object containing the necessary information.
  */
-export function getRegexScripts(option = DEFAULT_GET_REGEX_SCRIPTS_OPTIONS) {
+export function getRegexScripts(options = DEFAULT_GET_REGEX_SCRIPTS_OPTIONS) {
-    return [...Object.values(SCRIPT_TYPES).flatMap(type => getScriptsByType(type, option))];
+    return [...Object.values(SCRIPT_TYPES).flatMap(type => getScriptsByType(type, options))];
+}
 /**
  * Retrieves the regex scripts for a specific type.
- * @param {SCRIPT_TYPES} scriptType
+ * @param {SCRIPT_TYPES} scriptType The type of regex scripts to retrieve.
- * @param {GetRegexScriptsOptions} option
+ * @param {GetRegexScriptsOptions} options Options for retrieving the regex scripts
  * @returns {RegexScript[]} An array of regex scripts for the specified type.
  */
 export function getScriptsByType(scriptType, { allowedOnly } = DEFAULT_GET_REGEX_SCRIPTS_OPTIONS) {
     switch (scriptType) {
+        case SCRIPT_TYPES.UNKNOWN:
+            return [];
         case SCRIPT_TYPES.GLOBAL:
             return extension_settings.regex ?? [];
         case SCRIPT_TYPES.SCOPED: {

             return Array.isArray(scopedScripts) ? scopedScripts : [];
+        }
         default:
+            console.warn(`getScriptsByType: Invalid script type ${scriptType}`);
             return [];
+    }
+}
 /**
  * @enum {number} Where the regex script should be applied
+ * @readonly
  */
-const regex_placement = {
+export const regex_placement = {
     /**
      * @deprecated MD Display is deprecated. Do not use.
      */

     REASONING: 6,
 };
+/**
+ * @enum {number} How to substitute parameters in the find regex
+ * @readonly
+ */
 export const substitute_find_regex = {
     NONE: 0,
     RAW: 1,

  * @returns {string} The regexed string
  * @typedef {{characterOverride?: string, isMarkdown?: boolean, isPrompt?: boolean, isEdit?: boolean, depth?: number }} RegexParams The parameters to use for the regex script
  */
-function getRegexedString(rawString, placement, { characterOverride, isMarkdown, isPrompt, isEdit, depth } = {}) {
+export function getRegexedString(rawString, placement, { characterOverride, isMarkdown, isPrompt, isEdit, depth } = {}) {
     // WTF have you passed me?
     if (typeof rawString !== 'string') {
         console.warn('getRegexedString: rawString is not a string. Returning empty string.');

  * @returns {string} The new string
  * @typedef {{characterOverride?: string}} RegexScriptParams The parameters to use for the regex script
  */
-function runRegexScript(regexScript, rawString, { characterOverride } = {}) {
+export function runRegexScript(regexScript, rawString, { characterOverride } = {}) {
     let newString = rawString;
     if (!regexScript || !!(regexScript.disabled) || !regexScript?.findRegex || !rawString) {
         return newString;

public/scripts/extensions/regex/index.js+62 -25 Viewed

     selectAllIcon.toggleClass('fa-minus', allAreChecked);
+}
+/**
+ * Sets the visibility of the bulk move buttons based on selected scripts.
+ */
 function setMoveButtonsVisibility() {
     const hasGlobalScripts = $('#saved_regex_scripts .regex-script-label:has(.regex_bulk_checkbox:checked)').length > 0;
-    const hasScopedScripts =
+    const hasScopedScripts = $('#saved_scoped_scripts .regex-script-label:has(.regex_bulk_checkbox:checked)').length > 0;
-        $('#saved_scoped_scripts .regex-script-label:has(.regex_bulk_checkbox:checked)').length > 0;
     $('#bulk_regex_move_to_global').toggle(hasScopedScripts);
     $('#bulk_regex_move_to_scoped').toggle(hasGlobalScripts);
+}

@@ -538,7 +540,7 @@ async function saveRegexScript(regexScript, existingScriptIndex, scriptType, sav
538		540
539	// Reload the current chat to undo previous markdown	541	// Reload the current chat to undo previous markdown
540	const currentChatId = getCurrentChatId();	542	const currentChatId = getCurrentChatId();
541	if (currentChatId !== undefined && currentChatId !== null) {	543	if (currentChatId) {
542	await reloadCurrentChat();	544	await reloadCurrentChat();
543	}	545	}
544	}	546	}

+}
 /**
- * Delete a regex script
+ * Delete a regex script by ID
- * @param {string} id
+ * @param {string} id ID of the script to delete
- * @param {SCRIPT_TYPES} scriptType
+ * @param {SCRIPT_TYPES} scriptType global? scoped?
- * @param {boolean} saveSettings
+ * @param {boolean} saveSettings Whether to save the settings immediately
  * @returns {Promise<void>}
  */
 async function deleteRegexScript(id, scriptType, saveSettings = true) {

 /**
  * Move a regex script from one type to another
- * @param {import('../../char-data.js').RegexScriptData} script
+ * @param {import('../../char-data.js').RegexScriptData} script The script to move
- * @param {SCRIPT_TYPES} toType
+ * @param {SCRIPT_TYPES} toType Target type
- * @param {SCRIPT_TYPES|null} fromType
+ * @param {SCRIPT_TYPES|null} fromType Source type, if null it will be determined automatically
- * @param {boolean} saveSettings
+ * @param {boolean} saveSettings Whether to save the settings immediately
  * @returns {Promise<void>}
  */
 async function moveRegexScript(script, toType, fromType = null, saveSettings = true) {
-    if (!fromType) {
+    if (!Object.values(SCRIPT_TYPES).includes(toType)) {
+        console.warn(`moveRegexScript: Invalid target script type ${toType}`);
+        return;
+    }
+    if (!Object.values(SCRIPT_TYPES).includes(fromType)) {
         fromType = getScriptType(script);
+    }
-    if (fromType === toType || fromType === -1) {
+    if (fromType === toType || fromType === SCRIPT_TYPES.UNKNOWN || toType === SCRIPT_TYPES.UNKNOWN) {
         return;
+    }
     await deleteRegexScript(script.id, fromType, false);

         });
         popupContainer.append(navPanel).append(contentPanel);
-        callGenericPopup(popupContainer, POPUP_TYPE.TEXT, 'Step-by-step Transformation', { wide: true, allowVerticalScrolling: false });
+        callGenericPopup(popupContainer, POPUP_TYPE.TEXT, t`Step-by-step Transformation`, { wide: true, allowVerticalScrolling: false });
     });
     debuggerHtml.find('#regex_debugger_expand_final').on('click', function () {
         const content = $('#regex_debugger_final_output').html();
         const popupContent = $('<div class="regex-popup-content"></div>').html(content);
-        callGenericPopup(popupContent, POPUP_TYPE.TEXT, 'Final Output', { wide: true, large: true, allowVerticalScrolling: true });
+        callGenericPopup(popupContent, POPUP_TYPE.TEXT, t`Final Output`, { wide: true, large: true, allowVerticalScrolling: true });
     });
     await callGenericPopup(debuggerHtml.children(), POPUP_TYPE.TEXT, '', { wide: true, allowVerticalScrolling: true });

+    }
+}
+/**
+ * Determines the type of a given script.
+ * @param {RegexScript} script The script to check
+ * @returns {SCRIPT_TYPES} The script type.
+ */
 function getScriptType(script) {
-    return getScriptsByType(SCRIPT_TYPES.SCOPED).some(s => s.id === script.id)
+    const scopedScripts = getScriptsByType(SCRIPT_TYPES.SCOPED);
-        ? SCRIPT_TYPES.SCOPED
+    if (scopedScripts.some(s => s.id === script.id)) {
-        : SCRIPT_TYPES.GLOBAL;
+        return SCRIPT_TYPES.SCOPED;
+    }
+    const globalScripts = getScriptsByType(SCRIPT_TYPES.GLOBAL);
+    if (globalScripts.some(s => s.id === script.id)) {
+        return SCRIPT_TYPES.GLOBAL;
+    }
+    return SCRIPT_TYPES.UNKNOWN;
+}
 function getSelectedScripts() {

         checkboxes.prop('checked', newState);
         setToggleAllIcon(newState);
+        setMoveButtonsVisibility();
     });
     $('#bulk_enable_regex').on('click', async function () {

         // Reload the current chat to undo previous markdown
         const currentChatId = getCurrentChatId();
-        if (currentChatId !== undefined && currentChatId !== null) {
+        if (currentChatId) {
             await reloadCurrentChat();
+        }
+    }
-    $('#bulk_regex_move_to_global').on('click', () => bulkMoveRegexScript(SCRIPT_TYPES.GLOBAL));
-    $('#bulk_regex_move_to_scoped').on('click', () => bulkMoveRegexScript(SCRIPT_TYPES.SCOPED));
+    $('#bulk_regex_move_to_global').on('click', async () => {
+        const confirm = await callGenericPopup(t`Are you sure you want to move the selected regex scripts to global?`, POPUP_TYPE.CONFIRM);
+        if (!confirm) {
+            return;
+        }
+        await bulkMoveRegexScript(SCRIPT_TYPES.GLOBAL);
+    });
+    $('#bulk_regex_move_to_scoped').on('click', async () => {
+        const confirm = await callGenericPopup(t`Are you sure you want to move the selected regex scripts to scoped?`, POPUP_TYPE.CONFIRM);
+        if (!confirm) {
+            return;
+        }
+        await bulkMoveRegexScript(SCRIPT_TYPES.SCOPED);
+    });
     $('#bulk_delete_regex').on('click', async function () {
         const scripts = getSelectedScripts();

@@ -1650,7 +1684,7 @@ jQuery(async () => {
1650	toastr.warning(t`No regex scripts selected for deletion.`);	1684	toastr.warning(t`No regex scripts selected for deletion.`);
1651	return;	1685	return;
1652	}	1686	}
1653	const confirm = await callGenericPopup('Are you sure you want to delete the selected regex scripts?', POPUP_TYPE.CONFIRM);	1687	const confirm = await callGenericPopup(t`Are you sure you want to delete the selected regex scripts?`, POPUP_TYPE.CONFIRM);
1654	if (!confirm) {	1688	if (!confirm) {
1655	return;	1689	return;
1656	}	1690	}

      * @property {import('../../slash-commands/SlashCommandEnumValue.js').EnumType} color
      * @property {string} icon
      */
     /**
-     * @param {SCRIPT_TYPES} type
+     * @param {SCRIPT_TYPES} type The script type
-     * @returns {ScriptDecorators}
+     * @returns {ScriptDecorators} The decorators for the script type
      */
     function getScriptDecorators(type) {
         switch (type) {

                     color: enumTypes.name,
                     icon: 'S',
                 };
-        }
+            default:
                 return {
                     typename: 'Unknown',
                     color: enumTypes.variable,
                     icon: 'Unknown',
                 };
+        }
+    }
     const localEnumProviders = {
         regexScripts: () =>
             getRegexScripts().map(script => {