Preset Regex: add preset type for script regexes (#4642) * feat: preset regex * refactor: unify `saveScriptsByType` * fix: default branch for `saveScriptsByType` * refactor: resolve some reviews * fix: lint * refactor: getPresetName -> getCurrentPresetName * refactor: unify regex allow operation * feat: notify whether to reload current chat when preset is changed * refacotr: set timeout for reload current chat notification * fix: _ -> lodash * i18n * Refactor API ID access * refactor: replace UNKNOWN type with a separate constant * refactor: consolidate CSS rules for scoped and preset script blocks * Extend toast timeout * Fix bug with moving, refactor * Refactor bulk toggle operations * Use for..of for preset application * refactor: enhance parameter documentation for scriptType in regex functions * fix: await loadRegexScripts in event handlers * fix: correct script type in saveScriptsByType for preset handling * fix: add null checks for preset manager and API ID in regex functions * feat: implement expandable regex script options in UI * Always show edit/delete buttons * Add title attribute to regex script name * fix: correct class name for regex script display * Remove extra paddings from script blocks * fix: ensure preset scripts are only disallowed if currently allowed during rename * fix: reload on bulk script toggle * feat: add PRESET_RENAMED_BEFORE event type and emit it during preset renaming * fix: always preserve preset extensions on rename * Handle horde in getPresetManager --------- Co-authored-by: ZoinkCN <zoinkcn@outlook.com> Co-authored-by: StageDog <aksanajw845@gmail.com>

df7f0469129ebaaddd307e0c06cb29fbbb2e1097

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

Signed

Parents: e4d779d4500e2b7f0e3cc6734bb68488c60a7fa8

public/locales/zh-cn.json+14 -2 Viewed

     "macro for manual injection)": "宏用于手动注入）",
     "Color": "颜色",
     "Only apply color as accent": "仅应用颜色作为强调",
-    "ext_regex_new_global_script_desc": "新增「全局」正规表达式",
+    "ext_regex_new_global_script_desc": "新增「全局」正则表达式",
-    "ext_regex_new_scoped_script_desc": "新增「局部」正规表达式",
+    "ext_regex_new_scoped_script_desc": "新增「局部」正则表达式",
+    "ext_regex_new_preset_script_desc": "新增「预设」正则表达式",
     "ext_regex_debugger_active_rules": "激活的规则",
     "ext_regex_debugger_save_order": "保存此顺序",
     "ext_regex_debugger_testing_area": "测试区域",

     "ext_regex_preset_delete": "删除当前预设",
     "ext_regex_new_global_script": "新建全局正则",
     "ext_regex_new_scoped_script": "新建局部正则",
+    "ext_regex_new_preset_script": "新建预设正则",
     "ext_regex_import_script": "导入正则",
     "ext_regex_bulk_edit": "批量编辑",
     "ext_regex_debugger_desc": "高级正则调试工具",

     "No scripts found": "没有找到脚本",
     "ext_regex_scoped_scripts": "局部正则脚本",
     "ext_regex_scoped_scripts_desc": "只影响当前角色，保存在角色卡片中",
+    "ext_regex_preset_scripts": "预设正则脚本",
+    "ext_regex_preset_scripts_desc": "只影响当前预设，保存在预设中",
     "ext_regex_disallow_scoped": "不允许使用局部正则",
     "ext_regex_allow_scoped": "允许使用局部正则",
+    "ext_regex_disallow_preset": "不允许使用预设正则",
+    "ext_regex_allow_preset": "允许使用预设正则",
     "Regex Editor": "正则表达式编辑器",
     "Test Mode": "测试模式",
     "ext_regex_desc": "“正则”是一个使用“正则表达式”来查找/替换字符串的工具。如果您想了解更多信息，请点击标题旁边的“？”。",

     "ext_regex_edit_script": "编辑脚本",
     "ext_regex_move_to_global": "移至全局",
     "ext_regex_move_to_scoped": "移至局部",
+    "ext_regex_move_to_preset": "移至预设",
     "ext_regex_export_script": "导出脚本",
     "ext_regex_delete_script": "删除脚本",
+    "This preset has embedded regex script(s).": "此预设包含内置正则脚本。",
+    "Preset '${0}' contains enabled regex scripts": "预设 '${0}' 包含被启用的正则脚本",
+    "Reload the chat for regex to take effect": "重新加载聊天以使正则生效",
+    "Click here to reload immediately": "点击此处立即重新加载",
+    "If you want to do it later, select \"Regex\" from the extensions menu.": "您可稍后从扩展菜单中的（Regex）启用。",
     "Trigger Stable Diffusion": "触发Stable Diffusion",
     "Abort current image generation task": "中止当前图像生成",
     "Stop Image Generation": "停止图像生成",

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

     PRESET_CHANGED: 'preset_changed',
     PRESET_DELETED: 'preset_deleted',
     PRESET_RENAMED: 'preset_renamed',
+    PRESET_RENAMED_BEFORE: 'preset_renamed_before',
     MAIN_API_CHANGED: 'main_api_changed',
     WORLDINFO_ENTRIES_LOADED: 'worldinfo_entries_loaded',
 };

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

     regex: [],
     /** @type {import('./extensions/regex/index.js').RegexPreset[]} */
     regex_presets: [],
+    /** @type {string[]} */
     character_allowed_regex: [],
