@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

package/vscode/src/vs/workbench/contrib/codeEditor/browser/suggestEnabledInput/suggestEnabledInput.js

@@ -1,249 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import './suggestEnabledInput.css.js';
-import { append, $ } from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { Widget } from 'monaco-editor/esm/vs/base/browser/ui/widget.js';
-import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
-import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
-import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
-import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ContextMenuController } from 'monaco-editor/esm/vs/editor/contrib/contextmenu/browser/contextmenu.js';
-import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
-import { SuggestController } from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggestController.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { selectionBackground, inputBackground, inputForeground, editorSelectionBackground, asCssVariable, inputPlaceholderForeground, asCssVariableWithDefault, inputBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
-import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
-import { MenuPreventer } from '../menuPreventer.js';
-import { getSimpleEditorOptions } from '../simpleEditorOptions.js';
-import { SelectionClipboardContributionID } from '../selectionClipboard.js';
-import { EditorExtensionsRegistry } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
-import { DEFAULT_FONT_FAMILY } from '../../../../browser/style.js';
-import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
-import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
-import { ensureValidWordDefinition, getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-let SuggestEnabledInput = class SuggestEnabledInput extends Widget {
-    constructor(id, parent, suggestionProvider, ariaLabel, resourceHandle, options, defaultInstantiationService, modelService, contextKeyService, languageFeaturesService, configurationService) {
-        super();
-        this._onShouldFocusResults = ( (new Emitter()));
-        this.onShouldFocusResults = this._onShouldFocusResults.event;
-        this._onInputDidChange = ( (new Emitter()));
-        this.onInputDidChange = this._onInputDidChange.event;
-        this._onDidFocus = this._register(( (new Emitter())));
-        this.onDidFocus = this._onDidFocus.event;
-        this._onDidBlur = this._register(( (new Emitter())));
-        this.onDidBlur = this._onDidBlur.event;
-        this.stylingContainer = append(parent, $('.suggest-input-container'));
-        this.element = parent;
-        this.placeholderText = append(this.stylingContainer, $('.suggest-input-placeholder', undefined, options.placeholderText || ''));
-        const editorOptions = mixin(getSimpleEditorOptions(configurationService), getSuggestEnabledInputOptions(ariaLabel));
-        editorOptions.overflowWidgetsDomNode = options.overflowWidgetsDomNode;
-        const scopedContextKeyService = this.getScopedContextKeyService(contextKeyService);
-        const instantiationService = scopedContextKeyService
-            ? defaultInstantiationService.createChild(( (new ServiceCollection([IContextKeyService, scopedContextKeyService]))))
-            : defaultInstantiationService;
-        this.inputWidget = this._register(instantiationService.createInstance(CodeEditorWidget, this.stylingContainer, editorOptions, {
-            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
-                SuggestController.ID,
-                SnippetController2.ID,
-                ContextMenuController.ID,
-                MenuPreventer.ID,
-                SelectionClipboardContributionID,
-            ]),
-            isSimpleWidget: true,
-        }));
-        this._register(configurationService.onDidChangeConfiguration((e) => {
-            if (e.affectsConfiguration('editor.accessibilitySupport') ||
-                e.affectsConfiguration('editor.cursorBlinking')) {
-                const accessibilitySupport = configurationService.getValue('editor.accessibilitySupport');
-                const cursorBlinking = configurationService.getValue('editor.cursorBlinking');
-                this.inputWidget.updateOptions({
-                    accessibilitySupport,
-                    cursorBlinking
-                });
-            }
-        }));
-        this._register(this.inputWidget.onDidFocusEditorText(() => this._onDidFocus.fire()));
-        this._register(this.inputWidget.onDidBlurEditorText(() => this._onDidBlur.fire()));
-        const scopeHandle = ( URI.parse(resourceHandle));
-        this.inputModel = modelService.createModel('', null, scopeHandle, true);
-        this._register(this.inputModel);
-        this.inputWidget.setModel(this.inputModel);
-        this._register(this.inputWidget.onDidPaste(() => this.setValue(this.getValue())));
-        this._register((this.inputWidget.onDidFocusEditorText(() => {
-            if (options.focusContextKey) {
-                options.focusContextKey.set(true);
-            }
-            this.stylingContainer.classList.add('synthetic-focus');
-        })));
-        this._register((this.inputWidget.onDidBlurEditorText(() => {
-            if (options.focusContextKey) {
-                options.focusContextKey.set(false);
-            }
-            this.stylingContainer.classList.remove('synthetic-focus');
-        })));
-        const onKeyDownMonaco = Event.chain(this.inputWidget.onKeyDown);
-        this._register(onKeyDownMonaco.filter(e => e.keyCode === 3 ).on(e => { e.preventDefault();  }, this));
-        this._register(onKeyDownMonaco.filter(e => e.keyCode === 18  && (isMacintosh ? e.metaKey : e.ctrlKey)).on(() => this._onShouldFocusResults.fire(), this));
-        let preexistingContent = this.getValue();
-        const inputWidgetModel = this.inputWidget.getModel();
-        if (inputWidgetModel) {
-            this._register(inputWidgetModel.onDidChangeContent(() => {
-                const content = this.getValue();
-                this.placeholderText.style.visibility = content ? 'hidden' : 'visible';
-                if (preexistingContent.trim() === content.trim()) {
-                    return;
-                }
-                this._onInputDidChange.fire(undefined);
-                preexistingContent = content;
-            }));
-        }
-        const validatedSuggestProvider = {
-            provideResults: suggestionProvider.provideResults,
-            sortKey: suggestionProvider.sortKey || (a => a),
-            triggerCharacters: suggestionProvider.triggerCharacters || [],
-            wordDefinition: suggestionProvider.wordDefinition ? ensureValidWordDefinition(suggestionProvider.wordDefinition) : undefined,
-            alwaysShowSuggestions: !!suggestionProvider.alwaysShowSuggestions,
-        };
-        this.setValue(options.value || '');
-        this._register(languageFeaturesService.completionProvider.register({ scheme: scopeHandle.scheme, pattern: '**/' + scopeHandle.path, hasAccessToAllModels: true }, {
-            _debugDisplayName: `suggestEnabledInput/${id}`,
-            triggerCharacters: validatedSuggestProvider.triggerCharacters,
-            provideCompletionItems: (model, position, _context) => {
-                const query = model.getValue();
-                const zeroIndexedColumn = position.column - 1;
-                let alreadyTypedCount = 0, zeroIndexedWordStart = 0;
-                if (validatedSuggestProvider.wordDefinition) {
-                    const wordAtText = getWordAtText(position.column, validatedSuggestProvider.wordDefinition, query, 0);
-                    alreadyTypedCount = wordAtText?.word.length ?? 0;
-                    zeroIndexedWordStart = wordAtText ? wordAtText.startColumn - 1 : 0;
-                }
-                else {
-                    zeroIndexedWordStart = query.lastIndexOf(' ', zeroIndexedColumn - 1) + 1;
-                    alreadyTypedCount = zeroIndexedColumn - zeroIndexedWordStart;
-                }
-                if (!validatedSuggestProvider.alwaysShowSuggestions && alreadyTypedCount > 0 && validatedSuggestProvider.triggerCharacters?.indexOf(query[zeroIndexedWordStart]) === -1) {
-                    return { suggestions: [] };
-                }
-                return {
-                    suggestions: ( (suggestionProvider.provideResults(query).map((result) => {
-                        let label;
-                        let rest;
-                        if (typeof result === 'string') {
-                            label = result;
-                        }
-                        else {
-                            label = result.label;
-                            rest = result;
-                        }
-                        return {
-                            label,
-                            insertText: label,
-                            range: Range.fromPositions(position.delta(0, -alreadyTypedCount), position),
-                            sortText: validatedSuggestProvider.sortKey(label),
-                            kind: 17 ,
-                            ...rest
-                        };
-                    })))
-                };
-            }
-        }));
-        this.style(options.styleOverrides || {});
-    }
-    getScopedContextKeyService(_contextKeyService) {
-        return undefined;
-    }
-    updateAriaLabel(label) {
-        this.inputWidget.updateOptions({ ariaLabel: label });
-    }
-    setValue(val) {
-        val = val.replace(/\s/g, ' ');
-        const fullRange = this.inputModel.getFullModelRange();
-        this.inputWidget.executeEdits('suggestEnabledInput.setValue', [EditOperation.replace(fullRange, val)]);
-        this.inputWidget.setScrollTop(0);
-        this.inputWidget.setPosition(( (new Position(1, val.length + 1))));
-    }
-    getValue() {
-        return this.inputWidget.getValue();
-    }
-    style(styleOverrides) {
-        this.stylingContainer.style.backgroundColor = asCssVariable(styleOverrides.inputBackground ?? inputBackground);
-        this.stylingContainer.style.color = asCssVariable(styleOverrides.inputForeground ?? inputForeground);
-        this.placeholderText.style.color = asCssVariable(styleOverrides.inputPlaceholderForeground ?? inputPlaceholderForeground);
-        this.stylingContainer.style.borderWidth = '1px';
-        this.stylingContainer.style.borderStyle = 'solid';
-        this.stylingContainer.style.borderColor = asCssVariableWithDefault(styleOverrides.inputBorder ?? inputBorder, 'transparent');
-        const cursor = this.stylingContainer.getElementsByClassName('cursor')[0];
-        if (cursor) {
-            cursor.style.backgroundColor = asCssVariable(styleOverrides.inputForeground ?? inputForeground);
-        }
-    }
-    focus(selectAll) {
-        this.inputWidget.focus();
-        if (selectAll && this.inputWidget.getValue()) {
-            this.selectAll();
-        }
-    }
-    onHide() {
-        this.inputWidget.onHide();
-    }
-    layout(dimension) {
-        this.inputWidget.layout(dimension);
-        this.placeholderText.style.width = `${dimension.width - 2}px`;
-    }
-    selectAll() {
-        this.inputWidget.setSelection(( (new Range(1, 1, 1, this.getValue().length + 1))));
-    }
-};
-SuggestEnabledInput = ( (__decorate([
-    ( (__param(6, IInstantiationService))),
-    ( (__param(7, IModelService))),
-    ( (__param(8, IContextKeyService))),
-    ( (__param(9, ILanguageFeaturesService))),
-    ( (__param(10, IConfigurationService)))
-], SuggestEnabledInput)));
-registerThemingParticipant((theme, collector) => {
-    const selectionBackgroundColor = theme.getColor(selectionBackground);
-    if (selectionBackgroundColor) {
-        const inputBackgroundColor = theme.getColor(inputBackground);
-        if (inputBackgroundColor) {
-            collector.addRule(`.suggest-input-container .monaco-editor .selected-text { background-color: ${( ( inputBackgroundColor.transparent(0.4)))}; }`);
-        }
-        const inputForegroundColor = theme.getColor(inputForeground);
-        if (inputForegroundColor) {
-            collector.addRule(`.suggest-input-container .monaco-editor .view-line span.inline-selected-text { color: ${inputForegroundColor}; }`);
-        }
-        const backgroundColor = theme.getColor(inputBackground);
-        if (backgroundColor) {
-            collector.addRule(`.suggest-input-container .monaco-editor-background { background-color: ${backgroundColor}; } `);
-        }
-        collector.addRule(`.suggest-input-container .monaco-editor .focused .selected-text { background-color: ${selectionBackgroundColor}; }`);
-    }
-    else {
-        collector.addRule(`.suggest-input-container .monaco-editor .focused .selected-text { background-color: ${theme.getColor(editorSelectionBackground)}; }`);
-    }
-});
-function getSuggestEnabledInputOptions(ariaLabel) {
-    return {
-        fontSize: 13,
-        lineHeight: 20,
-        wordWrap: 'off',
-        scrollbar: { vertical: 'hidden', },
-        roundedSelection: false,
-        guides: {
-            indentation: false
-        },
-        cursorWidth: 1,
-        fontFamily: DEFAULT_FONT_FAMILY,
-        ariaLabel: ariaLabel || '',
-        snippetSuggestions: 'none',
-        suggest: { filterGraceful: false, showIcons: false },
-        autoClosingBrackets: 'never'
-    };
-}
-export { SuggestEnabledInput };

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditor.contribution.js

