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

package/dist/vscode/vs/workbench/api/common/extHostUriTransformerService.js

@@ -0,0 +1,19 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IURITransformerService = ( createDecorator('IURITransformerService'));
+class URITransformerService {
+    constructor(delegate) {
+        if (!delegate) {
+            this.transformIncoming = arg => arg;
+            this.transformOutgoing = arg => arg;
+            this.transformOutgoingURI = arg => arg;
+            this.transformOutgoingScheme = arg => arg;
+        }
+        else {
+            this.transformIncoming = delegate.transformIncoming.bind(delegate);
+            this.transformOutgoing = delegate.transformOutgoing.bind(delegate);
+            this.transformOutgoingURI = delegate.transformOutgoingURI.bind(delegate);
+            this.transformOutgoingScheme = delegate.transformOutgoingScheme.bind(delegate);
+        }
+    }
+}
+export { IURITransformerService, URITransformerService };

package/dist/vscode/vs/workbench/api/common/extHostVariableResolverService.js

@@ -0,0 +1,138 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as paths from 'monaco-editor/esm/vs/base/common/path.js';
+import * as process from 'monaco-editor/esm/vs/base/common/process.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostDocumentsAndEditors } from './extHostDocumentsAndEditors.js';
+import { IExtHostEditorTabs } from './extHostEditorTabs.js';
+import { IExtHostExtensionService } from './extHostExtensionService.js';
+import { TextDiffTabInput, NotebookDiffEditorTabInput, TextTabInput, NotebookEditorTabInput, CustomEditorTabInput } from './extHostTypes.js';
+import { IExtHostWorkspace } from './extHostWorkspace.js';
+import { AbstractVariableResolverService } from '../../services/configurationResolver/common/variableResolver.js';
+import { IExtHostConfiguration } from './extHostConfiguration.js';
+const IExtHostVariableResolverProvider = ( createDecorator('IExtHostVariableResolverProvider'));
+class ExtHostVariableResolverService extends AbstractVariableResolverService {
+    constructor(extensionService, workspaceService, editorService, editorTabs, configProvider, context, homeDir) {
+        function getActiveUri() {
+            if (editorService) {
+                const activeEditor = editorService.activeEditor();
+                if (activeEditor) {
+                    return activeEditor.document.uri;
+                }
+                const activeTab = editorTabs.tabGroups.all.find(group => group.isActive)?.activeTab;
+                if (activeTab !== undefined) {
+                    if (activeTab.input instanceof TextDiffTabInput || activeTab.input instanceof NotebookDiffEditorTabInput) {
+                        return activeTab.input.modified;
+                    }
+                    else if (activeTab.input instanceof TextTabInput || activeTab.input instanceof NotebookEditorTabInput || activeTab.input instanceof CustomEditorTabInput) {
+                        return activeTab.input.uri;
+                    }
+                }
+            }
+            return undefined;
+        }
+        super({
+            getFolderUri: (folderName) => {
+                const found = context.folders.filter(f => f.name === folderName);
+                if (found && found.length > 0) {
+                    return found[0].uri;
+                }
+                return undefined;
+            },
+            getWorkspaceFolderCount: () => {
+                return context.folders.length;
+            },
+            getConfigurationValue: (folderUri, section) => {
+                return configProvider.getConfiguration(undefined, folderUri).get(section);
+            },
+            getAppRoot: () => {
+                return process.cwd();
+            },
+            getExecPath: () => {
+                return process.env['VSCODE_EXEC_PATH'];
+            },
+            getFilePath: () => {
+                const activeUri = getActiveUri();
+                if (activeUri) {
+                    return paths.normalize(activeUri.fsPath);
+                }
+                return undefined;
+            },
+            getWorkspaceFolderPathForFile: () => {
+                if (workspaceService) {
+                    const activeUri = getActiveUri();
+                    if (activeUri) {
+                        const ws = workspaceService.getWorkspaceFolder(activeUri);
+                        if (ws) {
+                            return paths.normalize(ws.uri.fsPath);
+                        }
+                    }
+                }
+                return undefined;
+            },
+            getSelectedText: () => {
+                if (editorService) {
+                    const activeEditor = editorService.activeEditor();
+                    if (activeEditor && !activeEditor.selection.isEmpty) {
+                        return activeEditor.document.getText(activeEditor.selection);
+                    }
+                }
+                return undefined;
+            },
+            getLineNumber: () => {
+                if (editorService) {
+                    const activeEditor = editorService.activeEditor();
+                    if (activeEditor) {
+                        return String(activeEditor.selection.end.line + 1);
+                    }
+                }
+                return undefined;
+            },
+            getExtension: (id) => {
+                return extensionService.getExtension(id);
+            },
+        }, undefined, homeDir ? Promise.resolve(homeDir) : undefined, Promise.resolve(process.env));
+    }
+}
+let ExtHostVariableResolverProviderService = class ExtHostVariableResolverProviderService extends Disposable {
+    constructor(extensionService, workspaceService, editorService, configurationService, editorTabs) {
+        super();
+        this.extensionService = extensionService;
+        this.workspaceService = workspaceService;
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+        this.editorTabs = editorTabs;
+        this._resolver = ( new Lazy(async () => {
+            const configProvider = await this.configurationService.getConfigProvider();
+            const folders = (await this.workspaceService.getWorkspaceFolders2()) || [];
+            const dynamic = { folders };
+            this._register(this.workspaceService.onDidChangeWorkspace(async (e) => {
+                dynamic.folders = (await this.workspaceService.getWorkspaceFolders2()) || [];
+            }));
+            return ( new ExtHostVariableResolverService(
+                this.extensionService,
+                this.workspaceService,
+                this.editorService,
+                this.editorTabs,
+                configProvider,
+                dynamic,
+                this.homeDir()
+            ));
+        }));
+    }
+    getResolver() {
+        return this._resolver.value;
+    }
+    homeDir() {
+        return undefined;
+    }
+};
+ExtHostVariableResolverProviderService = ( __decorate([
+    ( __param(0, IExtHostExtensionService)),
+    ( __param(1, IExtHostWorkspace)),
+    ( __param(2, IExtHostDocumentsAndEditors)),
+    ( __param(3, IExtHostConfiguration)),
+    ( __param(4, IExtHostEditorTabs))
+], ExtHostVariableResolverProviderService));
+export { ExtHostVariableResolverProviderService, IExtHostVariableResolverProvider };

