@covalent/code-editor 4.0.0-alpha.0 → 4.0.0-beta.1

package/code-editor.component.d.ts

@@ -1,6 +1,8 @@
 import { EventEmitter, OnInit, ElementRef, NgZone, ChangeDetectorRef, OnDestroy } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { Observable } from 'rxjs';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import * as i0 from "@angular/core";
 export declare class TdCodeEditorComponent implements OnInit, ControlValueAccessor, OnDestroy {
     private zone;
     private _changeDetectorRef;
@@ -21,12 +23,13 @@ export declare class TdCodeEditorComponent implements OnInit, ControlValueAccess
     private _isFullScreen;
     private _keycode;
     private _registeredLanguagesStyles;
+    private _onDidChangeContentDisposable?;
     _editorContainer: ElementRef;
     /**
      * editorInitialized: function($event)
      * Event emitted when editor is first initialized
      */
-    editorInitialized: EventEmitter<void>;
+    editorInitialized: EventEmitter<monaco.editor.IStandaloneCodeEditor>;
     /**
      * editorConfigurationChanged: function($event)
      * Event emitted when editor's configuration changes
@@ -128,4 +131,6 @@ export declare class TdCodeEditorComponent implements OnInit, ControlValueAccess
      * addFullScreenModeCommand used to add the fullscreen option to the context menu
      */
     private addFullScreenModeCommand;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TdCodeEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TdCodeEditorComponent, "td-code-editor", never, { "value": "value"; "language": "language"; "editorStyle": "editorStyle"; "theme": "theme"; "fullScreenKeyBinding": "fullScreenKeyBinding"; "editorOptions": "editorOptions"; }, { "editorInitialized": "editorInitialized"; "editorConfigurationChanged": "editorConfigurationChanged"; "editorLanguageChanged": "editorLanguageChanged"; "editorValueChange": "editorValueChange"; "change": "change"; }, never, never>;
 }

package/code-editor.component.scss

