@codingame/monaco-vscode-api 11.1.1 → 12.0.0

package/vscode/src/vs/editor/browser/observableCodeEditor.d.ts

@@ -0,0 +1,57 @@
+import { Disposable, IDisposable } from "../../base/common/lifecycle.js";
+import { IObservable, ITransaction } from "../../base/common/observable.js";
+import { EditorOption, FindComputedEditorOptionValueById } from "../common/config/editorOptions.js";
+import { Position } from "../common/core/position.js";
+import { Selection } from "../common/core/selection.js";
+import { ICursorSelectionChangedEvent } from "../common/cursorEvents.js";
+import { IModelDeltaDecoration, ITextModel } from "../common/model.js";
+import { IModelContentChangedEvent } from "../common/textModelEvents.js";
+import { ICodeEditor, IOverlayWidgetPosition } from "./editorBrowser.js";
+export declare function observableCodeEditor(editor: ICodeEditor): ObservableCodeEditor;
+export declare class ObservableCodeEditor extends Disposable {
+    readonly editor: ICodeEditor;
+    private static readonly _map;
+    static get(editor: ICodeEditor): ObservableCodeEditor;
+    private _updateCounter;
+    private _currentTransaction;
+    private _beginUpdate;
+    private _endUpdate;
+    private constructor();
+    forceUpdate(): void;
+    forceUpdate<T>(cb: (tx: ITransaction) => T): T;
+    private _forceUpdate;
+    private readonly _model;
+    readonly model: IObservable<ITextModel | null>;
+    readonly isReadonly: IObservable<boolean, unknown>;
+    private readonly _versionId;
+    readonly versionId: IObservable<number | null, IModelContentChangedEvent | undefined>;
+    private readonly _selections;
+    readonly selections: IObservable<Selection[] | null, ICursorSelectionChangedEvent | undefined>;
+    readonly positions: IObservable<readonly Position[] | null, unknown>;
+    readonly isFocused: IObservable<boolean, unknown>;
+    readonly isTextFocused: IObservable<boolean, unknown>;
+    readonly inComposition: IObservable<boolean, unknown>;
+    readonly value: import("../../base/common/observable.js").ISettableObservable<string, void>;
+    readonly valueIsEmpty: IObservable<boolean, unknown>;
+    readonly cursorSelection: IObservable<Selection | null, unknown>;
+    readonly cursorPosition: IObservable<Position | null, unknown>;
+    readonly cursorLineNumber: IObservable<number | null, unknown>;
+    readonly onDidType: import("../../base/common/observable.js").IObservableSignal<string>;
+    readonly scrollTop: IObservable<number, unknown>;
+    readonly scrollLeft: IObservable<number, unknown>;
+    readonly layoutInfo: IObservable<import("../common/config/editorOptions.js").EditorLayoutInfo, unknown>;
+    readonly layoutInfoContentLeft: IObservable<number, unknown>;
+    readonly layoutInfoDecorationsLeft: IObservable<number, unknown>;
+    readonly contentWidth: IObservable<number, unknown>;
+    getOption<T extends EditorOption>(id: T): IObservable<FindComputedEditorOptionValueById<T>>;
+    setDecorations(decorations: IObservable<IModelDeltaDecoration[]>): IDisposable;
+    private _overlayWidgetCounter;
+    createOverlayWidget(widget: IObservableOverlayWidget): IDisposable;
+}
+interface IObservableOverlayWidget {
+    get domNode(): HTMLElement;
+    readonly position: IObservable<IOverlayWidgetPosition | null>;
+    readonly minContentWidthInPx: IObservable<number>;
+    get allowEditorOverflow(): boolean;
+}
+export {};

package/vscode/src/vs/editor/browser/observableCodeEditor.js

@@ -1,3 +1,4 @@
+
 import { equalsIfDefined, itemsEquals } from '../../base/common/equals.js';
 import { Disposable, DisposableStore, toDisposable } from '../../base/common/lifecycle.js';
 import { observableValueOpts } from '../../base/common/observableInternal/api.js';
@@ -7,6 +8,7 @@ import { derivedOpts, derivedWithSetter, derived } from '../../base/common/obser
 import '../../base/common/cancellation.js';
 import '../../base/common/event.js';
 import { observableFromEvent, observableSignal } from '../../base/common/observableInternal/utils.js';
+import { EditorOption } from '../common/config/editorOptions.js';
 import { Position } from '../common/core/position.js';
 import { Selection } from '../common/core/selection.js';
 
@@ -53,7 +55,7 @@ class ObservableCodeEditor extends Disposable {
         this._currentTransaction = undefined;
         this._model = observableValue(this, this.editor.getModel());
         this.model = this._model;
-        this.isReadonly = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(94 ));
+        this.isReadonly = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(EditorOption.readOnly));
         this._versionId = observableValueOpts({ owner: this, lazy: true }, this.editor.getModel()?.getVersionId() ?? null);
         this.versionId = this._versionId;
         this._selections = observableValueOpts({ owner: this, equalsFn: equalsIfDefined(itemsEquals(Selection.selectionsEqual)), lazy: true }, this.editor.getSelections() ?? null);
@@ -69,6 +71,30 @@ class ObservableCodeEditor extends Disposable {
                 }
             };
         }, () => this.editor.hasWidgetFocus());
