@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.1

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatEditorAffordance.d.ts

@@ -10,22 +10,11 @@ import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
  * When clicked, it shows the overlay widget for inline chat.
  */
 export declare class InlineChatEditorAffordance extends Disposable implements IContentWidget {
-    private readonly _editor;
-    private static _idPool;
-    private readonly _id;
-    private readonly _domNode;
-    private _position;
-    private _isVisible;
-    private readonly _onDidRunAction;
+    #private;
     readonly onDidRunAction: Event<string>;
     readonly allowEditorOverflow = true;
     readonly suppressMouseDown = false;
-    constructor(_editor: ICodeEditor, selection: IObservable<Selection | undefined>, instantiationService: IInstantiationService);
-    private _show;
-    private _showAtSelection;
-    private _showAtLineStart;
-    private _isPositionInViewport;
-    private _hide;
+    constructor(editor: ICodeEditor, selection: IObservable<Selection | undefined>, instantiationService: IInstantiationService);
     getId(): string;
     getDomNode(): HTMLElement;
     getPosition(): IContentWidgetPosition | null;

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatEditorAffordance.js

@@ -31,9 +31,12 @@ import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 var InlineChatEditorAffordance_1;
 registerCss(inlineChatEditorAffordance);
 let QuickFixActionViewItem = class QuickFixActionViewItem extends MenuEntryActionViewItem {
+    #lightBulbStore = this._store.add(( new MutableDisposable()));
+    #currentTitle;
+    #editor;
     constructor(
         action,
-        _editor,
+        editor,
         keybindingService,
         notificationService,
         contextKeyService,
@@ -56,7 +59,7 @@ let QuickFixActionViewItem = class QuickFixActionViewItem extends MenuEntryActio
                 this.elementGetter = () => undefined;
             }
             async run(...args) {
-                const controller = CodeActionController.get(_editor);
+                const controller = CodeActionController.get(editor);
                 const info = controller?.lightBulbState.get();
                 const element = this.elementGetter();
                 if (controller && info && element) {
@@ -74,24 +77,23 @@ let QuickFixActionViewItem = class QuickFixActionViewItem extends MenuEntryActio
         super(wrappedAction, {
             draggable: false
         }, keybindingService, notificationService, contextKeyService, themeService, contextMenuService, accessibilityService);
-        this._editor = _editor;
-        this._lightBulbStore = this._store.add(( new MutableDisposable()));
+        this.#editor = editor;
         wrappedAction.elementGetter = () => this.element;
     }
     render(container) {
         super.render(container);
-        this._updateFromLightBulb();
+        this.#updateFromLightBulb();
     }
     getTooltip() {
-        return this._currentTitle ?? super.getTooltip();
+        return this.#currentTitle ?? super.getTooltip();
     }
-    _updateFromLightBulb() {
-        const controller = CodeActionController.get(this._editor);
+    #updateFromLightBulb() {
+        const controller = CodeActionController.get(this.#editor);
         if (!controller) {
             return;
         }
         const store = ( new DisposableStore());
-        this._lightBulbStore.value = store;
+        this.#lightBulbStore.value = store;
         store.add(autorun(reader => {
             const info = controller.lightBulbState.read(reader);
             if (this.label) {
@@ -100,13 +102,14 @@ let QuickFixActionViewItem = class QuickFixActionViewItem extends MenuEntryActio
                 this.label.className = "";
                 this.label.classList.add("codicon", "action-label", ...iconClasses);
             }
-            this._currentTitle = info?.title;
+            this.#currentTitle = info?.title;
             this.updateTooltip();
         }));
     }
 };
 QuickFixActionViewItem = ( __decorate([( __param(2, IKeybindingService)), ( __param(3, INotificationService)), ( __param(4, IContextKeyService)), ( __param(5, IThemeService)), ( __param(6, IContextMenuService)), ( __param(7, IAccessibilityService)), ( __param(8, ICommandService))], QuickFixActionViewItem));
 let LabelWithKeybindingActionViewItem = class LabelWithKeybindingActionViewItem extends MenuEntryActionViewItem {
+    #kbLabel;
     constructor(
         action,
         keybindingService,
@@ -121,14 +124,14 @@ let LabelWithKeybindingActionViewItem = class LabelWithKeybindingActionViewItem
         }, keybindingService, notificationService, contextKeyService, themeService, contextMenuService, accessibilityService);
         this.options.label = true;
         this.options.icon = false;
-        this._kbLabel = keybindingService.lookupKeybinding(action.id)?.getLabel() ?? undefined;
+        this.#kbLabel = keybindingService.lookupKeybinding(action.id)?.getLabel() ?? undefined;
     }
     updateLabel() {
         if (this.label) {
             reset(
                 this.label,
                 this.action.label,
-                ...(this._kbLabel ? [$("span.inline-chat-keybinding", undefined, this._kbLabel)] : [])
+                ...(this.#kbLabel ? [$("span.inline-chat-keybinding", undefined, this.#kbLabel)] : [])
             );
         }
     }
@@ -138,22 +141,26 @@ let InlineChatEditorAffordance = class InlineChatEditorAffordance extends Dispos
     static {
         InlineChatEditorAffordance_1 = this;
     }
-    static {
-        this._idPool = 0;
-    }
-    constructor(_editor, selection, instantiationService) {
+    static #idPool = 0;
+    #id;
+    #domNode;
+    #position;
+    #isVisible;
+    #onDidRunAction;
+    #editor;
+    constructor(editor, selection, instantiationService) {
         super();
-        this._editor = _editor;
-        this._id = `inline-chat-content-widget-${InlineChatEditorAffordance_1._idPool++}`;
-        this._position = null;
-        this._isVisible = false;
-        this._onDidRunAction = this._store.add(( new Emitter()));
-        this.onDidRunAction = this._onDidRunAction.event;
+        this.#id = `inline-chat-content-widget-${InlineChatEditorAffordance_1.#idPool++}`;
+        this.#position = null;
+        this.#isVisible = false;
+        this.#onDidRunAction = this._store.add(( new Emitter()));
+        this.onDidRunAction = this.#onDidRunAction.event;
         this.allowEditorOverflow = true;
         this.suppressMouseDown = false;
-        this._domNode = $(".inline-chat-content-widget");
+        this.#editor = editor;
+        this.#domNode = $(".inline-chat-content-widget");
         const toolbar = this._store.add(
-            instantiationService.createInstance(MenuWorkbenchToolBar, this._domNode, MenuId.InlineChatEditorAffordance, {
+            instantiationService.createInstance(MenuWorkbenchToolBar, this.#domNode, MenuId.InlineChatEditorAffordance, {
                 telemetrySource: "inlineChatEditorAffordance",
                 hiddenItemStrategy: HiddenItemStrategy.Ignore,
                 menuOptions: {
@@ -165,7 +172,7 @@ let InlineChatEditorAffordance = class InlineChatEditorAffordance extends Dispos
                 },
                 actionViewItemProvider: action => {
                     if (action instanceof MenuItemAction && action.id === quickFixCommandId) {
-                        return instantiationService.createInstance(QuickFixActionViewItem, action, this._editor);
+                        return instantiationService.createInstance(QuickFixActionViewItem, action, this.#editor);
                     }
                     if (action instanceof MenuItemAction && (action.id === ACTION_START || action.id === ACTION_ASK_IN_CHAT || action.id === "inlineChat.fixDiagnostics")) {
                         return instantiationService.createInstance(LabelWithKeybindingActionViewItem, action);
@@ -175,59 +182,59 @@ let InlineChatEditorAffordance = class InlineChatEditorAffordance extends Dispos
             })
         );
         this._store.add(toolbar.actionRunner.onDidRun(e => {
-            this._onDidRunAction.fire(e.action.id);
-            this._hide();
+            this.#onDidRunAction.fire(e.action.id);
+            this.#hide();
         }));
         this._store.add(autorun(r => {
             const sel = selection.read(r);
             if (sel) {
-                this._show(sel);
+                this.#show(sel);
             } else {
-                this._hide();
+                this.#hide();
             }
         }));
-        this._store.add(this._editor.onDidScrollChange(() => {
+        this._store.add(this.#editor.onDidScrollChange(() => {
             const sel = selection.get();
             if (!sel) {
                 return;
             }
-            const isInViewport = this._isPositionInViewport();
-            if (isInViewport && !this._isVisible) {
-                this._show(sel);
-            } else if (!isInViewport && this._isVisible) {
-                this._hide();
+            const isInViewport = this.#isPositionInViewport();
+            if (isInViewport && !this.#isVisible) {
+                this.#show(sel);
+            } else if (!isInViewport && this.#isVisible) {
+                this.#hide();
             }
         }));
     }
-    _show(selection) {
+    #show(selection) {
         if (selection.isEmpty()) {
-            this._showAtLineStart(selection.getPosition().lineNumber);
+            this.#showAtLineStart(selection.getPosition().lineNumber);
         } else {
-            this._showAtSelection(selection);
+            this.#showAtSelection(selection);
         }
-        if (this._isVisible) {
-            this._editor.layoutContentWidget(this);
+        if (this.#isVisible) {
+            this.#editor.layoutContentWidget(this);
         } else {
-            this._editor.addContentWidget(this);
-            this._isVisible = true;
+            this.#editor.addContentWidget(this);
+            this.#isVisible = true;
         }
     }
-    _showAtSelection(selection) {
+    #showAtSelection(selection) {
         const cursorPosition = selection.getPosition();
         const direction = selection.getDirection();
         const preference = direction === SelectionDirection.RTL ? ContentWidgetPositionPreference.ABOVE : ContentWidgetPositionPreference.BELOW;
-        this._position = {
+        this.#position = {
             position: cursorPosition,
             preference: [preference]
         };
     }
-    _showAtLineStart(lineNumber) {
-        const model = this._editor.getModel();
+    #showAtLineStart(lineNumber) {
+        const model = this.#editor.getModel();
         if (!model) {
             return;
         }
         const tabSize = model.getOptions().tabSize;
-        const fontInfo = this._editor.getOptions().get(EditorOption.fontInfo);
+        const fontInfo = this.#editor.getOptions().get(EditorOption.fontInfo);
         const lineContent = model.getLineContent(lineNumber);
         const indent = computeIndentLevel(lineContent, tabSize);
         const lineHasSpace = indent < 0 ? true : fontInfo.spaceWidth * indent > 22;
@@ -245,7 +252,7 @@ let InlineChatEditorAffordance = class InlineChatEditorAffordance extends Dispos
             }
         }
         const effectiveColumnNumber = /^\S\s*$/.test(model.getLineContent(effectiveLineNumber)) ? 2 : 1;
-        this._position = {
+        this.#position = {
             position: {
                 lineNumber: effectiveLineNumber,
                 column: effectiveColumnNumber
@@ -253,49 +260,49 @@ let InlineChatEditorAffordance = class InlineChatEditorAffordance extends Dispos
             preference: [ContentWidgetPositionPreference.EXACT]
         };
     }
-    _isPositionInViewport() {
-        const widgetPosition = this._position?.position;
+    #isPositionInViewport() {
+        const widgetPosition = this.#position?.position;
         if (!widgetPosition) {
             return false;
         }
-        const visibleRanges = this._editor.getVisibleRanges();
+        const visibleRanges = this.#editor.getVisibleRanges();
         const isLineVisible = ( visibleRanges.some(
             range => widgetPosition.lineNumber >= range.startLineNumber && widgetPosition.lineNumber <= range.endLineNumber
         ));
         if (!isLineVisible) {
             return false;
         }
-        const scrolledPos = this._editor.getScrolledVisiblePosition(widgetPosition);
+        const scrolledPos = this.#editor.getScrolledVisiblePosition(widgetPosition);
         if (!scrolledPos) {
             return false;
         }
-        const layoutInfo = this._editor.getOptions().get(EditorOption.layoutInfo);
+        const layoutInfo = this.#editor.getOptions().get(EditorOption.layoutInfo);
         return scrolledPos.left >= 0 && scrolledPos.left <= layoutInfo.width;
     }
-    _hide() {
-        if (this._isVisible) {
-            this._isVisible = false;
-            this._editor.removeContentWidget(this);
+    #hide() {
+        if (this.#isVisible) {
+            this.#isVisible = false;
+            this.#editor.removeContentWidget(this);
         }
     }
     getId() {
-        return this._id;
+        return this.#id;
     }
     getDomNode() {
-        return this._domNode;
+        return this.#domNode;
     }
     getPosition() {
-        return this._position;
+        return this.#position;
     }
     beforeRender() {
-        const position = this._editor.getPosition();
-        const lineHeight = position ? this._editor.getLineHeightForPosition(position) : this._editor.getOption(EditorOption.lineHeight);
-        this._domNode.style.setProperty("--vscode-inline-chat-affordance-height", `${lineHeight}px`);
+        const position = this.#editor.getPosition();
+        const lineHeight = position ? this.#editor.getLineHeightForPosition(position) : this.#editor.getOption(EditorOption.lineHeight);
+        this.#domNode.style.setProperty("--vscode-inline-chat-affordance-height", `${lineHeight}px`);
         return null;
     }
     dispose() {
-        if (this._isVisible) {
-            this._editor.removeContentWidget(this);
+        if (this.#isVisible) {
+            this.#editor.removeContentWidget(this);
         }
         super.dispose();
     }

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatOverlayWidget.d.ts

@@ -7,7 +7,6 @@ import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/ac
 import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { IInlineChatSession2 } from "./inlineChatSessionService.js";
 import { IInlineChatHistoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatHistoryService.service";
@@ -15,28 +14,11 @@ import { IInlineChatHistoryService } from "@codingame/monaco-vscode-api/vscode/v
  * Overlay widget that displays a vertical action bar menu.
  */
 export declare class InlineChatInputWidget extends Disposable {
-    private readonly _editorObs;
-    private readonly _contextKeyService;
-    private readonly _menuService;
-    private readonly _historyService;
-    private readonly _domNode;
-    private readonly _container;
-    private readonly _inputContainer;
-    private readonly _toolbarContainer;
-    private readonly _input;
-    private readonly _position;
+    #private;
     readonly position: IObservable<IOverlayWidgetPosition | null>;
-    private readonly _showStore;
-    private readonly _stickyScrollHeight;
-    private readonly _layoutData;
-    private _anchorLineNumber;
-    private _anchorLeft;
-    private _anchorAbove;
-    constructor(_editorObs: ObservableCodeEditor, _contextKeyService: IContextKeyService, _menuService: IMenuService, instantiationService: IInstantiationService, modelService: IModelService, configurationService: IConfigurationService, _historyService: IInlineChatHistoryService);
+    constructor(editorObs: ObservableCodeEditor, contextKeyService: IContextKeyService, menuService: IMenuService, instantiationService: IInstantiationService, modelService: IModelService, configurationService: IConfigurationService, historyService: IInlineChatHistoryService);
     get value(): string;
     addToHistory(value: string): void;
-    private _showPreviousHistoryValue;
-    private _showNextHistoryValue;
     /**
      * Show the widget at the specified line.
      * @param lineNumber The line number to anchor the widget to
@@ -44,35 +26,14 @@ export declare class InlineChatInputWidget extends Disposable {
      * @param anchorAbove Whether to anchor above the position (widget grows upward)
      */
     show(lineNumber: number, left: number, anchorAbove: boolean, placeholder: string, value?: string): void;
-    private _updatePosition;
-    /**
-     * Hide the widget (removes from editor but does not dispose).
-     */
     hide(): void;
 }
 /**
  * Overlay widget that displays progress messages during inline chat requests.
  */
 export declare class InlineChatSessionOverlayWidget extends Disposable {
-    private readonly _editorObs;
-    private readonly _instaService;
-    private readonly _keybindingService;
-    private readonly _logService;
-    private readonly _domNode;
-    private readonly _container;
-    private readonly _markdownContainer;
-    private readonly _markdownMessage;
-    private readonly _markdownScrollable;
-    private readonly _contentRow;
-    private readonly _statusNode;
-    private readonly _icon;
-    private readonly _message;
-    private readonly _toolbarNode;
-    private readonly _showStore;
-    private readonly _position;
-    private readonly _minContentWidthInPx;
-    private readonly _stickyScrollHeight;
-    constructor(_editorObs: ObservableCodeEditor, _instaService: IInstantiationService, _keybindingService: IKeybindingService, _logService: ILogService);
+    #private;
+    constructor(editorObs: ObservableCodeEditor, instaService: IInstantiationService, keybindingService: IKeybindingService);
     show(session: IInlineChatSession2): void;
     hide(): void;
 }