Use eslint&prettier for code linting&formatting

arduino-ide-extension/src/browser/theia/monaco/monaco-editor-provider.ts

@@ -1,22 +1,32 @@
 import { inject, injectable } from 'inversify';
 import URI from '@theia/core/lib/common/uri';
-import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import {
+    Disposable,
+    DisposableCollection,
+} from '@theia/core/lib/common/disposable';
 import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 import { MonacoEditorProvider as TheiaMonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
 import { SketchesServiceClientImpl } from '../../../common/protocol/sketches-service-client-impl';
 
-type CancelablePromise = Promise<monaco.referenceSearch.ReferencesModel> & { cancel: () => void };
+type CancelablePromise = Promise<monaco.referenceSearch.ReferencesModel> & {
+    cancel: () => void;
+};
 interface EditorFactory {
-    (override: monaco.editor.IEditorOverrideServices, toDispose: DisposableCollection): Promise<MonacoEditor>;
+    (
+        override: monaco.editor.IEditorOverrideServices,
+        toDispose: DisposableCollection
+    ): Promise<MonacoEditor>;
 }
 
 @injectable()
 export class MonacoEditorProvider extends TheiaMonacoEditorProvider {
-
     @inject(SketchesServiceClientImpl)
     protected readonly sketchesServiceClient: SketchesServiceClientImpl;
 
-    protected async doCreateEditor(uri: URI, factory: EditorFactory): Promise<MonacoEditor> {
+    protected async doCreateEditor(
+        uri: URI,
+        factory: EditorFactory
+    ): Promise<MonacoEditor> {
         const editor = await super.doCreateEditor(uri, factory);
         const toDispose = new DisposableCollection();
         toDispose.push(this.installCustomReferencesController(editor));
@@ -24,32 +34,60 @@ export class MonacoEditorProvider extends TheiaMonacoEditorProvider {
         return editor;
     }
 
-    private installCustomReferencesController(editor: MonacoEditor): Disposable {
+    private installCustomReferencesController(
+        editor: MonacoEditor
+    ): Disposable {
         const control = editor.getControl();
-        const referencesController = control._contributions['editor.contrib.referencesController'];
+        const referencesController =
+            control._contributions['editor.contrib.referencesController'];
         const originalToggleWidget = referencesController.toggleWidget;
         const toDispose = new DisposableCollection();
         const toDisposeBeforeToggleWidget = new DisposableCollection();
-        referencesController.toggleWidget = (range: monaco.Range, modelPromise: CancelablePromise, peekMode: boolean) => {
+        referencesController.toggleWidget = (
+            range: monaco.Range,
+            modelPromise: CancelablePromise,
+            peekMode: boolean
+        ) => {
             toDisposeBeforeToggleWidget.dispose();
-            originalToggleWidget.bind(referencesController)(range, modelPromise, peekMode);
+            originalToggleWidget.bind(referencesController)(
+                range,
+                modelPromise,
+                peekMode
+            );
             if (referencesController._widget) {
                 if ('onDidClose' in referencesController._widget) {
-                    toDisposeBeforeToggleWidget.push((referencesController._widget as any).onDidClose(() => toDisposeBeforeToggleWidget.dispose()));
+                    toDisposeBeforeToggleWidget.push(
+                        (referencesController._widget as any).onDidClose(() =>
+                            toDisposeBeforeToggleWidget.dispose()
+                        )
+                    );
                 }
-                const preview = (referencesController._widget as any)._preview as monaco.editor.ICodeEditor;
+                const preview = (referencesController._widget as any)
+                    ._preview as monaco.editor.ICodeEditor;
                 if (preview) {
-                    toDisposeBeforeToggleWidget.push(preview.onDidChangeModel(() => this.updateReadOnlyState(preview)))
+                    toDisposeBeforeToggleWidget.push(
+                        preview.onDidChangeModel(() =>
+                            this.updateReadOnlyState(preview)
+                        )
+                    );
                     this.updateReadOnlyState(preview);
                 }
             }
         };
-        toDispose.push(Disposable.create(() => toDisposeBeforeToggleWidget.dispose()));
-        toDispose.push(Disposable.create(() => referencesController.toggleWidget = originalToggleWidget));
+        toDispose.push(
+            Disposable.create(() => toDisposeBeforeToggleWidget.dispose())
+        );
+        toDispose.push(
+            Disposable.create(
+                () => (referencesController.toggleWidget = originalToggleWidget)
+            )
+        );
         return toDispose;
     }
 
-    private updateReadOnlyState(editor: monaco.editor.ICodeEditor | undefined): void {
+    private updateReadOnlyState(
+        editor: monaco.editor.ICodeEditor | undefined
+    ): void {
         if (!editor) {
             return;
         }
@@ -60,5 +98,4 @@ export class MonacoEditorProvider extends TheiaMonacoEditorProvider {
         const readOnly = this.sketchesServiceClient.isReadOnly(model.uri);
         editor.updateOptions({ readOnly });
     }
-
 }

arduino-ide-extension/src/browser/theia/monaco/monaco-status-bar-contribution.ts

@@ -3,11 +3,7 @@ import { MonacoStatusBarContribution as TheiaMonacoStatusBarContribution } from
 
 @injectable()
 export class MonacoStatusBarContribution extends TheiaMonacoStatusBarContribution {
+    protected setConfigTabSizeWidget() {}
 
-    protected setConfigTabSizeWidget() {
-    }
-
-    protected setLineEndingWidget() {
-    }
-
+    protected setLineEndingWidget() {}
 }

arduino-ide-extension/src/browser/theia/monaco/monaco-text-model-service.ts

@@ -10,42 +10,52 @@ import { SketchesServiceClientImpl } from '../../../common/protocol/sketches-ser
 
 @injectable()
 export class MonacoTextModelService extends TheiaMonacoTextModelService {
-
     @inject(SketchesServiceClientImpl)
     protected readonly sketchesServiceClient: SketchesServiceClientImpl;
 
-    protected async createModel(resource: Resource): Promise<MonacoEditorModel> {
-        const factory = this.factories.getContributions().find(({ scheme }) => resource.uri.scheme === scheme);
+    protected async createModel(
+        resource: Resource
+    ): Promise<MonacoEditorModel> {
+        const factory = this.factories
+            .getContributions()
+            .find(({ scheme }) => resource.uri.scheme === scheme);
         const readOnly = this.sketchesServiceClient.isReadOnly(resource.uri);
-        return factory ? factory.createModel(resource) : new MaybeReadonlyMonacoEditorModel(resource, this.m2p, this.p2m, this.logger, undefined, readOnly);
+        return factory
+            ? factory.createModel(resource)
+            : new MaybeReadonlyMonacoEditorModel(
+                  resource,
+                  this.m2p,
+                  this.p2m,
+                  this.logger,
+                  undefined,
+                  readOnly
+              );
     }
-
 }
 
 // https://github.com/eclipse-theia/theia/pull/8491
 class SilentMonacoEditorModel extends MonacoEditorModel {
-
     protected trace(loggable: Loggable): void {
         if (this.logger) {
             this.logger.trace((log: Log) =>
-                loggable((message, ...params) => log(message, ...params, this.resource.uri.toString(true)))
+                loggable((message, ...params) =>
+                    log(message, ...params, this.resource.uri.toString(true))
+                )
             );
         }
     }
-
 }
 
 class MaybeReadonlyMonacoEditorModel extends SilentMonacoEditorModel {
-
     constructor(
         protected readonly resource: Resource,
         protected readonly m2p: MonacoToProtocolConverter,
         protected readonly p2m: ProtocolToMonacoConverter,
         protected readonly logger?: ILogger,
         protected readonly editorPreferences?: EditorPreferences,
-        protected readonly _readOnly?: boolean,
+        protected readonly _readOnly?: boolean
     ) {
-        super(resource, m2p, p2m, logger, editorPreferences)
+        super(resource, m2p, p2m, logger, editorPreferences);
     }
 
     get readOnly(): boolean {
@@ -69,6 +79,4 @@ class MaybeReadonlyMonacoEditorModel extends SilentMonacoEditorModel {
         }
         this.onDirtyChangedEmitter.fire(undefined);
     }
-
-
 }