dazscript-framework 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dazscript-framework",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "author": "Freddy Diaz",
   "license": "MPL-2.0",
   "description": "",

package/src/helpers/action-helper.ts

@@ -1,58 +1,11 @@
 import { debug, warn } from '@dsf/common/log'
 import { mainWindow } from '@dsf/core/global'
 import { isGUID } from './string-helper'
+export { normalizeShortcut } from './shortcut-helper'
+import { normalizeShortcut } from './shortcut-helper'
 
 const actionMgr = mainWindow.getActionMgr()
 
-const shortcutTokenMap: { [key: string]: string } = {
-    'CTRL': 'Ctrl',
-    'CONTROL': 'Ctrl',
-    'SHIFT': 'Shift',
-    'ALT': 'Alt',
-    'OPTION': 'Alt',
-    'WIN': 'Win',
-    'WINDOWS': 'Win',
-    'CMD': 'Win',
-    'COMMAND': 'Win',
-    'SPACE': 'Space',
-    'HOME': 'Home',
-    'END': 'End',
-    'INS': 'Ins',
-    'INSERT': 'Ins',
-    'DEL': 'Del',
-    'DELETE': 'Del',
-    'TAB': 'Tab',
-    'BACKSPACE': 'Backspace',
-    'COMMA': 'Comma',
-    'PERIOD': 'Period',
-    'PLUS': 'Plus',
-    'MINUS': 'Minus',
-    'PGUP': 'PgUp',
-    'PAGEUP': 'PgUp',
-    'PGDOWN': 'PgDn',
-    'PGDN': 'PgDn',
-    'LEFT': 'Left',
-    'RIGHT': 'Right',
-    'UP': 'Up',
-    'DOWN': 'Down',
-}
-
-export const normalizeShortcut = (shortcut: string): string => {
-    if (!shortcut) return ''
-
-    return shortcut
-        .split('+')
-        .map(part => part.trim())
-        .filter(Boolean)
-        .map(part => {
-            if (part.length === 1) return part.toUpperCase()
-
-            const key = part.toUpperCase()
-            return shortcutTokenMap[key] || part
-        })
-        .join('+')
-}
-
 export const getActionShortcut = (name: string): string => {
     const action = findAction(name)
     if (!action) return ''
@@ -184,7 +137,7 @@ export const findActionsForShortcut = (shortcut: string): DzAction[] => {
     return result
 }
 
-export const clearActionShorcut = (name: string) => {
+export const clearActionShortcut = (name: string) => {
     let action = findAction(name)
     if (!action) return
     if (isCustomAction(action)) {
@@ -195,6 +148,8 @@ export const clearActionShorcut = (name: string) => {
     }
 }
 
+export const clearActionShorcut = clearActionShortcut
+
 export const getActionPixmap = (action: string, icon: string, maxSize?: number): Pixmap | null => {
     try {
         if (!action) return null;

package/src/helpers/custom-action-helper.ts

@@ -280,6 +280,12 @@ const removeUnderlyingCustomAction = (actionName: string | null | undefined) =>
     const index = actionMgr.findCustomAction(actionName)
     if (index < 0) return
 
+    const shortcut = String(actionMgr.getCustomActionShortcut(index) ?? '').trim()
+    if (shortcut) {
+        actionMgr.setCustomActionShortcut(index, '')
+        debug(`Action ${actionName} shortcut cleared before removal`)
+    }
+
     actionMgr.removeCustomAction(index)
     debug(`Action ${actionName} removed`)
 }

package/src/helpers/custom-action-installer-entries.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest'
+import { getCanonicalInstallerEntry, toActionKey } from './custom-action-installer-entries'
+
+const entries = [
+    { action: { text: 'Power Menu - Main Actions', filePath: './Power Menu Actions.dsa' }, effectiveShortcut: '' },
+    { action: { text: 'Power Menu', filePath: './Power Menu.dsa' }, effectiveShortcut: '' },
+]
+
+describe('setup installer entries', () => {
+    it('builds an empty key for missing action data instead of throwing', () => {
+        expect(toActionKey(undefined)).toBe('')
+    })
+
+    it('resolves row data back to the canonical installer entry', () => {
+        const rowCopy = {
+            action: { text: 'Power Menu', filePath: './Power Menu.dsa' },
+            effectiveShortcut: 'F12'
+        }
+
+        const canonical = getCanonicalInstallerEntry(entries, rowCopy)
+
+        expect(canonical).toBe(entries[1])
+    })
+
+    it('falls back to the displayed action text when row data is not an installer entry', () => {
+        const canonical = getCanonicalInstallerEntry(entries, { value: null }, 'Power Menu')
+
+        expect(canonical).toBe(entries[1])
+    })
+
+    it('ignores row data with an invalid action property before falling back to displayed text', () => {
+        const canonical = getCanonicalInstallerEntry(entries, { action: true }, 'Power Menu')
+
+        expect(canonical).toBe(entries[1])
+    })
+
+    it('prefers displayed row text over attached row data', () => {
+        const staleRowData = {
+            action: { text: 'Power Menu - Main Actions', filePath: './Power Menu Actions.dsa' },
+            effectiveShortcut: ''
+        }
+
+        const canonical = getCanonicalInstallerEntry(entries, staleRowData, 'Power Menu')
+
+        expect(canonical).toBe(entries[1])
+    })
+
+    it('returns null when neither row data nor displayed text identify an installer entry', () => {
+        const canonical = getCanonicalInstallerEntry(entries, { action: true }, 'Missing')
+
+        expect(canonical).toBeNull()
+    })
+})

package/src/helpers/custom-action-installer-entries.ts

@@ -0,0 +1,58 @@
+import type { CustomAction } from '@dsf/core/custom-action'
+
+export type InstallerActionEntry = {
+    action: CustomAction
+}
+
+const isActionLike = (value: any): value is CustomAction =>
+    Boolean(value && (typeof value.filePath !== 'undefined' || typeof value.text !== 'undefined'))
+
+export const toActionKey = (action?: CustomAction | null): string =>
+    String(action?.filePath ?? action?.text ?? '')
+
+const findByDisplayedText = <TEntry extends InstallerActionEntry>(
+    entries: TEntry[],
+    displayedText: string
+): TEntry | null => {
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i]
+        if (String(entry.action.text ?? '') === displayedText) return entry
+    }
+
+    return null
+}
+
+const findByActionKey = <TEntry extends InstallerActionEntry>(
+    entries: TEntry[],
+    key: string
+): TEntry | null => {
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i]
+        if (toActionKey(entry.action) === key) return entry
+    }
+
+    return null
+}
+
+export const asInstallerActionEntry = <TEntry extends InstallerActionEntry>(value: any): TEntry | null => {
+    if (isActionLike(value?.action)) return value as TEntry
+    if (isActionLike(value?.value?.action)) return value.value as TEntry
+    return null
+}
+
+export const getCanonicalInstallerEntry = <TEntry extends InstallerActionEntry>(
+    entries: TEntry[],
+    value: any,
+    displayedActionText?: string
+): TEntry | null => {
+    const displayedText = String(displayedActionText ?? '')
+    const displayedMatch = findByDisplayedText(entries, displayedText)
+    if (displayedMatch) return displayedMatch
+
+    const candidate = asInstallerActionEntry<TEntry>(value)
+
+    if (!candidate || !isActionLike(candidate.action)) return null
+
+    const key = toActionKey(candidate.action)
+    return findByActionKey(entries, key) ?? candidate
+}

