@codingame/monaco-vscode-api 13.1.6 → 14.0.0

package/vscode/src/vs/editor/browser/widget/diffEditor/components/diffEditorViewZones/renderLines.js

@@ -8,7 +8,7 @@ import { renderViewLine, RenderLineInput } from '../../../../../common/viewLayou
 import { ViewLineRenderingData } from '../../../../../common/viewModel.js';
 
 const ttPolicy = createTrustedTypesPolicy('diffEditorWidget', { createHTML: value => value });
-function renderLines(source, options, decorations, domNode) {
+function renderLines(source, options, decorations, domNode, noExtra = false) {
     applyFontInfo(domNode, options.fontInfo);
     const hasCharChanges = (decorations.length > 0);
     const sb = ( new StringBuilder(10000));
@@ -24,7 +24,7 @@ function renderLines(source, options, decorations, domNode) {
             let lastBreakOffset = 0;
             for (const breakOffset of lineBreakData.breakOffsets) {
                 const viewLineTokens = lineTokens.sliceAndInflate(lastBreakOffset, breakOffset, 0);
-                maxCharsPerLine = Math.max(maxCharsPerLine, renderOriginalLine(renderedLineCount, viewLineTokens, LineDecoration.extractWrapped(actualDecorations, lastBreakOffset, breakOffset), hasCharChanges, source.mightContainNonBasicASCII, source.mightContainRTL, options, sb));
+                maxCharsPerLine = Math.max(maxCharsPerLine, renderOriginalLine(renderedLineCount, viewLineTokens, LineDecoration.extractWrapped(actualDecorations, lastBreakOffset, breakOffset), hasCharChanges, source.mightContainNonBasicASCII, source.mightContainRTL, options, sb, noExtra));
                 renderedLineCount++;
                 lastBreakOffset = breakOffset;
             }
@@ -32,7 +32,7 @@ function renderLines(source, options, decorations, domNode) {
         }
         else {
             viewLineCounts.push(1);
-            maxCharsPerLine = Math.max(maxCharsPerLine, renderOriginalLine(renderedLineCount, lineTokens, actualDecorations, hasCharChanges, source.mightContainNonBasicASCII, source.mightContainRTL, options, sb));
+            maxCharsPerLine = Math.max(maxCharsPerLine, renderOriginalLine(renderedLineCount, lineTokens, actualDecorations, hasCharChanges, source.mightContainNonBasicASCII, source.mightContainRTL, options, sb, noExtra));
             renderedLineCount++;
         }
     }
@@ -74,7 +74,7 @@ class RenderOptions {
             modifiedEditorOptions.get(EditorOption.fontLigatures)
         ));
     }
