@codingame/monaco-vscode-api 1.79.0 → 1.79.1

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.js

@@ -1,3 +1,110 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const IUntitledTextEditorService = ( createDecorator('untitledTextEditorService'));
-export { IUntitledTextEditorService };
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { UntitledTextEditorModel } from './untitledTextEditorModel.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const IUntitledTextEditorService = ( (createDecorator('untitledTextEditorService')));
+let UntitledTextEditorService = class UntitledTextEditorService extends Disposable {
+    constructor(instantiationService, configurationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this._onDidChangeDirty = this._register(( (new Emitter())));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeEncoding = this._register(( (new Emitter())));
+        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
+        this._onWillDispose = this._register(( (new Emitter())));
+        this.onWillDispose = this._onWillDispose.event;
+        this._onDidChangeLabel = this._register(( (new Emitter())));
+        this.onDidChangeLabel = this._onDidChangeLabel.event;
+        this.mapResourceToModel = ( (new ResourceMap()));
+    }
+    get(resource) {
+        return this.mapResourceToModel.get(resource);
+    }
+    getValue(resource) {
+        return this.get(resource)?.textEditorModel?.getValue();
+    }
+    async resolve(options) {
+        const model = this.doCreateOrGet(options);
+        await model.resolve();
+        return model;
+    }
+    create(options) {
+        return this.doCreateOrGet(options);
+    }
+    doCreateOrGet(options = Object.create(null)) {
+        const massagedOptions = this.massageOptions(options);
+        if (massagedOptions.untitledResource && ( (this.mapResourceToModel.has(massagedOptions.untitledResource)))) {
+            return this.mapResourceToModel.get(massagedOptions.untitledResource);
+        }
+        return this.doCreate(massagedOptions);
+    }
+    massageOptions(options) {
+        const massagedOptions = Object.create(null);
+        if (options.associatedResource) {
+            massagedOptions.untitledResource = ( (URI.from({
+                scheme: Schemas.untitled,
+                authority: options.associatedResource.authority,
+                fragment: options.associatedResource.fragment,
+                path: options.associatedResource.path,
+                query: options.associatedResource.query
+            })));
+            massagedOptions.associatedResource = options.associatedResource;
+        }
+        else {
+            if (options.untitledResource?.scheme === Schemas.untitled) {
+                massagedOptions.untitledResource = options.untitledResource;
+            }
+        }
+        if (options.languageId) {
+            massagedOptions.languageId = options.languageId;
+        }
+        else if (!massagedOptions.associatedResource) {
+            const configuration = this.configurationService.getValue();
+            if (configuration.files?.defaultLanguage) {
+                massagedOptions.languageId = configuration.files.defaultLanguage;
+            }
+        }
+        massagedOptions.encoding = options.encoding;
+        massagedOptions.initialValue = options.initialValue;
+        return massagedOptions;
+    }
+    doCreate(options) {
+        let untitledResource = options.untitledResource;
+        if (!untitledResource) {
+            let counter = 1;
+            do {
+                untitledResource = ( ( URI.from({ scheme: Schemas.untitled, path: `Untitled-${counter}` })));
+                counter++;
+            } while (( (this.mapResourceToModel.has(untitledResource))));
+        }
+        const model = this._register(this.instantiationService.createInstance(UntitledTextEditorModel, untitledResource, !!options.associatedResource, options.initialValue, options.languageId, options.encoding));
+        this.registerModel(model);
+        return model;
+    }
+    registerModel(model) {
+        const modelListeners = ( (new DisposableStore()));
+        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
+        modelListeners.add(model.onDidChangeName(() => this._onDidChangeLabel.fire(model)));
+        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
+        modelListeners.add(model.onWillDispose(() => this._onWillDispose.fire(model)));
+        Event.once(model.onWillDispose)(() => {
+            this.mapResourceToModel.delete(model.resource);
+            modelListeners.dispose();
+        });
+        this.mapResourceToModel.set(model.resource, model);
+        if (model.isDirty()) {
+            this._onDidChangeDirty.fire(model);
+        }
+    }
+};
+UntitledTextEditorService = ( (__decorate([
+    ( (__param(0, IInstantiationService))),
+    ( (__param(1, IConfigurationService)))
+], UntitledTextEditorService)));
+export { IUntitledTextEditorService, UntitledTextEditorService };

package/dist/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.js

@@ -3,5 +3,5 @@ import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/com
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 const IUserDataProfileService = ( createDecorator('IUserDataProfileService'));
-const defaultUserDataProfileIcon = ( registerIcon('defaultProfile-icon', Codicon.settings, ( localize('defaultProfileIcon', 'Icon for Default Profile.'))));
+const defaultUserDataProfileIcon = registerIcon('defaultProfile-icon', Codicon.settings, ( localize('defaultProfileIcon', 'Icon for Default Profile.')));
 export { IUserDataProfileService, defaultUserDataProfileIcon };

