@elice/material-exercise 1.220803.0

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoEventCursor.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+const EMPTY_DEPS = [];
+/**
+ * Hook for cursor activity event of monaco editor.
+ */
+
+const useMonacoEventCursor = (monaco, cb, deps = EMPTY_DEPS) => {
+  React.useEffect(() => {
+    if (!monaco.current) {
+      return;
+    }
+
+    const subscription = monaco.current.onDidChangeCursorSelection(e => {
+      var _a;
+
+      if (typeof cb !== 'function') {
+        return;
+      }
+
+      const model = (_a = monaco.current) === null || _a === void 0 ? void 0 : _a.getModel();
+
+      if (!model || model.isDisposed()) {
+        return;
+      }
+
+      const selection = e.selection;
+      const from = model.getOffsetAt(selection.getStartPosition());
+      const to = model.getOffsetAt(selection.getEndPosition());
+      cb({
+        from,
+        to
+      });
+    });
+    return () => {
+      subscription.dispose();
+    };
+  }, // eslint-disable-next-line react-hooks/exhaustive-deps
+  [monaco, ...deps]);
+};
+
+exports.useMonacoEventCursor = useMonacoEventCursor;

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoEventScroll.d.ts

@@ -0,0 +1,12 @@
+import type { editor } from 'monaco-editor/esm/vs/editor/editor.api';
+import type React from 'react';
+declare type Monaco = React.MutableRefObject<editor.IStandaloneCodeEditor | null>;
+declare type ScrollEventCallback = (position: {
+    x: number;
+    y: number;
+}) => void;
+/**
+ * Hook for scroll event of monaco editor.
+ */
+export declare const useMonacoEventScroll: (monaco: Monaco, cb?: ScrollEventCallback | undefined, deps?: unknown[]) => void;
+export {};

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoEventScroll.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+
+const EMPTY_DEPS = [];
+/**
+ * Hook for scroll event of monaco editor.
+ */
+
+const useMonacoEventScroll = (monaco, cb, deps = EMPTY_DEPS) => {
+  React.useEffect(() => {
+    if (!monaco.current) {
+      return;
+    }
+
+    const subscription = monaco.current.onDidScrollChange(e => {
+      if (typeof cb !== 'function') {
+        return;
+      }
+
+      cb({
+        x: e.scrollLeft,
+        y: e.scrollTop
+      });
+    });
+    return () => {
+      subscription.dispose();
+    };
+  }, // eslint-disable-next-line react-hooks/exhaustive-deps
+  [monaco, ...deps]);
+};
+
+exports.useMonacoEventScroll = useMonacoEventScroll;

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoMarkers.d.ts

@@ -0,0 +1,20 @@
+import type { editor } from 'monaco-editor/esm/vs/editor/editor.api';
+import type React from 'react';
+declare type Monaco = React.MutableRefObject<editor.IStandaloneCodeEditor | null>;
+interface UseMonacoMarkersReturns {
+    init: () => void;
+    dispose: () => void;
+}
+export interface MonacoEditorMarker {
+    id: number;
+    accesskey: string;
+    fullname: string;
+    email: string;
+    from: number;
+    to: number;
+}
+/**
+ * Hook for cursor activity event of monaco editor.
+ */
+export declare const useMonacoMarkers: (monaco: Monaco, markers: MonacoEditorMarker[]) => UseMonacoMarkersReturns;
+export {};

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoMarkers.js

