@codingame/monaco-vscode-api 4.4.1 → 4.5.0

package/vscode/src/vs/platform/extensionRecommendations/common/extensionRecommendations.js

@@ -1,10 +0,0 @@
-import { createDecorator } from '../../instantiation/common/instantiation.js';
-function RecommendationSourceToString(source) {
-    switch (source) {
-        case 1 : return 'file';
-        case 2 : return 'workspace';
-        case 3 : return 'exe';
-    }
-}
-const IExtensionRecommendationNotificationService = ( createDecorator('IExtensionRecommendationNotificationService'));
-export { IExtensionRecommendationNotificationService, RecommendationSourceToString };

package/vscode/src/vs/platform/languagePacks/common/localizedStrings.js

@@ -1,10 +0,0 @@
-import { localizeWithPath } from '../../../nls.js';
-const open = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'open', 'open'));
-const close = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'close', 'close'));
-const find = ( localizeWithPath('vs/platform/languagePacks/common/localizedStrings', 'find', 'find'));
-var localizedStrings = {
-    open: open,
-    close: close,
-    find: find
-};
-export { localizedStrings as default };

package/vscode/src/vs/platform/remote/common/remoteExtensionsScanner.d.ts

@@ -1,13 +0,0 @@
-import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
-import { URI } from '../../../base/common/uri.js';
-import { IExtensionDescription } from '../../extensions/common/extensions.js';
-
-declare const IRemoteExtensionsScannerService: ServiceIdentifier<IRemoteExtensionsScannerService>;
-interface IRemoteExtensionsScannerService {
-    readonly _serviceBrand: undefined;
-    whenExtensionsReady(): Promise<void>;
-    scanExtensions(): Promise<IExtensionDescription[]>;
-    scanSingleExtension(extensionLocation: URI, isBuiltin: boolean): Promise<IExtensionDescription | null>;
-}
-
-export { IRemoteExtensionsScannerService };

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

@@ -1,30 +0,0 @@
-import { toDisposable } from '../../../base/common/lifecycle.js';
-import { createDecorator } from '../../instantiation/common/instantiation.js';
-const IRemoteSocketFactoryService = ( createDecorator('remoteSocketFactoryService'));
-class RemoteSocketFactoryService {
-    constructor() {
-        this.factories = {};
-    }
-    register(type, factory) {
-        this.factories[type] ??= [];
-        this.factories[type].push(factory);
-        return toDisposable(() => {
-            const idx = this.factories[type]?.indexOf(factory);
-            if (typeof idx === 'number' && idx >= 0) {
-                this.factories[type]?.splice(idx, 1);
-            }
-        });
-    }
-    getSocketFactory(messagePassing) {
-        const factories = (this.factories[messagePassing.type] || []);
-        return factories.find(factory => factory.supports(messagePassing));
-    }
-    connect(connectTo, path, query, debugLabel) {
-        const socketFactory = this.getSocketFactory(connectTo);
-        if (!socketFactory) {
-            throw new Error(`No socket factory found for ${connectTo}`);
-        }
-        return socketFactory.connect(connectTo, path, query, debugLabel);
-    }
-}
-export { IRemoteSocketFactoryService, RemoteSocketFactoryService };

package/vscode/src/vs/platform/secrets/common/secrets.js

