@elice/material-exercise 1.220803.0

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

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var onigasm = require('onigasm');
+
+const 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 onigasm.loadWASM(ONIGASM_WASM);
+    window.__elice_monaco_editor_tm_init__ = true;
+  }
+}
+
+exports.initOnigasm = initOnigasm;

package/cjs/components/shared/monaco-editor/utils/grammar/textmate.d.ts

@@ -0,0 +1,9 @@
+import type { Registry } from 'monaco-textmate';
+/**
+ * Wires up monaco-editor with monaco-textmate
+ *
+ * @param monaco monaco namespace this operation should apply to (usually the `monaco` global unless you have some other setup)
+ * @param registry TmGrammar `Registry` this wiring should rely on to provide the grammars
+ * @param languages `Map` of language ids (string) to TM names (string)
+ */
+export declare function wireTmGrammars(registry: Registry, languages: Map<string, string>): Promise<void[]>;

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

@@ -0,0 +1,89 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var monaco = require('monaco-editor/esm/vs/editor/editor.api');
+var monacoTextmate = require('monaco-textmate');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var monaco__namespace = /*#__PURE__*/_interopNamespace(monaco);
+
+/**
+ * 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) {
+    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;
+    }
+
+    return true;
+  }
+
+}
+/**
+ * Wires up monaco-editor with monaco-textmate
+ *
+ * @param monaco monaco namespace this operation should apply to (usually the `monaco` global unless you have some other setup)
+ * @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__namespace.languages.setTokensProvider(languageId, {
+        getInitialState: () => new TokenizerState(monacoTextmate.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]
+            }))
+          };
+        }
+      });
+    } catch (_) {// console.warn(_);
+    }
+  }));
+}
+
+exports.wireTmGrammars = wireTmGrammars;

package/cjs/components/shared/monaco-editor/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './monacoLanguage';
+export * from './monacoPreference';

package/cjs/components/shared/monaco-editor/utils/monacoLanguage.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get language according to filename.
+ */
+export declare function getLanguageFromFilename(filename?: null | string): string;

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

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var monaco = require('monaco-editor/esm/vs/editor/editor.api');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+var monaco__namespace = /*#__PURE__*/_interopNamespace(monaco);
+
+/**
+ * Language map for monaco editor.
+ *
+ * keyvalue: {extension -> language id}
+ */
+
+const monacoLanguageMap = new Map();
+/**
+ * Initialize monaco language map.
+ */
+
+function initLanguageMap() {
+  if (monacoLanguageMap.size > 0) {
+    return;
+  } // get languages from `monaco.languages`.
+
+
+  monaco__namespace.languages.getLanguages().forEach(supportLang => {
+    var _a;
+
+    (_a = supportLang.extensions) === null || _a === void 0 ? void 0 : _a.forEach(ext => {
+      monacoLanguageMap.set(ext.slice(1), supportLang.id);
+    });
+  }); // ========== 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);
+
+    if (monacoLang) {
+      return monacoLang;
+    }
+  }
+
+  return 'plaintext';
+}
+
+exports.getLanguageFromFilename = getLanguageFromFilename;

package/cjs/components/shared/monaco-editor/utils/monacoPreference.d.ts

@@ -0,0 +1,5 @@
+import type { MonacoEditorPreference } from '../constants';
+/**
+ * Normalize monaco editor preferences for elice exercise.
+ */
+export declare function normalizeMonacoPreference(raw?: any): Required<MonacoEditorPreference>;

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

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var preferences = require('../constants/monaco/preferences.js');
+
+/**
+ * Normalize monaco editor preferences for elice exercise.
+ */
+
+function normalizeMonacoPreference(raw = {}) {
+  try {
+    // deep copy normalized preference.
+    const normalized = JSON.parse(JSON.stringify(preferences.DEFAULT_MONACO_EDITOR_PREFERENCE));
+    Object.keys(preferences.DEFAULT_MONACO_EDITOR_PREFERENCE).forEach(key => {
+      if (raw[key] !== null && raw[key] !== undefined && typeof normalized[key] === typeof raw[key]) {
+        normalized[key] = raw[key];
+      }
+    });
+    return normalized;
+  } catch (_) {
+    return preferences.DEFAULT_MONACO_EDITOR_PREFERENCE;
+  }
+}
+
+exports.normalizeMonacoPreference = normalizeMonacoPreference;