@@ -0,0 +1,179 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var reactUse = require('react-use');
+var RemoteCursorManager = require('../utils/remoteMarker/RemoteCursorManager.js');
+var RemoteSelectionManager = require('../utils/remoteMarker/RemoteSelectionManager.js');
+require('../utils/remoteMarker/styles.js');
+
+/** Available colors for marker. */
+
+const MARKER_COLORS = Object.freeze(['purple', 'turquoise', 'red', 'yellow', 'lime', 'blue', 'pink']);
+const MARKER_DELAY_AFTER_INIT = 100;
+/**
+ * Hook for cursor activity event of monaco editor.
+ */
+
+const useMonacoMarkers = (monaco, markers) => {
+  const _returns = React.useRef({});
+  /** Cache storage of markers. */
+
+
+  const caches = React.useRef({});
+  /** Ref of remote cursor manager. */
+
+  const remoteCursor = React.useRef();
+  /** Ref of remote selection manager. */
+
+  const remoteSelection = React.useRef();
+  /**
+   * Get color of marker according to user ID.
+   * @param userId  ID of user.
+   */
+
+  const getMarkerColor = userId => {
+    const index = userId % MARKER_COLORS.length;
+    return MARKER_COLORS[index];
+  };
+  /**
+   * Set markers to code editor.
+   */
+
+
+  const setMarkers = () => {
+    const editor = monaco.current;
+    const model = editor === null || editor === void 0 ? void 0 : editor.getModel();
+
+    if (!editor || !model) {
+      return;
+    } // Update marker's cache.
+
+
+    markers // if marker type is `selection`,
+    // add cursor marker at end position of current selection.
+    .flatMap(marker => {
+      if (marker.from !== marker.to) {
+        const cursorForSelectionMarker = Object.assign(Object.assign({}, marker), {
+          from: marker.to,
+          to: marker.to
+        });
+        return [marker, cursorForSelectionMarker];
+      }
+
+      return marker;
+    }) // create or update cache for markers.
+    .forEach(marker => {
+      if (!remoteCursor.current || !remoteSelection.current) {
+        return;
+      }
+
+      const id = marker.id.toString();
+      const color = getMarkerColor(marker.id);
+      const markerType = marker.from === marker.to ? 'cursor' : 'selection';
+      const cacheId = `${id}-${marker.accesskey}-${marker.fullname}-${markerType}`;
+      const needToCreate = !caches.current[cacheId] || caches.current[cacheId].manager.isDisposed(); // cursor
+
+      if (markerType === 'cursor') {
+        // create new cursor marker
+        if (needToCreate) {
+          caches.current[cacheId] = {
+            type: 'cursor',
+            manager: remoteCursor.current.addCursor(id, color, marker.fullname)
+          };
+        } // update position of cursor marker
+
+
+        const markerPosition = model.getPositionAt(marker.from);
+        caches.current[cacheId].position = markerPosition;
+      } // selection
+      else {
+        // create new selection marker
+        if (needToCreate) {
+          caches.current[cacheId] = {
+            type: 'selection',
+            manager: remoteSelection.current.addSelection(id, color, marker.fullname)
+          };
+        } // update position of selection marker
+
+
+        const markerStartPosition = model.getPositionAt(marker.from);
+        const markerEndPosition = model.getPositionAt(marker.to);
+        caches.current[cacheId].position = {
+          start: markerStartPosition,
+          end: markerEndPosition
+        };
+      }
+    }); // Update marker postion from cache.
+
+    Object.keys(caches.current).forEach(id => {
+      const cache = caches.current[id];
+
+      if (!cache.position) {
+        // Dispose marker cache, if postion not exist.
+        cache.manager.dispose();
+        return;
+      }
+
+      switch (cache.type) {
+        case 'cursor':
+          cache.manager.setPosition(cache.position);
+          break;
+
+        case 'selection':
+          cache.manager.setPositions(cache.position.start, cache.position.end);
+          break;
+      } // Delete marker position at cache,
+      // because marker position is for once usage.
+
+
+      delete caches.current[id].position;
+    });
+  };
+  /**
+   * Initialize remoter marker manager.
+   */
+
+
+  const init = () => {
+    if (!monaco.current) {
+      return;
+    }
+
+    remoteCursor.current = new RemoteCursorManager.RemoteCursorManager({
+      editor: monaco.current,
+      tooltips: true,
+      tooltipDuration: 5
+    });
+    remoteSelection.current = new RemoteSelectionManager.RemoteSelectionManager({
+      editor: monaco.current
+    });
+    setTimeout(() => setMarkers(), MARKER_DELAY_AFTER_INIT);
+  };
+  /**
+   * Dispose remoter marker manager.
+   */
+
+
+  const dispose = () => {
+    Object.keys(caches.current).forEach(cacheId => {
+      caches.current[cacheId].manager.dispose();
+    });
+    remoteCursor.current = undefined;
+    remoteSelection.current = undefined;
+  }; //
+  // Update markers.
+  //
+
+
+  reactUse.useDeepCompareEffect(() => setMarkers(), [markers]); //
+  //
+  //
+
+  _returns.current.init = init;
+  _returns.current.dispose = dispose;
+  return _returns.current;
+};
+
+exports.useMonacoMarkers = useMonacoMarkers;

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoOptions.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api';
+import type { EditorOptions } from '../hooks';
+declare type Monaco = React.MutableRefObject<editor.IStandaloneCodeEditor | null>;
+/**
+ * Hook for update options of monaco editor.
+ */
+export declare const useMonacoOptions: (monaco: Monaco, options: EditorOptions) => void;
+export {};

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoOptions.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var monaco = require('monaco-editor/esm/vs/editor/editor.api');
+var preferences = require('../constants/monaco/preferences.js');
+var config = require('../utils/prettier/config.js');
+
+const FONT_LOAD_TEXT = '각난닫ABCabc1230!@#\t !@#():{}[]-_\\|';
+/**
+ * Hook for update options of monaco editor.
+ */
+
+const useMonacoOptions = (monaco$1, options) => {
+  //
+  // Update options from preference.
+  //
+  React.useEffect(() => {
+    var _a;
+
+    return (_a = monaco$1.current) === null || _a === void 0 ? void 0 : _a.updateOptions(options);
+  }, [monaco$1, options]); //
+  // Sync prettier config with monaco editor preference.
+  //
+
+  React.useEffect(() => {
+    config.prettierConfigSource.config.tabWidth = options.tabSize;
+    config.prettierConfigSource.config.useTabs = options.insertSpaces === false;
+  }, [options]); //
+  // Load font and remeasure font of editor.
+  //
+
+  React.useEffect(() => {
+    var _a, _b, _c;
+
+    if (typeof ((_b = (_a = document) === null || _a === void 0 ? void 0 : _a.fonts) === null || _b === void 0 ? void 0 : _b.load) !== 'function') {
+      return;
+    }
+
+    const size = (_c = options.fontSize) !== null && _c !== void 0 ? _c : preferences.DEFAULT_MONACO_EDITOR_PREFERENCE.fontSize;
+    document.fonts.load(`${size}px Elice Digital Coding`, FONT_LOAD_TEXT).then(() => monaco.editor.remeasureFonts()).catch(() => {// do nothing.
+    });
+  }, [options.fontSize]);
+};
+
+exports.useMonacoOptions = useMonacoOptions;

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoTheme.d.ts

