@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/browser/services/openerService.js

@@ -0,0 +1,201 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { windowOpenNoOpener } from '../../../base/browser/dom.js';
+import { mainWindow } from '../../../base/browser/window.js';
+import { CancellationToken } from '../../../base/common/cancellation.js';
+import { LinkedList } from '../../../base/common/linkedList.js';
+import { ResourceMap } from '../../../base/common/map.js';
+import { parse } from '../../../base/common/marshalling.js';
+import { matchesSomeScheme, Schemas, matchesScheme } from '../../../base/common/network.js';
+import { normalizePath } from '../../../base/common/resources.js';
+import { URI } from '../../../base/common/uri.js';
+import { ICodeEditorService } from './codeEditorService.js';
+import { ICommandService } from '../../../platform/commands/common/commands.js';
+import { EditorOpenSource } from '../../../platform/editor/common/editor.js';
+import { extractSelection } from '../../../platform/opener/common/opener.js';
+let CommandOpener = class CommandOpener {
+    constructor(_commandService) {
+        this._commandService = _commandService;
+    }
+    async open(target, options) {
+        if (!matchesScheme(target, Schemas.command)) {
+            return false;
+        }
+        if (!options?.allowCommands) {
+            return true;
+        }
+        if (typeof target === 'string') {
+            target = ( URI.parse(target));
+        }
+        if (Array.isArray(options.allowCommands)) {
+            if (!options.allowCommands.includes(target.path)) {
+                return true;
+            }
+        }
+        let args = [];
+        try {
+            args = parse(decodeURIComponent(target.query));
+        }
+        catch {
+            try {
+                args = parse(target.query);
+            }
+            catch {
+            }
+        }
+        if (!Array.isArray(args)) {
+            args = [args];
+        }
+        await this._commandService.executeCommand(target.path, ...args);
+        return true;
+    }
+};
+CommandOpener = ( __decorate([
+    ( __param(0, ICommandService))
+], CommandOpener));
+let EditorOpener = class EditorOpener {
+    constructor(_editorService) {
+        this._editorService = _editorService;
+    }
+    async open(target, options) {
+        if (typeof target === 'string') {
+            target = ( URI.parse(target));
+        }
+        const { selection, uri } = extractSelection(target);
+        target = uri;
+        if (target.scheme === Schemas.file) {
+            target = normalizePath(target);
+        }
+        await this._editorService.openCodeEditor({
+            resource: target,
+            options: {
+                selection,
+                source: options?.fromUserGesture ? EditorOpenSource.USER : EditorOpenSource.API,
+                ...options?.editorOptions
+            }
+        }, this._editorService.getFocusedCodeEditor(), options?.openToSide);
+        return true;
+    }
+};
+EditorOpener = ( __decorate([
+    ( __param(0, ICodeEditorService))
+], EditorOpener));
+let OpenerService = class OpenerService {
+    constructor(editorService, commandService) {
+        this._openers = ( new LinkedList());
+        this._validators = ( new LinkedList());
+        this._resolvers = ( new LinkedList());
+        this._resolvedUriTargets = ( new ResourceMap(uri => ( uri.with({ path: null, fragment: null, query: null }).toString())));
+        this._externalOpeners = ( new LinkedList());
+        this._defaultExternalOpener = {
+            openExternal: async (href) => {
+                if (matchesSomeScheme(href, Schemas.http, Schemas.https)) {
+                    windowOpenNoOpener(href);
+                }
+                else {
+                    mainWindow.location.href = href;
+                }
+                return true;
+            }
+        };
+        this._openers.push({
+            open: async (target, options) => {
+                if (options?.openExternal || matchesSomeScheme(target, Schemas.mailto, Schemas.http, Schemas.https, Schemas.vsls)) {
+                    await this._doOpenExternal(target, options);
+                    return true;
+                }
+                return false;
+            }
+        });
+        this._openers.push(( new CommandOpener(commandService)));
+        this._openers.push(( new EditorOpener(editorService)));
+    }
+    registerOpener(opener) {
+        const remove = this._openers.unshift(opener);
+        return { dispose: remove };
+    }
+    registerValidator(validator) {
+        const remove = this._validators.push(validator);
+        return { dispose: remove };
+    }
+    registerExternalUriResolver(resolver) {
+        const remove = this._resolvers.push(resolver);
+        return { dispose: remove };
+    }
+    setDefaultExternalOpener(externalOpener) {
+        this._defaultExternalOpener = externalOpener;
+    }
+    registerExternalOpener(opener) {
+        const remove = this._externalOpeners.push(opener);
+        return { dispose: remove };
+    }
+    async open(target, options) {
+        const targetURI = typeof target === 'string' ? ( URI.parse(target)) : target;
+        const validationTarget = this._resolvedUriTargets.get(targetURI) ?? target;
+        for (const validator of this._validators) {
+            if (!(await validator.shouldOpen(validationTarget, options))) {
+                return false;
+            }
+        }
+        for (const opener of this._openers) {
+            const handled = await opener.open(target, options);
+            if (handled) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async resolveExternalUri(resource, options) {
+        for (const resolver of this._resolvers) {
+            try {
+                const result = await resolver.resolveExternalUri(resource, options);
+                if (result) {
+                    if (!( this._resolvedUriTargets.has(result.resolved))) {
+                        this._resolvedUriTargets.set(result.resolved, resource);
+                    }
+                    return result;
+                }
+            }
+            catch {
+            }
+        }
+        throw new Error('Could not resolve external URI: ' + resource.toString());
+    }
+    async _doOpenExternal(resource, options) {
+        const uri = typeof resource === 'string' ? ( URI.parse(resource)) : resource;
+        let externalUri;
+        try {
+            externalUri = (await this.resolveExternalUri(uri, options)).resolved;
+        }
+        catch {
+            externalUri = uri;
+        }
+        let href;
+        if (typeof resource === 'string' && ( uri.toString()) === ( externalUri.toString())) {
+            href = resource;
+        }
+        else {
+            href = encodeURI(( externalUri.toString(true)));
+        }
+        if (options?.allowContributedOpeners) {
+            const preferredOpenerId = typeof options?.allowContributedOpeners === 'string' ? options?.allowContributedOpeners : undefined;
+            for (const opener of this._externalOpeners) {
+                const didOpen = await opener.openExternal(href, {
+                    sourceUri: uri,
+                    preferredOpenerId,
+                }, CancellationToken.None);
+                if (didOpen) {
+                    return true;
+                }
+            }
+        }
+        return this._defaultExternalOpener.openExternal(href, { sourceUri: uri }, CancellationToken.None);
+    }
+    dispose() {
+        this._validators.clear();
+    }
+};
+OpenerService = ( __decorate([
+    ( __param(0, ICodeEditorService)),
+    ( __param(1, ICommandService))
+], OpenerService));
+export { OpenerService };

package/vscode/src/vs/editor/browser/services/webWorker.js

@@ -0,0 +1,57 @@
+import { getAllMethodNames } from '../../../base/common/objects.js';
+import { EditorWorkerClient } from './editorWorkerService.js';
+function createWebWorker(modelService, languageConfigurationService, opts) {
+    return ( new MonacoWebWorkerImpl(modelService, languageConfigurationService, opts));
+}
+class MonacoWebWorkerImpl extends EditorWorkerClient {
+    constructor(modelService, languageConfigurationService, opts) {
+        super(modelService, opts.keepIdleModels || false, opts.label, languageConfigurationService);
+        this._foreignModuleId = opts.moduleId;
+        this._foreignModuleCreateData = opts.createData || null;
+        this._foreignModuleHost = opts.host || null;
+        this._foreignProxy = null;
+    }
+    fhr(method, args) {
+        if (!this._foreignModuleHost || typeof this._foreignModuleHost[method] !== 'function') {
+            return Promise.reject(( new Error('Missing method ' + method + ' or missing main thread foreign host.')));
+        }
+        try {
+            return Promise.resolve(this._foreignModuleHost[method].apply(this._foreignModuleHost, args));
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    _getForeignProxy() {
+        if (!this._foreignProxy) {
+            this._foreignProxy = this._getProxy().then((proxy) => {
+                const foreignHostMethods = this._foreignModuleHost ? getAllMethodNames(this._foreignModuleHost) : [];
+                return proxy.loadForeignModule(this._foreignModuleId, this._foreignModuleCreateData, foreignHostMethods).then((foreignMethods) => {
+                    this._foreignModuleCreateData = null;
+                    const proxyMethodRequest = (method, args) => {
+                        return proxy.fmr(method, args);
+                    };
+                    const createProxyMethod = (method, proxyMethodRequest) => {
+                        return function () {
+                            const args = Array.prototype.slice.call(arguments, 0);
+                            return proxyMethodRequest(method, args);
+                        };
+                    };
+                    const foreignProxy = {};
+                    for (const foreignMethod of foreignMethods) {
+                        foreignProxy[foreignMethod] = createProxyMethod(foreignMethod, proxyMethodRequest);
+                    }
+                    return foreignProxy;
+                });
+            });
+        }
+        return this._foreignProxy;
+    }
+    getProxy() {
+        return this._getForeignProxy();
+    }
+    withSyncedResources(resources) {
+        return this._withSyncedResources(resources).then(_ => ( this.getProxy()));
+    }
+}
+export { createWebWorker };

package/vscode/src/vs/editor/browser/stableEditorScroll.js

@@ -0,0 +1,50 @@
+class StableEditorScrollState {
+    static capture(editor) {
+        if (editor.getScrollTop() === 0 || editor.hasPendingScrollAnimation()) {
+            return ( new StableEditorScrollState(editor.getScrollTop(), editor.getContentHeight(), null, 0, null));
+        }
+        let visiblePosition = null;
+        let visiblePositionScrollDelta = 0;
+        const visibleRanges = editor.getVisibleRanges();
+        if (visibleRanges.length > 0) {
+            visiblePosition = visibleRanges[0].getStartPosition();
+            const visiblePositionScrollTop = editor.getTopForPosition(visiblePosition.lineNumber, visiblePosition.column);
+            visiblePositionScrollDelta = editor.getScrollTop() - visiblePositionScrollTop;
+        }
+        return ( new StableEditorScrollState(
+            editor.getScrollTop(),
+            editor.getContentHeight(),
+            visiblePosition,
+            visiblePositionScrollDelta,
+            editor.getPosition()
+        ));
+    }
+    constructor(_initialScrollTop, _initialContentHeight, _visiblePosition, _visiblePositionScrollDelta, _cursorPosition) {
+        this._initialScrollTop = _initialScrollTop;
+        this._initialContentHeight = _initialContentHeight;
+        this._visiblePosition = _visiblePosition;
+        this._visiblePositionScrollDelta = _visiblePositionScrollDelta;
+        this._cursorPosition = _cursorPosition;
+    }
+    restore(editor) {
+        if (this._initialContentHeight === editor.getContentHeight() && this._initialScrollTop === editor.getScrollTop()) {
+            return;
+        }
+        if (this._visiblePosition) {
+            const visiblePositionScrollTop = editor.getTopForPosition(this._visiblePosition.lineNumber, this._visiblePosition.column);
+            editor.setScrollTop(visiblePositionScrollTop + this._visiblePositionScrollDelta);
+        }
+    }
+    restoreRelativeVerticalPositionOfCursor(editor) {
+        if (this._initialContentHeight === editor.getContentHeight() && this._initialScrollTop === editor.getScrollTop()) {
+            return;
+        }
+        const currentCursorPosition = editor.getPosition();
+        if (!this._cursorPosition || !currentCursorPosition) {
+            return;
+        }
+        const offset = editor.getTopForLineNumber(currentCursorPosition.lineNumber) - editor.getTopForLineNumber(this._cursorPosition.lineNumber);
+        editor.setScrollTop(editor.getScrollTop() + offset);
+    }
+}
+export { StableEditorScrollState };

package/vscode/src/vs/editor/browser/view/domLineBreaksComputer.js

@@ -0,0 +1,287 @@
+import { createTrustedTypesPolicy } from '../../../base/browser/trustedTypes.js';
+import { firstNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
+import { assertIsDefined } from '../../../base/common/types.js';
+import { applyFontInfo } from '../config/domFontInfo.js';
+import { StringBuilder } from '../../common/core/stringBuilder.js';
+import { ModelLineProjectionData } from '../../common/modelLineProjectionData.js';
+import { LineInjectedText } from '../../common/textModelEvents.js';
+const ttPolicy = createTrustedTypesPolicy('domLineBreaksComputer', { createHTML: value => value });
+class DOMLineBreaksComputerFactory {
+    static create(targetWindow) {
+        return ( new DOMLineBreaksComputerFactory(( new WeakRef(targetWindow))));
+    }
+    constructor(targetWindow) {
+        this.targetWindow = targetWindow;
+    }
+    createLineBreaksComputer(fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak) {
+        const requests = [];
+        const injectedTexts = [];
+        return {
+            addRequest: (lineText, injectedText, previousLineBreakData) => {
+                requests.push(lineText);
+                injectedTexts.push(injectedText);
+            },
+            finalize: () => {
+                return createLineBreaks(assertIsDefined(this.targetWindow.deref()), requests, fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak, injectedTexts);
+            }
+        };
+    }
+}
+function createLineBreaks(targetWindow, requests, fontInfo, tabSize, firstLineBreakColumn, wrappingIndent, wordBreak, injectedTextsPerLine) {
+    function createEmptyLineBreakWithPossiblyInjectedText(requestIdx) {
+        const injectedTexts = injectedTextsPerLine[requestIdx];
+        if (injectedTexts) {
+            const lineText = LineInjectedText.applyInjectedText(requests[requestIdx], injectedTexts);
+            const injectionOptions = ( injectedTexts.map(t => t.options));
+            const injectionOffsets = ( injectedTexts.map(text => text.column - 1));
+            return ( new ModelLineProjectionData(injectionOffsets, injectionOptions, [lineText.length], [], 0));
+        }
+        else {
+            return null;
+        }
+    }
+    if (firstLineBreakColumn === -1) {
+        const result = [];
+        for (let i = 0, len = requests.length; i < len; i++) {
+            result[i] = createEmptyLineBreakWithPossiblyInjectedText(i);
+        }
+        return result;
+    }
+    const overallWidth = Math.round(firstLineBreakColumn * fontInfo.typicalHalfwidthCharacterWidth);
+    const additionalIndent = (wrappingIndent === 3  ? 2 : wrappingIndent === 2  ? 1 : 0);
+    const additionalIndentSize = Math.round(tabSize * additionalIndent);
+    const additionalIndentLength = Math.ceil(fontInfo.spaceWidth * additionalIndentSize);
+    const containerDomNode = document.createElement('div');
+    applyFontInfo(containerDomNode, fontInfo);
+    const sb = ( new StringBuilder(10000));
+    const firstNonWhitespaceIndices = [];
+    const wrappedTextIndentLengths = [];
+    const renderLineContents = [];
+    const allCharOffsets = [];
+    const allVisibleColumns = [];
+    for (let i = 0; i < requests.length; i++) {
+        const lineContent = LineInjectedText.applyInjectedText(requests[i], injectedTextsPerLine[i]);
+        let firstNonWhitespaceIndex$1 = 0;
+        let wrappedTextIndentLength = 0;
+        let width = overallWidth;
+        if (wrappingIndent !== 0 ) {
+            firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineContent);
+            if (firstNonWhitespaceIndex$1 === -1) {
+                firstNonWhitespaceIndex$1 = 0;
+            }
+            else {
+                for (let i = 0; i < firstNonWhitespaceIndex$1; i++) {
+                    const charWidth = (lineContent.charCodeAt(i) === 9
+                        ? (tabSize - (wrappedTextIndentLength % tabSize))
+                        : 1);
+                    wrappedTextIndentLength += charWidth;
+                }
+                const indentWidth = Math.ceil(fontInfo.spaceWidth * wrappedTextIndentLength);
+                if (indentWidth + fontInfo.typicalFullwidthCharacterWidth > overallWidth) {
+                    firstNonWhitespaceIndex$1 = 0;
+                    wrappedTextIndentLength = 0;
+                }
+                else {
+                    width = overallWidth - indentWidth;
+                }
+            }
+        }
+        const renderLineContent = lineContent.substr(firstNonWhitespaceIndex$1);
+        const tmp = renderLine(renderLineContent, wrappedTextIndentLength, tabSize, width, sb, additionalIndentLength);
+        firstNonWhitespaceIndices[i] = firstNonWhitespaceIndex$1;
+        wrappedTextIndentLengths[i] = wrappedTextIndentLength;
+        renderLineContents[i] = renderLineContent;
+        allCharOffsets[i] = tmp[0];
+        allVisibleColumns[i] = tmp[1];
+    }
+    const html = sb.build();
+    const trustedhtml = ttPolicy?.createHTML(html) ?? html;
+    containerDomNode.innerHTML = trustedhtml;
+    containerDomNode.style.position = 'absolute';
+    containerDomNode.style.top = '10000';
+    if (wordBreak === 'keepAll') {
+        containerDomNode.style.wordBreak = 'keep-all';
+        containerDomNode.style.overflowWrap = 'anywhere';
+    }
+    else {
+        containerDomNode.style.wordBreak = 'inherit';
+        containerDomNode.style.overflowWrap = 'break-word';
+    }
+    targetWindow.document.body.appendChild(containerDomNode);
+    const range = document.createRange();
+    const lineDomNodes = Array.prototype.slice.call(containerDomNode.children, 0);
+    const result = [];
+    for (let i = 0; i < requests.length; i++) {
+        const lineDomNode = lineDomNodes[i];
+        const breakOffsets = readLineBreaks(range, lineDomNode, renderLineContents[i], allCharOffsets[i]);
+        if (breakOffsets === null) {
+            result[i] = createEmptyLineBreakWithPossiblyInjectedText(i);
+            continue;
+        }
+        const firstNonWhitespaceIndex = firstNonWhitespaceIndices[i];
+        const wrappedTextIndentLength = wrappedTextIndentLengths[i] + additionalIndentSize;
+        const visibleColumns = allVisibleColumns[i];
+        const breakOffsetsVisibleColumn = [];
+        for (let j = 0, len = breakOffsets.length; j < len; j++) {
+            breakOffsetsVisibleColumn[j] = visibleColumns[breakOffsets[j]];
+        }
+        if (firstNonWhitespaceIndex !== 0) {
+            for (let j = 0, len = breakOffsets.length; j < len; j++) {
+                breakOffsets[j] += firstNonWhitespaceIndex;
+            }
+        }
+        let injectionOptions;
+        let injectionOffsets;
+        const curInjectedTexts = injectedTextsPerLine[i];
+        if (curInjectedTexts) {
+            injectionOptions = ( curInjectedTexts.map(t => t.options));
+            injectionOffsets = ( curInjectedTexts.map(text => text.column - 1));
+        }
+        else {
+            injectionOptions = null;
+            injectionOffsets = null;
+        }
+        result[i] = ( new ModelLineProjectionData(
+            injectionOffsets,
+            injectionOptions,
+            breakOffsets,
+            breakOffsetsVisibleColumn,
+            wrappedTextIndentLength
+        ));
+    }
+    targetWindow.document.body.removeChild(containerDomNode);
+    return result;
+}
+function renderLine(lineContent, initialVisibleColumn, tabSize, width, sb, wrappingIndentLength) {
+    if (wrappingIndentLength !== 0) {
+        const hangingOffset = String(wrappingIndentLength);
+        sb.appendString('<div style="text-indent: -');
+        sb.appendString(hangingOffset);
+        sb.appendString('px; padding-left: ');
+        sb.appendString(hangingOffset);
+        sb.appendString('px; box-sizing: border-box; width:');
+    }
+    else {
+        sb.appendString('<div style="width:');
+    }
+    sb.appendString(String(width));
+    sb.appendString('px;">');
+    const len = lineContent.length;
+    let visibleColumn = initialVisibleColumn;
+    let charOffset = 0;
+    const charOffsets = [];
+    const visibleColumns = [];
+    let nextCharCode = ((0 < len ? lineContent.charCodeAt(0) : 0) );
+    sb.appendString('<span>');
+    for (let charIndex = 0; charIndex < len; charIndex++) {
+        if (charIndex !== 0 && charIndex % 16384  === 0) {
+            sb.appendString('</span><span>');
+        }
+        charOffsets[charIndex] = charOffset;
+        visibleColumns[charIndex] = visibleColumn;
+        const charCode = nextCharCode;
+        nextCharCode = ((charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0) );
+        let producedCharacters = 1;
+        let charWidth = 1;
+        switch (charCode) {
+            case 9 :
+                producedCharacters = (tabSize - (visibleColumn % tabSize));
+                charWidth = producedCharacters;
+                for (let space = 1; space <= producedCharacters; space++) {
+                    if (space < producedCharacters) {
+                        sb.appendCharCode(0xA0);
+                    }
+                    else {
+                        sb.appendASCIICharCode(32 );
+                    }
+                }
+                break;
+            case 32 :
+                if (nextCharCode === 32 ) {
+                    sb.appendCharCode(0xA0);
+                }
+                else {
+                    sb.appendASCIICharCode(32 );
+                }
+                break;
+            case 60 :
+                sb.appendString('&lt;');
+                break;
+            case 62 :
+                sb.appendString('&gt;');
+                break;
+            case 38 :
+                sb.appendString('&amp;');
+                break;
+            case 0 :
+                sb.appendString('&#00;');
+                break;
+            case 65279 :
+            case 8232 :
+            case 8233 :
+            case 133 :
+                sb.appendCharCode(0xFFFD);
+                break;
+            default:
+                if (isFullWidthCharacter(charCode)) {
+                    charWidth++;
+                }
+                if (charCode < 32) {
+                    sb.appendCharCode(9216 + charCode);
+                }
+                else {
+                    sb.appendCharCode(charCode);
+                }
+        }
+        charOffset += producedCharacters;
+        visibleColumn += charWidth;
+    }
+    sb.appendString('</span>');
+    charOffsets[lineContent.length] = charOffset;
+    visibleColumns[lineContent.length] = visibleColumn;
+    sb.appendString('</div>');
+    return [charOffsets, visibleColumns];
+}
+function readLineBreaks(range, lineDomNode, lineContent, charOffsets) {
+    if (lineContent.length <= 1) {
+        return null;
+    }
+    const spans = Array.prototype.slice.call(lineDomNode.children, 0);
+    const breakOffsets = [];
+    try {
+        discoverBreaks(range, spans, charOffsets, 0, null, lineContent.length - 1, null, breakOffsets);
+    }
+    catch (err) {
+        console.log(err);
+        return null;
+    }
+    if (breakOffsets.length === 0) {
+        return null;
+    }
+    breakOffsets.push(lineContent.length);
+    return breakOffsets;
+}
+function discoverBreaks(range, spans, charOffsets, low, lowRects, high, highRects, result) {
+    if (low === high) {
+        return;
+    }
+    lowRects = lowRects || readClientRect(range, spans, charOffsets[low], charOffsets[low + 1]);
+    highRects = highRects || readClientRect(range, spans, charOffsets[high], charOffsets[high + 1]);
+    if (Math.abs(lowRects[0].top - highRects[0].top) <= 0.1) {
+        return;
+    }
+    if (low + 1 === high) {
+        result.push(high);
+        return;
+    }
+    const mid = low + ((high - low) / 2) | 0;
+    const midRects = readClientRect(range, spans, charOffsets[mid], charOffsets[mid + 1]);
+    discoverBreaks(range, spans, charOffsets, low, lowRects, mid, midRects, result);
+    discoverBreaks(range, spans, charOffsets, mid, midRects, high, highRects, result);
+}
+function readClientRect(range, spans, startOffset, endOffset) {
+    range.setStart(spans[((startOffset / 16384) ) | 0].firstChild, startOffset % 16384 );
+    range.setEnd(spans[((endOffset / 16384) ) | 0].firstChild, endOffset % 16384 );
+    return range.getClientRects();
+}
+export { DOMLineBreaksComputerFactory };

package/vscode/src/vs/editor/browser/view/dynamicViewOverlay.js

@@ -0,0 +1,4 @@
+import { ViewEventHandler } from '../../common/viewEventHandler.js';
+class DynamicViewOverlay extends ViewEventHandler {
+}
+export { DynamicViewOverlay };