@codingame/monaco-vscode-api 32.0.2 → 33.0.3

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditorBrowser.d.ts

@@ -0,0 +1,180 @@
+import { CellLayoutState, ICellOutputViewModel, ICommonCellInfo, IGenericCellViewModel, IInsetRenderOutput, INotebookEditor } from "../notebookBrowser.js";
+import { DiffElementCellViewModelBase, IDiffElementViewModelBase } from "./diffElementViewModel.js";
+import { Event } from "../../../../../base/common/event.js";
+import { BareFontInfo } from "../../../../../editor/common/config/fontInfo.js";
+import { DisposableStore, IDisposable } from "../../../../../base/common/lifecycle.js";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { CodeEditorWidget } from "../../../../../editor/browser/widget/codeEditor/codeEditorWidget.js";
+import { IMouseWheelEvent } from "../../../../../base/browser/mouseEvent.js";
+import { RawContextKey } from "../../../../../platform/contextkey/common/contextkey.js";
+import { NotebookOptions } from "../notebookOptions.js";
+import { NotebookLayoutInfo } from "../notebookViewEvents.js";
+import { WorkbenchToolBar } from "../../../../../platform/actions/browser/toolbar.js";
+import { DiffEditorWidget } from "../../../../../editor/browser/widget/diffEditor/diffEditorWidget.js";
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { IObservable } from "../../../../../base/common/observable.js";
+export declare enum DiffSide {
+    Original = 0,
+    Modified = 1
+}
+export interface IDiffCellInfo extends ICommonCellInfo {
+    diffElement: DiffElementCellViewModelBase;
+}
+export interface INotebookTextDiffEditor {
+    notebookOptions: NotebookOptions;
+    readonly textModel?: NotebookTextModel;
+    inlineNotebookEditor: INotebookEditor | undefined;
+    readonly currentChangedIndex: IObservable<number>;
+    readonly onMouseUp: Event<{
+        readonly event: MouseEvent;
+        readonly target: IDiffElementViewModelBase;
+    }>;
+    readonly onDidScroll: Event<void>;
+    readonly onDidDynamicOutputRendered: Event<{
+        cell: IGenericCellViewModel;
+        output: ICellOutputViewModel;
+    }>;
+    getOverflowContainerDomNode(): HTMLElement;
+    getLayoutInfo(): NotebookLayoutInfo;
+    getScrollTop(): number;
+    getScrollHeight(): number;
+    layoutNotebookCell(cell: IDiffElementViewModelBase, height: number): void;
+    createOutput(cellDiffViewModel: DiffElementCellViewModelBase, cellViewModel: IDiffNestedCellViewModel, output: IInsetRenderOutput, getOffset: () => number, diffSide: DiffSide): void;
+    showInset(cellDiffViewModel: DiffElementCellViewModelBase, cellViewModel: IDiffNestedCellViewModel, displayOutput: ICellOutputViewModel, diffSide: DiffSide): void;
+    removeInset(cellDiffViewModel: DiffElementCellViewModelBase, cellViewModel: IDiffNestedCellViewModel, output: ICellOutputViewModel, diffSide: DiffSide): void;
+    hideInset(cellDiffViewModel: DiffElementCellViewModelBase, cellViewModel: IDiffNestedCellViewModel, output: ICellOutputViewModel): void;
+    /**
+     * Trigger the editor to scroll from scroll event programmatically
+     */
+    triggerScroll(event: IMouseWheelEvent): void;
+    delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void;
+    getCellByInfo(cellInfo: ICommonCellInfo): IGenericCellViewModel;
+    focusNotebookCell(cell: IGenericCellViewModel, focus: "editor" | "container" | "output"): Promise<void>;
+    focusNextNotebookCell(cell: IGenericCellViewModel, focus: "editor" | "container" | "output"): Promise<void>;
+    updateOutputHeight(cellInfo: ICommonCellInfo, output: ICellOutputViewModel, height: number, isInit: boolean): void;
+    deltaCellOutputContainerClassNames(diffSide: DiffSide, cellId: string, added: string[], removed: string[]): void;
+    firstChange(): void;
+    lastChange(): void;
+    previousChange(): void;
+    nextChange(): void;
+    toggleInlineView(): void;
+}
+export interface IDiffNestedCellViewModel {
+}
+export interface CellDiffCommonRenderTemplate {
+    readonly leftBorder: HTMLElement;
+    readonly rightBorder: HTMLElement;
+    readonly topBorder: HTMLElement;
+    readonly bottomBorder: HTMLElement;
+}
+export interface CellDiffPlaceholderRenderTemplate {
+    readonly container: HTMLElement;
+    readonly placeholder: HTMLElement;
+    readonly body: HTMLElement;
+    readonly marginOverlay: IDiffCellMarginOverlay;
+    readonly elementDisposables: DisposableStore;
+}
+export interface CellDiffSingleSideRenderTemplate extends CellDiffCommonRenderTemplate {
+    readonly container: HTMLElement;
+    readonly body: HTMLElement;
+    readonly diffEditorContainer: HTMLElement;
+    readonly diagonalFill: HTMLElement;
+    readonly elementDisposables: DisposableStore;
+    readonly cellHeaderContainer: HTMLElement;
+    readonly editorContainer: HTMLElement;
+    readonly sourceEditor: CodeEditorWidget;
+    readonly metadataHeaderContainer: HTMLElement;
+    readonly metadataInfoContainer: HTMLElement;
+    readonly outputHeaderContainer: HTMLElement;
+    readonly outputInfoContainer: HTMLElement;
+}
+export interface NotebookDocumentDiffElementRenderTemplate extends CellDiffCommonRenderTemplate {
+    readonly container: HTMLElement;
+    readonly body: HTMLElement;
+    readonly diffEditorContainer: HTMLElement;
+    readonly elementDisposables: DisposableStore;
+    readonly cellHeaderContainer: HTMLElement;
+    readonly sourceEditor: DiffEditorWidget;
+    readonly editorContainer: HTMLElement;
+    readonly inputToolbarContainer: HTMLElement;
+    readonly toolbar: WorkbenchToolBar;
+    readonly marginOverlay: IDiffCellMarginOverlay;
+}
+export interface IDiffCellMarginOverlay extends IDisposable {
+    readonly onAction: Event<void>;
+    show(): void;
+    hide(): void;
+}
+export interface CellDiffSideBySideRenderTemplate extends CellDiffCommonRenderTemplate {
+    readonly container: HTMLElement;
+    readonly body: HTMLElement;
+    readonly diffEditorContainer: HTMLElement;
+    readonly elementDisposables: DisposableStore;
+    readonly cellHeaderContainer: HTMLElement;
+    readonly sourceEditor: DiffEditorWidget;
+    readonly editorContainer: HTMLElement;
+    readonly inputToolbarContainer: HTMLElement;
+    readonly toolbar: WorkbenchToolBar;
+    readonly metadataHeaderContainer: HTMLElement;
+    readonly metadataInfoContainer: HTMLElement;
+    readonly outputHeaderContainer: HTMLElement;
+    readonly outputInfoContainer: HTMLElement;
+    readonly marginOverlay: IDiffCellMarginOverlay;
+}
+export interface IDiffElementLayoutInfo {
+    totalHeight: number;
+    width: number;
+    editorHeight: number;
+    editorMargin: number;
+    metadataHeight: number;
+    cellStatusHeight: number;
+    metadataStatusHeight: number;
+    rawOutputHeight: number;
+    outputMetadataHeight: number;
+    outputTotalHeight: number;
+    outputStatusHeight: number;
+    bodyMargin: number;
+    layoutState: CellLayoutState;
+}
+type IDiffElementSelfLayoutChangeEvent = {
+    [K in keyof IDiffElementLayoutInfo]?: boolean;
+};
+export interface CellDiffViewModelLayoutChangeEvent extends IDiffElementSelfLayoutChangeEvent {
+    font?: BareFontInfo;
+    outerWidth?: boolean;
+    metadataEditor?: boolean;
+    outputEditor?: boolean;
+    outputView?: boolean;
+}
+export declare const DIFF_CELL_MARGIN = 16;
+export declare const NOTEBOOK_DIFF_CELL_INPUT: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_METADATA: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY = "notebook.diffEditor.cell.ignoreWhitespace";
+export declare const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_CELL_PROPERTY: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_CELLS_COLLAPSED: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_ITEM_KIND: RawContextKey<boolean>;
+export declare const NOTEBOOK_DIFF_ITEM_DIFF_STATE: RawContextKey<boolean>;
+export interface INotebookDiffViewModelUpdateEvent {
+    readonly start: number;
+    readonly deleteCount: number;
+    readonly elements: readonly IDiffElementViewModelBase[];
+    readonly firstChangeIndex?: number;
+}
+export interface INotebookDiffViewModel extends IDisposable {
+    readonly items: readonly IDiffElementViewModelBase[];
+    /**
+     * Triggered when ever there's a change in the view model items.
+     */
+    readonly onDidChangeItems: Event<INotebookDiffViewModelUpdateEvent>;
+    /**
+     * Computes the differences and generates the viewmodel.
+     * If view models are generated, then the onDidChangeItems is triggered.
+     * @param token
+     */
+    computeDiff(token: CancellationToken): Promise<void>;
+}
+export {};

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditorBrowser.js

