@codingame/monaco-vscode-api 2.1.3 → 2.2.0-next.1

package/vscode/src/vs/workbench/services/activity/browser/activityService.js

@@ -0,0 +1,143 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IActivityService } from '../common/activity.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { IViewDescriptorService } from '../../../common/views.js';
+import { ACCOUNTS_ACTIVITY_ID, GLOBAL_ACTIVITY_ID } from '../../../common/activity.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { isUndefined } from '../../../../base/common/types.js';
+let ViewContainerActivityByView = class ViewContainerActivityByView extends Disposable {
+    constructor(viewId, viewDescriptorService, activityService) {
+        super();
+        this.viewId = viewId;
+        this.viewDescriptorService = viewDescriptorService;
+        this.activityService = activityService;
+        this.activity = undefined;
+        this.activityDisposable = Disposable.None;
+        this._register(Event.filter(this.viewDescriptorService.onDidChangeContainer, e => ( e.views.some(view => view.id === viewId)))(() => this.update()));
+        this._register(Event.filter(this.viewDescriptorService.onDidChangeLocation, e => ( e.views.some(view => view.id === viewId)))(() => this.update()));
+    }
+    setActivity(activity) {
+        this.activity = activity;
+        this.update();
+    }
+    clearActivity() {
+        this.activity = undefined;
+        this.update();
+    }
+    update() {
+        this.activityDisposable.dispose();
+        const container = this.viewDescriptorService.getViewContainerByViewId(this.viewId);
+        if (container && this.activity) {
+            this.activityDisposable = this.activityService.showViewContainerActivity(container.id, this.activity);
+        }
+    }
+    dispose() {
+        this.activityDisposable.dispose();
+        super.dispose();
+    }
+};
+ViewContainerActivityByView = ( __decorate([
+    ( __param(1, IViewDescriptorService)),
+    ( __param(2, IActivityService))
+], ViewContainerActivityByView));
+let ActivityService = class ActivityService extends Disposable {
+    constructor(viewDescriptorService, instantiationService) {
+        super();
+        this.viewDescriptorService = viewDescriptorService;
+        this.instantiationService = instantiationService;
+        this.viewActivities = ( new Map());
+        this._onDidChangeActivity = this._register(( new Emitter()));
+        this.onDidChangeActivity = this._onDidChangeActivity.event;
+        this.viewContainerActivities = ( new Map());
+        this.globalActivities = ( new Map());
+    }
+    showViewContainerActivity(viewContainerId, activity) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(viewContainerId);
+        if (viewContainer) {
+            let activities = this.viewContainerActivities.get(viewContainerId);
+            if (!activities) {
+                activities = [];
+                this.viewContainerActivities.set(viewContainerId, activities);
+            }
+            for (let i = 0; i <= activities.length; i++) {
+                if (i === activities.length || isUndefined(activity.priority)) {
+                    activities.push(activity);
+                    break;
+                }
+                else if (isUndefined(activities[i].priority) || activities[i].priority <= activity.priority) {
+                    activities.splice(i, 0, activity);
+                    break;
+                }
+            }
+            this._onDidChangeActivity.fire(viewContainer);
+            return toDisposable(() => {
+                activities.splice(activities.indexOf(activity), 1);
+                if (activities.length === 0) {
+                    this.viewContainerActivities.delete(viewContainerId);
+                }
+                this._onDidChangeActivity.fire(viewContainer);
+            });
+        }
+        return Disposable.None;
+    }
+    getViewContainerActivities(viewContainerId) {
+        const viewContainer = this.viewDescriptorService.getViewContainerById(viewContainerId);
+        if (viewContainer) {
+            return this.viewContainerActivities.get(viewContainerId) ?? [];
+        }
+        return [];
+    }
+    showViewActivity(viewId, activity) {
+        let maybeItem = this.viewActivities.get(viewId);
+        if (maybeItem) {
+            maybeItem.id++;
+        }
+        else {
+            maybeItem = {
+                id: 1,
+                activity: this.instantiationService.createInstance(ViewContainerActivityByView, viewId)
+            };
+            this.viewActivities.set(viewId, maybeItem);
+        }
+        const id = maybeItem.id;
+        maybeItem.activity.setActivity(activity);
+        const item = maybeItem;
+        return toDisposable(() => {
+            if (item.id === id) {
+                item.activity.dispose();
+                this.viewActivities.delete(viewId);
+            }
+        });
+    }
+    showAccountsActivity(activity) {
+        return this.showActivity(ACCOUNTS_ACTIVITY_ID, activity);
+    }
+    showGlobalActivity(activity) {
+        return this.showActivity(GLOBAL_ACTIVITY_ID, activity);
+    }
+    getActivity(id) {
+        return this.globalActivities.get(id) ?? [];
+    }
+    showActivity(id, activity) {
+        let activities = this.globalActivities.get(id);
+        if (!activities) {
+            activities = [];
+            this.globalActivities.set(id, activities);
+        }
+        activities.push(activity);
+        this._onDidChangeActivity.fire(id);
+        return toDisposable(() => {
+            activities.splice(activities.indexOf(activity), 1);
+            if (activities.length === 0) {
+                this.globalActivities.delete(id);
+            }
+            this._onDidChangeActivity.fire(id);
+        });
+    }
+};
+ActivityService = ( __decorate([
+    ( __param(0, IViewDescriptorService)),
+    ( __param(1, IInstantiationService))
+], ActivityService));
+export { ActivityService };

