@cqa-lib/cqa-ui 1.1.554 → 1.1.555

package/esm2020/lib/test-suite/move-test-suite-dialog/move-test-suite-dialog.component.mjs

@@ -0,0 +1,307 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { DEFAULT_MODULAR_LABELS, } from '../../templates/modular-table-template/modular-table-template.models';
+import { DEFAULT_TEST_SUITE_LABELS } from '../test-suite.models';
+import * as i0 from "@angular/core";
+import * as i1 from "../../custom-input/custom-input.component";
+import * as i2 from "../../templates/modular-table-template/dialogs/move-to-folder-dialog.component";
+/**
+ * Body of the "Move Test Suite" dialog.
+ *
+ * Reuses `<cqa-move-to-folder-dialog>` as the tree picker (same embedding pattern
+ * as `NewFolderDialogComponent`) so consumers get the same folder-tree UX, while
+ * adding two read-only rows above it: the suite's **current folder** (source)
+ * and the **destination folder** the user has picked (live-updates).
+ *
+ * Two integration paths:
+ *
+ *  1. **From within this library** via `DialogService.open(...)`. The outer
+ *     `cqa-dialog` supplies title/description/Cancel/Move buttons; the Move
+ *     button reads `pickedFolderId` via `dialogRef.getComponentInstance()` and
+ *     checks `isValid` before closing.
+ *
+ *  2. **Host-driven** — host renders `<cqa-move-test-suite-dialog>` inside its
+ *     own modal and listens to `(submitted)` / `(cancelled)` / `(pickedFolderIdChange)`.
+ */
+export class MoveTestSuiteDialogComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        // NOTE: `folders` and `labels` are declared as setters (instead of plain @Input fields)
+        // because `DialogService.open(...)` assigns the `inputs` map via direct property
+        // assignment *after* `attachComponent` has already run the component's lifecycle
+        // hooks — direct assignment bypasses `ngOnChanges`, so setters keep derived state
+        // in sync no matter the assignment order. Same pattern as `NewFolderDialogComponent`.
+        this._folders = [];
+        this._labels = { ...DEFAULT_MODULAR_LABELS };
+        /** Test-suite-section labels (title, description, button text, field labels,
+         *  placeholder). Kept separate from `labels` (ModularLabels) so the embedded
+         *  picker can keep its modular-table-template label model. Same setter
+         *  pattern as `labels` for DialogService property-assignment compatibility. */
+        this._testSuiteLabels = { ...DEFAULT_TEST_SUITE_LABELS };
+        /** Folder the suite currently lives in. Used both to gray out the row in the
+         *  embedded picker and to render the "Current folder" readout. */
+        this.currentFolderId = null;
+        /** Optional override for the current-folder display name. When not provided,
+         *  the component resolves the name from `folders` by walking to `currentFolderId`,
+         *  falling back to `labels.moveDialogRoot` ("Unorganized") when null. */
+        this.currentFolderName = null;
+        /** Name of the test suite being moved. Rendered as a disabled input at the
+         *  top of the dialog body so the user can confirm which suite the move
+         *  applies to. Defaults to empty string. */
+        this.suiteName = '';
+        /** Destination folder id picked by the user. Two-way-bind friendly. */
+        this.pickedFolderId = null;
+        /** Height of the embedded picker. Defaults to 240px (matches the parent-folder
+         *  picker height in `NewFolderDialogComponent`) so the modal stays compact. */
+        this.pickerHeight = '240px';
+        /** When true (default), both the Current folder and Destination folder inputs
+         *  render as disabled (read-only via the cqa-custom-input `[disabled]` flag).
+         *  Set to false if a host needs to re-enable interaction on those fields. */
+        this.fieldsDisabled = true;
+        this.pickedFolderIdChange = new EventEmitter();
+        this.submitted = new EventEmitter();
+        this.cancelled = new EventEmitter();
+        /** Bubble cqa-custom-input focus/blur events up to hosts. Useful when
+         *  `fieldsDisabled = false` and the host wants to react to interaction. */
+        this.currentFieldFocus = new EventEmitter();
+        this.currentFieldBlur = new EventEmitter();
+        this.destinationFieldFocus = new EventEmitter();
+        this.destinationFieldBlur = new EventEmitter();
+        /** Set to true the first time the user picks anything. Lets `isValid` treat
+         *  the initial pre-touch state as "nothing selected" — important when the
+         *  suite starts in Unorganized (`currentFolderId = null`) so a fresh dialog
+         *  doesn't appear valid just because `pickedFolderId` also defaults to null. */
+        this.pickedTouched = false;
+    }
+    set folders(value) {
+        this._folders = value || [];
+        this.cdr.markForCheck();
+    }
+    get folders() { return this._folders; }
+    set labels(value) {
+        this._labels = value || { ...DEFAULT_MODULAR_LABELS };
+        this.cdr.markForCheck();
+    }
+    get labels() { return this._labels; }
+    set testSuiteLabels(value) {
+        this._testSuiteLabels = value || { ...DEFAULT_TEST_SUITE_LABELS };
+        this.cdr.markForCheck();
+    }
+    get testSuiteLabels() { return this._testSuiteLabels; }
+    onParentPicked(id) {
+        let next = null;
+        if (id != null) {
+            const coerced = typeof id === 'number' ? id : Number(id);
+            if (Number.isFinite(coerced))
+                next = coerced;
+        }
+        this.pickedFolderId = next;
+        this.pickedTouched = true;
+        this.pickedFolderIdChange.emit(next);
+        this.cdr.markForCheck();
+    }
+    /** True once the user has picked a destination via the embedded tree. Drives
+     *  the destination-readout styling (indigo when picked, muted when not). */
+    get hasPick() {
+        return this.pickedTouched;
+    }
+    get resolvedCurrentName() {
+        if (this.currentFolderName && this.currentFolderName.trim().length) {
+            return this.currentFolderName;
+        }
+        if (this.currentFolderId == null) {
+            return this.labels.moveDialogRoot;
+        }
+        const name = this.findFolderName(this._folders, this.currentFolderId);
+        return name ?? this.labels.moveDialogRoot;
+    }
+    /** Value shown inside the Destination input. Empty until the user picks; once
+     *  picked, the resolved folder name (or `labels.moveDialogRoot` for Unorganized).
+     *  Empty state lets the input's `[placeholder]` show through. */
+    get destinationFieldValue() {
+        if (!this.pickedTouched)
+            return '';
+        if (this.pickedFolderId == null)
+            return this.labels.moveDialogRoot;
+        return this.findFolderName(this._folders, this.pickedFolderId) ?? this.labels.moveDialogRoot;
+    }
+    /** Placeholder shown in the Destination input before the user picks. */
+    get destinationFieldPlaceholder() {
+        return this._testSuiteLabels.moveTestSuiteDialogDestinationPlaceholder;
+    }
+    /** Move is valid when the user has picked a destination different from the
+     *  current folder. Picking the same folder as the source is a no-op, and we
+     *  also require an explicit interaction (`pickedTouched`). */
+    get isValid() {
+        if (!this.pickedTouched)
+            return false;
+        return this.pickedFolderId !== this.currentFolderId;
+    }
+    submit() {
+        if (!this.isValid)
+            return;
+        this.submitted.emit({ targetFolderId: this.pickedFolderId });
+    }
+    cancel() {
+        this.cancelled.emit();
+    }
+    /** Hooks for the Current folder cqa-custom-input. Field is disabled by
+     *  default, so these mostly no-op; they're wired so the component still
+     *  behaves correctly when `fieldsDisabled = false`. */
+    onCurrentFieldValueChange(_value) {
+        // Read-only field — ignore programmatic changes.
+    }
+    onCurrentFieldFocused(event) {
+        this.currentFieldFocus.emit(event);
+    }
+    onCurrentFieldBlurred(event) {
+        this.currentFieldBlur.emit(event);
+    }
+    /** Hooks for the Destination folder cqa-custom-input. Value is driven by the
+     *  tree picker below, so the input itself is informational. */
+    onDestinationFieldValueChange(_value) {
+        // Destination is driven by the tree picker, not the input itself.
+    }
+    onDestinationFieldFocused(event) {
+        this.destinationFieldFocus.emit(event);
+    }
+    onDestinationFieldBlurred(event) {
+        this.destinationFieldBlur.emit(event);
+    }
+    findFolderName(nodes, id) {
+        for (const n of nodes || []) {
+            if (n.id === id)
+                return n.name;
+            if (n.children?.length) {
+                const hit = this.findFolderName(n.children, id);
+                if (hit != null)
+                    return hit;
+            }
+        }
+        return null;
+    }
+}
+MoveTestSuiteDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: MoveTestSuiteDialogComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+MoveTestSuiteDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: MoveTestSuiteDialogComponent, selector: "cqa-move-test-suite-dialog", inputs: { folders: "folders", labels: "labels", testSuiteLabels: "testSuiteLabels", currentFolderId: "currentFolderId", currentFolderName: "currentFolderName", suiteName: "suiteName", pickedFolderId: "pickedFolderId", pickerHeight: "pickerHeight", fieldsDisabled: "fieldsDisabled" }, outputs: { pickedFolderIdChange: "pickedFolderIdChange", submitted: "submitted", cancelled: "cancelled", currentFieldFocus: "currentFieldFocus", currentFieldBlur: "currentFieldBlur", destinationFieldFocus: "destinationFieldFocus", destinationFieldBlur: "destinationFieldBlur" }, host: { classAttribute: "cqa-ui-root" }, ngImport: i0, template: `
+    <div class="cqa-flex cqa-flex-col cqa-gap-2 cqa-w-full">
+      <!-- Test suite name (read-only display; surfaces which suite is being moved) -->
+      <cqa-custom-input
+        [label]="testSuiteLabels.moveTestSuiteDialogSuiteNameLabel"
+        [value]="suiteName"
+        [disabled]="fieldsDisabled"
+        [fullWidth]="true"
+      ></cqa-custom-input>
+
+      <!-- Current folder (rendered as a disabled input) -->
+      <cqa-custom-input
+        [label]="testSuiteLabels.moveTestSuiteDialogCurrentLabel"
+        [value]="resolvedCurrentName"
+        [disabled]="fieldsDisabled"
+        [fullWidth]="true"
+        (valueChange)="onCurrentFieldValueChange($event)"
+        (focused)="onCurrentFieldFocused($event)"
+        (blurred)="onCurrentFieldBlurred($event)"
+      ></cqa-custom-input>
+
+      <!-- Destination folder (rendered as a disabled input; value driven by the tree picker below) -->
+      <cqa-custom-input
+        [label]="testSuiteLabels.moveTestSuiteDialogDestinationLabel"
+        [value]="destinationFieldValue"
+        [placeholder]="destinationFieldPlaceholder"
+        [disabled]="fieldsDisabled"
+        [fullWidth]="true"
+        (valueChange)="onDestinationFieldValueChange($event)"
+        (focused)="onDestinationFieldFocused($event)"
+        (blurred)="onDestinationFieldBlurred($event)"
+      ></cqa-custom-input>
+
+      <!-- Folder tree picker -->
+      <cqa-move-to-folder-dialog
+        [folders]="folders"
+        [labels]="labels"
+        [currentFolderId]="currentFolderId"
+        [pickedFolderId]="pickedFolderId"
+        [pickerHeight]="pickerHeight"
+        (pickedFolderIdChange)="onParentPicked($event)"
+      ></cqa-move-to-folder-dialog>
+    </div>
+  `, isInline: true, components: [{ type: i1.CustomInputComponent, selector: "cqa-custom-input", inputs: ["inputId", "label", "type", "placeholder", "value", "disabled", "errors", "required", "ariaLabel", "size", "fullWidth", "maxLength", "showCharCount", "inputInlineStyle", "labelInlineStyle"], outputs: ["valueChange", "blurred", "focused", "enterPressed"] }, { type: i2.MoveToFolderDialogComponent, selector: "cqa-move-to-folder-dialog", inputs: ["folders", "labels", "currentFolderId", "pickedFolderId", "initialExpandedIds", "rootDisabled", "pickerHeight"], outputs: ["folderPicked", "pickedFolderIdChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: MoveTestSuiteDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'cqa-move-test-suite-dialog', template: `
+    <div class="cqa-flex cqa-flex-col cqa-gap-2 cqa-w-full">
+      <!-- Test suite name (read-only display; surfaces which suite is being moved) -->
+      <cqa-custom-input
+        [label]="testSuiteLabels.moveTestSuiteDialogSuiteNameLabel"
+        [value]="suiteName"
+        [disabled]="fieldsDisabled"
+        [fullWidth]="true"
+      ></cqa-custom-input>
+
+      <!-- Current folder (rendered as a disabled input) -->
+      <cqa-custom-input
+        [label]="testSuiteLabels.moveTestSuiteDialogCurrentLabel"
+        [value]="resolvedCurrentName"
+        [disabled]="fieldsDisabled"
+        [fullWidth]="true"
+        (valueChange)="onCurrentFieldValueChange($event)"
+        (focused)="onCurrentFieldFocused($event)"
+        (blurred)="onCurrentFieldBlurred($event)"
+      ></cqa-custom-input>
+
+      <!-- Destination folder (rendered as a disabled input; value driven by the tree picker below) -->
+      <cqa-custom-input
+        [label]="testSuiteLabels.moveTestSuiteDialogDestinationLabel"
+        [value]="destinationFieldValue"
+        [placeholder]="destinationFieldPlaceholder"
+        [disabled]="fieldsDisabled"
+        [fullWidth]="true"
+        (valueChange)="onDestinationFieldValueChange($event)"
+        (focused)="onDestinationFieldFocused($event)"
+        (blurred)="onDestinationFieldBlurred($event)"
+      ></cqa-custom-input>
+
+      <!-- Folder tree picker -->
+      <cqa-move-to-folder-dialog
+        [folders]="folders"
+        [labels]="labels"
+        [currentFolderId]="currentFolderId"
+        [pickedFolderId]="pickedFolderId"
+        [pickerHeight]="pickerHeight"
+        (pickedFolderIdChange)="onParentPicked($event)"
+      ></cqa-move-to-folder-dialog>
+    </div>
+  `, host: { class: 'cqa-ui-root' }, changeDetection: ChangeDetectionStrategy.OnPush, styles: [] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { folders: [{
+                type: Input
+            }], labels: [{
+                type: Input
+            }], testSuiteLabels: [{
+                type: Input
+            }], currentFolderId: [{
+                type: Input
+            }], currentFolderName: [{
+                type: Input
+            }], suiteName: [{
+                type: Input
+            }], pickedFolderId: [{
+                type: Input
+            }], pickerHeight: [{
+                type: Input
+            }], fieldsDisabled: [{
+                type: Input
+            }], pickedFolderIdChange: [{
+                type: Output
+            }], submitted: [{
+                type: Output
+            }], cancelled: [{
+                type: Output
+            }], currentFieldFocus: [{
+                type: Output
+            }], currentFieldBlur: [{
+                type: Output
+            }], destinationFieldFocus: [{
+                type: Output
+            }], destinationFieldBlur: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"move-test-suite-dialog.component.js","sourceRoot":"","sources":["../../../../../../src/lib/test-suite/move-test-suite-dialog/move-test-suite-dialog.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n} from '@angular/core';\nimport {\n  DEFAULT_MODULAR_LABELS,\n  FolderNode,\n  ModularLabels,\n} from '../../templates/modular-table-template/modular-table-template.models';\nimport { DEFAULT_TEST_SUITE_LABELS, TestSuiteLabels } from '../test-suite.models';\n\n/**\n * Body of the \"Move Test Suite\" dialog.\n *\n * Reuses `<cqa-move-to-folder-dialog>` as the tree picker (same embedding pattern\n * as `NewFolderDialogComponent`) so consumers get the same folder-tree UX, while\n * adding two read-only rows above it: the suite's **current folder** (source)\n * and the **destination folder** the user has picked (live-updates).\n *\n * Two integration paths:\n *\n *  1. **From within this library** via `DialogService.open(...)`. The outer\n *     `cqa-dialog` supplies title/description/Cancel/Move buttons; the Move\n *     button reads `pickedFolderId` via `dialogRef.getComponentInstance()` and\n *     checks `isValid` before closing.\n *\n *  2. **Host-driven** — host renders `<cqa-move-test-suite-dialog>` inside its\n *     own modal and listens to `(submitted)` / `(cancelled)` / `(pickedFolderIdChange)`.\n */\n@Component({\n  selector: 'cqa-move-test-suite-dialog',\n  template: `\n    <div class=\"cqa-flex cqa-flex-col cqa-gap-2 cqa-w-full\">\n      <!-- Test suite name (read-only display; surfaces which suite is being moved) -->\n      <cqa-custom-input\n        [label]=\"testSuiteLabels.moveTestSuiteDialogSuiteNameLabel\"\n        [value]=\"suiteName\"\n        [disabled]=\"fieldsDisabled\"\n        [fullWidth]=\"true\"\n      ></cqa-custom-input>\n\n      <!-- Current folder (rendered as a disabled input) -->\n      <cqa-custom-input\n        [label]=\"testSuiteLabels.moveTestSuiteDialogCurrentLabel\"\n        [value]=\"resolvedCurrentName\"\n        [disabled]=\"fieldsDisabled\"\n        [fullWidth]=\"true\"\n        (valueChange)=\"onCurrentFieldValueChange($event)\"\n        (focused)=\"onCurrentFieldFocused($event)\"\n        (blurred)=\"onCurrentFieldBlurred($event)\"\n      ></cqa-custom-input>\n\n      <!-- Destination folder (rendered as a disabled input; value driven by the tree picker below) -->\n      <cqa-custom-input\n        [label]=\"testSuiteLabels.moveTestSuiteDialogDestinationLabel\"\n        [value]=\"destinationFieldValue\"\n        [placeholder]=\"destinationFieldPlaceholder\"\n        [disabled]=\"fieldsDisabled\"\n        [fullWidth]=\"true\"\n        (valueChange)=\"onDestinationFieldValueChange($event)\"\n        (focused)=\"onDestinationFieldFocused($event)\"\n        (blurred)=\"onDestinationFieldBlurred($event)\"\n      ></cqa-custom-input>\n\n      <!-- Folder tree picker -->\n      <cqa-move-to-folder-dialog\n        [folders]=\"folders\"\n        [labels]=\"labels\"\n        [currentFolderId]=\"currentFolderId\"\n        [pickedFolderId]=\"pickedFolderId\"\n        [pickerHeight]=\"pickerHeight\"\n        (pickedFolderIdChange)=\"onParentPicked($event)\"\n      ></cqa-move-to-folder-dialog>\n    </div>\n  `,\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' },\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class MoveTestSuiteDialogComponent {\n  // NOTE: `folders` and `labels` are declared as setters (instead of plain @Input fields)\n  // because `DialogService.open(...)` assigns the `inputs` map via direct property\n  // assignment *after* `attachComponent` has already run the component's lifecycle\n  // hooks — direct assignment bypasses `ngOnChanges`, so setters keep derived state\n  // in sync no matter the assignment order. Same pattern as `NewFolderDialogComponent`.\n\n  private _folders: FolderNode[] = [];\n  @Input() set folders(value: FolderNode[]) {\n    this._folders = value || [];\n    this.cdr.markForCheck();\n  }\n  get folders(): FolderNode[] { return this._folders; }\n\n  private _labels: ModularLabels = { ...DEFAULT_MODULAR_LABELS };\n  @Input() set labels(value: ModularLabels) {\n    this._labels = value || { ...DEFAULT_MODULAR_LABELS };\n    this.cdr.markForCheck();\n  }\n  get labels(): ModularLabels { return this._labels; }\n\n  /** Test-suite-section labels (title, description, button text, field labels,\n   *  placeholder). Kept separate from `labels` (ModularLabels) so the embedded\n   *  picker can keep its modular-table-template label model. Same setter\n   *  pattern as `labels` for DialogService property-assignment compatibility. */\n  private _testSuiteLabels: TestSuiteLabels = { ...DEFAULT_TEST_SUITE_LABELS };\n  @Input() set testSuiteLabels(value: TestSuiteLabels) {\n    this._testSuiteLabels = value || { ...DEFAULT_TEST_SUITE_LABELS };\n    this.cdr.markForCheck();\n  }\n  get testSuiteLabels(): TestSuiteLabels { return this._testSuiteLabels; }\n\n  /** Folder the suite currently lives in. Used both to gray out the row in the\n   *  embedded picker and to render the \"Current folder\" readout. */\n  @Input() currentFolderId: number | null = null;\n\n  /** Optional override for the current-folder display name. When not provided,\n   *  the component resolves the name from `folders` by walking to `currentFolderId`,\n   *  falling back to `labels.moveDialogRoot` (\"Unorganized\") when null. */\n  @Input() currentFolderName: string | null = null;\n\n  /** Name of the test suite being moved. Rendered as a disabled input at the\n   *  top of the dialog body so the user can confirm which suite the move\n   *  applies to. Defaults to empty string. */\n  @Input() suiteName: string = '';\n\n  /** Destination folder id picked by the user. Two-way-bind friendly. */\n  @Input() pickedFolderId: number | null = null;\n\n  /** Height of the embedded picker. Defaults to 240px (matches the parent-folder\n   *  picker height in `NewFolderDialogComponent`) so the modal stays compact. */\n  @Input() pickerHeight: string = '240px';\n\n  /** When true (default), both the Current folder and Destination folder inputs\n   *  render as disabled (read-only via the cqa-custom-input `[disabled]` flag).\n   *  Set to false if a host needs to re-enable interaction on those fields. */\n  @Input() fieldsDisabled: boolean = true;\n\n  @Output() pickedFolderIdChange = new EventEmitter<number | null>();\n  @Output() submitted = new EventEmitter<{ targetFolderId: number | null }>();\n  @Output() cancelled = new EventEmitter<void>();\n\n  /** Bubble cqa-custom-input focus/blur events up to hosts. Useful when\n   *  `fieldsDisabled = false` and the host wants to react to interaction. */\n  @Output() currentFieldFocus = new EventEmitter<FocusEvent>();\n  @Output() currentFieldBlur = new EventEmitter<FocusEvent>();\n  @Output() destinationFieldFocus = new EventEmitter<FocusEvent>();\n  @Output() destinationFieldBlur = new EventEmitter<FocusEvent>();\n\n  /** Set to true the first time the user picks anything. Lets `isValid` treat\n   *  the initial pre-touch state as \"nothing selected\" — important when the\n   *  suite starts in Unorganized (`currentFolderId = null`) so a fresh dialog\n   *  doesn't appear valid just because `pickedFolderId` also defaults to null. */\n  private pickedTouched = false;\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  onParentPicked(id: number | null): void {\n    let next: number | null = null;\n    if (id != null) {\n      const coerced = typeof id === 'number' ? id : Number(id);\n      if (Number.isFinite(coerced)) next = coerced;\n    }\n    this.pickedFolderId = next;\n    this.pickedTouched = true;\n    this.pickedFolderIdChange.emit(next);\n    this.cdr.markForCheck();\n  }\n\n  /** True once the user has picked a destination via the embedded tree. Drives\n   *  the destination-readout styling (indigo when picked, muted when not). */\n  get hasPick(): boolean {\n    return this.pickedTouched;\n  }\n\n  get resolvedCurrentName(): string {\n    if (this.currentFolderName && this.currentFolderName.trim().length) {\n      return this.currentFolderName;\n    }\n    if (this.currentFolderId == null) {\n      return this.labels.moveDialogRoot;\n    }\n    const name = this.findFolderName(this._folders, this.currentFolderId);\n    return name ?? this.labels.moveDialogRoot;\n  }\n\n  /** Value shown inside the Destination input. Empty until the user picks; once\n   *  picked, the resolved folder name (or `labels.moveDialogRoot` for Unorganized).\n   *  Empty state lets the input's `[placeholder]` show through. */\n  get destinationFieldValue(): string {\n    if (!this.pickedTouched) return '';\n    if (this.pickedFolderId == null) return this.labels.moveDialogRoot;\n    return this.findFolderName(this._folders, this.pickedFolderId) ?? this.labels.moveDialogRoot;\n  }\n\n  /** Placeholder shown in the Destination input before the user picks. */\n  get destinationFieldPlaceholder(): string {\n    return this._testSuiteLabels.moveTestSuiteDialogDestinationPlaceholder;\n  }\n\n  /** Move is valid when the user has picked a destination different from the\n   *  current folder. Picking the same folder as the source is a no-op, and we\n   *  also require an explicit interaction (`pickedTouched`). */\n  get isValid(): boolean {\n    if (!this.pickedTouched) return false;\n    return this.pickedFolderId !== this.currentFolderId;\n  }\n\n  submit(): void {\n    if (!this.isValid) return;\n    this.submitted.emit({ targetFolderId: this.pickedFolderId });\n  }\n\n  cancel(): void {\n    this.cancelled.emit();\n  }\n\n  /** Hooks for the Current folder cqa-custom-input. Field is disabled by\n   *  default, so these mostly no-op; they're wired so the component still\n   *  behaves correctly when `fieldsDisabled = false`. */\n  onCurrentFieldValueChange(_value: string): void {\n    // Read-only field — ignore programmatic changes.\n  }\n  onCurrentFieldFocused(event: FocusEvent): void {\n    this.currentFieldFocus.emit(event);\n  }\n  onCurrentFieldBlurred(event: FocusEvent): void {\n    this.currentFieldBlur.emit(event);\n  }\n\n  /** Hooks for the Destination folder cqa-custom-input. Value is driven by the\n   *  tree picker below, so the input itself is informational. */\n  onDestinationFieldValueChange(_value: string): void {\n    // Destination is driven by the tree picker, not the input itself.\n  }\n  onDestinationFieldFocused(event: FocusEvent): void {\n    this.destinationFieldFocus.emit(event);\n  }\n  onDestinationFieldBlurred(event: FocusEvent): void {\n    this.destinationFieldBlur.emit(event);\n  }\n\n  private findFolderName(nodes: FolderNode[], id: number): string | null {\n    for (const n of nodes || []) {\n      if (n.id === id) return n.name;\n      if (n.children?.length) {\n        const hit = this.findFolderName(n.children, id);\n        if (hit != null) return hit;\n      }\n    }\n    return null;\n  }\n}\n"]}

package/esm2020/lib/test-suite/test-suite.models.mjs

@@ -0,0 +1,11 @@
+export const DEFAULT_TEST_SUITE_LABELS = {
+    moveTestSuiteDialogTitle: 'Move test suite',
+    moveTestSuiteDialogDescription: 'Pick a destination folder for this test suite.',
+    moveTestSuiteDialogSuiteNameLabel: 'Test suite',
+    moveTestSuiteDialogCurrentLabel: 'Current folder',
+    moveTestSuiteDialogDestinationLabel: 'Destination folder',
+    moveTestSuiteDialogDestinationPlaceholder: 'Select a folder below',
+    moveTestSuiteDialogCancel: 'Cancel',
+    moveTestSuiteDialogConfirm: 'Move',
+};
+//# sourceMappingURL=data:application/json;base64,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