@theia/api-tests 1.26.0-next.2 → 1.26.0-next.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (5) hide show
  1. package/package.json +3 -3
  2. package/src/monaco-api.spec.js +19 -4
  3. package/src/saveable.spec.js +1 -1
  4. package/src/typescript.spec.js +215 -360
  5. package/src/undo-redo-selectAll.spec.js +10 -4
package/package.json CHANGED
@@ -1,9 +1,9 @@
1
1
  {
2
2
  "name": "@theia/api-tests",
3
- "version": "1.26.0-next.2+08722fad0ec",
3
+ "version": "1.26.0-next.22+1265154246d",
4
4
  "description": "Theia API tests",
5
5
  "dependencies": {
6
- "@theia/core": "1.26.0-next.2+08722fad0ec"
6
+ "@theia/core": "1.26.0-next.22+1265154246d"
7
7
  },
8
8
  "license": "EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0",
9
9
  "repository": {
@@ -20,5 +20,5 @@
20
20
  "publishConfig": {
21
21
  "access": "public"
22
22
  },
23
- "gitHead": "08722fad0ecdd3259457c34db61b86c8da6b61c8"
23
+ "gitHead": "1265154246d98e44c0e1ee479aa9d42b2615d9d1"
24
24
  }
package/src/monaco-api.spec.js CHANGED
@@ -29,15 +29,18 @@ describe('Monaco API', async function () {
29
29
  const { SimpleKeybinding } = require('@theia/monaco-editor-core/esm/vs/base/common/keybindings');
30
30
  const { IKeybindingService } = require('@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding');
31
31
  const { StandaloneServices } = require('@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices');
32
- const { KeyCode } = require('@theia/monaco-editor-core/esm/vs/base/common/keyCodes');
33
32
  const { TokenizationRegistry } = require('@theia/monaco-editor-core/esm/vs/editor/common/languages');
34
- const { Uri } = require('@theia/monaco-editor-core');
33
+ const { MonacoContextKeyService } = require('@theia/monaco/lib/browser/monaco-context-key-service');
34
+ const { URI } = require('@theia/monaco-editor-core/esm/vs/base/common/uri');
35
35
 
36
36
  const container = window.theia.container;
37
37
  const editorManager = container.get(EditorManager);
38
38
  const workspaceService = container.get(WorkspaceService);
39
39
  const textmateService = container.get(MonacoTextmateService);
40
+ /** @type {import('@theia/core/src/common/command').CommandRegistry} */
40
41
  const commands = container.get(CommandRegistry);
42
+ /** @type {import('@theia/monaco/src/browser/monaco-context-key-service').MonacoContextKeyService} */
43
+ const contextKeys = container.get(MonacoContextKeyService);
41
44
 
42
45
  /** @type {MonacoEditor} */
43
46
  let monacoEditor;
@@ -55,7 +58,7 @@ describe('Monaco API', async function () {
55
58
  });
56
59
 
57
60
  it('KeybindingService.resolveKeybinding', () => {
58
- const simpleKeybinding = new SimpleKeybinding(true, true, true, true, KeyCode.KeyK);
61
+ const simpleKeybinding = new SimpleKeybinding(true, true, true, true, 41 /* KeyCode.KeyK */);
59
62
  const chordKeybinding = simpleKeybinding.toChord();
60
63
  assert.equal(chordKeybinding.parts.length, 1);
61
64
  assert.equal(chordKeybinding.parts[0], simpleKeybinding);
@@ -163,11 +166,23 @@ describe('Monaco API', async function () {
163
166
  execute: arg => (console.log(arg), opened = arg === 'foo')
164
167
  });
165
168
  try {
166
- await openerService.open(Uri.parse('command:' + id + '?"foo"'));
169
+ await openerService.open(URI.parse('command:' + id + '?"foo"'));
167
170
  assert.isTrue(opened);
168
171
  } finally {
169
172
  unregisterCommand.dispose();
170
173
  }
171
174
  });
172
175
 
176
+ it('Supports setting contexts using the command registry', async () => {
177
+ const setContext = 'setContext';
178
+ const key = 'monaco-api-test-context';
179
+ const firstValue = 'first setting';
180
+ const secondValue = 'second setting';
181
+ assert.isFalse(contextKeys.match(`${key} == ${firstValue}`));
182
+ await commands.executeCommand(setContext, key, firstValue);
183
+ assert.isTrue(contextKeys.match(`${key} == ${firstValue}`));
184
+ await commands.executeCommand(setContext, key, secondValue);
185
+ assert.isTrue(contextKeys.match(`${key} == ${secondValue}`));
186
+ });
187
+
173
188
  });
package/src/saveable.spec.js CHANGED
@@ -31,7 +31,7 @@ describe('Saveable', function () {
31
31
  const { MonacoEditor } = require('@theia/monaco/lib/browser/monaco-editor');
32
32
  const { Deferred } = require('@theia/core/lib/common/promise-util');
33
33
  const { Disposable, DisposableCollection } = require('@theia/core/lib/common/disposable');
34
- const { Range } = require('@theia/monaco-editor-core');
34
+ const { Range } = require('@theia/monaco-editor-core/esm/vs/editor/common/core/range');
35
35
 
36
36
  const container = window.theia.container;
37
37
  /** @type {EditorManager} */
package/src/typescript.spec.js CHANGED
@@ -16,7 +16,7 @@
16
16
 
17
17
  // @ts-check
18
18
  describe('TypeScript', function () {
19
- this.timeout(30000);
19
+ this.timeout(30_000);
20
20
 
21
21
  const { assert } = chai;
22
22
 
@@ -36,10 +36,9 @@ describe('TypeScript', function () {
36
36
  const { animationFrame } = require('@theia/core/lib/browser/browser');
37
37
  const { PreferenceService, PreferenceScope } = require('@theia/core/lib/browser/preferences/preference-service');
38
38
  const { ProgressStatusBarItem } = require('@theia/core/lib/browser/progress-status-bar-item');
39
- const { FileService } = require('@theia/filesystem/lib/browser/file-service');
40
39
  const { PluginViewRegistry } = require('@theia/plugin-ext/lib/main/browser/view/plugin-view-registry');
41
- const { Deferred } = require('@theia/core/lib/common/promise-util');
42
- const { Range } = require('@theia/monaco-editor-core');
40
+ const { Range } = require('@theia/monaco-editor-core/esm/vs/editor/common/core/range');
41
+ const { Selection } = require('@theia/monaco-editor-core/esm/vs/editor/common/core/selection');
43
42
 
44
43
  const container = window.theia.container;
45
44
  const editorManager = container.get(EditorManager);
@@ -53,92 +52,25 @@ describe('TypeScript', function () {
53
52
  /** @type {import('@theia/core/lib/browser/preferences/preference-service').PreferenceService} */
54
53
  const preferences = container.get(PreferenceService);
55
54
  const progressStatusBarItem = container.get(ProgressStatusBarItem);
56
- const fileService = container.get(FileService);
55
+ /** @type {PluginViewRegistry} */
57
56
  const pluginViewRegistry = container.get(PluginViewRegistry);
58
57
 
59
58
  const typescriptPluginId = 'vscode.typescript-language-features';
60
59
  const referencesPluginId = 'ms-vscode.references-view';
60
+ /** @type Uri.URI */
61
61
  const rootUri = workspaceService.tryGetRoots()[0].resource;
62
- const serverUri = rootUri.resolve('src-gen/backend/test-server.js');
63
- const inversifyUri = rootUri.resolve('../../node_modules/inversify/lib/inversify.d.ts').normalizePath();
64
- const containerUri = rootUri.resolve('../../node_modules/inversify/lib/container/container.d.ts').normalizePath();
62
+ const demoFileUri = rootUri.resolveToAbsolute('../api-tests/test-ts-workspace/demo-file.ts');
63
+ const definitionFileUri = rootUri.resolveToAbsolute('../api-tests/test-ts-workspace/demo-definitions-file.ts');
64
+ let originalAutoSaveValue = preferences.get('files.autoSave', undefined, rootUri.toString());
65
65
 
66
66
  before(async function () {
67
- await fileService.create(serverUri, `// @ts-check
68
- require('reflect-metadata');
69
- const path = require('path');
70
- const express = require('express');
71
- const { Container } = require('inversify');
72
- const { BackendApplication, CliManager } = require('@theia/core/lib/node');
73
- const { backendApplicationModule } = require('@theia/core/lib/node/backend-application-module');
74
- const { messagingBackendModule } = require('@theia/core/lib/node/messaging/messaging-backend-module');
75
- const { loggerBackendModule } = require('@theia/core/lib/node/logger-backend-module');
76
-
77
- const container = new Container();
78
- container.load(backendApplicationModule);
79
- container.load(messagingBackendModule);
80
- container.load(loggerBackendModule);
81
-
82
- function load(raw) {
83
- return Promise.resolve(raw.default).then(module =>
84
- container.load(module)
85
- );
86
- }
87
-
88
- function start(port, host, argv) {
89
- if (argv === undefined) {
90
- argv = process.argv;
91
- }
92
-
93
- const cliManager = container.get(CliManager);
94
- return cliManager.initializeCli(argv).then(function () {
95
- const application = container.get(BackendApplication);
96
- application.use(express.static(path.join(__dirname, '../../lib')));
97
- application.use(express.static(path.join(__dirname, '../../lib/index.html')));
98
- return application.start(port, host);
99
- });
100
- }
101
-
102
- module.exports = (port, host, argv) => Promise.resolve()
103
- .then(function () { return Promise.resolve(require('@theia/process/lib/node/process-backend-module')).then(load) })
104
- .then(function () { return Promise.resolve(require('@theia/filesystem/lib/node/filesystem-backend-module')).then(load) })
105
- .then(function () { return Promise.resolve(require('@theia/filesystem/lib/node/download/file-download-backend-module')).then(load) })
106
- .then(function () { return Promise.resolve(require('@theia/workspace/lib/node/workspace-backend-module')).then(load) })
107
- .then(function () { return Promise.resolve(require('@theia/languages/lib/node/languages-backend-module')).then(load) })
108
- .then(function () { return Promise.resolve(require('@theia/terminal/lib/node/terminal-backend-module')).then(load) })
109
- .then(function () { return Promise.resolve(require('@theia/task/lib/node/task-backend-module')).then(load) })
110
- .then(function () { return Promise.resolve(require('@theia/debug/lib/node/debug-backend-module')).then(load) })
111
- .then(function () { return Promise.resolve(require('@theia/file-search/lib/node/file-search-backend-module')).then(load) })
112
- .then(function () { return Promise.resolve(require('@theia/git/lib/node/git-backend-module')).then(load) })
113
- .then(function () { return Promise.resolve(require('@theia/git/lib/node/env/git-env-module')).then(load) })
114
- .then(function () { return Promise.resolve(require('@theia/json/lib/node/json-backend-module')).then(load) })
115
- .then(function () { return Promise.resolve(require('@theia/metrics/lib/node/metrics-backend-module')).then(load) })
116
- .then(function () { return Promise.resolve(require('@theia/mini-browser/lib/node/mini-browser-backend-module')).then(load) })
117
- .then(function () { return Promise.resolve(require('@theia/search-in-workspace/lib/node/search-in-workspace-backend-module')).then(load) })
118
- .then(function () { return Promise.resolve(require('@theia/plugin-ext/lib/plugin-ext-backend-module')).then(load) })
119
- .then(function () { return Promise.resolve(require('@theia/plugin-dev/lib/node/plugin-dev-backend-module')).then(load) })
120
- .then(function () { return Promise.resolve(require('@theia/plugin-ext-vscode/lib/node/plugin-vscode-backend-module')).then(load) })
121
- .then(function () { return Promise.resolve(require('@theia/plugin-metrics/lib/node/plugin-metrics-backend-module')).then(load) })
122
- .then(function () { return Promise.resolve(require('@theia/vsx-registry/lib/node/vsx-registry-backend-module')).then(load) })
123
- .then(() => start(port, host, argv)).catch(reason => {
124
- console.error('Failed to start the backend application.');
125
- if (reason) {
126
- console.error(reason);
127
- }
128
- throw reason;
129
- });
130
- `, { fromUserGesture: false, overwrite: true });
131
67
  await pluginService.didStart;
132
68
  await Promise.all([typescriptPluginId, referencesPluginId].map(async pluginId => {
133
69
  if (!pluginService.getPlugin(pluginId)) {
134
70
  throw new Error(pluginId + ' should be started');
135
71
  }
136
72
  await pluginService.activatePlugin(pluginId);
137
- }));
138
- });
139
-
140
- after(async function () {
141
- await fileService.delete(serverUri, { fromUserGesture: false });
73
+ }).concat(preferences.set('files.autoSave', 'off', PreferenceScope.Workspace)));
142
74
  });
143
75
 
144
76
  beforeEach(async function () {
@@ -151,6 +83,10 @@ module.exports = (port, host, argv) => Promise.resolve()
151
83
  await editorManager.closeAll({ save: false });
152
84
  });
153
85
 
86
+ after(async () => {
87
+ await preferences.set('files.autoSave', originalAutoSaveValue, PreferenceScope.Workspace);
88
+ })
89
+
154
90
  /**
155
91
  * @param {Uri.default} uri
156
92
  * @param {boolean} preview
@@ -160,30 +96,36 @@ module.exports = (port, host, argv) => Promise.resolve()
160
96
  const editorWidget = widget instanceof EditorWidget ? widget : undefined;
161
97
  const editor = MonacoEditor.get(editorWidget);
162
98
  assert.isDefined(editor);
163
-
164
99
  // wait till tsserver is running, see:
165
100
  // https://github.com/microsoft/vscode/blob/93cbbc5cae50e9f5f5046343c751b6d010468200/extensions/typescript-language-features/src/extension.ts#L98-L103
166
101
  await waitForAnimation(() => contextKeyService.match('typescript.isManagedFile'));
167
-
168
102
  // wait till projects are loaded, see:
169
103
  // https://github.com/microsoft/vscode/blob/4aac84268c6226d23828cc6a1fe45ee3982927f0/extensions/typescript-language-features/src/typescriptServiceClient.ts#L911
170
104
  await waitForAnimation(() => !progressStatusBarItem.currentProgress);
171
-
172
105
  return /** @type {MonacoEditor} */ (editor);
173
106
  }
174
107
 
175
108
  /**
176
- * @param {() => Promise<unknown> | unknown} condition
109
+ * @param {() => Promise<unknown> | unknown} condition
110
+ * @param {number | undefined} [timeout]
177
111
  * @returns {Promise<void>}
178
112
  */
179
- function waitForAnimation(condition) {
180
- return new Promise(async (resolve, dispose) => {
113
+ function waitForAnimation(condition, timeout) {
114
+ const success = new Promise(async (resolve, dispose) => {
181
115
  toTearDown.push({ dispose });
182
116
  do {
183
117
  await animationFrame();
184
118
  } while (!condition());
185
119
  resolve();
186
120
  });
121
+ if (timeout !== undefined) {
122
+ const timedOut = new Promise((_, fail) => {
123
+ const toClear = setTimeout(() => fail(new Error('Wait for animation timed out.')), timeout);
124
+ toTearDown.push({ dispose: () => (fail(new Error('Wait for animation timed out.')), clearTimeout(toClear)) });
125
+ });
126
+ return Promise.race([success, timedOut]);
127
+ }
128
+ return success;
187
129
  }
188
130
 
189
131
  /**
@@ -259,7 +201,7 @@ module.exports = (port, host, argv) => Promise.resolve()
259
201
  }
260
202
 
261
203
  it('document formatting should be visible and enabled', async function () {
262
- await openEditor(serverUri);
204
+ await openEditor(demoFileUri);
263
205
  const menu = menuFactory.createContextMenu(EDITOR_CONTEXT_MENU);
264
206
  const item = menu.items.find(i => i.command === 'editor.action.formatDocument');
265
207
  if (item) {
@@ -274,68 +216,57 @@ module.exports = (port, host, argv) => Promise.resolve()
274
216
  for (const preview of [false, true]) {
275
217
  const from = 'an editor' + (preview ? ' preview' : '');
276
218
  it('within ' + from, async function () {
277
- const editor = await openEditor(serverUri, preview);
278
- // con|tainer.load(backendApplicationModule);
279
- editor.getControl().setPosition({ lineNumber: 12, column: 4 });
280
- // @ts-ignore
281
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'container');
219
+ const editor = await openEditor(demoFileUri, preview);
220
+ // const demoInstance = new Demo|Class('demo');
221
+ editor.getControl().setPosition({ lineNumber: 24, column: 30 });
222
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DemoClass');
282
223
 
283
224
  await commands.executeCommand('editor.action.revealDefinition');
284
225
 
285
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
286
- // @ts-ignore
226
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
287
227
  assert.equal(editorManager.activeEditor.isPreview, preview);
288
- assert.equal(activeEditor.uri.toString(), serverUri.toString());
289
- // const |container = new Container();
290
- // @ts-ignore
228
+ assert.equal(activeEditor.uri.toString(), demoFileUri.toString());
229
+ // constructor(someString: string) {
291
230
  const { lineNumber, column } = activeEditor.getControl().getPosition();
292
- assert.deepEqual({ lineNumber, column }, { lineNumber: 11, column: 7 });
293
- // @ts-ignore
294
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'container');
231
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 11, column: 5 });
232
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'constructor');
295
233
  });
296
234
 
297
235
  it(`from ${from} to another editor`, async function () {
298
- await editorManager.open(inversifyUri, { mode: 'open' });
236
+ await editorManager.open(definitionFileUri, { mode: 'open' });
299
237
 
300
- const editor = await openEditor(serverUri, preview);
301
- // const { Cont|ainer } = require('inversify');
302
- editor.getControl().setPosition({ lineNumber: 5, column: 13 });
303
- // @ts-ignore
304
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'Container');
238
+ const editor = await openEditor(demoFileUri, preview);
239
+ // const bar: Defined|Interface = { coolField: [] };
240
+ editor.getControl().setPosition({ lineNumber: 32, column: 19 });
241
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DefinedInterface');
305
242
 
306
243
  await commands.executeCommand('editor.action.revealDefinition');
307
244
 
308
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
309
- // @ts-ignore
245
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
310
246
  assert.isFalse(editorManager.activeEditor.isPreview);
311
- assert.equal(activeEditor.uri.toString(), inversifyUri.toString());
312
- // export { |Container } from "./container/container";
313
- // @ts-ignore
247
+ assert.equal(activeEditor.uri.toString(), definitionFileUri.toString());
248
+
249
+ // export interface |DefinedInterface {
314
250
  const { lineNumber, column } = activeEditor.getControl().getPosition();
315
- assert.deepEqual({ lineNumber, column }, { lineNumber: 3, column: 10 });
316
- // @ts-ignore
317
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'Container');
251
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 2, column: 18 });
252
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'DefinedInterface');
318
253
  });
319
254
 
320
255
  it(`from ${from} to an editor preview`, async function () {
321
- const editor = await openEditor(serverUri);
322
- // const { Cont|ainer } = require('inversify');
323
- editor.getControl().setPosition({ lineNumber: 5, column: 13 });
324
- // @ts-ignore
325
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'Container');
256
+ const editor = await openEditor(demoFileUri);
257
+ // const bar: Defined|Interface = { coolField: [] };
258
+ editor.getControl().setPosition({ lineNumber: 32, column: 19 });
259
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DefinedInterface');
326
260
 
327
261
  await commands.executeCommand('editor.action.revealDefinition');
328
262
 
329
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
330
- // @ts-ignore
263
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
331
264
  assert.isTrue(editorManager.activeEditor.isPreview);
332
- assert.equal(activeEditor.uri.toString(), inversifyUri.toString());
333
- // export { |Container } from "./container/container";
334
- // @ts-ignore
265
+ assert.equal(activeEditor.uri.toString(), definitionFileUri.toString());
266
+ // export interface |DefinedInterface {
335
267
  const { lineNumber, column } = activeEditor.getControl().getPosition();
336
- assert.deepEqual({ lineNumber, column }, { lineNumber: 3, column: 10 });
337
- // @ts-ignore
338
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'Container');
268
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 2, column: 18 });
269
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'DefinedInterface');
339
270
  });
340
271
  }
341
272
  });
@@ -345,75 +276,63 @@ module.exports = (port, host, argv) => Promise.resolve()
345
276
  for (const preview of [false, true]) {
346
277
  const from = 'an editor' + (preview ? ' preview' : '');
347
278
  it('within ' + from, async function () {
348
- const editor = await openEditor(serverUri, preview);
349
- // con|tainer.load(backendApplicationModule);
350
- editor.getControl().setPosition({ lineNumber: 12, column: 4 });
351
- // @ts-ignore
352
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'container');
279
+ const editor = await openEditor(demoFileUri, preview);
280
+ // const demoInstance = new Demo|Class('demo');
281
+ editor.getControl().setPosition({ lineNumber: 24, column: 30 });
282
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DemoClass');
353
283
 
354
284
  await openPeek(editor);
355
285
  await openReference();
356
286
 
357
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
358
- // @ts-ignore
287
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
359
288
  assert.equal(editorManager.activeEditor.isPreview, preview);
360
- assert.equal(activeEditor.uri.toString(), serverUri.toString());
361
- // const |container = new Container();
362
- // @ts-ignore
289
+ assert.equal(activeEditor.uri.toString(), demoFileUri.toString());
290
+ // constructor(someString: string) {
363
291
  const { lineNumber, column } = activeEditor.getControl().getPosition();
364
- assert.deepEqual({ lineNumber, column }, { lineNumber: 11, column: 7 });
365
- // @ts-ignore
366
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'container');
292
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 11, column: 5 });
293
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'constructor');
367
294
 
368
295
  await closePeek(activeEditor);
369
296
  });
370
297
 
371
298
  it(`from ${from} to another editor`, async function () {
372
- await editorManager.open(inversifyUri, { mode: 'open' });
299
+ await editorManager.open(definitionFileUri, { mode: 'open' });
373
300
 
374
- const editor = await openEditor(serverUri, preview);
375
- // const { Cont|ainer } = require('inversify');
376
- editor.getControl().setPosition({ lineNumber: 5, column: 13 });
377
- // @ts-ignore
378
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'Container');
301
+ const editor = await openEditor(demoFileUri, preview);
302
+ // const bar: Defined|Interface = { coolField: [] };
303
+ editor.getControl().setPosition({ lineNumber: 32, column: 19 });
304
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DefinedInterface');
379
305
 
380
306
  await openPeek(editor);
381
307
  await openReference();
382
308
 
383
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
384
- // @ts-ignore
309
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
385
310
  assert.isFalse(editorManager.activeEditor.isPreview);
386
- assert.equal(activeEditor.uri.toString(), inversifyUri.toString());
387
- // export { |Container } from "./container/container";
388
- // @ts-ignore
311
+ assert.equal(activeEditor.uri.toString(), definitionFileUri.toString());
312
+ // export interface |DefinedInterface {
389
313
  const { lineNumber, column } = activeEditor.getControl().getPosition();
390
- assert.deepEqual({ lineNumber, column }, { lineNumber: 3, column: 10 });
391
- // @ts-ignore
392
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'Container');
314
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 2, column: 18 });
315
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'DefinedInterface');
393
316
 
394
317
  await closePeek(activeEditor);
395
318
  });
396
319
 
397
320
  it(`from ${from} to an editor preview`, async function () {
398
- const editor = await openEditor(serverUri);
399
- // const { Cont|ainer } = require('inversify');
400
- editor.getControl().setPosition({ lineNumber: 5, column: 13 });
401
- // @ts-ignore
402
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'Container');
321
+ const editor = await openEditor(demoFileUri);
322
+ // const bar: Defined|Interface = { coolField: [] };
323
+ editor.getControl().setPosition({ lineNumber: 32, column: 19 });
324
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DefinedInterface');
403
325
 
404
326
  await openPeek(editor);
405
327
  await openReference();
406
328
 
407
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
408
- // @ts-ignore
329
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
409
330
  assert.isTrue(editorManager.activeEditor.isPreview);
410
- assert.equal(activeEditor.uri.toString(), inversifyUri.toString());
411
- // export { |Container } from "./container/container";
412
- // @ts-ignore
331
+ assert.equal(activeEditor.uri.toString(), definitionFileUri.toString());
332
+ // export interface |DefinedInterface {
413
333
  const { lineNumber, column } = activeEditor.getControl().getPosition();
414
- assert.deepEqual({ lineNumber, column }, { lineNumber: 3, column: 10 });
415
- // @ts-ignore
416
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'Container');
334
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 2, column: 18 });
335
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'DefinedInterface');
417
336
 
418
337
  await closePeek(activeEditor);
419
338
  });
@@ -421,12 +340,11 @@ module.exports = (port, host, argv) => Promise.resolve()
421
340
  });
422
341
 
423
342
  it('editor.action.triggerSuggest', async function () {
424
- const editor = await openEditor(serverUri);
425
- // const { [|Container] } = require('inversify');
426
- editor.getControl().setPosition({ lineNumber: 5, column: 9 });
427
- editor.getControl().setSelection({ startLineNumber: 5, startColumn: 9, endLineNumber: 5, endColumn: 18 });
428
- // @ts-ignore
429
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'Container');
343
+ const editor = await openEditor(demoFileUri);
344
+ // const demoVariable = demoInstance.[stringField];
345
+ editor.getControl().setPosition({ lineNumber: 26, column: 46 });
346
+ editor.getControl().setSelection(new Selection(26, 46, 26, 35));
347
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'stringField');
430
348
 
431
349
  assert.isTrue(contextKeyService.match('editorTextFocus'));
432
350
  assert.isFalse(contextKeyService.match('suggestWidgetVisible'));
@@ -443,25 +361,22 @@ module.exports = (port, host, argv) => Promise.resolve()
443
361
  assert.isTrue(contextKeyService.match('editorTextFocus'));
444
362
  assert.isFalse(contextKeyService.match('suggestWidgetVisible'));
445
363
 
446
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
447
- assert.equal(activeEditor.uri.toString(), serverUri.toString());
448
- // const { Container| } = require('inversify');
449
- // @ts-ignore
364
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
365
+ assert.equal(activeEditor.uri.toString(), demoFileUri.toString());
366
+ // demoInstance.stringField;
450
367
  const { lineNumber, column } = activeEditor.getControl().getPosition();
451
- assert.deepEqual({ lineNumber, column }, { lineNumber: 5, column: 18 });
452
- // @ts-ignore
453
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'Container');
368
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 26, column: 46 });
369
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'doSomething');
454
370
  });
455
371
 
456
372
  it('editor.action.triggerSuggest navigate', async function () {
457
- const editor = await openEditor(serverUri);
458
- // const { [|Container] } = require('inversify');
459
- editor.getControl().setPosition({ lineNumber: 5, column: 9 });
460
- editor.getControl().setSelection({ startLineNumber: 5, startColumn: 9, endLineNumber: 5, endColumn: 18 });
461
- // @ts-ignore
462
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'Container');
373
+ const editor = await openEditor(demoFileUri);
374
+ // demoInstance.[|stringField];
375
+ editor.getControl().setPosition({ lineNumber: 26, column: 46 });
376
+ editor.getControl().setSelection(new Selection(26, 46, 26, 35));
377
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'stringField');
463
378
 
464
- /** @type any */
379
+ /** @type {import('@theia/monaco-editor-core/src/vs/editor/contrib/suggest/browser/suggestController').SuggestController} */
465
380
  const suggest = editor.getControl().getContribution('editor.contrib.suggestController');
466
381
  const getFocusedLabel = () => {
467
382
  const focusedItem = suggest.widget.value.getFocusedItem();
@@ -472,36 +387,35 @@ module.exports = (port, host, argv) => Promise.resolve()
472
387
  assert.isFalse(contextKeyService.match('suggestWidgetVisible'));
473
388
 
474
389
  await commands.executeCommand('editor.action.triggerSuggest');
475
- await waitForAnimation(() => contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === 'Container');
390
+ await waitForAnimation(() => contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === 'doSomething', 5000);
476
391
 
477
- assert.equal(getFocusedLabel(), 'Container');
392
+ assert.equal(getFocusedLabel(), 'doSomething');
478
393
  assert.isTrue(contextKeyService.match('suggestWidgetVisible'));
479
394
 
480
395
  keybindings.dispatchKeyDown('ArrowDown');
481
- await waitForAnimation(() => contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === 'ContainerModule');
396
+ await waitForAnimation(() => contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === 'numberField', 2000);
482
397
 
483
- assert.equal(getFocusedLabel(), 'ContainerModule');
398
+ assert.equal(getFocusedLabel(), 'numberField');
484
399
  assert.isTrue(contextKeyService.match('suggestWidgetVisible'));
485
400
 
486
401
  keybindings.dispatchKeyDown('ArrowUp');
487
- await waitForAnimation(() => contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === 'Container');
402
+ await waitForAnimation(() => contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === 'doSomething', 2000);
488
403
 
489
- assert.equal(getFocusedLabel(), 'Container');
404
+ assert.equal(getFocusedLabel(), 'doSomething');
490
405
  assert.isTrue(contextKeyService.match('suggestWidgetVisible'));
491
406
 
492
407
  keybindings.dispatchKeyDown('Escape');
493
- await waitForAnimation(() => !contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === undefined);
408
+ await waitForAnimation(() => !contextKeyService.match('suggestWidgetVisible') && getFocusedLabel() === undefined, 5000);
494
409
 
495
410
  assert.isUndefined(getFocusedLabel());
496
411
  assert.isFalse(contextKeyService.match('suggestWidgetVisible'));
497
412
  });
498
413
 
499
414
  it('editor.action.rename', async function () {
500
- const editor = await openEditor(serverUri);
501
- // const |container = new Container();
502
- editor.getControl().setPosition({ lineNumber: 11, column: 7 });
503
- // @ts-ignore
504
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'container');
415
+ const editor = await openEditor(demoFileUri);
416
+ // const |demoVariable = demoInstance.stringField;
417
+ editor.getControl().setPosition({ lineNumber: 26, column: 7 });
418
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'demoVariable');
505
419
 
506
420
  assert.isTrue(contextKeyService.match('editorTextFocus'));
507
421
  assert.isFalse(contextKeyService.match('renameInputVisible'));
@@ -509,7 +423,7 @@ module.exports = (port, host, argv) => Promise.resolve()
509
423
  commands.executeCommand('editor.action.rename');
510
424
  await waitForAnimation(() => contextKeyService.match('renameInputVisible')
511
425
  && document.activeElement instanceof HTMLInputElement
512
- && document.activeElement.selectionEnd === 'container'.length);
426
+ && document.activeElement.selectionEnd === 'demoVariable'.length);
513
427
  assert.isFalse(contextKeyService.match('editorTextFocus'));
514
428
  assert.isTrue(contextKeyService.match('renameInputVisible'));
515
429
 
@@ -523,29 +437,24 @@ module.exports = (port, host, argv) => Promise.resolve()
523
437
  keybindings.dispatchKeyDown('Enter', input);
524
438
 
525
439
  // all rename edits should be grouped in one edit operation and applied in the same tick
526
- const waitForApplyRenameEdits = new Deferred();
527
- editor.getControl().onDidChangeModelContent(() => waitForApplyRenameEdits.resolve());
528
- await waitForApplyRenameEdits.promise;
440
+ await new Promise(resolve => editor.getControl().onDidChangeModelContent(resolve));
529
441
 
530
442
  assert.isTrue(contextKeyService.match('editorTextFocus'));
531
443
  assert.isFalse(contextKeyService.match('renameInputVisible'));
532
444
 
533
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
534
- assert.equal(activeEditor.uri.toString(), serverUri.toString());
445
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
446
+ assert.equal(activeEditor.uri.toString(), demoFileUri.toString());
535
447
  // const |foo = new Container();
536
- // @ts-ignore
537
448
  const { lineNumber, column } = activeEditor.getControl().getPosition();
538
- assert.deepEqual({ lineNumber, column }, { lineNumber: 11, column: 7 });
539
- // @ts-ignore
540
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'foo');
449
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 26, column: 7 });
450
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber: 28, column: 1 }).word, 'foo');
541
451
  });
