@codingame/monaco-editor-wrapper 4.0.0-next.1 → 4.0.0-next.3

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/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,77 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+export { __assign, __awaiter, __generator, __spreadArray };

package/dist/services.d.ts

@@ -1,4 +1,7 @@
+import * as monaco from 'monaco-editor';
 import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry';
+import 'vscode/ext-hosts/all';
 declare const editorOpenHandlerRegistry: EditorOpenHandlerRegistry;
+export declare function registerServices(newServices: monaco.editor.IEditorOverrideServices): void;
 export declare function initialize(): Promise<void>;
 export { editorOpenHandlerRegistry };

package/dist/services.js

@@ -0,0 +1,55 @@
+import getModelServiceOverride from 'vscode/service-override/model';
+import getDialogsServiceOverride from 'vscode/service-override/dialogs';
+import getConfigurationServiceOverride from 'vscode/service-override/configuration';
+import getKeybindingsServiceOverride from 'vscode/service-override/keybindings';
+import getTextmateServiceOverride from 'vscode/service-override/textmate';
+import getThemeServiceOverride from 'vscode/service-override/theme';
+import getLanguagesServiceOverride from 'vscode/service-override/languages';
+import getAudioCueServiceOverride from 'vscode/service-override/audioCue';
+import getPreferencesServiceOverride from 'vscode/service-override/preferences';
+import getSnippetServiceOverride from 'vscode/service-override/snippets';
+import getQuickAccessServiceOverride from 'vscode/service-override/quickaccess';
+import getAccessibilityServiceOverride from 'vscode/service-override/accessibility';
+import getEditorServiceOverride from 'vscode/service-override/editor';
+import { initialize as initialize$1, StandaloneServices, ILogService, LogLevel } from 'vscode/services';
+import { initialize as initialize$2 } from 'vscode/extensions';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import EditorOpenHandlerRegistry from './tools/EditorOpenHandlerRegistry.js';
+import 'vscode/ext-hosts/all';
+
+const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
+let services = {
+    ...getModelServiceOverride(),
+    ...getDialogsServiceOverride(),
+    ...getConfigurationServiceOverride(monaco.Uri.file('/tmp/project')),
+    ...getKeybindingsServiceOverride(),
+    ...getTextmateServiceOverride(),
+    ...getThemeServiceOverride(),
+    ...getLanguagesServiceOverride(),
+    ...getAudioCueServiceOverride(),
+    ...getPreferencesServiceOverride(),
+    ...getSnippetServiceOverride(),
+    ...getQuickAccessServiceOverride({
+        isKeybindingConfigurationVisible: () => false,
+        shouldUseGlobalPicker: () => false
+    }),
+    ...getEditorServiceOverride((model, input, sideBySide) => {
+        return editorOpenHandlerRegistry.openCodeEditor(model, input, sideBySide);
+    }),
+    ...getAccessibilityServiceOverride()
+};
+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);
+    StandaloneServices.get(ILogService).setLevel(LogLevel.Off);
+    await initialize$2();
+}
+
+export { editorOpenHandlerRegistry, initialize, registerServices };

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.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.js

@@ -0,0 +1,108 @@
+import { createEditor } from '../monaco.js';
+
+let currentEditor = null;
+async 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 = await 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 = await 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 };