dazscript-framework 1.0.1 → 1.0.3

package/README.md

@@ -241,6 +241,7 @@ This scans all `.dsa.ts` entry files, reads each top-level `action(...)` call, a
 The generated setup dialog:
 
 - Shows an install checkbox per action with columns for Action, Shortcut, Description, Menu, and Toolbar
+- Adds a `Keyboard Shortcuts` tab when a project defines shortcut JSON
 - Includes a search box that filters across all columns
 - Supports Select All / Deselect All on the visible rows
 - Lets the user right-click to set or reset a shortcut (overrides shown with `[ovr]`)
@@ -251,9 +252,44 @@ Applying the dialog:
 - Checked rows are installed or updated
 - Unchecked rows are removed from their menu and toolbar targets
 - Affected toolbars are rebuilt; empty framework-created toolbars are removed
+- Selected keyboard shortcut rows are applied after actions are installed
 
 This replaces the older `Install.dsa.ts` / `Uninstall.dsa.ts` pattern. The installer generator removes those legacy files if they exist.
 
+### Setup Keyboard Shortcuts
+
+Projects can define keyboard shortcuts for both framework custom actions and built-in Daz Studio actions. The installer generator looks for shortcut JSON in this order:
+
+- `keyboardShortcutsPath`, `shortcutsPath`, or `actionAcceleratorsPath` in `dazscript.config.ts`
+- `src/keyboard-shortcuts.json`
+- `src/action-accelerators.json`
+- `keyboard-shortcuts.json`
+- `action-accelerators.json`
+
+The JSON can be an array or an object containing `actions`, `shortcuts`, or `accelerators`. Each entry can use the Action Accelerator Finder style fields:
+
+```json
+[
+  {
+    "name": "DzRenderAction",
+    "text": "Render",
+    "shortcut": "CTRL+R"
+  }
+]
+```
+
+Accepted shortcut fields are `shortcut`, `accelerator`, or `key`. Accepted action-name fields are `name` or `action`.
+
+At build time the JSON is embedded into generated `Setup.dsa.ts`; Daz Studio does not need to read the original JSON file at setup time. During setup, the `Keyboard Shortcuts` tab shows the action label, current shortcut, new shortcut, action type, and conflicts. The user chooses which shortcut rows to apply.
+
+Before changing a non-custom Daz Studio action shortcut, setup writes the original value to:
+
+```text
+App.getAppDataPath()/<appDataPath>/Installer/keyboard-shortcuts-backup.json
+```
+
+Shortcut setup is part of the generated setup dialog. The generator does not create a separate shortcut-only uninstall script.
+
 ---
 
 ### Action-Level Bundles

package/dist/scripts/install-generator.js

@@ -21,14 +21,11 @@ function stringOrDefault(str, defaultValue) {
   return str !== undefined && str !== null && str !== '' ? str : defaultValue;
 }
 
-function generateInstallerTemplate(data, settingsPath, bundleName) {
+function generateInstallerTemplate(data, options) {
   return `
 import { showSetupCustomActionsDialog as setup } from '@dsf/helpers/custom-action-installer-helper';
 
-setup(${data}, ${JSON.stringify({
-    settingsPath,
-    bundleName,
-  })});
+setup(${data}, ${JSON.stringify(options)});
 `;
 }
 
@@ -151,7 +148,7 @@ function findActionEntryFiles(workdir, options) {
   });
 }
 
