@codingame/monaco-vscode-api 1.83.8 → 1.83.10-next.0

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

@@ -1,331 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
-import { isCancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
-import { or, matchesPrefix, matchesWords, matchesContiguousSubString } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { createSingleCallFunction } from 'monaco-editor/esm/vs/base/common/functional.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
-import { normalizeTfIdfScores, TfIdfCalculator } from '../../../base/common/tfIdf.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import '../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { PickerQuickAccessProvider } from './pickerQuickAccess.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IDialogService } from '../../dialogs/common/dialogs.js';
-var AbstractCommandsQuickAccessProvider_1, CommandsHistory_1;
-let AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvider extends PickerQuickAccessProvider {
-    static { AbstractCommandsQuickAccessProvider_1 = this; }
-    static { this.PREFIX = '>'; }
-    static { this.TFIDF_THRESHOLD = 0.5; }
-    static { this.TFIDF_MAX_RESULTS = 5; }
-    static { this.WORD_FILTER = or(matchesPrefix, matchesWords, matchesContiguousSubString); }
-    constructor(options, instantiationService, keybindingService, commandService, telemetryService, dialogService) {
-        super(AbstractCommandsQuickAccessProvider_1.PREFIX, options);
-        this.instantiationService = instantiationService;
-        this.keybindingService = keybindingService;
-        this.commandService = commandService;
-        this.telemetryService = telemetryService;
-        this.dialogService = dialogService;
-        this.commandsHistory = this._register(this.instantiationService.createInstance(CommandsHistory));
-        this.options = options;
-    }
-    async _getPicks(filter, _disposables, token, runOptions) {
-        const allCommandPicks = await this.getCommandPicks(token);
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const runTfidf = createSingleCallFunction(() => {
-            const tfidf = ( new TfIdfCalculator());
-            tfidf.updateDocuments(( allCommandPicks.map(commandPick => ({
-                key: commandPick.commandId,
-                textChunks: [commandPick.label + (commandPick.commandAlias ? ` ${commandPick.commandAlias}` : '')]
-            }))));
-            const result = tfidf.calculateScores(filter, token);
-            return normalizeTfIdfScores(result)
-                .filter(score => score.score > AbstractCommandsQuickAccessProvider_1.TFIDF_THRESHOLD)
-                .slice(0, AbstractCommandsQuickAccessProvider_1.TFIDF_MAX_RESULTS);
-        });
-        const filteredCommandPicks = [];
-        for (const commandPick of allCommandPicks) {
-            const labelHighlights = AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.label) ?? undefined;
-            const aliasHighlights = commandPick.commandAlias ? AbstractCommandsQuickAccessProvider_1.WORD_FILTER(filter, commandPick.commandAlias) ?? undefined : undefined;
-            if (labelHighlights || aliasHighlights) {
-                commandPick.highlights = {
-                    label: labelHighlights,
-                    detail: this.options.showAlias ? aliasHighlights : undefined
-                };
-                filteredCommandPicks.push(commandPick);
-            }
-            else if (filter === commandPick.commandId) {
-                filteredCommandPicks.push(commandPick);
-            }
-            else if (filter.length >= 3) {
-                const tfidf = runTfidf();
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                const tfidfScore = tfidf.find(score => score.key === commandPick.commandId);
-                if (tfidfScore) {
-                    commandPick.tfIdfScore = tfidfScore.score;
-                    filteredCommandPicks.push(commandPick);
-                }
-            }
-        }
-        const mapLabelToCommand = ( new Map());
-        for (const commandPick of filteredCommandPicks) {
-            const existingCommandForLabel = mapLabelToCommand.get(commandPick.label);
-            if (existingCommandForLabel) {
-                commandPick.description = commandPick.commandId;
-                existingCommandForLabel.description = existingCommandForLabel.commandId;
-            }
-            else {
-                mapLabelToCommand.set(commandPick.label, commandPick);
-            }
-        }
-        filteredCommandPicks.sort((commandPickA, commandPickB) => {
-            if (commandPickA.tfIdfScore && commandPickB.tfIdfScore) {
-                if (commandPickA.tfIdfScore === commandPickB.tfIdfScore) {
-                    return commandPickA.label.localeCompare(commandPickB.label);
-                }
-                return commandPickB.tfIdfScore - commandPickA.tfIdfScore;
-            }
-            else if (commandPickA.tfIdfScore) {
-                return 1;
-            }
-            else if (commandPickB.tfIdfScore) {
-                return -1;
-            }
-            const commandACounter = this.commandsHistory.peek(commandPickA.commandId);
-            const commandBCounter = this.commandsHistory.peek(commandPickB.commandId);
-            if (commandACounter && commandBCounter) {
-                return commandACounter > commandBCounter ? -1 : 1;
-            }
-            if (commandACounter) {
-                return -1;
-            }
-            if (commandBCounter) {
-                return 1;
-            }
-            if (this.options.suggestedCommandIds) {
-                const commandASuggestion = ( this.options.suggestedCommandIds.has(commandPickA.commandId));
-                const commandBSuggestion = ( this.options.suggestedCommandIds.has(commandPickB.commandId));
-                if (commandASuggestion && commandBSuggestion) {
-                    return 0;
-                }
-                if (commandASuggestion) {
-                    return -1;
-                }
-                if (commandBSuggestion) {
-                    return 1;
-                }
-            }
-            return commandPickA.label.localeCompare(commandPickB.label);
-        });
-        const commandPicks = [];
-        let addOtherSeparator = false;
-        let addSuggestedSeparator = true;
-        let addCommonlyUsedSeparator = !!this.options.suggestedCommandIds;
-        for (let i = 0; i < filteredCommandPicks.length; i++) {
-            const commandPick = filteredCommandPicks[i];
-            if (i === 0 && this.commandsHistory.peek(commandPick.commandId)) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'recentlyUsed',
-                    "recently used"
-                )) });
-                addOtherSeparator = true;
-            }
-            if (addSuggestedSeparator && commandPick.tfIdfScore !== undefined) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'suggested',
-                    "similar commands"
-                )) });
-                addSuggestedSeparator = false;
-            }
-            if (addCommonlyUsedSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && this.options.suggestedCommandIds?.has(commandPick.commandId)) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'commonlyUsed',
-                    "commonly used"
-                )) });
-                addOtherSeparator = true;
-                addCommonlyUsedSeparator = false;
-            }
-            if (addOtherSeparator && commandPick.tfIdfScore === undefined && !this.commandsHistory.peek(commandPick.commandId) && !this.options.suggestedCommandIds?.has(commandPick.commandId)) {
-                commandPicks.push({ type: 'separator', label: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/commandsQuickAccess',
-                    'morecCommands',
-                    "other commands"
-                )) });
-                addOtherSeparator = false;
-            }
-            commandPicks.push(this.toCommandPick(commandPick, runOptions));
-        }
-        if (!this.hasAdditionalCommandPicks(filter, token)) {
-            return commandPicks;
-        }
-        return {
-            picks: commandPicks,
-            additionalPicks: (async () => {
-                const additionalCommandPicks = await this.getAdditionalCommandPicks(allCommandPicks, filteredCommandPicks, filter, token);
-                if (token.isCancellationRequested) {
-                    return [];
-                }
-                const commandPicks = ( additionalCommandPicks.map(commandPick => this.toCommandPick(commandPick, runOptions)));
-                if (addSuggestedSeparator && commandPicks[0]?.type !== 'separator') {
-                    commandPicks.unshift({ type: 'separator', label: ( localizeWithPath(
-                        'vs/platform/quickinput/browser/commandsQuickAccess',
-                        'suggested',
-                        "similar commands"
-                    )) });
-                }
-                return commandPicks;
-            })()
-        };
-    }
-    toCommandPick(commandPick, runOptions) {
-        if (commandPick.type === 'separator') {
-            return commandPick;
-        }
-        const keybinding = this.keybindingService.lookupKeybinding(commandPick.commandId);
-        const ariaLabel = keybinding ?
-            ( localizeWithPath(
-                'vs/platform/quickinput/browser/commandsQuickAccess',
-                'commandPickAriaLabelWithKeybinding',
-                "{0}, {1}",
-                commandPick.label,
-                keybinding.getAriaLabel()
-            )) :
-            commandPick.label;
-        return {
-            ...commandPick,
-            ariaLabel,
-            detail: this.options.showAlias && commandPick.commandAlias !== commandPick.label ? commandPick.commandAlias : undefined,
-            keybinding,
-            accept: async () => {
-                this.commandsHistory.push(commandPick.commandId);
-                this.telemetryService.publicLog2('workbenchActionExecuted', {
-                    id: commandPick.commandId,
-                    from: runOptions?.from ?? 'quick open'
-                });
-                try {
-                    commandPick.args?.length
-                        ? await this.commandService.executeCommand(commandPick.commandId, ...commandPick.args)
-                        : await this.commandService.executeCommand(commandPick.commandId);
-                }
-                catch (error) {
-                    if (!isCancellationError(error)) {
-                        this.dialogService.error(( localizeWithPath(
-                            'vs/platform/quickinput/browser/commandsQuickAccess',
-                            'canNotRun',
-                            "Command '{0}' resulted in an error",
-                            commandPick.label
-                        )), toErrorMessage(error));
-                    }
-                }
-            }
-        };
-    }
-};
-AbstractCommandsQuickAccessProvider = AbstractCommandsQuickAccessProvider_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IKeybindingService)),
-    ( __param(3, ICommandService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IDialogService))
-], AbstractCommandsQuickAccessProvider));
-let CommandsHistory = class CommandsHistory extends Disposable {
-    static { CommandsHistory_1 = this; }
-    static { this.DEFAULT_COMMANDS_HISTORY_LENGTH = 50; }
-    static { this.PREF_KEY_CACHE = 'commandPalette.mru.cache'; }
-    static { this.PREF_KEY_COUNTER = 'commandPalette.mru.counter'; }
-    static { this.counter = 1; }
-    constructor(storageService, configurationService) {
-        super();
-        this.storageService = storageService;
-        this.configurationService = configurationService;
-        this.configuredCommandsHistoryLength = 0;
-        this.updateConfiguration();
-        this.load();
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
-    }
-    updateConfiguration(e) {
-        if (e && !e.affectsConfiguration('workbench.commandPalette.history')) {
-            return;
-        }
-        this.configuredCommandsHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(this.configurationService);
-        if (CommandsHistory_1.cache && CommandsHistory_1.cache.limit !== this.configuredCommandsHistoryLength) {
-            CommandsHistory_1.cache.limit = this.configuredCommandsHistoryLength;
-            CommandsHistory_1.saveState(this.storageService);
-        }
-    }
-    load() {
-        const raw = this.storageService.get(CommandsHistory_1.PREF_KEY_CACHE, 0 );
-        let serializedCache;
-        if (raw) {
-            try {
-                serializedCache = JSON.parse(raw);
-            }
-            catch (error) {
-            }
-        }
-        const cache = CommandsHistory_1.cache = ( new LRUCache(this.configuredCommandsHistoryLength, 1));
-        if (serializedCache) {
-            let entries;
-            if (serializedCache.usesLRU) {
-                entries = serializedCache.entries;
-            }
-            else {
-                entries = serializedCache.entries.sort((a, b) => a.value - b.value);
-            }
-            entries.forEach(entry => cache.set(entry.key, entry.value));
-        }
-        CommandsHistory_1.counter = this.storageService.getNumber(CommandsHistory_1.PREF_KEY_COUNTER, 0 , CommandsHistory_1.counter);
-    }
-    push(commandId) {
-        if (!CommandsHistory_1.cache) {
-            return;
-        }
-        CommandsHistory_1.cache.set(commandId, CommandsHistory_1.counter++);
-        CommandsHistory_1.saveState(this.storageService);
-    }
-    peek(commandId) {
-        return CommandsHistory_1.cache?.peek(commandId);
-    }
-    static saveState(storageService) {
-        if (!CommandsHistory_1.cache) {
-            return;
-        }
-        const serializedCache = { usesLRU: true, entries: [] };
-        CommandsHistory_1.cache.forEach((value, key) => serializedCache.entries.push({ key, value }));
-        storageService.store(CommandsHistory_1.PREF_KEY_CACHE, JSON.stringify(serializedCache), 0 , 0 );
-        storageService.store(CommandsHistory_1.PREF_KEY_COUNTER, CommandsHistory_1.counter, 0 , 0 );
-    }
-    static getConfiguredCommandHistoryLength(configurationService) {
-        const config = configurationService.getValue();
-        const configuredCommandHistoryLength = config.workbench?.commandPalette?.history;
-        if (typeof configuredCommandHistoryLength === 'number') {
-            return configuredCommandHistoryLength;
-        }
-        return CommandsHistory_1.DEFAULT_COMMANDS_HISTORY_LENGTH;
-    }
-    static clearHistory(configurationService, storageService) {
-        const commandHistoryLength = CommandsHistory_1.getConfiguredCommandHistoryLength(configurationService);
-        CommandsHistory_1.cache = ( new LRUCache(commandHistoryLength));
-        CommandsHistory_1.counter = 1;
-        CommandsHistory_1.saveState(storageService);
-    }
-};
-CommandsHistory = CommandsHistory_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IConfigurationService))
-], CommandsHistory));
-export { AbstractCommandsQuickAccessProvider, CommandsHistory };

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

