@cqa-lib/cqa-ui 1.1.333 → 1.1.335

package/esm2020/lib/code-editor/code-editor.component.mjs

@@ -0,0 +1,267 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { CODE_EDITOR_STYLES } from './code-editor.styles';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-monaco-editor";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+/** Maps custom code step language values to Monaco editor language IDs */
+export const MONACO_LANGUAGE_MAP = {
+    javascript: 'javascript',
+    typescript: 'typescript',
+    python: 'python',
+    java: 'java',
+    ruby: 'ruby',
+    go: 'go',
+    rust: 'rust',
+    csharp: 'csharp',
+};
+export class CodeEditorComponent {
+    constructor() {
+        this.value = '';
+        this.language = 'javascript';
+        this.label = '';
+        this.required = false;
+        this.placeholder = '// Write your code here...';
+        this.fullWidth = true;
+        this.ariaLabel = '';
+        this.minHeight = '200px';
+        this.readOnly = false;
+        /** External error messages (e.g. from form validation). Shown alongside syntax errors. */
+        this.errors = [];
+        /** When true, use a plain textarea instead of Monaco (e.g. for Storybook where Monaco may not load) */
+        this.useFallback = false;
+        this.valueChange = new EventEmitter();
+        this.validationChange = new EventEmitter();
+        this.blur = new EventEmitter();
+        this.codeValue = '';
+        this.validationErrors = [];
+        this.editorOptions = {};
+        this.editorInstance = null;
+        this.markersSubscription = null;
+        this.fallbackSyntaxTimer = null;
+        this.monacoMarkersTimer = null;
+    }
+    ngOnInit() {
+        this.codeValue = this.value ?? '';
+        this.updateEditorOptions();
+        if (this.useFallback && ['javascript', 'typescript'].includes(this.language)) {
+            this.scheduleFallbackSyntaxCheck(this.codeValue);
+        }
+    }
+    ngOnDestroy() {
+        if (this.fallbackSyntaxTimer)
+            clearTimeout(this.fallbackSyntaxTimer);
+        if (this.monacoMarkersTimer) {
+            clearTimeout(this.monacoMarkersTimer);
+            this.monacoMarkersTimer = null;
+        }
+        this.markersSubscription?.();
+    }
+    ngOnChanges(changes) {
+        if (changes['value'] && changes['value'].currentValue !== undefined) {
+            const newVal = changes['value'].currentValue ?? '';
+            // Only update when value actually changed - avoids overwriting user input during typing
+            if (newVal !== this.codeValue) {
+                this.codeValue = newVal;
+                if (this.useFallback && ['javascript', 'typescript'].includes(this.language)) {
+                    this.scheduleFallbackSyntaxCheck(newVal);
+                }
+            }
+        }
+        // Only update editor options when language or readOnly changes - value changes must NOT
+        // recreate editorOptions or ngx-monaco-editor will re-init and dispose the editor,
+        // causing "Canceled" errors from Monaco's async operations (word highlighting, etc.)
+        if (changes['language'] || changes['readOnly']) {
+            this.updateEditorOptions();
+        }
+    }
+    updateEditorOptions() {
+        const monacoLang = MONACO_LANGUAGE_MAP[this.language] || this.language || 'plaintext';
+        const hasDiagnostics = ['javascript', 'typescript'].includes(monacoLang);
+        this.editorOptions = {
+            theme: 'vs',
+            language: monacoLang,
+            minimap: { enabled: false },
+            scrollBeyondLastLine: false,
+            automaticLayout: true,
+            fontSize: 13,
+            lineNumbers: 'on',
+            roundedSelection: false,
+            readOnly: this.readOnly,
+            cursorStyle: 'line',
+            wordWrap: 'on',
+            // useWorker: false - Monaco workers require AMD loader (define) which fails in
+            // bundled environments (Storybook, some webpack setups). Running in main thread
+            // avoids "define is not defined" and worker creation errors.
+            ...(hasDiagnostics ? { quickSuggestions: true } : {}),
+            useWorker: false,
+        };
+    }
+    onCodeChange(newValue) {
+        this.codeValue = newValue;
+        this.valueChange.emit(newValue);
+        if (!this.useFallback && ['javascript', 'typescript'].includes(this.language)) {
+            this.scheduleFallbackSyntaxCheck(newValue);
+        }
+    }
+    onFallbackInput(event) {
+        const target = event.target;
+        const newValue = target?.value ?? '';
+        this.codeValue = newValue;
+        this.valueChange.emit(newValue);
+        if (['javascript', 'typescript'].includes(this.language)) {
+            this.scheduleFallbackSyntaxCheck(newValue);
+        }
+    }
+    /** Debounced syntax check for fallback mode - avoids running on every keystroke */
+    scheduleFallbackSyntaxCheck(code) {
+        if (this.fallbackSyntaxTimer)
+            clearTimeout(this.fallbackSyntaxTimer);
+        this.fallbackSyntaxTimer = setTimeout(() => {
+            this.fallbackSyntaxTimer = null;
+            this.checkFallbackSyntax(code);
+        }, 300);
+    }
+    /** Syntax validation for fallback (textarea) mode - JS/TS only */
+    checkFallbackSyntax(code) {
+        if (!['javascript', 'typescript'].includes(this.language)) {
+            this.validationErrors = [];
+            this.validationChange.emit(this.validationErrors);
+            return;
+        }
+        if (!code || !code.trim()) {
+            this.validationErrors = [];
+            this.validationChange.emit(this.validationErrors);
+            return;
+        }
+        try {
+            new Function(code);
+            this.validationErrors = [];
+        }
+        catch (e) {
+            if (e instanceof SyntaxError) {
+                const err = e;
+                const line = err.lineNumber ?? 1;
+                this.validationErrors = [{
+                        message: err.message || 'Syntax error',
+                        severity: 'error',
+                        lineNumber: line,
+                        column: err.columnNumber,
+                    }];
+            }
+            else {
+                this.validationErrors = [];
+            }
+        }
+        this.validationChange.emit(this.validationErrors);
+    }
+    onEditorInit(editor) {
+        this.editorInstance = editor;
+        this.setupMarkersListener(editor);
+        editor.onDidBlurEditorWidget?.(() => this.blur.emit());
+        if (['javascript', 'typescript'].includes(this.language)) {
+            this.scheduleFallbackSyntaxCheck(this.codeValue);
+        }
+    }
+    setupMarkersListener(editor) {
+        this.markersSubscription?.();
+        const model = editor.getModel?.();
+        if (!model?.uri)
+            return;
+        const win = window;
+        const checkMarkers = () => {
+            try {
+                if (!win.monaco?.editor?.getModelMarkers)
+                    return;
+                const markers = win.monaco.editor.getModelMarkers({ resource: model.uri }) || [];
+                const monacoErrors = markers
+                    .filter((m) => m.severity === 8) // 8 = Error in Monaco
+                    .map((m) => ({
+                    message: m.message || 'Syntax error',
+                    severity: 'error',
+                    lineNumber: m.startLineNumber || 1,
+                    column: m.startColumn,
+                }));
+                // Only update from Monaco when it has markers - otherwise keep fallback results
+                // (Monaco may not produce markers when useWorker: false in bundled environments)
+                if (monacoErrors.length > 0) {
+                    this.validationErrors = monacoErrors;
+                    this.validationChange.emit(this.validationErrors);
+                }
+            }
+            catch {
+                // Monaco may not be loaded yet
+            }
+        };
+        const disposeMarkers = win.monaco?.editor?.onDidChangeMarkers?.(() => {
+            checkMarkers();
+        });
+        const scheduleCheckMarkers = () => {
+            if (this.monacoMarkersTimer)
+                clearTimeout(this.monacoMarkersTimer);
+            this.monacoMarkersTimer = setTimeout(() => {
+                this.monacoMarkersTimer = null;
+                checkMarkers();
+            }, 400);
+        };
+        editor.onDidChangeModelContent?.(scheduleCheckMarkers);
+        setTimeout(checkMarkers, 600);
+        this.markersSubscription = () => {
+            if (this.monacoMarkersTimer) {
+                clearTimeout(this.monacoMarkersTimer);
+                this.monacoMarkersTimer = null;
+            }
+            disposeMarkers?.dispose?.();
+        };
+    }
+    get hasValidationErrors() {
+        return this.validationErrors.length > 0;
+    }
+    get hasErrors() {
+        return (this.errors?.length ?? 0) > 0 || this.hasValidationErrors;
+    }
+    /** All error messages: external errors + syntax errors formatted as strings */
+    get allErrorMessages() {
+        const external = this.errors ?? [];
+        const syntax = this.validationErrors.map((e) => `Line ${e.lineNumber}: ${e.message}`);
+        return [...external, ...syntax];
+    }
+}
+CodeEditorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CodeEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CodeEditorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: CodeEditorComponent, selector: "cqa-code-editor", inputs: { value: "value", language: "language", label: "label", required: "required", placeholder: "placeholder", fullWidth: "fullWidth", ariaLabel: "ariaLabel", minHeight: "minHeight", readOnly: "readOnly", errors: "errors", useFallback: "useFallback" }, outputs: { valueChange: "valueChange", validationChange: "validationChange", blur: "blur" }, host: { classAttribute: "cqa-ui-root" }, viewQueries: [{ propertyName: "monacoEditorRef", first: true, predicate: ["monacoEditor"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div class=\"cqa-flex cqa-flex-col cqa-w-full\" [style.width]=\"fullWidth ? '100%' : 'auto'\">\n  <label\n    *ngIf=\"label\"\n    class=\"cqa-leading-[100%] cqa-block cqa-text-[12px] cqa-font-medium cqa-text-[#161617] cqa-mb-1\">\n    {{ label }}\n    <span *ngIf=\"required\" class=\"cqa-text-[#EF4444] cqa-ml-0.5\">*</span>\n  </label>\n\n  <!-- Fallback: plain textarea when Monaco is not available (e.g. Storybook) -->\n  <div\n    *ngIf=\"useFallback\"\n    class=\"cqa-code-editor-container cqa-code-editor-fallback cqa-w-full\"\n    [class.cqa-has-errors]=\"hasErrors\"\n    [style.height]=\"minHeight\"\n    [style.min-height]=\"minHeight\">\n    <textarea\n      class=\"cqa-code-editor-textarea\"\n      [value]=\"codeValue\"\n      (input)=\"onFallbackInput($event)\"\n      (blur)=\"blur.emit()\"\n      [placeholder]=\"placeholder\"\n      [readonly]=\"readOnly\"\n      [attr.aria-label]=\"ariaLabel || label || 'Code editor'\"\n      [attr.aria-invalid]=\"hasErrors\"\n      [attr.aria-required]=\"required\">\n    </textarea>\n  </div>\n  <!-- Monaco editor (used in main app) -->\n  <div\n    *ngIf=\"!useFallback\"\n    class=\"cqa-code-editor-container cqa-w-full\"\n    [class.cqa-has-errors]=\"hasErrors\"\n    [style.height]=\"minHeight\"\n    [style.min-height]=\"minHeight\">\n    <ngx-monaco-editor\n      #monacoEditor\n      class=\"cqa-monaco-editor\"\n      [options]=\"editorOptions\"\n      [ngModel]=\"codeValue\"\n      (ngModelChange)=\"onCodeChange($event)\"\n      (onInit)=\"onEditorInit($event)\">\n    </ngx-monaco-editor>\n  </div>\n\n  <!-- Error messages (same style as custom-textarea) -->\n  <div *ngIf=\"hasErrors\" class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-mt-1.5\">\n    <div *ngFor=\"let error of allErrorMessages\" class=\"cqa-flex cqa-items-start cqa-gap-1.5\">\n      <svg\n        xmlns=\"http://www.w3.org/2000/svg\"\n        width=\"14\"\n        height=\"14\"\n        viewBox=\"0 0 14 14\"\n        fill=\"none\"\n        class=\"cqa-flex-shrink-0 cqa-mt-0.5\">\n        <path d=\"M7 1.75C4.1 1.75 1.75 4.1 1.75 7C1.75 9.9 4.1 12.25 7 12.25C9.9 12.25 12.25 9.9 12.25 7C12.25 4.1 9.9 1.75 7 1.75ZM7 9.625C6.65625 9.625 6.375 9.34375 6.375 9V7C6.375 6.65625 6.65625 6.375 7 6.375C7.34375 6.375 7.625 6.65625 7.625 7V9C7.625 9.34375 7.34375 9.625 7 9.625ZM7.625 5.25H6.375V4H7.625V5.25Z\" fill=\"#EF4444\"/>\n      </svg>\n      <span class=\"cqa-text-xs cqa-text-[#EF4444] cqa-font-medium cqa-leading-[18px]\">\n        {{ error }}\n      </span>\n    </div>\n  </div>\n</div>\n", styles: [".cqa-code-editor-container{min-height:200px;height:200px;border:1px solid #e5e7eb;border-radius:6px;overflow:hidden;display:flex;flex-direction:column;background:#fff;transition:border-color .2s,box-shadow .2s}.cqa-code-editor-container:focus-within{border-color:#3b82f6;box-shadow:0 0 0 1px #3b82f6}.cqa-code-editor-container.cqa-has-errors{border-color:#ef4444}.cqa-code-editor-container.cqa-has-errors:focus-within{border-color:#ef4444;box-shadow:0 0 0 1px #ef4444}.cqa-code-editor-container .cqa-monaco-editor,.cqa-code-editor-container ngx-monaco-editor{flex:1;min-height:0}.cqa-code-editor-container ::ng-deep .monaco-editor{height:100%!important}.cqa-code-editor-fallback .cqa-code-editor-textarea{width:100%;height:100%;min-height:180px;padding:12px;font-family:Monaco,Menlo,Ubuntu Mono,Consolas,monospace;font-size:13px;line-height:1.5;border:none;resize:none;outline:none;background:#fff;color:#0a0a0a}.cqa-code-editor-fallback .cqa-code-editor-textarea::placeholder{color:#9ca3af}\n"], components: [{ type: i1.EditorComponent, selector: "ngx-monaco-editor", inputs: ["options", "model"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: CodeEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cqa-code-editor', styles: [CODE_EDITOR_STYLES], host: { class: 'cqa-ui-root' }, template: "<div class=\"cqa-flex cqa-flex-col cqa-w-full\" [style.width]=\"fullWidth ? '100%' : 'auto'\">\n  <label\n    *ngIf=\"label\"\n    class=\"cqa-leading-[100%] cqa-block cqa-text-[12px] cqa-font-medium cqa-text-[#161617] cqa-mb-1\">\n    {{ label }}\n    <span *ngIf=\"required\" class=\"cqa-text-[#EF4444] cqa-ml-0.5\">*</span>\n  </label>\n\n  <!-- Fallback: plain textarea when Monaco is not available (e.g. Storybook) -->\n  <div\n    *ngIf=\"useFallback\"\n    class=\"cqa-code-editor-container cqa-code-editor-fallback cqa-w-full\"\n    [class.cqa-has-errors]=\"hasErrors\"\n    [style.height]=\"minHeight\"\n    [style.min-height]=\"minHeight\">\n    <textarea\n      class=\"cqa-code-editor-textarea\"\n      [value]=\"codeValue\"\n      (input)=\"onFallbackInput($event)\"\n      (blur)=\"blur.emit()\"\n      [placeholder]=\"placeholder\"\n      [readonly]=\"readOnly\"\n      [attr.aria-label]=\"ariaLabel || label || 'Code editor'\"\n      [attr.aria-invalid]=\"hasErrors\"\n      [attr.aria-required]=\"required\">\n    </textarea>\n  </div>\n  <!-- Monaco editor (used in main app) -->\n  <div\n    *ngIf=\"!useFallback\"\n    class=\"cqa-code-editor-container cqa-w-full\"\n    [class.cqa-has-errors]=\"hasErrors\"\n    [style.height]=\"minHeight\"\n    [style.min-height]=\"minHeight\">\n    <ngx-monaco-editor\n      #monacoEditor\n      class=\"cqa-monaco-editor\"\n      [options]=\"editorOptions\"\n      [ngModel]=\"codeValue\"\n      (ngModelChange)=\"onCodeChange($event)\"\n      (onInit)=\"onEditorInit($event)\">\n    </ngx-monaco-editor>\n  </div>\n\n  <!-- Error messages (same style as custom-textarea) -->\n  <div *ngIf=\"hasErrors\" class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-mt-1.5\">\n    <div *ngFor=\"let error of allErrorMessages\" class=\"cqa-flex cqa-items-start cqa-gap-1.5\">\n      <svg\n        xmlns=\"http://www.w3.org/2000/svg\"\n        width=\"14\"\n        height=\"14\"\n        viewBox=\"0 0 14 14\"\n        fill=\"none\"\n        class=\"cqa-flex-shrink-0 cqa-mt-0.5\">\n        <path d=\"M7 1.75C4.1 1.75 1.75 4.1 1.75 7C1.75 9.9 4.1 12.25 7 12.25C9.9 12.25 12.25 9.9 12.25 7C12.25 4.1 9.9 1.75 7 1.75ZM7 9.625C6.65625 9.625 6.375 9.34375 6.375 9V7C6.375 6.65625 6.65625 6.375 7 6.375C7.34375 6.375 7.625 6.65625 7.625 7V9C7.625 9.34375 7.34375 9.625 7 9.625ZM7.625 5.25H6.375V4H7.625V5.25Z\" fill=\"#EF4444\"/>\n      </svg>\n      <span class=\"cqa-text-xs cqa-text-[#EF4444] cqa-font-medium cqa-leading-[18px]\">\n        {{ error }}\n      </span>\n    </div>\n  </div>\n</div>\n" }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], language: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], fullWidth: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], errors: [{
+                type: Input
+            }], useFallback: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], validationChange: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }], monacoEditorRef: [{
+                type: ViewChild,
+                args: ['monacoEditor', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code-editor.component.js","sourceRoot":"","sources":["../../../../../src/lib/code-editor/code-editor.component.ts","../../../../../src/lib/code-editor/code-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { CODE_EDITOR_STYLES } from './code-editor.styles';\n\n/** Maps custom code step language values to Monaco editor language IDs */\nexport const MONACO_LANGUAGE_MAP: Record<string, string> = {\n  javascript: 'javascript',\n  typescript: 'typescript',\n  python: 'python',\n  java: 'java',\n  ruby: 'ruby',\n  go: 'go',\n  rust: 'rust',\n  csharp: 'csharp',\n};\n\nexport interface CodeEditorMarker {\n  message: string;\n  severity: 'error' | 'warning' | 'info';\n  lineNumber: number;\n  column?: number;\n}\n\n@Component({\n  selector: 'cqa-code-editor',\n  templateUrl: './code-editor.component.html',\n  styles: [CODE_EDITOR_STYLES],\n  host: { class: 'cqa-ui-root' },\n})\nexport class CodeEditorComponent implements OnInit, OnChanges, OnDestroy {\n  @Input() value = '';\n  @Input() language = 'javascript';\n  @Input() label = '';\n  @Input() required = false;\n  @Input() placeholder = '// Write your code here...';\n  @Input() fullWidth = true;\n  @Input() ariaLabel = '';\n  @Input() minHeight = '200px';\n  @Input() readOnly = false;\n  /** External error messages (e.g. from form validation). Shown alongside syntax errors. */\n  @Input() errors: string[] = [];\n  /** When true, use a plain textarea instead of Monaco (e.g. for Storybook where Monaco may not load) */\n  @Input() useFallback = false;\n\n  @Output() valueChange = new EventEmitter<string>();\n  @Output() validationChange = new EventEmitter<CodeEditorMarker[]>();\n  @Output() blur = new EventEmitter<void>();\n\n  @ViewChild('monacoEditor', { static: false }) monacoEditorRef: unknown;\n\n  codeValue = '';\n  validationErrors: CodeEditorMarker[] = [];\n  editorOptions: Record<string, unknown> = {};\n  private editorInstance: unknown = null;\n  private markersSubscription: (() => void) | null = null;\n  private fallbackSyntaxTimer: ReturnType<typeof setTimeout> | null = null;\n  private monacoMarkersTimer: ReturnType<typeof setTimeout> | null = null;\n\n  ngOnInit(): void {\n    this.codeValue = this.value ?? '';\n    this.updateEditorOptions();\n    if (this.useFallback && ['javascript', 'typescript'].includes(this.language)) {\n      this.scheduleFallbackSyntaxCheck(this.codeValue);\n    }\n  }\n\n  ngOnDestroy(): void {\n    if (this.fallbackSyntaxTimer) clearTimeout(this.fallbackSyntaxTimer);\n    if (this.monacoMarkersTimer) {\n      clearTimeout(this.monacoMarkersTimer);\n      this.monacoMarkersTimer = null;\n    }\n    this.markersSubscription?.();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['value'] && changes['value'].currentValue !== undefined) {\n      const newVal = changes['value'].currentValue ?? '';\n      // Only update when value actually changed - avoids overwriting user input during typing\n      if (newVal !== this.codeValue) {\n        this.codeValue = newVal;\n        if (this.useFallback && ['javascript', 'typescript'].includes(this.language)) {\n          this.scheduleFallbackSyntaxCheck(newVal);\n        }\n      }\n    }\n    // Only update editor options when language or readOnly changes - value changes must NOT\n    // recreate editorOptions or ngx-monaco-editor will re-init and dispose the editor,\n    // causing \"Canceled\" errors from Monaco's async operations (word highlighting, etc.)\n    if (changes['language'] || changes['readOnly']) {\n      this.updateEditorOptions();\n    }\n  }\n\n  private updateEditorOptions(): void {\n    const monacoLang = MONACO_LANGUAGE_MAP[this.language] || this.language || 'plaintext';\n    const hasDiagnostics = ['javascript', 'typescript'].includes(monacoLang);\n\n    this.editorOptions = {\n      theme: 'vs',\n      language: monacoLang,\n      minimap: { enabled: false },\n      scrollBeyondLastLine: false,\n      automaticLayout: true,\n      fontSize: 13,\n      lineNumbers: 'on',\n      roundedSelection: false,\n      readOnly: this.readOnly,\n      cursorStyle: 'line',\n      wordWrap: 'on',\n      // useWorker: false - Monaco workers require AMD loader (define) which fails in\n      // bundled environments (Storybook, some webpack setups). Running in main thread\n      // avoids \"define is not defined\" and worker creation errors.\n      ...(hasDiagnostics ? { quickSuggestions: true } : {}),\n      useWorker: false,\n    };\n  }\n\n  onCodeChange(newValue: string): void {\n    this.codeValue = newValue;\n    this.valueChange.emit(newValue);\n    if (!this.useFallback && ['javascript', 'typescript'].includes(this.language)) {\n      this.scheduleFallbackSyntaxCheck(newValue);\n    }\n  }\n\n  onFallbackInput(event: Event): void {\n    const target = event.target as HTMLTextAreaElement;\n    const newValue = target?.value ?? '';\n    this.codeValue = newValue;\n    this.valueChange.emit(newValue);\n    if (['javascript', 'typescript'].includes(this.language)) {\n      this.scheduleFallbackSyntaxCheck(newValue);\n    }\n  }\n\n  /** Debounced syntax check for fallback mode - avoids running on every keystroke */\n  private scheduleFallbackSyntaxCheck(code: string): void {\n    if (this.fallbackSyntaxTimer) clearTimeout(this.fallbackSyntaxTimer);\n    this.fallbackSyntaxTimer = setTimeout(() => {\n      this.fallbackSyntaxTimer = null;\n      this.checkFallbackSyntax(code);\n    }, 300);\n  }\n\n  /** Syntax validation for fallback (textarea) mode - JS/TS only */\n  private checkFallbackSyntax(code: string): void {\n    if (!['javascript', 'typescript'].includes(this.language)) {\n      this.validationErrors = [];\n      this.validationChange.emit(this.validationErrors);\n      return;\n    }\n    if (!code || !code.trim()) {\n      this.validationErrors = [];\n      this.validationChange.emit(this.validationErrors);\n      return;\n    }\n    try {\n      new Function(code);\n      this.validationErrors = [];\n    } catch (e) {\n      if (e instanceof SyntaxError) {\n        const err = e as SyntaxError & { lineNumber?: number; columnNumber?: number };\n        const line = err.lineNumber ?? 1;\n        this.validationErrors = [{\n          message: err.message || 'Syntax error',\n          severity: 'error',\n          lineNumber: line,\n          column: err.columnNumber,\n        }];\n      } else {\n        this.validationErrors = [];\n      }\n    }\n    this.validationChange.emit(this.validationErrors);\n  }\n\n  onEditorInit(editor: {\n    getModel?: () => { uri?: { toString?: () => string } };\n    onDidChangeModelContent?: (fn: () => void) => { dispose?: () => void };\n    onDidBlurEditorWidget?: (fn: () => void) => { dispose?: () => void };\n  }): void {\n    this.editorInstance = editor;\n    this.setupMarkersListener(editor);\n    editor.onDidBlurEditorWidget?.(() => this.blur.emit());\n    if (['javascript', 'typescript'].includes(this.language)) {\n      this.scheduleFallbackSyntaxCheck(this.codeValue);\n    }\n  }\n\n  private setupMarkersListener(editor: {\n    getModel?: () => { uri?: unknown };\n    onDidChangeModelContent?: (fn: () => void) => { dispose?: () => void };\n  }): void {\n    this.markersSubscription?.();\n\n    const model = editor.getModel?.();\n    if (!model?.uri) return;\n\n    const win = window as unknown as {\n      monaco?: {\n        editor?: {\n          getModelMarkers?: (filter: { resource?: unknown }) => Array<{\n            message?: string;\n            severity?: number;\n            startLineNumber?: number;\n            startColumn?: number;\n          }>;\n          onDidChangeMarkers?: (fn: (uris: unknown[]) => void) => { dispose?: () => void };\n        };\n      };\n    };\n\n    const checkMarkers = (): void => {\n      try {\n        if (!win.monaco?.editor?.getModelMarkers) return;\n        const markers = win.monaco.editor.getModelMarkers({ resource: model.uri }) || [];\n        const monacoErrors = markers\n          .filter((m) => m.severity === 8) // 8 = Error in Monaco\n          .map((m) => ({\n            message: m.message || 'Syntax error',\n            severity: 'error' as const,\n            lineNumber: m.startLineNumber || 1,\n            column: m.startColumn,\n          }));\n        // Only update from Monaco when it has markers - otherwise keep fallback results\n        // (Monaco may not produce markers when useWorker: false in bundled environments)\n        if (monacoErrors.length > 0) {\n          this.validationErrors = monacoErrors;\n          this.validationChange.emit(this.validationErrors);\n        }\n      } catch {\n        // Monaco may not be loaded yet\n      }\n    };\n\n    const disposeMarkers = win.monaco?.editor?.onDidChangeMarkers?.(() => {\n      checkMarkers();\n    });\n    const scheduleCheckMarkers = (): void => {\n      if (this.monacoMarkersTimer) clearTimeout(this.monacoMarkersTimer);\n      this.monacoMarkersTimer = setTimeout(() => {\n        this.monacoMarkersTimer = null;\n        checkMarkers();\n      }, 400);\n    };\n    editor.onDidChangeModelContent?.(scheduleCheckMarkers);\n    setTimeout(checkMarkers, 600);\n\n    this.markersSubscription = (): void => {\n      if (this.monacoMarkersTimer) {\n        clearTimeout(this.monacoMarkersTimer);\n        this.monacoMarkersTimer = null;\n      }\n      disposeMarkers?.dispose?.();\n    };\n  }\n\n  get hasValidationErrors(): boolean {\n    return this.validationErrors.length > 0;\n  }\n\n  get hasErrors(): boolean {\n    return (this.errors?.length ?? 0) > 0 || this.hasValidationErrors;\n  }\n\n  /** All error messages: external errors + syntax errors formatted as strings */\n  get allErrorMessages(): string[] {\n    const external = this.errors ?? [];\n    const syntax = this.validationErrors.map(\n      (e) => `Line ${e.lineNumber}: ${e.message}`\n    );\n    return [...external, ...syntax];\n  }\n}\n","<div class=\"cqa-flex cqa-flex-col cqa-w-full\" [style.width]=\"fullWidth ? '100%' : 'auto'\">\n  <label\n    *ngIf=\"label\"\n    class=\"cqa-leading-[100%] cqa-block cqa-text-[12px] cqa-font-medium cqa-text-[#161617] cqa-mb-1\">\n    {{ label }}\n    <span *ngIf=\"required\" class=\"cqa-text-[#EF4444] cqa-ml-0.5\">*</span>\n  </label>\n\n  <!-- Fallback: plain textarea when Monaco is not available (e.g. Storybook) -->\n  <div\n    *ngIf=\"useFallback\"\n    class=\"cqa-code-editor-container cqa-code-editor-fallback cqa-w-full\"\n    [class.cqa-has-errors]=\"hasErrors\"\n    [style.height]=\"minHeight\"\n    [style.min-height]=\"minHeight\">\n    <textarea\n      class=\"cqa-code-editor-textarea\"\n      [value]=\"codeValue\"\n      (input)=\"onFallbackInput($event)\"\n      (blur)=\"blur.emit()\"\n      [placeholder]=\"placeholder\"\n      [readonly]=\"readOnly\"\n      [attr.aria-label]=\"ariaLabel || label || 'Code editor'\"\n      [attr.aria-invalid]=\"hasErrors\"\n      [attr.aria-required]=\"required\">\n    </textarea>\n  </div>\n  <!-- Monaco editor (used in main app) -->\n  <div\n    *ngIf=\"!useFallback\"\n    class=\"cqa-code-editor-container cqa-w-full\"\n    [class.cqa-has-errors]=\"hasErrors\"\n    [style.height]=\"minHeight\"\n    [style.min-height]=\"minHeight\">\n    <ngx-monaco-editor\n      #monacoEditor\n      class=\"cqa-monaco-editor\"\n      [options]=\"editorOptions\"\n      [ngModel]=\"codeValue\"\n      (ngModelChange)=\"onCodeChange($event)\"\n      (onInit)=\"onEditorInit($event)\">\n    </ngx-monaco-editor>\n  </div>\n\n  <!-- Error messages (same style as custom-textarea) -->\n  <div *ngIf=\"hasErrors\" class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-mt-1.5\">\n    <div *ngFor=\"let error of allErrorMessages\" class=\"cqa-flex cqa-items-start cqa-gap-1.5\">\n      <svg\n        xmlns=\"http://www.w3.org/2000/svg\"\n        width=\"14\"\n        height=\"14\"\n        viewBox=\"0 0 14 14\"\n        fill=\"none\"\n        class=\"cqa-flex-shrink-0 cqa-mt-0.5\">\n        <path d=\"M7 1.75C4.1 1.75 1.75 4.1 1.75 7C1.75 9.9 4.1 12.25 7 12.25C9.9 12.25 12.25 9.9 12.25 7C12.25 4.1 9.9 1.75 7 1.75ZM7 9.625C6.65625 9.625 6.375 9.34375 6.375 9V7C6.375 6.65625 6.65625 6.375 7 6.375C7.34375 6.375 7.625 6.65625 7.625 7V9C7.625 9.34375 7.34375 9.625 7 9.625ZM7.625 5.25H6.375V4H7.625V5.25Z\" fill=\"#EF4444\"/>\n      </svg>\n      <span class=\"cqa-text-xs cqa-text-[#EF4444] cqa-font-medium cqa-leading-[18px]\">\n        {{ error }}\n      </span>\n    </div>\n  </div>\n</div>\n"]}

package/esm2020/lib/code-editor/code-editor.styles.mjs

@@ -0,0 +1,56 @@
+/**
+ * Code editor styles as a string for use in component `styles` arrays.
+ * Matches step-builder-custom-code form styling (custom-input, custom-textarea).
+ * Using a string constant avoids Angular's style compiler receiving non-string values
+ * (e.g. from styleUrls resolution in Storybook), which causes "input.match is not a function".
+ */
+export const CODE_EDITOR_STYLES = `
+.cqa-code-editor-container {
+  min-height: 200px;
+  height: 200px;
+  border: 1px solid #e5e7eb;
+  border-radius: 6px;
+  overflow: hidden;
+  display: flex;
+  flex-direction: column;
+  background: #fff;
+  transition: border-color 0.2s, box-shadow 0.2s;
+}
+.cqa-code-editor-container:focus-within {
+  border-color: #3b82f6;
+  box-shadow: 0 0 0 1px #3b82f6;
+}
+.cqa-code-editor-container.cqa-has-errors {
+  border-color: #ef4444;
+}
+.cqa-code-editor-container.cqa-has-errors:focus-within {
+  border-color: #ef4444;
+  box-shadow: 0 0 0 1px #ef4444;
+}
+.cqa-code-editor-container .cqa-monaco-editor,
+.cqa-code-editor-container ngx-monaco-editor {
+  flex: 1;
+  min-height: 0;
+}
+.cqa-code-editor-container ::ng-deep .monaco-editor {
+  height: 100% !important;
+}
+.cqa-code-editor-fallback .cqa-code-editor-textarea {
+  width: 100%;
+  height: 100%;
+  min-height: 180px;
+  padding: 12px;
+  font-family: Monaco, Menlo, "Ubuntu Mono", Consolas, monospace;
+  font-size: 13px;
+  line-height: 1.5;
+  border: none;
+  resize: none;
+  outline: none;
+  background: #fff;
+  color: #0a0a0a;
+}
+.cqa-code-editor-fallback .cqa-code-editor-textarea::placeholder {
+  color: #9ca3af;
+}
+`;
+//# sourceMappingURL=data:application/json;base64,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