@eqproject/eqp-dynamic-module 2.11.5 → 2.11.7

package/esm2020/lib/utils/refresh-outline-notch.mjs

@@ -0,0 +1,38 @@
+/**
+ * Rimisura la label di un mat-form-field "outline" e riallinea l'apertura nel bordo.
+ *
+ * Material misura la label solo alla creazione del campo: se poi gli stili iniettati
+ * cambiano font, spaziatura o larghezza della descrizione, l'apertura resta stretta
+ * e la label sollevata viene tagliata.
+ */
+export function refreshOutlineNotch(formField) {
+    if (!formField) {
+        return;
+    }
+    // Attende che il browser applichi il nuovo tag <style> prima di misurare
+    setTimeout(() => {
+        formField._refreshOutlineNotchWidth();
+        // Il form field è OnPush: senza questo la nuova larghezza non arriva al bordo
+        formField._changeDetectorRef?.markForCheck();
+    });
+}
+/**
+ * Rimisura la label ogni volta che si solleva o torna dentro la casella: le due posizioni
+ * possono avere grafiche diverse, e Material misurerebbe quella a riposo anche per il bordo.
+ * Restituisce l'osservatore, da scollegare nell'ngOnDestroy.
+ */
+export function watchOutlineNotch(formField) {
+    const host = formField?._elementRef?.nativeElement;
+    if (!host || typeof MutationObserver === 'undefined') {
+        return null;
+    }
+    const observer = new MutationObserver((mutations) => {
+        const labelChanged = mutations.some((m) => m.target.classList?.contains('mdc-floating-label'));
+        if (labelChanged) {
+            refreshOutlineNotch(formField);
+        }
+    });
+    observer.observe(host, { attributes: true, attributeFilter: ['class'], subtree: true });
+    return observer;
+}
+//# sourceMappingURL=data:application/json;base64,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