@@ -1,65 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/quickinput/common/quickAccess.js';
-import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
-var HelpQuickAccessProvider_1;
-let HelpQuickAccessProvider = class HelpQuickAccessProvider {
-    static { HelpQuickAccessProvider_1 = this; }
-    static { this.PREFIX = '?'; }
-    constructor(quickInputService, keybindingService) {
-        this.quickInputService = quickInputService;
-        this.keybindingService = keybindingService;
-        this.registry = ( Registry.as(Extensions.Quickaccess));
-    }
-    provide(picker) {
-        const disposables = ( new DisposableStore());
-        disposables.add(picker.onDidAccept(() => {
-            const [item] = picker.selectedItems;
-            if (item) {
-                this.quickInputService.quickAccess.show(item.prefix, { preserveValue: true });
-            }
-        }));
-        disposables.add(picker.onDidChangeValue(value => {
-            const providerDescriptor = this.registry.getQuickAccessProvider(value.substr(HelpQuickAccessProvider_1.PREFIX.length));
-            if (providerDescriptor && providerDescriptor.prefix && providerDescriptor.prefix !== HelpQuickAccessProvider_1.PREFIX) {
-                this.quickInputService.quickAccess.show(providerDescriptor.prefix, { preserveValue: true });
-            }
-        }));
-        picker.items = this.getQuickAccessProviders().filter(p => p.prefix !== HelpQuickAccessProvider_1.PREFIX);
-        return disposables;
-    }
-    getQuickAccessProviders() {
-        const providers = this.registry
-            .getQuickAccessProviders()
-            .sort((providerA, providerB) => providerA.prefix.localeCompare(providerB.prefix))
-            .flatMap(provider => this.createPicks(provider));
-        return providers;
-    }
-    createPicks(provider) {
-        return ( provider.helpEntries.map(helpEntry => {
-            const prefix = helpEntry.prefix || provider.prefix;
-            const label = prefix || '\u2026' ;
-            return {
-                prefix,
-                label,
-                keybinding: helpEntry.commandId ? this.keybindingService.lookupKeybinding(helpEntry.commandId) : undefined,
-                ariaLabel: ( localizeWithPath(
-                    'vs/platform/quickinput/browser/helpQuickAccess',
-                    'helpPickAriaLabel',
-                    "{0}, {1}",
-                    label,
-                    helpEntry.description
-                )),
-                description: helpEntry.description
-            };
-        }));
-    }
-};
-HelpQuickAccessProvider = HelpQuickAccessProvider_1 = ( __decorate([
-    ( __param(0, IQuickInputService)),
-    ( __param(1, IKeybindingService))
-], HelpQuickAccessProvider));
-export { HelpQuickAccessProvider };

