@codingame/monaco-vscode-api 1.83.8 → 1.83.9

package/vscode/src/vs/base/common/tfIdf.js

@@ -1,137 +0,0 @@
-function countMapFrom(values) {
-    const map = ( new Map());
-    for (const value of values) {
-        map.set(value, (map.get(value) ?? 0) + 1);
-    }
-    return map;
-}
-class TfIdfCalculator {
-    constructor() {
-        this.chunkCount = 0;
-        this.chunkOccurrences = ( new Map());
-        this.documents = ( new Map());
-    }
-    calculateScores(query, token) {
-        const embedding = this.computeEmbedding(query);
-        const idfCache = ( new Map());
-        const scores = [];
-        for (const [key, doc] of this.documents) {
-            if (token.isCancellationRequested) {
-                return [];
-            }
-            for (const chunk of doc.chunks) {
-                const score = this.computeSimilarityScore(chunk, embedding, idfCache);
-                if (score > 0) {
-                    scores.push({ key, score });
-                }
-            }
-        }
-        return scores;
-    }
-    static termFrequencies(input) {
-        return countMapFrom(TfIdfCalculator.splitTerms(input));
-    }
-    static *splitTerms(input) {
-        const normalize = (word) => word.toLowerCase();
-        for (const [word] of input.matchAll(/\b\p{Letter}[\p{Letter}\d]{2,}\b/gu)) {
-            yield normalize(word);
-            const camelParts = word.split(/(?<=[a-z])(?=[A-Z])/g);
-            if (camelParts.length > 1) {
-                for (const part of camelParts) {
-                    if (part.length > 2 && /\p{Letter}{3,}/gu.test(part)) {
-                        yield normalize(part);
-                    }
-                }
-            }
-        }
-    }
-    updateDocuments(documents) {
-        for (const { key } of documents) {
-            this.deleteDocument(key);
-        }
-        for (const doc of documents) {
-            const chunks = [];
-            for (const text of doc.textChunks) {
-                const tf = TfIdfCalculator.termFrequencies(text);
-                for (const term of ( tf.keys())) {
-                    this.chunkOccurrences.set(term, (this.chunkOccurrences.get(term) ?? 0) + 1);
-                }
-                chunks.push({ text, tf });
-            }
-            this.chunkCount += chunks.length;
-            this.documents.set(doc.key, { chunks });
-        }
-        return this;
-    }
-    deleteDocument(key) {
-        const doc = this.documents.get(key);
-        if (!doc) {
-            return;
-        }
-        this.documents.delete(key);
-        this.chunkCount -= doc.chunks.length;
-        for (const chunk of doc.chunks) {
-            for (const term of ( chunk.tf.keys())) {
-                const currentOccurrences = this.chunkOccurrences.get(term);
-                if (typeof currentOccurrences === 'number') {
-                    const newOccurrences = currentOccurrences - 1;
-                    if (newOccurrences <= 0) {
-                        this.chunkOccurrences.delete(term);
-                    }
-                    else {
-                        this.chunkOccurrences.set(term, newOccurrences);
-                    }
-                }
-            }
-        }
-    }
-    computeSimilarityScore(chunk, queryEmbedding, idfCache) {
-        let sum = 0;
-        for (const [term, termTfidf] of Object.entries(queryEmbedding)) {
-            const chunkTf = chunk.tf.get(term);
-            if (!chunkTf) {
-                continue;
-            }
-            let chunkIdf = idfCache.get(term);
-            if (typeof chunkIdf !== 'number') {
-                chunkIdf = this.computeIdf(term);
-                idfCache.set(term, chunkIdf);
-            }
-            const chunkTfidf = chunkTf * chunkIdf;
-            sum += chunkTfidf * termTfidf;
-        }
-        return sum;
-    }
-    computeEmbedding(input) {
-        const tf = TfIdfCalculator.termFrequencies(input);
-        return this.computeTfidf(tf);
-    }
-    computeIdf(term) {
-        const chunkOccurrences = this.chunkOccurrences.get(term) ?? 0;
-        return chunkOccurrences > 0
-            ? Math.log((this.chunkCount + 1) / chunkOccurrences)
-            : 0;
-    }
-    computeTfidf(termFrequencies) {
-        const embedding = Object.create(null);
-        for (const [word, occurrences] of termFrequencies) {
-            const idf = this.computeIdf(word);
-            if (idf > 0) {
-                embedding[word] = occurrences * idf;
-            }
-        }
-        return embedding;
-    }
-}
-function normalizeTfIdfScores(scores) {
-    const result = scores.slice(0);
-    result.sort((a, b) => b.score - a.score);
-    const max = result[0]?.score ?? 0;
-    if (max > 0) {
-        for (const score of result) {
-            score.score /= max;
-        }
-    }
-    return result;
-}
-export { TfIdfCalculator, normalizeTfIdfScores };