package/src/helpers/custom-action-installer-helper.ts

@@ -11,6 +11,8 @@ import CustomSet from '@dsf/lib/set'
 import { TreeNode } from '@dsf/lib/tree-node'
 import { promptKeyboardShortcut } from '@dsf/shared/set-keyboard-shortcut'
 import { readFromFile, saveToFile } from './file-helper'
+import { getCanonicalInstallerEntry, toActionKey } from './custom-action-installer-entries'
+import { canResetSetupShortcut, getDisplayedSetupShortcut, resetSetupShortcut, setSetupShortcut, updateShortcutOverrideState } from './custom-action-installer-shortcuts'
 
 type InstallerEntry = {
     action: CustomAction
@@ -70,9 +72,7 @@ type SetupSelection = {
     shortcuts: ShortcutEntry[]
 }
 
-const OVERRIDE_MARKER = '[ovr]'
-
-const toKey = (action: CustomAction): string => String(action.filePath ?? action.text ?? '')
+const toKey = toActionKey
 
 const toTreeNode = (entry: InstallerEntry): TreeNode<InstallerEntry> =>
     new TreeNode(String(entry.action.text), toKey(entry.action), entry)
@@ -96,18 +96,6 @@ const getSetupDialogOptions = (options: string | SetupDialogOptions): SetupDialo
 const getShortcutBackupPath = (options: SetupDialogOptions): string =>
     `${App.getAppDataPath()}/${options.shortcutBackupPath ?? `${options.settingsPath}/keyboard-shortcuts-backup.json`}`
 
-const getDisplayedShortcut = (entry: InstallerEntry): string => {
-    if (!entry.isShortcutOverridden) return entry.effectiveShortcut
-    return entry.effectiveShortcut
-        ? `${entry.effectiveShortcut} ${OVERRIDE_MARKER}`
-        : OVERRIDE_MARKER
-}
-
-const updateOverrideState = (entry: InstallerEntry) => {
-    entry.isShortcutOverridden = Boolean(entry.installedActionName) &&
-        normalizeShortcut(entry.installedShortcut) !== normalizeShortcut(entry.defaultShortcut)
-}
-
 const buildEntries = (actions: CustomAction[]): InstallerEntry[] => {
     return actions
         .filter((action) => Boolean(action.menuPath) || Boolean(action.toolbar))
@@ -132,7 +120,7 @@ const buildEntries = (actions: CustomAction[]): InstallerEntry[] => {
                 installedActionName: String(installed.customAction?.name ?? '')
             }
 
-            updateOverrideState(entry)
+            updateShortcutOverrideState(entry)
             return entry
         })
 }