package/vscode/src/vs/platform/remote/common/managedSocket.js

@@ -1,96 +0,0 @@
-import { VSBuffer, encodeBase64 } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { PauseableEmitter, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { SocketDiagnostics } from '../../../base/parts/ipc/common/ipc.net.js';
-const makeRawSocketHeaders = (path, query, deubgLabel) => {
-    const buffer = ( new Uint8Array(16));
-    for (let i = 0; i < 16; i++) {
-        buffer[i] = Math.round(Math.random() * 256);
-    }
-    const nonce = encodeBase64(VSBuffer.wrap(buffer));
-    const headers = [
-        `GET ws://localhost${path}?${query}&skipWebSocketFrames=true HTTP/1.1`,
-        `Connection: Upgrade`,
-        `Upgrade: websocket`,
-        `Sec-WebSocket-Key: ${nonce}`
-    ];
-    return headers.join('\r\n') + '\r\n\r\n';
-};
-const socketRawEndHeaderSequence = VSBuffer.fromString('\r\n\r\n');
-async function connectManagedSocket(socket, path, query, debugLabel, half) {
-    socket.write(VSBuffer.fromString(makeRawSocketHeaders(path, query)));
-    const d = ( new DisposableStore());
-    try {
-        return await ( new Promise((resolve, reject) => {
-            let dataSoFar;
-            d.add(socket.onData(d_1 => {
-                if (!dataSoFar) {
-                    dataSoFar = d_1;
-                }
-                else {
-                    dataSoFar = VSBuffer.concat([dataSoFar, d_1], dataSoFar.byteLength + d_1.byteLength);
-                }
-                const index = dataSoFar.indexOf(socketRawEndHeaderSequence);
-                if (index === -1) {
-                    return;
-                }
-                resolve(socket);
-                socket.pauseData();
-                const rest = dataSoFar.slice(index + socketRawEndHeaderSequence.byteLength);
-                if (rest.byteLength) {
-                    half.onData.fire(rest);
-                }
-            }));
-            d.add(socket.onClose(err => reject(err ?? ( new Error('socket closed')))));
-            d.add(socket.onEnd(() => reject(( new Error('socket ended')))));
-        }));
-    }
-    catch (e) {
-        socket.dispose();
-        throw e;
-    }
-    finally {
-        d.dispose();
-    }
-}
-class ManagedSocket extends Disposable {
-    constructor(debugLabel, half) {
-        super();
-        this.debugLabel = debugLabel;
-        this.pausableDataEmitter = this._register(( new PauseableEmitter()));
-        this.onData = (...args) => {
-            if (this.pausableDataEmitter.isPaused) {
-                queueMicrotask(() => this.pausableDataEmitter.resume());
-            }
-            return this.pausableDataEmitter.event(...args);
-        };
-        this.didDisposeEmitter = this._register(( new Emitter()));
-        this.onDidDispose = this.didDisposeEmitter.event;
-        this.ended = false;
-        this._register(half.onData);
-        this._register(half.onData.event(data => this.pausableDataEmitter.fire(data)));
-        this.onClose = this._register(half.onClose).event;
-        this.onEnd = this._register(half.onEnd).event;
-    }
-    pauseData() {
-        this.pausableDataEmitter.pause();
-    }
-    drain() {
-        return Promise.resolve();
-    }
-    end() {
-        this.ended = true;
-        this.closeRemote();
-    }
-    traceSocketEvent(type, data) {
-        SocketDiagnostics.traceSocketEvent(this, this.debugLabel, type, data);
-    }
-    dispose() {
-        if (!this.ended) {
-            this.closeRemote();
-        }
-        this.didDisposeEmitter.fire();
-        super.dispose();
-    }
-}
-export { ManagedSocket, connectManagedSocket, makeRawSocketHeaders, socketRawEndHeaderSequence };

package/vscode/src/vs/workbench/api/browser/mainThreadAiEmbeddingVector.js

@@ -1,29 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IAiEmbeddingVectorService } from '../../services/aiEmbeddingVector/common/aiEmbeddingVectorService.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-let MainThreadAiEmbeddingVector = class MainThreadAiEmbeddingVector extends Disposable {
-    constructor(context, _AiEmbeddingVectorService) {
-        super();
-        this._AiEmbeddingVectorService = _AiEmbeddingVectorService;
-        this._registrations = this._register(( new DisposableMap()));
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiEmbeddingVector));
-    }
-    $registerAiEmbeddingVectorProvider(model, handle) {
-        const provider = {
-            provideAiEmbeddingVector: (strings, token) => {
-                return this._proxy.$provideAiEmbeddingVector(handle, strings, token);
-            },
-        };
-        this._registrations.set(handle, this._AiEmbeddingVectorService.registerAiEmbeddingVectorProvider(model, provider));
-    }
-    $unregisterAiEmbeddingVectorProvider(handle) {
-        this._registrations.deleteAndDispose(handle);
-    }
-};
-MainThreadAiEmbeddingVector = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadAiEmbeddingVector),
-    ( __param(1, IAiEmbeddingVectorService))
-], MainThreadAiEmbeddingVector);
-export { MainThreadAiEmbeddingVector };