@@ -0,0 +1,6 @@
+declare type SupportedTheme = string | null | undefined;
+/**
+ * Import and set theme for monaco editor.
+ */
+export declare const useMonacoTheme: <T extends SupportedTheme>(rawTheme?: T | undefined, cb?: ((theme: T) => void) | undefined) => void;
+export {};

package/cjs/components/shared/monaco-editor/editor-hooks/useMonacoTheme.js

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var React = require('react');
+var monaco = require('monaco-editor/esm/vs/editor/editor.api');
+var index = require('../utils/theme/index.js');
+
+/**
+ * Import and set theme for monaco editor.
+ */
+
+const useMonacoTheme = (rawTheme, cb) => {
+  const theme = rawTheme !== null && rawTheme !== void 0 ? rawTheme : 'elice';
+  React.useEffect(() => {
+    index.importTheme(theme).then(themeData => {
+      monaco.editor.defineTheme(theme, themeData);
+      monaco.editor.setTheme(theme);
+
+      if (typeof cb === 'function') {
+        cb(theme);
+      }
+    }).catch(err => {
+      // eslint-disable-next-line no-console
+      console.warn(`fail to load theme (\`${theme}\`)`, err);
+    });
+  }, // eslint-disable-next-line react-hooks/exhaustive-deps
+  [theme]);
+};
+
+exports.useMonacoTheme = useMonacoTheme;

package/cjs/components/shared/monaco-editor/editor-languages/css/formatter.d.ts