package/dist/vscode/vs/workbench/api/common/extHostWindow.js

@@ -0,0 +1,59 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MainContext } from './extHost.protocol.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+let ExtHostWindow = class ExtHostWindow {
+    get state() { return this._state; }
+    constructor(extHostRpc) {
+        this._onDidChangeWindowState = ( new Emitter());
+        this.onDidChangeWindowState = this._onDidChangeWindowState.event;
+        this._state = ExtHostWindow.InitialState;
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadWindow));
+        this._proxy.$getWindowVisibility().then(isFocused => this.$onDidChangeWindowFocus(isFocused));
+    }
+    $onDidChangeWindowFocus(focused) {
+        if (focused === this._state.focused) {
+            return;
+        }
+        this._state = { ...this._state, focused };
+        this._onDidChangeWindowState.fire(this._state);
+    }
+    openUri(stringOrUri, options) {
+        let uriAsString;
+        if (typeof stringOrUri === 'string') {
+            uriAsString = stringOrUri;
+            try {
+                stringOrUri = ( URI.parse(stringOrUri));
+            }
+            catch (e) {
+                return Promise.reject(`Invalid uri - '${stringOrUri}'`);
+            }
+        }
+        if (isFalsyOrWhitespace(stringOrUri.scheme)) {
+            return Promise.reject('Invalid scheme - cannot be empty');
+        }
+        else if (stringOrUri.scheme === Schemas.command) {
+            return Promise.reject(`Invalid scheme '${stringOrUri.scheme}'`);
+        }
+        return this._proxy.$openUri(stringOrUri, uriAsString, options);
+    }
+    async asExternalUri(uri, options) {
+        if (isFalsyOrWhitespace(uri.scheme)) {
+            return Promise.reject('Invalid scheme - cannot be empty');
+        }
+        const result = await this._proxy.$asExternalUri(uri, options);
+        return ( URI.from(result));
+    }
+};
+ExtHostWindow.InitialState = {
+    focused: true
+};
+ExtHostWindow = ( __decorate([
+    ( __param(0, IExtHostRpcService))
+], ExtHostWindow));
+const IExtHostWindow = ( createDecorator('IExtHostWindow'));
+export { ExtHostWindow, IExtHostWindow };