@@ -1,14 +0,0 @@
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { EditorPaneDescriptor } from '../../../browser/editor.js';
-import { Extensions } from '../../../common/contributions.js';
-import { EditorExtensions } from '../../../common/editor.js';
-import { ComplexCustomWorkingCopyEditorHandler } from './customEditorInputFactory.js';
-import { WebviewEditor } from '../../webviewPanel/browser/webviewEditor.js';
-import { CustomEditorInput } from './customEditorInput.js';
-( Registry.as(EditorExtensions.EditorPane))
-    .registerEditorPane(EditorPaneDescriptor.create(WebviewEditor, WebviewEditor.ID, 'Webview Editor'), [
-    ( new SyncDescriptor(CustomEditorInput))
-]);
-( Registry.as(Extensions.Workbench))
-    .registerWorkbenchContribution(ComplexCustomWorkingCopyEditorHandler, 1 );

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInputFactory.js

@@ -1,137 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { CustomEditorInput } from './customEditorInput.js';
-import { ICustomEditorService } from '../common/customEditor.js';
-import { NotebookEditorInput } from '../../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
-import { IWebviewService } from '../../webview/browser/webview.js';
-import { WebviewEditorInputSerializer, restoreWebviewOptions, restoreWebviewContentOptions, reviveWebviewExtensionDescription } from '../../webviewPanel/browser/webviewEditorInputSerializer.js';
-import { IWorkingCopyBackupService } from '../../../services/workingCopy/common/workingCopyBackup.js';
-import { IWorkingCopyEditorService } from '../../../services/workingCopy/common/workingCopyEditorService.js';
-(class CustomEditorInputSerializer extends WebviewEditorInputSerializer {
-    static { this.ID = CustomEditorInput.typeId; }
-    constructor(webviewWorkbenchService, _instantiationService, _webviewService) {
-        super(webviewWorkbenchService);
-        this._instantiationService = _instantiationService;
-        this._webviewService = _webviewService;
-    }
-    serialize(input) {
-        const dirty = input.isDirty();
-        const data = {
-            ...this.toJson(input),
-            editorResource: input.resource.toJSON(),
-            dirty,
-            backupId: dirty ? input.backupId : undefined,
-        };
-        try {
-            return JSON.stringify(data);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    fromJson(data) {
-        return {
-            ...super.fromJson(data),
-            editorResource: ( URI.from(data.editorResource)),
-            dirty: data.dirty,
-        };
-    }
-    deserialize(_instantiationService, serializedEditorInput) {
-        const data = this.fromJson(JSON.parse(serializedEditorInput));
-        const webview = reviveWebview(this._webviewService, data);
-        const customInput = this._instantiationService.createInstance(CustomEditorInput, { resource: data.editorResource, viewType: data.viewType }, webview, { startsDirty: data.dirty, backupId: data.backupId });
-        if (typeof data.group === 'number') {
-            customInput.updateGroup(data.group);
-        }
-        return customInput;
-    }
-});
-function reviveWebview(webviewService, data) {
-    const webview = webviewService.createWebviewOverlay({
-        providedViewType: data.viewType,
-        origin: data.origin,
-        title: undefined,
-        options: {
-            purpose: "customEditor" ,
-            enableFindWidget: data.webviewOptions.enableFindWidget,
-            retainContextWhenHidden: data.webviewOptions.retainContextWhenHidden,
-        },
-        contentOptions: data.contentOptions,
-        extension: data.extension,
-    });
-    webview.state = data.state;
-    return webview;
-}
-let ComplexCustomWorkingCopyEditorHandler = class ComplexCustomWorkingCopyEditorHandler extends Disposable {
-    constructor(_instantiationService, _workingCopyEditorService, _workingCopyBackupService, _webviewService, _customEditorService
-    ) {
-        super();
-        this._instantiationService = _instantiationService;
-        this._workingCopyBackupService = _workingCopyBackupService;
-        this._webviewService = _webviewService;
-        this._register(_workingCopyEditorService.registerHandler(this));
-    }
-    handles(workingCopy) {
-        return workingCopy.resource.scheme === Schemas.vscodeCustomEditor;
-    }
-    isOpen(workingCopy, editor) {
-        if (!this.handles(workingCopy)) {
-            return false;
-        }
-        if (workingCopy.resource.authority === 'jupyter-notebook-ipynb' && editor instanceof NotebookEditorInput) {
-            try {
-                const data = JSON.parse(workingCopy.resource.query);
-                const workingCopyResource = ( URI.from(data));
-                return isEqual(workingCopyResource, editor.resource);
-            }
-            catch {
-                return false;
-            }
-        }
-        if (!(editor instanceof CustomEditorInput)) {
-            return false;
-        }
-        if (workingCopy.resource.authority !== editor.viewType.replace(/[^a-z0-9\-_]/gi, '-').toLowerCase()) {
-            return false;
-        }
-        try {
-            const data = JSON.parse(workingCopy.resource.query);
-            const workingCopyResource = ( URI.from(data));
-            return isEqual(workingCopyResource, editor.resource);
-        }
-        catch {
-            return false;
-        }
-    }
-    async createEditor(workingCopy) {
-        const backup = await this._workingCopyBackupService.resolve(workingCopy);
-        if (!backup?.meta) {
-            throw new Error(`No backup found for custom editor: ${workingCopy.resource}`);
-        }
-        const backupData = backup.meta;
-        const extension = reviveWebviewExtensionDescription(backupData.extension?.id, backupData.extension?.location);
-        const webview = reviveWebview(this._webviewService, {
-            viewType: backupData.viewType,
-            origin: backupData.webview.origin,
-            webviewOptions: restoreWebviewOptions(backupData.webview.options),
-            contentOptions: restoreWebviewContentOptions(backupData.webview.options),
-            state: backupData.webview.state,
-            extension,
-        });
-        const editor = this._instantiationService.createInstance(CustomEditorInput, { resource: URI.revive(backupData.editorResource), viewType: backupData.viewType }, webview, { backupId: backupData.backupId });
-        editor.updateGroup(0);
-        return editor;
-    }
-};
-ComplexCustomWorkingCopyEditorHandler = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkingCopyEditorService)),
-    ( __param(2, IWorkingCopyBackupService)),
-    ( __param(3, IWebviewService)),
-    ( __param(4, ICustomEditorService))
-], ComplexCustomWorkingCopyEditorHandler));
-export { ComplexCustomWorkingCopyEditorHandler };

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditors.js

