@cqa-lib/cqa-ui 1.0.52 → 1.0.53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/esm2020/lib/utils/tw-overlay-container.mjs +40 -15
  2. package/fesm2015/cqa-lib-cqa-ui.mjs +39 -14
  3. package/fesm2015/cqa-lib-cqa-ui.mjs.map +1 -1
  4. package/fesm2020/cqa-lib-cqa-ui.mjs +39 -14
  5. package/fesm2020/cqa-lib-cqa-ui.mjs.map +1 -1
  6. package/lib/utils/tw-overlay-container.d.ts +1 -0
  7. package/package.json +1 -1
package/esm2020/lib/utils/tw-overlay-container.mjs CHANGED
@@ -43,34 +43,59 @@ export class TailwindOverlayContainer extends OverlayContainer {
43
43
  // Also check immediately in case overlays already exist
44
44
  requestAnimationFrame(() => this.updateContainerClass());
45
45
  }
46
+ isElementVisible(element) {
47
+ const style = window.getComputedStyle(element);
48
+ // Check if element is visible (not display: none, not opacity: 0, not visibility: hidden)
49
+ const isDisplayed = style.display !== 'none';
50
+ const isOpaque = parseFloat(style.opacity) > 0.01; // Allow for very small opacity values during animations
51
+ const isVisible = style.visibility !== 'hidden';
52
+ // Also check if element has dimensions (width/height > 0)
53
+ const rect = element.getBoundingClientRect();
54
+ const hasSize = rect.width > 0 && rect.height > 0;
55
+ return isDisplayed && isOpaque && isVisible && hasSize;
56
+ }
46
57
  updateContainerClass() {
47
58
  if (!this._containerElement)
48
59
  return;
49
60
  // Count library overlays (dialogs, select panels, datepicker panels)
50
- // These are library-specific classes that indicate library components
51
- // Only count overlays that are actually in the DOM (CDK removes them when closed)
52
- const libraryDialogs = this._containerElement.querySelectorAll('.cqa-dialog-panel').length;
53
- const libraryBackdrops = this._containerElement.querySelectorAll('.cqa-dialog-backdrop').length;
54
- const librarySelectPanels = this._containerElement.querySelectorAll('.ctc-select-panel').length;
55
- const libraryDatePanels = this._containerElement.querySelectorAll('.ctc-date-range-panel').length;
56
- const totalLibraryOverlays = libraryDialogs + libraryBackdrops + librarySelectPanels + libraryDatePanels;
61
+ // Only count overlays that are actually visible/active (not hidden or closing)
62
+ // Library dialogs - check visibility
63
+ const libraryDialogs = Array.from(this._containerElement.querySelectorAll('.cqa-dialog-panel'));
64
+ const visibleLibraryDialogs = libraryDialogs.filter(dialog => this.isElementVisible(dialog)).length;
65
+ // Library backdrops - check visibility (backdrops can be transparent but still present)
66
+ const libraryBackdrops = Array.from(this._containerElement.querySelectorAll('.cqa-dialog-backdrop'));
67
+ const visibleLibraryBackdrops = libraryBackdrops.filter(backdrop => {
68
+ // Backdrops might have low opacity but should still be considered if they're showing
69
+ const style = window.getComputedStyle(backdrop);
70
+ return style.display !== 'none' && backdrop.classList.contains('cdk-overlay-backdrop-showing');
71
+ }).length;
72
+ // Select panels - check visibility
73
+ const selectPanels = Array.from(this._containerElement.querySelectorAll('.ctc-select-panel'));
74
+ const visibleSelectPanels = selectPanels.filter(panel => this.isElementVisible(panel)).length;
75
+ // Date panels - check visibility
76
+ const datePanels = Array.from(this._containerElement.querySelectorAll('.ctc-date-range-panel'));
77
+ const visibleDatePanels = datePanels.filter(panel => this.isElementVisible(panel)).length;
78
+ const totalLibraryOverlays = visibleLibraryDialogs + visibleLibraryBackdrops + visibleSelectPanels + visibleDatePanels;
57
79
  // Check for portal Material dialogs (those without .cqa-dialog-panel class)
58
80
  // Portal dialogs use .mat-dialog-container but NOT .cqa-dialog-panel
59
- const portalDialogs = this._containerElement.querySelectorAll('.mat-dialog-container:not(.cqa-dialog-panel)').length;
60
- // Decision logic: Only add cqa-ui-root when library overlays are present
81
+ const portalDialogs = Array.from(this._containerElement.querySelectorAll('.mat-dialog-container:not(.cqa-dialog-panel)'));
82
+ const visiblePortalDialogs = portalDialogs.filter(dialog => this.isElementVisible(dialog)).length;
83
+ // Decision logic: Only add cqa-ui-root when VISIBLE library overlays are present
61
84
  // This ensures portal Material dialogs don't get affected by library CSS
85
+ // even if library overlays are in the DOM but closing/hidden
62
86
  if (totalLibraryOverlays > 0) {
63
- // Library overlays exist - add the class (they need Tailwind styles scoped to .cqa-ui-root)
87
+ // Visible library overlays exist - add the class (they need Tailwind styles scoped to .cqa-ui-root)
64
88
  this._containerElement.classList.add('cqa-ui-root');
65
89
  }
66
90
  else {
67
- // No library overlays exist - remove the class
68
- // This handles both cases:
91
+ // No visible library overlays exist - remove the class
92
+ // This handles:
69
93
  // 1. Only portal dialogs exist (should not have cqa-ui-root)
70
- // 2. No overlays exist at all (clean state)
94
+ // 2. Library overlays are closing/hidden (should not have cqa-ui-root)
95
+ // 3. No overlays exist at all (clean state)
71
96
  this._containerElement.classList.remove('cqa-ui-root');
72
97
  }
73
- // Note: If both library overlays and portal dialogs exist simultaneously,
98
+ // Note: If both library overlays and portal dialogs exist simultaneously and are visible,
74
99
  // the class will be present because library overlays need it. In this case,
75
100
  // portal dialogs may be affected by library CSS. To avoid this, ensure library
76
101
  // overlays are closed before opening portal dialogs, or use CSS specificity
@@ -82,4 +107,4 @@ TailwindOverlayContainer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0
82
107
  i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TailwindOverlayContainer, decorators: [{
83
108
  type: Injectable
84
109
  }] });
