@codingame/monaco-vscode-api 1.69.0 → 1.69.1

package/dist/textmate.js

@@ -1,5 +1,5 @@
 import { _ as __decorate, a as __param } from './tslib.es6.js';
-import { M as ExtensionsRegistry, O as ExtensionMessageCollector, Q as ITextMateService, E as Emitter } from './missing-services.js';
+import { h as ExtensionsRegistry, O as ExtensionMessageCollector, Q as ITextMateService, E as Emitter } from './missing-services.js';
 export { Q as ITextMateService } from './missing-services.js';
 import { l as languagesExtPoint } from './languageService.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
@@ -21,13 +21,12 @@ import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
 import { nullTokenizeEncoded } from 'monaco-editor/esm/vs/editor/common/languages/nullTokenize.js';
-import { g as getExtensionPoint, c as consoleExtensionMessageHandler } from './tools.js';
+import { g as getExtensionPoint, c as consoleExtensionMessageHandler, o as onServicesInitialized } from './tools.js';
 import { S as Services } from './services2.js';
 import { bd as DEFAULT_EXTENSION } from './extHost.js';
 import { c as createInjectedClass } from './injection.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 const grammarsExtPoint = ( (ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'grammars',
     deps: [languagesExtPoint],
@@ -458,7 +457,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
         if (this._grammarFactory) {
             return this._grammarFactory;
         }
