@codingame/monaco-editor-wrapper 3.10.0 → 4.0.0-monaco-update.2

package/dist/node_modules/monaco-vim/lib/index.js

@@ -0,0 +1,71 @@
+import { __exports as lib } from '../../../_virtual/index.js';
+import './cm/keymap_vim.js';
+import './statusbar.js';
+import { __exports as keymap_vim } from '../../../_virtual/keymap_vim.js';
+import { __exports as statusbar } from '../../../_virtual/statusbar.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	Object.defineProperty(exports, "StatusBar", {
+	  enumerable: true,
+	  get: function get() {
+	    return _statusbar["default"];
+	  }
+	});
+	Object.defineProperty(exports, "VimMode", {
+	  enumerable: true,
+	  get: function get() {
+	    return _keymap_vim["default"];
+	  }
+	});
+	exports.initVimMode = initVimMode;
+
+	var _keymap_vim = _interopRequireDefault(keymap_vim);
+
+	var _statusbar = _interopRequireDefault(statusbar);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+	function initVimMode(editor) {
+	  var statusbarNode = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+	  var StatusBarClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _statusbar["default"];
+	  var sanitizer = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+	  var vimAdapter = new _keymap_vim["default"](editor);
+
+	  if (!statusbarNode) {
+	    vimAdapter.attach();
+	    return vimAdapter;
+	  }
+
+	  var statusBar = new StatusBarClass(statusbarNode, editor, sanitizer);
+	  var keyBuffer = "";
+	  vimAdapter.on("vim-mode-change", function (mode) {
+	    statusBar.setMode(mode);
+	  });
+	  vimAdapter.on("vim-keypress", function (key) {
+	    if (key === ":") {
+	      keyBuffer = "";
+	    } else {
+	      keyBuffer += key;
+	    }
+
+	    statusBar.setKeyBuffer(keyBuffer);
+	  });
+	  vimAdapter.on("vim-command-done", function () {
+	    keyBuffer = "";
+	    statusBar.setKeyBuffer(keyBuffer);
+	  });
+	  vimAdapter.on("dispose", function () {
+	    statusBar.toggleVisibility(false);
+	    statusBar.closeInput();
+	    statusBar.clear();
+	  });
+	  statusBar.toggleVisibility(true);
+	  vimAdapter.setStatusBar(statusBar);
+	  vimAdapter.attach();
+	  return vimAdapter;
+	} 
+} (lib));

package/dist/node_modules/monaco-vim/lib/statusbar.js