+        this.isTextFocused = observableFromEvent(this, e => {
+            const d1 = this.editor.onDidFocusEditorText(e);
+            const d2 = this.editor.onDidBlurEditorText(e);
+            return {
+                dispose() {
+                    d1.dispose();
+                    d2.dispose();
+                }
+            };
+        }, () => this.editor.hasTextFocus());
+        this.inComposition = observableFromEvent(this, e => {
+            const d1 = this.editor.onDidCompositionStart(() => {
+                e(undefined);
+            });
+            const d2 = this.editor.onDidCompositionEnd(() => {
+                e(undefined);
+            });
+            return {
+                dispose() {
+                    d1.dispose();
+                    d2.dispose();
+                }
+            };
+        }, () => this.editor.inComposition);
         this.value = derivedWithSetter(this, reader => { this.versionId.read(reader); return this.model.read(reader)?.getValue() ?? ''; }, (value, tx) => {
             const model = this.model.get();
             if (model !== null) {

package/vscode/src/vs/editor/browser/services/abstractCodeEditorService.d.ts

@@ -0,0 +1,88 @@
+import { Emitter, Event } from "../../../base/common/event.js";
+import { IDisposable, Disposable } from "../../../base/common/lifecycle.js";
+import { URI } from "../../../base/common/uri.js";
+import { ICodeEditor, IDiffEditor } from "../editorBrowser.js";
+import { ICodeEditorOpenHandler, ICodeEditorService } from "./codeEditorService.js";
+import { IDecorationRenderOptions } from "../../common/editorCommon.js";
+import { IModelDecorationOptions, ITextModel } from "../../common/model.js";
+import { IResourceEditorInput } from "../../../platform/editor/common/editor.js";
+import { IThemeService } from "../../../platform/theme/common/themeService.service.js";
+export declare abstract class AbstractCodeEditorService extends Disposable implements ICodeEditorService {
+    private readonly _themeService;
+    readonly _serviceBrand: undefined;
+    private readonly _onWillCreateCodeEditor;
+    readonly onWillCreateCodeEditor: Event<void>;
+    private readonly _onCodeEditorAdd;
+    readonly onCodeEditorAdd: Event<ICodeEditor>;
+    private readonly _onCodeEditorRemove;
+    readonly onCodeEditorRemove: Event<ICodeEditor>;
+    private readonly _onWillCreateDiffEditor;
+    readonly onWillCreateDiffEditor: Event<void>;
+    private readonly _onDiffEditorAdd;
+    readonly onDiffEditorAdd: Event<IDiffEditor>;
+    private readonly _onDiffEditorRemove;
+    readonly onDiffEditorRemove: Event<IDiffEditor>;
+    private readonly _onDidChangeTransientModelProperty;
+    readonly onDidChangeTransientModelProperty: Event<ITextModel>;
+    protected readonly _onDecorationTypeRegistered: Emitter<string>;
+    onDecorationTypeRegistered: Event<string>;
+    private readonly _codeEditors;
+    private readonly _diffEditors;
+    protected _globalStyleSheet: GlobalStyleSheet | null;
+    private readonly _decorationOptionProviders;
+    private readonly _editorStyleSheets;
+    private readonly _codeEditorOpenHandlers;
+    constructor(_themeService: IThemeService);
+    willCreateCodeEditor(): void;
+    addCodeEditor(editor: ICodeEditor): void;
+    removeCodeEditor(editor: ICodeEditor): void;
+    listCodeEditors(): ICodeEditor[];
+    willCreateDiffEditor(): void;
+    addDiffEditor(editor: IDiffEditor): void;
+    removeDiffEditor(editor: IDiffEditor): void;
+    listDiffEditors(): IDiffEditor[];
+    getFocusedCodeEditor(): ICodeEditor | null;
+    private _getOrCreateGlobalStyleSheet;
+    protected _createGlobalStyleSheet(): GlobalStyleSheet;
+    private _getOrCreateStyleSheet;
+    _removeEditorStyleSheets(editorId: string): void;
+    registerDecorationType(description: string, key: string, options: IDecorationRenderOptions, parentTypeKey?: string, editor?: ICodeEditor): IDisposable;
+    listDecorationTypes(): string[];
+    removeDecorationType(key: string): void;
+    resolveDecorationOptions(decorationTypeKey: string, writable: boolean): IModelDecorationOptions;
+    resolveDecorationCSSRules(decorationTypeKey: string): CSSRuleList | null;
+    private readonly _transientWatchers;
+    private readonly _modelProperties;
+    setModelProperty(resource: URI, key: string, value: any): void;
+    getModelProperty(resource: URI, key: string): any;
+    setTransientModelProperty(model: ITextModel, key: string, value: any): void;
+    getTransientModelProperty(model: ITextModel, key: string): any;
+    getTransientModelProperties(model: ITextModel): [
+        string,
+        any
+    ][] | undefined;
+    _removeWatcher(w: ModelTransientSettingWatcher): void;
+    abstract getActiveCodeEditor(): ICodeEditor | null;
+    openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise<ICodeEditor | null>;
+    registerCodeEditorOpenHandler(handler: ICodeEditorOpenHandler): IDisposable;
+}
+export declare class ModelTransientSettingWatcher {
+    readonly uri: string;
+    private readonly _values;
+    constructor(uri: string, model: ITextModel, owner: AbstractCodeEditorService);
+    set(key: string, value: any): void;
+    get(key: string): any;
+    keys(): string[];
+}
+export declare class GlobalStyleSheet {
+    private readonly _styleSheet;
+    get sheet(): CSSStyleSheet;
+    constructor(styleSheet: HTMLStyleElement);
+    ref(): void;
+    unref(): void;
+    insertRule(selector: string, rule: string): void;
+    removeRulesContainingSelector(ruleName: string): void;
+}
+export declare const _CSS_MAP: {
+    [prop: string]: string;
+};

package/vscode/src/vs/editor/browser/services/abstractCodeEditorService.js

@@ -1,5 +1,7 @@
+
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { createStyleSheet, isInShadowDOM, createCSSRule, removeCSSRulesContainingSelector } from '../../../base/browser/dom.js';
+import { isInShadowDOM } from '../../../base/browser/dom.js';
+import { createStyleSheet, createCSSRule, removeCSSRulesContainingSelector } from '../../../base/browser/domStylesheets.js';
 import { asCSSUrl } from '../../../base/browser/cssValue.js';
 import { Emitter } from '../../../base/common/event.js';
 import { Disposable, toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
@@ -301,12 +303,12 @@ class DecorationSubTypeOptionsProvider {
         this._parentTypeKey = providerArgs.parentTypeKey;
         this.refCount = 0;
         this._beforeContentRules = ( new DecorationCSSRules(
-            3 ,
+            ModelDecorationCSSRuleType.BeforeContentClassName,
             providerArgs,
             themeService
         ));
         this._afterContentRules = ( new DecorationCSSRules(
-            4 ,
+            ModelDecorationCSSRuleType.AfterContentClassName,
             providerArgs,
             themeService
         ));
@@ -359,16 +361,16 @@ class DecorationTypeOptionsProvider {
             }
             return null;
         };
-        this.className = createCSSRules(0 );
-        const inlineData = createInlineCSSRules(1 );
+        this.className = createCSSRules(ModelDecorationCSSRuleType.ClassName);
+        const inlineData = createInlineCSSRules(ModelDecorationCSSRuleType.InlineClassName);
         if (inlineData) {
             this.inlineClassName = inlineData.className;
             this.inlineClassNameAffectsLetterSpacing = inlineData.hasLetterSpacing;
         }
-        this.beforeContentClassName = createCSSRules(3 );
-        this.afterContentClassName = createCSSRules(4 );
+        this.beforeContentClassName = createCSSRules(ModelDecorationCSSRuleType.BeforeContentClassName);
+        this.afterContentClassName = createCSSRules(ModelDecorationCSSRuleType.AfterContentClassName);
         if (providerArgs.options.beforeInjectedText && providerArgs.options.beforeInjectedText.contentText) {
-            const beforeInlineData = createInlineCSSRules(5 );
+            const beforeInlineData = createInlineCSSRules(ModelDecorationCSSRuleType.BeforeInjectedTextClassName);
             this.beforeInjectedText = {
                 content: providerArgs.options.beforeInjectedText.contentText,
                 inlineClassName: beforeInlineData?.className,
@@ -376,14 +378,14 @@ class DecorationTypeOptionsProvider {
             };
         }
         if (providerArgs.options.afterInjectedText && providerArgs.options.afterInjectedText.contentText) {
-            const afterInlineData = createInlineCSSRules(6 );
+            const afterInlineData = createInlineCSSRules(ModelDecorationCSSRuleType.AfterInjectedTextClassName);
             this.afterInjectedText = {
                 content: providerArgs.options.afterInjectedText.contentText,
                 inlineClassName: afterInlineData?.className,
                 inlineClassNameAffectsLetterSpacing: afterInlineData?.hasLetterSpacing || providerArgs.options.afterInjectedText.affectsLetterSpacing
             };
         }
-        this.glyphMarginClassName = createCSSRules(2 );
+        this.glyphMarginClassName = createCSSRules(ModelDecorationCSSRuleType.GlyphMarginClassName);
         const options = providerArgs.options;
         this.isWholeLine = Boolean(options.isWholeLine);
         this.stickiness = options.rangeBehavior;
@@ -504,37 +506,37 @@ class DecorationCSSRules {
         const options = this._providerArgs.options;
         let unthemedCSS, lightCSS, darkCSS;
         switch (this._ruleType) {
-            case 0 :
+            case ModelDecorationCSSRuleType.ClassName:
                 unthemedCSS = this.getCSSTextForModelDecorationClassName(options);
                 lightCSS = this.getCSSTextForModelDecorationClassName(options.light);
                 darkCSS = this.getCSSTextForModelDecorationClassName(options.dark);
                 break;
-            case 1 :
+            case ModelDecorationCSSRuleType.InlineClassName:
                 unthemedCSS = this.getCSSTextForModelDecorationInlineClassName(options);
                 lightCSS = this.getCSSTextForModelDecorationInlineClassName(options.light);
                 darkCSS = this.getCSSTextForModelDecorationInlineClassName(options.dark);
                 break;
-            case 2 :
+            case ModelDecorationCSSRuleType.GlyphMarginClassName:
                 unthemedCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options);
                 lightCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options.light);
                 darkCSS = this.getCSSTextForModelDecorationGlyphMarginClassName(options.dark);
                 break;
-            case 3 :
+            case ModelDecorationCSSRuleType.BeforeContentClassName:
                 unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.before);
                 lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.before);
                 darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.before);
                 break;
-            case 4 :
+            case ModelDecorationCSSRuleType.AfterContentClassName:
                 unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.after);
                 lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.after);
                 darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.after);
                 break;
