update

2025-04-22 02:10:45 +08:00
parent 7b3a9fd88f
commit 7eac93a569
5 changed files with 340 additions and 236 deletions
@@ -177,14 +177,14 @@ const handleGlobalKeyUp = async (event: KeyboardEvent) => {
          }
      }

-      const configuredItems = focusSwitcherStore.configuredItems;
-      if (configuredItems.length === 0) {
+      const order = focusSwitcherStore.sequenceOrder; // ++ 使用新的 sequenceOrder state ++
+      if (order.length === 0) { // ++ 检查新的 state ++
        console.log('[App] No focus sequence configured.');
        return;
      }

      let focused = false;
-      for (let i = 0; i < configuredItems.length; i++) {
+      for (let i = 0; i < order.length; i++) { // ++ Use order.length for loop condition ++
        const nextFocusId = focusSwitcherStore.getNextFocusTargetId(currentFocusId);
        if (!nextFocusId) {
          console.warn('[App] Could not determine next focus target ID in sequence.');
@@ -2,11 +2,11 @@
 import { ref, computed, watch, reactive, type Ref } from 'vue'; // 添加 Ref
 import { useI18n } from 'vue-i18n';
 import draggable from 'vuedraggable';
-import { useFocusSwitcherStore, type FocusableInput, type ConfiguredFocusableInput } from '../stores/focusSwitcher.store'; // +++ 导入新接口 +++
+import { useFocusSwitcherStore, type FocusableInput, type FocusItemConfig, type FocusSwitcherFullConfig } from '../stores/focusSwitcher.store'; // ++ 导入新接口 ++
 import { storeToRefs } from 'pinia';
-// --- 移除本地类型定义 ---
-

+// 本地接口，仅用于右侧列表显示
+interface SequenceDisplayItem extends FocusableInput {}


 // --- Props ---
@@ -36,27 +36,50 @@ const dialogStyle = reactive({
  position: 'absolute' as 'absolute',
 });
 const hasChanges = ref(false);
-// 本地副本，用于在弹窗内编辑而不直接修改 store
-const localSequence: Ref<ConfiguredFocusableInput[]> = ref([]); // +++ 使用导入的接口 +++
-// +++ 存储原始序列（包含 ID 和快捷键），用于比较 +++
-const originalSequence: Ref<ConfiguredFocusableInput[]> = ref([]); // +++ 使用导入的接口 +++
+// 本地副本，用于在弹窗内编辑
+const localSequence = ref<SequenceDisplayItem[]>([]); // 右侧列表，只关心顺序和基础信息
+const localItemConfigs = ref<Record<string, FocusItemConfig>>({}); // 所有项目的配置 (快捷键)
+const originalConfig = ref<FocusSwitcherFullConfig | null>(null); // 存储原始完整配置用于比较

 // --- Watchers ---
-watch(() => props.isVisible, (newValue) => {
+watch(() => props.isVisible, async (newValue) => { // ++ Make async for potential backend load ++
  if (newValue) {
-    // 从 Store 加载当前配置到本地副本
-    // 从 Store 加载当前配置到本地副本
-    // !!! 注意：Store 现在也需要支持快捷键，这里暂时假设它返回的数据包含 shortcut !!!
-    // 假设 getConfiguredInputs 返回的是 LocalFocusableInput[] 或能转换的类型
-    const loadedSequenceFromStore = focusSwitcherStore.getConfiguredInputs; // 这个 getter 可能需要修改
-    console.log('[FocusSwitcherConfigurator] Loading sequence from store getter...');
-    // 深拷贝，并确保每个项目都有 shortcut 属性（可能为 undefined）
-    // Store getter 现在返回正确的类型，可以直接深拷贝
-    localSequence.value = JSON.parse(JSON.stringify(loadedSequenceFromStore));
-    originalSequence.value = JSON.parse(JSON.stringify(loadedSequenceFromStore)); // 同样直接拷贝
+    // --- 加载完整配置 ---
+    // 确保 Store 已初始化 (如果 Store 还没有加载完)
+    // await focusSwitcherStore.loadConfigurationFromBackend(); // 如果 Store 初始化时未加载，则在此加载
+
+    const currentSequenceOrder = focusSwitcherStore.sequenceOrder;
+    const currentItemConfigs = focusSwitcherStore.itemConfigs;
+    const allAvailableInputs = focusSwitcherStore.availableInputs; // 获取所有可用输入的基础信息
+    const inputsMap = new Map(allAvailableInputs.map(input => [input.id, input]));
+
+    console.log('[FocusSwitcherConfigurator] Loading full config from store...');
+    console.log('[FocusSwitcherConfigurator] Store sequenceOrder:', JSON.stringify(currentSequenceOrder));
+    console.log('[FocusSwitcherConfigurator] Store itemConfigs:', JSON.stringify(currentItemConfigs));
+
+    // 构建本地右侧列表 (localSequence)
+    localSequence.value = currentSequenceOrder
+      .map(id => inputsMap.get(id)) // 获取基础信息
+      .filter((input): input is SequenceDisplayItem => input !== undefined); // 过滤掉无效 ID 并断言类型
+
+    // 构建本地所有项目配置 (localItemConfigs) - 深拷贝
+    // 确保所有 availableInputs 都有一个条目，即使没有快捷键
+    const initialConfigs: Record<string, FocusItemConfig> = {};
+    allAvailableInputs.forEach(input => {
+        initialConfigs[input.id] = { ... (currentItemConfigs[input.id] || {}) }; // 复制 store 中的配置，或创建空对象
+    });
+    localItemConfigs.value = JSON.parse(JSON.stringify(initialConfigs));
+
+    // 存储原始完整配置用于比较
+    originalConfig.value = JSON.parse(JSON.stringify({
+        sequence: currentSequenceOrder,
+        shortcuts: currentItemConfigs
+    }));
+
    hasChanges.value = false;
-    console.log('[FocusSwitcherConfigurator] Dialog opened. Loaded sequence to local copy:', localSequence.value);
-    console.log('[FocusSwitcherConfigurator] Original sequence stored:', originalSequence.value);
+    console.log('[FocusSwitcherConfigurator] Dialog opened. Loaded localSequence:', JSON.stringify(localSequence.value));
+    console.log('[FocusSwitcherConfigurator] Loaded localItemConfigs:', JSON.stringify(localItemConfigs.value));
+    console.log('[FocusSwitcherConfigurator] Original full config stored:', JSON.stringify(originalConfig.value));
    // 重置/计算初始位置和大小
    requestAnimationFrame(() => {
      if (dialogRef.value) {
@@ -76,17 +99,30 @@ watch(() => props.isVisible, (newValue) => {
 });

 // 监听本地序列（包括快捷键）变化，标记未保存更改
-watch(localSequence, (currentLocalSequence) => {
-  // 比较当前本地序列和原始序列的 JSON 字符串
-  const hasChanged = JSON.stringify(currentLocalSequence) !== JSON.stringify(originalSequence.value);
-  if (hasChanged) {
-    // console.log('[FocusSwitcherConfigurator] Local sequence changed.'); // +++ Log: Changed +++
-    hasChanges.value = true;
-  } else {
-    // console.log('[FocusSwitcherConfigurator] Local sequence reverted to original.'); // +++ Log: Reverted +++
-    // 如果序列变回和原来一样，则标记为无更改
-    hasChanges.value = false;
+// --- 修改：监听 localSequence 和 localItemConfigs 的变化 ---
+watch([localSequence, localItemConfigs], ([currentSequence, currentConfigs]) => {
+  if (!originalConfig.value) return; // 尚未加载完成
+
+  // 比较序列顺序
+  const sequenceChanged = JSON.stringify(currentSequence.map(item => item.id)) !== JSON.stringify(originalConfig.value.sequence);
+
+  // 比较快捷键配置 (需要过滤掉原始配置中不存在的键，以防初始化时加入)
+  const currentShortcuts: Record<string, FocusItemConfig> = {};
+  for(const id in currentConfigs) {
+      // 只比较原始配置中存在的 ID 或当前序列中的 ID 的快捷键是否有变化
+      if (originalConfig.value.shortcuts[id] !== undefined || currentSequence.some(item => item.id === id)) {
+          currentShortcuts[id] = { shortcut: currentConfigs[id].shortcut };
+      }
  }
+  const originalShortcuts: Record<string, FocusItemConfig> = {};
+   for(const id in originalConfig.value.shortcuts) {
+       originalShortcuts[id] = { shortcut: originalConfig.value.shortcuts[id].shortcut };
+   }
+  const shortcutsChanged = JSON.stringify(currentShortcuts) !== JSON.stringify(originalShortcuts);
+
+  hasChanges.value = sequenceChanged || shortcutsChanged;
+  // console.log(`[FocusSwitcherConfigurator] Changes detected: sequence=${sequenceChanged}, shortcuts=${shortcutsChanged}, hasChanges=${hasChanges.value}`);
+
 }, { deep: true });


@@ -102,27 +138,41 @@ const closeDialog = () => {
 };

 const saveConfiguration = () => {
-  // 提取仅包含 id 和 shortcut 的配置项数组
-  const configToSave = localSequence.value.map(item => ({
-    id: item.id,
-    shortcut: item.shortcut || undefined, // 空字符串视为未设置
-  }));
-  console.log('[FocusSwitcherConfigurator] Saving configuration. Config to save:', configToSave);
-  // 调用 Store 中正确的更新函数
-  focusSwitcherStore.updateConfiguration(configToSave);
-  console.log('[FocusSwitcherConfigurator] Configuration save process triggered via updateConfiguration.');
+  // 构造 FocusSwitcherFullConfig 对象
+  const newSequence = localSequence.value.map(item => item.id);
+  // 清理 shortcuts，移除没有快捷键的条目 (可选，取决于后端是否需要)
+  const newShortcuts: Record<string, FocusItemConfig> = {};
+  for (const id in localItemConfigs.value) {
+      if (localItemConfigs.value[id]?.shortcut) {
+          newShortcuts[id] = { shortcut: localItemConfigs.value[id].shortcut };
+      }
+      // 如果需要保存空快捷键的记录，则取消 if 条件
+      // newShortcuts[id] = { shortcut: localItemConfigs.value[id]?.shortcut };
+  }
+
+  const fullConfigToSave: FocusSwitcherFullConfig = {
+    sequence: newSequence,
+    shortcuts: newShortcuts,
+  };
+
+  console.log('[FocusSwitcherConfigurator] Saving full configuration:', JSON.stringify(fullConfigToSave));
+  focusSwitcherStore.updateConfiguration(fullConfigToSave); // 调用 Store 更新函数
+  console.log('[FocusSwitcherConfigurator] Configuration save process triggered.');
  hasChanges.value = false;
  emit('close'); // 保存后关闭
 };

 // --- Computed ---
-// 新的计算属性：基于本地已配置列表动态计算可用输入框
+// ++ 修改：计算属性，获取不在右侧序列中的项目 (用于左侧列表) ++
 const localAvailableInputs = computed(() => {
-  // 获取本地已配置项的 ID 集合
-  const configuredIds = new Set(localSequence.value.map(item => item.id));
-  // 从 store 的 availableInputs state 中过滤掉已在本地配置的项
-  // 注意：直接访问 store 的 state ref
-  return focusSwitcherStore.availableInputs.filter(input => !configuredIds.has(input.id));
+  const sequenceIds = new Set(localSequence.value.map(item => item.id));
+  // 从所有可用输入中过滤掉已在序列中的，并合并本地快捷键配置
+  return focusSwitcherStore.availableInputs
+    .filter(input => !sequenceIds.has(input.id))
+    .map(input => ({
+        ...input,
+        shortcut: localItemConfigs.value[input.id]?.shortcut // 从本地配置获取快捷键
+    }));
 });

 // 注意：已配置的列表直接使用 localSequence ref
@@ -149,15 +199,23 @@ const localAvailableInputs = computed(() => {
            :group="{ name: 'focus-inputs', pull: true, put: false }"
            :sort="false"
          >
-            <template #item="{ element }: { element: FocusableInput }">
+            <template #item="{ element }: { element: FocusableInput & FocusItemConfig }">
              <li class="draggable-item">
                <i class="fas fa-grip-vertical drag-handle"></i>
                <span class="item-label">{{ element.label }}</span>
+                <!-- ++ 在左侧列表添加快捷键输入框 ++ -->
+                <input
+                  type="text"
+                  v-model="localItemConfigs[element.id].shortcut"
+                  class="shortcut-input"
+                  :placeholder="t('focusSwitcher.shortcutPlaceholder')"
+                  @keydown.prevent="captureShortcut($event, localItemConfigs[element.id])"
+                /> <!-- Correctly close the input tag -->
              </li>
            </template>
             <template #footer>
-               <li v-if="localAvailableInputs.length === 0" class="no-items-placeholder"> <!-- 判断条件也更新 -->
-                 {{ t('focusSwitcher.allInputsConfigured', '所有输入框都已配置') }}
+               <li v-if="localAvailableInputs.length === 0" class="no-items-placeholder">
+                 <span>{{ t('focusSwitcher.allInputsConfigured', '所有输入框都已配置') }}</span>
               </li>
             </template>
          </draggable>
@@ -173,23 +231,11 @@ const localAvailableInputs = computed(() => {
             :group="{ name: 'focus-inputs', put: true }"
             handle=".drag-handle"
           >
-             <template #item="{ element, index }: { element: ConfiguredFocusableInput, index: number }">
-               <div> <!-- Wrap the content in a single div -->
-                 <li class="draggable-item">
-                   <i class="fas fa-grip-vertical drag-handle"></i>
-                   <span class="item-label">{{ element.label }}</span>
-                 <!-- +++ 添加快捷键输入框 +++ -->
-                 <input
-                   type="text"
-                   v-model="element.shortcut"
-                   class="shortcut-input"
-                   :placeholder="t('focusSwitcher.shortcutPlaceholder')"
-                   @keydown.prevent="captureShortcut($event, element)"
-                 />
-                 <!-- 添加移除按钮 -->
-                 <button @click="localSequence.splice(index, 1)" class="remove-button" :title="t('common.remove', '移除')">&times;</button>
-                 </li>
-               </div>
+             <template #item="{ element, index }: { element: SequenceDisplayItem, index: number }">
+               <li class="draggable-item">
+                 <i class="fas fa-grip-vertical drag-handle"></i>
+                 <span class="item-label">{{ element.label }}</span>
+               </li>
             </template>
              <template #footer>
                <li v-if="localSequence.length === 0" class="no-items-placeholder">
@@ -214,8 +260,8 @@ const localAvailableInputs = computed(() => {
 // +++ 在 <script setup> 之外定义辅助函数（如果需要更复杂的逻辑或重用）+++
 // 或者直接在 setup 内部定义 captureShortcut

-// 内部定义 captureShortcut
-const captureShortcut = (event: KeyboardEvent, element: ConfiguredFocusableInput) => { // +++ 使用导入的接口 +++
+// ++ 修改：captureShortcut 现在接收 FocusItemConfig 并更新它 ++
+const captureShortcut = (event: KeyboardEvent, itemConfig: FocusItemConfig) => {
  if (event.key === 'Alt' || event.key === 'Control' || event.key === 'Shift' || event.key === 'Meta') {
    // 忽略单独的修饰键按下
    return;
@@ -229,16 +275,16 @@ const captureShortcut = (event: KeyboardEvent, element: ConfiguredFocusableInput
    }
    // 可以添加更多验证，例如只允许字母、数字等
    if (/^[a-zA-Z0-9]$/.test(key)) { // 简化：只允许单个字母或数字
-        element.shortcut = `Alt+${key}`;
+        itemConfig.shortcut = `Alt+${key}`; // 直接修改传入的配置对象
    } else if (key === 'Backspace' || key === 'Delete') {
-        element.shortcut = ''; // 允许使用 Backspace 或 Delete 清空
+        itemConfig.shortcut = undefined; // 使用 undefined 清空
    } else {
        // 可选：提示不支持的键
        console.warn(`[FocusSwitcherConfigurator] Unsupported key for shortcut: ${key}`);
    }
  } else if (event.key === 'Backspace' || event.key === 'Delete') {
      // 允许单独按 Backspace 或 Delete 清空 (即使没有 Alt)
-      element.shortcut = '';
+      itemConfig.shortcut = undefined; // 使用 undefined 清空
  } else {
    // 可选：如果按下非 Alt 组合键，可以清空或提示
    // console.log('[FocusSwitcherConfigurator] Invalid shortcut combination.');
@@ -385,4 +431,4 @@ h3 {
  border: 1px solid var(--border-color);
 }
 .button-secondary:hover { background-color: var(--secondary-button-hover-bg-color, #dee2e6); }
-</style>
+</style>
@@ -2,33 +2,35 @@ import { defineStore } from 'pinia';
 import { ref, computed, nextTick } from 'vue';
 import { useI18n } from 'vue-i18n';
 // 假设有一个 API 客户端或辅助函数，这里我们直接使用 fetch
-// import apiClient from '@/services/api'; // 理想情况下
+// import apiClient from '@/services/api';

-// 定义输入框的接口
+// 基础输入框接口 (保持不变)
 export interface FocusableInput {
-  id: string; // 唯一标识符
-  label: string; // 用户友好的名称
-  // componentPath 和 selector 不再需要，聚焦完全依赖 focusAction
-  focusAction: () => boolean | Promise<boolean>;
-  // shortcut?: string; // --- 从基础接口移除快捷键，因为它只在配置中相关 ---
-}
-
-// +++ 新增：定义包含快捷键的完整配置项接口 (用于 Store 内部和配置器) +++
-export interface ConfiguredFocusableInput extends FocusableInput {
-  shortcut?: string; // 快捷键是可选的
-}
-
-// 定义存储在后端的配置项接口 (仅 ID 和 shortcut)
-export interface ConfigurableFocusableItem {
  id: string;
-  shortcut?: string; // 快捷键是可选的
+  label: string;
+  focusAction: () => boolean | Promise<boolean>;
 }

-// 定义 Store 的 State 接口 (可选但推荐)
+// --- 移除 ConfiguredFocusableInput ---
+
+// 单个项目配置接口 (主要用于快捷键)
+export interface FocusItemConfig {
+  shortcut?: string;
+}
+
+// 存储在后端或发送给后端的完整配置结构
+export interface FocusSwitcherFullConfig {
+  sequence: string[]; // 顺序切换的 ID 列表
+  shortcuts: Record<string, FocusItemConfig>; // 所有项目的快捷键配置 (id -> config)
+}
+
+// --- 移除 ConfigurableFocusableItem ---
+
+// Store State 接口
 interface FocusSwitcherState {
-  availableInputs: FocusableInput[]; // 保持不变，定义所有可用项及其基础信息
-  // configuredSequence: string[]; // --- 移除旧的状态 ---
-  configuredItems: ConfigurableFocusableItem[]; // +++ 新增：存储已配置项的 ID 和快捷键 +++
+  availableInputs: FocusableInput[]; // 所有可用项的基础信息
+  sequenceOrder: string[]; // 顺序切换的 ID 列表
+  itemConfigs: Record<string, FocusItemConfig>; // 所有项目的配置 (id -> config)
  isConfiguratorVisible: boolean;
  activateFileManagerSearchTrigger: number;
  activateTerminalSearchTrigger: number;
@@ -51,8 +53,8 @@ export const useFocusSwitcherStore = defineStore('focusSwitcher', () => {
    { id: 'connectionListSearch', label: t('focusSwitcher.input.connectionListSearch', '连接列表搜索'), focusAction: () => false },
    { id: 'fileEditorActive', label: t('focusSwitcher.input.fileEditorActive', '文件编辑器'), focusAction: () => false },
  ]);
-  // const configuredSequence = ref<string[]>([]); // --- 移除旧的状态 ref ---
-  const configuredItems = ref<ConfigurableFocusableItem[]>([]); // +++ 新增：存储配置项的状态 ref +++
+  const sequenceOrder = ref<string[]>([]); // +++ 新增：存储顺序 +++
+  const itemConfigs = ref<Record<string, FocusItemConfig>>({}); // +++ 新增：存储所有配置 +++
  const isConfiguratorVisible = ref(false);
  const activateFileManagerSearchTrigger = ref(0);
  const activateTerminalSearchTrigger = ref(0);
@@ -63,9 +65,9 @@ export const useFocusSwitcherStore = defineStore('focusSwitcher', () => {
  // --- Actions ---

  // +++ 修改：从后端加载配置（包括快捷键） +++
-  async function loadConfigurationFromBackend() { // 重命名以反映加载的是完整配置
-    const apiUrl = '/api/v1/settings/focus-switcher-sequence'; // 假设 API 端点不变
-    console.log(`[FocusSwitcherStore] Attempting to load configuration (sequence & shortcuts) from backend via: ${apiUrl}`);
+  async function loadConfigurationFromBackend() {
+    const apiUrl = '/api/v1/settings/focus-switcher-sequence'; // 假设 API 端点不变，但返回结构改变
+    console.log(`[FocusSwitcherStore] Attempting to load full configuration (sequence & shortcuts) from backend via: ${apiUrl}`);
    try {
      const response = await fetch(apiUrl);
      console.log(`[FocusSwitcherStore] Received response from ${apiUrl}. Status: ${response.status}`);
@@ -75,68 +77,70 @@ export const useFocusSwitcherStore = defineStore('focusSwitcher', () => {
        throw new Error(`HTTP error! status: ${response.status}`);
      }

-      // *** 假设后端返回 ConfigurableFocusableItem[] 结构 ***
-      const loadedConfig = await response.json();
-      console.log(`[FocusSwitcherStore] Raw JSON received from backend:`, JSON.stringify(loadedConfig));
+      // *** 假设后端返回 FocusSwitcherFullConfig 结构 ***
+      const loadedFullConfig: FocusSwitcherFullConfig = await response.json();
+      console.log(`[FocusSwitcherStore] Raw JSON received from backend:`, JSON.stringify(loadedFullConfig));

-      // --- 验证和过滤 ---
-      if (Array.isArray(loadedConfig) && loadedConfig.every(item => typeof item?.id === 'string')) {
-        console.log('[FocusSwitcherStore] Configuration format seems valid (array of objects with id). Filtering against available inputs...');
-        const availableIds = new Set(availableInputs.value.map(input => input.id));
-        const filteredConfig: ConfigurableFocusableItem[] = loadedConfig
-          .filter((item: any) => {
-            const isValid = availableIds.has(item.id);
-            if (!isValid) {
-              console.warn(`[FocusSwitcherStore] Filtered out invalid ID during load: ${item.id}`);
-            }
-            return isValid;
-          })
-          .map((item: any) => ({ // 确保只保留 id 和 shortcut
-            id: item.id,
-            shortcut: typeof item.shortcut === 'string' && item.shortcut.startsWith('Alt+') ? item.shortcut : undefined // 验证快捷键格式
-          }));
+      // --- 验证和设置 ---
+      const availableIds = new Set(availableInputs.value.map(input => input.id));

-        configuredItems.value = filteredConfig;
-        console.log('[FocusSwitcherStore] Successfully loaded and set configuredItems:', JSON.stringify(configuredItems.value));
+      // 验证 sequence
+      if (Array.isArray(loadedFullConfig?.sequence) && loadedFullConfig.sequence.every(id => typeof id === 'string' && availableIds.has(id))) {
+        sequenceOrder.value = loadedFullConfig.sequence;
+        console.log('[FocusSwitcherStore] Successfully loaded and set sequenceOrder:', JSON.stringify(sequenceOrder.value));
      } else {
-         // --- 处理旧格式 (仅 ID 数组) 或无效格式 ---
-         if (Array.isArray(loadedConfig) && loadedConfig.every(item => typeof item === 'string')) {
-            console.warn('[FocusSwitcherStore] Received old format (string array) from backend. Converting to new structure without shortcuts.');
-            const availableIds = new Set(availableInputs.value.map(input => input.id));
-            const filteredSequence = loadedConfig.filter((id: string) => availableIds.has(id));
-            configuredItems.value = filteredSequence.map(id => ({ id })); // 转换为新结构，无快捷键
-            console.log('[FocusSwitcherStore] Converted old format to configuredItems:', JSON.stringify(configuredItems.value));
-            // 可以考虑触发一次保存，将转换后的新格式存回后端
-            // saveSequenceToBackend();
-         } else {
-            console.error('[FocusSwitcherStore] Invalid configuration format received from backend:', loadedConfig);
-            configuredItems.value = []; // 使用空数组作为回退
-            console.log('[FocusSwitcherStore] Set configuredItems to empty array due to invalid format.');
-         }
+        console.warn('[FocusSwitcherStore] Invalid or missing sequence in loaded config. Resetting to empty array.');
+        sequenceOrder.value = [];
      }
+
+      // 验证 shortcuts (itemConfigs)
+      if (typeof loadedFullConfig?.shortcuts === 'object' && loadedFullConfig.shortcuts !== null) {
+        const validConfigs: Record<string, FocusItemConfig> = {};
+        for (const id in loadedFullConfig.shortcuts) {
+          if (availableIds.has(id)) { // 只保留有效的 ID
+            const config = loadedFullConfig.shortcuts[id];
+            if (typeof config === 'object' && config !== null && (config.shortcut === undefined || (typeof config.shortcut === 'string' && config.shortcut.startsWith('Alt+')))) {
+              validConfigs[id] = { shortcut: config.shortcut }; // 只保留 shortcut
+            } else {
+               console.warn(`[FocusSwitcherStore] Invalid shortcut config for ID ${id}. Ignoring shortcut.`);
+               validConfigs[id] = {}; // 保留 ID 但清空无效快捷键
+            }
+          } else {
+             console.warn(`[FocusSwitcherStore] Ignoring shortcut config for unknown ID: ${id}`);
+          }
+        }
+        itemConfigs.value = validConfigs;
+        console.log('[FocusSwitcherStore] Successfully loaded and set itemConfigs:', JSON.stringify(itemConfigs.value));
+      } else {
+        console.warn('[FocusSwitcherStore] Invalid or missing shortcuts in loaded config. Resetting to empty object.');
+        itemConfigs.value = {};
+      }
+
    } catch (error) {
      console.error(`[FocusSwitcherStore] Failed to load or parse configuration from backend (${apiUrl}):`, error);
-      configuredItems.value = [];
-      console.log('[FocusSwitcherStore] Set configuredItems to empty array due to loading error.');
+      sequenceOrder.value = [];
+      itemConfigs.value = {};
+      console.log('[FocusSwitcherStore] Reset sequenceOrder and itemConfigs due to loading error.');
    }
  }

-  // +++ 修改：保存配置到后端（包括快捷键） +++
-  async function saveConfigurationToBackend() { // 重命名以反映保存的是完整配置
-    const apiUrl = '/api/v1/settings/focus-switcher-sequence'; // 假设 API 端点不变
-    console.log(`[FocusSwitcherStore] Attempting to save configuration (sequence & shortcuts) to backend via PUT: ${apiUrl}`);
+  async function saveConfigurationToBackend() {
+    const apiUrl = '/api/v1/settings/focus-switcher-sequence'; // 假设 API 端点不变，但接受结构改变
+    console.log(`[FocusSwitcherStore] Attempting to save full configuration (sequence & shortcuts) to backend via PUT: ${apiUrl}`);
    try {
-      // *** 发送 configuredItems 结构到后端 (包含快捷键) ***
-      // !!! 注意：这需要后端 API 支持接收此结构 !!!
-      const configToSave = configuredItems.value;
-      console.log('[FocusSwitcherStore] Configuration data to save (including shortcuts):', JSON.stringify(configToSave));
+      // *** 构造 FocusSwitcherFullConfig 结构发送给后端 ***
+      const configToSave: FocusSwitcherFullConfig = {
+        sequence: sequenceOrder.value,
+        shortcuts: itemConfigs.value,
+      };
+      console.log('[FocusSwitcherStore] Full configuration data to save:', JSON.stringify(configToSave));
      const response = await fetch(apiUrl, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json',
          // Auth headers if needed
        },
-        body: JSON.stringify(configToSave), // *** 发送完整的配置对象数组 ***
+        body: JSON.stringify(configToSave), // *** 发送包含 sequence 和 shortcuts 的对象 ***
      });
      console.log(`[FocusSwitcherStore] Received response from PUT ${apiUrl}. Status: ${response.status}`);

@@ -184,23 +188,40 @@ export const useFocusSwitcherStore = defineStore('focusSwitcher', () => {
  }
  */

-  // +++ 修改：更新配置（包括顺序和快捷键） +++
-  function updateConfiguration(newConfig: ConfigurableFocusableItem[]) { // 重命名并修改参数类型
-    console.log('[FocusSwitcherStore] updateConfiguration called with new configuration:', JSON.stringify(newConfig));
+  // +++ 修改：更新完整配置（包括顺序和所有快捷键） +++
+  function updateConfiguration(newFullConfig: FocusSwitcherFullConfig) {
+    console.log('[FocusSwitcherStore] updateConfiguration called with new full configuration:', JSON.stringify(newFullConfig));
    const availableIds = new Set(availableInputs.value.map(input => input.id));

-    // 过滤掉无效的 ID，并验证/清理快捷键
-    const filteredConfig = newConfig
-        .filter(item => availableIds.has(item.id))
-        .map(item => ({
-            id: item.id,
-            shortcut: typeof item.shortcut === 'string' && item.shortcut.startsWith('Alt+') ? item.shortcut : undefined
-        }));
+    // 更新 sequenceOrder (过滤无效 ID)
+    if (Array.isArray(newFullConfig?.sequence)) {
+      sequenceOrder.value = newFullConfig.sequence.filter(id => availableIds.has(id));
+      console.log('[FocusSwitcherStore] sequenceOrder updated locally to:', JSON.stringify(sequenceOrder.value));
+    } else {
+       console.warn('[FocusSwitcherStore] Invalid sequence provided in updateConfiguration. Keeping existing sequence.');
+    }
+
+    // 更新 itemConfigs (过滤无效 ID 和快捷键)
+    if (typeof newFullConfig?.shortcuts === 'object' && newFullConfig.shortcuts !== null) {
+        const validConfigs: Record<string, FocusItemConfig> = {};
+        for (const id in newFullConfig.shortcuts) {
+          if (availableIds.has(id)) {
+            const config = newFullConfig.shortcuts[id];
+             if (typeof config === 'object' && config !== null && (config.shortcut === undefined || (typeof config.shortcut === 'string' && config.shortcut.startsWith('Alt+')))) {
+               validConfigs[id] = { shortcut: config.shortcut };
+             } else {
+                validConfigs[id] = {}; // 保留 ID 但清空无效快捷键
+             }
+          }
+        }
+        itemConfigs.value = validConfigs;
+       console.log('[FocusSwitcherStore] itemConfigs updated locally to:', JSON.stringify(itemConfigs.value));
+    } else {
+        console.warn('[FocusSwitcherStore] Invalid shortcuts provided in updateConfiguration. Keeping existing configs.');
+    }

-    configuredItems.value = filteredConfig;
-    console.log('[FocusSwitcherStore] configuredItems updated locally to:', JSON.stringify(configuredItems.value));
    // 更新后立即保存到后端
-    saveConfigurationToBackend(); // 调用重命名后的保存函数
+    saveConfigurationToBackend();
  }

  // 注册聚焦动作 (现在更新 availableInputs 中的 focusAction)
@@ -257,49 +278,75 @@ export const useFocusSwitcherStore = defineStore('focusSwitcher', () => {
  // --- 修改 Getters ---
  // +++ 修改：获取完整的已配置输入框信息（合并快捷键）+++
  // 返回类型现在包含 shortcut，所以需要调整或确认 FocusableInput 定义
-  const getConfiguredInputs = computed((): ConfiguredFocusableInput[] => { // +++ 更新返回类型 +++
+  // +++ 修改：获取在序列中的输入框信息（包含快捷键）+++
+  const getSequenceInputs = computed((): (FocusableInput & FocusItemConfig)[] => {
    const inputsMap = new Map(availableInputs.value.map(input => [input.id, input]));
-    return configuredItems.value
-      .map(item => {
-        const baseInput = inputsMap.get(item.id);
+    const configs = itemConfigs.value;
+    // Step 1: Map sequenceOrder to potential objects or undefined
+    const mappedInputs = sequenceOrder.value
+      .map(id => {
+        const baseInput = inputsMap.get(id);
        if (!baseInput) return undefined;
-        // 创建一个新对象，类型为 ConfiguredFocusableInput
-        const configuredInput: ConfiguredFocusableInput = { // +++ 使用新类型 +++
+        const config = configs[id] || {};
+        // ++ Explicitly create object with the intersection type ++
+        const combinedInput: FocusableInput & FocusItemConfig = {
            ...baseInput,
-            shortcut: item.shortcut,
+            shortcut: config.shortcut,
        };
-        return configuredInput;
-      })
-      .filter((input): input is ConfiguredFocusableInput => input !== undefined); // +++ 更新类型断言 +++
+        return combinedInput; // Return the correctly typed object
+      });
+
+    // Step 2: Filter out any undefined values using the type predicate
+    const filteredInputs = mappedInputs.filter(
+        (input): input is FocusableInput & FocusItemConfig => input !== undefined
+    );
+
+    return filteredInputs; // Return the correctly typed array
  });

  // +++ 修改：获取配置器中“可用”的输入框列表 +++
-  const getAvailableInputsForConfigurator = computed((): FocusableInput[] => {
-    const configuredIds = new Set(configuredItems.value.map(item => item.id));
-    // 返回尚未配置的基础输入框信息（不需要快捷键）
-    return availableInputs.value.filter(input => !configuredIds.has(input.id));
+  // +++ 修改：获取不在序列中的输入框信息（也包含快捷键，因为现在全局管理） +++
+  const getAvailableInputsForConfigurator = computed((): (FocusableInput & FocusItemConfig)[] => {
+    const sequenceIds = new Set(sequenceOrder.value);
+    const configs = itemConfigs.value;
+    return availableInputs.value
+      .filter(input => !sequenceIds.has(input.id)) // 过滤掉已在序列中的
+      .map(input => {
+          const config = configs[input.id] || {};
+          return {
+              ...input,
+              shortcut: config.shortcut, // 合并快捷键
+          };
+      });
  });

  // +++ 修改：获取序列中的下一个聚焦目标 ID +++
+  // +++ 修改：根据 sequenceOrder 获取下一个聚焦目标 ID +++
  function getNextFocusTargetId(currentFocusedId: string | null): string | null {
-    if (configuredItems.value.length === 0) {
+    const order = sequenceOrder.value;
+    if (order.length === 0) {
      return null;
    }
    if (currentFocusedId === null) {
-      return configuredItems.value[0].id; // 返回第一个配置项的 ID
+      return order[0]; // 返回序列中的第一个 ID
    }
-    const currentIndex = configuredItems.value.findIndex(item => item.id === currentFocusedId);
+    const currentIndex = order.findIndex(id => id === currentFocusedId);
    if (currentIndex === -1) {
-      return configuredItems.value[0].id; // 如果当前 ID 不在配置中，返回第一个
+      return order[0]; // 如果当前 ID 不在序列中，返回第一个
    }
-    const nextIndex = (currentIndex + 1) % configuredItems.value.length;
-    return configuredItems.value[nextIndex].id; // 返回下一个配置项的 ID
+    const nextIndex = (currentIndex + 1) % order.length;
+    return order[nextIndex]; // 返回序列中的下一个 ID
  }

  // +++ 新增：根据快捷键获取目标 ID +++
+  // +++ 修改：根据 itemConfigs 获取快捷键对应的目标 ID +++
  function getFocusTargetIdByShortcut(shortcut: string): string | null {
-      const foundItem = configuredItems.value.find(item => item.shortcut === shortcut);
-      return foundItem?.id ?? null;
+      for (const id in itemConfigs.value) {
+          if (itemConfigs.value[id]?.shortcut === shortcut) {
+              return id;
+          }
+      }
+      return null;
  }


@@ -314,8 +361,8 @@ export const useFocusSwitcherStore = defineStore('focusSwitcher', () => {
  return {
    // State
    availableInputs,
-    // configuredSequence, // --- 移除 ---
-    configuredItems, // +++ 暴露新状态 +++
+    sequenceOrder, // +++ 暴露新状态 +++
+    itemConfigs,   // +++ 暴露新状态 +++
    isConfiguratorVisible,
    activateFileManagerSearchTrigger,
    activateTerminalSearchTrigger,
@@ -323,14 +370,14 @@ export const useFocusSwitcherStore = defineStore('focusSwitcher', () => {
    toggleConfigurator,
    triggerFileManagerSearchActivation,
    triggerTerminalSearchActivation,
-    loadConfigurationFromBackend, // +++ 使用新名称 +++
-    saveConfigurationToBackend, // +++ 使用新名称 +++
-    updateConfiguration, // +++ 使用新名称 +++
+    loadConfigurationFromBackend,
+    saveConfigurationToBackend,
+    updateConfiguration, // 已修改为接收完整配置
    // Getters / Methods
-    getConfiguredInputs, // 已修改
+    getSequenceInputs, // +++ 重命名并修改 +++
    getAvailableInputsForConfigurator, // 已修改
    getNextFocusTargetId, // 已修改
-    getFocusTargetIdByShortcut, // +++ 新增 +++
+    getFocusTargetIdByShortcut, // 已修改
    registerFocusAction,
    unregisterFocusAction,
    focusTarget,