@@ -0,0 +1,239 @@
+import { __exports as statusbar } from '../../../_virtual/statusbar.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports["default"] = void 0;
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+	var VimStatusBar = /*#__PURE__*/function () {
+	  function VimStatusBar(node, editor) {
+	    var _this = this;
+
+	    var sanitizer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+	    _classCallCheck(this, VimStatusBar);
+
+	    this.closeInput = function () {
+	      _this.removeInputListeners();
+
+	      _this.input = null;
+
+	      _this.setSec("");
+
+	      if (_this.editor) {
+	        _this.editor.focus();
+	      }
+	    };
+
+	    this.clear = function () {
+	      _this.setInnerHtml_(_this.node, "");
+	    };
+
+	    this.inputKeyUp = function (e) {
+	      var options = _this.input.options;
+
+	      if (options && options.onKeyUp) {
+	        options.onKeyUp(e, e.target.value, _this.closeInput);
+	      }
+	    };
+
+	    this.inputKeyInput = function (e) {
+	      var options = _this.input.options;
+
+	      if (options && options.onKeyInput) {
+	        options.onKeyUp(e, e.target.value, _this.closeInput);
+	      }
+	    };
+
+	    this.inputBlur = function () {
+	      var options = _this.input.options;
+
+	      if (options.closeOnBlur) {
+	        _this.closeInput();
+	      }
+	    };
+
+	    this.inputKeyDown = function (e) {
+	      var _this$input = _this.input,
+	          options = _this$input.options,
+	          callback = _this$input.callback;
+
+	      if (options && options.onKeyDown && options.onKeyDown(e, e.target.value, _this.closeInput)) {
+	        return;
+	      }
+
+	      if (e.keyCode === 27 || options && options.closeOnEnter !== false && e.keyCode == 13) {
+	        _this.input.node.blur();
+
+	        e.stopPropagation();
+
+	        _this.closeInput();
+	      }
+
+	      if (e.keyCode === 13 && callback) {
+	        e.stopPropagation();
+	        e.preventDefault();
+	        callback(e.target.value);
+	      }
+	    };
+
+	    this.node = node;
+	    this.modeInfoNode = document.createElement("span");
+	    this.secInfoNode = document.createElement("span");
+	    this.notifNode = document.createElement("span");
+	    this.notifNode.className = "vim-notification";
+	    this.keyInfoNode = document.createElement("span");
+	    this.keyInfoNode.setAttribute("style", "float: right");
+	    this.node.appendChild(this.modeInfoNode);
+	    this.node.appendChild(this.secInfoNode);
+	    this.node.appendChild(this.notifNode);
+	    this.node.appendChild(this.keyInfoNode);
+	    this.toggleVisibility(false);
+	    this.editor = editor;
+	    this.sanitizer = sanitizer;
+	  }
+
+	  _createClass(VimStatusBar, [{
+	    key: "setMode",
+	    value: function setMode(ev) {
+	      if (ev.mode === "visual") {
+	        if (ev.subMode === "linewise") {
+	          this.setText("--VISUAL LINE--");
+	        } else if (ev.subMode === "blockwise") {
+	          this.setText("--VISUAL BLOCK--");
+	        } else {
+	          this.setText("--VISUAL--");
+	        }
+
+	        return;
+	      }
+
+	      this.setText("--".concat(ev.mode.toUpperCase(), "--"));
+	    }
+	  }, {
+	    key: "setKeyBuffer",
+	    value: function setKeyBuffer(key) {
+	      this.keyInfoNode.textContent = key;
+	    }
+	  }, {
+	    key: "setSec",
+	    value: function setSec(text, callback, options) {
+	      this.notifNode.textContent = "";
+
+	      if (text === undefined) {
+	        return this.closeInput;
+	      }
+
+	      this.setInnerHtml_(this.secInfoNode, text);
+	      var input = this.secInfoNode.querySelector("input");
+
+	      if (input) {
+	        input.focus();
+	        this.input = {
+	          callback: callback,
+	          options: options,
+	          node: input
+	        };
+
+	        if (options) {
+	          if (options.selectValueOnOpen) {
+	            input.select();
+	          }
+
+	          if (options.value) {
+	            input.value = options.value;
+	          }
+	        }
+
+	        this.addInputListeners();
+	      }
+
+	      return this.closeInput;
+	    }
+	  }, {
+	    key: "setText",
+	    value: function setText(text) {
+	      this.modeInfoNode.textContent = text;
+	    }
+	  }, {
+	    key: "toggleVisibility",
+	    value: function toggleVisibility(toggle) {
+	      if (toggle) {
+	        this.node.style.display = "block";
+	      } else {
+	        this.node.style.display = "none";
+	      }
+
+	      if (this.input) {
+	        this.removeInputListeners();
+	      }
+
+	      clearInterval(this.notifTimeout);
+	    }
+	  }, {
+	    key: "addInputListeners",
+	    value: function addInputListeners() {
+	      var node = this.input.node;
+	      node.addEventListener("keyup", this.inputKeyUp);
+	      node.addEventListener("keydown", this.inputKeyDown);
+	      node.addEventListener("input", this.inputKeyInput);
+	      node.addEventListener("blur", this.inputBlur);
+	    }
+	  }, {
+	    key: "removeInputListeners",
+	    value: function removeInputListeners() {
+	      if (!this.input || !this.input.node) {
+	        return;
+	      }
+
+	      var node = this.input.node;
+	      node.removeEventListener("keyup", this.inputKeyUp);
+	      node.removeEventListener("keydown", this.inputKeyDown);
+	      node.removeEventListener("input", this.inputKeyInput);
+	      node.removeEventListener("blur", this.inputBlur);
+	    }
+	  }, {
+	    key: "showNotification",
+	    value: function showNotification(text) {
+	      var _this2 = this;
+
+	      var sp = document.createElement("span");
+	      this.setInnerHtml_(sp, text);
+	      this.notifNode.textContent = sp.textContent;
+	      this.notifTimeout = setTimeout(function () {
+	        _this2.notifNode.textContent = "";
+	      }, 5000);
+	    }
+	  }, {
+	    key: "setInnerHtml_",
+	    value: function setInnerHtml_(element, htmlContents) {
+	      // Clear out previous contents first.
+	      while (element.childNodes.length) {
+	        element.removeChild(element.childNodes[0]);
+	      }
+
+	      if (!htmlContents) {
+	        return;
+	      }
+
+	      if (this.sanitizer) {
+	        element.appendChild(this.sanitizer(htmlContents));
+	      } else {
+	        element.appendChild(htmlContents);
+	      }
+	    }
+	  }]);
+
+	  return VimStatusBar;
+	}();
+
+	exports["default"] = VimStatusBar; 
+} (statusbar));