542
452
 
543
453
  it('editor.action.triggerParameterHints', async function () {
544
- const editor = await openEditor(serverUri);
545
- // container.load(|backendApplicationModule);
546
- editor.getControl().setPosition({ lineNumber: 12, column: 16 });
547
- // @ts-ignore
548
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'backendApplicationModule');
454
+ const editor = await openEditor(demoFileUri);
455
+ // const demoInstance = new DemoClass('|demo');
456
+ editor.getControl().setPosition({ lineNumber: 24, column: 37 });
457
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, "demo");
549
458
 
550
459
  assert.isTrue(contextKeyService.match('editorTextFocus'));
551
460
  assert.isFalse(contextKeyService.match('parameterHintsVisible'));
@@ -564,25 +473,22 @@ module.exports = (port, host, argv) => Promise.resolve()
564
473
  });
565
474
 
566
475
  it('editor.action.showHover', async function () {
567
- const editor = await openEditor(serverUri);
568
- // container.load(|backendApplicationModule);
569
- editor.getControl().setPosition({ lineNumber: 12, column: 16 });
570
- // @ts-ignore
571
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'backendApplicationModule');
476
+ const editor = await openEditor(demoFileUri);
477
+ // class |DemoClass);
478
+ editor.getControl().setPosition({ lineNumber: 8, column: 7 });
479
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DemoClass');
572
480
 
573
- /** @type any */
481
+ /** @type {import('@theia/monaco-editor-core/src/vs/editor/contrib/hover/browser/hover').ModesHoverController} */
574
482
  const hover = editor.getControl().getContribution('editor.contrib.hover');
575
483
 
576
484
  assert.isTrue(contextKeyService.match('editorTextFocus'));
577
- assert.isFalse(!!hover._contentWidget && hover._contentWidget._isVisible);
578
-
485
+ assert.isFalse(Boolean(hover['_contentWidget']?.['_widget']?.['_visibleData']));
579
486
  await commands.executeCommand('editor.action.showHover');
580
- await waitForAnimation(() => !!hover._contentWidget && hover._contentWidget._isVisible);
581
-
487
+ let doLog = true;
488
+ await waitForAnimation(() => hover['_contentWidget']?.['_widget']?.['_visibleData']);
582
489
  assert.isTrue(contextKeyService.match('editorTextFocus'));
583
- assert.isTrue(!!hover._contentWidget && hover._contentWidget._isVisible);
584
-
585
- assert.deepEqual(hover._contentWidget && nodeAsString(hover._contentWidget._hover.contentsDomNode), `
490
+ assert.isTrue(Boolean(hover['_contentWidget']?.['_widget']?.['_visibleData']));
491
+ assert.deepEqual(nodeAsString(hover['_contentWidget']?.['_widget']?.['_hover']?.['contentsDomNode']).trim(), `
586
492
  DIV {
587
493
  DIV {
588
494
  DIV {
@@ -591,19 +497,13 @@ DIV {
591
497
  SPAN {
592
498
  DIV {
593
499
  SPAN {
594
- "const"
500
+ "class"
595
501
  }
596
502
  SPAN {
597
503
  " "
598
504
  }
599
505
  SPAN {
600
- "backendApplicationModule"
601
- }
602
- SPAN {
603
- ": "
604
- }
605
- SPAN {
606
- "ContainerModule"
506
+ "DemoClass"
607
507
  }
608
508
  }
609
509
  }
@@ -611,25 +511,21 @@ DIV {
611
511
  }
612
512
  }
613
513
  }
614
- }
615
- `);
616
-
514
+ }`.trim());
617
515
  keybindings.dispatchKeyDown('Escape');
618
- await waitForAnimation(() => !hover._contentWidget || !hover._contentWidget._isVisible);
619
-
516
+ await waitForAnimation(() => !hover['_contentWidget']?.['_widget']?.['_visibleData']);
620
517
  assert.isTrue(contextKeyService.match('editorTextFocus'));
621
- assert.isFalse(!!hover._contentWidget && hover._contentWidget._isVisible);
518
+ assert.isFalse(Boolean(hover['_contentWidget']?.['_widget']?.['_visibleData']));
622
519
  });
