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

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

@@ -0,0 +1,324 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { h, scheduleAtNextAnimationFrame, getWindow } from '../../../../base/browser/dom.js';
+import { SmoothScrollableElement } from '../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { findFirstMaxBy } from '../../../../base/common/arraysFind.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { transaction, globalTransaction, disposableObservableValue, observableValue } from '../../../../base/common/observableInternal/base.js';
+import { Scrollable } from '../../../../base/common/scrollable.js';
+import './style.css.js';
+import { ObservableElementSizeObserver } from '../diffEditor/utils.js';
+import { OffsetRange } from '../../../common/core/offsetRange.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { DiffEditorItemTemplate, TemplateData } from './diffEditorItemTemplate.js';
+import { ObjectPool } from './objectPool.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { Selection } from '../../../common/core/selection.js';
+import { observableFromEvent, derivedObservableWithCache } from '../../../../base/common/observableInternal/utils.js';
+import { derivedWithStore, derived } from '../../../../base/common/observableInternal/derived.js';
+import { autorunWithStore, autorun } from '../../../../base/common/observableInternal/autorun.js';
+let MultiDiffEditorWidgetImpl = class MultiDiffEditorWidgetImpl extends Disposable {
+    constructor(_element, _dimension, _viewModel, _workbenchUIElementFactory, _parentContextKeyService, _parentInstantiationService) {
+        super();
+        this._element = _element;
+        this._dimension = _dimension;
+        this._viewModel = _viewModel;
+        this._workbenchUIElementFactory = _workbenchUIElementFactory;
+        this._parentContextKeyService = _parentContextKeyService;
+        this._parentInstantiationService = _parentInstantiationService;
+        this._elements = h('div.monaco-component.multiDiffEditor', [
+            h('div@content', {
+                style: {
+                    overflow: 'hidden',
+                }
+            }),
+            h('div.monaco-editor@overflowWidgetsDomNode', {}),
+        ]);
+        this._sizeObserver = this._register(( new ObservableElementSizeObserver(this._element, undefined)));
+        this._objectPool = this._register(( new ObjectPool((data) => {
+            const template = this._instantiationService.createInstance(DiffEditorItemTemplate, this._elements.content, this._elements.overflowWidgetsDomNode, this._workbenchUIElementFactory);
+            template.setData(data);
+            return template;
+        })));
+        this._scrollable = this._register(( new Scrollable({
+            forceIntegerValues: false,
+            scheduleAtNextAnimationFrame: (cb) => scheduleAtNextAnimationFrame(getWindow(this._element), cb),
+            smoothScrollDuration: 100,
+        })));
+        this._scrollableElement = this._register(( new SmoothScrollableElement(this._elements.root, {
+            vertical: 1 ,
+            horizontal: 1 ,
+            useShadows: false,
+        }, this._scrollable)));
+        this.scrollTop = observableFromEvent(this._scrollableElement.onScroll, () =>  this._scrollableElement.getScrollPosition().scrollTop);
+        this.scrollLeft = observableFromEvent(this._scrollableElement.onScroll, () =>  this._scrollableElement.getScrollPosition().scrollLeft);
+        this._viewItems = derivedWithStore(this, (reader, store) => {
+            const vm = this._viewModel.read(reader);
+            if (!vm) {
+                return [];
+            }
+            const items = vm.items.read(reader);
+            return ( items.map(d => {
+                const item = store.add(( new VirtualizedViewItem(d, this._objectPool, this.scrollLeft)));
+                const data = this._lastDocStates?.[item.getKey()];
+                if (data) {
+                    transaction(tx => {
+                        item.setViewState(data, tx);
+                    });
+                }
+                return item;
+            }));
+        });
+        this._spaceBetweenPx = 10;
+        this._totalHeight = ( this._viewItems.map(
+            this,
+            (items, reader) => items.reduce((r, i) => r + i.contentHeight.read(reader) + this._spaceBetweenPx, 0)
+        ));
+        this.activeDiffItem = derived(this, reader => this._viewItems.read(reader).find(i => i.template.read(reader)?.isFocused.read(reader)));
+        this.lastActiveDiffItem = derivedObservableWithCache((reader, lastValue) => this.activeDiffItem.read(reader) ?? lastValue);
+        this.activeControl = derived(this, reader => this.lastActiveDiffItem.read(reader)?.template.read(reader)?.editor);
+        this._contextKeyService = this._register(this._parentContextKeyService.createScoped(this._element));
+        this._instantiationService = this._parentInstantiationService.createChild(( new ServiceCollection([IContextKeyService, this._contextKeyService])));
+        this._lastDocStates = {};
+        this._contextKeyService.createKey(EditorContextKeys.inMultiDiffEditor.key, true);
+        this._register(autorunWithStore((reader, store) => {
+            const viewModel = this._viewModel.read(reader);
+            if (viewModel && viewModel.contextKeys) {
+                for (const [key, value] of Object.entries(viewModel.contextKeys)) {
+                    const contextKey = this._contextKeyService.createKey(key, undefined);
+                    contextKey.set(value);
+                    store.add(toDisposable(() => contextKey.reset()));
+                }
+            }
+        }));
+        const ctxAllCollapsed = this._parentContextKeyService.createKey(EditorContextKeys.multiDiffEditorAllCollapsed.key, false);
+        this._register(autorun((reader) => {
+            const viewModel = this._viewModel.read(reader);
+            if (viewModel) {
+                const allCollapsed = viewModel.items.read(reader).every(item => item.collapsed.read(reader));
+                ctxAllCollapsed.set(allCollapsed);
+            }
+        }));
+        this._register(autorun((reader) => {
+            const lastActiveDiffItem = this.lastActiveDiffItem.read(reader);
+            transaction(tx => {
+                this._viewModel.read(reader)?.activeDiffItem.set(lastActiveDiffItem?.viewModel, tx);
+            });
+        }));
+        this._register(autorun((reader) => {
+            const dimension = this._dimension.read(reader);
+            this._sizeObserver.observe(dimension);
+        }));
+        this._elements.content.style.position = 'relative';
+        this._register(autorun((reader) => {
+            const height = this._sizeObserver.height.read(reader);
+            this._elements.root.style.height = `${height}px`;
+            const totalHeight = this._totalHeight.read(reader);
+            this._elements.content.style.height = `${totalHeight}px`;
+            const width = this._sizeObserver.width.read(reader);
+            let scrollWidth = width;
+            const viewItems = this._viewItems.read(reader);
+            const max = findFirstMaxBy(viewItems, i => i.maxScroll.read(reader).maxScroll);
+            if (max) {
+                const maxScroll = max.maxScroll.read(reader);
+                scrollWidth = width + maxScroll.maxScroll;
+            }
+            this._scrollableElement.setScrollDimensions({
+                width: width,
+                height: height,
+                scrollHeight: totalHeight,
+                scrollWidth,
+            });
+        }));
+        _element.replaceChildren(this._scrollableElement.getDomNode());
+        this._register(toDisposable(() => {
+            _element.replaceChildren();
+        }));
+        this._register(this._register(autorun(reader => {
+            globalTransaction(tx => {
+                this.render(reader);
+            });
+        })));
+    }
+    setScrollState(scrollState) {
+        this._scrollableElement.setScrollPosition({ scrollLeft: scrollState.left, scrollTop: scrollState.top });
+    }
+    getViewState() {
+        return {
+            scrollState: {
+                top: this.scrollTop.get(),
+                left: this.scrollLeft.get(),
+            },
+            docStates: Object.fromEntries(( this._viewItems.get().map(i => [i.getKey(), i.getViewState()]))),
+        };
+    }
+    setViewState(viewState) {
+        this.setScrollState(viewState.scrollState);
+        this._lastDocStates = viewState.docStates;
+        transaction(tx => {
+            if (viewState.docStates) {
+                for (const i of this._viewItems.get()) {
+                    const state = viewState.docStates[i.getKey()];
+                    if (state) {
+                        i.setViewState(state, tx);
+                    }
+                }
+            }
+        });
+    }
+    tryGetCodeEditor(resource) {
+        const item = this._viewItems.get().find(v => ( v.viewModel.diffEditorViewModel.model.modified.uri.toString()) === ( resource.toString())
+            || ( v.viewModel.diffEditorViewModel.model.original.uri.toString()) === ( resource.toString()));
+        const editor = item?.template.get()?.editor;
+        if (!editor) {
+            return undefined;
+        }
+        if (( item.viewModel.diffEditorViewModel.model.modified.uri.toString()) === ( resource.toString())) {
+            return { diffEditor: editor, editor: editor.getModifiedEditor() };
+        }
+        else {
+            return { diffEditor: editor, editor: editor.getOriginalEditor() };
+        }
+    }
+    render(reader) {
+        const scrollTop = this.scrollTop.read(reader);
+        let contentScrollOffsetToScrollOffset = 0;
+        let itemHeightSumBefore = 0;
+        let itemContentHeightSumBefore = 0;
+        const viewPortHeight = this._sizeObserver.height.read(reader);
+        const contentViewPort = OffsetRange.ofStartAndLength(scrollTop, viewPortHeight);
+        const width = this._sizeObserver.width.read(reader);
+        for (const v of this._viewItems.read(reader)) {
+            const itemContentHeight = v.contentHeight.read(reader);
+            const itemHeight = Math.min(itemContentHeight, viewPortHeight);
+            const itemRange = OffsetRange.ofStartAndLength(itemHeightSumBefore, itemHeight);
+            const itemContentRange = OffsetRange.ofStartAndLength(itemContentHeightSumBefore, itemContentHeight);
+            if (itemContentRange.isBefore(contentViewPort)) {
+                contentScrollOffsetToScrollOffset -= itemContentHeight - itemHeight;
+                v.hide();
+            }
+            else if (itemContentRange.isAfter(contentViewPort)) {
+                v.hide();
+            }
+            else {
+                const scroll = Math.max(0, Math.min(contentViewPort.start - itemContentRange.start, itemContentHeight - itemHeight));
+                contentScrollOffsetToScrollOffset -= scroll;
+                const viewPort = OffsetRange.ofStartAndLength(scrollTop + contentScrollOffsetToScrollOffset, viewPortHeight);
+                v.render(itemRange, scroll, width, viewPort);
+            }
+            itemHeightSumBefore += itemHeight + this._spaceBetweenPx;
+            itemContentHeightSumBefore += itemContentHeight + this._spaceBetweenPx;
+        }
+        this._elements.content.style.transform = `translateY(${-(scrollTop + contentScrollOffsetToScrollOffset)}px)`;
+    }
+};
+MultiDiffEditorWidgetImpl = ( __decorate([
+    ( __param(4, IContextKeyService)),
+    ( __param(5, IInstantiationService))
+], MultiDiffEditorWidgetImpl));
+class VirtualizedViewItem extends Disposable {
+    constructor(viewModel, _objectPool, _scrollLeft) {
+        super();
+        this.viewModel = viewModel;
+        this._objectPool = _objectPool;
+        this._scrollLeft = _scrollLeft;
+        this._templateRef = this._register(disposableObservableValue(this, undefined));
+        this.contentHeight = derived(this, reader => this._templateRef.read(reader)?.object.contentHeight?.read(reader) ?? this.viewModel.lastTemplateData.read(reader).contentHeight);
+        this.maxScroll = derived(this, reader => this._templateRef.read(reader)?.object.maxScroll.read(reader) ?? { maxScroll: 0, scrollWidth: 0 });
+        this.template = derived(this, reader => this._templateRef.read(reader)?.object);
+        this._isHidden = observableValue(this, false);
+        this._register(autorun((reader) => {
+            const scrollLeft = this._scrollLeft.read(reader);
+            this._templateRef.read(reader)?.object.setScrollLeft(scrollLeft);
+        }));
+        this._register(autorun(reader => {
+            const ref = this._templateRef.read(reader);
+            if (!ref) {
+                return;
+            }
+            const isHidden = this._isHidden.read(reader);
+            if (!isHidden) {
+                return;
+            }
+            const isFocused = ref.object.isFocused.read(reader);
+            if (isFocused) {
+                return;
+            }
+            this._clear();
+        }));
+    }
+    dispose() {
+        this._clear();
+        super.dispose();
+    }
+    toString() {
+        return `VirtualViewItem(${this.viewModel.entry.value.modified?.uri.toString()})`;
+    }
+    getKey() {
+        return this.viewModel.getKey();
+    }
+    getViewState() {
+        transaction(tx => {
+            this._updateTemplateData(tx);
+        });
+        return {
+            collapsed: this.viewModel.collapsed.get(),
+            selections: this.viewModel.lastTemplateData.get().selections,
+        };
+    }
+    setViewState(viewState, tx) {
+        this.viewModel.collapsed.set(viewState.collapsed, tx);
+        this._updateTemplateData(tx);
+        const data = this.viewModel.lastTemplateData.get();
+        const selections = viewState.selections?.map(Selection.liftSelection);
+        this.viewModel.lastTemplateData.set({
+            ...data,
+            selections,
+        }, tx);
+        const ref = this._templateRef.get();
+        if (ref) {
+            if (selections) {
+                ref.object.editor.setSelections(selections);
+            }
+        }
+    }
+    _updateTemplateData(tx) {
+        const ref = this._templateRef.get();
+        if (!ref) {
+            return;
+        }
+        this.viewModel.lastTemplateData.set({
+            contentHeight: ref.object.contentHeight.get(),
+            selections: ref.object.editor.getSelections() ?? undefined,
+        }, tx);
+    }
+    _clear() {
+        const ref = this._templateRef.get();
+        if (!ref) {
+            return;
+        }
+        transaction(tx => {
+            this._updateTemplateData(tx);
+            ref.object.hide();
+            this._templateRef.set(undefined, tx);
+        });
+    }
+    hide() {
+        this._isHidden.set(true, undefined);
+    }
+    render(verticalSpace, offset, width, viewPort) {
+        this._isHidden.set(false, undefined);
+        let ref = this._templateRef.get();
+        if (!ref) {
+            ref = this._objectPool.getUnusedObj(( new TemplateData(this.viewModel)));
+            this._templateRef.set(ref, undefined);
+            const selections = this.viewModel.lastTemplateData.get().selections;
+            if (selections) {
+                ref.object.editor.setSelections(selections);
+            }
+        }
+        ref.object.render(verticalSpace, width, offset, viewPort);
+    }
+}
+export { MultiDiffEditorWidgetImpl };

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

