@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.2

package/vscode/src/vs/base/common/network.js

@@ -109,7 +109,6 @@ class RemoteAuthoritiesImpl {
     }
 }
 const RemoteAuthorities = ( new RemoteAuthoritiesImpl());
-const builtinExtensionsPath = 'vs/../../extensions';
 const nodeModulesPath = 'vs/../../node_modules';
 const nodeModulesAsarPath = 'vs/../../node_modules.asar';
 const nodeModulesAsarUnpackedPath = 'vs/../../node_modules.asar.unpacked';
@@ -234,4 +233,4 @@ var COI;
     }
     COI.addSearchParam = addSearchParam;
 })(COI || (COI = {})));
-export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, builtinExtensionsPath, connectionTokenQueryName, matchesScheme, matchesSomeScheme, nodeModulesAsarPath, nodeModulesAsarUnpackedPath, nodeModulesPath };
+export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, connectionTokenQueryName, matchesScheme, matchesSomeScheme, nodeModulesAsarPath, nodeModulesAsarUnpackedPath, nodeModulesPath };

package/vscode/src/vs/base/common/observableInternal/utils.js

@@ -1,7 +1,7 @@
 import { toDisposable, DisposableStore } from '../lifecycle.js';
 import { autorun } from './autorun.js';
 import { ConvenientObservable, BaseObservable, subtransaction, getFunctionName, transaction, getDebugName, _setKeepObserved, _setRecomputeInitiallyAndOnChange, observableValue } from './base.js';
-import { derived, derivedOpts } from './derived.js';
+import { derivedOpts, derived } from './derived.js';
 function constObservable(value) {
     return ( new ConstObservable(value));
 }

package/vscode/src/vs/base/common/platform.js

@@ -126,6 +126,7 @@ var Language;
     }
     Language.isDefault = isDefault;
 })(Language || (Language = {})));
