@cqa-lib/cqa-ui 1.1.389 → 1.1.391

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

@@ -44,9 +44,9 @@ export class CodeEditorComponent {
     ngOnInit() {
         this.codeValue = this.value ?? '';
         this.updateEditorOptions();
-        if (this.useFallback && ['javascript', 'typescript'].includes(this.language)) {
-            this.scheduleFallbackSyntaxCheck(this.codeValue);
-        }
+        // if (this.useFallback && ['javascript', 'typescript'].includes(this.language)) {
+        //   this.scheduleFallbackSyntaxCheck(this.codeValue);
+        // }
     }
     ngOnDestroy() {
         if (this.fallbackSyntaxTimer)
@@ -61,12 +61,12 @@ export class CodeEditorComponent {
         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);
-                }
-            }
+            // 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,
@@ -80,7 +80,7 @@ export class CodeEditorComponent {
         const hasDiagnostics = ['javascript', 'typescript'].includes(monacoLang);
         this.editorOptions = {
             theme: 'vs',
-            language: monacoLang,
+            language: 'javascript',
             minimap: { enabled: false },
             scrollBeyondLastLine: false,
             automaticLayout: true,
@@ -94,24 +94,37 @@ export class CodeEditorComponent {
             // bundled environments (Storybook, some webpack setups). Running in main thread
             // avoids "define is not defined" and worker creation errors.
             ...(hasDiagnostics ? { quickSuggestions: true } : {}),
+            quickSuggestions: true,
+            suggestOnTriggerCharacters: true,
+            acceptSuggestionOnEnter: "on",
+            tabCompletion: "on",
+            wordBasedSuggestions: true,
+            parameterHints: {
+                enabled: true
+            },
+            // Disable TypeScript features
             useWorker: false,
+            // Disable TypeScript validation
+            validate: false,
+            // Disable TypeScript diagnostics
+            diagnostics: false
         };
     }
     onCodeChange(newValue) {
         this.codeValue = newValue;
         this.valueChange.emit(newValue);
-        if (!this.useFallback && ['javascript', 'typescript'].includes(this.language)) {
-            this.scheduleFallbackSyntaxCheck(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);
-        }
+        // if (['javascript', 'typescript'].includes(this.language)) {
+        //   this.scheduleFallbackSyntaxCheck(newValue);
+        // }
     }
     /** Debounced syntax check for fallback mode - avoids running on every keystroke */
     scheduleFallbackSyntaxCheck(code) {
@@ -135,7 +148,10 @@ export class CodeEditorComponent {
             return;
         }
         try {
-            new Function(code);
+            // Use AsyncFunction so that top-level `await` (valid in async contexts) is not
+            // flagged as a syntax error by the Function constructor.
+            const AsyncFunction = Object.getPrototypeOf(async function () { }).constructor;
+            new AsyncFunction(code);
             this.validationErrors = [];
         }
         catch (e) {
@@ -157,10 +173,45 @@ export class CodeEditorComponent {
     }
     onEditorInit(editor) {
         this.editorInstance = editor;
-        this.setupMarkersListener(editor);
+        // this.configureMonacoForAsyncCode();
+        // this.setupMarkersListener(editor);
         editor.onDidBlurEditorWidget?.(() => this.blur.emit());
-        if (['javascript', 'typescript'].includes(this.language)) {
-            this.scheduleFallbackSyntaxCheck(this.codeValue);
+        // if (['javascript', 'typescript'].includes(this.language)) {
+        //   this.scheduleFallbackSyntaxCheck(this.codeValue);
+        // }
+    }
+    /** Configure Monaco JS/TS language defaults to allow top-level await.
+     *  Sets module target to ESNext (enables top-level await as a module) and
+     *  suppresses error code 1308 ("await is only valid in async functions") which
+     *  Monaco incorrectly raises when code runs in an async context on the test runner. */
+    configureMonacoForAsyncCode() {
+        const win = window;
+        try {
+            const tsDefaults = win.monaco?.languages?.typescript;
+            if (!tsDefaults?.javascriptDefaults)
+                return;
+            const jsDefaults = tsDefaults.javascriptDefaults;
+            // Set module to ESNext so Monaco treats code as a module → top-level await is valid
+            if (jsDefaults.setCompilerOptions) {
+                jsDefaults.setCompilerOptions({
+                    ...(jsDefaults.getCompilerOptions?.() ?? {}),
+                    target: tsDefaults.ScriptTarget?.ESNext ?? 99,
+                    module: tsDefaults.ModuleKind?.ESNext ?? 99,
+                });
+            }
+            // Relax Monaco diagnostics so async snippets with top-level `await`
+            // (executed inside an async context in the runner) are not flagged.
+            if (jsDefaults.setDiagnosticsOptions) {
+                jsDefaults.setDiagnosticsOptions({
+                    // Disable semantic diagnostics (where TS1308 comes from) but keep
+                    // basic syntax highlighting/validation. Our own fallback checker
+                    // still validates syntax using AsyncFunction.
+                    noSemanticValidation: true,
+                });
+            }
+        }
+        catch {
+            // Monaco not available — safe to ignore
         }
     }
     setupMarkersListener(editor) {
@@ -264,4 +315,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                 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"]}
+//# 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: 'javascript',\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      quickSuggestions: true,\n      suggestOnTriggerCharacters: true,\n      acceptSuggestionOnEnter: \"on\",\n      tabCompletion: \"on\",\n      wordBasedSuggestions: true,\n      parameterHints: {\n        enabled: true\n      },\n      // Disable TypeScript features\n      useWorker: false,\n      // Disable TypeScript validation\n      validate: false,\n      // Disable TypeScript diagnostics\n      diagnostics: 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      // Use AsyncFunction so that top-level `await` (valid in async contexts) is not\n      // flagged as a syntax error by the Function constructor.\n      const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;\n      new AsyncFunction(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.configureMonacoForAsyncCode();\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  /** Configure Monaco JS/TS language defaults to allow top-level await.\n   *  Sets module target to ESNext (enables top-level await as a module) and\n   *  suppresses error code 1308 (\"await is only valid in async functions\") which\n   *  Monaco incorrectly raises when code runs in an async context on the test runner. */\n  private configureMonacoForAsyncCode(): void {\n    const win = window as unknown as {\n      monaco?: {\n        languages?: {\n          typescript?: {\n            javascriptDefaults?: {\n              setCompilerOptions?: (opts: Record<string, unknown>) => void;\n              getCompilerOptions?: () => Record<string, unknown>;\n              setDiagnosticsOptions?: (opts: Record<string, unknown>) => void;\n            };\n            ScriptTarget?: { ESNext?: number };\n            ModuleKind?: { ESNext?: number };\n          };\n        };\n      };\n    };\n    try {\n      const tsDefaults = win.monaco?.languages?.typescript;\n      if (!tsDefaults?.javascriptDefaults) return;\n      const jsDefaults = tsDefaults.javascriptDefaults;\n\n      // Set module to ESNext so Monaco treats code as a module → top-level await is valid\n      if (jsDefaults.setCompilerOptions) {\n        jsDefaults.setCompilerOptions({\n          ...(jsDefaults.getCompilerOptions?.() ?? {}),\n          target: tsDefaults.ScriptTarget?.ESNext ?? 99,\n          module: tsDefaults.ModuleKind?.ESNext ?? 99,\n        });\n      }\n\n      // Relax Monaco diagnostics so async snippets with top-level `await`\n      // (executed inside an async context in the runner) are not flagged.\n      if (jsDefaults.setDiagnosticsOptions) {\n        jsDefaults.setDiagnosticsOptions({\n          // Disable semantic diagnostics (where TS1308 comes from) but keep\n          // basic syntax highlighting/validation. Our own fallback checker\n          // still validates syntax using AsyncFunction.\n          noSemanticValidation: true,\n        });\n      }\n    } catch {\n      // Monaco not available — safe to ignore\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/error-modal/error-modal.component.mjs

@@ -1,7 +1,8 @@
 import { Component, Input, Output, EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
-import * as i1 from "../button/button.component";
-import * as i2 from "@angular/common";
+import * as i1 from "../badge/badge.component";
+import * as i2 from "../button/button.component";
+import * as i3 from "@angular/common";
 export class ErrorModalComponent {
     constructor() {
         this.isOpen = false;
@@ -13,6 +14,8 @@ export class ErrorModalComponent {
         this.appTime = '';
         this.toolTime = '';
         this.buttons = [];
+        /** When true, shows a loading badge instead of buttons (e.g. while waiting for async completion) */
+        this.showLoading = false;
         this.buttonClick = new EventEmitter();
         this.closeModal = new EventEmitter();
     }
@@ -24,6 +27,8 @@ export class ErrorModalComponent {
         }
     }
     onButtonClick(button) {
+        if (button.disabled)
+            return;
         this.buttonClick.emit(button.action);
     }
     onClose() {
@@ -46,10 +51,10 @@ export class ErrorModalComponent {
     }
 }
 ErrorModalComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ErrorModalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ErrorModalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: ErrorModalComponent, selector: "cqa-error-modal", inputs: { isOpen: "isOpen", title: "title", instructionalMessage: "instructionalMessage", errorMessage: "errorMessage", totalSteps: "totalSteps", completedSteps: "completedSteps", totalTime: "totalTime", appTime: "appTime", toolTime: "toolTime", buttons: "buttons" }, outputs: { buttonClick: "buttonClick", closeModal: "closeModal" }, ngImport: i0, template: "<div *ngIf=\"isOpen\"\n  class=\"modal-backdrop cqa-fixed cqa-inset-0 cqa-bg-black cqa-bg-opacity-50 cqa-z-[9999] cqa-flex cqa-items-center cqa-justify-center cqa-p-4\"\n  (click)=\"onBackdropClick($event)\">\n  <div\n    class=\"cqa-rounded-lg cqa-bg-white cqa-shadow-xl cqa-w-full cqa-max-w-[500px] cqa-overflow-hidden cqa-p-6 cqa-flex cqa-flex-col cqa-gap-2 cqa-max-h-[85vh] cqa-overflow-y-auto\"\n    style=\"box-shadow: 0px 8px 8px -4px #10182808;\" (click)=\"$event.stopPropagation()\">\n\n    <div class=\"cqa-flex cqa-flex-col cqa-items-center\">\n      <div>\n        <svg width=\"93\" height=\"93\" viewBox=\"0 0 93 93\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" fill=\"#F15F5F\"/>\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" stroke=\"#FCD9D9\" stroke-width=\"8\"/>\n          <path d=\"M32.3815 62.4437H60.619C63.5065 62.4437 65.3065 59.3125 63.8627 56.8188L49.744 32.425C48.3002 29.9313 44.7002 29.9313 43.2565 32.425L29.1377 56.8188C27.694 59.3125 29.494 62.4437 32.3815 62.4437ZM46.5002 49.3188C45.469 49.3188 44.6252 48.475 44.6252 47.4438V43.6938C44.6252 42.6625 45.469 41.8188 46.5002 41.8188C47.5315 41.8188 48.3752 42.6625 48.3752 43.6938V47.4438C48.3752 48.475 47.5315 49.3188 46.5002 49.3188ZM48.3752 56.8188H44.6252V53.0688H48.3752V56.8188Z\" fill=\"white\"/>\n          </svg>\n      </div>\n\n      <h2 class=\"cqa-text-[22px] cqa-font-semibold cqa-text-[#0B0B0C] cqa-mt-[20px] cqa-leading-[28px]\">\n        {{ title }}\n      </h2>\n\n      <!-- Instructional Message -->\n      <p *ngIf=\"instructionalMessage\" class=\"cqa-text-sm cqa-text-[#4A5565] cqa-mt-2 cqa-text-center\">\n        {{ instructionalMessage }}\n      </p>\n    </div>\n\n    <!-- <div *ngIf=\"hasTimingData\" class=\"cqa-rounded-lg cqa-border cqa-p-[17px] cqa-my-4\" [ngClass]=\"stepsBackgroundClass\"\n      style=\"border: 1px solid;\" [style.border-color]=\"stepsBorderClass\">\n      <div\n        class=\"cqa-grid sm:cqa-flex sm:cqa-justify-between sm:cqa-items-center cqa-grid-cols-2 sm:cqa-grid-cols-4 cqa-gap-4 sm:cqa-gap-2\">\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalSteps\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Steps</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ completedSteps }} / {{ totalSteps }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ totalTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"appTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">App Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ appTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"toolTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Tool Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ toolTime }}\n          </span>\n        </div>\n      </div>\n    </div> -->\n\n    <!-- Error Message Section -->\n    <div *ngIf=\"errorMessage\" class=\"cqa-my-4 cqa-p-4 cqa-rounded-lg cqa-bg-white\"\n      style=\"border: 1px solid #E5E7EB;\">\n      <div class=\"cqa-text-xs cqa-text-[#9CA3AF] cqa-mb-2 cqa-font-medium\">\n        Error Message\n      </div>\n      <div class=\"cqa-text-sm cqa-text-[#111827] cqa-font-semibold cqa-whitespace-normal cqa-break-anywhere\"\n        style=\"word-break: break-word; white-space: pre-line;\">\n        {{ errorMessage }}\n      </div>\n    </div>\n\n    <!-- Buttons -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-[20px]\">\n      <ng-container *ngFor=\"let button of buttons; let i = index\">\n        <cqa-button\n          [variant]=\"button.variant\"\n          [text]=\"button.label\"\n          [icon]=\"button.icon\"\n          [btnSize]=\"button.btnSize || 'lg'\"\n          [fullWidth]=\"button.fullWidth !== undefined ? button.fullWidth : true\"\n          (clicked)=\"onButtonClick(button)\">\n        </cqa-button>\n      </ng-container>\n    </div>\n  </div>\n</div>", components: [{ type: i1.ButtonComponent, selector: "cqa-button", inputs: ["variant", "btnSize", "disabled", "icon", "iconPosition", "fullWidth", "iconColor", "type", "text", "customClass", "inlineStyles", "tooltip", "tooltipPosition"], outputs: ["clicked"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+ErrorModalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: ErrorModalComponent, selector: "cqa-error-modal", inputs: { isOpen: "isOpen", title: "title", instructionalMessage: "instructionalMessage", errorMessage: "errorMessage", totalSteps: "totalSteps", completedSteps: "completedSteps", totalTime: "totalTime", appTime: "appTime", toolTime: "toolTime", buttons: "buttons", showLoading: "showLoading", loadingBadgeInlineStyles: "loadingBadgeInlineStyles" }, outputs: { buttonClick: "buttonClick", closeModal: "closeModal" }, ngImport: i0, template: "<div *ngIf=\"isOpen\"\n  class=\"modal-backdrop cqa-fixed cqa-inset-0 cqa-bg-black cqa-bg-opacity-50 cqa-z-[9999] cqa-flex cqa-items-center cqa-justify-center cqa-p-4\"\n  (click)=\"onBackdropClick($event)\">\n  <div\n    class=\"cqa-rounded-lg cqa-bg-white cqa-shadow-xl cqa-w-full cqa-max-w-[500px] cqa-overflow-hidden cqa-p-6 cqa-flex cqa-flex-col cqa-gap-2 cqa-max-h-[85vh] cqa-overflow-y-auto\"\n    style=\"box-shadow: 0px 8px 8px -4px #10182808;\" (click)=\"$event.stopPropagation()\">\n\n    <div class=\"cqa-flex cqa-flex-col cqa-items-center\">\n      <div>\n        <svg width=\"93\" height=\"93\" viewBox=\"0 0 93 93\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" fill=\"#F15F5F\"/>\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" stroke=\"#FCD9D9\" stroke-width=\"8\"/>\n          <path d=\"M32.3815 62.4437H60.619C63.5065 62.4437 65.3065 59.3125 63.8627 56.8188L49.744 32.425C48.3002 29.9313 44.7002 29.9313 43.2565 32.425L29.1377 56.8188C27.694 59.3125 29.494 62.4437 32.3815 62.4437ZM46.5002 49.3188C45.469 49.3188 44.6252 48.475 44.6252 47.4438V43.6938C44.6252 42.6625 45.469 41.8188 46.5002 41.8188C47.5315 41.8188 48.3752 42.6625 48.3752 43.6938V47.4438C48.3752 48.475 47.5315 49.3188 46.5002 49.3188ZM48.3752 56.8188H44.6252V53.0688H48.3752V56.8188Z\" fill=\"white\"/>\n          </svg>\n      </div>\n\n      <h2 class=\"cqa-text-[22px] cqa-font-semibold cqa-text-[#0B0B0C] cqa-mt-[20px] cqa-leading-[28px]\">\n        {{ title }}\n      </h2>\n\n      <!-- Instructional Message -->\n      <p *ngIf=\"instructionalMessage\" class=\"cqa-text-sm cqa-text-[#4A5565] cqa-mt-2 cqa-text-center\">\n        {{ instructionalMessage }}\n      </p>\n    </div>\n\n    <!-- <div *ngIf=\"hasTimingData\" class=\"cqa-rounded-lg cqa-border cqa-p-[17px] cqa-my-4\" [ngClass]=\"stepsBackgroundClass\"\n      style=\"border: 1px solid;\" [style.border-color]=\"stepsBorderClass\">\n      <div\n        class=\"cqa-grid sm:cqa-flex sm:cqa-justify-between sm:cqa-items-center cqa-grid-cols-2 sm:cqa-grid-cols-4 cqa-gap-4 sm:cqa-gap-2\">\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalSteps\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Steps</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ completedSteps }} / {{ totalSteps }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ totalTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"appTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">App Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ appTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"toolTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Tool Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ toolTime }}\n          </span>\n        </div>\n      </div>\n    </div> -->\n\n    <!-- Error Message Section -->\n    <div *ngIf=\"errorMessage\" class=\"cqa-my-4 cqa-p-4 cqa-rounded-lg cqa-bg-white\"\n      style=\"border: 1px solid #E5E7EB;\">\n      <div class=\"cqa-text-xs cqa-text-[#9CA3AF] cqa-mb-2 cqa-font-medium\">\n        Error Message\n      </div>\n      <div class=\"cqa-text-sm cqa-text-[#111827] cqa-font-semibold cqa-whitespace-normal cqa-break-anywhere\"\n        style=\"word-break: break-word; white-space: pre-line;\">\n        {{ errorMessage }}\n      </div>\n    </div>\n\n    <!-- Buttons (or loading badge when showLoading) -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-[20px]\">\n      <cqa-badge\n        *ngIf=\"showLoading\"\n        label=\"Updating Steps..\"\n        icon=\"autorenew\"\n        [isLoading]=\"true\"\n        [fullWidth]=\"true\"\n        [centerContent]=\"true\"\n        variant=\"info\"\n        size=\"medium\"\n        [inlineStyles]=\"loadingBadgeInlineStyles\">\n      </cqa-badge>\n      <ng-container *ngIf=\"!showLoading\">\n        <cqa-button\n          *ngFor=\"let button of buttons; let i = index\"\n          [variant]=\"button.variant\"\n          [text]=\"button.label\"\n          [icon]=\"button.icon\"\n          [btnSize]=\"button.btnSize || 'lg'\"\n          [fullWidth]=\"button.fullWidth !== undefined ? button.fullWidth : true\"\n          [disabled]=\"button.disabled ?? false\"\n          (clicked)=\"onButtonClick(button)\">\n        </cqa-button>\n      </ng-container>\n    </div>\n  </div>\n</div>", components: [{ type: i1.BadgeComponent, selector: "cqa-badge", inputs: ["type", "label", "icon", "iconLibrary", "variant", "size", "backgroundColor", "textColor", "borderColor", "iconBackgroundColor", "iconColor", "iconSize", "inlineStyles", "key", "value", "keyTextColor", "valueTextColor", "isLoading", "fullWidth", "centerContent", "title"] }, { type: i2.ButtonComponent, selector: "cqa-button", inputs: ["variant", "btnSize", "disabled", "icon", "iconPosition", "fullWidth", "iconColor", "type", "text", "customClass", "inlineStyles", "tooltip", "tooltipPosition"], outputs: ["clicked"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ErrorModalComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'cqa-error-modal', template: "<div *ngIf=\"isOpen\"\n  class=\"modal-backdrop cqa-fixed cqa-inset-0 cqa-bg-black cqa-bg-opacity-50 cqa-z-[9999] cqa-flex cqa-items-center cqa-justify-center cqa-p-4\"\n  (click)=\"onBackdropClick($event)\">\n  <div\n    class=\"cqa-rounded-lg cqa-bg-white cqa-shadow-xl cqa-w-full cqa-max-w-[500px] cqa-overflow-hidden cqa-p-6 cqa-flex cqa-flex-col cqa-gap-2 cqa-max-h-[85vh] cqa-overflow-y-auto\"\n    style=\"box-shadow: 0px 8px 8px -4px #10182808;\" (click)=\"$event.stopPropagation()\">\n\n    <div class=\"cqa-flex cqa-flex-col cqa-items-center\">\n      <div>\n        <svg width=\"93\" height=\"93\" viewBox=\"0 0 93 93\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" fill=\"#F15F5F\"/>\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" stroke=\"#FCD9D9\" stroke-width=\"8\"/>\n          <path d=\"M32.3815 62.4437H60.619C63.5065 62.4437 65.3065 59.3125 63.8627 56.8188L49.744 32.425C48.3002 29.9313 44.7002 29.9313 43.2565 32.425L29.1377 56.8188C27.694 59.3125 29.494 62.4437 32.3815 62.4437ZM46.5002 49.3188C45.469 49.3188 44.6252 48.475 44.6252 47.4438V43.6938C44.6252 42.6625 45.469 41.8188 46.5002 41.8188C47.5315 41.8188 48.3752 42.6625 48.3752 43.6938V47.4438C48.3752 48.475 47.5315 49.3188 46.5002 49.3188ZM48.3752 56.8188H44.6252V53.0688H48.3752V56.8188Z\" fill=\"white\"/>\n          </svg>\n      </div>\n\n      <h2 class=\"cqa-text-[22px] cqa-font-semibold cqa-text-[#0B0B0C] cqa-mt-[20px] cqa-leading-[28px]\">\n        {{ title }}\n      </h2>\n\n      <!-- Instructional Message -->\n      <p *ngIf=\"instructionalMessage\" class=\"cqa-text-sm cqa-text-[#4A5565] cqa-mt-2 cqa-text-center\">\n        {{ instructionalMessage }}\n      </p>\n    </div>\n\n    <!-- <div *ngIf=\"hasTimingData\" class=\"cqa-rounded-lg cqa-border cqa-p-[17px] cqa-my-4\" [ngClass]=\"stepsBackgroundClass\"\n      style=\"border: 1px solid;\" [style.border-color]=\"stepsBorderClass\">\n      <div\n        class=\"cqa-grid sm:cqa-flex sm:cqa-justify-between sm:cqa-items-center cqa-grid-cols-2 sm:cqa-grid-cols-4 cqa-gap-4 sm:cqa-gap-2\">\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalSteps\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Steps</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ completedSteps }} / {{ totalSteps }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ totalTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"appTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">App Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ appTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"toolTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Tool Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ toolTime }}\n          </span>\n        </div>\n      </div>\n    </div> -->\n\n    <!-- Error Message Section -->\n    <div *ngIf=\"errorMessage\" class=\"cqa-my-4 cqa-p-4 cqa-rounded-lg cqa-bg-white\"\n      style=\"border: 1px solid #E5E7EB;\">\n      <div class=\"cqa-text-xs cqa-text-[#9CA3AF] cqa-mb-2 cqa-font-medium\">\n        Error Message\n      </div>\n      <div class=\"cqa-text-sm cqa-text-[#111827] cqa-font-semibold cqa-whitespace-normal cqa-break-anywhere\"\n        style=\"word-break: break-word; white-space: pre-line;\">\n        {{ errorMessage }}\n      </div>\n    </div>\n\n    <!-- Buttons -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-[20px]\">\n      <ng-container *ngFor=\"let button of buttons; let i = index\">\n        <cqa-button\n          [variant]=\"button.variant\"\n          [text]=\"button.label\"\n          [icon]=\"button.icon\"\n          [btnSize]=\"button.btnSize || 'lg'\"\n          [fullWidth]=\"button.fullWidth !== undefined ? button.fullWidth : true\"\n          (clicked)=\"onButtonClick(button)\">\n        </cqa-button>\n      </ng-container>\n    </div>\n  </div>\n</div>", styles: [] }]
+            args: [{ selector: 'cqa-error-modal', template: "<div *ngIf=\"isOpen\"\n  class=\"modal-backdrop cqa-fixed cqa-inset-0 cqa-bg-black cqa-bg-opacity-50 cqa-z-[9999] cqa-flex cqa-items-center cqa-justify-center cqa-p-4\"\n  (click)=\"onBackdropClick($event)\">\n  <div\n    class=\"cqa-rounded-lg cqa-bg-white cqa-shadow-xl cqa-w-full cqa-max-w-[500px] cqa-overflow-hidden cqa-p-6 cqa-flex cqa-flex-col cqa-gap-2 cqa-max-h-[85vh] cqa-overflow-y-auto\"\n    style=\"box-shadow: 0px 8px 8px -4px #10182808;\" (click)=\"$event.stopPropagation()\">\n\n    <div class=\"cqa-flex cqa-flex-col cqa-items-center\">\n      <div>\n        <svg width=\"93\" height=\"93\" viewBox=\"0 0 93 93\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" fill=\"#F15F5F\"/>\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" stroke=\"#FCD9D9\" stroke-width=\"8\"/>\n          <path d=\"M32.3815 62.4437H60.619C63.5065 62.4437 65.3065 59.3125 63.8627 56.8188L49.744 32.425C48.3002 29.9313 44.7002 29.9313 43.2565 32.425L29.1377 56.8188C27.694 59.3125 29.494 62.4437 32.3815 62.4437ZM46.5002 49.3188C45.469 49.3188 44.6252 48.475 44.6252 47.4438V43.6938C44.6252 42.6625 45.469 41.8188 46.5002 41.8188C47.5315 41.8188 48.3752 42.6625 48.3752 43.6938V47.4438C48.3752 48.475 47.5315 49.3188 46.5002 49.3188ZM48.3752 56.8188H44.6252V53.0688H48.3752V56.8188Z\" fill=\"white\"/>\n          </svg>\n      </div>\n\n      <h2 class=\"cqa-text-[22px] cqa-font-semibold cqa-text-[#0B0B0C] cqa-mt-[20px] cqa-leading-[28px]\">\n        {{ title }}\n      </h2>\n\n      <!-- Instructional Message -->\n      <p *ngIf=\"instructionalMessage\" class=\"cqa-text-sm cqa-text-[#4A5565] cqa-mt-2 cqa-text-center\">\n        {{ instructionalMessage }}\n      </p>\n    </div>\n\n    <!-- <div *ngIf=\"hasTimingData\" class=\"cqa-rounded-lg cqa-border cqa-p-[17px] cqa-my-4\" [ngClass]=\"stepsBackgroundClass\"\n      style=\"border: 1px solid;\" [style.border-color]=\"stepsBorderClass\">\n      <div\n        class=\"cqa-grid sm:cqa-flex sm:cqa-justify-between sm:cqa-items-center cqa-grid-cols-2 sm:cqa-grid-cols-4 cqa-gap-4 sm:cqa-gap-2\">\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalSteps\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Steps</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ completedSteps }} / {{ totalSteps }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ totalTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"appTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">App Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ appTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"toolTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Tool Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ toolTime }}\n          </span>\n        </div>\n      </div>\n    </div> -->\n\n    <!-- Error Message Section -->\n    <div *ngIf=\"errorMessage\" class=\"cqa-my-4 cqa-p-4 cqa-rounded-lg cqa-bg-white\"\n      style=\"border: 1px solid #E5E7EB;\">\n      <div class=\"cqa-text-xs cqa-text-[#9CA3AF] cqa-mb-2 cqa-font-medium\">\n        Error Message\n      </div>\n      <div class=\"cqa-text-sm cqa-text-[#111827] cqa-font-semibold cqa-whitespace-normal cqa-break-anywhere\"\n        style=\"word-break: break-word; white-space: pre-line;\">\n        {{ errorMessage }}\n      </div>\n    </div>\n\n    <!-- Buttons (or loading badge when showLoading) -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-[20px]\">\n      <cqa-badge\n        *ngIf=\"showLoading\"\n        label=\"Updating Steps..\"\n        icon=\"autorenew\"\n        [isLoading]=\"true\"\n        [fullWidth]=\"true\"\n        [centerContent]=\"true\"\n        variant=\"info\"\n        size=\"medium\"\n        [inlineStyles]=\"loadingBadgeInlineStyles\">\n      </cqa-badge>\n      <ng-container *ngIf=\"!showLoading\">\n        <cqa-button\n          *ngFor=\"let button of buttons; let i = index\"\n          [variant]=\"button.variant\"\n          [text]=\"button.label\"\n          [icon]=\"button.icon\"\n          [btnSize]=\"button.btnSize || 'lg'\"\n          [fullWidth]=\"button.fullWidth !== undefined ? button.fullWidth : true\"\n          [disabled]=\"button.disabled ?? false\"\n          (clicked)=\"onButtonClick(button)\">\n        </cqa-button>\n      </ng-container>\n    </div>\n  </div>\n</div>", styles: [] }]
         }], propDecorators: { isOpen: [{
                 type: Input
             }], title: [{
@@ -70,9 +75,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                 type: Input
             }], buttons: [{
                 type: Input
+            }], showLoading: [{
+                type: Input
+            }], loadingBadgeInlineStyles: [{
+                type: Input
             }], buttonClick: [{
                 type: Output
             }], closeModal: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-modal.component.js","sourceRoot":"","sources":["../../../../../src/lib/error-modal/error-modal.component.ts","../../../../../src/lib/error-modal/error-modal.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;;;;AAiBvE,MAAM,OAAO,mBAAmB;IALhC;QAMW,WAAM,GAAY,KAAK,CAAC;QACxB,UAAK,GAAW,OAAO,CAAC;QAExB,iBAAY,GAAW,EAAE,CAAC;QAC1B,eAAU,GAAW,CAAC,CAAC;QACvB,mBAAc,GAAW,CAAC,CAAC;QAC3B,cAAS,GAAW,EAAE,CAAC;QACvB,YAAO,GAAW,EAAE,CAAC;QACrB,aAAQ,GAAW,EAAE,CAAC;QACtB,YAAO,GAAuB,EAAE,CAAC;QAEhC,gBAAW,GAAG,IAAI,YAAY,EAAU,CAAC;QACzC,eAAU,GAAG,IAAI,YAAY,EAAQ,CAAC;KAsCjD;IApCC,eAAe,CAAC,KAAiB;QAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAqB,CAAC;QAC3C,MAAM,aAAa,GAAG,KAAK,CAAC,aAA4B,CAAC;QAEzD,IAAI,MAAM,KAAK,aAAa,IAAI,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE;YAC3E,IAAI,CAAC,OAAO,EAAE,CAAC;SAChB;IACH,CAAC;IAED,aAAa,CAAC,MAAwB;QACpC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,OAAO;QACL,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IACzB,CAAC;IAED,IAAI,oBAAoB;QACtB,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,aAAa;QACf,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChF,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC;IAClE,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC;IAClE,CAAC;;gHAlDU,mBAAmB;oGAAnB,mBAAmB,sYCjBhC,m1IAsFM;2FDrEO,mBAAmB;kBAL/B,SAAS;+BACE,iBAAiB;8BAKlB,MAAM;sBAAd,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,oBAAoB;sBAA5B,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBAEI,WAAW;sBAApB,MAAM;gBACG,UAAU;sBAAnB,MAAM","sourcesContent":["import { Component, Input, Output, EventEmitter } from '@angular/core';\nimport { ButtonVariant } from '../button/button.component';\n\nexport interface ErrorModalButton {\n  label: string;\n  variant: ButtonVariant;\n  icon?: string;\n  action: string;\n  btnSize?: 'sm' | 'md' | 'lg';\n  fullWidth?: boolean;\n}\n\n@Component({\n  selector: 'cqa-error-modal',\n  templateUrl: './error-modal.component.html',\n  styleUrls: []\n})\nexport class ErrorModalComponent {\n  @Input() isOpen: boolean = false;\n  @Input() title: string = 'Error';\n  @Input() instructionalMessage?: string;\n  @Input() errorMessage: string = '';\n  @Input() totalSteps: number = 0;\n  @Input() completedSteps: number = 0;\n  @Input() totalTime: string = '';\n  @Input() appTime: string = '';\n  @Input() toolTime: string = '';\n  @Input() buttons: ErrorModalButton[] = [];\n\n  @Output() buttonClick = new EventEmitter<string>();\n  @Output() closeModal = new EventEmitter<void>();\n\n  onBackdropClick(event: MouseEvent): void {\n    const target = event.target as HTMLElement;\n    const currentTarget = event.currentTarget as HTMLElement;\n    \n    if (target === currentTarget || target.classList.contains('modal-backdrop')) {\n      this.onClose();\n    }\n  }\n\n  onButtonClick(button: ErrorModalButton): void {\n    this.buttonClick.emit(button.action);\n  }\n\n  onClose(): void {\n    this.closeModal.emit();\n  }\n\n  get stepsBackgroundClass(): string {\n    return 'cqa-bg-[#EE3F3F1A]';\n  }\n\n  get stepsBorderClass(): string {\n    return '#FECACA';\n  }\n\n  get hasTimingData(): boolean {\n    return !!(this.totalSteps || this.totalTime || this.appTime || this.toolTime);\n  }\n\n  getNonTextButtons(): ErrorModalButton[] {\n    return this.buttons.filter(button => button.variant !== 'text');\n  }\n\n  getTextButtons(): ErrorModalButton[] {\n    return this.buttons.filter(button => button.variant === 'text');\n  }\n}\n\n","<div *ngIf=\"isOpen\"\n  class=\"modal-backdrop cqa-fixed cqa-inset-0 cqa-bg-black cqa-bg-opacity-50 cqa-z-[9999] cqa-flex cqa-items-center cqa-justify-center cqa-p-4\"\n  (click)=\"onBackdropClick($event)\">\n  <div\n    class=\"cqa-rounded-lg cqa-bg-white cqa-shadow-xl cqa-w-full cqa-max-w-[500px] cqa-overflow-hidden cqa-p-6 cqa-flex cqa-flex-col cqa-gap-2 cqa-max-h-[85vh] cqa-overflow-y-auto\"\n    style=\"box-shadow: 0px 8px 8px -4px #10182808;\" (click)=\"$event.stopPropagation()\">\n\n    <div class=\"cqa-flex cqa-flex-col cqa-items-center\">\n      <div>\n        <svg width=\"93\" height=\"93\" viewBox=\"0 0 93 93\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" fill=\"#F15F5F\"/>\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" stroke=\"#FCD9D9\" stroke-width=\"8\"/>\n          <path d=\"M32.3815 62.4437H60.619C63.5065 62.4437 65.3065 59.3125 63.8627 56.8188L49.744 32.425C48.3002 29.9313 44.7002 29.9313 43.2565 32.425L29.1377 56.8188C27.694 59.3125 29.494 62.4437 32.3815 62.4437ZM46.5002 49.3188C45.469 49.3188 44.6252 48.475 44.6252 47.4438V43.6938C44.6252 42.6625 45.469 41.8188 46.5002 41.8188C47.5315 41.8188 48.3752 42.6625 48.3752 43.6938V47.4438C48.3752 48.475 47.5315 49.3188 46.5002 49.3188ZM48.3752 56.8188H44.6252V53.0688H48.3752V56.8188Z\" fill=\"white\"/>\n          </svg>\n      </div>\n\n      <h2 class=\"cqa-text-[22px] cqa-font-semibold cqa-text-[#0B0B0C] cqa-mt-[20px] cqa-leading-[28px]\">\n        {{ title }}\n      </h2>\n\n      <!-- Instructional Message -->\n      <p *ngIf=\"instructionalMessage\" class=\"cqa-text-sm cqa-text-[#4A5565] cqa-mt-2 cqa-text-center\">\n        {{ instructionalMessage }}\n      </p>\n    </div>\n\n    <!-- <div *ngIf=\"hasTimingData\" class=\"cqa-rounded-lg cqa-border cqa-p-[17px] cqa-my-4\" [ngClass]=\"stepsBackgroundClass\"\n      style=\"border: 1px solid;\" [style.border-color]=\"stepsBorderClass\">\n      <div\n        class=\"cqa-grid sm:cqa-flex sm:cqa-justify-between sm:cqa-items-center cqa-grid-cols-2 sm:cqa-grid-cols-4 cqa-gap-4 sm:cqa-gap-2\">\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalSteps\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Steps</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ completedSteps }} / {{ totalSteps }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ totalTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"appTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">App Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ appTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"toolTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Tool Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ toolTime }}\n          </span>\n        </div>\n      </div>\n    </div> -->\n\n    <!-- Error Message Section -->\n    <div *ngIf=\"errorMessage\" class=\"cqa-my-4 cqa-p-4 cqa-rounded-lg cqa-bg-white\"\n      style=\"border: 1px solid #E5E7EB;\">\n      <div class=\"cqa-text-xs cqa-text-[#9CA3AF] cqa-mb-2 cqa-font-medium\">\n        Error Message\n      </div>\n      <div class=\"cqa-text-sm cqa-text-[#111827] cqa-font-semibold cqa-whitespace-normal cqa-break-anywhere\"\n        style=\"word-break: break-word; white-space: pre-line;\">\n        {{ errorMessage }}\n      </div>\n    </div>\n\n    <!-- Buttons -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-[20px]\">\n      <ng-container *ngFor=\"let button of buttons; let i = index\">\n        <cqa-button\n          [variant]=\"button.variant\"\n          [text]=\"button.label\"\n          [icon]=\"button.icon\"\n          [btnSize]=\"button.btnSize || 'lg'\"\n          [fullWidth]=\"button.fullWidth !== undefined ? button.fullWidth : true\"\n          (clicked)=\"onButtonClick(button)\">\n        </cqa-button>\n      </ng-container>\n    </div>\n  </div>\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-modal.component.js","sourceRoot":"","sources":["../../../../../src/lib/error-modal/error-modal.component.ts","../../../../../src/lib/error-modal/error-modal.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;;;;;AAmBvE,MAAM,OAAO,mBAAmB;IALhC;QAMW,WAAM,GAAY,KAAK,CAAC;QACxB,UAAK,GAAW,OAAO,CAAC;QAExB,iBAAY,GAAW,EAAE,CAAC;QAC1B,eAAU,GAAW,CAAC,CAAC;QACvB,mBAAc,GAAW,CAAC,CAAC;QAC3B,cAAS,GAAW,EAAE,CAAC;QACvB,YAAO,GAAW,EAAE,CAAC;QACrB,aAAQ,GAAW,EAAE,CAAC;QACtB,YAAO,GAAuB,EAAE,CAAC;QAC1C,oGAAoG;QAC3F,gBAAW,GAAY,KAAK,CAAC;QAI5B,gBAAW,GAAG,IAAI,YAAY,EAAU,CAAC;QACzC,eAAU,GAAG,IAAI,YAAY,EAAQ,CAAC;KAuCjD;IArCC,eAAe,CAAC,KAAiB;QAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAqB,CAAC;QAC3C,MAAM,aAAa,GAAG,KAAK,CAAC,aAA4B,CAAC;QAEzD,IAAI,MAAM,KAAK,aAAa,IAAI,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE;YAC3E,IAAI,CAAC,OAAO,EAAE,CAAC;SAChB;IACH,CAAC;IAED,aAAa,CAAC,MAAwB;QACpC,IAAI,MAAM,CAAC,QAAQ;YAAE,OAAO;QAC5B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,OAAO;QACL,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IACzB,CAAC;IAED,IAAI,oBAAoB;QACtB,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAED,IAAI,gBAAgB;QAClB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,aAAa;QACf,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChF,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC;IAClE,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC;IAClE,CAAC;;gHAvDU,mBAAmB;oGAAnB,mBAAmB,wdCnBhC,wxJAmGM;2FDhFO,mBAAmB;kBAL/B,SAAS;+BACE,iBAAiB;8BAKlB,MAAM;sBAAd,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,oBAAoB;sBAA5B,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBACG,cAAc;sBAAtB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBAEG,WAAW;sBAAnB,KAAK;gBAEG,wBAAwB;sBAAhC,KAAK;gBAEI,WAAW;sBAApB,MAAM;gBACG,UAAU;sBAAnB,MAAM","sourcesContent":["import { Component, Input, Output, EventEmitter } from '@angular/core';\nimport { ButtonVariant } from '../button/button.component';\n\nexport interface ErrorModalButton {\n  label: string;\n  variant: ButtonVariant;\n  icon?: string;\n  action: string;\n  btnSize?: 'sm' | 'md' | 'lg';\n  fullWidth?: boolean;\n  /** When true, button is disabled and does not emit click */\n  disabled?: boolean;\n}\n\n@Component({\n  selector: 'cqa-error-modal',\n  templateUrl: './error-modal.component.html',\n  styleUrls: []\n})\nexport class ErrorModalComponent {\n  @Input() isOpen: boolean = false;\n  @Input() title: string = 'Error';\n  @Input() instructionalMessage?: string;\n  @Input() errorMessage: string = '';\n  @Input() totalSteps: number = 0;\n  @Input() completedSteps: number = 0;\n  @Input() totalTime: string = '';\n  @Input() appTime: string = '';\n  @Input() toolTime: string = '';\n  @Input() buttons: ErrorModalButton[] = [];\n  /** When true, shows a loading badge instead of buttons (e.g. while waiting for async completion) */\n  @Input() showLoading: boolean = false;\n  /** Inline styles for the loading badge (e.g. min-height to match button). Pass from parent for reusability. */\n  @Input() loadingBadgeInlineStyles?: string;\n\n  @Output() buttonClick = new EventEmitter<string>();\n  @Output() closeModal = new EventEmitter<void>();\n\n  onBackdropClick(event: MouseEvent): void {\n    const target = event.target as HTMLElement;\n    const currentTarget = event.currentTarget as HTMLElement;\n    \n    if (target === currentTarget || target.classList.contains('modal-backdrop')) {\n      this.onClose();\n    }\n  }\n\n  onButtonClick(button: ErrorModalButton): void {\n    if (button.disabled) return;\n    this.buttonClick.emit(button.action);\n  }\n\n  onClose(): void {\n    this.closeModal.emit();\n  }\n\n  get stepsBackgroundClass(): string {\n    return 'cqa-bg-[#EE3F3F1A]';\n  }\n\n  get stepsBorderClass(): string {\n    return '#FECACA';\n  }\n\n  get hasTimingData(): boolean {\n    return !!(this.totalSteps || this.totalTime || this.appTime || this.toolTime);\n  }\n\n  getNonTextButtons(): ErrorModalButton[] {\n    return this.buttons.filter(button => button.variant !== 'text');\n  }\n\n  getTextButtons(): ErrorModalButton[] {\n    return this.buttons.filter(button => button.variant === 'text');\n  }\n}\n\n","<div *ngIf=\"isOpen\"\n  class=\"modal-backdrop cqa-fixed cqa-inset-0 cqa-bg-black cqa-bg-opacity-50 cqa-z-[9999] cqa-flex cqa-items-center cqa-justify-center cqa-p-4\"\n  (click)=\"onBackdropClick($event)\">\n  <div\n    class=\"cqa-rounded-lg cqa-bg-white cqa-shadow-xl cqa-w-full cqa-max-w-[500px] cqa-overflow-hidden cqa-p-6 cqa-flex cqa-flex-col cqa-gap-2 cqa-max-h-[85vh] cqa-overflow-y-auto\"\n    style=\"box-shadow: 0px 8px 8px -4px #10182808;\" (click)=\"$event.stopPropagation()\">\n\n    <div class=\"cqa-flex cqa-flex-col cqa-items-center\">\n      <div>\n        <svg width=\"93\" height=\"93\" viewBox=\"0 0 93 93\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" fill=\"#F15F5F\"/>\n          <rect x=\"4\" y=\"4\" width=\"85\" height=\"85\" rx=\"42.5\" stroke=\"#FCD9D9\" stroke-width=\"8\"/>\n          <path d=\"M32.3815 62.4437H60.619C63.5065 62.4437 65.3065 59.3125 63.8627 56.8188L49.744 32.425C48.3002 29.9313 44.7002 29.9313 43.2565 32.425L29.1377 56.8188C27.694 59.3125 29.494 62.4437 32.3815 62.4437ZM46.5002 49.3188C45.469 49.3188 44.6252 48.475 44.6252 47.4438V43.6938C44.6252 42.6625 45.469 41.8188 46.5002 41.8188C47.5315 41.8188 48.3752 42.6625 48.3752 43.6938V47.4438C48.3752 48.475 47.5315 49.3188 46.5002 49.3188ZM48.3752 56.8188H44.6252V53.0688H48.3752V56.8188Z\" fill=\"white\"/>\n          </svg>\n      </div>\n\n      <h2 class=\"cqa-text-[22px] cqa-font-semibold cqa-text-[#0B0B0C] cqa-mt-[20px] cqa-leading-[28px]\">\n        {{ title }}\n      </h2>\n\n      <!-- Instructional Message -->\n      <p *ngIf=\"instructionalMessage\" class=\"cqa-text-sm cqa-text-[#4A5565] cqa-mt-2 cqa-text-center\">\n        {{ instructionalMessage }}\n      </p>\n    </div>\n\n    <!-- <div *ngIf=\"hasTimingData\" class=\"cqa-rounded-lg cqa-border cqa-p-[17px] cqa-my-4\" [ngClass]=\"stepsBackgroundClass\"\n      style=\"border: 1px solid;\" [style.border-color]=\"stepsBorderClass\">\n      <div\n        class=\"cqa-grid sm:cqa-flex sm:cqa-justify-between sm:cqa-items-center cqa-grid-cols-2 sm:cqa-grid-cols-4 cqa-gap-4 sm:cqa-gap-2\">\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalSteps\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Steps</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ completedSteps }} / {{ totalSteps }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"totalTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Total Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ totalTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"appTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">App Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ appTime }}\n          </span>\n        </div>\n\n        <div class=\"cqa-flex cqa-flex-col\" *ngIf=\"toolTime\">\n          <span class=\"cqa-text-xs cqa-text-[#4A5565] cqa-mb-1\">Tool Time</span>\n          <span class=\"cqa-text-[18px] cqa-font-medium cqa-text-[#101828]\">\n            {{ toolTime }}\n          </span>\n        </div>\n      </div>\n    </div> -->\n\n    <!-- Error Message Section -->\n    <div *ngIf=\"errorMessage\" class=\"cqa-my-4 cqa-p-4 cqa-rounded-lg cqa-bg-white\"\n      style=\"border: 1px solid #E5E7EB;\">\n      <div class=\"cqa-text-xs cqa-text-[#9CA3AF] cqa-mb-2 cqa-font-medium\">\n        Error Message\n      </div>\n      <div class=\"cqa-text-sm cqa-text-[#111827] cqa-font-semibold cqa-whitespace-normal cqa-break-anywhere\"\n        style=\"word-break: break-word; white-space: pre-line;\">\n        {{ errorMessage }}\n      </div>\n    </div>\n\n    <!-- Buttons (or loading badge when showLoading) -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-[20px]\">\n      <cqa-badge\n        *ngIf=\"showLoading\"\n        label=\"Updating Steps..\"\n        icon=\"autorenew\"\n        [isLoading]=\"true\"\n        [fullWidth]=\"true\"\n        [centerContent]=\"true\"\n        variant=\"info\"\n        size=\"medium\"\n        [inlineStyles]=\"loadingBadgeInlineStyles\">\n      </cqa-badge>\n      <ng-container *ngIf=\"!showLoading\">\n        <cqa-button\n          *ngFor=\"let button of buttons; let i = index\"\n          [variant]=\"button.variant\"\n          [text]=\"button.label\"\n          [icon]=\"button.icon\"\n          [btnSize]=\"button.btnSize || 'lg'\"\n          [fullWidth]=\"button.fullWidth !== undefined ? button.fullWidth : true\"\n          [disabled]=\"button.disabled ?? false\"\n          (clicked)=\"onButtonClick(button)\">\n        </cqa-button>\n      </ng-container>\n    </div>\n  </div>\n</div>"]}