@codingame/monaco-vscode-monarch-service-override 4.5.0

package/index.d.ts

@@ -0,0 +1 @@
+export { default } from './monarch.js';

package/index.js

@@ -0,0 +1 @@
+export { default } from './monarch.js';

package/monarch.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/monarch.js

@@ -0,0 +1,8 @@
+import './vscode/src/vs/editor/standalone/browser/inspectTokens/inspectTokens.js';
+import './vscode/src/vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast.js';
+
+function getServiceOverride() {
+    return {};
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@codingame/monaco-vscode-monarch-service-override",
+  "version": "4.5.0",
+  "keywords": [],
+  "author": {
+    "name": "CodinGame",
+    "url": "http://www.codingame.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:CodinGame/monaco-vscode-api.git"
+  },
+  "type": "module",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - monarch service-override",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./vscode/*": {
+      "default": "./vscode/src/*.js"
+    }
+  },
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@4.5.0"
+  }
+}

package/vscode/src/vs/editor/standalone/browser/inspectTokens/inspectTokens.css.js

@@ -0,0 +1,6 @@
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-editor .tokens-inspect-widget{background-color:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);color:var(--vscode-editorHoverWidget-foreground);padding:10px;user-select:text;-webkit-user-select:text;z-index:50}.monaco-editor.hc-black .tokens-inspect-widget,.monaco-editor.hc-light .tokens-inspect-widget{border-width:2px}.monaco-editor .tokens-inspect-widget .tokens-inspect-separator{background-color:var(--vscode-editorHoverWidget-border);border:0;height:1px}.monaco-editor .tokens-inspect-widget .tm-token{font-family:var(--monaco-monospace-font)}.monaco-editor .tokens-inspect-widget .tm-token-length{float:right;font-size:60%;font-weight:400}.monaco-editor .tokens-inspect-widget .tm-metadata-table{width:100%}.monaco-editor .tokens-inspect-widget .tm-metadata-value{font-family:var(--monaco-monospace-font);text-align:right}.monaco-editor .tokens-inspect-widget .tm-token-type{font-family:var(--monaco-monospace-font)}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/editor/standalone/browser/inspectTokens/inspectTokens.js