package/vscode/src/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.js

@@ -207,9 +207,6 @@ let BrowserAuxiliaryWindowService = class BrowserAuxiliaryWindowService extends
         return { stylesLoaded, container };
     }
     patchMethods(auxiliaryWindow) {
-        auxiliaryWindow.document.createElement = function () {
-            throw new Error('Not allowed to create elements in child window JavaScript context. Always use the main window so that "xyz instanceof HTMLElement" continues to work.');
-        };
     }
     applyMeta(auxiliaryWindow) {
         for (const metaTag of ['meta[charset="utf-8"]', 'meta[http-equiv="Content-Security-Policy"]', 'meta[name="viewport"]', 'meta[name="theme-color"]']) {

package/vscode/src/vs/workbench/services/driver/browser/driver.js

@@ -0,0 +1,184 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { getTopLeftOffset, getClientArea } from '../../../../base/browser/dom.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { language, locale } from '../../../../base/common/platform.js';
+import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import localizedStrings from '../../../../platform/languagePacks/common/localizedStrings.js';
+import { getLogs } from '../../../../platform/log/browser/log.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Extensions } from '../../../common/contributions.js';
+import { ILifecycleService } from '../../lifecycle/common/lifecycle.js';
+let BrowserWindowDriver = class BrowserWindowDriver {
+    constructor(fileService, environmentService, lifecycleService, logService) {
+        this.fileService = fileService;
+        this.environmentService = environmentService;
+        this.lifecycleService = lifecycleService;
+        this.logService = logService;
+    }
+    async getLogs() {
+        return getLogs(this.fileService, this.environmentService);
+    }
+    async whenWorkbenchRestored() {
+        this.logService.info('[driver] Waiting for restored lifecycle phase...');
+        await this.lifecycleService.when(3 );
+        this.logService.info('[driver] Restored lifecycle phase reached. Waiting for contributions...');
+        await ( Registry.as(Extensions.Workbench)).whenRestored;
+        this.logService.info('[driver] Workbench contributions created.');
+    }
+    async setValue(selector, text) {
+        const element = mainWindow.document.querySelector(selector);
+        if (!element) {
+            return Promise.reject(( new Error(`Element not found: ${selector}`)));
+        }
+        const inputElement = element;
+        inputElement.value = text;
+        const event = ( new Event('input', { bubbles: true, cancelable: true }));
+        inputElement.dispatchEvent(event);
+    }
+    async isActiveElement(selector) {
+        const element = mainWindow.document.querySelector(selector);
+        if (element !== mainWindow.document.activeElement) {
+            const chain = [];
+            let el = mainWindow.document.activeElement;
+            while (el) {
+                const tagName = el.tagName;
+                const id = el.id ? `#${el.id}` : '';
+                const classes = ( coalesce(( el.className.split(/\s+/g).map(c => c.trim()))).map(c => `.${c}`)).join('');
+                chain.unshift(`${tagName}${id}${classes}`);
+                el = el.parentElement;
+            }
+            throw new Error(`Active element not found. Current active element is '${chain.join(' > ')}'. Looking for ${selector}`);
+        }
+        return true;
+    }
+    async getElements(selector, recursive) {
+        const query = mainWindow.document.querySelectorAll(selector);
+        const result = [];
+        for (let i = 0; i < query.length; i++) {
+            const element = query.item(i);
+            result.push(this.serializeElement(element, recursive));
+        }
+        return result;
+    }
+    serializeElement(element, recursive) {
+        const attributes = Object.create(null);
+        for (let j = 0; j < element.attributes.length; j++) {
+            const attr = element.attributes.item(j);
+            if (attr) {
+                attributes[attr.name] = attr.value;
+            }
+        }
+        const children = [];
+        if (recursive) {
+            for (let i = 0; i < element.children.length; i++) {
+                const child = element.children.item(i);
+                if (child) {
+                    children.push(this.serializeElement(child, true));
+                }
+            }
+        }
+        const { left, top } = getTopLeftOffset(element);
+        return {
+            tagName: element.tagName,
+            className: element.className,
+            textContent: element.textContent || '',
+            attributes,
+            children,
+            left,
+            top
+        };
+    }
+    async getElementXY(selector, xoffset, yoffset) {
+        const offset = typeof xoffset === 'number' && typeof yoffset === 'number' ? { x: xoffset, y: yoffset } : undefined;
+        return this._getElementXY(selector, offset);
+    }
+    async typeInEditor(selector, text) {
+        const element = mainWindow.document.querySelector(selector);
+        if (!element) {
+            throw new Error(`Editor not found: ${selector}`);
+        }
+        const textarea = element;
+        const start = textarea.selectionStart;
+        const newStart = start + text.length;
+        const value = textarea.value;
+        const newValue = value.substr(0, start) + text + value.substr(start);
+        textarea.value = newValue;
+        textarea.setSelectionRange(newStart, newStart);
+        const event = ( new Event('input', { 'bubbles': true, 'cancelable': true }));
+        textarea.dispatchEvent(event);
+    }
+    async getTerminalBuffer(selector) {
+        const element = mainWindow.document.querySelector(selector);
+        if (!element) {
+            throw new Error(`Terminal not found: ${selector}`);
+        }
+        const xterm = element.xterm;
+        if (!xterm) {
+            throw new Error(`Xterm not found: ${selector}`);
+        }
+        const lines = [];
+        for (let i = 0; i < xterm.buffer.active.length; i++) {
+            lines.push(xterm.buffer.active.getLine(i).translateToString(true));
+        }
+        return lines;
+    }
+    async writeInTerminal(selector, text) {
+        const element = mainWindow.document.querySelector(selector);
+        if (!element) {
+            throw new Error(`Element not found: ${selector}`);
+        }
+        const xterm = element.xterm;
+        if (!xterm) {
+            throw new Error(`Xterm not found: ${selector}`);
+        }
+        xterm._core.coreService.triggerDataEvent(text);
+    }
+    getLocaleInfo() {
+        return Promise.resolve({
+            language: language,
+            locale: locale
+        });
+    }
+    getLocalizedStrings() {
+        return Promise.resolve({
+            open: localizedStrings.open,
+            close: localizedStrings.close,
+            find: localizedStrings.find
+        });
+    }
+    async _getElementXY(selector, offset) {
+        const element = mainWindow.document.querySelector(selector);
+        if (!element) {
+            return Promise.reject(( new Error(`Element not found: ${selector}`)));
+        }
+        const { left, top } = getTopLeftOffset(element);
+        const { width, height } = getClientArea(element);
+        let x, y;
+        if (offset) {
+            x = left + offset.x;
+            y = top + offset.y;
+        }
+        else {
+            x = left + (width / 2);
+            y = top + (height / 2);
+        }
+        x = Math.round(x);
+        y = Math.round(y);
+        return { x, y };
+    }
+    async exitApplication() {
+    }
+};
+BrowserWindowDriver = ( __decorate([
+    ( __param(0, IFileService)),
+    ( __param(1, IEnvironmentService)),
+    ( __param(2, ILifecycleService)),
+    ( __param(3, ILogService))
+], BrowserWindowDriver));
+function registerWindowDriver(instantiationService) {
+    Object.assign(mainWindow, { driver: instantiationService.createInstance(BrowserWindowDriver) });
+}
+export { BrowserWindowDriver, registerWindowDriver };