@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js

@@ -0,0 +1,220 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { newWriteableStream } from 'monaco-editor/esm/vs/base/common/stream.js';
+import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+class File {
+    constructor(name) {
+        this.type = FileType.File;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+    }
+}
+class Directory {
+    constructor(name) {
+        this.type = FileType.Directory;
+        this.ctime = Date.now();
+        this.mtime = Date.now();
+        this.size = 0;
+        this.name = name;
+        this.entries = ( new Map());
+    }
+}
+class InMemoryFileSystemProvider extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.memoryFdCounter = 0;
+        this.fdMemory = ( new Map());
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this._capabilities = 2  | 1024 ;
+        this.root = ( new Directory(''));
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+        this._bufferedChanges = [];
+    }
+    get capabilities() { return this._capabilities; }
+    setReadOnly(readonly) {
+        const isReadonly = !!((this._capabilities & 2048) );
+        if (readonly !== isReadonly) {
+            this._capabilities = readonly ? 2048  | 1024  | 2
+                : 2  | 1024 ;
+            this._onDidChangeCapabilities.fire();
+        }
+    }
+    async stat(resource) {
+        return this._lookup(resource, false);
+    }
+    async readdir(resource) {
+        const entry = this._lookupAsDirectory(resource, false);
+        const result = [];
+        entry.entries.forEach((child, name) => result.push([name, child.type]));
+        return result;
+    }
+    async readFile(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            return data;
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    readFileStream(resource) {
+        const data = this._lookupAsFile(resource, false).data;
+        const stream = newWriteableStream(data => VSBuffer.concat(( data.map(data => VSBuffer.wrap(data)))).buffer);
+        stream.end(data);
+        return stream;
+    }
+    async writeFile(resource, content, opts) {
+        const basename = resources.basename(resource);
+        const parent = this._lookupParentDirectory(resource);
+        let entry = parent.entries.get(basename);
+        if (entry instanceof Directory) {
+            throw createFileSystemProviderError('file is directory', FileSystemProviderErrorCode.FileIsADirectory);
+        }
+        if (!entry && !opts.create) {
+            throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+        }
+        if (entry && opts.create && !opts.overwrite) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        if (!entry) {
+            entry = ( new File(basename));
+            parent.entries.set(basename, entry);
+            this._fireSoon({ type: 1 , resource });
+        }
+        entry.mtime = Date.now();
+        entry.size = content.byteLength;
+        entry.data = content;
+        this._fireSoon({ type: 0 , resource });
+    }
+    open(resource, opts) {
+        const data = this._lookupAsFile(resource, false).data;
+        if (data) {
+            const fd = this.memoryFdCounter++;
+            this.fdMemory.set(fd, data);
+            return Promise.resolve(fd);
+        }
+        throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+    }
+    close(fd) {
+        this.fdMemory.delete(fd);
+        return Promise.resolve();
+    }
+    read(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(memory).slice(pos, pos + length);
+        data.set(toWrite.buffer, offset);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    write(fd, pos, data, offset, length) {
+        const memory = this.fdMemory.get(fd);
+        if (!memory) {
+            throw createFileSystemProviderError(`No file with that descriptor open`, FileSystemProviderErrorCode.Unavailable);
+        }
+        const toWrite = VSBuffer.wrap(data).slice(offset, offset + length);
+        memory.set(toWrite.buffer, pos);
+        return Promise.resolve(toWrite.byteLength);
+    }
+    async rename(from, to, opts) {
+        if (!opts.overwrite && this._lookup(to, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const entry = this._lookup(from, false);
+        const oldParent = this._lookupParentDirectory(from);
+        const newParent = this._lookupParentDirectory(to);
+        const newName = resources.basename(to);
+        oldParent.entries.delete(entry.name);
+        entry.name = newName;
+        newParent.entries.set(newName, entry);
+        this._fireSoon({ type: 2 , resource: from }, { type: 1 , resource: to });
+    }
+    async delete(resource, opts) {
+        const dirname = resources.dirname(resource);
+        const basename = resources.basename(resource);
+        const parent = this._lookupAsDirectory(dirname, false);
+        if (( parent.entries.has(basename))) {
+            parent.entries.delete(basename);
+            parent.mtime = Date.now();
+            parent.size -= 1;
+            this._fireSoon({ type: 0 , resource: dirname }, { resource, type: 2  });
+        }
+    }
+    async mkdir(resource) {
+        if (this._lookup(resource, true)) {
+            throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
+        }
+        const basename = resources.basename(resource);
+        const dirname = resources.dirname(resource);
+        const parent = this._lookupAsDirectory(dirname, false);
+        const entry = ( new Directory(basename));
+        parent.entries.set(entry.name, entry);
+        parent.mtime = Date.now();
+        parent.size += 1;
+        this._fireSoon({ type: 0 , resource: dirname }, { type: 1 , resource });
+    }
+    _lookup(uri, silent) {
+        const parts = uri.path.split('/');
+        let entry = this.root;
+        for (const part of parts) {
+            if (!part) {
+                continue;
+            }
+            let child;
+            if (entry instanceof Directory) {
+                child = entry.entries.get(part);
+            }
+            if (!child) {
+                if (!silent) {
+                    throw createFileSystemProviderError('file not found', FileSystemProviderErrorCode.FileNotFound);
+                }
+                else {
+                    return undefined;
+                }
+            }
+            entry = child;
+        }
+        return entry;
+    }
+    _lookupAsDirectory(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof Directory) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file not a directory', FileSystemProviderErrorCode.FileNotADirectory);
+    }
+    _lookupAsFile(uri, silent) {
+        const entry = this._lookup(uri, silent);
+        if (entry instanceof File) {
+            return entry;
+        }
+        throw createFileSystemProviderError('file is a directory', FileSystemProviderErrorCode.FileIsADirectory);
+    }
+    _lookupParentDirectory(uri) {
+        const dirname = resources.dirname(uri);
+        return this._lookupAsDirectory(dirname, false);
+    }
+    watch(resource, opts) {
+        return Disposable.None;
+    }
+    _fireSoon(...changes) {
+        this._bufferedChanges.push(...changes);
+        if (this._fireSoonHandle) {
+            clearTimeout(this._fireSoonHandle);
+        }
+        this._fireSoonHandle = setTimeout(() => {
+            this._onDidChangeFile.fire(this._bufferedChanges);
+            this._bufferedChanges.length = 0;
+        }, 5);
+    }
+    dispose() {
+        super.dispose();
+        this.fdMemory.clear();
+    }
+}
+export { InMemoryFileSystemProvider };

package/vscode/src/vs/platform/layout/browser/zIndexRegistry.js

@@ -0,0 +1,58 @@
+import { createStyleSheet, clearNode, createCSSRule } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+var ZIndex;
+( (function(ZIndex) {
+    ZIndex[ZIndex["Base"] = 0] = "Base";
+    ZIndex[ZIndex["Sash"] = 35] = "Sash";
+    ZIndex[ZIndex["SuggestWidget"] = 40] = "SuggestWidget";
+    ZIndex[ZIndex["Hover"] = 50] = "Hover";
+    ZIndex[ZIndex["DragImage"] = 1000] = "DragImage";
+    ZIndex[ZIndex["MenubarMenuItemsHolder"] = 2000] = "MenubarMenuItemsHolder";
+    ZIndex[ZIndex["ContextView"] = 2500] = "ContextView";
+    ZIndex[ZIndex["ModalDialog"] = 2600] = "ModalDialog";
+    ZIndex[ZIndex["PaneDropOverlay"] = 10000] = "PaneDropOverlay";
+})(ZIndex || (ZIndex = {})));
+const ZIndexValues = ( ( Object.keys(ZIndex)).filter(key => !isNaN(Number(key))).map(key => Number(key))).sort((a, b) => b - a);
+function findBase(z) {
+    for (const zi of ZIndexValues) {
+        if (z >= zi) {
+            return zi;
+        }
+    }
+    return -1;
+}
+class ZIndexRegistry {
+    constructor() {
+        this.styleSheet = createStyleSheet();
+        this.zIndexMap = ( new Map());
+        this.scheduler = ( new RunOnceScheduler(() => this.updateStyleElement(), 200));
+    }
+    registerZIndex(relativeLayer, z, name) {
+        if (this.zIndexMap.get(name)) {
+            throw new Error(`z-index with name ${name} has already been registered.`);
+        }
+        const proposedZValue = relativeLayer + z;
+        if (findBase(proposedZValue) !== relativeLayer) {
+            throw new Error(`Relative layer: ${relativeLayer} + z-index: ${z} exceeds next layer ${proposedZValue}.`);
+        }
+        this.zIndexMap.set(name, proposedZValue);
+        this.scheduler.schedule();
+        return this.getVarName(name);
+    }
+    getVarName(name) {
+        return `--z-index-${name}`;
+    }
+    updateStyleElement() {
+        clearNode(this.styleSheet);
+        let ruleBuilder = '';
+        this.zIndexMap.forEach((zIndex, name) => {
+            ruleBuilder += `${this.getVarName(name)}: ${zIndex};\n`;
+        });
+        createCSSRule(':root', ruleBuilder, this.styleSheet);
+    }
+}
+const zIndexRegistry = ( new ZIndexRegistry());
+function registerZIndex(relativeLayer, z, name) {
+    return zIndexRegistry.registerZIndex(relativeLayer, z, name);
+}
+export { ZIndex, registerZIndex };

package/vscode/src/vs/platform/quickinput/browser/quickPickPin.js

@@ -0,0 +1,102 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+const pinButtonClass = ThemeIcon.asClassName(Codicon.pin);
+const pinnedButtonClass = ThemeIcon.asClassName(Codicon.pinned);
+const buttonClasses = [pinButtonClass, pinnedButtonClass];
+async function showWithPinnedItems(storageService, storageKey, quickPick, filterDuplicates) {
+    const itemsWithoutPinned = quickPick.items;
+    let itemsWithPinned = _formatPinnedItems(storageKey, quickPick, storageService, undefined, filterDuplicates);
+    quickPick.onDidTriggerItemButton(async (buttonEvent) => {
+        const expectedButton = buttonEvent.button.iconClass && buttonClasses.includes(buttonEvent.button.iconClass);
+        if (expectedButton) {
+            quickPick.items = itemsWithoutPinned;
+            itemsWithPinned = _formatPinnedItems(storageKey, quickPick, storageService, buttonEvent.item, filterDuplicates);
+            quickPick.items = quickPick.value ? itemsWithoutPinned : itemsWithPinned;
+        }
+    });
+    quickPick.onDidChangeValue(async (value) => {
+        if (quickPick.items === itemsWithPinned && value) {
+            quickPick.items = itemsWithoutPinned;
+        }
+        else if (quickPick.items === itemsWithoutPinned && !value) {
+            quickPick.items = itemsWithPinned;
+        }
+    });
+    quickPick.items = quickPick.value ? itemsWithoutPinned : itemsWithPinned;
+    quickPick.show();
+}
+function _formatPinnedItems(storageKey, quickPick, storageService, changedItem, filterDuplicates) {
+    const formattedItems = [];
+    let pinnedItems;
+    if (changedItem) {
+        pinnedItems = updatePinnedItems(storageKey, changedItem, storageService);
+    }
+    else {
+        pinnedItems = getPinnedItems(storageKey, storageService);
+    }
+    if (pinnedItems.length) {
+        formattedItems.push({ type: 'separator', label: ( localizeWithPath(
+            'vs/platform/quickinput/browser/quickPickPin',
+            "terminal.commands.pinned",
+            'pinned'
+        )) });
+    }
+    const pinnedIds = ( new Set());
+    for (const itemToFind of pinnedItems) {
+        const itemToPin = quickPick.items.find(item => itemsMatch(item, itemToFind));
+        if (itemToPin) {
+            const pinnedItemId = getItemIdentifier(itemToPin);
+            const pinnedItem = Object.assign({}, itemToPin);
+            if (!filterDuplicates || !( pinnedIds.has(pinnedItemId))) {
+                pinnedIds.add(pinnedItemId);
+                updateButtons(pinnedItem, false);
+                formattedItems.push(pinnedItem);
+            }
+        }
+    }
+    for (const item of quickPick.items) {
+        updateButtons(item, true);
+        formattedItems.push(item);
+    }
+    return formattedItems;
+}
+function getItemIdentifier(item) {
+    return item.type === 'separator' ? '' : item.id || `${item.label}${item.description}${item.detail}}`;
+}
+function updateButtons(item, removePin) {
+    if (item.type === 'separator') {
+        return;
+    }
+    const newButtons = item.buttons?.filter(button => button.iconClass && !buttonClasses.includes(button.iconClass)) ?? [];
+    newButtons.unshift({
+        iconClass: removePin ? pinButtonClass : pinnedButtonClass,
+        tooltip: removePin ? ( localizeWithPath('vs/platform/quickinput/browser/quickPickPin', 'pinCommand', "Pin command")) : ( localizeWithPath(
+            'vs/platform/quickinput/browser/quickPickPin',
+            'pinnedCommand',
+            "Pinned command"
+        )),
+        alwaysVisible: false
+    });
+    item.buttons = newButtons;
+}
+function itemsMatch(itemA, itemB) {
+    return getItemIdentifier(itemA) === getItemIdentifier(itemB);
+}
+function updatePinnedItems(storageKey, changedItem, storageService) {
+    const removePin = changedItem.buttons?.find(b => b.iconClass === pinnedButtonClass);
+    let items = getPinnedItems(storageKey, storageService);
+    if (removePin) {
+        items = items.filter(item => getItemIdentifier(item) !== getItemIdentifier(changedItem));
+    }
+    else {
+        items.push(changedItem);
+    }
+    storageService.store(storageKey, JSON.stringify(items), 1 , 1 );
+    return items;
+}
+function getPinnedItems(storageKey, storageService) {
+    const items = storageService.get(storageKey, 1 );
+    return items ? JSON.parse(items) : [];
+}
+export { showWithPinnedItems };

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetectionCapability.js

@@ -645,7 +645,62 @@ let WindowsPtyHeuristics = class WindowsPtyHeuristics extends Disposable {
 WindowsPtyHeuristics = ( __decorate([
     ( __param(3, ILogService))
 ], WindowsPtyHeuristics));
+function getLinesForCommand(buffer, command, cols, outputMatcher) {
+    if (!outputMatcher) {
+        return undefined;
+    }
+    const executedMarker = command.executedMarker;
+    const endMarker = command.endMarker;
+    if (!executedMarker || !endMarker) {
+        return undefined;
+    }
+    const startLine = executedMarker.line;
+    const endLine = endMarker.line;
+    const linesToCheck = outputMatcher.length;
+    const lines = [];
+    if (outputMatcher.anchor === 'bottom') {
+        for (let i = endLine - (outputMatcher.offset || 0); i >= startLine; i--) {
+            let wrappedLineStart = i;
+            const wrappedLineEnd = i;
+            while (wrappedLineStart >= startLine && buffer.getLine(wrappedLineStart)?.isWrapped) {
+                wrappedLineStart--;
+            }
+            i = wrappedLineStart;
+            lines.unshift(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
+            if (lines.length > linesToCheck) {
+                lines.pop();
+            }
+        }
+    }
+    else {
+        for (let i = startLine + (outputMatcher.offset || 0); i < endLine; i++) {
+            const wrappedLineStart = i;
+            let wrappedLineEnd = i;
+            while (wrappedLineEnd + 1 < endLine && buffer.getLine(wrappedLineEnd + 1)?.isWrapped) {
+                wrappedLineEnd++;
+            }
+            i = wrappedLineEnd;
+            lines.push(getXtermLineContent(buffer, wrappedLineStart, wrappedLineEnd, cols));
+            if (lines.length === linesToCheck) {
+                lines.shift();
+            }
+        }
+    }
+    return lines;
+}
+function getXtermLineContent(buffer, lineStart, lineEnd, cols) {
+    const maxLineLength = Math.max(2048 / cols * 2);
+    lineEnd = Math.min(lineEnd, lineStart + maxLineLength);
+    let content = '';
+    for (let i = lineStart; i <= lineEnd; i++) {
+        const line = buffer.getLine(i);
+        if (line) {
+            content += line.translateToString(true, 0, cols);
+        }
+    }
+    return content;
+}
 function cloneMarker(xterm, marker, offset = 0) {
     return xterm.registerMarker(marker.line - (xterm.buffer.active.baseY + xterm.buffer.active.cursorY) + offset);
 }
-export { CommandDetectionCapability };
+export { CommandDetectionCapability, getLinesForCommand };

package/vscode/src/vs/platform/userDataSync/common/content.js

@@ -0,0 +1,9 @@
+import { setProperty } from '../../../base/common/jsonEdit.js';
+function edit(content, originalPath, value, formattingOptions) {
+    const edit = setProperty(content, originalPath, value, formattingOptions)[0];
+    if (edit) {
+        content = content.substring(0, edit.offset) + edit.content + content.substring(edit.offset + edit.length);
+    }
+    return content;
+}
+export { edit };