623
520
 
624
- it('highligh semantic (write) occurrences', async function () {
625
- const editor = await openEditor(serverUri);
521
+ it('highlight semantic (write) occurrences', async function () {
522
+ const editor = await openEditor(demoFileUri);
626
523
  // const |container = new Container();
627
- const lineNumber = 11;
524
+ const lineNumber = 24;
628
525
  const column = 7;
629
- const endColumn = column + 'container'.length;
526
+ const endColumn = column + 'demoInstance'.length;
630
527
 
631
528
  const hasWriteDecoration = () => {
632
- // @ts-ignore
633
529
  for (const decoration of editor.getControl().getModel().getLineDecorations(lineNumber)) {
634
530
  if (decoration.range.startColumn === column && decoration.range.endColumn === endColumn && decoration.options.className === 'wordHighlightStrong') {
635
531
  return true;
@@ -640,8 +536,7 @@ DIV {
640
536
  assert.isFalse(hasWriteDecoration());
641
537
 
642
538
  editor.getControl().setPosition({ lineNumber, column });
643
- // @ts-ignore
644
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'container');
539
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'demoInstance');
645
540
  // highlight occurrences is not trigged on the explicit position change, so move a cursor as a user
646
541
  keybindings.dispatchKeyDown('ArrowRight');
647
542
  await waitForAnimation(() => hasWriteDecoration());
@@ -650,55 +545,48 @@ DIV {
650
545
  });
651
546
 
652
547
  it('editor.action.goToImplementation', async function () {
653
- const editor = await openEditor(serverUri);
654
- // con|tainer.load(backendApplicationModule);
655
- editor.getControl().setPosition({ lineNumber: 12, column: 4 });
656
- // @ts-ignore
657
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'container');
548
+ const editor = await openEditor(demoFileUri);
549
+ // const demoInstance = new Demo|Class('demo');
550
+ editor.getControl().setPosition({ lineNumber: 24, column: 30 });
551
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'DemoClass');
658
552
 
659
553
  await commands.executeCommand('editor.action.goToImplementation');
660
554
 
661
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
662
- assert.equal(activeEditor.uri.toString(), serverUri.toString());
663
- // const |container = new Container();
664
- // @ts-ignore
555
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
556
+ assert.equal(activeEditor.uri.toString(), demoFileUri.toString());
557
+ // class |DemoClass implements DemoInterface {
665
558
  const { lineNumber, column } = activeEditor.getControl().getPosition();
666
- assert.deepEqual({ lineNumber, column }, { lineNumber: 11, column: 7 });
667
- // @ts-ignore
668
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'container');
559
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 8, column: 7 });
560
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'DemoClass');
669
561
  });
