@codingame/monaco-vscode-api 1.85.1 → 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/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/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 };