@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/api/common/extHostEditorTabs.js

@@ -0,0 +1,328 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { ViewColumn } from './extHostTypeConverters.js';
+import { MainContext } from './extHost.protocol.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { InteractiveWindowInput, TerminalEditorTabInput, NotebookDiffEditorTabInput, NotebookEditorTabInput, WebviewEditorTabInput, CustomEditorTabInput, TextMergeTabInput, TextDiffTabInput, TextTabInput } from './extHostTypes.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { diffSets } from 'monaco-editor/esm/vs/base/common/collections.js';
+const IExtHostEditorTabs = ( createDecorator('IExtHostEditorTabs'));
+class ExtHostEditorTab {
+    constructor(dto, parentGroup, activeTabIdGetter) {
+        this._activeTabIdGetter = activeTabIdGetter;
+        this._parentGroup = parentGroup;
+        this.acceptDtoUpdate(dto);
+    }
+    get apiObject() {
+        if (!this._apiObject) {
+            const that = this;
+            const obj = {
+                get isActive() {
+                    return that._dto.id === that._activeTabIdGetter();
+                },
+                get label() {
+                    return that._dto.label;
+                },
+                get input() {
+                    return that._input;
+                },
+                get isDirty() {
+                    return that._dto.isDirty;
+                },
+                get isPinned() {
+                    return that._dto.isPinned;
+                },
+                get isPreview() {
+                    return that._dto.isPreview;
+                },
+                get group() {
+                    return that._parentGroup.apiObject;
+                }
+            };
+            this._apiObject = ( Object.freeze(obj));
+        }
+        return this._apiObject;
+    }
+    get tabId() {
+        return this._dto.id;
+    }
+    acceptDtoUpdate(dto) {
+        this._dto = dto;
+        this._input = this._initInput();
+    }
+    _initInput() {
+        switch (this._dto.input.kind) {
+            case 1 :
+                return ( new TextTabInput(URI.revive(this._dto.input.uri)));
+            case 2 :
+                return ( new TextDiffTabInput(URI.revive(this._dto.input.original), URI.revive(this._dto.input.modified)));
+            case 3 :
+                return ( new TextMergeTabInput(
+                    URI.revive(this._dto.input.base),
+                    URI.revive(this._dto.input.input1),
+                    URI.revive(this._dto.input.input2),
+                    URI.revive(this._dto.input.result)
+                ));
+            case 6 :
+                return ( new CustomEditorTabInput(URI.revive(this._dto.input.uri), this._dto.input.viewType));
+            case 7 :
+                return ( new WebviewEditorTabInput(this._dto.input.viewType));
+            case 4 :
+                return ( new NotebookEditorTabInput(URI.revive(this._dto.input.uri), this._dto.input.notebookType));
+            case 5 :
+                return ( new NotebookDiffEditorTabInput(
+                    URI.revive(this._dto.input.original),
+                    URI.revive(this._dto.input.modified),
+                    this._dto.input.notebookType
+                ));
+            case 8 :
+                return ( new TerminalEditorTabInput());
+            case 9 :
+                return ( new InteractiveWindowInput(URI.revive(this._dto.input.uri), URI.revive(this._dto.input.inputBoxUri)));
+            default:
+                return undefined;
+        }
+    }
+}
+class ExtHostEditorTabGroup {
+    constructor(dto, activeGroupIdGetter) {
+        this._tabs = [];
+        this._activeTabId = '';
+        this._dto = dto;
+        this._activeGroupIdGetter = activeGroupIdGetter;
+        for (const tabDto of dto.tabs) {
+            if (tabDto.isActive) {
+                this._activeTabId = tabDto.id;
+            }
+            this._tabs.push(( new ExtHostEditorTab(tabDto, this, () => this.activeTabId())));
+        }
+    }
+    get apiObject() {
+        if (!this._apiObject) {
+            const that = this;
+            const obj = {
+                get isActive() {
+                    return that._dto.groupId === that._activeGroupIdGetter();
+                },
+                get viewColumn() {
+                    return ViewColumn.to(that._dto.viewColumn);
+                },
+                get activeTab() {
+                    return that._tabs.find(tab => tab.tabId === that._activeTabId)?.apiObject;
+                },
+                get tabs() {
+                    return ( Object.freeze(( that._tabs.map(tab => tab.apiObject))));
+                }
+            };
+            this._apiObject = ( Object.freeze(obj));
+        }
+        return this._apiObject;
+    }
+    get groupId() {
+        return this._dto.groupId;
+    }
+    get tabs() {
+        return this._tabs;
+    }
+    acceptGroupDtoUpdate(dto) {
+        this._dto = dto;
+    }
+    acceptTabOperation(operation) {
+        if (operation.kind === 0 ) {
+            const tab = ( new ExtHostEditorTab(operation.tabDto, this, () => this.activeTabId()));
+            this._tabs.splice(operation.index, 0, tab);
+            if (operation.tabDto.isActive) {
+                this._activeTabId = tab.tabId;
+            }
+            return tab;
+        }
+        else if (operation.kind === 1 ) {
+            const tab = this._tabs.splice(operation.index, 1)[0];
+            if (!tab) {
+                throw new Error(`Tab close updated received for index ${operation.index} which does not exist`);
+            }
+            if (tab.tabId === this._activeTabId) {
+                this._activeTabId = '';
+            }
+            return tab;
+        }
+        else if (operation.kind === 3 ) {
+            if (operation.oldIndex === undefined) {
+                throw new Error('Invalid old index on move IPC');
+            }
+            const tab = this._tabs.splice(operation.oldIndex, 1)[0];
+            if (!tab) {
+                throw new Error(`Tab move updated received for index ${operation.oldIndex} which does not exist`);
+            }
+            this._tabs.splice(operation.index, 0, tab);
+            return tab;
+        }
+        const tab = this._tabs.find(extHostTab => extHostTab.tabId === operation.tabDto.id);
+        if (!tab) {
+            throw new Error('INVALID tab');
+        }
+        if (operation.tabDto.isActive) {
+            this._activeTabId = operation.tabDto.id;
+        }
+        else if (this._activeTabId === operation.tabDto.id && !operation.tabDto.isActive) {
+            this._activeTabId = '';
+        }
+        tab.acceptDtoUpdate(operation.tabDto);
+        return tab;
+    }
+    activeTabId() {
+        return this._activeTabId;
+    }
+}
+let ExtHostEditorTabs = class ExtHostEditorTabs {
+    constructor(extHostRpc) {
+        this._onDidChangeTabs = ( new Emitter());
+        this._onDidChangeTabGroups = ( new Emitter());
+        this._extHostTabGroups = [];
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadEditorTabs));
+    }
+    get tabGroups() {
+        if (!this._apiObject) {
+            const that = this;
+            const obj = {
+                onDidChangeTabGroups: that._onDidChangeTabGroups.event,
+                onDidChangeTabs: that._onDidChangeTabs.event,
+                get all() {
+                    return ( Object.freeze(( that._extHostTabGroups.map(group => group.apiObject))));
+                },
+                get activeTabGroup() {
+                    const activeTabGroupId = that._activeGroupId;
+                    const activeTabGroup = assertIsDefined(that._extHostTabGroups.find(candidate => candidate.groupId === activeTabGroupId)?.apiObject);
+                    return activeTabGroup;
+                },
+                close: async (tabOrTabGroup, preserveFocus) => {
+                    const tabsOrTabGroups = Array.isArray(tabOrTabGroup) ? tabOrTabGroup : [tabOrTabGroup];
+                    if (!tabsOrTabGroups.length) {
+                        return true;
+                    }
+                    if (isTabGroup(tabsOrTabGroups[0])) {
+                        return this._closeGroups(tabsOrTabGroups, preserveFocus);
+                    }
+                    else {
+                        return this._closeTabs(tabsOrTabGroups, preserveFocus);
+                    }
+                },
+            };
+            this._apiObject = ( Object.freeze(obj));
+        }
+        return this._apiObject;
+    }
+    $acceptEditorTabModel(tabGroups) {
+        const groupIdsBefore = ( new Set(( this._extHostTabGroups.map(group => group.groupId))));
+        const groupIdsAfter = ( new Set(( tabGroups.map(dto => dto.groupId))));
+        const diff = diffSets(groupIdsBefore, groupIdsAfter);
+        const closed = ( this._extHostTabGroups.filter(group => diff.removed.includes(group.groupId)).map(group => group.apiObject));
+        const opened = [];
+        const changed = [];
+        this._extHostTabGroups = ( tabGroups.map(tabGroup => {
+            const group = ( new ExtHostEditorTabGroup(tabGroup, () => this._activeGroupId));
+            if (diff.added.includes(group.groupId)) {
+                opened.push(group.apiObject);
+            }
+            else {
+                changed.push(group.apiObject);
+            }
+            return group;
+        }));
+        const activeTabGroupId = assertIsDefined(tabGroups.find(group => group.isActive === true)?.groupId);
+        if (activeTabGroupId !== undefined && this._activeGroupId !== activeTabGroupId) {
+            this._activeGroupId = activeTabGroupId;
+        }
+        this._onDidChangeTabGroups.fire(( Object.freeze({ opened, closed, changed })));
+    }
+    $acceptTabGroupUpdate(groupDto) {
+        const group = this._extHostTabGroups.find(group => group.groupId === groupDto.groupId);
+        if (!group) {
+            throw new Error('Update Group IPC call received before group creation.');
+        }
+        group.acceptGroupDtoUpdate(groupDto);
+        if (groupDto.isActive) {
+            this._activeGroupId = groupDto.groupId;
+        }
+        this._onDidChangeTabGroups.fire(( Object.freeze({ changed: [group.apiObject], opened: [], closed: [] })));
+    }
+    $acceptTabOperation(operation) {
+        const group = this._extHostTabGroups.find(group => group.groupId === operation.groupId);
+        if (!group) {
+            throw new Error('Update Tabs IPC call received before group creation.');
+        }
+        const tab = group.acceptTabOperation(operation);
+        switch (operation.kind) {
+            case 0 :
+                this._onDidChangeTabs.fire(( Object.freeze({
+                    opened: [tab.apiObject],
+                    closed: [],
+                    changed: []
+                })));
+                return;
+            case 1 :
+                this._onDidChangeTabs.fire(( Object.freeze({
+                    opened: [],
+                    closed: [tab.apiObject],
+                    changed: []
+                })));
+                return;
+            case 3 :
+            case 2 :
+                this._onDidChangeTabs.fire(( Object.freeze({
+                    opened: [],
+                    closed: [],
+                    changed: [tab.apiObject]
+                })));
+                return;
+        }
+    }
+    _findExtHostTabFromApi(apiTab) {
+        for (const group of this._extHostTabGroups) {
+            for (const tab of group.tabs) {
+                if (tab.apiObject === apiTab) {
+                    return tab;
+                }
+            }
+        }
+        return;
+    }
+    _findExtHostTabGroupFromApi(apiTabGroup) {
+        return this._extHostTabGroups.find(candidate => candidate.apiObject === apiTabGroup);
+    }
+    async _closeTabs(tabs, preserveFocus) {
+        const extHostTabIds = [];
+        for (const tab of tabs) {
+            const extHostTab = this._findExtHostTabFromApi(tab);
+            if (!extHostTab) {
+                throw new Error('Tab close: Invalid tab not found!');
+            }
+            extHostTabIds.push(extHostTab.tabId);
+        }
+        return this._proxy.$closeTab(extHostTabIds, preserveFocus);
+    }
+    async _closeGroups(groups, preserverFoucs) {
+        const extHostGroupIds = [];
+        for (const group of groups) {
+            const extHostGroup = this._findExtHostTabGroupFromApi(group);
+            if (!extHostGroup) {
+                throw new Error('Group close: Invalid group not found!');
+            }
+            extHostGroupIds.push(extHostGroup.groupId);
+        }
+        return this._proxy.$closeGroup(extHostGroupIds, preserverFoucs);
+    }
+};
+ExtHostEditorTabs = ( __decorate([
+    ( __param(0, IExtHostRpcService))
+], ExtHostEditorTabs));
+function isTabGroup(obj) {
+    const tabGroup = obj;
+    if (tabGroup.tabs !== undefined) {
+        return true;
+    }
+    return false;
+}
+export { ExtHostEditorTabs, IExtHostEditorTabs };

