Download assets/monaco.html from chahuadev/chahuadev-Code-Editor-apk: direct link, hf CLI and curl.
- Browser
- Download file 32.3 kB
-
https://huggingface.co/datasets/chahuadev/chahuadev-Code-Editor-apk/resolve/main/assets/monaco.html
- Command line
-
hf download hf://datasets/chahuadev/chahuadev-Code-Editor-apk/assets/monaco.html
-
curl -L -o monaco.html https://huggingface.co/datasets/chahuadev/chahuadev-Code-Editor-apk/resolve/main/assets/monaco.html
32.3 kB
| <html lang="en"> | |
| <head> | |
| <meta charset="UTF-8" /> | |
| <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" /> | |
| <title>Code Editor</title> | |
| <style> | |
| * { margin: 0; padding: 0; box-sizing: border-box; } | |
| html, body { width: 100%; height: 100%; background: #0e0e14; overflow: hidden; } | |
| #editor-container { width: 100%; height: 100%; } | |
| #loading { | |
| position: absolute; top: 0; left: 0; right: 0; bottom: 0; | |
| display: flex; align-items: center; justify-content: center; | |
| flex-direction: column; gap: 14px; | |
| background: #0e0e14; color: #6ee7b7; font-family: 'Courier New', monospace; font-size: 14px; | |
| z-index: 9999; | |
| } | |
| .spin { | |
| width: 32px; height: 32px; | |
| border: 3px solid #2d2d44; border-top-color: #818cf8; | |
| border-radius: 50%; animation: spin 0.9s linear infinite; | |
| } | |
| @keyframes spin { to { transform: rotate(360deg); } } | |
| /* Make Monaco's inputarea big enough for Android to detect as a real text field */ | |
| .monaco-editor .inputarea { | |
| pointer-events: auto ; | |
| width: 50px ; | |
| height: 50px ; | |
| opacity: 0.01 ; | |
| } | |
| /* Error Lens inline decoration styles */ | |
| .el-error { color: #f87171 ; font-style: italic; font-size: 12px ; pointer-events: none; } | |
| .el-warn { color: #fbbf24 ; font-style: italic; font-size: 12px ; pointer-events: none; } | |
| .el-info { color: #38bdf8 ; font-style: italic; font-size: 12px ; pointer-events: none; } | |
| /* TODO / FIXME / NOTE highlight decorations */ | |
| .td-todo { background: rgba(251,191,36,0.12); border-bottom: 1px solid #fbbf24cc; color: #fbbf24; font-weight: 600; } | |
| .td-fixme { background: rgba(248,113,113,0.12); border-bottom: 1px solid #f87171cc; color: #f87171; font-weight: 600; } | |
| .td-note { background: rgba(56,189,248,0.12); border-bottom: 1px solid #38bdf8cc; color: #38bdf8; font-weight: 600; } | |
| </style> | |
| </head> | |
| <body> | |
| <div id="loading"><div class="spin"></div>Loading Monacoβ¦</div> | |
| <div id="editor-container"></div> | |
| <script src="https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.46.0/min/vs/loader.min.js"></script> | |
| <script> | |
| (function () { | |
| var editor = null; | |
| var currentFontSize = 15; | |
| var wordWrapEnabled = false; | |
| var errorLensIds = []; | |
| var prettierReady = false; | |
| var prettierLoading = false; | |
| var todoIds = []; | |
| var todoDebounce = null; | |
| var emmetReady = false; | |
| var emmetLoading = false; | |
| // βββ Load Monaco βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| require.config({ paths: { vs: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.46.0/min/vs' } }); | |
| require(['vs/editor/editor.main'], function () { | |
| document.getElementById('loading').style.display = 'none'; | |
| // ββ Theme ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| monaco.editor.defineTheme('cha-dark', { | |
| base: 'vs-dark', inherit: true, | |
| rules: [ | |
| { token: 'comment', foreground: '6b7280', fontStyle: 'italic' }, | |
| { token: 'keyword', foreground: 'c084fc' }, | |
| { token: 'keyword.control', foreground: 'f472b6' }, | |
| { token: 'string', foreground: '6ee7b7' }, | |
| { token: 'string.escape', foreground: 'fb923c' }, | |
| { token: 'number', foreground: 'fb923c' }, | |
| { token: 'regexp', foreground: 'f87171' }, | |
| { token: 'type', foreground: '38bdf8' }, | |
| { token: 'type.identifier', foreground: '38bdf8' }, | |
| { token: 'class', foreground: 'fbbf24' }, | |
| { token: 'function', foreground: 'fbbf24' }, | |
| { token: 'variable', foreground: 'e2e8f0' }, | |
| { token: 'variable.predefined', foreground: 'f87171' }, | |
| { token: 'constant', foreground: 'fb923c' }, | |
| { token: 'tag', foreground: 'f87171' }, | |
| { token: 'tag.id', foreground: 'fbbf24' }, | |
| { token: 'tag.class', foreground: '6ee7b7' }, | |
| { token: 'attribute.name', foreground: '818cf8' }, | |
| { token: 'attribute.value', foreground: '6ee7b7' }, | |
| { token: 'delimiter', foreground: '94a3b8' }, | |
| { token: 'operator', foreground: '94a3b8' }, | |
| { token: 'namespace', foreground: '38bdf8' }, | |
| { token: 'constructor', foreground: 'fbbf24' }, | |
| { token: 'identifier', foreground: 'e2e8f0' }, | |
| { token: 'annotation', foreground: 'f472b6' }, | |
| { token: 'decorator', foreground: 'f472b6' }, | |
| ], | |
| colors: { | |
| 'editor.background': '#0e0e14', | |
| 'editor.foreground': '#e2e8f0', | |
| 'editor.lineHighlightBackground': '#1a1a2e', | |
| 'editor.lineHighlightBorder': '#2d2d4460', | |
| 'editorLineNumber.foreground': '#374151', | |
| 'editorLineNumber.activeForeground': '#818cf8', | |
| 'editor.selectionBackground': '#818cf840', | |
| 'editor.inactiveSelectionBackground': '#818cf820', | |
| 'editor.wordHighlightBackground': '#818cf820', | |
| 'editor.findMatchBackground': '#fbbf2440', | |
| 'editor.findMatchHighlightBackground': '#fbbf2420', | |
| 'editorCursor.foreground': '#6ee7b7', | |
| 'editorWidget.background': '#1a1a2e', | |
| 'editorWidget.border': '#2d2d44', | |
| 'editorSuggestWidget.background': '#1a1a2e', | |
| 'editorSuggestWidget.border': '#2d2d44', | |
| 'editorSuggestWidget.foreground': '#e2e8f0', | |
| 'editorSuggestWidget.selectedBackground': '#2d2d44', | |
| 'editorSuggestWidget.highlightForeground': '#818cf8', | |
| 'editorGutter.background': '#0e0e14', | |
| 'scrollbarSlider.background': '#2d2d44aa', | |
| 'scrollbarSlider.hoverBackground': '#818cf860', | |
| 'scrollbarSlider.activeBackground': '#818cf8aa', | |
| 'editorError.foreground': '#f87171', | |
| 'editorWarning.foreground': '#fbbf24', | |
| 'editorInfo.foreground': '#38bdf8', | |
| 'editorHint.foreground': '#6ee7b780', | |
| 'editorOverviewRuler.errorForeground': '#f87171', | |
| 'editorOverviewRuler.warningForeground': '#fbbf24', | |
| 'editorBracketMatch.background': '#818cf820', | |
| 'editorBracketMatch.border': '#818cf8', | |
| 'editorIndentGuide.background1': '#2d2d44', | |
| 'editorIndentGuide.activeBackground1': '#818cf840', | |
| 'list.activeSelectionBackground': '#2d2d44', | |
| 'list.hoverBackground': '#1a1a2e', | |
| 'peekView.border': '#818cf8', | |
| 'peekViewResult.background': '#1a1a2e', | |
| 'peekViewEditor.background': '#0e0e14', | |
| } | |
| }); | |
| // ββ Create Editor ββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| editor = monaco.editor.create(document.getElementById('editor-container'), { | |
| value: '', language: 'javascript', theme: 'cha-dark', | |
| fontSize: currentFontSize, | |
| fontFamily: "'JetBrains Mono', 'Fira Code', 'Consolas', 'Courier New', monospace", | |
| fontLigatures: true, | |
| lineHeight: 22, | |
| letterSpacing: 0.3, | |
| lineNumbers: function(n) { | |
| if (n >= 10000) return Math.floor(n/1000) + 'k'; | |
| if (n >= 1000) return (n/1000).toFixed(1).replace(/\.0$/,'') + 'k'; | |
| return String(n); | |
| }, | |
| lineNumbersMinChars: 2, | |
| lineDecorationsWidth: 2, | |
| wordWrap: 'off', | |
| minimap: { enabled: false }, | |
| scrollbar: { | |
| vertical: 'auto', horizontal: 'auto', | |
| verticalScrollbarSize: 5, horizontalScrollbarSize: 5, | |
| useShadows: false, | |
| }, | |
| automaticLayout: true, | |
| suggestOnTriggerCharacters: true, | |
| quickSuggestions: { other: true, comments: false, strings: false }, | |
| quickSuggestionsDelay: 200, | |
| parameterHints: { enabled: true }, | |
| tabSize: 2, insertSpaces: true, detectIndentation: true, | |
| renderWhitespace: 'selection', | |
| bracketPairColorization: { enabled: true, independentColorPoolPerBracketType: true }, | |
| guides: { indentation: true, bracketPairs: true }, | |
| autoClosingBrackets: 'always', | |
| autoClosingQuotes: 'always', | |
| autoSurround: 'quotes', | |
| matchBrackets: 'always', | |
| formatOnType: false, | |
| scrollBeyondLastLine: false, | |
| padding: { top: 12, bottom: 80 }, | |
| cursorBlinking: 'smooth', | |
| cursorSmoothCaretAnimation: 'on', | |
| smoothScrolling: true, | |
| contextmenu: false, | |
| mouseWheelZoom: false, | |
| folding: true, | |
| showFoldingControls: 'mouseover', | |
| foldingStrategy: 'indentation', | |
| glyphMargin: false, | |
| colorDecorators: true, | |
| renderLineHighlight: 'line', | |
| linkedEditing: true, | |
| selectionHighlight: true, | |
| occurrencesHighlight: 'multiFile', | |
| codeLens: false, | |
| hover: { enabled: true, delay: 600 }, | |
| 'semanticHighlighting.enabled': true, | |
| overviewRulerLanes: 3, | |
| unicodeHighlight: { ambiguousCharacters: false }, | |
| stickyScroll: { enabled: true }, | |
| }); | |
| // ββ TS/JS built-in diagnostics (ESLint-like for JS & TS) ββββββββββββββ | |
| var tsCompOpts = { | |
| target: monaco.languages.typescript.ScriptTarget.ESNext, | |
| module: monaco.languages.typescript.ModuleKind.ESNext, | |
| allowJs: true, | |
| checkJs: true, | |
| jsx: monaco.languages.typescript.JsxEmit.React, | |
| noUnusedLocals: true, | |
| noUnusedParameters: false, | |
| strict: false, | |
| allowNonTsExtensions: true, | |
| }; | |
| monaco.languages.typescript.javascriptDefaults.setCompilerOptions(tsCompOpts); | |
| monaco.languages.typescript.typescriptDefaults.setCompilerOptions( | |
| Object.assign({}, tsCompOpts, { strict: true, noUnusedLocals: true }) | |
| ); | |
| monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({ | |
| noSemanticValidation: false, | |
| noSyntaxValidation: false, | |
| diagnosticCodesToIgnore: [2792, 2307], // ignore "cannot find module" warnings | |
| }); | |
| monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({ | |
| noSemanticValidation: false, | |
| noSyntaxValidation: false, | |
| diagnosticCodesToIgnore: [2792, 2307], | |
| }); | |
| // ββ Language snippets (custom completions per language) ββββββββββββββββ | |
| function makeSnip(label, insertText, docs) { | |
| return { | |
| label: label, | |
| kind: monaco.languages.CompletionItemKind.Snippet, | |
| documentation: docs || label, | |
| insertText: insertText, | |
| insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet, | |
| range: undefined, | |
| }; | |
| } | |
| var jsSnippets = [ | |
| makeSnip('cl', 'console.log(${1:value});$0', 'console.log'), | |
| makeSnip('ce', 'console.error(${1:error});$0', 'console.error'), | |
| makeSnip('fn', 'function ${1:name}(${2:params}) {\n\t$0\n}', 'function'), | |
| makeSnip('afn', '(${1:params}) => {\n\t$0\n}', 'arrow function'), | |
| makeSnip('aafn', 'async (${1:params}) => {\n\t$0\n}', 'async arrow function'), | |
| makeSnip('anfn', 'async function ${1:name}(${2:params}) {\n\t$0\n}', 'async function'), | |
| makeSnip('imp', "import ${1:thing} from '${2:module}';$0", 'import'), | |
| makeSnip('imd', "import * as ${1:name} from '${2:module}';$0", 'import *'), | |
| makeSnip('imn', "import '${1:module}';$0", 'import (side-effect)'), | |
| makeSnip('req', "const ${1:name} = require('${2:module}');$0", 'require'), | |
| makeSnip('trycatch', 'try {\n\t${1:// code}\n} catch (${2:err}) {\n\t${3:// handle}\n}$0', 'try/catch'), | |
| makeSnip('prom', 'new Promise((resolve, reject) => {\n\t$0\n});', 'new Promise'), | |
| makeSnip('cls', 'class ${1:Name} {\n\tconstructor(${2:params}) {\n\t\t$0\n\t}\n}', 'class'), | |
| makeSnip('ternary', '${1:cond} ? ${2:then} : ${3:else}', 'ternary'), | |
| makeSnip('des', 'const { ${1:key} } = ${2:obj};$0', 'destructure object'), | |
| makeSnip('itar', 'for (let ${1:i} = 0; ${1:i} < ${2:arr}.length; ${1:i}++) {\n\t$0\n}', 'for loop'), | |
| makeSnip('forof', 'for (const ${1:item} of ${2:iterable}) {\n\t$0\n}', 'for...of'), | |
| makeSnip('forin', 'for (const ${1:key} in ${2:obj}) {\n\t$0\n}', 'for...in'), | |
| makeSnip('sw', 'switch (${1:expr}) {\n\tcase ${2:val}:\n\t\t$0\n\t\tbreak;\n\tdefault:\n\t\tbreak;\n}', 'switch'), | |
| makeSnip('settimeout', 'setTimeout(() => {\n\t$0\n}, ${1:1000});', 'setTimeout'), | |
| makeSnip('setinterval', 'setInterval(() => {\n\t$0\n}, ${1:1000});', 'setInterval'), | |
| makeSnip('docid', "document.getElementById('${1:id}')$0", 'getElementById'), | |
| makeSnip('docqs', "document.querySelector('${1:selector}')$0", 'querySelector'), | |
| ]; | |
| ['javascript','javascriptreact','typescript','typescriptreact'].forEach(function(lid) { | |
| monaco.languages.registerCompletionItemProvider(lid, { | |
| provideCompletionItems: function(model, pos) { | |
| var word = model.getWordUntilPosition(pos); | |
| var range = { startLineNumber: pos.lineNumber, endLineNumber: pos.lineNumber, | |
| startColumn: word.startColumn, endColumn: word.endColumn }; | |
| return { suggestions: jsSnippets.map(function(s) { return Object.assign({}, s, { range: range }); }) }; | |
| } | |
| }); | |
| }); | |
| var pySnippets = [ | |
| makeSnip('def', 'def ${1:name}(${2:params}):\n\t${3:pass}$0', 'def'), | |
| makeSnip('cls', 'class ${1:Name}:\n\tdef __init__(self${2:, params}):\n\t\t${3:pass}$0', 'class'), | |
| makeSnip('ifmain', "if __name__ == '__main__':\n\t$0", 'if __name__'), | |
| makeSnip('trycatch','try:\n\t${1:pass}\nexcept ${2:Exception} as e:\n\t${3:pass}$0', 'try/except'), | |
| makeSnip('wopen', "with open('${1:file}', '${2:r}') as f:\n\t$0", 'with open'), | |
| makeSnip('lc', '[${1:expr} for ${2:x} in ${3:iterable}]$0', 'list comprehension'), | |
| makeSnip('dc', '{${1:key}: ${2:val} for ${3:k}, ${4:v} in ${5:dict}.items()}$0', 'dict comprehension'), | |
| makeSnip('pr', 'print(${1:value})$0', 'print'), | |
| makeSnip('prf', 'print(f"${1:text}")$0', 'print f-string'), | |
| makeSnip('impas', 'import ${1:module} as ${2:alias}$0', 'import as'), | |
| makeSnip('fromimp', 'from ${1:module} import ${2:name}$0', 'from import'), | |
| makeSnip('lam', 'lambda ${1:params}: ${2:expr}$0', 'lambda'), | |
| makeSnip('forloop', 'for ${1:item} in ${2:iterable}:\n\t$0', 'for'), | |
| makeSnip('whileloop','while ${1:True}:\n\t$0', 'while'), | |
| makeSnip('glb', 'global ${1:var}$0', 'global'), | |
| ]; | |
| monaco.languages.registerCompletionItemProvider('python', { | |
| provideCompletionItems: function(model, pos) { | |
| var word = model.getWordUntilPosition(pos); | |
| var range = { startLineNumber: pos.lineNumber, endLineNumber: pos.lineNumber, | |
| startColumn: word.startColumn, endColumn: word.endColumn }; | |
| return { suggestions: pySnippets.map(function(s) { return Object.assign({}, s, { range: range }); }) }; | |
| } | |
| }); | |
| var cssSnippets = [ | |
| makeSnip('flex', 'display: flex;\nalign-items: ${1:center};\njustify-content: ${2:center};$0', 'flexbox center'), | |
| makeSnip('grid', 'display: grid;\ngrid-template-columns: ${1:repeat(3, 1fr)};\ngap: ${2:1rem};$0', 'grid'), | |
| makeSnip('abs', 'position: absolute;\ntop: ${1:0};\nleft: ${2:0};$0', 'absolute'), | |
| makeSnip('tr', 'transition: ${1:all} ${2:0.3s} ${3:ease};$0', 'transition'), | |
| makeSnip('shadow', 'box-shadow: ${1:0 4px 6px} rgba(0,0,0,${2:0.1});$0', 'box-shadow'), | |
| makeSnip('size', 'width: ${1};\nheight: ${2};$0', 'width+height'), | |
| makeSnip('media', '@media (max-width: ${1:768px}) {\n\t$0\n}', '@media'), | |
| makeSnip('var', 'var(--${1:name})$0', 'CSS variable'), | |
| makeSnip('mixin', '@mixin ${1:name}(${2:params}) {\n\t$0\n}', '@mixin (SCSS)'), | |
| ]; | |
| ['css','scss','less'].forEach(function(lid) { | |
| monaco.languages.registerCompletionItemProvider(lid, { | |
| provideCompletionItems: function(model, pos) { | |
| var word = model.getWordUntilPosition(pos); | |
| var range = { startLineNumber: pos.lineNumber, endLineNumber: pos.lineNumber, | |
| startColumn: word.startColumn, endColumn: word.endColumn }; | |
| return { suggestions: cssSnippets.map(function(s) { return Object.assign({}, s, { range: range }); }) }; | |
| } | |
| }); | |
| }); | |
| // ββ Cursor position β broadcast to RN (status bar) ββββββββββββββββββββ | |
| editor.onDidChangeCursorSelection(function(e) { | |
| var pos = editor.getPosition(); | |
| var sel = editor.getSelection(); | |
| var selLen = 0; | |
| if (sel && !sel.isEmpty()) { | |
| selLen = editor.getModel().getValueInRange(sel).length; | |
| } | |
| postToRN({ type: 'cursor', line: pos.lineNumber, col: pos.column, sel: selLen }); | |
| }); | |
| // ββ TODO / FIXME / HACK / BUG / NOTE highlight decorations ββββββββββββ | |
| function refreshTodo() { | |
| if (!editor) return; | |
| var model = editor.getModel(); | |
| if (!model) return; | |
| clearTimeout(todoDebounce); | |
| todoDebounce = setTimeout(function () { | |
| var content = model.getValue(); | |
| var decs = []; | |
| var re = /\b(TODO|FIXME|HACK|BUG|NOTE|XXX)\b[^\n]*/g; | |
| var match; | |
| while ((match = re.exec(content)) !== null) { | |
| var startPos = model.getPositionAt(match.index); | |
| var endPos = model.getPositionAt(match.index + match[0].length); | |
| var kw = match[1]; | |
| var cls = /FIXME|BUG/.test(kw) ? 'td-fixme' : /NOTE|HACK/.test(kw) ? 'td-note' : 'td-todo'; | |
| var ovColor = /FIXME|BUG/.test(kw) ? '#f87171' : /NOTE|HACK/.test(kw) ? '#38bdf8' : '#fbbf24'; | |
| decs.push({ | |
| range: { | |
| startLineNumber: startPos.lineNumber, startColumn: startPos.column, | |
| endLineNumber: endPos.lineNumber, endColumn: endPos.column, | |
| }, | |
| options: { | |
| inlineClassName: cls, | |
| overviewRuler: { color: ovColor, position: monaco.editor.OverviewRulerLane.Right }, | |
| stickiness: 1, | |
| } | |
| }); | |
| } | |
| todoIds = editor.deltaDecorations(todoIds, decs); | |
| }, 600); | |
| } | |
| editor.onDidChangeModelContent(refreshTodo); | |
| // ββ Emmet for HTML / CSS (lazy CDN) βββββββββββββββββββββββββββββββββββ | |
| function loadEmmet(cb) { | |
| if (emmetReady) { if (cb) cb(); return; } | |
| if (emmetLoading) return; | |
| emmetLoading = true; | |
| var s = document.createElement('script'); | |
| s.src = 'https://cdn.jsdelivr.net/npm/emmet-monaco-es@5.3.1/dist/emmet-monaco.min.js'; | |
| s.onload = function () { | |
| try { | |
| if (window.emmetMonaco) | |
| window.emmetMonaco.emmetHTML(monaco, ['html','xml','php','jsx','tsx','vue','handlebars']); | |
| } catch(e) {} | |
| emmetReady = true; | |
| if (cb) cb(); | |
| }; | |
| s.onerror = function () { emmetLoading = false; }; | |
| document.head.appendChild(s); | |
| } | |
| // Pre-load Emmet in the background after editor is ready | |
| setTimeout(loadEmmet, 2000); | |
| // ββ Error Lens βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| function refreshErrorLens() { | |
| if (!editor) return; | |
| var model = editor.getModel(); | |
| if (!model) return; | |
| var markers = monaco.editor.getModelMarkers({ resource: model.uri }); | |
| var decs = markers | |
| .filter(function (m) { return m.severity >= 4; }) | |
| .map(function (m) { | |
| var cls = m.severity === 8 ? 'el-error' : m.severity === 4 ? 'el-warn' : 'el-info'; | |
| var icon = m.severity === 8 ? 'β ' : m.severity === 4 ? 'β ' : 'βΉ '; | |
| var txt = m.message.replace(/[\r\n]+/g, ' ').slice(0, 80); | |
| return { | |
| range: { | |
| startLineNumber: m.endLineNumber, | |
| startColumn: model.getLineMaxColumn(m.endLineNumber), | |
| endLineNumber: m.endLineNumber, | |
| endColumn: model.getLineMaxColumn(m.endLineNumber), | |
| }, | |
| options: { | |
| after: { content: ' ' + icon + txt, inlineClassName: cls }, | |
| stickiness: 1, | |
| } | |
| }; | |
| }); | |
| errorLensIds = editor.deltaDecorations(errorLensIds, decs); | |
| } | |
| monaco.editor.onDidChangeMarkers(function (uris) { | |
| if (!editor) return; | |
| var m = editor.getModel(); | |
| if (!m) return; | |
| var me = m.uri.toString(); | |
| if (uris.some(function (u) { return u.toString() === me; })) refreshErrorLens(); | |
| }); | |
| // ββ Content change β notify RN ββββββββββββββββββββββββββββββββββββββββ | |
| editor.onDidChangeModelContent(function () { | |
| postToRN({ type: 'contentChanged', isDirty: true }); | |
| }); | |
| // ββ Pinch-to-zoom + Two-finger swipe Undo/Redo ββββββββββββββββββββββββ | |
| // DISABLED: custom touch listeners were blocking native WebView scroll. | |
| // Re-enable only after native scroll is confirmed working. | |
| /* | |
| var t2 = { on: false, startD: 0, startFS: 15, startY: 0, didPinch: false }; | |
| function fingerDist(e) { | |
| var dx = e.touches[1].clientX - e.touches[0].clientX; | |
| var dy = e.touches[1].clientY - e.touches[0].clientY; | |
| return Math.sqrt(dx * dx + dy * dy); | |
| } | |
| document.addEventListener('touchstart', function (e) { | |
| if (e.touches.length === 2) { | |
| t2.on = true; t2.didPinch = false; | |
| t2.startD = fingerDist(e); | |
| t2.startFS = currentFontSize; | |
| t2.startY = (e.touches[0].clientY + e.touches[1].clientY) / 2; | |
| } else { t2.on = false; } | |
| }, { passive: true }); | |
| document.addEventListener('touchmove', function (e) { | |
| if (!t2.on || e.touches.length < 2) return; | |
| var ratio = fingerDist(e) / t2.startD; | |
| if (Math.abs(ratio - 1) > 0.12) { | |
| t2.didPinch = true; | |
| var ns = Math.round(Math.max(10, Math.min(32, t2.startFS * ratio))); | |
| if (ns !== currentFontSize) { | |
| currentFontSize = ns; | |
| editor.updateOptions({ fontSize: ns }); | |
| postToRN({ type: 'fontSizeChanged', size: ns }); | |
| } | |
| } | |
| }, { passive: true }); | |
| document.addEventListener('touchend', function (e) { | |
| if (t2.on && !t2.didPinch && e.changedTouches.length > 0) { | |
| var dy = e.changedTouches[0].clientY - t2.startY; | |
| if (Math.abs(dy) > 50) { | |
| if (dy > 0) { editor.trigger('kb', 'undo', null); postToRN({ type: 'undo' }); } | |
| else { editor.trigger('kb', 'redo', null); postToRN({ type: 'redo' }); } | |
| } | |
| } | |
| t2.on = false; | |
| }, { passive: true }); | |
| document.getElementById('editor-container').addEventListener('touchend', function () { | |
| editor.focus(); | |
| }, { passive: true }); | |
| */ | |
| window.__focusKeyboard = function() { | |
| editor.focus(); | |
| var inputArea = document.querySelector('textarea.inputarea'); | |
| if (inputArea) inputArea.focus(); | |
| }; | |
| // Keep textarea focused when user taps editor text area (no custom touch interception). | |
| editor.onDidFocusEditorText(function () { | |
| if (window.__focusKeyboard) window.__focusKeyboard(); | |
| }); | |
| postToRN({ type: 'ready' }); | |
| }); // end require | |
| // βββ Prettier (lazy load from CDN) ββββββββββββββββββββββββββββββββββββββββ | |
| var PV = '2.8.8'; | |
| function loadPrettier(cb) { | |
| if (prettierReady) { cb(); return; } | |
| if (prettierLoading) { | |
| var ti = setInterval(function () { if (prettierReady) { clearInterval(ti); cb(); } }, 300); | |
| return; | |
| } | |
| prettierLoading = true; | |
| var srcs = [ | |
| 'standalone', 'parser-babel', 'parser-typescript', | |
| 'parser-html', 'parser-postcss', 'parser-markdown', | |
| 'parser-yaml', 'parser-graphql', 'parser-angular', | |
| ].map(function (n) { return 'https://cdn.jsdelivr.net/npm/prettier@' + PV + '/' + n + '.js'; }); | |
| var done = 0; | |
| srcs.forEach(function (src) { | |
| var s = document.createElement('script'); | |
| s.src = src; s.async = false; | |
| s.onload = s.onerror = function () { if (++done === srcs.length) { prettierReady = true; cb(); } }; | |
| document.head.appendChild(s); | |
| }); | |
| } | |
| function runPrettier(content, lang, cb) { | |
| loadPrettier(function () { | |
| if (!window.prettier || !window.prettierPlugins) { cb(null); return; } | |
| var pm = { | |
| javascript: 'babel', javascriptreact: 'babel', | |
| typescript: 'typescript', typescriptreact: 'typescript', | |
| html: 'html', css: 'css', scss: 'scss', less: 'less', | |
| json: 'json', markdown: 'markdown', yaml: 'yaml', | |
| graphql: 'graphql', vue: 'vue', angular: 'angular', | |
| }; | |
| var parser = pm[lang]; | |
| if (!parser) { cb(null); return; } | |
| var p = window.prettierPlugins; | |
| var plugins = [p.babel, p.typescript, p.html, p.postcss, p.markdown, p.yaml, p.graphql, p.angular].filter(Boolean); | |
| try { | |
| cb(window.prettier.format(content, { | |
| parser: parser, plugins: plugins, | |
| printWidth: 80, tabWidth: 2, semi: true, | |
| singleQuote: true, trailingComma: 'es5', | |
| bracketSpacing: true, arrowParens: 'avoid', endOfLine: 'lf', | |
| })); | |
| } catch (e) { cb(null); } | |
| }); | |
| } | |
| // βββ Command bus ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| function onMsg(e) { try { run(JSON.parse(e.data)); } catch (_) {} } | |
| window.addEventListener('message', onMsg); | |
| document.addEventListener('message', onMsg); | |
| function run(msg) { | |
| if (!editor) return; | |
| var model = editor.getModel(); | |
| switch (msg.type) { | |
| case 'setContent': | |
| editor.setValue(msg.content || ''); | |
| if (msg.language && model) { | |
| monaco.editor.setModelLanguage(model, msg.language); | |
| // Enable JS/TS diagnostics ONLY for JS/TS files β everything else gets no false errors | |
| var _isJsTs = ['javascript','javascriptreact','typescript','typescriptreact'].indexOf(msg.language) !== -1; | |
| var _diagOn = { noSemanticValidation: !_isJsTs, noSyntaxValidation: !_isJsTs, diagnosticCodesToIgnore: [2792, 2307] }; | |
| monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions(_diagOn); | |
| monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions(_diagOn); | |
| } | |
| editor.setScrollPosition({ scrollTop: 0, scrollLeft: 0 }); | |
| refreshTodo(); | |
| break; | |
| case 'getContent': | |
| postToRN({ type: 'content', content: editor.getValue() }); | |
| break; | |
| case 'setLanguage': | |
| model && monaco.editor.setModelLanguage(model, msg.language); | |
| break; | |
| case 'undo': editor.trigger('kb', 'undo', null); break; | |
| case 'redo': editor.trigger('kb', 'redo', null); break; | |
| case 'find': | |
| (editor.getAction('actions.find') || editor.getAction('editor.action.findWithArgs')).run(); | |
| break; | |
| case 'format': { | |
| var lang = model ? model.getLanguageId() : 'plaintext'; | |
| var src = editor.getValue(); | |
| runPrettier(src, lang, function (r) { | |
| if (r && r !== src) { | |
| var pos = editor.getPosition(); | |
| editor.setValue(r); | |
| pos && editor.setPosition(pos); | |
| } else { | |
| var a = editor.getAction('editor.action.formatDocument'); | |
| a && a.run(); | |
| } | |
| }); | |
| break; | |
| } | |
| case 'fontSize': { | |
| var next = msg.delta !== undefined ? currentFontSize + msg.delta : (msg.size || currentFontSize); | |
| currentFontSize = Math.max(10, Math.min(32, Math.round(next))); | |
| editor.updateOptions({ fontSize: currentFontSize }); | |
| postToRN({ type: 'fontSizeChanged', size: currentFontSize }); | |
| break; | |
| } | |
| case 'toggleWordWrap': | |
| wordWrapEnabled = !wordWrapEnabled; | |
| editor.updateOptions({ wordWrap: wordWrapEnabled ? 'on' : 'off' }); | |
| postToRN({ type: 'wordWrapChanged', enabled: wordWrapEnabled }); | |
| break; | |
| case 'wordWrap': | |
| wordWrapEnabled = !!msg.enabled; | |
| editor.updateOptions({ wordWrap: wordWrapEnabled ? 'on' : 'off' }); | |
| break; | |
| case 'insertText': { | |
| var t = msg.text; | |
| if (t === 'β₯') editor.trigger('kb', 'editor.action.indentLines', null); | |
| else if (t === 'β€') editor.trigger('kb', 'editor.action.outdentLines', null); | |
| else if (t === 'β') editor.trigger('kb', 'cursorLeft', null); | |
| else if (t === 'β') editor.trigger('kb', 'cursorRight', null); | |
| else if (t === 'β') editor.trigger('kb', 'cursorUp', null); | |
| else if (t === 'β') editor.trigger('kb', 'cursorDown', null); | |
| else { | |
| editor.executeEdits('snip', [{ range: editor.getSelection(), text: t, forceMoveMarkers: true }]); | |
| editor.focus(); | |
| } | |
| break; | |
| } | |
| case 'duplicateLine': | |
| editor.trigger('kb', 'editor.action.copyLinesDownAction', null); | |
| break; | |
| case 'toggleComment': | |
| editor.trigger('kb', 'editor.action.commentLine', null); | |
| break; | |
| case 'lineUp': | |
| editor.trigger('kb', 'editor.action.moveLinesUpAction', null); | |
| break; | |
| case 'lineDown': | |
| editor.trigger('kb', 'editor.action.moveLinesDownAction', null); | |
| break; | |
| case 'toggleMinimap': { | |
| var cur = editor.getOption(monaco.editor.EditorOption.minimap); | |
| editor.updateOptions({ minimap: { enabled: !cur.enabled } }); | |
| postToRN({ type: 'minimapChanged', enabled: !cur.enabled }); | |
| break; | |
| } | |
| case 'focusKeyboard': | |
| if (window.__focusKeyboard) window.__focusKeyboard(); | |
| break; | |
| case 'markClean': break; | |
| } | |
| } | |
| function postToRN(obj) { | |
| window.ReactNativeWebView && window.ReactNativeWebView.postMessage(JSON.stringify(obj)); | |
| } | |
| })(); | |
| </script> | |
| </body> | |
| </html> | |