close.ts

import{Dialog}from'@theia/core/lib/browser/dialogs';
importtype{FrontendApplication}from'@theia/core/lib/browser/frontend-application';
importtype{OnWillStopAction}from'@theia/core/lib/browser/frontend-application-contribution';
import{ApplicationShell}from'@theia/core/lib/browser/shell/application-shell';
import{nls}from'@theia/core/lib/common/nls';
importtype{MaybePromise}from'@theia/core/lib/common/types';
import{toArray}from'@theia/core/shared/@phosphor/algorithm';
import{inject,injectable}from'@theia/core/shared/inversify';
import{MonacoEditor}from'@theia/monaco/lib/browser/monaco-editor';
import{ArduinoMenus}from'../menu/arduino-menus';
import{CurrentSketch}from'../sketches-service-client-impl';
import{WindowServiceExt}from'../theia/core/window-service-ext';
import{
Command,
CommandRegistry,
KeybindingRegistry,
MenuModelRegistry,
Sketch,
SketchContribution,
URI,
}from'./contribution';
import{SaveAsSketch}from'./save-as-sketch';

/**
 * Closes the `current` closeable editor, or any closeable current widget from the main area, or the current sketch window.
 */
@injectable()
exportclassCloseextendsSketchContribution{
 @inject(WindowServiceExt)
privatereadonlywindowServiceExt: WindowServiceExt;

privateshell: ApplicationShell|undefined;

overrideonStart(app: FrontendApplication): MaybePromise<void>{
this.shell=app.shell;
}

overrideregisterCommands(registry: CommandRegistry): void{
registry.registerCommand(Close.Commands.CLOSE,{
execute: ()=>{
// Close current editor if closeable.
const{ currentEditor }=this.editorManager;
if(currentEditor&&currentEditor.title.closable){
currentEditor.close();
return;
}

if(this.shell){
// Close current widget from the main area if possible.
const{ currentWidget }=this.shell;
if(currentWidget){
constcurrentWidgetInMain=toArray(
this.shell.mainPanel.widgets()
).find((widget)=>widget===currentWidget);
if(currentWidgetInMain&&currentWidgetInMain.title.closable){
returncurrentWidgetInMain.close();
}
}
}
returnthis.windowServiceExt.close();
},
});
}

overrideregisterMenus(registry: MenuModelRegistry): void{
registry.registerMenuAction(ArduinoMenus.FILE__SKETCH_GROUP,{
commandId: Close.Commands.CLOSE.id,
label: nls.localize('vscode/editor.contribution/close','Close'),
order: '6',
});
}

overrideregisterKeybindings(registry: KeybindingRegistry): void{
registry.registerKeybinding({
command: Close.Commands.CLOSE.id,
keybinding: 'CtrlCmd+W',
});
}

// `FrontendApplicationContribution#onWillStop`
onWillStop(): OnWillStopAction{
return{
reason: 'save-sketch',
action: ()=>{
returnthis.showSaveSketchDialog();
},
};
}

/**
 * If returns with `true`, IDE2 will close. Otherwise, it won't.
 */
privateasyncshowSaveSketchDialog(): Promise<boolean>{
constsketch=awaitthis.isCurrentSketchTemp();
if(!sketch){
// Normal close workflow: if there are dirty editors prompt the user.
if(!this.shell){
console.error(
`Could not get the application shell. Something went wrong.`
);
returntrue;
}
if(this.shell.canSaveAll()){
constprompt=awaitthis.prompt(false);
switch(prompt){
casePrompt.DoNotSave:
returntrue;
casePrompt.Cancel:
returnfalse;
casePrompt.Save: {
awaitthis.shell.saveAll();
returntrue;
}
default:
thrownewError(`Unexpected prompt: ${prompt}`);
}
}
returntrue;
}

// If non of the sketch files were ever touched, do not prompt the save dialog. (#1274)
constwereTouched=awaitPromise.all(
Sketch.uris(sketch).map((uri)=>this.wasTouched(uri))
);
if(wereTouched.every((wasTouched)=>!Boolean(wasTouched))){
returntrue;
}

constprompt=awaitthis.prompt(true);
switch(prompt){
casePrompt.DoNotSave:
returntrue;
casePrompt.Cancel:
returnfalse;
casePrompt.Save: {
// If `save as` was canceled by user, the result will be `undefined`, otherwise the new URI.
constresult=awaitthis.commandService.executeCommand(
SaveAsSketch.Commands.SAVE_AS_SKETCH.id,
{
execOnlyIfTemp: false,
openAfterMove: false,
wipeOriginal: true,
markAsRecentlyOpened: true,
}
);
return!!result;
}
default:
thrownewError(`Unexpected prompt: ${prompt}`);
}
}

privateasyncprompt(isTemp: boolean): Promise<Prompt>{
const{ response }=awaitthis.dialogService.showMessageBox({
message: nls.localize(
'arduino/sketch/saveSketch',
'Save your sketch to open it again later.'
),
title: nls.localize(
'theia/core/quitTitle',
'Are you sure you want to quit?'
),
type: 'question',
buttons: [
nls.localizeByDefault("Don't Save"),
Dialog.CANCEL,
nls.localizeByDefault(isTemp ? 'Save As...' : 'Save'),
],
defaultId: 2,// `Save`/`Save As...` button index is the default.
});
switch(response){
case0:
returnPrompt.DoNotSave;
case1:
returnPrompt.Cancel;
case2:
returnPrompt.Save;
default:
thrownewError(`Unexpected response: ${response}`);
}
}

privateasyncisCurrentSketchTemp(): Promise<false|Sketch>{
constcurrentSketch=awaitthis.sketchServiceClient.currentSketch();
if(CurrentSketch.isValid(currentSketch)){
constisTemp=awaitthis.sketchesService.isTemp(currentSketch);
if(isTemp){
returncurrentSketch;
}
}
returnfalse;
}

/**
 * If the file was ever touched/modified. We get this based on the `version` of the monaco model.
 */
protectedasyncwasTouched(uri: string): Promise<boolean>{
consteditorWidget=awaitthis.editorManager.getByUri(newURI(uri));
if(editorWidget){
const{ editor }=editorWidget;
if(editorinstanceofMonacoEditor){
constversionId=editor.getControl().getModel()?.getVersionId();
if(this.isInteger(versionId)&&versionId>1){
returntrue;
}
}
}
returnfalse;
}

privateisInteger(arg: unknown): arg is number{
returnNumber.isInteger(arg);
}
}

enumPrompt{
Save,
DoNotSave,
Cancel,
}

exportnamespaceClose{
exportnamespaceCommands{
exportconstCLOSE: Command={
id: 'arduino-close',
};
}
}