-function processScript(filePath, container, defaultMenuPath, settingsPath, bundleName) {
+function processScript(filePath, container, defaultMenuPath, setupOptions) {
   const fileInfo = path.parse(filePath);
   const content = fs.readFileSync(filePath, 'utf-8').toString();
   const actionCall = findTopLevelActionCall(content, filePath);
@@ -213,8 +210,7 @@ function processScript(filePath, container, defaultMenuPath, settingsPath, bundl
 
     let bundleScriptContent = generateInstallerTemplate(
       JSON.stringify(container.scripts, null, 4),
-      settingsPath,
-      bundleName
+      setupOptions
     );
     let bundleScriptFilePath = path.join(
       path.parse(filePath).dir,
@@ -224,13 +220,66 @@ function processScript(filePath, container, defaultMenuPath, settingsPath, bundl
   }
 }
 
-function processScripts(paths, container, defaultMenuPath, settingsPath, bundleName) {
+function processScripts(paths, container, defaultMenuPath, setupOptions) {
   paths.forEach((filePath) => {
     console.log(`Processing ${filePath}`);
-    processScript(filePath, container, defaultMenuPath, settingsPath, bundleName);
+    processScript(filePath, container, defaultMenuPath, setupOptions);
   });
 }
 
+function toPosix(filePath) {
+  return filePath.replace(/\\/g, '/');
+}
+
+function resolveShortcutFile(workdir, config) {
+  const configuredPath =
+    config.keyboardShortcutsPath ||
+    config.shortcutsPath ||
+    config.actionAcceleratorsPath;
+
+  const candidates = [];
+  if (configuredPath) {
+    candidates.push(path.resolve(workdir, configuredPath));
+  }
+
+  candidates.push(
+    path.join(workdir, 'src', 'keyboard-shortcuts.json'),
+    path.join(workdir, 'src', 'action-accelerators.json'),
+    path.join(workdir, 'keyboard-shortcuts.json'),
+    path.join(workdir, 'action-accelerators.json')
+  );
+
+  return candidates.find((candidate) => fs.existsSync(candidate)) || null;
+}
+
+function normalizeShortcutData(raw) {
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw;
+  if (Array.isArray(raw.actions)) return raw.actions;
+  if (Array.isArray(raw.shortcuts)) return raw.shortcuts;
+  if (Array.isArray(raw.accelerators)) return raw.accelerators;
+  return [];
+}
+
+function loadShortcutData(workdir, config) {
+  const shortcutFile = resolveShortcutFile(workdir, config);
+  if (!shortcutFile) {
+    return { shortcuts: undefined, sourcePath: undefined };
+  }
+
+  const raw = JSON.parse(fs.readFileSync(shortcutFile, 'utf8'));
+  const shortcuts = normalizeShortcutData(raw);
+
+  if (shortcuts.length === 0) {
+    console.warn(`[dazscript] Keyboard shortcut file has no shortcut entries: ${shortcutFile}`);
+  }
+
+  return {
+    shortcuts,
+    sourcePath: toPosix(path.relative(workdir, shortcutFile)),
+  };
+}
+
 function generateInstallerFiles(workdir, options) {
   const defaultMenuPath = options.defaultMenuPath.endsWith('/')
     ? options.defaultMenuPath
@@ -241,10 +290,20 @@ function generateInstallerFiles(workdir, options) {
   const bundleName = typeof config.bundleName === 'string' && config.bundleName.trim()
     ? config.bundleName.trim()
     : undefined;
+  const shortcutData = loadShortcutData(workdir, config);
+  const setupOptions = {
+    settingsPath,
+    bundleName,
+    shortcutBackupPath: `${appDataPath}/Installer/keyboard-shortcuts-backup.json`,
+  };
+  if (shortcutData.shortcuts && shortcutData.shortcuts.length > 0) {
+    setupOptions.shortcuts = shortcutData.shortcuts;
+    setupOptions.shortcutsSourcePath = shortcutData.sourcePath;
+  }
   const container = { scripts: [] };
   const matches = findActionEntryFiles(workdir, options);
 
-  processScripts(matches, container, defaultMenuPath, settingsPath, bundleName);
+  processScripts(matches, container, defaultMenuPath, setupOptions);
 
   container.scripts = container.scripts.sort((a, b) => {
     const aKey = a.menuPath + a.filePath;
@@ -254,15 +313,17 @@ function generateInstallerFiles(workdir, options) {
 
   const installerScriptContent = generateInstallerTemplate(
     JSON.stringify(container.scripts, null, 4),
-    settingsPath,
-    bundleName
+    setupOptions
   );
   fs.writeFileSync(path.join(workdir, 'src', 'Setup.dsa.ts'), installerScriptContent);
 
   const installPath = path.join(workdir, 'src', 'Install.dsa.ts');
   const uninstallPath = path.join(workdir, 'src', 'Uninstall.dsa.ts');
   if (fs.existsSync(installPath)) fs.unlinkSync(installPath);
-  if (fs.existsSync(uninstallPath)) fs.unlinkSync(uninstallPath);
+
+  if (fs.existsSync(uninstallPath)) {
+    fs.unlinkSync(uninstallPath);
+  }
 }
 
 if (require.main === module) {

package/package.json

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

package/src/Setup.dsa.ts

@@ -44,4 +44,4 @@ setup([
         "menuPath": "/DazScriptFramework/examples",
         "description": "06-showcase-dialog"
     }
-], {"settingsPath":"DazScriptFramework/examples/Installer","bundleName":"Examples"});
+], {"settingsPath":"DazScriptFramework/examples/Installer","bundleName":"Examples","shortcutBackupPath":"DazScriptFramework/examples/Installer/keyboard-shortcuts-backup.json"});

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

@@ -78,6 +78,10 @@ export type CustomActionTargets = {
     toolbar: boolean
 }
 
+type ApplyCustomActionOptions = {
+    deferToolbar?: boolean
+}
+
 type CustomActionCandidate = {
     name: string
     text: string
@@ -377,13 +381,18 @@ export const getInstalledCustomActionState = (action: CustomAction, scriptsPath:
     }
 }
 
-export const applyCustomActionTargets = (action: CustomAction, targets: CustomActionTargets, scriptsPath: string = getScriptPath()) => {
+export const applyCustomActionTargets = (
+    action: CustomAction,
+    targets: CustomActionTargets,
+    scriptsPath: string = getScriptPath(),
+    options: ApplyCustomActionOptions = {}
+): CustomAction | null => {
     const resolvedAction = resolveActionPaths(action, scriptsPath)
     const shouldInstall = targets.menu || targets.toolbar
 
     if (!shouldInstall) {
         removeCustomActionTargets(action, { menu: true, toolbar: true }, scriptsPath)
-        return
+        return null
     }
 
     const customAction = createOrUpdateCustomAction(action, resolvedAction)
@@ -392,9 +401,11 @@ export const applyCustomActionTargets = (action: CustomAction, targets: CustomAc
         addToMenu(customAction)
     }
 
-    if (targets.toolbar && action.toolbar) {
+    if (targets.toolbar && action.toolbar && !options.deferToolbar) {
         addToToolbar(customAction)
     }
+
+    return customAction
 }
 
 export const removeCustomActionTargets = (action: CustomAction, targets: CustomActionTargets, scriptsPath: string = getScriptPath()) => {

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

@@ -2,15 +2,15 @@ import { debug } from '@dsf/common/log'
 import { CustomAction } from '@dsf/core/custom-action'
 import { BasicDialog } from '@dsf/dialog/basic-dialog'
 import { PopupMenuBuilder, PopupMenuItem } from '@dsf/dialog/builders/popup-menu-builder'
+import { findAction, findActionsForShortcut, getActionShortcut, isCustomAction, normalizeShortcut, setActionShortcut } from '@dsf/helpers/action-helper'
 import { addToToolbar, applyCustomActionTargets, cleanupEmptyToolbar, clearToolbar, getInstalledCustomActionState, removeCustomActionTargets } from '@dsf/helpers/custom-action-helper'
 import { checkAll, getDataItem } from '@dsf/helpers/list-view-helper'
-import { normalizeShortcut, setActionShortcut } from '@dsf/helpers/action-helper'
 import { progress } from '@dsf/helpers/progress-helper'
 import { Observable } from '@dsf/lib/observable'
 import CustomSet from '@dsf/lib/set'
 import { TreeNode } from '@dsf/lib/tree-node'
 import { promptKeyboardShortcut } from '@dsf/shared/set-keyboard-shortcut'
-import { readFromFile } from './file-helper'
+import { readFromFile, saveToFile } from './file-helper'
 
 type InstallerEntry = {
     action: CustomAction
@@ -29,14 +29,47 @@ type InstallerEntry = {
 type SetupDialogOptions = {
     settingsPath: string
     bundleName?: string
-    shortcutsPath?: string
+    shortcuts?: ActionAccelerator[]
+    shortcutsSourcePath?: string
+    shortcutBackupPath?: string
 }
 
 type ActionAccelerator = {
+    name?: string
+    action?: string
+    text?: string
+    label?: string
+    shortcut?: string
+    accelerator?: string
+    key?: string
+}
+
+type ShortcutEntry = {
+    selected: boolean
+    name: string
+    label: string
+    currentShortcut: string
+    newShortcut: string
+    conflictText: string
+    exists: boolean
+    isCustom: boolean
+}
+
+type ShortcutBackupEntry = {
     name: string
     shortcut: string
 }
 
+type ShortcutBackupFile = {
+    version: number
+    shortcuts: ShortcutBackupEntry[]
+}
+
+type SetupSelection = {
+    actions: InstallerEntry[]
+    shortcuts: ShortcutEntry[]
+}
+
 const OVERRIDE_MARKER = '[ovr]'
 
 const toKey = (action: CustomAction): string => String(action.filePath ?? action.text ?? '')
@@ -44,9 +77,15 @@ const toKey = (action: CustomAction): string => String(action.filePath ?? action
 const toTreeNode = (entry: InstallerEntry): TreeNode<InstallerEntry> =>
     new TreeNode(String(entry.action.text), toKey(entry.action), entry)
 
+const toShortcutTreeNode = (entry: ShortcutEntry): TreeNode<ShortcutEntry> =>
+    new TreeNode(entry.label, entry.name, entry)
+
 const getEntry = (item: TreeNode<InstallerEntry>): InstallerEntry =>
     item.value as InstallerEntry
 
+const getShortcutEntry = (item: TreeNode<ShortcutEntry>): ShortcutEntry =>
+    item.value as ShortcutEntry
+
 const getDisplayedToolbar = (entry: InstallerEntry): string => String(entry.action.toolbar ?? '')
 
 const getSetupDialogOptions = (options: string | SetupDialogOptions): SetupDialogOptions =>
@@ -54,6 +93,9 @@ const getSetupDialogOptions = (options: string | SetupDialogOptions): SetupDialo
         ? { settingsPath: options }
         : options
 
+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
@@ -95,15 +137,66 @@ const buildEntries = (actions: CustomAction[]): InstallerEntry[] => {
         })
 }
 
+const normalizeAccelerator = (accelerator: ActionAccelerator): { name: string, label: string, shortcut: string } | null => {
+    const name = String(accelerator.name ?? accelerator.action ?? '').trim()
+    const shortcut = normalizeShortcut(String(accelerator.shortcut ?? accelerator.accelerator ?? accelerator.key ?? '').trim())
+    if (!name || !shortcut) return null
+
+    return {
+        name,
+        label: String(accelerator.text ?? accelerator.label ?? name),
+        shortcut
+    }
+}
+
+const getShortcutConflictText = (name: string, shortcut: string): string => {
+    if (!shortcut) return ''
+
+    const conflicts = findActionsForShortcut(shortcut)
+        .filter(action => action && action.name !== name)
+
+    return conflicts.map(action => String(action.text || action.name)).join(', ')
+}
+
+const buildShortcutEntries = (accelerators: ActionAccelerator[] = []): ShortcutEntry[] => {
+    return accelerators
+        .map(normalizeAccelerator)
+        .filter((accelerator): accelerator is { name: string, label: string, shortcut: string } => accelerator !== null)
+        .map((accelerator) => {
+            const action = findAction(accelerator.name)
+            const currentShortcut = getActionShortcut(accelerator.name)
+            const newShortcut = normalizeShortcut(accelerator.shortcut)
+
+            return {
+                selected: true,
+                name: accelerator.name,
+                label: action?.text ? String(action.text) : accelerator.label,
+                currentShortcut,
+                newShortcut,
+                conflictText: getShortcutConflictText(accelerator.name, newShortcut),
+                exists: action !== null,
+                isCustom: action ? isCustomAction(action) : false
+            }
+        })
+}
+
 class InstallerSelectionDialog extends BasicDialog {
     private readonly keywords$ = new Observable('')
     private readonly items$: Observable<TreeNode<InstallerEntry>[]>
+    private readonly shortcutKeywords$ = new Observable('')
+    private readonly shortcutItems$: Observable<TreeNode<ShortcutEntry>[]>
     private readonly refreshListEvent$ = new Observable<void>()
     private listView: DzListView | null = null
+    private shortcutListView: DzListView | null = null
 
-    constructor(private readonly entries: InstallerEntry[], bundleName?: string) {
+    constructor(
+        private readonly entries: InstallerEntry[],
+        private readonly shortcutEntries: ShortcutEntry[],
+        bundleName?: string
+    ) {
         super(bundleName ? `${bundleName} Setup` : 'Setup Scripts', 'dsfSetupScripts')
         this.items$ = new Observable(entries.map(toTreeNode))
+        this.shortcutItems$ = new Observable(shortcutEntries.map(toShortcutTreeNode))
     }
 
     protected build(): void {
@@ -111,7 +204,28 @@ class InstallerSelectionDialog extends BasicDialog {
         this.dialog.setAcceptButtonText('Apply')
         this.dialog.setCancelButtonText('Cancel')
 
+        if (this.shortcutEntries.length > 0) {
+            const add = this.add
+            add.tab('Scripts').build(() => this.buildScriptsTab())
+            add.tab('Keyboard Shortcuts').build(() => this.buildShortcutsTab())
+            return
+        }
+
+        this.buildScriptsTab()
+    }
+
+    getSelections(): SetupSelection {
+        this.syncSelectionsFromListView()
+        this.syncShortcutSelectionsFromListView()
+        return {
+            actions: this.entries,
+            shortcuts: this.shortcutEntries
+        }
+    }
+
+    private buildScriptsTab(): void {
         const add = this.add
+
         add.label('Choose which scripts to install, then use the columns to review their shortcut, menu, and toolbar targets.')
             .wordWrap()
             .build()
@@ -179,9 +293,71 @@ class InstallerSelectionDialog extends BasicDialog {
             })
     }
 
-    getSelections(): InstallerEntry[] {
-        this.syncSelectionsFromListView()
-        return this.entries
+    private buildShortcutsTab(): void {
+        const add = this.add
+
+        add.label('Choose which keyboard shortcuts to apply. Current and new shortcut values are shown side by side.')
+            .wordWrap()
+            .build()
+        add.group('Search').horizontal().build(() => {
+            add.edit()
+                .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.group('Keyboard Shortcuts')
+            .style({ flat: true })
+            .build(() => {
+                add.list.view<ShortcutEntry, ShortcutEntry>()
+                    .sorting(true)
+                    .sortOnBuild(true)
+                    .row((item, parent, id) => {
+                        const entry = getShortcutEntry(item)
+                        const listItem = new DzCheckListItem(parent, DzCheckListItem.CheckBox, id)
+                        listItem.on = entry.selected
+                        listItem.setText(0, '')
+                        return listItem
+                    })
+                    .items(this.shortcutItems$)
+                    .columns(['Apply', 'Action', 'Current', 'New', 'Status', 'Conflicts'], (index, width) => {
+                        if (index === 0) return Math.max(width, 70)
+                        if (index === 1) return Math.max(width * 2, 260)
+                        if (index === 2) return Math.max(width, 130)
+                        if (index === 3) return Math.max(width, 130)
+                        if (index === 4) return Math.max(width, 120)
+                        if (index === 5) return Math.max(width * 2, 260)
+                        return width
+                    })
+                    .text((item) => {
+                        const entry = getShortcutEntry(item)
+                        return [
+                            '',
+                            entry.label,
+                            entry.currentShortcut || '(none)',
+                            entry.newShortcut || '(none)',
+                            entry.exists ? (entry.isCustom ? 'Custom Action' : 'DAZ Action') : 'Not currently found',
+                            entry.conflictText || ''
+                        ]
+                    })
+                    .data((item) => getShortcutEntry(item))
+                    .filter({
+                        keywords: this.shortcutKeywords$,
+                        field: (listItem) => [
+                            listItem.text(1),
+                            listItem.text(2),
+                            listItem.text(3),
+                            listItem.text(4),
+                            listItem.text(5),
+                        ].join(' ')
+                    })
+                    .build((listView) => {
+                        this.shortcutListView = listView
+                        listView.allColumnsShowFocus = true
+                    })
+            })
     }
 
     private buildContextMenu(listView: DzListView, listItem: DzListViewItem | null): DzPopupMenu {
@@ -288,54 +464,128 @@ class InstallerSelectionDialog extends BasicDialog {
             }
         })
     }
+
+    private setVisibleShortcutSelections(onOff: boolean) {
+        if (!this.shortcutListView) return
+        this.checkShortcutVisible(this.shortcutListView, onOff)
+    }
+
+    private checkShortcutVisible(listView: DzListView, onOff: boolean) {
+        if (!this.shortcutKeywords$.value?.trim()) {
+            checkAll(listView, onOff)
+        }
+
+        listView.getItems(DzListView.All).forEach((item) => {
+            if (!item.visible || !(item as any).inherits('DzCheckListItem')) return
+
+            const checkbox = item as DzCheckListItem
+            checkbox.on = onOff
+
+            const data = getDataItem<ShortcutEntry>(item)
+            if (!data) return
+            data.selected = onOff
+        })
+    }
+
+    private syncShortcutSelectionsFromListView() {
+        if (!this.shortcutListView) return
+
+        const selectionByName: Record<string, boolean> = {}
+
+        this.shortcutListView.getItems(DzListView.All).forEach((item) => {
+            if (!(item as any).inherits('DzCheckListItem')) return
+
+            const data = getDataItem<ShortcutEntry>(item)
+            if (!data) return
+
+            const checkbox = item as DzCheckListItem
+            const selected = !(checkbox.state === 0 && !checkbox.on)
+            selectionByName[data.name] = selected
+        })
+
+        this.shortcutEntries.forEach((entry) => {
+            if (Object.prototype.hasOwnProperty.call(selectionByName, entry.name)) {
+                entry.selected = selectionByName[entry.name]
+            }
+        })
+    }
 }
 
-const runDialog = (actions: CustomAction[], options: SetupDialogOptions): InstallerEntry[] | null => {
+const runDialog = (actions: CustomAction[], options: SetupDialogOptions): SetupSelection | null => {
     const entries = buildEntries(actions)
-    const dialog = new InstallerSelectionDialog(entries, options.bundleName)
+    const shortcutEntries = buildShortcutEntries(options.shortcuts)
+    const dialog = new InstallerSelectionDialog(entries, shortcutEntries, options.bundleName)
     return dialog.ok() ? dialog.getSelections() : null
 }
 
+const readShortcutBackup = (backupPath: string): ShortcutBackupFile => {
+    const backup = readFromFile<ShortcutBackupFile>(backupPath)
+    return backup ?? { version: 1, shortcuts: [] }
+}
+
+const saveShortcutBackup = (backupPath: string, backup: ShortcutBackupFile): void => {
+    saveToFile(backupPath, JSON.stringify(backup, null, 2))
+}
+
+const backupCurrentShortcut = (entry: ShortcutEntry, backupPath: string): void => {
+    const action = findAction(entry.name)
+    if (!action || isCustomAction(action)) return
+
+    const backup = readShortcutBackup(backupPath)
+    const alreadyBackedUp = backup.shortcuts.some(shortcut => shortcut.name === entry.name)
+    if (alreadyBackedUp) return
+
+    backup.shortcuts.push({
+        name: entry.name,
+        shortcut: getActionShortcut(entry.name)
+    })
+    saveShortcutBackup(backupPath, backup)
+}
+
+const applyKeyboardShortcuts = (shortcuts: ShortcutEntry[], options: SetupDialogOptions): void => {
+    const selected = shortcuts.filter(shortcut => shortcut.selected)
+    if (selected.length === 0) return
+
+    const backupPath = getShortcutBackupPath(options)
+
+    progress('Applying Keyboard Shortcuts', selected, (shortcut) => {
+        backupCurrentShortcut(shortcut, backupPath)
+        setActionShortcut(shortcut.name, shortcut.newShortcut)
+    })
+}
+
 export const showSetupCustomActionsDialog = (actions: CustomAction[], options: string | SetupDialogOptions) => {
     const settings = getSetupDialogOptions(options)
     const selections = runDialog(actions, settings)
     if (!selections) return
 
-    if (settings.shortcutsPath) {
-        try {
-            const shortcuts = readFromFile<ActionAccelerator[]>(settings.shortcutsPath)
-            if (shortcuts) {
-                progress('Applying Keyboard Shortcuts', shortcuts, (shortcut) => {
-                    if (shortcut.name && shortcut.shortcut) {
-                        setActionShortcut(shortcut.name, shortcut.shortcut)
-                    }
-                })
-            }
-        } catch (e) {
-            debug(`[Setup] Failed to apply shortcuts from ${settings.shortcutsPath}: ${e}`)
-        }
-    }
-
-    debug(`[Setup] applying ${selections.filter(selection => selection.selected).length}/${selections.length} selected actions`)
+    debug(`[Setup] applying ${selections.actions.filter(selection => selection.selected).length}/${selections.actions.length} selected actions`)
 
-    const removedToolbarNames = new CustomSet<string>()
+    const touchedToolbarNames = new CustomSet<string>()
+    const selectedToolbarActions: CustomAction[] = []
 
-    progress('Setting Up Scripts', selections, (selection) => {
+    progress('Setting Up Scripts', selections.actions, (selection) => {
         debug(`[Setup] ${selection.selected ? 'install' : 'remove'} "${selection.action.text}"`)
 
+        if (selection.supportsToolbar && selection.action.toolbar) {
+            touchedToolbarNames.add(selection.action.toolbar)
+        }
+
         if (selection.selected) {
-            applyCustomActionTargets({
+            const customAction = applyCustomActionTargets({
                 ...selection.action,
                 shortcut: selection.effectiveShortcut
             }, {
                 menu: selection.supportsMenu,
                 toolbar: selection.supportsToolbar
+            }, undefined, {
+                deferToolbar: true
             })
-            return
-        }
 
-        if (selection.supportsToolbar && selection.action.toolbar) {
-            removedToolbarNames.add(selection.action.toolbar)
+            if (customAction && selection.supportsToolbar && selection.action.toolbar) {
+                selectedToolbarActions.push(customAction)
+            }
+            return
         }
 
         removeCustomActionTargets(selection.action, {
@@ -344,18 +594,29 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
         })
     })
 
-    removedToolbarNames.forEach((toolbarName) => {
+    touchedToolbarNames.forEach((toolbarName) => {
         clearToolbar(toolbarName)
 
-        const stillSelected = selections.filter(s => s.selected && s.supportsToolbar && s.action.toolbar === toolbarName)
-        stillSelected.forEach((s) => addToToolbar({
-            ...s.action,
-            shortcut: s.effectiveShortcut
-        }))
+        const stillSelected = selectedToolbarActions.filter(action => action.toolbar === toolbarName)
+        stillSelected.forEach((action) => addToToolbar(action))
         debug(`[Setup] Toolbar ${toolbarName} rebuilt with ${stillSelected.length} remaining actions`)
 
         if (stillSelected.length === 0) {
             cleanupEmptyToolbar(toolbarName)
         }
     })
+
+    applyKeyboardShortcuts(selections.shortcuts, settings)
+}
+
+export const restoreSetupKeyboardShortcuts = (options: string | SetupDialogOptions) => {
+    const settings = getSetupDialogOptions(options)
+    const backupPath = getShortcutBackupPath(settings)
+    const backup = readFromFile<ShortcutBackupFile>(backupPath)
+    if (!backup || !backup.shortcuts || backup.shortcuts.length === 0) return
+
+    progress('Restoring Keyboard Shortcuts', backup.shortcuts, (shortcut) => {
+        if (!shortcut.name) return
+        setActionShortcut(shortcut.name, shortcut.shortcut ?? '')
+    })
 }

package/webpack.config.js

@@ -75,6 +75,12 @@ module.exports = (env, argv) => {
               loader: 'ts-loader',
               options: {
                 allowTsInNodeModules: true,
+                configFile: path.resolve(projectRoot, 'tsconfig.json'),
+                compilerOptions: {
+                  strict: false,
+                  strictNullChecks: false,
+                  strictPropertyInitialization: false,
+                },
                 ignoreDiagnostics: [5107],
               },
             },