+const locale = _locale;
 const platformLocale = _platformLocale;
 const setTimeout0IsFaster = (typeof $globalThis.postMessage === 'function' && !$globalThis.importScripts);
 const setTimeout0 = (() => {
@@ -180,4 +181,4 @@ const isFirefox = !!(userAgent && userAgent.indexOf('Firefox') >= 0);
 const isSafari = !!(!isChrome && (userAgent && userAgent.indexOf('Safari') >= 0));
 const isEdge = !!(userAgent && userAgent.indexOf('Edg/') >= 0);
 const isAndroid = !!(userAgent && userAgent.indexOf('Android') >= 0);
-export { LANGUAGE_DEFAULT, Language, OS, OperatingSystem, Platform, PlatformToString, isAndroid, isCI, isChrome, isEdge, isFirefox, isIOS, isLinux, isLittleEndian, isMacintosh, isMobile, isNative, isSafari, isWeb, isWebWorker, isWindows, language, platform, platformLocale, setTimeout0, setTimeout0IsFaster, userAgent, webWorkerOrigin };
+export { LANGUAGE_DEFAULT, Language, OS, OperatingSystem, Platform, PlatformToString, isAndroid, isCI, isChrome, isEdge, isFirefox, isIOS, isLinux, isLittleEndian, isMacintosh, isMobile, isNative, isSafari, isWeb, isWebWorker, isWindows, language, locale, platform, platformLocale, setTimeout0, setTimeout0IsFaster, userAgent, webWorkerOrigin };

package/vscode/src/vs/base/common/scrollable.d.ts

@@ -0,0 +1,28 @@
+declare const enum ScrollbarVisibility {
+    Auto = 1,
+    Hidden = 2,
+    Visible = 3
+}
+interface ScrollEvent {
+    inSmoothScrolling: boolean;
+    oldWidth: number;
+    oldScrollWidth: number;
+    oldScrollLeft: number;
+    width: number;
+    scrollWidth: number;
+    scrollLeft: number;
+    oldHeight: number;
+    oldScrollHeight: number;
+    oldScrollTop: number;
+    height: number;
+    scrollHeight: number;
+    scrollTop: number;
+    widthChanged: boolean;
+    scrollWidthChanged: boolean;
+    scrollLeftChanged: boolean;
+    heightChanged: boolean;
+    scrollHeightChanged: boolean;
+    scrollTopChanged: boolean;
+}
+
+export { type ScrollEvent, ScrollbarVisibility };

package/vscode/src/vs/editor/browser/widget/multiDiffEditorWidget/colors.js

@@ -0,0 +1,17 @@
+import { localizeWithPath } from '../../../../nls.js';
+import { registerColor } from '../../../../platform/theme/common/colorRegistry.js';
+registerColor('multiDiffEditor.headerBackground', { dark: '#808080', light: '#b4b4b4', hcDark: '#808080', hcLight: '#b4b4b4', }, ( localizeWithPath(
+ 'vs/editor/browser/widget/multiDiffEditorWidget/colors',
+ 'multiDiffEditor.headerBackground',
+ 'The background color of the diff editor\'s header'
+)));
+registerColor('multiDiffEditor.background', { dark: '#000000', light: '#e5e5e5', hcDark: '#000000', hcLight: '#e5e5e5', }, ( localizeWithPath(
+ 'vs/editor/browser/widget/multiDiffEditorWidget/colors',
+ 'multiDiffEditor.background',
+ 'The background color of the multi file diff editor'
+)));
+registerColor('multiDiffEditor.border', { dark: 'sideBarSectionHeader.border', light: '#cccccc', hcDark: 'sideBarSectionHeader.border', hcLight: '#cccccc', }, ( localizeWithPath(
+ 'vs/editor/browser/widget/multiDiffEditorWidget/colors',
+ 'multiDiffEditor.border',
+ 'The border color of the multi file diff editor'
+)));

package/vscode/src/vs/editor/browser/widget/multiDiffEditorWidget/diffEditorItemTemplate.js

@@ -0,0 +1,214 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { h } from '../../../../base/browser/dom.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { observableValue, globalTransaction } from '../../../../base/common/observableInternal/base.js';
+import { DiffEditorWidget } from '../diffEditor/diffEditorWidget.js';
+import { MenuWorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ActionRunnerWithContext } from './utils.js';
+import { derived } from '../../../../base/common/observableInternal/derived.js';
+import { autorun } from '../../../../base/common/observableInternal/autorun.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/utils.js';
+class TemplateData {
+    constructor(viewModel) {
+        this.viewModel = viewModel;
+    }
+    getId() {
+        return this.viewModel;
+    }
+}
+let DiffEditorItemTemplate = class DiffEditorItemTemplate extends Disposable {
+    constructor(_container, _overflowWidgetsDomNode, _workbenchUIElementFactory, _instantiationService) {
+        super();
+        this._container = _container;
+        this._overflowWidgetsDomNode = _overflowWidgetsDomNode;
+        this._workbenchUIElementFactory = _workbenchUIElementFactory;
+        this._instantiationService = _instantiationService;
+        this._viewModel = observableValue(this, undefined);
+        this._collapsed = derived(this, reader => this._viewModel.read(reader)?.collapsed.read(reader));
+        this._editorContentHeight = observableValue(this, 500);
+        this.contentHeight = derived(this, reader => {
+            const h = this._collapsed.read(reader) ? 0 : this._editorContentHeight.read(reader);
+            return h + this._outerEditorHeight;
+        });
+        this._modifiedContentWidth = observableValue(this, 0);
+        this._modifiedWidth = observableValue(this, 0);
+        this._originalContentWidth = observableValue(this, 0);
+        this._originalWidth = observableValue(this, 0);
+        this.maxScroll = derived(this, reader => {
+            const scroll1 = this._modifiedContentWidth.read(reader) - this._modifiedWidth.read(reader);
+            const scroll2 = this._originalContentWidth.read(reader) - this._originalWidth.read(reader);
+            if (scroll1 > scroll2) {
+                return { maxScroll: scroll1, width: this._modifiedWidth.read(reader) };
+            }
+            else {
+                return { maxScroll: scroll2, width: this._originalWidth.read(reader) };
+            }
+        });
+        this._elements = h('div.multiDiffEntry', [
+            h('div.header@header', [
+                h('div.collapse-button@collapseButton'),
+                h('div.file-path', [
+                    h('div.title.modified.show-file-icons@primaryPath', []),
+                    h('div.status.deleted@status', ['R']),
+                    h('div.title.original.show-file-icons@secondaryPath', []),
+                ]),
+                h('div.actions@actions'),
+            ]),
+            h('div.editorParent', [
+                h('div.editorContainer@editor'),
+            ])
+        ]);
+        this.editor = this._register(this._instantiationService.createInstance(DiffEditorWidget, this._elements.editor, {
+            overflowWidgetsDomNode: this._overflowWidgetsDomNode,
+        }, {}));
+        this.isModifedFocused = isFocused(this.editor.getModifiedEditor());
+        this.isOriginalFocused = isFocused(this.editor.getOriginalEditor());
+        this.isFocused = derived(this, reader => this.isModifedFocused.read(reader) || this.isOriginalFocused.read(reader));
+        this._resourceLabel = this._workbenchUIElementFactory.createResourceLabel
+            ? this._register(this._workbenchUIElementFactory.createResourceLabel(this._elements.primaryPath))
+            : undefined;
+        this._resourceLabel2 = this._workbenchUIElementFactory.createResourceLabel
+            ? this._register(this._workbenchUIElementFactory.createResourceLabel(this._elements.secondaryPath))
+            : undefined;
+        this._dataStore = ( new DisposableStore());
+        this._headerHeight = 38;
+        const btn = ( new Button(this._elements.collapseButton, {}));
+        this._register(autorun(reader => {
+            btn.element.className = '';
+            btn.icon = this._collapsed.read(reader) ? Codicon.chevronRight : Codicon.chevronDown;
+        }));
+        this._register(btn.onDidClick(() => {
+            this._viewModel.get()?.collapsed.set(!this._collapsed.get(), undefined);
+        }));
+        this._register(autorun(reader => {
+            this._elements.editor.style.display = this._collapsed.read(reader) ? 'none' : 'block';
+        }));
+        this.editor.getModifiedEditor().onDidLayoutChange(e => {
+            const width = this.editor.getModifiedEditor().getLayoutInfo().contentWidth;
+            this._modifiedWidth.set(width, undefined);
+        });
+        this.editor.getOriginalEditor().onDidLayoutChange(e => {
+            const width = this.editor.getOriginalEditor().getLayoutInfo().contentWidth;
+            this._originalWidth.set(width, undefined);
+        });
+        this._register(this.editor.onDidContentSizeChange(e => {
+            globalTransaction(tx => {
+                this._editorContentHeight.set(e.contentHeight, tx);
+                this._modifiedContentWidth.set(this.editor.getModifiedEditor().getContentWidth(), tx);
+                this._originalContentWidth.set(this.editor.getOriginalEditor().getContentWidth(), tx);
+            });
+        }));
+        this._register(autorun(reader => {
+            const isFocused = this.isFocused.read(reader);
+            this._elements.root.classList.toggle('focused', isFocused);
+        }));
+        this._container.appendChild(this._elements.root);
+        this._outerEditorHeight = 38;
+        this._register(this._instantiationService.createInstance(MenuWorkbenchToolBar, this._elements.actions, MenuId.MultiDiffEditorFileToolbar, {
+            actionRunner: this._register(( new ActionRunnerWithContext(() => (this._viewModel.get()?.modifiedUri)))),
+            menuOptions: {
+                shouldForwardArgs: true,
+            },
+            toolbarOptions: { primaryGroup: g => g.startsWith('navigation') },
+        }));
+    }
+    setScrollLeft(left) {
+        if (this._modifiedContentWidth.get() - this._modifiedWidth.get() > this._originalContentWidth.get() - this._originalWidth.get()) {
+            this.editor.getModifiedEditor().setScrollLeft(left);
+        }
+        else {
+            this.editor.getOriginalEditor().setScrollLeft(left);
+        }
+    }
+    setData(data) {
+        function updateOptions(options) {
+            return {
+                ...options,
+                scrollBeyondLastLine: false,
+                hideUnchangedRegions: {
+                    enabled: true,
+                },
+                scrollbar: {
+                    vertical: 'hidden',
+                    horizontal: 'hidden',
+                    handleMouseWheel: false,
+                    useShadows: false,
+                },
+                renderOverviewRuler: false,
+                fixedOverflowWidgets: true,
+                overviewRulerBorder: false,
+            };
+        }
+        const value = data.viewModel.entry.value;
+        if (value.onOptionsDidChange) {
+            this._dataStore.add(value.onOptionsDidChange(() => {
+                this.editor.updateOptions(updateOptions(value.options ?? {}));
+            }));
+        }
+        globalTransaction(tx => {
+            this._resourceLabel?.setUri(data.viewModel.modifiedUri ?? data.viewModel.originalUri, { strikethrough: data.viewModel.modifiedUri === undefined });
+            let isRenamed = false;
+            let isDeleted = false;
+            let isAdded = false;
+            let flag = '';
+            if (data.viewModel.modifiedUri && data.viewModel.originalUri && data.viewModel.modifiedUri.path !== data.viewModel.originalUri.path) {
+                flag = 'R';
+                isRenamed = true;
+            }
+            else if (!data.viewModel.modifiedUri) {
+                flag = 'D';
+                isDeleted = true;
+            }
+            else if (!data.viewModel.originalUri) {
+                flag = 'A';
+                isAdded = true;
+            }
+            this._elements.status.classList.toggle('renamed', isRenamed);
+            this._elements.status.classList.toggle('deleted', isDeleted);
+            this._elements.status.classList.toggle('added', isAdded);
+            this._elements.status.innerText = flag;
+            this._resourceLabel2?.setUri(isRenamed ? data.viewModel.originalUri : undefined, { strikethrough: true });
+            this._dataStore.clear();
+            this._viewModel.set(data.viewModel, tx);
+            this.editor.setModel(data.viewModel.diffEditorViewModel, tx);
+            this.editor.updateOptions(updateOptions(value.options ?? {}));
+        });
+    }
+    render(verticalRange, width, editorScroll, viewPort) {
+        this._elements.root.style.visibility = 'visible';
+        this._elements.root.style.top = `${verticalRange.start}px`;
+        this._elements.root.style.height = `${verticalRange.length}px`;
+        this._elements.root.style.width = `${width}px`;
+        this._elements.root.style.position = 'absolute';
+        const delta = Math.max(0, Math.min(verticalRange.length - this._headerHeight, viewPort.start - verticalRange.start));
+        this._elements.header.style.transform = `translateY(${delta}px)`;
+        globalTransaction(tx => {
+            this.editor.layout({
+                width: width,
+                height: verticalRange.length - this._outerEditorHeight,
+            });
+        });
+        this.editor.getOriginalEditor().setScrollTop(editorScroll);
+        this._elements.header.classList.toggle('shadow', delta > 0 || editorScroll > 0);
+    }
+    hide() {
+        this._elements.root.style.top = `-100000px`;
+        this._elements.root.style.visibility = 'hidden';
+    }
+};
+DiffEditorItemTemplate = ( __decorate([
+    ( __param(3, IInstantiationService))
+], DiffEditorItemTemplate));
+function isFocused(editor) {
+    return observableFromEvent(h => {
+        const store = ( new DisposableStore());
+        store.add(editor.onDidFocusEditorWidget(() => h(true)));
+        store.add(editor.onDidBlurEditorWidget(() => h(false)));
+        return store;
+    }, () => editor.hasWidgetFocus());
+}
+export { DiffEditorItemTemplate, TemplateData };

package/vscode/src/vs/editor/browser/widget/multiDiffEditorWidget/multiDiffEditorViewModel.js

@@ -0,0 +1,84 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { observableFromEvent, mapObservableArrayCached } from '../../../../base/common/observableInternal/utils.js';
+import { DiffEditorOptions } from '../diffEditor/diffEditorOptions.js';
+import { DiffEditorViewModel } from '../diffEditor/diffEditorViewModel.js';
+import { IModelService } from '../../../common/services/model.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { transaction, observableValue } from '../../../../base/common/observableInternal/base.js';
+class MultiDiffEditorViewModel extends Disposable {
+    async waitForDiffs() {
+        for (const d of this.items.get()) {
+            await d.diffEditorViewModel.waitForDiff();
+        }
+    }
+    collapseAll() {
+        transaction(tx => {
+            for (const d of this.items.get()) {
+                d.collapsed.set(true, tx);
+            }
+        });
+    }
+    expandAll() {
+        transaction(tx => {
+            for (const d of this.items.get()) {
+                d.collapsed.set(false, tx);
+            }
+        });
+    }
+    get contextKeys() {
+        return this.model.contextKeys;
+    }
+    constructor(model, _instantiationService) {
+        super();
+        this.model = model;
+        this._instantiationService = _instantiationService;
+        this._documents = observableFromEvent(this.model.onDidChange,  () => this.model.documents);
+        this.items = mapObservableArrayCached(this, this._documents, (d, store) => store.add(this._instantiationService.createInstance(DocumentDiffItemViewModel, d)))
+            .recomputeInitiallyAndOnChange(this._store);
+        this.activeDiffItem = observableValue(this, undefined);
+    }
+}
+let DocumentDiffItemViewModel = class DocumentDiffItemViewModel extends Disposable {
+    get originalUri() { return this.entry.value.original?.uri; }
+    get modifiedUri() { return this.entry.value.modified?.uri; }
+    constructor(entry, _instantiationService, _modelService) {
+        super();
+        this.entry = entry;
+        this._instantiationService = _instantiationService;
+        this._modelService = _modelService;
+        this.collapsed = observableValue(this, false);
+        this.lastTemplateData = observableValue(this, { contentHeight: 500, selections: undefined, });
+        function updateOptions(options) {
+            return {
+                ...options,
+                hideUnchangedRegions: {
+                    enabled: true,
+                },
+            };
+        }
+        const options = ( new DiffEditorOptions(updateOptions(this.entry.value.options || {})));
+        if (this.entry.value.onOptionsDidChange) {
+            this._register(this.entry.value.onOptionsDidChange(() => {
+                options.updateOptions(updateOptions(this.entry.value.options || {}));
+            }));
+        }
+        const originalTextModel = this.entry.value.original ?? this._register(this._modelService.createModel('', null));
+        const modifiedTextModel = this.entry.value.modified ?? this._register(this._modelService.createModel('', null));
+        this.diffEditorViewModel = this._register(this._instantiationService.createInstance(DiffEditorViewModel, {
+            original: originalTextModel,
+            modified: modifiedTextModel,
+        }, options));
+    }
+    getKey() {
+        return JSON.stringify([
+            this.originalUri?.toString(),
+            this.modifiedUri?.toString()
+        ]);
+    }
+};
+DocumentDiffItemViewModel = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IModelService))
+], DocumentDiffItemViewModel));
+export { DocumentDiffItemViewModel, MultiDiffEditorViewModel };

