WIP: attempt to use ResizeObserver for layout offset calculation

mmalerba · mmalerba · commit 2f113b60a90f · 2025-03-24T22:54:51.000Z
diff --git a/src/cdk/bidi/dir.ts b/src/cdk/bidi/dir.ts
@@ -6,7 +6,15 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import {Directive, Output, Input, EventEmitter, AfterContentInit, OnDestroy} from '@angular/core';
+import {
+  AfterContentInit,
+  Directive,
+  EventEmitter,
+  Input,
+  OnDestroy,
+  Output,
+  signal,
+} from '@angular/core';
 
 import {Direction, Directionality, _resolveDirectionality} from './directionality';
 
@@ -23,9 +31,6 @@ import {Direction, Directionality, _resolveDirectionality} from './directionalit
   exportAs: 'dir',
 })
 export class Dir implements Directionality, AfterContentInit, OnDestroy {
-  /** Normalized direction that accounts for invalid/unsupported values. */
-  private _dir: Direction = 'ltr';
-
   /** Whether the `value` has been set to its initial value. */
   private _isInitialized: boolean = false;
 
@@ -38,19 +43,19 @@ export class Dir implements Directionality, AfterContentInit, OnDestroy {
   /** @docs-private */
   @Input()
   get dir(): Direction {
-    return this._dir;
+    return this.valueSignal();
   }
   set dir(value: Direction | 'auto') {
-    const previousValue = this._dir;
+    const previousValue = this.valueSignal();
 
     // Note: `_resolveDirectionality` resolves the language based on the browser's language,
     // whereas the browser does it based on the content of the element. Since doing so based
     // on the content can be expensive, for now we're doing the simpler matching.
-    this._dir = _resolveDirectionality(value);
+    this.valueSignal.set(_resolveDirectionality(value));
     this._rawDir = value;
 
-    if (previousValue !== this._dir && this._isInitialized) {
-      this.change.emit(this._dir);
+    if (previousValue !== this.valueSignal() && this._isInitialized) {
+      this.change.emit(this.valueSignal());
     }
   }
 
@@ -59,6 +64,8 @@ export class Dir implements Directionality, AfterContentInit, OnDestroy {
     return this.dir;
   }
 
+  readonly valueSignal = signal<Direction>('ltr');
+
   /** Initialize once default value has been set. */
   ngAfterContentInit() {
     this._isInitialized = true;
diff --git a/src/cdk/bidi/directionality.ts b/src/cdk/bidi/directionality.ts
@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import {EventEmitter, Injectable, OnDestroy, inject} from '@angular/core';
+import {EventEmitter, Injectable, OnDestroy, inject, signal} from '@angular/core';
 import {DIR_DOCUMENT} from './dir-document-token';
 
 export type Direction = 'ltr' | 'rtl';
@@ -33,7 +33,14 @@ export function _resolveDirectionality(rawValue: string): Direction {
 @Injectable({providedIn: 'root'})
 export class Directionality implements OnDestroy {
   /** The current 'ltr' or 'rtl' value. */
-  readonly value: Direction = 'ltr';
+  get value() {
+    return this.valueSignal();
+  }
+
+  /**
+   * The current 'ltr' or 'rtl' value.
+   */
+  readonly valueSignal = signal<Direction>('ltr');
 
   /** Stream that emits whenever the 'ltr' / 'rtl' state changes. */
   readonly change = new EventEmitter<Direction>();
@@ -46,7 +53,7 @@ export class Directionality implements OnDestroy {
     if (_document) {
       const bodyDir = _document.body ? _document.body.dir : null;
       const htmlDir = _document.documentElement ? _document.documentElement.dir : null;
-      this.value = _resolveDirectionality(bodyDir || htmlDir || 'ltr');
+      this.valueSignal.set(_resolveDirectionality(bodyDir || htmlDir || 'ltr'));
     }
   }
 
diff --git a/src/dev-app/dev-app/dev-app-directionality.ts b/src/dev-app/dev-app/dev-app-directionality.ts
@@ -7,20 +7,21 @@
  */
 
 import {Direction, Directionality} from '@angular/cdk/bidi';
-import {EventEmitter, Injectable, OnDestroy} from '@angular/core';
+import {EventEmitter, Injectable, OnDestroy, signal} from '@angular/core';
 
 @Injectable()
 export class DevAppDirectionality implements Directionality, OnDestroy {
   readonly change = new EventEmitter<Direction>();
 
   get value(): Direction {
-    return this._value;
+    return this.valueSignal();
   }
   set value(value: Direction) {
-    this._value = value;
+    this.valueSignal.set(value);
     this.change.next(value);
   }
-  private _value: Direction = 'ltr';
+
+  valueSignal = signal<Direction>('ltr');
 
   ngOnDestroy() {
     this.change.complete();
diff --git a/src/material/form-field/form-field.ts b/src/material/form-field/form-field.ts
@@ -5,6 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
+import {_IdGenerator} from '@angular/cdk/a11y';
 import {Directionality} from '@angular/cdk/bidi';
 import {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';
 import {Platform} from '@angular/cdk/platform';
@@ -27,16 +28,16 @@ import {
   QueryList,
   ViewChild,
   ViewEncapsulation,
-  afterRender,
+  afterRenderEffect,
   computed,
   contentChild,
   inject,
+  signal,
 } from '@angular/core';
 import {AbstractControlDirective, ValidatorFn} from '@angular/forms';
-import {_animationsDisabled, ThemePalette} from '../core';
-import {_IdGenerator} from '@angular/cdk/a11y';
 import {Subject, Subscription, merge} from 'rxjs';
-import {map, pairwise, takeUntil, filter, startWith} from 'rxjs/operators';
+import {filter, map, pairwise, startWith, takeUntil} from 'rxjs/operators';
+import {ThemePalette, _animationsDisabled} from '../core';
 import {MAT_ERROR, MatError} from './directives/error';
 import {
   FLOATING_LABEL_PARENT,
@@ -250,10 +251,9 @@ export class MatFormField
   /** The form field appearance style. */
   @Input()
   get appearance(): MatFormFieldAppearance {
-    return this._appearance;
+    return this._appearanceSignal();
   }
   set appearance(value: MatFormFieldAppearance) {
-    const oldValue = this._appearance;
     const newAppearance = value || this._defaults?.appearance || DEFAULT_APPEARANCE;
     if (typeof ngDevMode === 'undefined' || ngDevMode) {
       if (newAppearance !== 'fill' && newAppearance !== 'outline') {
@@ -262,15 +262,9 @@ export class MatFormField
         );
       }
     }
-    this._appearance = newAppearance;
-    if (this._appearance === 'outline' && this._appearance !== oldValue) {
-      // If the appearance has been switched to `outline`, the label offset needs to be updated.
-      // The update can happen once the view has been re-checked, but not immediately because
-      // the view has not been updated and the notched-outline floating label is not present.
-      this._needsOutlineLabelOffsetUpdate = true;
-    }
+    this._appearanceSignal.set(newAppearance);
   }
-  private _appearance: MatFormFieldAppearance = DEFAULT_APPEARANCE;
+  private _appearanceSignal = signal(DEFAULT_APPEARANCE);
 
   /**
    * Whether the form field should reserve space for one line of hint/error text (default)
@@ -319,7 +313,6 @@ export class MatFormField
   private _destroyed = new Subject<void>();
   private _isFocused: boolean | null = null;
   private _explicitFormFieldControl: MatFormFieldControl<any>;
-  private _needsOutlineLabelOffsetUpdate = false;
   private _previousControl: MatFormFieldControl<unknown> | null = null;
   private _previousControlValidatorFn: ValidatorFn | null = null;
   private _stateChanges: Subscription | undefined;
@@ -399,6 +392,7 @@ export class MatFormField
   }
 
   ngOnDestroy() {
+    this._outlineLabelOffsetResizeObserver.disconnect();
     this._stateChanges?.unsubscribe();
     this._valueChanges?.unsubscribe();
     this._describedByChanges?.unsubscribe();
@@ -546,6 +540,10 @@ export class MatFormField
     );
   }
 
+  private _outlineLabelOffsetResizeObserver = new ResizeObserver(() =>
+    this._updateOutlineLabelOffset(),
+  );
+
   /**
    * The floating label in the docked state needs to account for prefixes. The horizontal offset
    * is calculated whenever the appearance changes to `outline`, the prefixes change, or when the
@@ -554,26 +552,33 @@ export class MatFormField
    */
   private _initializeOutlineLabelOffsetSubscriptions() {
     // Whenever the prefix changes, schedule an update of the label offset.
-    // TODO(mmalerba): Use ResizeObserver to better support dynamically changing prefix content.
-    this._prefixChildren.changes.subscribe(() => (this._needsOutlineLabelOffsetUpdate = true));
-
     // TODO(mmalerba): Split this into separate `afterRender` calls using the `EarlyRead` and
     //  `Write` phases.
-    afterRender(
+    afterRenderEffect(
       () => {
-        if (this._needsOutlineLabelOffsetUpdate) {
-          this._needsOutlineLabelOffsetUpdate = false;
+        if (this._appearanceSignal() === 'outline') {
+          // Trigger effect on directionality changes.
+          this._dir.valueSignal();
+          const prefixSuffixEls = [
+            this._textPrefixContainer,
+            this._iconPrefixContainer,
+            this._textSuffixContainer,
+            this._iconSuffixContainer,
+          ]
+            .filter(e => e != null)
+            .map(e => e.nativeElement);
+          for (const el of prefixSuffixEls) {
+            this._outlineLabelOffsetResizeObserver.observe(el, {box: 'border-box'});
+          }
           this._updateOutlineLabelOffset();
+        } else {
+          this._outlineLabelOffsetResizeObserver.disconnect();
         }
       },
       {
         injector: this._injector,
       },
     );
-
-    this._dir.change
-      .pipe(takeUntil(this._destroyed))
-      .subscribe(() => (this._needsOutlineLabelOffsetUpdate = true));
   }
 
   /** Whether the floating label should always float or not. */
@@ -732,7 +737,6 @@ export class MatFormField
     // If the form field is not attached to the DOM yet (e.g. in a tab), we defer
     // the label offset update until the zone stabilizes.
     if (!this._isAttachedToDom()) {
-      this._needsOutlineLabelOffsetUpdate = true;
       return;
     }
     const iconPrefixContainer = this._iconPrefixContainer?.nativeElement;
