@codingame/monaco-vscode-api 1.79.0-next.0 → 1.79.1

package/dist/service-override/files.js

@@ -12,6 +12,7 @@ import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/li
 import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 export { HTMLFileSystemProvider } from 'monaco-editor/esm/vs/platform/files/browser/htmlFileSystemProvider.js';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
 import '../vscode/vs/workbench/contrib/files/browser/files.contribution.js';
 class File {
     constructor(getContent) {
@@ -73,8 +74,7 @@ class SimpleTextFileSystemProvider {
     }
     async mkdir() {
     }
-    async readdir(directory) {
-        console.debug('Not implemented: readdir', directory);
+    async readdir(_directory) {
         return [];
     }
     delete() {
@@ -84,6 +84,17 @@ class SimpleTextFileSystemProvider {
         throw createFileSystemProviderError('Not allowed', FileSystemProviderErrorCode.NoPermissions);
     }
 }
+class TypescriptWorkerFileSystemProvider extends SimpleTextFileSystemProvider {
+    async getFileContent(resource) {
+        const typescript = monaco.languages.typescript;
+        if (typescript == null) {
+            return undefined;
+        }
+        const path = resource.path.slice(1);
+        return typescript.typescriptDefaults.getExtraLibs()[path]?.content ?? typescript.javascriptDefaults.getExtraLibs()[path]?.content;
+    }
+    async setFileContent() { }
+}
 class ExtensionFileSystemProviderWithFileReadWriteCapability {
     constructor() {
         this.capabilities = 2  | 1024  | 2048 ;
@@ -263,4 +274,5 @@ function registerExtensionFile(extensionLocation, path, getContent) {
 function registerFileSystemOverlay(provider) {
     return fileSystemProvider.register(provider);
 }
+registerFileSystemOverlay(new TypescriptWorkerFileSystemProvider());
 export { FileType, SimpleTextFileSystemProvider, getServiceOverride as default, registerExtensionFile, registerFileSystemOverlay };

package/dist/service-override/keybindings.js

@@ -1,91 +1,15 @@
-import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
 import '../vscode-services/missing-services.js';
-import { StandaloneServices, StandaloneKeybindingService } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { WorkbenchKeybindingService } from '../vscode/vs/workbench/services/keybinding/browser/keybindingService.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
 import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { KeybindingResolver } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingResolver.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
-import { StandaloneCommandsQuickAccessProvider } from 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
-import { CommandsQuickAccessProvider } from '../vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js';
 import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
 import { IKeyboardLayoutService } from '../vscode/vs/platform/keyboardLayout/common/keyboardLayout.js';
 import { BrowserKeyboardLayoutService } from '../vscode/vs/workbench/services/keybinding/browser/keyboardLayoutService.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import getServiceOverride$1 from './files.js';
-import { createInjectedClass } from '../tools/injection.js';
-let DelegateStandaloneKeybindingService = class DelegateStandaloneKeybindingService extends createInjectedClass(StandaloneKeybindingService) {
-    constructor(instantiationService) {
-        super(instantiationService);
-        this.delegate = instantiationService.createInstance(WorkbenchKeybindingService);
-        this._cachedOverridenResolver = null;
-        this.onDidUpdateKeybindings(() => {
-            this._cachedOverridenResolver = null;
-        });
-        this.delegate.onDidUpdateKeybindings(() => {
-            this._cachedOverridenResolver = null;
-        });
-    }
-    _getResolver() {
-        if (this._cachedOverridenResolver == null) {
-            const overrides = this['_toNormalizedKeybindingItems'](this['_dynamicKeybindings'], false);
-            this._cachedOverridenResolver = new KeybindingResolver(
-            [...this.delegate['_getResolver']().getKeybindings()], overrides, (str) => this._log(str));
-        }
-        return this._cachedOverridenResolver;
-    }
-};
-DelegateStandaloneKeybindingService = __decorate([
-    ( __param(0, IInstantiationService))
-], DelegateStandaloneKeybindingService);
-const quickAccessRegistry = ( Registry.as(Extensions.Quickaccess));
-const provider = quickAccessRegistry.getQuickAccessProviders().find(provider => provider.ctor === StandaloneCommandsQuickAccessProvider);
-if (provider != null) {
-    provider.ctor = class extends CommandsQuickAccessProvider {
-        get defaultFilterValue() { return undefined; }
-        async getCommandPicks(token) {
-            return ( (await super.getCommandPicks(token)).map(pick => {
-                pick.buttons = [];
-                return pick;
-            }));
-        }
-    };
-}
-const configurationRegistry = ( Registry.as(Extensions$1.Configuration));
-configurationRegistry.registerConfiguration({
-    properties: {
-        'workbench.commandPalette.history': {
-            type: 'number',
-            description: ( localize(
-                'commandHistory',
-                'Controls the number of recently used commands to keep in history for the command palette. Set to 0 to disable command history.'
-            )),
-            default: 50,
-            minimum: 0
-        },
-        'workbench.commandPalette.preserveInput': {
-            type: 'boolean',
-            description: ( localize(
-                'preserveInput',
-                'Controls whether the last typed input to the command palette should be restored when opening it the next time.'
-            )),
-            default: false
-        },
-        'workbench.commandPalette.experimental.suggestCommands': {
-            type: 'boolean',
-            description: ( localize(
-                'suggestCommands',
-                'Controls whether the command palette should have a list of commonly used commands.'
-            )),
-            default: false
-        }
-    }
-});
+import '../vscode/vs/workbench/browser/workbench.contribution.js';
 async function updateUserKeybindings(keybindingsJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
     await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsJson));
@@ -93,7 +17,7 @@ async function updateUserKeybindings(keybindingsJson) {
 function getServiceOverride() {
     return {
         ...getServiceOverride$1(),
-        [( IKeybindingService.toString())]: new SyncDescriptor(DelegateStandaloneKeybindingService),
+        [( IKeybindingService.toString())]: new SyncDescriptor(WorkbenchKeybindingService),
         [( IKeyboardLayoutService.toString())]: new SyncDescriptor(BrowserKeyboardLayoutService, undefined, true)
     };
 }

package/dist/service-override/layout.js

@@ -3,7 +3,7 @@ import '../vscode-services/missing-services.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { IWorkbenchLayoutService } from '../vscode/vs/workbench/services/layout/browser/layoutService.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { isAncestorUsingFlowTo } from 'monaco-editor/esm/vs/base/browser/dom.js';
@@ -13,6 +13,7 @@ let LayoutService = class LayoutService {
     constructor(container, paneCompositeService) {
         this.container = container;
         this.paneCompositeService = paneCompositeService;
+        this.onDidChangeFullscreen = Event.None;
         this.parts = new Map();
         this.hiddenParts = new Set();
         this._onDidChangePartVisibility = new Emitter();
@@ -23,6 +24,9 @@ let LayoutService = class LayoutService {
         window.addEventListener('resize', () => this.layout());
         this.layout();
     }
+    getMaximumEditorDimensions() {
+        return new dom.Dimension(Infinity, Infinity);
+    }
     isPanelMaximized() {
         return false;
     }
@@ -112,4 +116,4 @@ function getServiceOverride(container = document.body) {
         [( IWorkbenchLayoutService.toString())]: new SyncDescriptor(LayoutService, [container])
     };
 }
-export { getServiceOverride as default };
+export { LayoutService, getServiceOverride as default };

package/dist/service-override/model.d.ts

@@ -0,0 +1,7 @@
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import '../instantiation.js';
+import 'monaco-editor';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/dist/service-override/model.js

@@ -0,0 +1,10 @@
+import '../vscode-services/missing-services.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { TextModelResolverService } from '../vscode/vs/workbench/services/textmodelResolver/common/textModelResolverService.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+function getServiceOverride() {
+    return {
+        [( ITextModelService.toString())]: new SyncDescriptor(TextModelResolverService, undefined, true)
+    };
+}
+export { getServiceOverride as default };

package/dist/service-override/quickaccess.d.ts

@@ -0,0 +1,7 @@
+import { I as IEditorOverrideServices } from '../standaloneServices.js';
+import '../instantiation.js';
+import 'monaco-editor';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/dist/service-override/quickaccess.js

@@ -0,0 +1,80 @@
+import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
+import '../vscode-services/missing-services.js';
+import { CommandsQuickAccessProvider } from '../vscode/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { StandaloneQuickInputService } from 'monaco-editor/esm/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { QuickInputService } from '../vscode/vs/workbench/services/quickinput/browser/quickInputService.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { StandaloneCodeEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import '../vscode/vs/workbench/contrib/codeEditor/browser/quickaccess/gotoLineQuickAccess.js';
+import '../vscode/vs/workbench/browser/actions/quickAccessActions.js';
+import '../vscode/vs/workbench/contrib/quickaccess/browser/quickAccess.contribution.js';
+import '../vscode/vs/workbench/contrib/search/browser/search.contribution.js';
+const originalGetCommandPicks = CommandsQuickAccessProvider.prototype['getCommandPicks'];
+CommandsQuickAccessProvider.prototype['getCommandPicks'] = async function (token) {
+    return ( (await originalGetCommandPicks.call(this, token)).map(pick => {
+        pick.buttons = [];
+        return pick;
+    }));
+};
+let DelegateQuickInputService = class DelegateQuickInputService {
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.workbenchQuickInputService = instantiationService.createInstance(QuickInputService);
+    }
+    get activeService() {
+        const activeCodeEditor = StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor();
+        if (!(activeCodeEditor instanceof StandaloneCodeEditor)) {
+            return this.workbenchQuickInputService;
+        }
+        this.standaloneQuickInputService ?? (this.standaloneQuickInputService = this.instantiationService.createInstance(StandaloneQuickInputService));
+        return this.standaloneQuickInputService;
+    }
+    get quickAccess() { return this.activeService.quickAccess; }
+    get backButton() { return this.activeService.backButton; }
+    get onShow() { return this.activeService.onShow; }
+    get onHide() { return this.activeService.onHide; }
+    pick(picks, options = {}, token = CancellationToken.None) {
+        return this.activeService .pick(picks, options, token);
+    }
+    input(options, token) {
+        return this.activeService.input(options, token);
+    }
+    createQuickPick() {
+        return this.activeService.createQuickPick();
+    }
+    createInputBox() {
+        return this.activeService.createInputBox();
+    }
+    focus() {
+        return this.activeService.focus();
+    }
+    toggle() {
+        return this.activeService.toggle();
+    }
+    navigate(next, quickNavigate) {
+        return this.activeService.navigate(next, quickNavigate);
+    }
+    accept() {
+        return this.activeService.accept();
+    }
+    back() {
+        return this.activeService.back();
+    }
+    cancel() {
+        return this.activeService.cancel();
+    }
+};
+DelegateQuickInputService = __decorate([
+    ( __param(0, IInstantiationService))
+], DelegateQuickInputService);
+function getServiceOverride() {
+    return {
+        [( IQuickInputService.toString())]: new SyncDescriptor(DelegateQuickInputService)
+    };
+}
+export { getServiceOverride as default };

package/dist/service-override/snippets.js

@@ -1,11 +1,15 @@
 import '../vscode-services/missing-services.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { ISnippetsService } from '../vscode/vs/workbench/contrib/snippets/browser/snippets.js';
 import { SnippetsService } from '../vscode/vs/workbench/contrib/snippets/browser/snippetsService.js';
+import { ILifecycleService } from '../vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
 import getServiceOverride$1 from './files.js';
 import { registerServiceInitializeParticipant } from '../services.js';
 registerServiceInitializeParticipant(async (accessor) => {
-    accessor.get(ISnippetsService);
+    void accessor.get(ILifecycleService).when(2 ).then(() => {
+        StandaloneServices.get(ISnippetsService);
+    });
 });
 function getServiceOverride() {
     return {

package/dist/service-override/textmate.js

@@ -1,21 +1,26 @@
 import { __decorate, __param } from '../node_modules/tslib/tslib.es6.js';
 import '../vscode-services/missing-services.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { ITextMateTokenizationService } from '../vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeature.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { TextMateTokenizationFeature } from '../vscode/vs/workbench/services/textMate/browser/textMateTokenizationFeatureImpl.js';
 import { TokenClassificationExtensionPoints } from '../vscode/vs/workbench/services/themes/common/tokenClassificationExtensionPoint.js';
 import { Extensions } from '../vscode/vs/workbench/common/contributions.js';
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { ILifecycleService } from '../vscode/vs/workbench/services/lifecycle/common/lifecycle.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import _onigWasm from 'vscode-oniguruma/release/onig.wasm';
 import getServiceOverride$1 from './files.js';
 import { registerServiceInitializeParticipant } from '../services.js';
 import { registerAssets } from '../assets.js';
 registerAssets({
-    'vscode-oniguruma/../onig.wasm': _onigWasm
+    'vscode-oniguruma/../onig.wasm': _onigWasm,
+    'vs/../../node_modules/vscode-oniguruma/release/onig.wasm': _onigWasm
 });
 registerServiceInitializeParticipant(async (accessor) => {
-    accessor.get(ITextMateTokenizationService);
+    void accessor.get(ILifecycleService).when(2 ).then(() => {
+        StandaloneServices.get(ITextMateTokenizationService);
+    });
 });
 let ExtensionPoints = class ExtensionPoints {
     constructor(instantiationService) {

package/dist/service-override/theme.d.ts

@@ -1,4 +1,4 @@
-import { b as IThemeExtensionPoint } from '../workbenchThemeService.js';
+import { I as IThemeExtensionPoint } from '../workbenchThemeService.js';
 import { I as IEditorOverrideServices } from '../standaloneServices.js';
 import '../instantiation.js';
 import 'monaco-editor';

package/dist/service-override/tools/editor.js

@@ -0,0 +1,73 @@
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { isPreferredGroup, SIDE_GROUP } from '../../vscode/vs/workbench/services/editor/common/editorService.js';
+import { isResourceEditorInput, isEditorInput } from '../../vscode/vs/workbench/common/editor.js';
+import { applyTextEditorOptions } from '../../vscode/vs/workbench/common/editor/editorOptions.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from '../../vscode/vs/workbench/browser/parts/editor/editor.js';
+import { StandaloneEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import { unsupported } from '../../tools.js';
+class SimpleEditorPane {
+    constructor(editor) {
+        this.editor = editor;
+        this.onDidChangeControl = Event.None;
+        this.onDidChangeSizeConstraints = Event.None;
+        this.onDidFocus = Event.None;
+        this.onDidBlur = Event.None;
+        this.input = undefined;
+        this.options = undefined;
+        this.group = undefined;
+        this.scopedContextKeyService = undefined;
+        this.getViewState = unsupported;
+        this.isVisible = unsupported;
+        this.hasFocus = unsupported;
+        this.getId = unsupported;
+        this.getTitle = unsupported;
+        this.focus = unsupported;
+    }
+    get minimumWidth() { return DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
+    get maximumWidth() { return DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
+    get minimumHeight() { return DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
+    get maximumHeight() { return DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
+    getControl() {
+        return this.editor;
+    }
+}
+function wrapOpenEditor(textModelService, defaultBehavior, fallbackBahavior) {
+    async function openEditor(editor, optionsOrPreferredGroup, preferredGroup) {
+        const options = isEditorInput(editor) ? optionsOrPreferredGroup : editor.options;
+        if (isPreferredGroup(optionsOrPreferredGroup)) {
+            preferredGroup = optionsOrPreferredGroup;
+        }
+        const resource = isResourceEditorInput(editor) || isEditorInput(editor) ? editor.resource : undefined;
+        if (resource == null) {
+            return defaultBehavior(editor, optionsOrPreferredGroup, preferredGroup);
+        }
+        let modelEditor;
+        const modelRef = await textModelService.createModelReference(resource);
+        const codeEditors = StandaloneServices.get(ICodeEditorService).listCodeEditors();
+        modelEditor = codeEditors.find(editor => editor instanceof StandaloneEditor && editor.getModel() === modelRef.object.textEditorModel);
+        if (modelEditor == null) {
+            const defaultBehaviorResult = await defaultBehavior(editor, optionsOrPreferredGroup, preferredGroup);
+            if (defaultBehaviorResult != null) {
+                modelRef.dispose();
+                return defaultBehaviorResult;
+            }
+            modelEditor = await fallbackBahavior?.(modelRef, options, preferredGroup === SIDE_GROUP);
+        }
+        if (modelEditor == null) {
+            modelRef.dispose();
+            return undefined;
+        }
+        if (options != null) {
+            applyTextEditorOptions(options, modelEditor, 1 );
+        }
+        if (!(options?.preserveFocus ?? false)) {
+            modelEditor.focus();
+            modelEditor.getContainerDomNode().scrollIntoView();
+        }
+        return new SimpleEditorPane(modelEditor);
+    }
+    return openEditor;
+}
+export { wrapOpenEditor };