@@ -1,127 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { SequencerByKey } from '../../../base/common/async.js';
-import { IEncryptionService } from '../../encryption/common/encryptionService.js';
-import { createDecorator } from '../../instantiation/common/instantiation.js';
-import { InMemoryStorageService, IStorageService } from '../../storage/common/storage.js';
-import { Emitter } from '../../../base/common/event.js';
-import { ILogService } from '../../log/common/log.js';
-import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
-import { Lazy } from '../../../base/common/lazy.js';
-const ISecretStorageService = ( createDecorator('secretStorageService'));
-let BaseSecretStorageService = class BaseSecretStorageService extends Disposable {
-    constructor(_useInMemoryStorage, _storageService, _encryptionService, _logService) {
-        super();
-        this._useInMemoryStorage = _useInMemoryStorage;
-        this._storageService = _storageService;
-        this._encryptionService = _encryptionService;
-        this._logService = _logService;
-        this._storagePrefix = 'secret://';
-        this.onDidChangeSecretEmitter = this._register(( new Emitter()));
-        this.onDidChangeSecret = this.onDidChangeSecretEmitter.event;
-        this._sequencer = ( new SequencerByKey());
-        this._type = 'unknown';
-        this._onDidChangeValueDisposable = this._register(( new DisposableStore()));
-        this._lazyStorageService = ( new Lazy(() => this.initialize()));
-    }
-    get type() {
-        return this._type;
-    }
-    get resolvedStorageService() {
-        return this._lazyStorageService.value;
-    }
-    get(key) {
-        return this._sequencer.queue(key, async () => {
-            const storageService = await this.resolvedStorageService;
-            const fullKey = this.getKey(key);
-            this._logService.trace('[secrets] getting secret for key:', fullKey);
-            const encrypted = storageService.get(fullKey, -1 );
-            if (!encrypted) {
-                this._logService.trace('[secrets] no secret found for key:', fullKey);
-                return undefined;
-            }
-            try {
-                this._logService.trace('[secrets] decrypting gotten secret for key:', fullKey);
-                const result = this._type === 'in-memory'
-                    ? encrypted
-                    : await this._encryptionService.decrypt(encrypted);
-                this._logService.trace('[secrets] decrypted secret for key:', fullKey);
-                return result;
-            }
-            catch (e) {
-                this._logService.error(e);
-                this.delete(key);
-                return undefined;
-            }
-        });
-    }
-    set(key, value) {
-        return this._sequencer.queue(key, async () => {
-            const storageService = await this.resolvedStorageService;
-            this._logService.trace('[secrets] encrypting secret for key:', key);
-            let encrypted;
-            try {
-                encrypted = this._type === 'in-memory'
-                    ? value
-                    : await this._encryptionService.encrypt(value);
-            }
-            catch (e) {
-                this._logService.error(e);
-                throw e;
-            }
-            const fullKey = this.getKey(key);
-            this._logService.trace('[secrets] storing encrypted secret for key:', fullKey);
-            storageService.store(fullKey, encrypted, -1 , 1 );
-            this._logService.trace('[secrets] stored encrypted secret for key:', fullKey);
-        });
-    }
-    delete(key) {
-        return this._sequencer.queue(key, async () => {
-            const storageService = await this.resolvedStorageService;
-            const fullKey = this.getKey(key);
-            this._logService.trace('[secrets] deleting secret for key:', fullKey);
-            storageService.remove(fullKey, -1 );
-            this._logService.trace('[secrets] deleted secret for key:', fullKey);
-        });
-    }
-    async initialize() {
-        let storageService;
-        if (!this._useInMemoryStorage && (await this._encryptionService.isEncryptionAvailable())) {
-            this._logService.trace(`[SecretStorageService] Encryption is available, using persisted storage`);
-            this._type = 'persisted';
-            storageService = this._storageService;
-        }
-        else {
-            if (this._type === 'in-memory') {
-                return this._storageService;
-            }
-            this._logService.trace('[SecretStorageService] Encryption is not available, falling back to in-memory storage');
-            this._type = 'in-memory';
-            storageService = this._register(( new InMemoryStorageService()));
-        }
-        this._onDidChangeValueDisposable.clear();
-        this._onDidChangeValueDisposable.add(storageService.onDidChangeValue(-1 , undefined, this._onDidChangeValueDisposable)(e => {
-            this.onDidChangeValue(e.key);
-        }));
-        return storageService;
-    }
-    reinitialize() {
-        this._lazyStorageService = ( new Lazy(() => this.initialize()));
-    }
-    onDidChangeValue(key) {
-        if (!key.startsWith(this._storagePrefix)) {
-            return;
-        }
-        const secretKey = key.slice(this._storagePrefix.length);
-        this._logService.trace(`[SecretStorageService] Notifying change in value for secret: ${secretKey}`);
-        this.onDidChangeSecretEmitter.fire(secretKey);
-    }
-    getKey(key) {
-        return `${this._storagePrefix}${key}`;
-    }
-};
-BaseSecretStorageService = ( __decorate([
-    ( __param(1, IStorageService)),
-    ( __param(2, IEncryptionService)),
-    ( __param(3, ILogService))
-], BaseSecretStorageService));
-export { BaseSecretStorageService, ISecretStorageService };

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

@@ -1,41 +0,0 @@
-import { Emitter } from '../../../../base/common/event.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-class BufferMarkCapability extends Disposable {
-    constructor(_terminal) {
-        super();
-        this._terminal = _terminal;
-        this.type = 4 ;
-        this._idToMarkerMap = ( new Map());
-        this._anonymousMarkers = ( new Map());
-        this._onMarkAdded = this._register(( new Emitter()));
-        this.onMarkAdded = this._onMarkAdded.event;
-    }
-    *markers() {
-        for (const m of ( this._idToMarkerMap.values())) {
-            yield m;
-        }
-        for (const m of ( this._anonymousMarkers.values())) {
-            yield m;
-        }
-    }
-    addMark(properties) {
-        const marker = properties?.marker || this._terminal.registerMarker();
-        const id = properties?.id;
-        if (!marker) {
-            return;
-        }
-        if (id) {
-            this._idToMarkerMap.set(id, marker);
-            marker.onDispose(() => this._idToMarkerMap.delete(id));
-        }
-        else {
-            this._anonymousMarkers.set(marker.id, marker);
-            marker.onDispose(() => this._anonymousMarkers.delete(marker.id));
-        }
-        this._onMarkAdded.fire({ marker, id, hidden: properties?.hidden, hoverMessage: properties?.hoverMessage });
-    }
-    getMark(id) {
-        return this._idToMarkerMap.get(id);
-    }
-}
-export { BufferMarkCapability };

