dazscript-framework 0.2.5 → 0.3.2

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

@@ -0,0 +1,332 @@
+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 { 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'
+
+type InstallerEntry = {
+    action: CustomAction
+    supportsMenu: boolean
+    supportsToolbar: boolean
+    selected: boolean
+    installedMenu: boolean
+    installedToolbar: boolean
+    installedShortcut: string
+    defaultShortcut: string
+    effectiveShortcut: string
+    isShortcutOverridden: boolean
+    installedActionName: string
+}
+
+type SetupDialogOptions = {
+    settingsPath: string
+    bundleName?: string
+}
+
+const OVERRIDE_MARKER = '[ovr]'
+
+const toKey = (action: CustomAction): string => String(action.filePath ?? action.text ?? '')
+
+const toTreeNode = (entry: InstallerEntry): TreeNode<InstallerEntry> =>
+    new TreeNode(String(entry.action.text), toKey(entry.action), entry)
+
+const getDisplayedToolbar = (entry: InstallerEntry): string => String(entry.action.toolbar ?? '')
+
+const getSetupDialogOptions = (options: string | SetupDialogOptions): SetupDialogOptions =>
+    typeof options === 'string'
+        ? { settingsPath: options }
+        : options
+
+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))
+        .map((action) => {
+            const installed = getInstalledCustomActionState(action)
+            const supportsMenu = Boolean(action.menuPath)
+            const supportsToolbar = Boolean(action.toolbar)
+            const hasInstalledTargets = installed.installedMenu || installed.installedToolbar
+            const defaultShortcut = normalizeShortcut(String(action.shortcut ?? ''))
+            const installedShortcut = normalizeShortcut(String(installed.customAction?.shortcut ?? ''))
+            const entry: InstallerEntry = {
+                action: { ...action },
+                supportsMenu,
+                supportsToolbar,
+                selected: hasInstalledTargets,
+                installedMenu: installed.installedMenu,
+                installedToolbar: installed.installedToolbar,
+                installedShortcut,
+                defaultShortcut,
+                effectiveShortcut: installed.customAction?.name ? installedShortcut : defaultShortcut,
+                isShortcutOverridden: false,
+                installedActionName: String(installed.customAction?.name ?? '')
+            }
+
+            updateOverrideState(entry)
+            return entry
+        })
+}
+
+class InstallerSelectionDialog extends BasicDialog {
+    private readonly keywords$ = new Observable('')
+    private readonly items$: Observable<TreeNode<InstallerEntry>[]>
+    private readonly refreshListEvent$ = new Observable<void>()
+    private listView: DzListView | null = null
+
+    constructor(private readonly entries: InstallerEntry[], bundleName?: string) {
+        super(bundleName ? `${bundleName} Setup` : 'Setup Scripts', 'dsfSetupScripts')
+        this.items$ = new Observable(entries.map(toTreeNode))
+    }
+
+    protected build(): void {
+        this.builder.options({ resizable: true, width: 1100, height: 700 })
+        this.dialog.setAcceptButtonText('Apply')
+        this.dialog.setCancelButtonText('Cancel')
+
+        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()
+        add.group('Search').horizontal().build(() => {
+            add.edit()
+                .value(this.keywords$)
+                .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.group('Scripts')
+            .style({ flat: true })
+            .build(() => {
+                add.list.view<InstallerEntry, InstallerEntry>()
+                    .sorting(true)
+                    .sortOnBuild(true)
+                    .refresh(this.refreshListEvent$)
+                    .row((item, parent, id) => {
+                        const listItem = new DzCheckListItem(parent, DzCheckListItem.CheckBox, id)
+                        listItem.on = item.value.selected
+                        listItem.setText(0, '')
+                        return listItem
+                    })
+                    .contextMenu((listView, item) => this.buildContextMenu(listView, item))
+                    .items(this.items$)
+                    .columns(['Install', 'Action', 'Shortcut', 'Description', 'Menu', 'Toolbar'], (index, width) => {
+                        if (index === 0) return Math.max(width, 70)
+                        if (index === 1) return Math.max(width * 1.6, 220)
+                        if (index === 2) return Math.max(width, 140)
+                        if (index === 3) return Math.max(width * 1.8, 240)
+                        if (index === 4) return Math.max(width * 2.5, 320)
+                        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)
+                    .filter({
+                        keywords: this.keywords$,
+                        field: (listItem) => [
+                            listItem.text(1),
+                            listItem.text(2),
+                            listItem.text(3),
+                            listItem.text(4),
+                            listItem.text(5),
+                        ].join(' ')
+                    })
+                    .build((listView) => {
+                        this.listView = listView
+                        listView.allColumnsShowFocus = true
+                    })
+            })
+    }
+
+    getSelections(): InstallerEntry[] {
+        this.syncSelectionsFromListView()
+        return this.entries
+    }
+
+    private buildContextMenu(listView: DzListView, listItem: DzListViewItem | null): DzPopupMenu {
+        const entry = listItem ? getDataItem<InstallerEntry>(listItem) : null
+        const canSetShortcut = Boolean(entry)
+        const canResetShortcut = Boolean(entry?.installedActionName && entry?.isShortcutOverridden)
+
+        const items = [
+            {
+                text: 'Set Shortcut',
+                activated: () => {
+                    if (!entry) return
+                    this.setShortcut(entry)
+                }
+            },
+            {
+                text: 'Reset Default Shortcut',
+                activated: () => {
+                    if (!entry) return
+                    this.resetDefaultShortcut(entry)
+                }
+            },
+            {},
+            { text: 'Check All', activated: () => this.checkVisible(listView, true) },
+            { text: 'Uncheck All', activated: () => this.checkVisible(listView, false) }
+        ] as PopupMenuItem[]
+
+        return new PopupMenuBuilder(this.builder.context).items(...items).build((menu) => {
+            menu.setItemEnabled(0, canSetShortcut)
+            menu.setItemEnabled(1, canResetShortcut)
+        })
+    }
+
+    private setShortcut(entry: InstallerEntry) {
+        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)
+        }
+
+        this.refreshListEvent$.trigger()
+    }
+
+    private resetDefaultShortcut(entry: InstallerEntry) {
+        if (!entry.installedActionName || !entry.isShortcutOverridden) return
+
+        setActionShortcut(entry.installedActionName, entry.defaultShortcut)
+        entry.installedShortcut = normalizeShortcut(entry.defaultShortcut)
+        entry.effectiveShortcut = entry.installedShortcut
+        updateOverrideState(entry)
+        this.refreshListEvent$.trigger()
+    }
+
+    private checkVisible(listView: DzListView, onOff: boolean) {
+        if (!this.keywords$.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<InstallerEntry>(item)
+            if (!data) return
+            data.selected = onOff
+        })
+    }
+
+    private setVisibleSelections(onOff: boolean) {
+        if (!this.listView) return
+        this.checkVisible(this.listView, onOff)
+    }
+
+    private syncSelectionsFromListView() {
+        if (!this.listView) return
+
+        const selectionByKey: Record<string, boolean> = {}
+
+        this.listView.getItems(DzListView.All).forEach((item) => {
+            if (!(item as any).inherits('DzCheckListItem')) return
+
+            const data = getDataItem<InstallerEntry>(item)
+            if (!data) return
+
+            const checkbox = item as DzCheckListItem
+            const selected = !(checkbox.state === 0 && !checkbox.on)
+            selectionByKey[toKey(data.action)] = selected
+        })
+
+        this.entries.forEach((entry) => {
+            const key = toKey(entry.action)
+            if (Object.prototype.hasOwnProperty.call(selectionByKey, key)) {
+                entry.selected = selectionByKey[key]
+            }
+        })
+    }
+}
+
+const runDialog = (actions: CustomAction[], options: SetupDialogOptions): InstallerEntry[] | null => {
+    const entries = buildEntries(actions)
+    const dialog = new InstallerSelectionDialog(entries, options.bundleName)
+    return dialog.ok() ? dialog.getSelections() : null
+}
+
+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`)
+
+    const removedToolbarNames = new CustomSet<string>()
+
+    progress('Setting Up Scripts', selections, (selection) => {
+        debug(`[Setup] ${selection.selected ? 'install' : 'remove'} "${selection.action.text}"`)
+
+        if (selection.selected) {
+            applyCustomActionTargets({
+                ...selection.action,
+                shortcut: selection.effectiveShortcut
+            }, {
+                menu: selection.supportsMenu,
+                toolbar: selection.supportsToolbar
+            })
+            return
+        }
+
+        if (selection.supportsToolbar && selection.action.toolbar) {
+            removedToolbarNames.add(selection.action.toolbar)
+        }
+
+        removeCustomActionTargets(selection.action, {
+            menu: selection.supportsMenu,
+            toolbar: selection.supportsToolbar
+        })
+    })
+
+    removedToolbarNames.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
+        }))
+        debug(`[Setup] Toolbar ${toolbarName} rebuilt with ${stillSelected.length} remaining actions`)
+
+        if (stillSelected.length === 0) {
+            cleanupEmptyToolbar(toolbarName)
+        }
+    })
+}

package/src/helpers/file-helper.ts

@@ -80,7 +80,7 @@ export const deleteFile = (filePath: string): boolean => {
     try {
         var file = new DzFile(filePath)
         if (!file.exists()) return false
-        file.remove(filePath)
+        file.remove(/*filePath*/)
         file.deleteLater()
         return true
     } catch (error) {

package/src/helpers/list-view-helper.ts

@@ -13,7 +13,7 @@ export const setDataItem = (listItem: DzListViewItem, data: any) => {
 }
 
 export const getDataItem = <T>(listItem: DzListViewItem): T | null => {
-    return listItem?.getDataItem('data') ?? null
+    return (listItem?.getDataItem('data') ?? null) as T | null
 }
 
 export const filter = (listView: DzListView, filterOn: (viewItem: DzListViewItem) => string, keywords: string, options?: { selectOnFilter?: boolean, filters?: (viewItem: DzListViewItem) => boolean }) => {

package/src/helpers/message-box-helper.ts

@@ -10,7 +10,7 @@ export const error = (message: string, writeLog: boolean = true) => {
 }
 
 export const warning = (message: string) => {
-    MessageBox.warning(message, "Warning", "Ok")
+    MessageBox.warning(message, "Warning", "Ok", "")
 }
 
 export const confirm = (message?: string): { ok: boolean, cancel: boolean } => {
@@ -20,7 +20,7 @@ export const confirm = (message?: string): { ok: boolean, cancel: boolean } => {
 }
 
 export const prompt = (text: string, title: string, button0: string, button1?: string): { cancel: boolean, selection: number } => {
-    const response = MessageBox.question(text, title, button0, button1, "Cancel")
+    const response = MessageBox.question(text, title, button0, button1 ?? "", "Cancel")
 
     return { cancel: response === 0, selection: response };
 }

package/src/helpers/node-helper.ts

@@ -26,7 +26,7 @@ export const isFigure = (node: DzNode): boolean => {
  * @param node
  * @returns The root of the node, if the node is part of a figure, return the figure (skeleton) otherwise return the node itself
  */
-export const getRoot = (node: DzNode): DzNode => {
+export const getRoot = (node: DzNode | null): DzNode | null => {
     if (node && node.className() === "DzBone" && node.getSkeleton)
         return node.getSkeleton();
     else
@@ -44,8 +44,8 @@ export const getFigure = (node: DzNode): DzSkeleton | null => {
  * @returns The first property with the given name or internal name, or NULL.
  */
 export const findProperty = <T extends DzProperty = DzProperty>(node: DzNode, name: string): T | null => {
-    return sceneHelper.findPropertyOnNode(name, node) as T
-        ?? sceneHelper.findPropertyOnNodeByInternalName(name, node) as T
+    return sceneHelper.findPropertyOnNode(name, node) as unknown as T
+        ?? sceneHelper.findPropertyOnNodeByInternalName(name, node) as unknown as T
 }
 
 /**
@@ -90,7 +90,7 @@ export const isChildOf = (node: DzNode, figure: DzNode): boolean => {
  * @returns the fitting target (skeleton) of the node or null
  */
 export const getFittingTarget = (node: DzNode): DzSkeleton | null => {
-    return getRoot(node).getSkeleton()?.getFollowTarget()
+    return getRoot(node)?.getSkeleton()?.getFollowTarget() ?? null
 }
 
 /**
@@ -99,7 +99,7 @@ export const getFittingTarget = (node: DzNode): DzSkeleton | null => {
 * @param target if specified, check if the node is fitted to the target node, otherwise check if the node is fitted to any other node
 * @returns true if the node is fitted to another node
 */
-export const isFitting = (figure: DzSkeleton, target?: DzNode): boolean => {
+export const isFitting = (figure: DzSkeleton | null, target?: DzNode): boolean => {
     return target
         ? figure?.getFollowTarget() == target
         : figure?.getFollowTarget() != null
@@ -140,12 +140,12 @@ export const getTransforms = (node: DzNode, include: { rotations?: boolean, tran
 export const getRotations = (node: DzNode, includeExtraRotations: boolean = true): DzFloatProperty[] => {
     if (!node) return [];
 
-    const xRotate = sceneHelper.findPropertyOnNode('XRotate', node) as DzFloatProperty;
-    const xRotate2 = sceneHelper.findPropertyOnNode('XRotate2', node) as DzFloatProperty;
-    const yRotate = sceneHelper.findPropertyOnNode('YRotate', node) as DzFloatProperty;
-    const yRotate2 = sceneHelper.findPropertyOnNode('YRotate2', node) as DzFloatProperty;
-    const zRotate = sceneHelper.findPropertyOnNode('ZRotate', node) as DzFloatProperty;
-    const zRotate2 = sceneHelper.findPropertyOnNode('ZRotate2', node) as DzFloatProperty;
+    const xRotate = sceneHelper.findPropertyOnNode('XRotate', node) as unknown as DzFloatProperty;
+    const xRotate2 = sceneHelper.findPropertyOnNode('XRotate2', node) as unknown as DzFloatProperty;
+    const yRotate = sceneHelper.findPropertyOnNode('YRotate', node) as unknown as DzFloatProperty;
+    const yRotate2 = sceneHelper.findPropertyOnNode('YRotate2', node) as unknown as DzFloatProperty;
+    const zRotate = sceneHelper.findPropertyOnNode('ZRotate', node) as unknown as DzFloatProperty;
+    const zRotate2 = sceneHelper.findPropertyOnNode('ZRotate2', node) as unknown as DzFloatProperty;
 
     if (includeExtraRotations) {
         return [xRotate, xRotate2, yRotate, yRotate2, zRotate, zRotate2].filter(Boolean);
@@ -162,7 +162,7 @@ export const getRotations = (node: DzNode, includeExtraRotations: boolean = true
 export const getRotationsForAxis = (node: DzNode, axis: 'x' | 'y' | 'z'): DzFloatProperty => {
     debug(`Getting rotation property for axis: ${axis} on node: ${node.getName()} - isBone: ${isBone(node)}`);
 
-    let prop: DzFloatProperty | undefined;
+    let prop: DzFloatProperty | null = null;
 
     if (isBone(node)) {
         prop = getNamedRotationForAxis(node, axis);
@@ -175,7 +175,7 @@ export const getRotationsForAxis = (node: DzNode, axis: 'x' | 'y' | 'z'): DzFloa
         prop = find(
             getRotations(node, false),
             (rotation) => rotation.getName().valueOf()[0].toLowerCase() === axis
-        ) as DzFloatProperty;
+        ) as unknown as DzFloatProperty;
     }
 
     return prop;
@@ -185,7 +185,7 @@ export const getNamedRotations = (node: DzNode): DzFloatProperty[] => {
     const rotations: DzFloatProperty[] = []
 
     for (let namedAxis in NamedAxis) {
-        let property = sceneHelper.findPropertyOnNodeByLabel(NamedAxis[namedAxis], node) as DzFloatProperty
+        let property = sceneHelper.findPropertyOnNodeByLabel(NamedAxis[namedAxis], node) as unknown as DzFloatProperty
         if (property) rotations.push(property)
     }
 

package/src/helpers/pane-helper.ts

@@ -1,11 +1,11 @@
 import { mainWindow } from '@dsf/core/global'
 
 const findPane = <T extends DzPane>(className: string): T => {
-    return mainWindow.getPaneMgr().findPane(className) as T
+    return mainWindow.getPaneMgr().findPane(className) as unknown as T
 }
 
 export const getSmartContentPane = (): DzSmartContentPane => {
-    return <DzSmartContentPane>findPane("DzSmartContentPane")
+    return findPane("DzSmartContentPane") as unknown as DzSmartContentPane
 }
 
 export const getSurfacesPane = (): DzSurfacesPane => {
@@ -20,10 +20,10 @@ export const getParametersPane = (): DzParametersPane => {
     return findPane<DzParametersPane>("DzParametersPane")
 }
 
-export const getParametersPaneNodeEditor = (): DzPropertySideNavHierarchy => {
+export const getParametersPaneNodeEditor = (): DzPropertySideNavHierarchy | null => {
     return findPane<DzParametersPane>("DzParametersPane")?.getNodeEditor() ?? null
 }
 
-export const getPaneNodeEditor = (pane: DzAbstractNodeEditorPane): DzPropertySideNavHierarchy => {
+export const getPaneNodeEditor = (pane: DzAbstractNodeEditorPane): DzPropertySideNavHierarchy | null => {
     return pane.getNodeEditor ? pane.getNodeEditor() : null
-}
+}

package/src/helpers/scene-helper.ts

@@ -4,9 +4,9 @@ import { getRoot, isFigure } from './node-helper'
 import { getPaneNodeEditor, getParametersPane, getParametersPaneNodeEditor } from './pane-helper'
 
 export const getSelectedOf = <T>(typeName: string): DzNode[] => {
-    let nodes = []
+    let nodes: DzNode[] = []
     for (let node of scene.getSelectedNodeList()) {
-        if (!node.inherits(typeName)) continue
+        if (!node || !node.inherits(typeName)) continue
         nodes.push(node)
     }
     return nodes
@@ -45,7 +45,7 @@ export const getFigures = (): DzSkeleton[] => {
  * @returns the figure skeleton, or null if there is no current selection or the selected node is not part of a figure
  */
 export const getSelectedFigure = (): DzSkeleton | null => {
-    return getSelectedNode()?.getSkeleton?.()
+    return getSelectedNode()?.getSkeleton?.() ?? null
 }
 
 /**
@@ -66,12 +66,12 @@ export const getSelectedNodes = (): DzNode[] => {
     return scene.getSelectedNodeList()
 }
 
-export const getSelectedRoot = (): DzNode => {
+export const getSelectedRoot = (): DzNode | null => {
     return getRoot(getSelectedNode())
 }
 
 export const getSelectedRoots = (): DzNode[] => {
-    return distinct(getSelectedNodes().map(n => getRoot(n)))
+    return distinct(getSelectedNodes().map(n => getRoot(n))).filter(n => n !== null) as DzNode[]
 }
 
 export const getSelectedProperties = (): DzProperty[] => {
@@ -79,7 +79,7 @@ export const getSelectedProperties = (): DzProperty[] => {
 }
 
 export const getSelectedNumericProperties = (): (DzFloatProperty | DzIntProperty | DzBoolProperty)[] => {
-    return getParametersPane()?.getNodeEditor()?.getPropertySelections(true).map(p => p as DzFloatProperty | DzIntProperty | DzBoolProperty) ?? []
+    return getParametersPane()?.getNodeEditor()?.getPropertySelections(true).map(p => p as unknown as DzFloatProperty | DzIntProperty | DzBoolProperty) ?? []
 }
 
 export const getSelectedPropertiesOfType = <TProperty extends DzProperty>(type: string): TProperty[] => {
@@ -125,7 +125,7 @@ export const getCurrentFrame = (): number => {
 }
 
 export const getEndFrame = (): number => {
-    return scene.getAnimRange().end / scene.getTimeStep().valueOf()
+    return scene.getAnimRange().end.valueOf() / scene.getTimeStep().valueOf()
 }
 
 /**
@@ -133,7 +133,7 @@ export const getEndFrame = (): number => {
  * @returns the last frame number (0-based)
  */
 export const getLastFrame = (): number => {
-    return scene.getAnimRange().end / scene.getTimeStep().valueOf()
+    return scene.getAnimRange().end.valueOf() / scene.getTimeStep().valueOf()
 }
 
 export const timeToFrame = (time: DzTime): number => {
@@ -142,4 +142,4 @@ export const timeToFrame = (time: DzTime): number => {
 
 export const frameToTime = (frame: number): DzTime => {
     return new DzTime(scene.getTimeStep().valueOf() * frame)
-}
+}

package/src/helpers/viewport-helper.ts

@@ -2,7 +2,7 @@ import { mainWindow } from '@dsf/core/global'
 
 export const selectUniversalRotateTool = (coordinateSpace?: number): DzUniversalRotateTool => {
     const viewportMgr = mainWindow.getViewportMgr()
-    const tool = viewportMgr.findTool('DzUniversalRotateTool') as DzUniversalRotateTool
+    const tool = viewportMgr.findTool('DzUniversalRotateTool') as unknown as DzUniversalRotateTool
     viewportMgr.setActiveTool(tool)
     if (coordinateSpace) tool.setCoordinateSpace(coordinateSpace)
     return tool
@@ -19,4 +19,4 @@ export const getAuxViewport = (): DzViewport | null => {
         if (viewport.name === 'AuxViewportView') return viewport
     }
     return null
-}
+}

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

@@ -1,6 +1,6 @@
 import { BasicDialog } from '@dsf/dialog/basic-dialog';
 import { debug } from '@dsf/common/log';
-import { findAction, findActionsForShortcut, setActionShortcut } from '@dsf/helpers/action-helper';
+import { findAction, 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';
@@ -69,6 +69,8 @@ class KeyboardShortcutDialog extends BasicDialog {
             this.dialog.setAcceptButtonEnabled(Boolean(text))
         })
 
+        this.loadInitialShortcut(model.shortcut.value)
+
         add.group('Assign Keyboard Shortcut').build((layout) => {
             layout.spacing = 5
             add.edit().value(model.actionLabel).readOnly()
@@ -117,17 +119,32 @@ class KeyboardShortcutDialog extends BasicDialog {
 
         return `Already assigned to: ${conflicts.map(action => action.text || action.name).join(', ')}`
     }
+
+    private loadInitialShortcut(shortcut: string): void {
+        const normalized = normalizeShortcut(shortcut)
+        if (!normalized) return
+
+        const parts = normalized.split('+').map(part => part.trim()).filter(Boolean)
+        const key = parts.pop() ?? ''
+
+        this.model.control.value = parts.indexOf('Ctrl') >= 0
+        this.model.alt.value = parts.indexOf('Alt') >= 0
+        this.model.shift.value = parts.indexOf('Shift') >= 0
+        this.model.windows.value = parts.indexOf('Win') >= 0
+        this.key.value = key
+    }
 }
 
-export const setKeyboardShortcut = (actionLabel: string, actionName: string) => {
+export const promptKeyboardShortcut = (actionLabel: string, actionName: string, initialShortcut?: string): string | null => {
     let model = new KeyboardShortcutModel()
     model.actionLabel = actionLabel
     model.actionName = actionName
+    model.shortcut.value = normalizeShortcut(initialShortcut ?? getActionShortcut(actionName) ?? '')
 
     let dialog = new KeyboardShortcutDialog(model)
     let result = dialog.run()
 
-    if (!result || !model.shortcut) return
+    if (!result || !model.shortcut) return null
 
     const conflicts = findActionsForShortcut(model.shortcut.value)
         .filter(action => action && action.name !== actionName)
@@ -139,8 +156,15 @@ export const setKeyboardShortcut = (actionLabel: string, actionName: string) =>
     if (conflicts.length > 0) {
         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
+        if (!response.ok) return null
     }
 
-    setActionShortcut(actionName, model.shortcut.value)
+    return model.shortcut.value
+}
+
+export const setKeyboardShortcut = (actionLabel: string, actionName: string, initialShortcut?: string) => {
+    const shortcut = promptKeyboardShortcut(actionLabel, actionName, initialShortcut)
+    if (!shortcut) return
+
+    setActionShortcut(actionName, shortcut)
 }

package/tsconfig.json

@@ -32,7 +32,11 @@
     "baseUrl": "./" /* Specify the base directory to resolve non-relative module names. */,
     "paths": {
       "shared/*": ["src/shared/*"],
-      "@dst/*": ["node_modules/dazscript-types/src/types/*"],
+      "@dst/*": [
+        "node_modules/dazscript-types/src/types/*",
+        "../node_modules/dazscript-types/src/types/*",
+        "../script-types/src/types/*"
+      ],
       "@dsf/*": ["src/*"]
     },
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
@@ -112,5 +116,10 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true /* Skip type checking all .d.ts files. */
   },
-  "include": ["node_modules/dazscript-types/src/types/**/*", "src/**/*"]
+  "include": [
+    "node_modules/dazscript-types/src/types/**/*",
+    "../node_modules/dazscript-types/src/types/**/*",
+    "../script-types/src/types/**/*",
+    "src/**/*"
+  ]
 }

package/webpack.config.js

@@ -1,7 +1,8 @@
 const path = require('path');
 const glob = require('glob');
 const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
-const { createActionLaunchers, validateAppDataPath } = require('./dist/scripts/launchers');
+const { createActionLaunchers } = require('./dist/scripts/launchers');
+const { validateAppDataPath } = require('./dist/scripts/app-data-path');
 const { loadConfig } = require('./dist/scripts/config-loader');
 
 class ActionLauncherPlugin {