@codingame/monaco-vscode-notebook-service-override 1.85.1

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

@@ -0,0 +1,383 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IconLabel } from 'monaco-editor/esm/vs/base/browser/ui/iconLabel/iconLabel.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
+import { DisposableStore, Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+import { getIconClassesForLanguageId } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MarkerSeverity } from 'monaco-editor/esm/vs/platform/markers/common/markers.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { listErrorForeground, listWarningForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+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 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { mainWindow } from 'monaco-editor/esm/vs/base/browser/window.js';
+import { WindowIdleValue } from 'monaco-editor/esm/vs/base/browser/dom.js';
+
+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: false,
+            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

@@ -0,0 +1,117 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { NotebookSetting } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { IWorkbenchAssignmentService } from 'vscode/vscode/vs/workbench/services/assignment/common/assignmentService';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+
+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;
+}
+let NotebookProfileContribution = class NotebookProfileContribution extends Disposable {
+    constructor(configService, experimentService) {
+        super();
+        this.experimentService = experimentService;
+        if (this.experimentService) {
+            this.experimentService.getTreatment('notebookprofile').then(treatment => {
+                if (treatment === undefined) {
+                    return;
+                }
+                else {
+                    const focusIndicator = configService.getValue(NotebookSetting.focusIndicator);
+                    const insertToolbarPosition = configService.getValue(NotebookSetting.insertToolbarLocation);
+                    const globalToolbar = configService.getValue(NotebookSetting.globalToolbar);
+                    const compactView = configService.getValue(NotebookSetting.compactView);
+                    const showCellStatusBar = configService.getValue(NotebookSetting.showCellStatusBar);
+                    const consolidatedRunButton = configService.getValue(NotebookSetting.consolidatedRunButton);
+                    if (focusIndicator === 'border'
+                        && insertToolbarPosition === 'both'
+                        && globalToolbar === false
+                        && compactView === true
+                        && showCellStatusBar === 'visible'
+                        && consolidatedRunButton === true) {
+                        applyProfile(configService, profiles[treatment] ?? profiles[NotebookProfileType.default]);
+                    }
+                }
+            });
+        }
+    }
+};
+NotebookProfileContribution = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IWorkbenchAssignmentService))
+], NotebookProfileContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(NotebookProfileContribution, 2 );
+
+export { NotebookProfileContribution, NotebookProfileType };