package/cjs/components/shared/monaco-editor/utils/prettier/config.d.ts

@@ -0,0 +1,9 @@
+import type { Config as PrettierConfig } from 'prettier';
+interface PrettierConfigSource {
+    config: PrettierConfig;
+}
+/**
+ * Global prettier config source.
+ */
+export declare const prettierConfigSource: PrettierConfigSource;
+export {};

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

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Default prettier config.
+ */
+const DEFAULT_PRETTIER_CONFIG = Object.freeze({
+  arrowParens: 'avoid',
+  bracketSpacing: true,
+  endOfLine: 'auto',
+  jsxBracketSameLine: false,
+  jsxSingleQuote: false,
+  quoteProps: 'as-needed',
+  semi: true,
+  singleQuote: true
+});
+/**
+ * Global prettier config source.
+ */
+
+const prettierConfigSource = {
+  config: Object.assign({}, DEFAULT_PRETTIER_CONFIG)
+};
+
+exports.prettierConfigSource = prettierConfigSource;

package/cjs/components/shared/monaco-editor/utils/prettier/index.d.ts

@@ -0,0 +1,17 @@
+import type { Options } from 'prettier';
+declare type PrettierOptions = Pick<Options, 
+/**
+ * Specify which parser to use.
+ * - ref: https://prettier.io/docs/en/options.html#parser
+ */
+'parser'
+/**
+ * Plugins are ways of adding new languages or formatting rules to Prettier.
+ * - https://prettier.io/docs/en/plugins.html#official-plugins
+ */
+ | 'plugins'>;
+/**
+ * Run prettier on the given text.
+ */
+export default function (value: string, options: PrettierOptions): Promise<string>;
+export {};

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var config = require('./config.js');
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+/**
+ * Run prettier on the given text.
+ */
+
+async function prettier (value, options) {
+  const prettier = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('prettier/standalone')); });
+  return prettier.format(value, Object.assign(Object.assign({}, options), config.prettierConfigSource.config));
+}
+
+module.exports = prettier;

package/cjs/components/shared/monaco-editor/utils/remoteMarker/OnDisposed.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A simple callback type that signifies a resource has been disposed.
+ */
+export declare type OnDisposed = () => void;

package/cjs/components/shared/monaco-editor/utils/remoteMarker/RemoteCursor.d.ts

@@ -0,0 +1,49 @@
+import type { IPosition } from 'monaco-editor/esm/vs/editor/editor.api';
+import type { RemoteCursorWidget } from './RemoteCursorWidget';
+/**
+ * The RemoteCursor class represents a remote cursor in the MonacoEditor. This
+ * class allows you to control the location and visibility of the cursor.
+ */
+export declare class RemoteCursor {
+    private readonly _delegate;
+    constructor(delegate: RemoteCursorWidget);
+    /**
+     * Gets the unique id of this cursor.
+     */
+    getId(): string;
+    /**
+     * Gets the position of the cursor.
+     */
+    getPosition(): IPosition | null | undefined;
+    /**
+     * Sets the location of the cursor based on a Monaco Editor IPosition.
+     */
+    setPosition(position: IPosition): void;
+    /**
+     * Sets the location of the cursor using a zero-based text offset.
+     *
+     * @param offset
+     *   The offset of the cursor.
+     */
+    setOffset(offset: number): void;
+    /**
+     * Shows the cursor if it is hidden.
+     */
+    show(): void;
+    /**
+     * Hides the cursor if it is shown.
+     */
+    hide(): void;
+    /**
+     * Determines if the cursor has already been disposed. A cursor is disposed
+     * when it has been permanently removed from the editor.
+     *
+     * @returns
+     *   True if the cursor has been disposed, false otherwise.
+     */
+    isDisposed(): boolean;
+    /**
+     * Disposes of this cursor, removing it from the editor.
+     */
+    dispose(): void;
+}