package/vscode/src/vs/editor/contrib/quickAccess/browser/commandsQuickAccess.js

@@ -1,23 +0,0 @@
-import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
-import { AbstractCommandsQuickAccessProvider } from '../../../../platform/quickinput/browser/commandsQuickAccess.js';
-class AbstractEditorCommandsQuickAccessProvider extends AbstractCommandsQuickAccessProvider {
-    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
-        super(options, instantiationService, keybindingService, commandService, telemetryService, dialogService);
-    }
-    getCodeEditorCommandPicks() {
-        const activeTextEditorControl = this.activeTextEditorControl;
-        if (!activeTextEditorControl) {
-            return [];
-        }
-        const editorCommandPicks = [];
-        for (const editorAction of activeTextEditorControl.getSupportedActions()) {
-            editorCommandPicks.push({
-                commandId: editorAction.id,
-                commandAlias: editorAction.alias,
-                label: stripIcons(editorAction.label) || editorAction.id,
-            });
-        }
-        return editorCommandPicks;
-    }
-}
-export { AbstractEditorCommandsQuickAccessProvider };

package/vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js

@@ -1,404 +0,0 @@
-import { Throttler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtUri } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { isString } from 'monaco-editor/esm/vs/base/common/types.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { createFileSystemProviderError, FileSystemProviderErrorCode, FileType, FileSystemProviderError } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { DBClosedError } from 'monaco-editor/esm/vs/base/browser/indexedDB.js';
-import { BroadcastDataChannel } from '../../../base/browser/broadcast.js';
-const ERR_FILE_NOT_FOUND = createFileSystemProviderError(( localizeWithPath(
-    'vs/platform/files/browser/indexedDBFileSystemProvider',
-    'fileNotExists',
-    "File does not exist"
-)), FileSystemProviderErrorCode.FileNotFound);
-const ERR_FILE_IS_DIR = createFileSystemProviderError(( localizeWithPath(
-    'vs/platform/files/browser/indexedDBFileSystemProvider',
-    'fileIsDirectory',
-    "File is Directory"
-)), FileSystemProviderErrorCode.FileIsADirectory);
-const ERR_FILE_NOT_DIR = createFileSystemProviderError(( localizeWithPath(
-    'vs/platform/files/browser/indexedDBFileSystemProvider',
-    'fileNotDirectory',
-    "File is not a directory"
-)), FileSystemProviderErrorCode.FileNotADirectory);
-const ERR_DIR_NOT_EMPTY = createFileSystemProviderError(( localizeWithPath(
-    'vs/platform/files/browser/indexedDBFileSystemProvider',
-    'dirIsNotEmpty',
-    "Directory is not empty"
-)), FileSystemProviderErrorCode.Unknown);
-const ERR_FILE_EXCEEDS_STORAGE_QUOTA = createFileSystemProviderError(( localizeWithPath(
-    'vs/platform/files/browser/indexedDBFileSystemProvider',
-    'fileExceedsStorageQuota',
-    "File exceeds available storage quota"
-)), FileSystemProviderErrorCode.FileExceedsStorageQuota);
-const ERR_UNKNOWN_INTERNAL = (message) => createFileSystemProviderError(( localizeWithPath(
-    'vs/platform/files/browser/indexedDBFileSystemProvider',
-    'internal',
-    "Internal error occurred in IndexedDB File System Provider. ({0})",
-    message
-)), FileSystemProviderErrorCode.Unknown);
-class IndexedDBFileSystemNode {
-    constructor(entry) {
-        this.entry = entry;
-        this.type = entry.type;
-    }
-    read(path) {
-        return this.doRead(path.split('/').filter(p => p.length));
-    }
-    doRead(pathParts) {
-        if (pathParts.length === 0) {
-            return this.entry;
-        }
-        if (this.entry.type !== FileType.Directory) {
-            throw ERR_UNKNOWN_INTERNAL('Internal error reading from IndexedDBFSNode -- expected directory at ' + this.entry.path);
-        }
-        const next = this.entry.children.get(pathParts[0]);
-        if (!next) {
-            return undefined;
-        }
-        return next.doRead(pathParts.slice(1));
-    }
-    delete(path) {
-        const toDelete = path.split('/').filter(p => p.length);
-        if (toDelete.length === 0) {
-            if (this.entry.type !== FileType.Directory) {
-                throw ERR_UNKNOWN_INTERNAL(`Internal error deleting from IndexedDBFSNode. Expected root entry to be directory`);
-            }
-            this.entry.children.clear();
-        }
-        else {
-            return this.doDelete(toDelete, path);
-        }
-    }
-    doDelete(pathParts, originalPath) {
-        if (pathParts.length === 0) {
-            throw ERR_UNKNOWN_INTERNAL(`Internal error deleting from IndexedDBFSNode -- got no deletion path parts (encountered while deleting ${originalPath})`);
-        }
-        else if (this.entry.type !== FileType.Directory) {
-            throw ERR_UNKNOWN_INTERNAL('Internal error deleting from IndexedDBFSNode -- expected directory at ' + this.entry.path);
-        }
-        else if (pathParts.length === 1) {
-            this.entry.children.delete(pathParts[0]);
-        }
-        else {
-            const next = this.entry.children.get(pathParts[0]);
-            if (!next) {
-                throw ERR_UNKNOWN_INTERNAL('Internal error deleting from IndexedDBFSNode -- expected entry at ' + this.entry.path + '/' + next);
-            }
-            next.doDelete(pathParts.slice(1), originalPath);
-        }
-    }
-    add(path, entry) {
-        this.doAdd(path.split('/').filter(p => p.length), entry, path);
-    }
-    doAdd(pathParts, entry, originalPath) {
-        if (pathParts.length === 0) {
-            throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- adding empty path (encountered while adding ${originalPath})`);
-        }
-        else if (this.entry.type !== FileType.Directory) {
-            throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- parent is not a directory (encountered while adding ${originalPath})`);
-        }
-        else if (pathParts.length === 1) {
-            const next = pathParts[0];
-            const existing = this.entry.children.get(next);
-            if (entry.type === 'dir') {
-                if (existing?.entry.type === FileType.File) {
-                    throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting file with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
-                }
-                this.entry.children.set(next, existing ?? ( new IndexedDBFileSystemNode({
-                    type: FileType.Directory,
-                    path: this.entry.path + '/' + next,
-                    children: ( new Map()),
-                })));
-            }
-            else {
-                if (existing?.entry.type === FileType.Directory) {
-                    throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting directory with file: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
-                }
-                this.entry.children.set(next, ( new IndexedDBFileSystemNode({
-                    type: FileType.File,
-                    path: this.entry.path + '/' + next,
-                    size: entry.size,
-                })));
-            }
-        }
-        else if (pathParts.length > 1) {
-            const next = pathParts[0];
-            let childNode = this.entry.children.get(next);
-            if (!childNode) {
-                childNode = ( new IndexedDBFileSystemNode({
-                    children: ( new Map()),
-                    path: this.entry.path + '/' + next,
-                    type: FileType.Directory
-                }));
-                this.entry.children.set(next, childNode);
-            }
-            else if (childNode.type === FileType.File) {
-                throw ERR_UNKNOWN_INTERNAL(`Internal error creating IndexedDBFSNode -- overwriting file entry with directory: ${this.entry.path}/${next} (encountered while adding ${originalPath})`);
-            }
-            childNode.doAdd(pathParts.slice(1), entry, originalPath);
-        }
-    }
-    print(indentation = '') {
-        console.log(indentation + this.entry.path);
-        if (this.entry.type === FileType.Directory) {
-            this.entry.children.forEach(child => child.print(indentation + ' '));
-        }
-    }
-}
-class IndexedDBFileSystemProvider extends Disposable {
-    constructor(scheme, indexedDB, store, watchCrossWindowChanges) {
-        super();
-        this.scheme = scheme;
-        this.indexedDB = indexedDB;
-        this.store = store;
-        this.capabilities = 2
-            | 1024 ;
-        this.onDidChangeCapabilities = Event.None;
-        this.extUri = ( new ExtUri(() => false)) ;
-        this._onDidChangeFile = this._register(( new Emitter()));
-        this.onDidChangeFile = this._onDidChangeFile.event;
-        this._onReportError = this._register(( new Emitter()));
-        this.onReportError = this._onReportError.event;
-        this.mtimes = ( new Map());
-        this.fileWriteBatch = [];
-        this.writeManyThrottler = ( new Throttler());
-        if (watchCrossWindowChanges) {
-            this.changesBroadcastChannel = this._register(( new BroadcastDataChannel(`vscode.indexedDB.${scheme}.changes`)));
-            this._register(this.changesBroadcastChannel.onDidReceiveData(changes => {
-                this._onDidChangeFile.fire(( changes.map(c => ({ type: c.type, resource: URI.revive(c.resource) }))));
-            }));
-        }
-    }
-    watch(resource, opts) {
-        return Disposable.None;
-    }
-    async mkdir(resource) {
-        try {
-            const resourceStat = await this.stat(resource);
-            if (resourceStat.type === FileType.File) {
-                throw ERR_FILE_NOT_DIR;
-            }
-        }
-        catch (error) {  }
-        (await this.getFiletree()).add(resource.path, { type: 'dir' });
-    }
-    async stat(resource) {
-        const entry = (await this.getFiletree()).read(resource.path);
-        if (entry?.type === FileType.File) {
-            return {
-                type: FileType.File,
-                ctime: 0,
-                mtime: this.mtimes.get(( resource.toString())) || 0,
-                size: entry.size ?? (await this.readFile(resource)).byteLength
-            };
-        }
-        if (entry?.type === FileType.Directory) {
-            return {
-                type: FileType.Directory,
-                ctime: 0,
-                mtime: 0,
-                size: 0
-            };
-        }
-        throw ERR_FILE_NOT_FOUND;
-    }
-    async readdir(resource) {
-        try {
-            const entry = (await this.getFiletree()).read(resource.path);
-            if (!entry) {
-                return [];
-            }
-            if (entry.type !== FileType.Directory) {
-                throw ERR_FILE_NOT_DIR;
-            }
-            else {
-                return ( [...entry.children.entries()].map(([name, node]) => [name, node.type]));
-            }
-        }
-        catch (error) {
-            this.reportError('readDir', error);
-            throw error;
-        }
-    }
-    async readFile(resource) {
-        try {
-            const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.get(resource.path));
-            if (result === undefined) {
-                throw ERR_FILE_NOT_FOUND;
-            }
-            const buffer = result instanceof Uint8Array ? result : isString(result) ? VSBuffer.fromString(result).buffer : undefined;
-            if (buffer === undefined) {
-                throw ERR_UNKNOWN_INTERNAL(`IndexedDB entry at "${resource.path}" in unexpected format`);
-            }
-            const fileTree = await this.getFiletree();
-            fileTree.add(resource.path, { type: 'file', size: buffer.byteLength });
-            return buffer;
-        }
-        catch (error) {
-            this.reportError('readFile', error);
-            throw error;
-        }
-    }
-    async writeFile(resource, content, opts) {
-        try {
-            const existing = await this.stat(resource).catch(() => undefined);
-            if (existing?.type === FileType.Directory) {
-                throw ERR_FILE_IS_DIR;
-            }
-            await this.bulkWrite([[resource, content]]);
-        }
-        catch (error) {
-            this.reportError('writeFile', error);
-            throw error;
-        }
-    }
-    async rename(from, to, opts) {
-        const fileTree = await this.getFiletree();
-        const fromEntry = fileTree.read(from.path);
-        if (!fromEntry) {
-            throw ERR_FILE_NOT_FOUND;
-        }
-        const toEntry = fileTree.read(to.path);
-        if (toEntry) {
-            if (!opts.overwrite) {
-                throw createFileSystemProviderError('file exists already', FileSystemProviderErrorCode.FileExists);
-            }
-            if (toEntry.type !== fromEntry.type) {
-                throw createFileSystemProviderError('Cannot rename files with different types', FileSystemProviderErrorCode.Unknown);
-            }
-            await this.delete(to, { recursive: true, useTrash: false, atomic: false });
-        }
-        const toTargetResource = (path) => this.extUri.joinPath(to, this.extUri.relativePath(from, from.with({ path })) || '');
-        const sourceEntries = await this.tree(from);
-        const sourceFiles = [];
-        for (const sourceEntry of sourceEntries) {
-            if (sourceEntry[1] === FileType.File) {
-                sourceFiles.push(sourceEntry);
-            }
-            else if (sourceEntry[1] === FileType.Directory) {
-                fileTree.add(toTargetResource(sourceEntry[0]).path, { type: 'dir' });
-            }
-        }
-        if (sourceFiles.length) {
-            const targetFiles = [];
-            const sourceFilesContents = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => ( sourceFiles.map(([path]) => objectStore.get(path))));
-            for (let index = 0; index < sourceFiles.length; index++) {
-                const content = sourceFilesContents[index] instanceof Uint8Array ? sourceFilesContents[index] : isString(sourceFilesContents[index]) ? VSBuffer.fromString(sourceFilesContents[index]).buffer : undefined;
-                if (content) {
-                    targetFiles.push([toTargetResource(sourceFiles[index][0]), content]);
-                }
-            }
-            await this.bulkWrite(targetFiles);
-        }
-        await this.delete(from, { recursive: true, useTrash: false, atomic: false });
-    }
-    async delete(resource, opts) {
-        let stat;
-        try {
-            stat = await this.stat(resource);
-        }
-        catch (e) {
-            if (e.code === FileSystemProviderErrorCode.FileNotFound) {
-                return;
-            }
-            throw e;
-        }
-        let toDelete;
-        if (opts.recursive) {
-            const tree = await this.tree(resource);
-            toDelete = ( tree.map(([path]) => path));
-        }
-        else {
-            if (stat.type === FileType.Directory && (await this.readdir(resource)).length) {
-                throw ERR_DIR_NOT_EMPTY;
-            }
-            toDelete = [resource.path];
-        }
-        await this.deleteKeys(toDelete);
-        (await this.getFiletree()).delete(resource.path);
-        toDelete.forEach(key => this.mtimes.delete(key));
-        this.triggerChanges(( toDelete.map(
-            path => ({ resource: resource.with({ path }), type: 2  })
-        )));
-    }
-    async tree(resource) {
-        const stat = await this.stat(resource);
-        const allEntries = [[resource.path, stat.type]];
-        if (stat.type === FileType.Directory) {
-            const dirEntries = await this.readdir(resource);
-            for (const [key, type] of dirEntries) {
-                const childResource = this.extUri.joinPath(resource, key);
-                allEntries.push([childResource.path, type]);
-                if (type === FileType.Directory) {
-                    const childEntries = await this.tree(childResource);
-                    allEntries.push(...childEntries);
-                }
-            }
-        }
-        return allEntries;
-    }
-    triggerChanges(changes) {
-        if (changes.length) {
-            this._onDidChangeFile.fire(changes);
-            this.changesBroadcastChannel?.postData(changes);
-        }
-    }
-    getFiletree() {
-        if (!this.cachedFiletree) {
-            this.cachedFiletree = (async () => {
-                const rootNode = ( new IndexedDBFileSystemNode({
-                    children: ( new Map()),
-                    path: '',
-                    type: FileType.Directory
-                }));
-                const result = await this.indexedDB.runInTransaction(this.store, 'readonly', objectStore => objectStore.getAllKeys());
-                const keys = ( result.map(key => ( key.toString())));
-                keys.forEach(key => rootNode.add(key, { type: 'file' }));
-                return rootNode;
-            })();
-        }
-        return this.cachedFiletree;
-    }
-    async bulkWrite(files) {
-        files.forEach(([resource, content]) => this.fileWriteBatch.push({ content, resource }));
-        await this.writeManyThrottler.queue(() => this.writeMany());
-        const fileTree = await this.getFiletree();
-        for (const [resource, content] of files) {
-            fileTree.add(resource.path, { type: 'file', size: content.byteLength });
-            this.mtimes.set(( resource.toString()), Date.now());
-        }
-        this.triggerChanges(( files.map(([resource]) => ({ resource, type: 0  }))));
-    }
-    async writeMany() {
-        if (this.fileWriteBatch.length) {
-            const fileBatch = this.fileWriteBatch.splice(0, this.fileWriteBatch.length);
-            try {
-                await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( fileBatch.map(entry => {
-                    return objectStore.put(entry.content, entry.resource.path);
-                })));
-            }
-            catch (ex) {
-                if (ex instanceof DOMException && ex.name === 'QuotaExceededError') {
-                    throw ERR_FILE_EXCEEDS_STORAGE_QUOTA;
-                }
-                throw ex;
-            }
-        }
-    }
-    async deleteKeys(keys) {
-        if (keys.length) {
-            await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => ( keys.map(key => objectStore.delete(key))));
-        }
-    }
-    async reset() {
-        await this.indexedDB.runInTransaction(this.store, 'readwrite', objectStore => objectStore.clear());
-    }
-    reportError(operation, error) {
-        this._onReportError.fire({ scheme: this.scheme, operation, code: error instanceof FileSystemProviderError || error instanceof DBClosedError ? error.code : 'unknown' });
-    }
-}
-export { IndexedDBFileSystemProvider };