@codingame/monaco-vscode-notebook-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline.js

@@ -1,383 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IconLabel } from 'vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { createMatches } from 'vscode/vscode/vs/base/common/filters';
-import { DisposableStore, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { getIconClassesForLanguageId } from 'vscode/vscode/vs/editor/common/services/getIconClasses';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { Extensions as Extensions$1 } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { MarkerSeverity } from 'vscode/vscode/vs/platform/markers/common/markers';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { listErrorForeground, listWarningForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { NotebookEditor } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
-import { NotebookCellOutlineProvider } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineProvider';
-import { NotebookSetting, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { SIDE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { IOutlineService } from 'vscode/vscode/vs/workbench/services/outline/browser/outline';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { WindowIdleValue } from 'vscode/vscode/vs/base/browser/dom';
-
-var NotebookCellOutline_1;
-class NotebookOutlineTemplate {
-    static { this.templateId = 'NotebookOutlineRenderer'; }
-    constructor(container, iconClass, iconLabel, decoration) {
-        this.container = container;
-        this.iconClass = iconClass;
-        this.iconLabel = iconLabel;
-        this.decoration = decoration;
-    }
-}
-let NotebookOutlineRenderer = class NotebookOutlineRenderer {
-    constructor(_themeService, _configurationService) {
-        this._themeService = _themeService;
-        this._configurationService = _configurationService;
-        this.templateId = NotebookOutlineTemplate.templateId;
-    }
-    renderTemplate(container) {
-        container.classList.add('notebook-outline-element', 'show-file-icons');
-        const iconClass = document.createElement('div');
-        container.append(iconClass);
-        const iconLabel = ( new IconLabel(container, { supportHighlights: true }));
-        const decoration = document.createElement('div');
-        decoration.className = 'element-decoration';
-        container.append(decoration);
-        return ( new NotebookOutlineTemplate(container, iconClass, iconLabel, decoration));
-    }
-    renderElement(node, _index, template, _height) {
-        const extraClasses = [];
-        const options = {
-            matches: createMatches(node.filterData),
-            labelEscapeNewLines: true,
-            extraClasses,
-        };
-        if (node.element.cell.cellKind === CellKind.Code && this._themeService.getFileIconTheme().hasFileIcons && !node.element.isExecuting) {
-            template.iconClass.className = '';
-            extraClasses.push(...getIconClassesForLanguageId(node.element.cell.language ?? ''));
-        }
-        else {
-            template.iconClass.className = 'element-icon ' + ThemeIcon.asClassNameArray(node.element.icon).join(' ');
-        }
-        template.iconLabel.setLabel(node.element.label, undefined, options);
-        const { markerInfo } = node.element;
-        template.container.style.removeProperty('--outline-element-color');
-        template.decoration.innerText = '';
-        if (markerInfo) {
-            const problem = this._configurationService.getValue('problems.visibility');
-            const useBadges = this._configurationService.getValue("outline.problems.badges" );
-            if (!useBadges || !problem) {
-                template.decoration.classList.remove('bubble');
-                template.decoration.innerText = '';
-            }
-            else if (markerInfo.count === 0) {
-                template.decoration.classList.add('bubble');
-                template.decoration.innerText = '\uea71';
-            }
-            else {
-                template.decoration.classList.remove('bubble');
-                template.decoration.innerText = markerInfo.count > 9 ? '9+' : String(markerInfo.count);
-            }
-            const color = this._themeService.getColorTheme().getColor(markerInfo.topSev === MarkerSeverity.Error ? listErrorForeground : listWarningForeground);
-            if (problem === undefined) {
-                return;
-            }
-            const useColors = this._configurationService.getValue("outline.problems.colors" );
-            if (!useColors || !problem) {
-                template.container.style.removeProperty('--outline-element-color');
-                template.decoration.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
-            }
-            else {
-                template.container.style.setProperty('--outline-element-color', color?.toString() ?? 'inherit');
-            }
-        }
-    }
-    disposeTemplate(templateData) {
-        templateData.iconLabel.dispose();
-    }
-};
-NotebookOutlineRenderer = ( __decorate([
-    ( __param(0, IThemeService)),
-    ( __param(1, IConfigurationService))
-], NotebookOutlineRenderer));
-class NotebookOutlineAccessibility {
-    getAriaLabel(element) {
-        return element.label;
-    }
-    getWidgetAriaLabel() {
-        return '';
-    }
-}
-class NotebookNavigationLabelProvider {
-    getKeyboardNavigationLabel(element) {
-        return element.label;
-    }
-}
-class NotebookOutlineVirtualDelegate {
-    getHeight(_element) {
-        return 22;
-    }
-    getTemplateId(_element) {
-        return NotebookOutlineTemplate.templateId;
-    }
-}
-let NotebookQuickPickProvider = class NotebookQuickPickProvider {
-    constructor(_getEntries, _themeService) {
-        this._getEntries = _getEntries;
-        this._themeService = _themeService;
-    }
-    getQuickPickElements() {
-        const bucket = [];
-        for (const entry of this._getEntries()) {
-            entry.asFlatList(bucket);
-        }
-        const result = [];
-        const { hasFileIcons } = this._themeService.getFileIconTheme();
-        for (const element of bucket) {
-            const useFileIcon = hasFileIcons && !element.symbolKind;
-            result.push({
-                element,
-                label: useFileIcon ? element.label : `$(${element.icon.id}) ${element.label}`,
-                ariaLabel: element.label,
-                iconClasses: useFileIcon ? getIconClassesForLanguageId(element.cell.language ?? '') : undefined,
-            });
-        }
-        return result;
-    }
-};
-NotebookQuickPickProvider = ( __decorate([
-    ( __param(1, IThemeService))
-], NotebookQuickPickProvider));
-class NotebookComparator {
-    constructor() {
-        this._collator = ( new WindowIdleValue(mainWindow, () => new Intl.Collator(undefined, { numeric: true })));
-    }
-    compareByPosition(a, b) {
-        return a.index - b.index;
-    }
-    compareByType(a, b) {
-        return a.cell.cellKind - b.cell.cellKind || this._collator.value.compare(a.label, b.label);
-    }
-    compareByName(a, b) {
-        return this._collator.value.compare(a.label, b.label);
-    }
-}
-let NotebookCellOutline = NotebookCellOutline_1 = class NotebookCellOutline {
-    get entries() {
-        return this._outlineProvider?.entries ?? [];
-    }
-    get activeElement() {
-        return this._outlineProvider?.activeElement;
-    }
-    constructor(_editor, _target, instantiationService, _editorService, _configurationService) {
-        this._editor = _editor;
-        this._editorService = _editorService;
-        this._dispoables = ( new DisposableStore());
-        this._onDidChange = ( new Emitter());
-        this.onDidChange = this._onDidChange.event;
-        this._entriesDisposables = ( new DisposableStore());
-        this.outlineKind = 'notebookCells';
-        this._localDisposables = ( new DisposableStore());
-        const installSelectionListener = () => {
-            const notebookEditor = _editor.getControl();
-            if (!notebookEditor?.hasModel()) {
-                this._outlineProvider?.dispose();
-                this._outlineProvider = undefined;
-                this._localDisposables.clear();
-            }
-            else {
-                this._outlineProvider?.dispose();
-                this._localDisposables.clear();
-                this._outlineProvider = instantiationService.createInstance(NotebookCellOutlineProvider, notebookEditor, _target);
-                this._localDisposables.add(this._outlineProvider.onDidChange(e => {
-                    this._onDidChange.fire(e);
-                }));
-            }
-        };
-        this._dispoables.add(_editor.onDidChangeModel(() => {
-            installSelectionListener();
-        }));
-        installSelectionListener();
-        const treeDataSource = { getChildren: parent => parent instanceof NotebookCellOutline_1 ? (this._outlineProvider?.entries ?? []) : parent.children };
-        const delegate = ( new NotebookOutlineVirtualDelegate());
-        const renderers = [instantiationService.createInstance(NotebookOutlineRenderer)];
-        const comparator = ( new NotebookComparator());
-        const options = {
-            collapseByDefault: _target === 2  || ((_target === 1  && _configurationService.getValue("outline.collapseItems" ) === "alwaysCollapse") ),
-            expandOnlyOnTwistieClick: true,
-            multipleSelectionSupport: false,
-            accessibilityProvider: ( new NotebookOutlineAccessibility()),
-            identityProvider: { getId: element => ( element.cell.uri.toString()) },
-            keyboardNavigationLabelProvider: ( new NotebookNavigationLabelProvider())
-        };
-        this.config = {
-            breadcrumbsDataSource: {
-                getBreadcrumbElements: () => {
-                    const result = [];
-                    let candidate = this.activeElement;
-                    while (candidate) {
-                        result.unshift(candidate);
-                        candidate = candidate.parent;
-                    }
-                    return result;
-                }
-            },
-            quickPickDataSource: instantiationService.createInstance(NotebookQuickPickProvider, () => (this._outlineProvider?.entries ?? [])),
-            treeDataSource,
-            delegate,
-            renderers,
-            comparator,
-            options
-        };
-    }
-    async setFullSymbols(cancelToken) {
-        await this._outlineProvider?.setFullSymbols(cancelToken);
-    }
-    get uri() {
-        return this._outlineProvider?.uri;
-    }
-    get isEmpty() {
-        return this._outlineProvider?.isEmpty ?? true;
-    }
-    async reveal(entry, options, sideBySide) {
-        await this._editorService.openEditor({
-            resource: entry.cell.uri,
-            options: {
-                ...options,
-                override: this._editor.input?.editorId,
-                cellRevealType: 5 ,
-                selection: entry.position
-            },
-        }, sideBySide ? SIDE_GROUP : undefined);
-    }
-    preview(entry) {
-        const widget = this._editor.getControl();
-        if (!widget) {
-            return Disposable.None;
-        }
-        if (entry.range) {
-            const range = Range.lift(entry.range);
-            widget.revealRangeInCenterIfOutsideViewportAsync(entry.cell, range);
-        }
-        else {
-            widget.revealInCenterIfOutsideViewport(entry.cell);
-        }
-        const ids = widget.deltaCellDecorations([], [{
-                handle: entry.cell.handle,
-                options: { className: 'nb-symbolHighlight', outputClassName: 'nb-symbolHighlight' }
-            }]);
-        let editorDecorations;
-        widget.changeModelDecorations(accessor => {
-            if (entry.range) {
-                const decorations = [
-                    {
-                        range: entry.range, options: {
-                            description: 'document-symbols-outline-range-highlight',
-                            className: 'rangeHighlight',
-                            isWholeLine: true
-                        }
-                    }
-                ];
-                const deltaDecoration = {
-                    ownerId: entry.cell.handle,
-                    decorations: decorations
-                };
-                editorDecorations = accessor.deltaDecorations([], [deltaDecoration]);
-            }
-        });
-        return toDisposable(() => {
-            widget.deltaCellDecorations(ids, []);
-            if (editorDecorations?.length) {
-                widget.changeModelDecorations(accessor => {
-                    accessor.deltaDecorations(editorDecorations, []);
-                });
-            }
-        });
-    }
-    captureViewState() {
-        const widget = this._editor.getControl();
-        const viewState = widget?.getEditorViewState();
-        return toDisposable(() => {
-            if (viewState) {
-                widget?.restoreListViewState(viewState);
-            }
-        });
-    }
-    dispose() {
-        this._onDidChange.dispose();
-        this._dispoables.dispose();
-        this._entriesDisposables.dispose();
-        this._outlineProvider?.dispose();
-        this._localDisposables.dispose();
-    }
-};
-NotebookCellOutline = NotebookCellOutline_1 = ( __decorate([
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IConfigurationService))
-], NotebookCellOutline));
-let NotebookOutlineCreator = class NotebookOutlineCreator {
-    constructor(outlineService, _instantiationService, _configurationService) {
-        this._instantiationService = _instantiationService;
-        this._configurationService = _configurationService;
-        const reg = outlineService.registerOutlineCreator(this);
-        this.dispose = () => reg.dispose();
-    }
-    matches(candidate) {
-        return candidate.getId() === NotebookEditor.ID;
-    }
-    async createOutline(editor, target, cancelToken) {
-        const outline = this._instantiationService.createInstance(NotebookCellOutline, editor, target);
-        const showAllSymbols = this._configurationService.getValue(NotebookSetting.gotoSymbolsAllSymbols);
-        if (target === 4  && showAllSymbols) {
-            await outline.setFullSymbols(cancelToken);
-        }
-        return outline;
-    }
-};
-NotebookOutlineCreator = ( __decorate([
-    ( __param(0, IOutlineService)),
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IConfigurationService))
-], NotebookOutlineCreator));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookOutlineCreator, 4 );
-( Registry.as(Extensions$1.Configuration)).registerConfiguration({
-    id: 'notebook',
-    order: 100,
-    type: 'object',
-    'properties': {
-        'notebook.outline.showCodeCells': {
-            type: 'boolean',
-            default: false,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'outline.showCodeCells',
-                "When enabled notebook outline shows code cells."
-            ))
-        },
-        'notebook.breadcrumbs.showCodeCells': {
-            type: 'boolean',
-            default: true,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'breadcrumbs.showCodeCells',
-                "When enabled notebook breadcrumbs contain code cells."
-            ))
-        },
-        [NotebookSetting.gotoSymbolsAllSymbols]: {
-            type: 'boolean',
-            default: true,
-            markdownDescription: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/outline/notebookOutline',
-                'notebook.gotoSymbols.showAllSymbols',
-                "When enabled the Go to Symbol Quick Pick will display full code symbols from the notebook, as well as Markdown headers."
-            ))
-        },
-    }
-});
-
-export { NotebookCellOutline, NotebookOutlineCreator };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile.js

