Visual-Code-Space
diff --git a/‎index.html‎
Lines changed: 34 additions & 0 deletions b/‎index.html‎
Lines changed: 34 additions & 0 deletions
diff --git a/‎main.js‎
Lines changed: 224 additions & 0 deletions b/‎main.js‎
Lines changed: 224 additions & 0 deletions
@@ -0,0 +1,34 @@
+<!--
+  ~ This file is part of Visual Code Space.
+  ~
+  ~ Visual Code Space is free software: you can redistribute it and/or modify it under the terms of
+  ~ the GNU General Public License as published by the Free Software Foundation, either version 3 of
+  ~ the License, or (at your option) any later version.
+  ~
+  ~ Visual Code Space is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+  ~ without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  ~ GNU General Public License for more details.
+  ~
+  ~ You should have received a copy of the GNU General Public License along with Visual Code Space.
+  ~ If not, see <https://www.gnu.org/licenses/>.
+  -->
+
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Editor</title>
+    <link rel="stylesheet" href="style.css" />
+    <link
+      href="https://fonts.googleapis.com/css2?family=JetBrains+Mono&display=swap"
+      rel="stylesheet"
+    />
+  </head>
+  <body>
+    <div id="container"></div>
+
+    <script src="monaco-editor/dev/vs/loader.js"></script>
+    <script src="main.js"></script>
+  </body>
+</html>
@@ -0,0 +1,224 @@
+let editor;
+let currentValue = "";
+
+require.config({
+    paths: {
+        vs: "https://appassets.androidplatform.net/assets/code-oss/editor/monaco-editor/min/vs",
+    },
+});
+
+window.MonacoEnvironment = {
+    getWorkerUrl: () => proxy,
+};
+
+let proxy = URL.createObjectURL(new Blob([`
+    self.MonacoEnvironment = {
+        baseUrl: 'https://appassets.androidplatform.net/assets/code-oss/editor/monaco-editor/min/'
+    };
+    importScripts('https://appassets.androidplatform.net/assets/code-oss/editor/monaco-editor/min/vs/base/worker/workerMain.js');
+`], { type: 'text/javascript' }));
+
+// Create the editor
+require(["vs/editor/editor.main"], function () {
+    editor = monaco.editor.create(document.getElementById("container"), {
+        value: "",
+        language: "plaintext",
+        theme: "vs-dark",
+        fontFamily: 'JetBrains Mono'
+    });
+
+    window.MonacoAndroid.setCanUndo(editor.getModel().canUndo());
+    window.MonacoAndroid.setCanRedo(editor.getModel().canRedo());
+
+    editor.onDidChangeModelContent(() => {
+        const newValue = editor.getValue();
+        if (currentValue !== newValue) {
+            currentValue = newValue;
+            window.MonacoAndroid.onTextChanged(newValue);
+        }
+
+        const content = editor.getValue();
+        const model = editor.getModel();
+        const isModified = model.getAlternativeVersionId() !== model.getVersionId();
+
+        window.updateCursorInfo();
+        window.MonacoAndroid.setModified(isModified);
+        window.MonacoAndroid.setValue(content);
+        window.MonacoAndroid.setCanUndo(model.canUndo());
+        window.MonacoAndroid.setCanRedo(model.canRedo());
+    });
+
+    window.updateCursorInfo = function () {
+        const position = editor.getPosition();
+        window.MonacoAndroid.setLineNumber(position.lineNumber);
+        window.MonacoAndroid.setColumn(position.column);
+    };
+});
+
+function setText(content) {
+    if (editor) {
+        currentValue = content;
+        editor.setValue(content);
+    }
+}
+
+function setLanguage(language) {
+    if (editor) {
+        monaco.editor.setModelLanguage(editor.getModel(), language);
+        monaco.languages.registerInlineCompletionsProvider(language, {
+            provideInlineCompletions: async function (model, position, context, token) {
+                console.log('Provide new completion', position, context, token);
+
+                let textBeforeCursor = model.getValueInRange({
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: position.lineNumber,
+                    endColumn: position.column
+                });
+
+                let textAfterCursor = model.getValueInRange({
+                    startLineNumber: position.lineNumber,
+                    startColumn: position.column,
+                    endLineNumber: model.getLineCount(),
+                    endColumn: model.getLineMaxColumn(model.getLineCount())
+                });
+
+                // Fetch suggestions from Android
+                const suggestions = await window.MonacoAndroid.onInlineCompletion(language, textBeforeCursor, textAfterCursor);
+
+                // Ensure suggestions are valid
+                const validSuggestions = suggestions ? [{
+                    insertText: suggestions
+                }] : [];
+
+                return {
+                    items: [
+                        ...validSuggestions
+                    ]
+                };
+            },
+            freeInlineCompletions: function (completions) {
+                console.log(completions);
+            },
+        });
+    }
+}
+
+function setTheme(theme) {
+    if (editor) {
+        monaco.editor.setTheme(theme);
+    }
+}
+
+function focusEditor() {
+    if (editor) {
+        editor.focus();
+    }
+}
+
+function setEditorOptions(option, value) {
+    if (editor) {
+        const options = {};
+        options[option] = value;
+        editor.updateOptions(options);
+    }
+}
+
+function setCursorStyle(styleValue) {
+    const cursorStyleMap = {
+        1: 'line',
+        2: 'block',
+        3: 'underline',
+        4: 'line-thin',
+        5: 'block-outline',
+        6: 'underline-thin'
+    };
+    const cursorStyle = cursorStyleMap[styleValue];
+    if (cursorStyle) {
+        editor.updateOptions({ cursorStyle });
+    }
+}
+
+function setCursorBlinkingStyle(styleValue) {
+    const blinkingStyleMap = {
+        0: 'hidden',
+        1: 'blink',
+        2: 'smooth',
+        3: 'phase',
+        4: 'expand',
+        5: 'solid'
+    };
+
+    const cursorBlinking = blinkingStyleMap[styleValue];
+    if (cursorBlinking) {
+        editor.updateOptions({ cursorBlinking });
+    }
+}
+
+function applyMinimapOptions(optionsJson) {
+    try {
+        const options = JSON.parse(optionsJson);
+        editor.updateOptions({
+            minimap: {
+                enabled: options.enabled,
+                autohide: options.autohide,
+                side: options.side,
+                size: options.size,
+                showSlider: options.showSlider,
+                renderCharacters: options.renderCharacters,
+                maxColumn: options.maxColumn,
+                scale: options.scale,
+                showRegionSectionHeaders: options.showRegionSectionHeaders,
+                showMarkSectionHeaders: options.showMarkSectionHeaders,
+                sectionHeaderFontSize: options.sectionHeaderFontSize,
+                sectionHeaderLetterSpacing: options.sectionHeaderLetterSpacing,
+            },
+        });
+    } catch (error) {
+        console.error("Error applying minimap options:", error);
+    }
+}
+
+function undo() {
+    if (editor) {
+        editor.trigger('keyboard', 'undo');
+    }
+}
+
+function redo() {
+    if (editor) {
+        editor.trigger('keyboard', 'redo');
+    }
+}
+
+function insert(text, line, column) {
+    const position = { lineNumber: line, column: column };
+    editor.executeEdits(null, [
+        {
+            range: new monaco.Range(position.lineNumber, position.column, position.lineNumber, position.column),
+            text: text,
+            forceMoveMarkers: true
+        }
+    ]);
+}
+
+function simulateKeyPress(key) {
+    editor.trigger('keyboard', 'type', { text: key });
+}
+
+function selectText(startLineNumber, startColumn, endLineNumber, endColumn) {
+    const range = new monaco.Range(startLineNumber, startColumn, endLineNumber, endColumn);
+    editor.setSelection(range);
+    editor.focus();
+}
+
+function replaceSelectedText(text) {
+    const selection = editor.getSelection();
+    editor.executeEdits(null, [
+        {
+            range: selection,
+            text: text,
+            forceMoveMarkers: true
+        }
+    ]);
+}