670
562
 
671
563
  it('editor.action.goToTypeDefinition', async function () {
672
- const editor = await openEditor(serverUri);
673
- // con|tainer.load(backendApplicationModule);
674
- editor.getControl().setPosition({ lineNumber: 12, column: 4 });
675
- // @ts-ignore
676
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'container');
564
+ const editor = await openEditor(demoFileUri);
565
+ // const demoVariable = demo|Instance.stringField;
566
+ editor.getControl().setPosition({ lineNumber: 26, column: 26 });
567
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'demoInstance');
677
568
 
678
569
  await commands.executeCommand('editor.action.goToTypeDefinition');
679
570
 
680
- const activeEditor = /** @type {MonacoEditor} */ (MonacoEditor.get(editorManager.activeEditor));
681
- assert.equal(activeEditor.uri.toString(), containerUri.toString());
682
- // declare class |Container implements interfaces.Container {
683
- // @ts-ignore
571
+ const activeEditor = /** @type {MonacoEditor} */ MonacoEditor.get(editorManager.activeEditor);
572
+ assert.equal(activeEditor.uri.toString(), demoFileUri.toString());
573
+ // class |DemoClass implements DemoInterface {
684
574
  const { lineNumber, column } = activeEditor.getControl().getPosition();
685
- assert.deepEqual({ lineNumber, column }, { lineNumber: 2, column: 15 });
686
- // @ts-ignore
687
- assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'Container');
575
+ assert.deepEqual({ lineNumber, column }, { lineNumber: 8, column: 7 });
576
+ assert.equal(activeEditor.getControl().getModel().getWordAtPosition({ lineNumber, column }).word, 'DemoClass');
688
577
  });