package/vscode/src/vs/workbench/api/browser/mainThreadAiRelatedInformation.js

@@ -1,33 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
-import { Disposable, DisposableMap } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { IAiRelatedInformationService } from '../../services/aiRelatedInformation/common/aiRelatedInformation.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-let MainThreadAiRelatedInformation = class MainThreadAiRelatedInformation extends Disposable {
-    constructor(context, _aiRelatedInformationService) {
-        super();
-        this._aiRelatedInformationService = _aiRelatedInformationService;
-        this._registrations = this._register(( new DisposableMap()));
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostAiRelatedInformation));
-    }
-    $getAiRelatedInformation(query, types) {
-        return this._aiRelatedInformationService.getRelatedInformation(query, types, CancellationToken.None);
-    }
-    $registerAiRelatedInformationProvider(handle, type) {
-        const provider = {
-            provideAiRelatedInformation: (query, token) => {
-                return this._proxy.$provideAiRelatedInformation(handle, query, token);
-            },
-        };
-        this._registrations.set(handle, this._aiRelatedInformationService.registerAiRelatedInformationProvider(type, provider));
-    }
-    $unregisterAiRelatedInformationProvider(handle) {
-        this._registrations.deleteAndDispose(handle);
-    }
-};
-MainThreadAiRelatedInformation = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadAiRelatedInformation),
-    ( __param(1, IAiRelatedInformationService))
-], MainThreadAiRelatedInformation);
-export { MainThreadAiRelatedInformation };