dazscript-framework 0.3.2 → 1.0.2

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

@@ -4,6 +4,7 @@ import { mainWindow } from '@dsf/core/global'
 import * as array from '@dsf/helpers/array-helper'
 import { keys } from '@dsf/helpers/object-helper'
 import { progress } from '@dsf/helpers/progress-helper'
+import CustomSet from '@dsf/lib/set'
 import { getMenu } from './menu-helper'
 import { getScriptPath } from './script-helper'
 
@@ -445,7 +446,7 @@ export const installCustomActions = (actions: CustomAction[]) => {
 
 export const uninstallCustomActions = (actions: CustomAction[]) => {
     debug(`Uninstalling Actions`)
-    const toolbarNames = new Set<string>()
+    const toolbarNames = new CustomSet<string>()
 
     actions.forEach(action => {
         if (!action) return

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

@@ -2,14 +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, saveToFile } from './file-helper'
 
 type InstallerEntry = {
     action: CustomAction
@@ -28,6 +29,45 @@ type InstallerEntry = {
 type SetupDialogOptions = {
     settingsPath: string
     bundleName?: 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]'
@@ -37,6 +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 =>
@@ -44,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
@@ -85,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 {
@@ -101,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()
@@ -123,8 +247,9 @@ class InstallerSelectionDialog extends BasicDialog {
                     .sortOnBuild(true)
                     .refresh(this.refreshListEvent$)
                     .row((item, parent, id) => {
+                        const entry = getEntry(item)
                         const listItem = new DzCheckListItem(parent, DzCheckListItem.CheckBox, id)
-                        listItem.on = item.value.selected
+                        listItem.on = entry.selected
                         listItem.setText(0, '')
                         return listItem
                     })
@@ -139,15 +264,18 @@ class InstallerSelectionDialog extends BasicDialog {
                         if (index === 5) return Math.max(width * 1.2, 140)
                         return width
                     })
-                    .text((item) => [
-                        '',
-                        String(item.value.action.text ?? ''),
-                        getDisplayedShortcut(item.value),
-                        String(item.value.action.description ?? ''),
-                        String(item.value.action.menuPath ?? ''),
-                        getDisplayedToolbar(item.value),
-                    ])
-                    .data((item) => item.value)
+                    .text((item) => {
+                        const entry = getEntry(item)
+                        return [
+                            '',
+                            String(entry.action.text ?? ''),
+                            getDisplayedShortcut(entry),
+                            String(entry.action.description ?? ''),
+                            String(entry.action.menuPath ?? ''),
+                            getDisplayedToolbar(entry),
+                        ]
+                    })
+                    .data((item) => getEntry(item))
                     .filter({
                         keywords: this.keywords$,
                         field: (listItem) => [
@@ -165,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 {
@@ -274,24 +464,106 @@ 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
 
-    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>()
 
-    progress('Setting Up Scripts', selections, (selection) => {
+    progress('Setting Up Scripts', selections.actions, (selection) => {
         debug(`[Setup] ${selection.selected ? 'install' : 'remove'} "${selection.action.text}"`)
 
         if (selection.selected) {
@@ -318,7 +590,7 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
     removedToolbarNames.forEach((toolbarName) => {
         clearToolbar(toolbarName)
 
-        const stillSelected = selections.filter(s => s.selected && s.supportsToolbar && s.action.toolbar === toolbarName)
+        const stillSelected = selections.actions.filter(s => s.selected && s.supportsToolbar && s.action.toolbar === toolbarName)
         stillSelected.forEach((s) => addToToolbar({
             ...s.action,
             shortcut: s.effectiveShortcut
@@ -329,4 +601,18 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
             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 ?? '')
+    })
 }