package/dist/vscode/vs/workbench/api/common/extHostExtensionActivator.js

@@ -0,0 +1,309 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { ExtensionDescriptionRegistry } from '../../services/extensions/common/extensionDescriptionRegistry.js';
+import { ExtensionIdentifierMap } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
+import { MissingExtensionDependency } from '../../services/extensions/common/extensions.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
+class ExtensionActivationTimes {
+    constructor(startup, codeLoadingTime, activateCallTime, activateResolvedTime) {
+        this.startup = startup;
+        this.codeLoadingTime = codeLoadingTime;
+        this.activateCallTime = activateCallTime;
+        this.activateResolvedTime = activateResolvedTime;
+    }
+}
+ExtensionActivationTimes.NONE = ( new ExtensionActivationTimes(false, -1, -1, -1));
+class ExtensionActivationTimesBuilder {
+    constructor(startup) {
+        this._startup = startup;
+        this._codeLoadingStart = -1;
+        this._codeLoadingStop = -1;
+        this._activateCallStart = -1;
+        this._activateCallStop = -1;
+        this._activateResolveStart = -1;
+        this._activateResolveStop = -1;
+    }
+    _delta(start, stop) {
+        if (start === -1 || stop === -1) {
+            return -1;
+        }
+        return stop - start;
+    }
+    build() {
+        return ( new ExtensionActivationTimes(
+            this._startup,
+            this._delta(this._codeLoadingStart, this._codeLoadingStop),
+            this._delta(this._activateCallStart, this._activateCallStop),
+            this._delta(this._activateResolveStart, this._activateResolveStop)
+        ));
+    }
+    codeLoadingStart() {
+        this._codeLoadingStart = Date.now();
+    }
+    codeLoadingStop() {
+        this._codeLoadingStop = Date.now();
+    }
+    activateCallStart() {
+        this._activateCallStart = Date.now();
+    }
+    activateCallStop() {
+        this._activateCallStop = Date.now();
+    }
+    activateResolveStart() {
+        this._activateResolveStart = Date.now();
+    }
+    activateResolveStop() {
+        this._activateResolveStop = Date.now();
+    }
+}
+class ActivatedExtension {
+    constructor(activationFailed, activationFailedError, activationTimes, module, exports, subscriptions) {
+        this.activationFailed = activationFailed;
+        this.activationFailedError = activationFailedError;
+        this.activationTimes = activationTimes;
+        this.module = module;
+        this.exports = exports;
+        this.subscriptions = subscriptions;
+    }
+}
+class EmptyExtension extends ActivatedExtension {
+    constructor(activationTimes) {
+        super(false, null, activationTimes, { activate: undefined, deactivate: undefined }, undefined, []);
+    }
+}
+class HostExtension extends ActivatedExtension {
+    constructor() {
+        super(false, null, ExtensionActivationTimes.NONE, { activate: undefined, deactivate: undefined }, undefined, []);
+    }
+}
+class FailedExtension extends ActivatedExtension {
+    constructor(activationError) {
+        super(true, activationError, ExtensionActivationTimes.NONE, { activate: undefined, deactivate: undefined }, undefined, []);
+    }
+}
+let ExtensionsActivator = class ExtensionsActivator {
+    constructor(registry, globalRegistry, host, _logService) {
+        this._logService = _logService;
+        this._registry = registry;
+        this._globalRegistry = globalRegistry;
+        this._host = host;
+        this._operations = ( new ExtensionIdentifierMap());
+        this._alreadyActivatedEvents = Object.create(null);
+    }
+    dispose() {
+        for (const [_, op] of this._operations) {
+            op.dispose();
+        }
+    }
+    async waitForActivatingExtensions() {
+        const res = [];
+        for (const [_, op] of this._operations) {
+            res.push(op.wait());
+        }
+        await Promise.all(res);
+    }
+    isActivated(extensionId) {
+        const op = this._operations.get(extensionId);
+        return Boolean(op && op.value);
+    }
+    getActivatedExtension(extensionId) {
+        const op = this._operations.get(extensionId);
+        if (!op || !op.value) {
+            throw new Error(`Extension '${extensionId.value}' is not known or not activated`);
+        }
+        return op.value;
+    }
+    async activateByEvent(activationEvent, startup) {
+        if (this._alreadyActivatedEvents[activationEvent]) {
+            return;
+        }
+        const activateExtensions = this._registry.getExtensionDescriptionsForActivationEvent(activationEvent);
+        await this._activateExtensions(( activateExtensions.map(e => ({
+            id: e.identifier,
+            reason: { startup, extensionId: e.identifier, activationEvent }
+        }))));
+        this._alreadyActivatedEvents[activationEvent] = true;
+    }
+    activateById(extensionId, reason) {
+        const desc = this._registry.getExtensionDescription(extensionId);
+        if (!desc) {
+            throw new Error(`Extension '${extensionId}' is not known`);
+        }
+        return this._activateExtensions([{ id: desc.identifier, reason }]);
+    }
+    async _activateExtensions(extensions) {
+        const operations = ( extensions
+            .filter((p) => !this.isActivated(p.id))
+            .map(ext => this._handleActivationRequest(ext)));
+        await Promise.all(( operations.map(op => op.wait())));
+    }
+    _handleActivationRequest(currentActivation) {
+        if (this._operations.has(currentActivation.id)) {
+            return this._operations.get(currentActivation.id);
+        }
+        if (this._isHostExtension(currentActivation.id)) {
+            return this._createAndSaveOperation(currentActivation, null, [], null);
+        }
+        const currentExtension = this._registry.getExtensionDescription(currentActivation.id);
+        if (!currentExtension) {
+            const error = ( new Error(`Cannot activate unknown extension '${currentActivation.id.value}'`));
+            const result = this._createAndSaveOperation(currentActivation, null, [], ( new FailedExtension(error)));
+            this._host.onExtensionActivationError(currentActivation.id, error, ( new MissingExtensionDependency(currentActivation.id.value)));
+            return result;
+        }
+        const deps = [];
+        const depIds = (typeof currentExtension.extensionDependencies === 'undefined' ? [] : currentExtension.extensionDependencies);
+        for (const depId of depIds) {
+            if (this._isResolvedExtension(depId)) {
+                continue;
+            }
+            const dep = this._operations.get(depId);
+            if (dep) {
+                deps.push(dep);
+                continue;
+            }
+            if (this._isHostExtension(depId)) {
+                deps.push(this._handleActivationRequest({
+                    id: this._globalRegistry.getExtensionDescription(depId).identifier,
+                    reason: currentActivation.reason
+                }));
+                continue;
+            }
+            const depDesc = this._registry.getExtensionDescription(depId);
+            if (depDesc) {
+                if (!depDesc.main && !depDesc.browser) {
+                    continue;
+                }
+                deps.push(this._handleActivationRequest({
+                    id: depDesc.identifier,
+                    reason: currentActivation.reason
+                }));
+                continue;
+            }
+            const currentExtensionFriendlyName = currentExtension.displayName || currentExtension.identifier.value;
+            const error = ( new Error(
+                `Cannot activate the '${currentExtensionFriendlyName}' extension because it depends on unknown extension '${depId}'`
+            ));
+            const result = this._createAndSaveOperation(currentActivation, currentExtension.displayName, [], ( new FailedExtension(error)));
+            this._host.onExtensionActivationError(currentExtension.identifier, error, ( new MissingExtensionDependency(depId)));
+            return result;
+        }
+        return this._createAndSaveOperation(currentActivation, currentExtension.displayName, deps, null);
+    }
+    _createAndSaveOperation(activation, displayName, deps, value) {
+        const operation = ( new ActivationOperation(
+            activation.id,
+            displayName,
+            activation.reason,
+            deps,
+            value,
+            this._host,
+            this._logService
+        ));
+        this._operations.set(activation.id, operation);
+        return operation;
+    }
+    _isHostExtension(extensionId) {
+        return ExtensionDescriptionRegistry.isHostExtension(extensionId, this._registry, this._globalRegistry);
+    }
+    _isResolvedExtension(extensionId) {
+        const extensionDescription = this._globalRegistry.getExtensionDescription(extensionId);
+        if (!extensionDescription) {
+            return false;
+        }
+        return (!extensionDescription.main && !extensionDescription.browser);
+    }
+};
+ExtensionsActivator = ( __decorate([
+    ( __param(3, ILogService))
+], ExtensionsActivator));
+let ActivationOperation = class ActivationOperation {
+    get value() {
+        return this._value;
+    }
+    get friendlyName() {
+        return this._displayName || this._id.value;
+    }
+    constructor(_id, _displayName, _reason, _deps, _value, _host, _logService) {
+        this._id = _id;
+        this._displayName = _displayName;
+        this._reason = _reason;
+        this._deps = _deps;
+        this._value = _value;
+        this._host = _host;
+        this._logService = _logService;
+        this._barrier = ( new Barrier());
+        this._isDisposed = false;
+        this._initialize();
+    }
+    dispose() {
+        this._isDisposed = true;
+    }
+    wait() {
+        return this._barrier.wait();
+    }
+    async _initialize() {
+        await this._waitForDepsThenActivate();
+        this._barrier.open();
+    }
+    async _waitForDepsThenActivate() {
+        if (this._value) {
+            return;
+        }
+        while (this._deps.length > 0) {
+            for (let i = 0; i < this._deps.length; i++) {
+                const dep = this._deps[i];
+                if (dep.value && !dep.value.activationFailed) {
+                    this._deps.splice(i, 1);
+                    i--;
+                    continue;
+                }
+                if (dep.value && dep.value.activationFailed) {
+                    const error = ( new Error(
+                        `Cannot activate the '${this.friendlyName}' extension because its dependency '${dep.friendlyName}' failed to activate`
+                    ));
+                    error.detail = dep.value.activationFailedError;
+                    this._value = ( new FailedExtension(error));
+                    this._host.onExtensionActivationError(this._id, error, null);
+                    return;
+                }
+            }
+            if (this._deps.length > 0) {
+                await Promise.race(( this._deps.map(dep => dep.wait())));
+            }
+        }
+        await this._activate();
+    }
+    async _activate() {
+        try {
+            this._value = await this._host.actualActivateExtension(this._id, this._reason);
+        }
+        catch (err) {
+            const error = ( new Error());
+            if (err && err.name) {
+                error.name = err.name;
+            }
+            if (err && err.message) {
+                error.message = `Activating extension '${this._id.value}' failed: ${err.message}.`;
+            }
+            else {
+                error.message = `Activating extension '${this._id.value}' failed: ${err}.`;
+            }
+            if (err && err.stack) {
+                error.stack = err.stack;
+            }
+            this._value = ( new FailedExtension(error));
+            if (this._isDisposed && errors.isCancellationError(err)) {
+                return;
+            }
+            this._host.onExtensionActivationError(this._id, error, null);
+            this._logService.error(`Activating extension ${this._id.value} failed due to an error:`);
+            this._logService.error(err);
+        }
+    }
+};
+ActivationOperation = ( __decorate([
+    ( __param(6, ILogService))
+], ActivationOperation));
+export { ActivatedExtension, EmptyExtension, ExtensionActivationTimes, ExtensionActivationTimesBuilder, ExtensionsActivator, HostExtension };