@elice/material-exercise 1.220803.0

package/es/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/es/components/shared/monaco-editor/utils/monacoLanguage.js

@@ -0,0 +1,53 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+
+/**
+ * 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.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';
+}
+
+export { getLanguageFromFilename };

package/es/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/es/components/shared/monaco-editor/utils/monacoPreference.js

@@ -0,0 +1,22 @@
+import { DEFAULT_MONACO_EDITOR_PREFERENCE } from '../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(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]) {
+        normalized[key] = raw[key];
+      }
+    });
+    return normalized;
+  } catch (_) {
+    return DEFAULT_MONACO_EDITOR_PREFERENCE;
+  }
+}
+
+export { normalizeMonacoPreference };

package/es/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/es/components/shared/monaco-editor/utils/prettier/config.js

@@ -0,0 +1,22 @@
+/**
+ * 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)
+};
+
+export { prettierConfigSource };

package/es/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/es/components/shared/monaco-editor/utils/prettier/index.js

@@ -0,0 +1,12 @@
+import { prettierConfigSource } from './config.js';
+
+/**
+ * Run prettier on the given text.
+ */
+
+async function prettier (value, options) {
+  const prettier = await import('prettier/standalone');
+  return prettier.format(value, Object.assign(Object.assign({}, options), prettierConfigSource.config));
+}
+
+export { prettier as default };

package/es/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/es/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/es/components/shared/monaco-editor/utils/remoteMarker/RemoteCursor.js

@@ -0,0 +1,93 @@
+/* ====================================================================================================
+ * 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();
+  }
+
+}
+
+export { RemoteCursor };

package/es/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/es/components/shared/monaco-editor/utils/remoteMarker/RemoteCursorManager.js

@@ -0,0 +1,115 @@
+import { RemoteCursor } from './RemoteCursor.js';
+import { RemoteCursorWidget } from './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(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(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;
+  }
+
+}
+
+export { RemoteCursorManager };

package/es/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;
+}

package/es/components/shared/monaco-editor/utils/remoteMarker/RemoteCursorWidget.js

@@ -0,0 +1,177 @@
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api';
+import { REMOTE_MARKER_CLASS_NAME } from './styles.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
+ * ==================================================================================================== */
+
+function getConfiguration(editorInstance) {
+  // Support for Monaco < 0.19.0
+  if (typeof editorInstance.getConfiguration === 'function') {
+    return editorInstance.getConfiguration();
+  }
+
+  return {
+    lineHeight: editorInstance.getOption(editor.EditorOption.lineHeight)
+  };
+}
+
+class RemoteCursorWidget {
+  constructor(codeEditor, widgetId, color, label, tooltipEnabled, tooltipDuration, onDisposed) {
+    this._position = null;
+    this._editor = codeEditor;
+    this._tooltipDuration = tooltipDuration;
+    this._id = `${REMOTE_MARKER_CLASS_NAME}-cursor-${widgetId}`;
+    this._onDisposed = onDisposed; // Create the main node for the cursor element.
+
+    const {
+      lineHeight
+    } = getConfiguration(this._editor);
+    this._domNode = document.createElement('div');
+    this._domNode.className = `${REMOTE_MARKER_CLASS_NAME}-cursor`;
+    this._domNode.style.background = color;
+    this._domNode.style.height = `${lineHeight}px`; // Create the tooltip element if the tooltip is enabled.
+
+    if (tooltipEnabled) {
+      this._tooltipNode = document.createElement('div');
+      this._tooltipNode.className = `${REMOTE_MARKER_CLASS_NAME}-cursor-tooltip`;
+      this._tooltipNode.style.background = color;
+      this._tooltipNode.innerHTML = label;
+
+      this._domNode.appendChild(this._tooltipNode); // we only need to listen to scroll positions to update the
+      // tooltip location on scrolling.
+
+
+      this._scrollListener = this._editor.onDidScrollChange(() => {
+        this._updateTooltipPosition();
+      });
+    } else {
+      this._tooltipNode = null;
+      this._scrollListener = null;
+    }
+
+    this._hideTimer = null;
+
+    this._editor.addContentWidget(this);
+
+    this._disposed = false;
+  }
+
+  hide() {
+    this._domNode.style.display = 'none';
+  }
+
+  show() {
+    this._domNode.style.display = 'inherit';
+  }
+
+  setOffset(offset) {
+    var _a;
+
+    const position = (_a = this._editor.getModel()) === null || _a === void 0 ? void 0 : _a.getPositionAt(offset);
+
+    if (position) {
+      this.setPosition(position);
+    }
+  }
+
+  setPosition(position) {
+    this._updatePosition(position);
+
+    if (this._tooltipNode !== null) {
+      setTimeout(() => this._showTooltip(), 0);
+    }
+  }
+
+  isDisposed() {
+    return this._disposed;
+  }
+
+  dispose() {
+    if (this._disposed) {
+      return;
+    }
+
+    this._editor.removeContentWidget(this);
+
+    if (this._scrollListener !== null) {
+      this._scrollListener.dispose();
+    }
+
+    this._disposed = true;
+
+    this._onDisposed();
+  }
+
+  getId() {
+    return this._id;
+  }
+
+  getDomNode() {
+    return this._domNode;
+  }
+
+  getPosition() {
+    return this._position;
+  }
+
+  _updatePosition(position) {
+    this._position = {
+      position: Object.assign({}, position),
+      preference: [editor.ContentWidgetPositionPreference.EXACT]
+    };
+
+    this._editor.layoutContentWidget(this);
+  }
+
+  _showTooltip() {
+    this._updateTooltipPosition();
+
+    if (this._hideTimer !== null) {
+      clearTimeout(this._hideTimer);
+    } else {
+      this._setTooltipVisible(true);
+    }
+
+    this._hideTimer = setTimeout(() => {
+      this._setTooltipVisible(false);
+
+      this._hideTimer = null;
+    }, this._tooltipDuration);
+  }
+
+  _updateTooltipPosition() {
+    if (!this._tooltipNode) {
+      return;
+    }
+
+    const distanceFromTop = this._domNode.offsetTop - this._editor.getScrollTop();
+
+    if (distanceFromTop - this._tooltipNode.offsetHeight < 5) {
+      this._tooltipNode.style.top = `${this._tooltipNode.offsetHeight + 2}px`;
+    } else {
+      this._tooltipNode.style.top = `-${this._tooltipNode.offsetHeight}px`;
+    }
+
+    this._tooltipNode.style.left = '0';
+  }
+
+  _setTooltipVisible(visible) {
+    if (!this._tooltipNode) {
+      return;
+    }
+
+    if (visible) {
+      this._tooltipNode.style.opacity = '1.0';
+    } else {
+      this._tooltipNode.style.opacity = '0';
+    }
+  }
+
+}
+
+export { RemoteCursorWidget };