package/vscode/src/vs/platform/terminal/common/capabilities/commandDetection/terminalCommand.js

@@ -1,272 +0,0 @@
-class TerminalCommand {
-    get command() { return this._properties.command; }
-    get isTrusted() { return this._properties.isTrusted; }
-    get timestamp() { return this._properties.timestamp; }
-    get duration() { return this._properties.duration; }
-    get promptStartMarker() { return this._properties.promptStartMarker; }
-    get marker() { return this._properties.marker; }
-    get endMarker() { return this._properties.endMarker; }
-    set endMarker(value) { this._properties.endMarker = value; }
-    get executedMarker() { return this._properties.executedMarker; }
-    get aliases() { return this._properties.aliases; }
-    get wasReplayed() { return this._properties.wasReplayed; }
-    get cwd() { return this._properties.cwd; }
-    get exitCode() { return this._properties.exitCode; }
-    get commandStartLineContent() { return this._properties.commandStartLineContent; }
-    get markProperties() { return this._properties.markProperties; }
-    get executedX() { return this._properties.executedX; }
-    get startX() { return this._properties.startX; }
-    constructor(_xterm, _properties) {
-        this._xterm = _xterm;
-        this._properties = _properties;
-    }
-    static deserialize(xterm, serialized, isCommandStorageDisabled) {
-        const buffer = xterm.buffer.normal;
-        const marker = serialized.startLine !== undefined ? xterm.registerMarker(serialized.startLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        if (!marker) {
-            return undefined;
-        }
-        const promptStartMarker = serialized.promptStartLine !== undefined ? xterm.registerMarker(serialized.promptStartLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        const endMarker = serialized.endLine !== undefined ? xterm.registerMarker(serialized.endLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        const executedMarker = serialized.executedLine !== undefined ? xterm.registerMarker(serialized.executedLine - (buffer.baseY + buffer.cursorY)) : undefined;
-        const newCommand = ( new TerminalCommand(xterm, {
-            command: isCommandStorageDisabled ? '' : serialized.command,
-            isTrusted: serialized.isTrusted,
-            promptStartMarker,
-            marker,
-            startX: serialized.startX,
-            endMarker,
-            executedMarker,
-            executedX: serialized.executedX,
-            timestamp: serialized.timestamp,
-            duration: serialized.duration,
-            cwd: serialized.cwd,
-            commandStartLineContent: serialized.commandStartLineContent,
-            exitCode: serialized.exitCode,
-            markProperties: serialized.markProperties,
-            aliases: undefined,
-            wasReplayed: true
-        }));
-        return newCommand;
-    }
-    serialize(isCommandStorageDisabled) {
-        return {
-            promptStartLine: this.promptStartMarker?.line,
-            startLine: this.marker?.line,
-            startX: undefined,
-            endLine: this.endMarker?.line,
-            executedLine: this.executedMarker?.line,
-            executedX: this.executedX,
-            command: isCommandStorageDisabled ? '' : this.command,
-            isTrusted: this.isTrusted,
-            cwd: this.cwd,
-            exitCode: this.exitCode,
-            commandStartLineContent: this.commandStartLineContent,
-            timestamp: this.timestamp,
-            duration: this.duration,
-            markProperties: this.markProperties,
-        };
-    }
-    getOutput() {
-        if (!this.executedMarker || !this.endMarker) {
-            return undefined;
-        }
-        const startLine = this.executedMarker.line;
-        const endLine = this.endMarker.line;
-        if (startLine === endLine) {
-            return undefined;
-        }
-        let output = '';
-        let line;
-        for (let i = startLine; i < endLine; i++) {
-            line = this._xterm.buffer.active.getLine(i);
-            if (!line) {
-                continue;
-            }
-            output += line.translateToString(!line.isWrapped) + (line.isWrapped ? '' : '\n');
-        }
-        return output === '' ? undefined : output;
-    }
-    getOutputMatch(outputMatcher) {
-        if (!this.executedMarker || !this.endMarker) {
-            return undefined;
-        }
-        const endLine = this.endMarker.line;
-        if (endLine === -1) {
-            return undefined;
-        }
-        const buffer = this._xterm.buffer.active;
-        const startLine = Math.max(this.executedMarker.line, 0);
-        const matcher = outputMatcher.lineMatcher;
-        const linesToCheck = typeof matcher === 'string' ? 1 : outputMatcher.length || countNewLines(matcher);
-        const lines = [];
-        let match;
-        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, this._xterm.cols));
-                if (!match) {
-                    match = lines[0].match(matcher);
-                }
-                if (lines.length >= linesToCheck) {
-                    break;
-                }
-            }
-        }
-        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, this._xterm.cols));
-                if (!match) {
-                    match = lines[lines.length - 1].match(matcher);
-                }
-                if (lines.length >= linesToCheck) {
-                    break;
-                }
-            }
-        }
-        return match ? { regexMatch: match, outputLines: lines } : undefined;
-    }
-    hasOutput() {
-        return (!this.executedMarker?.isDisposed &&
-            !this.endMarker?.isDisposed &&
-            !!(this.executedMarker &&
-                this.endMarker &&
-                this.executedMarker.line < this.endMarker.line));
-    }
-    getPromptRowCount() {
-        return getPromptRowCount(this, this._xterm.buffer.active);
-    }
-    getCommandRowCount() {
-        return getCommandRowCount(this);
-    }
-}
-class PartialTerminalCommand {
-    constructor(_xterm) {
-        this._xterm = _xterm;
-    }
-    serialize(cwd) {
-        if (!this.commandStartMarker) {
-            return undefined;
-        }
-        return {
-            promptStartLine: this.promptStartMarker?.line,
-            startLine: this.commandStartMarker.line,
-            startX: this.commandStartX,
-            endLine: undefined,
-            executedLine: undefined,
-            executedX: undefined,
-            command: '',
-            isTrusted: true,
-            cwd,
-            exitCode: undefined,
-            commandStartLineContent: undefined,
-            timestamp: 0,
-            duration: 0,
-            markProperties: undefined
-        };
-    }
-    promoteToFullCommand(cwd, exitCode, ignoreCommandLine, markProperties) {
-        if (exitCode === undefined && this.command === undefined) {
-            this.command = '';
-        }
-        if ((this.command !== undefined && !this.command.startsWith('\\')) || ignoreCommandLine) {
-            return ( new TerminalCommand(this._xterm, {
-                command: ignoreCommandLine ? '' : (this.command || ''),
-                isTrusted: !!this.isTrusted,
-                promptStartMarker: this.promptStartMarker,
-                marker: this.commandStartMarker,
-                startX: this.commandStartX,
-                endMarker: this.commandFinishedMarker,
-                executedMarker: this.commandExecutedMarker,
-                executedX: this.commandExecutedX,
-                timestamp: Date.now(),
-                duration: this.commandDuration || 0,
-                cwd,
-                exitCode,
-                commandStartLineContent: this.commandStartLineContent,
-                markProperties
-            }));
-        }
-        return undefined;
-    }
-    markExecutedTime() {
-        if (this.commandExecutedTimestamp === undefined) {
-            this.commandExecutedTimestamp = Date.now();
-        }
-    }
-    markFinishedTime() {
-        if (this.commandDuration === undefined && this.commandExecutedTimestamp !== undefined) {
-            this.commandDuration = Date.now() - this.commandExecutedTimestamp;
-        }
-    }
-    getPromptRowCount() {
-        return getPromptRowCount(this, this._xterm.buffer.active);
-    }
-    getCommandRowCount() {
-        return getCommandRowCount(this);
-    }
-}
-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 countNewLines(regex) {
-    if (!regex.multiline) {
-        return 1;
-    }
-    const source = regex.source;
-    let count = 1;
-    let i = source.indexOf('\\n');
-    while (i !== -1) {
-        count++;
-        i = source.indexOf('\\n', i + 1);
-    }
-    return count;
-}
-function getPromptRowCount(command, buffer) {
-    const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
-    if (!marker || !command.promptStartMarker) {
-        return 1;
-    }
-    let promptRowCount = 1;
-    let promptStartLine = command.promptStartMarker.line;
-    while (promptStartLine < marker.line && (buffer.getLine(promptStartLine)?.translateToString(true) ?? '').length === 0) {
-        promptStartLine++;
-    }
-    promptRowCount = marker.line - promptStartLine + 1;
-    return promptRowCount;
-}
-function getCommandRowCount(command) {
-    const marker = 'hasOutput' in command ? command.marker : command.commandStartMarker;
-    const executedMarker = 'hasOutput' in command ? command.executedMarker : command.commandExecutedMarker;
-    if (!marker || !executedMarker) {
-        return 1;
-    }
-    const commandExecutedLine = Math.max(executedMarker.line, marker.line);
-    let commandRowCount = commandExecutedLine - marker.line + 1;
-    const executedX = 'hasOutput' in command ? command.executedX : command.commandExecutedX;
-    if (executedX === 0) {
-        commandRowCount--;
-    }
-    return commandRowCount;
-}
-export { PartialTerminalCommand, TerminalCommand };