package/dist/services.d.ts

@@ -0,0 +1,8 @@
+import * as monaco from 'monaco-editor';
+import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry';
+declare const editorOpenHandlerRegistry: EditorOpenHandlerRegistry;
+export declare function setUseGlobalPicker(useGlobalPicker?: boolean): void;
+export declare function useGlobalPicker(): boolean;
+export declare function registerServices(newServices: monaco.editor.IEditorOverrideServices): void;
+export declare function initialize(): Promise<void>;
+export { editorOpenHandlerRegistry };

package/dist/services.js

@@ -0,0 +1,73 @@
+import getExtensionServiceOverride from '@codingame/monaco-vscode-extensions-service-override';
+import getModelServiceOverride from '@codingame/monaco-vscode-model-service-override';
+import getDialogsServiceOverride from '@codingame/monaco-vscode-dialogs-service-override';
+import getConfigurationServiceOverride from '@codingame/monaco-vscode-configuration-service-override';
+import getKeybindingsServiceOverride from '@codingame/monaco-vscode-keybindings-service-override';
+import getTextmateServiceOverride from '@codingame/monaco-vscode-textmate-service-override';
+import getThemeServiceOverride from '@codingame/monaco-vscode-theme-service-override';
+import getLanguagesServiceOverride from '@codingame/monaco-vscode-languages-service-override';
+import getAudioCueServiceOverride from '@codingame/monaco-vscode-audio-cue-service-override';
+import getPreferencesServiceOverride from '@codingame/monaco-vscode-preferences-service-override';
+import getSnippetServiceOverride from '@codingame/monaco-vscode-snippets-service-override';
+import getAccessibilityServiceOverride from '@codingame/monaco-vscode-accessibility-service-override';
+import getLanguageDetectionWorkerServiceOverride from '@codingame/monaco-vscode-language-detection-worker-service-override';
+import getEditorServiceOverride from '@codingame/monaco-vscode-editor-service-override';
+import getStorageServiceOverride from '@codingame/monaco-vscode-storage-service-override';
+import getLifecycleServiceOverride from '@codingame/monaco-vscode-lifecycle-service-override';
+import getQuickAccessServiceOverride from '@codingame/monaco-vscode-quickaccess-service-override';
+import { initialize as initialize$1, StandaloneServices, ILogService, LogLevel } from 'vscode/services';
+import * as monaco from 'monaco-editor';
+import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry.js';
+
+const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
+let _useGlobalPicker = false;
+function setUseGlobalPicker(useGlobalPicker = true) {
+    _useGlobalPicker = useGlobalPicker;
+}
+function useGlobalPicker() {
+    // should picker and keybindings be global or per-editor
+    return _useGlobalPicker;
+}
+let services = {
+    ...getExtensionServiceOverride(),
+    ...getModelServiceOverride(),
+    ...getDialogsServiceOverride(),
+    ...getConfigurationServiceOverride(),
+    ...getKeybindingsServiceOverride({
+        shouldUseGlobalKeybindings() {
+            return useGlobalPicker();
+        }
+    }),
+    ...getTextmateServiceOverride(),
+    ...getThemeServiceOverride(),
+    ...getLanguagesServiceOverride(),
+    ...getAudioCueServiceOverride(),
+    ...getPreferencesServiceOverride(),
+    ...getSnippetServiceOverride(),
+    ...getLanguageDetectionWorkerServiceOverride(),
+    ...getEditorServiceOverride((model, input, sideBySide) => {
+        return editorOpenHandlerRegistry.openCodeEditor(model, input, sideBySide);
+    }),
+    ...getAccessibilityServiceOverride(),
+    ...getStorageServiceOverride(),
+    ...getLifecycleServiceOverride(),
+    ...getQuickAccessServiceOverride({
+        shouldUseGlobalPicker() {
+            return useGlobalPicker();
+        }
+    })
+};
+function registerServices(newServices) {
+    services = {
+        ...services,
+        ...newServices
+    };
+}
+async function initialize() {
+    // wait a short time for the services to be registered
+    await new Promise(resolve => setTimeout(resolve, 0));
+    await initialize$1(services, undefined, { workspaceProvider: { open: async () => false, workspace: { workspaceUri: monaco.Uri.file('/tmp/project') }, trusted: true } });
+    StandaloneServices.get(ILogService).setLevel(LogLevel.Off);
+}
+
+export { editorOpenHandlerRegistry, initialize, registerServices, setUseGlobalPicker, useGlobalPicker };

