@codingame/monaco-vscode-api 31.0.1 → 32.0.1

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorDiffInput.js

@@ -0,0 +1,428 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { localize } from '../../../../nls.js';
+import { IFileDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { IUndoRedoService } from '../../../../platform/undoRedo/common/undoRedo.service.js';
+import { EditorInputCapabilities, isEditorInput, isResourceDiffEditorInput, isResourceEditorInput } from '../../../common/editor.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.service.js';
+import { ITextEditorService } from '../../../services/textfile/common/textEditorService.service.js';
+import { ICustomEditorService } from '../common/customEditor.service.js';
+import { IWebviewService } from '../../webview/browser/webview.service.js';
+import { LazilyResolvedWebviewEditorInput } from '../../webviewPanel/browser/webviewWorkbenchService.js';
+import { IWebviewWorkbenchService } from '../../webviewPanel/browser/webviewWorkbenchService.service.js';
+
+var CustomEditorDiffInput_1, CustomEditorSideBySideDiffInput_1;
+let CustomEditorDiffInput = class CustomEditorDiffInput extends LazilyResolvedWebviewEditorInput {
+    static {
+        CustomEditorDiffInput_1 = this;
+    }
+    static create(instantiationService, init, group) {
+        return instantiationService.invokeFunction(accessor => {
+            const textEditorService = accessor.get(ITextEditorService);
+            const original = textEditorService.createTextEditor({
+                resource: init.originalResource
+            });
+            const modified = textEditorService.createTextEditor({
+                resource: init.modifiedResource
+            });
+            const webview = accessor.get(IWebviewService).createWebviewOverlay({
+                providedViewType: init.viewType,
+                title: init.label,
+                options: {},
+                contentOptions: {},
+                extension: undefined
+            });
+            const input = instantiationService.createInstance(CustomEditorDiffInput_1, init, original, modified, webview);
+            if (group) {
+                input.updateGroup(group.id);
+            }
+            return input;
+        });
+    }
+    static {
+        this.typeId = "workbench.editors.customDiffEditor";
+    }
+    constructor(
+        init,
+        original,
+        modified,
+        webview,
+        themeService,
+        webviewWorkbenchService,
+        instantiationService,
+        customEditorService,
+        filesConfigurationService,
+        fileDialogService,
+        undoRedoService
+    ) {
+        super({
+            providedId: init.viewType,
+            viewType: init.viewType,
+            name: init.label ?? "",
+            iconPath: init.iconPath
+        }, webview, themeService, webviewWorkbenchService);
+        this.init = init;
+        this.original = original;
+        this.modified = modified;
+        this.instantiationService = instantiationService;
+        this.customEditorService = customEditorService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.fileDialogService = fileDialogService;
+        this.undoRedoService = undoRedoService;
+        this._register(
+            this.filesConfigurationService.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire())
+        );
+    }
+    dispose() {
+        this.original.dispose();
+        this.modified.dispose();
+        super.dispose();
+    }
+    get typeId() {
+        return CustomEditorDiffInput_1.typeId;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = EditorInputCapabilities.Singleton | EditorInputCapabilities.CanDropIntoEditor;
+        if (this.isReadonly()) {
+            capabilities |= EditorInputCapabilities.Readonly;
+        }
+        return capabilities;
+    }
+    get resource() {
+        return this.modifiedResource;
+    }
+    get originalResource() {
+        return this.init.originalResource;
+    }
+    get modifiedResource() {
+        return this.init.modifiedResource;
+    }
+    getName() {
+        return this.init.label ?? ( localize(8480, "{0} - {1}", this.original.getName(), this.modified.getName()));
+    }
+    getDescription(_verbosity) {
+        return this.init.description ?? super.getDescription();
+    }
+    getTitle(verbosity) {
+        const description = this.getDescription(verbosity);
+        if (description) {
+            return localize(8481, "{0} ({1})", this.getName(), description);
+        }
+        return this.getName();
+    }
+    isReadonly() {
+        if (!this._modelRef) {
+            return this.filesConfigurationService.isReadonly(this.modifiedResource);
+        }
+        return this._modelRef.object.isReadonly();
+    }
+    isDirty() {
+        return this._modelRef?.object.isDirty() ?? false;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof CustomEditorDiffInput_1) {
+            return this.viewType === otherInput.viewType && isEqual(this.originalResource, otherInput.originalResource) && isEqual(this.modifiedResource, otherInput.modifiedResource);
+        }
+        if (isEditorInput(otherInput)) {
+            return false;
+        }
+        if (isResourceDiffEditorInput(otherInput)) {
+            const override = otherInput.options?.override;
+            return override === this.viewType && isEqual(this.originalResource, otherInput.original.resource) && isEqual(this.modifiedResource, otherInput.modified.resource);
+        }
+        return false;
+    }
+    copy() {
+        return CustomEditorDiffInput_1.create(this.instantiationService, this.init, undefined);
+    }
+    async save(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const target = await this._modelRef.object.saveCustomEditor(options);
+        if (!target) {
+            return undefined;
+        }
+        if (!isEqual(target, this.modifiedResource)) {
+            return this.toUntypedWithModifiedResource(target);
+        }
+        return this;
+    }
+    async saveAs(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const target = await this.fileDialogService.pickFileToSave(this.modifiedResource, options?.availableFileSystems);
+        if (!target) {
+            return undefined;
+        }
+        if (!(await this._modelRef.object.saveCustomEditorAs(this.modifiedResource, target, options))) {
+            return undefined;
+        }
+        return this.toUntypedWithModifiedResource(target);
+    }
+    async revert(group, options) {
+        await this._modelRef?.object.revert(options);
+    }
+    async resolve() {
+        await super.resolve();
+        if (this.isDisposed()) {
+            return null;
+        }
+        if (!this._modelRef) {
+            const modelRef = this.customEditorService.models.tryRetain(this.modifiedResource, this.viewType);
+            if (modelRef) {
+                const oldCapabilities = this.capabilities;
+                this._modelRef = this._register(await modelRef);
+                this._register(
+                    this._modelRef.object.onDidChangeDirty(() => this._onDidChangeDirty.fire())
+                );
+                this._register(
+                    this._modelRef.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire())
+                );
+                if (this.isDirty()) {
+                    this._onDidChangeDirty.fire();
+                }
+                if (this.capabilities !== oldCapabilities) {
+                    this._onDidChangeCapabilities.fire();
+                }
+            }
+        }
+        return null;
+    }
+    undo() {
+        return this.undoRedoService.undo(this.modifiedResource);
+    }
+    redo() {
+        return this.undoRedoService.redo(this.modifiedResource);
+    }
+    toUntyped(_options) {
+        return this.toUntypedWithModifiedResource(this.modifiedResource);
+    }
+    toUntypedWithModifiedResource(modifiedResource) {
+        return {
+            original: {
+                resource: this.originalResource
+            },
+            modified: {
+                resource: modifiedResource
+            },
+            label: this.init.label,
+            description: this.init.description,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+};
+CustomEditorDiffInput = CustomEditorDiffInput_1 = ( __decorate([( __param(4, IThemeService)), ( __param(5, IWebviewWorkbenchService)), ( __param(6, IInstantiationService)), ( __param(7, ICustomEditorService)), ( __param(8, IFilesConfigurationService)), ( __param(9, IFileDialogService)), ( __param(10, IUndoRedoService))], CustomEditorDiffInput));
+let CustomEditorSideBySideDiffInput = class CustomEditorSideBySideDiffInput extends LazilyResolvedWebviewEditorInput {
+    static {
+        CustomEditorSideBySideDiffInput_1 = this;
+    }
+    static create(instantiationService, init, group) {
+        return instantiationService.invokeFunction(accessor => {
+            const textEditorService = accessor.get(ITextEditorService);
+            const sideInput = textEditorService.createTextEditor({
+                resource: init.side === "original" ? init.originalResource : init.modifiedResource
+            });
+            const webview = accessor.get(IWebviewService).createWebviewOverlay({
+                providedViewType: init.viewType,
+                title: sideInput.getName(),
+                options: {},
+                contentOptions: {},
+                extension: undefined
+            });
+            const input = instantiationService.createInstance(CustomEditorSideBySideDiffInput_1, init, sideInput, webview);
+            if (group) {
+                input.updateGroup(group.id);
+            }
+            return input;
+        });
+    }
+    static {
+        this.typeId = "workbench.editors.customSideBySideDiffEditor";
+    }
+    constructor(
+        init,
+        sideInput,
+        webview,
+        themeService,
+        webviewWorkbenchService,
+        instantiationService,
+        customEditorService,
+        filesConfigurationService,
+        fileDialogService,
+        undoRedoService
+    ) {
+        super({
+            providedId: init.viewType,
+            viewType: init.viewType,
+            name: sideInput.getName(),
+            iconPath: init.iconPath
+        }, webview, themeService, webviewWorkbenchService);
+        this.init = init;
+        this.sideInput = sideInput;
+        this.instantiationService = instantiationService;
+        this.customEditorService = customEditorService;
+        this.filesConfigurationService = filesConfigurationService;
+        this.fileDialogService = fileDialogService;
+        this.undoRedoService = undoRedoService;
+        this._register(
+            this.filesConfigurationService.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire())
+        );
+    }
+    dispose() {
+        this.sideInput.dispose();
+        super.dispose();
+    }
+    get typeId() {
+        return CustomEditorSideBySideDiffInput_1.typeId;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = EditorInputCapabilities.Singleton | EditorInputCapabilities.CanDropIntoEditor;
+        if (this.isReadonly()) {
+            capabilities |= EditorInputCapabilities.Readonly;
+        }
+        return capabilities;
+    }
+    get resource() {
+        return this.side === "original" ? this.originalResource : this.modifiedResource;
+    }
+    get originalResource() {
+        return this.init.originalResource;
+    }
+    get modifiedResource() {
+        return this.init.modifiedResource;
+    }
+    get side() {
+        return this.init.side;
+    }
+    get diffId() {
+        return this.init.diffId;
+    }
+    getName() {
+        return this.sideInput.getName();
+    }
+    getDescription(verbosity) {
+        return this.sideInput.getDescription(verbosity);
+    }
+    getTitle(verbosity) {
+        return this.sideInput.getTitle(verbosity);
+    }
+    isReadonly() {
+        if (this.side === "original") {
+            return true;
+        }
+        if (!this._modelRef) {
+            return this.filesConfigurationService.isReadonly(this.modifiedResource);
+        }
+        return this._modelRef.object.isReadonly();
+    }
+    isDirty() {
+        return this.side === "modified" ? this._modelRef?.object.isDirty() ?? false : false;
+    }
+    matches(otherInput) {
+        if (this === otherInput) {
+            return true;
+        }
+        if (otherInput instanceof CustomEditorSideBySideDiffInput_1) {
+            return this.editorId === otherInput.editorId && this.side === otherInput.side && isEqual(this.originalResource, otherInput.originalResource) && isEqual(this.modifiedResource, otherInput.modifiedResource);
+        }
+        if (isEditorInput(otherInput)) {
+            return false;
+        }
+        if (isResourceEditorInput(otherInput)) {
+            return isEqual(this.resource, otherInput.resource);
+        }
+        return false;
+    }
+    copy() {
+        return CustomEditorSideBySideDiffInput_1.create(this.instantiationService, this.init, undefined);
+    }
+    async save(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const target = await this._modelRef.object.saveCustomEditor(options);
+        if (!target) {
+            return undefined;
+        }
+        if (!isEqual(target, this.modifiedResource)) {
+            return {
+                resource: target
+            };
+        }
+        return this;
+    }
+    async saveAs(groupId, options) {
+        if (!this._modelRef) {
+            return undefined;
+        }
+        const target = await this.fileDialogService.pickFileToSave(this.modifiedResource, options?.availableFileSystems);
+        if (!target) {
+            return undefined;
+        }
+        if (!(await this._modelRef.object.saveCustomEditorAs(this.modifiedResource, target, options))) {
+            return undefined;
+        }
+        return {
+            resource: target
+        };
+    }
+    async revert(group, options) {
+        await this._modelRef?.object.revert(options);
+    }
+    async resolve() {
+        await super.resolve();
+        if (this.isDisposed()) {
+            return null;
+        }
+        if (this.side === "modified" && !this._modelRef) {
+            const modelRef = this.customEditorService.models.tryRetain(this.modifiedResource, this.viewType);
+            if (modelRef) {
+                const oldCapabilities = this.capabilities;
+                this._modelRef = this._register(await modelRef);
+                this._register(
+                    this._modelRef.object.onDidChangeDirty(() => this._onDidChangeDirty.fire())
+                );
+                this._register(
+                    this._modelRef.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire())
+                );
+                if (this.isDirty()) {
+                    this._onDidChangeDirty.fire();
+                }
+                if (this.capabilities !== oldCapabilities) {
+                    this._onDidChangeCapabilities.fire();
+                }
+            }
+        }
+        return null;
+    }
+    undo() {
+        return this.undoRedoService.undo(this.modifiedResource);
+    }
+    redo() {
+        return this.undoRedoService.redo(this.modifiedResource);
+    }
+    toUntyped(_options) {
+        return {
+            resource: this.resource
+        };
+    }
+};
+CustomEditorSideBySideDiffInput = CustomEditorSideBySideDiffInput_1 = ( __decorate([( __param(3, IThemeService)), ( __param(4, IWebviewWorkbenchService)), ( __param(5, IInstantiationService)), ( __param(6, ICustomEditorService)), ( __param(7, IFilesConfigurationService)), ( __param(8, IFileDialogService)), ( __param(9, IUndoRedoService))], CustomEditorSideBySideDiffInput));
+
+export { CustomEditorDiffInput, CustomEditorSideBySideDiffInput };

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInput.d.ts