@@ -235,8 +223,7 @@ class InstallerSelectionDialog extends BasicDialog {
                 .focus()
                 .placeholder('Search actions...')
                 .toolTip('Search by action name, description, path, shortcut, or available targets.')
-            add.button('Select All').clicked(() => this.setVisibleSelections(true))
-            add.button('Deselect All').clicked(() => this.setVisibleSelections(false))
+            add.button('Clear').clicked(() => this.keywords$.value = '')
         })
 
         add.group('Scripts')
@@ -269,7 +256,7 @@ class InstallerSelectionDialog extends BasicDialog {
                         return [
                             '',
                             String(entry.action.text ?? ''),
-                            getDisplayedShortcut(entry),
+                            getDisplayedSetupShortcut(entry),
                             String(entry.action.description ?? ''),
                             String(entry.action.menuPath ?? ''),
                             getDisplayedToolbar(entry),
@@ -291,6 +278,11 @@ class InstallerSelectionDialog extends BasicDialog {
                         listView.allColumnsShowFocus = true
                     })
             })
+        add.group().horizontal().build((layout) => {
+            layout.addStretch()
+            add.button('Select All').clicked(() => this.setVisibleSelections(true))
+            add.button('Deselect All').clicked(() => this.setVisibleSelections(false))
+        })
     }
 
     private buildShortcutsTab(): void {
@@ -304,8 +296,7 @@ class InstallerSelectionDialog extends BasicDialog {
                 .value(this.shortcutKeywords$)
                 .placeholder('Search shortcuts...')
                 .toolTip('Search by action name, current shortcut, new shortcut, status, or conflicts.')
-            add.button('Select All').clicked(() => this.setVisibleShortcutSelections(true))
-            add.button('Deselect All').clicked(() => this.setVisibleShortcutSelections(false))
+            add.button('Clear').clicked(() => this.shortcutKeywords$.value = '')
         })
 
         add.group('Keyboard Shortcuts')
@@ -358,12 +349,20 @@ class InstallerSelectionDialog extends BasicDialog {
                         listView.allColumnsShowFocus = true
                     })
             })
