@skyux/phone-field 8.7.2 → 9.0.0-alpha.1

package/documentation.json

@@ -2422,14 +2422,9 @@
   },
   "codeExamples": [
     {
-      "fileName": "phone-field-demo.component.html",
-      "filePath": "/projects/phone-field/documentation/code-examples/phone-field/basic/phone-field-demo.component.html",
-      "rawContents": "<form class=\"phone-field-demo\" [formGroup]=\"phoneForm\">\n  <sky-input-box labelText=\"Phone number\">\n    <sky-phone-field [defaultCountry]=\"'us'\">\n      <input formControlName=\"phoneControl\" skyPhoneFieldInput />\n    </sky-phone-field>\n  </sky-input-box>\n</form>\n"
-    },
-    {
-      "fileName": "phone-field-demo.component.scss",
-      "filePath": "/projects/phone-field/documentation/code-examples/phone-field/basic/phone-field-demo.component.scss",
-      "rawContents": ".phone-field-demo {\n  width: 50%;\n\n  &.ng-valid ::ng-deep .sky-phone-field {\n    margin-bottom: 0;\n  }\n}\n"
+      "fileName": "phone-field-demo.module.ts",
+      "filePath": "/projects/phone-field/documentation/code-examples/phone-field/basic/phone-field-demo.module.ts",
+      "rawContents": "import { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { SkyInputBoxModule } from '@skyux/forms';\nimport { SkyStatusIndicatorModule } from '@skyux/indicators';\nimport { SkyPhoneFieldModule } from '@skyux/phone-field';\n\nimport { PhoneFieldDemoComponent } from './phone-field-demo.component';\n\n@NgModule({\n  declarations: [PhoneFieldDemoComponent],\n  imports: [\n    CommonModule,\n    ReactiveFormsModule,\n    SkyInputBoxModule,\n    SkyPhoneFieldModule,\n    SkyStatusIndicatorModule,\n  ],\n  exports: [PhoneFieldDemoComponent],\n})\nexport class PhoneFieldDemoModule {}\n"
     },
     {
       "fileName": "phone-field-demo.component.ts",
@@ -2437,9 +2432,14 @@
       "rawContents": "import { Component } from '@angular/core';\nimport { UntypedFormControl, UntypedFormGroup } from '@angular/forms';\n\n@Component({\n  selector: 'app-phone-field-demo',\n  templateUrl: './phone-field-demo.component.html',\n  styleUrls: ['./phone-field-demo.component.scss'],\n})\nexport class PhoneFieldDemoComponent {\n  public phoneControl: UntypedFormControl;\n\n  public phoneForm: UntypedFormGroup;\n\n  constructor() {\n    this.phoneControl = new UntypedFormControl();\n    this.phoneForm = new UntypedFormGroup({\n      phoneControl: this.phoneControl,\n    });\n  }\n}\n"
     },
     {
-      "fileName": "phone-field-demo.module.ts",
-      "filePath": "/projects/phone-field/documentation/code-examples/phone-field/basic/phone-field-demo.module.ts",
-      "rawContents": "import { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { SkyInputBoxModule } from '@skyux/forms';\nimport { SkyStatusIndicatorModule } from '@skyux/indicators';\nimport { SkyPhoneFieldModule } from '@skyux/phone-field';\n\nimport { PhoneFieldDemoComponent } from './phone-field-demo.component';\n\n@NgModule({\n  declarations: [PhoneFieldDemoComponent],\n  imports: [\n    CommonModule,\n    ReactiveFormsModule,\n    SkyInputBoxModule,\n    SkyPhoneFieldModule,\n    SkyStatusIndicatorModule,\n  ],\n  exports: [PhoneFieldDemoComponent],\n})\nexport class PhoneFieldDemoModule {}\n"
+      "fileName": "phone-field-demo.component.scss",
+      "filePath": "/projects/phone-field/documentation/code-examples/phone-field/basic/phone-field-demo.component.scss",
+      "rawContents": ".phone-field-demo {\n  width: 50%;\n\n  &.ng-valid ::ng-deep .sky-phone-field {\n    margin-bottom: 0;\n  }\n}\n"
+    },
+    {
+      "fileName": "phone-field-demo.component.html",
+      "filePath": "/projects/phone-field/documentation/code-examples/phone-field/basic/phone-field-demo.component.html",
+      "rawContents": "<form class=\"phone-field-demo\" [formGroup]=\"phoneForm\">\n  <sky-input-box labelText=\"Phone number\">\n    <sky-phone-field [defaultCountry]=\"'us'\">\n      <input formControlName=\"phoneControl\" skyPhoneFieldInput />\n    </sky-phone-field>\n  </sky-input-box>\n</form>\n"
     }
   ]
 }