@@ -0,0 +1,46 @@
+class ObjectPool {
+    constructor(_create) {
+        this._create = _create;
+        this._unused = ( new Set());
+        this._used = ( new Set());
+        this._itemData = ( new Map());
+    }
+    getUnusedObj(data) {
+        let obj;
+        if (this._unused.size === 0) {
+            obj = this._create(data);
+            this._itemData.set(obj, data);
+        }
+        else {
+            const values = [...( this._unused.values())];
+            obj = values.find(obj => this._itemData.get(obj).getId() === data.getId()) ?? values[0];
+            this._unused.delete(obj);
+            this._itemData.set(obj, data);
+            obj.setData(data);
+        }
+        this._used.add(obj);
+        return {
+            object: obj,
+            dispose: () => {
+                this._used.delete(obj);
+                if (this._unused.size > 5) {
+                    obj.dispose();
+                }
+                else {
+                    this._unused.add(obj);
+                }
+            }
+        };
+    }
+    dispose() {
+        for (const obj of this._used) {
+            obj.dispose();
+        }
+        for (const obj of this._unused) {
+            obj.dispose();
+        }
+        this._used.clear();
+        this._unused.clear();
+    }
+}
+export { ObjectPool };

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

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-component.multiDiffEditor{background:var(--vscode-multiDiffEditor-background);overflow-y:hidden}.monaco-component .multiDiffEntry{border-bottom:1px solid var(--vscode-multiDiffEditor-border);display:flex;flex:1;flex-direction:column;overflow:hidden}.monaco-component .multiDiffEntry .collapse-button{cursor:pointer;margin:0 5px}.monaco-component .multiDiffEntry .collapse-button a{display:block}.monaco-component .multiDiffEntry .header{align-items:center;background:var(--vscode-editor-background);border-bottom:1px solid var(--vscode-sideBarSectionHeader-border);border-top:1px solid var(--vscode-multiDiffEditor-border);color:var(--vscode-foreground);display:flex;padding:8px 5px;z-index:1000}.monaco-component .multiDiffEntry .header.shadow{box-shadow:var(--vscode-scrollbar-shadow) 0 6px 6px -6px}.monaco-component .multiDiffEntry .header .file-path{display:flex;flex:1;min-width:0}.monaco-component .multiDiffEntry .header .file-path .title{font-size:14px;line-height:22px}.monaco-component .multiDiffEntry .header .file-path .status{font-weight:600;line-height:22px;margin:0 10px;opacity:.75}.monaco-component .multiDiffEntry .header .file-path .title.original{flex:1;min-width:0;text-overflow:ellipsis}.monaco-component .multiDiffEntry .header .actions{padding:0 8px}.monaco-component .multiDiffEntry .editorParent{display:flex;flex:1;flex-direction:column}.monaco-component .multiDiffEntry .editorContainer{flex:1}";
+n(css,{});
+export { css, css as default };

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