+        add.group().horizontal().build((layout) => {
+            layout.addStretch()
+            add.button('Select All').clicked(() => this.setVisibleShortcutSelections(true))
+            add.button('Deselect All').clicked(() => this.setVisibleShortcutSelections(false))
+        })
     }
 
     private buildContextMenu(listView: DzListView, listItem: DzListViewItem | null): DzPopupMenu {
-        const entry = listItem ? getDataItem<InstallerEntry>(listItem) : null
+        debug(`[Setup] context menu row input ${this.describeListItem('item', listItem)} ${this.describeListItem('selected', listView.selectedItem())} ${this.describeListItem('current', listView.currentItem())}`)
+        const contextItem = this.getContextListItem(listView, listItem)
+        const entry = contextItem ? this.getCanonicalEntry(getDataItem<InstallerEntry>(contextItem), contextItem) : null
+        debug(`[Setup] context menu row resolved item="${this.safeListItemText(contextItem, 1)}" entry="${entry?.action?.text ?? ''}"`)
         const canSetShortcut = Boolean(entry)
-        const canResetShortcut = Boolean(entry?.installedActionName && entry?.isShortcutOverridden)
+        const canResetShortcut = Boolean(entry && canResetSetupShortcut(entry))
 
         const items = [
             {
@@ -391,31 +390,77 @@ class InstallerSelectionDialog extends BasicDialog {
         })
     }
 
+    private getContextListItem(listView: DzListView, listItem: any): DzListViewItem | null {
+        if (this.isListViewItem(listItem)) return listItem
+
+        const selectedItem = listView.selectedItem()
+        if (this.isListViewItem(selectedItem)) return selectedItem
+
+        const currentItem = listView.currentItem()
+        if (this.isListViewItem(currentItem)) return currentItem
+
+        return null
+    }
+
+    private isListViewItem(value: any): value is DzListViewItem {
+        return Boolean(value && typeof value.text === 'function')
+    }
+
+    private describeListItem(label: string, value: any): string {
+        if (!value) return `${label}=null`
+
+        const hasTextFunction = typeof value.text === 'function'
+        const text0 = this.safeListItemText(value, 0)
+        const text1 = this.safeListItemText(value, 1)
+        const text2 = this.safeListItemText(value, 2)
+        const hasDataFunction = typeof value.getDataItem === 'function'
+        let dataText = ''
+
+        if (hasDataFunction) {
+            const data = getDataItem<any>(value)
+            dataText = String(data?.action?.text ?? data?.value?.action?.text ?? '')
+        }
+
+        return `${label} type=${typeof value} textFn=${hasTextFunction} text0="${text0}" text1="${text1}" text2="${text2}" dataFn=${hasDataFunction} data="${dataText}"`
+    }
+
+    private safeListItemText(value: any, column: number): string {
+        try {
+            if (!value || typeof value.text !== 'function') return ''
+            return String(value.text(column) ?? '')
+        } catch (error) {
+            return `[error:${String(error)}]`
+        }
+    }
+
+    private getCanonicalEntry(entry: InstallerEntry | null, listItem?: DzListViewItem | null): InstallerEntry | null {
+        return getCanonicalInstallerEntry(this.entries, entry, listItem?.text(1))
+    }
+
     private setShortcut(entry: InstallerEntry) {
+        if (!entry?.action) {
+            debug('[Setup] shortcut set ignored because the selected row did not resolve to an installer entry')
+            return
+        }
+
         const actionName = entry.installedActionName || toKey(entry.action)
         const actionLabel = String(entry.action.text ?? entry.action.filePath ?? actionName)
         const shortcut = promptKeyboardShortcut(actionLabel, actionName, entry.effectiveShortcut)
         if (shortcut == null) return
 
-        if (entry.installedActionName) {
-            setActionShortcut(entry.installedActionName, shortcut)
-            entry.installedShortcut = normalizeShortcut(shortcut)
-            entry.effectiveShortcut = entry.installedShortcut
-            updateOverrideState(entry)
-        } else {
-            entry.effectiveShortcut = normalizeShortcut(shortcut)
-        }
+        const previousShortcut = entry.effectiveShortcut
+        setSetupShortcut(entry, shortcut)
+        debug(`[Setup] shortcut queued action="${entry.action.text}" installed=${Boolean(entry.installedActionName)} previous="${previousShortcut}" next="${entry.effectiveShortcut}" custom=${entry.isShortcutOverridden}`)
 
         this.refreshListEvent$.trigger()
     }
 
     private resetDefaultShortcut(entry: InstallerEntry) {
-        if (!entry.installedActionName || !entry.isShortcutOverridden) return
+        if (!canResetSetupShortcut(entry)) return
 
-        setActionShortcut(entry.installedActionName, entry.defaultShortcut)
-        entry.installedShortcut = normalizeShortcut(entry.defaultShortcut)
-        entry.effectiveShortcut = entry.installedShortcut
-        updateOverrideState(entry)
+        const previousShortcut = entry.effectiveShortcut
+        resetSetupShortcut(entry)
+        debug(`[Setup] shortcut reset queued action="${entry.action.text}" previous="${previousShortcut}" default="${entry.defaultShortcut}"`)
         this.refreshListEvent$.trigger()
     }
 
@@ -565,7 +610,7 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
     const selectedToolbarActions: CustomAction[] = []
 
     progress('Setting Up Scripts', selections.actions, (selection) => {
-        debug(`[Setup] ${selection.selected ? 'install' : 'remove'} "${selection.action.text}"`)
+        debug(`[Setup] ${selection.selected ? 'install' : 'remove'} "${selection.action.text}" shortcut="${selection.effectiveShortcut}" custom=${selection.isShortcutOverridden}`)
 
         if (selection.supportsToolbar && selection.action.toolbar) {
             touchedToolbarNames.add(selection.action.toolbar)
@@ -574,7 +619,7 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
         if (selection.selected) {
             const customAction = applyCustomActionTargets({
                 ...selection.action,
-                shortcut: selection.effectiveShortcut
+                shortcut: ''
             }, {
                 menu: selection.supportsMenu,
                 toolbar: selection.supportsToolbar
@@ -582,6 +627,12 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
                 deferToolbar: true
             })
 
+            if (customAction) {
+                setActionShortcut(String(customAction.name), selection.effectiveShortcut)
+                const appliedShortcut = getActionShortcut(String(customAction.name))
+                debug(`[Setup] applied shortcut "${appliedShortcut}" to "${selection.action.text}" after install`)
+            }
+
             if (customAction && selection.supportsToolbar && selection.action.toolbar) {
                 selectedToolbarActions.push(customAction)
             }

package/src/helpers/custom-action-installer-shortcuts.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest'
+import {
+    canResetSetupShortcut,
+    getDisplayedSetupShortcut,
+    resetSetupShortcut,
+    setSetupShortcut,
+    updateShortcutOverrideState
+} from './custom-action-installer-shortcuts'
+
+const shortcutState = (overrides: Partial<ReturnType<typeof baseState>> = {}) => ({
+    ...baseState(),
+    ...overrides
+})
+
+const baseState = () => ({
+    installedActionName: '',
+    installedShortcut: '',
+    defaultShortcut: '',
+    effectiveShortcut: '',
+    isShortcutOverridden: false
+})
+
+describe('setup shortcut state', () => {
+    it('stores pending shortcuts for actions that are not installed yet', () => {
+        const entry = shortcutState()
+
+        setSetupShortcut(entry, 'F12')
+
+        expect(entry.effectiveShortcut).toBe('F12')
+        expect(entry.installedShortcut).toBe('')
+        expect(entry.isShortcutOverridden).toBe(false)
+        expect(canResetSetupShortcut(entry)).toBe(true)
+    })
+
+    it('marks installed shortcuts that differ from the default as custom', () => {
+        const entry = shortcutState({
+            installedActionName: 'installed-guid',
+            defaultShortcut: '',
+            installedShortcut: ''
+        })
+
+        setSetupShortcut(entry, 'F12')
+
+        expect(entry.installedShortcut).toBe('F12')
+        expect(entry.effectiveShortcut).toBe('F12')
+        expect(entry.isShortcutOverridden).toBe(true)
+        expect(getDisplayedSetupShortcut(entry)).toBe('F12 [custom]')
+        expect(canResetSetupShortcut(entry)).toBe(true)
+    })
+
+    it('resets installed custom shortcuts to the default', () => {
+        const entry = shortcutState({
+            installedActionName: 'installed-guid',
+            defaultShortcut: 'Ctrl+P',
+            installedShortcut: 'F12',
+            effectiveShortcut: 'F12',
+            isShortcutOverridden: true
+        })
+
+        resetSetupShortcut(entry)
+
+        expect(entry.installedShortcut).toBe('Ctrl+P')
+        expect(entry.effectiveShortcut).toBe('Ctrl+P')
+        expect(entry.isShortcutOverridden).toBe(false)
+        expect(canResetSetupShortcut(entry)).toBe(false)
+    })
+
+    it('resets pending shortcuts without inventing an installed shortcut', () => {
+        const entry = shortcutState({
+            defaultShortcut: '',
+            installedShortcut: '',
+            effectiveShortcut: 'F12'
+        })
+
+        resetSetupShortcut(entry)
+
+        expect(entry.installedShortcut).toBe('')
+        expect(entry.effectiveShortcut).toBe('')
+        expect(entry.isShortcutOverridden).toBe(false)
+        expect(canResetSetupShortcut(entry)).toBe(false)
+    })
+
+    it('displays custom marker when installed shortcut was changed outside setup', () => {
+        const entry = shortcutState({
+            installedActionName: 'installed-guid',
+            defaultShortcut: '',
+            installedShortcut: 'F12',
+            effectiveShortcut: 'F12'
+        })
+
+        updateShortcutOverrideState(entry)
+
+        expect(getDisplayedSetupShortcut(entry)).toBe('F12 [custom]')
+    })
+})

package/src/helpers/custom-action-installer-shortcuts.ts

@@ -0,0 +1,49 @@
+import { normalizeShortcut } from '@dsf/helpers/shortcut-helper'
+
+export const CUSTOM_SHORTCUT_MARKER = '[custom]'
+
+export type InstallerShortcutState = {
+    installedActionName: string
+    installedShortcut: string
+    defaultShortcut: string
+    effectiveShortcut: string
+    isShortcutOverridden: boolean
+}
+
+export const updateShortcutOverrideState = (entry: InstallerShortcutState): void => {
+    entry.isShortcutOverridden = Boolean(entry.installedActionName) &&
+        normalizeShortcut(entry.installedShortcut) !== normalizeShortcut(entry.defaultShortcut)
+}
+
+export const getDisplayedSetupShortcut = (entry: InstallerShortcutState): string => {
+    if (!entry.isShortcutOverridden) return entry.effectiveShortcut
+
+    return entry.effectiveShortcut
+        ? `${entry.effectiveShortcut} ${CUSTOM_SHORTCUT_MARKER}`
+        : CUSTOM_SHORTCUT_MARKER
+}
+
+export const canResetSetupShortcut = (entry: InstallerShortcutState): boolean =>
+    normalizeShortcut(entry.effectiveShortcut) !== normalizeShortcut(entry.defaultShortcut)
+
+export const setSetupShortcut = (entry: InstallerShortcutState, shortcut: string): void => {
+    const normalizedShortcut = normalizeShortcut(shortcut)
+
+    if (entry.installedActionName) {
+        entry.installedShortcut = normalizedShortcut
+    }
+
+    entry.effectiveShortcut = normalizedShortcut
+    updateShortcutOverrideState(entry)
+}
+
+export const resetSetupShortcut = (entry: InstallerShortcutState): void => {
+    const defaultShortcut = normalizeShortcut(entry.defaultShortcut)
+
+    if (entry.installedActionName) {
+        entry.installedShortcut = defaultShortcut
+    }
+
+    entry.effectiveShortcut = defaultShortcut
+    updateShortcutOverrideState(entry)
+}

package/src/helpers/shortcut-helper.ts

@@ -0,0 +1,48 @@
+const shortcutTokenMap: { [key: string]: string } = {
+    'CTRL': 'Ctrl',
+    'CONTROL': 'Ctrl',
+    'SHIFT': 'Shift',
+    'ALT': 'Alt',
+    'OPTION': 'Alt',
+    'WIN': 'Win',
+    'WINDOWS': 'Win',
+    'CMD': 'Win',
+    'COMMAND': 'Win',
+    'SPACE': 'Space',
+    'HOME': 'Home',
+    'END': 'End',
+    'INS': 'Ins',
+    'INSERT': 'Ins',
+    'DEL': 'Del',
+    'DELETE': 'Del',
+    'TAB': 'Tab',
+    'BACKSPACE': 'Backspace',
+    'COMMA': 'Comma',
+    'PERIOD': 'Period',
+    'PLUS': 'Plus',
+    'MINUS': 'Minus',
+    'PGUP': 'PgUp',
+    'PAGEUP': 'PgUp',
+    'PGDOWN': 'PgDn',
+    'PGDN': 'PgDn',
+    'LEFT': 'Left',
+    'RIGHT': 'Right',
+    'UP': 'Up',
+    'DOWN': 'Down',
+}
+
+export const normalizeShortcut = (shortcut: string): string => {
+    if (!shortcut) return ''
+
+    return shortcut
+        .split('+')
+        .map(part => part.trim())
+        .filter(Boolean)
+        .map(part => {
+            if (part.length === 1) return part.toUpperCase()
+
+            const key = part.toUpperCase()
+            return shortcutTokenMap[key] || part
+        })
+        .join('+')
+}

package/src/shared/set-keyboard-shortcut-conflicts.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+import { clearShortcutConflicts } from './set-keyboard-shortcut-conflicts'
+
+describe('clearShortcutConflicts', () => {
+    it('clears conflicting actions without clearing the target action', () => {
+        const cleared: string[] = []
+
+        clearShortcutConflicts('target-action', [
+            { name: 'target-action', text: 'Target' } as DzAction,
+            { name: 'old-owner', text: 'Old Owner' } as DzAction,
+            { name: 'other-owner', text: 'Other Owner' } as DzAction
+        ], (name) => {
+            cleared.push(name)
+        })
+
+        expect(cleared).toEqual(['old-owner', 'other-owner'])
+    })
+})

package/src/shared/set-keyboard-shortcut-conflicts.ts

@@ -0,0 +1,14 @@
+export type ShortcutConflict = {
+    name: string
+}
+
+export const clearShortcutConflicts = (
+    actionName: string,
+    conflicts: ShortcutConflict[],
+    clearShortcut: (name: string) => void
+): void => {
+    conflicts.forEach((action) => {
+        if (!action || action.name === actionName) return
+        clearShortcut(action.name)
+    })
+}

package/src/shared/set-keyboard-shortcut.ts

@@ -1,9 +1,10 @@
 import { BasicDialog } from '@dsf/dialog/basic-dialog';
 import { debug } from '@dsf/common/log';
-import { findAction, findActionsForShortcut, getActionShortcut, normalizeShortcut, setActionShortcut } from '@dsf/helpers/action-helper';
+import { clearActionShortcut, findActionsForShortcut, getActionShortcut, normalizeShortcut, setActionShortcut } from '@dsf/helpers/action-helper';
 import { contains } from '@dsf/helpers/array-helper';
 import { confirm } from '@dsf/helpers/message-box-helper';
 import { Observable } from '@dsf/lib/observable';
+import { clearShortcutConflicts } from './set-keyboard-shortcut-conflicts';
 
 class KeyboardShortcutModel {
     actionLabel: string
@@ -157,6 +158,7 @@ export const promptKeyboardShortcut = (actionLabel: string, actionName: string,
         const conflictText = conflicts.map(action => action.text || action.name).join(', ')
         const response = confirm(`"${model.shortcut.value}" is already assigned to: ${conflictText}\n\nReplace it?`)
         if (!response.ok) return null
+        clearShortcutConflicts(actionName, conflicts, clearActionShortcut)
     }
 
     return model.shortcut.value