npm - @cqa-lib/cqa-ui - Versions diffs - 1.1.65 → 1.1.67 - Mend

@cqa-lib/cqa-ui 1.1.65 → 1.1.67

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/esm2020/lib/execution-screen/base-step.component.mjs CHANGED Viewed

@@ -62,6 +62,9 @@ export class BaseStepComponent {
         if (seconds < 1) {
             return `${(seconds * 1000).toFixed(0)}ms`;
         }
+        if (seconds < 60 && !Number.isInteger(seconds)) {
+            return `${seconds.toFixed(1)}s`;
+        }
         const hours = Math.floor(seconds / 3600);
         const minutes = Math.floor((seconds % 3600) / 60);
         const secs = Math.floor(seconds % 60);
@@ -91,4 +94,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
             }], toggleExpanded: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/execution-screen/condition-step/condition-step.component.mjs CHANGED Viewed

@@ -40,6 +40,8 @@ export class ConditionStepComponent extends BaseStepComponent {
         super.toggle();
         if (!wasExpanded && this.isExpanded) {
             this.onExpand.emit();
+            // Note: Condition steps typically don't have nested children that need fetching
+            // But if needed, we can add similar logic here
         }
     }
     getExecutedBranch() {
@@ -139,4 +141,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
             }], selfHealAction: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/execution-screen/condition-step/condition-step.component.ts","../../../../../../src/lib/execution-screen/condition-step/condition-step.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { ConditionStepConfig, ConditionBranch, StepStatus, TimingBreakdown, FailureDetails, SubStep, SelfHealAnalysisData, SelfHealAction } from '../execution-step.models';\nimport { BaseStepComponent } from '../base-step.component';\nimport { makeCurrentBaselineEvent, uploadBaselineEvent } from '../visual-comparison/visual-comparison.component';\n\n@Component({\n  selector: 'cqa-condition-step',\n  templateUrl: './condition-step.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' }\n})\nexport class ConditionStepComponent extends BaseStepComponent implements OnInit {\n  // Individual inputs\n  @Input() id!: string;\n  @Input() testStepResultId!: string;\n  @Input() stepNumber!: string;\n  @Input() title!: string;\n  @Input() status!: StepStatus;\n  @Input() duration!: number;\n  @Input() timingBreakdown?: TimingBreakdown;\n  @Input() expanded?: boolean;\n  @Input() conditionText!: string;\n  @Input() branches!: ConditionBranch[];\n  @Input() failureDetails?: FailureDetails;\n  @Input() reasoning?: string[];\n  @Input() confidence?: string;\n  @Input() selfHealAnalysis?: SelfHealAnalysisData;\n  @Input() isLoading?: boolean;\n  @Output() onBranchClickEvent = new EventEmitter<ConditionBranch>();\n  @Output() onExpand = new EventEmitter<void>();\n  @Input() isUploadingBaseline = {};\n  @Output() makeCurrentBaseline = new EventEmitter<makeCurrentBaselineEvent>();\n  @Output() uploadBaseline = new EventEmitter<uploadBaselineEvent>();\n  @Output() analyze = new EventEmitter<void>();\n  @Output() viewFullLogs = new EventEmitter<void>();\n  @Output() selfHealAction = new EventEmitter<{ type: SelfHealAction; healedLocator: string; }>();\n\n  showFailedStepDetails: boolean = false;\n\n  // Config property for base class - built from individual inputs in ngOnInit\n  override config!: ConditionStepConfig;\n\n  override ngOnInit(): void {\n    // Build config from individual inputs\n    this.config = {\n      id: this.id,\n      testStepResultId: this.testStepResultId,\n      stepNumber: this.stepNumber,\n      title: this.title,\n      status: this.status,\n      duration: this.duration,\n      type: 'condition',\n      conditionText: this.conditionText,\n      branches: this.branches,\n      timingBreakdown: this.timingBreakdown,\n      expanded: this.expanded,\n    } as ConditionStepConfig;\n\n    super.ngOnInit();\n  }\n\n  override toggle(): void {\n    const wasExpanded = this.isExpanded;\n    super.toggle();\n    if (!wasExpanded && this.isExpanded) {\n      this.onExpand.emit();\n    }\n  }\n\n  getExecutedBranch(): ConditionBranch | null {\n    return this.branches.find(branch => branch.executed) || null;\n  }\n\n  getUnexecutedBranches(): ConditionBranch[] {\n    return this.branches.filter(branch => !branch.executed);\n  }\n\n  getSubStepIndex(subSteps: any[], subStep: any): number {\n    return subSteps.indexOf(subStep) + 1;\n  }\n\n  onViewMoreFailedStepClick(expanded: boolean): void {\n    this.showFailedStepDetails = expanded;\n  }\n\n  getSubStepsForFailedStep(): SubStep[] {\n    const executedBranch = this.getExecutedBranch();\n    return executedBranch?.subSteps || [];\n  }\n\n  onMakeCurrentBaseline(event: makeCurrentBaselineEvent): void {\n    this.makeCurrentBaseline.emit(event);\n  }\n\n  onUploadBaseline(event: uploadBaselineEvent): void {\n    this.uploadBaseline.emit(event);\n  }\n\n  onAnalyze(): void {\n    this.analyze.emit();\n  }\n\n  onViewFullLogs(): void {\n    this.viewFullLogs.emit();\n  }\n\n  onSelfHealAction(event: { type: SelfHealAction; healedLocator: string; }): void {\n    this.selfHealAction.emit(event);\n  }\n\n  get showViewMoreButton(): boolean {\n    return this.isExpanded && Boolean(this.failureDetails) &&\n      (\n        (Boolean(this.failureDetails?.expected || this.failureDetails?.actual)) ||\n        (Boolean(this.failureDetails?.screenshots?.current || this.failureDetails?.screenshots?.baseline || this.failureDetails?.screenshots?.difference)\n          || Boolean(this.failureDetails?.logs?.length)) || \n        (Boolean(this.failureDetails?.aiFixApplied && (this.failureDetails?.aiFixMessage || this.confidence || this.reasoning?.length)))\n      )\n  }\n\n  toggleHeader(): void {\n    this.toggle();\n    if(!this.isExpanded){\n      this.showFailedStepDetails = false;\n    }\n  }\n}\n","<div>\n  <div class=\"cqa-p-2\">\n    <!-- Header -->\n    <div\n      class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-pb-1.5 cqa-cursor-pointer\"\n      (click)=\"toggleHeader()\">\n      \n      <!-- Status Icon -->\n      <div *ngIf=\"config.status.toLowerCase() === 'success'\" ><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n      <div *ngIf=\"config.status.toLowerCase() === 'failure'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7.5 4.5L4.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 4.5L7.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n      <!-- Condition Icon -->\n      <div><svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"16\" height=\"16\" rx=\"4\" fill=\"#FFEDD5\"/><path d=\"M6 5V9\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M10 7C10.5523 7 11 6.55228 11 6C11 5.44772 10.5523 5 10 5C9.44772 5 9 5.44772 9 6C9 6.55228 9.44772 7 10 7Z\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 11C6.55228 11 7 10.5523 7 10C7 9.44772 6.55228 9 6 9C5.44772 9 5 9.44772 5 10C5 10.5523 5.44772 11 6 11Z\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M10 7C10 7.79565 9.68393 8.55871 9.12132 9.12132C8.55871 9.68393 7.79565 10 7 10\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n      <!-- Step Number and Title -->\n      <div class=\"cqa-flex-1 cqa-flex cqa-items-center cqa-gap-3\">\n        <span class=\"cqa-font-bold cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n          {{ config.stepNumber }}. Condition: <span [innerHTML]=\"config.conditionText\"></span>\n        </span>\n        \n        <!-- Condition Badge -->\n        <span class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#EA580C] cqa-bg-[#FFEDD5] cqa-text-[10px] cqa-leading-[15px]\">\n          CONDITION\n        </span>\n      </div>\n\n      <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n        <span class=\"cqa-text-[9px] cqa-leading-[11px] cqa-text-[#9CA3AF]\">\n          {{ formatDuration(config.duration) }}\n        </span>\n        <svg [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      </div>\n    </div>\n    <!-- Branch Buttons -->\n    <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-px-4 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#737373]\">\n      <div\n        *ngFor=\"let branch of config.branches\"\n        class=\"cqa-px-2 cqa-py-1 cqa-rounded cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-flex cqa-items-center cqa-gap-1.5\"\n        [ngClass]=\"branch.executed \n          ? 'cqa-bg-[#DCFCE7] cqa-text-[#008236] cqa-border cqa-border-solid cqa-border-[#B9F8CF]' \n          : 'cqa-bg-[#F3F4F6] cqa-text-[#99A1AF] cqa-border cqa-border-solid cqa-border-[#E5E7EB]'\">\n        <div *ngIf=\"branch.executed\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3L4.5 8.5L2 6\" stroke=\"#008236\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n        <span>{{ branch.type.toUpperCase() }} ({{ branch.label }})</span>\n      </div>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && !isLoading\">\n\n    <!-- Executed Branch Sub-steps -->\n    <div *ngFor=\"let branch of config.branches\">\n      <div *ngIf=\"branch.executed && branch.subSteps\" class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pb-1 cqa-ml-9\" style=\"border-bottom: '1px solid #F3F4F6'\">\n        <div\n          *ngFor=\"let subStep of branch.subSteps\"\n          class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n          \n          <!-- Sub-step Status Icon -->\n          <div><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n          <!-- Sub-step Description -->\n          <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n            {{ config.stepNumber }}.{{ getSubStepIndex(branch.subSteps, subStep) }}. <span [innerHTML]=\"subStep.description\"></span>\n          </span>\n\n          <!-- Sub-step Duration -->\n          <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-metadata-key\">\n            {{ formatDuration(subStep.duration) }}\n          </span>\n        </div>\n      </div>\n    </div>\n\n    <!-- Unexecuted Branch Message -->\n    <div *ngIf=\"getUnexecutedBranches().length > 0 && getUnexecutedBranches().length < 2\" class=\"cqa-ml-9\">\n      <p class=\"cqa-px-3 cqa-py-[10px] cqa-text-[12px] cqa-leading-4 cqa-text-[#737373] cqa-italic\">\n        {{ getUnexecutedBranches()?.[0]?.type?.toUpperCase() }} branch not executed\n      </p>\n    </div>\n\n    <div *ngIf=\"getUnexecutedBranches().length > 1\" class=\"cqa-ml-9\">\n      <p class=\"cqa-px-3 cqa-py-[10px] cqa-text-[12px] cqa-leading-4 cqa-text-[#737373] cqa-italic\">\n        {{ getUnexecutedBranches()?.[0]?.type?.toUpperCase() }} and {{ getUnexecutedBranches()?.[1]?.type?.toUpperCase() }} branches not executed\n      </p>\n    </div>\n\n      <!-- Self Heal Analysis -->\n    <cqa-self-heal-analysis \n      *ngIf=\"selfHealAnalysis\" \n      [originalLocator]=\"selfHealAnalysis.originalLocator\"\n      [healedLocator]=\"selfHealAnalysis.healedLocator\"\n      [confidence]=\"selfHealAnalysis.confidence\"\n      [healMethod]=\"selfHealAnalysis.healMethod\"\n      (action)=\"onSelfHealAction($event)\">\n    </cqa-self-heal-analysis>\n\n    <!-- Timing Breakdown -->\n    <div *ngIf=\"config.timingBreakdown\" class=\"cqa-flex cqa-items-center cqa-justify-end cqa-gap-5 cqa-pt-1.5 cqa-px-4 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#9CA3AF]\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n        <div><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n        <span>Timing breakdown</span>\n      </div>\n      <span class=\"cqa-text-dialog-muted cqa-flex cqa-items-center cqa-gap-3\">\n        <div>\n          App <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.app) }}</span>\n        </div>\n        <div><svg width=\"1\" height=\"11\" viewBox=\"0 0 1 11\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M-3.8147e-06 10.32V-7.15256e-07H0.959996V10.32H-3.8147e-06Z\" fill=\"#E5E7EB\"/></svg></div>\n        <div>\n          Tool <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.tool) }}</span>\n        </div>\n      </span>\n    </div>\n  </div>\n\n  <!-- View More Failed Step Button - shown when expanded and failure details exist -->\n  <div *ngIf=\"showViewMoreButton && !isLoading\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-view-more-failed-step-button\n      [timingBreakdown]=\"timingBreakdown\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [isExpanded]=\"showFailedStepDetails\"\n      (viewMoreClick)=\"onViewMoreFailedStepClick($event)\">\n    </cqa-view-more-failed-step-button>\n  </div>\n\n  <!-- Updated Failed Step Component - shown when button is clicked -->\n  <div *ngIf=\"showViewMoreButton && showFailedStepDetails && failureDetails\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-updated-failed-step\n      [timingBreakdown]=\"timingBreakdown\"\n      [testStepResultId]=\"testStepResultId\"\n      [expanded]=\"true\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [reasoning]=\"reasoning\"\n      [confidence]=\"confidence\"\n      [isUploadingBaseline]=\"isUploadingBaseline\"\n      (makeCurrentBaseline)=\"onMakeCurrentBaseline($event)\"\n      (uploadBaseline)=\"onUploadBaseline($event)\"\n      (analyze)=\"onAnalyze()\"\n      (viewFullLogs)=\"onViewFullLogs()\">\n    </cqa-updated-failed-step>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/execution-screen/condition-step/condition-step.component.ts","../../../../../../src/lib/execution-screen/condition-step/condition-step.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport { ConditionStepConfig, ConditionBranch, StepStatus, TimingBreakdown, FailureDetails, SubStep, SelfHealAnalysisData, SelfHealAction } from '../execution-step.models';\nimport { BaseStepComponent } from '../base-step.component';\nimport { makeCurrentBaselineEvent, uploadBaselineEvent } from '../visual-comparison/visual-comparison.component';\n\n@Component({\n  selector: 'cqa-condition-step',\n  templateUrl: './condition-step.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' }\n})\nexport class ConditionStepComponent extends BaseStepComponent implements OnInit {\n  // Individual inputs\n  @Input() id!: string;\n  @Input() testStepResultId!: string;\n  @Input() stepNumber!: string;\n  @Input() title!: string;\n  @Input() status!: StepStatus;\n  @Input() duration!: number;\n  @Input() timingBreakdown?: TimingBreakdown;\n  @Input() expanded?: boolean;\n  @Input() conditionText!: string;\n  @Input() branches!: ConditionBranch[];\n  @Input() failureDetails?: FailureDetails;\n  @Input() reasoning?: string[];\n  @Input() confidence?: string;\n  @Input() selfHealAnalysis?: SelfHealAnalysisData;\n  @Input() isLoading?: boolean;\n  @Output() onBranchClickEvent = new EventEmitter<ConditionBranch>();\n  @Output() onExpand = new EventEmitter<void>();\n  @Input() isUploadingBaseline = {};\n  @Output() makeCurrentBaseline = new EventEmitter<makeCurrentBaselineEvent>();\n  @Output() uploadBaseline = new EventEmitter<uploadBaselineEvent>();\n  @Output() analyze = new EventEmitter<void>();\n  @Output() viewFullLogs = new EventEmitter<void>();\n  @Output() selfHealAction = new EventEmitter<{ type: SelfHealAction; healedLocator: string; }>();\n\n  showFailedStepDetails: boolean = false;\n\n  // Config property for base class - built from individual inputs in ngOnInit\n  override config!: ConditionStepConfig;\n\n  override ngOnInit(): void {\n    // Build config from individual inputs\n    this.config = {\n      id: this.id,\n      testStepResultId: this.testStepResultId,\n      stepNumber: this.stepNumber,\n      title: this.title,\n      status: this.status,\n      duration: this.duration,\n      type: 'condition',\n      conditionText: this.conditionText,\n      branches: this.branches,\n      timingBreakdown: this.timingBreakdown,\n      expanded: this.expanded,\n    } as ConditionStepConfig;\n\n    super.ngOnInit();\n  }\n\n  override toggle(): void {\n    const wasExpanded = this.isExpanded;\n    super.toggle();\n    if (!wasExpanded && this.isExpanded) {\n      this.onExpand.emit();\n      // Note: Condition steps typically don't have nested children that need fetching\n      // But if needed, we can add similar logic here\n    }\n  }\n\n  getExecutedBranch(): ConditionBranch | null {\n    return this.branches.find(branch => branch.executed) || null;\n  }\n\n  getUnexecutedBranches(): ConditionBranch[] {\n    return this.branches.filter(branch => !branch.executed);\n  }\n\n  getSubStepIndex(subSteps: any[], subStep: any): number {\n    return subSteps.indexOf(subStep) + 1;\n  }\n\n  onViewMoreFailedStepClick(expanded: boolean): void {\n    this.showFailedStepDetails = expanded;\n  }\n\n  getSubStepsForFailedStep(): SubStep[] {\n    const executedBranch = this.getExecutedBranch();\n    return executedBranch?.subSteps || [];\n  }\n\n  onMakeCurrentBaseline(event: makeCurrentBaselineEvent): void {\n    this.makeCurrentBaseline.emit(event);\n  }\n\n  onUploadBaseline(event: uploadBaselineEvent): void {\n    this.uploadBaseline.emit(event);\n  }\n\n  onAnalyze(): void {\n    this.analyze.emit();\n  }\n\n  onViewFullLogs(): void {\n    this.viewFullLogs.emit();\n  }\n\n  onSelfHealAction(event: { type: SelfHealAction; healedLocator: string; }): void {\n    this.selfHealAction.emit(event);\n  }\n\n  get showViewMoreButton(): boolean {\n    return this.isExpanded && Boolean(this.failureDetails) &&\n      (\n        (Boolean(this.failureDetails?.expected || this.failureDetails?.actual)) ||\n        (Boolean(this.failureDetails?.screenshots?.current || this.failureDetails?.screenshots?.baseline || this.failureDetails?.screenshots?.difference)\n          || Boolean(this.failureDetails?.logs?.length)) || \n        (Boolean(this.failureDetails?.aiFixApplied && (this.failureDetails?.aiFixMessage || this.confidence || this.reasoning?.length)))\n      )\n  }\n\n  toggleHeader(): void {\n    this.toggle();\n    if(!this.isExpanded){\n      this.showFailedStepDetails = false;\n    }\n  }\n}\n","<div>\n  <div class=\"cqa-p-2\">\n    <!-- Header -->\n    <div\n      class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-pb-1.5 cqa-cursor-pointer\"\n      (click)=\"toggleHeader()\">\n      \n      <!-- Status Icon -->\n      <div *ngIf=\"config.status.toLowerCase() === 'success'\" ><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n      <div *ngIf=\"config.status.toLowerCase() === 'failure'\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7.5 4.5L4.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 4.5L7.5 7.5\" stroke=\"#DC2626\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n      <!-- Condition Icon -->\n      <div><svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"16\" height=\"16\" rx=\"4\" fill=\"#FFEDD5\"/><path d=\"M6 5V9\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M10 7C10.5523 7 11 6.55228 11 6C11 5.44772 10.5523 5 10 5C9.44772 5 9 5.44772 9 6C9 6.55228 9.44772 7 10 7Z\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 11C6.55228 11 7 10.5523 7 10C7 9.44772 6.55228 9 6 9C5.44772 9 5 9.44772 5 10C5 10.5523 5.44772 11 6 11Z\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M10 7C10 7.79565 9.68393 8.55871 9.12132 9.12132C8.55871 9.68393 7.79565 10 7 10\" stroke=\"#FD9A00\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n      <!-- Step Number and Title -->\n      <div class=\"cqa-flex-1 cqa-flex cqa-items-center cqa-gap-3\">\n        <span class=\"cqa-font-bold cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n          {{ config.stepNumber }}. Condition: <span [innerHTML]=\"config.conditionText\"></span>\n        </span>\n        \n        <!-- Condition Badge -->\n        <span class=\"cqa-px-1.5 cqa-rounded-full cqa-font-medium cqa-text-[#EA580C] cqa-bg-[#FFEDD5] cqa-text-[10px] cqa-leading-[15px]\">\n          CONDITION\n        </span>\n      </div>\n\n      <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n        <span class=\"cqa-text-[9px] cqa-leading-[11px] cqa-text-[#9CA3AF]\">\n          {{ formatDuration(config.duration) }}\n        </span>\n        <svg [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      </div>\n    </div>\n    <!-- Branch Buttons -->\n    <div class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-px-4 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#737373]\">\n      <div\n        *ngFor=\"let branch of config.branches\"\n        class=\"cqa-px-2 cqa-py-1 cqa-rounded cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-flex cqa-items-center cqa-gap-1.5\"\n        [ngClass]=\"branch.executed \n          ? 'cqa-bg-[#DCFCE7] cqa-text-[#008236] cqa-border cqa-border-solid cqa-border-[#B9F8CF]' \n          : 'cqa-bg-[#F3F4F6] cqa-text-[#99A1AF] cqa-border cqa-border-solid cqa-border-[#E5E7EB]'\">\n        <div *ngIf=\"branch.executed\"><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3L4.5 8.5L2 6\" stroke=\"#008236\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n        <span>{{ branch.type.toUpperCase() }} ({{ branch.label }})</span>\n      </div>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && !isLoading\">\n\n    <!-- Executed Branch Sub-steps -->\n    <div *ngFor=\"let branch of config.branches\">\n      <div *ngIf=\"branch.executed && branch.subSteps\" class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pb-1 cqa-ml-9\" style=\"border-bottom: '1px solid #F3F4F6'\">\n        <div\n          *ngFor=\"let subStep of branch.subSteps\"\n          class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n          \n          <!-- Sub-step Status Icon -->\n          <div><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n\n          <!-- Sub-step Description -->\n          <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n            {{ config.stepNumber }}.{{ getSubStepIndex(branch.subSteps, subStep) }}. <span [innerHTML]=\"subStep.description\"></span>\n          </span>\n\n          <!-- Sub-step Duration -->\n          <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-metadata-key\">\n            {{ formatDuration(subStep.duration) }}\n          </span>\n        </div>\n      </div>\n    </div>\n\n    <!-- Unexecuted Branch Message -->\n    <div *ngIf=\"getUnexecutedBranches().length > 0 && getUnexecutedBranches().length < 2\" class=\"cqa-ml-9\">\n      <p class=\"cqa-px-3 cqa-py-[10px] cqa-text-[12px] cqa-leading-4 cqa-text-[#737373] cqa-italic\">\n        {{ getUnexecutedBranches()?.[0]?.type?.toUpperCase() }} branch not executed\n      </p>\n    </div>\n\n    <div *ngIf=\"getUnexecutedBranches().length > 1\" class=\"cqa-ml-9\">\n      <p class=\"cqa-px-3 cqa-py-[10px] cqa-text-[12px] cqa-leading-4 cqa-text-[#737373] cqa-italic\">\n        {{ getUnexecutedBranches()?.[0]?.type?.toUpperCase() }} and {{ getUnexecutedBranches()?.[1]?.type?.toUpperCase() }} branches not executed\n      </p>\n    </div>\n\n      <!-- Self Heal Analysis -->\n    <cqa-self-heal-analysis \n      *ngIf=\"selfHealAnalysis\" \n      [originalLocator]=\"selfHealAnalysis.originalLocator\"\n      [healedLocator]=\"selfHealAnalysis.healedLocator\"\n      [confidence]=\"selfHealAnalysis.confidence\"\n      [healMethod]=\"selfHealAnalysis.healMethod\"\n      (action)=\"onSelfHealAction($event)\">\n    </cqa-self-heal-analysis>\n\n    <!-- Timing Breakdown -->\n    <div *ngIf=\"config.timingBreakdown\" class=\"cqa-flex cqa-items-center cqa-justify-end cqa-gap-5 cqa-pt-1.5 cqa-px-4 cqa-text-[10px] cqa-leading-[15px] cqa-font-medium cqa-text-[#9CA3AF]\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\">\n        <div><svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></div>\n        <span>Timing breakdown</span>\n      </div>\n      <span class=\"cqa-text-dialog-muted cqa-flex cqa-items-center cqa-gap-3\">\n        <div>\n          App <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.app) }}</span>\n        </div>\n        <div><svg width=\"1\" height=\"11\" viewBox=\"0 0 1 11\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M-3.8147e-06 10.32V-7.15256e-07H0.959996V10.32H-3.8147e-06Z\" fill=\"#E5E7EB\"/></svg></div>\n        <div>\n          Tool <span class=\"cqa-text-gray-700\">{{ formatDuration(config.timingBreakdown.tool) }}</span>\n        </div>\n      </span>\n    </div>\n  </div>\n\n  <!-- View More Failed Step Button - shown when expanded and failure details exist -->\n  <div *ngIf=\"showViewMoreButton && !isLoading\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-view-more-failed-step-button\n      [timingBreakdown]=\"timingBreakdown\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [isExpanded]=\"showFailedStepDetails\"\n      (viewMoreClick)=\"onViewMoreFailedStepClick($event)\">\n    </cqa-view-more-failed-step-button>\n  </div>\n\n  <!-- Updated Failed Step Component - shown when button is clicked -->\n  <div *ngIf=\"showViewMoreButton && showFailedStepDetails && failureDetails\" class=\"cqa-mt-2 cqa-px-4\">\n    <cqa-updated-failed-step\n      [timingBreakdown]=\"timingBreakdown\"\n      [testStepResultId]=\"testStepResultId\"\n      [expanded]=\"true\"\n      [subSteps]=\"getSubStepsForFailedStep()\"\n      [failureDetails]=\"failureDetails\"\n      [reasoning]=\"reasoning\"\n      [confidence]=\"confidence\"\n      [isUploadingBaseline]=\"isUploadingBaseline\"\n      (makeCurrentBaseline)=\"onMakeCurrentBaseline($event)\"\n      (uploadBaseline)=\"onUploadBaseline($event)\"\n      (analyze)=\"onAnalyze()\"\n      (viewFullLogs)=\"onViewFullLogs()\">\n    </cqa-updated-failed-step>\n  </div>\n</div>\n"]}

package/esm2020/lib/execution-screen/execution-step.models.mjs CHANGED Viewed

@@ -2,4 +2,4 @@
  * Models and interfaces for execution screen step components
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"execution-step.models.js","sourceRoot":"","sources":["../../../../../src/lib/execution-screen/execution-step.models.ts"],"names":[],"mappings":"AAAA;;GAEG","sourcesContent":["/**\n * Models and interfaces for execution screen step components\n */\n\nexport type StepStatus = 'success' | 'failed' | 'pending' | 'running';\n\nexport interface TimingBreakdown {\n  app: number; // in seconds\n  tool: number; // in seconds\n}\n\nexport interface SubStep {\n  id: string;\n  description: string;\n  status: StepStatus;\n  duration: number; // in seconds\n  timestamp?: string; // optional timestamp like \"00:12\"\n}\n\nexport interface LoopIteration {\n  id: string;\n  label: string; // e.g., \"Iter 2 (production)\"\n  status: StepStatus;\n  subSteps?: SubStep[];\n}\n\nexport interface ConditionBranch {\n  type: 'if' | 'else' | 'else if';\n  label: string; // e.g., \"Premium user\" or \"Free user\"\n  executed: boolean;\n  subSteps?: SubStep[];\n}\n\nexport interface ScreenshotData {\n  baseline?: string; // URL or base64\n  current?: string; // URL or base64\n  difference?: string; // URL or base64\n}\n\nexport interface LogEntry {\n  level: 'info' | 'warning' | 'error';\n  message: string;\n  timestamp?: string;\n}\n\nexport interface FailureDetails {\n  expected: string;\n  actual: string;\n  failedAction?: string; // The action that failed\n  aiFixApplied?: boolean;\n  aiFixMessage?: string;\n  screenshots?: ScreenshotData;\n  logs?: LogEntry[];\n}\n\nexport interface BaseStepConfig {\n  id: string;\n  testStepResultId: string;\n  stepNumber: string; // e.g., \"1\", \"2.1\", \"3.2.1\"\n  title: string;\n  status: StepStatus;\n  duration: number; // total duration in seconds\n  timingBreakdown?: TimingBreakdown;\n  expanded?: boolean; // whether the step is expanded by default\n  failureDetails?: FailureDetails;\n  reasoning?: string[];\n  confidence?: string;\n}\n\nexport interface SelfHealAnalysisData {\n  originalLocator: string;\n  healedLocator: string;\n  confidence: number; // 0-100\n  healMethod: string; // e.g., \"Semantic Attribute Matching\"\n}\n\nexport type SelfHealAction = 'accept' | 'reject' | 'modify-accept';\n\nexport interface BasicStepConfig extends BaseStepConfig {\n  type: 'basic';\n  subSteps: SubStep[];\n  selfHealAnalysis?: SelfHealAnalysisData;\n  selfHealed?: boolean; // Indicates if self-healing was applied\n  selfHealDuration?: number; // Duration of self-healing process\n}\n\nexport interface StepGroupConfig extends BaseStepConfig {\n  type: 'step-group';\n  groupName: string; // e.g., \"Navigation\", \"Checkout flow\"\n  steps: ExecutionStepConfig[]; // nested steps\n}\n\nexport interface LoopStepConfig extends BaseStepConfig {\n  type: 'loop';\n  loopType?: 'for' | 'while';\n  iterations: LoopIteration[];\n  selectedIterationId?: string; // which iteration to display\n  defaultIteration?: 'first' | 'last'; // default iteration to show\n  nestedSteps?: ExecutionStepConfig[]; // steps nested within the loop\n  showViewAllIterations?: boolean;\n}\n\nexport interface ConditionStepConfig extends BaseStepConfig {\n  type: 'condition';\n  conditionText: string; // e.g., \"if user type is 'Premium'\"\n  branches: ConditionBranch[];\n}\n\nexport interface FailedStepConfig extends BaseStepConfig {\n  type: 'failed';\n  subSteps: SubStep[];\n  failureDetails: FailureDetails;\n  reasoning?: string[];\n  confidence?: string;\n}\n\nexport interface AIAgentAction {\n  id: string;\n  description: string;\n  type: 'extract' | 'validate' | 'AI_AGENT_ACTION' | 'TYPE' | 'CLICK';\n  status: StepStatus;\n  confidence?: number; // 0-100\n  duration: number;\n}\n\nexport interface AIAgentStepConfig extends BaseStepConfig {\n  type: 'ai-agent';\n  prompt: string;\n  optimizedRun?: boolean;\n  actionCount?: number;\n  actions: AIAgentAction[];\n  selectedTab?: 'action-trace' | 'planner-timeline' | 'ai-reasoning';\n}\n\nexport interface ApiAssertion {\n  id: string;\n  description: string;\n  status: 'passed' | 'failed';\n  expected: string;\n  actual: string;\n}\n\nexport interface ApiStepConfig extends BaseStepConfig {\n  type: 'api';\n  method: string; // GET, POST, PUT, DELETE, etc.\n  endpoint: string;\n  statusCode: number;\n  responseTime: number; // in milliseconds\n  requestBody?: any;\n  responseBody?: any;\n  requestHeaders?: any;\n  responseHeaders?: any;\n  assertions?: ApiAssertion[];\n  initialActions?: SubStep[]; // Actions before the API call\n}\n\nexport interface FileDownloadStepConfig extends BaseStepConfig {\n  type: 'file-download';\n  fileName: string;\n  fileType: string; // PDF, CSV, etc.\n  fileSize?: string; // e.g., \"2.4 MB\"\n  filePath?: string;\n  downloaded: boolean;\n}\n\nexport interface ExtractedField {\n  label: string;\n  value: string;\n  confidence: number; // 0-100\n}\n\nexport interface VerificationCheck {\n  id: string;\n  description: string;\n  status: 'pass' | 'fail';\n  expected: string;\n  actual: string;\n}\n\nexport interface DocumentVerificationStepConfig extends BaseStepConfig {\n  type: 'document-verification';\n  documentScreenshot?: string; // URL or base64\n  extractedFields: ExtractedField[];\n  verificationChecks: VerificationCheck[];\n}\n\nexport interface LiveSubStep {\n  id: string;\n  text: string; // Text from socket\n  isRunning: boolean; // true = show loader, false = show icon\n}\n\nexport interface LiveExecutionStepConfig extends BaseStepConfig {\n  type: 'live-execution';\n  subSteps: LiveSubStep[];\n}\n\nexport interface PrerequisiteItem {\n  id: string;\n  title: string; // e.g., \"Prerequisite 1: Login flow\"\n  status: StepStatus;\n  duration: number; // in seconds\n  stepConfig?: ExecutionStepConfig; // Optional: full step config to view details\n}\n\nexport type ExecutionStepConfig =\n  | BasicStepConfig\n  | StepGroupConfig\n  | LoopStepConfig\n  | ConditionStepConfig\n  | FailedStepConfig\n  | AIAgentStepConfig\n  | ApiStepConfig\n  | FileDownloadStepConfig\n  | DocumentVerificationStepConfig\n  | LiveExecutionStepConfig;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"execution-step.models.js","sourceRoot":"","sources":["../../../../../src/lib/execution-screen/execution-step.models.ts"],"names":[],"mappings":"AAAA;;GAEG","sourcesContent":["/**\n * Models and interfaces for execution screen step components\n */\n\nexport type StepStatus = 'success' | 'failed' | 'pending' | 'running';\n\nexport interface TimingBreakdown {\n  app: number; // in seconds\n  tool: number; // in seconds\n}\n\nexport interface SubStep {\n  id: string;\n  description: string;\n  status: StepStatus;\n  duration: number; // in seconds\n  timestamp?: string; // optional timestamp like \"00:12\"\n}\n\nexport interface LoopIteration {\n  id: string;\n  label: string; // e.g., \"Iter 2 (production)\"\n  status: StepStatus;\n  subSteps?: SubStep[];\n}\n\nexport interface ConditionBranch {\n  type: 'if' | 'else' | 'else if';\n  label: string; // e.g., \"Premium user\" or \"Free user\"\n  executed: boolean;\n  subSteps?: SubStep[];\n}\n\nexport interface ScreenshotData {\n  baseline?: string; // URL or base64\n  current?: string; // URL or base64\n  difference?: string; // URL or base64\n}\n\nexport interface LogEntry {\n  level: 'info' | 'warning' | 'error';\n  message: string;\n  timestamp?: string;\n}\n\nexport interface FailureDetails {\n  expected: string;\n  actual: string;\n  failedAction?: string; // The action that failed\n  aiFixApplied?: boolean;\n  aiFixMessage?: string;\n  screenshots?: ScreenshotData;\n  logs?: LogEntry[];\n}\n\nexport interface BaseStepConfig {\n  id: string;\n  testStepResultId: string;\n  stepNumber: string; // e.g., \"1\", \"2.1\", \"3.2.1\"\n  title: string;\n  status: StepStatus;\n  duration: number; // total duration in seconds\n  timingBreakdown?: TimingBreakdown;\n  expanded?: boolean; // whether the step is expanded by default\n  failureDetails?: FailureDetails;\n  reasoning?: string[];\n  confidence?: string;\n}\n\nexport interface SelfHealAnalysisData {\n  originalLocator: string;\n  healedLocator: string;\n  confidence: number; // 0-100\n  healMethod: string; // e.g., \"Semantic Attribute Matching\"\n}\n\nexport type SelfHealAction = 'accept' | 'reject' | 'modify-accept';\n\nexport interface BasicStepConfig extends BaseStepConfig {\n  type: 'basic';\n  subSteps: SubStep[];\n  selfHealAnalysis?: SelfHealAnalysisData;\n  selfHealed?: boolean; // Indicates if self-healing was applied\n  selfHealDuration?: number; // Duration of self-healing process\n}\n\nexport interface StepGroupConfig extends BaseStepConfig {\n  type: 'step-group';\n  groupName: string; // e.g., \"Navigation\", \"Checkout flow\"\n  steps: ExecutionStepConfig[]; // nested steps\n}\n\nexport interface LoopStepConfig extends BaseStepConfig {\n  type: 'loop';\n  loopType?: 'for' | 'while';\n  iterations: LoopIteration[];\n  selectedIterationId?: string; // which iteration to display\n  defaultIteration?: 'first' | 'last'; // default iteration to show\n  nestedSteps?: ExecutionStepConfig[]; // steps nested within the loop\n  showViewAllIterations?: boolean;\n}\n\nexport interface ConditionStepConfig extends BaseStepConfig {\n  type: 'condition';\n  conditionText: string; // e.g., \"if user type is 'Premium'\"\n  branches: ConditionBranch[];\n}\n\nexport interface FailedStepConfig extends BaseStepConfig {\n  type: 'failed';\n  subSteps: SubStep[];\n  failureDetails: FailureDetails;\n  reasoning?: string[];\n  confidence?: string;\n}\n\nexport interface AIAgentAction {\n  id: string;\n  description: string;\n  type: 'extract' | 'validate' | 'AI_AGENT_ACTION' | 'TYPE' | 'CLICK';\n  status: StepStatus;\n  confidence?: number; // 0-100\n  duration: number;\n}\n\nexport interface AIAgentStepConfig extends BaseStepConfig {\n  type: 'ai-agent';\n  prompt: string;\n  optimizedRun?: boolean;\n  actionCount?: number;\n  actions: AIAgentAction[];\n  selectedTab?: 'action-trace' | 'planner-timeline' | 'ai-reasoning';\n}\n\nexport interface ApiAssertion {\n  id: string;\n  description: string;\n  status: 'passed' | 'failed';\n  expected: string;\n  actual: string;\n}\n\nexport interface ApiStepConfig extends BaseStepConfig {\n  type: 'api';\n  method: string; // GET, POST, PUT, DELETE, etc.\n  endpoint: string;\n  statusCode: number;\n  responseTime: number; // in milliseconds\n  requestBody?: any;\n  responseBody?: any;\n  requestHeaders?: any;\n  responseHeaders?: any;\n  assertions?: ApiAssertion[];\n  initialActions?: SubStep[]; // Actions before the API call\n}\n\nexport interface FileDownloadStepConfig extends BaseStepConfig {\n  type: 'file-download';\n  fileName: string;\n  fileType: string; // PDF, CSV, etc.\n  fileSize?: string; // e.g., \"2.4 MB\"\n  filePath?: string;\n  downloaded: boolean;\n}\n\nexport interface ExtractedField {\n  label: string;\n  value: string;\n  confidence: number; // 0-100\n}\n\nexport interface VerificationCheck {\n  id: string;\n  description: string;\n  status: 'pass' | 'fail';\n  expected: string;\n  actual: string;\n}\n\nexport interface DocumentVerificationStepConfig extends BaseStepConfig {\n  type: 'document-verification';\n  documentScreenshot?: string; // URL or base64\n  extractedFields: ExtractedField[];\n  verificationChecks: VerificationCheck[];\n}\n\nexport interface LiveSubStep {\n  id: string;\n  text: string; // Text from socket\n  isRunning: boolean; // true = show loader, false = show icon\n  duration?: number; // in seconds\n}\n\nexport interface LiveExecutionStepConfig extends BaseStepConfig {\n  type: 'live-execution';\n  subSteps: LiveSubStep[];\n}\n\nexport interface PrerequisiteItem {\n  id: string;\n  title: string; // e.g., \"Prerequisite 1: Login flow\"\n  status: StepStatus;\n  duration: number; // in seconds\n  stepConfig?: ExecutionStepConfig; // Optional: full step config to view details\n}\n\nexport type ExecutionStepConfig =\n  | BasicStepConfig\n  | StepGroupConfig\n  | LoopStepConfig\n  | ConditionStepConfig\n  | FailedStepConfig\n  | AIAgentStepConfig\n  | ApiStepConfig\n  | FileDownloadStepConfig\n  | DocumentVerificationStepConfig\n  | LiveExecutionStepConfig;\n"]}

package/esm2020/lib/execution-screen/live-execution-step/live-execution-step.component.mjs CHANGED Viewed

@@ -100,10 +100,10 @@ export class LiveExecutionStepComponent extends BaseStepComponent {
     }
 }
 LiveExecutionStepComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: LiveExecutionStepComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-LiveExecutionStepComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: LiveExecutionStepComponent, selector: "cqa-live-execution-step", inputs: { id: "id", testStepResultId: "testStepResultId", stepNumber: "stepNumber", title: "title", status: "status", duration: "duration", expanded: "expanded", subSteps: "subSteps" }, host: { classAttribute: "cqa-ui-root" }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div>\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggle()\"\n    style=\"border-bottom: '1px solid #F3F4F6'\"\n    >\n    \n    <!-- Status Icon -->\n    <div class=\"cqa-flex cqa-items-center cqa-justify-center\">\n      <!-- Success -->\n      <svg *ngIf=\"status.toLowerCase() === 'success'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Failed -->\n      <svg *ngIf=\"status.toLowerCase() === 'failure'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4 4L8 8M8 4L4 8\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Pending -->\n      <svg *ngIf=\"status.toLowerCase() === 'pending'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Running - Show spinner -->\n      <svg *ngIf=\"status.toLowerCase() === 'running'\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n        <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n        <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n      </svg>\n    </div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-font-bold cqa-flex-1 cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n      {{ stepNumber }}. <span [innerHTML]=\"title\"></span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n      <span class=\"cqa-text-[9px] cqa-leading-[11px] cqa-text-[#9CA3AF]\">\n        {{ formatDuration(duration) }}\n      </span>\n      <svg *ngIf=\"hasSubSteps\" [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && hasSubSteps\">\n    <!-- Sub-steps -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pt-1 cqa-pl-9\">\n      <div\n        *ngFor=\"let subStep of subSteps; trackBy: trackBySubStepId\"\n        class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n        \n        <!-- Sub-step Status Icon or Loader -->\n        <div class=\"cqa-flex cqa-items-center cqa-justify-center cqa-w-3 cqa-h-3\">\n          <!-- Loader when running -->\n          <svg *ngIf=\"subStep.isRunning\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n            <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n          </svg>\n          \n          <!-- Success Icon when complete -->\n          <svg *ngIf=\"!subStep.isRunning\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n            <path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n          </svg>\n        </div>\n\n        <!-- Sub-step Description (text from socket) with typing animation -->\n        <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n          <ngx-typed-js \n            *ngIf=\"subStep.isRunning && subStep.text\"\n            [strings]=\"[subStep.text]\"\n            [typeSpeed]=\"30\"\n            [showCursor]=\"false\"\n            [fadeOut]=\"false\">\n            <span class=\"typing\"></span>\n          </ngx-typed-js>\n          <span *ngIf=\"!subStep.isRunning\">{{ subStep.text }}</span>\n        </span>\n      </div>\n    </div>\n  </div>\n</div>\n\n", components: [{ type: i1.NgxTypedJsComponent, selector: "ngx-typed-js", inputs: ["cursorColor", "strings", "stringsElement", "typeSpeed", "startDelay", "backSpeed", "smartBackspace", "shuffle", "backDelay", "fadeOut", "fadeOutClass", "fadeOutDelay", "loop", "loopCount", "showCursor", "cursorChar", "autoInsertCss", "attr", "bindInputFocusEvents", "contentType"], outputs: ["completed", "preStringTyped", "stringTyped", "lastStringBackspaced", "typingPaused", "typingResumed", "reset", "stopped", "started", "destroyed"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+LiveExecutionStepComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: LiveExecutionStepComponent, selector: "cqa-live-execution-step", inputs: { id: "id", testStepResultId: "testStepResultId", stepNumber: "stepNumber", title: "title", status: "status", duration: "duration", expanded: "expanded", subSteps: "subSteps" }, host: { classAttribute: "cqa-ui-root" }, usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div>\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggle()\"\n    style=\"border-bottom: '1px solid #F3F4F6'\"\n    >\n    \n    <!-- Status Icon -->\n    <div class=\"cqa-flex cqa-items-center cqa-justify-center\">\n      <!-- Success -->\n      <svg *ngIf=\"status.toLowerCase() === 'success'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Failed -->\n      <svg *ngIf=\"status.toLowerCase() === 'failure'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4 4L8 8M8 4L4 8\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Pending -->\n      <svg *ngIf=\"status.toLowerCase() === 'pending'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Running - Show spinner -->\n      <svg *ngIf=\"status.toLowerCase() === 'running'\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n        <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n        <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n      </svg>\n    </div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-font-bold cqa-flex-1 cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n      {{ stepNumber }}. <span [innerHTML]=\"title\"></span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n      <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-text-[#9CA3AF] cqa-font-medium\">\n        {{ formatDuration(duration) }}\n      </span>\n      <svg *ngIf=\"hasSubSteps\" [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && hasSubSteps\">\n    <!-- Sub-steps -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pt-1 cqa-pl-9\">\n      <div\n        *ngFor=\"let subStep of subSteps; trackBy: trackBySubStepId\"\n        class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n        \n        <!-- Sub-step Status Icon or Loader -->\n        <div class=\"cqa-flex cqa-items-center cqa-justify-center cqa-w-3 cqa-h-3\">\n          <!-- Loader when running -->\n          <svg *ngIf=\"subStep.isRunning\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n            <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n          </svg>\n          \n          <!-- Success Icon when complete -->\n          <svg *ngIf=\"!subStep.isRunning\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n            <path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n          </svg>\n        </div>\n\n        <!-- Sub-step Description (text from socket) with typing animation -->\n        <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n          <ngx-typed-js \n            *ngIf=\"subStep.isRunning && subStep.text\"\n            [strings]=\"[subStep.text]\"\n            [typeSpeed]=\"30\"\n            [showCursor]=\"false\"\n            [fadeOut]=\"false\">\n            <span class=\"typing\"></span>\n          </ngx-typed-js>\n          <span *ngIf=\"!subStep.isRunning\">{{ subStep.text }}</span>\n        </span>\n        <span *ngIf=\"subStep.duration\" class=\"cqa-text-[10px] cqa-leading-[15px] cqa-text-[#6A7282] cqa-font-medium\">\n          {{ formatDuration(subStep.duration) }}\n        </span>\n      </div>\n    </div>\n  </div>\n</div>\n\n", components: [{ type: i1.NgxTypedJsComponent, selector: "ngx-typed-js", inputs: ["cursorColor", "strings", "stringsElement", "typeSpeed", "startDelay", "backSpeed", "smartBackspace", "shuffle", "backDelay", "fadeOut", "fadeOutClass", "fadeOutDelay", "loop", "loopCount", "showCursor", "cursorChar", "autoInsertCss", "attr", "bindInputFocusEvents", "contentType"], outputs: ["completed", "preStringTyped", "stringTyped", "lastStringBackspaced", "typingPaused", "typingResumed", "reset", "stopped", "started", "destroyed"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: LiveExecutionStepComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'cqa-live-execution-step', host: { class: 'cqa-ui-root' }, template: "<div>\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggle()\"\n    style=\"border-bottom: '1px solid #F3F4F6'\"\n    >\n    \n    <!-- Status Icon -->\n    <div class=\"cqa-flex cqa-items-center cqa-justify-center\">\n      <!-- Success -->\n      <svg *ngIf=\"status.toLowerCase() === 'success'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Failed -->\n      <svg *ngIf=\"status.toLowerCase() === 'failure'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4 4L8 8M8 4L4 8\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Pending -->\n      <svg *ngIf=\"status.toLowerCase() === 'pending'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Running - Show spinner -->\n      <svg *ngIf=\"status.toLowerCase() === 'running'\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n        <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n        <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n      </svg>\n    </div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-font-bold cqa-flex-1 cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n      {{ stepNumber }}. <span [innerHTML]=\"title\"></span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n      <span class=\"cqa-text-[9px] cqa-leading-[11px] cqa-text-[#9CA3AF]\">\n        {{ formatDuration(duration) }}\n      </span>\n      <svg *ngIf=\"hasSubSteps\" [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && hasSubSteps\">\n    <!-- Sub-steps -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pt-1 cqa-pl-9\">\n      <div\n        *ngFor=\"let subStep of subSteps; trackBy: trackBySubStepId\"\n        class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n        \n        <!-- Sub-step Status Icon or Loader -->\n        <div class=\"cqa-flex cqa-items-center cqa-justify-center cqa-w-3 cqa-h-3\">\n          <!-- Loader when running -->\n          <svg *ngIf=\"subStep.isRunning\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n            <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n          </svg>\n          \n          <!-- Success Icon when complete -->\n          <svg *ngIf=\"!subStep.isRunning\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n            <path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n          </svg>\n        </div>\n\n        <!-- Sub-step Description (text from socket) with typing animation -->\n        <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n          <ngx-typed-js \n            *ngIf=\"subStep.isRunning && subStep.text\"\n            [strings]=\"[subStep.text]\"\n            [typeSpeed]=\"30\"\n            [showCursor]=\"false\"\n            [fadeOut]=\"false\">\n            <span class=\"typing\"></span>\n          </ngx-typed-js>\n          <span *ngIf=\"!subStep.isRunning\">{{ subStep.text }}</span>\n        </span>\n      </div>\n    </div>\n  </div>\n</div>\n\n", styles: [] }]
+            args: [{ selector: 'cqa-live-execution-step', host: { class: 'cqa-ui-root' }, template: "<div>\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggle()\"\n    style=\"border-bottom: '1px solid #F3F4F6'\"\n    >\n    \n    <!-- Status Icon -->\n    <div class=\"cqa-flex cqa-items-center cqa-justify-center\">\n      <!-- Success -->\n      <svg *ngIf=\"status.toLowerCase() === 'success'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Failed -->\n      <svg *ngIf=\"status.toLowerCase() === 'failure'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4 4L8 8M8 4L4 8\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Pending -->\n      <svg *ngIf=\"status.toLowerCase() === 'pending'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Running - Show spinner -->\n      <svg *ngIf=\"status.toLowerCase() === 'running'\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n        <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n        <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n      </svg>\n    </div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-font-bold cqa-flex-1 cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n      {{ stepNumber }}. <span [innerHTML]=\"title\"></span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n      <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-text-[#9CA3AF] cqa-font-medium\">\n        {{ formatDuration(duration) }}\n      </span>\n      <svg *ngIf=\"hasSubSteps\" [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && hasSubSteps\">\n    <!-- Sub-steps -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pt-1 cqa-pl-9\">\n      <div\n        *ngFor=\"let subStep of subSteps; trackBy: trackBySubStepId\"\n        class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n        \n        <!-- Sub-step Status Icon or Loader -->\n        <div class=\"cqa-flex cqa-items-center cqa-justify-center cqa-w-3 cqa-h-3\">\n          <!-- Loader when running -->\n          <svg *ngIf=\"subStep.isRunning\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n            <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n          </svg>\n          \n          <!-- Success Icon when complete -->\n          <svg *ngIf=\"!subStep.isRunning\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n            <path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n          </svg>\n        </div>\n\n        <!-- Sub-step Description (text from socket) with typing animation -->\n        <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n          <ngx-typed-js \n            *ngIf=\"subStep.isRunning && subStep.text\"\n            [strings]=\"[subStep.text]\"\n            [typeSpeed]=\"30\"\n            [showCursor]=\"false\"\n            [fadeOut]=\"false\">\n            <span class=\"typing\"></span>\n          </ngx-typed-js>\n          <span *ngIf=\"!subStep.isRunning\">{{ subStep.text }}</span>\n        </span>\n        <span *ngIf=\"subStep.duration\" class=\"cqa-text-[10px] cqa-leading-[15px] cqa-text-[#6A7282] cqa-font-medium\">\n          {{ formatDuration(subStep.duration) }}\n        </span>\n      </div>\n    </div>\n  </div>\n</div>\n\n", styles: [] }]
         }], propDecorators: { id: [{
                 type: Input
             }], testStepResultId: [{
@@ -121,4 +121,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
             }], subSteps: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-execution-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/execution-screen/live-execution-step/live-execution-step.component.ts","../../../../../../src/lib/execution-screen/live-execution-step/live-execution-step.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, OnChanges, SimpleChanges } from '@angular/core';\nimport { BaseStepConfig, StepStatus, LiveSubStep, LiveExecutionStepConfig } from '../execution-step.models';\nimport { BaseStepComponent } from '../base-step.component';\n\n@Component({\n  selector: 'cqa-live-execution-step',\n  templateUrl: './live-execution-step.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' }\n})\nexport class LiveExecutionStepComponent extends BaseStepComponent implements OnInit, OnChanges {\n  // Individual inputs\n  @Input() id!: string;\n  @Input() testStepResultId!: string;\n  @Input() stepNumber!: string;\n  @Input() title!: string;\n  @Input() status!: StepStatus;\n  @Input() duration!: number;\n  @Input() expanded?: boolean;\n  @Input() subSteps: LiveSubStep[] = [];\n\n  // Config property for base class - built from individual inputs in ngOnInit\n  override config!: LiveExecutionStepConfig;\n  \n  // Track previous status to detect when step starts executing\n  private previousStatus?: StepStatus;\n  private userManuallyClosed: boolean = false;\n\n  override ngOnInit(): void {\n    // Build config from individual inputs\n    this.config = {\n      id: this.id,\n      testStepResultId: this.testStepResultId,\n      stepNumber: this.stepNumber,\n      title: this.title,\n      status: this.status,\n      duration: this.duration,\n      type: 'live-execution',\n      subSteps: this.subSteps || [],\n      expanded: this.expanded,\n    } as LiveExecutionStepConfig;\n\n    super.ngOnInit();\n    \n    // Initialize previous status\n    this.previousStatus = this.status;\n    \n    // Auto-expand if step is running and has subSteps on init\n    if (this.status === 'running' && this.hasSubSteps && !this.isExpanded) {\n      this.autoExpand();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // Update subSteps array when new ones are added\n    if (changes['subSteps']) {\n      const previousSubStepsCount = changes['subSteps'].previousValue?.length || 0;\n      const currentSubStepsCount = (this.subSteps || []).length;\n      \n      // Sub-steps are appended externally, so we just update the config\n      if (this.config) {\n        this.config.subSteps = this.subSteps || [];\n      }\n      \n      // Auto-expand if step is running and new subSteps are added (logs coming in)\n      if (!changes['subSteps'].firstChange && \n          this.status === 'running' && \n          currentSubStepsCount > previousSubStepsCount &&\n          this.hasSubSteps && \n          !this.isExpanded && \n          !this.userManuallyClosed) {\n        this.autoExpand();\n      }\n    }\n    \n    // Handle status changes - auto-expand when step starts executing\n    if (changes['status'] && !changes['status'].firstChange) {\n      const newStatus = changes['status'].currentValue;\n      const oldStatus = changes['status'].previousValue;\n      \n      // Auto-expand when status changes to 'running' and has subSteps (or will have soon)\n      if (newStatus === 'running' && oldStatus !== 'running' && !this.userManuallyClosed) {\n        // Expand immediately if already has subSteps, or wait for them\n        if (this.hasSubSteps) {\n          this.autoExpand();\n        }\n      }\n      \n      this.previousStatus = newStatus;\n    }\n    \n    // Update expanded state from parent (sync with parent's state)\n    if (changes['expanded']) {\n      const newExpanded = changes['expanded'].currentValue ?? false;\n      if (newExpanded !== this.isExpanded) {\n        this.isExpanded = newExpanded;\n        // Reset manual close flag if parent explicitly expands\n        if (newExpanded) {\n          this.userManuallyClosed = false;\n        }\n      }\n    }\n  }\n\n  override toggle(): void {\n    // Track if user manually closes the step\n    if (this.isExpanded) {\n      this.userManuallyClosed = true;\n    } else {\n      // Reset flag when user opens it\n      this.userManuallyClosed = false;\n    }\n    \n    super.toggle();\n  }\n\n  private autoExpand(): void {\n    if (!this.isExpanded && this.hasSubSteps) {\n      this.isExpanded = true;\n      this.userManuallyClosed = false;\n      this.toggleExpanded.emit(true);\n    }\n  }\n\n  get hasSubSteps(): boolean {\n    return this.subSteps && this.subSteps.length > 0;\n  }\n\n  trackBySubStepId(index: number, subStep: LiveSubStep): string {\n    return subStep.id;\n  }\n}\n\n","<div>\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggle()\"\n    style=\"border-bottom: '1px solid #F3F4F6'\"\n    >\n    \n    <!-- Status Icon -->\n    <div class=\"cqa-flex cqa-items-center cqa-justify-center\">\n      <!-- Success -->\n      <svg *ngIf=\"status.toLowerCase() === 'success'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Failed -->\n      <svg *ngIf=\"status.toLowerCase() === 'failure'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4 4L8 8M8 4L4 8\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Pending -->\n      <svg *ngIf=\"status.toLowerCase() === 'pending'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Running - Show spinner -->\n      <svg *ngIf=\"status.toLowerCase() === 'running'\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n        <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n        <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n      </svg>\n    </div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-font-bold cqa-flex-1 cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n      {{ stepNumber }}. <span [innerHTML]=\"title\"></span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n      <span class=\"cqa-text-[9px] cqa-leading-[11px] cqa-text-[#9CA3AF]\">\n        {{ formatDuration(duration) }}\n      </span>\n      <svg *ngIf=\"hasSubSteps\" [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && hasSubSteps\">\n    <!-- Sub-steps -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pt-1 cqa-pl-9\">\n      <div\n        *ngFor=\"let subStep of subSteps; trackBy: trackBySubStepId\"\n        class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n        \n        <!-- Sub-step Status Icon or Loader -->\n        <div class=\"cqa-flex cqa-items-center cqa-justify-center cqa-w-3 cqa-h-3\">\n          <!-- Loader when running -->\n          <svg *ngIf=\"subStep.isRunning\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n            <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n          </svg>\n          \n          <!-- Success Icon when complete -->\n          <svg *ngIf=\"!subStep.isRunning\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n            <path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n          </svg>\n        </div>\n\n        <!-- Sub-step Description (text from socket) with typing animation -->\n        <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n          <ngx-typed-js \n            *ngIf=\"subStep.isRunning && subStep.text\"\n            [strings]=\"[subStep.text]\"\n            [typeSpeed]=\"30\"\n            [showCursor]=\"false\"\n            [fadeOut]=\"false\">\n            <span class=\"typing\"></span>\n          </ngx-typed-js>\n          <span *ngIf=\"!subStep.isRunning\">{{ subStep.text }}</span>\n        </span>\n      </div>\n    </div>\n  </div>\n</div>\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-execution-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/execution-screen/live-execution-step/live-execution-step.component.ts","../../../../../../src/lib/execution-screen/live-execution-step/live-execution-step.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, OnChanges, SimpleChanges } from '@angular/core';\nimport { BaseStepConfig, StepStatus, LiveSubStep, LiveExecutionStepConfig } from '../execution-step.models';\nimport { BaseStepComponent } from '../base-step.component';\n\n@Component({\n  selector: 'cqa-live-execution-step',\n  templateUrl: './live-execution-step.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' }\n})\nexport class LiveExecutionStepComponent extends BaseStepComponent implements OnInit, OnChanges {\n  // Individual inputs\n  @Input() id!: string;\n  @Input() testStepResultId!: string;\n  @Input() stepNumber!: string;\n  @Input() title!: string;\n  @Input() status!: StepStatus;\n  @Input() duration!: number;\n  @Input() expanded?: boolean;\n  @Input() subSteps: LiveSubStep[] = [];\n\n  // Config property for base class - built from individual inputs in ngOnInit\n  override config!: LiveExecutionStepConfig;\n  \n  // Track previous status to detect when step starts executing\n  private previousStatus?: StepStatus;\n  private userManuallyClosed: boolean = false;\n\n  override ngOnInit(): void {\n    // Build config from individual inputs\n    this.config = {\n      id: this.id,\n      testStepResultId: this.testStepResultId,\n      stepNumber: this.stepNumber,\n      title: this.title,\n      status: this.status,\n      duration: this.duration,\n      type: 'live-execution',\n      subSteps: this.subSteps || [],\n      expanded: this.expanded,\n    } as LiveExecutionStepConfig;\n\n    super.ngOnInit();\n    \n    // Initialize previous status\n    this.previousStatus = this.status;\n    \n    // Auto-expand if step is running and has subSteps on init\n    if (this.status === 'running' && this.hasSubSteps && !this.isExpanded) {\n      this.autoExpand();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    // Update subSteps array when new ones are added\n    if (changes['subSteps']) {\n      const previousSubStepsCount = changes['subSteps'].previousValue?.length || 0;\n      const currentSubStepsCount = (this.subSteps || []).length;\n      \n      // Sub-steps are appended externally, so we just update the config\n      if (this.config) {\n        this.config.subSteps = this.subSteps || [];\n      }\n      \n      // Auto-expand if step is running and new subSteps are added (logs coming in)\n      if (!changes['subSteps'].firstChange && \n          this.status === 'running' && \n          currentSubStepsCount > previousSubStepsCount &&\n          this.hasSubSteps && \n          !this.isExpanded && \n          !this.userManuallyClosed) {\n        this.autoExpand();\n      }\n    }\n    \n    // Handle status changes - auto-expand when step starts executing\n    if (changes['status'] && !changes['status'].firstChange) {\n      const newStatus = changes['status'].currentValue;\n      const oldStatus = changes['status'].previousValue;\n      \n      // Auto-expand when status changes to 'running' and has subSteps (or will have soon)\n      if (newStatus === 'running' && oldStatus !== 'running' && !this.userManuallyClosed) {\n        // Expand immediately if already has subSteps, or wait for them\n        if (this.hasSubSteps) {\n          this.autoExpand();\n        }\n      }\n      \n      this.previousStatus = newStatus;\n    }\n    \n    // Update expanded state from parent (sync with parent's state)\n    if (changes['expanded']) {\n      const newExpanded = changes['expanded'].currentValue ?? false;\n      if (newExpanded !== this.isExpanded) {\n        this.isExpanded = newExpanded;\n        // Reset manual close flag if parent explicitly expands\n        if (newExpanded) {\n          this.userManuallyClosed = false;\n        }\n      }\n    }\n  }\n\n  override toggle(): void {\n    // Track if user manually closes the step\n    if (this.isExpanded) {\n      this.userManuallyClosed = true;\n    } else {\n      // Reset flag when user opens it\n      this.userManuallyClosed = false;\n    }\n    \n    super.toggle();\n  }\n\n  private autoExpand(): void {\n    if (!this.isExpanded && this.hasSubSteps) {\n      this.isExpanded = true;\n      this.userManuallyClosed = false;\n      this.toggleExpanded.emit(true);\n    }\n  }\n\n  get hasSubSteps(): boolean {\n    return this.subSteps && this.subSteps.length > 0;\n  }\n\n  trackBySubStepId(index: number, subStep: LiveSubStep): string {\n    return subStep.id;\n  }\n}\n\n","<div>\n  <!-- Header -->\n  <div\n    class=\"cqa-flex cqa-items-center cqa-gap-2 cqa-p-2 cqa-cursor-pointer\"\n    (click)=\"toggle()\"\n    style=\"border-bottom: '1px solid #F3F4F6'\"\n    >\n    \n    <!-- Status Icon -->\n    <div class=\"cqa-flex cqa-items-center cqa-justify-center\">\n      <!-- Success -->\n      <svg *ngIf=\"status.toLowerCase() === 'success'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10.9005 4.99999C11.1289 6.12064 10.9662 7.28571 10.4395 8.30089C9.91279 9.31608 9.054 10.12 8.00631 10.5787C6.95862 11.0373 5.78536 11.1229 4.6822 10.8212C3.57904 10.5195 2.61265 9.84869 1.94419 8.92071C1.27573 7.99272 0.945611 6.86361 1.00888 5.72169C1.07215 4.57976 1.52499 3.49404 2.29188 2.64558C3.05876 1.79712 4.09334 1.23721 5.22308 1.05922C6.35282 0.881233 7.50944 1.09592 8.50005 1.66749\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.5 5.5L6 7L11 2\" stroke=\"#22C55E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Failed -->\n      <svg *ngIf=\"status.toLowerCase() === 'failure'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4 4L8 8M8 4L4 8\" stroke=\"#EF4444\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Pending -->\n      <svg *ngIf=\"status.toLowerCase() === 'pending'\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M6 3V6L8 7\" stroke=\"#9CA3AF\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      <!-- Running - Show spinner -->\n      <svg *ngIf=\"status.toLowerCase() === 'running'\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n        <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n        <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n      </svg>\n    </div>\n\n    <!-- Step Number and Title -->\n    <div class=\"cqa-font-bold cqa-flex-1 cqa-text-[#334155] cqa-text-[11px] cqa-leading-[13px]\">\n      {{ stepNumber }}. <span [innerHTML]=\"title\"></span>\n    </div>\n\n    <div class=\"cqa-flex cqa-items-center cqa-gap-1\">\n      <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-text-[#9CA3AF] cqa-font-medium\">\n        {{ formatDuration(duration) }}\n      </span>\n      <svg *ngIf=\"hasSubSteps\" [class.cqa-rotate-180]=\"isExpanded\" class=\"cqa-transition-transform\" width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M3.5 5L7 8.5L10.5 5\" stroke=\"#9CA3AF\" stroke-width=\"0.833333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </div>\n  </div>\n\n  <!-- Expanded Content -->\n  <div *ngIf=\"isExpanded && hasSubSteps\">\n    <!-- Sub-steps -->\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-1 cqa-pt-1 cqa-pl-9\">\n      <div\n        *ngFor=\"let subStep of subSteps; trackBy: trackBySubStepId\"\n        class=\"cqa-flex cqa-items-center cqa-gap-3 cqa-py-[5.5px] cqa-px-3\">\n        \n        <!-- Sub-step Status Icon or Loader -->\n        <div class=\"cqa-flex cqa-items-center cqa-justify-center cqa-w-3 cqa-h-3\">\n          <!-- Loader when running -->\n          <svg *ngIf=\"subStep.isRunning\" class=\"cqa-animate-spin cqa-text-[#3B82F6]\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <circle cx=\"6\" cy=\"6\" r=\"5\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" opacity=\"0.25\"/>\n            <path d=\"M6 1A5 5 0 0 1 11 6\" stroke=\"currentColor\" stroke-width=\"1.5\" fill=\"none\" stroke-linecap=\"round\"/>\n          </svg>\n          \n          <!-- Success Icon when complete -->\n          <svg *ngIf=\"!subStep.isRunning\" width=\"12\" height=\"12\" viewBox=\"0 0 12 12\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n            <path d=\"M6 11C8.76142 11 11 8.76142 11 6C11 3.23858 8.76142 1 6 1C3.23858 1 1 3.23858 1 6C1 8.76142 3.23858 11 6 11Z\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n            <path d=\"M4.5 6L5.5 7L7.5 5\" stroke=\"#00A63E\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/>\n          </svg>\n        </div>\n\n        <!-- Sub-step Description (text from socket) with typing animation -->\n        <span class=\"cqa-flex-1 cqa-text-[11px] cqa-leading-[13px] cqa-text-[#364153]\">\n          <ngx-typed-js \n            *ngIf=\"subStep.isRunning && subStep.text\"\n            [strings]=\"[subStep.text]\"\n            [typeSpeed]=\"30\"\n            [showCursor]=\"false\"\n            [fadeOut]=\"false\">\n            <span class=\"typing\"></span>\n          </ngx-typed-js>\n          <span *ngIf=\"!subStep.isRunning\">{{ subStep.text }}</span>\n        </span>\n        <span *ngIf=\"subStep.duration\" class=\"cqa-text-[10px] cqa-leading-[15px] cqa-text-[#6A7282] cqa-font-medium\">\n          {{ formatDuration(subStep.duration) }}\n        </span>\n      </div>\n    </div>\n  </div>\n</div>\n\n"]}