-            case 5 :
+            case ModelDecorationCSSRuleType.BeforeInjectedTextClassName:
                 unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.beforeInjectedText);
                 lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.beforeInjectedText);
                 darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.beforeInjectedText);
                 break;
-            case 6 :
+            case ModelDecorationCSSRuleType.AfterInjectedTextClassName:
                 unthemedCSS = this.getCSSTextForModelDecorationContentClassName(options.afterInjectedText);
                 lightCSS = this.getCSSTextForModelDecorationContentClassName(options.light && options.light.afterInjectedText);
                 darkCSS = this.getCSSTextForModelDecorationContentClassName(options.dark && options.dark.afterInjectedText);
@@ -646,6 +648,16 @@ class DecorationCSSRules {
         return value;
     }
 }
+var ModelDecorationCSSRuleType;
+(function (ModelDecorationCSSRuleType) {
+    ModelDecorationCSSRuleType[ModelDecorationCSSRuleType["ClassName"] = 0] = "ClassName";
+    ModelDecorationCSSRuleType[ModelDecorationCSSRuleType["InlineClassName"] = 1] = "InlineClassName";
+    ModelDecorationCSSRuleType[ModelDecorationCSSRuleType["GlyphMarginClassName"] = 2] = "GlyphMarginClassName";
+    ModelDecorationCSSRuleType[ModelDecorationCSSRuleType["BeforeContentClassName"] = 3] = "BeforeContentClassName";
+    ModelDecorationCSSRuleType[ModelDecorationCSSRuleType["AfterContentClassName"] = 4] = "AfterContentClassName";
+    ModelDecorationCSSRuleType[ModelDecorationCSSRuleType["BeforeInjectedTextClassName"] = 5] = "BeforeInjectedTextClassName";
+    ModelDecorationCSSRuleType[ModelDecorationCSSRuleType["AfterInjectedTextClassName"] = 6] = "AfterInjectedTextClassName";
+})(ModelDecorationCSSRuleType || (ModelDecorationCSSRuleType = {}));
 class CSSNameHelper {
     static getClassName(key, type) {
         return 'ced-' + key + '-' + type;
@@ -655,10 +667,10 @@ class CSSNameHelper {
         if (parentKey) {
             selector = selector + '.' + this.getClassName(parentKey, ruleType);
         }
-        if (ruleType === 3 ) {
+        if (ruleType === ModelDecorationCSSRuleType.BeforeContentClassName) {
             selector += '::before';
         }
-        else if (ruleType === 4 ) {
+        else if (ruleType === ModelDecorationCSSRuleType.AfterContentClassName) {
             selector += '::after';
         }
         return selector;

package/vscode/src/vs/editor/browser/services/bulkEditService.d.ts

@@ -1,18 +1,29 @@
-import { ServiceIdentifier } from '../../../platform/instantiation/common/instantiation.js';
-import { ICodeEditor } from '../editorBrowser.js';
-import { WorkspaceEdit, WorkspaceEditMetadata, IWorkspaceFileEdit, WorkspaceFileEditOptions } from '../../common/languages.js';
-import { IProgress, IProgressStep } from '../../../platform/progress/common/progress.js';
-import { IDisposable } from '../../../base/common/lifecycle.js';
-import { URI } from '../../../base/common/uri.js';
-import { UndoRedoSource } from '../../../platform/undoRedo/common/undoRedo.js';
-import { CancellationToken } from '../../../base/common/cancellation.js';
-
-declare class ResourceEdit {
+import { ICodeEditor } from "../editorBrowser.js";
+import { TextEdit, WorkspaceEdit, WorkspaceEditMetadata, IWorkspaceFileEdit, WorkspaceFileEditOptions, IWorkspaceTextEdit } from "../../common/languages.js";
+import { IProgress, IProgressStep } from "../../../platform/progress/common/progress.js";
+import { IDisposable } from "../../../base/common/lifecycle.js";
+import { URI } from "../../../base/common/uri.js";
+import { UndoRedoSource } from "../../../platform/undoRedo/common/undoRedo.js";
+import { CancellationToken } from "../../../base/common/cancellation.js";
+export declare const IBulkEditService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IBulkEditService>;
+export declare class ResourceEdit {
     readonly metadata?: WorkspaceEditMetadata | undefined;
     protected constructor(metadata?: WorkspaceEditMetadata | undefined);
     static convert(edit: WorkspaceEdit): ResourceEdit[];
 }
-declare class ResourceFileEdit extends ResourceEdit implements IWorkspaceFileEdit {
+export declare class ResourceTextEdit extends ResourceEdit implements IWorkspaceTextEdit {
+    readonly resource: URI;
+    readonly textEdit: TextEdit & {
+        insertAsSnippet?: boolean;
+    };
+    readonly versionId: number | undefined;
+    static is(candidate: any): candidate is IWorkspaceTextEdit;
+    static lift(edit: IWorkspaceTextEdit): ResourceTextEdit;
+    constructor(resource: URI, textEdit: TextEdit & {
+        insertAsSnippet?: boolean;
+    }, versionId?: number | undefined, metadata?: WorkspaceEditMetadata);
+}
+export declare class ResourceFileEdit extends ResourceEdit implements IWorkspaceFileEdit {
     readonly oldResource: URI | undefined;
     readonly newResource: URI | undefined;
     readonly options: WorkspaceFileEditOptions;
@@ -20,7 +31,7 @@ declare class ResourceFileEdit extends ResourceEdit implements IWorkspaceFileEdi
     static lift(edit: IWorkspaceFileEdit): ResourceFileEdit;
     constructor(oldResource: URI | undefined, newResource: URI | undefined, options?: WorkspaceFileEditOptions, metadata?: WorkspaceEditMetadata);
 }
-interface IBulkEditOptions {
+export interface IBulkEditOptions {
     editor?: ICodeEditor;
     progress?: IProgress<IProgressStep>;
     token?: CancellationToken;
@@ -33,18 +44,14 @@ interface IBulkEditOptions {
     confirmBeforeUndo?: boolean;
     respectAutoSaveConfig?: boolean;
 }
-interface IBulkEditResult {
+export interface IBulkEditResult {
     ariaSummary: string;
     isApplied: boolean;
 }
-type IBulkEditPreviewHandler = (edits: ResourceEdit[], options?: IBulkEditOptions) => Promise<ResourceEdit[]>;
-
-declare const IBulkEditService: ServiceIdentifier<IBulkEditService>;
-interface IBulkEditService {
+export type IBulkEditPreviewHandler = (edits: ResourceEdit[], options?: IBulkEditOptions) => Promise<ResourceEdit[]>;
+export interface IBulkEditService {
     readonly _serviceBrand: undefined;
     hasPreviewHandler(): boolean;
     setPreviewHandler(handler: IBulkEditPreviewHandler): IDisposable;
     apply(edit: ResourceEdit[] | WorkspaceEdit, options?: IBulkEditOptions): Promise<IBulkEditResult>;
 }
-
-export { type IBulkEditOptions, type IBulkEditPreviewHandler, type IBulkEditResult, IBulkEditService, ResourceEdit, ResourceFileEdit };

package/vscode/src/vs/editor/browser/services/bulkEditService.js

@@ -1,3 +1,4 @@
+
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 import { URI } from '../../../base/common/uri.js';
 import { isObject } from '../../../base/common/types.js';

package/vscode/src/vs/editor/browser/services/codeEditorService.d.ts

@@ -1,14 +1,12 @@
-import { ServiceIdentifier } from '../../../platform/instantiation/common/instantiation.js';
-import { Event } from '../../../base/common/event.js';
-import { ICodeEditor, IDiffEditor } from '../editorBrowser.js';
-import { IDecorationRenderOptions } from '../../common/editorCommon.js';
-import { ITextModel, IModelDecorationOptions } from '../../common/model.js';
-import { ITextResourceEditorInput } from '../../../platform/editor/common/editor.js';
-import { URI } from '../../../base/common/uri.js';
-import { IDisposable } from '../../../base/common/lifecycle.js';
-
-declare const ICodeEditorService: ServiceIdentifier<ICodeEditorService>;
-interface ICodeEditorService {
+import { Event } from "../../../base/common/event.js";
+import { ICodeEditor, IDiffEditor } from "../editorBrowser.js";
+import { IDecorationRenderOptions } from "../../common/editorCommon.js";
+import { IModelDecorationOptions, ITextModel } from "../../common/model.js";
+import { ITextResourceEditorInput } from "../../../platform/editor/common/editor.js";
+import { URI } from "../../../base/common/uri.js";
+import { IDisposable } from "../../../base/common/lifecycle.js";
+export declare const ICodeEditorService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ICodeEditorService>;
+export interface ICodeEditorService {
     readonly _serviceBrand: undefined;
     readonly onWillCreateCodeEditor: Event<void>;
     readonly onCodeEditorAdd: Event<ICodeEditor>;
@@ -26,9 +24,6 @@ interface ICodeEditorService {
     addDiffEditor(editor: IDiffEditor): void;
     removeDiffEditor(editor: IDiffEditor): void;
     listDiffEditors(): readonly IDiffEditor[];
-    /**
-     * Returns the current focused code editor (if the focus is in the editor or in an editor widget) or null.
-     */
     getFocusedCodeEditor(): ICodeEditor | null;
     registerDecorationType(description: string, key: string, options: IDecorationRenderOptions, parentTypeKey?: string, editor?: ICodeEditor): void;
     listDecorationTypes(): string[];
@@ -39,13 +34,14 @@ interface ICodeEditorService {
     getModelProperty(resource: URI, key: string): any;
     setTransientModelProperty(model: ITextModel, key: string, value: any): void;
     getTransientModelProperty(model: ITextModel, key: string): any;
-    getTransientModelProperties(model: ITextModel): [string, any][] | undefined;
+    getTransientModelProperties(model: ITextModel): [
+        string,
+        any
+    ][] | undefined;
     getActiveCodeEditor(): ICodeEditor | null;
     openCodeEditor(input: ITextResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise<ICodeEditor | null>;
     registerCodeEditorOpenHandler(handler: ICodeEditorOpenHandler): IDisposable;
 }
-interface ICodeEditorOpenHandler {
+export interface ICodeEditorOpenHandler {
     (input: ITextResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise<ICodeEditor | null>;
 }
-
-export { type ICodeEditorOpenHandler, ICodeEditorService };

package/vscode/src/vs/editor/browser/services/codeEditorService.js

@@ -1,3 +1,4 @@
+
 import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
 
 const ICodeEditorService = ( createDecorator('codeEditorService'));

package/vscode/src/vs/editor/browser/services/editorWorkerService.d.ts

@@ -0,0 +1,65 @@
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { URI } from "../../../base/common/uri.js";
+import { Proxied, IWorkerDescriptor } from "../../../base/common/worker/simpleWorker.js";
+import { IRange } from "../../common/core/range.js";
+import * as languages from "../../common/languages.js";
+import { ILanguageConfigurationService } from "../../common/languages/languageConfigurationRegistry.js";
+import { EditorSimpleWorker } from "../../common/services/editorSimpleWorker.js";
+import { DiffAlgorithmName, IEditorWorkerService, IUnicodeHighlightsResult } from "../../common/services/editorWorker.js";
+import { IModelService } from "../../common/services/model.js";
+import { ITextResourceConfigurationService } from "../../common/services/textResourceConfiguration.js";
+import { ILogService } from "../../../platform/log/common/log.service.js";
+import { UnicodeHighlighterOptions } from "../../common/services/unicodeTextModelHighlighter.js";
+import { ILanguageFeaturesService } from "../../common/services/languageFeatures.js";
+import { IChange } from "../../common/diff/legacyLinesDiffComputer.js";
+import { IDocumentDiff, IDocumentDiffProviderOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/editor/common/diff/documentDiffProvider";
+import { SectionHeader, FindSectionHeaderOptions } from "../../common/services/findSectionHeaders.js";
+export declare abstract class EditorWorkerService extends Disposable implements IEditorWorkerService {
+    private readonly _languageConfigurationService;
+    readonly _serviceBrand: undefined;
+    private readonly _modelService;
+    private readonly _workerManager;
+    private readonly _logService;
+    constructor(workerDescriptor: IWorkerDescriptor, modelService: IModelService, configurationService: ITextResourceConfigurationService, logService: ILogService, _languageConfigurationService: ILanguageConfigurationService, languageFeaturesService: ILanguageFeaturesService);
+    dispose(): void;
+    canComputeUnicodeHighlights(uri: URI): boolean;
+    computedUnicodeHighlights(uri: URI, options: UnicodeHighlighterOptions, range?: IRange): Promise<IUnicodeHighlightsResult>;
+    computeDiff(original: URI, modified: URI, options: IDocumentDiffProviderOptions, algorithm: DiffAlgorithmName): Promise<IDocumentDiff | null>;
+    canComputeDirtyDiff(original: URI, modified: URI): boolean;
+    computeDirtyDiff(original: URI, modified: URI, ignoreTrimWhitespace: boolean): Promise<IChange[] | null>;
+    computeMoreMinimalEdits(resource: URI, edits: languages.TextEdit[] | null | undefined, pretty?: boolean): Promise<languages.TextEdit[] | undefined>;
+    computeHumanReadableDiff(resource: URI, edits: languages.TextEdit[] | null | undefined): Promise<languages.TextEdit[] | undefined>;
+    canNavigateValueSet(resource: URI): boolean;
+    navigateValueSet(resource: URI, range: IRange, up: boolean): Promise<languages.IInplaceReplaceSupportResult | null>;
+    canComputeWordRanges(resource: URI): boolean;
+    computeWordRanges(resource: URI, range: IRange): Promise<{
+        [word: string]: IRange[];
+    } | null>;
+    findSectionHeaders(uri: URI, options: FindSectionHeaderOptions): Promise<SectionHeader[]>;
+    computeDefaultDocumentColors(uri: URI): Promise<languages.IColorInformation[] | null>;
+    private _workerWithResources;
+}
+export interface IEditorWorkerClient {
+    fhr(method: string, args: any[]): Promise<any>;
+}
+export declare class EditorWorkerClient extends Disposable implements IEditorWorkerClient {
+    private readonly _workerDescriptor;
+    private readonly _modelService;
+    private readonly _keepIdleModels;
+    private _worker;
+    private _modelManager;
+    private _disposed;
+    constructor(_workerDescriptor: IWorkerDescriptor, keepIdleModels: boolean, modelService: IModelService);
+    fhr(method: string, args: any[]): Promise<any>;
+    private _getOrCreateWorker;
+    protected _getProxy(): Promise<Proxied<EditorSimpleWorker>>;
+    private _createFallbackLocalWorker;
+    private _createEditorWorkerHost;
+    private _getOrCreateModelManager;
+    workerWithSyncedResources(resources: URI[], forceLargeModels?: boolean): Promise<Proxied<EditorSimpleWorker>>;
+    textualSuggest(resources: URI[], leadingWord: string | undefined, wordDefRegExp: RegExp): Promise<{
+        words: string[];
+        duration: number;
+    } | null>;
+    dispose(): void;
+}

package/vscode/src/vs/editor/browser/services/editorWorkerService.js

@@ -1,9 +1,11 @@
+
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { timeout } from '../../../base/common/async.js';
 import { Disposable } from '../../../base/common/lifecycle.js';
 import { logOnceWebWorkerWarning } from '../../../base/common/worker/simpleWorker.js';
 import { createWebWorker } from '../../../base/browser/defaultWorkerFactory.js';
 import { Range } from '../../common/core/range.js';
+import { CompletionItemKind } from '../../common/languages.js';
 import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.js';
 import { EditorSimpleWorker } from '../../common/services/editorSimpleWorker.js';
 import { IModelService } from '../../common/services/model.js';
@@ -220,7 +222,7 @@ class WordBasedCompletionItemProvider {
             duration: data.duration,
             suggestions: ( data.words.map((word) => {
                 return {
-                    kind: 18 ,
+                    kind: CompletionItemKind.Text,
                     label: word,
                     insertText: word,
                     range: { insert, replace }

package/vscode/src/vs/editor/browser/services/hoverService/hover.css.js

@@ -1,6 +1,6 @@
 import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
 
-var css = ".monaco-workbench .workbench-hover{background:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);border-radius:3px;box-shadow:0 2px 8px var(--vscode-widget-shadow);color:var(--vscode-editorHoverWidget-foreground);font-size:13px;line-height:19px;max-width:700px;overflow:hidden;position:relative;z-index:40}.monaco-workbench .workbench-hover hr{border-bottom:none}.monaco-workbench .workbench-hover:not(.skip-fade-in){animation:fadein .1s linear}.monaco-workbench .workbench-hover.compact{font-size:12px}.monaco-workbench .workbench-hover.compact .hover-contents{padding:2px 8px}.monaco-workbench .workbench-hover-container.locked .workbench-hover{outline:1px solid var(--vscode-editorHoverWidget-border)}.monaco-workbench .workbench-hover-container.locked .workbench-hover:focus,.monaco-workbench .workbench-hover-lock:focus{outline:1px solid var(--vscode-focusBorder)}.monaco-workbench .workbench-hover-container.locked .workbench-hover-lock:hover{background:var(--vscode-toolbar-hoverBackground)}.monaco-workbench .workbench-hover-pointer{pointer-events:none;position:absolute;z-index:41}.monaco-workbench .workbench-hover-pointer:after{background-color:var(--vscode-editorHoverWidget-background);border-bottom:1px solid var(--vscode-editorHoverWidget-border);border-right:1px solid var(--vscode-editorHoverWidget-border);content:\"\";height:5px;position:absolute;width:5px}.monaco-workbench .locked .workbench-hover-pointer:after{border-bottom-width:2px;border-right-width:2px;height:4px;width:4px}.monaco-workbench .workbench-hover-pointer.left{left:-3px}.monaco-workbench .workbench-hover-pointer.right{right:3px}.monaco-workbench .workbench-hover-pointer.top{top:-3px}.monaco-workbench .workbench-hover-pointer.bottom{bottom:3px}.monaco-workbench .workbench-hover-pointer.left:after{transform:rotate(135deg)}.monaco-workbench .workbench-hover-pointer.right:after{transform:rotate(315deg)}.monaco-workbench .workbench-hover-pointer.top:after{transform:rotate(225deg)}.monaco-workbench .workbench-hover-pointer.bottom:after{transform:rotate(45deg)}.monaco-workbench .workbench-hover a{color:var(--vscode-textLink-foreground)}.monaco-workbench .workbench-hover a:focus{outline:1px solid;outline-color:var(--vscode-focusBorder);outline-offset:-1px;text-decoration:underline}.monaco-workbench .workbench-hover a:active,.monaco-workbench .workbench-hover a:hover{color:var(--vscode-textLink-activeForeground)}.monaco-workbench .workbench-hover code{background:var(--vscode-textCodeBlock-background)}.monaco-workbench .workbench-hover .hover-row .actions{background:var(--vscode-editorHoverWidget-statusBarBackground)}.monaco-workbench .workbench-hover.right-aligned{left:1px}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions{flex-direction:row-reverse}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions .action-container{margin-left:16px;margin-right:0}";
+var css = ".monaco-workbench .workbench-hover{background:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);border-radius:3px;box-shadow:0 2px 8px var(--vscode-widget-shadow);color:var(--vscode-editorHoverWidget-foreground);font-size:13px;line-height:19px;max-width:700px;overflow:hidden;position:relative;z-index:40}.monaco-workbench .workbench-hover hr{border-bottom:none}.monaco-workbench .workbench-hover.compact{font-size:12px}.monaco-workbench .workbench-hover.compact .hover-contents{padding:2px 8px}.monaco-workbench .workbench-hover-container.locked .workbench-hover{outline:1px solid var(--vscode-editorHoverWidget-border)}.monaco-workbench .workbench-hover-container.locked .workbench-hover:focus,.monaco-workbench .workbench-hover-lock:focus{outline:1px solid var(--vscode-focusBorder)}.monaco-workbench .workbench-hover-container.locked .workbench-hover-lock:hover{background:var(--vscode-toolbar-hoverBackground)}.monaco-workbench .workbench-hover-pointer{pointer-events:none;position:absolute;z-index:41}.monaco-workbench .workbench-hover-pointer:after{background-color:var(--vscode-editorHoverWidget-background);border-bottom:1px solid var(--vscode-editorHoverWidget-border);border-right:1px solid var(--vscode-editorHoverWidget-border);content:\"\";height:5px;position:absolute;width:5px}.monaco-workbench .locked .workbench-hover-pointer:after{border-bottom-width:2px;border-right-width:2px;height:4px;width:4px}.monaco-workbench .workbench-hover-pointer.left{left:-3px}.monaco-workbench .workbench-hover-pointer.right{right:3px}.monaco-workbench .workbench-hover-pointer.top{top:-3px}.monaco-workbench .workbench-hover-pointer.bottom{bottom:3px}.monaco-workbench .workbench-hover-pointer.left:after{transform:rotate(135deg)}.monaco-workbench .workbench-hover-pointer.right:after{transform:rotate(315deg)}.monaco-workbench .workbench-hover-pointer.top:after{transform:rotate(225deg)}.monaco-workbench .workbench-hover-pointer.bottom:after{transform:rotate(45deg)}.monaco-workbench .workbench-hover a{color:var(--vscode-textLink-foreground)}.monaco-workbench .workbench-hover a:focus{outline:1px solid;outline-color:var(--vscode-focusBorder);outline-offset:-1px;text-decoration:underline}.monaco-workbench .workbench-hover a:active,.monaco-workbench .workbench-hover a:hover{color:var(--vscode-textLink-activeForeground)}.monaco-workbench .workbench-hover code{background:var(--vscode-textCodeBlock-background)}.monaco-workbench .workbench-hover .hover-row .actions{background:var(--vscode-editorHoverWidget-statusBarBackground)}.monaco-workbench .workbench-hover.right-aligned{left:1px}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions{flex-direction:row-reverse}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions .action-container{margin-left:16px;margin-right:0}";
 n(css,{});
 
 export { css, css as default };

package/vscode/src/vs/editor/browser/services/hoverService/hoverService.d.ts

@@ -0,0 +1,44 @@
+import { IHoverService } from "../../../../platform/hover/browser/hover.service.js";
+import { IContextMenuService } from "../../../../platform/contextview/browser/contextView.service.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
+import { IKeybindingService } from "../../../../platform/keybinding/common/keybinding.service.js";
+import { IAccessibilityService } from "../../../../platform/accessibility/common/accessibility.service.js";
+import { ILayoutService } from "../../../../platform/layout/browser/layoutService.service.js";
+import type { IHoverLifecycleOptions, IHoverOptions, IHoverWidget, IManagedHover, IManagedHoverContentOrFactory, IManagedHoverOptions } from "../../../../base/browser/ui/hover/hover.js";
+import type { IHoverDelegate } from "../../../../base/browser/ui/hover/hoverDelegate.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+export declare class HoverService extends Disposable implements IHoverService {
+    private readonly _instantiationService;
+    private readonly _configurationService;
+    private readonly _keybindingService;
+    private readonly _layoutService;
+    private readonly _accessibilityService;
+    readonly _serviceBrand: undefined;
+    private _contextViewHandler;
+    private _currentHoverOptions;
+    private _currentHover;
+    private _currentDelayedHover;
+    private _currentDelayedHoverWasShown;
+    private _currentDelayedHoverGroupId;
+    private _lastHoverOptions;
+    private _lastFocusedElementBeforeOpen;
+    constructor(_instantiationService: IInstantiationService, _configurationService: IConfigurationService, contextMenuService: IContextMenuService, _keybindingService: IKeybindingService, _layoutService: ILayoutService, _accessibilityService: IAccessibilityService);
+    showHover(options: IHoverOptions, focus?: boolean, skipLastFocusedUpdate?: boolean, dontShow?: boolean): IHoverWidget | undefined;
+    showDelayedHover(options: IHoverOptions, lifecycleOptions: Pick<IHoverLifecycleOptions, "groupId">): IHoverWidget | undefined;
+    setupDelayedHover(target: HTMLElement, options: (() => Omit<IHoverOptions, "target">) | Omit<IHoverOptions, "target">, lifecycleOptions?: IHoverLifecycleOptions): IDisposable;
+    setupDelayedHoverAtMouse(target: HTMLElement, options: (() => Omit<IHoverOptions, "target" | "position">) | Omit<IHoverOptions, "target" | "position">, lifecycleOptions?: IHoverLifecycleOptions): IDisposable;
+    private _setupDelayedHover;
+    private _createHover;
+    private _showHover;
+    hideHover(): void;
+    private doHideHover;
+    private _intersectionChange;
+    showAndFocusLastHover(): void;
+    private _keyDown;
+    private _keyUp;
+    private readonly _managedHovers;
+    setupManagedHover(hoverDelegate: IHoverDelegate, targetElement: HTMLElement, content: IManagedHoverContentOrFactory, options?: IManagedHoverOptions | undefined): IManagedHover;
+    showManagedHover(target: HTMLElement): void;
+    dispose(): void;
+}