package/esm2022/lib/modules/phone-field/phone-field-adapter.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/i18n";
+/**
+ * Service for interacting with the DOM elements of the phone field.
+ * @internal
+ */
+export class SkyPhoneFieldAdapterService {
+    #ngUnsubscribe = new Subject();
+    #renderer;
+    #resourcesService;
+    constructor(renderer, resourcesService) {
+        this.#renderer = renderer;
+        this.#resourcesService = resourcesService;
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    addElementClass(elementRef, className) {
+        this.#renderer.addClass(elementRef.nativeElement, className);
+    }
+    setElementDisabledState(elementRef, disabled) {
+        this.#renderer.setProperty(elementRef.nativeElement, 'disabled', disabled);
+    }
+    setElementPlaceholder(elementRef, placeholder) {
+        this.#renderer.setAttribute(elementRef.nativeElement, 'placeholder', placeholder);
+    }
+    setElementType(elementRef) {
+        this.#renderer.setAttribute(elementRef.nativeElement, 'type', 'tel');
+    }
+    setElementValue(elementRef, value) {
+        this.#renderer.setProperty(elementRef.nativeElement, 'value', value);
+    }
+    setAriaLabel(element) {
+        /* Sanity check */
+        /* istanbul ignore else */
+        if (!element.nativeElement.getAttribute('aria-label')) {
+            this.#resourcesService
+                .getString('skyux_phone_field_default_label')
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((value) => {
+                this.#renderer.setAttribute(element.nativeElement, 'aria-label', value);
+            });
+        }
+    }
+    focusCountrySearchElement(el) {
+        const input = el.querySelector('textarea');
+        input?.focus();
+    }
+    focusPhoneInput(el) {
+        const input = el.querySelector('.sky-phone-field-container input');
+        input?.focus();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPhoneFieldAdapterService, deps: [{ token: i0.Renderer2 }, { token: i1.SkyLibResourcesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPhoneFieldAdapterService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPhoneFieldAdapterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i1.SkyLibResourcesService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/phone-field/phone-field-input.directive.mjs

@@ -0,0 +1,307 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, HostListener, Input, Optional, forwardRef, } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, } from '@angular/forms';
+import { PhoneNumberFormat, PhoneNumberUtil } from 'google-libphonenumber';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./phone-field-adapter.service";
+import * as i2 from "./phone-field.component";
+const SKY_PHONE_FIELD_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => SkyPhoneFieldInputDirective),
+    multi: true,
+};
+const SKY_PHONE_FIELD_VALIDATOR = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => SkyPhoneFieldInputDirective),
+    multi: true,
+};
+/**
+ * Creates a button, search input, and text input for entering and validating
+ * international phone numbers. Place this attribute on an `input` element, and wrap
+ * that element in a `sky-phone-field` component. By default, the country selector
+ * button displays a flag icon for the default country, and the phone number input
+ * displays a sample of the correct phone number format. When users select the country
+ * selector button, they expose the country search input, which is
+ * [an autocomplete input](https://developer.blackbaud.com/skyux/components/autocomplete)
+ * that allows them to select different countries. When users enter `+` followed by an
+ * international dial code in the phone number input, the country automatically switches
+ * to the country associated with the dial code.
+ * @required
+ */
+export class SkyPhoneFieldInputDirective {
+    /**
+     * Whether to disable the phone field on template-driven forms. Don't use this input on reactive forms because they may overwrite the input or leave the control out of sync.
+     * To set the disabled state on reactive forms, use the `FormControl` instead.
+     * @default false
+     */
+    set disabled(value) {
+        const coercedValue = coerceBooleanProperty(value);
+        if (this.#phoneFieldComponent) {
+            this.#phoneFieldComponent.countrySelectDisabled = coercedValue;
+            this.#adapterService?.setElementDisabledState(this.#elRef, coercedValue);
+        }
+        this.#_disabled = coercedValue;
+    }
+    get disabled() {
+        return this.#_disabled;
+    }
+    set #modelValue(value) {
+        const valueOrDefault = value ?? '';
+        this.#_modelValue = valueOrDefault;
+        this.#adapterService?.setElementValue(this.#elRef, valueOrDefault);
+        if (valueOrDefault) {
+            const formattedValue = this.#formatNumber(valueOrDefault.toString());
+            this.#onChange(formattedValue);
+        }
+        else {
+            this.#onChange(valueOrDefault);
+        }
+        this.#validatorChange();
+    }
+    get #modelValue() {
+        return this.#_modelValue;
+    }
+    #control;
+    #textChanges;
+    #ngUnsubscribe;
+    #phoneUtils;
+    #_disabled;
+    #_modelValue;
+    #changeDetector;
+    #elRef;
+    #adapterService;
+    #phoneFieldComponent;
+    constructor(changeDetector, elRef, adapterService, phoneFieldComponent) {
+        /**
+         * Whether to prevent validation on the phone number input. For validation,
+         * phone numbers are driven through the `ngModel` attribute that you specify on an
+         * `input` element or on a `FormControl` in a reactive form. To prevent validation,
+         * set this property to `true`.
+         * @default false
+         */
+        this.skyPhoneFieldNoValidate = false;
+        this.#ngUnsubscribe = new Subject();
+        this.#phoneUtils = PhoneNumberUtil.getInstance();
+        this.#_modelValue = '';
+        // eslint-disable-next-line @typescript-eslint/no-empty-function , @typescript-eslint/no-unused-vars
+        this.#onChange = (_) => { };
+        // istanbul ignore next
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.#onTouched = () => { };
+        // istanbul ignore next
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        this.#validatorChange = () => { };
+        this.#changeDetector = changeDetector;
+        this.#elRef = elRef;
+        this.#adapterService = adapterService;
+        this.#phoneFieldComponent = phoneFieldComponent;
+    }
+    ngOnInit() {
+        if (!this.#phoneFieldComponent) {
+            throw new Error('You must wrap the `skyPhoneFieldInput` directive within a ' +
+                '`<sky-phone-field>` component!');
+        }
+        this.#adapterService?.setElementType(this.#elRef);
+        this.#adapterService?.addElementClass(this.#elRef, 'sky-form-control');
+        if (this.#phoneFieldComponent?.selectedCountry?.exampleNumber) {
+            this.#adapterService?.setElementPlaceholder(this.#elRef, this.#phoneFieldComponent.selectedCountry.exampleNumber);
+        }
+        this.#adapterService?.setAriaLabel(this.#elRef);
+    }
+    ngAfterViewInit() {
+        this.#phoneFieldComponent?.selectedCountryChange
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((country) => {
+            this.#modelValue = this.#elRef.nativeElement.value;
+            if (country?.exampleNumber) {
+                this.#adapterService?.setElementPlaceholder(this.#elRef, country.exampleNumber);
+            }
+        });
+        // This is needed to address a bug in Angular 4, where the value is not changed on the view.
+        // See: https://github.com/angular/angular/issues/13792
+        /* istanbul ignore else */
+        if (this.#control && this.#modelValue) {
+            this.#control.setValue(this.#modelValue, { emitEvent: false });
+            this.#changeDetector.detectChanges();
+        }
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    /**
+     * Writes the new value for reactive forms on change events on the input element
+     * @param event The change event that was received
+     */
+    onInputChange(event) {
+        if (!this.#textChanges) {
+            this.#setupTextChangeSubscription(event.target.value);
+        }
+        else {
+            this.#textChanges.next(event.target.value);
+        }
+    }
+    /**
+     * Marks reactive form controls as touched on input blur events
+     */
+    onInputBlur() {
+        this.#onTouched();
+    }
+    onInputTyping(event) {
+        if (!this.#textChanges) {
+            this.#setupTextChangeSubscription(event.target.value);
+        }
+        else {
+            this.#textChanges.next(event.target.value);
+        }
+    }
+    /**
+     * Writes the new value for reactive forms
+     * @param value The new value for the input
+     */
+    writeValue(value) {
+        this.#phoneFieldComponent?.setCountryByDialCode(value);
+        this.#modelValue = value;
+    }
+    registerOnChange(fn) {
+        this.#onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.#onTouched = fn;
+    }
+    registerOnValidatorChange(fn) {
+        this.#validatorChange = fn;
+    }
+    /**
+     * Sets the disabled state on the input
+     * @param isDisabled the new value of the input's disabled state
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    /**
+     * Validate's the form control's current value
+     * @param control the form control for the input
+     */
+    validate(control) {
+        if (!this.#control) {
+            this.#control = control;
+        }
+        if (this.skyPhoneFieldNoValidate) {
+            return null;
+        }
+        const value = control.value;
+        if (!value) {
+            return null;
+        }
+        if (this.#phoneFieldComponent?.selectedCountry &&
+            !this.#validateNumber(value)) {
+            if (!this.#textChanges) {
+                // Mark the invalid control as touched so that the input's invalid CSS styles appear.
+                // (This is only required when the invalid value is set by the FormControl constructor.)
+                // We don't do this if the input is the active element so that we don't show validation
+                // errors unless it is invalid on initialization or the input has been blurred.
+                control.markAsTouched();
+            }
+            return {
+                skyPhoneField: {
+                    invalid: value,
+                },
+            };
+        }
+        return null;
+    }
+    #setupTextChangeSubscription(text) {
+        this.#textChanges = new BehaviorSubject(text);
+        this.#textChanges
+            .pipe(debounceTime(500), takeUntil(this.#ngUnsubscribe))
+            .subscribe((newValue) => {
+            this.writeValue(newValue);
+        });
+    }
+    #validateNumber(phoneNumber) {
+        try {
+            const numberObj = this.#phoneUtils.parseAndKeepRawInput(phoneNumber, this.#phoneFieldComponent?.selectedCountry?.iso2);
+            if (this.#phoneFieldComponent &&
+                !this.#phoneFieldComponent.allowExtensions &&
+                numberObj.getExtension()) {
+                return false;
+            }
+            return this.#phoneUtils.isValidNumber(numberObj);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Format's the given phone number based on the currently selected country.
+     * @param phoneNumber The number to format
+     */
+    #formatNumber(phoneNumber) {
+        try {
+            const numberObj = this.#phoneUtils.parseAndKeepRawInput(phoneNumber, this.#phoneFieldComponent?.selectedCountry?.iso2);
+            if (this.#phoneUtils.isPossibleNumber(numberObj)) {
+                switch (this.#phoneFieldComponent?.returnFormat) {
+                    case 'international':
+                        return this.#phoneUtils.format(numberObj, PhoneNumberFormat.INTERNATIONAL);
+                    case 'national':
+                        return this.#phoneUtils.format(numberObj, PhoneNumberFormat.NATIONAL);
+                    case 'default':
+                    default:
+                        if (this.#phoneFieldComponent?.selectedCountry?.iso2 !==
+                            this.#phoneFieldComponent?.defaultCountry) {
+                            return this.#phoneUtils.format(numberObj, PhoneNumberFormat.INTERNATIONAL);
+                        }
+                        else {
+                            return this.#phoneUtils.format(numberObj, PhoneNumberFormat.NATIONAL);
+                        }
+                }
+            }
+            else {
+                return phoneNumber;
+            }
+        }
+        catch (e) {
+            /* sanity check */
+            /* istanbul ignore next */
+            return phoneNumber;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function , @typescript-eslint/no-unused-vars
+    #onChange;
+    // istanbul ignore next
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    #onTouched;
+    // istanbul ignore next
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    #validatorChange;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPhoneFieldInputDirective, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i1.SkyPhoneFieldAdapterService, optional: true }, { token: i2.SkyPhoneFieldComponent, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: SkyPhoneFieldInputDirective, selector: "[skyPhoneFieldInput]", inputs: { disabled: "disabled", skyPhoneFieldNoValidate: "skyPhoneFieldNoValidate" }, host: { listeners: { "change": "onInputChange($event)", "blur": "onInputBlur()", "input": "onInputTyping($event)" } }, providers: [SKY_PHONE_FIELD_VALUE_ACCESSOR, SKY_PHONE_FIELD_VALIDATOR], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyPhoneFieldInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[skyPhoneFieldInput]',
+                    providers: [SKY_PHONE_FIELD_VALUE_ACCESSOR, SKY_PHONE_FIELD_VALIDATOR],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i1.SkyPhoneFieldAdapterService, decorators: [{
+                    type: Optional
+                }] }, { type: i2.SkyPhoneFieldComponent, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { disabled: [{
+                type: Input
+            }], skyPhoneFieldNoValidate: [{
+                type: Input
+            }], onInputChange: [{
+                type: HostListener,
+                args: ['change', ['$event']]
+            }], onInputBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }], onInputTyping: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"phone-field-input.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/components/phone-field/src/lib/modules/phone-field/phone-field-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Directive,\n  ElementRef,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  forwardRef,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  Validator,\n} from '@angular/forms';\n\nimport { PhoneNumberFormat, PhoneNumberUtil } from 'google-libphonenumber';\nimport { BehaviorSubject, Subject } from 'rxjs';\nimport { debounceTime, takeUntil } from 'rxjs/operators';\n\nimport { SkyPhoneFieldAdapterService } from './phone-field-adapter.service';\nimport { SkyPhoneFieldComponent } from './phone-field.component';\nimport { SkyPhoneFieldCountry } from './types/country';\n\nconst SKY_PHONE_FIELD_VALUE_ACCESSOR = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => SkyPhoneFieldInputDirective),\n  multi: true,\n};\n\nconst SKY_PHONE_FIELD_VALIDATOR = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => SkyPhoneFieldInputDirective),\n  multi: true,\n};\n\n/**\n * Creates a button, search input, and text input for entering and validating\n * international phone numbers. Place this attribute on an `input` element, and wrap\n * that element in a `sky-phone-field` component. By default, the country selector\n * button displays a flag icon for the default country, and the phone number input\n * displays a sample of the correct phone number format. When users select the country\n * selector button, they expose the country search input, which is\n * [an autocomplete input](https://developer.blackbaud.com/skyux/components/autocomplete)\n * that allows them to select different countries. When users enter `+` followed by an\n * international dial code in the phone number input, the country automatically switches\n * to the country associated with the dial code.\n * @required\n */\n@Directive({\n  selector: '[skyPhoneFieldInput]',\n  providers: [SKY_PHONE_FIELD_VALUE_ACCESSOR, SKY_PHONE_FIELD_VALIDATOR],\n})\nexport class SkyPhoneFieldInputDirective\n  implements OnInit, OnDestroy, AfterViewInit, ControlValueAccessor, Validator\n{\n  /**\n   * Whether to disable the phone field on template-driven forms. Don't use this input on reactive forms because they may overwrite the input or leave the control out of sync.\n   * To set the disabled state on reactive forms, use the `FormControl` instead.\n   * @default false\n   */\n  @Input()\n  public set disabled(value: boolean | undefined) {\n    const coercedValue = coerceBooleanProperty(value);\n    if (this.#phoneFieldComponent) {\n      this.#phoneFieldComponent.countrySelectDisabled = coercedValue;\n      this.#adapterService?.setElementDisabledState(this.#elRef, coercedValue);\n    }\n    this.#_disabled = coercedValue;\n  }\n\n  public get disabled(): boolean {\n    return this.#_disabled;\n  }\n\n  /**\n   * Whether to prevent validation on the phone number input. For validation,\n   * phone numbers are driven through the `ngModel` attribute that you specify on an\n   * `input` element or on a `FormControl` in a reactive form. To prevent validation,\n   * set this property to `true`.\n   * @default false\n   */\n  @Input()\n  public skyPhoneFieldNoValidate: boolean | undefined = false;\n\n  set #modelValue(value: string | undefined) {\n    const valueOrDefault = value ?? '';\n    this.#_modelValue = valueOrDefault;\n    this.#adapterService?.setElementValue(this.#elRef, valueOrDefault);\n\n    if (valueOrDefault) {\n      const formattedValue = this.#formatNumber(valueOrDefault.toString());\n\n      this.#onChange(formattedValue);\n    } else {\n      this.#onChange(valueOrDefault);\n    }\n    this.#validatorChange();\n  }\n\n  get #modelValue(): string {\n    return this.#_modelValue;\n  }\n\n  #control: AbstractControl | undefined;\n\n  #textChanges: BehaviorSubject<string> | undefined;\n\n  #ngUnsubscribe = new Subject<void>();\n\n  #phoneUtils = PhoneNumberUtil.getInstance();\n\n  #_disabled!: boolean;\n\n  #_modelValue = '';\n\n  #changeDetector: ChangeDetectorRef;\n  #elRef: ElementRef;\n\n  #adapterService: SkyPhoneFieldAdapterService | undefined;\n  #phoneFieldComponent: SkyPhoneFieldComponent | undefined;\n\n  constructor(\n    changeDetector: ChangeDetectorRef,\n    elRef: ElementRef,\n    @Optional() adapterService?: SkyPhoneFieldAdapterService,\n    @Optional() phoneFieldComponent?: SkyPhoneFieldComponent\n  ) {\n    this.#changeDetector = changeDetector;\n    this.#elRef = elRef;\n    this.#adapterService = adapterService;\n    this.#phoneFieldComponent = phoneFieldComponent;\n  }\n\n  public ngOnInit(): void {\n    if (!this.#phoneFieldComponent) {\n      throw new Error(\n        'You must wrap the `skyPhoneFieldInput` directive within a ' +\n          '`<sky-phone-field>` component!'\n      );\n    }\n\n    this.#adapterService?.setElementType(this.#elRef);\n    this.#adapterService?.addElementClass(this.#elRef, 'sky-form-control');\n    if (this.#phoneFieldComponent?.selectedCountry?.exampleNumber) {\n      this.#adapterService?.setElementPlaceholder(\n        this.#elRef,\n        this.#phoneFieldComponent.selectedCountry.exampleNumber\n      );\n    }\n\n    this.#adapterService?.setAriaLabel(this.#elRef);\n  }\n\n  public ngAfterViewInit(): void {\n    this.#phoneFieldComponent?.selectedCountryChange\n      .pipe(takeUntil(this.#ngUnsubscribe))\n      .subscribe((country: SkyPhoneFieldCountry) => {\n        this.#modelValue = this.#elRef.nativeElement.value;\n        if (country?.exampleNumber) {\n          this.#adapterService?.setElementPlaceholder(\n            this.#elRef,\n            country.exampleNumber\n          );\n        }\n      });\n\n    // This is needed to address a bug in Angular 4, where the value is not changed on the view.\n    // See: https://github.com/angular/angular/issues/13792\n    /* istanbul ignore else */\n    if (this.#control && this.#modelValue) {\n      this.#control.setValue(this.#modelValue, { emitEvent: false });\n      this.#changeDetector.detectChanges();\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n  }\n\n  /**\n   * Writes the new value for reactive forms on change events on the input element\n   * @param event The change event that was received\n   */\n  @HostListener('change', ['$event'])\n  public onInputChange(event: any): void {\n    if (!this.#textChanges) {\n      this.#setupTextChangeSubscription(event.target.value);\n    } else {\n      this.#textChanges.next(event.target.value);\n    }\n  }\n\n  /**\n   * Marks reactive form controls as touched on input blur events\n   */\n  @HostListener('blur')\n  public onInputBlur(): void {\n    this.#onTouched();\n  }\n\n  @HostListener('input', ['$event'])\n  public onInputTyping(event: any): void {\n    if (!this.#textChanges) {\n      this.#setupTextChangeSubscription(event.target.value);\n    } else {\n      this.#textChanges.next(event.target.value);\n    }\n  }\n\n  /**\n   * Writes the new value for reactive forms\n   * @param value The new value for the input\n   */\n  public writeValue(value: string): void {\n    this.#phoneFieldComponent?.setCountryByDialCode(value);\n\n    this.#modelValue = value;\n  }\n\n  public registerOnChange(fn: (value: string | undefined) => void): void {\n    this.#onChange = fn;\n  }\n\n  public registerOnTouched(fn: () => void): void {\n    this.#onTouched = fn;\n  }\n\n  public registerOnValidatorChange(fn: () => void): void {\n    this.#validatorChange = fn;\n  }\n\n  /**\n   * Sets the disabled state on the input\n   * @param isDisabled the new value of the input's disabled state\n   */\n  public setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  /**\n   * Validate's the form control's current value\n   * @param control the form control for the input\n   */\n  public validate(control: AbstractControl): ValidationErrors | null {\n    if (!this.#control) {\n      this.#control = control;\n    }\n\n    if (this.skyPhoneFieldNoValidate) {\n      return null;\n    }\n\n    const value = control.value;\n\n    if (!value) {\n      return null;\n    }\n\n    if (\n      this.#phoneFieldComponent?.selectedCountry &&\n      !this.#validateNumber(value)\n    ) {\n      if (!this.#textChanges) {\n        // Mark the invalid control as touched so that the input's invalid CSS styles appear.\n        // (This is only required when the invalid value is set by the FormControl constructor.)\n        // We don't do this if the input is the active element so that we don't show validation\n        // errors unless it is invalid on initialization or the input has been blurred.\n        control.markAsTouched();\n      }\n\n      return {\n        skyPhoneField: {\n          invalid: value,\n        },\n      };\n    }\n    return null;\n  }\n\n  #setupTextChangeSubscription(text: string): void {\n    this.#textChanges = new BehaviorSubject(text);\n\n    this.#textChanges\n      .pipe(debounceTime(500), takeUntil(this.#ngUnsubscribe))\n      .subscribe((newValue) => {\n        this.writeValue(newValue);\n      });\n  }\n\n  #validateNumber(phoneNumber: string): boolean {\n    try {\n      const numberObj = this.#phoneUtils.parseAndKeepRawInput(\n        phoneNumber,\n        this.#phoneFieldComponent?.selectedCountry?.iso2\n      );\n\n      if (\n        this.#phoneFieldComponent &&\n        !this.#phoneFieldComponent.allowExtensions &&\n        numberObj.getExtension()\n      ) {\n        return false;\n      }\n\n      return this.#phoneUtils.isValidNumber(numberObj);\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Format's the given phone number based on the currently selected country.\n   * @param phoneNumber The number to format\n   */\n  #formatNumber(phoneNumber: string): string {\n    try {\n      const numberObj = this.#phoneUtils.parseAndKeepRawInput(\n        phoneNumber,\n        this.#phoneFieldComponent?.selectedCountry?.iso2\n      );\n      if (this.#phoneUtils.isPossibleNumber(numberObj)) {\n        switch (this.#phoneFieldComponent?.returnFormat) {\n          case 'international':\n            return this.#phoneUtils.format(\n              numberObj,\n              PhoneNumberFormat.INTERNATIONAL\n            );\n          case 'national':\n            return this.#phoneUtils.format(\n              numberObj,\n              PhoneNumberFormat.NATIONAL\n            );\n          case 'default':\n          default:\n            if (\n              this.#phoneFieldComponent?.selectedCountry?.iso2 !==\n              this.#phoneFieldComponent?.defaultCountry\n            ) {\n              return this.#phoneUtils.format(\n                numberObj,\n                PhoneNumberFormat.INTERNATIONAL\n              );\n            } else {\n              return this.#phoneUtils.format(\n                numberObj,\n                PhoneNumberFormat.NATIONAL\n              );\n            }\n        }\n      } else {\n        return phoneNumber;\n      }\n    } catch (e) {\n      /* sanity check */\n      /* istanbul ignore next */\n      return phoneNumber;\n    }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-empty-function , @typescript-eslint/no-unused-vars\n  #onChange = (_: string | undefined) => {};\n\n  // istanbul ignore next\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  #onTouched = () => {};\n\n  // istanbul ignore next\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  #validatorChange = () => {};\n}\n"]}