@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

package/vscode/src/vs/platform/remote/browser/browserSocketFactory.js

@@ -1,193 +0,0 @@
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-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 { SocketDiagnostics } from '../../../base/parts/ipc/common/ipc.net.js';
-import { RemoteAuthorityResolverError, RemoteAuthorityResolverErrorCode } from '../common/remoteAuthorityResolver.js';
-class BrowserWebSocket extends Disposable {
-    traceSocketEvent(type, data) {
-        SocketDiagnostics.traceSocketEvent(this._socket, this._debugLabel, type, data);
-    }
-    constructor(url, debugLabel) {
-        super();
-        this._onData = ( new Emitter());
-        this.onData = this._onData.event;
-        this._onOpen = this._register(( new Emitter()));
-        this.onOpen = this._onOpen.event;
-        this._onClose = this._register(( new Emitter()));
-        this.onClose = this._onClose.event;
-        this._onError = this._register(( new Emitter()));
-        this.onError = this._onError.event;
-        this._debugLabel = debugLabel;
-        this._socket = ( new WebSocket(url));
-        this.traceSocketEvent("created" , { type: 'BrowserWebSocket', url });
-        this._fileReader = ( new FileReader());
-        this._queue = [];
-        this._isReading = false;
-        this._isClosed = false;
-        this._fileReader.onload = (event) => {
-            this._isReading = false;
-            const buff = event.target.result;
-            this.traceSocketEvent("read" , buff);
-            this._onData.fire(buff);
-            if (this._queue.length > 0) {
-                enqueue(this._queue.shift());
-            }
-        };
-        const enqueue = (blob) => {
-            if (this._isReading) {
-                this._queue.push(blob);
-                return;
-            }
-            this._isReading = true;
-            this._fileReader.readAsArrayBuffer(blob);
-        };
-        this._socketMessageListener = (ev) => {
-            const blob = ev.data;
-            this.traceSocketEvent("browserWebSocketBlobReceived" , { type: blob.type, size: blob.size });
-            enqueue(blob);
-        };
-        this._socket.addEventListener('message', this._socketMessageListener);
-        this._register(dom.addDisposableListener(this._socket, 'open', (e) => {
-            this.traceSocketEvent("open" );
-            this._onOpen.fire();
-        }));
-        let pendingErrorEvent = null;
-        const sendPendingErrorNow = () => {
-            const err = pendingErrorEvent;
-            pendingErrorEvent = null;
-            this._onError.fire(err);
-        };
-        const errorRunner = this._register(( new RunOnceScheduler(sendPendingErrorNow, 0)));
-        const sendErrorSoon = (err) => {
-            errorRunner.cancel();
-            pendingErrorEvent = err;
-            errorRunner.schedule();
-        };
-        const sendErrorNow = (err) => {
-            errorRunner.cancel();
-            pendingErrorEvent = err;
-            sendPendingErrorNow();
-        };
-        this._register(dom.addDisposableListener(this._socket, 'close', (e) => {
-            this.traceSocketEvent("close" , { code: e.code, reason: e.reason, wasClean: e.wasClean });
-            this._isClosed = true;
-            if (pendingErrorEvent) {
-                if (!window.navigator.onLine) {
-                    sendErrorNow(( new RemoteAuthorityResolverError(
-                        'Browser is offline',
-                        RemoteAuthorityResolverErrorCode.TemporarilyNotAvailable,
-                        e
-                    )));
-                }
-                else {
-                    if (!e.wasClean) {
-                        sendErrorNow(( new RemoteAuthorityResolverError(
-                            e.reason || `WebSocket close with status code ${e.code}`,
-                            RemoteAuthorityResolverErrorCode.TemporarilyNotAvailable,
-                            e
-                        )));
-                    }
-                    else {
-                        errorRunner.cancel();
-                        sendPendingErrorNow();
-                    }
-                }
-            }
-            this._onClose.fire({ code: e.code, reason: e.reason, wasClean: e.wasClean, event: e });
-        }));
-        this._register(dom.addDisposableListener(this._socket, 'error', (err) => {
-            this.traceSocketEvent("error" , { message: err?.message });
-            sendErrorSoon(err);
-        }));
-    }
-    send(data) {
-        if (this._isClosed) {
-            return;
-        }
-        this.traceSocketEvent("write" , data);
-        this._socket.send(data);
-    }
-    close() {
-        this._isClosed = true;
-        this.traceSocketEvent("close" );
-        this._socket.close();
-        this._socket.removeEventListener('message', this._socketMessageListener);
-        this.dispose();
-    }
-}
-const defaultWebSocketFactory = new class {
-    create(url, debugLabel) {
-        return ( new BrowserWebSocket(url, debugLabel));
-    }
-};
-class BrowserSocket {
-    traceSocketEvent(type, data) {
-        if (typeof this.socket.traceSocketEvent === 'function') {
-            this.socket.traceSocketEvent(type, data);
-        }
-        else {
-            SocketDiagnostics.traceSocketEvent(this.socket, this.debugLabel, type, data);
-        }
-    }
-    constructor(socket, debugLabel) {
-        this.socket = socket;
-        this.debugLabel = debugLabel;
-    }
-    dispose() {
-        this.socket.close();
-    }
-    onData(listener) {
-        return this.socket.onData((data) => listener(VSBuffer.wrap(( new Uint8Array(data)))));
-    }
-    onClose(listener) {
-        const adapter = (e) => {
-            if (typeof e === 'undefined') {
-                listener(e);
-            }
-            else {
-                listener({
-                    type: 1 ,
-                    code: e.code,
-                    reason: e.reason,
-                    wasClean: e.wasClean,
-                    event: e.event
-                });
-            }
-        };
-        return this.socket.onClose(adapter);
-    }
-    onEnd(listener) {
-        return Disposable.None;
-    }
-    write(buffer) {
-        this.socket.send(buffer.buffer);
-    }
-    end() {
-        this.socket.close();
-    }
-    drain() {
-        return Promise.resolve();
-    }
-}
-class BrowserSocketFactory {
-    constructor(webSocketFactory) {
-        this._webSocketFactory = webSocketFactory || defaultWebSocketFactory;
-    }
-    supports(connectTo) {
-        return true;
-    }
-    connect({ host, port }, path, query, debugLabel) {
-        return ( new Promise((resolve, reject) => {
-            const webSocketSchema = (/^https:/.test(window.location.href) ? 'wss' : 'ws');
-            const socket = this._webSocketFactory.create(`${webSocketSchema}://${(/:/.test(host) && !/\[/.test(host)) ? `[${host}]` : host}:${port}${path}?${query}&skipWebSocketFrames=false`, debugLabel);
-            const errorListener = socket.onError(reject);
-            socket.onOpen(() => {
-                errorListener.dispose();
-                resolve(( new BrowserSocket(socket, debugLabel)));
-            });
-        }));
-    }
-}
-export { BrowserSocketFactory };