@@ -25,6 +25,7 @@ interface CustomEditorInputInitInfo {
     readonly resource: URI;
     readonly viewType: string;
     readonly webviewTitle: string | undefined;
+    readonly preferredName: string | undefined;
     readonly iconPath: WebviewIconPath | undefined;
 }
 export declare class CustomEditorInput extends LazilyResolvedWebviewEditorInput {

package/vscode/src/vs/workbench/contrib/customEditor/browser/customEditorInput.js

@@ -36,7 +36,6 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
             const untitledTextModel = untitledTextEditorService.get(init.resource);
             const untitledString = untitledTextModel?.textEditorModel?.getValue();
             const untitledDocumentData = untitledString ? VSBuffer.fromString(untitledString) : undefined;
-            untitledTextModel?.revert();
             const webview = accessor.get(IWebviewService).createWebviewOverlay({
                 providedViewType: init.viewType,
                 title: init.webviewTitle,
@@ -82,7 +81,7 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
         super({
             providedId: init.viewType,
             viewType: init.viewType,
-            name: "",
+            name: init.preferredName ?? "",
             iconPath: init.iconPath
         }, webview, themeService, webviewWorkbenchService);
         this.instantiationService = instantiationService;
@@ -149,14 +148,8 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
         if (!this.customEditorService.getCustomEditorCapabilities(this.viewType)?.supportsMultipleEditorsPerDocument) {
             capabilities |= EditorInputCapabilities.Singleton;
         }
-        if (this._modelRef) {
-            if (this._modelRef.object.isReadonly()) {
-                capabilities |= EditorInputCapabilities.Readonly;
-            }
-        } else {
-            if (this.filesConfigurationService.isReadonly(this.resource)) {
-                capabilities |= EditorInputCapabilities.Readonly;
-            }
+        if (this.isReadonly()) {
+            capabilities |= EditorInputCapabilities.Readonly;
         }
         if (this.resource.scheme === Schemas.untitled) {
             capabilities |= EditorInputCapabilities.Untitled;
@@ -236,6 +229,7 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
             resource: this.resource,
             viewType: this.viewType,
             webviewTitle: this.getWebviewTitle(),
+            preferredName: undefined,
             iconPath: this.iconPath
         }, this.group, this.webview.options);
     }
@@ -361,11 +355,11 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
     claim(claimant, targetWindow, scopedContextKeyService) {
         if (this.doCanMove(targetWindow.vscodeWindowId) !== true) {
             throw createEditorOpenError(( localize(
-                8138,
+                8482,
                 "Unable to open the editor in this window, it contains modifications that can only be saved in the original window."
             )), [toAction({
                 id: "openInOriginalWindow",
-                label: ( localize(8139, "Open in Original Window")),
+                label: ( localize(8483, "Open in Original Window")),
                 run: async () => {
                     const originalPart = this.editorGroupsService.getPart(this.layoutService.getContainer(getWindow(this.webview.container).window));
                     const currentPart = this.editorGroupsService.getPart(this.layoutService.getContainer(targetWindow.window));
@@ -392,7 +386,7 @@ let CustomEditorInput = class CustomEditorInput extends LazilyResolvedWebviewEdi
             const sourceWindowId = getWindow(this.webview.container).vscodeWindowId;
             if (sourceWindowId !== targetWindowId) {
                 return localize(
-                    8140,
+                    8484,
                     "Unable to move '{0}': The editor contains changes that can only be saved in its current window.",
                     this.getName()
                 );

package/vscode/src/vs/workbench/contrib/debug/browser/baseDebugView.js

@@ -94,7 +94,7 @@ let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
         const lazyButton = append(expression, $("span.lazy-button"));
         lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
         templateDisposable.add(
-            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), lazyButton, ( localize(8156, "Click to expand")))
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), lazyButton, ( localize(8506, "Click to expand")))
         );
         const type = append(expression, $("span.type"));
         const value = append(expression, $("span.value"));