package/cjs/components/shared/monaco-editor/utils/remoteMarker/RemoteCursor.js

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* ====================================================================================================
+ * These codes forked and modified from `convergencelabs/monaco-collab-ext`
+ * under the terms of the MIT license.
+ * Make sure to check the original project if any issue exists.
+ * - project: https://github.com/convergencelabs/monaco-collab-ext
+ * - codes: https://github.com/convergencelabs/monaco-collab-ext/tree/6ece72028e4b8fb35e9928a304fbdfe28a4e7be9/src/ts
+ * ==================================================================================================== */
+
+/**
+ * The RemoteCursor class represents a remote cursor in the MonacoEditor. This
+ * class allows you to control the location and visibility of the cursor.
+ */
+class RemoteCursor {
+  constructor(delegate) {
+    this._delegate = delegate;
+  }
+  /**
+   * Gets the unique id of this cursor.
+   */
+
+
+  getId() {
+    return this._delegate.getId();
+  }
+  /**
+   * Gets the position of the cursor.
+   */
+
+
+  getPosition() {
+    var _a;
+
+    return (_a = this._delegate.getPosition()) === null || _a === void 0 ? void 0 : _a.position;
+  }
+  /**
+   * Sets the location of the cursor based on a Monaco Editor IPosition.
+   */
+
+
+  setPosition(position) {
+    this._delegate.setPosition(position);
+  }
+  /**
+   * Sets the location of the cursor using a zero-based text offset.
+   *
+   * @param offset
+   *   The offset of the cursor.
+   */
+
+
+  setOffset(offset) {
+    this._delegate.setOffset(offset);
+  }
+  /**
+   * Shows the cursor if it is hidden.
+   */
+
+
+  show() {
+    this._delegate.show();
+  }
+  /**
+   * Hides the cursor if it is shown.
+   */
+
+
+  hide() {
+    this._delegate.hide();
+  }
+  /**
+   * Determines if the cursor has already been disposed. A cursor is disposed
+   * when it has been permanently removed from the editor.
+   *
+   * @returns
+   *   True if the cursor has been disposed, false otherwise.
+   */
+
+
+  isDisposed() {
+    return this._delegate.isDisposed();
+  }
+  /**
+   * Disposes of this cursor, removing it from the editor.
+   */
+
+
+  dispose() {
+    this._delegate.dispose();
+  }
+
+}
+
+exports.RemoteCursor = RemoteCursor;

package/cjs/components/shared/monaco-editor/utils/remoteMarker/RemoteCursorManager.d.ts

@@ -0,0 +1,48 @@
+import { RemoteCursor } from './RemoteCursor';
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type { IPosition } from 'monaco-editor/esm/vs/editor/editor.api';
+export interface IRemoteCursorManagerOptions {
+    editor: monaco.editor.ICodeEditor;
+    tooltips?: boolean;
+    tooltipDuration?: number;
+}
+export declare class RemoteCursorManager {
+    /** A counter that generates unique ids for the cursor widgets. */
+    private _nextWidgetId;
+    /** Tracks the current cursor widgets by the userland id. */
+    private readonly _cursorWidgets;
+    /** The options (and defaults) used to configure this instance. */
+    private readonly _options;
+    constructor(options: IRemoteCursorManagerOptions);
+    /**
+     * Adds a new remote cursor to the editor.
+     */
+    addCursor(id: string, color: string, label?: string): RemoteCursor;
+    /**
+     * Removes the remote cursor from the editor.
+     */
+    removeCursor(id: string): void;
+    /**
+     * Updates the location of the specified remote cursor
+     * using a Monaco IPosition object.
+     */
+    setCursorPosition(id: string, position: IPosition): void;
+    /**
+     * Updates the location of the specified remote cursor
+     * based on a zero-based text offset.
+     */
+    setCursorOffset(id: string, offset: number): void;
+    /**
+     * Shows the specified cursor. Note the cursor may be scrolled out of view.
+     */
+    showCursor(id: string): void;
+    /**
+     * Hides the specified cursor.
+     */
+    hideCursor(id: string): void;
+    /**
+     * A helper method that gets a cursor by id, or throws an exception.
+     * @internal
+     */
+    private _getCursor;
+}

package/cjs/components/shared/monaco-editor/utils/remoteMarker/RemoteCursorManager.js