85
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tw-overlay-container.js","sourceRoot":"","sources":["../../../../../src/lib/utils/tw-overlay-container.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;;AAExD;;;;;;;GAOG;AAEH,MAAM,OAAO,wBAAyB,SAAQ,gBAAgB;IAD9D;;QAEU,kBAAa,GAAkB,IAAI,CAAC;KAyE7C;IAvEoB,gBAAgB;QACjC,KAAK,CAAC,gBAAgB,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,iBAAiB,EAAE;YAC1B,yFAAyF;YACzF,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YAEvD,6EAA6E;YAC7E,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;IACH,CAAC;IAEO,sBAAsB;QAC5B,IAAI,CAAC,IAAI,CAAC,iBAAiB;YAAE,OAAO;QAEpC,MAAM,QAAQ,GAAG,IAAI,gBAAgB,CAAC,GAAG,EAAE;YACzC,sEAAsE;YACtE,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,EAAE;gBAC/B,oBAAoB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;aAC1C;YACD,IAAI,CAAC,aAAa,GAAG,qBAAqB,CAAC,GAAG,EAAE;gBAC9C,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC5B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC5B,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE;YACvC,SAAS,EAAE,IAAI;YACf,OAAO,EAAE,IAAI;SACd,CAAC,CAAC;QAEH,wDAAwD;QACxD,qBAAqB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAC3D,CAAC;IAEO,oBAAoB;QAC1B,IAAI,CAAC,IAAI,CAAC,iBAAiB;YAAE,OAAO;QAEpC,qEAAqE;QACrE,sEAAsE;QACtE,kFAAkF;QAClF,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,CAAC,MAAM,CAAC;QAC3F,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,CAAC,MAAM,CAAC;QAChG,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,CAAC,MAAM,CAAC;QAChG,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,uBAAuB,CAAC,CAAC,MAAM,CAAC;QAElG,MAAM,oBAAoB,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,GAAG,iBAAiB,CAAC;QAEzG,4EAA4E;QAC5E,qEAAqE;QACrE,MAAM,aAAa,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,8CAA8C,CAAC,CAAC,MAAM,CAAC;QAErH,yEAAyE;QACzE,yEAAyE;QAEzE,IAAI,oBAAoB,GAAG,CAAC,EAAE;YAC5B,4FAA4F;YAC5F,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;SACrD;aAAM;YACL,+CAA+C;YAC/C,2BAA2B;YAC3B,6DAA6D;YAC7D,4CAA4C;YAC5C,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;SACxD;QAED,0EAA0E;QAC1E,4EAA4E;QAC5E,+EAA+E;QAC/E,4EAA4E;QAC5E,oDAAoD;IACtD,CAAC;;qHAzEU,wBAAwB;yHAAxB,wBAAwB;2FAAxB,wBAAwB;kBADpC,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\nimport { OverlayContainer } from '@angular/cdk/overlay';\n\n/**\n * Ensures Angular CDK overlay content (e.g., MatSelect, Datepicker panels, library dialogs)\n * is nested under an element with class=\"cqa-ui-root\" so Tailwind utilities\n * configured with important: '.cqa-ui-root' are applied inside overlays.\n * \n * IMPORTANT: Only sets class=\"cqa-ui-root\" when library overlays are present.\n * Portal Material dialogs should NOT have this class to prevent library CSS from affecting them.\n */\n@Injectable()\nexport class TailwindOverlayContainer extends OverlayContainer {\n  private updateTimeout: number | null = null;\n\n  protected override _createContainer(): void {\n    super._createContainer();\n    if (this._containerElement) {\n      // Don't set class initially - we'll set it dynamically when library overlays are created\n      this._containerElement.classList.remove('cqa-ui-root');\n      \n      // Use MutationObserver to detect when library overlays are created/destroyed\n      this.observeLibraryOverlays();\n    }\n  }\n\n  private observeLibraryOverlays(): void {\n    if (!this._containerElement) return;\n\n    const observer = new MutationObserver(() => {\n      // Debounce updates to avoid excessive checks during rapid DOM changes\n      if (this.updateTimeout !== null) {\n        cancelAnimationFrame(this.updateTimeout);\n      }\n      this.updateTimeout = requestAnimationFrame(() => {\n        this.updateContainerClass();\n        this.updateTimeout = null;\n      });\n    });\n\n    observer.observe(this._containerElement, {\n      childList: true,\n      subtree: true,\n    });\n\n    // Also check immediately in case overlays already exist\n    requestAnimationFrame(() => this.updateContainerClass());\n  }\n\n  private updateContainerClass(): void {\n    if (!this._containerElement) return;\n\n    // Count library overlays (dialogs, select panels, datepicker panels)\n    // These are library-specific classes that indicate library components\n    // Only count overlays that are actually in the DOM (CDK removes them when closed)\n    const libraryDialogs = this._containerElement.querySelectorAll('.cqa-dialog-panel').length;\n    const libraryBackdrops = this._containerElement.querySelectorAll('.cqa-dialog-backdrop').length;\n    const librarySelectPanels = this._containerElement.querySelectorAll('.ctc-select-panel').length;\n    const libraryDatePanels = this._containerElement.querySelectorAll('.ctc-date-range-panel').length;\n    \n    const totalLibraryOverlays = libraryDialogs + libraryBackdrops + librarySelectPanels + libraryDatePanels;\n    \n    // Check for portal Material dialogs (those without .cqa-dialog-panel class)\n    // Portal dialogs use .mat-dialog-container but NOT .cqa-dialog-panel\n    const portalDialogs = this._containerElement.querySelectorAll('.mat-dialog-container:not(.cqa-dialog-panel)').length;\n\n    // Decision logic: Only add cqa-ui-root when library overlays are present\n    // This ensures portal Material dialogs don't get affected by library CSS\n    \n    if (totalLibraryOverlays > 0) {\n      // Library overlays exist - add the class (they need Tailwind styles scoped to .cqa-ui-root)\n      this._containerElement.classList.add('cqa-ui-root');\n    } else {\n      // No library overlays exist - remove the class\n      // This handles both cases:\n      // 1. Only portal dialogs exist (should not have cqa-ui-root)\n      // 2. No overlays exist at all (clean state)\n      this._containerElement.classList.remove('cqa-ui-root');\n    }\n    \n    // Note: If both library overlays and portal dialogs exist simultaneously,\n    // the class will be present because library overlays need it. In this case,\n    // portal dialogs may be affected by library CSS. To avoid this, ensure library\n    // overlays are closed before opening portal dialogs, or use CSS specificity\n    // to override library styles within portal dialogs.\n  }\n}\n\n\n"]}
110
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tw-overlay-container.js","sourceRoot":"","sources":["../../../../../src/lib/utils/tw-overlay-container.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { OverlayContainer } from '@angular/cdk/overlay';\n\n/**\n * Ensures Angular CDK overlay content (e.g., MatSelect, Datepicker panels, library dialogs)\n * is nested under an element with class=\"cqa-ui-root\" so Tailwind utilities\n * configured with important: '.cqa-ui-root' are applied inside overlays.\n * \n * IMPORTANT: Only sets class=\"cqa-ui-root\" when library overlays are present.\n * Portal Material dialogs should NOT have this class to prevent library CSS from affecting them.\n */\n@Injectable()\nexport class TailwindOverlayContainer extends OverlayContainer {\n  private updateTimeout: number | null = null;\n\n  protected override _createContainer(): void {\n    super._createContainer();\n    if (this._containerElement) {\n      // Don't set class initially - we'll set it dynamically when library overlays are created\n      this._containerElement.classList.remove('cqa-ui-root');\n      \n      // Use MutationObserver to detect when library overlays are created/destroyed\n      this.observeLibraryOverlays();\n    }\n  }\n\n  private observeLibraryOverlays(): void {\n    if (!this._containerElement) return;\n\n    const observer = new MutationObserver(() => {\n      // Debounce updates to avoid excessive checks during rapid DOM changes\n      if (this.updateTimeout !== null) {\n        cancelAnimationFrame(this.updateTimeout);\n      }\n      this.updateTimeout = requestAnimationFrame(() => {\n        this.updateContainerClass();\n        this.updateTimeout = null;\n      });\n    });\n\n    observer.observe(this._containerElement, {\n      childList: true,\n      subtree: true,\n    });\n\n    // Also check immediately in case overlays already exist\n    requestAnimationFrame(() => this.updateContainerClass());\n  }\n\n  private isElementVisible(element: Element): boolean {\n    const style = window.getComputedStyle(element);\n    // Check if element is visible (not display: none, not opacity: 0, not visibility: hidden)\n    const isDisplayed = style.display !== 'none';\n    const isOpaque = parseFloat(style.opacity) > 0.01; // Allow for very small opacity values during animations\n    const isVisible = style.visibility !== 'hidden';\n    \n    // Also check if element has dimensions (width/height > 0)\n    const rect = element.getBoundingClientRect();\n    const hasSize = rect.width > 0 && rect.height > 0;\n    \n    return isDisplayed && isOpaque && isVisible && hasSize;\n  }\n\n  private updateContainerClass(): void {\n    if (!this._containerElement) return;\n\n    // Count library overlays (dialogs, select panels, datepicker panels)\n    // Only count overlays that are actually visible/active (not hidden or closing)\n    \n    // Library dialogs - check visibility\n    const libraryDialogs = Array.from(this._containerElement.querySelectorAll('.cqa-dialog-panel'));\n    const visibleLibraryDialogs = libraryDialogs.filter(dialog => this.isElementVisible(dialog)).length;\n    \n    // Library backdrops - check visibility (backdrops can be transparent but still present)\n    const libraryBackdrops = Array.from(this._containerElement.querySelectorAll('.cqa-dialog-backdrop'));\n    const visibleLibraryBackdrops = libraryBackdrops.filter(backdrop => {\n      // Backdrops might have low opacity but should still be considered if they're showing\n      const style = window.getComputedStyle(backdrop);\n      return style.display !== 'none' && backdrop.classList.contains('cdk-overlay-backdrop-showing');\n    }).length;\n    \n    // Select panels - check visibility\n    const selectPanels = Array.from(this._containerElement.querySelectorAll('.ctc-select-panel'));\n    const visibleSelectPanels = selectPanels.filter(panel => this.isElementVisible(panel)).length;\n    \n    // Date panels - check visibility\n    const datePanels = Array.from(this._containerElement.querySelectorAll('.ctc-date-range-panel'));\n    const visibleDatePanels = datePanels.filter(panel => this.isElementVisible(panel)).length;\n    \n    const totalLibraryOverlays = visibleLibraryDialogs + visibleLibraryBackdrops + visibleSelectPanels + visibleDatePanels;\n    \n    // Check for portal Material dialogs (those without .cqa-dialog-panel class)\n    // Portal dialogs use .mat-dialog-container but NOT .cqa-dialog-panel\n    const portalDialogs = Array.from(this._containerElement.querySelectorAll('.mat-dialog-container:not(.cqa-dialog-panel)'));\n    const visiblePortalDialogs = portalDialogs.filter(dialog => this.isElementVisible(dialog)).length;\n\n    // Decision logic: Only add cqa-ui-root when VISIBLE library overlays are present\n    // This ensures portal Material dialogs don't get affected by library CSS\n    // even if library overlays are in the DOM but closing/hidden\n    \n    if (totalLibraryOverlays > 0) {\n      // Visible library overlays exist - add the class (they need Tailwind styles scoped to .cqa-ui-root)\n      this._containerElement.classList.add('cqa-ui-root');\n    } else {\n      // No visible library overlays exist - remove the class\n      // This handles:\n      // 1. Only portal dialogs exist (should not have cqa-ui-root)\n      // 2. Library overlays are closing/hidden (should not have cqa-ui-root)\n      // 3. No overlays exist at all (clean state)\n      this._containerElement.classList.remove('cqa-ui-root');\n    }\n    \n    // Note: If both library overlays and portal dialogs exist simultaneously and are visible,\n    // the class will be present because library overlays need it. In this case,\n    // portal dialogs may be affected by library CSS. To avoid this, ensure library\n    // overlays are closed before opening portal dialogs, or use CSS specificity\n    // to override library styles within portal dialogs.\n  }\n}\n\n\n"]}
package/fesm2015/cqa-lib-cqa-ui.mjs CHANGED
@@ -4255,34 +4255,59 @@ class TailwindOverlayContainer extends OverlayContainer {
4255
4255
  // Also check immediately in case overlays already exist
4256
4256
  requestAnimationFrame(() => this.updateContainerClass());
4257
4257
  }
4258
+ isElementVisible(element) {
4259
+ const style = window.getComputedStyle(element);
4260
+ // Check if element is visible (not display: none, not opacity: 0, not visibility: hidden)
4261
+ const isDisplayed = style.display !== 'none';
4262
+ const isOpaque = parseFloat(style.opacity) > 0.01; // Allow for very small opacity values during animations
4263
+ const isVisible = style.visibility !== 'hidden';
4264
+ // Also check if element has dimensions (width/height > 0)
4265
+ const rect = element.getBoundingClientRect();
4266
+ const hasSize = rect.width > 0 && rect.height > 0;
4267
+ return isDisplayed && isOpaque && isVisible && hasSize;
4268
+ }
4258
4269
  updateContainerClass() {
4259
4270
  if (!this._containerElement)
4260
4271
  return;
4261
4272
  // Count library overlays (dialogs, select panels, datepicker panels)
4262
- // These are library-specific classes that indicate library components
4263
- // Only count overlays that are actually in the DOM (CDK removes them when closed)
4264
- const libraryDialogs = this._containerElement.querySelectorAll('.cqa-dialog-panel').length;
4265
- const libraryBackdrops = this._containerElement.querySelectorAll('.cqa-dialog-backdrop').length;
4266
- const librarySelectPanels = this._containerElement.querySelectorAll('.ctc-select-panel').length;
4267
- const libraryDatePanels = this._containerElement.querySelectorAll('.ctc-date-range-panel').length;
4268
- const totalLibraryOverlays = libraryDialogs + libraryBackdrops + librarySelectPanels + libraryDatePanels;
4273
+ // Only count overlays that are actually visible/active (not hidden or closing)
4274
+ // Library dialogs - check visibility
4275
+ const libraryDialogs = Array.from(this._containerElement.querySelectorAll('.cqa-dialog-panel'));
4276
+ const visibleLibraryDialogs = libraryDialogs.filter(dialog => this.isElementVisible(dialog)).length;
4277
+ // Library backdrops - check visibility (backdrops can be transparent but still present)
4278
+ const libraryBackdrops = Array.from(this._containerElement.querySelectorAll('.cqa-dialog-backdrop'));
4279
+ const visibleLibraryBackdrops = libraryBackdrops.filter(backdrop => {
4280
+ // Backdrops might have low opacity but should still be considered if they're showing
4281
+ const style = window.getComputedStyle(backdrop);
4282
+ return style.display !== 'none' && backdrop.classList.contains('cdk-overlay-backdrop-showing');
4283
+ }).length;
4284
+ // Select panels - check visibility
4285
+ const selectPanels = Array.from(this._containerElement.querySelectorAll('.ctc-select-panel'));
4286
+ const visibleSelectPanels = selectPanels.filter(panel => this.isElementVisible(panel)).length;
4287
+ // Date panels - check visibility
4288
+ const datePanels = Array.from(this._containerElement.querySelectorAll('.ctc-date-range-panel'));
4289
+ const visibleDatePanels = datePanels.filter(panel => this.isElementVisible(panel)).length;
4290
+ const totalLibraryOverlays = visibleLibraryDialogs + visibleLibraryBackdrops + visibleSelectPanels + visibleDatePanels;
4269
4291
  // Check for portal Material dialogs (those without .cqa-dialog-panel class)
4270
4292
  // Portal dialogs use .mat-dialog-container but NOT .cqa-dialog-panel
4271
- const portalDialogs = this._containerElement.querySelectorAll('.mat-dialog-container:not(.cqa-dialog-panel)').length;
4272
- // Decision logic: Only add cqa-ui-root when library overlays are present
4293
+ const portalDialogs = Array.from(this._containerElement.querySelectorAll('.mat-dialog-container:not(.cqa-dialog-panel)'));
4294
+ const visiblePortalDialogs = portalDialogs.filter(dialog => this.isElementVisible(dialog)).length;
4295
+ // Decision logic: Only add cqa-ui-root when VISIBLE library overlays are present
4273
4296
  // This ensures portal Material dialogs don't get affected by library CSS
4297
+ // even if library overlays are in the DOM but closing/hidden
4274
4298
  if (totalLibraryOverlays > 0) {
4275
- // Library overlays exist - add the class (they need Tailwind styles scoped to .cqa-ui-root)
4299
+ // Visible library overlays exist - add the class (they need Tailwind styles scoped to .cqa-ui-root)
4276
4300
  this._containerElement.classList.add('cqa-ui-root');
4277
4301
  }
4278
4302
  else {
4279
- // No library overlays exist - remove the class
4280
- // This handles both cases:
4303
+ // No visible library overlays exist - remove the class
4304
+ // This handles:
4281
4305
  // 1. Only portal dialogs exist (should not have cqa-ui-root)
4282
- // 2. No overlays exist at all (clean state)
4306
+ // 2. Library overlays are closing/hidden (should not have cqa-ui-root)
4307
+ // 3. No overlays exist at all (clean state)
4283
4308
  this._containerElement.classList.remove('cqa-ui-root');
4284
4309
  }
4285
- // Note: If both library overlays and portal dialogs exist simultaneously,
4310
+ // Note: If both library overlays and portal dialogs exist simultaneously and are visible,
4286
4311
  // the class will be present because library overlays need it. In this case,
4287
4312
  // portal dialogs may be affected by library CSS. To avoid this, ensure library
4288
4313
  // overlays are closed before opening portal dialogs, or use CSS specificity