boards-data-menu-updater.ts

import * as PQueue from 'p-queue';
import { inject, injectable } from 'inversify';
import { CommandRegistry } from '@theia/core/lib/common/command';
import { MenuModelRegistry } from '@theia/core/lib/common/menu';
import {
    Disposable,
    DisposableCollection,
} from '@theia/core/lib/common/disposable';
import { BoardsServiceProvider } from './boards-service-provider';
import { Board, ConfigOption, Programmer } from '../../common/protocol';
import { FrontendApplicationContribution } from '@theia/core/lib/browser';
import { BoardsDataStore } from './boards-data-store';
import { MainMenuManager } from '../../common/main-menu-manager';
import { ArduinoMenus, unregisterSubmenu } from '../menu/arduino-menus';

@injectable()   
export class BoardsDataMenuUpdater implements FrontendApplicationContribution {
    @inject(CommandRegistry)
    protected readonly commandRegistry: CommandRegistry;

    @inject(MenuModelRegistry)
    protected readonly menuRegistry: MenuModelRegistry;

    @inject(MainMenuManager)
    protected readonly mainMenuManager: MainMenuManager;

    @inject(BoardsDataStore)
    protected readonly boardsDataStore: BoardsDataStore;

    @inject(BoardsServiceProvider)
    protected readonly boardsServiceClient: BoardsServiceProvider;

    protected readonly queue = new PQueue({ autoStart: true, concurrency: 1 });
    protected readonly toDisposeOnBoardChange = new DisposableCollection();

    async onStart(): Promise<void> {
        this.updateMenuActions(
            this.boardsServiceClient.boardsConfig.selectedBoard
        );
        this.boardsDataStore.onChanged(() =>
            this.updateMenuActions(
                this.boardsServiceClient.boardsConfig.selectedBoard
            )
        );
        this.boardsServiceClient.onBoardsConfigChanged(({ selectedBoard }) =>
            this.updateMenuActions(selectedBoard)
        );
    }

    protected async updateMenuActions(
        selectedBoard: Board | undefined
    ): Promise<void> {
        return this.queue.add(async () => {
            this.toDisposeOnBoardChange.dispose();
            this.mainMenuManager.update();
            if (selectedBoard) {
                const { fqbn } = selectedBoard;
                if (fqbn) {
                    const { configOptions, programmers, selectedProgrammer } =
                        await this.boardsDataStore.getData(fqbn);
                    if (configOptions.length) {
                        const boardsConfigMenuPath = [
                            ...ArduinoMenus.TOOLS__BOARD_SETTINGS_GROUP,
                            'z01_boardsConfig',
                        ]; // `z_` is for ordering.
                        for (const {
                            label,
                            option,
                            values,
                        } of configOptions.sort(
                            ConfigOption.LABEL_COMPARATOR
                        )) {
                            const menuPath = [
                                ...boardsConfigMenuPath,
                                `${option}`,
                            ];
                            const commands = new Map<
                                string,
                                Disposable & { label: string }
                            >();
                            for (const value of values) {
                                const id = `${fqbn}-${option}--${value.value}`;
                                const command = { id };
                                const selectedValue = value.value;
                                const handler = {
                                    execute: () =>
                                        this.boardsDataStore.selectConfigOption(
                                            { fqbn, option, selectedValue }
                                        ),
                                    isToggled: () => value.selected,
                                };
                                commands.set(
                                    id,
                                    Object.assign(
                                        this.commandRegistry.registerCommand(
                                            command,
                                            handler
                                        ),
                                        { label: value.label }
                                    )
                                );
                            }
                            this.menuRegistry.registerSubmenu(menuPath, label);
                            this.toDisposeOnBoardChange.pushAll([
                                ...commands.values(),
                                Disposable.create(() =>
                                    unregisterSubmenu(
                                        menuPath,
                                        this.menuRegistry
                                    )
                                ),
                                ...Array.from(commands.keys()).map(
                                    (commandId, i) => {
                                        const { label } =
                                            commands.get(commandId)!;
                                        this.menuRegistry.registerMenuAction(
                                            menuPath,
                                            { commandId, order: `${i}`, label }
                                        );
                                        return Disposable.create(() =>
                                            this.menuRegistry.unregisterMenuAction(
                                                commandId
                                            )
                                        );
                                    }
                                ),
                            ]);
                        }
                    }
                    if (programmers.length) {
                        const programmersMenuPath = [
                            ...ArduinoMenus.TOOLS__BOARD_SETTINGS_GROUP,
                            'z02_programmers',
                        ];
                        const label = selectedProgrammer
                            ? `Programmer: "${selectedProgrammer.name}"`
                            : 'Programmer';
                        this.menuRegistry.registerSubmenu(
                            programmersMenuPath,
                            label
                        );
                        this.toDisposeOnBoardChange.push(
                            Disposable.create(() =>
                                unregisterSubmenu(
                                    programmersMenuPath,
                                    this.menuRegistry
                                )
                            )
                        );
                        for (const programmer of programmers) {
                            const { id, name } = programmer;
                            const command = { id: `${fqbn}-programmer--${id}` };
                            const handler = {
                                execute: () =>
                                    this.boardsDataStore.selectProgrammer({
                                        fqbn,
                                        selectedProgrammer: programmer,
                                    }),
                                isToggled: () =>
                                    Programmer.equals(
                                        programmer,
                                        selectedProgrammer
                                    ),
                            };
                            this.menuRegistry.registerMenuAction(
                                programmersMenuPath,
                                { commandId: command.id, label: name }
                            );
                            this.commandRegistry.registerCommand(
                                command,
                                handler
                            );
                            this.toDisposeOnBoardChange.pushAll([
                                Disposable.create(() =>
                                    this.commandRegistry.unregisterCommand(
                                        command
                                    )
                                ),
                                Disposable.create(() =>
                                    this.menuRegistry.unregisterMenuAction(
                                        command.id
                                    )
                                ),
                            ]);
                        }
                    }
                    this.mainMenuManager.update();
                }
            }
        });
    }
}