@@ -1,212 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/customEditor.css.js';
-import { coalesce } from 'monaco-editor/esm/vs/base/common/arrays.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { extname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { UndoCommand, RedoCommand } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
-import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.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 { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { EditorExtensions, DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
-import { DiffEditorInput } from '../../../common/editor/diffEditorInput.js';
-import { CONTEXT_ACTIVE_CUSTOM_EDITOR_ID, CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE, CustomEditorInfoCollection } from '../common/customEditor.js';
-import { CustomEditorModelManager } from '../common/customEditorModelManager.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { ContributedCustomEditors } from '../common/contributedCustomEditors.js';
-import { CustomEditorInput } from './customEditorInput.js';
-let CustomEditorService = class CustomEditorService extends Disposable {
-    constructor(contextKeyService, fileService, storageService, editorService, editorGroupService, instantiationService, uriIdentityService, editorResolverService) {
-        super();
-        this.editorService = editorService;
-        this.editorGroupService = editorGroupService;
-        this.instantiationService = instantiationService;
-        this.uriIdentityService = uriIdentityService;
-        this.editorResolverService = editorResolverService;
-        this._untitledCounter = 0;
-        this._editorResolverDisposables = this._register(( new DisposableStore()));
-        this._editorCapabilities = ( new Map());
-        this._models = ( new CustomEditorModelManager());
-        this._onDidChangeEditorTypes = this._register(( new Emitter()));
-        this.onDidChangeEditorTypes = this._onDidChangeEditorTypes.event;
-        this._fileEditorFactory = ( Registry.as(EditorExtensions.EditorFactory)).getFileEditorFactory();
-        this._activeCustomEditorId = CONTEXT_ACTIVE_CUSTOM_EDITOR_ID.bindTo(contextKeyService);
-        this._focusedCustomEditorIsEditable = CONTEXT_FOCUSED_CUSTOM_EDITOR_IS_EDITABLE.bindTo(contextKeyService);
-        this._contributedEditors = this._register(( new ContributedCustomEditors(storageService)));
-        this.editorResolverService.bufferChangeEvents(this.registerContributionPoints.bind(this));
-        this._register(this._contributedEditors.onChange(() => {
-            this.editorResolverService.bufferChangeEvents(this.registerContributionPoints.bind(this));
-            this.updateContexts();
-            this._onDidChangeEditorTypes.fire();
-        }));
-        this._register(this.editorService.onDidActiveEditorChange(() => this.updateContexts()));
-        this._register(fileService.onDidRunOperation(e => {
-            if (e.isOperation(2 )) {
-                this.handleMovedFileInOpenedFileEditors(e.resource, this.uriIdentityService.asCanonicalUri(e.target.resource));
-            }
-        }));
-        const PRIORITY = 105;
-        this._register(UndoCommand.addImplementation(PRIORITY, 'custom-editor', () => {
-            return this.withActiveCustomEditor(editor => editor.undo());
-        }));
-        this._register(RedoCommand.addImplementation(PRIORITY, 'custom-editor', () => {
-            return this.withActiveCustomEditor(editor => editor.redo());
-        }));
-        this.updateContexts();
-    }
-    getEditorTypes() {
-        return [...this._contributedEditors];
-    }
-    withActiveCustomEditor(f) {
-        const activeEditor = this.editorService.activeEditor;
-        if (activeEditor instanceof CustomEditorInput) {
-            const result = f(activeEditor);
-            if (result) {
-                return result;
-            }
-            return true;
-        }
-        return false;
-    }
-    registerContributionPoints() {
-        this._editorResolverDisposables.clear();
-        for (const contributedEditor of this._contributedEditors) {
-            for (const globPattern of contributedEditor.selector) {
-                if (!globPattern.filenamePattern) {
-                    continue;
-                }
-                this._editorResolverDisposables.add(this.editorResolverService.registerEditor(globPattern.filenamePattern, {
-                    id: contributedEditor.id,
-                    label: contributedEditor.displayName,
-                    detail: contributedEditor.providerDisplayName,
-                    priority: contributedEditor.priority,
-                }, {
-                    singlePerResource: () => !this.getCustomEditorCapabilities(contributedEditor.id)?.supportsMultipleEditorsPerDocument ?? true
-                }, {
-                    createEditorInput: ({ resource }, group) => {
-                        return { editor: CustomEditorInput.create(this.instantiationService, resource, contributedEditor.id, group.id) };
-                    },
-                    createUntitledEditorInput: ({ resource }, group) => {
-                        return { editor: CustomEditorInput.create(this.instantiationService, resource ?? ( URI.from(
-                            { scheme: Schemas.untitled, authority: `Untitled-${this._untitledCounter++}` }
-                        )), contributedEditor.id, group.id) };
-                    },
-                    createDiffEditorInput: (diffEditorInput, group) => {
-                        return { editor: this.createDiffEditorInput(diffEditorInput, contributedEditor.id, group) };
-                    },
-                }));
-            }
-        }
-    }
-    createDiffEditorInput(editor, editorID, group) {
-        const modifiedOverride = CustomEditorInput.create(this.instantiationService, assertIsDefined(editor.modified.resource), editorID, group.id, { customClasses: 'modified' });
-        const originalOverride = CustomEditorInput.create(this.instantiationService, assertIsDefined(editor.original.resource), editorID, group.id, { customClasses: 'original' });
-        return this.instantiationService.createInstance(DiffEditorInput, editor.label, editor.description, originalOverride, modifiedOverride, true);
-    }
-    get models() { return this._models; }
-    getCustomEditor(viewType) {
-        return this._contributedEditors.get(viewType);
-    }
-    getContributedCustomEditors(resource) {
-        return ( new CustomEditorInfoCollection(this._contributedEditors.getContributedEditors(resource)));
-    }
-    getUserConfiguredCustomEditors(resource) {
-        const resourceAssocations = this.editorResolverService.getAssociationsForResource(resource);
-        return ( new CustomEditorInfoCollection(coalesce(( resourceAssocations
-            .map(association => this._contributedEditors.get(association.viewType))))));
-    }
-    getAllCustomEditors(resource) {
-        return ( new CustomEditorInfoCollection([
-            ...this.getUserConfiguredCustomEditors(resource).allEditors,
-            ...this.getContributedCustomEditors(resource).allEditors,
-        ]));
-    }
-    registerCustomEditorCapabilities(viewType, options) {
-        if (( this._editorCapabilities.has(viewType))) {
-            throw new Error(`Capabilities for ${viewType} already set`);
-        }
-        this._editorCapabilities.set(viewType, options);
-        return toDisposable(() => {
-            this._editorCapabilities.delete(viewType);
-        });
-    }
-    getCustomEditorCapabilities(viewType) {
-        return this._editorCapabilities.get(viewType);
-    }
-    updateContexts() {
-        const activeEditorPane = this.editorService.activeEditorPane;
-        const resource = activeEditorPane?.input?.resource;
-        if (!resource) {
-            this._activeCustomEditorId.reset();
-            this._focusedCustomEditorIsEditable.reset();
-            return;
-        }
-        this._activeCustomEditorId.set(activeEditorPane?.input instanceof CustomEditorInput ? activeEditorPane.input.viewType : '');
-        this._focusedCustomEditorIsEditable.set(activeEditorPane?.input instanceof CustomEditorInput);
-    }
-    async handleMovedFileInOpenedFileEditors(oldResource, newResource) {
-        if (extname(oldResource).toLowerCase() === extname(newResource).toLowerCase()) {
-            return;
-        }
-        const possibleEditors = this.getAllCustomEditors(newResource);
-        if (!( possibleEditors.allEditors.some(editor => editor.priority !== RegisteredEditorPriority.option))) {
-            return;
-        }
-        const editorsToReplace = ( new Map());
-        for (const group of this.editorGroupService.groups) {
-            for (const editor of group.editors) {
-                if (this._fileEditorFactory.isFileEditor(editor)
-                    && !(editor instanceof CustomEditorInput)
-                    && isEqual(editor.resource, newResource)) {
-                    let entry = editorsToReplace.get(group.id);
-                    if (!entry) {
-                        entry = [];
-                        editorsToReplace.set(group.id, entry);
-                    }
-                    entry.push(editor);
-                }
-            }
-        }
-        if (!editorsToReplace.size) {
-            return;
-        }
-        for (const [group, entries] of editorsToReplace) {
-            this.editorService.replaceEditors(( entries.map(editor => {
-                let replacement;
-                if (possibleEditors.defaultEditor) {
-                    const viewType = possibleEditors.defaultEditor.id;
-                    replacement = CustomEditorInput.create(this.instantiationService, newResource, viewType, group);
-                }
-                else {
-                    replacement = { resource: newResource, options: { override: DEFAULT_EDITOR_ASSOCIATION.id } };
-                }
-                return {
-                    editor,
-                    replacement,
-                    options: {
-                        preserveFocus: true,
-                    }
-                };
-            })), group);
-        }
-    }
-};
-CustomEditorService = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IStorageService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IEditorGroupsService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IUriIdentityService)),
-    ( __param(7, IEditorResolverService))
-], CustomEditorService));
-export { CustomEditorService };

package/vscode/src/vs/workbench/contrib/customEditor/browser/media/customEditor.css.js

@@ -1,4 +0,0 @@
-import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".webview.modified{box-shadow:-6px 0 5px -5px var(--vscode-scrollbar-shadow)}";
-n(css,{});
-export { css, css as default };