@@ -0,0 +1,119 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var RemoteCursor = require('./RemoteCursor.js');
+var RemoteCursorWidget = require('./RemoteCursorWidget.js');
+
+/* ====================================================================================================
+ * These codes forked and modified from `convergencelabs/monaco-collab-ext`
+ * under the terms of the MIT license.
+ * Make sure to check the original project if any issue exists.
+ * - project: https://github.com/convergencelabs/monaco-collab-ext
+ * - codes: https://github.com/convergencelabs/monaco-collab-ext/tree/6ece72028e4b8fb35e9928a304fbdfe28a4e7be9/src/ts
+ * ==================================================================================================== */
+class RemoteCursorManager {
+  constructor(options) {
+    var _a, _b;
+
+    this._options = {
+      editor: options.editor,
+      tooltips: (_a = options.tooltips) !== null && _a !== void 0 ? _a : true,
+      tooltipDuration: (_b = options.tooltipDuration) !== null && _b !== void 0 ? _b : 1
+    };
+    this._cursorWidgets = new Map();
+    this._nextWidgetId = 0;
+  }
+  /**
+   * Adds a new remote cursor to the editor.
+   */
+
+
+  addCursor(id, color, label) {
+    const widgetId = `${this._nextWidgetId++}`;
+    const tooltipDurationMs = this._options.tooltipDuration * 1000;
+    const cursorWidget = new RemoteCursorWidget.RemoteCursorWidget(this._options.editor, widgetId, color, label !== null && label !== void 0 ? label : '', this._options.tooltips, tooltipDurationMs, () => this.removeCursor(id));
+
+    this._cursorWidgets.set(id, cursorWidget);
+
+    return new RemoteCursor.RemoteCursor(cursorWidget);
+  }
+  /**
+   * Removes the remote cursor from the editor.
+   */
+
+
+  removeCursor(id) {
+    const remoteCursorWidget = this._getCursor(id);
+
+    if (remoteCursorWidget && !remoteCursorWidget.isDisposed()) {
+      remoteCursorWidget.dispose();
+    }
+
+    this._cursorWidgets.delete(id);
+  }
+  /**
+   * Updates the location of the specified remote cursor
+   * using a Monaco IPosition object.
+   */
+
+
+  setCursorPosition(id, position) {
+    const remoteCursorWidget = this._getCursor(id);
+
+    if (remoteCursorWidget) {
+      remoteCursorWidget.setPosition(position);
+    }
+  }
+  /**
+   * Updates the location of the specified remote cursor
+   * based on a zero-based text offset.
+   */
+
+
+  setCursorOffset(id, offset) {
+    const remoteCursorWidget = this._getCursor(id);
+
+    if (remoteCursorWidget) {
+      remoteCursorWidget.setOffset(offset);
+    }
+  }
+  /**
+   * Shows the specified cursor. Note the cursor may be scrolled out of view.
+   */
+
+
+  showCursor(id) {
+    const remoteCursorWidget = this._getCursor(id);
+
+    if (remoteCursorWidget) {
+      remoteCursorWidget.show();
+    }
+  }
+  /**
+   * Hides the specified cursor.
+   */
+
+
+  hideCursor(id) {
+    const remoteCursorWidget = this._getCursor(id);
+
+    if (remoteCursorWidget) {
+      remoteCursorWidget.hide();
+    }
+  }
+  /**
+   * A helper method that gets a cursor by id, or throws an exception.
+   * @internal
+   */
+
+
+  _getCursor(id) {
+    var _a;
+
+    return (_a = this._cursorWidgets.get(id)) !== null && _a !== void 0 ? _a : null;
+  }
+
+}
+
+exports.RemoteCursorManager = RemoteCursorManager;

package/cjs/components/shared/monaco-editor/utils/remoteMarker/RemoteCursorWidget.d.ts

@@ -0,0 +1,29 @@
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api';
+import type { IDisposable, IPosition } from 'monaco-editor/esm/vs/editor/editor.api';
+import type { OnDisposed } from './OnDisposed';
+export declare class RemoteCursorWidget implements editor.IContentWidget, IDisposable {
+    private readonly _id;
+    private readonly _editor;
+    private readonly _domNode;
+    private readonly _tooltipNode;
+    private readonly _tooltipDuration;
+    private readonly _scrollListener;
+    private readonly _onDisposed;
+    private _position;
+    private _hideTimer;
+    private _disposed;
+    constructor(codeEditor: editor.ICodeEditor, widgetId: string, color: string, label: string, tooltipEnabled: boolean, tooltipDuration: number, onDisposed: OnDisposed);
+    hide(): void;
+    show(): void;
+    setOffset(offset: number): void;
+    setPosition(position: IPosition): void;
+    isDisposed(): boolean;
+    dispose(): void;
+    getId(): string;
+    getDomNode(): HTMLElement;
+    getPosition(): editor.IContentWidgetPosition | null;
+    private _updatePosition;
+    private _showTooltip;
+    private _updateTooltipPosition;
+    private _setTooltipVisible;
+}