@@ -0,0 +1,11 @@
+import { ActionRunner } from '../../../../base/common/actions.js';
+class ActionRunnerWithContext extends ActionRunner {
+    constructor(_getContext) {
+        super();
+        this._getContext = _getContext;
+    }
+    runAction(action, _context) {
+        return super.runAction(action, this._getContext());
+    }
+}
+export { ActionRunnerWithContext };

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

@@ -1,5 +1,65 @@
 import { createDecorator } from '../../instantiation/common/instantiation.js';
 const IKeyboardLayoutService = ( createDecorator('keyboardLayoutService'));
+function areKeyboardLayoutsEqual(a, b) {
+    if (!a || !b) {
+        return false;
+    }
+    if (a.name && b.name && a.name === b.name) {
+        return true;
+    }
+    if (a.id && b.id && a.id === b.id) {
+        return true;
+    }
+    if (a.model &&
+        b.model &&
+        a.model === b.model &&
+        a.layout === b.layout) {
+        return true;
+    }
+    return false;
+}
+function parseKeyboardLayoutDescription(layout) {
+    if (!layout) {
+        return { label: '', description: '' };
+    }
+    if (layout.name) {
+        const windowsLayout = layout;
+        return {
+            label: windowsLayout.text,
+            description: ''
+        };
+    }
+    if (layout.id) {
+        const macLayout = layout;
+        if (macLayout.localizedName) {
+            return {
+                label: macLayout.localizedName,
+                description: ''
+            };
+        }
+        if (/^com\.apple\.keylayout\./.test(macLayout.id)) {
+            return {
+                label: macLayout.id.replace(/^com\.apple\.keylayout\./, '').replace(/-/, ' '),
+                description: ''
+            };
+        }
+        if (/^.*inputmethod\./.test(macLayout.id)) {
+            return {
+                label: macLayout.id.replace(/^.*inputmethod\./, '').replace(/[-\.]/, ' '),
+                description: `Input Method (${macLayout.lang})`
+            };
+        }
+        return {
+            label: macLayout.lang,
+            description: ''
+        };
+    }
+    const linuxLayout = layout;
+    return {
+        label: linuxLayout.layout,
+        description: ''
+    };
+}
 function getKeyboardLayoutId(layout) {
     if (layout.name) {
         return layout.name;
@@ -9,4 +69,4 @@ function getKeyboardLayoutId(layout) {
     }
     return layout.layout;
 }
-export { IKeyboardLayoutService, getKeyboardLayoutId };
+export { IKeyboardLayoutService, areKeyboardLayoutsEqual, getKeyboardLayoutId, parseKeyboardLayoutDescription };

package/vscode/src/vs/platform/languagePacks/common/localizedStrings.js

@@ -0,0 +1,10 @@
+import { localizeWithPath } from '../../../nls.js';
+const open = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'open', 'open'));
+const close = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'close', 'close'));
+const find = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'find', 'find'));
+var localizedStrings = {
+    open: open,
+    close: close,
+    find: find
+};
+export { localizedStrings as default };

package/vscode/src/vs/platform/log/browser/log.js

@@ -0,0 +1,24 @@
+import { relativePath } from '../../../base/common/resources.js';
+async function getLogs(fileService, environmentService) {
+    const result = [];
+    await doGetLogs(fileService, result, environmentService.logsHome, environmentService.logsHome);
+    return result;
+}
+async function doGetLogs(fileService, logs, curFolder, logsHome) {
+    const stat = await fileService.resolve(curFolder);
+    for (const { resource, isDirectory } of stat.children || []) {
+        if (isDirectory) {
+            await doGetLogs(fileService, logs, resource, logsHome);
+        }
+        else {
+            const contents = ( (await fileService.readFile(resource)).value.toString());
+            if (contents) {
+                const path = relativePath(logsHome, resource);
+                if (path) {
+                    logs.push({ relativePath: path, contents });
+                }
+            }
+        }
+    }
+}
+export { getLogs };

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

@@ -44,5 +44,4 @@ else {
         });
     }
 }
-var product$1 = product;
-export { product$1 as default };
+export { product as default };