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.
815 lines
23 KiB
815 lines
23 KiB
(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[125],{
|
|
|
|
/***/ "6xWC":
|
|
/*!************************************!*\
|
|
!*** ./src/pages/Editor/index.tsx ***!
|
|
\************************************/
|
|
/*! exports provided: default */
|
|
/*! all exports used */
|
|
/*! ModuleConcatenation bailout: Module is referenced from these modules with unsupported syntax: ./src/.umi-production/core/routes.ts (referenced with import()) */
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
__webpack_require__.r(__webpack_exports__);
|
|
/* harmony import */ var _Users_dingyongkang_Documents_workspace_zhiqing_educoder_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node_modules/@umijs/babel-preset-umi/node_modules/@babel/runtime/helpers/esm/slicedToArray */ "tJVT");
|
|
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "cDcd");
|
|
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
|
|
/* harmony import */ var _monaco_editor_react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @monaco-editor/react */ "eYFr");
|
|
/* harmony import */ var umi__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! umi */ "9kvl");
|
|
/* harmony import */ var _pages_tasks_xterm_panel__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @/pages/tasks/xterm-panel */ "Dqnf");
|
|
/* harmony import */ var _components_mediator__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @/components/mediator */ "dhSg");
|
|
|
|
// import MonacoEditor from 'react-monaco-editor';
|
|
|
|
|
|
|
|
|
|
// you can change the source of the monaco files
|
|
// loader.config({ paths: { vs: "monaco-editor/min/vs/editor" } });
|
|
// you can configure the locales
|
|
|
|
_monaco_editor_react__WEBPACK_IMPORTED_MODULE_2__[/* loader */ "b"].config({
|
|
"vs/nls": {
|
|
availableLanguages: {
|
|
"*": "zh-cn"
|
|
}
|
|
}
|
|
}); // or
|
|
// loader.config({
|
|
// paths: {
|
|
// vs: "...",
|
|
// },
|
|
// "vs/nls" : {
|
|
// availableLanguages: {
|
|
// "*": "zh-cn",
|
|
// },
|
|
// },
|
|
// });
|
|
// import MonacoEditor, { EditorProps, Monaco, monaco } from "@monaco-editor/react";
|
|
// import { HomePageModelState, ConnectProps, Loading, connect, Dispatch } from 'umi';
|
|
|
|
var IndexPage = function IndexPage(_ref) {
|
|
var index = _ref.index,
|
|
loading = _ref.loading,
|
|
dispatch = _ref.dispatch;
|
|
|
|
// useEffect(() => {
|
|
// dispatch({
|
|
// type: "index/query",
|
|
// payload: {},
|
|
// });
|
|
// }, [index])
|
|
// const { name } = index;
|
|
var _useState = Object(react__WEBPACK_IMPORTED_MODULE_1__["useState"])("// type your cod222e..."),
|
|
_useState2 = Object(_Users_dingyongkang_Documents_workspace_zhiqing_educoder_node_modules_umijs_babel_preset_umi_node_modules_babel_runtime_helpers_esm_slicedToArray__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(_useState, 2),
|
|
code = _useState2[0],
|
|
setCode = _useState2[1];
|
|
|
|
var options = {
|
|
selectOnLineNumbers: true // renderSideBySide: false
|
|
|
|
};
|
|
|
|
var onChangeHandle = function onChangeHandle() {};
|
|
|
|
var editorDidMountHandle = function editorDidMountHandle() {};
|
|
|
|
Object(react__WEBPACK_IMPORTED_MODULE_1__["useEffect"])(function () {
|
|
setTimeout(function () {
|
|
_components_mediator__WEBPACK_IMPORTED_MODULE_5__[/* default */ "a"].publish('create-socket', 1);
|
|
}, 500);
|
|
}, []);
|
|
return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement("div", null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(_pages_tasks_xterm_panel__WEBPACK_IMPORTED_MODULE_4__[/* default */ "a"], {
|
|
sshConfigData: {
|
|
"host": "106.75.231.63",
|
|
"port": "2021",
|
|
"ws_url": "wss://pre-webssh.educoder.net/ws",
|
|
"username": "root",
|
|
"password": "123123",
|
|
"game_id": 4799882,
|
|
"webssh_url": "http://172.16.94.254:8890/bridge",
|
|
"secret": "Dron_123123",
|
|
"width": 1004,
|
|
"height": 603,
|
|
"rows": 33,
|
|
"columns": 104
|
|
},
|
|
sid: 1
|
|
}), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1___default.a.createElement(_monaco_editor_react__WEBPACK_IMPORTED_MODULE_2__[/* default */ "a"], {
|
|
width: 800,
|
|
height: 400,
|
|
language: "javascript",
|
|
theme: "hc-black",
|
|
value: code,
|
|
options: options,
|
|
onChange: onChangeHandle,
|
|
editorDidMount: editorDidMountHandle
|
|
}));
|
|
};
|
|
|
|
/* harmony default export */ __webpack_exports__["default"] = (Object(umi__WEBPACK_IMPORTED_MODULE_3__[/* connect */ "a"])(function (_ref2) {
|
|
var index = _ref2.index,
|
|
loading = _ref2.loading;
|
|
return {
|
|
index: index,
|
|
loading: loading.models.index
|
|
};
|
|
})(IndexPage));
|
|
|
|
/***/ }),
|
|
|
|
/***/ "Sf0V":
|
|
/*!********************************************************!*\
|
|
!*** ./node_modules/state-local/lib/es/state-local.js ***!
|
|
\********************************************************/
|
|
/*! exports provided: default */
|
|
/*! exports used: default */
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
function _defineProperty(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
function ownKeys(object, enumerableOnly) {
|
|
var keys = Object.keys(object);
|
|
|
|
if (Object.getOwnPropertySymbols) {
|
|
var symbols = Object.getOwnPropertySymbols(object);
|
|
if (enumerableOnly) symbols = symbols.filter(function (sym) {
|
|
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
|
|
});
|
|
keys.push.apply(keys, symbols);
|
|
}
|
|
|
|
return keys;
|
|
}
|
|
|
|
function _objectSpread2(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
|
|
|
if (i % 2) {
|
|
ownKeys(Object(source), true).forEach(function (key) {
|
|
_defineProperty(target, key, source[key]);
|
|
});
|
|
} else if (Object.getOwnPropertyDescriptors) {
|
|
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
|
|
} else {
|
|
ownKeys(Object(source)).forEach(function (key) {
|
|
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
|
});
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
function compose() {
|
|
for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
fns[_key] = arguments[_key];
|
|
}
|
|
|
|
return function (x) {
|
|
return fns.reduceRight(function (y, f) {
|
|
return f(y);
|
|
}, x);
|
|
};
|
|
}
|
|
|
|
function curry(fn) {
|
|
return function curried() {
|
|
var _this = this;
|
|
|
|
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
args[_key2] = arguments[_key2];
|
|
}
|
|
|
|
return args.length >= fn.length ? fn.apply(this, args) : function () {
|
|
for (var _len3 = arguments.length, nextArgs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
|
|
nextArgs[_key3] = arguments[_key3];
|
|
}
|
|
|
|
return curried.apply(_this, [].concat(args, nextArgs));
|
|
};
|
|
};
|
|
}
|
|
|
|
function isObject(value) {
|
|
return {}.toString.call(value).includes('Object');
|
|
}
|
|
|
|
function isEmpty(obj) {
|
|
return !Object.keys(obj).length;
|
|
}
|
|
|
|
function isFunction(value) {
|
|
return typeof value === 'function';
|
|
}
|
|
|
|
function hasOwnProperty(object, property) {
|
|
return Object.prototype.hasOwnProperty.call(object, property);
|
|
}
|
|
|
|
function validateChanges(initial, changes) {
|
|
if (!isObject(changes)) errorHandler('changeType');
|
|
if (Object.keys(changes).some(function (field) {
|
|
return !hasOwnProperty(initial, field);
|
|
})) errorHandler('changeField');
|
|
return changes;
|
|
}
|
|
|
|
function validateSelector(selector) {
|
|
if (!isFunction(selector)) errorHandler('selectorType');
|
|
}
|
|
|
|
function validateHandler(handler) {
|
|
if (!(isFunction(handler) || isObject(handler))) errorHandler('handlerType');
|
|
if (isObject(handler) && Object.values(handler).some(function (_handler) {
|
|
return !isFunction(_handler);
|
|
})) errorHandler('handlersType');
|
|
}
|
|
|
|
function validateInitial(initial) {
|
|
if (!initial) errorHandler('initialIsRequired');
|
|
if (!isObject(initial)) errorHandler('initialType');
|
|
if (isEmpty(initial)) errorHandler('initialContent');
|
|
}
|
|
|
|
function throwError(errorMessages, type) {
|
|
throw new Error(errorMessages[type] || errorMessages["default"]);
|
|
}
|
|
|
|
var errorMessages = {
|
|
initialIsRequired: 'initial state is required',
|
|
initialType: 'initial state should be an object',
|
|
initialContent: 'initial state shouldn\'t be an empty object',
|
|
handlerType: 'handler should be an object or a function',
|
|
handlersType: 'all handlers should be a functions',
|
|
selectorType: 'selector should be a function',
|
|
changeType: 'provided value of changes should be an object',
|
|
changeField: 'it seams you want to change a field in the state which is not specified in the "initial" state',
|
|
"default": 'an unknown error accured in `state-local` package'
|
|
};
|
|
var errorHandler = curry(throwError)(errorMessages);
|
|
var validators = {
|
|
changes: validateChanges,
|
|
selector: validateSelector,
|
|
handler: validateHandler,
|
|
initial: validateInitial
|
|
};
|
|
|
|
function create(initial) {
|
|
var handler = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
validators.initial(initial);
|
|
validators.handler(handler);
|
|
var state = {
|
|
current: initial
|
|
};
|
|
var didUpdate = curry(didStateUpdate)(state, handler);
|
|
var update = curry(updateState)(state);
|
|
var validate = curry(validators.changes)(initial);
|
|
var getChanges = curry(extractChanges)(state);
|
|
|
|
function getState() {
|
|
var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (state) {
|
|
return state;
|
|
};
|
|
validators.selector(selector);
|
|
return selector(state.current);
|
|
}
|
|
|
|
function setState(causedChanges) {
|
|
compose(didUpdate, update, validate, getChanges)(causedChanges);
|
|
}
|
|
|
|
return [getState, setState];
|
|
}
|
|
|
|
function extractChanges(state, causedChanges) {
|
|
return isFunction(causedChanges) ? causedChanges(state.current) : causedChanges;
|
|
}
|
|
|
|
function updateState(state, changes) {
|
|
state.current = _objectSpread2(_objectSpread2({}, state.current), changes);
|
|
return changes;
|
|
}
|
|
|
|
function didStateUpdate(state, handler, changes) {
|
|
isFunction(handler) ? handler(state.current) : Object.keys(changes).forEach(function (field) {
|
|
var _handler$field;
|
|
|
|
return (_handler$field = handler[field]) === null || _handler$field === void 0 ? void 0 : _handler$field.call(handler, state.current[field]);
|
|
});
|
|
return changes;
|
|
}
|
|
|
|
var index = {
|
|
create: create
|
|
};
|
|
|
|
/* harmony default export */ __webpack_exports__["a"] = (index);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "o+RU":
|
|
/*!************************************************************************!*\
|
|
!*** ./node_modules/@monaco-editor/loader/lib/es/index.js + 9 modules ***!
|
|
\************************************************************************/
|
|
/*! exports provided: default */
|
|
/*! exports used: default */
|
|
/*! ModuleConcatenation bailout: Cannot concat with ./node_modules/state-local/lib/es/state-local.js because of ./node_modules/@monaco-editor/react/lib/es/Editor/Editor.js */
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, "a", function() { return /* reexport */ es_loader; });
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/_virtual/_rollupPluginBabelHelpers.js
|
|
function _defineProperty(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
function ownKeys(object, enumerableOnly) {
|
|
var keys = Object.keys(object);
|
|
|
|
if (Object.getOwnPropertySymbols) {
|
|
var symbols = Object.getOwnPropertySymbols(object);
|
|
if (enumerableOnly) symbols = symbols.filter(function (sym) {
|
|
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
|
|
});
|
|
keys.push.apply(keys, symbols);
|
|
}
|
|
|
|
return keys;
|
|
}
|
|
|
|
function _objectSpread2(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
|
|
|
if (i % 2) {
|
|
ownKeys(Object(source), true).forEach(function (key) {
|
|
_defineProperty(target, key, source[key]);
|
|
});
|
|
} else if (Object.getOwnPropertyDescriptors) {
|
|
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
|
|
} else {
|
|
ownKeys(Object(source)).forEach(function (key) {
|
|
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
|
});
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
function _objectWithoutPropertiesLoose(source, excluded) {
|
|
if (source == null) return {};
|
|
var target = {};
|
|
var sourceKeys = Object.keys(source);
|
|
var key, i;
|
|
|
|
for (i = 0; i < sourceKeys.length; i++) {
|
|
key = sourceKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
target[key] = source[key];
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
function _objectWithoutProperties(source, excluded) {
|
|
if (source == null) return {};
|
|
|
|
var target = _objectWithoutPropertiesLoose(source, excluded);
|
|
|
|
var key, i;
|
|
|
|
if (Object.getOwnPropertySymbols) {
|
|
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
|
|
|
|
for (i = 0; i < sourceSymbolKeys.length; i++) {
|
|
key = sourceSymbolKeys[i];
|
|
if (excluded.indexOf(key) >= 0) continue;
|
|
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
function _slicedToArray(arr, i) {
|
|
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
|
|
}
|
|
|
|
function _arrayWithHoles(arr) {
|
|
if (Array.isArray(arr)) return arr;
|
|
}
|
|
|
|
function _iterableToArrayLimit(arr, i) {
|
|
if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
|
|
var _arr = [];
|
|
var _n = true;
|
|
var _d = false;
|
|
var _e = undefined;
|
|
|
|
try {
|
|
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
|
|
_arr.push(_s.value);
|
|
|
|
if (i && _arr.length === i) break;
|
|
}
|
|
} catch (err) {
|
|
_d = true;
|
|
_e = err;
|
|
} finally {
|
|
try {
|
|
if (!_n && _i["return"] != null) _i["return"]();
|
|
} finally {
|
|
if (_d) throw _e;
|
|
}
|
|
}
|
|
|
|
return _arr;
|
|
}
|
|
|
|
function _unsupportedIterableToArray(o, minLen) {
|
|
if (!o) return;
|
|
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
|
|
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
if (n === "Object" && o.constructor) n = o.constructor.name;
|
|
if (n === "Map" || n === "Set") return Array.from(o);
|
|
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
|
|
}
|
|
|
|
function _arrayLikeToArray(arr, len) {
|
|
if (len == null || len > arr.length) len = arr.length;
|
|
|
|
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
|
|
|
|
return arr2;
|
|
}
|
|
|
|
function _nonIterableRest() {
|
|
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
|
|
|
|
|
|
// EXTERNAL MODULE: ./node_modules/state-local/lib/es/state-local.js
|
|
var state_local = __webpack_require__("Sf0V");
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/config/index.js
|
|
var config_config = {
|
|
paths: {
|
|
vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.33.0/min/vs'
|
|
}
|
|
};
|
|
|
|
/* harmony default export */ var es_config = (config_config);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/utils/curry.js
|
|
function curry(fn) {
|
|
return function curried() {
|
|
var _this = this;
|
|
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
return args.length >= fn.length ? fn.apply(this, args) : function () {
|
|
for (var _len2 = arguments.length, nextArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
nextArgs[_key2] = arguments[_key2];
|
|
}
|
|
|
|
return curried.apply(_this, [].concat(args, nextArgs));
|
|
};
|
|
};
|
|
}
|
|
|
|
/* harmony default export */ var utils_curry = (curry);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/utils/isObject.js
|
|
function isObject(value) {
|
|
return {}.toString.call(value).includes('Object');
|
|
}
|
|
|
|
/* harmony default export */ var utils_isObject = (isObject);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/validators/index.js
|
|
|
|
|
|
|
|
/**
|
|
* validates the configuration object and informs about deprecation
|
|
* @param {Object} config - the configuration object
|
|
* @return {Object} config - the validated configuration object
|
|
*/
|
|
|
|
function validateConfig(config) {
|
|
if (!config) errorHandler('configIsRequired');
|
|
if (!utils_isObject(config)) errorHandler('configType');
|
|
|
|
if (config.urls) {
|
|
informAboutDeprecation();
|
|
return {
|
|
paths: {
|
|
vs: config.urls.monacoBase
|
|
}
|
|
};
|
|
}
|
|
|
|
return config;
|
|
}
|
|
/**
|
|
* logs deprecation message
|
|
*/
|
|
|
|
|
|
function informAboutDeprecation() {
|
|
console.warn(errorMessages.deprecation);
|
|
}
|
|
|
|
function throwError(errorMessages, type) {
|
|
throw new Error(errorMessages[type] || errorMessages["default"]);
|
|
}
|
|
|
|
var errorMessages = {
|
|
configIsRequired: 'the configuration object is required',
|
|
configType: 'the configuration object should be an object',
|
|
"default": 'an unknown error accured in `@monaco-editor/loader` package',
|
|
deprecation: "Deprecation warning!\n You are using deprecated way of configuration.\n\n Instead of using\n monaco.config({ urls: { monacoBase: '...' } })\n use\n monaco.config({ paths: { vs: '...' } })\n\n For more please check the link https://github.com/suren-atoyan/monaco-loader#config\n "
|
|
};
|
|
var errorHandler = utils_curry(throwError)(errorMessages);
|
|
var validators = {
|
|
config: validateConfig
|
|
};
|
|
|
|
/* harmony default export */ var es_validators = (validators);
|
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/utils/compose.js
|
|
var compose = function compose() {
|
|
for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
fns[_key] = arguments[_key];
|
|
}
|
|
|
|
return function (x) {
|
|
return fns.reduceRight(function (y, f) {
|
|
return f(y);
|
|
}, x);
|
|
};
|
|
};
|
|
|
|
/* harmony default export */ var utils_compose = (compose);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/utils/deepMerge.js
|
|
|
|
|
|
function merge(target, source) {
|
|
Object.keys(source).forEach(function (key) {
|
|
if (source[key] instanceof Object) {
|
|
if (target[key]) {
|
|
Object.assign(source[key], merge(target[key], source[key]));
|
|
}
|
|
}
|
|
});
|
|
return _objectSpread2(_objectSpread2({}, target), source);
|
|
}
|
|
|
|
/* harmony default export */ var deepMerge = (merge);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/utils/makeCancelable.js
|
|
// The source (has been changed) is https://github.com/facebook/react/issues/5465#issuecomment-157888325
|
|
var CANCELATION_MESSAGE = {
|
|
type: 'cancelation',
|
|
msg: 'operation is manually canceled'
|
|
};
|
|
|
|
function makeCancelable(promise) {
|
|
var hasCanceled_ = false;
|
|
var wrappedPromise = new Promise(function (resolve, reject) {
|
|
promise.then(function (val) {
|
|
return hasCanceled_ ? reject(CANCELATION_MESSAGE) : resolve(val);
|
|
});
|
|
promise["catch"](reject);
|
|
});
|
|
return wrappedPromise.cancel = function () {
|
|
return hasCanceled_ = true;
|
|
}, wrappedPromise;
|
|
}
|
|
|
|
/* harmony default export */ var utils_makeCancelable = (makeCancelable);
|
|
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/loader/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** the local state of the module */
|
|
|
|
var _state$create = state_local["a" /* default */].create({
|
|
config: es_config,
|
|
resolve: null,
|
|
reject: null,
|
|
monaco: null
|
|
}),
|
|
_state$create2 = _slicedToArray(_state$create, 2),
|
|
getState = _state$create2[0],
|
|
setState = _state$create2[1];
|
|
/**
|
|
* set the loader configuration
|
|
* @param {Object} config - the configuration object
|
|
*/
|
|
|
|
|
|
function loader_config(globalConfig) {
|
|
var _validators$config = es_validators.config(globalConfig),
|
|
monaco = _validators$config.monaco,
|
|
config = _objectWithoutProperties(_validators$config, ["monaco"]);
|
|
|
|
setState(function (state) {
|
|
return {
|
|
config: deepMerge(state.config, config),
|
|
monaco: monaco
|
|
};
|
|
});
|
|
}
|
|
/**
|
|
* handles the initialization of the monaco-editor
|
|
* @return {Promise} - returns an instance of monaco (with a cancelable promise)
|
|
*/
|
|
|
|
|
|
function init() {
|
|
var state = getState(function (_ref) {
|
|
var monaco = _ref.monaco;
|
|
return {
|
|
monaco: monaco
|
|
};
|
|
});
|
|
|
|
if (!state.monaco) {
|
|
if (window.monaco && window.monaco.editor) {
|
|
storeMonacoInstance(window.monaco);
|
|
return utils_makeCancelable(Promise.resolve(window.monaco));
|
|
}
|
|
|
|
utils_compose(injectScripts, getMonacoLoaderScript)(configureLoader);
|
|
} else if (state.monaco) {
|
|
return utils_makeCancelable(Promise.resolve(state.monaco));
|
|
}
|
|
|
|
return utils_makeCancelable(wrapperPromise);
|
|
}
|
|
/**
|
|
* injects provided scripts into the document.body
|
|
* @param {Object} script - an HTML script element
|
|
* @return {Object} - the injected HTML script element
|
|
*/
|
|
|
|
|
|
function injectScripts(script) {
|
|
return document.body.appendChild(script);
|
|
}
|
|
/**
|
|
* creates an HTML script element with/without provided src
|
|
* @param {string} [src] - the source path of the script
|
|
* @return {Object} - the created HTML script element
|
|
*/
|
|
|
|
|
|
function createScript(src) {
|
|
var script = document.createElement('script');
|
|
return src && (script.src = src), script;
|
|
}
|
|
/**
|
|
* creates an HTML script element with the monaco loader src
|
|
* @return {Object} - the created HTML script element
|
|
*/
|
|
|
|
|
|
function getMonacoLoaderScript(configureLoader) {
|
|
var state = getState(function (_ref2) {
|
|
var config = _ref2.config,
|
|
reject = _ref2.reject;
|
|
return {
|
|
config: config,
|
|
reject: reject
|
|
};
|
|
});
|
|
var loaderScript = createScript("".concat(state.config.paths.vs, "/loader.js"));
|
|
|
|
loaderScript.onload = function () {
|
|
return configureLoader();
|
|
};
|
|
|
|
loaderScript.onerror = state.reject;
|
|
return loaderScript;
|
|
}
|
|
/**
|
|
* configures the monaco loader
|
|
*/
|
|
|
|
|
|
function configureLoader() {
|
|
var state = getState(function (_ref3) {
|
|
var config = _ref3.config,
|
|
resolve = _ref3.resolve,
|
|
reject = _ref3.reject;
|
|
return {
|
|
config: config,
|
|
resolve: resolve,
|
|
reject: reject
|
|
};
|
|
});
|
|
var require = window.require;
|
|
|
|
require.config(state.config);
|
|
|
|
require(['vs/editor/editor.main'], function (monaco) {
|
|
storeMonacoInstance(monaco);
|
|
state.resolve(monaco);
|
|
}, function (error) {
|
|
state.reject(error);
|
|
});
|
|
}
|
|
/**
|
|
* store monaco instance in local state
|
|
*/
|
|
|
|
|
|
function storeMonacoInstance(monaco) {
|
|
if (!getState().monaco) {
|
|
setState({
|
|
monaco: monaco
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* internal helper function
|
|
* extracts stored monaco instance
|
|
* @return {Object|null} - the monaco instance
|
|
*/
|
|
|
|
|
|
function __getMonacoInstance() {
|
|
return getState(function (_ref4) {
|
|
var monaco = _ref4.monaco;
|
|
return monaco;
|
|
});
|
|
}
|
|
|
|
var wrapperPromise = new Promise(function (resolve, reject) {
|
|
return setState({
|
|
resolve: resolve,
|
|
reject: reject
|
|
});
|
|
});
|
|
var loader = {
|
|
config: loader_config,
|
|
init: init,
|
|
__getMonacoInstance: __getMonacoInstance
|
|
};
|
|
|
|
/* harmony default export */ var es_loader = (loader);
|
|
|
|
// CONCATENATED MODULE: ./node_modules/@monaco-editor/loader/lib/es/index.js
|
|
|
|
|
|
|
|
|
|
/***/ })
|
|
|
|
}]); |