@energinet/watt 2.0.13 → 2.1.0

package/esm2022/phone-field/watt-phone-field-intl.service.js

@@ -0,0 +1,40 @@
+//#region License
+/**
+ * @license
+ * Copyright 2020 Energinet DataHub A/S
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License2");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//#endregion
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class WattPhoneFieldIntlService {
+    changes = new Subject();
+    invalidPhoneNumber = 'Invalid phone number';
+    DK = 'Denmark';
+    DE = 'Germany';
+    FI = 'Finland';
+    NO = 'Norway';
+    SE = 'Sweden';
+    PL = 'Poland';
+    NL = 'Netherlands';
+    CH = 'Switzerland';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPhoneFieldIntlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPhoneFieldIntlService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPhoneFieldIntlService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/phone-field/watt-phone-field.component.js

@@ -0,0 +1,262 @@
+//#region License
+/**
+ * @license
+ * Copyright 2020 Energinet DataHub A/S
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License2");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//#endregion
+import { Component, ElementRef, HostBinding, ViewChild, ViewEncapsulation, forwardRef, inject, input, signal, untracked, } from '@angular/core';
+import { NG_VALUE_ACCESSOR, ReactiveFormsModule, } from '@angular/forms';
+import { MaskitoDirective } from '@maskito/angular';
+import { MatSelectModule } from '@angular/material/select';
+import { MASKITO_DEFAULT_OPTIONS, maskitoTransform } from '@maskito/core';
+import { maskitoPhoneOptionsGenerator } from '@maskito/phone';
+import { isValidPhoneNumber } from 'libphonenumber-js';
+import phoneMetadata from 'libphonenumber-js/min/metadata';
+import { WattFlagComponent } from '@energinet/watt/icon/flags';
+import { WattFieldComponent, WattFieldErrorComponent } from '@energinet/watt/field';
+import { WattPhoneFieldIntlService } from './watt-phone-field-intl.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/material/select";
+function phoneValidator(countryCode) {
+    return (control) => {
+        if (!control.value)
+            return null;
+        const valid = isValidPhoneNumber(control.value, countryCode);
+        return valid ? null : { invalidPhone: true };
+    };
+}
+export class WattPhoneFieldComponent {
+    /** @ignore */
+    countries = [
+        { countryIsoCode: 'DK', phoneExtension: '+45' },
+        { countryIsoCode: 'SE', phoneExtension: '+46' },
+        { countryIsoCode: 'NO', phoneExtension: '+47' },
+        { countryIsoCode: 'DE', phoneExtension: '+49' },
+        { countryIsoCode: 'FI', phoneExtension: '+358' },
+        { countryIsoCode: 'PL', phoneExtension: '+48' },
+        { countryIsoCode: 'NL', phoneExtension: '+31' },
+        { countryIsoCode: 'CH', phoneExtension: '+41' },
+    ];
+    formControl = input.required();
+    label = input();
+    /** @ignore */
+    chosenCountry = signal(this.countries[0]);
+    /** @ignore */
+    mask = MASKITO_DEFAULT_OPTIONS;
+    /** @ignore */
+    intl = inject(WattPhoneFieldIntlService);
+    /** @ignore */
+    isDisabled = false;
+    /** @ignore */
+    value = null;
+    /** @ignore */
+    phoneNumberInput;
+    /** @ignore */
+    ngOnInit() {
+        this.setup();
+    }
+    /** @ignore */
+    writeValue(value) {
+        if (value) {
+            const country = this.countries.find((country) => value.startsWith(country.phoneExtension));
+            if (country) {
+                // Exclude Signal from being tracked
+                // in case the parent component sets the value inside an `effect`.
+                // Without this, updating the Signal internaly triggers the parrent `effect` to re-run.
+                // Note: Revisit once v19 is released because the `effect` API has changed
+                // significantly and this might not be necessary anymore
+                untracked(() => {
+                    this.setCountry(country);
+                });
+                value = maskitoTransform(value, this.mask);
+            }
+        }
+        this.value = value;
+    }
+    /** @ignore */
+    onChange = () => {
+        /* noop function */
+    };
+    /** @ignore */
+    onTouched = () => {
+        /* noop function */
+    };
+    /** @ignore */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /** @ignore */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /** @ignore */
+    setDisabledState(isDisabled) {
+        this.isDisabled = isDisabled;
+    }
+    /** @ignore */
+    selectedContry({ value }) {
+        const country = this.countries.find((contry) => contry.countryIsoCode === value);
+        if (!country) {
+            throw new Error('Prefix not found');
+        }
+        this.setCountry(country);
+        this.formControl().reset();
+        setTimeout(() => {
+            this.phoneNumberInput.nativeElement.focus();
+        }, 100);
+    }
+    /** @ignore */
+    setCountry(country) {
+        this.chosenCountry.set(country);
+        this.setup();
+    }
+    /** @ignore */
+    onChanged(event) {
+        const value = event.target?.value;
+        this.onChange(value);
+    }
+    /** @ignore */
+    generatePhoneOptions() {
+        const phoneOptions = maskitoPhoneOptionsGenerator({
+            countryIsoCode: this.chosenCountry().countryIsoCode,
+            metadata: phoneMetadata,
+            separator: ' ',
+        });
+        this.mask = phoneOptions;
+    }
+    /** @ignore */
+    setup() {
+        this.generatePhoneOptions();
+        this.setValidator();
+    }
+    /** @ignore */
+    setValidator() {
+        const countryCode = this.chosenCountry().countryIsoCode;
+        this.formControl().addValidators(phoneValidator(countryCode));
+    }
+    /** @ignore */
+    getCountryName(countryIsoCode) {
+        return this.intl[countryIsoCode];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPhoneFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.0.3", type: WattPhoneFieldComponent, isStandalone: true, selector: "watt-phone-field", inputs: { formControl: { classPropertyName: "formControl", publicName: "formControl", isSignal: true, isRequired: true, transformFunction: null }, label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.watt-field-disabled": "this.isDisabled" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => WattPhoneFieldComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "phoneNumberInput", first: true, predicate: ["phoneNumberInput"], descendants: true }], ngImport: i0, template: `
+    <watt-field [label]="label()" [control]="formControl()">
+      <div class="watt-phone-field__prefix-container">
+        <mat-select
+          panelWidth=""
+          panelClass="watt-phone-field__select"
+          [hideSingleSelectionIndicator]="true"
+          [value]="chosenCountry().countryIsoCode"
+          (selectionChange)="selectedContry($event)"
+        >
+          <mat-select-trigger>
+            <watt-flag [country]="chosenCountry().countryIsoCode" />
+          </mat-select-trigger>
+          @for (contry of countries; track contry; let index = $index) {
+            <mat-option value="{{ contry.countryIsoCode }}">
+              <watt-flag [country]="contry.countryIsoCode" />
+              <div>{{ getCountryName(contry.countryIsoCode) }}</div>
+            </mat-option>
+          }
+        </mat-select>
+        <input
+          [attr.aria-label]="label()"
+          autocomplete="tel"
+          inputmode="tel"
+          [value]="value"
+          [formControl]="formControl()"
+          (blur)="onTouched()"
+          (input)="onChanged($event)"
+          [maskito]="mask"
+          #phoneNumberInput
+        />
+      </div>
+      <ng-content ngProjectAs="watt-field-hint" select="watt-field-hint" />
+      <ng-content ngProjectAs="watt-field-error" select="watt-field-error" />
+      @if (formControl().hasError('invalidPhone')) {
+        <watt-field-error> {{ intl.invalidPhoneNumber }} </watt-field-error>
+      }
+    </watt-field>
+  `, isInline: true, styles: [".watt-phone-field__select.mat-mdc-select-panel{--mat-option-label-text-size: 14px;overflow-y:scroll}.watt-phone-field__select.mat-mdc-select-panel watt-icon{margin-right:var(--watt-space-s)}.watt-phone-field__select.mat-mdc-select-panel watt-icon .mat-icon{margin-right:0}.watt-phone-field__select.mat-mdc-select-panel .mat-mdc-option.mdc-list-item .mdc-list-item__primary-text{display:flex;width:100%;align-items:center;gap:var(--watt-space-xs)}watt-phone-field{display:block}watt-phone-field .watt-phone-field__prefix-container{width:100%;display:flex;align-items:center;gap:var(--watt-space-xs)}watt-phone-field input{width:100%;border:none}watt-phone-field input:focus-visible,watt-phone-field input:focus-within{border:none;outline:none}watt-phone-field .mat-mdc-select{width:auto;height:24px}watt-phone-field .mat-mdc-select .mat-mdc-select-arrow-wrapper{width:24px;justify-content:center}\n"], dependencies: [{ kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i2.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth", "canSelectNullableOptions"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "directive", type: i2.MatSelectTrigger, selector: "mat-select-trigger" }, { kind: "component", type: i2.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "directive", type: MaskitoDirective, selector: "[maskito]", inputs: ["maskito", "maskitoElement"] }, { kind: "component", type: WattFieldComponent, selector: "watt-field", inputs: ["control", "label", "id", "chipMode", "tooltip", "placeholder", "anchorName"] }, { kind: "component", type: WattFieldErrorComponent, selector: "watt-field-error" }, { kind: "component", type: WattFlagComponent, selector: "watt-flag", inputs: ["country", "label", "size"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPhoneFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'watt-phone-field', encapsulation: ViewEncapsulation.None, imports: [
+                        ReactiveFormsModule,
+                        MatSelectModule,
+                        MaskitoDirective,
+                        WattFieldComponent,
+                        WattFieldErrorComponent,
+                        WattFlagComponent,
+                    ], providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => WattPhoneFieldComponent),
+                            multi: true,
+                        },
+                    ], template: `
+    <watt-field [label]="label()" [control]="formControl()">
+      <div class="watt-phone-field__prefix-container">
+        <mat-select
+          panelWidth=""
+          panelClass="watt-phone-field__select"
+          [hideSingleSelectionIndicator]="true"
+          [value]="chosenCountry().countryIsoCode"
+          (selectionChange)="selectedContry($event)"
+        >
+          <mat-select-trigger>
+            <watt-flag [country]="chosenCountry().countryIsoCode" />
+          </mat-select-trigger>
+          @for (contry of countries; track contry; let index = $index) {
+            <mat-option value="{{ contry.countryIsoCode }}">
+              <watt-flag [country]="contry.countryIsoCode" />
+              <div>{{ getCountryName(contry.countryIsoCode) }}</div>
+            </mat-option>
+          }
+        </mat-select>
+        <input
+          [attr.aria-label]="label()"
+          autocomplete="tel"
+          inputmode="tel"
+          [value]="value"
+          [formControl]="formControl()"
+          (blur)="onTouched()"
+          (input)="onChanged($event)"
+          [maskito]="mask"
+          #phoneNumberInput
+        />
+      </div>
+      <ng-content ngProjectAs="watt-field-hint" select="watt-field-hint" />
+      <ng-content ngProjectAs="watt-field-error" select="watt-field-error" />
+      @if (formControl().hasError('invalidPhone')) {
+        <watt-field-error> {{ intl.invalidPhoneNumber }} </watt-field-error>
+      }
+    </watt-field>
+  `, styles: [".watt-phone-field__select.mat-mdc-select-panel{--mat-option-label-text-size: 14px;overflow-y:scroll}.watt-phone-field__select.mat-mdc-select-panel watt-icon{margin-right:var(--watt-space-s)}.watt-phone-field__select.mat-mdc-select-panel watt-icon .mat-icon{margin-right:0}.watt-phone-field__select.mat-mdc-select-panel .mat-mdc-option.mdc-list-item .mdc-list-item__primary-text{display:flex;width:100%;align-items:center;gap:var(--watt-space-xs)}watt-phone-field{display:block}watt-phone-field .watt-phone-field__prefix-container{width:100%;display:flex;align-items:center;gap:var(--watt-space-xs)}watt-phone-field input{width:100%;border:none}watt-phone-field input:focus-visible,watt-phone-field input:focus-within{border:none;outline:none}watt-phone-field .mat-mdc-select{width:auto;height:24px}watt-phone-field .mat-mdc-select .mat-mdc-select-arrow-wrapper{width:24px;justify-content:center}\n"] }]
+        }], propDecorators: { isDisabled: [{
+                type: HostBinding,
+                args: ['attr.watt-field-disabled']
+            }], phoneNumberInput: [{
+                type: ViewChild,
+                args: ['phoneNumberInput']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watt-phone-field.component.js","sourceRoot":"","sources":["../../../../libs/watt/package/phone-field/watt-phone-field.component.ts"],"names":[],"mappings":"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","sourcesContent":["//#region License\n/**\n * @license\n * Copyright 2020 Energinet DataHub A/S\n *\n * Licensed under the Apache License, Version 2.0 (the \"License2\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n//#endregion\nimport {\n  Component,\n  ElementRef,\n  HostBinding,\n  OnInit,\n  ViewChild,\n  ViewEncapsulation,\n  forwardRef,\n  inject,\n  input,\n  signal,\n  untracked,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  FormControl,\n  NG_VALUE_ACCESSOR,\n  ReactiveFormsModule,\n  ValidationErrors,\n  ValidatorFn,\n} from '@angular/forms';\nimport { MaskitoDirective } from '@maskito/angular';\nimport { MatSelectChange, MatSelectModule } from '@angular/material/select';\nimport { MASKITO_DEFAULT_OPTIONS, maskitoTransform } from '@maskito/core';\nimport { maskitoPhoneOptionsGenerator } from '@maskito/phone';\nimport { isValidPhoneNumber, type CountryCode } from 'libphonenumber-js';\nimport phoneMetadata from 'libphonenumber-js/min/metadata';\n\nimport { WattFlagComponent } from '@energinet/watt/icon/flags';\nimport { WattFieldComponent, WattFieldErrorComponent } from '@energinet/watt/field';\n\nimport { WattPhoneFieldIntlService } from './watt-phone-field-intl.service';\n\ntype Contry = {\n  countryIsoCode: CountryCode;\n  phoneExtension: string;\n};\n\nfunction phoneValidator(countryCode: CountryCode): ValidatorFn {\n  return (control: AbstractControl): ValidationErrors | null => {\n    if (!control.value) return null;\n    const valid = isValidPhoneNumber(control.value, countryCode);\n\n    return valid ? null : { invalidPhone: true };\n  };\n}\n\n@Component({\n  selector: 'watt-phone-field',\n  encapsulation: ViewEncapsulation.None,\n  imports: [\n    ReactiveFormsModule,\n    MatSelectModule,\n    MaskitoDirective,\n    WattFieldComponent,\n    WattFieldErrorComponent,\n    WattFlagComponent,\n  ],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => WattPhoneFieldComponent),\n      multi: true,\n    },\n  ],\n  template: `\n    <watt-field [label]=\"label()\" [control]=\"formControl()\">\n      <div class=\"watt-phone-field__prefix-container\">\n        <mat-select\n          panelWidth=\"\"\n          panelClass=\"watt-phone-field__select\"\n          [hideSingleSelectionIndicator]=\"true\"\n          [value]=\"chosenCountry().countryIsoCode\"\n          (selectionChange)=\"selectedContry($event)\"\n        >\n          <mat-select-trigger>\n            <watt-flag [country]=\"chosenCountry().countryIsoCode\" />\n          </mat-select-trigger>\n          @for (contry of countries; track contry; let index = $index) {\n            <mat-option value=\"{{ contry.countryIsoCode }}\">\n              <watt-flag [country]=\"contry.countryIsoCode\" />\n              <div>{{ getCountryName(contry.countryIsoCode) }}</div>\n            </mat-option>\n          }\n        </mat-select>\n        <input\n          [attr.aria-label]=\"label()\"\n          autocomplete=\"tel\"\n          inputmode=\"tel\"\n          [value]=\"value\"\n          [formControl]=\"formControl()\"\n          (blur)=\"onTouched()\"\n          (input)=\"onChanged($event)\"\n          [maskito]=\"mask\"\n          #phoneNumberInput\n        />\n      </div>\n      <ng-content ngProjectAs=\"watt-field-hint\" select=\"watt-field-hint\" />\n      <ng-content ngProjectAs=\"watt-field-error\" select=\"watt-field-error\" />\n      @if (formControl().hasError('invalidPhone')) {\n        <watt-field-error> {{ intl.invalidPhoneNumber }} </watt-field-error>\n      }\n    </watt-field>\n  `,\n  styleUrl: './watt-phone-field.component.scss',\n})\nexport class WattPhoneFieldComponent implements ControlValueAccessor, OnInit {\n  /** @ignore */\n  readonly countries: Contry[] = [\n    { countryIsoCode: 'DK', phoneExtension: '+45' },\n    { countryIsoCode: 'SE', phoneExtension: '+46' },\n    { countryIsoCode: 'NO', phoneExtension: '+47' },\n    { countryIsoCode: 'DE', phoneExtension: '+49' },\n    { countryIsoCode: 'FI', phoneExtension: '+358' },\n    { countryIsoCode: 'PL', phoneExtension: '+48' },\n    { countryIsoCode: 'NL', phoneExtension: '+31' },\n    { countryIsoCode: 'CH', phoneExtension: '+41' },\n  ];\n\n  formControl = input.required<FormControl>();\n  label = input<string>();\n\n  /** @ignore */\n  chosenCountry = signal<Contry>(this.countries[0]);\n\n  /** @ignore */\n  mask = MASKITO_DEFAULT_OPTIONS;\n\n  /** @ignore */\n  intl = inject(WattPhoneFieldIntlService);\n\n  /** @ignore */\n  @HostBinding('attr.watt-field-disabled')\n  isDisabled = false;\n\n  /** @ignore */\n  value: string | null = null;\n\n  /** @ignore */\n  @ViewChild('phoneNumberInput') phoneNumberInput!: ElementRef<HTMLInputElement>;\n\n  /** @ignore */\n  ngOnInit(): void {\n    this.setup();\n  }\n\n  /** @ignore */\n  writeValue(value: string): void {\n    if (value) {\n      const country = this.countries.find((country) => value.startsWith(country.phoneExtension));\n\n      if (country) {\n        // Exclude Signal from being tracked\n        // in case the parent component sets the value inside an `effect`.\n        // Without this, updating the Signal internaly triggers the parrent `effect` to re-run.\n        // Note: Revisit once v19 is released because the `effect` API has changed\n        // significantly and this might not be necessary anymore\n        untracked(() => {\n          this.setCountry(country);\n        });\n\n        value = maskitoTransform(value, this.mask);\n      }\n    }\n\n    this.value = value;\n  }\n\n  /** @ignore */\n  onChange: (value: string) => void = () => {\n    /* noop function */\n  };\n\n  /** @ignore */\n  onTouched: () => void = () => {\n    /* noop function */\n  };\n\n  /** @ignore */\n  registerOnChange(fn: (value: string) => void): void {\n    this.onChange = fn;\n  }\n\n  /** @ignore */\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  /** @ignore */\n  setDisabledState(isDisabled: boolean): void {\n    this.isDisabled = isDisabled;\n  }\n\n  /** @ignore */\n  selectedContry({ value }: MatSelectChange) {\n    const country = this.countries.find((contry) => contry.countryIsoCode === value);\n\n    if (!country) {\n      throw new Error('Prefix not found');\n    }\n\n    this.setCountry(country);\n    this.formControl().reset();\n\n    setTimeout(() => {\n      this.phoneNumberInput.nativeElement.focus();\n    }, 100);\n  }\n\n  /** @ignore */\n  setCountry(country: Contry) {\n    this.chosenCountry.set(country);\n    this.setup();\n  }\n\n  /** @ignore */\n  onChanged(event: Event): void {\n    const value = (event.target as HTMLSelectElement)?.value;\n    this.onChange(value);\n  }\n\n  /** @ignore */\n  private generatePhoneOptions(): void {\n    const phoneOptions = maskitoPhoneOptionsGenerator({\n      countryIsoCode: this.chosenCountry().countryIsoCode,\n      metadata: phoneMetadata,\n      separator: ' ',\n    });\n\n    this.mask = phoneOptions;\n  }\n\n  /** @ignore */\n  private setup(): void {\n    this.generatePhoneOptions();\n    this.setValidator();\n  }\n\n  /** @ignore */\n  private setValidator() {\n    const countryCode = this.chosenCountry().countryIsoCode;\n    this.formControl().addValidators(phoneValidator(countryCode));\n  }\n\n  /** @ignore */\n  getCountryName(countryIsoCode: CountryCode) {\n    return this.intl[countryIsoCode as keyof WattPhoneFieldIntlService];\n  }\n}\n"]}

package/esm2022/picker/__shared/energinet-watt-picker-__shared.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5lcmdpbmV0LXdhdHQtcGlja2VyLV9fc2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy93YXR0L3BhY2thZ2UvcGlja2VyL19fc2hhcmVkL2VuZXJnaW5ldC13YXR0LXBpY2tlci1fX3NoYXJlZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/picker/__shared/index.js

@@ -0,0 +1,21 @@
+//#region License
+/**
+ * @license
+ * Copyright 2020 Energinet DataHub A/S
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License2");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//#endregion
+export { WattPlaceholderMaskComponent } from './placeholder-mask/watt-placeholder-mask.component';
+export { WattPickerBase } from './watt-picker-base';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3dhdHQvcGFja2FnZS9waWNrZXIvX19zaGFyZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsaUJBQWlCO0FBQ2pCOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUNILFlBQVk7QUFDWixPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSxvREFBb0QsQ0FBQztBQUNsRyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyNyZWdpb24gTGljZW5zZVxuLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IDIwMjAgRW5lcmdpbmV0IERhdGFIdWIgQS9TXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZTJcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuLy8jZW5kcmVnaW9uXG5leHBvcnQgeyBXYXR0UGxhY2Vob2xkZXJNYXNrQ29tcG9uZW50IH0gZnJvbSAnLi9wbGFjZWhvbGRlci1tYXNrL3dhdHQtcGxhY2Vob2xkZXItbWFzay5jb21wb25lbnQnO1xuZXhwb3J0IHsgV2F0dFBpY2tlckJhc2UgfSBmcm9tICcuL3dhdHQtcGlja2VyLWJhc2UnO1xuZXhwb3J0IHsgV2F0dFBpY2tlclZhbHVlIH0gZnJvbSAnLi93YXR0LXBpY2tlci12YWx1ZSc7XG4iXX0=

package/esm2022/picker/__shared/placeholder-mask/watt-placeholder-mask.component.js

@@ -0,0 +1,71 @@
+//#region License
+/**
+ * @license
+ * Copyright 2020 Energinet DataHub A/S
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License2");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//#endregion
+import { ChangeDetectorRef, Component, ViewEncapsulation, effect, inject, input, output, signal, untracked, } from '@angular/core';
+import { Maskito } from '@maskito/core';
+import * as i0 from "@angular/core";
+export class WattPlaceholderMaskComponent {
+    cdr = inject(ChangeDetectorRef);
+    primaryInputElement = input.required();
+    secondaryInputElement = input();
+    mask = input.required();
+    placeholder = input.required();
+    maskApplied = output();
+    maskedInput = signal(null);
+    primaryGhost = signal('');
+    primaryFiller = signal(null);
+    maskEffect = effect((onCleanup) => {
+        const mask = this.mask();
+        const placeholder = this.placeholder();
+        const primaryMask = {
+            ...mask,
+            preprocessors: [
+                ...(mask.preprocessors ?? []),
+                (state) => {
+                    this.primaryGhost.set(state.elementState.value.slice(0, placeholder.length));
+                    this.primaryFiller.set(placeholder.slice(state.elementState.value.length));
+                    return state;
+                },
+            ],
+            postprocessors: [
+                (elementState) => {
+                    this.maskApplied.emit(elementState.value);
+                    return elementState;
+                },
+                ...(mask.postprocessors ?? []),
+            ],
+        };
+        const maskedInput = new Maskito(this.primaryInputElement(), primaryMask);
+        this.maskedInput.set(maskedInput);
+        onCleanup(() => {
+            maskedInput.destroy();
+            this.maskedInput.set(null);
+        });
+    });
+    inputEffect = effect(() => {
+        const primaryInputElement = this.primaryInputElement();
+        untracked(() => primaryInputElement.dispatchEvent(new InputEvent('input')));
+    });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPlaceholderMaskComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.0.3", type: WattPlaceholderMaskComponent, isStandalone: true, selector: "watt-placeholder-mask", inputs: { primaryInputElement: { classPropertyName: "primaryInputElement", publicName: "primaryInputElement", isSignal: true, isRequired: true, transformFunction: null }, secondaryInputElement: { classPropertyName: "secondaryInputElement", publicName: "secondaryInputElement", isSignal: true, isRequired: false, transformFunction: null }, mask: { classPropertyName: "mask", publicName: "mask", isSignal: true, isRequired: true, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { maskApplied: "maskApplied" }, ngImport: i0, template: "<!--\n@license\nCopyright 2020 Energinet DataHub A/S\n\nLicensed under the Apache License, Version 2.0 (the \"License2\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n-->\n<span class=\"ghost\">{{ primaryGhost() }}</span>\n<span class=\"filler\">{{ primaryFiller() ?? placeholder() }}</span>\n", styles: ["watt-placeholder-mask{position:absolute;font-family:Droid Sans Mono,monospace;box-sizing:content-box;max-width:100%;line-height:20px;padding:1px 2px;letter-spacing:-.03em;pointer-events:none;display:block}.ghost{color:transparent;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:100%}.filler{color:var(--watt-color-neutral-grey-300);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:100%}\n"], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPlaceholderMaskComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'watt-placeholder-mask', encapsulation: ViewEncapsulation.None, template: "<!--\n@license\nCopyright 2020 Energinet DataHub A/S\n\nLicensed under the Apache License, Version 2.0 (the \"License2\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n-->\n<span class=\"ghost\">{{ primaryGhost() }}</span>\n<span class=\"filler\">{{ primaryFiller() ?? placeholder() }}</span>\n", styles: ["watt-placeholder-mask{position:absolute;font-family:Droid Sans Mono,monospace;box-sizing:content-box;max-width:100%;line-height:20px;padding:1px 2px;letter-spacing:-.03em;pointer-events:none;display:block}.ghost{color:transparent;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:100%}.filler{color:var(--watt-color-neutral-grey-300);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:100%}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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