689
578
 
690
- // TODO: FIXME! As of 28/01/2022 this test is failing or timing out for unknown reasons.
691
- it.skip('run reference code lens', async function () {
692
- this.timeout(300_000); // 5 min (give time to `tsserver` to initialize and then respond to make this test pass.)
693
- // @ts-ignore
694
- const globalValue = preferences.inspect('javascript.referencesCodeLens.enabled').globalValue;
695
- toTearDown.push({ dispose: () => preferences.set('javascript.referencesCodeLens.enabled', globalValue, PreferenceScope.User) });
579
+ it('run reference code lens', async function () {
580
+ const preferenceName = 'typescript.referencesCodeLens.enabled';
581
+ const globalValue = preferences.inspect(preferenceName).globalValue;
582
+ toTearDown.push({ dispose: () => preferences.set(preferenceName, globalValue, PreferenceScope.User) });
583
+ await preferences.set(preferenceName, false, PreferenceScope.User);
696
584
 
697
- const editor = await openEditor(serverUri);
585
+ const editor = await openEditor(demoFileUri);
698
586
 
699
- /** @type any */
587
+ /** @type {import('@theia/monaco-editor-core/src/vs/editor/contrib/codelens/browser/codelensController').CodeLensContribution} */
700
588
  const codeLens = editor.getControl().getContribution('css.editor.codeLens');
701
- const codeLensNode = () => codeLens._lenses[0] && codeLens._lenses[0]._contentWidget && codeLens._lenses[0]._contentWidget._domNode;
589
+ const codeLensNode = () => codeLens['_lenses'][0]?.['_contentWidget']?.['_domNode'];
702
590
  const codeLensNodeVisible = () => {
703
591
  const n = codeLensNode();
704
592
  return !!n && n.style.visibility !== 'hidden';
@@ -706,77 +594,57 @@ DIV {
706
594
 
707
595
  assert.isFalse(codeLensNodeVisible());
708
596
 
709
- // [export ]function load(raw) {
710
- const position = { lineNumber: 16, column: 1 };
711
- // @ts-ignore
712
- editor.getControl().getModel().applyEdits([{
713
- range: Range.fromPositions(position, position),
714
- forceMoveMarkers: false,
715
- text: 'export '
716
- }]);
717
- await preferences.set('javascript.referencesCodeLens.enabled', true, PreferenceScope.User);
718
-
719
- // Recall `applyEdits` to workaround `vscode` bug, See: https://github.com/eclipse-theia/theia/issues/9714#issuecomment-876582947.
720
- // @ts-ignore
721
- editor.getControl().getModel().applyEdits([{
722
- range: Range.fromPositions(position, position),
723
- forceMoveMarkers: false,
724
- text: ' '
725
- }]);
597
+ // |interface DemoInterface {
598
+ const position = { lineNumber: 2, column: 1 };
599
+ await preferences.set(preferenceName, true, PreferenceScope.User);
726
600
 
727
601
  editor.getControl().revealPosition(position);
728
602
  await waitForAnimation(() => codeLensNodeVisible());
729
603
 
730
604
  assert.isTrue(codeLensNodeVisible());
731
605
  const node = codeLensNode();
732
- if (node) {
733
- assert.equal(nodeAsString(node), `
606
+ assert.isDefined(node);
607
+ assert.equal(nodeAsString(node), `
734
608
  SPAN {
735
609
  A {
736
- "20 references"
610
+ "1 reference"
737
611
  }
738
612
  }
739
613
  `);
740
- const link = node.getElementsByTagName('a').item(0);
741
- if (link) {
742
- link.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
743
- await assertPeekOpened(editor);
744
- await closePeek(editor);
745
- } else {
746
- assert.isDefined(link);
747
- }
748
- } else {
749
- assert.isDefined(node);
750
- }
614
+ const link = node.getElementsByTagName('a').item(0);
615
+ assert.isDefined(link);
616
+ link.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
617
+ await assertPeekOpened(editor);
618
+ await closePeek(editor);
751
619
  });
752
620
 
753
621
  it('editor.action.quickFix', async function () {
754
- const column = 29;
755
- const lineNumber = 18;
756
- const editor = await openEditor(serverUri);
622
+ const column = 45;
623
+ const lineNumber = 26;
624
+ const editor = await openEditor(demoFileUri);
757
625
  const currentChar = () => editor.getControl().getModel().getLineContent(lineNumber).charAt(column - 1);
758
626
 
759
- // container.load(module)
627
+ // const demoVariable = demoInstance.stringField; --> const demoVariable = demoInstance.stringFiel;
760
628
  editor.getControl().getModel().applyEdits([{
761
629
  range: {
762
630
  startLineNumber: lineNumber,
763
631
  endLineNumber: lineNumber,
764
- startColumn: 29,
765
- endColumn: 30
632
+ startColumn: 45,
633
+ endColumn: 46
766
634
  },
767
635
  forceMoveMarkers: false,
768
636
  text: ''
769
637
  }]);
770
638
  editor.getControl().setPosition({ lineNumber, column });
771
639
  editor.getControl().revealPosition({ lineNumber, column });
772
- assert.equal(currentChar(), ')');
640
+ assert.equal(currentChar(), ';');
773
641
 
774
- /** @type any */
642
+ /** @type {import('@theia/monaco-editor-core/src/vs/editor/contrib/codeAction/browser/codeActionCommands').QuickFixController} */
775
643
  const quickFixController = editor.getControl().getContribution('editor.contrib.quickFixController');
776
644
  const lightBulbNode = () => {
777
- const ui = quickFixController._ui.rawValue;
778
- const lightBulb = ui && ui._lightBulbWidget.rawValue;
779
- return lightBulb && lightBulb._domNode;
645
+ const ui = quickFixController['_ui'].rawValue;
646
+ const lightBulb = ui && ui['_lightBulbWidget'].rawValue;
647
+ return lightBulb && lightBulb['_domNode'];
780
648
  };
781
649
  const lightBulbVisible = () => {
782
650
  const node = lightBulbNode();
@@ -787,14 +655,14 @@ SPAN {
787
655
  await waitForAnimation(() => lightBulbVisible());
788
656
 
789
657
  await commands.executeCommand('editor.action.quickFix');
790
- await waitForAnimation(() => !!document.querySelector('.p-Widget.p-Menu'));
658
+ await waitForAnimation(() => !!document.querySelector('.p-Widget.p-Menu'), 5000);
791
659
  await animationFrame();
792
660
 
793
661
  keybindings.dispatchKeyDown('ArrowDown');
794
662
  keybindings.dispatchKeyDown('Enter');
795
663
 
796
- await waitForAnimation(() => currentChar() === 'e');
797
- assert.equal(currentChar(), 'e');
664
+ await waitForAnimation(() => currentChar() === 'd', 5000);
665
+ assert.equal(currentChar(), 'd');
798
666
 
799
667
  await waitForAnimation(() => !lightBulbVisible());
800
668
  assert.isFalse(lightBulbVisible());
@@ -802,76 +670,63 @@ SPAN {
802
670
 
803
671
  it('editor.action.formatDocument', async function () {
804
672
  const lineNumber = 5;
805
- const editor = await openEditor(serverUri);
806
- // @ts-ignore
673
+ const editor = await openEditor(demoFileUri);
807
674
  const originalLength = editor.getControl().getModel().getLineLength(lineNumber);
808
675
 
809
- // const { Container[ ] } = require('inversify');
810
- // @ts-ignore
676
+ // doSomething(): number; --> doSomething() : number;
811
677
  editor.getControl().getModel().applyEdits([{
812
678
  range: Range.fromPositions({ lineNumber, column: 18 }, { lineNumber, column: 18 }),
813
679
  forceMoveMarkers: false,
814
680
  text: ' '
815
681
  }]);
816
682
 
817
- // @ts-ignore
818
683
  assert.equal(editor.getControl().getModel().getLineLength(lineNumber), originalLength + 1);
819
684
 
820
685
  await commands.executeCommand('editor.action.formatDocument');
821
686
 
822
- // @ts-ignore
823
687
  assert.equal(editor.getControl().getModel().getLineLength(lineNumber), originalLength);
824
688
  });
825
689
 
826
690
  it('editor.action.formatSelection', async function () {
827
- const lineNumber = 5;
828
- const editor = await openEditor(serverUri);
829
- // @ts-ignore
830
- const originalLength = editor.getControl().getModel().getLineLength(lineNumber);
691
+ // doSomething(): number {
692
+ const lineNumber = 15;
693
+ const editor = await openEditor(demoFileUri);
694
+ const originalLength /* 28 */ = editor.getControl().getModel().getLineLength(lineNumber);
831
695
 
832
- // const { Container[ } ]= require('inversify');
833
- // @ts-ignore
696
+ // doSomething( ) : number {
834
697
  editor.getControl().getModel().applyEdits([{
835
- range: Range.fromPositions({ lineNumber, column: 18 }, { lineNumber, column: 21 }),
698
+ range: Range.fromPositions({ lineNumber, column: 17 }, { lineNumber, column: 18 }),
836
699
  forceMoveMarkers: false,
837
- text: ' } '
700
+ text: ' ) '
838
701
  }]);
839
702
 
840
- // @ts-ignore
841
- assert.equal(editor.getControl().getModel().getLineLength(lineNumber), originalLength + 2);
703
+ assert.equal(editor.getControl().getModel().getLineLength(lineNumber), originalLength + 4);
842
704
 
843
705
  // [const { Container }] = require('inversify');
844
- editor.getControl().setSelection({ startLineNumber: lineNumber, startColumn: 1, endLineNumber: lineNumber, endColumn: 21 });
706
+ editor.getControl().setSelection({ startLineNumber: lineNumber, startColumn: 1, endLineNumber: lineNumber, endColumn: 32 });
845
707
 
846
708
  await commands.executeCommand('editor.action.formatSelection');
847
709
 
848
710
  // [const { Container }] = require('inversify');
849
- // @ts-ignore
850
- assert.equal(editor.getControl().getModel().getLineLength(lineNumber), originalLength + 1);
711
+ assert.equal(editor.getControl().getModel().getLineLength(lineNumber), originalLength);
851
712
  });
852
713
 
853
714
  for (const referenceViewCommand of ['references-view.find', 'references-view.findImplementations']) {
854
715
  it(referenceViewCommand, async function () {
855
- const editor = await openEditor(serverUri);
856
- // const |container = new Container();
857
- editor.getControl().setPosition({ lineNumber: 11, column: 7 });
858
- // @ts-ignore
859
- assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'container');
860
-
861
- const view = await pluginViewRegistry.openView('references-view.tree');
862
- if (!view) {
863
- assert.isDefined(view);
864
- return;
865
- }
866
-
716
+ let steps = 0;
717
+ const editor = await openEditor(demoFileUri);
718
+ // const demo|Instance = new DemoClass('demo');
719
+ editor.getControl().setPosition({ lineNumber: 24, column: 11 });
720
+ assert.equal(editor.getControl().getModel().getWordAtPosition(editor.getControl().getPosition()).word, 'demoInstance');
721
+ const view = await pluginViewRegistry.openView('references-view.tree', { reveal: true });
722
+ assert.isDefined(view);
723
+ assert.isTrue(view.isVisible);
867
724
  await commands.executeCommand('references-view.clear');
868
- await waitForAnimation(() => view.title.label.toLowerCase() === 'results');
869
- assert.equal(view.title.label.toLowerCase(), 'results');
870
-
725
+ const expectedMessage = referenceViewCommand === 'references-view.find' ? '2 results in 1 file' : '1 result in 1 file';
726
+ const getResultText = () => view.node.getElementsByClassName('theia-TreeViewInfo').item(0)?.textContent;
871
727
  await commands.executeCommand(referenceViewCommand);
872
-
873
- await waitForAnimation(() => view.title.label.toLowerCase() !== 'results');
874
- assert.notEqual(view.title.label.toLowerCase(), 'results');
728
+ await waitForAnimation(() => getResultText() === expectedMessage, 5000);
729
+ assert.equal(getResultText(), expectedMessage);
875
730
  });
876
731
  }
877
732
 
package/src/undo-redo-selectAll.spec.js CHANGED
@@ -31,7 +31,8 @@ describe('Undo, Redo and Select All', function () {
31
31
  const { ApplicationShell } = require('@theia/core/lib/browser/shell/application-shell');
32
32
  const { MonacoEditor } = require('@theia/monaco/lib/browser/monaco-editor');
33
33
  const { ScmContribution } = require('@theia/scm/lib/browser/scm-contribution');
34
- const { Range } = require('@theia/monaco-editor-core');
34
+ const { Range } = require('@theia/monaco-editor-core/esm/vs/editor/common/core/range');
35
+ const { PreferenceService, PreferenceScope } = require('@theia/core/lib/browser');
35
36
 
36
37
  const container = window.theia.container;
37
38
  const editorManager = container.get(EditorManager);
@@ -41,6 +42,8 @@ describe('Undo, Redo and Select All', function () {
41
42
  const navigatorContribution = container.get(FileNavigatorContribution);
42
43
  const shell = container.get(ApplicationShell);
43
44
  const scmContribution = container.get(ScmContribution);
45
+ /** @type {PreferenceService} */
46
+ const preferenceService = container.get(PreferenceService)
44
47
 
45
48
  const rootUri = workspaceService.tryGetRoots()[0].resource;
46
49
  const fileUri = rootUri.resolve('webpack.config.js');
@@ -61,8 +64,10 @@ describe('Undo, Redo and Select All', function () {
61
64
  resolve(undefined);
62
65
  });
63
66
  }
64
-
65
- before(() => {
67
+ let originalValue = undefined;
68
+ before(async () => {
69
+ originalValue = preferenceService.inspect('files.autoSave').globalValue;
70
+ await preferenceService.set('files.autoSave', false, PreferenceScope.User);
66
71
  shell.leftPanelHandler.collapse();
67
72
  });
68
73
 
@@ -79,7 +84,8 @@ describe('Undo, Redo and Select All', function () {
79
84
  await editorManager.closeAll({ save: false });
80
85
  });
81
86
 
82
- after(() => {
87
+ after(async () => {
88
+ await preferenceService.set('files.autoSave', originalValue, PreferenceScope.User);
83
89
  shell.leftPanelHandler.collapse();
84
90
  });
85
91