@@ -0,0 +1,32 @@
+
+import { RawContextKey } from '../../../../../platform/contextkey/common/contextkey.js';
+import { localize } from '../../../../../nls.js';
+
+var DiffSide;
+(function(DiffSide) {
+    DiffSide[DiffSide["Original"] = 0] = "Original";
+    DiffSide[DiffSide["Modified"] = 1] = "Modified";
+})(DiffSide || (DiffSide = {}));
+const DIFF_CELL_MARGIN = 16;
+const NOTEBOOK_DIFF_CELL_INPUT = ( new RawContextKey("notebook.diffEditor.cell.inputChanged", false));
+const NOTEBOOK_DIFF_METADATA = ( new RawContextKey("notebook.diffEditor.metadataChanged", false));
+const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY = "notebook.diffEditor.cell.ignoreWhitespace";
+const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE = ( new RawContextKey(NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY, false));
+const NOTEBOOK_DIFF_CELL_PROPERTY = ( new RawContextKey("notebook.diffEditor.cell.property.changed", false));
+const NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED = ( new RawContextKey("notebook.diffEditor.cell.property.expanded", false));
+const NOTEBOOK_DIFF_CELLS_COLLAPSED = ( new RawContextKey("notebook.diffEditor.allCollapsed", undefined, ( localize(11820, "Whether all cells in notebook diff editor are collapsed"))));
+const NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS = ( new RawContextKey("notebook.diffEditor.hasUnchangedCells", undefined, ( localize(11821, "Whether there are unchanged cells in the notebook diff editor"))));
+const NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN = ( new RawContextKey("notebook.diffEditor.unchangedCellsAreHidden", undefined, ( localize(
+    11822,
+    "Whether the unchanged cells in the notebook diff editor are hidden"
+))));
+const NOTEBOOK_DIFF_ITEM_KIND = ( new RawContextKey("notebook.diffEditor.item.kind", undefined, ( localize(
+    11823,
+    "The kind of item in the notebook diff editor, Cell, Metadata or Output"
+))));
+const NOTEBOOK_DIFF_ITEM_DIFF_STATE = ( new RawContextKey("notebook.diffEditor.item.state", undefined, ( localize(
+    11824,
+    "The diff state of item in the notebook diff editor, delete, insert, modified or unchanged"
+))));
+
+export { DIFF_CELL_MARGIN, DiffSide, NOTEBOOK_DIFF_CELLS_COLLAPSED, NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE, NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY, NOTEBOOK_DIFF_CELL_INPUT, NOTEBOOK_DIFF_CELL_PROPERTY, NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED, NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS, NOTEBOOK_DIFF_ITEM_DIFF_STATE, NOTEBOOK_DIFF_ITEM_KIND, NOTEBOOK_DIFF_METADATA, NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN };

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/notebookDiffList.d.ts

