@codingame/monaco-vscode-api 3.0.0 → 3.1.0

package/api.js

@@ -29,7 +29,7 @@ function createProxy(key) {
     });
 }
 const api = {
-    version: "1.87.0",
+    version: "1.87.1",
     tasks: createProxy('tasks'),
     notebooks: createProxy('notebooks'),
     scm: createProxy('scm'),

package/contributions.js

@@ -26,6 +26,8 @@ import './vscode/src/vs/workbench/contrib/list/browser/list.contribution.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/editorFeatures.js';
 import './vscode/src/vs/workbench/contrib/contextmenu/browser/contextmenu.contribution.js';
 import './vscode/src/vs/workbench/contrib/mappedEdits/common/mappedEdits.contribution.js';
+import './vscode/src/vs/workbench/browser/actions/textInputActions.js';
+import './vscode/src/vs/workbench/browser/actions/developerActions.js';
 let ExtensionPoints = class ExtensionPoints {
     constructor(instantiationService) {
         this.instantiationService = instantiationService;

package/missing-services.js

@@ -192,6 +192,8 @@ import { IWorkspaceTagsService } from './vscode/src/vs/workbench/contrib/tags/co
 import { NoOpWorkspaceTagsService } from './vscode/src/vs/workbench/contrib/tags/browser/workspaceTagsService.js';
 import { IExtensionFeaturesManagementService } from './vscode/src/vs/workbench/services/extensionManagement/common/extensionFeatures.js';
 import { IEditorPaneService } from './vscode/src/vs/workbench/services/editor/common/editorPaneService.js';
+import { IWorkspaceIdentityService } from './vscode/src/vs/workbench/services/workspaces/common/workspaceIdentityService.js';
+import { IDefaultLogLevelsService } from './vscode/src/vs/workbench/contrib/logs/common/defaultLogLevels.js';
 import { getBuiltInExtensionTranslationsUris } from './l10n.js';
 import { unsupported } from './tools.js';
 import { IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
@@ -528,8 +530,8 @@ registerSingleton(IPathService, BrowserPathService, 1 );
 registerSingleton(IProductService, class ProductService {
     constructor() {
         this._serviceBrand = undefined;
-        this.version = "1.87.0";
-        this.commit = "1.87.0";
+        this.version = "1.87.1";
+        this.commit = "1.87.1";
         this.quality = 'oss';
         this.nameShort = 'Code - OSS Dev';
         this.nameLong = 'Code - OSS Dev';
@@ -3010,3 +3012,16 @@ registerSingleton(IEditorPaneService, class EditorPaneService {
         this.didInstantiateEditorPane = () => false;
     }
 }, 1 );
+registerSingleton(IWorkspaceIdentityService, class WorkspaceIdentityService {
+    constructor() {
+        this.matches = unsupported;
+        this.getWorkspaceStateFolders = unsupported;
+    }
+}, 1 );
+registerSingleton(IDefaultLogLevelsService, class DefaultLogLevelsService {
+    constructor() {
+        this.getDefaultLogLevels = unsupported;
+        this.setDefaultLogLevel = unsupported;
+        this.migrateLogLevels = unsupported;
+    }
+}, 1 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -96,12 +96,12 @@
   "dependencies": {
     "vscode-marked": "npm:marked@=3.0.2",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-files-service-override": "3.0.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "3.0.0",
-    "@codingame/monaco-vscode-extensions-service-override": "3.0.0",
-    "@codingame/monaco-vscode-environment-service-override": "3.0.0",
-    "@codingame/monaco-vscode-layout-service-override": "3.0.0",
-    "@codingame/monaco-vscode-host-service-override": "3.0.0",
-    "@codingame/monaco-vscode-base-service-override": "3.0.0"
+    "@codingame/monaco-vscode-extensions-service-override": "3.1.0",
+    "@codingame/monaco-vscode-files-service-override": "3.1.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "3.1.0",
+    "@codingame/monaco-vscode-environment-service-override": "3.1.0",
+    "@codingame/monaco-vscode-layout-service-override": "3.1.0",
+    "@codingame/monaco-vscode-host-service-override": "3.1.0",
+    "@codingame/monaco-vscode-base-service-override": "3.1.0"
   }
 }

package/service-override/tools/editorAssets.js

@@ -0,0 +1,3 @@
+import pngAssets from '../../vscode/src/vs/workbench/contrib/debug/browser/media/all.png.js';
+import { registerAssets } from '../../assets.js';
+registerAssets(pngAssets);

package/services.d.ts

@@ -16,14 +16,17 @@ export { IConfigurationChangeEvent, IConfigurationService } from './vscode/src/v
 export { INeverShowAgainOptions, INotification, INotificationActions, INotificationHandle, INotificationProgress, INotificationProgressProperties, INotificationProperties, INotificationService, IPromptChoice, IPromptChoiceWithMenu, IPromptOptions, IStatusMessageOptions, NeverShowAgainScope, NoOpNotification, NoOpProgress, NotificationMessage, NotificationPriority, NotificationsFilter } from './vscode/src/vs/platform/notification/common/notification.js';
 export { IStorageService, StorageScope, StorageTarget } from './vscode/src/vs/platform/storage/common/storage.js';
 export { ITextModelContentProvider, ITextModelService } from './vscode/src/vs/editor/common/services/resolverService.js';
+import { WorkbenchContributionInstantiation } from './vscode/src/vs/workbench/common/contributions.js';
+export { ILazyWorkbenchContributionInstantiation, IOnEditorWorkbenchContributionInstantiation, WorkbenchPhase } from './vscode/src/vs/workbench/common/contributions.js';
 export { ITextFileService } from './vscode/src/vs/workbench/services/textfile/common/textfiles.js';
 export { IAction } from './vscode/src/vs/base/common/actions.js';
 export { IAccessibilitySignalService } from './vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.js';
+export { IWorkbenchLayoutService } from './vscode/src/vs/workbench/services/layout/browser/layoutService.js';
+export { IClipboardService } from './vscode/src/vs/platform/clipboard/common/clipboardService.js';
 export { ILanguageFeaturesService } from './vscode/src/vs/editor/common/services/languageFeatures.js';
 export { ILogService, ILoggerService, LogLevel } from './vscode/src/vs/platform/log/common/log.js';
 export { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/keybinding.js';
 export { IWorkspaceContextService } from './vscode/src/vs/platform/workspace/common/workspace.js';
-export { IClipboardService } from './vscode/src/vs/platform/clipboard/common/clipboardService.js';
 export { IEditorWorkerService } from './vscode/src/vs/editor/common/services/editorWorker.js';
 export { IOpenerService } from './vscode/src/vs/platform/opener/common/opener.js';
 export { IModelService } from './vscode/src/vs/editor/common/services/model.js';
@@ -71,7 +74,6 @@ export { IRemoteSocketFactoryService } from './vscode/src/vs/platform/remote/com
 export { ITerminalInstanceService, ITerminalService } from './vscode/src/vs/workbench/contrib/terminal/browser/terminal.js';
 export { IFilesConfigurationService } from './vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
 export { ILabelService } from './vscode/src/vs/platform/label/common/label.js';
-export { IWorkbenchLayoutService } from './vscode/src/vs/workbench/services/layout/browser/layoutService.js';
 export { IActivityService, IBadge } from './vscode/src/vs/workbench/services/activity/common/activity.js';
 export { IHoverService } from './vscode/src/vs/platform/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';
@@ -87,5 +89,6 @@ declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R
  * Equivalent to `StandaloneServices.withServices` except the callback is called when the services are ready, not just initialized
  */
 declare function withReadyServices(callback: (serviceAccessor: ServicesAccessor) => IDisposable): IDisposable;
+declare const registerWorkbenchContribution: (id: string, contribution: (accessor: ServicesAccessor) => void, instantiation: WorkbenchContributionInstantiation) => void;
 
-export { IEditorOverrideServices, IWorkbenchConstructionOptions, createInstance, createInstanceSync, getService, initialize, withReadyServices };
+export { IEditorOverrideServices, IWorkbenchConstructionOptions, ServicesAccessor, WorkbenchContributionInstantiation, createInstance, createInstanceSync, getService, initialize, registerWorkbenchContribution, withReadyServices };

package/services.js

@@ -1,3 +1,4 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
 import './missing-services.js';
 import './contributions.js';
 import './vscode/src/vs/editor/browser/coreCommands.js';
@@ -68,6 +69,8 @@ import { mixin } from './vscode/src/vs/base/common/objects.js';
 import { IInstantiationService } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 import { IProductService } from './vscode/src/vs/platform/product/common/productService.js';
 import { DisposableStore } from './vscode/src/vs/base/common/lifecycle.js';
+import { registerWorkbenchContribution2 } from './vscode/src/vs/workbench/common/contributions.js';
+export { WorkbenchPhase } from './vscode/src/vs/workbench/common/contributions.js';
 import { initialize as initialize$1 } from './workbench.js';
 import { checkServicesNotInitialized, startup, waitServicesReady, checkServicesReady, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
 import getServiceOverride$2$1 from '@codingame/monaco-vscode-quickaccess-service-override';
@@ -147,9 +150,9 @@ async function initialize(overrides, container = document.body, configuration =
     initialize$1(container, configuration);
     const instantiationService = StandaloneServices.initialize({
         [( IProductService.toString())]: mixin({
-            version: "1.87.0",
+            version: "1.87.1",
             quality: 'oss',
-            commit: "1.87.0",
+            commit: "1.87.1",
             nameShort: 'Code - OSS Dev',
             nameLong: 'Code - OSS Dev',
             applicationName: 'code-oss',
@@ -195,4 +198,15 @@ function withReadyServices(callback) {
     }));
     return disposable;
 }
-export { IInstantiationService, IProductService, StandaloneServices, createInstance, createInstanceSync, getService, initialize, withReadyServices };
+const registerWorkbenchContribution = (id, contribution, instantiation) => {
+    let Contribution = class Contribution {
+        constructor(instantiationService) {
+            instantiationService.invokeFunction(contribution);
+        }
+    };
+    Contribution = __decorate([
+        ( __param(0, IInstantiationService))
+    ], Contribution);
+    registerWorkbenchContribution2(id, Contribution, instantiation);
+};
+export { IInstantiationService, IProductService, StandaloneServices, createInstance, createInstanceSync, getService, initialize, registerWorkbenchContribution, withReadyServices };

package/vscode/src/vs/base/common/lifecycle.js

@@ -1,9 +1,147 @@
+import { compareBy, numberComparator } from './arrays.js';
+import { groupBy } from './collections.js';
+import { SetMap } from './map.js';
 import { createSingleCallFunction } from './functional.js';
 import { Iterable } from './iterator.js';
+let disposableTracker = null;
+class DisposableTracker {
+    constructor() {
+        this.livingDisposables = ( new Map());
+    }
+    static { this.idx = 0; }
+    getDisposableData(d) {
+        let val = this.livingDisposables.get(d);
+        if (!val) {
+            val = { parent: null, source: null, isSingleton: false, value: d, idx: DisposableTracker.idx++ };
+            this.livingDisposables.set(d, val);
+        }
+        return val;
+    }
+    trackDisposable(d) {
+        const data = this.getDisposableData(d);
+        if (!data.source) {
+            data.source =
+                ( new Error()).stack;
+        }
+    }
+    setParent(child, parent) {
+        const data = this.getDisposableData(child);
+        data.parent = parent;
+    }
+    markAsDisposed(x) {
+        this.livingDisposables.delete(x);
+    }
+    markAsSingleton(disposable) {
+        this.getDisposableData(disposable).isSingleton = true;
+    }
+    getRootParent(data, cache) {
+        const cacheValue = cache.get(data);
+        if (cacheValue) {
+            return cacheValue;
+        }
+        const result = data.parent ? this.getRootParent(this.getDisposableData(data.parent), cache) : data;
+        cache.set(data, result);
+        return result;
+    }
+    getTrackedDisposables() {
+        const rootParentCache = ( new Map());
+        const leaking = [...this.livingDisposables.entries()]
+            .filter(([, v]) => v.source !== null && !this.getRootParent(v, rootParentCache).isSingleton)
+            .flatMap(([k]) => k);
+        return leaking;
+    }
+    computeLeakingDisposables(maxReported = 10, preComputedLeaks) {
+        let uncoveredLeakingObjs;
+        if (preComputedLeaks) {
+            uncoveredLeakingObjs = preComputedLeaks;
+        }
+        else {
+            const rootParentCache = ( new Map());
+            const leakingObjects = [...( this.livingDisposables.values())]
+                .filter((info) => info.source !== null && !this.getRootParent(info, rootParentCache).isSingleton);
+            if (leakingObjects.length === 0) {
+                return;
+            }
+            const leakingObjsSet = ( new Set(( leakingObjects.map(o => o.value))));
+            uncoveredLeakingObjs = leakingObjects.filter(l => {
+                return !(l.parent && ( leakingObjsSet.has(l.parent)));
+            });
+            if (uncoveredLeakingObjs.length === 0) {
+                throw new Error('There are cyclic diposable chains!');
+            }
+        }
+        if (!uncoveredLeakingObjs) {
+            return undefined;
+        }
+        function getStackTracePath(leaking) {
+            function removePrefix(array, linesToRemove) {
+                while (array.length > 0 && ( linesToRemove.some(
+                    regexp => typeof regexp === 'string' ? regexp === array[0] : array[0].match(regexp)
+                ))) {
+                    array.shift();
+                }
+            }
+            const lines = ( leaking.source.split('\n').map(p => p.trim().replace('at ', ''))).filter(l => l !== '');
+            removePrefix(lines, ['Error', /^trackDisposable \(.*\)$/, /^DisposableTracker.trackDisposable \(.*\)$/]);
+            return lines.reverse();
+        }
+        const stackTraceStarts = ( new SetMap());
+        for (const leaking of uncoveredLeakingObjs) {
+            const stackTracePath = getStackTracePath(leaking);
+            for (let i = 0; i <= stackTracePath.length; i++) {
+                stackTraceStarts.add(stackTracePath.slice(0, i).join('\n'), leaking);
+            }
+        }
+        uncoveredLeakingObjs.sort(compareBy(l => l.idx, numberComparator));
+        let message = '';
+        let i = 0;
+        for (const leaking of uncoveredLeakingObjs.slice(0, maxReported)) {
+            i++;
+            const stackTracePath = getStackTracePath(leaking);
+            const stackTraceFormattedLines = [];
+            for (let i = 0; i < stackTracePath.length; i++) {
+                let line = stackTracePath[i];
+                const starts = stackTraceStarts.get(stackTracePath.slice(0, i + 1).join('\n'));
+                line = `(shared with ${starts.size}/${uncoveredLeakingObjs.length} leaks) at ${line}`;
+                const prevStarts = stackTraceStarts.get(stackTracePath.slice(0, i).join('\n'));
+                const continuations = groupBy(( [...prevStarts].map(d => getStackTracePath(d)[i])), v => v);
+                delete continuations[stackTracePath[i]];
+                for (const [cont, set] of Object.entries(continuations)) {
+                    stackTraceFormattedLines.unshift(`    - stacktraces of ${set.length} other leaks continue with ${cont}`);
+                }
+                stackTraceFormattedLines.unshift(line);
+            }
+            message += `\n\n\n==================== Leaking disposable ${i}/${uncoveredLeakingObjs.length}: ${leaking.value.constructor.name} ====================\n${stackTraceFormattedLines.join('\n')}\n============================================================\n\n`;
+        }
+        if (uncoveredLeakingObjs.length > maxReported) {
+            message += `\n\n\n... and ${uncoveredLeakingObjs.length - maxReported} more leaking disposables\n\n`;
+        }
+        return { leaks: uncoveredLeakingObjs, details: message };
+    }
+}
+function setDisposableTracker(tracker) {
+    disposableTracker = tracker;
+}
 function trackDisposable(x) {
+    disposableTracker?.trackDisposable(x);
     return x;
 }
+function markAsDisposed(disposable) {
+    disposableTracker?.markAsDisposed(disposable);
+}
+function setParentOfDisposable(child, parent) {
+    disposableTracker?.setParent(child, parent);
+}
+function setParentOfDisposables(children, parent) {
+    if (!disposableTracker) {
+        return;
+    }
+    for (const child of children) {
+        disposableTracker.setParent(child, parent);
+    }
+}
 function markAsSingleton(singleton) {
+    disposableTracker?.markAsSingleton(singleton);
     return singleton;
 }
 function isDisposable(thing) {
@@ -45,11 +183,13 @@ function disposeIfDisposable(disposables) {
 }
 function combinedDisposable(...disposables) {
     const parent = toDisposable(() => dispose(disposables));
+    setParentOfDisposables(disposables, parent);
     return parent;
 }
 function toDisposable(fn) {
     const self = trackDisposable({
         dispose: createSingleCallFunction(() => {
+            markAsDisposed(self);
             fn();
         })
     });
@@ -60,11 +200,13 @@ class DisposableStore {
     constructor() {
         this._toDispose = ( new Set());
         this._isDisposed = false;
+        trackDisposable(this);
     }
     dispose() {
         if (this._isDisposed) {
             return;
         }
+        markAsDisposed(this);
         this._isDisposed = true;
         this.clear();
     }
@@ -89,6 +231,7 @@ class DisposableStore {
         if (o === this) {
             throw new Error('Cannot register a disposable on itself!');
         }
+        setParentOfDisposable(o, this);
         if (this._isDisposed) {
             if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
                 console.warn(( new Error(
@@ -117,6 +260,7 @@ class DisposableStore {
         }
         if (( this._toDispose.has(o))) {
             this._toDispose.delete(o);
+            setParentOfDisposable(o, null);
         }
     }
 }
@@ -124,8 +268,11 @@ class Disposable {
     static { this.None = ( Object.freeze({ dispose() { } })); }
     constructor() {
         this._store = ( new DisposableStore());
+        trackDisposable(this);
+        setParentOfDisposable(this._store, this);
     }
     dispose() {
+        markAsDisposed(this);
         this._store.dispose();
     }
     _register(o) {
@@ -138,6 +285,7 @@ class Disposable {
 class MutableDisposable {
     constructor() {
         this._isDisposed = false;
+        trackDisposable(this);
     }
     get value() {
         return this._isDisposed ? undefined : this._value;
@@ -147,6 +295,9 @@ class MutableDisposable {
             return;
         }
         this._value?.dispose();
+        if (value) {
+            setParentOfDisposable(value, this);
+        }
         this._value = value;
     }
     clear() {
@@ -154,12 +305,16 @@ class MutableDisposable {
     }
     dispose() {
         this._isDisposed = true;
+        markAsDisposed(this);
         this._value?.dispose();
         this._value = undefined;
     }
     clearAndLeak() {
         const oldValue = this._value;
         this._value = undefined;
+        if (oldValue) {
+            setParentOfDisposable(oldValue, null);
+        }
         return oldValue;
     }
 }
@@ -249,8 +404,10 @@ class DisposableMap {
     constructor() {
         this._store = ( new Map());
         this._isDisposed = false;
+        trackDisposable(this);
     }
     dispose() {
+        markAsDisposed(this);
         this._isDisposed = true;
         this.clearAndDisposeAll();
     }
@@ -299,4 +456,4 @@ class DisposableMap {
         return this._store[Symbol.iterator]();
     }
 }
-export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsSingleton, toDisposable, trackDisposable };
+export { AsyncReferenceCollection, Disposable, DisposableMap, DisposableStore, DisposableTracker, ImmortalReference, MandatoryMutableDisposable, MutableDisposable, RefCountedDisposable, ReferenceCollection, combinedDisposable, dispose, disposeIfDisposable, isDisposable, markAsDisposed, markAsSingleton, setDisposableTracker, toDisposable, trackDisposable };

package/vscode/src/vs/base/common/observableInternal/autorun.js

@@ -1,5 +1,5 @@
 import { assertFn } from '../assert.js';
-import { toDisposable, DisposableStore } from '../lifecycle.js';
+import { toDisposable, DisposableStore, trackDisposable, markAsDisposed } from '../lifecycle.js';
 import { DebugNameData } from './debugName.js';
 function autorun(fn) {
     return ( new AutorunObserver(( new DebugNameData(undefined, undefined, fn)), fn, undefined, undefined));
@@ -50,6 +50,7 @@ class AutorunObserver {
         this.dependenciesToBeRemoved = ( new Set());
         this.changeSummary = this.createChangeSummary?.();
         this._runIfNeeded();
+        trackDisposable(this);
     }
     dispose() {
         this.disposed = true;
@@ -57,6 +58,7 @@ class AutorunObserver {
             o.removeObserver(this);
         }
         this.dependencies.clear();
+        markAsDisposed(this);
     }
     _runIfNeeded() {
         if (this.state === 3 ) {

package/vscode/src/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.js

@@ -213,6 +213,9 @@ let WordHighlighter = class WordHighlighter {
             this._onPositionChanged(e);
         }));
         this.toUnhook.add(editor.onDidFocusEditorText((e) => {
+            if (this.occurrencesHighlight === 'off') {
+                return;
+            }
             if (!this.workerRequest) {
                 this._run();
             }