@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/contrib/files/common/explorerModel.js

@@ -12,7 +12,7 @@ import { basenameOrAuthority, isEqualOrParent, joinPath } from 'monaco-editor/es
 import { ExplorerFileNestingTrie } from './explorerFileNestingTrie.js';
 import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
 class ExplorerModel {
-    constructor(contextService, uriIdentityService, fileService, configService) {
+    constructor(contextService, uriIdentityService, fileService, configService, filesConfigService) {
         this.contextService = contextService;
         this.uriIdentityService = uriIdentityService;
         this._onDidChangeRoots = ( new Emitter());
@@ -21,10 +21,12 @@ class ExplorerModel {
             folder.uri,
             fileService,
             configService,
+            filesConfigService,
             undefined,
             true,
             false,
             false,
+            false,
             folder.name
         ))));
         setRoots();
@@ -57,14 +59,16 @@ class ExplorerModel {
     }
 }
 class ExplorerItem {
-    constructor(resource, fileService, configService, _parent, _isDirectory, _isSymbolicLink, _readonly, _name = basenameOrAuthority(resource), _mtime, _unknown = false) {
+    constructor(resource, fileService, configService, filesConfigService, _parent, _isDirectory, _isSymbolicLink, _readonly, _locked, _name = basenameOrAuthority(resource), _mtime, _unknown = false) {
         this.resource = resource;
         this.fileService = fileService;
         this.configService = configService;
+        this.filesConfigService = filesConfigService;
         this._parent = _parent;
         this._isDirectory = _isDirectory;
         this._isSymbolicLink = _isSymbolicLink;
         this._readonly = _readonly;
+        this._locked = _locked;
         this._name = _name;
         this._mtime = _mtime;
         this._unknown = _unknown;
@@ -105,7 +109,7 @@ class ExplorerItem {
         return !!this._isDirectory;
     }
     get isReadonly() {
-        return this._readonly || this.fileService.hasCapability(this.resource, 2048 );
+        return this.filesConfigService.isReadonly(this.resource, { resource: this.resource, name: this.name, readonly: this._readonly, locked: this._locked });
     }
     get mtime() {
         return this._mtime;
@@ -142,15 +146,17 @@ class ExplorerItem {
     get isRoot() {
         return this === this.root;
     }
-    static create(fileService, configService, raw, parent, resolveTo) {
+    static create(fileService, configService, filesConfigService, raw, parent, resolveTo) {
         const stat = ( new ExplorerItem(
             raw.resource,
             fileService,
             configService,
+            filesConfigService,
             parent,
             raw.isDirectory,
             raw.isSymbolicLink,
             raw.readonly,
+            raw.locked,
             raw.name,
             raw.mtime,
             !raw.isFile && !raw.isDirectory
@@ -161,7 +167,7 @@ class ExplorerItem {
             })));
             if (raw.children) {
                 for (let i = 0, len = raw.children.length; i < len; i++) {
-                    const child = ExplorerItem.create(fileService, configService, raw.children[i], stat, resolveTo);
+                    const child = ExplorerItem.create(fileService, configService, filesConfigService, raw.children[i], stat, resolveTo);
                     stat.addChild(child);
                 }
             }
@@ -228,7 +234,7 @@ class ExplorerItem {
                 this.error = undefined;
                 try {
                     const stat = await this.fileService.resolve(this.resource, { resolveSingleChildDescendants: true, resolveMetadata });
-                    const resolved = ExplorerItem.create(this.fileService, this.configService, stat, this);
+                    const resolved = ExplorerItem.create(this.fileService, this.configService, this.filesConfigService, stat, this);
                     ExplorerItem.mergeLocalWithDisk(resolved, this);
                 }
                 catch (e) {
@@ -285,7 +291,8 @@ class ExplorerItem {
                 .filter(entry => typeof (entry[0]) === 'string' && typeof (entry[1]) === 'string' && entry[0] && entry[1])
                 .map(([parentPattern, childrenPatterns]) => [
                 this.getPlatformAwareName(parentPattern.trim()),
-                ( childrenPatterns.split(',').map(p => this.getPlatformAwareName(p.trim().replace(/\u200b/g, ''))))
+                ( childrenPatterns.split(',').map(p => this.getPlatformAwareName(p.trim().replace(/\u200b/g, '').trim())))
+                    .filter(p => p !== '')
             ]));
             this.root._fileNester = ( new ExplorerFileNestingTrie(patterns));
         }
@@ -361,8 +368,8 @@ ExplorerItem.__decorator = ( __decorate([
     memoize
 ], ExplorerItem.prototype, "children", null));
 class NewExplorerItem extends ExplorerItem {
-    constructor(fileService, configService, parent, isDirectory) {
-        super(URI.file(''), fileService, configService, parent, isDirectory);
+    constructor(fileService, configService, filesConfigService, parent, isDirectory) {
+        super(URI.file(''), fileService, configService, filesConfigService, parent, isDirectory);
         this._isDirectoryResolved = true;
     }
 }

package/dist/vscode/vs/workbench/contrib/files/common/files.js

@@ -63,11 +63,7 @@ const ExplorerResourceMoveableToTrash = ( new RawContextKey(
     )) }
 ));
 const FilesExplorerFocusedContext = ( new RawContextKey('filesExplorerFocus', true, { type: 'boolean', description: ( localize('filesExplorerFocus', "True when the focus is inside the EXPLORER view.")) }));
-const OpenEditorsVisibleContext = ( new RawContextKey(
-    'openEditorsVisible',
-    false,
-    { type: 'boolean', description: ( localize('openEditorsVisible', "True when the OPEN EDITORS view is visible.")) }
-));
+const OpenEditorsFocusedContext = ( new RawContextKey('openEditorsFocus', true, { type: 'boolean', description: ( localize('openEditorsFocus', "True when the focus is inside the OPEN EDITORS view.")) }));
 const ExplorerFocusedContext = ( new RawContextKey(
     'explorerViewletFocus',
     true,
@@ -220,4 +216,4 @@ class OpenEditor {
     }
 }
 OpenEditor.COUNTER = 0;
-export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceNotReadonlyContext, ExplorerResourceReadonlyContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, OpenEditor, OpenEditorsVisibleContext, TEXT_FILE_EDITOR_ID, TextFileContentProvider, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };
+export { BINARY_FILE_EDITOR_ID, BINARY_TEXT_FILE_MODE, ExplorerCompressedFirstFocusContext, ExplorerCompressedFocusContext, ExplorerCompressedLastFocusContext, ExplorerFocusCondition, ExplorerFocusedContext, ExplorerFolderContext, ExplorerResourceAvailableEditorIdsContext, ExplorerResourceCut, ExplorerResourceMoveableToTrash, ExplorerResourceNotReadonlyContext, ExplorerResourceReadonlyContext, ExplorerRootContext, ExplorerViewletVisibleContext, FILE_EDITOR_INPUT_ID, FilesExplorerFocusCondition, FilesExplorerFocusedContext, FoldersViewVisibleContext, OpenEditor, OpenEditorsFocusedContext, TEXT_FILE_EDITOR_ID, TextFileContentProvider, VIEWLET_ID, VIEW_ID, ViewHasSomeCollapsibleRootItemContext };

package/dist/vscode/vs/workbench/contrib/interactive/browser/interactiveDocumentService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IInteractiveDocumentService = ( createDecorator('IInteractiveDocumentService'));
+export { IInteractiveDocumentService };

package/dist/vscode/vs/workbench/contrib/interactive/browser/interactiveEditorInput.js

@@ -0,0 +1,200 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { IInteractiveDocumentService } from './interactiveDocumentService.js';
+import { IInteractiveHistoryService } from './interactiveHistoryService.js';
+import { NotebookEditorInput } from '../../../../../../override/vs/workbench/contrib/notebook/common/notebookEditorInput.js';
+let InteractiveEditorInput = class InteractiveEditorInput extends EditorInput {
+    static create(instantiationService, resource, inputResource, title) {
+        return instantiationService.createInstance(InteractiveEditorInput, resource, inputResource, title);
+    }
+    get editorId() {
+        return 'interactive';
+    }
+    get typeId() {
+        return InteractiveEditorInput.ID;
+    }
+    get notebookEditorInput() {
+        return this._notebookEditorInput;
+    }
+    get editorInputs() {
+        return [this._notebookEditorInput];
+    }
+    get resource() {
+        return this._resource;
+    }
+    get inputResource() {
+        return this._inputResource;
+    }
+    get primary() {
+        return this._notebookEditorInput;
+    }
+    constructor(resource, inputResource, title, instantiationService, textModelService, interactiveDocumentService, historyService) {
+        const input = NotebookEditorInput.create(instantiationService, resource, 'interactive', {});
+        super();
+        this._notebookEditorInput = input;
+        this._register(this._notebookEditorInput);
+        this._initTitle = title;
+        this._resource = resource;
+        this._inputResource = inputResource;
+        this._inputResolver = null;
+        this._editorModelReference = null;
+        this._inputModelRef = null;
+        this._textModelService = textModelService;
+        this._interactiveDocumentService = interactiveDocumentService;
+        this._historyService = historyService;
+        this._registerListeners();
+    }
+    _registerListeners() {
+        const oncePrimaryDisposed = Event.once(this.primary.onWillDispose);
+        this._register(oncePrimaryDisposed(() => {
+            if (!this.isDisposed()) {
+                this.dispose();
+            }
+        }));
+        this._register(this.primary.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+        this._register(this.primary.onDidChangeLabel(() => this._onDidChangeLabel.fire()));
+        this._register(this.primary.onDidChangeCapabilities(() => this._onDidChangeCapabilities.fire()));
+    }
+    isDirty() {
+        return false;
+    }
+    async _resolveEditorModel() {
+        if (!this._editorModelReference) {
+            this._editorModelReference = await this._notebookEditorInput.resolve();
+        }
+        return this._editorModelReference;
+    }
+    async resolve() {
+        if (this._editorModelReference) {
+            return this._editorModelReference;
+        }
+        if (this._inputResolver) {
+            return this._inputResolver;
+        }
+        this._inputResolver = this._resolveEditorModel().then(editorModel => {
+            if (this._data) {
+                editorModel?.notebook.reset(( this._data.notebookData.cells.map((cell) => deserializeCell(cell))), this._data.notebookData.metadata, this._data.notebookData.transientOptions);
+            }
+            return editorModel;
+        });
+        return this._inputResolver;
+    }
+    async resolveInput(language) {
+        if (this._inputModelRef) {
+            return this._inputModelRef.object.textEditorModel;
+        }
+        this._interactiveDocumentService.willCreateInteractiveDocument(this.resource, this.inputResource, language);
+        this._inputModelRef = await this._textModelService.createModelReference(this.inputResource);
+        if (this._data && this._data.inputData) {
+            this._inputModelRef.object.textEditorModel.setValue(this._data.inputData.value);
+        }
+        return this._inputModelRef.object.textEditorModel;
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof InteractiveEditorInput) {
+            return isEqual(this.resource, otherInput.resource) && isEqual(this.inputResource, otherInput.inputResource);
+        }
+        return false;
+    }
+    getName() {
+        if (this._initTitle) {
+            return this._initTitle;
+        }
+        const p = this.primary.resource.path;
+        const basename = path.basename(p);
+        return basename.substr(0, basename.length - path.extname(p).length);
+    }
+    getSerialization() {
+        return {
+            notebookData: this._serializeNotebook(this._editorModelReference?.notebook),
+            inputData: this._inputModelRef ? {
+                value: this._inputModelRef.object.textEditorModel.getValue(),
+                language: this._inputModelRef.object.textEditorModel.getLanguageId()
+            } : undefined
+        };
+    }
+    async restoreSerialization(data) {
+        this._data = data;
+    }
+    _serializeNotebook(notebook) {
+        if (!notebook) {
+            return undefined;
+        }
+        const cells = ( notebook.cells.map(cell => serializeCell(cell)));
+        return {
+            cells: cells,
+            metadata: notebook.metadata,
+            transientOptions: notebook.transientOptions
+        };
+    }
+    dispose() {
+        this._editorModelReference?.revert({ soft: true });
+        this._notebookEditorInput?.dispose();
+        this._editorModelReference?.dispose();
+        this._editorModelReference = null;
+        this._interactiveDocumentService.willRemoveInteractiveDocument(this.resource, this.inputResource);
+        this._inputModelRef?.dispose();
+        this._inputModelRef = null;
+        super.dispose();
+    }
+    get historyService() {
+        return this._historyService;
+    }
+};
+InteractiveEditorInput.ID = 'workbench.input.interactive';
+InteractiveEditorInput = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ITextModelService)),
+    ( __param(5, IInteractiveDocumentService)),
+    ( __param(6, IInteractiveHistoryService))
+], InteractiveEditorInput));
+function serializeCell(cell) {
+    return {
+        cellKind: cell.cellKind,
+        language: cell.language,
+        metadata: cell.metadata,
+        mime: cell.mime,
+        outputs: ( cell.outputs.map(output => serializeCellOutput(output))),
+        source: cell.getValue()
+    };
+}
+function deserializeCell(cell) {
+    return {
+        cellKind: cell.cellKind,
+        source: cell.source,
+        language: cell.language,
+        metadata: cell.metadata,
+        mime: cell.mime,
+        outputs: ( cell.outputs.map((output) => deserializeCellOutput(output)))
+    };
+}
+function serializeCellOutput(output) {
+    return {
+        outputId: output.outputId,
+        outputs: ( output.outputs.map(ot => ({
+            mime: ot.mime,
+            data: ot.data.buffer ? Array.from(ot.data.buffer) : []
+        }))),
+        metadata: output.metadata
+    };
+}
+function deserializeCellOutput(output) {
+    return {
+        outputId: output.outputId,
+        outputs: ( output.outputs.map(ot => ({
+            mime: ot.mime,
+            data: VSBuffer.fromByteArray(ot.data)
+        }))),
+        metadata: output.metadata
+    };
+}
+export { InteractiveEditorInput };

package/dist/vscode/vs/workbench/contrib/interactive/browser/interactiveHistoryService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IInteractiveHistoryService = ( createDecorator('IInteractiveHistoryService'));
+export { IInteractiveHistoryService };