@testgorilla/tgo-coding-test 0.0.1 → 1.0.0

package/README.md

@@ -113,6 +113,54 @@ import { TgoCodingTestCandidateViewComponent } from '@testgorilla/tgo-coding-tes
 export class MyComponent {}
 ```
 
+## Assets (translations)
+
+This package ships its translations under `assets/i18n`. Consumer apps must copy these assets into their build output so Transloco can load them at runtime.
+
+- **Angular CLI / Nx**: add an `assets` entry pointing at the package:
+
+```json
+{
+  "assets": [
+    "src/favicon.ico",
+    "src/assets",
+    {
+      "glob": "**/*",
+      "input": "node_modules/@testgorilla/tgo-coding-test/assets",
+      "output": "assets/tgo-coding-test"
+    }
+  ]
+}
+```
+
+If you develop inside this repo (consuming the workspace sources), also include the local path:
+
+```json
+{
+  "glob": "**/*",
+  "input": "packages/tgo-coding-test/src/assets",
+  "output": "assets/tgo-coding-test"
+}
+```
+
+After adding the asset entries, rebuild/re-serve your app so `/assets/tgo-coding-test/i18n/en.json` is available.
+
+## Mocking ApiService for demo/local runs
+
+The candidate view includes a mocked API service for demos. To use it:
+
+1. In `tgo-coding-test-candidate-view.component.ts`, uncomment the mock provider and comment the real one:
+
+```typescript
+// use MockedApiService for local demo only
+{ provide: ApiService, useClass: MockedApiService },
+// ApiService,
+```
+
+2. Ensure `MockedApiService` is imported at the top of the file.
+
+This lets the component run without live backend calls when serving the demo app.
+
 ## API
 
 ### TgoCodingTestComponent
@@ -196,7 +244,6 @@ This library requires the following peer dependencies:
 - `@angular/router` ^18.2.13
 - `@ngneat/transloco` ~4.3.0
 - `@ngneat/until-destroy` 10.0.0
-- `@testgorilla/tgo-test-shared` ^0.0.1
 - `@testgorilla/tgo-ui` ^3.0.0
 - `angular-split` ^18.0.0
 - `monaco-editor` 0.50.0
@@ -218,7 +265,7 @@ All required services, models, and components are included within this library:
 - `CoderunnerApiService` - API service for code execution
 - `CodingTestConfigService` - Provides access to library configuration (injects configuration token internally)
 - `ThemeService` - Provides theme/company color configuration
-- `Question`, `TestResultRead`, `Assessment`, `ISubmissionState` - Type definitions from `@testgorilla/tgo-test-shared`
+- `Question`, `TestResultRead`, `Assessment`, `ISubmissionState` - Type definitions (bundled from shared code)
 - `CodeEditorComponent`, `CodingQuestionComponent`, `RunnableEditorComponent` - UI components
 - `TranslocoLazyModuleUtils`, `getAvailableLangs` - Translation utilities
 

package/esm2022/index.mjs

@@ -0,0 +1,12 @@
+/*
+ * Public API Surface of coding-test
+ */
+export { TgoCodingTestComponent } from './lib/components/tgo-coding-test/tgo-coding-test.component';
+export { TgoCodingTestCandidateViewComponent } from './lib/components/tgo-coding-test-candidate-view/tgo-coding-test-candidate-view.component';
+export { ViewMode } from './lib/models/view-mode';
+export { LibCodingTestService } from './lib/services/lib-coding-test.service';
+export { StorageCodingService } from './lib/services/storage.service';
+export { CodingTestConfigService } from './lib/services/coding-test-config.service';
+// Configuration exports
+export { provideTgoCodingTest, } from './lib/config';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/code-editor/code-editor.component.mjs

@@ -0,0 +1,335 @@
+import { __decorate } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, inject, Input, Output, ViewChild, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { UntilDestroy, untilDestroyed } from '@ngneat/until-destroy';
+import { combineLatest, distinctUntilChanged, filter, first, interval, map, take } from 'rxjs';
+import { MonacoEditorModule } from 'ngx-monaco-editor-v2';
+import { erlangLanguage } from '../../utils/additional-languages/erlang';
+import { ConfigurationsService } from '../../services/configurations.service';
+import { LibCodingTestService } from '../../services/lib-coding-test.service';
+import { StorageCodingService } from '../../services/storage.service';
+import { CodeEditorService } from './code-editor.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "ngx-monaco-editor-v2";
+let CodeEditorComponent = class CodeEditorComponent {
+    libCodingTestService = inject(LibCodingTestService);
+    configurationsService = inject(ConfigurationsService);
+    codeEditorService = inject(CodeEditorService);
+    changeDetectorRef = inject(ChangeDetectorRef);
+    StorageCodingService = inject(StorageCodingService);
+    initCode;
+    functionParams;
+    functionName;
+    returnType;
+    hasCodingConfigPanel;
+    isReadonly;
+    autoHeight;
+    shouldGenerateInitCode;
+    set snapshot(snap) {
+        if (snap) {
+            this.currentSnapshot = snap;
+            this.handleSnapshot(snap.text);
+        }
+    }
+    pasteEvent = new EventEmitter();
+    codeChange = new EventEmitter();
+    codeEditorElRef;
+    code = '';
+    codePublished = '';
+    codeLanguage = '';
+    editorOptions = {
+        theme: "vs-dark" /* MonacoColorTheme.Dark */,
+        fontSize: '14',
+        scrollBeyondLastLine: false,
+        minimap: { enabled: false },
+        fixedOverflowWidgets: true,
+        insertSpaces: false,
+        detectIndentation: false,
+        automaticLayout: true,
+    };
+    editor;
+    previousConfig = this.StorageCodingService.getSavedConfig();
+    currentSnapshot;
+    previousMonacoDecoration;
+    pasteListener;
+    contentChangedSub;
+    ngOnInit() {
+        if (!this.previousConfig) {
+            this.previousConfig = this.configurationsService.getInitialConfig();
+        }
+        if (this.hasCodingConfigPanel) {
+            this.updateIDEConfig();
+        }
+        this.listenUpdates();
+        this.setupConfigs();
+        this.setupCode();
+    }
+    ngOnChanges(changes) {
+        if (typeof changes.initCode?.currentValue === 'string') {
+            this.code = changes.initCode.currentValue;
+        }
+    }
+    ngOnDestroy() {
+        this.contentChangedSub?.dispose();
+        this.pasteListener?.dispose();
+    }
+    initEditor(editor) {
+        this.editor = editor;
+        this.pasteListener = this.editor.onDidPaste(event => this.catchEvent(event));
+        if (this.currentSnapshot) {
+            this.handleSnapshot(this.currentSnapshot.text);
+        }
+        if (this.autoHeight) {
+            this.listenContentHeight(editor);
+        }
+    }
+    catchEvent(event) {
+        const data = this.editor.getModel()?.getValueInRange(event.range);
+        if (data) {
+            this.pasteEvent.emit({ type: 'paste', data });
+        }
+    }
+    publishCode(code) {
+        if (code !== this.codePublished) {
+            this.codePublished = code;
+            this.codeChange.emit(this.codePublished);
+        }
+    }
+    updateIDEConfig() {
+        this.configurationsService.config$
+            .pipe(distinctUntilChanged(), untilDestroyed(this))
+            .subscribe((config) => {
+            let configObject = {};
+            // eslint-disable-next-line guard-for-in
+            for (const key in config) {
+                if (config[key] !== this.previousConfig[key]) {
+                    switch (key) {
+                        case "Color theme" /* FormattingOptions.ColorTheme */:
+                            configObject = {
+                                theme: config["Color theme" /* FormattingOptions.ColorTheme */] === "theme-default" /* Themes.Default */
+                                    ? "vs" /* MonacoColorTheme.Light */
+                                    : "vs-dark" /* MonacoColorTheme.Dark */,
+                            };
+                            break;
+                        case "Auto-complete" /* CodingAssistanceOptions.AutoComplete */:
+                            configObject = {
+                                quickSuggestions: {
+                                    other: config["Auto-complete" /* CodingAssistanceOptions.AutoComplete */],
+                                },
+                            };
+                            break;
+                        case "Auto-brackets" /* CodingAssistanceOptions.AutoBrackets */:
+                            configObject = {
+                                autoClosingBrackets: config["Auto-brackets" /* CodingAssistanceOptions.AutoBrackets */] ? 'always' : 'never',
+                            };
+                            break;
+                        case "Tab size" /* FormattingOptions.TabSize */:
+                            configObject = {
+                                tabSize: config["Tab size" /* FormattingOptions.TabSize */],
+                            };
+                            break;
+                        case "Font size" /* FormattingOptions.FontSize */:
+                            configObject = {
+                                fontSize: config["Font size" /* FormattingOptions.FontSize */],
+                            };
+                            break;
+                        case "Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */:
+                            this.libCodingTestService.currentLanguage$.pipe(take(1)).subscribe(language => {
+                                if (language === "javascript" /* CodeEditorLanguages.Javascript */) {
+                                    window['monaco'].languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+                                        noSemanticValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                                        noSyntaxValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                                    });
+                                }
+                                else if (language === "typescript" /* CodeEditorLanguages.Typescript */) {
+                                    window['monaco'].languages.typescript.typescriptDefaults.setDiagnosticsOptions({
+                                        noSemanticValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                                        noSyntaxValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                                    });
+                                }
+                            });
+                            break;
+                    }
+                    this.editorOptions = Object.assign({}, this.editorOptions, configObject);
+                }
+            }
+            this.changeDetectorRef.detectChanges();
+            this.previousConfig = config;
+        });
+        this.editorOptions = Object.assign({}, this.editorOptions, {
+            automaticLayout: true,
+        });
+    }
+    listenContentHeight(editor) {
+        const updateHeight = () => {
+            window.requestAnimationFrame(() => {
+                const { width } = this.codeEditorElRef.nativeElement.getBoundingClientRect();
+                const contentHeight = Math.min(1000, editor.getContentHeight());
+                this.codeEditorElRef.nativeElement.style.height = `${contentHeight}px`;
+                editor.layout({ width, height: contentHeight });
+            });
+        };
+        this.contentChangedSub = editor.onDidContentSizeChange(updateHeight);
+        updateHeight();
+    }
+    setupConfigs() {
+        const { functionParams: params, functionName: name, returnType } = this;
+        const config = this.previousConfig;
+        const wordWrap = this.currentSnapshot ? 'on' : 'off';
+        const theme = this.getInitialColorTheme(config, this.currentSnapshot);
+        this.libCodingTestService.currentLanguage$.pipe(untilDestroyed(this)).subscribe((language) => {
+            if (this.shouldGenerateInitCode) {
+                this.codeEditorService.setHelper(language, { params, name, returnType });
+                this.codeLanguage = this.codeEditorService.getEditorLang();
+            }
+            else {
+                if (language === "c++" /* CodeEditorLanguages.Cpp */) {
+                    this.codeLanguage = "cpp" /* CodeEditorLanguages.CppEditor */;
+                }
+                else if (language === "c#" /* CodeEditorLanguages.CSharp */ || language === "c#_legacy" /* CodeEditorLanguages.CSharpLegacy */) {
+                    this.codeLanguage = "csharp" /* CodeEditorLanguages.CSharpEditor */;
+                }
+                else if (language === "sqlite3" /* CodeEditorLanguages.Sqlite */) {
+                    this.codeLanguage = "sql" /* CodeEditorLanguages.Sql */;
+                }
+                else {
+                    this.codeLanguage = language;
+                }
+            }
+            this.editorOptions = Object.assign({}, this.editorOptions, {
+                language: this.codeLanguage,
+            });
+        });
+        this.editorOptions = Object.assign({}, this.editorOptions, {
+            readOnly: this.isReadonly,
+            quickSuggestions: {
+                other: config["Auto-complete" /* CodingAssistanceOptions.AutoComplete */],
+            },
+            autoClosingBrackets: config["Auto-brackets" /* CodingAssistanceOptions.AutoBrackets */] ? 'always' : 'never',
+            tabSize: config["Tab size" /* FormattingOptions.TabSize */],
+            fontSize: config["Font size" /* FormattingOptions.FontSize */],
+            theme,
+            wordWrap,
+        });
+        const monacoLibraryReady$ = interval(100).pipe(map(() => window.monaco), filter(Boolean), first());
+        combineLatest({
+            monaco: monacoLibraryReady$,
+            language: this.libCodingTestService.currentLanguage$,
+        })
+            .pipe(take(1))
+            .subscribe(result => {
+            if (result.language === "javascript" /* CodeEditorLanguages.Javascript */) {
+                result.monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+                    noSemanticValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                    noSyntaxValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                });
+            }
+            else if (result.language === "typescript" /* CodeEditorLanguages.Typescript */) {
+                result.monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({
+                    noSemanticValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                    noSyntaxValidation: !config["Error highlighting" /* CodingAssistanceOptions.ErrorHighlighting */],
+                });
+            }
+            result.monaco.languages.register({ id: "erlang" /* CodeEditorLanguages.Erlang */ });
+            result.monaco.languages.setMonarchTokensProvider("erlang" /* CodeEditorLanguages.Erlang */, erlangLanguage);
+        });
+    }
+    getInitialColorTheme(config, snapshot) {
+        let theme;
+        if (snapshot) {
+            theme = "vs-dark" /* MonacoColorTheme.Dark */;
+        }
+        else {
+            theme = config["Color theme" /* FormattingOptions.ColorTheme */] === "theme-default" /* Themes.Default */ ? "vs" /* MonacoColorTheme.Light */ : "vs-dark" /* MonacoColorTheme.Dark */;
+        }
+        return theme;
+    }
+    setupCode(calledFromReset = false) {
+        this.handleInitCode(calledFromReset);
+        this.publishCode(this.code);
+    }
+    handleInitCode(calledFromReset = false) {
+        if (calledFromReset) {
+            this.code = this.libCodingTestService.getInitCode();
+        }
+        else if (this.initCode) {
+            this.code = this.initCode;
+        }
+        else if (this.currentSnapshot) {
+            return;
+        }
+        else if (this.shouldGenerateInitCode) {
+            this.code = this.codeEditorService.getInitCode();
+        }
+    }
+    listenUpdates() {
+        this.libCodingTestService.codeReset$
+            .pipe(filter(val => val === "confirm" /* ResetCodeAction.Confirm */), untilDestroyed(this))
+            .subscribe(() => {
+            this.setupCode(true);
+        });
+    }
+    handleSnapshot(code) {
+        this.code = code;
+        if (!this.editor) {
+            return;
+        }
+        this.editor.setValue(code); // make sure editor model has the latest value of the code
+        if (this.previousMonacoDecoration) {
+            this.previousMonacoDecoration.clear();
+        }
+        if (this.currentSnapshot.copied_text) {
+            // if the snapshot contains copyPasted code, find it's range in monaco
+            const matches = this.editor
+                .getModel()
+                .findMatches(this.currentSnapshot.copied_text, false, false, true, null, true);
+            if (matches.length) {
+                // if the range is found in editor model, decorate it with additional class to highlight on the ui
+                this.previousMonacoDecoration = this.editor.createDecorationsCollection([
+                    {
+                        range: matches[0].range,
+                        options: { inlineClassName: 'copy-pasted-code' },
+                    },
+                ]);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodeEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: CodeEditorComponent, isStandalone: true, selector: "tgo-code-editor", inputs: { initCode: "initCode", functionParams: "functionParams", functionName: "functionName", returnType: "returnType", hasCodingConfigPanel: "hasCodingConfigPanel", isReadonly: "isReadonly", autoHeight: "autoHeight", shouldGenerateInitCode: "shouldGenerateInitCode", snapshot: "snapshot" }, outputs: { pasteEvent: "pasteEvent", codeChange: "codeChange" }, viewQueries: [{ propertyName: "codeEditorElRef", first: true, predicate: ["editor"], descendants: true, read: ElementRef }], usesOnChanges: true, ngImport: i0, template: "<div class=\"container notranslate\" translate=\"no\">\n  <ngx-monaco-editor\n    #editor\n    class=\"editor\"\n    [options]=\"editorOptions\"\n    [(ngModel)]=\"code\"\n    (ngModelChange)=\"publishCode($event)\"\n    (onInit)=\"initEditor($event)\"\n  ></ngx-monaco-editor>\n</div>\n", styles: [":host{display:block;height:100%;max-width:100%;max-height:100%}.container{height:100%;background-color:var(--code-editor-background)}.editor{height:100%}.editor ::ng-deep .copy-pasted-code{background-color:#ff0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MonacoEditorModule }, { kind: "component", type: i2.EditorComponent, selector: "ngx-monaco-editor", inputs: ["options", "model"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+};
+CodeEditorComponent = __decorate([
+    UntilDestroy()
+], CodeEditorComponent);
+export { CodeEditorComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodeEditorComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tgo-code-editor', changeDetection: ChangeDetectionStrategy.OnPush, imports: [CommonModule, FormsModule, MonacoEditorModule], template: "<div class=\"container notranslate\" translate=\"no\">\n  <ngx-monaco-editor\n    #editor\n    class=\"editor\"\n    [options]=\"editorOptions\"\n    [(ngModel)]=\"code\"\n    (ngModelChange)=\"publishCode($event)\"\n    (onInit)=\"initEditor($event)\"\n  ></ngx-monaco-editor>\n</div>\n", styles: [":host{display:block;height:100%;max-width:100%;max-height:100%}.container{height:100%;background-color:var(--code-editor-background)}.editor{height:100%}.editor ::ng-deep .copy-pasted-code{background-color:#ff0}\n"] }]
+        }], propDecorators: { initCode: [{
+                type: Input
+            }], functionParams: [{
+                type: Input
+            }], functionName: [{
+                type: Input
+            }], returnType: [{
+                type: Input
+            }], hasCodingConfigPanel: [{
+                type: Input
+            }], isReadonly: [{
+                type: Input
+            }], autoHeight: [{
+                type: Input
+            }], shouldGenerateInitCode: [{
+                type: Input
+            }], snapshot: [{
+                type: Input
+            }], pasteEvent: [{
+                type: Output
+            }], codeChange: [{
+                type: Output
+            }], codeEditorElRef: [{
+                type: ViewChild,
+                args: ['editor', { read: ElementRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code-editor.component.js","sourceRoot":"","sources":["../../../../../../../packages/tgo-coding-test/src/lib/components/code-editor/code-editor.component.ts","../../../../../../../packages/tgo-coding-test/src/lib/components/code-editor/code-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { UntilDestroy, untilDestroyed } from '@ngneat/until-destroy';\nimport { editor, IDisposable } from 'monaco-editor';\nimport { combineLatest, distinctUntilChanged, filter, first, interval, map, take } from 'rxjs';\nimport { MonacoEditorModule } from 'ngx-monaco-editor-v2';\n\nimport { erlangLanguage } from '../../utils/additional-languages/erlang';\nimport { CodingAssistanceOptions, Config, FormattingOptions } from '../../models/configs';\nimport { Themes } from '../../models/theme';\nimport { ConfigurationsService } from '../../services/configurations.service';\nimport { LibCodingTestService, ResetCodeAction } from '../../services/lib-coding-test.service';\nimport { StorageCodingService } from '../../services/storage.service';\nimport { CodeEditorService } from './code-editor.service';\nimport { CodeEditorFuncParam, CodeEditorLanguages, CodeEditorTypesMap } from './helpers/code-editor-helper.model';\nimport { MonacoColorTheme, PasteData } from './models/code-editor.model';\nimport { CodingSnapshot } from './models/coding-snapshot.model';\n\n@UntilDestroy()\n@Component({\n  standalone: true,\n  selector: 'tgo-code-editor',\n  templateUrl: './code-editor.component.html',\n  styleUrls: ['./code-editor.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [CommonModule, FormsModule, MonacoEditorModule],\n})\nexport class CodeEditorComponent implements OnInit, OnDestroy, OnChanges {\n  private readonly libCodingTestService = inject(LibCodingTestService);\n  private readonly configurationsService = inject(ConfigurationsService);\n  private readonly codeEditorService = inject(CodeEditorService);\n  private readonly changeDetectorRef = inject(ChangeDetectorRef);\n  private readonly StorageCodingService = inject(StorageCodingService);\n\n  @Input() initCode: string;\n  @Input() functionParams: CodeEditorFuncParam[];\n  @Input() functionName: string;\n  @Input() returnType: keyof CodeEditorTypesMap;\n  @Input() hasCodingConfigPanel: boolean;\n  @Input() isReadonly: boolean;\n  @Input() autoHeight: boolean;\n  @Input() shouldGenerateInitCode: boolean;\n\n  @Input() set snapshot(snap: CodingSnapshot) {\n    if (snap) {\n      this.currentSnapshot = snap;\n      this.handleSnapshot(snap.text);\n    }\n  }\n\n  @Output() pasteEvent = new EventEmitter<PasteData>();\n  @Output() codeChange = new EventEmitter<string>();\n\n  @ViewChild('editor', { read: ElementRef }) codeEditorElRef: ElementRef;\n\n  code = '';\n  codePublished = '';\n  codeLanguage = '';\n  editorOptions: { [key: string]: any } = {\n    theme: MonacoColorTheme.Dark,\n    fontSize: '14',\n    scrollBeyondLastLine: false,\n    minimap: { enabled: false },\n    fixedOverflowWidgets: true,\n    insertSpaces: false,\n    detectIndentation: false,\n    automaticLayout: true,\n  };\n\n  editor: editor.ICodeEditor;\n  previousConfig = this.StorageCodingService.getSavedConfig();\n\n  currentSnapshot: CodingSnapshot;\n  previousMonacoDecoration: editor.IEditorDecorationsCollection;\n\n  private pasteListener: IDisposable;\n  private contentChangedSub: IDisposable;\n\n  ngOnInit(): void {\n    if (!this.previousConfig) {\n      this.previousConfig = this.configurationsService.getInitialConfig();\n    }\n\n    if (this.hasCodingConfigPanel) {\n      this.updateIDEConfig();\n    }\n    this.listenUpdates();\n\n    this.setupConfigs();\n    this.setupCode();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (typeof changes.initCode?.currentValue === 'string') {\n      this.code = changes.initCode.currentValue;\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.contentChangedSub?.dispose();\n    this.pasteListener?.dispose();\n  }\n\n  initEditor(editor: editor.ICodeEditor): void {\n    this.editor = editor;\n\n    this.pasteListener = this.editor.onDidPaste(event => this.catchEvent(event));\n\n    if (this.currentSnapshot) {\n      this.handleSnapshot(this.currentSnapshot.text);\n    }\n\n    if (this.autoHeight) {\n      this.listenContentHeight(editor);\n    }\n  }\n\n  private catchEvent(event: editor.IPasteEvent): void {\n    const data = this.editor.getModel()?.getValueInRange(event.range);\n    if (data) {\n      this.pasteEvent.emit({ type: 'paste', data });\n    }\n  }\n\n  publishCode(code): void {\n    if (code !== this.codePublished) {\n      this.codePublished = code;\n      this.codeChange.emit(this.codePublished);\n    }\n  }\n\n  private updateIDEConfig(): void {\n    this.configurationsService.config$\n      .pipe(distinctUntilChanged(), untilDestroyed(this))\n      .subscribe((config: Config) => {\n        let configObject = {};\n        // eslint-disable-next-line guard-for-in\n        for (const key in config) {\n          if (config[key] !== this.previousConfig[key]) {\n            switch (key as FormattingOptions | CodingAssistanceOptions) {\n              case FormattingOptions.ColorTheme:\n                configObject = {\n                  theme:\n                    config[FormattingOptions.ColorTheme] === Themes.Default\n                      ? MonacoColorTheme.Light\n                      : MonacoColorTheme.Dark,\n                };\n\n                break;\n              case CodingAssistanceOptions.AutoComplete:\n                configObject = {\n                  quickSuggestions: {\n                    other: config[CodingAssistanceOptions.AutoComplete],\n                  },\n                };\n\n                break;\n              case CodingAssistanceOptions.AutoBrackets:\n                configObject = {\n                  autoClosingBrackets: config[CodingAssistanceOptions.AutoBrackets] ? 'always' : 'never',\n                };\n\n                break;\n              case FormattingOptions.TabSize:\n                configObject = {\n                  tabSize: config[FormattingOptions.TabSize],\n                };\n\n                break;\n              case FormattingOptions.FontSize:\n                configObject = {\n                  fontSize: config[FormattingOptions.FontSize],\n                };\n\n                break;\n              case CodingAssistanceOptions.ErrorHighlighting:\n                this.libCodingTestService.currentLanguage$.pipe(take(1)).subscribe(language => {\n                  if (language === CodeEditorLanguages.Javascript) {\n                    window['monaco'].languages.typescript.javascriptDefaults.setDiagnosticsOptions({\n                      noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n                      noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n                    });\n                  } else if (language === CodeEditorLanguages.Typescript) {\n                    window['monaco'].languages.typescript.typescriptDefaults.setDiagnosticsOptions({\n                      noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n                      noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n                    });\n                  }\n                });\n                break;\n            }\n            this.editorOptions = Object.assign({}, this.editorOptions, configObject);\n          }\n        }\n        this.changeDetectorRef.detectChanges();\n        this.previousConfig = config;\n      });\n\n    this.editorOptions = Object.assign({}, this.editorOptions, {\n      automaticLayout: true,\n    });\n  }\n\n  private listenContentHeight(editor: editor.ICodeEditor): void {\n    const updateHeight = () => {\n      window.requestAnimationFrame(() => {\n        const { width } = this.codeEditorElRef.nativeElement.getBoundingClientRect();\n        const contentHeight = Math.min(1000, editor.getContentHeight());\n        this.codeEditorElRef.nativeElement.style.height = `${contentHeight}px`;\n        editor.layout({ width, height: contentHeight });\n      });\n    };\n\n    this.contentChangedSub = editor.onDidContentSizeChange(updateHeight);\n    updateHeight();\n  }\n\n  private setupConfigs(): void {\n    const { functionParams: params, functionName: name, returnType } = this;\n\n    const config = this.previousConfig;\n\n    const wordWrap = this.currentSnapshot ? 'on' : 'off';\n    const theme = this.getInitialColorTheme(config, this.currentSnapshot);\n\n    this.libCodingTestService.currentLanguage$.pipe(untilDestroyed(this)).subscribe((language: CodeEditorLanguages) => {\n      if (this.shouldGenerateInitCode) {\n        this.codeEditorService.setHelper(language, { params, name, returnType });\n        this.codeLanguage = this.codeEditorService.getEditorLang();\n      } else {\n        if (language === CodeEditorLanguages.Cpp) {\n          this.codeLanguage = CodeEditorLanguages.CppEditor;\n        } else if (language === CodeEditorLanguages.CSharp || language === CodeEditorLanguages.CSharpLegacy) {\n          this.codeLanguage = CodeEditorLanguages.CSharpEditor;\n        } else if (language === CodeEditorLanguages.Sqlite) {\n          this.codeLanguage = CodeEditorLanguages.Sql;\n        } else {\n          this.codeLanguage = language;\n        }\n      }\n      this.editorOptions = Object.assign({}, this.editorOptions, {\n        language: this.codeLanguage,\n      });\n    });\n\n    this.editorOptions = Object.assign({}, this.editorOptions, {\n      readOnly: this.isReadonly,\n      quickSuggestions: {\n        other: config[CodingAssistanceOptions.AutoComplete],\n      },\n      autoClosingBrackets: config[CodingAssistanceOptions.AutoBrackets] ? 'always' : 'never',\n      tabSize: config[FormattingOptions.TabSize],\n      fontSize: config[FormattingOptions.FontSize],\n      theme,\n      wordWrap,\n    });\n    const monacoLibraryReady$ = interval(100).pipe(\n      map(() => window.monaco),\n      filter(Boolean),\n      first()\n    );\n    combineLatest({\n      monaco: monacoLibraryReady$,\n      language: this.libCodingTestService.currentLanguage$,\n    })\n      .pipe(take(1))\n      .subscribe(result => {\n        if (result.language === CodeEditorLanguages.Javascript) {\n          result.monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({\n            noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n            noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n          });\n        } else if (result.language === CodeEditorLanguages.Typescript) {\n          result.monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({\n            noSemanticValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n            noSyntaxValidation: !config[CodingAssistanceOptions.ErrorHighlighting],\n          });\n        }\n        result.monaco.languages.register({ id: CodeEditorLanguages.Erlang });\n        result.monaco.languages.setMonarchTokensProvider(CodeEditorLanguages.Erlang, erlangLanguage);\n      });\n  }\n\n  private getInitialColorTheme(config: Config, snapshot: CodingSnapshot): string {\n    let theme: MonacoColorTheme;\n\n    if (snapshot) {\n      theme = MonacoColorTheme.Dark;\n    } else {\n      theme = config[FormattingOptions.ColorTheme] === Themes.Default ? MonacoColorTheme.Light : MonacoColorTheme.Dark;\n    }\n\n    return theme;\n  }\n\n  private setupCode(calledFromReset = false) {\n    this.handleInitCode(calledFromReset);\n    this.publishCode(this.code);\n  }\n\n  private handleInitCode(calledFromReset = false): void {\n    if (calledFromReset) {\n      this.code = this.libCodingTestService.getInitCode();\n    } else if (this.initCode) {\n      this.code = this.initCode;\n    } else if (this.currentSnapshot) {\n      return;\n    } else if (this.shouldGenerateInitCode) {\n      this.code = this.codeEditorService.getInitCode();\n    }\n  }\n\n  private listenUpdates(): void {\n    this.libCodingTestService.codeReset$\n      .pipe(\n        filter(val => val === ResetCodeAction.Confirm),\n        untilDestroyed(this)\n      )\n      .subscribe(() => {\n        this.setupCode(true);\n      });\n  }\n\n  private handleSnapshot(code: string): void {\n    this.code = code;\n\n    if (!this.editor) {\n      return;\n    }\n\n    this.editor.setValue(code); // make sure editor model has the latest value of the code\n\n    if (this.previousMonacoDecoration) {\n      this.previousMonacoDecoration.clear();\n    }\n\n    if (this.currentSnapshot.copied_text) {\n      // if the snapshot contains copyPasted code, find it's range in monaco\n      const matches = this.editor\n        .getModel()\n        .findMatches(this.currentSnapshot.copied_text, false, false, true, null, true);\n\n      if (matches.length) {\n        // if the range is found in editor model, decorate it with additional class to highlight on the ui\n        this.previousMonacoDecoration = this.editor.createDecorationsCollection([\n          {\n            range: matches[0].range,\n            options: { inlineClassName: 'copy-pasted-code' },\n          },\n        ]);\n      }\n    }\n  }\n}\n","<div class=\"container notranslate\" translate=\"no\">\n  <ngx-monaco-editor\n    #editor\n    class=\"editor\"\n    [options]=\"editorOptions\"\n    [(ngModel)]=\"code\"\n    (ngModelChange)=\"publishCode($event)\"\n    (onInit)=\"initEditor($event)\"\n  ></ngx-monaco-editor>\n</div>\n"]}

package/esm2022/lib/components/code-editor/code-editor.service.mjs

@@ -0,0 +1,72 @@
+import { Injectable } from '@angular/core';
+import { CodeEditorCHelper, CodeEditorCppHelper, CodeEditorCSharpHelper, CodeEditorGoHelper, CodeEditorJavaHelper, CodeEditorJavascriptHelper, CodeEditorKotlinHelper, CodeEditorPhpHelper, CodeEditorPythonHelper, CodeEditorRHelper, CodeEditorRubyHelper, CodeEditorScalaHelper, CodeEditorSqlHelper, CodeEditorSwiftHelper, CodeEditorTypescriptHelper, } from './helpers';
+import * as i0 from "@angular/core";
+export class CodeEditorService {
+    helper;
+    setHelper(language, funcParams) {
+        this.helper = this.createHelper(language, funcParams);
+    }
+    getInitCode() {
+        return this.helper.getInitCode();
+    }
+    getEditorLang() {
+        return this.helper.getEditorLang();
+    }
+    createHelper(lang, funcParams) {
+        // todo: review this logic according to new TAT, remove generated init code if not needed ?
+        switch (lang) {
+            case "javascript" /* CodeEditorLanguages.Javascript */:
+                return new CodeEditorJavascriptHelper(funcParams);
+            case "typescript" /* CodeEditorLanguages.Typescript */:
+                return new CodeEditorTypescriptHelper(funcParams);
+            case "php" /* CodeEditorLanguages.Php */:
+                return new CodeEditorPhpHelper(funcParams);
+            case "python" /* CodeEditorLanguages.Python */:
+                return new CodeEditorPythonHelper(funcParams);
+            case "java" /* CodeEditorLanguages.Java */:
+                return new CodeEditorJavaHelper(funcParams);
+            case "ruby" /* CodeEditorLanguages.Ruby */:
+                return new CodeEditorRubyHelper(funcParams);
+            case "c" /* CodeEditorLanguages.C */:
+                return new CodeEditorCHelper(funcParams);
+            case "c++" /* CodeEditorLanguages.Cpp */:
+                return new CodeEditorCppHelper(funcParams);
+            case "r" /* CodeEditorLanguages.R */:
+                return new CodeEditorRHelper(funcParams);
+            case "scala" /* CodeEditorLanguages.Scala */:
+                return new CodeEditorScalaHelper(funcParams);
+            case "c#" /* CodeEditorLanguages.CSharp */:
+            case "c#_legacy" /* CodeEditorLanguages.CSharpLegacy */:
+                return new CodeEditorCSharpHelper(funcParams);
+            case "go" /* CodeEditorLanguages.Go */:
+                return new CodeEditorGoHelper(funcParams);
+            case "sql" /* CodeEditorLanguages.Sql */:
+            case "sqlite3" /* CodeEditorLanguages.Sqlite */:
+                return new CodeEditorSqlHelper(funcParams);
+            default: {
+                const versionedHelper = lang && this.getVersionedHelper(lang, funcParams);
+                if (!versionedHelper) {
+                    throw new Error(`language ${lang} is not supported`);
+                }
+                return versionedHelper;
+            }
+        }
+    }
+    getVersionedHelper(lang, funcParams) {
+        if (lang.startsWith("kotlin" /* CodeEditorLanguages.Kotlin */)) {
+            return new CodeEditorKotlinHelper(funcParams);
+        }
+        if (lang.startsWith("swift" /* CodeEditorLanguages.Swift */)) {
+            return new CodeEditorSwiftHelper(funcParams);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodeEditorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodeEditorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CodeEditorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/code-editor/helpers/c-helper.mjs

@@ -0,0 +1,40 @@
+import { CodeEditorHelperBase } from './code-editor-helper.base';
+export class CodeEditorCHelper extends CodeEditorHelperBase {
+    functionOptions;
+    language = "c" /* CodeEditorLanguages.C */;
+    typesMap = {
+        boolean: 'bool',
+        int: 'int',
+        number: 'int',
+        double: 'double',
+        float: 'float',
+        str: 'char *',
+        array_boolean: 'bool *',
+        array_int: 'int *',
+        array_float: 'float *',
+        array_double: 'double *',
+    };
+    constructor(functionOptions) {
+        super();
+        this.functionOptions = functionOptions;
+    }
+    getInitCode() {
+        return `${this.getFunctionOpening()}\t //Insert your code here \n}`;
+    }
+    getFunctionOpening() {
+        const { name: funcName, returnType } = this.functionOptions;
+        const params = this.getParamsString();
+        const showingReturnType = this.parseType(returnType);
+        return `${showingReturnType} ${funcName}(${params}) {\n`;
+    }
+    getParamsString() {
+        const { params } = this.functionOptions;
+        let paramsString = '';
+        if (params && params.length > 0) {
+            params.forEach(values => (paramsString += `${this.parseType(values.type)} ${values.name}, `));
+            paramsString = paramsString.slice(0, -2);
+        }
+        return paramsString;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYy1oZWxwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy90Z28tY29kaW5nLXRlc3Qvc3JjL2xpYi9jb21wb25lbnRzL2NvZGUtZWRpdG9yL2hlbHBlcnMvYy1oZWxwZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFRakUsTUFBTSxPQUFPLGlCQUFrQixTQUFRLG9CQUFvQjtJQWVyQztJQWRwQixRQUFRLG1DQUF5QjtJQUNqQyxRQUFRLEdBQXVCO1FBQzdCLE9BQU8sRUFBRSxNQUFNO1FBQ2YsR0FBRyxFQUFFLEtBQUs7UUFDVixNQUFNLEVBQUUsS0FBSztRQUNiLE1BQU0sRUFBRSxRQUFRO1FBQ2hCLEtBQUssRUFBRSxPQUFPO1FBQ2QsR0FBRyxFQUFFLFFBQVE7UUFDYixhQUFhLEVBQUUsUUFBUTtRQUN2QixTQUFTLEVBQUUsT0FBTztRQUNsQixXQUFXLEVBQUUsU0FBUztRQUN0QixZQUFZLEVBQUUsVUFBVTtLQUN6QixDQUFDO0lBRUYsWUFBb0IsZUFBc0M7UUFDeEQsS0FBSyxFQUFFLENBQUM7UUFEVSxvQkFBZSxHQUFmLGVBQWUsQ0FBdUI7SUFFMUQsQ0FBQztJQUVELFdBQVc7UUFDVCxPQUFPLEdBQUcsSUFBSSxDQUFDLGtCQUFrQixFQUFFLGdDQUFnQyxDQUFDO0lBQ3RFLENBQUM7SUFFRCxrQkFBa0I7UUFDaEIsTUFBTSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQztRQUM1RCxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDdEMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBRXJELE9BQU8sR0FBRyxpQkFBaUIsSUFBSSxRQUFRLElBQUksTUFBTSxPQUFPLENBQUM7SUFDM0QsQ0FBQztJQUVPLGVBQWU7UUFDckIsTUFBTSxFQUFFLE1BQU0sRUFBRSxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUM7UUFDeEMsSUFBSSxZQUFZLEdBQUcsRUFBRSxDQUFDO1FBRXRCLElBQUksTUFBTSxJQUFJLE1BQU0sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDaEMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsWUFBWSxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLElBQUksTUFBTSxDQUFDLElBQUksSUFBSSxDQUFDLENBQUMsQ0FBQztZQUM5RixZQUFZLEdBQUcsWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUMzQyxDQUFDO1FBRUQsT0FBTyxZQUFZLENBQUM7SUFDdEIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29kZUVkaXRvckhlbHBlckJhc2UgfSBmcm9tICcuL2NvZGUtZWRpdG9yLWhlbHBlci5iYXNlJztcbmltcG9ydCB7XG4gIENvZGVFZGl0b3JGdW5jT3B0aW9ucyxcbiAgQ29kZUVkaXRvckhlbHBlcixcbiAgQ29kZUVkaXRvckxhbmd1YWdlcyxcbiAgQ29kZUVkaXRvclR5cGVzTWFwLFxufSBmcm9tICcuL2NvZGUtZWRpdG9yLWhlbHBlci5tb2RlbCc7XG5cbmV4cG9ydCBjbGFzcyBDb2RlRWRpdG9yQ0hlbHBlciBleHRlbmRzIENvZGVFZGl0b3JIZWxwZXJCYXNlIGltcGxlbWVudHMgQ29kZUVkaXRvckhlbHBlciB7XG4gIGxhbmd1YWdlID0gQ29kZUVkaXRvckxhbmd1YWdlcy5DO1xuICB0eXBlc01hcDogQ29kZUVkaXRvclR5cGVzTWFwID0ge1xuICAgIGJvb2xlYW46ICdib29sJyxcbiAgICBpbnQ6ICdpbnQnLFxuICAgIG51bWJlcjogJ2ludCcsXG4gICAgZG91YmxlOiAnZG91YmxlJyxcbiAgICBmbG9hdDogJ2Zsb2F0JyxcbiAgICBzdHI6ICdjaGFyIConLFxuICAgIGFycmF5X2Jvb2xlYW46ICdib29sIConLFxuICAgIGFycmF5X2ludDogJ2ludCAqJyxcbiAgICBhcnJheV9mbG9hdDogJ2Zsb2F0IConLFxuICAgIGFycmF5X2RvdWJsZTogJ2RvdWJsZSAqJyxcbiAgfTtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGZ1bmN0aW9uT3B0aW9uczogQ29kZUVkaXRvckZ1bmNPcHRpb25zKSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuXG4gIGdldEluaXRDb2RlKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIGAke3RoaXMuZ2V0RnVuY3Rpb25PcGVuaW5nKCl9XFx0IC8vSW5zZXJ0IHlvdXIgY29kZSBoZXJlIFxcbn1gO1xuICB9XG5cbiAgZ2V0RnVuY3Rpb25PcGVuaW5nKCk6IHN0cmluZyB7XG4gICAgY29uc3QgeyBuYW1lOiBmdW5jTmFtZSwgcmV0dXJuVHlwZSB9ID0gdGhpcy5mdW5jdGlvbk9wdGlvbnM7XG4gICAgY29uc3QgcGFyYW1zID0gdGhpcy5nZXRQYXJhbXNTdHJpbmcoKTtcbiAgICBjb25zdCBzaG93aW5nUmV0dXJuVHlwZSA9IHRoaXMucGFyc2VUeXBlKHJldHVyblR5cGUpO1xuXG4gICAgcmV0dXJuIGAke3Nob3dpbmdSZXR1cm5UeXBlfSAke2Z1bmNOYW1lfSgke3BhcmFtc30pIHtcXG5gO1xuICB9XG5cbiAgcHJpdmF0ZSBnZXRQYXJhbXNTdHJpbmcoKTogc3RyaW5nIHtcbiAgICBjb25zdCB7IHBhcmFtcyB9ID0gdGhpcy5mdW5jdGlvbk9wdGlvbnM7XG4gICAgbGV0IHBhcmFtc1N0cmluZyA9ICcnO1xuXG4gICAgaWYgKHBhcmFtcyAmJiBwYXJhbXMubGVuZ3RoID4gMCkge1xuICAgICAgcGFyYW1zLmZvckVhY2godmFsdWVzID0+IChwYXJhbXNTdHJpbmcgKz0gYCR7dGhpcy5wYXJzZVR5cGUodmFsdWVzLnR5cGUpfSAke3ZhbHVlcy5uYW1lfSwgYCkpO1xuICAgICAgcGFyYW1zU3RyaW5nID0gcGFyYW1zU3RyaW5nLnNsaWNlKDAsIC0yKTtcbiAgICB9XG5cbiAgICByZXR1cm4gcGFyYW1zU3RyaW5nO1xuICB9XG59XG4iXX0=

package/esm2022/lib/components/code-editor/helpers/code-editor-helper.base.mjs

@@ -0,0 +1,11 @@
+export class CodeEditorHelperBase {
+    language;
+    typesMap;
+    getEditorLang() {
+        return this.language;
+    }
+    parseType(type) {
+        return this.typesMap[type];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZS1lZGl0b3ItaGVscGVyLmJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy90Z28tY29kaW5nLXRlc3Qvc3JjL2xpYi9jb21wb25lbnRzL2NvZGUtZWRpdG9yL2hlbHBlcnMvY29kZS1lZGl0b3ItaGVscGVyLmJhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFnQixvQkFBb0I7SUFDOUIsUUFBUSxDQUFzQjtJQUM5QixRQUFRLENBQXFCO0lBSXZDLGFBQWE7UUFDWCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUM7SUFDdkIsQ0FBQztJQUVTLFNBQVMsQ0FBQyxJQUE4QjtRQUNoRCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDN0IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29kZUVkaXRvckxhbmd1YWdlcywgQ29kZUVkaXRvclR5cGVzTWFwIH0gZnJvbSAnLi9jb2RlLWVkaXRvci1oZWxwZXIubW9kZWwnO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQ29kZUVkaXRvckhlbHBlckJhc2Uge1xuICBwcm90ZWN0ZWQgbGFuZ3VhZ2U6IENvZGVFZGl0b3JMYW5ndWFnZXM7XG4gIHByb3RlY3RlZCB0eXBlc01hcDogQ29kZUVkaXRvclR5cGVzTWFwO1xuXG4gIGFic3RyYWN0IGdldEZ1bmN0aW9uT3BlbmluZygpOiBzdHJpbmc7XG5cbiAgZ2V0RWRpdG9yTGFuZygpOiBDb2RlRWRpdG9yTGFuZ3VhZ2VzIHtcbiAgICByZXR1cm4gdGhpcy5sYW5ndWFnZTtcbiAgfVxuXG4gIHByb3RlY3RlZCBwYXJzZVR5cGUodHlwZToga2V5b2YgQ29kZUVkaXRvclR5cGVzTWFwKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy50eXBlc01hcFt0eXBlXTtcbiAgfVxufVxuIl19