@elice/material-exercise 1.230328.0 → 1.230418.0

package/es/components/shared/monaco-editor/utils/emmet/registerProvider.js

@@ -5,18 +5,22 @@ import { isValidLocationForEmmetAbbreviation } from './abbreviationActions.js';
 /**
  * Register completion provider of emmet.
  */
-
 function registerProvider(_monaco, languages, syntax) {
   if (!_monaco) {
     return;
   }
-
-  const providers = languages.map(language => _monaco.languages.registerCompletionItemProvider(language, {
-    triggerCharacters: LANGUAGE_MODES[MAPPED_MODES[language] || language],
-    provideCompletionItems: (model, position) => isValidLocationForEmmetAbbreviation(model, position, syntax) ? doComplete(_monaco, model, position, syntax, DEFAULT_CONFIG) : undefined
-  }));
-  return () => {
-    providers.forEach(provider => provider.dispose());
+  var providers = languages.map(function (language) {
+    return _monaco.languages.registerCompletionItemProvider(language, {
+      triggerCharacters: LANGUAGE_MODES[MAPPED_MODES[language] || language],
+      provideCompletionItems: function provideCompletionItems(model, position) {
+        return isValidLocationForEmmetAbbreviation(model, position, syntax) ? doComplete(_monaco, model, position, syntax, DEFAULT_CONFIG) : undefined;
+      }
+    });
+  });
+  return function () {
+    providers.forEach(function (provider) {
+      return provider.dispose();
+    });
   };
 }
 

package/es/components/shared/monaco-editor/utils/grammar/index.js

@@ -1,3 +1,4 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { Registry } from 'monaco-textmate';
 import { TM_LANGUAGES } from '../../constants/grammars/index.js';
 import '../../constants/monaco/preferences.js';
@@ -7,11 +8,10 @@ import { wireTmGrammars } from './textmate.js';
 /**
  * Create grammar map.
  */
-
 function createGrammarMap() {
   // {language => scopeName}
-  const grammars = new Map();
-  TM_LANGUAGES.forEach(tm => {
+  var grammars = new Map();
+  TM_LANGUAGES.forEach(function (tm) {
     grammars.set(tm.language, tm.scopeName);
   });
   return grammars;
@@ -19,42 +19,78 @@ function createGrammarMap() {
 /**
  * Create grammar registry.
  */
-
-
 function createGrammarRegistry() {
   return new Registry({
-    getGrammarDefinition: async scopeName => {
-      try {
-        const lang = TM_LANGUAGES.find(l => l.scopeName === scopeName);
-
-        if (!lang) {
-          throw Error(`no language found for scopeName: ${scopeName}`);
-        }
-
-        const definition = await lang.getDefinition();
-        return {
-          format: 'json',
-          content: JSON.stringify(definition)
-        };
-      } catch (_) {
-        return {
-          format: 'json',
-          content: '{}'
-        };
+    getGrammarDefinition: function () {
+      var _getGrammarDefinition = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(scopeName) {
+        var lang, definition;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              lang = TM_LANGUAGES.find(function (l) {
+                return l.scopeName === scopeName;
+              });
+              if (lang) {
+                _context.next = 4;
+                break;
+              }
+              throw Error("no language found for scopeName: ".concat(scopeName));
+            case 4:
+              _context.next = 6;
+              return lang.getDefinition();
+            case 6:
+              definition = _context.sent;
+              return _context.abrupt("return", {
+                format: 'json',
+                content: JSON.stringify(definition)
+              });
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](0);
+              return _context.abrupt("return", {
+                format: 'json',
+                content: '{}'
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[0, 10]]);
+      }));
+      function getGrammarDefinition(_x) {
+        return _getGrammarDefinition.apply(this, arguments);
       }
-    }
+      return getGrammarDefinition;
+    }()
   });
 }
 /**
  *
  */
-
-
-async function initMonacoGrammars () {
-  await initOnigasm();
-  const grammars = createGrammarMap();
-  const registry = createGrammarRegistry();
-  await wireTmGrammars(registry, grammars);
+function initMonacoGrammars () {
+  return _ref.apply(this, arguments);
+}
+function _ref() {
+  _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    var grammars, registry;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return initOnigasm();
+        case 2:
+          grammars = createGrammarMap();
+          registry = createGrammarRegistry();
+          _context2.next = 6;
+          return wireTmGrammars(registry, grammars);
+        case 6:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _ref.apply(this, arguments);
 }
 
 export { initMonacoGrammars as default };

package/es/components/shared/monaco-editor/utils/grammar/onigasm.js

@@ -1,15 +1,33 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { loadWASM } from 'onigasm';
 
-const ONIGASM_WASM = 'https://static.elice.io/vendors/onigasm@2.2.5/onigasm.wasm';
+var ONIGASM_WASM = 'https://static.elice.io/vendors/onigasm@2.2.5/onigasm.wasm';
 /**
  * Init onigasm wasm.
  */
-
-async function initOnigasm() {
-  if (!window.__elice_monaco_editor_tm_init__) {
-    await loadWASM(ONIGASM_WASM);
-    window.__elice_monaco_editor_tm_init__ = true;
-  }
+function initOnigasm() {
+  return _initOnigasm.apply(this, arguments);
+}
+function _initOnigasm() {
+  _initOnigasm = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (window.__elice_monaco_editor_tm_init__) {
+            _context.next = 4;
+            break;
+          }
+          _context.next = 3;
+          return loadWASM(ONIGASM_WASM);
+        case 3:
+          window.__elice_monaco_editor_tm_init__ = true;
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _initOnigasm.apply(this, arguments);
 }
 
 export { initOnigasm };

package/es/components/shared/monaco-editor/utils/grammar/textmate.js

@@ -1,3 +1,4 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime, createClass as _createClass, classCallCheck as _classCallCheck } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { INITIAL } from 'monaco-textmate';
 
@@ -5,29 +6,32 @@ import { INITIAL } from 'monaco-textmate';
  * TokenizerState
  * -ref: https://github.com/codesandbox/codesandbox-client/blob/389073613e06eee944231f4aeef9dfa746c1b947/packages/app/src/embed/components/Content/Monaco/grammars/set-grammars.js#L3-L27
  */
-
-class TokenizerState {
-  constructor(_ruleStack) {
+var TokenizerState = /*#__PURE__*/function () {
+  function TokenizerState(_ruleStack) {
+    _classCallCheck(this, TokenizerState);
     this._ruleStack = _ruleStack;
   }
-
-  get ruleStack() {
-    return this._ruleStack;
-  }
-
-  clone() {
-    return new TokenizerState(this._ruleStack);
-  }
-
-  equals(other) {
-    if (!other || !(other instanceof TokenizerState) || other !== this || other._ruleStack !== this._ruleStack) {
-      return false;
+  _createClass(TokenizerState, [{
+    key: "ruleStack",
+    get: function get() {
+      return this._ruleStack;
     }
-
-    return true;
-  }
-
-}
+  }, {
+    key: "clone",
+    value: function clone() {
+      return new TokenizerState(this._ruleStack);
+    }
+  }, {
+    key: "equals",
+    value: function equals(other) {
+      if (!other || !(other instanceof TokenizerState) || other !== this || other._ruleStack !== this._ruleStack) {
+        return false;
+      }
+      return true;
+    }
+  }]);
+  return TokenizerState;
+}();
 /**
  * Wires up monaco-editor with monaco-textmate
  *
@@ -35,31 +39,51 @@ class TokenizerState {
  * @param registry TmGrammar `Registry` this wiring should rely on to provide the grammars
  * @param languages `Map` of language ids (string) to TM names (string)
  */
-
-
 function wireTmGrammars(registry, languages) {
-  return Promise.all(Array.from(languages.keys()).map(async languageId => {
-    var _a;
-
-    try {
-      const grammarScopeName = (_a = languages.get(languageId)) !== null && _a !== void 0 ? _a : 'plaintext';
-      const grammar = await registry.loadGrammar(grammarScopeName);
-      monaco.languages.setTokensProvider(languageId, {
-        getInitialState: () => new TokenizerState(INITIAL),
-        tokenize: (line, state) => {
-          const res = grammar.tokenizeLine(line, state.ruleStack);
-          return {
-            endState: new TokenizerState(res.ruleStack),
-            tokens: res.tokens.map(token => Object.assign(Object.assign({}, token), {
-              // TODO: At the moment, monaco-editor doesn't seem to accept array of scopes
-              scopes: token.scopes[token.scopes.length - 1]
-            }))
-          };
+  return Promise.all(Array.from(languages.keys()).map( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(languageId) {
+      var _a, grammarScopeName, grammar;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            grammarScopeName = (_a = languages.get(languageId)) !== null && _a !== void 0 ? _a : 'plaintext';
+            _context.next = 4;
+            return registry.loadGrammar(grammarScopeName);
+          case 4:
+            grammar = _context.sent;
+            monaco.languages.setTokensProvider(languageId, {
+              getInitialState: function getInitialState() {
+                return new TokenizerState(INITIAL);
+              },
+              tokenize: function tokenize(line, state) {
+                var res = grammar.tokenizeLine(line, state.ruleStack);
+                return {
+                  endState: new TokenizerState(res.ruleStack),
+                  tokens: res.tokens.map(function (token) {
+                    return Object.assign(Object.assign({}, token), {
+                      // TODO: At the moment, monaco-editor doesn't seem to accept array of scopes
+                      scopes: token.scopes[token.scopes.length - 1]
+                    });
+                  })
+                };
+              }
+            });
+            _context.next = 10;
+            break;
+          case 8:
+            _context.prev = 8;
+            _context.t0 = _context["catch"](0);
+          case 10:
+          case "end":
+            return _context.stop();
         }
-      });
-    } catch (_) {// console.warn(_);
-    }
-  }));
+      }, _callee, null, [[0, 8]]);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }()));
 }
 
 export { wireTmGrammars };

package/es/components/shared/monaco-editor/utils/monacoLanguage.js

@@ -5,48 +5,38 @@ import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
  *
  * keyvalue: {extension -> language id}
  */
-
-const monacoLanguageMap = new Map();
+var monacoLanguageMap = new Map();
 /**
  * Initialize monaco language map.
  */
-
 function initLanguageMap() {
   if (monacoLanguageMap.size > 0) {
     return;
-  } // get languages from `monaco.languages`.
-
-
-  monaco.languages.getLanguages().forEach(supportLang => {
+  }
+  // get languages from `monaco.languages`.
+  monaco.languages.getLanguages().forEach(function (supportLang) {
     var _a;
-
-    (_a = supportLang.extensions) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
+    (_a = supportLang.extensions) === null || _a === void 0 ? void 0 : _a.forEach(function (ext) {
       monacoLanguageMap.set(ext.slice(1), supportLang.id);
     });
-  }); // ========== custom languages ==========
+  });
+  // ========== custom languages ==========
   // Arduion (`.ino`)
-
   monacoLanguageMap.set('ino', 'cpp');
 }
 /**
  * Get language according to filename.
  */
-
-
 function getLanguageFromFilename(filename) {
   var _a;
-
   initLanguageMap();
-
   if (filename) {
-    const extension = ((_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
-    const monacoLang = monacoLanguageMap.get(extension);
-
+    var extension = ((_a = filename.split('.').pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+    var monacoLang = monacoLanguageMap.get(extension);
     if (monacoLang) {
       return monacoLang;
     }
   }
-
   return 'plaintext';
 }
 

package/es/components/shared/monaco-editor/utils/monacoPreference.js

@@ -1,15 +1,16 @@
+import { typeof as _typeof } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { DEFAULT_MONACO_EDITOR_PREFERENCE } from '../constants/monaco/preferences.js';
 
 /**
  * Normalize monaco editor preferences for elice exercise.
  */
-
-function normalizeMonacoPreference(raw = {}) {
+function normalizeMonacoPreference() {
+  var raw = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   try {
     // deep copy normalized preference.
-    const normalized = JSON.parse(JSON.stringify(DEFAULT_MONACO_EDITOR_PREFERENCE));
-    Object.keys(DEFAULT_MONACO_EDITOR_PREFERENCE).forEach(key => {
-      if (raw[key] !== null && raw[key] !== undefined && typeof normalized[key] === typeof raw[key]) {
+    var normalized = JSON.parse(JSON.stringify(DEFAULT_MONACO_EDITOR_PREFERENCE));
+    Object.keys(DEFAULT_MONACO_EDITOR_PREFERENCE).forEach(function (key) {
+      if (raw[key] !== null && raw[key] !== undefined && _typeof(normalized[key]) === _typeof(raw[key])) {
         normalized[key] = raw[key];
       }
     });

package/es/components/shared/monaco-editor/utils/prettier/config.js

@@ -1,7 +1,7 @@
 /**
  * Default prettier config.
  */
-const DEFAULT_PRETTIER_CONFIG = Object.freeze({
+var DEFAULT_PRETTIER_CONFIG = Object.freeze({
   arrowParens: 'avoid',
   bracketSpacing: true,
   endOfLine: 'auto',
@@ -14,8 +14,7 @@ const DEFAULT_PRETTIER_CONFIG = Object.freeze({
 /**
  * Global prettier config source.
  */
-
-const prettierConfigSource = {
+var prettierConfigSource = {
   config: Object.assign({}, DEFAULT_PRETTIER_CONFIG)
 };
 

package/es/components/shared/monaco-editor/utils/prettier/index.js

@@ -1,16 +1,35 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { prettierConfigSource } from './config.js';
 
 /**
  * Run prettier on the given text.
  */
-
-async function prettier (value, options) {
-  try {
-    const prettier = await import('prettier/standalone');
-    return prettier.format(value, Object.assign(Object.assign({}, options), prettierConfigSource.config));
-  } catch (_) {
-    return value;
-  }
+function prettier (_x, _x2) {
+  return _ref.apply(this, arguments);
+}
+function _ref() {
+  _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(value, options) {
+    var prettier;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 3;
+          return import('prettier/standalone');
+        case 3:
+          prettier = _context.sent;
+          return _context.abrupt("return", prettier.format(value, Object.assign(Object.assign({}, options), prettierConfigSource.config)));
+        case 7:
+          _context.prev = 7;
+          _context.t0 = _context["catch"](0);
+          return _context.abrupt("return", value);
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 7]]);
+  }));
+  return _ref.apply(this, arguments);
 }
 
 export { prettier as default };

package/es/components/shared/monaco-editor/utils/theme/convert.js

@@ -2,16 +2,14 @@ import Color from 'color';
 
 //
 //
-
+//
 /**
  *
  */
-
 function sanitizeColor(color) {
   if (/^#[0-9a-f]{6,8}$/i.test(color)) {
     return color;
   }
-
   try {
     return new Color(color).hex();
   } catch (e) {
@@ -21,60 +19,56 @@ function sanitizeColor(color) {
 /**
  *
  */
-
-
 function getBase(type) {
   if (type === 'light') {
     return 'vs';
   }
-
   if (type === 'hc') {
     return 'hc-black';
   }
-
   return 'vs-dark';
 }
 /**
  *
  */
-
-
 function convertToMonacoTheme(theme) {
-  const {
-    tokenColors = [],
-    colors = {}
-  } = theme;
-  Object.keys(colors).forEach(c => {
+  var _theme$tokenColors = theme.tokenColors,
+    tokenColors = _theme$tokenColors === void 0 ? [] : _theme$tokenColors,
+    _theme$colors = theme.colors,
+    colors = _theme$colors === void 0 ? {} : _theme$colors;
+  Object.keys(colors).forEach(function (c) {
     if (!colors[c]) {
       delete colors[c];
     }
   });
-  const rules = tokenColors.filter(t => t.scope && t.settings && t.settings.foreground !== 'inherit' && t.settings.background !== 'inherit').reduce((acc, token) => {
-    const settings = {};
-
+  var rules = tokenColors.filter(function (t) {
+    return t.scope && t.settings && t.settings.foreground !== 'inherit' && t.settings.background !== 'inherit';
+  }).reduce(function (acc, token) {
+    var settings = {};
     if (token.settings.foreground) {
       settings.foreground = sanitizeColor(token.settings.foreground);
     }
-
     if (token.settings.background) {
       settings.background = sanitizeColor(token.settings.background);
     }
-
     if (token.settings.fontStyle) {
       settings.fontStyle = token.settings.fontStyle;
     }
-
-    const scope = typeof token.scope === 'string' ? token.scope.split(',').map(a => a.trim()) : token.scope;
-    scope.forEach(s => acc.push(Object.assign({
-      token: s
-    }, settings)));
+    var scope = typeof token.scope === 'string' ? token.scope.split(',').map(function (a) {
+      return a.trim();
+    }) : token.scope;
+    scope.forEach(function (s) {
+      return acc.push(Object.assign({
+        token: s
+      }, settings));
+    });
     return acc;
   }, []);
   return {
     base: getBase(theme.type),
     inherit: true,
-    colors,
-    rules
+    colors: colors,
+    rules: rules
   };
 }
 

package/es/components/shared/monaco-editor/utils/theme/index.js

@@ -1,14 +1,31 @@
+import { asyncToGenerator as _asyncToGenerator, regeneratorRuntime as _regeneratorRuntime } from '../../../../../_virtual/_rollupPluginBabelHelpers.js';
 import { VSCODE_THEMES } from '../../constants/themes/index.js';
 import { convertToMonacoTheme } from './convert.js';
 
 /**
  * Import theme of vscode.
  */
-
-async function importTheme(theme) {
-  var _a;
-
-  return ((_a = VSCODE_THEMES.find(t => t.id === theme)) !== null && _a !== void 0 ? _a : VSCODE_THEMES[0]).getTheme().then(themeData => convertToMonacoTheme(themeData));
+function importTheme(_x) {
+  return _importTheme.apply(this, arguments);
+}
+function _importTheme() {
+  _importTheme = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(theme) {
+    var _a;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          return _context.abrupt("return", ((_a = VSCODE_THEMES.find(function (t) {
+            return t.id === theme;
+          })) !== null && _a !== void 0 ? _a : VSCODE_THEMES[0]).getTheme().then(function (themeData) {
+            return convertToMonacoTheme(themeData);
+          }));
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _importTheme.apply(this, arguments);
 }
 
 export { importTheme };