package/dist/style.js

@@ -0,0 +1,12 @@
+function addStyle(styleString) {
+    const style = document.createElement('style');
+    style.textContent = styleString;
+    document.head.append(style);
+}
+addStyle(`
+.monaco-hover-content h1, .monaco-hover-content h2, .monaco-hover-content h3, .monaco-hover-content h4, .monaco-hover-content h5, .monaco-hover-content h6 {
+  all: revert;
+}
+`);
+
+export { addStyle };

package/dist/theme/index.d.ts

@@ -1,4 +1 @@
-import { IThemeExtensionPoint } from 'vscode/service-override/theme';
-import { Disposable } from 'vscode';
-declare function defineVSCodeTheme(idOrTheme: string | Pick<IThemeExtensionPoint, 'id' | 'label' | 'description' | 'uiTheme' | 'path'>, load: () => Promise<string>): Disposable;
-export { defineVSCodeTheme };
+export {};

package/dist/theme/index.js

@@ -0,0 +1,21 @@
+import { registerColor } from 'vscode/monaco';
+
+// Export 3 new colors used
+registerColor('statusBar.foreground', {
+    dark: '#ffffff',
+    light: '#20252a',
+    hcDark: '#ffffff',
+    hcLight: '#20252a'
+}, 'Status bar foreground color.');
+registerColor('statusBar.background', {
+    dark: '#252e38',
+    light: '#ffffff',
+    hcDark: null,
+    hcLight: null
+}, 'Status bar background color.');
+registerColor('statusBar.border', {
+    dark: '#41454a',
+    light: '#dadada',
+    hcDark: '#41454a',
+    hcLight: '#dadada'
+}, 'Status bar border color.');

package/dist/tools/EditorOpenHandlerRegistry.d.ts

@@ -1,6 +1,7 @@
 import * as monaco from 'monaco-editor';
