You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1022 lines
40 KiB
1022 lines
40 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[8691],{
|
|
|
|
/***/ 8691:
|
|
/*!************************************************************!*\
|
|
!*** ./src/components/monaco-editor/index.jsx + 3 modules ***!
|
|
\************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"SV": function() { return /* binding */ DiffEditor; },
|
|
"ZP": function() { return /* binding */ monaco_editor; }
|
|
});
|
|
|
|
// UNUSED EXPORTS: getLanguageByMirrorName
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(42122);
|
|
var objectSpread2_default = /*#__PURE__*/__webpack_require__.n(objectSpread2);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/toConsumableArray.js
|
|
var toConsumableArray = __webpack_require__(861);
|
|
var toConsumableArray_default = /*#__PURE__*/__webpack_require__.n(toConsumableArray);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/message/style/index.js + 1 modules
|
|
var style = __webpack_require__(14934);
|
|
// EXTERNAL MODULE: ./node_modules/antd/es/message/index.js + 1 modules
|
|
var message = __webpack_require__(12461);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js
|
|
var createForOfIteratorHelper = __webpack_require__(74704);
|
|
var createForOfIteratorHelper_default = /*#__PURE__*/__webpack_require__.n(createForOfIteratorHelper);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/slicedToArray.js
|
|
var slicedToArray = __webpack_require__(27424);
|
|
var slicedToArray_default = /*#__PURE__*/__webpack_require__.n(slicedToArray);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(70215);
|
|
var objectWithoutProperties_default = /*#__PURE__*/__webpack_require__.n(objectWithoutProperties);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js
|
|
var ResizeObserver_es = __webpack_require__(91033);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/regeneratorRuntime.js
|
|
var regeneratorRuntime = __webpack_require__(17061);
|
|
var regeneratorRuntime_default = /*#__PURE__*/__webpack_require__.n(regeneratorRuntime);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/asyncToGenerator.js
|
|
var asyncToGenerator = __webpack_require__(17156);
|
|
var asyncToGenerator_default = /*#__PURE__*/__webpack_require__.n(asyncToGenerator);
|
|
;// CONCATENATED MODULE: ./src/components/monaco-editor/keywords.tsx
|
|
var cLangage = {
|
|
keywords: ['print', 'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do', 'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if', 'int', 'long', 'register', 'return', 'short', 'signed', 'sizeof', 'static', 'struct', 'switch', 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while']
|
|
};
|
|
var javaLangage = {
|
|
quickKey: [{
|
|
label: "main",
|
|
content: ['public static void main(String[] args) {', '\t$0', '}'].join('\n')
|
|
}, {
|
|
label: "System.out.println",
|
|
content: ['System.out.println($0)'].join('\n')
|
|
}, {
|
|
label: "System.out.print",
|
|
content: ['System.out.print($0)'].join('\n')
|
|
}],
|
|
keywords: ['abstract', 'continue', 'for', 'new', 'switch', 'assert', 'default', 'goto', 'package', 'synchronized', 'boolean', 'do', 'if', 'private', 'this', 'break', 'double', 'implements', 'protected', 'throw', 'byte', 'else', 'import', 'public', 'throws', 'case', 'enum', 'instanceof', 'return', 'transient', 'catch', 'extends', 'int', 'short', 'try', 'char', 'final', 'interface', 'static', 'void', 'class', 'finally', 'long', 'strictfp', 'volatile', 'const', 'float', 'native', 'super', 'while', 'true', 'false']
|
|
};
|
|
var cppLangage = {
|
|
keywords: ['abstract', 'amp', 'array', 'auto', 'bool', 'break', 'case', 'catch', 'char', 'class', 'const', 'constexpr', 'const_cast', 'continue', 'cpu', 'decltype', 'default', 'delegate', 'delete', 'do', 'double', 'dynamic_cast', 'each', 'else', 'enum', 'event', 'explicit', 'export', 'extern', 'false', 'final', 'finally', 'float', 'friend', 'gcnew', 'generic', 'goto', 'in', 'initonly', 'inline', 'int', 'interface', 'interior_ptr', 'internal', 'literal', 'long', 'mutable', 'namespace', 'new', 'noexcept', 'nullptr', '__nullptr', 'operator', 'override', 'partial', 'pascal', 'pin_ptr', 'private', 'property', 'protected', 'public', 'ref', 'register', 'reinterpret_cast', 'restrict', 'return', 'safe_cast', 'sealed', 'short', 'signed', 'sizeof', 'static', 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this', 'thread_local', 'throw', 'tile_static', 'true', 'try', 'typedef', 'typeid', 'typename', 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t', 'where', 'while', '_asm', '_based', '_cdecl', '_declspec', '_fastcall', '_if_exists', '_if_not_exists', '_inline', '_multiple_inheritance', '_pascal', '_single_inheritance', '_stdcall', '_virtual_inheritance', '_w64', '__abstract', '__alignof', '__asm', '__assume', '__based', '__box', '__builtin_alignof', '__cdecl', '__clrcall', '__declspec', '__delegate', '__event', '__except', '__fastcall', '__finally', '__forceinline', '__gc', '__hook', '__identifier', '__if_exists', '__if_not_exists', '__inline', '__int128', '__int16', '__int32', '__int64', '__int8', '__interface', '__leave', '__m128', '__m128d', '__m128i', '__m256', '__m256d', '__m256i', '__m64', '__multiple_inheritance', '__newslot', '__nogc', '__noop', '__nounwind', '__novtordisp', '__pascal', '__pin', '__pragma', '__property', '__ptr32', '__ptr64', '__raise', '__restrict', '__resume', '__sealed', '__single_inheritance', '__stdcall', '__super', '__thiscall', '__try', '__try_cast', '__typeof', '__unaligned', '__unhook', '__uuidof', '__value', '__virtual_inheritance', '__w64', '__wchar_t'],
|
|
operators: ['=', '>', '<', '!', '~', '?', ':', '==', '<=', '>=', '!=', '&&', '||', '++', '--', '+', '-', '*', '/', '&', '|', '^', '%', '<<', '>>', '>>>', '+=', '-=', '*=', '/=', '&=', '|=', '^=', '%=', '<<=', '>>=', '>>>='],
|
|
quickKey: [{
|
|
label: "ifelse",
|
|
content: ['if (${1:condition}) {', '\t$0', '} else {', '\t', '}'].join('\n')
|
|
}, {
|
|
label: "include",
|
|
content: 'include<$0>'
|
|
}, {
|
|
label: "printf",
|
|
content: 'printf($0)'
|
|
}, {
|
|
label: "system",
|
|
content: 'system("$0")'
|
|
}, {
|
|
label: "main",
|
|
content: ['int main () {', '\t$0', '}'].join('\n')
|
|
}, {
|
|
label: "if",
|
|
content: ['if () {', '\t$0', '}'].join('\n')
|
|
}, {
|
|
label: "for",
|
|
content: ['for(int j=0 ; j<10; j++){', '\t$0', '}'].join('\n')
|
|
}, {
|
|
label: "trycatch",
|
|
content: ['try{', '\t$0', '}catch(ExceptionName e){', '}'].join('\n')
|
|
}, {
|
|
label: "using namespace std;",
|
|
content: ['using namespace std;'].join('\n')
|
|
}, {
|
|
label: "include <iostream>",
|
|
content: ['#include <iostream>'].join('\n')
|
|
}, {
|
|
label: "include <vector>",
|
|
content: ['#include <vector>'].join('\n')
|
|
}, {
|
|
label: "include <cstdio>",
|
|
content: ['#include <cstdio>'].join('\n')
|
|
}, {
|
|
label: "include <cstring>",
|
|
content: ['#include <cstring>'].join('\n')
|
|
}, {
|
|
label: "include <sstream>",
|
|
content: ['#include <sstream>'].join('\n')
|
|
}, {
|
|
label: "include <fstream>",
|
|
content: ['#include <fstream>'].join('\n')
|
|
}, {
|
|
label: "include <map>",
|
|
content: ['#include <map>'].join('\n')
|
|
}, {
|
|
label: "include <string>",
|
|
content: ['#include <string>'].join('\n')
|
|
}, {
|
|
label: "include <cmath>",
|
|
content: ['#include <cmath>'].join('\n')
|
|
}]
|
|
};
|
|
var pythonLangage = {
|
|
keywords: ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'None', 'not', 'or', 'pass', 'raise', 'return', 'self', 'try', 'while', 'with', 'yield', 'int', 'float', 'long', 'complex', 'hex', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'file', 'filter', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'id', 'input', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'locals', 'list', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'reversed', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip', 'True', 'False', '__dict__', '__methods__', '__members__', '__class__', '__bases__', '__name__', '__mro__', '__subclasses__', '__init__', '__import__'],
|
|
quickKey: [{
|
|
label: "print",
|
|
content: ['print($0)'].join('\n')
|
|
}
|
|
// { label: "#include", content: '#include ""' },
|
|
// { label: "printf", content: 'printf("")' },
|
|
]
|
|
};
|
|
|
|
var scalaLangage = {
|
|
keywords: ['asInstanceOf', 'catch', 'class', 'classOf', 'def', 'do', 'else', 'extends', 'finally', 'for', 'foreach', 'forSome', 'if', 'import', 'isInstanceOf', 'macro', 'match', 'new', 'object', 'package', 'return', 'throw', 'trait', 'try', 'type', 'until', 'val', 'var', 'while', 'with', 'yield',
|
|
// Dotty-specific:
|
|
'given', 'enum', 'then'],
|
|
quickKey: [{
|
|
label: "println",
|
|
content: ['println($0)'].join('\n')
|
|
}
|
|
// { label: "#include", content: '#include ""' },
|
|
// { label: "printf", content: 'printf("")' },
|
|
]
|
|
};
|
|
// EXTERNAL MODULE: ./node_modules/js-beautify/js/index.js
|
|
var js = __webpack_require__(84204);
|
|
var js_default = /*#__PURE__*/__webpack_require__.n(js);
|
|
;// CONCATENATED MODULE: ./src/components/monaco-editor/monaco-suggest-config.tsx
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var baseConfig = {
|
|
languages: ['c', 'abap', 'apex', 'azcli', 'bat', 'cameligo', 'clojure', 'coffee', 'cpp', 'csharp', 'csp', 'css', 'dockerfile', 'fsharp', 'go', 'graphql', 'handlebars', 'html', 'ini', 'java', 'javascript', 'json', 'kotlin', 'less', 'lua', 'markdown', 'mips', 'msdax', 'mysql', 'objective-c', 'pascal', 'pascaligo', 'perl', 'pgsql', 'php', 'postiats', 'powerquery', 'powershell', 'pug', 'python', 'r', 'razor', 'redis', 'redshift', 'restructuredtext', 'ruby', 'rust', 'sb', 'scheme', 'scss', 'shell', 'solidity', 'sophia', 'sql', 'st', 'swift', 'tcl', 'twig', 'vb', 'xml', "yaml'"],
|
|
tables: {
|
|
users: ["name", "id", "email", "phone", "password"],
|
|
roles: ["id", "name", "order", "created_at", "updated_at", "deleted_at"]
|
|
}
|
|
};
|
|
var getKeywordsSuggest = function getKeywordsSuggest(monaco, keywords) {
|
|
return keywords.map(function (key) {
|
|
return {
|
|
label: key,
|
|
// 显示的名称
|
|
kind: monaco.languages.CompletionItemKind.Keyword,
|
|
insertText: key // 真实补全的值
|
|
};
|
|
});
|
|
};
|
|
|
|
var getTableSuggest = function getTableSuggest(monaco) {
|
|
return Object.keys(baseConfig.tables).map(function (key) {
|
|
return {
|
|
label: key,
|
|
// 显示的名称
|
|
kind: monaco.languages.CompletionItemKind.Variable,
|
|
insertText: key // 真实补全的值
|
|
};
|
|
});
|
|
};
|
|
|
|
var getFieldsSuggest = function getFieldsSuggest(tableName, monaco) {
|
|
var fields = baseConfig.tables[tableName];
|
|
if (!fields) {
|
|
return [];
|
|
}
|
|
return fields.map(function (name) {
|
|
return {
|
|
label: name,
|
|
kind: monaco.languages.CompletionItemKind.Field,
|
|
insertText: name
|
|
};
|
|
});
|
|
};
|
|
function getSuggestions(monaco, model, position, keywords, snippts) {
|
|
var word = model.getWordUntilPosition(position);
|
|
var range = {
|
|
startLineNumber: position.lineNumber,
|
|
endLineNumber: position.lineNumber,
|
|
startColumn: word.startColumn,
|
|
endColumn: word.endColumn
|
|
};
|
|
var rs = keywords.map(function (item) {
|
|
return {
|
|
label: item,
|
|
kind: monaco.languages.CompletionItemKind.Keyword,
|
|
insertText: item,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: range
|
|
};
|
|
});
|
|
snippts.map(function (item) {
|
|
rs.push(_objectSpread(_objectSpread({}, item), {}, {
|
|
range: range
|
|
}));
|
|
});
|
|
return rs;
|
|
}
|
|
/* harmony default export */ var monaco_suggest_config = (function (monaco) {
|
|
baseConfig.languages.map(function (item) {
|
|
monaco.languages.registerDocumentFormattingEditProvider(item, {
|
|
provideDocumentFormattingEdits: function provideDocumentFormattingEdits(model, options, token) {
|
|
return asyncToGenerator_default()( /*#__PURE__*/regeneratorRuntime_default()().mark(function _callee() {
|
|
var formattedText;
|
|
return regeneratorRuntime_default()().wrap(function _callee$(_context) {
|
|
while (1) switch (_context.prev = _context.next) {
|
|
case 0:
|
|
formattedText = js_default()(model.getValue(), {
|
|
"indent_size": "2",
|
|
"indent_char": " ",
|
|
"max_preserve_newlines": "2",
|
|
"preserve_newlines": true,
|
|
"keep_array_indentation": true,
|
|
"break_chained_methods": false,
|
|
"indent_scripts": "normal",
|
|
"brace_style": "collapse",
|
|
"space_before_conditional": true,
|
|
"unescape_strings": false,
|
|
"jslint_happy": false,
|
|
"end_with_newline": true,
|
|
"wrap_line_length": "0",
|
|
"indent_inner_html": false,
|
|
"comma_first": false,
|
|
"e4x": false,
|
|
"indent_empty_lines": false
|
|
});
|
|
return _context.abrupt("return", [{
|
|
range: model.getFullModelRange(),
|
|
text: formattedText
|
|
}]);
|
|
case 2:
|
|
case "end":
|
|
return _context.stop();
|
|
}
|
|
}, _callee);
|
|
}))();
|
|
}
|
|
});
|
|
return item;
|
|
});
|
|
var cppKeyPrompt = cppLangage.quickKey.map(function (item) {
|
|
return {
|
|
label: item.label,
|
|
kind: monaco.languages.CompletionItemKind.Method,
|
|
insertText: item.content,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet
|
|
};
|
|
});
|
|
var pythonKeyPrompt = pythonLangage.quickKey.map(function (item) {
|
|
return {
|
|
label: item.label,
|
|
kind: monaco.languages.CompletionItemKind.Method,
|
|
insertText: item.content,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet
|
|
};
|
|
});
|
|
var javaKeyPrompt = javaLangage.quickKey.map(function (item) {
|
|
return {
|
|
label: item.label,
|
|
kind: monaco.languages.CompletionItemKind.Method,
|
|
insertText: item.content,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet
|
|
};
|
|
});
|
|
monaco.languages.registerCompletionItemProvider('cpp', {
|
|
provideCompletionItems: function provideCompletionItems(model, position) {
|
|
var word = model.getWordUntilPosition(position);
|
|
var wordRange = {
|
|
startLineNumber: position.lineNumber,
|
|
endLineNumber: position.lineNumber,
|
|
startColumn: word.startColumn,
|
|
endColumn: word.endColumn
|
|
};
|
|
var value = model.getLineContent(position.lineNumber).substring(word.startColumn - 2, word.endColumn);
|
|
return {
|
|
suggestions: [].concat(toConsumableArray_default()(cppLangage.keywords.map(function (item) {
|
|
return {
|
|
label: item,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item,
|
|
insertText: item,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})), toConsumableArray_default()(cppLangage.quickKey.map(function (item) {
|
|
return {
|
|
label: item.label,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item.content,
|
|
insertText: value.startsWith("#") ? item.content.replace(/#/, '') : item.content,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})))
|
|
};
|
|
}
|
|
});
|
|
monaco.languages.registerCompletionItemProvider('c', {
|
|
provideCompletionItems: function provideCompletionItems(model, position) {
|
|
var word = model.getWordUntilPosition(position);
|
|
var wordRange = {
|
|
startLineNumber: position.lineNumber,
|
|
endLineNumber: position.lineNumber,
|
|
startColumn: word.startColumn,
|
|
endColumn: word.endColumn
|
|
};
|
|
return {
|
|
suggestions: toConsumableArray_default()(cLangage.keywords.map(function (item) {
|
|
return {
|
|
label: item,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item,
|
|
insertText: item,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
}))
|
|
};
|
|
}
|
|
});
|
|
monaco.languages.registerCompletionItemProvider('java', {
|
|
provideCompletionItems: function provideCompletionItems(model, position) {
|
|
var word = model.getWordUntilPosition(position);
|
|
var wordRange = {
|
|
startLineNumber: position.lineNumber,
|
|
endLineNumber: position.lineNumber,
|
|
startColumn: word.startColumn,
|
|
endColumn: word.endColumn
|
|
};
|
|
var value = model.getLineContent(position.lineNumber).substring(word.startColumn - 2, word.endColumn);
|
|
return {
|
|
suggestions: [].concat(toConsumableArray_default()(javaLangage.keywords.map(function (item) {
|
|
return {
|
|
label: item,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item,
|
|
insertText: item,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})), toConsumableArray_default()(javaLangage.quickKey.map(function (item) {
|
|
return {
|
|
label: item.label,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item.content,
|
|
insertText: value.startsWith("#") ? item.content.replace(/#/, '') : item.content,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})))
|
|
};
|
|
}
|
|
});
|
|
monaco.languages.registerCompletionItemProvider('scala', {
|
|
provideCompletionItems: function provideCompletionItems(model, position) {
|
|
var word = model.getWordUntilPosition(position);
|
|
var wordRange = {
|
|
startLineNumber: position.lineNumber,
|
|
endLineNumber: position.lineNumber,
|
|
startColumn: word.startColumn,
|
|
endColumn: word.endColumn
|
|
};
|
|
var value = model.getLineContent(position.lineNumber).substring(word.startColumn - 2, word.endColumn);
|
|
return {
|
|
suggestions: [].concat(toConsumableArray_default()(scalaLangage.keywords.map(function (item) {
|
|
return {
|
|
label: item,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item,
|
|
insertText: item,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})), toConsumableArray_default()(scalaLangage.quickKey.map(function (item) {
|
|
return {
|
|
label: item.label,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item.content,
|
|
insertText: value.startsWith("#") ? item.content.replace(/#/, '') : item.content,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})))
|
|
};
|
|
}
|
|
});
|
|
monaco.languages.registerCompletionItemProvider('python', {
|
|
provideCompletionItems: function provideCompletionItems(model, position) {
|
|
var word = model.getWordUntilPosition(position);
|
|
var wordRange = {
|
|
startLineNumber: position.lineNumber,
|
|
endLineNumber: position.lineNumber,
|
|
startColumn: word.startColumn,
|
|
endColumn: word.endColumn
|
|
};
|
|
var value = model.getLineContent(position.lineNumber).substring(word.startColumn - 2, word.endColumn);
|
|
return {
|
|
suggestions: [].concat(toConsumableArray_default()(pythonLangage.keywords.map(function (item) {
|
|
return {
|
|
label: item,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item,
|
|
insertText: item,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})), toConsumableArray_default()(pythonLangage.quickKey.map(function (item) {
|
|
return {
|
|
label: item.label,
|
|
kind: monaco.languages.CompletionItemKind.Function,
|
|
documentation: item.content,
|
|
insertText: value.startsWith("#") ? item.content.replace(/#/, '') : item.content,
|
|
insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
|
|
range: wordRange
|
|
};
|
|
})))
|
|
};
|
|
}
|
|
});
|
|
});
|
|
var tipTxt = '该任务关卡设置了禁止复制粘贴，请手动输入代码。';
|
|
// EXTERNAL MODULE: ./node_modules/monaco-editor/esm/vs/platform/actions/common/actions.js
|
|
var actions = __webpack_require__(84144);
|
|
// EXTERNAL MODULE: ./node_modules/lodash/lodash.js
|
|
var lodash = __webpack_require__(96486);
|
|
;// CONCATENATED MODULE: ./src/components/monaco-editor/index.css
|
|
// extracted by mini-css-extract-plugin
|
|
|
|
// EXTERNAL MODULE: ./node_modules/react/jsx-runtime.js
|
|
var jsx_runtime = __webpack_require__(85893);
|
|
;// CONCATENATED MODULE: ./src/components/monaco-editor/index.jsx
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _excluded = ["width", "height", "value", "language", "style", "options", "overrideServices", "theme", "onEditBlur", "onSave", "autoHeight", "forbidCopy", "onChange", "editorDidMount", "onFocus", "filename", "errorLine", "errorContent"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function processSize(size) {
|
|
return !/^\d+$/.test(size) ? size : "".concat(size, "px");
|
|
}
|
|
function noop() {}
|
|
var __prevent_trigger_change_event = false;
|
|
var DICT = {
|
|
'Python3.6': 'python',
|
|
'Python2.7': 'python',
|
|
Dynamips: 'cpp',
|
|
Java: 'java',
|
|
Web: 'php',
|
|
Html: 'html',
|
|
Hive: 'sql',
|
|
Hadoop: 'java',
|
|
SDL: 'cpp',
|
|
PHP: 'php',
|
|
Matlab: 'python',
|
|
Git: 'python',
|
|
Python: 'python',
|
|
'C/C++': 'cpp',
|
|
'C++': 'cpp',
|
|
C: 'cpp',
|
|
Ruby: 'ruby',
|
|
Shell: 'shell',
|
|
JavaScript: 'javascript',
|
|
Perl6: 'perl',
|
|
Kotlin: 'kotlin',
|
|
Elixir: 'elixir',
|
|
Android: 'java',
|
|
JavaWeb: 'java',
|
|
Go: 'go',
|
|
Spark: 'sql',
|
|
MachineLearning: 'python',
|
|
Verilog: 'xml',
|
|
'Verilog/VNC': 'xml',
|
|
Docker: 'dockerfile',
|
|
'C#': 'csharp',
|
|
SQLite3: 'sql',
|
|
Oracle: 'sql',
|
|
Vhdl: 'vhdl',
|
|
R: 'r',
|
|
Swift: 'swift',
|
|
SQLServer: 'mysql',
|
|
MySQL: 'mysql',
|
|
Mongo: 'sql',
|
|
PostgreSql: 'pgsql',
|
|
Hbase: 'powershell',
|
|
Sqoop: 'sql',
|
|
Nasm: 'cpp',
|
|
Kafka: 'java',
|
|
Flink: 'java',
|
|
Sml: 'javascript',
|
|
OpenGL: 'cpp',
|
|
Perl5: 'perl',
|
|
Orange: 'python',
|
|
Scala: "scale"
|
|
};
|
|
function getLanguageByMirrorName() {
|
|
var mirror_name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
var lang = mirror_name;
|
|
if (Array.isArray(mirror_name)) {
|
|
for (var i = 0; i < mirror_name.length; i++) {
|
|
var languageVal = DICT[mirror_name[i]];
|
|
if (languageVal) {
|
|
return languageVal;
|
|
}
|
|
}
|
|
return lang[0];
|
|
}
|
|
return DICT[lang] || lang;
|
|
}
|
|
|
|
//onCodeChange 必须是幂等的，因为只会注册一次，如果有变化，会响应旧的，产生脏数据
|
|
var monaco = null;
|
|
/* harmony default export */ var monaco_editor = (function (_ref) {
|
|
var _ref$width = _ref.width,
|
|
width = _ref$width === void 0 ? '100%' : _ref$width,
|
|
_ref$height = _ref.height,
|
|
height = _ref$height === void 0 ? '100%' : _ref$height,
|
|
value = _ref.value,
|
|
_ref$language = _ref.language,
|
|
language = _ref$language === void 0 ? 'javascript' : _ref$language,
|
|
_ref$style = _ref.style,
|
|
style = _ref$style === void 0 ? {} : _ref$style,
|
|
_ref$options = _ref.options,
|
|
options = _ref$options === void 0 ? {} : _ref$options,
|
|
_ref$overrideServices = _ref.overrideServices,
|
|
overrideServices = _ref$overrideServices === void 0 ? {} : _ref$overrideServices,
|
|
_ref$theme = _ref.theme,
|
|
theme = _ref$theme === void 0 ? 'vs-dark' : _ref$theme,
|
|
onEditBlur = _ref.onEditBlur,
|
|
onSave = _ref.onSave,
|
|
_ref$autoHeight = _ref.autoHeight,
|
|
autoHeight = _ref$autoHeight === void 0 ? false : _ref$autoHeight,
|
|
_ref$forbidCopy = _ref.forbidCopy,
|
|
forbidCopy = _ref$forbidCopy === void 0 ? false : _ref$forbidCopy,
|
|
_ref$onChange = _ref.onChange,
|
|
onChange = _ref$onChange === void 0 ? noop : _ref$onChange,
|
|
_ref$editorDidMount = _ref.editorDidMount,
|
|
editorDidMount = _ref$editorDidMount === void 0 ? noop : _ref$editorDidMount,
|
|
_ref$onFocus = _ref.onFocus,
|
|
onFocus = _ref$onFocus === void 0 ? noop : _ref$onFocus,
|
|
_ref$filename = _ref.filename,
|
|
filename = _ref$filename === void 0 ? 'educoder.txt' : _ref$filename,
|
|
errorLine = _ref.errorLine,
|
|
_ref$errorContent = _ref.errorContent,
|
|
errorContent = _ref$errorContent === void 0 ? '' : _ref$errorContent,
|
|
props = objectWithoutProperties_default()(_ref, _excluded);
|
|
var editorEl = (0,react.useRef)();
|
|
var editor = (0,react.useRef)({});
|
|
var optionsRef = (0,react.useRef)();
|
|
var timeRef = (0,react.useRef)();
|
|
var inputLock = (0,react.useRef)(false);
|
|
var inputLockTime = (0,react.useRef)();
|
|
var _useState = (0,react.useState)(false),
|
|
_useState2 = slicedToArray_default()(_useState, 2),
|
|
init = _useState2[0],
|
|
setInit = _useState2[1];
|
|
function onLayout() {
|
|
var ro;
|
|
if (editorEl.current) {
|
|
ro = new ResizeObserver_es/* default */.Z(function (entries) {
|
|
var _iterator = createForOfIteratorHelper_default()(entries),
|
|
_step;
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var entry = _step.value;
|
|
if (entry.target.offsetHeight > 0 || entry.target.offsetWidth > 0) {
|
|
editor.current.instance.layout();
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
});
|
|
ro.observe(editorEl.current);
|
|
}
|
|
return ro;
|
|
}
|
|
function tipWarn() {
|
|
message/* default.warn */.ZP.warn({
|
|
content: decodeURIComponent(tipTxt),
|
|
key: "monaco-editor-tip"
|
|
});
|
|
}
|
|
var setCodeValue = function setCodeValue() {
|
|
var instance = editor.current.instance;
|
|
if (value != null && instance && init) {
|
|
var model = instance.getModel();
|
|
if (model && value !== model.getValue()) {
|
|
__prevent_trigger_change_event = true;
|
|
model.setValue(value);
|
|
instance.layout();
|
|
__prevent_trigger_change_event = false;
|
|
}
|
|
}
|
|
};
|
|
(0,react.useEffect)(function () {
|
|
if (timeRef.current) clearTimeout(timeRef.current);
|
|
timeRef.current = setTimeout(function () {
|
|
setCodeValue();
|
|
}, 500);
|
|
}, [value, init, editor.current]);
|
|
(0,react.useEffect)(function () {
|
|
if (errorLine && editor.current && editor.current.instance) {
|
|
var instance = editor.current.instance;
|
|
instance.changeViewZones(function (changeAccessor) {
|
|
var domNode = document.createElement('div');
|
|
domNode.style.padding = '10px 20px';
|
|
domNode.style.width = 'calc(100% - 20px)';
|
|
domNode.className = 'my-error-line-wrp';
|
|
domNode.innerHTML = errorContent;
|
|
changeAccessor.addZone({
|
|
afterLineNumber: errorLine || 11,
|
|
heightInLines: 3,
|
|
domNode: domNode
|
|
});
|
|
});
|
|
var overlayWidget = {
|
|
domNode: null,
|
|
getId: function getId() {
|
|
return 'my.overlay.widget';
|
|
},
|
|
getDomNode: function getDomNode() {
|
|
if (!this.domNode) {
|
|
this.domNode = document.createElement('div');
|
|
this.domNode.innerHTML = '';
|
|
this.domNode.style.width = '100%';
|
|
this.domNode.style.padding = '20px 100px';
|
|
this.domNode.style.right = '0px';
|
|
this.domNode.style.top = '50px';
|
|
this.domNode.style.position = 'relative';
|
|
this.domNode.style.color = '#333';
|
|
}
|
|
return this.domNode;
|
|
},
|
|
getPosition: function getPosition() {
|
|
return null;
|
|
}
|
|
};
|
|
instance.addOverlayWidget(overlayWidget);
|
|
// instance.revealPositionInCenter(11,1);
|
|
instance.revealPositionInCenter({
|
|
lineNumber: 20,
|
|
column: 1
|
|
});
|
|
}
|
|
}, [errorLine, editor.current, init]);
|
|
function onPaste() {
|
|
var instance = editor.current.instance;
|
|
if (instance) {
|
|
var selection = instance.getSelection();
|
|
var pastePos = editor.current.pastePos || {};
|
|
var range = new monaco.Range(pastePos.startLineNumber || selection.endLineNumber, pastePos.startColumn || selection.endColumn, pastePos.endLineNumber || selection.endLineNumber, pastePos.endColumn || selection.endColumn);
|
|
setTimeout(function () {
|
|
instance.executeEdits('', [{
|
|
range: range,
|
|
text: ''
|
|
}]);
|
|
}, 300);
|
|
}
|
|
}
|
|
function onSaveHandler(e) {
|
|
if ((window.navigator.platform.match('Mac') ? e.metaKey : e.ctrlKey) && e.keyCode == 83) {
|
|
e.preventDefault();
|
|
onSave();
|
|
}
|
|
}
|
|
var autoCalcHeight = function autoCalcHeight() {
|
|
if (autoHeight && editor.current.instance) {
|
|
var _height = editor.current.instance.getContentHeight();
|
|
setFixedHeight(_height < height ? height : _height);
|
|
} else {
|
|
setFixedHeight(height);
|
|
}
|
|
};
|
|
function fakeClick(obj) {
|
|
var ev = document.createEvent('MouseEvents');
|
|
ev.initMouseEvent('click', true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
|
|
obj.dispatchEvent(ev);
|
|
}
|
|
var checkPaste = function checkPaste(event) {
|
|
var keyCode = event.keyCode,
|
|
ctrlKey = event.ctrlKey,
|
|
metaKey = event.metaKey,
|
|
target = event.target,
|
|
type = event.type;
|
|
if ((type === "paste" || (keyCode === 67 || keyCode === 86) && (metaKey || ctrlKey)) && target.nodeName === "TEXTAREA") {
|
|
tipWarn();
|
|
event.preventDefault();
|
|
}
|
|
return false;
|
|
};
|
|
function exportRaw(name, data) {
|
|
var urlObject = window.URL || window.webkitURL || window;
|
|
var export_blob = new Blob([data]);
|
|
var save_link = document.createElementNS('http://www.w3.org/1999/xhtml', 'a');
|
|
save_link.href = urlObject.createObjectURL(export_blob);
|
|
save_link.download = name;
|
|
fakeClick(save_link);
|
|
}
|
|
(0,react.useEffect)(function () {
|
|
autoCalcHeight();
|
|
}, [autoCalcHeight]);
|
|
(0,react.useEffect)(function () {
|
|
if (editorEl.current && !init) {
|
|
// require.config({ paths: { vs: 'monaco-editor/min/vs' } });
|
|
// require.config({
|
|
// 'vs/nls': {
|
|
// availableLanguages: {
|
|
// '*': 'de',
|
|
// },
|
|
// },
|
|
// });
|
|
Promise.all(/*! import() | monaco-editor */[__webpack_require__.e(48764), __webpack_require__.e(39404)]).then(__webpack_require__.bind(__webpack_require__, /*! monaco-editor/esm/vs/editor/editor.api.js */ 26565)).then(function (mod) {
|
|
try {
|
|
monaco = mod;
|
|
editor.current.instance = monaco.editor.create(editorEl.current, {
|
|
value: value,
|
|
language: getLanguageByMirrorName(language),
|
|
theme: theme,
|
|
requireConfig: {
|
|
'vs/nls': {
|
|
availableLanguages: {
|
|
'*': 'zh-cn'
|
|
}
|
|
}
|
|
},
|
|
wordWrap: true,
|
|
autoIndent: true,
|
|
contextmenu: true,
|
|
// formatOnPaste: true,
|
|
formatOnType: true
|
|
}, overrideServices);
|
|
var instance = editor.current.instance;
|
|
var menus = actions/* MenuRegistry._menuItems */.BH._menuItems;
|
|
var contextMenuEntry = toConsumableArray_default()(menus).find(function (entry) {
|
|
return entry[0]._debugName == "EditorContext";
|
|
});
|
|
var contextMenuLinks = contextMenuEntry[1];
|
|
var removableIds = ["editor.action.clipboardCopyWithSyntaxHighlightingAction", "editor.action.quickCommand", "editor.action.clipboardCopyAction", "editor.action.clipboardPasteAction", "editor.action.clipboardCutAction"];
|
|
var removeById = function removeById(list, ids) {
|
|
var node = list._first;
|
|
do {
|
|
var _node$element, _node$element$command;
|
|
var shouldRemove = ids.includes((_node$element = node.element) === null || _node$element === void 0 ? void 0 : (_node$element$command = _node$element.command) === null || _node$element$command === void 0 ? void 0 : _node$element$command.id);
|
|
if (shouldRemove) {
|
|
list._remove(node);
|
|
}
|
|
} while (node = node.next);
|
|
};
|
|
editorDidMount(instance, monaco);
|
|
setTimeout(function () {
|
|
autoCalcHeight();
|
|
editor.current.instance.addAction({
|
|
id: 'd123123',
|
|
label: 'Download File',
|
|
contextMenuGroupId: '9_cutcopypaste',
|
|
run: function run() {
|
|
exportRaw(filename || 'educoder.txt', instance.getValue());
|
|
}
|
|
});
|
|
instance.getDomNode().addEventListener('input', function () {
|
|
if (optionsRef.current.autoFormat) instance.getAction('editor.action.formatDocument').run();
|
|
});
|
|
}, 500);
|
|
editor.current.subscription = instance.onDidChangeModelContent(function (event) {
|
|
if (!inputLock.current) {
|
|
autoCalcHeight();
|
|
onChange(instance.getValue(), event);
|
|
} else {
|
|
clearTimeout(inputLockTime.current);
|
|
}
|
|
inputLockTime.current = setTimeout(function () {
|
|
inputLock.current = false;
|
|
}, 500);
|
|
});
|
|
if (!window.Monaco) monaco_suggest_config(monaco, getLanguageByMirrorName(language));
|
|
if (forbidCopy) {
|
|
removeById(contextMenuLinks, removableIds);
|
|
editorEl.current.classList.add("noCopyPaste");
|
|
window.removeEventListener("keydown", checkPaste);
|
|
window.removeEventListener("paste", checkPaste);
|
|
window.addEventListener("keydown", checkPaste);
|
|
window.addEventListener("paste", checkPaste);
|
|
}
|
|
window.Monaco = monaco;
|
|
if (onEditBlur) {
|
|
instance.onDidBlurEditorWidget(function () {
|
|
onEditBlur(instance.getValue());
|
|
});
|
|
}
|
|
if (onFocus) {
|
|
instance.onDidFocusEditorText(function () {
|
|
onFocus(instance.getValue());
|
|
});
|
|
}
|
|
if (forbidCopy) {
|
|
try {
|
|
window.addEventListener('paste', onPaste);
|
|
} catch (e) {}
|
|
}
|
|
var ro = onLayout();
|
|
setInit(true);
|
|
return function () {
|
|
var el = editor.current.instance;
|
|
el.dispose();
|
|
var model = el.getModel();
|
|
if (model) {
|
|
model.dispose();
|
|
}
|
|
if (editor.current.subscription) {
|
|
editor.current.subscription.dispose();
|
|
}
|
|
if (forbidCopy) {
|
|
window.removeEventListener('paste', onPaste);
|
|
}
|
|
ro.unobserve(editorEl.current);
|
|
};
|
|
} catch (e) {
|
|
// ;
|
|
}
|
|
});
|
|
}
|
|
}, []);
|
|
(0,react.useEffect)(function () {
|
|
var instance = editor.current.instance;
|
|
if (instance && init) {
|
|
document.addEventListener('keydown', onSaveHandler, false);
|
|
return function () {
|
|
document.removeEventListener('keydown', onSaveHandler);
|
|
};
|
|
}
|
|
}, [onSave, init]);
|
|
(0,react.useEffect)(function () {
|
|
var instance = editor.current.instance;
|
|
if (instance && init) {
|
|
var lang = getLanguageByMirrorName(language);
|
|
monaco.editor.setModelLanguage(instance.getModel(), lang);
|
|
}
|
|
}, [language, init]);
|
|
(0,react.useEffect)(function () {
|
|
var instance = editor.current.instance;
|
|
if (instance && init) {
|
|
monaco.editor.setTheme(theme);
|
|
}
|
|
}, [theme, init]);
|
|
(0,react.useEffect)(function () {
|
|
var instance = editor.current.instance;
|
|
optionsRef.current = options;
|
|
if (instance && init) {
|
|
instance.updateOptions(objectSpread2_default()({}, options));
|
|
setTimeout(function () {
|
|
instance.getModel().updateOptions(objectSpread2_default()({}, options));
|
|
}, 200);
|
|
}
|
|
}, [JSON.stringify(options), init]);
|
|
(0,react.useEffect)(function () {
|
|
var instance = editor.current.instance;
|
|
if (instance && init) {
|
|
instance.layout();
|
|
}
|
|
}, [width, height, init]);
|
|
|
|
// const fixedWidth = processSize(width);
|
|
// const fixedHeight = processSize(height);
|
|
|
|
var _useState3 = (0,react.useState)(processSize(width)),
|
|
_useState4 = slicedToArray_default()(_useState3, 2),
|
|
fixedWidth = _useState4[0],
|
|
setFixedWidth = _useState4[1];
|
|
var _useState5 = (0,react.useState)(processSize(height)),
|
|
_useState6 = slicedToArray_default()(_useState5, 2),
|
|
fixedHeight = _useState6[0],
|
|
setFixedHeight = _useState6[1];
|
|
var mergeStyle = objectSpread2_default()(objectSpread2_default()({}, style), {}, {
|
|
width: fixedWidth,
|
|
height: fixedHeight
|
|
});
|
|
return /*#__PURE__*/(0,jsx_runtime.jsx)("div", {
|
|
className: "my-monaco-editor",
|
|
ref: editorEl,
|
|
style: mergeStyle
|
|
});
|
|
});
|
|
function DiffEditor(_ref2) {
|
|
var _ref2$width = _ref2.width,
|
|
width = _ref2$width === void 0 ? '100%' : _ref2$width,
|
|
_ref2$height = _ref2.height,
|
|
height = _ref2$height === void 0 ? '100%' : _ref2$height,
|
|
original = _ref2.original,
|
|
modified = _ref2.modified,
|
|
language = _ref2.language,
|
|
_ref2$options = _ref2.options,
|
|
options = _ref2$options === void 0 ? {} : _ref2$options;
|
|
var editorEl = (0,react.useRef)();
|
|
var _useState7 = (0,react.useState)(null),
|
|
_useState8 = slicedToArray_default()(_useState7, 2),
|
|
instance = _useState8[0],
|
|
setInstance = _useState8[1];
|
|
function onLayout(instance) {
|
|
var ro;
|
|
if (editorEl.current) {
|
|
ro = new ResizeObserver_es/* default */.Z(function (entries) {
|
|
var _iterator2 = createForOfIteratorHelper_default()(entries),
|
|
_step2;
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var entry = _step2.value;
|
|
if (entry.target.offsetHeight > 0 || entry.target.offsetWidth > 0) {
|
|
instance.layout();
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
});
|
|
ro.observe(editorEl.current);
|
|
}
|
|
return ro;
|
|
}
|
|
(0,react.useEffect)(function () {
|
|
if (editorEl.current) {
|
|
Promise.all(/*! import() | monaco-editor */[__webpack_require__.e(48764), __webpack_require__.e(39404)]).then(__webpack_require__.bind(__webpack_require__, /*! monaco-editor/esm/vs/editor/editor.api.js */ 26565)).then(function (mod) {
|
|
monaco = mod;
|
|
var instance = monaco.editor.createDiffEditor(editorEl.current, objectSpread2_default()(objectSpread2_default()({
|
|
enableSplitViewResizing: false,
|
|
scrollBeyondLastLine: false,
|
|
roundedSelection: false,
|
|
renderIndicators: false,
|
|
useShadows: false,
|
|
horizontal: 'hidden',
|
|
lineNumbers: 'off',
|
|
ignoreTrimWhitespace: false,
|
|
'semanticHighlighting.enabled': true,
|
|
followsCaret: true,
|
|
// resets the navigator state when the user selects something in the editor
|
|
ignoreCharChanges: true,
|
|
// jump from line to line,
|
|
minimap: {
|
|
enabled: false
|
|
},
|
|
readOnly: true
|
|
}, options), {}, {
|
|
wordWrap: true
|
|
}));
|
|
setInstance(instance);
|
|
var ro = onLayout(instance);
|
|
return function () {
|
|
instance.dispose();
|
|
var model = instance.getModel();
|
|
if (model) {
|
|
model.dispose();
|
|
}
|
|
ro.unobserve(editorEl.current);
|
|
};
|
|
});
|
|
}
|
|
return function () {
|
|
window.removeEventListener("keydown", checkPaste);
|
|
window.removeEventListener("paste", checkPaste);
|
|
};
|
|
}, []);
|
|
(0,react.useEffect)(function () {
|
|
if (instance) {
|
|
instance.setModel({
|
|
original: monaco.editor.createModel(original, language),
|
|
modified: monaco.editor.createModel(modified, language)
|
|
});
|
|
}
|
|
}, [original, modified, language, instance]);
|
|
var fixedWidth = processSize(width);
|
|
var fixedHeight = processSize(height);
|
|
var style = {
|
|
width: fixedWidth,
|
|
height: fixedHeight
|
|
};
|
|
return /*#__PURE__*/(0,jsx_runtime.jsx)("div", {
|
|
className: "my-diff-editor",
|
|
ref: editorEl,
|
|
style: style
|
|
});
|
|
}
|
|
|
|
/***/ })
|
|
|
|
}]); |