-        const [vscodeTextmate, vscodeOniguruma] = await Promise.all([import('vscode-textmate'), this._getVSCodeOniguruma()]);
+        const [vscodeTextmate, vscodeOniguruma] = await Promise.all([import('vscode-textmate').then(module => module.default ?? module), this._getVSCodeOniguruma()]);
         const onigLib = Promise.resolve({
             createOnigScanner: (sources) => vscodeOniguruma.createOnigScanner(sources),
             createOnigString: (str) => vscodeOniguruma.createOnigString(str)
@@ -651,7 +650,7 @@ let AbstractTextMateService = class AbstractTextMateService extends Disposable {
         return this._vscodeOniguruma;
     }
     async _doGetVSCodeOniguruma() {
-        const [vscodeOniguruma, wasm] = await Promise.all([import('vscode-oniguruma'), this._loadVSCodeOnigurumWASM()]);
+        const [vscodeOniguruma, wasm] = await Promise.all([import('vscode-oniguruma').then(module => module.default ?? module), this._loadVSCodeOnigurumWASM()]);
         const options = {
             data: wasm,
             print: (str) => {
@@ -727,11 +726,11 @@ function setGrammars(grammars, getContent, extension = Services.get().extension
         registerExtensionFile(joinPath(extension.extensionLocation, grammar.path), () => getContent(grammar));
     }
 }
-function initialize() {
-    StandaloneServices.get(ITextMateService);
+function initialize(instantiationService) {
+    instantiationService.invokeFunction((accessor) => accessor.get(ITextMateService));
 }
 function getServiceOverride(getOnigLib) {
-    setTimeout(initialize);
+    onServicesInitialized(initialize);
     return {
         ...getServiceOverride$1(),
         [( ITextMateService.toString())]: new SyncDescriptor(TextMateService, [getOnigLib])

package/dist/theme.d.ts

@@ -15,8 +15,9 @@ interface IThemeExtensionPoint {
 
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
-declare function setThemes<T extends IThemeExtensionPoint>(_themes: T[], getContent: (theme: T) => Promise<string>): void;
-declare function setDefaultThemes<T extends IThemeExtensionPoint>(_themes: T[], getContent: (theme: T) => Promise<string>): void;
+declare type PartialIThemeExtensionPoint = Partial<IThemeExtensionPoint> & Pick<IThemeExtensionPoint, 'id' | 'path'>;
+declare function setThemes<T extends PartialIThemeExtensionPoint>(_themes: T[], getContent: (theme: T) => Promise<string>): void;
+declare function setDefaultThemes<T extends PartialIThemeExtensionPoint>(_themes: T[], getContent: (theme: T) => Promise<string>): void;
 declare function getServiceOverride(): IEditorOverrideServices;
 
-export { IThemeExtensionPoint, getServiceOverride as default, setDefaultThemes, setThemes };
+export { PartialIThemeExtensionPoint as IThemeExtensionPoint, getServiceOverride as default, setDefaultThemes, setThemes };

package/dist/theme.js

@@ -1,4 +1,4 @@
-import { I as IExtensionService, T as IBrowserWorkbenchEnvironmentService, V as IHostColorSchemeService, W as IUserDataInitializationService, M as ExtensionsRegistry, E as Emitter, X as Sequencer, O as ExtensionMessageCollector, P as parse$1, S as getNodeType } from './missing-services.js';
+import { I as IExtensionService, T as IBrowserWorkbenchEnvironmentService, V as IHostColorSchemeService, W as IUserDataInitializationService, h as ExtensionsRegistry, E as Emitter, X as Sequencer, O as ExtensionMessageCollector, P as parse$1, S as getNodeType } from './missing-services.js';
 import { _ as __decorate, a as __param } from './tslib.es6.js';
 import { V as VS_DARK_THEME, a as VS_LIGHT_THEME, b as VS_HC_THEME, c as VS_HC_LIGHT_THEME, T as ThemeSettings, E as ExtensionData, d as THEME_SCOPE_OPEN_PAREN, e as THEME_SCOPE_CLOSE_PAREN, f as THEME_SCOPE_WILDCARD, t as themeScopeRegex } from './workbenchThemeService.js';
 import { workbenchColorsSchemaId, editorBackground, editorForeground, editorSelectionBackground, editorInactiveSelection, editorSelectionHighlight, editorFindMatchHighlight, editorFindMatch, editorHoverHighlight, editorFindRangeHighlight, asCssVariableName, Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';

package/dist/tokenClassification.js

@@ -1,11 +1,9 @@
-import { M as ExtensionsRegistry, O as ExtensionMessageCollector } from './missing-services.js';
+import { h as ExtensionsRegistry, O as ExtensionMessageCollector } from './missing-services.js';
 import { g as getTokenClassificationRegistry, a as typeAndModifierIdPattern } from './tokenClassificationRegistry.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { g as getExtensionPoint, c as consoleExtensionMessageHandler } from './tools.js';
+import { g as getExtensionPoint, c as consoleExtensionMessageHandler, o as onServicesInitialized } from './tools.js';
 import { S as Services } from './services2.js';
 import { bd as DEFAULT_EXTENSION } from './extHost.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';
 const tokenClassificationRegistry = getTokenClassificationRegistry();
 const tokenTypeExtPoint$1 = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'semanticTokenTypes',
@@ -294,11 +292,11 @@ function setTokenStyleDefaults(tokenStyleDefaults, extension = Services.get().ex
             collector: new ExtensionMessageCollector(consoleExtensionMessageHandler, extension, tokenModifierExtPoint.name)
         }]);
 }
-function register() {
-    StandaloneServices.get(IInstantiationService).createInstance(TokenClassificationExtensionPoints);
+function initialize(instantiationService) {
+    instantiationService.createInstance(TokenClassificationExtensionPoints);
 }
 function getServiceOverride() {
-    setTimeout(register);
+    onServicesInitialized(initialize);
     return {};
 }
 export { getServiceOverride as default, setTokenModifiers, setTokenStyleDefaults, setTokenTypes };

package/dist/tools.js

@@ -1,4 +1,6 @@
-import { M as ExtensionsRegistry } from './missing-services.js';
+import { h as ExtensionsRegistry } from './missing-services.js';
+import { EventEmitter } from 'vscode';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
 function consoleExtensionMessageHandler(msg) {
     if (msg.type === Severity.Error) {
@@ -14,4 +16,16 @@ function consoleExtensionMessageHandler(msg) {
 function getExtensionPoint(extensionPoint) {
     return ExtensionsRegistry.getExtensionPoints().find(ep => ep.name === extensionPoint);
 }
-export { consoleExtensionMessageHandler as c, getExtensionPoint as g };
+const emitter = new EventEmitter();
+const onServicesInitialized = emitter.event;
+let initialized = false;
+const original = StandaloneServices.initialize;
+StandaloneServices.initialize = (overrides) => {
+    const instantiationService = original.call(StandaloneServices, overrides);
+    if (!initialized) {
+        initialized = true;
+        emitter.fire(instantiationService);
+    }
+    return instantiationService;
+};
+export { consoleExtensionMessageHandler as c, getExtensionPoint as g, onServicesInitialized as o };

package/dist/workspaceContext.js

@@ -0,0 +1,49 @@
+import { u as unsupported } from './missing-services.js';
+import { S as Services } from './services2.js';
+import { IWorkspaceContextService, WorkspaceFolder } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+class SimpleWorkspaceContextService {
+    constructor() {
+        this.onDidChangeWorkspaceName = Event.None;
+        this.onWillChangeWorkspaceFolders = Event.None;
+        this.onDidChangeWorkspaceFolders = Event.None;
+        this.onDidChangeWorkbenchState = Event.None;
+        this.isCurrentWorkspace = unsupported;
+    }
+    getCompleteWorkspace() {
+        return Promise.resolve(this.getWorkspace());
+    }
+    getWorkspace() {
+        const workspaceFolders = Services.get().workspace?.workspaceFolders;
+        return {
+            id: '4064f6ec-cb38-4ad0-af64-ee6467e63c82',
+            folders: workspaceFolders?.map(folder => new WorkspaceFolder(folder)) ?? []
+        };
+    }
+    getWorkbenchState() {
+        const workspaceFoldersCount = Services.get().workspace?.workspaceFolders?.length ?? 1;
+        if (workspaceFoldersCount === 0) {
+            return 1 ;
+        }
+        else if (workspaceFoldersCount === 1) {
+            return 2 ;
+        }
+        else {
+            return 3 ;
+        }
+    }
+    getWorkspaceFolder(resource) {
+        const workspace = this.getWorkspace();
+        return workspace.folders.find(folder => folder.uri.scheme === resource.scheme && resource.path.startsWith(folder.uri.path)) ?? null;
+    }
+    isInsideWorkspace(resource) {
+        return this.getWorkspaceFolder(resource) != null;
+    }
+}
+function getServiceOverride() {
+    return {
+        [( IWorkspaceContextService.toString())]: new SyncDescriptor(SimpleWorkspaceContextService)
+    };
+}
+export { getServiceOverride as g };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.69.0",
+  "version": "1.69.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],