-import { OpenEditor, IEditorOptions } from 'vscode/service-override/modelEditor';
-export type EditorOpenHandler = (model: monaco.editor.ITextModel, input: IEditorOptions | undefined, editor: monaco.editor.ICodeEditor | null, sideBySide?: boolean) => Promise<monaco.editor.ICodeEditor | null>;
+import { OpenEditor, IEditorOptions, IResolvedTextEditorModel } from '@codingame/monaco-vscode-editor-service-override';
+import { IReference } from 'vscode/monaco';
+export type EditorOpenHandler = (modelRef: IReference<IResolvedTextEditorModel>, input: IEditorOptions | undefined, editor: monaco.editor.ICodeEditor | null, sideBySide?: boolean) => Promise<monaco.editor.ICodeEditor | null>;
 export default class EditorOpenHandlerRegistry {
     private handlers;
     registerEditorOpenHandler(handler: EditorOpenHandler): monaco.IDisposable;

package/dist/tools/EditorOpenHandlerRegistry.js

@@ -0,0 +1,108 @@
+import { createEditor } from '../monaco.js';
+
+let currentEditor = null;
+function openNewCodeEditor(modelRef) {
+    if (currentEditor != null && modelRef.object.textEditorModel === currentEditor.model) {
+        return currentEditor.editor;
+    }
+    if (currentEditor != null) {
+        currentEditor.dispose();
+        currentEditor = null;
+    }
+    const container = document.createElement('div');
+    container.style.position = 'fixed';
+    container.style.zIndex = '10000';
+    container.style.backgroundColor = 'rgba(0, 0, 0, 0.5)';
+    container.style.top = container.style.bottom = container.style.left = container.style.right = '0';
+    container.style.cursor = 'pointer';
+    const editorElem = document.createElement('div');
+    editorElem.style.position = 'absolute';
+    editorElem.style.top = editorElem.style.bottom = editorElem.style.left = editorElem.style.right = '0';
+    editorElem.style.margin = 'auto';
+    editorElem.style.width = '80%';
+    editorElem.style.height = '80%';
+    container.appendChild(editorElem);
+    document.body.appendChild(container);
+    try {
+        const editor = createEditor(editorElem, {
+            model: modelRef.object.textEditorModel,
+            readOnly: true,
+            automaticLayout: true
+        });
+        currentEditor = {
+            dispose: () => {
+                modelRef.dispose();
+                editor.dispose();
+                document.body.removeChild(container);
+                currentEditor = null;
+            },
+            model: modelRef.object.textEditorModel,
+            editor
+        };
+        container.addEventListener('mousedown', (event) => {
+            if (event.target !== container) {
+                return;
+            }
+            currentEditor?.dispose();
+        });
+        return editor;
+    }
+    catch (error) {
+        document.body.removeChild(container);
+        currentEditor = null;
+        throw error;
+    }
+}
+class EditorOpenHandlerRegistry {
+    constructor() {
+        this.handlers = [];
+        this.openCodeEditor = async (modelRef, options, sideBySide) => {
+            let modelEditor;
+            for (const handler of this.handlers) {
+                const handlerEditor = await handler(modelRef, options, null, sideBySide);
+                if (handlerEditor != null) {
+                    modelEditor = handlerEditor;
+                    break;
+                }
+            }
+            if (modelEditor == null) {
+                modelEditor = openNewCodeEditor(modelRef);
+                // Destroy model ref when we close the editor popup
+                const onModelUnmount = () => {
+                    modelRef.dispose();
+                };
+                const onDidDisposeDisposable = modelEditor.onDidDispose(() => {
+                    onModelUnmount();
+                });
+                const onDidChangeModelDisposable = modelEditor.onDidChangeModel((e) => {
+                    if (e.newModelUrl == null || e.newModelUrl.toString() !== modelRef.object.textEditorModel.uri.toString()) {
+                        onModelUnmount();
+                        onDidDisposeDisposable.dispose();
+                        onDidChangeModelDisposable.dispose();
+                    }
+                });
+            }
+            modelEditor.focus();
+            if (modelEditor.getDomNode()?.scrollIntoView != null) {
+                modelEditor.getDomNode()?.scrollIntoView({
+                    block: 'nearest',
+                    inline: 'nearest'
+                });
+            }
+            return modelEditor;
+        };
+    }
+    registerEditorOpenHandler(handler) {
+        this.handlers.push(handler);
+        return {
+            dispose: () => {
+                const index = this.handlers.indexOf(handler);
+                if (index >= 0) {
+                    this.handlers.splice(index, 1);
+                }
+            }
+        };
+    }
+}
+
+export { EditorOpenHandlerRegistry as default };

package/dist/tools/FakeWorker.d.ts

@@ -0,0 +1,5 @@
+export declare class Worker {
+    url: string | URL;
+    options?: WorkerOptions | undefined;
+    constructor(url: string | URL, options?: WorkerOptions | undefined);
+}

package/dist/tools/FakeWorker.js

@@ -0,0 +1,8 @@
+class Worker {
+    constructor(url, options) {
+        this.url = url;
+        this.options = options;
+    }
+}
+
+export { Worker };