@@ -0,0 +1,3 @@
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+declare const CssDocumentFormattingEditProvider: monaco.languages.DocumentFormattingEditProvider;
+export default CssDocumentFormattingEditProvider;

package/cjs/components/shared/monaco-editor/editor-languages/css/formatter.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var index = require('../../utils/prettier/index.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);
+}
+
+const CssDocumentFormattingEditProvider = {
+  async provideDocumentFormattingEdits(model) {
+    const text = await index(model.getValue(), {
+      parser: 'scss',
+      plugins: [await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('prettier/parser-postcss')); })]
+    });
+    return [{
+      range: model.getFullModelRange(),
+      text
+    }];
+  }
+
+};
+
+module.exports = CssDocumentFormattingEditProvider;

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

@@ -0,0 +1,9 @@
+/**
+ * Set CSS document formatting provider.
+ */
+export declare function setDocumentFormattingEditProvider(): void;
+/**
+ * Set CSS options.
+ */
+export declare function setOptions(): void;
+export default function (): void;

package/cjs/components/shared/monaco-editor/editor-languages/css/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var monaco = require('monaco-editor/esm/vs/editor/editor.api');
+var formatter = require('./formatter.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);
+}
+
+var monaco__namespace = /*#__PURE__*/_interopNamespace(monaco);
+
+/**
+ * Set CSS document formatting provider.
+ */
+
+function setDocumentFormattingEditProvider() {
+  monaco__namespace.languages.registerDocumentFormattingEditProvider('css', formatter);
+}
+/**
+ * Set CSS options.
+ */
+
+function setOptions() {
+  monaco__namespace.languages.css.cssDefaults.setOptions({
+    validate: false
+  });
+} //
+//
+//
+
+function css () {
+  setDocumentFormattingEditProvider();
+  setOptions();
+}
+
+exports["default"] = css;
+exports.setDocumentFormattingEditProvider = setDocumentFormattingEditProvider;
+exports.setOptions = setOptions;

package/cjs/components/shared/monaco-editor/editor-languages/html/formatter.d.ts

@@ -0,0 +1,3 @@
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+declare const HtmlDocumentFormattingEditProvider: monaco.languages.DocumentFormattingEditProvider;
+export default HtmlDocumentFormattingEditProvider;

package/cjs/components/shared/monaco-editor/editor-languages/html/formatter.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var index = require('../../utils/prettier/index.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);
+}
+
+const HtmlDocumentFormattingEditProvider = {
+  async provideDocumentFormattingEdits(model) {
+    const text = await index(model.getValue(), {
+      parser: 'html',
+      plugins: [await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('prettier/parser-html')); })]
+    });
+    return [{
+      range: model.getFullModelRange(),
+      text
+    }];
+  }
+
+};
+
+module.exports = HtmlDocumentFormattingEditProvider;

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

@@ -0,0 +1,9 @@
+/**
+ * Set HTML document formatting provider.
+ */
+export declare function setDocumentFormattingEditProvider(): void;
+/**
+ * Set HTML options.
+ */
+export declare function setOptions(): void;
+export default function (): void;

package/cjs/components/shared/monaco-editor/editor-languages/html/index.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var monaco = require('monaco-editor/esm/vs/editor/editor.api');
+var formatter = require('./formatter.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);
+}
+
+var monaco__namespace = /*#__PURE__*/_interopNamespace(monaco);
+
+/**
+ * Set HTML document formatting provider.
+ */
+
+function setDocumentFormattingEditProvider() {
+  monaco__namespace.languages.registerDocumentFormattingEditProvider('html', formatter);
+}
+/**
+ * Set HTML options.
+ */
+
+function setOptions() {
+  monaco__namespace.languages.html.htmlDefaults.setOptions({});
+} //
+//
+//
+
+function html () {
+  setDocumentFormattingEditProvider();
+  setOptions();
+}
+
+exports["default"] = html;
+exports.setDocumentFormattingEditProvider = setDocumentFormattingEditProvider;
+exports.setOptions = setOptions;

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

@@ -0,0 +1 @@
+export default function (): void;