+    /** @type {Record<string, string[]>} */
+    preset_allowed_regex: {},
     tts: {},
     sd: {
         prompts: {},

public/scripts/extensions/regex/dropdown.html+25 -2 Viewed

                     <i class="fa-solid fa-address-card"></i>
                     <small data-i18n="ext_regex_new_scoped_script">+ Scoped</small>
                 </div>
+                <div id="open_preset_editor" class="menu_button menu_button_icon" data-i18n="[title]ext_regex_new_preset_script_desc" title="New preset regex script">
+                    <i class="fa-solid fa-sliders"></i>
+                    <small data-i18n="ext_regex_new_preset_script">+ Preset</small>
+                </div>
                 <div id="import_regex" class="menu_button menu_button_icon">
                     <i class="fa-solid fa-file-import"></i>
                     <small data-i18n="ext_regex_import_script">Import</small>

                     <i class="fa-solid fa-address-card"></i>
                     <small data-i18n="ext_regex_move_to_scoped">Move to scoped scripts</small>
                 </div>
+                <div id="bulk_regex_move_to_preset" class="menu_button menu_button_icon" hidden>
+                    <i class="fa-solid fa-sliders"></i>
+                    <small data-i18n="ext_regex_move_to_preset">Move to preset scripts</small>
+                </div>
                 <div id="bulk_export_regex" class="menu_button menu_button_icon">
                     <i class="fa-solid fa-file-export"></i>
                     <small data-i18n="Export">Export</small>

                 </div>
             </div>
             <hr />
-            <div id="global_scripts_block" class="padding5">
+            <div id="global_scripts_block">
                 <div>
                     <strong data-i18n="ext_regex_global_scripts">Global Scripts</strong>
                 </div>

                 <div id="saved_regex_scripts" no-scripts-text="No scripts found" data-i18n="[no-scripts-text]No scripts found" class="flex-container regex-script-container flexFlowColumn"></div>
             </div>
             <hr />
-            <div id="scoped_scripts_block" class="padding5">
+            <div id="scoped_scripts_block">
                 <div class="flex-container alignItemsBaseline">
                     <strong class="flex1" data-i18n="ext_regex_scoped_scripts">Scoped Scripts</strong>
                     <label id="toggle_scoped_regex" class="checkbox flex-container" for="regex_scoped_toggle">

                 </small>
                 <div id="saved_scoped_scripts" no-scripts-text="No scripts found" data-i18n="[no-scripts-text]No scripts found" class="flex-container regex-script-container flexFlowColumn"></div>
             </div>
+            <hr />
+            <div id="preset_scripts_block">
+                <div class="flex-container alignItemsBaseline">
+                    <strong class="flex1" data-i18n="ext_regex_preset_scripts">Preset Scripts</strong>
+                    <label id="toggle_preset_regex" class="checkbox flex-container" for="regex_preset_toggle">
+                        <input type="checkbox" id="regex_preset_toggle" class="enable_scoped" />
+                        <span class="regex-toggle-on fa-solid fa-toggle-on fa-lg" data-i18n="[title]ext_regex_disallow_preset" title="Disallow using preset regex"></span>
+                        <span class="regex-toggle-off fa-solid fa-toggle-off fa-lg" data-i18n="[title]ext_regex_allow_preset" title="Allow using preset regex"></span>
+                    </label>
+                </div>
+                <small data-i18n="ext_regex_preset_scripts_desc">
+                    Only available for this preset. Saved to the preset data.
+                </small>
+                <div id="saved_preset_scripts" class="flex-container regex-script-container flexFlowColumn"></div>
+            </div>
         </div>
     </div>
 </div>

public/scripts/extensions/regex/engine.js+161 -4 Viewed

-import { characters, substituteParams, substituteParamsExtended, this_chid } from '../../../script.js';
+import { characters, saveSettingsDebounced, substituteParams, substituteParamsExtended, this_chid } from '../../../script.js';
-import { extension_settings } from '../../extensions.js';
+import { extension_settings, writeExtensionField } from '../../extensions.js';
+import { getPresetManager } from '../../preset-manager.js';
 import { regexFromString } from '../../utils.js';
+import { lodash } from '../../../lib.js';
 /**
  * @enum {number} Regex scripts types
  * @readonly
  */
 export const SCRIPT_TYPES = {
-    UNKNOWN: -1,
     GLOBAL: 0,
     SCOPED: 1,
+    PRESET: 2,
 };
 /**
+ * Special type for unknown/invalid script types.
+ */
+export const SCRIPT_TYPE_UNKNOWN = -1;
+/**
  * @typedef {import('../../char-data.js').RegexScriptData} RegexScript
  */

  */
 export function getScriptsByType(scriptType, { allowedOnly } = DEFAULT_GET_REGEX_SCRIPTS_OPTIONS) {
     switch (scriptType) {
-        case SCRIPT_TYPES.UNKNOWN:
+        case SCRIPT_TYPE_UNKNOWN:
             return [];
         case SCRIPT_TYPES.GLOBAL:
             return extension_settings.regex ?? [];

             const scopedScripts = characters[this_chid]?.data?.extensions?.regex_scripts;
             return Array.isArray(scopedScripts) ? scopedScripts : [];
+        }
+        case SCRIPT_TYPES.PRESET: {
+            if (allowedOnly && !extension_settings?.preset_allowed_regex?.[getCurrentPresetAPI()]?.includes(getCurrentPresetName())) {
+                return [];
+            }
+            const presetManager = getPresetManager();
+            const presetScripts = presetManager?.readPresetExtensionField({ path: 'regex_scripts' });
+            return Array.isArray(presetScripts) ? presetScripts : [];
+        }
         default:
             console.warn(`getScriptsByType: Invalid script type ${scriptType}`);
             return [];

+}
 /**
+ * Saves an array of regex scripts for a specific type.
+ * @param {RegexScript[]} scripts An array of regex scripts to save.
+ * @param {SCRIPT_TYPES} scriptType The type of regex scripts to save.
+ * @returns {Promise<void>}
+ */
+export async function saveScriptsByType(scripts, scriptType) {
+    switch (scriptType) {
+        case SCRIPT_TYPES.GLOBAL:
+            extension_settings.regex = scripts;
+            saveSettingsDebounced();
+            break;
+        case SCRIPT_TYPES.SCOPED:
+            await writeExtensionField(this_chid, 'regex_scripts', scripts);
+            break;
+        case SCRIPT_TYPES.PRESET: {
+            const presetManager = getPresetManager();
+            await presetManager.writePresetExtensionField({ path: 'regex_scripts', value: scripts });
+            break;
+        }
+        default:
+            console.warn(`saveScriptsByType: Invalid script type ${scriptType}`);
+            break;
+    }
+}
+/**
+ * Check if character's regexes are allowed to be used; if character is undefined, returns false
+ * @param {import('../../char-data.js').v1CharData|undefined} character
+ * @returns {boolean}
+ */
+export function isScopedScriptsAllowed(character) {
+    return !!extension_settings?.character_allowed_regex?.includes(character?.avatar);
+}
+/**
+ * Allow character's regexes to be used; if character is undefined, do nothing
+ * @param {import('../../char-data.js').v1CharData|undefined} character
+ * @returns {void}
+ */
+export function allowScopedScripts(character) {
+    const avatar = character?.avatar;
+    if (!avatar) {
+        return;
+    }
+    if (!Array.isArray(extension_settings?.character_allowed_regex)) {
+        extension_settings.character_allowed_regex = [];
+    }
+    if (!extension_settings.character_allowed_regex.includes(avatar)) {
+        extension_settings.character_allowed_regex.push(avatar);
+        saveSettingsDebounced();
+    }
+}
+/**
+ * Disallow character's regexes to be used; if character is undefined, do nothing
+ * @param {import('../../char-data.js').v1CharData|undefined} character
+ * @returns {void}
+ */
+export function disallowScopedScripts(character) {
+    const avatar = character?.avatar;
+    if (!avatar) {
+        return;
+    }
+    if (!Array.isArray(extension_settings?.character_allowed_regex)) {
+        return;
+    }
+    const index = extension_settings.character_allowed_regex.indexOf(avatar);
+    if (index !== -1) {
+        extension_settings.character_allowed_regex.splice(index, 1);
+        saveSettingsDebounced();
+    }
+}
+/**
+ * Check if preset's regexes are allowed to be used
+ * @param {string} apiId API ID
+ * @param {string} presetName Preset name
+ * @returns {boolean} True if allowed, false if not
+ */
+export function isPresetScriptsAllowed(apiId, presetName) {
+    if (!apiId || !presetName) {
+        return false;
+    }
+    return !!extension_settings?.preset_allowed_regex?.[apiId]?.includes(presetName);
+}
+/**
+ * Allow preset's regexes to be used
+ * @param {string} apiId API ID
+ * @param {string} presetName Preset name
+ * @returns {void}
+ */
+export function allowPresetScripts(apiId, presetName) {
+    if (!apiId || !presetName) {
+        return;
+    }
+    if (!Array.isArray(extension_settings?.preset_allowed_regex?.[apiId])) {
+        lodash.set(extension_settings, ['preset_allowed_regex', apiId], []);
+    }
+    if (!extension_settings.preset_allowed_regex[apiId].includes(presetName)) {
+        extension_settings.preset_allowed_regex[apiId].push(presetName);
+        saveSettingsDebounced();
+    }
+}
+/**
+ * Disallow preset's regexes to be used
+ * @param {string} apiId API ID
+ * @param {string} presetName Preset name
+ * @returns {void}
+ */
+export function disallowPresetScripts(apiId, presetName) {
+    if (!apiId || !presetName) {
+        return;
+    }
+    if (!Array.isArray(extension_settings?.preset_allowed_regex?.[apiId])) {
+        return;
+    }
+    const index = extension_settings.preset_allowed_regex[apiId].indexOf(presetName);
+    if (index !== -1) {
+        extension_settings.preset_allowed_regex[apiId].splice(index, 1);
+        saveSettingsDebounced();
+    }
+}
+/**
+ * Gets the current API ID from the preset manager.
+ * @returns {string|null} Current API ID, or null if no preset manager
+ */
+export function getCurrentPresetAPI() {
+    return getPresetManager()?.apiId ?? null;
+}
+/**
+ * Gets the name of the currently selected preset.
+ * @returns {string|null} The name of the currently selected preset, or null if no preset manager
+ */
+export function getCurrentPresetName() {
+    return getPresetManager()?.getSelectedPresetName() ?? null;
+}
+/**
  * @enum {number} Where the regex script should be applied
  * @readonly
  */

public/scripts/extensions/regex/importTarget.html+6 -0 Viewed

                 Scoped Scripts
             </span>
         </label>
+        <label for="regex_import_target_preset">
+            <input type="radio" name="regex_import_target" id="regex_import_target_preset" value="preset" />
+            <span data-i18n="ext_regex_preset_scripts">
+                Preset Scripts
+            </span>
+        </label>
     </div>
 </div>

public/scripts/extensions/regex/index.js+301 -88 Viewed

 import { characters, eventSource, event_types, getCurrentChatId, messageFormatting, reloadCurrentChat, saveSettingsDebounced, this_chid } from '../../../script.js';
-import { extension_settings, renderExtensionTemplateAsync, writeExtensionField } from '../../extensions.js';
+import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';
 import { selected_group } from '../../group-chats.js';
 import { callGenericPopup, Popup, POPUP_TYPE } from '../../popup.js';
 import { SlashCommand } from '../../slash-commands/SlashCommand.js';

 import { SlashCommandEnumValue, enumTypes } from '../../slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
 import { download, equalsIgnoreCaseAndAccents, escapeHtml, getFileText, getSortableDelay, isFalseBoolean, isTrueBoolean, regexFromString, setInfoBlock, uuidv4 } from '../../utils.js';
-import { getRegexScripts, getScriptsByType, regex_placement, runRegexScript, SCRIPT_TYPES, substitute_find_regex } from './engine.js';
+import { allowPresetScripts, allowScopedScripts, disallowPresetScripts, disallowScopedScripts, getCurrentPresetAPI, getCurrentPresetName, getRegexScripts, getScriptsByType, isPresetScriptsAllowed, isScopedScriptsAllowed, regex_placement, runRegexScript, saveScriptsByType, SCRIPT_TYPE_UNKNOWN, SCRIPT_TYPES, substitute_find_regex } from './engine.js';
 import { t } from '../../i18n.js';
 import { accountStorage } from '../../util/AccountStorage.js';
+import { getPresetManager } from '../../preset-manager.js';
 // Re-exports for legacy extensions
 export { getRegexScripts };

  * @property {boolean} isSelected - Whether the preset is currently selected
  * @property {RegexPresetItem[]} global - The list of global preset items
  * @property {RegexPresetItem[]} scoped - The list of scoped preset items
+ * @property {RegexPresetItem[]} preset - The list of preset preset items
  */
 /**
  * @typedef {object} RegexPresetState
  * @property {string[]} global - List of enabled global regex script IDs
  * @property {string[]} scoped - List of enabled scoped regex script IDs
+ * @property {string[]} preset - List of enabled preset regex script IDs
  */
 class RegexPresetManager {

     captureCurrentState() {
         const globalScripts = this.regexListToPresetItems(getScriptsByType(SCRIPT_TYPES.GLOBAL));
         const scopedScripts = this.regexListToPresetItems(getScriptsByType(SCRIPT_TYPES.SCOPED));
+        const presetScripts = this.regexListToPresetItems(getScriptsByType(SCRIPT_TYPES.PRESET));
         return {
             global: globalScripts.map(item => item.id).sort(),
             scoped: scopedScripts.map(item => item.id).sort(),
+            preset: presetScripts.map(item => item.id).sort(),
         };
+    }

         const global2 = state2.global || [];
         const scoped1 = state1.scoped || [];
         const scoped2 = state2.scoped || [];
+        const preset1 = state1.preset || [];
+        const preset2 = state2.preset || [];
         if (global1.length !== global2.length || scoped1.length !== scoped2.length) {
             return true;
+        }
         return !global1.every(id => global2.includes(id)) ||
-            !scoped1.every(id => scoped2.includes(id));
+            !scoped1.every(id => scoped2.includes(id)) ||
+            !preset1.every(id => preset2.includes(id));
+    }
     /**

             return;
+        }
-        // Apply to both global and scoped lists
+        // Apply preset to all lists
+        for (const scriptType of Object.values(SCRIPT_TYPES)) {
             await this.applyPresetList({
-            presetList: preset.global,
+                presetList: {
-            targetList: extension_settings.regex,
+                    [SCRIPT_TYPES.GLOBAL]: preset.global,
-            saveFunction: () => saveSettingsDebounced(),
+                    [SCRIPT_TYPES.SCOPED]: preset.scoped,
-        });
+                    [SCRIPT_TYPES.PRESET]: preset.preset,
-        await this.applyPresetList({
+                }[scriptType],
-            presetList: preset.scoped,
+                targetList: getScriptsByType(scriptType),
-            targetList: characters[this_chid]?.data?.extensions?.regex_scripts,
+                saveFunction: scripts => saveScriptsByType(scripts, scriptType),
-            saveFunction: (scripts) => writeExtensionField(this_chid, 'regex_scripts', scripts),
             });
+        }
         // Render the changes to the UI
         await loadRegexScripts();

             isSelected: false,
             global: this.regexListToPresetItems(getScriptsByType(SCRIPT_TYPES.GLOBAL)),
             scoped: this.regexListToPresetItems(getScriptsByType(SCRIPT_TYPES.SCOPED)),
+            preset: this.regexListToPresetItems(getScriptsByType(SCRIPT_TYPES.PRESET)),
         };
         if (isUpdate) {

 function setMoveButtonsVisibility() {
     const hasGlobalScripts = $('#saved_regex_scripts .regex-script-label:has(.regex_bulk_checkbox:checked)').length > 0;
     const hasScopedScripts = $('#saved_scoped_scripts .regex-script-label:has(.regex_bulk_checkbox:checked)').length > 0;
-    $('#bulk_regex_move_to_global').toggle(hasScopedScripts);
+    const hasPresetScripts = $('#saved_preset_scripts .regex-script-label:has(.regex_bulk_checkbox:checked)').length > 0;
-    $('#bulk_regex_move_to_scoped').toggle(hasGlobalScripts);
+    $('#bulk_regex_move_to_global').toggle(hasScopedScripts || hasPresetScripts);
+    $('#bulk_regex_move_to_scoped').toggle(hasGlobalScripts || hasPresetScripts);
+    $('#bulk_regex_move_to_preset').toggle(hasGlobalScripts || hasScopedScripts);
+}
 /**
  * Saves a regex script to the extension settings or character data.
  * @param {import('../../char-data.js').RegexScriptData} regexScript
  * @param {number} existingScriptIndex Index of the existing script
- * @param {SCRIPT_TYPES} scriptType global? scoped?
+ * @param {SCRIPT_TYPES} scriptType Type of the script
  * @param {boolean} [saveSettings=true] Whether to save the settings immediately
  * @returns {Promise<void>}
  */

@@ -529,12 +541,13 @@ async function saveRegexScript(regexScript, existingScriptIndex, scriptType, sav
529	}	541	}
530		542
531	if (scriptType === SCRIPT_TYPES.SCOPED) {	543	if (scriptType === SCRIPT_TYPES.SCOPED) {
532	await writeExtensionField(this_chid, 'regex_scripts', array);	544	await saveScriptsByType(array, SCRIPT_TYPES.SCOPED);
533		545	allowScopedScripts(characters?.[this_chid]);
534	// Add the character to the allowed list
535	if (!extension_settings.character_allowed_regex.includes(characters[this_chid].avatar)) {
536	extension_settings.character_allowed_regex.push(characters[this_chid].avatar);
537	}	546	}
		547
		548	if (scriptType === SCRIPT_TYPES.PRESET) {
		549	await saveScriptsByType(array, SCRIPT_TYPES.PRESET);
		550	allowPresetScripts(getCurrentPresetAPI(), getCurrentPresetName());
538	}	551	}
539		552
540	if (saveSettings) {	553	if (saveSettings) {

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

     if (existingScriptIndex !== -1) {
         array.splice(existingScriptIndex, 1);
-        if (scriptType === SCRIPT_TYPES.SCOPED) {
+        switch (scriptType) {
-            await writeExtensionField(this_chid, 'regex_scripts', array);
+            case SCRIPT_TYPES.GLOBAL:
+                // will be handled by saveSettingsDebounced
+                break;
+            case SCRIPT_TYPES.SCOPED:
+                await saveScriptsByType(array, SCRIPT_TYPES.SCOPED);
+                break;
+            case SCRIPT_TYPES.PRESET:
+                await saveScriptsByType(array, SCRIPT_TYPES.PRESET);
+                break;
+            default:
+                break;
+        }
         if (saveSettings) {
             saveSettingsDebounced();

@@ -594,7 +617,7 @@ async function moveRegexScript(script, toType, fromType = null, saveSettings = t
594	if (!Object.values(SCRIPT_TYPES).includes(fromType)) {	617	if (!Object.values(SCRIPT_TYPES).includes(fromType)) {
595	fromType = getScriptType(script);	618	fromType = getScriptType(script);
596	}	619	}
597	if (fromType === toType \|\| fromType === SCRIPT_TYPES.UNKNOWN \|\| toType === SCRIPT_TYPES.UNKNOWN) {	620	if (fromType === toType \|\| fromType === SCRIPT_TYPE_UNKNOWN \|\| toType === SCRIPT_TYPE_UNKNOWN) {
598	return;	621	return;
599	}	622	}
600	await deleteRegexScript(script.id, fromType, false);	623	await deleteRegexScript(script.id, fromType, false);

 async function loadRegexScripts() {
     $('#saved_regex_scripts').empty();
     $('#saved_scoped_scripts').empty();
+    $('#saved_preset_scripts').empty();
     setToggleAllIcon(false);
     const scriptTemplate = $(await renderExtensionTemplateAsync('regex', 'scriptTemplate'));

      * Renders a script to the UI.
      * @param {string} container Container to render the script to
      * @param {import('../../char-data.js').RegexScriptData} script Script data
-     * @param {SCRIPT_TYPES} scriptType global? scoped?
+     * @param {SCRIPT_TYPES} scriptType Type of the script
      * @param {number} index Index of the script in the array
      */
     function renderScript(container, script, scriptType, index) {

+        }
         scriptHtml.attr('id', script.id);
-        scriptHtml.find('.regex_script_name').text(script.scriptName);
+        scriptHtml.find('.regex_script_name').text(script.scriptName).attr('title', script.scriptName);
         scriptHtml.find('.disable_regex').prop('checked', script.disabled ?? false)
             .on('input', async function () {
                 script.disabled = !!$(this).prop('checked');

+            }
             await moveRegexScript(script, SCRIPT_TYPES.SCOPED, scriptType);
         });
+        scriptHtml.find('.move_to_preset').on('click', async function () {
+            const confirm = await callGenericPopup(
+                t`Are you sure you want to move this regex script to preset?`,
+                POPUP_TYPE.CONFIRM,
+            );
+            if (!confirm) {
+                return;
+            }
+            await moveRegexScript(script, SCRIPT_TYPES.PRESET, scriptType);
+        });
         scriptHtml.find('.export_regex').on('click', async function () {
             const fileName = `regex-${sanitizeFileName(script.scriptName)}.json`;
             const fileData = JSON.stringify(script, null, 4);

             const allAreChecked = checkboxes.length === checkboxes.filter(':checked').length;
             setToggleAllIcon(allAreChecked);
         });
+        scriptHtml.find('input[name="regex_expand"]').on('change', function () {
+            if (!(this instanceof HTMLInputElement)) {
+                return;
+            }
+            if (!this.checked) {
+                return;
+            }
+            const closeMenuHandler = (e) => {
+                if (e.target instanceof HTMLElement) {
+                    if (e.target.closest('.regex-script-label')) {
+                        return;
+                    }
+                    this.checked = false;
+                    document.removeEventListener('click', closeMenuHandler);
+                }
+            };
+            // Use setTimeout to avoid closing immediately from the same click
+            setTimeout(() => {
+                document.addEventListener('click', closeMenuHandler, { passive: true, once: false });
+            }, 0);
+        });
         $(container).append(scriptHtml);
+    }
     getScriptsByType(SCRIPT_TYPES.GLOBAL).forEach((script, index) => renderScript('#saved_regex_scripts', script, SCRIPT_TYPES.GLOBAL, index));
     getScriptsByType(SCRIPT_TYPES.SCOPED).forEach((script, index) => renderScript('#saved_scoped_scripts', script, SCRIPT_TYPES.SCOPED, index));
+    getScriptsByType(SCRIPT_TYPES.PRESET).forEach((script, index) => renderScript('#saved_preset_scripts', script, SCRIPT_TYPES.PRESET, index));
-    const isScopedAllowed = extension_settings?.character_allowed_regex?.includes(characters?.[this_chid]?.avatar);
+    $('#regex_scoped_toggle').prop('checked', isScopedScriptsAllowed(characters?.[this_chid]));
-    $('#regex_scoped_toggle').prop('checked', isScopedAllowed);
+    $('#regex_preset_toggle').prop('checked', isPresetScriptsAllowed(getCurrentPresetAPI(), getCurrentPresetName()));
     setMoveButtonsVisibility();
+}

 /**
  * Opens the regex editor.
  * @param {string|boolean} existingId Existing ID
- * @param {SCRIPT_TYPES} scriptType global? scoped?
+ * @param {SCRIPT_TYPES} scriptType Type of the script
  * @returns {Promise<void>}
  */
 async function onRegexEditorOpenClick(existingId, scriptType) {

+    }
     const globalScriptIds = new Set(getScriptsByType(SCRIPT_TYPES.GLOBAL).map(s => s.id));
+    const scopedScriptIds = new Set(getScriptsByType(SCRIPT_TYPES.SCOPED).map(s => s.id));
+    const presetScriptIds = new Set(getScriptsByType(SCRIPT_TYPES.PRESET).map(s => s.id));
     const globalScripts = [];
     const scopedScripts = [];
+    const presetScripts = [];
     allScripts.forEach(script => {
         const scriptCopy = structuredClone(script); // Use structuredClone for deep copy
         if (globalScriptIds.has(script.id)) {
             // @ts-ignore
-            scriptCopy.type = SCRIPT_TYPES.SCOPED;
+            scriptCopy.type = SCRIPT_TYPES.GLOBAL;
             globalScripts.push(scriptCopy);
-        } else {
+        } else if (scopedScriptIds.has(script.id)) {
             // @ts-ignore
             scriptCopy.type = SCRIPT_TYPES.SCOPED;
             scopedScripts.push(scriptCopy);
+        } else if (presetScriptIds.has(script.id)) {
+            // @ts-ignore
+            scriptCopy.type = SCRIPT_TYPES.PRESET;
+            presetScripts.push(scriptCopy);
+        }
     });
-    container.data('allScripts', [...globalScripts, ...scopedScripts]);
+    container.data('allScripts', [...globalScripts, ...scopedScripts, ...presetScripts]);
     const renderRule = (script) => {
         if (!script.id) script.id = uuidv4();

+                {
                     [SCRIPT_TYPES.SCOPED]: t`Scoped`,
                     [SCRIPT_TYPES.GLOBAL]: t`Global`,
+                    [SCRIPT_TYPES.PRESET]: t`Preset`,
                 }[script.type],
             );
         ruleElement.find('.rule-enabled').prop('checked', !script.disabled);

         scopedScripts.forEach(script => scopedList.append(renderRule(script)));
         rulesContainer.append(scopedList);
+    }
+    if (presetScripts.length > 0) {
+        rulesContainer.append('<div class="list-header regex-debugger-list-header">' + t`Preset Rules` + '</div>');
+        const presetList = $('<ul id="regex_debugger_rules_preset" class="sortable-list"></ul>');
+        presetScripts.forEach(script => presetList.append(renderRule(script)));
+        rulesContainer.append(presetList);
+    }
+}
 /**

     debuggerHtml.find('#regex_debugger_rules_global').sortable({ delay: getSortableDelay() }).disableSelection();
     // @ts-ignore
     debuggerHtml.find('#regex_debugger_rules_scoped').sortable({ delay: getSortableDelay() }).disableSelection();
+    // @ts-ignore
+    debuggerHtml.find('#regex_debugger_rules_preset').sortable({ delay: getSortableDelay() }).disableSelection();
     debuggerHtml.find('#regex_debugger_run_test').on('click', function () {
         const allScripts = debuggerHtml.data('allScripts');
         const orderedRuleIds = [
             ...$('#regex_debugger_rules_global').find('li.regex-debugger-rule').map((i, el) => $(el).data('id')).get(),
             ...$('#regex_debugger_rules_scoped').find('li.regex-debugger-rule').map((i, el) => $(el).data('id')).get(),
+            ...$('#regex_debugger_rules_preset').find('li.regex-debugger-rule').map((i, el) => $(el).data('id')).get(),
         ];
         const rawInput = String($('#regex_debugger_raw_input').val());

         const allKnownScripts = getRegexScripts();
         const newGlobalScripts = $('#regex_debugger_rules_global').children('li').map((_, el) => allKnownScripts.find(s => s.id === $(el).data('id'))).get().filter(Boolean);
         const newScopedScripts = $('#regex_debugger_rules_scoped').children('li').map((_, el) => allKnownScripts.find(s => s.id === $(el).data('id'))).get().filter(Boolean);
+        const newPresetScripts = $('#regex_debugger_rules_preset').children('li').map((_, el) => allKnownScripts.find(s => s.id === $(el).data('id'))).get().filter(Boolean);
         extension_settings.regex = newGlobalScripts;
         if (this_chid !== undefined) {
-            await writeExtensionField(this_chid, 'regex_scripts', newScopedScripts);
+            await saveScriptsByType(newScopedScripts, SCRIPT_TYPES.SCOPED);
+        }
+        await saveScriptsByType(newPresetScripts, SCRIPT_TYPES.PRESET);
         saveSettingsDebounced();
         await loadRegexScripts();

         currentPopupContent.find('#regex_debugger_rules_global').sortable({ delay: getSortableDelay() }).disableSelection();
         // @ts-ignore
         currentPopupContent.find('#regex_debugger_rules_scoped').sortable({ delay: getSortableDelay() }).disableSelection();
+        // @ts-ignore
+        currentPopupContent.find('#regex_debugger_rules_preset').sortable({ delay: getSortableDelay() }).disableSelection();
     });
     debuggerHtml.find('#regex_debugger_expand_steps').on('click', function () {

@@ -1328,11 +1409,6 @@ function migrateSettings() {
1328	}	1409	}
1329	});	1410	});
1330		1411
1331	if (!extension_settings.character_allowed_regex) {
1332	extension_settings.character_allowed_regex = [];
1333	performSave = true;
1334	}
1335
1336	if (performSave) {	1412	if (performSave) {
1337	saveSettingsDebounced();	1413	saveSettingsDebounced();
1338	}	1414	}

 /**
  * Performs the import of the regex object.
- * @param {Object} regexScript Input object
+ * @param {RegexScript} regexScript Input object
- * @param {SCRIPT_TYPES} scriptType global? scoped?
+ * @param {SCRIPT_TYPES} scriptType The type of script to import as
  */
 async function onRegexImportObjectChange(regexScript, scriptType) {
     try {

         const array = getScriptsByType(scriptType);
         array.push(regexScript);
-        if (scriptType === SCRIPT_TYPES.SCOPED) {
+        switch (scriptType) {
-            await writeExtensionField(this_chid, 'regex_scripts', array);
+            case SCRIPT_TYPES.GLOBAL:
+                // will be handled by saveSettingsDebounced
+                break;
+            case SCRIPT_TYPES.SCOPED:
+                await saveScriptsByType(array, SCRIPT_TYPES.SCOPED);
+                break;
+            case SCRIPT_TYPES.PRESET:
+                await saveScriptsByType(array, SCRIPT_TYPES.PRESET);
+                break;
+            default:
+                break;
+        }
         saveSettingsDebounced();

 /**
  * Performs the import of the regex file.
  * @param {File} file Input file
- * @param {SCRIPT_TYPES} scriptType global? scoped?
+ * @param {SCRIPT_TYPES} scriptType The type of script to import as
  */
 async function onRegexImportFileChange(file, scriptType) {
     if (!file) {

  * @returns {SCRIPT_TYPES} The script type.
  */
 function getScriptType(script) {
-    const scopedScripts = getScriptsByType(SCRIPT_TYPES.SCOPED);
+    for (const scriptType of Object.values(SCRIPT_TYPES)) {
-    if (scopedScripts.some(s => s.id === script.id)) {
+        const scripts = getScriptsByType(scriptType);
-        return SCRIPT_TYPES.SCOPED;
+        if (scripts.some(s => s.id === script.id)) {
+            return scriptType;
+        }
-    const globalScripts = getScriptsByType(SCRIPT_TYPES.GLOBAL);
-    if (globalScripts.some(s => s.id === script.id)) {
-        return SCRIPT_TYPES.GLOBAL;
+    }
+    return SCRIPT_TYPE_UNKNOWN;
-    return SCRIPT_TYPES.UNKNOWN;
+}
 function getSelectedScripts() {

     if (!avatar) {
         return;
+    }
-    const checkKey = `AlertRegex_${characters[this_chid].avatar}`;
+    const checkKey = `AlertRegex_${avatar}`;
     if (accountStorage.getItem(checkKey)) {
         accountStorage.removeItem(checkKey);
+    }
-    const index = extension_settings.character_allowed_regex.indexOf(avatar);
+    disallowScopedScripts(characters?.[this_chid]);
-    if (index !== -1) {
-        extension_settings.character_allowed_regex.splice(index, 1);
-        saveSettingsDebounced();
+}
+function purgePresetEmbeddedRegexScripts({ apiId, name }) {
+    const checkKey = `AlertRegex_${apiId}_${name}`;
+    if (accountStorage.getItem(checkKey)) {
+        accountStorage.removeItem(checkKey);
+    }
+    disallowPresetScripts(apiId, name);
+}
 async function checkCharEmbeddedRegexScripts() {
     const chid = this_chid;
     if (chid !== undefined && !selected_group) {
-        const avatar = characters[chid]?.avatar;
+        const character = characters[chid];
         const scripts = getScriptsByType(SCRIPT_TYPES.SCOPED);
         if (Array.isArray(scripts) && scripts.length > 0) {
-            if (avatar && !extension_settings.character_allowed_regex.includes(avatar)) {
+            if (!isScopedScriptsAllowed(character)) {
-                const checkKey = `AlertRegex_${characters[chid].avatar}`;
+                const checkKey = `AlertRegex_${character.avatar}`;
                 if (!accountStorage.getItem(checkKey)) {
                     accountStorage.setItem(checkKey, 'true');
                     const template = await renderExtensionTemplateAsync('regex', 'embeddedScripts', {});
-                    const result = await callGenericPopup(template, POPUP_TYPE.CONFIRM, '', { okButton: 'Yes' });
+                    const result = await callGenericPopup(template, POPUP_TYPE.CONFIRM, '');
                     if (result) {
-                        extension_settings.character_allowed_regex.push(avatar);
+                        allowScopedScripts(character);
                         await reloadCurrentChat();
-                        saveSettingsDebounced();
+                    }
+                }
+            }
+        }
+    }
-    loadRegexScripts();
+    await loadRegexScripts();
+}
+/**
+ * Notify whether to reload current chat when preset is changed
+ * @param {string} presetName The name of the preset
+ */
+function notifyReloadCurrentChat(presetName) {
+    toastr.info(
+        t`Reload the chat for regex to take effect` + '<br><u>' + t`Click here to reload immediately` + '</u>',
+        t`Preset '${presetName}' contains enabled regex scripts`,
+        {
+            timeOut: 5000,
+            escapeHtml: false,
+            onclick: reloadCurrentChat,
+        });
+}
+async function checkPresetEmbeddedRegexScripts() {
+    const apiId = getCurrentPresetAPI();
+    const name = getCurrentPresetName();
+    const scripts = getScriptsByType(SCRIPT_TYPES.PRESET);
+    if (Array.isArray(scripts) && scripts.length > 0) {
+        if (!isPresetScriptsAllowed(apiId, name)) {
+            const checkKey = `AlertRegex_${apiId}_${name}`;
+            if (!accountStorage.getItem(checkKey)) {
+                accountStorage.setItem(checkKey, 'true');
+                const template = await renderExtensionTemplateAsync('regex', 'presetEmbeddedScripts', {});
+                const result = await callGenericPopup(template, POPUP_TYPE.CONFIRM, '');
+                if (result) {
+                    allowPresetScripts(apiId, name);
+                    if (getCurrentChatId()) {
+                        await reloadCurrentChat();
+                    }
+                }
+            }
+        } else if (getCurrentChatId() && scripts.filter(script => !script.disabled).length > 0) {
+            notifyReloadCurrentChat(name);
+        }
+    }
+    await loadRegexScripts();
+}
+async function onMainApiChanged({ apiId }) {
+    const presetManager = getPresetManager(apiId);
+    if (!presetManager) {
+        return;
+    }
+    const presetName = presetManager.getSelectedPresetName();
+    const presetScripts = presetManager.readPresetExtensionField({ path: 'regex_scripts' }) ?? [];
+    if (getCurrentChatId() &&
+        isPresetScriptsAllowed(apiId, presetName) &&
+        Array.isArray(presetScripts) &&
+        presetScripts.filter(script => !script.disabled).length > 0) {
+        notifyReloadCurrentChat(presetName);
+    }
+    await loadRegexScripts();
+}
+function onPresetRenamed({ apiId, oldName, newName }) {
+    const oldCheckKey = `AlertRegex_${apiId}_${oldName}`;
+    const checkKey = `AlertRegex_${apiId}_${newName}`;
+    const value = accountStorage.getItem(oldCheckKey);
+    if (value) {
+        accountStorage.setItem(checkKey, value);
+        accountStorage.removeItem(oldCheckKey);
+    }
+    if (isPresetScriptsAllowed(apiId, oldName)) {
+        disallowPresetScripts(apiId, oldName);
+        allowPresetScripts(apiId, newName);
+    }
+}
 // Workaround for loading in sequence with other extensions

         onRegexEditorOpenClick(false, SCRIPT_TYPES.SCOPED);
     });
+    $('#open_preset_editor').on('click', function () {
+        onRegexEditorOpenClick(false, SCRIPT_TYPES.PRESET);
+    });
     $('#import_regex_file').on('change', async function () {
         let target = SCRIPT_TYPES.GLOBAL;
         const template = $(await renderExtensionTemplateAsync('regex', 'importTarget'));
         template.find('#regex_import_target_global').on('input', () => (target = SCRIPT_TYPES.GLOBAL));
         template.find('#regex_import_target_scoped').on('input', () => (target = SCRIPT_TYPES.SCOPED));
+        template.find('#regex_import_target_preset').on('input', () => (target = SCRIPT_TYPES.PRESET));
         await callGenericPopup(template, POPUP_TYPE.TEXT);

     });
     $('#bulk_enable_regex').on('click', async function () {
-        const scripts = getSelectedScripts().filter(script => script.disabled);
+        await bulkToggleRegexScripts(true);
-        if (scripts.length === 0) {
-            toastr.warning(t`No regex scripts selected for enabling.`);
-            return;
-        }
-        for (const script of scripts) {
-            script.disabled = false;
-        }
-        saveSettingsDebounced();
-        await loadRegexScripts();
     });
     $('#bulk_disable_regex').on('click', async function () {
-        const scripts = getSelectedScripts().filter(script => !script.disabled);
+        await bulkToggleRegexScripts(false);
+    });
+    /**
+     * Bulk enable or disable regex scripts
+     * @param {boolean} newState New state to set (true = enable, false = disable)
+     * @returns {Promise<void>}
+     */
+    async function bulkToggleRegexScripts(newState) {
+        const scripts = getSelectedScripts().filter(script => script.disabled === newState);
         if (scripts.length === 0) {
-            toastr.warning(t`No regex scripts selected for disabling.`);
+            toastr.warning(newState
+                ? t`No regex scripts selected for enabling.`
+                : t`No regex scripts selected for disabling.`,
+            );
             return;
+        }
+        const scriptTypesToSave = new Set();
         for (const script of scripts) {
-            script.disabled = true;
+            const scriptType = getScriptType(script);
+            scriptTypesToSave.add(scriptType);
+            script.disabled = !newState;
+        }
+        for (const scriptType of scriptTypesToSave) {
+            const scriptsOfType = getScriptsByType(scriptType);
+            await saveScriptsByType(scriptsOfType, scriptType);
+        }
         saveSettingsDebounced();
         await loadRegexScripts();
-    });
+        // Reload the current chat to undo previous markdown
+        const currentChatId = getCurrentChatId();
+        if (currentChatId) {
+            await reloadCurrentChat();
+        }
+    }
     /**
      * Bulk move regex scripts to the specified type

             await moveRegexScript(script, toType, getScriptType(script), false);
+        }
+        saveSettingsDebounced();
         await loadRegexScripts();
         // Reload the current chat to undo previous markdown

         await bulkMoveRegexScript(SCRIPT_TYPES.SCOPED);
     });
+    $('#bulk_regex_move_to_preset').on('click', async function () {
+        const confirm = await callGenericPopup(t`Are you sure you want to move the selected regex scripts to preset?`, POPUP_TYPE.CONFIRM);
+        if (!confirm) {
+            return;
+        }
+        await bulkMoveRegexScript(SCRIPT_TYPES.PRESET);
+    });
     $('#bulk_delete_regex').on('click', async function () {
         const scripts = getSelectedScripts();
         if (scripts.length === 0) {

     let sortableDatas = [
+        {
             selector: '#saved_regex_scripts',
-            setter: x => extension_settings.regex = x,
+            setter: scripts => saveScriptsByType(scripts, SCRIPT_TYPES.GLOBAL),
             getter: () => getScriptsByType(SCRIPT_TYPES.GLOBAL),
         },
+        {
             selector: '#saved_scoped_scripts',
-            setter: x => writeExtensionField(this_chid, 'regex_scripts', x),
+            setter: scripts => saveScriptsByType(scripts, SCRIPT_TYPES.SCOPED),
             getter: () => getScriptsByType(SCRIPT_TYPES.SCOPED),
         },
+        {
+            selector: '#saved_preset_scripts',
+            setter: scripts => saveScriptsByType(scripts, SCRIPT_TYPES.PRESET),
+            getter: () => getScriptsByType(SCRIPT_TYPES.PRESET),
+        },
     ];
     for (const { selector, setter, getter } of sortableDatas) {
         // @ts-ignore

+        }
         const isEnable = !!$(this).prop('checked');
-        const avatar = characters[this_chid].avatar;
+        const character = characters[this_chid];
         if (isEnable) {
-            if (!extension_settings.character_allowed_regex.includes(avatar)) {
+            allowScopedScripts(character);
-                extension_settings.character_allowed_regex.push(avatar);
-            }
         } else {
-            const index = extension_settings.character_allowed_regex.indexOf(avatar);
+            disallowScopedScripts(character);
-            if (index !== -1) {
-                extension_settings.character_allowed_regex.splice(index, 1);
+        }
+        saveSettingsDebounced();
+        reloadCurrentChat();
+    });
+    $('#regex_preset_toggle').on('input', function () {
+        const isEnable = !!$(this).prop('checked');
+        const name = getCurrentPresetName();
+        if (isEnable) {
+            allowPresetScripts(getCurrentPresetAPI(), name);
+        } else {
+            disallowPresetScripts(getCurrentPresetAPI(), name);
+        }
         saveSettingsDebounced();

                     color: enumTypes.name,
                     icon: 'S',
                 };
+            case SCRIPT_TYPES.PRESET:
+                return {
+                    typename: 'preset',
+                    color: enumTypes.name,
+                    icon: 'P',
+                };
             default:
                 return {
                     typename: 'Unknown',

         `,
     }));
+    eventSource.on(event_types.MAIN_API_CHANGED, onMainApiChanged);
     eventSource.on(event_types.CHAT_CHANGED, checkCharEmbeddedRegexScripts);
     eventSource.on(event_types.CHARACTER_DELETED, purgeEmbeddedRegexScripts);
+    eventSource.on(event_types.PRESET_RENAMED_BEFORE, onPresetRenamed);
+    eventSource.on(event_types.PRESET_CHANGED, checkPresetEmbeddedRegexScripts);
+    eventSource.on(event_types.PRESET_DELETED, purgePresetEmbeddedRegexScripts);
     presetManager.setupEventListeners();
     presetManager.registerSlashCommands();

public/scripts/extensions/regex/presetEmbeddedScripts.html+5 -0 Viewed

+<div>
+    <h3 data-i18n="This preset has embedded regex script(s).">This preset has embedded regex script(s).</h3>
+    <h3 data-i18n="Would you like to allow using them?">Would you like to allow using them?</h3>
+    <div class="m-b-1" data-i18n="If you want to do it later, select 'Regex' from the extensions menu.">If you want to do it later, select "Regex" from the extensions menu.</div>
+</div>

public/scripts/extensions/regex/scriptTemplate.html+14 -5 Viewed

 <div class="regex-script-label flex-container flexnowrap">
     <input type="checkbox" class="regex_bulk_checkbox" />
     <span class="drag-handle menu-handle">&#9776;</span>
-    <div class="regex_script_name flexGrow overflow-hidden"></div>
+    <div class="regex_script_name flex1 overflow-hidden"></div>
     <div class="flex-container flexnowrap">
-        <label class="checkbox flex-container" for="regex_disable">
+        <label class="checkbox flex-container margin-r5" for="regex_disable">
             <input type="checkbox" name="regex_disable" class="disable_regex" />
             <span class="regex-toggle-on fa-solid fa-toggle-on" data-i18n="[title]ext_regex_disable_script" title="Disable script"></span>
             <span class="regex-toggle-off fa-solid fa-toggle-off" data-i18n="[title]ext_regex_enable_script" title="Enable script"></span>
         </label>
-        <div class="edit_existing_regex menu_button" data-i18n="[title]ext_regex_edit_script" title="Edit script">
+        <label class="menu_button regex_script_expand" title="Show more options" data-i18n="[title]Show more options">
-            <i class="fa-solid fa-pencil"></i>
+            <input type="checkbox" name="regex_expand" />
-        </div>
+            <span class="fa-solid fa-ellipsis"></span>
+        </label>
+        <div class="flex-container regex_script_buttons">
             <div class="move_to_global menu_button" data-i18n="[title]ext_regex_move_to_global" title="Move to global scripts">
                 <i class="fa-solid fa-globe"></i>
             </div>
             <div class="move_to_scoped menu_button" data-i18n="[title]ext_regex_move_to_scoped" title="Move to scoped scripts">
                 <i class="fa-solid fa-address-card"></i>
             </div>
+            <div class="move_to_preset menu_button" data-i18n="[title]ext_regex_move_to_preset" title="Move to preset scripts">
+                <i class="fa-solid fa-sliders"></i>
+            </div>
             <div class="export_regex menu_button" data-i18n="[title]ext_regex_export_script" title="Export script">
                 <i class="fa-solid fa-file-export"></i>
             </div>
+        </div>
+        <div class="edit_existing_regex menu_button" data-i18n="[title]ext_regex_edit_script" title="Edit script">
+            <i class="fa-solid fa-pencil"></i>
+        </div>
         <div class="delete_regex menu_button" data-i18n="[title]ext_regex_delete_script" title="Delete script">
             <i class="fa-solid fa-trash"></i>
         </div>

public/scripts/extensions/regex/style.css+29 -25 Viewed

     text-align: center;
+}
-#scoped_scripts_block {
+#scoped_scripts_block,
+#preset_scripts_block {
     opacity: 1;
     transition: opacity var(--animation-duration-2x) ease-in-out;
+}
-#scoped_scripts_block .move_to_scoped {
+#scoped_scripts_block .move_to_scoped,
+#global_scripts_block .move_to_global,
+#preset_scripts_block .move_to_preset {
     display: none;
+}
-#global_scripts_block .move_to_global {
+#scoped_scripts_block:not(:has(#regex_scoped_toggle:checked)),
-    display: none;
+#preset_scripts_block:not(:has(#regex_preset_toggle:checked)) {
-}
-#scoped_scripts_block:not(:has(#regex_scoped_toggle:checked)) {
     opacity: 0.5;
+}
-.enable_scoped:checked~.regex-toggle-on {
+.enable_scoped:checked~.regex-toggle-on,
+.enable_scoped:not(:checked)~.regex-toggle-off {
     display: block;
+}
-.enable_scoped:checked~.regex-toggle-off {
+.enable_scoped:checked~.regex-toggle-off,
-    display: none;
-}
 .enable_scoped:not(:checked)~.regex-toggle-on {
     display: none;
+}
-.enable_scoped:not(:checked)~.regex-toggle-off {
-    display: block;
-}
 .regex-script-label {
     align-items: baseline;
     border: 1px solid var(--SmartThemeBorderColor);

     cursor: pointer;
+}
-.disable_regex:checked~.regex-toggle-off {
+.disable_regex:checked~.regex-toggle-on,
-    display: block;
-}
-.disable_regex:checked~.regex-toggle-on {
-    display: none;
-}
 .disable_regex:not(:checked)~.regex-toggle-off {
     display: none;
+}
-.disable_regex:not(:checked)~.regex-toggle-on {
+.disable_regex:not(:checked)~.regex-toggle-on,
+.disable_regex:checked~.regex-toggle-off {
     display: block;
+}

 .regex_settings:has(#regex_bulk_edit:checked) .regex_bulk_checkbox {
     display: inline-grid;
+}
+@supports not selector(:has(*)) {
+    .regex-script-label label.regex_script_expand {
+        display: none;
+    }
+    .regex-script-label .regex_script_buttons {
+        display: flex;
+    }
+}
+.regex-script-label label.regex_script_expand input[name="regex_expand"],
+.regex-script-label:has(input[name="regex_expand"]:checked) label.regex_script_expand,
+.regex-script-label:not(:has(input[name="regex_expand"]:checked)) .regex_script_buttons {
+    display: none;
+}

public/scripts/preset-manager.js+12 -7 Viewed

  * @returns {PresetManager} Preset manager
  */
 export function getPresetManager(apiId = '') {
+    if (apiId === 'koboldhorde') {
+        apiId = 'kobold';
+    }
     if (!apiId) {
         apiId = main_api == 'koboldhorde' ? 'kobold' : main_api;
+    }

      * Reads a preset extension field from the preset.
      * @param {object} options
      * @param {string} [options.name] Name of the preset. If not provided, uses the currently selected preset name.
-     * @param {string} options.path Path to the preset extension field, e.g. 'myextension.data'.
+     * @param {string} options.path Path to the preset extension field, e.g. 'myextension.data'. If empty, reads the entire extensions object.
      * @return {any} The value of the preset extension field, or null if not found.
      */
     readPresetExtensionField({ name, path }) {

         // Read from settings if the selected preset is the same as the provided name
         if (settings && selectedName === presetName) {
             const settingsExtensions = ensurePlainObject(settings.extensions || {});
-            return lodash.get(settingsExtensions, path, null);
+            return path ? lodash.get(settingsExtensions, path, null) : settingsExtensions;
+        }
         // Otherwise, read from the preset by name

@@ -835,7 +838,7 @@ class PresetManager {
835	}	838	}
836		839
837	const presetExtensions = ensurePlainObject(preset.extensions \|\| {});	840	const presetExtensions = ensurePlainObject(preset.extensions \|\| {});
838	const value = lodash.get(presetExtensions, path, null);	841	const value = path ? lodash.get(presetExtensions, path, null) : presetExtensions;
839	return value;	842	return value;
840	}	843	}
841		844

      * Writes a value to a preset extension field.
      * @param {object} options
      * @param {string} [options.name] Name of the preset. If not provided, uses the currently selected preset name.
-     * @param {string} options.path Path to the preset extension field, e.g. 'myextension.data'.
+     * @param {string} options.path Path to the preset extension field, e.g. 'myextension.data'. If empty, writes to the root of the extensions object.
      * @param {any} options.value Value to write to the preset extension field.
      * @return {Promise<void>} Resolves when the preset is saved.
      */

         if (settings && selectedName === presetName) {
             // Set the value at the specified path
             settings.extensions = ensurePlainObject(settings.extensions || {});
-            lodash.set(settings.extensions, path, value);
+            path ? lodash.set(settings.extensions, path, value) : (settings.extensions = value);
             await saveSettings();
+        }

         // Set the value at the specified path
         preset.extensions = ensurePlainObject(preset.extensions || {});
-        lodash.set(preset.extensions, path, value);
+        path ? lodash.set(preset.extensions, path, value) : (preset.extensions = value);
         // Save the updated preset
         await this.savePreset(presetName, preset, { skipUpdate: true });

             return;
+        }
+        await eventSource.emit(event_types.PRESET_RENAMED_BEFORE, { apiId: apiId, oldName: oldName, newName: newName });
+        const extensions = presetManager.readPresetExtensionField({ name: oldName, path: '' });
         await presetManager.renamePreset(newName);
+        await presetManager.writePresetExtensionField({ name: newName, path: '', value: extensions });
         await eventSource.emit(event_types.PRESET_RENAMED, { apiId: apiId, oldName: oldName, newName: newName });
         if (apiId === 'openai') {