@@ -1,7 +1,8 @@
 :host {
   display: block;
   position: relative;
-  .editorContainer {
+
+  .editor-container {
     position: absolute;
     top: 0;
     bottom: 0;

package/code-editor.module.d.ts

@@ -1,2 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./code-editor.component";
+import * as i2 from "@angular/common";
 export declare class CovalentCodeEditorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CovalentCodeEditorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CovalentCodeEditorModule, [typeof i1.TdCodeEditorComponent], [typeof i2.CommonModule], [typeof i1.TdCodeEditorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CovalentCodeEditorModule>;
 }

package/covalent-code-editor.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@covalent/code-editor" />
 export * from './index';

package/esm2020/code-editor.component.mjs

@@ -0,0 +1,425 @@
+import { Component, Input, Output, EventEmitter, ViewChild, ElementRef, forwardRef, NgZone, ChangeDetectorRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { fromEvent, merge, timer } from 'rxjs';
+import { debounceTime, distinctUntilChanged, takeUntil } from 'rxjs/operators';
+// Use esm version to support shipping subset of languages and features
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import * as i0 from "@angular/core";
+const _c0 = ["editorContainer"];
+const noop = () => {
+    // empty method
+};
+// counter for ids to allow for multiple editors on one page
+let uniqueCounter = 0;
+export class TdCodeEditorComponent {
+    // tslint:disable-next-line:member-ordering
+    constructor(zone, _changeDetectorRef, _elementRef) {
+        this.zone = zone;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._elementRef = _elementRef;
+        this._destroy = new Subject();
+        this._widthSubject = new Subject();
+        this._heightSubject = new Subject();
+        this._editorStyle = 'width:100%;height:100%;border:1px solid grey;';
+        this._value = '';
+        this._theme = 'vs';
+        this._language = 'javascript';
+        this._subject = new Subject();
+        this._editorInnerContainer = 'editorInnerContainer' + uniqueCounter++;
+        this._fromEditor = false;
+        this._componentInitialized = false;
+        this._editorOptions = {};
+        this._isFullScreen = false;
+        this._registeredLanguagesStyles = [];
+        /**
+         * editorInitialized: function($event)
+         * Event emitted when editor is first initialized
+         */
+        this.editorInitialized = new EventEmitter();
+        /**
+         * editorConfigurationChanged: function($event)
+         * Event emitted when editor's configuration changes
+         */
+        this.editorConfigurationChanged = new EventEmitter();
+        /**
+         * editorLanguageChanged: function($event)
+         * Event emitted when editor's Language changes
+         */
+        this.editorLanguageChanged = new EventEmitter();
+        /**
+         * editorValueChange: function($event)
+         * Event emitted any time something changes the editor value
+         */
+        this.editorValueChange = new EventEmitter();
+        /**
+         * The change event notifies you about a change happening in an input field.
+         * Since the component is not a native Angular component have to specifiy the event emitter ourself
+         */
+        this.change = new EventEmitter();
+        /* tslint:disable-next-line */
+        this.propagateChange = (_) => { };
+        this.onTouched = () => noop;
+    }
+    /**
+     * value?: string
+     */
+    set value(value) {
+        if (value === this._value) {
+            return;
+        }
+        this._value = value;
+        if (this._componentInitialized) {
+            this.applyValue();
+        }
+    }
+    get value() {
+        return this._value;
+    }
+    applyValue() {
+        if (!this._fromEditor) {
+            this._editor.setValue(this._value);
+        }
+        this._fromEditor = false;
+        this.propagateChange(this._value);
+        this.change.emit();
+        this.editorValueChange.emit();
+    }
+    /**
+     * Implemented as part of ControlValueAccessor.
+     */
+    writeValue(value) {
+        // do not write if null or undefined
+        // tslint:disable-next-line
+        if (value != undefined) {
+            this.value = value;
+        }
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * getEditorContent?: function
+     * Returns the content within the editor
+     */
+    getValue() {
+        if (this._componentInitialized) {
+            setTimeout(() => {
+                this._subject.next(this._value);
+                this._subject.complete();
+                this._subject = new Subject();
+            });
+            return this._subject.asObservable();
+        }
+    }
+    /**
+     * language?: string
+     * language used in editor
+     */
+    set language(language) {
+        this._language = language;
+        if (this._componentInitialized) {
+            this.applyLanguage();
+        }
+    }
+    get language() {
+        return this._language;
+    }
+    applyLanguage() {
+        if (this._language) {
+            monaco.editor.setModelLanguage(this._editor.getModel(), this._language);
+            this.editorLanguageChanged.emit();
+        }
+    }
+    /**
+     * registerLanguage?: function
+     * Registers a custom Language within the editor
+     */
+    registerLanguage(language) {
+        if (this._componentInitialized) {
+            for (const provider of language.completionItemProvider) {
+                /* tslint:disable-next-line */
+                provider.kind = eval(provider.kind);
+            }
+            for (const monarchTokens of language.monarchTokensProvider) {
+                /* tslint:disable-next-line */
+                monarchTokens[0] = eval(monarchTokens[0]);
+            }
+            monaco.languages.register({ id: language.id });
+            monaco.languages.setMonarchTokensProvider(language.id, {
+                tokenizer: {
+                    root: language.monarchTokensProvider,
+                },
+            });
+            // Define a new theme that constains only rules that match this language
+            monaco.editor.defineTheme(language.customTheme.id, language.customTheme.theme);
+            this._theme = language.customTheme.id;
+            monaco.languages.registerCompletionItemProvider(language.id, {
+                provideCompletionItems: () => {
+                    return language.completionItemProvider;
+                },
+            });
+            const css = document.createElement('style');
+            css.type = 'text/css';
+            css.innerHTML = language.monarchTokensProviderCSS;
+            document.body.appendChild(css);
+            this.editorConfigurationChanged.emit();
+            this._registeredLanguagesStyles = [...this._registeredLanguagesStyles, css];
+        }
+    }
+    /**
+     * style?: string
+     * css style of the editor on the page
+     */
+    set editorStyle(editorStyle) {
+        this._editorStyle = editorStyle;
+        if (this._componentInitialized) {
+            this.applyStyle();
+        }
+    }
+    get editorStyle() {
+        return this._editorStyle;
+    }
+    applyStyle() {
+        if (this._editorStyle) {
+            const containerDiv = this._editorContainer.nativeElement;
+            containerDiv.setAttribute('style', this._editorStyle);
+        }
+    }
+    /**
+     * theme?: string
+     * Theme to be applied to editor
+     */
+    set theme(theme) {
+        this._theme = theme;
+        if (this._componentInitialized) {
+            this._editor.updateOptions({ theme });
+            this.editorConfigurationChanged.emit();
+        }
+    }
+    get theme() {
+        return this._theme;
+    }
+    /**
+     * fullScreenKeyBinding?: number
+     * See here for key bindings https://microsoft.github.io/monaco-editor/api/enums/monaco.keycode.html
+     * Sets the KeyCode for shortcutting to Fullscreen mode
+     */
+    set fullScreenKeyBinding(keycode) {
+        this._keycode = keycode;
+    }
+    get fullScreenKeyBinding() {
+        return this._keycode;
+    }
+    /**
+     * editorOptions?: object
+     * Options used on editor instantiation. Available options listed here:
+     * https://microsoft.github.io/monaco-editor/api/interfaces/monaco.editor.ieditoroptions.html
+     */
+    set editorOptions(editorOptions) {
+        this._editorOptions = editorOptions;
+        if (this._componentInitialized) {
+            this._editor.updateOptions(editorOptions);
+            this.editorConfigurationChanged.emit();
+        }
+    }
+    get editorOptions() {
+        return this._editorOptions;
+    }
+    /**
+     * layout method that calls layout method of editor and instructs the editor to remeasure its container
+     */
+    layout() {
+        if (this._componentInitialized) {
+            this._editor.layout();
+        }
+    }
+    /**
+     * Returns if in Full Screen Mode or not
+     */
+    get isFullScreen() {
+        return this._isFullScreen;
+    }
+    ngOnInit() {
+        const containerDiv = this._editorContainer.nativeElement;
+        containerDiv.id = this._editorInnerContainer;
+        this._editor = monaco.editor.create(containerDiv, Object.assign({
+            value: this._value,
+            language: this.language,
+            theme: this._theme,
+        }, this.editorOptions));
+        this._componentInitialized = true;
+        setTimeout(() => {
+            this.applyLanguage();
+            this._fromEditor = true;
+            this.applyValue();
+            this.applyStyle();
+            this.editorInitialized.emit(this._editor);
+            this.editorConfigurationChanged.emit();
+        });
+        // The `onDidChangeContent` returns a disposable object (an object with `dispose()` method) which will cleanup
+        // the listener. The callback, that we pass to `onDidChangeContent`, captures `this`. This leads to a circular reference
+        // (`td-code-editor -> monaco -> td-code-editor`) and prevents the `td-code-editor` from being GC'd.
+        this._onDidChangeContentDisposable = this._editor.getModel().onDidChangeContent((e) => {
+            this._fromEditor = true;
+            this.writeValue(this._editor.getValue());
+            this.layout();
+        });
+        this.addFullScreenModeCommand();
+        merge(fromEvent(window, 'resize').pipe(debounceTime(100)), this._widthSubject.asObservable().pipe(distinctUntilChanged()), this._heightSubject.asObservable().pipe(distinctUntilChanged()))
+            .pipe(takeUntil(this._destroy), debounceTime(100))
+            .subscribe(() => {
+            this.layout();
+            this._changeDetectorRef.markForCheck();
+        });
+        timer(500, 250)
+            .pipe(takeUntil(this._destroy))
+            .subscribe(() => {
+            if (this._elementRef && this._elementRef.nativeElement) {
+                this._widthSubject.next(this._elementRef.nativeElement.getBoundingClientRect().width);
+                this._heightSubject.next(this._elementRef.nativeElement.getBoundingClientRect().height);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._changeDetectorRef.detach();
+        this._registeredLanguagesStyles.forEach((style) => style.remove());
+        if (this._onDidChangeContentDisposable) {
+            this._onDidChangeContentDisposable.dispose();
+            this._onDidChangeContentDisposable = undefined;
+        }
+        if (this._editor) {
+            this._editor.dispose();
+            this._editor = undefined;
+        }
+        this._destroy.next(true);
+        this._destroy.unsubscribe();
+    }
+    /**
+     * showFullScreenEditor request for full screen of Code Editor based on its browser type.
+     */
+    showFullScreenEditor() {
+        if (this._componentInitialized) {
+            const codeEditorElement = this._editorContainer.nativeElement;
+            const fullScreenMap = {
+                // Chrome
+                requestFullscreen: () => codeEditorElement.requestFullscreen(),
+                // Safari
+                webkitRequestFullscreen: () => codeEditorElement.webkitRequestFullscreen(),
+                // IE
+                msRequestFullscreen: () => codeEditorElement.msRequestFullscreen(),
+                // Firefox
+                mozRequestFullScreen: () => codeEditorElement.mozRequestFullScreen(),
+            };
+            for (const handler of Object.keys(fullScreenMap)) {
+                if (codeEditorElement[handler]) {
+                    fullScreenMap[handler]();
+                }
+            }
+        }
+        this._isFullScreen = true;
+    }
+    /**
+     * exitFullScreenEditor request to exit full screen of Code Editor based on its browser type.
+     */
+    exitFullScreenEditor() {
+        if (this._componentInitialized) {
+            const exitFullScreenMap = {
+                // Chrome
+                exitFullscreen: () => document.exitFullscreen(),
+                // Safari
+                webkitExitFullscreen: () => document.webkitExitFullscreen(),
+                // Firefox
+                mozCancelFullScreen: () => document.mozCancelFullScreen(),
+                // IE
+                msExitFullscreen: () => document.msExitFullscreen(),
+            };
+            for (const handler of Object.keys(exitFullScreenMap)) {
+                if (document[handler]) {
+                    exitFullScreenMap[handler]();
+                }
+            }
+        }
+        this._isFullScreen = false;
+    }
+    /**
+     * addFullScreenModeCommand used to add the fullscreen option to the context menu
+     */
+    addFullScreenModeCommand() {
+        this._editor.addAction({
+            // An unique identifier of the contributed action.
+            id: 'fullScreen',
+            // A label of the action that will be presented to the user.
+            label: 'Full Screen',
+            // An optional array of keybindings for the action.
+            contextMenuGroupId: 'navigation',
+            keybindings: this._keycode,
+            contextMenuOrder: 1.5,
+            // Method that will be executed when the action is triggered.
+            // @param editor The editor instance is passed in as a convinience
+            run: (ed) => {
+                this.showFullScreenEditor();
+            },
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdCodeEditorComponent.ɵfac = function TdCodeEditorComponent_Factory(t) { return new (t || TdCodeEditorComponent)(i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i0.ElementRef)); };
+/** @nocollapse */ /** @nocollapse */ TdCodeEditorComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdCodeEditorComponent, selectors: [["td-code-editor"]], viewQuery: function TdCodeEditorComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 7);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx._editorContainer = _t.first);
+    } }, inputs: { value: "value", language: "language", editorStyle: "editorStyle", theme: "theme", fullScreenKeyBinding: "fullScreenKeyBinding", editorOptions: "editorOptions" }, outputs: { editorInitialized: "editorInitialized", editorConfigurationChanged: "editorConfigurationChanged", editorLanguageChanged: "editorLanguageChanged", editorValueChange: "editorValueChange", change: "change" }, features: [i0.ɵɵProvidersFeature([
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef((() => TdCodeEditorComponent)),
+                multi: true,
+            },
+        ])], decls: 2, vars: 0, consts: [[1, "editor-container"], ["editorContainer", ""]], template: function TdCodeEditorComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelement(0, "div", 0, 1);
+    } }, styles: ["[_nghost-%COMP%]{display:block;position:relative}[_nghost-%COMP%]   .editor-container[_ngcontent-%COMP%]{position:absolute;top:0;bottom:0;left:0;right:0}  .monaco-aria-container{display:none}"] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdCodeEditorComponent, [{
+        type: Component,
+        args: [{ selector: 'td-code-editor', providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef((() => TdCodeEditorComponent)),
+                        multi: true,
+                    },
+                ], template: "<div class=\"editor-container\" #editorContainer></div>\n", styles: [":host{display:block;position:relative}:host .editor-container{position:absolute;top:0;bottom:0;left:0;right:0}::ng-deep .monaco-aria-container{display:none}\n"] }]
+    }], function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }]; }, { _editorContainer: [{
+            type: ViewChild,
+            args: ['editorContainer', { static: true }]
+        }], editorInitialized: [{
+            type: Output
+        }], editorConfigurationChanged: [{
+            type: Output
+        }], editorLanguageChanged: [{
+            type: Output
+        }], editorValueChange: [{
+            type: Output
+        }], change: [{
+            type: Output
+        }], value: [{
+            type: Input,
+            args: ['value']
+        }], language: [{
+            type: Input,
+            args: ['language']
+        }], editorStyle: [{
+            type: Input,
+            args: ['editorStyle']
+        }], theme: [{
+            type: Input,
+            args: ['theme']
+        }], fullScreenKeyBinding: [{
+            type: Input,
+            args: ['fullScreenKeyBinding']
+        }], editorOptions: [{
+            type: Input,
+            args: ['editorOptions']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code-editor.component.js","sourceRoot":"","sources":["../../../../src/platform/code-editor/code-editor.component.ts","../../../../src/platform/code-editor/code-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  OnInit,\n  ViewChild,\n  ElementRef,\n  forwardRef,\n  NgZone,\n  ChangeDetectorRef,\n  OnDestroy,\n} from '@angular/core';\nimport { NG_VALUE_ACCESSOR, ControlValueAccessor } from '@angular/forms';\nimport { Observable, Subject } from 'rxjs';\nimport { fromEvent, merge, timer } from 'rxjs';\nimport { debounceTime, distinctUntilChanged, takeUntil } from 'rxjs/operators';\n\n// Use esm version to support shipping subset of languages and features\nimport * as monaco from 'monaco-editor/esm/vs/editor/editor.api';\n\nconst noop: any = () => {\n  // empty method\n};\n\n// counter for ids to allow for multiple editors on one page\nlet uniqueCounter: number = 0;\n\n@Component({\n  selector: 'td-code-editor',\n  templateUrl: './code-editor.component.html',\n  styleUrls: ['./code-editor.component.scss'],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => TdCodeEditorComponent),\n      multi: true,\n    },\n  ],\n})\nexport class TdCodeEditorComponent implements OnInit, ControlValueAccessor, OnDestroy {\n  private _destroy: Subject<boolean> = new Subject<boolean>();\n  private _widthSubject: Subject<number> = new Subject<number>();\n  private _heightSubject: Subject<number> = new Subject<number>();\n\n  private _editorStyle: string = 'width:100%;height:100%;border:1px solid grey;';\n  private _value: string = '';\n  private _theme: string = 'vs';\n  private _language: string = 'javascript';\n  private _subject: Subject<string> = new Subject();\n  private _editorInnerContainer: string = 'editorInnerContainer' + uniqueCounter++;\n  private _editor: monaco.editor.IStandaloneCodeEditor;\n  private _fromEditor: boolean = false;\n  private _componentInitialized: boolean = false;\n  private _editorOptions: any = {};\n  private _isFullScreen: boolean = false;\n  private _keycode: any;\n  private _registeredLanguagesStyles: HTMLStyleElement[] = [];\n  private _onDidChangeContentDisposable?: monaco.IDisposable;\n\n  @ViewChild('editorContainer', { static: true }) _editorContainer: ElementRef;\n\n  /**\n   * editorInitialized: function($event)\n   * Event emitted when editor is first initialized\n   */\n  @Output() editorInitialized: EventEmitter<monaco.editor.IStandaloneCodeEditor> =\n    new EventEmitter<monaco.editor.IStandaloneCodeEditor>();\n\n  /**\n   * editorConfigurationChanged: function($event)\n   * Event emitted when editor's configuration changes\n   */\n  @Output() editorConfigurationChanged: EventEmitter<void> = new EventEmitter<void>();\n\n  /**\n   * editorLanguageChanged: function($event)\n   * Event emitted when editor's Language changes\n   */\n  @Output() editorLanguageChanged: EventEmitter<void> = new EventEmitter<void>();\n\n  /**\n   * editorValueChange: function($event)\n   * Event emitted any time something changes the editor value\n   */\n  @Output() editorValueChange: EventEmitter<void> = new EventEmitter<void>();\n\n  /**\n   * The change event notifies you about a change happening in an input field.\n   * Since the component is not a native Angular component have to specifiy the event emitter ourself\n   */\n  @Output() change: EventEmitter<void> = new EventEmitter<void>();\n  /* tslint:disable-next-line */\n  propagateChange = (_: any) => {};\n  onTouched = () => noop;\n\n  /**\n   * value?: string\n   */\n  @Input('value')\n  set value(value: string) {\n    if (value === this._value) {\n      return;\n    }\n    this._value = value;\n    if (this._componentInitialized) {\n      this.applyValue();\n    }\n  }\n\n  get value(): string {\n    return this._value;\n  }\n\n  applyValue(): void {\n    if (!this._fromEditor) {\n      this._editor.setValue(this._value);\n    }\n    this._fromEditor = false;\n    this.propagateChange(this._value);\n    this.change.emit();\n    this.editorValueChange.emit();\n  }\n\n  /**\n   * Implemented as part of ControlValueAccessor.\n   */\n  writeValue(value: any): void {\n    // do not write if null or undefined\n    // tslint:disable-next-line\n    if (value != undefined) {\n      this.value = value;\n    }\n  }\n  registerOnChange(fn: any): void {\n    this.propagateChange = fn;\n  }\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  /**\n   * getEditorContent?: function\n   * Returns the content within the editor\n   */\n  getValue(): Observable<string> {\n    if (this._componentInitialized) {\n      setTimeout(() => {\n        this._subject.next(this._value);\n        this._subject.complete();\n        this._subject = new Subject();\n      });\n      return this._subject.asObservable();\n    }\n  }\n\n  /**\n   * language?: string\n   * language used in editor\n   */\n  @Input('language')\n  set language(language: string) {\n    this._language = language;\n    if (this._componentInitialized) {\n      this.applyLanguage();\n    }\n  }\n\n  get language(): string {\n    return this._language;\n  }\n\n  applyLanguage(): void {\n    if (this._language) {\n      monaco.editor.setModelLanguage(this._editor.getModel(), this._language);\n      this.editorLanguageChanged.emit();\n    }\n  }\n\n  /**\n   * registerLanguage?: function\n   * Registers a custom Language within the editor\n   */\n  registerLanguage(language: any): void {\n    if (this._componentInitialized) {\n      for (const provider of language.completionItemProvider) {\n        /* tslint:disable-next-line */\n        provider.kind = eval(provider.kind);\n      }\n      for (const monarchTokens of language.monarchTokensProvider) {\n        /* tslint:disable-next-line */\n        monarchTokens[0] = eval(monarchTokens[0]);\n      }\n      monaco.languages.register({ id: language.id });\n\n      monaco.languages.setMonarchTokensProvider(language.id, {\n        tokenizer: {\n          root: language.monarchTokensProvider,\n        },\n      });\n\n      // Define a new theme that constains only rules that match this language\n      monaco.editor.defineTheme(language.customTheme.id, language.customTheme.theme);\n      this._theme = language.customTheme.id;\n\n      monaco.languages.registerCompletionItemProvider(language.id, {\n        provideCompletionItems: () => {\n          return language.completionItemProvider;\n        },\n      });\n\n      const css: HTMLStyleElement = document.createElement('style');\n      css.type = 'text/css';\n      css.innerHTML = language.monarchTokensProviderCSS;\n      document.body.appendChild(css);\n      this.editorConfigurationChanged.emit();\n      this._registeredLanguagesStyles = [...this._registeredLanguagesStyles, css];\n    }\n  }\n\n  /**\n   * style?: string\n   * css style of the editor on the page\n   */\n  @Input('editorStyle')\n  set editorStyle(editorStyle: string) {\n    this._editorStyle = editorStyle;\n    if (this._componentInitialized) {\n      this.applyStyle();\n    }\n  }\n\n  get editorStyle(): string {\n    return this._editorStyle;\n  }\n\n  applyStyle(): void {\n    if (this._editorStyle) {\n      const containerDiv: HTMLDivElement = this._editorContainer.nativeElement;\n      containerDiv.setAttribute('style', this._editorStyle);\n    }\n  }\n\n  /**\n   * theme?: string\n   * Theme to be applied to editor\n   */\n  @Input('theme')\n  set theme(theme: string) {\n    this._theme = theme;\n    if (this._componentInitialized) {\n      this._editor.updateOptions({ theme });\n      this.editorConfigurationChanged.emit();\n    }\n  }\n  get theme(): string {\n    return this._theme;\n  }\n\n  /**\n   * fullScreenKeyBinding?: number\n   * See here for key bindings https://microsoft.github.io/monaco-editor/api/enums/monaco.keycode.html\n   * Sets the KeyCode for shortcutting to Fullscreen mode\n   */\n  @Input('fullScreenKeyBinding')\n  set fullScreenKeyBinding(keycode: number[]) {\n    this._keycode = keycode;\n  }\n  get fullScreenKeyBinding(): number[] {\n    return this._keycode;\n  }\n\n  /**\n   * editorOptions?: object\n   * Options used on editor instantiation. Available options listed here:\n   * https://microsoft.github.io/monaco-editor/api/interfaces/monaco.editor.ieditoroptions.html\n   */\n  @Input('editorOptions')\n  set editorOptions(editorOptions: any) {\n    this._editorOptions = editorOptions;\n    if (this._componentInitialized) {\n      this._editor.updateOptions(editorOptions);\n      this.editorConfigurationChanged.emit();\n    }\n  }\n  get editorOptions(): any {\n    return this._editorOptions;\n  }\n\n  /**\n   * layout method that calls layout method of editor and instructs the editor to remeasure its container\n   */\n  layout(): void {\n    if (this._componentInitialized) {\n      this._editor.layout();\n    }\n  }\n\n  /**\n   * Returns if in Full Screen Mode or not\n   */\n  get isFullScreen(): boolean {\n    return this._isFullScreen;\n  }\n\n  // tslint:disable-next-line:member-ordering\n  constructor(private zone: NgZone, private _changeDetectorRef: ChangeDetectorRef, private _elementRef: ElementRef) {}\n\n  ngOnInit(): void {\n    const containerDiv: HTMLDivElement = this._editorContainer.nativeElement;\n    containerDiv.id = this._editorInnerContainer;\n\n    this._editor = monaco.editor.create(\n      containerDiv,\n      Object.assign(\n        {\n          value: this._value,\n          language: this.language,\n          theme: this._theme,\n        },\n        this.editorOptions,\n      ),\n    );\n    this._componentInitialized = true;\n    setTimeout(() => {\n      this.applyLanguage();\n      this._fromEditor = true;\n      this.applyValue();\n      this.applyStyle();\n      this.editorInitialized.emit(this._editor);\n      this.editorConfigurationChanged.emit();\n    });\n    // The `onDidChangeContent` returns a disposable object (an object with `dispose()` method) which will cleanup\n    // the listener. The callback, that we pass to `onDidChangeContent`, captures `this`. This leads to a circular reference\n    // (`td-code-editor -> monaco -> td-code-editor`) and prevents the `td-code-editor` from being GC'd.\n    this._onDidChangeContentDisposable = this._editor.getModel().onDidChangeContent((e: any) => {\n      this._fromEditor = true;\n      this.writeValue(this._editor.getValue());\n      this.layout();\n    });\n    this.addFullScreenModeCommand();\n\n    merge(\n      fromEvent(window, 'resize').pipe(debounceTime(100)),\n      this._widthSubject.asObservable().pipe(distinctUntilChanged()),\n      this._heightSubject.asObservable().pipe(distinctUntilChanged()),\n    )\n      .pipe(takeUntil(this._destroy), debounceTime(100))\n      .subscribe(() => {\n        this.layout();\n        this._changeDetectorRef.markForCheck();\n      });\n    timer(500, 250)\n      .pipe(takeUntil(this._destroy))\n      .subscribe(() => {\n        if (this._elementRef && this._elementRef.nativeElement) {\n          this._widthSubject.next((<HTMLElement>this._elementRef.nativeElement).getBoundingClientRect().width);\n          this._heightSubject.next((<HTMLElement>this._elementRef.nativeElement).getBoundingClientRect().height);\n        }\n      });\n  }\n\n  ngOnDestroy(): void {\n    this._changeDetectorRef.detach();\n    this._registeredLanguagesStyles.forEach((style: HTMLStyleElement) => style.remove());\n    if (this._onDidChangeContentDisposable) {\n      this._onDidChangeContentDisposable.dispose();\n      this._onDidChangeContentDisposable = undefined;\n    }\n    if (this._editor) {\n      this._editor.dispose();\n      this._editor = undefined;\n    }\n    this._destroy.next(true);\n    this._destroy.unsubscribe();\n  }\n\n  /**\n   * showFullScreenEditor request for full screen of Code Editor based on its browser type.\n   */\n  public showFullScreenEditor(): void {\n    if (this._componentInitialized) {\n      const codeEditorElement: HTMLDivElement = this._editorContainer.nativeElement as HTMLDivElement;\n      const fullScreenMap: object = {\n        // Chrome\n        requestFullscreen: () => codeEditorElement.requestFullscreen(),\n        // Safari\n        webkitRequestFullscreen: () => (<any>codeEditorElement).webkitRequestFullscreen(),\n        // IE\n        msRequestFullscreen: () => (<any>codeEditorElement).msRequestFullscreen(),\n        // Firefox\n        mozRequestFullScreen: () => (<any>codeEditorElement).mozRequestFullScreen(),\n      };\n\n      for (const handler of Object.keys(fullScreenMap)) {\n        if (codeEditorElement[handler]) {\n          fullScreenMap[handler]();\n        }\n      }\n    }\n    this._isFullScreen = true;\n  }\n\n  /**\n   * exitFullScreenEditor request to exit full screen of Code Editor based on its browser type.\n   */\n  public exitFullScreenEditor(): void {\n    if (this._componentInitialized) {\n      const exitFullScreenMap: object = {\n        // Chrome\n        exitFullscreen: () => document.exitFullscreen(),\n        // Safari\n        webkitExitFullscreen: () => (<any>document).webkitExitFullscreen(),\n        // Firefox\n        mozCancelFullScreen: () => (<any>document).mozCancelFullScreen(),\n        // IE\n        msExitFullscreen: () => (<any>document).msExitFullscreen(),\n      };\n\n      for (const handler of Object.keys(exitFullScreenMap)) {\n        if (document[handler]) {\n          exitFullScreenMap[handler]();\n        }\n      }\n    }\n    this._isFullScreen = false;\n  }\n\n  /**\n   * addFullScreenModeCommand used to add the fullscreen option to the context menu\n   */\n  private addFullScreenModeCommand(): void {\n    this._editor.addAction({\n      // An unique identifier of the contributed action.\n      id: 'fullScreen',\n      // A label of the action that will be presented to the user.\n      label: 'Full Screen',\n      // An optional array of keybindings for the action.\n      contextMenuGroupId: 'navigation',\n      keybindings: this._keycode,\n      contextMenuOrder: 1.5,\n      // Method that will be executed when the action is triggered.\n      // @param editor The editor instance is passed in as a convinience\n      run: (ed: any) => {\n        this.showFullScreenEditor();\n      },\n    });\n  }\n}\n","<div class=\"editor-container\" #editorContainer></div>\n"]}

package/esm2020/code-editor.module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TdCodeEditorComponent } from './code-editor.component';
+import * as i0 from "@angular/core";
+export class CovalentCodeEditorModule {
+}
+/** @nocollapse */ /** @nocollapse */ CovalentCodeEditorModule.ɵfac = function CovalentCodeEditorModule_Factory(t) { return new (t || CovalentCodeEditorModule)(); };
+/** @nocollapse */ /** @nocollapse */ CovalentCodeEditorModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: CovalentCodeEditorModule, bootstrap: [TdCodeEditorComponent] });
+/** @nocollapse */ /** @nocollapse */ CovalentCodeEditorModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ imports: [[CommonModule]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CovalentCodeEditorModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule],
+                declarations: [TdCodeEditorComponent],
+                exports: [TdCodeEditorComponent],
+                bootstrap: [TdCodeEditorComponent],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CovalentCodeEditorModule, { declarations: [TdCodeEditorComponent], imports: [CommonModule], exports: [TdCodeEditorComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZS1lZGl0b3IubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3BsYXRmb3JtL2NvZGUtZWRpdG9yL2NvZGUtZWRpdG9yLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQzs7QUFRaEUsTUFBTSxPQUFPLHdCQUF3Qjs7c0lBQXhCLHdCQUF3Qjs0SEFBeEIsd0JBQXdCLGNBRnZCLHFCQUFxQjtnSUFIeEIsQ0FBQyxZQUFZLENBQUM7dUZBS1osd0JBQXdCO2NBTnBDLFFBQVE7ZUFBQztnQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7Z0JBQ3ZCLFlBQVksRUFBRSxDQUFDLHFCQUFxQixDQUFDO2dCQUNyQyxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztnQkFDaEMsU0FBUyxFQUFFLENBQUMscUJBQXFCLENBQUM7YUFDbkM7O3dGQUNZLHdCQUF3QixtQkFKcEIscUJBQXFCLGFBRDFCLFlBQVksYUFFWixxQkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG5pbXBvcnQgeyBUZENvZGVFZGl0b3JDb21wb25lbnQgfSBmcm9tICcuL2NvZGUtZWRpdG9yLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IFtUZENvZGVFZGl0b3JDb21wb25lbnRdLFxuICBleHBvcnRzOiBbVGRDb2RlRWRpdG9yQ29tcG9uZW50XSxcbiAgYm9vdHN0cmFwOiBbVGRDb2RlRWRpdG9yQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgQ292YWxlbnRDb2RlRWRpdG9yTW9kdWxlIHt9XG4iXX0=

package/esm2020/covalent-code-editor.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQtY29kZS1lZGl0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGxhdGZvcm0vY29kZS1lZGl0b3IvY292YWxlbnQtY29kZS1lZGl0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2020/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGxhdGZvcm0vY29kZS1lZGl0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/public-api.mjs

@@ -0,0 +1,3 @@
+export { TdCodeEditorComponent } from './code-editor.component';
+export { CovalentCodeEditorModule } from './code-editor.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wbGF0Zm9ybS9jb2RlLWVkaXRvci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ2hFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgVGRDb2RlRWRpdG9yQ29tcG9uZW50IH0gZnJvbSAnLi9jb2RlLWVkaXRvci5jb21wb25lbnQnO1xuZXhwb3J0IHsgQ292YWxlbnRDb2RlRWRpdG9yTW9kdWxlIH0gZnJvbSAnLi9jb2RlLWVkaXRvci5tb2R1bGUnO1xuIl19