@@ -0,0 +1,227 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import './inspectTokens.css.js';
+import { reset, $, append } from 'vscode/vscode/vs/base/browser/dom';
+import { Color } from 'vscode/vscode/vs/base/common/color';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { EditorAction, registerEditorContribution, registerEditorAction } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { TokenizationRegistry } from 'vscode/vscode/vs/editor/common/languages';
+import { TokenMetadata } from 'vscode/vscode/vs/editor/common/encodedTokenAttributes';
+import { NullState, nullTokenize, nullTokenizeEncoded } from 'vscode/vscode/vs/editor/common/languages/nullTokenize';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { IStandaloneThemeService } from 'vscode/vscode/vs/editor/standalone/common/standaloneTheme';
+import { InspectTokensNLS } from 'vscode/vscode/vs/editor/common/standaloneStrings';
+
+var InspectTokensController_1;
+let InspectTokensController = class InspectTokensController extends Disposable {
+    static { InspectTokensController_1 = this; }
+    static { this.ID = 'editor.contrib.inspectTokens'; }
+    static get(editor) {
+        return editor.getContribution(InspectTokensController_1.ID);
+    }
+    constructor(editor, standaloneColorService, languageService) {
+        super();
+        this._editor = editor;
+        this._languageService = languageService;
+        this._widget = null;
+        this._register(this._editor.onDidChangeModel((e) => this.stop()));
+        this._register(this._editor.onDidChangeModelLanguage((e) => this.stop()));
+        this._register(TokenizationRegistry.onDidChange((e) => this.stop()));
+        this._register(this._editor.onKeyUp((e) => e.keyCode === 9  && this.stop()));
+    }
+    dispose() {
+        this.stop();
+        super.dispose();
+    }
+    launch() {
+        if (this._widget) {
+            return;
+        }
+        if (!this._editor.hasModel()) {
+            return;
+        }
+        this._widget = ( new InspectTokensWidget(this._editor, this._languageService));
+    }
+    stop() {
+        if (this._widget) {
+            this._widget.dispose();
+            this._widget = null;
+        }
+    }
+};
+InspectTokensController = InspectTokensController_1 = ( __decorate([
+    ( __param(1, IStandaloneThemeService)),
+    ( __param(2, ILanguageService))
+], InspectTokensController));
+class InspectTokens extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.inspectTokens',
+            label: InspectTokensNLS.inspectTokensAction,
+            alias: 'Developer: Inspect Tokens',
+            precondition: undefined
+        });
+    }
+    run(accessor, editor) {
+        const controller = InspectTokensController.get(editor);
+        controller?.launch();
+    }
+}
+function renderTokenText(tokenText) {
+    let result = '';
+    for (let charIndex = 0, len = tokenText.length; charIndex < len; charIndex++) {
+        const charCode = tokenText.charCodeAt(charIndex);
+        switch (charCode) {
+            case 9 :
+                result += '\u2192';
+                break;
+            case 32 :
+                result += '\u00B7';
+                break;
+            default:
+                result += String.fromCharCode(charCode);
+        }
+    }
+    return result;
+}
+function getSafeTokenizationSupport(languageIdCodec, languageId) {
+    const tokenizationSupport = TokenizationRegistry.get(languageId);
+    if (tokenizationSupport) {
+        return tokenizationSupport;
+    }
+    const encodedLanguageId = languageIdCodec.encodeLanguageId(languageId);
+    return {
+        getInitialState: () => NullState,
+        tokenize: (line, hasEOL, state) => nullTokenize(languageId, state),
+        tokenizeEncoded: (line, hasEOL, state) => nullTokenizeEncoded(encodedLanguageId, state)
+    };
+}
+class InspectTokensWidget extends Disposable {
+    static { this._ID = 'editor.contrib.inspectTokensWidget'; }
+    constructor(editor, languageService) {
+        super();
+        this.allowEditorOverflow = true;
+        this._editor = editor;
+        this._languageService = languageService;
+        this._model = this._editor.getModel();
+        this._domNode = document.createElement('div');
+        this._domNode.className = 'tokens-inspect-widget';
+        this._tokenizationSupport = getSafeTokenizationSupport(this._languageService.languageIdCodec, this._model.getLanguageId());
+        this._compute(this._editor.getPosition());
+        this._register(this._editor.onDidChangeCursorPosition((e) => this._compute(this._editor.getPosition())));
+        this._editor.addContentWidget(this);
+    }
+    dispose() {
+        this._editor.removeContentWidget(this);
+        super.dispose();
+    }
+    getId() {
+        return InspectTokensWidget._ID;
+    }
+    _compute(position) {
+        const data = this._getTokensAtLine(position.lineNumber);
+        let token1Index = 0;
+        for (let i = data.tokens1.length - 1; i >= 0; i--) {
+            const t = data.tokens1[i];
+            if (position.column - 1 >= t.offset) {
+                token1Index = i;
+                break;
+            }
+        }
+        let token2Index = 0;
+        for (let i = (data.tokens2.length >>> 1); i >= 0; i--) {
+            if (position.column - 1 >= data.tokens2[(i << 1)]) {
+                token2Index = i;
+                break;
+            }
+        }
+        const lineContent = this._model.getLineContent(position.lineNumber);
+        let tokenText = '';
+        if (token1Index < data.tokens1.length) {
+            const tokenStartIndex = data.tokens1[token1Index].offset;
+            const tokenEndIndex = token1Index + 1 < data.tokens1.length ? data.tokens1[token1Index + 1].offset : lineContent.length;
+            tokenText = lineContent.substring(tokenStartIndex, tokenEndIndex);
+        }
+        reset(this._domNode, $('h2.tm-token', undefined, renderTokenText(tokenText), $('span.tm-token-length', undefined, `${tokenText.length} ${tokenText.length === 1 ? 'char' : 'chars'}`)));
+        append(this._domNode, $('hr.tokens-inspect-separator', { 'style': 'clear:both' }));
+        const metadata = (token2Index << 1) + 1 < data.tokens2.length ? this._decodeMetadata(data.tokens2[(token2Index << 1) + 1]) : null;
+        append(this._domNode, $('table.tm-metadata-table', undefined, $('tbody', undefined, $('tr', undefined, $('td.tm-metadata-key', undefined, 'language'), $('td.tm-metadata-value', undefined, `${metadata ? metadata.languageId : '-?-'}`)), $('tr', undefined, $('td.tm-metadata-key', undefined, 'token type'), $('td.tm-metadata-value', undefined, `${metadata ? this._tokenTypeToString(metadata.tokenType) : '-?-'}`)), $('tr', undefined, $('td.tm-metadata-key', undefined, 'font style'), $('td.tm-metadata-value', undefined, `${metadata ? this._fontStyleToString(metadata.fontStyle) : '-?-'}`)), $('tr', undefined, $('td.tm-metadata-key', undefined, 'foreground'), $('td.tm-metadata-value', undefined, `${metadata ? Color.Format.CSS.formatHex(metadata.foreground) : '-?-'}`)), $('tr', undefined, $('td.tm-metadata-key', undefined, 'background'), $('td.tm-metadata-value', undefined, `${metadata ? Color.Format.CSS.formatHex(metadata.background) : '-?-'}`)))));
+        append(this._domNode, $('hr.tokens-inspect-separator'));
+        if (token1Index < data.tokens1.length) {
+            append(this._domNode, $('span.tm-token-type', undefined, data.tokens1[token1Index].type));
+        }
+        this._editor.layoutContentWidget(this);
+    }
+    _decodeMetadata(metadata) {
+        const colorMap = TokenizationRegistry.getColorMap();
+        const languageId = TokenMetadata.getLanguageId(metadata);
+        const tokenType = TokenMetadata.getTokenType(metadata);
+        const fontStyle = TokenMetadata.getFontStyle(metadata);
+        const foreground = TokenMetadata.getForeground(metadata);
+        const background = TokenMetadata.getBackground(metadata);
+        return {
+            languageId: this._languageService.languageIdCodec.decodeLanguageId(languageId),
+            tokenType: tokenType,
+            fontStyle: fontStyle,
+            foreground: colorMap[foreground],
+            background: colorMap[background]
+        };
+    }
+    _tokenTypeToString(tokenType) {
+        switch (tokenType) {
+            case 0 : return 'Other';
+            case 1 : return 'Comment';
+            case 2 : return 'String';
+            case 3 : return 'RegEx';
+            default: return '??';
+        }
+    }
+    _fontStyleToString(fontStyle) {
+        let r = '';
+        if (fontStyle & 1 ) {
+            r += 'italic ';
+        }
+        if (fontStyle & 2 ) {
+            r += 'bold ';
+        }
+        if (fontStyle & 4 ) {
+            r += 'underline ';
+        }
+        if (fontStyle & 8 ) {
+            r += 'strikethrough ';
+        }
+        if (r.length === 0) {
+            r = '---';
+        }
+        return r;
+    }
+    _getTokensAtLine(lineNumber) {
+        const stateBeforeLine = this._getStateBeforeLine(lineNumber);
+        const tokenizationResult1 = this._tokenizationSupport.tokenize(this._model.getLineContent(lineNumber), true, stateBeforeLine);
+        const tokenizationResult2 = this._tokenizationSupport.tokenizeEncoded(this._model.getLineContent(lineNumber), true, stateBeforeLine);
+        return {
+            startState: stateBeforeLine,
+            tokens1: tokenizationResult1.tokens,
+            tokens2: tokenizationResult2.tokens,
+            endState: tokenizationResult1.endState
+        };
+    }
+    _getStateBeforeLine(lineNumber) {
+        let state = this._tokenizationSupport.getInitialState();
+        for (let i = 1; i < lineNumber; i++) {
+            const tokenizationResult = this._tokenizationSupport.tokenize(this._model.getLineContent(i), true, state);
+            state = tokenizationResult.endState;
+        }
+        return state;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    getPosition() {
+        return {
+            position: this._editor.getPosition(),
+            preference: [2 , 1 ]
+        };
+    }
+}
+registerEditorContribution(InspectTokensController.ID, InspectTokensController, 4 );
+registerEditorAction(InspectTokens);

package/vscode/src/vs/editor/standalone/browser/toggleHighContrast/toggleHighContrast.js

@@ -0,0 +1,30 @@
+import { EditorAction, registerEditorAction } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { IStandaloneThemeService } from 'vscode/vscode/vs/editor/standalone/common/standaloneTheme';
+import { ToggleHighContrastNLS } from 'vscode/vscode/vs/editor/common/standaloneStrings';
+import { isHighContrast, isDark } from 'vscode/vscode/vs/platform/theme/common/theme';
+import { VS_DARK_THEME_NAME, VS_LIGHT_THEME_NAME, HC_BLACK_THEME_NAME, HC_LIGHT_THEME_NAME } from 'vscode/vscode/vs/editor/standalone/browser/standaloneThemeService';
+
+class ToggleHighContrast extends EditorAction {
+    constructor() {
+        super({
+            id: 'editor.action.toggleHighContrast',
+            label: ToggleHighContrastNLS.toggleHighContrast,
+            alias: 'Toggle High Contrast Theme',
+            precondition: undefined
+        });
+        this._originalThemeName = null;
+    }
+    run(accessor, editor) {
+        const standaloneThemeService = accessor.get(IStandaloneThemeService);
+        const currentTheme = standaloneThemeService.getColorTheme();
+        if (isHighContrast(currentTheme.type)) {
+            standaloneThemeService.setTheme(this._originalThemeName || (isDark(currentTheme.type) ? VS_DARK_THEME_NAME : VS_LIGHT_THEME_NAME));
+            this._originalThemeName = null;
+        }
+        else {
+            standaloneThemeService.setTheme(isDark(currentTheme.type) ? HC_BLACK_THEME_NAME : HC_LIGHT_THEME_NAME);
+            this._originalThemeName = currentTheme.themeName;
+        }
+    }
+}
+registerEditorAction(ToggleHighContrast);