-    constructor(tabSize, fontInfo, disableMonospaceOptimizations, typicalHalfwidthCharacterWidth, scrollBeyondLastColumn, lineHeight, lineDecorationsWidth, stopRenderingLineAfter, renderWhitespace, renderControlCharacters, fontLigatures) {
+    constructor(tabSize, fontInfo, disableMonospaceOptimizations, typicalHalfwidthCharacterWidth, scrollBeyondLastColumn, lineHeight, lineDecorationsWidth, stopRenderingLineAfter, renderWhitespace, renderControlCharacters, fontLigatures, setWidth = true) {
         this.tabSize = tabSize;
         this.fontInfo = fontInfo;
         this.disableMonospaceOptimizations = disableMonospaceOptimizations;
@@ -86,16 +86,38 @@ class RenderOptions {
         this.renderWhitespace = renderWhitespace;
         this.renderControlCharacters = renderControlCharacters;
         this.fontLigatures = fontLigatures;
+        this.setWidth = setWidth;
+    }
+    withSetWidth(setWidth) {
+        return ( new RenderOptions(
+            this.tabSize,
+            this.fontInfo,
+            this.disableMonospaceOptimizations,
+            this.typicalHalfwidthCharacterWidth,
+            this.scrollBeyondLastColumn,
+            this.lineHeight,
+            this.lineDecorationsWidth,
+            this.stopRenderingLineAfter,
+            this.renderWhitespace,
+            this.renderControlCharacters,
+            this.fontLigatures,
+            setWidth
+        ));
     }
 }
-function renderOriginalLine(viewLineIdx, lineTokens, decorations, hasCharChanges, mightContainNonBasicASCII, mightContainRTL, options, sb) {
+function renderOriginalLine(viewLineIdx, lineTokens, decorations, hasCharChanges, mightContainNonBasicASCII, mightContainRTL, options, sb, noExtra) {
     sb.appendString('<div class="view-line');
-    if (!hasCharChanges) {
+    if (!noExtra && !hasCharChanges) {
         sb.appendString(' char-delete');
     }
     sb.appendString('" style="top:');
     sb.appendString(String(viewLineIdx * options.lineHeight));
-    sb.appendString('px;width:1000000px;">');
+    if (options.setWidth) {
+        sb.appendString('px;width:1000000px;">');
+    }
+    else {
+        sb.appendString('px;">');
+    }
     const lineContent = lineTokens.getLineContent();
     const isBasicASCII = ViewLineRenderingData.isBasicASCII(lineContent, mightContainNonBasicASCII);
     const containsRTL = ViewLineRenderingData.containsRTL(lineContent, isBasicASCII, mightContainRTL);

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorOptions.d.ts

@@ -1,47 +1,47 @@
-import { IObservable } from "../../../../base/common/observable.js";
+import { IObservable, IObservableWithChange } from "../../../../base/common/observable.js";
 import { IAccessibilityService } from "../../../../platform/accessibility/common/accessibility.service.js";
 import { IDiffEditorOptions, IEditorOptions } from "../../../common/config/editorOptions.js";
 import { DiffEditorViewModel } from "./diffEditorViewModel.js";
 export declare class DiffEditorOptions {
     private readonly _accessibilityService;
     private readonly _options;
-    get editorOptions(): IObservable<IEditorOptions, {
+    get editorOptions(): IObservableWithChange<IEditorOptions, {
         changedOptions: IEditorOptions;
     }>;
     private readonly _diffEditorWidth;
     private readonly _screenReaderMode;
     constructor(options: Readonly<IDiffEditorOptions>, _accessibilityService: IAccessibilityService);
-    readonly couldShowInlineViewBecauseOfSize: IObservable<boolean, unknown>;
-    readonly renderOverviewRuler: IObservable<boolean, unknown>;
-    readonly renderSideBySide: IObservable<boolean, unknown>;
-    readonly readOnly: IObservable<boolean | undefined, unknown>;
-    readonly shouldRenderOldRevertArrows: IObservable<boolean, unknown>;
-    readonly shouldRenderGutterMenu: IObservable<boolean, unknown>;
-    readonly renderIndicators: IObservable<boolean, unknown>;
-    readonly enableSplitViewResizing: IObservable<boolean, unknown>;
-    readonly splitViewDefaultRatio: IObservable<number, unknown>;
-    readonly ignoreTrimWhitespace: IObservable<boolean, unknown>;
-    readonly maxComputationTimeMs: IObservable<number, unknown>;
-    readonly showMoves: IObservable<boolean, unknown>;
-    readonly isInEmbeddedEditor: IObservable<boolean, unknown>;
-    readonly diffWordWrap: IObservable<"inherit" | "off" | "on", unknown>;
-    readonly originalEditable: IObservable<boolean, unknown>;
-    readonly diffCodeLens: IObservable<boolean, unknown>;
-    readonly accessibilityVerbose: IObservable<boolean, unknown>;
-    readonly diffAlgorithm: IObservable<"advanced" | "legacy", unknown>;
-    readonly showEmptyDecorations: IObservable<boolean, unknown>;
-    readonly onlyShowAccessibleDiffViewer: IObservable<boolean, unknown>;
-    readonly compactMode: IObservable<boolean, unknown>;
+    readonly couldShowInlineViewBecauseOfSize: IObservable<boolean>;
+    readonly renderOverviewRuler: IObservable<boolean>;
+    readonly renderSideBySide: IObservable<boolean>;
+    readonly readOnly: IObservable<boolean | undefined>;
+    readonly shouldRenderOldRevertArrows: IObservable<boolean>;
+    readonly shouldRenderGutterMenu: IObservable<boolean>;
+    readonly renderIndicators: IObservable<boolean>;
+    readonly enableSplitViewResizing: IObservable<boolean>;
+    readonly splitViewDefaultRatio: IObservable<number>;
+    readonly ignoreTrimWhitespace: IObservable<boolean>;
+    readonly maxComputationTimeMs: IObservable<number>;
+    readonly showMoves: IObservable<boolean>;
+    readonly isInEmbeddedEditor: IObservable<boolean>;
+    readonly diffWordWrap: IObservable<"inherit" | "off" | "on">;
+    readonly originalEditable: IObservable<boolean>;
+    readonly diffCodeLens: IObservable<boolean>;
+    readonly accessibilityVerbose: IObservable<boolean>;
+    readonly diffAlgorithm: IObservable<"advanced" | "legacy">;
+    readonly showEmptyDecorations: IObservable<boolean>;
+    readonly onlyShowAccessibleDiffViewer: IObservable<boolean>;
+    readonly compactMode: IObservable<boolean>;
     private readonly trueInlineDiffRenderingEnabled;
     readonly useTrueInlineDiffRendering: IObservable<boolean>;
-    readonly hideUnchangedRegions: IObservable<boolean, unknown>;
-    readonly hideUnchangedRegionsRevealLineCount: IObservable<number, unknown>;
-    readonly hideUnchangedRegionsContextLineCount: IObservable<number, unknown>;
-    readonly hideUnchangedRegionsMinimumLineCount: IObservable<number, unknown>;
+    readonly hideUnchangedRegions: IObservable<boolean>;
+    readonly hideUnchangedRegionsRevealLineCount: IObservable<number>;
+    readonly hideUnchangedRegionsContextLineCount: IObservable<number>;
+    readonly hideUnchangedRegionsMinimumLineCount: IObservable<number>;
     updateOptions(changedOptions: IDiffEditorOptions): void;
     setWidth(width: number): void;
     private readonly _model;
     setModel(model: DiffEditorViewModel | undefined): void;
     private readonly shouldRenderInlineViewInSmartMode;
-    readonly inlineViewHideOriginalLineNumbers: IObservable<boolean, unknown>;
+    readonly inlineViewHideOriginalLineNumbers: IObservable<boolean>;
 }

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorViewModel.d.ts

@@ -2,7 +2,7 @@ import { Disposable } from "../../../../base/common/lifecycle.js";
 import { IObservable, IReader, ISettableObservable, ITransaction } from "../../../../base/common/observable.js";
 import { IDiffProviderFactoryService } from "./diffProviderFactoryService.js";
 import { ISerializedLineRange, LineRange } from "../../../common/core/lineRange.js";
-import { IDocumentDiff } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiff } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/editor/common/diff/documentDiffProvider";
 import { MovedText } from "../../../common/diff/linesDiffComputer.js";
 import { DetailedLineRangeMapping, LineRangeMapping } from "../../../common/diff/rangeMapping.js";
 import { IDiffEditorModel, IDiffEditorViewModel } from "../../../common/editorCommon.js";
@@ -21,7 +21,7 @@ export declare class DiffEditorViewModel extends Disposable implements IDiffEdit
     readonly movedTextToCompare: ISettableObservable<MovedText | undefined, void>;
     private readonly _activeMovedText;
     private readonly _hoveredMovedText;
-    readonly activeMovedText: IObservable<MovedText | undefined, unknown>;
+    readonly activeMovedText: IObservable<MovedText | undefined>;
     setActiveMovedText(movedText: MovedText | undefined): void;
     setHoveredMovedText(movedText: MovedText | undefined): void;
     private readonly _cancellationTokenSource;

package/vscode/src/vs/editor/browser/widget/diffEditor/diffEditorViewModel.js

@@ -16,7 +16,6 @@ import { filterWithPrevious } from './utils.js';
 import '../../../../base/common/process.js';
 import { LineRange, LineRangeSet } from '../../../common/core/lineRange.js';
 import '../../../../base/common/strings.js';
-import '../../../common/core/lineEdit.js';
 import '../../../../base/common/arraysFind.js';
 import '../../../common/core/textLength.js';
 import { LineRangeMapping, DetailedLineRangeMapping, RangeMapping } from '../../../common/diff/rangeMapping.js';

package/vscode/src/vs/editor/browser/widget/diffEditor/diffProviderFactoryService.d.ts

@@ -2,7 +2,7 @@ import { IInstantiationService } from "../../../../platform/instantiation/common
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
-import { IDocumentDiff, IDocumentDiffProvider, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { IDocumentDiff, IDocumentDiffProvider, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/editor/common/diff/documentDiffProvider";
 import { ITextModel } from "../../../common/model.js";
 import { IEditorWorkerService } from "../../../common/services/editorWorker.js";
 import { ITelemetryService } from "../../../../platform/telemetry/common/telemetry.service.js";

package/vscode/src/vs/editor/browser/widget/diffEditor/features/gutterFeature.d.ts

@@ -23,9 +23,9 @@ export declare class DiffEditorGutter extends Disposable {
     private readonly _actions;
     private readonly _hasActions;
     private readonly _showSash;
-    readonly width: IObservable<0 | 35, unknown>;
+    readonly width: IObservable<0 | 35>;
     private readonly elements;
-    constructor(diffEditorRoot: HTMLDivElement, _diffModel: IObservable<DiffEditorViewModel | undefined>, _editors: DiffEditorEditors, _options: DiffEditorOptions, _sashLayout: SashLayout, _boundarySashes: IObservable<IBoundarySashes | undefined, void>, _instantiationService: IInstantiationService, _contextKeyService: IContextKeyService, _menuService: IMenuService);
+    constructor(diffEditorRoot: HTMLDivElement, _diffModel: IObservable<DiffEditorViewModel | undefined>, _editors: DiffEditorEditors, _options: DiffEditorOptions, _sashLayout: SashLayout, _boundarySashes: IObservable<IBoundarySashes | undefined>, _instantiationService: IInstantiationService, _contextKeyService: IContextKeyService, _menuService: IMenuService);
     computeStagedValue(mapping: DetailedLineRangeMapping): string;
     private readonly _currentDiff;
     private readonly _selectedDiffs;

package/vscode/src/vs/editor/browser/widget/diffEditor/utils.d.ts

@@ -1,7 +1,7 @@
 import { IDimension } from "../../../../base/browser/dom.js";
 import { CancellationTokenSource } from "../../../../base/common/cancellation.js";
 import { Disposable, DisposableStore, IDisposable, IReference } from "../../../../base/common/lifecycle.js";
-import { IObservable } from "../../../../base/common/observable.js";
+import { IObservable, IObservableWithChange } from "../../../../base/common/observable.js";
 import { ICodeEditor, IViewZone } from "../../editorBrowser.js";
 import { Position } from "../../../common/core/position.js";
 import { Range } from "../../../common/core/range.js";
@@ -23,7 +23,7 @@ export declare class ObservableElementSizeObserver extends Disposable {
     observe(dimension?: IDimension): void;
     setAutomaticLayout(automaticLayout: boolean): void;
 }
-export declare function animatedObservable(targetWindow: Window, base: IObservable<number, boolean>, store: DisposableStore): IObservable<number>;
+export declare function animatedObservable(targetWindow: Window, base: IObservableWithChange<number, boolean>, store: DisposableStore): IObservable<number>;
 export declare function deepMerge<T extends {}>(source1: T, source2: Partial<T>): T;
 export declare abstract class ViewZoneOverlayWidget extends Disposable {
     constructor(editor: ICodeEditor, viewZone: PlaceholderViewZone, htmlElement: HTMLElement);

package/vscode/src/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer.d.ts

@@ -1,9 +1,9 @@
 import { MarkdownRenderOptions, MarkedOptions } from "../../../../../base/browser/markdownRenderer.js";
 import { IMarkdownString, MarkdownStringTrustedOptions } from "../../../../../base/common/htmlContent.js";
 import { DisposableStore, IDisposable } from "../../../../../base/common/lifecycle.js";
-import { ICodeEditor } from "../../../editorBrowser.js";
-import { ILanguageService } from "../../../../common/languages/language.js";
 import { IOpenerService } from "../../../../../platform/opener/common/opener.service.js";
+import { ILanguageService } from "../../../../common/languages/language.js";
+import { ICodeEditor } from "../../../editorBrowser.js";
 export interface IMarkdownRenderResult extends IDisposable {
     readonly element: HTMLElement;
 }
@@ -12,15 +12,12 @@ export interface IMarkdownRendererOptions {
     readonly codeBlockFontFamily?: string;
     readonly codeBlockFontSize?: string;
 }
-export declare class MarkdownRenderer implements IDisposable {
+export declare class MarkdownRenderer {
     private readonly _options;
     private readonly _languageService;
     private readonly _openerService;
     private static _ttpTokenizer;
-    private readonly _onDidRenderAsync;
-    readonly onDidRenderAsync: import("../../../../../base/common/event.js").Event<void>;
     constructor(_options: IMarkdownRendererOptions, _languageService: ILanguageService, _openerService: IOpenerService);
-    dispose(): void;
     render(markdown: IMarkdownString | undefined, options?: MarkdownRenderOptions, markedOptions?: MarkedOptions): IMarkdownRenderResult;
     protected _getRenderOptions(markdown: IMarkdownString, disposables: DisposableStore): MarkdownRenderOptions;
     protected openMarkdownLink(link: string, markdown: IMarkdownString): Promise<void>;

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

@@ -3,15 +3,14 @@ import { __decorate, __param } from '../../../../../../../../external/tslib/tsli
 import { renderMarkdown } from '../../../../../base/browser/markdownRenderer.js';
 import { createTrustedTypesPolicy } from '../../../../../base/browser/trustedTypes.js';
 import { onUnexpectedError } from '../../../../../base/common/errors.js';
-import { Emitter } from '../../../../../base/common/event.js';
 import { DisposableStore } from '../../../../../base/common/lifecycle.js';
-import './renderedMarkdown.css.js';
-import { applyFontInfo } from '../../../config/domFontInfo.js';
+import { IOpenerService } from '../../../../../platform/opener/common/opener.service.js';
 import { EditorOption } from '../../../../common/config/editorOptions.js';
 import { ILanguageService } from '../../../../common/languages/language.js';
 import { PLAINTEXT_LANGUAGE_ID } from '../../../../common/languages/modesRegistry.js';
 import { tokenizeToString } from '../../../../common/languages/textToHtmlTokenizer.js';
-import { IOpenerService } from '../../../../../platform/opener/common/opener.service.js';
+import { applyFontInfo } from '../../../config/domFontInfo.js';
+import './renderedMarkdown.css.js';
 
 var MarkdownRenderer_1;
 let MarkdownRenderer = class MarkdownRenderer {
@@ -25,11 +24,6 @@ let MarkdownRenderer = class MarkdownRenderer {
         this._options = _options;
         this._languageService = _languageService;
         this._openerService = _openerService;
-        this._onDidRenderAsync = ( new Emitter());
-        this.onDidRenderAsync = this._onDidRenderAsync.event;
-    }
-    dispose() {
-        this._onDidRenderAsync.dispose();
     }
     render(markdown, options, markedOptions) {
         if (!markdown) {
@@ -72,7 +66,6 @@ let MarkdownRenderer = class MarkdownRenderer {
                 }
                 return element;
             },
-            asyncRenderCallback: () => this._onDidRenderAsync.fire(),
             actionHandler: {
                 callback: (link) => this.openMarkdownLink(link, markdown),
                 disposables: disposables

package/vscode/src/vs/editor/common/config/editorOptions.d.ts

@@ -161,6 +161,7 @@ export interface IEditorFindOptions {
     globalFindClipboard?: boolean;
     loop?: boolean;
     history?: "never" | "workspace";
+    replaceHistory?: "never" | "workspace";
 }
 export type EditorFindOptions = Readonly<Required<IEditorFindOptions>>;
 export declare class EditorFontLigatures extends BaseEditorOption<EditorOption.fontLigatures, boolean | string, string> {
@@ -456,12 +457,13 @@ export interface IInlineSuggestOptions {
     keepOnBlur?: boolean;
     fontFamily?: string | "default";
     edits?: {
-        experimental?: {
-            enabled?: boolean;
-            useMixedLinesDiff?: "never" | "whenPossible" | "afterJumpWhenPossible";
-            useInterleavedLinesDiff?: "never" | "always" | "afterJump";
-            onlyShowWhenCloseToCursor?: boolean;
-        };
+        codeShifting?: boolean;
+        renderSideBySide?: "never" | "auto";
+        enabled?: boolean;
+        useMixedLinesDiff?: "never" | "whenPossible" | "forStableInsertions" | "afterJumpWhenPossible";
+        useInterleavedLinesDiff?: "never" | "always" | "afterJump";
+        useMultiLineGhostText?: boolean;
+        useGutterIndicator?: boolean;
     };
 }
 type RequiredRecursive<T> = {