package/dist/vscode-services/extHost.js

@@ -35,7 +35,7 @@ import { IExtHostLocalizationService, ExtHostLocalizationService } from '../vsco
 import { IExtHostEditorTabs, ExtHostEditorTabs } from '../vscode/vs/workbench/api/common/extHostEditorTabs.js';
 import { registerSingleton } from 'monaco-editor/esm/vs/platform/instantiation/common/extensions.js';
 import { BufferedEmitter } from '../vscode/vs/base/parts/ipc/common/ipc.net.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { RPCProtocol } from '../vscode/vs/workbench/services/extensions/common/rpcProtocol.js';
 import { IExtHostConsumerFileSystem, ExtHostConsumerFileSystem } from '../vscode/vs/workbench/api/common/extHostFileSystemConsumer.js';
 import { IExtHostInitDataService } from '../vscode/vs/workbench/api/common/extHostInitDataService.js';
@@ -53,6 +53,7 @@ import { IExtHostOutputService, ExtHostOutputService } from '../vscode/vs/workbe
 import { ExtHostTreeViews } from '../vscode/vs/workbench/api/common/extHostTreeViews.js';
 import { ExtHostStorage } from '../vscode/vs/workbench/api/common/extHostStorage.js';
 import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ExtHostStatusBar } from '../vscode/vs/workbench/api/common/extHostStatusBar.js';
 import '../vscode/vs/workbench/api/browser/mainThreadLocalization.js';
 import '../vscode/vs/workbench/api/browser/mainThreadCommands.js';
 import '../vscode/vs/workbench/api/browser/mainThreadWindow.js';
@@ -77,7 +78,9 @@ import '../vscode/vs/workbench/api/browser/mainThreadOutputService.js';
 import '../vscode/vs/workbench/api/browser/mainThreadSaveParticipant.js';
 import '../vscode/vs/workbench/api/browser/mainThreadTreeViews.js';
 import '../vscode/vs/workbench/api/browser/mainThreadStorage.js';
