@energinet/watt 2.0.13 → 2.1.0

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

@@ -0,0 +1,292 @@
+//#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 { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectorRef, DestroyRef, Directive, ElementRef, HostBinding, Input, inject, } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class WattPickerBase {
+    elementRef = inject(ElementRef);
+    changeDetectionRef = inject(ChangeDetectorRef);
+    ngControl = inject(NgControl, { optional: true });
+    /**
+     * @ignore
+     */
+    static nextId = 0;
+    /**
+     * @ignore
+     */
+    id;
+    /**
+     * @ignore
+     */
+    initialValue = null;
+    /**
+     * @ignore
+     */
+    focused = false;
+    /**
+     * @ignore
+     */
+    controlType = 'mat-date-range-input'; // We keep the controlType of Material Date Range Input as is, to keep some styling.
+    /**
+     * @ignore
+     */
+    stateChanges = new Subject();
+    /**
+     * @ignore
+     */
+    _destroyRef = inject(DestroyRef);
+    // eslint-disable-next-line @angular-eslint/no-input-rename
+    userAriaDescribedBy;
+    /**
+     * @ignore
+     */
+    get placeholder() {
+        return this._placeholder;
+    }
+    /**
+     * @ignore
+     */
+    set placeholder(value) {
+        this._placeholder = value;
+        this.stateChanges.next();
+    }
+    /**
+     * @ignore
+     */
+    get value() {
+        if (this.ngControl?.valid) {
+            const { value: { start, end }, } = this.ngControl;
+            return { start, end };
+        }
+        return null;
+    }
+    /**
+     * @ignore
+     */
+    set value(value) {
+        const inputNotToBeInTheDocument = !this.range ? !this.input : !this.startInput;
+        if (inputNotToBeInTheDocument) {
+            this.initialValue = value;
+            return;
+        }
+        if (this.range) {
+            this.setRangeValue(value, this.startInput.nativeElement, this.endInput.nativeElement);
+        }
+        else {
+            this.setSingleValue(value, this.input.nativeElement);
+        }
+        this.stateChanges.next();
+    }
+    set range(range) {
+        this._range = coerceBooleanProperty(range);
+    }
+    get range() {
+        return this._range;
+    }
+    /**
+     * @ignore
+     */
+    _range = false;
+    /**
+     * @ignore
+     */
+    get required() {
+        return this._required;
+    }
+    /**
+     * @ignore
+     */
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+        this.stateChanges.next();
+    }
+    /**
+     * @ignore
+     */
+    _required = false;
+    /**
+     * @ignore
+     */
+    get disabled() {
+        return this._disabled;
+    }
+    /**
+     * @ignore
+     */
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this.stateChanges.next();
+    }
+    /**
+     * @ignore
+     */
+    _disabled = false;
+    /**
+     * @ignore
+     */
+    get empty() {
+        if (this.range) {
+            return !this.ngControl?.value?.start && !this.ngControl?.value?.end;
+        }
+        else {
+            return this.ngControl?.value?.length === 0;
+        }
+    }
+    /**
+     * @ignore
+     */
+    get errorState() {
+        return !!this.ngControl?.invalid && !!this.ngControl?.touched;
+    }
+    /**
+     * @ignore
+     */
+    get shouldLabelFloat() {
+        return this.focused || !this.empty;
+    }
+    /**
+     *
+     * @ignore
+     */
+    control = null;
+    constructor(id) {
+        this.id = id;
+        this.elementRef.nativeElement.setAttribute('id', id);
+        if (this.ngControl != null) {
+            this.ngControl.valueAccessor = this;
+        }
+    }
+    ngOnInit() {
+        this.control = this.ngControl?.control;
+    }
+    /**
+     * @ignore
+     */
+    ngAfterViewInit() {
+        if (this.initialValue) {
+            this.writeValue(this.initialValue);
+        }
+        if (this.range) {
+            this.initRangeInput();
+        }
+        else {
+            this.initSingleInput();
+        }
+    }
+    /**
+     * @ignore
+     */
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    /**
+     * @ignore
+     */
+    setDescribedByIds(ids) {
+        this.elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));
+    }
+    /**
+     * @ignore
+     */
+    onContainerClick() {
+        // Intentionally left empty
+    }
+    /**
+     * @ignore
+     */
+    writeValue(value) {
+        this.value = value;
+    }
+    /**
+     * @ignore
+     */
+    registerOnChange(onChangeFn) {
+        this.changeParentValue = onChangeFn;
+    }
+    /**
+     * @ignore
+     */
+    registerOnTouched(onTouchFn) {
+        this.markParentControlAsTouched = onTouchFn;
+    }
+    /**
+     * @ignore
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.changeDetectionRef.detectChanges();
+    }
+    /**
+     * @ignore
+     */
+    onFocusIn() {
+        if (!this.focused) {
+            this.focused = true;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * @ignore
+     */
+    onFocusOut(event) {
+        const id = this.elementRef.nativeElement.attributes.getNamedItem('aria-owns');
+        const overlay = id ? document.getElementById(id.value) : null;
+        const isChild = overlay?.contains(event.relatedTarget);
+        if (!this.elementRef.nativeElement.contains(event.relatedTarget) && !isChild) {
+            this.focused = false;
+            this.markParentControlAsTouched();
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * @ignore
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    changeParentValue = (value) => {
+        // Intentionally left empty
+    };
+    /**
+     * @ignore
+     */
+    markParentControlAsTouched = () => {
+        // Intentionally left empty
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPickerBase, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.3", type: WattPickerBase, isStandalone: true, inputs: { userAriaDescribedBy: ["aria-describedby", "userAriaDescribedBy"], value: "value", range: "range", required: "required", disabled: "disabled" }, host: { properties: { "attr.watt-field-disabled": "this.disabled" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattPickerBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: undefined }], propDecorators: { userAriaDescribedBy: [{
+                type: Input,
+                args: ['aria-describedby']
+            }], value: [{
+                type: Input
+            }], range: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: HostBinding,
+                args: ['attr.watt-field-disabled']
+            }, {
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watt-picker-base.js","sourceRoot":"","sources":["../../../../../libs/watt/package/picker/__shared/watt-picker-base.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 { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n  AfterViewInit,\n  ChangeDetectorRef,\n  DestroyRef,\n  Directive,\n  ElementRef,\n  HostBinding,\n  Input,\n  OnDestroy,\n  OnInit,\n  inject,\n} from '@angular/core';\nimport { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';\nimport { Subject } from 'rxjs';\n\nimport { WattDateRange } from '@energinet/watt/core/date';\nimport { WattPickerValue } from './watt-picker-value';\n\n@Directive()\nexport abstract class WattPickerBase\n  implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor\n{\n  protected elementRef = inject<ElementRef<HTMLElement>>(ElementRef);\n  protected changeDetectionRef = inject(ChangeDetectorRef);\n  protected ngControl = inject(NgControl, { optional: true });\n\n  /**\n   * @ignore\n   */\n  abstract input: ElementRef;\n\n  /**\n   * @ignore\n   */\n  abstract startInput: ElementRef;\n\n  /**\n   * @ignore\n   */\n  abstract endInput: ElementRef;\n\n  /**\n   * @ignore\n   */\n  static nextId = 0;\n\n  /**\n   * @ignore\n   */\n  id: string;\n\n  /**\n   * @ignore\n   */\n  initialValue: WattPickerValue = null;\n\n  /**\n   * @ignore\n   */\n  focused = false;\n\n  /**\n   * @ignore\n   */\n  controlType = 'mat-date-range-input'; // We keep the controlType of Material Date Range Input as is, to keep some styling.\n\n  /**\n   * @ignore\n   */\n  stateChanges = new Subject<void>();\n\n  /**\n   * @ignore\n   */\n  protected _destroyRef = inject(DestroyRef);\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('aria-describedby') userAriaDescribedBy?: string;\n\n  /**\n   * @ignore\n   */\n  get placeholder(): string {\n    return this._placeholder;\n  }\n\n  /**\n   * @ignore\n   */\n  set placeholder(value: string) {\n    this._placeholder = value;\n    this.stateChanges.next();\n  }\n\n  /**\n   * @ignore\n   */\n  protected abstract _placeholder: string;\n\n  /**\n   * @ignore\n   */\n  @Input()\n  get value(): WattDateRange | null {\n    if (this.ngControl?.valid) {\n      const {\n        value: { start, end },\n      } = this.ngControl;\n\n      return { start, end };\n    }\n\n    return null;\n  }\n\n  /**\n   * @ignore\n   */\n  set value(value: WattPickerValue) {\n    const inputNotToBeInTheDocument = !this.range ? !this.input : !this.startInput;\n\n    if (inputNotToBeInTheDocument) {\n      this.initialValue = value;\n      return;\n    }\n\n    if (this.range) {\n      this.setRangeValue(\n        value as WattDateRange,\n        this.startInput.nativeElement,\n        this.endInput.nativeElement\n      );\n    } else {\n      this.setSingleValue(\n        value as Exclude<WattPickerValue, WattDateRange>,\n        this.input.nativeElement\n      );\n    }\n\n    this.stateChanges.next();\n  }\n\n  @Input()\n  set range(range: boolean) {\n    this._range = coerceBooleanProperty(range);\n  }\n  get range(): boolean {\n    return this._range;\n  }\n\n  /**\n   * @ignore\n   */\n  private _range = false;\n\n  /**\n   * @ignore\n   */\n  @Input()\n  get required(): boolean {\n    return this._required;\n  }\n\n  /**\n   * @ignore\n   */\n  set required(value: BooleanInput) {\n    this._required = coerceBooleanProperty(value);\n    this.stateChanges.next();\n  }\n\n  /**\n   * @ignore\n   */\n  private _required = false;\n\n  /**\n   * @ignore\n   */\n  @HostBinding('attr.watt-field-disabled')\n  @Input()\n  get disabled(): boolean {\n    return this._disabled;\n  }\n\n  /**\n   * @ignore\n   */\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n    this.stateChanges.next();\n  }\n\n  /**\n   * @ignore\n   */\n  private _disabled = false;\n\n  /**\n   * @ignore\n   */\n  get empty() {\n    if (this.range) {\n      return !this.ngControl?.value?.start && !this.ngControl?.value?.end;\n    } else {\n      return this.ngControl?.value?.length === 0;\n    }\n  }\n\n  /**\n   * @ignore\n   */\n  get errorState(): boolean {\n    return !!this.ngControl?.invalid && !!this.ngControl?.touched;\n  }\n\n  /**\n   * @ignore\n   */\n  get shouldLabelFloat() {\n    return this.focused || !this.empty;\n  }\n\n  /**\n   *\n   * @ignore\n   */\n  control: FormControl | null = null;\n\n  constructor(id: string) {\n    this.id = id;\n    this.elementRef.nativeElement.setAttribute('id', id);\n\n    if (this.ngControl != null) {\n      this.ngControl.valueAccessor = this;\n    }\n  }\n\n  ngOnInit(): void {\n    this.control = this.ngControl?.control as FormControl;\n  }\n\n  /**\n   * @ignore\n   */\n  ngAfterViewInit() {\n    if (this.initialValue) {\n      this.writeValue(this.initialValue);\n    }\n\n    if (this.range) {\n      this.initRangeInput();\n    } else {\n      this.initSingleInput();\n    }\n  }\n\n  /**\n   * @ignore\n   */\n  ngOnDestroy(): void {\n    this.stateChanges.complete();\n  }\n\n  /**\n   * @ignore\n   */\n  protected abstract initRangeInput(): void;\n\n  /**\n   * @ignore\n   */\n  protected abstract initSingleInput(): void;\n\n  /**\n   * @ignore\n   */\n  protected abstract setSingleValue(\n    value: Exclude<WattPickerValue, WattDateRange>,\n    input: HTMLInputElement\n  ): void;\n\n  /**\n   * @ignore\n   */\n  protected abstract setRangeValue(\n    value: WattDateRange,\n    startInput: HTMLInputElement,\n    endInput: HTMLInputElement\n  ): void;\n\n  /**\n   * @ignore\n   */\n  setDescribedByIds(ids: string[]) {\n    this.elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));\n  }\n\n  /**\n   * @ignore\n   */\n  onContainerClick() {\n    // Intentionally left empty\n  }\n\n  /**\n   * @ignore\n   */\n  writeValue(value: WattPickerValue): void {\n    this.value = value;\n  }\n\n  /**\n   * @ignore\n   */\n  registerOnChange(onChangeFn: (value: string | WattDateRange) => void): void {\n    this.changeParentValue = onChangeFn;\n  }\n\n  /**\n   * @ignore\n   */\n  registerOnTouched(onTouchFn: () => void) {\n    this.markParentControlAsTouched = onTouchFn;\n  }\n\n  /**\n   * @ignore\n   */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n    this.changeDetectionRef.detectChanges();\n  }\n\n  /**\n   * @ignore\n   */\n  onFocusIn() {\n    if (!this.focused) {\n      this.focused = true;\n      this.stateChanges.next();\n    }\n  }\n\n  /**\n   * @ignore\n   */\n  onFocusOut(event: FocusEvent) {\n    const id = this.elementRef.nativeElement.attributes.getNamedItem('aria-owns');\n    const overlay = id ? document.getElementById(id.value) : null;\n    const isChild = overlay?.contains(event.relatedTarget as Element);\n\n    if (!this.elementRef.nativeElement.contains(event.relatedTarget as Element) && !isChild) {\n      this.focused = false;\n      this.markParentControlAsTouched();\n      this.stateChanges.next();\n    }\n  }\n\n  /**\n   * @ignore\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected changeParentValue = (value: string | WattDateRange): void => {\n    // Intentionally left empty\n  };\n\n  /**\n   * @ignore\n   */\n  protected markParentControlAsTouched = (): void => {\n    // Intentionally left empty\n  };\n}\n"]}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0dC1waWNrZXItdmFsdWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3dhdHQvcGFja2FnZS9waWNrZXIvX19zaGFyZWQvd2F0dC1waWNrZXItdmFsdWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8vI3JlZ2lvbiBMaWNlbnNlXG4vKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgMjAyMCBFbmVyZ2luZXQgRGF0YUh1YiBBL1NcbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlMlwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG4vLyNlbmRyZWdpb25cbmltcG9ydCB7IFdhdHREYXRlUmFuZ2UgfSBmcm9tICdAZW5lcmdpbmV0L3dhdHQvY29yZS9kYXRlJztcblxuZXhwb3J0IHR5cGUgV2F0dFBpY2tlclZhbHVlID0gc3RyaW5nIHwgV2F0dERhdGVSYW5nZSB8IG51bGwgfCB1bmRlZmluZWQ7XG4iXX0=

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

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

package/esm2022/picker/datepicker/index.js

@@ -0,0 +1,22 @@
+//#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 { WattDatepickerComponent } from './watt-datepicker.component';
+export { danishTimeZoneIdentifier } from './watt-datepicker.component';
+export { WattDatepickerIntlService } from './watt-datepicker-intl.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL3dhdHQvcGFja2FnZS9waWNrZXIvZGF0ZXBpY2tlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxpQkFBaUI7QUFDakI7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBQ0gsWUFBWTtBQUNaLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3RFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8jcmVnaW9uIExpY2Vuc2Vcbi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCAyMDIwIEVuZXJnaW5ldCBEYXRhSHViIEEvU1xuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2UyXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cbi8vI2VuZHJlZ2lvblxuZXhwb3J0IHsgV2F0dERhdGVwaWNrZXJDb21wb25lbnQgfSBmcm9tICcuL3dhdHQtZGF0ZXBpY2tlci5jb21wb25lbnQnO1xuZXhwb3J0IHsgZGFuaXNoVGltZVpvbmVJZGVudGlmaWVyIH0gZnJvbSAnLi93YXR0LWRhdGVwaWNrZXIuY29tcG9uZW50JztcbmV4cG9ydCB7IFdhdHREYXRlcGlja2VySW50bFNlcnZpY2UgfSBmcm9tICcuL3dhdHQtZGF0ZXBpY2tlci1pbnRsLnNlcnZpY2UnO1xuIl19

package/esm2022/picker/datepicker/watt-datepicker-intl.service.js

@@ -0,0 +1,31 @@
+//#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 * as i0 from "@angular/core";
+export class WattDatepickerIntlService {
+    clear = 'Clear';
+    select = 'OK';
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattDatepickerIntlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattDatepickerIntlService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.3", ngImport: i0, type: WattDatepickerIntlService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2F0dC1kYXRlcGlja2VyLWludGwuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvd2F0dC9wYWNrYWdlL3BpY2tlci9kYXRlcGlja2VyL3dhdHQtZGF0ZXBpY2tlci1pbnRsLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsaUJBQWlCO0FBQ2pCOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUNILFlBQVk7QUFDWixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUczQyxNQUFNLE9BQU8seUJBQXlCO0lBQ3BDLEtBQUssR0FBRyxPQUFPLENBQUM7SUFDaEIsTUFBTSxHQUFHLElBQUksQ0FBQzt1R0FGSCx5QkFBeUI7MkdBQXpCLHlCQUF5QixjQURaLE1BQU07OzJGQUNuQix5QkFBeUI7a0JBRHJDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiLy8jcmVnaW9uIExpY2Vuc2Vcbi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCAyMDIwIEVuZXJnaW5ldCBEYXRhSHViIEEvU1xuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2UyXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cbi8vI2VuZHJlZ2lvblxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxuZXhwb3J0IGNsYXNzIFdhdHREYXRlcGlja2VySW50bFNlcnZpY2Uge1xuICBjbGVhciA9ICdDbGVhcic7XG4gIHNlbGVjdCA9ICdPSyc7XG59XG4iXX0=