package/cjs/components/shared/monaco-editor/editor-languages/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('./css/index.js');
+var index$1 = require('./html/index.js');
+var index$2 = require('./typescript/index.js');
+
+function configEditorLanguages () {
+  index["default"]();
+  index$1["default"]();
+  index$2["default"]();
+}
+
+module.exports = configEditorLanguages;

package/cjs/components/shared/monaco-editor/editor-languages/typescript/dts/_helper.d.ts

@@ -0,0 +1,7 @@
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+export declare type DtsParams = Parameters<typeof monaco.languages.typescript.typescriptDefaults['addExtraLib']>;
+export interface DtsOptions {
+    path: DtsParams[1];
+    content: DtsParams[0];
+}
+export declare function dts(options: DtsOptions): DtsOptions;

package/cjs/components/shared/monaco-editor/editor-languages/typescript/dts/_helper.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function dts(options) {
+  return {
+    path: options.path ? `file:///node_modules/${options.path}` : '',
+    content: options.content
+  };
+}
+
+exports.dts = dts;

package/cjs/components/shared/monaco-editor/editor-languages/typescript/dts/express.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("./_helper").DtsOptions;
+/**
+ * @types/express@4.17.13
+ */
+export default _default;

package/cjs/components/shared/monaco-editor/editor-languages/typescript/dts/express.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var _helper = require('./_helper.js');
+
+/**
+ * @types/express@4.17.13
+ */
+
+var express = _helper.dts({
+  path: '@types/express/index.d.ts',
+  content: "/// <reference types=\"express-serve-static-core\" />\n/// <reference types=\"serve-static\" />\nimport*as bodyParser from'body-parser';import*as serveStatic from'serve-static';import*as core from'express-serve-static-core';import*as qs from'qs';declare function e():core.Express;declare namespace e{var json:typeof bodyParser.json;var raw:typeof bodyParser.raw;var text:typeof bodyParser.text;var application:Application;var request:Request;var response:Response;var static:serveStatic.RequestHandlerConstructor<Response>;var urlencoded:typeof bodyParser.urlencoded;export function query(options:qs.IParseOptions|typeof qs.parse):Handler;export function Router(options?:RouterOptions):core.Router;interface RouterOptions{caseSensitive?:boolean|undefined;mergeParams?:boolean|undefined;strict?:boolean|undefined;}interface Application extends core.Application{}interface CookieOptions extends core.CookieOptions{}interface Errback extends core.Errback{}interface ErrorRequestHandler<\nP=core.ParamsDictionary,ResBody=any,ReqBody=any,ReqQuery=core.Query,Locals extends Record<string,any>=Record<string,any>>extends core.ErrorRequestHandler<P,ResBody,ReqBody,ReqQuery,Locals>{}interface Express extends core.Express{}interface Handler extends core.Handler{}interface IRoute extends core.IRoute{}interface IRouter extends core.IRouter{}interfaceIRouterHandler<T>extends core.IRouterHandler<T>{}interface IRouterMatcher<T>extends core.IRouterMatcher<T>{}interface MediaType extends core.MediaType{}interface NextFunction extends core.NextFunction{}interface Request<\nP=core.ParamsDictionary,ResBody=any,ReqBody=any,ReqQuery=core.Query,Locals extends Record<string,any>=Record<string,any>>extends core.Request<P,ResBody,ReqBody,ReqQuery,Locals>{}interface RequestHandler<\nP=core.ParamsDictionary,ResBody=any,ReqBody=any,ReqQuery=core.Query,Locals extends Record<string,any>=Record<string,any>>extends core.RequestHandler<P,ResBody,ReqBody,ReqQuery,Locals>{}interface RequestParamHandler extends core.RequestParamHandler{}export interface Response<ResBody=any,Locals extends Record<string,any>=Record<string,any>>extends core.Response<ResBody,Locals>{}interface Router extends core.Router{}interface Send extends core.Send{}}export=e;"
+});
+
+module.exports = express;

package/cjs/components/shared/monaco-editor/editor-languages/typescript/dts/index.d.ts

@@ -0,0 +1,3 @@
+export { default as express } from './express';
+export { default as propTypes } from './propTypes';
+export { default as react } from './react';