@@ -0,0 +1,102 @@
+import { IListMouseEvent, IListRenderer, IListVirtualDelegate } from "../../../../../base/browser/ui/list/list.js";
+import { IListOptions, IListStyles, IStyleController, MouseController } from "../../../../../base/browser/ui/list/listWidget.js";
+import { IDisposable } from "../../../../../base/common/lifecycle.js";
+import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
+import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
+import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
+import { IKeybindingService } from "../../../../../platform/keybinding/common/keybinding.service.js";
+import { IWorkbenchListOptions, WorkbenchList } from "../../../../../platform/list/browser/listService.js";
+import { IListService } from "../../../../../platform/list/browser/listService.service.js";
+import { IThemeService } from "../../../../../platform/theme/common/themeService.service.js";
+import { DiffElementPlaceholderViewModel, IDiffElementViewModelBase, NotebookDocumentMetadataViewModel, SideBySideDiffElementViewModel, SingleSideDiffElementViewModel } from "./diffElementViewModel.js";
+import { CellDiffPlaceholderRenderTemplate, CellDiffSideBySideRenderTemplate, CellDiffSingleSideRenderTemplate, INotebookTextDiffEditor, NotebookDocumentDiffElementRenderTemplate } from "./notebookDiffEditorBrowser.js";
+import { IMenuService } from "../../../../../platform/actions/common/actions.service.js";
+import { IContextMenuService } from "../../../../../platform/contextview/browser/contextView.service.js";
+import { INotificationService } from "../../../../../platform/notification/common/notification.service.js";
+import { IMouseWheelEvent } from "../../../../../base/browser/mouseEvent.js";
+import { IAccessibilityService } from "../../../../../platform/accessibility/common/accessibility.service.js";
+export declare class NotebookCellTextDiffListDelegate implements IListVirtualDelegate<IDiffElementViewModelBase> {
+    private readonly configurationService;
+    private readonly lineHeight;
+    constructor(targetWindow: Window, configurationService: IConfigurationService);
+    getHeight(element: IDiffElementViewModelBase): number;
+    hasDynamicHeight(element: IDiffElementViewModelBase): boolean;
+    getTemplateId(element: IDiffElementViewModelBase): string;
+}
+export declare class CellDiffPlaceholderRenderer implements IListRenderer<DiffElementPlaceholderViewModel, CellDiffPlaceholderRenderTemplate> {
+    readonly notebookEditor: INotebookTextDiffEditor;
+    protected readonly instantiationService: IInstantiationService;
+    static readonly TEMPLATE_ID = "cell_diff_placeholder";
+    constructor(notebookEditor: INotebookTextDiffEditor, instantiationService: IInstantiationService);
+    get templateId(): string;
+    renderTemplate(container: HTMLElement): CellDiffPlaceholderRenderTemplate;
+    renderElement(element: DiffElementPlaceholderViewModel, index: number, templateData: CellDiffPlaceholderRenderTemplate): void;
+    disposeTemplate(templateData: CellDiffPlaceholderRenderTemplate): void;
+    disposeElement(element: DiffElementPlaceholderViewModel, index: number, templateData: CellDiffPlaceholderRenderTemplate): void;
+}
+export declare class NotebookDocumentMetadataDiffRenderer implements IListRenderer<NotebookDocumentMetadataViewModel, NotebookDocumentDiffElementRenderTemplate> {
+    readonly notebookEditor: INotebookTextDiffEditor;
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly contextMenuService: IContextMenuService;
+    protected readonly keybindingService: IKeybindingService;
+    protected readonly menuService: IMenuService;
+    protected readonly contextKeyService: IContextKeyService;
+    protected readonly notificationService: INotificationService;
+    protected readonly themeService: IThemeService;
+    protected readonly accessibilityService: IAccessibilityService;
+    static readonly TEMPLATE_ID = "notebook_metadata_diff_side_by_side";
+    constructor(notebookEditor: INotebookTextDiffEditor, instantiationService: IInstantiationService, contextMenuService: IContextMenuService, keybindingService: IKeybindingService, menuService: IMenuService, contextKeyService: IContextKeyService, notificationService: INotificationService, themeService: IThemeService, accessibilityService: IAccessibilityService);
+    get templateId(): string;
+    renderTemplate(container: HTMLElement): NotebookDocumentDiffElementRenderTemplate;
+    private _buildSourceEditor;
+    renderElement(element: NotebookDocumentMetadataViewModel, index: number, templateData: NotebookDocumentDiffElementRenderTemplate): void;
+    disposeTemplate(templateData: NotebookDocumentDiffElementRenderTemplate): void;
+    disposeElement(element: NotebookDocumentMetadataViewModel, index: number, templateData: NotebookDocumentDiffElementRenderTemplate): void;
+}
+export declare class CellDiffSingleSideRenderer implements IListRenderer<SingleSideDiffElementViewModel, CellDiffSingleSideRenderTemplate | CellDiffSideBySideRenderTemplate> {
+    readonly notebookEditor: INotebookTextDiffEditor;
+    protected readonly instantiationService: IInstantiationService;
+    static readonly TEMPLATE_ID = "cell_diff_single";
+    constructor(notebookEditor: INotebookTextDiffEditor, instantiationService: IInstantiationService);
+    get templateId(): string;
+    renderTemplate(container: HTMLElement): CellDiffSingleSideRenderTemplate;
+    private _buildSourceEditor;
+    renderElement(element: SingleSideDiffElementViewModel, index: number, templateData: CellDiffSingleSideRenderTemplate): void;
+    disposeTemplate(templateData: CellDiffSingleSideRenderTemplate): void;
+    disposeElement(element: SingleSideDiffElementViewModel, index: number, templateData: CellDiffSingleSideRenderTemplate): void;
+}
+export declare class CellDiffSideBySideRenderer implements IListRenderer<SideBySideDiffElementViewModel, CellDiffSideBySideRenderTemplate> {
+    readonly notebookEditor: INotebookTextDiffEditor;
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly contextMenuService: IContextMenuService;
+    protected readonly keybindingService: IKeybindingService;
+    protected readonly menuService: IMenuService;
+    protected readonly contextKeyService: IContextKeyService;
+    protected readonly notificationService: INotificationService;
+    protected readonly themeService: IThemeService;
+    protected readonly accessibilityService: IAccessibilityService;
+    static readonly TEMPLATE_ID = "cell_diff_side_by_side";
+    constructor(notebookEditor: INotebookTextDiffEditor, instantiationService: IInstantiationService, contextMenuService: IContextMenuService, keybindingService: IKeybindingService, menuService: IMenuService, contextKeyService: IContextKeyService, notificationService: INotificationService, themeService: IThemeService, accessibilityService: IAccessibilityService);
+    get templateId(): string;
+    renderTemplate(container: HTMLElement): CellDiffSideBySideRenderTemplate;
+    private _buildSourceEditor;
+    renderElement(element: SideBySideDiffElementViewModel, index: number, templateData: CellDiffSideBySideRenderTemplate): void;
+    disposeTemplate(templateData: CellDiffSideBySideRenderTemplate): void;
+    disposeElement(element: SideBySideDiffElementViewModel, index: number, templateData: CellDiffSideBySideRenderTemplate): void;
+}
+export declare class NotebookMouseController<T> extends MouseController<T> {
+    protected onViewPointer(e: IListMouseEvent<T>): void;
+}
+export declare class NotebookTextDiffList extends WorkbenchList<IDiffElementViewModelBase> implements IDisposable, IStyleController {
+    private styleElement?;
+    get rowsContainer(): HTMLElement;
+    constructor(listUser: string, container: HTMLElement, delegate: IListVirtualDelegate<IDiffElementViewModelBase>, renderers: IListRenderer<IDiffElementViewModelBase, CellDiffSingleSideRenderTemplate | CellDiffSideBySideRenderTemplate | CellDiffPlaceholderRenderTemplate | NotebookDocumentDiffElementRenderTemplate>[], contextKeyService: IContextKeyService, options: IWorkbenchListOptions<IDiffElementViewModelBase>, listService: IListService, configurationService: IConfigurationService, instantiationService: IInstantiationService);
+    protected createMouseController(options: IListOptions<IDiffElementViewModelBase>): MouseController<IDiffElementViewModelBase>;
+    getCellViewScrollTop(element: IDiffElementViewModelBase): number;
+    getScrollHeight(): number;
+    triggerScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
+    delegateVerticalScrollbarPointerDown(browserEvent: PointerEvent): void;
+    clear(): void;
+    updateElementHeight2(element: IDiffElementViewModelBase, size: number): void;
+    style(styles: IListStyles): void;
+}