monaco-editor
Version:
A browser based code editor
785 lines (784 loc) • 38.1 kB
JavaScript
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import './standaloneCodeEditorService.js';
import './standaloneLayoutService.js';
import '../../../platform/undoRedo/common/undoRedoService.js';
import '../../common/services/languageFeatureDebounce.js';
import '../../common/services/semanticTokensStylingService.js';
import '../../common/services/languageFeaturesService.js';
import '../../browser/services/hoverService/hoverService.js';
import * as strings from '../../../base/common/strings.js';
import * as dom from '../../../base/browser/dom.js';
import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
import { Emitter } from '../../../base/common/event.js';
import { KeyCodeChord, decodeKeybinding } from '../../../base/common/keybindings.js';
import { ImmortalReference, toDisposable, DisposableStore, Disposable, combinedDisposable } from '../../../base/common/lifecycle.js';
import { OS, isLinux, isMacintosh } from '../../../base/common/platform.js';
import Severity from '../../../base/common/severity.js';
import { URI } from '../../../base/common/uri.js';
import { IBulkEditService, ResourceEdit, ResourceTextEdit } from '../../browser/services/bulkEditService.js';
import { isDiffEditorConfigurationKey, isEditorConfigurationKey } from '../../common/config/editorConfigurationSchema.js';
import { EditOperation } from '../../common/core/editOperation.js';
import { Position as Pos } from '../../common/core/position.js';
import { Range } from '../../common/core/range.js';
import { IModelService } from '../../common/services/model.js';
import { ITextModelService } from '../../common/services/resolverService.js';
import { ITextResourceConfigurationService, ITextResourcePropertiesService } from '../../common/services/textResourceConfiguration.js';
import { CommandsRegistry, ICommandService } from '../../../platform/commands/common/commands.js';
import { IConfigurationService } from '../../../platform/configuration/common/configuration.js';
import { Configuration, ConfigurationModel, ConfigurationChangeEvent } from '../../../platform/configuration/common/configurationModels.js';
import { IContextKeyService } from '../../../platform/contextkey/common/contextkey.js';
import { IDialogService } from '../../../platform/dialogs/common/dialogs.js';
import { createDecorator, IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
import { AbstractKeybindingService } from '../../../platform/keybinding/common/abstractKeybindingService.js';
import { IKeybindingService } from '../../../platform/keybinding/common/keybinding.js';
import { KeybindingResolver } from '../../../platform/keybinding/common/keybindingResolver.js';
import { KeybindingsRegistry } from '../../../platform/keybinding/common/keybindingsRegistry.js';
import { ResolvedKeybindingItem } from '../../../platform/keybinding/common/resolvedKeybindingItem.js';
import { USLayoutResolvedKeybinding } from '../../../platform/keybinding/common/usLayoutResolvedKeybinding.js';
import { ILabelService } from '../../../platform/label/common/label.js';
import { INotificationService, NoOpNotification } from '../../../platform/notification/common/notification.js';
import { IEditorProgressService, IProgressService } from '../../../platform/progress/common/progress.js';
import { ITelemetryService } from '../../../platform/telemetry/common/telemetry.js';
import { IWorkspaceContextService, WorkspaceFolder, STANDALONE_EDITOR_WORKSPACE_ID } from '../../../platform/workspace/common/workspace.js';
import { ILayoutService } from '../../../platform/layout/browser/layoutService.js';
import { StandaloneServicesNLS } from '../../common/standaloneStrings.js';
import { basename } from '../../../base/common/resources.js';
import { ICodeEditorService } from '../../browser/services/codeEditorService.js';
import { ConsoleLogger, ILogService } from '../../../platform/log/common/log.js';
import { IWorkspaceTrustManagementService } from '../../../platform/workspace/common/workspaceTrust.js';
import { IContextMenuService, IContextViewService } from '../../../platform/contextview/browser/contextView.js';
import { ContextViewService } from '../../../platform/contextview/browser/contextViewService.js';
import { LanguageService } from '../../common/services/languageService.js';
import { ContextMenuService } from '../../../platform/contextview/browser/contextMenuService.js';
import { getSingletonServiceDescriptors, registerSingleton } from '../../../platform/instantiation/common/extensions.js';
import { OpenerService } from '../../browser/services/openerService.js';
import { IEditorWorkerService } from '../../common/services/editorWorker.js';
import { EditorWorkerService } from '../../browser/services/editorWorkerService.js';
import { ILanguageService } from '../../common/languages/language.js';
import { MarkerDecorationsService } from '../../common/services/markerDecorationsService.js';
import { IMarkerDecorationsService } from '../../common/services/markerDecorations.js';
import { ModelService } from '../../common/services/modelService.js';
import { StandaloneQuickInputService } from './quickInput/standaloneQuickInputService.js';
import { StandaloneThemeService } from './standaloneThemeService.js';
import { IStandaloneThemeService } from '../common/standaloneTheme.js';
import { AccessibilityService } from '../../../platform/accessibility/browser/accessibilityService.js';
import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.js';
import { IMenuService } from '../../../platform/actions/common/actions.js';
import { MenuService } from '../../../platform/actions/common/menuService.js';
import { BrowserClipboardService } from '../../../platform/clipboard/browser/clipboardService.js';
import { IClipboardService } from '../../../platform/clipboard/common/clipboardService.js';
import { ContextKeyService } from '../../../platform/contextkey/browser/contextKeyService.js';
import { SyncDescriptor } from '../../../platform/instantiation/common/descriptors.js';
import { InstantiationService } from '../../../platform/instantiation/common/instantiationService.js';
import { ServiceCollection } from '../../../platform/instantiation/common/serviceCollection.js';
import { IListService, ListService } from '../../../platform/list/browser/listService.js';
import { IMarkerService } from '../../../platform/markers/common/markers.js';
import { MarkerService } from '../../../platform/markers/common/markerService.js';
import { IOpenerService } from '../../../platform/opener/common/opener.js';
import { IQuickInputService } from '../../../platform/quickinput/common/quickInput.js';
import { IStorageService, InMemoryStorageService } from '../../../platform/storage/common/storage.js';
import { DefaultConfiguration } from '../../../platform/configuration/common/configurations.js';
import { IAccessibilitySignalService } from '../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
import { ILanguageFeaturesService } from '../../common/services/languageFeatures.js';
import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.js';
import { LogService } from '../../../platform/log/common/logService.js';
import { getEditorFeatures } from '../../common/editorFeatures.js';
import { onUnexpectedError } from '../../../base/common/errors.js';
import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
import { mainWindow } from '../../../base/browser/window.js';
import { ResourceMap } from '../../../base/common/map.js';
import { ITreeSitterParserService } from '../../common/services/treeSitterParserService.js';
import { StandaloneTreeSitterParserService } from './standaloneTreeSitterService.js';
class SimpleModel {
constructor(model) {
this.disposed = false;
this.model = model;
this._onWillDispose = new Emitter();
}
get textEditorModel() {
return this.model;
}
dispose() {
this.disposed = true;
this._onWillDispose.fire();
}
}
let StandaloneTextModelService = class StandaloneTextModelService {
constructor(modelService) {
this.modelService = modelService;
}
createModelReference(resource) {
const model = this.modelService.getModel(resource);
if (!model) {
return Promise.reject(new Error(`Model not found`));
}
return Promise.resolve(new ImmortalReference(new SimpleModel(model)));
}
};
StandaloneTextModelService = __decorate([
__param(0, IModelService)
], StandaloneTextModelService);
class StandaloneEditorProgressService {
static { this.NULL_PROGRESS_RUNNER = {
done: () => { },
total: () => { },
worked: () => { }
}; }
show() {
return StandaloneEditorProgressService.NULL_PROGRESS_RUNNER;
}
async showWhile(promise, delay) {
await promise;
}
}
class StandaloneProgressService {
withProgress(_options, task, onDidCancel) {
return task({
report: () => { },
});
}
}
class StandaloneEnvironmentService {
constructor() {
this.isExtensionDevelopment = false;
this.isBuilt = false;
}
}
class StandaloneDialogService {
async confirm(confirmation) {
const confirmed = this.doConfirm(confirmation.message, confirmation.detail);
return {
confirmed,
checkboxChecked: false // unsupported
};
}
doConfirm(message, detail) {
let messageText = message;
if (detail) {
messageText = messageText + '\n\n' + detail;
}
return mainWindow.confirm(messageText);
}
async prompt(prompt) {
let result = undefined;
const confirmed = this.doConfirm(prompt.message, prompt.detail);
if (confirmed) {
const promptButtons = [...(prompt.buttons ?? [])];
if (prompt.cancelButton && typeof prompt.cancelButton !== 'string' && typeof prompt.cancelButton !== 'boolean') {
promptButtons.push(prompt.cancelButton);
}
result = await promptButtons[0]?.run({ checkboxChecked: false });
}
return { result };
}
async error(message, detail) {
await this.prompt({ type: Severity.Error, message, detail });
}
}
export class StandaloneNotificationService {
static { this.NO_OP = new NoOpNotification(); }
info(message) {
return this.notify({ severity: Severity.Info, message });
}
warn(message) {
return this.notify({ severity: Severity.Warning, message });
}
error(error) {
return this.notify({ severity: Severity.Error, message: error });
}
notify(notification) {
switch (notification.severity) {
case Severity.Error:
console.error(notification.message);
break;
case Severity.Warning:
console.warn(notification.message);
break;
default:
console.log(notification.message);
break;
}
return StandaloneNotificationService.NO_OP;
}
prompt(severity, message, choices, options) {
return StandaloneNotificationService.NO_OP;
}
status(message, options) {
return Disposable.None;
}
}
let StandaloneCommandService = class StandaloneCommandService {
constructor(instantiationService) {
this._onWillExecuteCommand = new Emitter();
this._onDidExecuteCommand = new Emitter();
this.onDidExecuteCommand = this._onDidExecuteCommand.event;
this._instantiationService = instantiationService;
}
executeCommand(id, ...args) {
const command = CommandsRegistry.getCommand(id);
if (!command) {
return Promise.reject(new Error(`command '${id}' not found`));
}
try {
this._onWillExecuteCommand.fire({ commandId: id, args });
const result = this._instantiationService.invokeFunction.apply(this._instantiationService, [command.handler, ...args]);
this._onDidExecuteCommand.fire({ commandId: id, args });
return Promise.resolve(result);
}
catch (err) {
return Promise.reject(err);
}
}
};
StandaloneCommandService = __decorate([
__param(0, IInstantiationService)
], StandaloneCommandService);
export { StandaloneCommandService };
let StandaloneKeybindingService = class StandaloneKeybindingService extends AbstractKeybindingService {
constructor(contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService) {
super(contextKeyService, commandService, telemetryService, notificationService, logService);
this._cachedResolver = null;
this._dynamicKeybindings = [];
this._domNodeListeners = [];
const addContainer = (domNode) => {
const disposables = new DisposableStore();
// for standard keybindings
disposables.add(dom.addDisposableListener(domNode, dom.EventType.KEY_DOWN, (e) => {
const keyEvent = new StandardKeyboardEvent(e);
const shouldPreventDefault = this._dispatch(keyEvent, keyEvent.target);
if (shouldPreventDefault) {
keyEvent.preventDefault();
keyEvent.stopPropagation();
}
}));
// for single modifier chord keybindings (e.g. shift shift)
disposables.add(dom.addDisposableListener(domNode, dom.EventType.KEY_UP, (e) => {
const keyEvent = new StandardKeyboardEvent(e);
const shouldPreventDefault = this._singleModifierDispatch(keyEvent, keyEvent.target);
if (shouldPreventDefault) {
keyEvent.preventDefault();
}
}));
this._domNodeListeners.push(new DomNodeListeners(domNode, disposables));
};
const removeContainer = (domNode) => {
for (let i = 0; i < this._domNodeListeners.length; i++) {
const domNodeListeners = this._domNodeListeners[i];
if (domNodeListeners.domNode === domNode) {
this._domNodeListeners.splice(i, 1);
domNodeListeners.dispose();
}
}
};
const addCodeEditor = (codeEditor) => {
if (codeEditor.getOption(61 /* EditorOption.inDiffEditor */)) {
return;
}
addContainer(codeEditor.getContainerDomNode());
};
const removeCodeEditor = (codeEditor) => {
if (codeEditor.getOption(61 /* EditorOption.inDiffEditor */)) {
return;
}
removeContainer(codeEditor.getContainerDomNode());
};
this._register(codeEditorService.onCodeEditorAdd(addCodeEditor));
this._register(codeEditorService.onCodeEditorRemove(removeCodeEditor));
codeEditorService.listCodeEditors().forEach(addCodeEditor);
const addDiffEditor = (diffEditor) => {
addContainer(diffEditor.getContainerDomNode());
};
const removeDiffEditor = (diffEditor) => {
removeContainer(diffEditor.getContainerDomNode());
};
this._register(codeEditorService.onDiffEditorAdd(addDiffEditor));
this._register(codeEditorService.onDiffEditorRemove(removeDiffEditor));
codeEditorService.listDiffEditors().forEach(addDiffEditor);
}
addDynamicKeybinding(command, keybinding, handler, when) {
return combinedDisposable(CommandsRegistry.registerCommand(command, handler), this.addDynamicKeybindings([{
keybinding,
command,
when
}]));
}
addDynamicKeybindings(rules) {
const entries = rules.map((rule) => {
const keybinding = decodeKeybinding(rule.keybinding, OS);
return {
keybinding,
command: rule.command ?? null,
commandArgs: rule.commandArgs,
when: rule.when,
weight1: 1000,
weight2: 0,
extensionId: null,
isBuiltinExtension: false
};
});
this._dynamicKeybindings = this._dynamicKeybindings.concat(entries);
this.updateResolver();
return toDisposable(() => {
// Search the first entry and remove them all since they will be contiguous
for (let i = 0; i < this._dynamicKeybindings.length; i++) {
if (this._dynamicKeybindings[i] === entries[0]) {
this._dynamicKeybindings.splice(i, entries.length);
this.updateResolver();
return;
}
}
});
}
updateResolver() {
this._cachedResolver = null;
this._onDidUpdateKeybindings.fire();
}
_getResolver() {
if (!this._cachedResolver) {
const defaults = this._toNormalizedKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
const overrides = this._toNormalizedKeybindingItems(this._dynamicKeybindings, false);
this._cachedResolver = new KeybindingResolver(defaults, overrides, (str) => this._log(str));
}
return this._cachedResolver;
}
_documentHasFocus() {
return mainWindow.document.hasFocus();
}
_toNormalizedKeybindingItems(items, isDefault) {
const result = [];
let resultLen = 0;
for (const item of items) {
const when = item.when || undefined;
const keybinding = item.keybinding;
if (!keybinding) {
// This might be a removal keybinding item in user settings => accept it
result[resultLen++] = new ResolvedKeybindingItem(undefined, item.command, item.commandArgs, when, isDefault, null, false);
}
else {
const resolvedKeybindings = USLayoutResolvedKeybinding.resolveKeybinding(keybinding, OS);
for (const resolvedKeybinding of resolvedKeybindings) {
result[resultLen++] = new ResolvedKeybindingItem(resolvedKeybinding, item.command, item.commandArgs, when, isDefault, null, false);
}
}
}
return result;
}
resolveKeyboardEvent(keyboardEvent) {
const chord = new KeyCodeChord(keyboardEvent.ctrlKey, keyboardEvent.shiftKey, keyboardEvent.altKey, keyboardEvent.metaKey, keyboardEvent.keyCode);
return new USLayoutResolvedKeybinding([chord], OS);
}
};
StandaloneKeybindingService = __decorate([
__param(0, IContextKeyService),
__param(1, ICommandService),
__param(2, ITelemetryService),
__param(3, INotificationService),
__param(4, ILogService),
__param(5, ICodeEditorService)
], StandaloneKeybindingService);
export { StandaloneKeybindingService };
class DomNodeListeners extends Disposable {
constructor(domNode, disposables) {
super();
this.domNode = domNode;
this._register(disposables);
}
}
function isConfigurationOverrides(thing) {
return thing
&& typeof thing === 'object'
&& (!thing.overrideIdentifier || typeof thing.overrideIdentifier === 'string')
&& (!thing.resource || thing.resource instanceof URI);
}
let StandaloneConfigurationService = class StandaloneConfigurationService {
constructor(logService) {
this.logService = logService;
this._onDidChangeConfiguration = new Emitter();
this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
const defaultConfiguration = new DefaultConfiguration(logService);
this._configuration = new Configuration(defaultConfiguration.reload(), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), ConfigurationModel.createEmptyModel(logService), new ResourceMap(), ConfigurationModel.createEmptyModel(logService), new ResourceMap(), logService);
defaultConfiguration.dispose();
}
getValue(arg1, arg2) {
const section = typeof arg1 === 'string' ? arg1 : undefined;
const overrides = isConfigurationOverrides(arg1) ? arg1 : isConfigurationOverrides(arg2) ? arg2 : {};
return this._configuration.getValue(section, overrides, undefined);
}
updateValues(values) {
const previous = { data: this._configuration.toData() };
const changedKeys = [];
for (const entry of values) {
const [key, value] = entry;
if (this.getValue(key) === value) {
continue;
}
this._configuration.updateValue(key, value);
changedKeys.push(key);
}
if (changedKeys.length > 0) {
const configurationChangeEvent = new ConfigurationChangeEvent({ keys: changedKeys, overrides: [] }, previous, this._configuration, undefined, this.logService);
configurationChangeEvent.source = 8 /* ConfigurationTarget.MEMORY */;
this._onDidChangeConfiguration.fire(configurationChangeEvent);
}
return Promise.resolve();
}
updateValue(key, value, arg3, arg4) {
return this.updateValues([[key, value]]);
}
inspect(key, options = {}) {
return this._configuration.inspect(key, options, undefined);
}
};
StandaloneConfigurationService = __decorate([
__param(0, ILogService)
], StandaloneConfigurationService);
export { StandaloneConfigurationService };
let StandaloneResourceConfigurationService = class StandaloneResourceConfigurationService {
constructor(configurationService, modelService, languageService) {
this.configurationService = configurationService;
this.modelService = modelService;
this.languageService = languageService;
this._onDidChangeConfiguration = new Emitter();
this.configurationService.onDidChangeConfiguration((e) => {
this._onDidChangeConfiguration.fire({ affectedKeys: e.affectedKeys, affectsConfiguration: (resource, configuration) => e.affectsConfiguration(configuration) });
});
}
getValue(resource, arg2, arg3) {
const position = Pos.isIPosition(arg2) ? arg2 : null;
const section = position ? (typeof arg3 === 'string' ? arg3 : undefined) : (typeof arg2 === 'string' ? arg2 : undefined);
const language = resource ? this.getLanguage(resource, position) : undefined;
if (typeof section === 'undefined') {
return this.configurationService.getValue({
resource,
overrideIdentifier: language
});
}
return this.configurationService.getValue(section, {
resource,
overrideIdentifier: language
});
}
getLanguage(resource, position) {
const model = this.modelService.getModel(resource);
if (model) {
return position ? model.getLanguageIdAtPosition(position.lineNumber, position.column) : model.getLanguageId();
}
return this.languageService.guessLanguageIdByFilepathOrFirstLine(resource);
}
};
StandaloneResourceConfigurationService = __decorate([
__param(0, IConfigurationService),
__param(1, IModelService),
__param(2, ILanguageService)
], StandaloneResourceConfigurationService);
let StandaloneResourcePropertiesService = class StandaloneResourcePropertiesService {
constructor(configurationService) {
this.configurationService = configurationService;
}
getEOL(resource, language) {
const eol = this.configurationService.getValue('files.eol', { overrideIdentifier: language, resource });
if (eol && typeof eol === 'string' && eol !== 'auto') {
return eol;
}
return (isLinux || isMacintosh) ? '\n' : '\r\n';
}
};
StandaloneResourcePropertiesService = __decorate([
__param(0, IConfigurationService)
], StandaloneResourcePropertiesService);
class StandaloneTelemetryService {
publicLog2() { }
}
class StandaloneWorkspaceContextService {
static { this.SCHEME = 'inmemory'; }
constructor() {
const resource = URI.from({ scheme: StandaloneWorkspaceContextService.SCHEME, authority: 'model', path: '/' });
this.workspace = { id: STANDALONE_EDITOR_WORKSPACE_ID, folders: [new WorkspaceFolder({ uri: resource, name: '', index: 0 })] };
}
getWorkspace() {
return this.workspace;
}
getWorkspaceFolder(resource) {
return resource && resource.scheme === StandaloneWorkspaceContextService.SCHEME ? this.workspace.folders[0] : null;
}
}
export function updateConfigurationService(configurationService, source, isDiffEditor) {
if (!source) {
return;
}
if (!(configurationService instanceof StandaloneConfigurationService)) {
return;
}
const toUpdate = [];
Object.keys(source).forEach((key) => {
if (isEditorConfigurationKey(key)) {
toUpdate.push([`editor.${key}`, source[key]]);
}
if (isDiffEditor && isDiffEditorConfigurationKey(key)) {
toUpdate.push([`diffEditor.${key}`, source[key]]);
}
});
if (toUpdate.length > 0) {
configurationService.updateValues(toUpdate);
}
}
let StandaloneBulkEditService = class StandaloneBulkEditService {
constructor(_modelService) {
this._modelService = _modelService;
//
}
hasPreviewHandler() {
return false;
}
async apply(editsIn, _options) {
const edits = Array.isArray(editsIn) ? editsIn : ResourceEdit.convert(editsIn);
const textEdits = new Map();
for (const edit of edits) {
if (!(edit instanceof ResourceTextEdit)) {
throw new Error('bad edit - only text edits are supported');
}
const model = this._modelService.getModel(edit.resource);
if (!model) {
throw new Error('bad edit - model not found');
}
if (typeof edit.versionId === 'number' && model.getVersionId() !== edit.versionId) {
throw new Error('bad state - model changed in the meantime');
}
let array = textEdits.get(model);
if (!array) {
array = [];
textEdits.set(model, array);
}
array.push(EditOperation.replaceMove(Range.lift(edit.textEdit.range), edit.textEdit.text));
}
let totalEdits = 0;
let totalFiles = 0;
for (const [model, edits] of textEdits) {
model.pushStackElement();
model.pushEditOperations([], edits, () => []);
model.pushStackElement();
totalFiles += 1;
totalEdits += edits.length;
}
return {
ariaSummary: strings.format(StandaloneServicesNLS.bulkEditServiceSummary, totalEdits, totalFiles),
isApplied: totalEdits > 0
};
}
};
StandaloneBulkEditService = __decorate([
__param(0, IModelService)
], StandaloneBulkEditService);
class StandaloneUriLabelService {
getUriLabel(resource, options) {
if (resource.scheme === 'file') {
return resource.fsPath;
}
return resource.path;
}
getUriBasenameLabel(resource) {
return basename(resource);
}
}
let StandaloneContextViewService = class StandaloneContextViewService extends ContextViewService {
constructor(layoutService, _codeEditorService) {
super(layoutService);
this._codeEditorService = _codeEditorService;
}
showContextView(delegate, container, shadowRoot) {
if (!container) {
const codeEditor = this._codeEditorService.getFocusedCodeEditor() || this._codeEditorService.getActiveCodeEditor();
if (codeEditor) {
container = codeEditor.getContainerDomNode();
}
}
return super.showContextView(delegate, container, shadowRoot);
}
};
StandaloneContextViewService = __decorate([
__param(0, ILayoutService),
__param(1, ICodeEditorService)
], StandaloneContextViewService);
class StandaloneWorkspaceTrustManagementService {
constructor() {
this._neverEmitter = new Emitter();
this.onDidChangeTrust = this._neverEmitter.event;
}
isWorkspaceTrusted() {
return true;
}
}
class StandaloneLanguageService extends LanguageService {
constructor() {
super();
}
}
class StandaloneLogService extends LogService {
constructor() {
super(new ConsoleLogger());
}
}
let StandaloneContextMenuService = class StandaloneContextMenuService extends ContextMenuService {
constructor(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService) {
super(telemetryService, notificationService, contextViewService, keybindingService, menuService, contextKeyService);
this.configure({ blockMouse: false }); // we do not want that in the standalone editor
}
};
StandaloneContextMenuService = __decorate([
__param(0, ITelemetryService),
__param(1, INotificationService),
__param(2, IContextViewService),
__param(3, IKeybindingService),
__param(4, IMenuService),
__param(5, IContextKeyService)
], StandaloneContextMenuService);
export const standaloneEditorWorkerDescriptor = {
amdModuleId: 'vs/editor/common/services/editorSimpleWorker',
esmModuleLocation: undefined,
label: 'editorWorkerService'
};
let StandaloneEditorWorkerService = class StandaloneEditorWorkerService extends EditorWorkerService {
constructor(modelService, configurationService, logService, languageConfigurationService, languageFeaturesService) {
super(standaloneEditorWorkerDescriptor, modelService, configurationService, logService, languageConfigurationService, languageFeaturesService);
}
};
StandaloneEditorWorkerService = __decorate([
__param(0, IModelService),
__param(1, ITextResourceConfigurationService),
__param(2, ILogService),
__param(3, ILanguageConfigurationService),
__param(4, ILanguageFeaturesService)
], StandaloneEditorWorkerService);
class StandaloneAccessbilitySignalService {
async playSignal(cue, options) {
}
}
registerSingleton(ILogService, StandaloneLogService, 0 /* InstantiationType.Eager */);
registerSingleton(IConfigurationService, StandaloneConfigurationService, 0 /* InstantiationType.Eager */);
registerSingleton(ITextResourceConfigurationService, StandaloneResourceConfigurationService, 0 /* InstantiationType.Eager */);
registerSingleton(ITextResourcePropertiesService, StandaloneResourcePropertiesService, 0 /* InstantiationType.Eager */);
registerSingleton(IWorkspaceContextService, StandaloneWorkspaceContextService, 0 /* InstantiationType.Eager */);
registerSingleton(ILabelService, StandaloneUriLabelService, 0 /* InstantiationType.Eager */);
registerSingleton(ITelemetryService, StandaloneTelemetryService, 0 /* InstantiationType.Eager */);
registerSingleton(IDialogService, StandaloneDialogService, 0 /* InstantiationType.Eager */);
registerSingleton(IEnvironmentService, StandaloneEnvironmentService, 0 /* InstantiationType.Eager */);
registerSingleton(INotificationService, StandaloneNotificationService, 0 /* InstantiationType.Eager */);
registerSingleton(IMarkerService, MarkerService, 0 /* InstantiationType.Eager */);
registerSingleton(ILanguageService, StandaloneLanguageService, 0 /* InstantiationType.Eager */);
registerSingleton(IStandaloneThemeService, StandaloneThemeService, 0 /* InstantiationType.Eager */);
registerSingleton(IModelService, ModelService, 0 /* InstantiationType.Eager */);
registerSingleton(IMarkerDecorationsService, MarkerDecorationsService, 0 /* InstantiationType.Eager */);
registerSingleton(IContextKeyService, ContextKeyService, 0 /* InstantiationType.Eager */);
registerSingleton(IProgressService, StandaloneProgressService, 0 /* InstantiationType.Eager */);
registerSingleton(IEditorProgressService, StandaloneEditorProgressService, 0 /* InstantiationType.Eager */);
registerSingleton(IStorageService, InMemoryStorageService, 0 /* InstantiationType.Eager */);
registerSingleton(IEditorWorkerService, StandaloneEditorWorkerService, 0 /* InstantiationType.Eager */);
registerSingleton(IBulkEditService, StandaloneBulkEditService, 0 /* InstantiationType.Eager */);
registerSingleton(IWorkspaceTrustManagementService, StandaloneWorkspaceTrustManagementService, 0 /* InstantiationType.Eager */);
registerSingleton(ITextModelService, StandaloneTextModelService, 0 /* InstantiationType.Eager */);
registerSingleton(IAccessibilityService, AccessibilityService, 0 /* InstantiationType.Eager */);
registerSingleton(IListService, ListService, 0 /* InstantiationType.Eager */);
registerSingleton(ICommandService, StandaloneCommandService, 0 /* InstantiationType.Eager */);
registerSingleton(IKeybindingService, StandaloneKeybindingService, 0 /* InstantiationType.Eager */);
registerSingleton(IQuickInputService, StandaloneQuickInputService, 0 /* InstantiationType.Eager */);
registerSingleton(IContextViewService, StandaloneContextViewService, 0 /* InstantiationType.Eager */);
registerSingleton(IOpenerService, OpenerService, 0 /* InstantiationType.Eager */);
registerSingleton(IClipboardService, BrowserClipboardService, 0 /* InstantiationType.Eager */);
registerSingleton(IContextMenuService, StandaloneContextMenuService, 0 /* InstantiationType.Eager */);
registerSingleton(IMenuService, MenuService, 0 /* InstantiationType.Eager */);
registerSingleton(IAccessibilitySignalService, StandaloneAccessbilitySignalService, 0 /* InstantiationType.Eager */);
registerSingleton(ITreeSitterParserService, StandaloneTreeSitterParserService, 0 /* InstantiationType.Eager */);
/**
* We don't want to eagerly instantiate services because embedders get a one time chance
* to override services when they create the first editor.
*/
export var StandaloneServices;
(function (StandaloneServices) {
const serviceCollection = new ServiceCollection();
for (const [id, descriptor] of getSingletonServiceDescriptors()) {
serviceCollection.set(id, descriptor);
}
const instantiationService = new InstantiationService(serviceCollection, true);
serviceCollection.set(IInstantiationService, instantiationService);
function get(serviceId) {
if (!initialized) {
initialize({});
}
const r = serviceCollection.get(serviceId);
if (!r) {
throw new Error('Missing service ' + serviceId);
}
if (r instanceof SyncDescriptor) {
return instantiationService.invokeFunction((accessor) => accessor.get(serviceId));
}
else {
return r;
}
}
StandaloneServices.get = get;
let initialized = false;
const onDidInitialize = new Emitter();
function initialize(overrides) {
if (initialized) {
return instantiationService;
}
initialized = true;
// Add singletons that were registered after this module loaded
for (const [id, descriptor] of getSingletonServiceDescriptors()) {
if (!serviceCollection.get(id)) {
serviceCollection.set(id, descriptor);
}
}
// Initialize the service collection with the overrides, but only if the
// service was not instantiated in the meantime.
for (const serviceId in overrides) {
if (overrides.hasOwnProperty(serviceId)) {
const serviceIdentifier = createDecorator(serviceId);
const r = serviceCollection.get(serviceIdentifier);
if (r instanceof SyncDescriptor) {
serviceCollection.set(serviceIdentifier, overrides[serviceId]);
}
}
}
// Instantiate all editor features
const editorFeatures = getEditorFeatures();
for (const feature of editorFeatures) {
try {
instantiationService.createInstance(feature);
}
catch (err) {
onUnexpectedError(err);
}
}
onDidInitialize.fire();
return instantiationService;
}
StandaloneServices.initialize = initialize;
/**
* Executes callback once services are initialized.
*/
function withServices(callback) {
if (initialized) {
return callback();
}
const disposable = new DisposableStore();
const listener = disposable.add(onDidInitialize.event(() => {
listener.dispose();
disposable.add(callback());
}));
return disposable;
}
StandaloneServices.withServices = withServices;
})(StandaloneServices || (StandaloneServices = {}));