package/vscode/src/vs/editor/browser/widget/multiDiffEditorWidget/multiDiffEditorWidget.js

@@ -0,0 +1,54 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { readHotReloadableExport } from '../diffEditor/utils.js';
+import { MultiDiffEditorWidgetImpl } from './multiDiffEditorWidgetImpl.js';
+import { MultiDiffEditorViewModel } from './multiDiffEditorViewModel.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import './colors.js';
+import { DiffEditorItemTemplate } from './diffEditorItemTemplate.js';
+import { Event } from '../../../../base/common/event.js';
+import { observableValue } from '../../../../base/common/observableInternal/base.js';
+import { derivedWithStore, derived } from '../../../../base/common/observableInternal/derived.js';
+import { recomputeInitiallyAndOnChange } from '../../../../base/common/observableInternal/utils.js';
+let MultiDiffEditorWidget = class MultiDiffEditorWidget extends Disposable {
+    constructor(_element, _workbenchUIElementFactory, _instantiationService) {
+        super();
+        this._element = _element;
+        this._workbenchUIElementFactory = _workbenchUIElementFactory;
+        this._instantiationService = _instantiationService;
+        this._dimension = observableValue(this, undefined);
+        this._viewModel = observableValue(this, undefined);
+        this._widgetImpl = derivedWithStore(this, (reader, store) => {
+            readHotReloadableExport(DiffEditorItemTemplate, reader);
+            return store.add(this._instantiationService.createInstance((readHotReloadableExport(MultiDiffEditorWidgetImpl, reader)), this._element, this._dimension, this._viewModel, this._workbenchUIElementFactory));
+        });
+        this._activeControl = derived(this, (reader) => this._widgetImpl.read(reader).activeControl.read(reader));
+        this.onDidChangeActiveControl = Event.fromObservableLight(this._activeControl);
+        this._register(recomputeInitiallyAndOnChange(this._widgetImpl));
+    }
+    createViewModel(model) {
+        return ( new MultiDiffEditorViewModel(model, this._instantiationService));
+    }
+    setViewModel(viewModel) {
+        this._viewModel.set(viewModel, undefined);
+    }
+    layout(dimension) {
+        this._dimension.set(dimension, undefined);
+    }
+    getActiveControl() {
+        return this._activeControl.get();
+    }
+    getViewState() {
+        return this._widgetImpl.get().getViewState();
+    }
+    setViewState(viewState) {
+        this._widgetImpl.get().setViewState(viewState);
+    }
+    tryGetCodeEditor(resource) {
+        return this._widgetImpl.get().tryGetCodeEditor(resource);
+    }
+};
+MultiDiffEditorWidget = ( __decorate([
+    ( __param(2, IInstantiationService))
+], MultiDiffEditorWidget));
+export { MultiDiffEditorWidget };