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

package/dist/vscode/vs/workbench/services/configurationResolver/common/variableResolver.js

@@ -1,4 +1,4 @@
-import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as process from 'monaco-editor/esm/vs/base/common/process.js';
 import * as types from 'monaco-editor/esm/vs/base/common/types.js';
 import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
@@ -74,7 +74,7 @@ class AbstractVariableResolverService {
         throw new Error('resolveWithInteraction not implemented.');
     }
     contributeVariable(variable, resolution) {
-        if (this._contributedVariables.has(variable)) {
+        if (( this._contributedVariables.has(variable))) {
             throw new Error('Variable ' + variable + ' is contributed twice.');
         }
         else {
@@ -141,7 +141,7 @@ class AbstractVariableResolverService {
                     return normalizeDriveLetter(folderPath);
                 }
             }
-            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, paths.basename(filePath)));
+            throw new VariableError(variableKind, localize('canNotResolveFolderForFile', "Variable {0}: can not find workspace folder of '{1}'.", match, path.basename(filePath)));
         };
         const getFolderUri = (variableKind) => {
             if (argument) {
@@ -205,7 +205,7 @@ class AbstractVariableResolverService {
                         return ((folderUri || argument) ? normalizeDriveLetter(this.fsPath(getFolderUri(VariableKind.Cwd))) : process.cwd());
                     case 'workspaceRootFolderName':
                     case 'workspaceFolderBasename':
-                        return normalizeDriveLetter(paths.basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
+                        return normalizeDriveLetter(path.basename(this.fsPath(getFolderUri(VariableKind.WorkspaceFolderBasename))));
                     case 'userHome': {
                         if (environment.userHome) {
                             return environment.userHome;
@@ -232,29 +232,29 @@ class AbstractVariableResolverService {
                         return getFolderPathForFile(VariableKind.FileWorkspaceFolder);
                     case 'relativeFile':
                         if (folderUri || argument) {
-                            return paths.relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
+                            return path.relative(this.fsPath(getFolderUri(VariableKind.RelativeFile)), getFilePath(VariableKind.RelativeFile));
                         }
                         return getFilePath(VariableKind.RelativeFile);
                     case 'relativeFileDirname': {
-                        const dirname = paths.dirname(getFilePath(VariableKind.RelativeFileDirname));
+                        const dirname = path.dirname(getFilePath(VariableKind.RelativeFileDirname));
                         if (folderUri || argument) {
-                            const relative = paths.relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname);
+                            const relative = path.relative(this.fsPath(getFolderUri(VariableKind.RelativeFileDirname)), dirname);
                             return relative.length === 0 ? '.' : relative;
                         }
                         return dirname;
                     }
                     case 'fileDirname':
-                        return paths.dirname(getFilePath(VariableKind.FileDirname));
+                        return path.dirname(getFilePath(VariableKind.FileDirname));
                     case 'fileExtname':
-                        return paths.extname(getFilePath(VariableKind.FileExtname));
+                        return path.extname(getFilePath(VariableKind.FileExtname));
                     case 'fileBasename':
-                        return paths.basename(getFilePath(VariableKind.FileBasename));
+                        return path.basename(getFilePath(VariableKind.FileBasename));
                     case 'fileBasenameNoExtension': {
-                        const basename = paths.basename(getFilePath(VariableKind.FileBasenameNoExtension));
-                        return (basename.slice(0, basename.length - paths.extname(basename).length));
+                        const basename = path.basename(getFilePath(VariableKind.FileBasenameNoExtension));
+                        return (basename.slice(0, basename.length - path.extname(basename).length));
                     }
                     case 'fileDirnameBasename':
-                        return paths.basename(paths.dirname(getFilePath(VariableKind.FileDirnameBasename)));
+                        return path.basename(path.dirname(getFilePath(VariableKind.FileDirnameBasename)));
                     case 'execPath': {
                         const ep = this._context.getExecPath();
                         if (ep) {
@@ -270,7 +270,7 @@ class AbstractVariableResolverService {
                         return match;
                     }
                     case 'pathSeparator':
-                        return paths.sep;
+                        return path.sep;
                     default:
                         try {
                             const key = argument ? `${variable}:${argument}` : variable;

package/dist/vscode/vs/workbench/services/extensions/common/extensionDescriptionRegistry.js

@@ -1,6 +1,6 @@
 import { ExtensionIdentifierMap, ExtensionIdentifier, ExtensionIdentifierSet } from 'monaco-editor/esm/vs/platform/extensions/common/extensions.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 class DeltaExtensionsResult {
     constructor(removedDueToLooping) {
         this.removedDueToLooping = removedDueToLooping;
@@ -33,7 +33,7 @@ class ExtensionDescriptionRegistry {
         this._extensionsArr = [];
         this._activationMap = ( new Map());
         for (const extensionDescription of this._extensionDescriptions) {
-            if (this._extensionsMap.has(extensionDescription.identifier)) {
+            if (( this._extensionsMap.has(extensionDescription.identifier))) {
                 console.error('Extension `' + extensionDescription.identifier.value + '` is already registered');
                 continue;
             }
@@ -45,7 +45,7 @@ class ExtensionDescriptionRegistry {
                     if (activationEvent === 'onUri') {
                         activationEvent = `onUri:${ExtensionIdentifier.toKey(extensionDescription.identifier)}`;
                     }
-                    if (!this._activationMap.has(activationEvent)) {
+                    if (!( this._activationMap.has(activationEvent))) {
                         this._activationMap.set(activationEvent, []);
                     }
                     this._activationMap.get(activationEvent).push(extensionDescription);
@@ -75,7 +75,7 @@ class ExtensionDescriptionRegistry {
                 this._nodesArr = [];
             }
             addNode(id) {
-                if (!this._nodesSet.has(id)) {
+                if (!( this._nodesSet.has(id))) {
                     this._nodesSet.add(id);
                     this._nodesArr.push(id);
                 }
@@ -83,7 +83,7 @@ class ExtensionDescriptionRegistry {
             addArc(from, to) {
                 this.addNode(from);
                 this.addNode(to);
-                if (this._arcs.has(from)) {
+                if (( this._arcs.has(from))) {
                     this._arcs.get(from).push(to);
                 }
                 else {
@@ -91,7 +91,7 @@ class ExtensionDescriptionRegistry {
                 }
             }
             getArcs(id) {
-                if (this._arcs.has(id)) {
+                if (( this._arcs.has(id))) {
                     return this._arcs.get(id);
                 }
                 return [];
@@ -99,7 +99,7 @@ class ExtensionDescriptionRegistry {
             hasOnlyGoodArcs(id, good) {
                 const dependencies = G.getArcs(id);
                 for (let i = 0; i < dependencies.length; i++) {
-                    if (!good.has(dependencies[i])) {
+                    if (!( good.has(dependencies[i]))) {
                         return false;
                     }
                 }
@@ -120,7 +120,7 @@ class ExtensionDescriptionRegistry {
         }
         const good = ( new Set());
         G.getNodes().filter(id => G.getArcs(id).length === 0).forEach(id => good.add(id));
-        const nodes = G.getNodes().filter(id => !good.has(id));
+        const nodes = G.getNodes().filter(id => !( good.has(id)));
         let madeProgress;
         do {
             madeProgress = false;
@@ -137,10 +137,10 @@ class ExtensionDescriptionRegistry {
         return ( nodes.map(id => descs.get(id)));
     }
     containsActivationEvent(activationEvent) {
-        return this._activationMap.has(activationEvent);
+        return ( this._activationMap.has(activationEvent));
     }
     containsExtension(extensionId) {
-        return this._extensionsMap.has(extensionId);
+        return ( this._extensionsMap.has(extensionId));
     }
     getExtensionDescriptionsForActivationEvent(activationEvent) {
         const extensions = this._activationMap.get(activationEvent);
@@ -172,8 +172,8 @@ function extensionCmp(a, b) {
     if (aSortBucket !== bSortBucket) {
         return aSortBucket - bSortBucket;
     }
-    const aLastSegment = paths.posix.basename(a.extensionLocation.path);
-    const bLastSegment = paths.posix.basename(b.extensionLocation.path);
+    const aLastSegment = path.posix.basename(a.extensionLocation.path);
+    const bLastSegment = path.posix.basename(b.extensionLocation.path);
     if (aLastSegment < bLastSegment) {
         return -1;
     }
@@ -184,6 +184,6 @@ function extensionCmp(a, b) {
 }
 function removeExtensions(arr, toRemove) {
     const toRemoveSet = ( new ExtensionIdentifierSet(toRemove));
-    return arr.filter(extension => !toRemoveSet.has(extension.identifier));
+    return arr.filter(extension => !( toRemoveSet.has(extension.identifier)));
 }
 export { DeltaExtensionsResult, ExtensionDescriptionRegistry };

package/dist/vscode/vs/workbench/services/extensions/common/extensionStorageMigration.js

@@ -0,0 +1,56 @@
+import { getErrorMessage } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { IExtensionStorageService } from '../../../../platform/extensionManagement/common/extensionStorage.js';
+import { IFileService, FileSystemProviderErrorCode } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+async function migrateExtensionStorage(fromExtensionId, toExtensionId, global, instantionService) {
+    return instantionService.invokeFunction(async (serviceAccessor) => {
+        const environmentService = serviceAccessor.get(IEnvironmentService);
+        const userDataProfilesService = serviceAccessor.get(IUserDataProfilesService);
+        const extensionStorageService = serviceAccessor.get(IExtensionStorageService);
+        const storageService = serviceAccessor.get(IStorageService);
+        const uriIdentityService = serviceAccessor.get(IUriIdentityService);
+        const fileService = serviceAccessor.get(IFileService);
+        const workspaceContextService = serviceAccessor.get(IWorkspaceContextService);
+        const logService = serviceAccessor.get(ILogService);
+        const storageMigratedKey = `extensionStorage.migrate.${fromExtensionId}-${toExtensionId}`;
+        const migrateLowerCaseStorageKey = fromExtensionId.toLowerCase() === toExtensionId.toLowerCase() ? `extension.storage.migrateFromLowerCaseKey.${fromExtensionId.toLowerCase()}` : undefined;
+        if (fromExtensionId === toExtensionId) {
+            return;
+        }
+        const getExtensionStorageLocation = (extensionId, global) => {
+            if (global) {
+                return uriIdentityService.extUri.joinPath(userDataProfilesService.defaultProfile.globalStorageHome, extensionId.toLowerCase() );
+            }
+            return uriIdentityService.extUri.joinPath(environmentService.workspaceStorageHome, workspaceContextService.getWorkspace().id, extensionId);
+        };
+        const storageScope = global ? 0  : 1 ;
+        if (!storageService.getBoolean(storageMigratedKey, storageScope, false) && !(migrateLowerCaseStorageKey && storageService.getBoolean(migrateLowerCaseStorageKey, storageScope, false))) {
+            logService.info(`Migrating ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}...`);
+            const value = extensionStorageService.getExtensionState(fromExtensionId, global);
+            if (value) {
+                extensionStorageService.setExtensionState(toExtensionId, value, global);
+                extensionStorageService.setExtensionState(fromExtensionId, undefined, global);
+            }
+            const fromPath = getExtensionStorageLocation(fromExtensionId, global);
+            const toPath = getExtensionStorageLocation(toExtensionId, global);
+            if (!uriIdentityService.extUri.isEqual(fromPath, toPath)) {
+                try {
+                    await fileService.move(fromPath, toPath, true);
+                }
+                catch (error) {
+                    if (error.code !== FileSystemProviderErrorCode.FileNotFound) {
+                        logService.info(`Error while migrating ${global ? 'global' : 'workspace'} file storage from '${fromExtensionId}' to '${toExtensionId}'`, getErrorMessage(error));
+                    }
+                }
+            }
+            logService.info(`Migrated ${global ? 'global' : 'workspace'} extension storage from ${fromExtensionId} to ${toExtensionId}`);
+            storageService.store(storageMigratedKey, true, storageScope, 1 );
+        }
+    });
+}
+export { migrateExtensionStorage };

package/dist/vscode/vs/workbench/services/extensions/common/extensionsRegistry.js

@@ -50,8 +50,8 @@ class ExtensionPointUserDelta {
         }
         const previousSet = this._toSet(previous);
         const currentSet = this._toSet(current);
-        const added = current.filter(user => !previousSet.has(user.description.identifier));
-        const removed = previous.filter(user => !currentSet.has(user.description.identifier));
+        const added = current.filter(user => !( previousSet.has(user.description.identifier)));
+        const removed = previous.filter(user => !( currentSet.has(user.description.identifier)));
         return ( new ExtensionPointUserDelta(added, removed));
     }
     constructor(added, removed) {
@@ -728,7 +728,7 @@ class ExtensionsRegistryImpl {
         this._extensionPoints = ( new Map());
     }
     registerExtensionPoint(desc) {
-        if (this._extensionPoints.has(desc.extensionPoint)) {
+        if (( this._extensionPoints.has(desc.extensionPoint))) {
             throw new Error('Duplicate extension point: ' + desc.extensionPoint);
         }
         const result = ( new ExtensionPoint(desc.extensionPoint, desc.defaultExtensionKind));

package/dist/vscode/vs/workbench/services/hover/browser/hover.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IHoverService = ( createDecorator('hoverService'));
+export { IHoverService };

package/dist/vscode/vs/workbench/services/hover/browser/hoverService.js

@@ -0,0 +1,149 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/hover.css";
+import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { editorHoverBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IContextViewService, IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { HoverWidget } from './hoverWidget.js';
+import { toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { addDisposableListener, EventType } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
+let HoverService = class HoverService {
+    constructor(_instantiationService, _contextViewService, contextMenuService, _keybindingService) {
+        this._instantiationService = _instantiationService;
+        this._contextViewService = _contextViewService;
+        this._keybindingService = _keybindingService;
+        contextMenuService.onDidShowContextMenu(() => this.hideHover());
+    }
+    showHover(options, focus) {
+        if (getHoverOptionsIdentity(this._currentHoverOptions) === getHoverOptionsIdentity(options)) {
+            return undefined;
+        }
+        this._currentHoverOptions = options;
+        if (options.trapFocus && document.activeElement) {
+            this._lastFocusedElementBeforeOpen = document.activeElement;
+        }
+        else {
+            this._lastFocusedElementBeforeOpen = undefined;
+        }
+        const hoverDisposables = ( (new DisposableStore()));
+        const hover = this._instantiationService.createInstance(HoverWidget, options);
+        hover.onDispose(() => {
+            this._lastFocusedElementBeforeOpen?.focus();
+            if (this._currentHoverOptions === options) {
+                this._currentHoverOptions = undefined;
+            }
+            hoverDisposables.dispose();
+        });
+        const provider = this._contextViewService;
+        provider.showContextView(( (new HoverContextViewDelegate(hover, focus))), options.container);
+        hover.onRequestLayout(() => provider.layout());
+        if ('targetElements' in options.target) {
+            for (const element of options.target.targetElements) {
+                hoverDisposables.add(addDisposableListener(element, EventType.CLICK, () => this.hideHover()));
+            }
+        }
+        else {
+            hoverDisposables.add(addDisposableListener(options.target, EventType.CLICK, () => this.hideHover()));
+        }
+        const focusedElement = document.activeElement;
+        if (focusedElement) {
+            hoverDisposables.add(addDisposableListener(focusedElement, EventType.KEY_DOWN, e => this._keyDown(e, hover, !!options.hideOnKeyDown)));
+            hoverDisposables.add(addDisposableListener(document, EventType.KEY_DOWN, e => this._keyDown(e, hover, !!options.hideOnKeyDown)));
+            hoverDisposables.add(addDisposableListener(focusedElement, EventType.KEY_UP, e => this._keyUp(e, hover)));
+            hoverDisposables.add(addDisposableListener(document, EventType.KEY_UP, e => this._keyUp(e, hover)));
+        }
+        if ('IntersectionObserver' in window) {
+            const observer = ( (new IntersectionObserver(e => this._intersectionChange(e, hover), { threshold: 0 })));
+            const firstTargetElement = 'targetElements' in options.target ? options.target.targetElements[0] : options.target;
+            observer.observe(firstTargetElement);
+            hoverDisposables.add(toDisposable(() => observer.disconnect()));
+        }
+        this._currentHover = hover;
+        return hover;
+    }
+    hideHover() {
+        if (this._currentHover?.isLocked || !this._currentHoverOptions) {
+            return;
+        }
+        this._currentHover = undefined;
+        this._currentHoverOptions = undefined;
+        this._contextViewService.hideContextView();
+    }
+    _intersectionChange(entries, hover) {
+        const entry = entries[entries.length - 1];
+        if (!entry.isIntersecting) {
+            hover.dispose();
+        }
+    }
+    _keyDown(e, hover, hideOnKeyDown) {
+        if (e.key === 'Alt') {
+            hover.isLocked = true;
+            return;
+        }
+        const event = ( (new StandardKeyboardEvent(e)));
+        const keybinding = this._keybindingService.resolveKeyboardEvent(event);
+        if (( (keybinding.getSingleModifierDispatchChords().some(value => !!value))) || this._keybindingService.softDispatch(event, event.target)) {
+            return;
+        }
+        if (hideOnKeyDown && (!this._currentHoverOptions?.trapFocus || e.key !== 'Tab')) {
+            this.hideHover();
+            this._lastFocusedElementBeforeOpen?.focus();
+        }
+    }
+    _keyUp(e, hover) {
+        if (e.key === 'Alt') {
+            hover.isLocked = false;
+            if (!hover.isMouseIn) {
+                this.hideHover();
+                this._lastFocusedElementBeforeOpen?.focus();
+            }
+        }
+    }
+};
+HoverService = ( (__decorate([
+    ( (__param(0, IInstantiationService))),
+    ( (__param(1, IContextViewService))),
+    ( (__param(2, IContextMenuService))),
+    ( (__param(3, IKeybindingService)))
+], HoverService)));
+function getHoverOptionsIdentity(options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    return options?.id ?? options;
+}
+class HoverContextViewDelegate {
+    get anchorPosition() {
+        return this._hover.anchor;
+    }
+    constructor(_hover, _focus = false) {
+        this._hover = _hover;
+        this._focus = _focus;
+    }
+    render(container) {
+        this._hover.render(container);
+        if (this._focus) {
+            this._hover.focus();
+        }
+        return this._hover;
+    }
+    getAnchor() {
+        return {
+            x: this._hover.x,
+            y: this._hover.y
+        };
+    }
+    layout() {
+        this._hover.layout();
+    }
+}
+registerThemingParticipant((theme, collector) => {
+    const hoverBorder = theme.getColor(editorHoverBorder);
+    if (hoverBorder) {
+        collector.addRule(`.monaco-workbench .workbench-hover .hover-row:not(:first-child):not(:empty) { border-top: 1px solid ${( ( hoverBorder.transparent(0.5)))}; }`);
+        collector.addRule(`.monaco-workbench .workbench-hover hr { border-top: 1px solid ${( ( hoverBorder.transparent(0.5)))}; }`);
+    }
+});
+export { HoverService };