package/vscode/src/vs/platform/remote/browser/remoteAuthorityResolverService.js

@@ -1,107 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
-import * as errors from 'monaco-editor/esm/vs/base/common/errors.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { RemoteAuthorities } from 'monaco-editor/esm/vs/base/common/network.js';
-import * as performance from 'monaco-editor/esm/vs/base/common/performance.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
-import { getRemoteAuthorityPrefix, WebSocketRemoteConnection } from '../common/remoteAuthorityResolver.js';
-import { getRemoteServerRootPath, parseAuthorityWithOptionalPort } from 'monaco-editor/esm/vs/platform/remote/common/remoteHosts.js';
-let RemoteAuthorityResolverService = class RemoteAuthorityResolverService extends Disposable {
-    constructor(isWorkbenchOptionsBasedResolution, connectionToken, resourceUriProvider, productService, _logService) {
-        super();
-        this._logService = _logService;
-        this._onDidChangeConnectionData = this._register(( new Emitter()));
-        this.onDidChangeConnectionData = this._onDidChangeConnectionData.event;
-        this._resolveAuthorityRequests = ( new Map());
-        this._cache = ( new Map());
-        this._connectionToken = connectionToken;
-        this._connectionTokens = ( new Map());
-        this._isWorkbenchOptionsBasedResolution = isWorkbenchOptionsBasedResolution;
-        if (resourceUriProvider) {
-            RemoteAuthorities.setDelegate(resourceUriProvider);
-        }
-        RemoteAuthorities.setServerRootPath(getRemoteServerRootPath(productService));
-    }
-    async resolveAuthority(authority) {
-        let result = this._resolveAuthorityRequests.get(authority);
-        if (!result) {
-            result = ( new DeferredPromise());
-            this._resolveAuthorityRequests.set(authority, result);
-            if (this._isWorkbenchOptionsBasedResolution) {
-                this._doResolveAuthority(authority).then(v => result.complete(v), (err) => result.error(err));
-            }
-        }
-        return result.p;
-    }
-    async getCanonicalURI(uri) {
-        return uri;
-    }
-    getConnectionData(authority) {
-        if (!( this._cache.has(authority))) {
-            return null;
-        }
-        const resolverResult = this._cache.get(authority);
-        const connectionToken = this._connectionTokens.get(authority) || resolverResult.authority.connectionToken;
-        return {
-            connectTo: resolverResult.authority.connectTo,
-            connectionToken: connectionToken
-        };
-    }
-    async _doResolveAuthority(authority) {
-        const authorityPrefix = getRemoteAuthorityPrefix(authority);
-        const sw = StopWatch.create(false);
-        this._logService.info(`Resolving connection token (${authorityPrefix})...`);
-        performance.mark(`code/willResolveConnectionToken/${authorityPrefix}`);
-        const connectionToken = await Promise.resolve(this._connectionTokens.get(authority) || this._connectionToken);
-        performance.mark(`code/didResolveConnectionToken/${authorityPrefix}`);
-        this._logService.info(`Resolved connection token (${authorityPrefix}) after ${sw.elapsed()} ms`);
-        const defaultPort = (/^https:/.test(window.location.href) ? 443 : 80);
-        const { host, port } = parseAuthorityWithOptionalPort(authority, defaultPort);
-        const result = { authority: { authority, connectTo: ( new WebSocketRemoteConnection(host, port)), connectionToken } };
-        RemoteAuthorities.set(authority, host, port);
-        this._cache.set(authority, result);
-        this._onDidChangeConnectionData.fire();
-        return result;
-    }
-    _clearResolvedAuthority(authority) {
-        if (( this._resolveAuthorityRequests.has(authority))) {
-            this._resolveAuthorityRequests.get(authority).cancel();
-            this._resolveAuthorityRequests.delete(authority);
-        }
-    }
-    _setResolvedAuthority(resolvedAuthority, options) {
-        if (( this._resolveAuthorityRequests.has(resolvedAuthority.authority))) {
-            const request = this._resolveAuthorityRequests.get(resolvedAuthority.authority);
-            if (resolvedAuthority.connectTo.type === 0 ) {
-                RemoteAuthorities.set(resolvedAuthority.authority, resolvedAuthority.connectTo.host, resolvedAuthority.connectTo.port);
-            }
-            if (resolvedAuthority.connectionToken) {
-                RemoteAuthorities.setConnectionToken(resolvedAuthority.authority, resolvedAuthority.connectionToken);
-            }
-            request.complete({ authority: resolvedAuthority, options });
-            this._onDidChangeConnectionData.fire();
-        }
-    }
-    _setResolvedAuthorityError(authority, err) {
-        if (( this._resolveAuthorityRequests.has(authority))) {
-            const request = this._resolveAuthorityRequests.get(authority);
-            request.error(errors.ErrorNoTelemetry.fromError(err));
-        }
-    }
-    _setAuthorityConnectionToken(authority, connectionToken) {
-        this._connectionTokens.set(authority, connectionToken);
-        RemoteAuthorities.setConnectionToken(authority, connectionToken);
-        this._onDidChangeConnectionData.fire();
-    }
-    _setCanonicalURIProvider(provider) {
-    }
-};
-RemoteAuthorityResolverService = ( __decorate([
-    ( __param(3, IProductService)),
-    ( __param(4, ILogService))
-], RemoteAuthorityResolverService));
-export { RemoteAuthorityResolverService };

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

@@ -1,41 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/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 };