@cqa-lib/cqa-ui 1.1.158 → 1.1.160

package/esm2020/lib/test-case-details/test-case-details-renderer/test-case-details-renderer.component.mjs

@@ -0,0 +1,224 @@
+import { Component, Input, Output, EventEmitter, ViewChild, ViewContainerRef, Inject, } from '@angular/core';
+import { TEST_CASE_STEP_COMPONENT_MAP } from '../test-case-step-components.token';
+import { isStepGroupConfig, isConditionStepConfig, isLoopStepConfig, isNormalStepConfig, isApiStepConfig, isDatabaseStepConfig, isAiAgentStepConfig, isUploadStepConfig, isScreenshotStepConfig, isCustomCodeStepConfig, } from '../test-case-step.models';
+import * as i0 from "@angular/core";
+export class TestCaseDetailsRendererComponent {
+    constructor(componentMap, cdr) {
+        this.componentMap = componentMap;
+        this.cdr = cdr;
+        this.isNested = false;
+        this.isInsideLoop = false;
+        this.nestedStepChange = new EventEmitter();
+        this.addStep = new EventEmitter();
+        this.deleteStep = new EventEmitter();
+        this.toggleExpanded = new EventEmitter();
+        this.groupNameChange = new EventEmitter();
+        this.descriptionChange = new EventEmitter();
+        this.reusableChange = new EventEmitter();
+        this.openExternal = new EventEmitter();
+        this.edit = new EventEmitter();
+        this.link = new EventEmitter();
+        this.duplicate = new EventEmitter();
+        this.delete = new EventEmitter();
+        this.viewDetails = new EventEmitter();
+        this.selectionChange = new EventEmitter();
+        this.conditionChange = new EventEmitter();
+        this.branchStepChange = new EventEmitter();
+        this.addStepForBranch = new EventEmitter();
+        this.deleteStepWithBranch = new EventEmitter();
+        this.addBranch = new EventEmitter();
+        this.deleteBranch = new EventEmitter();
+        this.testDataProfileChange = new EventEmitter();
+        this.startStepChange = new EventEmitter();
+        this.endStepChange = new EventEmitter();
+        this.maxIterationsChange = new EventEmitter();
+        this.eventTypeChange = new EventEmitter();
+        this.parameterChange = new EventEmitter();
+        this.componentRef = null;
+    }
+    ngAfterViewInit() {
+        this.renderStep();
+    }
+    ngOnChanges(changes) {
+        if (changes['step'] || changes['index'] || changes['isNested'] || changes['isInsideLoop']) {
+            this.renderStep();
+        }
+    }
+    getComponentType(step) {
+        if (isStepGroupConfig(step))
+            return this.componentMap.stepGroup;
+        if (isConditionStepConfig(step))
+            return this.componentMap.conditionStep;
+        if (isLoopStepConfig(step))
+            return this.componentMap.loopStep;
+        if (isApiStepConfig(step))
+            return this.componentMap.apiStep;
+        if (isDatabaseStepConfig(step))
+            return this.componentMap.databaseStep;
+        if (isAiAgentStepConfig(step))
+            return this.componentMap.aiAgentStep;
+        if (isUploadStepConfig(step))
+            return this.componentMap.uploadStep;
+        if (isScreenshotStepConfig(step))
+            return this.componentMap.screenshotStep;
+        if (isCustomCodeStepConfig(step))
+            return this.componentMap.customCodeStep;
+        if (isNormalStepConfig(step))
+            return this.componentMap.normalStep;
+        return null;
+    }
+    renderStep() {
+        if (!this.stepHost || !this.step)
+            return;
+        const componentType = this.getComponentType(this.step);
+        if (!componentType)
+            return;
+        this.stepHost.clear();
+        this.componentRef = this.stepHost.createComponent(componentType);
+        const instance = this.componentRef.instance;
+        instance.config = this.step;
+        instance.stepNumber = this.step.stepNumber;
+        instance.isNested = this.isNested;
+        instance.isInsideLoop = this.isInsideLoop;
+        Object.keys(this.step).forEach((key) => {
+            if (key !== 'stepType' && key !== 'nestedSteps' && key !== 'branches') {
+                instance[key] = this.step[key];
+            }
+        });
+        if (this.step.nestedSteps)
+            instance.nestedSteps = this.step.nestedSteps;
+        if (this.step.branches)
+            instance.branches = this.step.branches;
+        this.wireOutputs(instance);
+        this.cdr.detectChanges();
+    }
+    wireOutputs(instance) {
+        const wire = (key, emitter) => {
+            if (instance[key] && typeof instance[key].subscribe === 'function') {
+                instance[key].subscribe((v) => emitter.emit(v));
+            }
+        };
+        wire('nestedStepChange', this.nestedStepChange);
+        wire('addStep', {
+            emit: (v) => {
+                if (v != null && typeof v === 'object' && 'branch' in v)
+                    this.addStepForBranch.emit(v);
+                else
+                    this.addStep.emit(v);
+            },
+        });
+        wire('deleteStep', {
+            emit: (v) => {
+                if (v != null && typeof v === 'object' && 'branch' in v && 'stepIndex' in v)
+                    this.deleteStepWithBranch.emit(v);
+                else
+                    this.deleteStep.emit(v);
+            },
+        });
+        wire('toggleExpanded', {
+            emit: (v) => {
+                // Handle both boolean and object formats
+                // If it's an object with config and expanded, emit it as-is
+                // If it's just a boolean, emit it as-is
+                this.toggleExpanded.emit(v);
+            },
+        });
+        wire('groupNameChange', this.groupNameChange);
+        wire('descriptionChange', this.descriptionChange);
+        wire('reusableChange', this.reusableChange);
+        wire('openExternal', this.openExternal);
+        wire('edit', this.edit);
+        wire('link', this.link);
+        wire('duplicate', this.duplicate);
+        wire('delete', this.delete);
+        wire('viewDetails', this.viewDetails);
+        wire('selectionChange', this.selectionChange);
+        wire('conditionChange', this.conditionChange);
+        wire('branchStepChange', this.branchStepChange);
+        wire('addStepForBranch', this.addStepForBranch);
+        wire('deleteStepWithBranch', this.deleteStepWithBranch);
+        wire('addBranch', this.addBranch);
+        wire('deleteBranch', this.deleteBranch);
+        wire('testDataProfileChange', this.testDataProfileChange);
+        wire('startStepChange', this.startStepChange);
+        wire('endStepChange', this.endStepChange);
+        wire('maxIterationsChange', this.maxIterationsChange);
+        wire('eventTypeChange', this.eventTypeChange);
+        wire('parameterChange', this.parameterChange);
+    }
+}
+TestCaseDetailsRendererComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TestCaseDetailsRendererComponent, deps: [{ token: TEST_CASE_STEP_COMPONENT_MAP }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+TestCaseDetailsRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: TestCaseDetailsRendererComponent, selector: "cqa-test-case-details-renderer", inputs: { step: "step", index: "index", isNested: "isNested", isInsideLoop: "isInsideLoop", branch: "branch" }, outputs: { nestedStepChange: "nestedStepChange", addStep: "addStep", deleteStep: "deleteStep", toggleExpanded: "toggleExpanded", groupNameChange: "groupNameChange", descriptionChange: "descriptionChange", reusableChange: "reusableChange", openExternal: "openExternal", edit: "edit", link: "link", duplicate: "duplicate", delete: "delete", viewDetails: "viewDetails", selectionChange: "selectionChange", conditionChange: "conditionChange", branchStepChange: "branchStepChange", addStepForBranch: "addStepForBranch", deleteStepWithBranch: "deleteStepWithBranch", addBranch: "addBranch", deleteBranch: "deleteBranch", testDataProfileChange: "testDataProfileChange", startStepChange: "startStepChange", endStepChange: "endStepChange", maxIterationsChange: "maxIterationsChange", eventTypeChange: "eventTypeChange", parameterChange: "parameterChange" }, host: { classAttribute: "cqa-ui-root" }, viewQueries: [{ propertyName: "stepHost", first: true, predicate: ["stepHost"], descendants: true, read: ViewContainerRef }], usesOnChanges: true, ngImport: i0, template: "<div class=\"cqa-relative\">\n    <ng-container #stepHost></ng-container>\n    <button class=\"cqa-absolute cqa-top-[calc(100%-12px)] cqa-left-[50%] cqa-translate-x-[-50%] cqa-p-0 cqa-z-[1] cqa-hidden\">\n        <svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect x=\"1\" y=\"1\" width=\"21.1822\" height=\"22\" rx=\"10.5911\" fill=\"white\"/><rect x=\"1\" y=\"1\" width=\"21.1822\" height=\"22\" rx=\"10.5911\" stroke=\"#3F43EE\" stroke-width=\"2\"/><path d=\"M8.5 12H15.5\" stroke=\"#3F43EE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M12 8.5V15.5\" stroke=\"#3F43EE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </button>\n</div>" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TestCaseDetailsRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cqa-test-case-details-renderer', host: { class: 'cqa-ui-root' }, template: "<div class=\"cqa-relative\">\n    <ng-container #stepHost></ng-container>\n    <button class=\"cqa-absolute cqa-top-[calc(100%-12px)] cqa-left-[50%] cqa-translate-x-[-50%] cqa-p-0 cqa-z-[1] cqa-hidden\">\n        <svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect x=\"1\" y=\"1\" width=\"21.1822\" height=\"22\" rx=\"10.5911\" fill=\"white\"/><rect x=\"1\" y=\"1\" width=\"21.1822\" height=\"22\" rx=\"10.5911\" stroke=\"#3F43EE\" stroke-width=\"2\"/><path d=\"M8.5 12H15.5\" stroke=\"#3F43EE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M12 8.5V15.5\" stroke=\"#3F43EE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </button>\n</div>" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TEST_CASE_STEP_COMPONENT_MAP]
+                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { stepHost: [{
+                type: ViewChild,
+                args: ['stepHost', { read: ViewContainerRef }]
+            }], step: [{
+                type: Input
+            }], index: [{
+                type: Input
+            }], isNested: [{
+                type: Input
+            }], isInsideLoop: [{
+                type: Input
+            }], branch: [{
+                type: Input
+            }], nestedStepChange: [{
+                type: Output
+            }], addStep: [{
+                type: Output
+            }], deleteStep: [{
+                type: Output
+            }], toggleExpanded: [{
+                type: Output
+            }], groupNameChange: [{
+                type: Output
+            }], descriptionChange: [{
+                type: Output
+            }], reusableChange: [{
+                type: Output
+            }], openExternal: [{
+                type: Output
+            }], edit: [{
+                type: Output
+            }], link: [{
+                type: Output
+            }], duplicate: [{
+                type: Output
+            }], delete: [{
+                type: Output
+            }], viewDetails: [{
+                type: Output
+            }], selectionChange: [{
+                type: Output
+            }], conditionChange: [{
+                type: Output
+            }], branchStepChange: [{
+                type: Output
+            }], addStepForBranch: [{
+                type: Output
+            }], deleteStepWithBranch: [{
+                type: Output
+            }], addBranch: [{
+                type: Output
+            }], deleteBranch: [{
+                type: Output
+            }], testDataProfileChange: [{
+                type: Output
+            }], startStepChange: [{
+                type: Output
+            }], endStepChange: [{
+                type: Output
+            }], maxIterationsChange: [{
+                type: Output
+            }], eventTypeChange: [{
+                type: Output
+            }], parameterChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-case-details-renderer.component.js","sourceRoot":"","sources":["../../../../../../src/lib/test-case-details/test-case-details-renderer/test-case-details-renderer.component.ts","../../../../../../src/lib/test-case-details/test-case-details-renderer/test-case-details-renderer.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,EACL,MAAM,EACN,YAAY,EACZ,SAAS,EACT,gBAAgB,EAGhB,MAAM,GAIP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,4BAA4B,EAA4B,MAAM,oCAAoC,CAAC;AAC5G,OAAO,EAEL,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,GAEvB,MAAM,0BAA0B,CAAC;;AAOlC,MAAM,OAAO,gCAAgC;IAuC3C,YACgD,YAAsC,EAC5E,GAAsB;QADgB,iBAAY,GAAZ,YAAY,CAA0B;QAC5E,QAAG,GAAH,GAAG,CAAmB;QApCvB,aAAQ,GAAY,KAAK,CAAC;QAC1B,iBAAY,GAAY,KAAK,CAAC;QAI7B,qBAAgB,GAAG,IAAI,YAAY,EAA+C,CAAC;QACnF,YAAO,GAAG,IAAI,YAAY,EAAQ,CAAC;QACnC,eAAU,GAAG,IAAI,YAAY,EAAU,CAAC;QACxC,mBAAc,GAAG,IAAI,YAAY,EAA6D,CAAC;QAC/F,oBAAe,GAAG,IAAI,YAAY,EAAU,CAAC;QAC7C,sBAAiB,GAAG,IAAI,YAAY,EAAU,CAAC;QAC/C,mBAAc,GAAG,IAAI,YAAY,EAAW,CAAC;QAC7C,iBAAY,GAAG,IAAI,YAAY,EAA8B,CAAC;QAC9D,SAAI,GAAG,IAAI,YAAY,EAAQ,CAAC;QAChC,SAAI,GAAG,IAAI,YAAY,EAAQ,CAAC;QAChC,cAAS,GAAG,IAAI,YAAY,EAAQ,CAAC;QACrC,WAAM,GAAG,IAAI,YAAY,EAAQ,CAAC;QAClC,gBAAW,GAAG,IAAI,YAAY,EAAQ,CAAC;QACvC,oBAAe,GAAG,IAAI,YAAY,EAAW,CAAC;QAC9C,oBAAe,GAAG,IAAI,YAAY,EAAU,CAAC;QAC7C,qBAAgB,GAAG,IAAI,YAAY,EAA4E,CAAC;QAChH,qBAAgB,GAAG,IAAI,YAAY,EAA+B,CAAC;QACnE,yBAAoB,GAAG,IAAI,YAAY,EAAkD,CAAC;QAC1F,cAAS,GAAG,IAAI,YAAY,EAAQ,CAAC;QACrC,iBAAY,GAAG,IAAI,YAAY,EAAmB,CAAC;QACnD,0BAAqB,GAAG,IAAI,YAAY,EAAU,CAAC;QACnD,oBAAe,GAAG,IAAI,YAAY,EAAU,CAAC;QAC7C,kBAAa,GAAG,IAAI,YAAY,EAAU,CAAC;QAC3C,wBAAmB,GAAG,IAAI,YAAY,EAAU,CAAC;QACjD,oBAAe,GAAG,IAAI,YAAY,EAAO,CAAC;QAC1C,oBAAe,GAAG,IAAI,YAAY,EAAO,CAAC;QAE5C,iBAAY,GAA6B,IAAI,CAAC;IAKnD,CAAC;IAEJ,eAAe;QACb,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC,cAAc,CAAC,EAAE;YACzF,IAAI,CAAC,UAAU,EAAE,CAAC;SACnB;IACH,CAAC;IAEO,gBAAgB,CAAC,IAAwB;QAC/C,IAAI,iBAAiB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC;QAChE,IAAI,qBAAqB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC;QACxE,IAAI,gBAAgB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;QAC9D,IAAI,eAAe,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAC5D,IAAI,oBAAoB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC;QACtE,IAAI,mBAAmB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;QACpE,IAAI,kBAAkB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC;QAClE,IAAI,sBAAsB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC;QAC1E,IAAI,sBAAsB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC;QAC1E,IAAI,kBAAkB,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC;QAClE,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,UAAU;QAChB,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QAEzC,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,aAAa;YAAE,OAAO;QAE3B,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;QACjE,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;QAE5C,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC;QAC5B,QAAQ,CAAC,UAAU,GAAI,IAAI,CAAC,IAAY,CAAC,UAAU,CAAC;QACpD,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAClC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QAC1C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACrC,IAAI,GAAG,KAAK,UAAU,IAAI,GAAG,KAAK,aAAa,IAAI,GAAG,KAAK,UAAU,EAAE;gBACpE,QAAgB,CAAC,GAAG,CAAC,GAAI,IAAI,CAAC,IAAY,CAAC,GAAG,CAAC,CAAC;aAClD;QACH,CAAC,CAAC,CAAC;QACH,IAAK,IAAI,CAAC,IAAY,CAAC,WAAW;YAAG,QAAgB,CAAC,WAAW,GAAI,IAAI,CAAC,IAAY,CAAC,WAAW,CAAC;QACnG,IAAK,IAAI,CAAC,IAAY,CAAC,QAAQ;YAAG,QAAgB,CAAC,QAAQ,GAAI,IAAI,CAAC,IAAY,CAAC,QAAQ,CAAC;QAE1F,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAC3B,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,CAAC;IAC3B,CAAC;IAEO,WAAW,CAAC,QAAa;QAC/B,MAAM,IAAI,GAAG,CAAC,GAAW,EAAE,OAA0B,EAAE,EAAE;YACvD,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,SAAS,KAAK,UAAU,EAAE;gBAClE,QAAQ,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;aACtD;QACH,CAAC,CAAC;QACF,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,gBAAuB,CAAC,CAAC;QACvD,IAAI,CAAC,SAAS,EAAE;YACd,IAAI,EAAE,CAAC,CAAM,EAAE,EAAE;gBACf,IAAI,CAAC,IAAI,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,QAAQ,IAAI,CAAC;oBAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;oBAClF,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC5B,CAAC;SACK,CAAC,CAAC;QACV,IAAI,CAAC,YAAY,EAAE;YACjB,IAAI,EAAE,CAAC,CAAM,EAAE,EAAE;gBACf,IAAI,CAAC,IAAI,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,QAAQ,IAAI,CAAC,IAAI,WAAW,IAAI,CAAC;oBAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;;oBAC1G,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC/B,CAAC;SACK,CAAC,CAAC;QACV,IAAI,CAAC,gBAAgB,EAAE;YACrB,IAAI,EAAE,CAAC,CAAM,EAAE,EAAE;gBACf,yCAAyC;gBACzC,4DAA4D;gBAC5D,wCAAwC;gBACxC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9B,CAAC;SACK,CAAC,CAAC;QACV,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAsB,CAAC,CAAC;QACrD,IAAI,CAAC,mBAAmB,EAAE,IAAI,CAAC,iBAAwB,CAAC,CAAC;QACzD,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,cAAqB,CAAC,CAAC;QACnD,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,YAAmB,CAAC,CAAC;QAC/C,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAW,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAW,CAAC,CAAC;QAC/B,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,SAAgB,CAAC,CAAC;QACzC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAa,CAAC,CAAC;QACnC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,WAAkB,CAAC,CAAC;QAC7C,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAsB,CAAC,CAAC;QACrD,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAsB,CAAC,CAAC;QACrD,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,gBAAuB,CAAC,CAAC;QACvD,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,gBAAuB,CAAC,CAAC;QACvD,IAAI,CAAC,sBAAsB,EAAE,IAAI,CAAC,oBAA2B,CAAC,CAAC;QAC/D,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,SAAgB,CAAC,CAAC;QACzC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,YAAmB,CAAC,CAAC;QAC/C,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC,qBAA4B,CAAC,CAAC;QACjE,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAsB,CAAC,CAAC;QACrD,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,aAAoB,CAAC,CAAC;QACjD,IAAI,CAAC,qBAAqB,EAAE,IAAI,CAAC,mBAA0B,CAAC,CAAC;QAC7D,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAsB,CAAC,CAAC;QACrD,IAAI,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAsB,CAAC,CAAC;IACvD,CAAC;;6HA/IU,gCAAgC,kBAwCjC,4BAA4B;iHAxC3B,gCAAgC,ioCACZ,gBAAgB,kDCpCjD,8tBAKM;2FD8BO,gCAAgC;kBAL5C,SAAS;+BACE,gCAAgC,QAEpC,EAAE,KAAK,EAAE,aAAa,EAAE;;0BA0C3B,MAAM;2BAAC,4BAA4B;4EAvCa,QAAQ;sBAA1D,SAAS;uBAAC,UAAU,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE;gBAExC,IAAI;sBAAZ,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,YAAY;sBAApB,KAAK;gBAEG,MAAM;sBAAd,KAAK;gBAEI,gBAAgB;sBAAzB,MAAM;gBACG,OAAO;sBAAhB,MAAM;gBACG,UAAU;sBAAnB,MAAM;gBACG,cAAc;sBAAvB,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBACG,iBAAiB;sBAA1B,MAAM;gBACG,cAAc;sBAAvB,MAAM;gBACG,YAAY;sBAArB,MAAM;gBACG,IAAI;sBAAb,MAAM;gBACG,IAAI;sBAAb,MAAM;gBACG,SAAS;sBAAlB,MAAM;gBACG,MAAM;sBAAf,MAAM;gBACG,WAAW;sBAApB,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBACG,gBAAgB;sBAAzB,MAAM;gBACG,gBAAgB;sBAAzB,MAAM;gBACG,oBAAoB;sBAA7B,MAAM;gBACG,SAAS;sBAAlB,MAAM;gBACG,YAAY;sBAArB,MAAM;gBACG,qBAAqB;sBAA9B,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBACG,aAAa;sBAAtB,MAAM;gBACG,mBAAmB;sBAA5B,MAAM;gBACG,eAAe;sBAAxB,MAAM;gBACG,eAAe;sBAAxB,MAAM","sourcesContent":["import {\n  Component,\n  Input,\n  Output,\n  EventEmitter,\n  ViewChild,\n  ViewContainerRef,\n  OnChanges,\n  SimpleChanges,\n  Inject,\n  AfterViewInit,\n  ChangeDetectorRef,\n  ComponentRef,\n} from '@angular/core';\nimport { TEST_CASE_STEP_COMPONENT_MAP, TestCaseStepComponentMap } from '../test-case-step-components.token';\nimport {\n  TestCaseStepConfig,\n  isStepGroupConfig,\n  isConditionStepConfig,\n  isLoopStepConfig,\n  isNormalStepConfig,\n  isApiStepConfig,\n  isDatabaseStepConfig,\n  isAiAgentStepConfig,\n  isUploadStepConfig,\n  isScreenshotStepConfig,\n  isCustomCodeStepConfig,\n  ConditionBranch,\n} from '../test-case-step.models';\n\n@Component({\n  selector: 'cqa-test-case-details-renderer',\n  templateUrl: './test-case-details-renderer.component.html',\n  host: { class: 'cqa-ui-root' },\n})\nexport class TestCaseDetailsRendererComponent implements OnChanges, AfterViewInit {\n  @ViewChild('stepHost', { read: ViewContainerRef }) stepHost!: ViewContainerRef;\n\n  @Input() step!: TestCaseStepConfig;\n  @Input() index!: number;\n  @Input() isNested: boolean = false;\n  @Input() isInsideLoop: boolean = false;\n  /** When rendering a step inside a condition branch, the branch context (for addStepForBranch / deleteStepWithBranch). */\n  @Input() branch?: ConditionBranch;\n\n  @Output() nestedStepChange = new EventEmitter<{ step: TestCaseStepConfig; index: number }>();\n  @Output() addStep = new EventEmitter<void>();\n  @Output() deleteStep = new EventEmitter<number>();\n  @Output() toggleExpanded = new EventEmitter<boolean | {config: TestCaseStepConfig, expanded: boolean}>();\n  @Output() groupNameChange = new EventEmitter<string>();\n  @Output() descriptionChange = new EventEmitter<string>();\n  @Output() reusableChange = new EventEmitter<boolean>();\n  @Output() openExternal = new EventEmitter<{step: TestCaseStepConfig}>();\n  @Output() edit = new EventEmitter<void>();\n  @Output() link = new EventEmitter<void>();\n  @Output() duplicate = new EventEmitter<void>();\n  @Output() delete = new EventEmitter<void>();\n  @Output() viewDetails = new EventEmitter<void>();\n  @Output() selectionChange = new EventEmitter<boolean>();\n  @Output() conditionChange = new EventEmitter<string>();\n  @Output() branchStepChange = new EventEmitter<{ branch: ConditionBranch; step: TestCaseStepConfig; stepIndex: number }>();\n  @Output() addStepForBranch = new EventEmitter<{ branch: ConditionBranch }>();\n  @Output() deleteStepWithBranch = new EventEmitter<{ branch: ConditionBranch; stepIndex: number }>();\n  @Output() addBranch = new EventEmitter<void>();\n  @Output() deleteBranch = new EventEmitter<ConditionBranch>();\n  @Output() testDataProfileChange = new EventEmitter<string>();\n  @Output() startStepChange = new EventEmitter<number>();\n  @Output() endStepChange = new EventEmitter<number>();\n  @Output() maxIterationsChange = new EventEmitter<number>();\n  @Output() eventTypeChange = new EventEmitter<any>();\n  @Output() parameterChange = new EventEmitter<any>();\n\n  private componentRef: ComponentRef<any> | null = null;\n\n  constructor(\n    @Inject(TEST_CASE_STEP_COMPONENT_MAP) private componentMap: TestCaseStepComponentMap,\n    private cdr: ChangeDetectorRef\n  ) {}\n\n  ngAfterViewInit(): void {\n    this.renderStep();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['step'] || changes['index'] || changes['isNested'] || changes['isInsideLoop']) {\n      this.renderStep();\n    }\n  }\n\n  private getComponentType(step: TestCaseStepConfig): any {\n    if (isStepGroupConfig(step)) return this.componentMap.stepGroup;\n    if (isConditionStepConfig(step)) return this.componentMap.conditionStep;\n    if (isLoopStepConfig(step)) return this.componentMap.loopStep;\n    if (isApiStepConfig(step)) return this.componentMap.apiStep;\n    if (isDatabaseStepConfig(step)) return this.componentMap.databaseStep;\n    if (isAiAgentStepConfig(step)) return this.componentMap.aiAgentStep;\n    if (isUploadStepConfig(step)) return this.componentMap.uploadStep;\n    if (isScreenshotStepConfig(step)) return this.componentMap.screenshotStep;\n    if (isCustomCodeStepConfig(step)) return this.componentMap.customCodeStep;\n    if (isNormalStepConfig(step)) return this.componentMap.normalStep;\n    return null;\n  }\n\n  private renderStep(): void {\n    if (!this.stepHost || !this.step) return;\n\n    const componentType = this.getComponentType(this.step);\n    if (!componentType) return;\n\n    this.stepHost.clear();\n    this.componentRef = this.stepHost.createComponent(componentType);\n    const instance = this.componentRef.instance;\n\n    instance.config = this.step;\n    instance.stepNumber = (this.step as any).stepNumber;\n    instance.isNested = this.isNested;\n    instance.isInsideLoop = this.isInsideLoop;\n    Object.keys(this.step).forEach((key) => {\n      if (key !== 'stepType' && key !== 'nestedSteps' && key !== 'branches') {\n        (instance as any)[key] = (this.step as any)[key];\n      }\n    });\n    if ((this.step as any).nestedSteps) (instance as any).nestedSteps = (this.step as any).nestedSteps;\n    if ((this.step as any).branches) (instance as any).branches = (this.step as any).branches;\n\n    this.wireOutputs(instance);\n    this.cdr.detectChanges();\n  }\n\n  private wireOutputs(instance: any): void {\n    const wire = (key: string, emitter: EventEmitter<any>) => {\n      if (instance[key] && typeof instance[key].subscribe === 'function') {\n        instance[key].subscribe((v: any) => emitter.emit(v));\n      }\n    };\n    wire('nestedStepChange', this.nestedStepChange as any);\n    wire('addStep', {\n      emit: (v: any) => {\n        if (v != null && typeof v === 'object' && 'branch' in v) this.addStepForBranch.emit(v);\n        else this.addStep.emit(v);\n      },\n    } as any);\n    wire('deleteStep', {\n      emit: (v: any) => {\n        if (v != null && typeof v === 'object' && 'branch' in v && 'stepIndex' in v) this.deleteStepWithBranch.emit(v);\n        else this.deleteStep.emit(v);\n      },\n    } as any);\n    wire('toggleExpanded', {\n      emit: (v: any) => {\n        // Handle both boolean and object formats\n        // If it's an object with config and expanded, emit it as-is\n        // If it's just a boolean, emit it as-is\n        this.toggleExpanded.emit(v);\n      },\n    } as any);\n    wire('groupNameChange', this.groupNameChange as any);\n    wire('descriptionChange', this.descriptionChange as any);\n    wire('reusableChange', this.reusableChange as any);\n    wire('openExternal', this.openExternal as any);\n    wire('edit', this.edit as any);\n    wire('link', this.link as any);\n    wire('duplicate', this.duplicate as any);\n    wire('delete', this.delete as any);\n    wire('viewDetails', this.viewDetails as any);\n    wire('selectionChange', this.selectionChange as any);\n    wire('conditionChange', this.conditionChange as any);\n    wire('branchStepChange', this.branchStepChange as any);\n    wire('addStepForBranch', this.addStepForBranch as any);\n    wire('deleteStepWithBranch', this.deleteStepWithBranch as any);\n    wire('addBranch', this.addBranch as any);\n    wire('deleteBranch', this.deleteBranch as any);\n    wire('testDataProfileChange', this.testDataProfileChange as any);\n    wire('startStepChange', this.startStepChange as any);\n    wire('endStepChange', this.endStepChange as any);\n    wire('maxIterationsChange', this.maxIterationsChange as any);\n    wire('eventTypeChange', this.eventTypeChange as any);\n    wire('parameterChange', this.parameterChange as any);\n  }\n}\n\n","<div class=\"cqa-relative\">\n    <ng-container #stepHost></ng-container>\n    <button class=\"cqa-absolute cqa-top-[calc(100%-12px)] cqa-left-[50%] cqa-translate-x-[-50%] cqa-p-0 cqa-z-[1] cqa-hidden\">\n        <svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><rect x=\"1\" y=\"1\" width=\"21.1822\" height=\"22\" rx=\"10.5911\" fill=\"white\"/><rect x=\"1\" y=\"1\" width=\"21.1822\" height=\"22\" rx=\"10.5911\" stroke=\"#3F43EE\" stroke-width=\"2\"/><path d=\"M8.5 12H15.5\" stroke=\"#3F43EE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M12 8.5V15.5\" stroke=\"#3F43EE\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    </button>\n</div>"]}

package/esm2020/lib/test-case-details/test-case-step-components.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const TEST_CASE_STEP_COMPONENT_MAP = new InjectionToken('TEST_CASE_STEP_COMPONENT_MAP');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1jYXNlLXN0ZXAtY29tcG9uZW50cy50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvdGVzdC1jYXNlLWRldGFpbHMvdGVzdC1jYXNlLXN0ZXAtY29tcG9uZW50cy50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFRLE1BQU0sZUFBZSxDQUFDO0FBZ0JyRCxNQUFNLENBQUMsTUFBTSw0QkFBNEIsR0FBRyxJQUFJLGNBQWMsQ0FDNUQsOEJBQThCLENBQy9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKiogTWFwIG9mIHN0ZXAgdHlwZSBrZXkgdG8gY29tcG9uZW50IHR5cGUuIFVzZWQgYnkgdGVzdC1jYXNlLWRldGFpbHMtcmVuZGVyZXIgdG8gYXZvaWQgY2lyY3VsYXIgZGVwcy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgVGVzdENhc2VTdGVwQ29tcG9uZW50TWFwIHtcbiAgc3RlcEdyb3VwOiBUeXBlPHVua25vd24+O1xuICBjb25kaXRpb25TdGVwOiBUeXBlPHVua25vd24+O1xuICBsb29wU3RlcDogVHlwZTx1bmtub3duPjtcbiAgbm9ybWFsU3RlcDogVHlwZTx1bmtub3duPjtcbiAgYXBpU3RlcDogVHlwZTx1bmtub3duPjtcbiAgZGF0YWJhc2VTdGVwOiBUeXBlPHVua25vd24+O1xuICBhaUFnZW50U3RlcDogVHlwZTx1bmtub3duPjtcbiAgdXBsb2FkU3RlcDogVHlwZTx1bmtub3duPjtcbiAgc2NyZWVuc2hvdFN0ZXA6IFR5cGU8dW5rbm93bj47XG4gIGN1c3RvbUNvZGVTdGVwOiBUeXBlPHVua25vd24+O1xufVxuXG5leHBvcnQgY29uc3QgVEVTVF9DQVNFX1NURVBfQ09NUE9ORU5UX01BUCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxUZXN0Q2FzZVN0ZXBDb21wb25lbnRNYXA+KFxuICAnVEVTVF9DQVNFX1NURVBfQ09NUE9ORU5UX01BUCdcbik7XG4iXX0=

package/esm2020/lib/test-case-details/test-case-step.models.mjs

@@ -0,0 +1,51 @@
+/**
+ * Models and interfaces for test case details step components
+ */
+export var StepTypes;
+(function (StepTypes) {
+    StepTypes["NORMAL"] = "NORMAL";
+    StepTypes["API"] = "API";
+    StepTypes["DATABASE"] = "DATABASE";
+    StepTypes["AI_AGENT"] = "AI_AGENT";
+    StepTypes["UPLOAD"] = "UPLOAD";
+    StepTypes["SCREENSHOT"] = "SCREENSHOT";
+    StepTypes["CUSTOM_CODE"] = "CUSTOM_CODE";
+    StepTypes["FOR_LOOP"] = "FOR_LOOP";
+    StepTypes["WHILE_LOOP"] = "WHILE_LOOP";
+    StepTypes["BREAK_LOOP"] = "BREAK_LOOP";
+    StepTypes["CONTINUE_LOOP"] = "CONTINUE_LOOP";
+    StepTypes["CONDITION_IF"] = "CONDITION_IF";
+    StepTypes["STEP_GROUP"] = "STEP_GROUP";
+})(StepTypes || (StepTypes = {}));
+/** Type guards for dispatching step type (e.g. in test-case-details-renderer) */
+export function isNormalStepConfig(step) {
+    return step != null && 'eventType' in step && 'parameters' in step;
+}
+export function isLoopStepConfig(step) {
+    return step != null && 'loopType' in step;
+}
+export function isConditionStepConfig(step) {
+    return step != null && 'condition' in step && 'branches' in step;
+}
+export function isStepGroupConfig(step) {
+    return step != null && 'groupName' in step;
+}
+export function isApiStepConfig(step) {
+    return step != null && 'stepType' in step && step.stepType === StepTypes.API;
+}
+export function isDatabaseStepConfig(step) {
+    return step != null && 'stepType' in step && step.stepType === StepTypes.DATABASE;
+}
+export function isAiAgentStepConfig(step) {
+    return step != null && 'stepType' in step && step.stepType === StepTypes.AI_AGENT;
+}
+export function isUploadStepConfig(step) {
+    return step != null && 'stepType' in step && step.stepType === StepTypes.UPLOAD;
+}
+export function isScreenshotStepConfig(step) {
+    return step != null && 'stepType' in step && step.stepType === StepTypes.SCREENSHOT;
+}
+export function isCustomCodeStepConfig(step) {
+    return step != null && 'stepType' in step && step.stepType === StepTypes.CUSTOM_CODE;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-case-step.models.js","sourceRoot":"","sources":["../../../../../src/lib/test-case-details/test-case-step.models.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,CAAN,IAAY,SAcX;AAdD,WAAY,SAAS;IACnB,8BAAiB,CAAA;IACjB,wBAAW,CAAA;IACX,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,8BAAiB,CAAA;IACjB,sCAAyB,CAAA;IACzB,wCAA2B,CAAA;IAC3B,kCAAqB,CAAA;IACrB,sCAAyB,CAAA;IACzB,sCAAyB,CAAA;IACzB,4CAA+B,CAAA;IAC/B,0CAA6B,CAAA;IAC7B,sCAAwB,CAAA;AAC1B,CAAC,EAdW,SAAS,KAAT,SAAS,QAcpB;AAqID,iFAAiF;AACjF,MAAM,UAAU,kBAAkB,CAAC,IAAwB;IACzD,OAAO,IAAI,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC;AACrE,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,IAAwB;IACvD,OAAO,IAAI,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,IAAwB;IAC5D,OAAO,IAAI,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,CAAC;AACnE,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,IAAwB;IACxD,OAAO,IAAI,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAwB;IACtD,OAAO,IAAI,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,IAAK,IAAsB,CAAC,QAAQ,KAAK,SAAS,CAAC,GAAG,CAAC;AAClG,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,IAAwB;IAC3D,OAAO,IAAI,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,IAAK,IAA2B,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ,CAAC;AAC5G,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,IAAwB;IAC1D,OAAO,IAAI,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,IAAK,IAA0B,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ,CAAC;AAC3G,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,IAAwB;IACzD,OAAO,IAAI,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,IAAK,IAAyB,CAAC,QAAQ,KAAK,SAAS,CAAC,MAAM,CAAC;AACxG,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,IAAwB;IAC7D,OAAO,IAAI,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,IAAK,IAA6B,CAAC,QAAQ,KAAK,SAAS,CAAC,UAAU,CAAC;AAChH,CAAC;AAED,MAAM,UAAU,sBAAsB,CAAC,IAAwB;IAC7D,OAAO,IAAI,IAAI,IAAI,IAAI,UAAU,IAAI,IAAI,IAAK,IAA6B,CAAC,QAAQ,KAAK,SAAS,CAAC,WAAW,CAAC;AACjH,CAAC","sourcesContent":["/**\n * Models and interfaces for test case details step components\n */\n\nexport type TestCaseEventType = 'navigate' | 'custom' | 'ai-agent' | 'type' | 'click' | 'verify' | 'wait';\n\n\nexport enum StepTypes {\n  NORMAL = 'NORMAL',\n  API = 'API',\n  DATABASE = 'DATABASE',\n  AI_AGENT = 'AI_AGENT',\n  UPLOAD = 'UPLOAD',\n  SCREENSHOT = 'SCREENSHOT',\n  CUSTOM_CODE = 'CUSTOM_CODE',\n  FOR_LOOP = 'FOR_LOOP',\n  WHILE_LOOP = 'WHILE_LOOP',\n  BREAK_LOOP = 'BREAK_LOOP',\n  CONTINUE_LOOP = 'CONTINUE_LOOP',\n  CONDITION_IF = 'CONDITION_IF',\n  STEP_GROUP= 'STEP_GROUP'\n}\n\n// export type StepType = StepTypes.NORMAL | StepTypes.API | StepTypes.DATABASE | StepTypes.AI_AGENT | StepTypes.UPLOAD | StepTypes.SCREENSHOT | StepTypes.CUSTOM_CODE | StepTypes.FOR_LOOP | StepTypes.WHILE_LOOP | StepTypes.BREAK_LOOP | StepTypes.CONTINUE_LOOP;\n\nexport interface EventTypeConfig {\n  type: TestCaseEventType;\n  label: string;\n  icon?: string;\n  color: string;\n  backgroundColor: string;\n}\n\nexport interface StepParameter {\n  name: string;\n  value: string;\n  displayValue?: string; // For display purposes (e.g., with quotes)\n}\n\n/** Base interface containing common properties for all step configurations */\nexport interface BaseStepConfig {\n  id: string;\n  stepNumber: number | string;\n  stepType: StepTypes;\n  description?: string;\n  selected?: boolean;\n  disabled?: boolean;\n  expanded?: boolean;\n}\n\nexport interface NormalStepConfig extends BaseStepConfig {\n  stepType: StepTypes.NORMAL;\n  eventType: TestCaseEventType;\n  parameters: StepParameter[];\n}\n\n/** API Step Configuration */\nexport interface ApiStepConfig extends BaseStepConfig {\n  stepType: StepTypes.API;\n  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';\n  endpoint: string;\n  baseUrl?: string;\n  requestBody?: string;\n  headers?: Record<string, string>;\n  headersCount?: number;\n  hasBody?: boolean;\n  saveTo?: string;\n  expectedStatus?: number;\n}\n\n/** Database Step Configuration */\nexport interface DatabaseStepConfig extends BaseStepConfig {\n  stepType: StepTypes.DATABASE;\n  query: string;\n  databaseType?: 'mysql' | 'postgresql' | 'mongodb' | 'mssql' | 'oracle';\n  connectionName?: string;\n  saveTo?: string;\n}\n\n/** AI Agent Step Configuration */\nexport interface AiAgentStepConfig extends BaseStepConfig {\n  stepType: StepTypes.AI_AGENT;\n  instructions: string;\n}\n\n/** Upload Step Configuration */\nexport interface UploadStepConfig extends BaseStepConfig {\n  stepType: StepTypes.UPLOAD;\n  selector: string;\n  fileName: string;\n  source: 'Data Library' | 'Local' | 'URL';\n  sourcePath: string;\n}\n\n/** Screenshot Step Configuration */\nexport interface ScreenshotStepConfig extends BaseStepConfig {\n  stepType: StepTypes.SCREENSHOT;\n  name?: string;\n  fullPage?: boolean;\n  selector?: string;\n}\n\n/** Custom Code Step Configuration */\nexport interface CustomCodeStepConfig extends BaseStepConfig {\n  stepType: StepTypes.CUSTOM_CODE;\n  language: 'javascript' | 'python' | 'typescript';\n  code: string;\n}\n\nexport interface LoopStepConfig extends BaseStepConfig {\n  loopType: 'for' | 'while';\n  stepType: StepTypes.FOR_LOOP | StepTypes.WHILE_LOOP;\n  condition?: string; // For while loop: \"While element \\\".notification-badge\\\" exists (max 5 iterations)\"\n  maxIterations?: number; // For while loop\n  testDataProfile?: string; // For for loop\n  startStep?: number;\n  endStep?: number;\n  nestedSteps: TestCaseStepConfig[];\n}\n\nexport interface ConditionBranch {\n  type: 'if' | 'else' | 'else-if';\n  stepType: StepTypes.CONDITION_IF;\n  label: string; // e.g., \"IF TRUE\", \"ELSE\"\n  nestedSteps: TestCaseStepConfig[];\n}\n\nexport interface ConditionStepConfig extends BaseStepConfig {\n  condition: string; // e.g., \"If element `.success-message` is visible\"\n  branches: ConditionBranch[];\n  nestedSteps: TestCaseStepConfig[];\n}\n\nexport interface StepGroupConfig extends BaseStepConfig {\n  stepGroupId: number;\n  groupName: string; // e.g., \"Checkout Flow\"\n  reusable?: boolean; // Whether the group is reusable\n  stepType: StepTypes.STEP_GROUP\n  nestedSteps: TestCaseStepConfig[];\n}\n\n// Union type for all test case step configurations (supports recursive nesting)\nexport type TestCaseStepConfig =\n  | NormalStepConfig\n  | LoopStepConfig\n  | ConditionStepConfig\n  | StepGroupConfig\n  | ApiStepConfig\n  | DatabaseStepConfig\n  | AiAgentStepConfig\n  | UploadStepConfig\n  | ScreenshotStepConfig\n  | CustomCodeStepConfig;\n\n/** Type guards for dispatching step type (e.g. in test-case-details-renderer) */\nexport function isNormalStepConfig(step: TestCaseStepConfig): step is NormalStepConfig {\n  return step != null && 'eventType' in step && 'parameters' in step;\n}\n\nexport function isLoopStepConfig(step: TestCaseStepConfig): step is LoopStepConfig {\n  return step != null && 'loopType' in step;\n}\n\nexport function isConditionStepConfig(step: TestCaseStepConfig): step is ConditionStepConfig {\n  return step != null && 'condition' in step && 'branches' in step;\n}\n\nexport function isStepGroupConfig(step: TestCaseStepConfig): step is StepGroupConfig {\n  return step != null && 'groupName' in step;\n}\n\nexport function isApiStepConfig(step: TestCaseStepConfig): step is ApiStepConfig {\n  return step != null && 'stepType' in step && (step as ApiStepConfig).stepType === StepTypes.API;\n}\n\nexport function isDatabaseStepConfig(step: TestCaseStepConfig): step is DatabaseStepConfig {\n  return step != null && 'stepType' in step && (step as DatabaseStepConfig).stepType === StepTypes.DATABASE;\n}\n\nexport function isAiAgentStepConfig(step: TestCaseStepConfig): step is AiAgentStepConfig {\n  return step != null && 'stepType' in step && (step as AiAgentStepConfig).stepType === StepTypes.AI_AGENT;\n}\n\nexport function isUploadStepConfig(step: TestCaseStepConfig): step is UploadStepConfig {\n  return step != null && 'stepType' in step && (step as UploadStepConfig).stepType === StepTypes.UPLOAD;\n}\n\nexport function isScreenshotStepConfig(step: TestCaseStepConfig): step is ScreenshotStepConfig {\n  return step != null && 'stepType' in step && (step as ScreenshotStepConfig).stepType === StepTypes.SCREENSHOT;\n}\n\nexport function isCustomCodeStepConfig(step: TestCaseStepConfig): step is CustomCodeStepConfig {\n  return step != null && 'stepType' in step && (step as CustomCodeStepConfig).stepType === StepTypes.CUSTOM_CODE;\n}\n"]}

package/esm2020/lib/test-case-details/upload-step/upload-step.component.mjs

@@ -0,0 +1,85 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { STEP_ROW_ACTIONS_STYLES } from '../step-row-actions.styles';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class TestCaseUploadStepComponent {
+    constructor() {
+        this.selector = '';
+        this.fileName = '';
+        this.source = 'Data Library';
+        this.sourcePath = '';
+        this.selected = false;
+        this.disabled = false;
+        this.isNested = false;
+        this.isInsideLoop = false;
+        this.edit = new EventEmitter();
+        this.link = new EventEmitter();
+        this.duplicate = new EventEmitter();
+        this.delete = new EventEmitter();
+        this.moreOptions = new EventEmitter();
+        this.viewDetails = new EventEmitter();
+        this.selectionChange = new EventEmitter();
+    }
+    ngOnInit() {
+        if (this.config) {
+            this.stepNumber = this.config.stepNumber;
+            this.selector = this.config.selector;
+            this.fileName = this.config.fileName;
+            this.source = this.config.source;
+            this.sourcePath = this.config.sourcePath;
+            this.description = this.config.description;
+            this.selected = this.config.selected || false;
+            this.disabled = this.config.disabled || false;
+        }
+    }
+    onEdit() { this.edit.emit(); }
+    onLink() { this.link.emit(); }
+    onDuplicate() { this.duplicate.emit(); }
+    onDelete() { this.delete.emit(); }
+    onMoreOptions() { this.moreOptions.emit(); }
+    onViewDetails() { this.viewDetails.emit(); }
+    onSelectionChange(checked) { this.selected = checked; this.selectionChange.emit(checked); }
+}
+TestCaseUploadStepComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TestCaseUploadStepComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TestCaseUploadStepComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: TestCaseUploadStepComponent, selector: "cqa-test-case-upload-step", inputs: { config: "config", stepNumber: "stepNumber", selector: "selector", fileName: "fileName", source: "source", sourcePath: "sourcePath", description: "description", selected: "selected", disabled: "disabled", isNested: "isNested", isInsideLoop: "isInsideLoop" }, outputs: { edit: "edit", link: "link", duplicate: "duplicate", delete: "delete", moreOptions: "moreOptions", viewDetails: "viewDetails", selectionChange: "selectionChange" }, host: { classAttribute: "cqa-ui-root" }, ngImport: i0, template: "<div [class]=\"'step-row cqa-flex cqa-items-center cqa-gap-3 cqa-py-[12.5px] ' + (isInsideLoop ? 'cqa-pl-10 cqa-pr-4' : 'cqa-px-4')\" style=\"border-top: 1px solid #E5E7EB;\">\n  <div class=\"cqa-inline-flex cqa-items-center\">\n    <label class=\"cqa-flex cqa-items-center cqa-cursor-pointer cqa-relative cqa-mr-2\">\n      <input type=\"checkbox\"\n        [ngModel]=\"selected\"\n        [disabled]=\"disabled\"\n        (ngModelChange)=\"onSelectionChange($event)\"\n        class=\"cqa-h-4 cqa-w-4 cqa-cursor-pointer cqa-transition-all cqa-appearance-none cqa-rounded shadow hover:cqa-shadow-md cqa-border cqa-border-solid cqa-border-slate-300 cqa-flex-shrink-0\"\n        [class.cqa-bg-[#3F43EE]]=\"selected\"\n        [class.cqa-border-[#3F43EE]]=\"selected\"\n        id=\"check\" />\n      <span class=\"cqa-absolute cqa-text-white cqa-top-1/2 cqa-left-1/2 cqa--translate-x-1/2 cqa--translate-y-1/2 cqa-pointer-events-none cqa-flex cqa-items-center cqa-justify-center\"\n        [class.cqa-opacity-0]=\"!selected\"\n        [class.cqa-opacity-100]=\"selected\">\n        <svg width=\"12\" height=\"13\" viewBox=\"0 0 12 13\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3.125L4.5 8.625L2 6.125\" stroke=\"white\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      </span>\n    </label>\n  </div>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px] cqa-min-w-[32px]\">{{ stepNumber }}</span>\n  <span class=\"cqa-px-2.5 cqa-py-1 cqa-rounded-lg cqa-flex cqa-items-center cqa-gap-2 cqa-bg-[#DBEAFE] cqa-text-[#2563EB]\">\n    <svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M12.25 8.75V11.0833C12.25 11.3928 12.1271 11.6895 11.9083 11.9083C11.6895 12.1271 11.3928 12.25 11.0833 12.25H2.91667C2.60725 12.25 2.3105 12.1271 2.09171 11.9083C1.87292 11.6895 1.75 11.3928 1.75 11.0833V8.75\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9.91667 4.66667L7 1.75L4.08333 4.66667\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7 1.75V8.75\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium\">Upload</span>\n  </span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">Upload file to</span>\n  <span class=\"cqa-py-0.5 cqa-px-2 cqa-text-[#2563EB] cqa-text-[14px] cqa-leading-[17px] cqa-font-semibold cqa-border cqa-border-solid cqa-border-[#93C5FD] cqa-rounded cqa-bg-[#DBEAFE]\">{{ selector }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">File:</span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">{{ fileName }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">Source:</span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">{{ source }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">{{ sourcePath }}</span>\n  <div class=\"cqa-flex-grow\"></div>\n  <div class=\"step-actions cqa-flex cqa-items-center cqa-gap-3 cqa-px-[7px]\">\n    <button type=\"button\" (click)=\"onEdit(); $event.stopPropagation()\" title=\"Edit\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M7 11.6666H12.25\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9.55208 2.1128C9.7843 1.88058 10.0993 1.75012 10.4277 1.75012C10.7561 1.75012 11.071 1.88058 11.3033 2.1128C11.5355 2.34502 11.6659 2.65998 11.6659 2.98838C11.6659 3.31679 11.5355 3.63175 11.3033 3.86397L4.29742 10.8704C4.15864 11.0092 3.9871 11.1107 3.79867 11.1656L2.12333 11.6544C2.07314 11.669 2.01993 11.6699 1.96928 11.6569C1.91863 11.6439 1.8724 11.6176 1.83543 11.5806C1.79846 11.5437 1.7721 11.4974 1.75913 11.4468C1.74615 11.3961 1.74703 11.3429 1.76167 11.2927L2.2505 9.61738C2.30546 9.42916 2.40698 9.25783 2.54567 9.11922L9.55208 2.1128Z\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onLink(); $event.stopPropagation()\" title=\"Link\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M5.00065 9.91671H3.66732C2.78326 9.91671 1.93542 9.60942 1.3103 9.06244C0.685174 8.51545 0.333984 7.77359 0.333984 7.00004C0.333984 6.22649 0.685174 5.48463 1.3103 4.93765C1.93542 4.39066 2.78326 4.08337 3.66732 4.08337H5.00065\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9 4.08337H10.3333C11.2174 4.08337 12.0652 4.39066 12.6904 4.93765C13.3155 5.48463 13.6667 6.22649 13.6667 7.00004C13.6667 7.77359 13.3155 8.51545 12.6904 9.06244C12.0652 9.60942 11.2174 9.91671 10.3333 9.91671H9\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.33398 7H9.66732\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onDuplicate(); $event.stopPropagation()\" title=\"Duplicate\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M11.666 4.66663H5.83268C5.18835 4.66663 4.66602 5.18896 4.66602 5.83329V11.6666C4.66602 12.311 5.18835 12.8333 5.83268 12.8333H11.666C12.3103 12.8333 12.8327 12.311 12.8327 11.6666V5.83329C12.8327 5.18896 12.3103 4.66663 11.666 4.66663Z\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2.33268 9.33329C1.69102 9.33329 1.16602 8.80829 1.16602 8.16663V2.33329C1.16602 1.69163 1.69102 1.16663 2.33268 1.16663H8.16602C8.80768 1.16663 9.33268 1.69163 9.33268 2.33329\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onDelete(); $event.stopPropagation()\" title=\"Delete\" class=\"cqa-p-0 cqa-text-[#ff6467] hover:cqa-text-[#C63535]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M1.75 3.5H12.25\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M11.0827 3.5V11.6667C11.0827 12.25 10.4993 12.8333 9.91602 12.8333H4.08268C3.49935 12.8333 2.91602 12.25 2.91602 11.6667V3.5\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.66602 3.49996V2.33329C4.66602 1.74996 5.24935 1.16663 5.83268 1.16663H8.16602C8.74935 1.16663 9.33268 1.74996 9.33268 2.33329V3.49996\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M5.83398 6.41663V9.91663\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M8.16602 6.41663V9.91663\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n  </div>\n</div>\n", styles: [".step-actions{opacity:0;transition:opacity .15s ease}.step-row:hover .step-actions{opacity:1}\n"], directives: [{ type: i1.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TestCaseUploadStepComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cqa-test-case-upload-step', host: { class: 'cqa-ui-root' }, styles: [STEP_ROW_ACTIONS_STYLES], template: "<div [class]=\"'step-row cqa-flex cqa-items-center cqa-gap-3 cqa-py-[12.5px] ' + (isInsideLoop ? 'cqa-pl-10 cqa-pr-4' : 'cqa-px-4')\" style=\"border-top: 1px solid #E5E7EB;\">\n  <div class=\"cqa-inline-flex cqa-items-center\">\n    <label class=\"cqa-flex cqa-items-center cqa-cursor-pointer cqa-relative cqa-mr-2\">\n      <input type=\"checkbox\"\n        [ngModel]=\"selected\"\n        [disabled]=\"disabled\"\n        (ngModelChange)=\"onSelectionChange($event)\"\n        class=\"cqa-h-4 cqa-w-4 cqa-cursor-pointer cqa-transition-all cqa-appearance-none cqa-rounded shadow hover:cqa-shadow-md cqa-border cqa-border-solid cqa-border-slate-300 cqa-flex-shrink-0\"\n        [class.cqa-bg-[#3F43EE]]=\"selected\"\n        [class.cqa-border-[#3F43EE]]=\"selected\"\n        id=\"check\" />\n      <span class=\"cqa-absolute cqa-text-white cqa-top-1/2 cqa-left-1/2 cqa--translate-x-1/2 cqa--translate-y-1/2 cqa-pointer-events-none cqa-flex cqa-items-center cqa-justify-center\"\n        [class.cqa-opacity-0]=\"!selected\"\n        [class.cqa-opacity-100]=\"selected\">\n        <svg width=\"12\" height=\"13\" viewBox=\"0 0 12 13\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3.125L4.5 8.625L2 6.125\" stroke=\"white\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      </span>\n    </label>\n  </div>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px] cqa-min-w-[32px]\">{{ stepNumber }}</span>\n  <span class=\"cqa-px-2.5 cqa-py-1 cqa-rounded-lg cqa-flex cqa-items-center cqa-gap-2 cqa-bg-[#DBEAFE] cqa-text-[#2563EB]\">\n    <svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M12.25 8.75V11.0833C12.25 11.3928 12.1271 11.6895 11.9083 11.9083C11.6895 12.1271 11.3928 12.25 11.0833 12.25H2.91667C2.60725 12.25 2.3105 12.1271 2.09171 11.9083C1.87292 11.6895 1.75 11.3928 1.75 11.0833V8.75\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9.91667 4.66667L7 1.75L4.08333 4.66667\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7 1.75V8.75\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium\">Upload</span>\n  </span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">Upload file to</span>\n  <span class=\"cqa-py-0.5 cqa-px-2 cqa-text-[#2563EB] cqa-text-[14px] cqa-leading-[17px] cqa-font-semibold cqa-border cqa-border-solid cqa-border-[#93C5FD] cqa-rounded cqa-bg-[#DBEAFE]\">{{ selector }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">File:</span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">{{ fileName }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">Source:</span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">{{ source }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">{{ sourcePath }}</span>\n  <div class=\"cqa-flex-grow\"></div>\n  <div class=\"step-actions cqa-flex cqa-items-center cqa-gap-3 cqa-px-[7px]\">\n    <button type=\"button\" (click)=\"onEdit(); $event.stopPropagation()\" title=\"Edit\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M7 11.6666H12.25\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9.55208 2.1128C9.7843 1.88058 10.0993 1.75012 10.4277 1.75012C10.7561 1.75012 11.071 1.88058 11.3033 2.1128C11.5355 2.34502 11.6659 2.65998 11.6659 2.98838C11.6659 3.31679 11.5355 3.63175 11.3033 3.86397L4.29742 10.8704C4.15864 11.0092 3.9871 11.1107 3.79867 11.1656L2.12333 11.6544C2.07314 11.669 2.01993 11.6699 1.96928 11.6569C1.91863 11.6439 1.8724 11.6176 1.83543 11.5806C1.79846 11.5437 1.7721 11.4974 1.75913 11.4468C1.74615 11.3961 1.74703 11.3429 1.76167 11.2927L2.2505 9.61738C2.30546 9.42916 2.40698 9.25783 2.54567 9.11922L9.55208 2.1128Z\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onLink(); $event.stopPropagation()\" title=\"Link\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M5.00065 9.91671H3.66732C2.78326 9.91671 1.93542 9.60942 1.3103 9.06244C0.685174 8.51545 0.333984 7.77359 0.333984 7.00004C0.333984 6.22649 0.685174 5.48463 1.3103 4.93765C1.93542 4.39066 2.78326 4.08337 3.66732 4.08337H5.00065\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9 4.08337H10.3333C11.2174 4.08337 12.0652 4.39066 12.6904 4.93765C13.3155 5.48463 13.6667 6.22649 13.6667 7.00004C13.6667 7.77359 13.3155 8.51545 12.6904 9.06244C12.0652 9.60942 11.2174 9.91671 10.3333 9.91671H9\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.33398 7H9.66732\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onDuplicate(); $event.stopPropagation()\" title=\"Duplicate\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M11.666 4.66663H5.83268C5.18835 4.66663 4.66602 5.18896 4.66602 5.83329V11.6666C4.66602 12.311 5.18835 12.8333 5.83268 12.8333H11.666C12.3103 12.8333 12.8327 12.311 12.8327 11.6666V5.83329C12.8327 5.18896 12.3103 4.66663 11.666 4.66663Z\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2.33268 9.33329C1.69102 9.33329 1.16602 8.80829 1.16602 8.16663V2.33329C1.16602 1.69163 1.69102 1.16663 2.33268 1.16663H8.16602C8.80768 1.16663 9.33268 1.69163 9.33268 2.33329\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onDelete(); $event.stopPropagation()\" title=\"Delete\" class=\"cqa-p-0 cqa-text-[#ff6467] hover:cqa-text-[#C63535]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M1.75 3.5H12.25\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M11.0827 3.5V11.6667C11.0827 12.25 10.4993 12.8333 9.91602 12.8333H4.08268C3.49935 12.8333 2.91602 12.25 2.91602 11.6667V3.5\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.66602 3.49996V2.33329C4.66602 1.74996 5.24935 1.16663 5.83268 1.16663H8.16602C8.74935 1.16663 9.33268 1.74996 9.33268 2.33329V3.49996\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M5.83398 6.41663V9.91663\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M8.16602 6.41663V9.91663\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n  </div>\n</div>\n" }]
+        }], propDecorators: { config: [{
+                type: Input
+            }], stepNumber: [{
+                type: Input
+            }], selector: [{
+                type: Input
+            }], fileName: [{
+                type: Input
+            }], source: [{
+                type: Input
+            }], sourcePath: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], selected: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], isNested: [{
+                type: Input
+            }], isInsideLoop: [{
+                type: Input
+            }], edit: [{
+                type: Output
+            }], link: [{
+                type: Output
+            }], duplicate: [{
+                type: Output
+            }], delete: [{
+                type: Output
+            }], moreOptions: [{
+                type: Output
+            }], viewDetails: [{
+                type: Output
+            }], selectionChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upload-step.component.js","sourceRoot":"","sources":["../../../../../../src/lib/test-case-details/upload-step/upload-step.component.ts","../../../../../../src/lib/test-case-details/upload-step/upload-step.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, OnInit } from '@angular/core';\nimport { UploadStepConfig } from '../test-case-step.models';\nimport { STEP_ROW_ACTIONS_STYLES } from '../step-row-actions.styles';\n\n@Component({\n  selector: 'cqa-test-case-upload-step',\n  templateUrl: './upload-step.component.html',\n  host: { class: 'cqa-ui-root' },\n  styles: [STEP_ROW_ACTIONS_STYLES],\n})\nexport class TestCaseUploadStepComponent implements OnInit {\n  @Input() config!: UploadStepConfig;\n  @Input() stepNumber!: number | string;\n  @Input() selector: string = '';\n  @Input() fileName: string = '';\n  @Input() source: 'Data Library' | 'Local' | 'URL' = 'Data Library';\n  @Input() sourcePath: string = '';\n  @Input() description?: string;\n  @Input() selected: boolean = false;\n  @Input() disabled: boolean = false;\n  @Input() isNested: boolean = false;\n  @Input() isInsideLoop: boolean = false;\n\n  @Output() edit = new EventEmitter<void>();\n  @Output() link = new EventEmitter<void>();\n  @Output() duplicate = new EventEmitter<void>();\n  @Output() delete = new EventEmitter<void>();\n  @Output() moreOptions = new EventEmitter<void>();\n  @Output() viewDetails = new EventEmitter<void>();\n  @Output() selectionChange = new EventEmitter<boolean>();\n\n  ngOnInit(): void {\n    if (this.config) {\n      this.stepNumber = this.config.stepNumber;\n      this.selector = this.config.selector;\n      this.fileName = this.config.fileName;\n      this.source = this.config.source;\n      this.sourcePath = this.config.sourcePath;\n      this.description = this.config.description;\n      this.selected = this.config.selected || false;\n      this.disabled = this.config.disabled || false;\n    }\n  }\n\n  onEdit(): void { this.edit.emit(); }\n  onLink(): void { this.link.emit(); }\n  onDuplicate(): void { this.duplicate.emit(); }\n  onDelete(): void { this.delete.emit(); }\n  onMoreOptions(): void { this.moreOptions.emit(); }\n  onViewDetails(): void { this.viewDetails.emit(); }\n  onSelectionChange(checked: boolean): void { this.selected = checked; this.selectionChange.emit(checked); }\n}\n","<div [class]=\"'step-row cqa-flex cqa-items-center cqa-gap-3 cqa-py-[12.5px] ' + (isInsideLoop ? 'cqa-pl-10 cqa-pr-4' : 'cqa-px-4')\" style=\"border-top: 1px solid #E5E7EB;\">\n  <div class=\"cqa-inline-flex cqa-items-center\">\n    <label class=\"cqa-flex cqa-items-center cqa-cursor-pointer cqa-relative cqa-mr-2\">\n      <input type=\"checkbox\"\n        [ngModel]=\"selected\"\n        [disabled]=\"disabled\"\n        (ngModelChange)=\"onSelectionChange($event)\"\n        class=\"cqa-h-4 cqa-w-4 cqa-cursor-pointer cqa-transition-all cqa-appearance-none cqa-rounded shadow hover:cqa-shadow-md cqa-border cqa-border-solid cqa-border-slate-300 cqa-flex-shrink-0\"\n        [class.cqa-bg-[#3F43EE]]=\"selected\"\n        [class.cqa-border-[#3F43EE]]=\"selected\"\n        id=\"check\" />\n      <span class=\"cqa-absolute cqa-text-white cqa-top-1/2 cqa-left-1/2 cqa--translate-x-1/2 cqa--translate-y-1/2 cqa-pointer-events-none cqa-flex cqa-items-center cqa-justify-center\"\n        [class.cqa-opacity-0]=\"!selected\"\n        [class.cqa-opacity-100]=\"selected\">\n        <svg width=\"12\" height=\"13\" viewBox=\"0 0 12 13\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M10 3.125L4.5 8.625L2 6.125\" stroke=\"white\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n      </span>\n    </label>\n  </div>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px] cqa-min-w-[32px]\">{{ stepNumber }}</span>\n  <span class=\"cqa-px-2.5 cqa-py-1 cqa-rounded-lg cqa-flex cqa-items-center cqa-gap-2 cqa-bg-[#DBEAFE] cqa-text-[#2563EB]\">\n    <svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M12.25 8.75V11.0833C12.25 11.3928 12.1271 11.6895 11.9083 11.9083C11.6895 12.1271 11.3928 12.25 11.0833 12.25H2.91667C2.60725 12.25 2.3105 12.1271 2.09171 11.9083C1.87292 11.6895 1.75 11.3928 1.75 11.0833V8.75\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9.91667 4.66667L7 1.75L4.08333 4.66667\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M7 1.75V8.75\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>\n    <span class=\"cqa-text-[10px] cqa-leading-[15px] cqa-font-medium\">Upload</span>\n  </span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">Upload file to</span>\n  <span class=\"cqa-py-0.5 cqa-px-2 cqa-text-[#2563EB] cqa-text-[14px] cqa-leading-[17px] cqa-font-semibold cqa-border cqa-border-solid cqa-border-[#93C5FD] cqa-rounded cqa-bg-[#DBEAFE]\">{{ selector }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">File:</span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">{{ fileName }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">Source:</span>\n  <span class=\"cqa-text-[#111827] cqa-text-[14px] cqa-leading-[18px]\">{{ source }}</span>\n  <span class=\"cqa-text-[#6B7280] cqa-text-[14px] cqa-leading-[18px]\">{{ sourcePath }}</span>\n  <div class=\"cqa-flex-grow\"></div>\n  <div class=\"step-actions cqa-flex cqa-items-center cqa-gap-3 cqa-px-[7px]\">\n    <button type=\"button\" (click)=\"onEdit(); $event.stopPropagation()\" title=\"Edit\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M7 11.6666H12.25\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9.55208 2.1128C9.7843 1.88058 10.0993 1.75012 10.4277 1.75012C10.7561 1.75012 11.071 1.88058 11.3033 2.1128C11.5355 2.34502 11.6659 2.65998 11.6659 2.98838C11.6659 3.31679 11.5355 3.63175 11.3033 3.86397L4.29742 10.8704C4.15864 11.0092 3.9871 11.1107 3.79867 11.1656L2.12333 11.6544C2.07314 11.669 2.01993 11.6699 1.96928 11.6569C1.91863 11.6439 1.8724 11.6176 1.83543 11.5806C1.79846 11.5437 1.7721 11.4974 1.75913 11.4468C1.74615 11.3961 1.74703 11.3429 1.76167 11.2927L2.2505 9.61738C2.30546 9.42916 2.40698 9.25783 2.54567 9.11922L9.55208 2.1128Z\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onLink(); $event.stopPropagation()\" title=\"Link\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M5.00065 9.91671H3.66732C2.78326 9.91671 1.93542 9.60942 1.3103 9.06244C0.685174 8.51545 0.333984 7.77359 0.333984 7.00004C0.333984 6.22649 0.685174 5.48463 1.3103 4.93765C1.93542 4.39066 2.78326 4.08337 3.66732 4.08337H5.00065\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M9 4.08337H10.3333C11.2174 4.08337 12.0652 4.39066 12.6904 4.93765C13.3155 5.48463 13.6667 6.22649 13.6667 7.00004C13.6667 7.77359 13.3155 8.51545 12.6904 9.06244C12.0652 9.60942 11.2174 9.91671 10.3333 9.91671H9\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.33398 7H9.66732\" stroke=\"currentColor\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onDuplicate(); $event.stopPropagation()\" title=\"Duplicate\" class=\"cqa-p-0 cqa-text-[#99A1Af] hover:cqa-text-[#1447E6]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M11.666 4.66663H5.83268C5.18835 4.66663 4.66602 5.18896 4.66602 5.83329V11.6666C4.66602 12.311 5.18835 12.8333 5.83268 12.8333H11.666C12.3103 12.8333 12.8327 12.311 12.8327 11.6666V5.83329C12.8327 5.18896 12.3103 4.66663 11.666 4.66663Z\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2.33268 9.33329C1.69102 9.33329 1.16602 8.80829 1.16602 8.16663V2.33329C1.16602 1.69163 1.69102 1.16663 2.33268 1.16663H8.16602C8.80768 1.16663 9.33268 1.69163 9.33268 2.33329\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n    <button type=\"button\" (click)=\"onDelete(); $event.stopPropagation()\" title=\"Delete\" class=\"cqa-p-0 cqa-text-[#ff6467] hover:cqa-text-[#C63535]\"><svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M1.75 3.5H12.25\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M11.0827 3.5V11.6667C11.0827 12.25 10.4993 12.8333 9.91602 12.8333H4.08268C3.49935 12.8333 2.91602 12.25 2.91602 11.6667V3.5\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M4.66602 3.49996V2.33329C4.66602 1.74996 5.24935 1.16663 5.83268 1.16663H8.16602C8.74935 1.16663 9.33268 1.74996 9.33268 2.33329V3.49996\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M5.83398 6.41663V9.91663\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M8.16602 6.41663V9.91663\" stroke=\"currentColor\" stroke-width=\"1.16667\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg></button>\n  </div>\n</div>\n"]}