Merge pull request #13741 from gitbutlerapp/push-wztynolskttm

Lite: misc

Author: OliverJAsh

apps/lite/electron/src/ipc.ts

@@ -201,6 +201,7 @@ export interface NativeMenuPosition {
 
 type NativeMenuPopupItemData = {
 	label: string;
+	accelerator?: string;
 	enabled?: boolean;
 	itemId?: string;
 	submenu?: Array<NativeMenuPopupItem>;

apps/lite/electron/src/main.ts

@@ -195,6 +195,7 @@ const buildNativeMenuTemplate = (
 
 		return {
 			label: item.label,
+			accelerator: item.accelerator,
 			enabled: item.enabled,
 			click: itemId !== undefined ? () => onItem(itemId) : undefined,
 			submenu: item.submenu ? buildNativeMenuTemplate(item.submenu, onItem) : undefined,

apps/lite/ui/src/commands/manager.ts

@@ -15,41 +15,14 @@ import type { CommandGroup } from "./groups";
 import type { NativeMenuItem, NativeMenuItemData } from "#ui/native-menu.ts";
 import { useAppDispatch, useAppSelector } from "#ui/store.ts";
 import { commandsActions, CommandRegistrationId } from "./state";
-import { Order } from "effect";
-import { optionalOrder } from "#ui/lib/order.ts";
-
-export type CommandLayer =
-	| "global"
-	| "selection-tree"
-	| "selection"
-	| "focused-selection-tree"
-	| "focused-selection";
-
-export const CommandLayerOrder: Order.Order<CommandLayer> = Order.mapInput(Order.number, (cl) => {
-	switch (cl) {
-		case "global":
-			return 0;
-		case "selection-tree":
-			return 1;
-		case "selection":
-			return 2;
-		case "focused-selection-tree":
-			return 3;
-		case "focused-selection":
-			return 4;
-	}
-});
 
 // consider if many of these could typically share a label
 export type CommandOptions = {
+	group: CommandGroup;
 	/** @default true */
 	enabled?: boolean;
-	layer: CommandLayer;
 	commandPalette?: {
-		group: CommandGroup;
 		label: string;
-		/** @default true */
-		hotkeys?: boolean;
 	};
 	shortcutsBar?: {
 		label: string;
@@ -81,31 +54,49 @@ export type CommandFn = (scenario: CommandTrigger) => void;
 export const CommandFnContext: Context<Map<CommandRegistrationId, CommandFn> | null> =
 	createContext<Map<CommandRegistrationId, CommandFn> | null>(null);
 
-const sequenceKey = (s: HotkeySequence): string =>
-	s
-		.join("")
-		// Disambiguate from non-sequenced hotkeys.
-		.concat("_seq_");
-
-const useMaxHotkeyLayers = (): Record<string, CommandLayer | undefined> => {
-	const regs = useAppSelector((state) => state.commands.registrations);
+type HotkeySegment<T extends string> = T extends `${infer Head}+${infer Tail}`
+	? Head | HotkeySegment<Tail>
+	: T;
+
+const electronAcceleratorKeys: Partial<Record<HotkeySegment<Hotkey>, string>> = {
+	Alt: "Alt",
+	ArrowDown: "Down",
+	ArrowLeft: "Left",
+	ArrowRight: "Right",
+	ArrowUp: "Up",
+	Backspace: "Backspace",
+	Control: "Control",
+	Delete: "Delete",
+	End: "End",
+	Escape: "Esc",
+	Enter: "Enter",
+	Home: "Home",
+	Meta: "Command",
+	Mod: "CommandOrControl",
+	PageDown: "PageDown",
+	PageUp: "PageUp",
+	Shift: "Shift",
+	Space: "Space",
+	Tab: "Tab",
+};
 
-	return Object.values(regs).reduce(
-		(acc, val) => {
-			if (!val.hotkeys) return acc;
+const toElectronAccelerator = (hotkey: RegisterableHotkey): string | undefined => {
+	const accelerator = normalizeRegisterableHotkey(hotkey)
+		.split("+")
+		.map((part) => electronAcceleratorKeys[part as HotkeySegment<Hotkey>] ?? part)
+		.join("+");
 
-			for (const hotkey of val.hotkeys) {
-				const k =
-					"sequence" in hotkey
-						? sequenceKey(hotkey.sequence)
-						: normalizeRegisterableHotkey(hotkey.hotkey);
-				acc[k] = Order.max(optionalOrder(CommandLayerOrder))(acc[k], val.layer);
-			}
+	return accelerator.length > 0 ? accelerator : undefined;
+};
 
-			return acc;
-		},
-		{} as Record<string, CommandLayer | undefined>,
+const firstNativeMenuAccelerator = (
+	hotkeys: Array<CommandHotkey | CommandHotkeySequence> | undefined,
+): string | undefined => {
+	const firstHotkey = hotkeys?.find(
+		(hotkey): hotkey is CommandHotkey => !("sequence" in hotkey) && hotkey.enabled !== false,
 	);
+
+	return firstHotkey ? toElectronAccelerator(firstHotkey.hotkey) : undefined;
 };
 
 type ResolvedCommand<F extends CommandFn, O extends CommandOptions> = {
@@ -132,7 +123,6 @@ export const useCommand = <F extends CommandFn, O extends CommandOptions>(
 	const dispatch = useAppDispatch();
 	const regs = useAppSelector((state) => state.commands.registrations);
 	const regOptions = regs[id];
-	const maxKeybindLayers = useMaxHotkeyLayers();
 
 	useEffect(() => {
 		dispatch(commandsActions.register({ id, options }));
@@ -148,16 +138,7 @@ export const useCommand = <F extends CommandFn, O extends CommandOptions>(
 
 	const { hotkeyDefs, sequenceDefs, resolvedHotkeys } = (regOptions?.hotkeys ?? []).reduce(
 		(acc, hk) => {
-			const maxKeybindLayer =
-				maxKeybindLayers[
-					"sequence" in hk ? sequenceKey(hk.sequence) : normalizeRegisterableHotkey(hk.hotkey)
-				];
-
-			const defEnabled =
-				regOptions &&
-				regOptions.layer === maxKeybindLayer &&
-				regOptions.enabled !== false &&
-				hk.enabled !== false;
+			const defEnabled = regOptions && regOptions.enabled !== false && hk.enabled !== false;
 
 			if (defEnabled)
 				acc.resolvedHotkeys.push(
@@ -200,6 +181,7 @@ export const useCommand = <F extends CommandFn, O extends CommandOptions>(
 			? ({
 					enabled: regOptions.enabled !== false,
 					onSelect: () => commandFn("contextMenu"),
+					accelerator: firstNativeMenuAccelerator(regOptions.hotkeys),
 					...regOptions.contextMenu,
 					_tag: "Item",
 				} satisfies NativeMenuItem)

apps/lite/ui/src/lib/order.ts

@@ -5,6 +5,7 @@ type NativeMenuAction = () => void | Promise<void>;
 
 export type NativeMenuItemData = {
 	label: string;
+	accelerator?: string;
 	enabled?: boolean;
 	onSelect?: NativeMenuAction;
 	submenu?: Array<NativeMenuItem>;
@@ -24,6 +25,7 @@ const serializeNativeMenuItems = (
 			return {
 				_tag: "Item",
 				label: item.label,
+				accelerator: item.accelerator,
 				enabled: item.enabled,
 				submenu: serializeNativeMenuItems(item.submenu, handlers, nextActionId),
 			};
@@ -34,6 +36,7 @@ const serializeNativeMenuItems = (
 		return {
 			_tag: "Item",
 			label: item.label,
+			accelerator: item.accelerator,
 			enabled: item.enabled,
 			itemId,
 		};

apps/lite/ui/src/native-menu.ts

@@ -11,6 +11,11 @@ export type FileParent =
 	| ({ _tag: "Branch" } & BranchFileParent)
 	| ({ _tag: "Commit" } & CommitFileParent);
 
+/** @public */
+export const changesFileParent: FileParent = {
+	_tag: "Changes",
+};
+
 /** @public */
 export const branchFileParent = ({ stackId, branchRef }: BranchFileParent): FileParent => ({
 	_tag: "Branch",
@@ -25,11 +30,6 @@ export const commitFileParent = ({ stackId, commitId }: CommitFileParent): FileP
 	commitId,
 });
 
-/** @public */
-export const changesFileParent: FileParent = {
-	_tag: "Changes",
-};
-
 /** @public */
 export type StackOperand = {
 	stackId: string;
@@ -150,3 +150,21 @@ export const operandFileParent = (operand: Operand): FileParent | null =>
 		}),
 		Match.orElse(() => null),
 	);
+
+const fileParentToOperand = (fileParent: FileParent): Operand =>
+	Match.value(fileParent).pipe(
+		Match.tagsExhaustive({
+			Changes: () => changesSectionOperand,
+			Branch: ({ stackId, branchRef }) => branchOperand({ stackId, branchRef }),
+			Commit: ({ stackId, commitId }) => commitOperand({ stackId, commitId }),
+		}),
+	);
+
+export const operandContains = (a: Operand, b: Operand) => {
+	if (operandEquals(a, b)) return true;
+
+	const bFileParent = operandFileParent(b);
+	if (bFileParent && operandEquals(a, fileParentToOperand(bFileParent))) return true;
+
+	return false;
+};

apps/lite/ui/src/operands.ts

@@ -4,6 +4,7 @@ import {
 	branchOperand,
 	CommitOperand,
 	commitOperand,
+	operandContains,
 	operandEquals,
 	type Operand,
 } from "#ui/operands.ts";
@@ -154,28 +155,20 @@ const operationModeHasOperation = ({
 
 export const filterNavigationIndexForOutlineMode = ({
 	navigationIndex: navigationIndexUnfiltered,
-	selection,
 	outlineMode,
 }: {
 	navigationIndex: NavigationIndex;
-	selection: Operand;
 	outlineMode: OutlineMode;
 }) =>
 	Match.value(outlineMode).pipe(
 		Match.tagsExhaustive({
 			Default: () => navigationIndexUnfiltered,
-			Operation: (operationMode) =>
+			Operation: ({ value: operationMode }) =>
 				filterNavigationIndex(
 					navigationIndexUnfiltered,
 					(operand) =>
-						// When entering operation mode, the selection must still be
-						// selectable otherwise the details panel will suddenly appear to
-						// change and the user may lose sight of their source operand (e.g.
-						// hunk).
-						operandEquals(selection, operand) ||
-						// After selection moves, allow returning selection to the source operand.
-						operandEquals(operationMode.value.source, operand) ||
-						operationModeHasOperation({ mode: operationMode.value, operand }),
+						operandContains(operand, operationMode.source) ||
+						operationModeHasOperation({ mode: operationMode, operand }),
 				),
 			RenameBranch: (x) =>
 				filterNavigationIndex(navigationIndexUnfiltered, (operand) =>

apps/lite/ui/src/outline/mode.ts

@@ -103,40 +103,40 @@ export const useNavigationIndexHotkeys = ({
 	};
 
 	useCommand(selectPreviousItem, {
+		group,
 		enabled: focusedPanel === panel,
-		layer: "focused-selection-tree",
 		shortcutsBar: { label: "Up" },
 		hotkeys: [{ hotkey: "ArrowUp" }, { hotkey: "K" }],
 	});
 
 	useCommand(selectNextItem, {
+		group,
 		enabled: focusedPanel === panel,
-		layer: "focused-selection-tree",
 		shortcutsBar: { label: "Down" },
 		hotkeys: [{ hotkey: "ArrowDown" }, { hotkey: "J" }],
 	});
 
 	useCommand(selectPreviousSection, {
+		group,
 		enabled: focusedPanel === panel,
-		layer: "focused-selection-tree",
 		hotkeys: [{ hotkey: "Shift+ArrowUp" }, { hotkey: "Shift+K" }],
 	});
 
 	useCommand(selectNextSection, {
+		group,
 		enabled: focusedPanel === panel,
-		layer: "focused-selection-tree",
 		hotkeys: [{ hotkey: "Shift+ArrowDown" }, { hotkey: "Shift+J" }],
 	});
 
 	useCommand(selectFirstItem, {
+		group,
 		enabled: focusedPanel === panel,
-		layer: "focused-selection-tree",
 		hotkeys: [{ hotkey: "Home" }, { hotkey: "Meta+ArrowUp" }, { sequence: ["G", "G"] }],
 	});
 
 	useCommand(selectLastItem, {
+		group,
 		enabled: focusedPanel === panel,
-		layer: "focused-selection-tree",
 		hotkeys: [{ hotkey: "End" }, { hotkey: "Meta+ArrowDown" }, { hotkey: "Shift+G" }],
 	});
 
@@ -163,33 +163,33 @@ export const useNavigationIndexHotkeys = ({
 	};
 
 	useCommand(enterMoveMode, {
+		group,
 		enabled: focusedPanel === panel && outlineMode._tag === "Default",
-		layer: "focused-selection-tree",
-		commandPalette: { group, label: "Move" },
+		commandPalette: { label: "Move" },
 		shortcutsBar: { label: "Move" },
 		hotkeys: [{ hotkey: "M" }],
 	});
 
 	useCommand(enterCutMode, {
+		group,
 		enabled: focusedPanel === panel && outlineMode._tag === "Default",
-		layer: "focused-selection-tree",
-		commandPalette: { group, label: "Cut" },
+		commandPalette: { label: "Cut" },
 		shortcutsBar: { label: "Cut" },
 		hotkeys: [{ hotkey: "Mod+X", ignoreInputs: true }],
 	});
 
 	useCommand(enterRubMode, {
+		group,
 		enabled: focusedPanel === panel && outlineMode._tag === "Default",
-		layer: "focused-selection-tree",
-		commandPalette: { group, label: "Rub" },
+		commandPalette: { label: "Rub" },
 		shortcutsBar: { label: "Rub" },
 		hotkeys: [{ hotkey: "R" }],
 	});
 
 	useCommand(enterCommitMode, {
+		group,
 		enabled: focusedPanel === panel && outlineMode._tag === "Default",
-		layer: "focused-selection-tree",
-		commandPalette: { group, label: "Commit" },
+		commandPalette: { label: "Commit" },
 		shortcutsBar: { label: "Commit" },
 		hotkeys: [{ hotkey: "C" }],
 	});

apps/lite/ui/src/panels.ts

@@ -29,9 +29,9 @@ const ProjectSelect: FC = () => {
 			setPickerOpen(true);
 		},
 		{
-			layer: "global",
 			enabled: projects.length > 0,
-			commandPalette: { group: "Global", label: "Select project" },
+			group: "Global",
+			commandPalette: { label: "Select project" },
 			shortcutsBar: { label: "Project" },
 			hotkeys: [{ hotkey: "Mod+Shift+P" }],
 		},