+import '../vscode/vs/workbench/api/browser/mainThreadStatusBar.js';
 import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Barrier } from 'monaco-editor/esm/vs/base/common/async.js';
 import { unsupported } from '../tools.js';
 const original = MainThreadMessageService.prototype.$showMessage;
 MainThreadMessageService.prototype.$showMessage = function (severity, message, options, commands) {
@@ -319,6 +322,7 @@ async function createExtHostServices() {
     const extHostBulkEdits = new ExtHostBulkEdits(rpcProtocol, extHostDocumentsAndEditors);
     const extHostClipboard = new ExtHostClipboard(mainContext);
     const extHostMessageService = new ExtHostMessageService(rpcProtocol, logService);
+    const extHostStatusBar = new ExtHostStatusBar(rpcProtocol, extHostCommands.converter);
     ExtHostApiCommands.register(extHostCommands);
     const namedCustomers = ExtHostCustomersRegistry.getNamedCustomers();
     for (let i = 0, len = namedCustomers.length; i < len; i++) {
@@ -374,18 +378,21 @@ async function createExtHostServices() {
         extHostOutputService,
         extHostTreeViews,
         extHostStorage,
-        extHostLocalization
+        extHostLocalization,
+        extHostStatusBar
     };
 }
 let extHostServices;
 let configProvider;
 let initializePromise;
-const extHostInitializedEmitter = new Emitter();
-const onExtHostInitialized = extHostInitializedEmitter.event;
+const extHostInitializedBarrier = new Barrier();
+function onExtHostInitialized(fct) {
+    void extHostInitializedBarrier.wait().then(fct);
+}
 async function _initialize() {
     extHostServices = await createExtHostServices();
     configProvider = await extHostServices.extHostConfiguration.getConfigProvider();
-    extHostInitializedEmitter.fire();
+    extHostInitializedBarrier.open();
 }
 async function initialize() {
     if (initializePromise == null) {

package/dist/vscode-services/missing-services.js

@@ -54,7 +54,6 @@ import { BrowserPathService } from '../vscode/vs/workbench/services/path/browser
 import { IRemoteAgentService } from '../vscode/vs/workbench/services/remote/common/remoteAgentService.js';
 import { ICustomEndpointTelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
 import { NullEndpointTelemetryService } from '../vscode/vs/platform/telemetry/common/telemetryUtils.js';
-import { SearchService } from '../vscode/vs/workbench/services/search/common/searchService.js';
 import { ISearchService } from '../vscode/vs/workbench/services/search/common/search.js';
 import { IRequestService } from '../vscode/vs/platform/request/common/request.js';
 import { IEditSessionIdentityService } from '../vscode/vs/platform/workspace/common/editSessions.js';
@@ -96,6 +95,14 @@ import { TreeViewsDnDService } from 'monaco-editor/esm/vs/editor/common/services
 import { ITreeViewsDnDService } from 'monaco-editor/esm/vs/editor/common/services/treeViewsDndService.js';
 import { TreeviewsService } from '../vscode/vs/workbench/services/views/common/treeViewsService.js';
 import { ITreeViewsService } from '../vscode/vs/workbench/services/views/browser/treeViewsService.js';
+import { IBreadcrumbsService } from '../vscode/vs/workbench/browser/parts/editor/breadcrumbs.js';
+import { ISemanticSimilarityService } from '../vscode/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.js';
+import { IInteractiveSessionService } from '../vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionService.js';
+import { IOutlineService } from '../vscode/vs/workbench/services/outline/browser/outline.js';
+import { IUpdateService, State } from '../vscode/vs/platform/update/common/update.js';
+import { IStatusbarService } from '../vscode/vs/workbench/services/statusbar/browser/statusbar.js';
+import { IExtensionGalleryService } from '../vscode/vs/platform/extensionManagement/common/extensionManagement.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { unsupported } from '../tools.js';
 class NullLoggerService extends AbstractLoggerService {
     constructor() {
@@ -708,7 +715,7 @@ registerSingleton(IHistoryService, class HistoryService {
         this.goPrevious = unsupported;
         this.goLast = unsupported;
         this.reopenLastClosedEditor = unsupported;
-        this.getHistory = unsupported;
+        this.getHistory = () => [];
         this.removeFromHistory = unsupported;
         this.getLastActiveWorkspaceRoot = () => undefined;
         this.getLastActiveFile = () => undefined;
@@ -786,7 +793,32 @@ registerSingleton(IRemoteAgentService, class RemoteAgentService {
     }
 }, 0 );
 registerSingleton(ICustomEndpointTelemetryService, NullEndpointTelemetryService, 0 );
-registerSingleton(ISearchService, SearchService, 0 );
+let MonacoSearchService = class MonacoSearchService {
+    constructor(modelService) {
+        this.modelService = modelService;
+        this.registerSearchResultProvider = unsupported;
+    }
+    async textSearch() {
+        return {
+            results: [],
+            messages: []
+        };
+    }
+    async fileSearch() {
+        return {
+            results: ( this.modelService.getModels().map(model => ({
+                resource: model.uri
+            }))),
+            messages: []
+        };
+    }
+    async clearCache() {
+    }
+};
+MonacoSearchService = __decorate([
+    ( __param(0, IModelService))
+], MonacoSearchService);
+registerSingleton(ISearchService, MonacoSearchService, 0 );
 registerSingleton(IEditSessionIdentityService, class EditSessionIdentityService {
     constructor() {
         this.registerEditSessionIdentityProvider = unsupported;
@@ -1009,3 +1041,85 @@ registerSingleton(ILanguagePackService, class LanguagePackService {
 }, 1 );
 registerSingleton(ITreeViewsDnDService, TreeViewsDnDService, 1 );
 registerSingleton(ITreeViewsService, TreeviewsService, 1 );
+registerSingleton(IBreadcrumbsService, class BreadcrumbsService {
+    constructor() {
+        this.register = unsupported;
+        this.getWidget = () => undefined;
+    }
+}, 0 );
+registerSingleton(ISemanticSimilarityService, class SemanticSimilarityService {
+    constructor() {
+        this.isEnabled = () => false;
+        this.getSimilarityScore = unsupported;
+        this.registerSemanticSimilarityProvider = unsupported;
+    }
+}, 1 );
+registerSingleton(IInteractiveSessionService, class InteractiveSessionService {
+    constructor() {
+        this.registerProvider = unsupported;
+        this.getProviderInfos = unsupported;
+        this.startSession = unsupported;
+        this.retrieveSession = unsupported;
+        this.sendRequest = unsupported;
+        this.cancelCurrentRequestForSession = unsupported;
+        this.getSlashCommands = unsupported;
+        this.clearSession = unsupported;
+        this.addInteractiveRequest = unsupported;
+        this.addCompleteRequest = unsupported;
+        this.sendInteractiveRequestToProvider = unsupported;
+        this.getHistory = unsupported;
+        this.onDidPerformUserAction = Event.None;
+        this.notifyUserAction = unsupported;
+    }
+}, 1 );
+registerSingleton(IOutlineService, class OutlineService {
+    constructor() {
+        this.onDidChange = Event.None;
+        this.canCreateOutline = () => false;
+        this.createOutline = async () => undefined;
+        this.registerOutlineCreator = unsupported;
+    }
+}, 0 );
+registerSingleton(IUpdateService, class UpdateService {
+    constructor() {
+        this.onStateChange = Event.None;
+        this.state = State.Uninitialized;
+        this.checkForUpdates = unsupported;
+        this.downloadUpdate = unsupported;
+        this.applyUpdate = unsupported;
+        this.quitAndInstall = unsupported;
+        this.isLatestVersion = unsupported;
+        this._applySpecificUpdate = unsupported;
+    }
+}, 0 );
+registerSingleton(IStatusbarService, class StatusbarService {
+    constructor() {
+        this.onDidChangeEntryVisibility = Event.None;
+        this.addEntry = unsupported;
+        this.isEntryVisible = unsupported;
+        this.updateEntryVisibility = unsupported;
+        this.focus = unsupported;
+        this.focusNextEntry = unsupported;
+        this.focusPreviousEntry = unsupported;
+        this.isEntryFocused = unsupported;
+        this.overrideStyle = unsupported;
+    }
+}, 0 );
+registerSingleton(IExtensionGalleryService, class ExtensionGalleryService {
+    constructor() {
+        this.isEnabled = () => false;
+        this.query = unsupported;
+        this.getExtensions = unsupported;
+        this.isExtensionCompatible = unsupported;
+        this.getCompatibleExtension = unsupported;
+        this.getAllCompatibleVersions = unsupported;
+        this.download = unsupported;
+        this.downloadSignatureArchive = unsupported;
+        this.reportStatistic = unsupported;
+        this.getReadme = unsupported;
+        this.getManifest = unsupported;
+        this.getChangelog = unsupported;
+        this.getCoreTranslation = unsupported;
+        this.getExtensionsControlManifest = unsupported;
+    }
+}, 0 );

package/dist/vscode-services/window.js

@@ -95,8 +95,27 @@ function create(getExtension, workspace) {
         showOpenDialog: unsupported,
         showSaveDialog: unsupported,
         createWebviewPanel: unsupported,
-        setStatusBarMessage: unsupported,
-        createStatusBarItem: unsupported,
+        createStatusBarItem(alignmentOrId, priorityOrAlignment, priorityArg) {
+            const { extHostStatusBar } = getExtHostServices();
+            const extension = getExtension();
+            let id;
+            let alignment;
+            let priority;
+            if (typeof alignmentOrId === 'string') {
+                id = alignmentOrId;
+                alignment = priorityOrAlignment;
+                priority = priorityArg;
+            }
+            else {
+                alignment = alignmentOrId;
+                priority = priorityOrAlignment;
+            }
+            return extHostStatusBar.createStatusBarEntry(extension, id, alignment, priority);
+        },
+        setStatusBarMessage(text, timeoutOrThenable) {
+            const { extHostStatusBar } = getExtHostServices();
+            return extHostStatusBar.setStatusBarMessage(text, timeoutOrThenable);
+        },
         createTerminal: unsupported,
         registerTreeDataProvider(viewId, treeDataProvider) {
             const { extHostTreeViews } = getExtHostServices();

package/dist/vscode-services/workspace.js

@@ -158,7 +158,8 @@ function create(getExtension) {
             return extHostWorkspace.name;
         },
         onDidChangeNotebookDocument: unsupported,
-        onDidSaveNotebookDocument: unsupported
+        onDidSaveNotebookDocument: unsupported,
+        onWillSaveNotebookDocument: unsupported
     };
 }
 export { create as default };

package/dist/workbenchThemeService.d.ts

@@ -17,4 +17,4 @@ interface IThemeExtensionPoint {
     _watch: boolean;
 }
 
-export { IThemeScopedColorCustomizations as I, IColorCustomizations as a, IThemeExtensionPoint as b };
+export { IThemeExtensionPoint as I, IThemeScopedColorCustomizations as a, IColorCustomizations as b };

package/dist/workers/textMate.worker.d.ts

@@ -0,0 +1,2 @@
+
+export { }

package/dist/workers/textMate.worker.js

@@ -0,0 +1,3 @@
+import { TextMateTokenizationWorker } from '../vscode/vs/workbench/services/textMate/browser/worker/textMate.worker.js';
+import { initialize } from 'monaco-editor/esm/vs/editor/editor.worker.js';
+initialize((ctx, createData) => new TextMateTokenizationWorker(ctx, createData));

package/dist/workspace.d.ts

@@ -138,4 +138,4 @@ interface IWorkspaceFolder extends IWorkspaceFolderData {
     toResource: (relativePath: string) => URI;
 }
 
-export { IWorkspaceFolder as I, IWorkspaceContextService as a, IAnyWorkspaceIdentifier as b };
+export { IAnyWorkspaceIdentifier as I, IWorkspaceFolder as a, IWorkspaceContextService as b };