@@ -1,77 +0,0 @@
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-
-var NotebookProfileType;
-( (function(NotebookProfileType) {
-    NotebookProfileType["default"] = "default";
-    NotebookProfileType["jupyter"] = "jupyter";
-    NotebookProfileType["colab"] = "colab";
-})(NotebookProfileType || (NotebookProfileType = {})));
-const profiles = {
-    [NotebookProfileType.default]: {
-        [NotebookSetting.focusIndicator]: 'gutter',
-        [NotebookSetting.insertToolbarLocation]: 'both',
-        [NotebookSetting.globalToolbar]: true,
-        [NotebookSetting.cellToolbarLocation]: { default: 'right' },
-        [NotebookSetting.compactView]: true,
-        [NotebookSetting.showCellStatusBar]: 'visible',
-        [NotebookSetting.consolidatedRunButton]: true,
-        [NotebookSetting.undoRedoPerCell]: false
-    },
-    [NotebookProfileType.jupyter]: {
-        [NotebookSetting.focusIndicator]: 'gutter',
-        [NotebookSetting.insertToolbarLocation]: 'notebookToolbar',
-        [NotebookSetting.globalToolbar]: true,
-        [NotebookSetting.cellToolbarLocation]: { default: 'left' },
-        [NotebookSetting.compactView]: true,
-        [NotebookSetting.showCellStatusBar]: 'visible',
-        [NotebookSetting.consolidatedRunButton]: false,
-        [NotebookSetting.undoRedoPerCell]: true
-    },
-    [NotebookProfileType.colab]: {
-        [NotebookSetting.focusIndicator]: 'border',
-        [NotebookSetting.insertToolbarLocation]: 'betweenCells',
-        [NotebookSetting.globalToolbar]: false,
-        [NotebookSetting.cellToolbarLocation]: { default: 'right' },
-        [NotebookSetting.compactView]: false,
-        [NotebookSetting.showCellStatusBar]: 'hidden',
-        [NotebookSetting.consolidatedRunButton]: true,
-        [NotebookSetting.undoRedoPerCell]: false
-    }
-};
-async function applyProfile(configService, profile) {
-    const promises = [];
-    for (const settingKey in profile) {
-        promises.push(configService.updateValue(settingKey, profile[settingKey]));
-    }
-    await Promise.all(promises);
-}
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'notebook.setProfile',
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile',
-                'setProfileTitle',
-                "Set Profile"
-            ))
-        });
-    }
-    async run(accessor, args) {
-        if (!isSetProfileArgs(args)) {
-            return;
-        }
-        const configService = accessor.get(IConfigurationService);
-        return applyProfile(configService, profiles[args.profile]);
-    }
-});
-function isSetProfileArgs(args) {
-    const setProfileArgs = args;
-    return setProfileArgs.profile === NotebookProfileType.colab ||
-        setProfileArgs.profile === NotebookProfileType.default ||
-        setProfileArgs.profile === NotebookProfileType.jupyter;
-}
-
-export { NotebookProfileType };