@odx/angular 5.7.0 → 5.7.2

package/esm2022/components/timepicker/lib/timepicker.component.mjs

@@ -0,0 +1,213 @@
+var TimepickerComponent_1;
+import { __decorate, __metadata } from "tslib";
+import { A11yModule, ActiveDescendantKeyManager } from '@angular/cdk/a11y';
+import { ChangeDetectionStrategy, Component, HostListener, Input, QueryList, ViewChild, ViewChildren, ViewEncapsulation, booleanAttribute, forwardRef, inject, numberAttribute, } from '@angular/core';
+import { DisabledController, ReadonlyController } from '@odx/angular';
+import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
+import { ActionGroupComponent } from '@odx/angular/components/action-group';
+import { ButtonComponent } from '@odx/angular/components/button';
+import { DropdownDirective, DropdownModule } from '@odx/angular/components/dropdown';
+import { IconComponent } from '@odx/angular/components/icon';
+import { CSSComponent } from '@odx/angular/internal';
+import { injectElement, isFunction, trackByIndex, untilDestroyed } from '@odx/angular/utils';
+import { TimepickerOptionComponent } from './components/timepicker-option.component';
+import { TimepickerInputControlDirective } from './directives/timepicker-input-control.directive';
+import { TimepickerService } from './timepicker.service';
+import { TIMEPICKER_CONTROL } from './timepicker.token';
+import { generateTimeStamps } from './utils/generate-time-stamps';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@odx/angular";
+import * as i3 from "@odx/angular/components/dropdown";
+/**
+ * Represents a time picker component allowing users to select a time from a dropdown list.
+ * This component integrates with Angular forms and supports customization for locale, time range, and step intervals.
+ *
+ * @extends {CustomFormControl<string | null>}
+ */
+export let TimepickerComponent = class TimepickerComponent extends CustomFormControl {
+    static { TimepickerComponent_1 = this; }
+    /**
+     * Controls whether the timepicker should use locale-specific time formats AM/PM.
+     * @default false
+     */
+    set useLocale(val) {
+        if (this.value && this.dateField) {
+            const time = this.timepickerService.getLocalizedTimeFormat(this.value, val);
+            this.updateValue(time);
+            this.dateField.nativeElementValue = time;
+        }
+        this._useLocale = val;
+    }
+    get useLocale() {
+        return this._useLocale;
+    }
+    constructor() {
+        super(null);
+        this.timepickerService = inject(TimepickerService);
+        this._useLocale = false;
+        this.takeUntilDestroyed = untilDestroyed();
+        this.trackByIndex = trackByIndex;
+        this.element = injectElement();
+        /**
+         * Controls the step interval between time options in minutes.
+         * @default 30
+         */
+        this.step = 30;
+        /**
+         * Specifies the minimum time value that can be selected ('05:00' or '05:00 AM').
+         * @default '00:00'
+         */
+        this.min = '00:00';
+        /**
+         * Specifies the maximum time value that can be selected ('22:00' or '10:00 PM').
+         * @default '23:59'
+         */
+        this.max = '23:59';
+    }
+    ngAfterViewInit() {
+        this.handleDateFieldChanges();
+        this.updateInputValue();
+    }
+    onOpen() {
+        this.keyManager = new ActiveDescendantKeyManager(this.options).withHomeAndEnd();
+        this.setActiveOptionBasedOnCurrentValue();
+    }
+    isTimeOptionSelected(option) {
+        return this.value === option.value;
+    }
+    /**
+     * Handles the selection of a time option from the dropdown, updating the input field and closing the dropdown.
+     *
+     * @param {TimepickerOptionComponent} option - The selected time option component.
+     */
+    timeSelected(option) {
+        if (!option || option.disabled)
+            return;
+        const time = this.timepickerService.getLocalizedTimeFormat(option.getLabel(), this.useLocale);
+        this.dateField && (this.dateField.nativeElementValue = time);
+        this.updateValue(time);
+        this.dropdown?.close();
+    }
+    /**
+     * Determines whether the specified time is within the allowed time range.
+     *
+     * @param {string} time - The time to check, in 'HH:mm' or 'HH:mm AM/PM' format.
+     * @returns {boolean} True if the time is within the range; otherwise, false.
+     */
+    inTimeRange(time) {
+        return this.timepickerService.maxValidation(time, this.max) && this.timepickerService.minValidation(time, this.min);
+    }
+    /**
+     * Generates the list of time options based on the configured step interval and locale settings AM/PM.
+     *
+     * @returns {string[]} An array of time strings in 'HH:mm' format.
+     */
+    get timeStampsList() {
+        return generateTimeStamps(this.step, this.useLocale);
+    }
+    handleControllerEvent(event) {
+        if (this.readonlyController?.readonly)
+            return;
+        this.keyManager?.onKeydown(event);
+        const activeOption = this.keyManager?.activeItem;
+        activeOption && this.scrollToActiveOption(activeOption, { behavior: 'smooth' });
+        if (event.key === 'Enter' || event.key === ' ' || event.key === 'Spacebar') {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            this.timeSelected(activeOption);
+        }
+    }
+    handleDateFieldChanges() {
+        this.dateField?.valueChange$.pipe(this.takeUntilDestroyed()).subscribe((time) => this.updateValue(time ?? null));
+    }
+    setActiveOptionBasedOnCurrentValue() {
+        const isSelected = this.options.find((option) => option.isSelected);
+        if (isSelected) {
+            this.activateOption(isSelected);
+            return;
+        }
+        this.activateNearestTimeOption();
+    }
+    activateOption(option) {
+        this.keyManager && this.keyManager.setActiveItem(option);
+        this.scrollToActiveOption(option);
+    }
+    activateNearestTimeOption() {
+        if (!this.value) {
+            const currentDate = new Date();
+            const isNearest = this.findNearestTimeOption(currentDate);
+            if (isNearest) {
+                this.activateOption(isNearest);
+            }
+        }
+    }
+    findNearestTimeOption(currentDate) {
+        const availableTimeSlots = this.options.filter((option) => !option.disabled);
+        const nearestTimeValue = this.timepickerService.findClosestDate(availableTimeSlots.map((option) => option.value), `${currentDate.getHours()}:${currentDate.getMinutes()}`);
+        return availableTimeSlots.find((option) => option.value === nearestTimeValue);
+    }
+    updateInputValue() {
+        if (this.value && this.dateField) {
+            const time = this.timepickerService.getLocalizedTimeFormat(this.value, this.useLocale);
+            this.dateField.nativeElementValue = time;
+        }
+    }
+    scrollToActiveOption(option, _opts = {}) {
+        if (isFunction(option.element.nativeElement.scrollIntoView)) {
+            option.element.nativeElement.scrollIntoView({ block: 'center', ..._opts });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "16.2.12", type: TimepickerComponent, isStandalone: true, selector: "odx-timepicker", inputs: { useLocale: ["useLocale", "useLocale", booleanAttribute], step: ["step", "step", numberAttribute], min: "min", max: "max" }, host: { listeners: { "click": "handleControllerEvent($event)", "keydown": "handleControllerEvent($event)" }, properties: { "attr.readonly": "readonlyController?.readonly || null" } }, providers: [
+            DisabledController.connect(),
+            ReadonlyController.connect(),
+            {
+                provide: TIMEPICKER_CONTROL,
+                useExisting: forwardRef(() => TimepickerComponent_1),
+            },
+        ], viewQueries: [{ propertyName: "dropdown", first: true, predicate: DropdownDirective, descendants: true }, { propertyName: "dateField", first: true, predicate: TimepickerInputControlDirective, descendants: true }, { propertyName: "options", predicate: TimepickerOptionComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"odx-timepicker__wrapper\">\n  <input [value]=\"value\" odxTimepickerControl type=\"text\" />\n</div>\n\n<odx-action-group class=\"odx-no-margin\">\n  <button\n    #dropdownTrigger\n    class=\"odx-timepicker__trigger\"\n    odxButton\n    size=\"small\"\n    variant=\"ghost\"\n    aria-label=\"Select time\"\n    [odxDropdown]=\"timeList\"\n    [odxDropdownOptions]=\"{ matchReferenceWidth: true, position: 'bottom-start', enableFallback: false }\"\n    [odxDropdownTriggerElement]=\"dropdownTrigger.element.nativeElement\"\n    [odxDropdownReferenceElement]=\"element.nativeElement\"\n    (odxDropdownBeforeClose)=\"onTouched()\"\n    (odxDropdownAfterOpen)=\"onOpen()\"\n  >\n    <odx-icon name=\"chevron-down\"></odx-icon>\n  </button>\n</odx-action-group>\n\n<ng-template #timeList>\n  <div class=\"odx-timepicker__option-list\" role=\"listbox\">\n    <odx-timepicker-option\n      [value]=\"time\"\n      [disabled]=\"!inTimeRange(time)\"\n      *ngFor=\"let time of timeStampsList; trackBy: trackByIndex\"\n      (selected)=\"timeSelected($event)\"\n      >{{ time }}</odx-timepicker-option\n    >\n  </div>\n</ng-template>\n", dependencies: [{ kind: "ngmodule", type: A11yModule }, { kind: "component", type: ActionGroupComponent, selector: "odx-action-group", inputs: ["reverse"] }, { kind: "component", type: ButtonComponent, selector: "button[odxButton], a[odxButton]", inputs: ["variant", "size"] }, { kind: "ngmodule", type: DropdownModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.DisabledController, selector: "[disabled]", inputs: ["disabled"] }, { kind: "directive", type: i3.DropdownDirective, selector: "[odxDropdown]", inputs: ["odxDropdown", "odxDropdownDisabled", "odxDropdownShowLoader", "odxDropdownClickOutsideActive", "odxDropdownOptions", "odxDropdownReferenceElement", "odxDropdownTriggerElement", "odxDropdownHost", "odxDropdownOpenTrigger", "odxDropdownCloseTrigger"], outputs: ["odxDropdownBeforeOpen", "odxDropdownAfterOpen", "odxDropdownBeforeClose", "odxDropdownAfterClose"], exportAs: ["odxDropdown"] }, { kind: "component", type: TimepickerOptionComponent, selector: "odx-timepicker-option", outputs: ["selected"] }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }, { kind: "directive", type: TimepickerInputControlDirective, selector: "input[odxTimepickerControl]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+};
+TimepickerComponent = TimepickerComponent_1 = __decorate([
+    CSSComponent('timepicker'),
+    __metadata("design:paramtypes", [])
+], TimepickerComponent);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'odx-timepicker', providers: [
+                        DisabledController.connect(),
+                        ReadonlyController.connect(),
+                        {
+                            provide: TIMEPICKER_CONTROL,
+                            useExisting: forwardRef(() => TimepickerComponent),
+                        },
+                    ], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, imports: [A11yModule, ActionGroupComponent, ButtonComponent, DropdownModule, TimepickerOptionComponent, IconComponent, TimepickerInputControlDirective], host: {
+                        '[attr.readonly]': 'readonlyController?.readonly || null',
+                    }, template: "<div class=\"odx-timepicker__wrapper\">\n  <input [value]=\"value\" odxTimepickerControl type=\"text\" />\n</div>\n\n<odx-action-group class=\"odx-no-margin\">\n  <button\n    #dropdownTrigger\n    class=\"odx-timepicker__trigger\"\n    odxButton\n    size=\"small\"\n    variant=\"ghost\"\n    aria-label=\"Select time\"\n    [odxDropdown]=\"timeList\"\n    [odxDropdownOptions]=\"{ matchReferenceWidth: true, position: 'bottom-start', enableFallback: false }\"\n    [odxDropdownTriggerElement]=\"dropdownTrigger.element.nativeElement\"\n    [odxDropdownReferenceElement]=\"element.nativeElement\"\n    (odxDropdownBeforeClose)=\"onTouched()\"\n    (odxDropdownAfterOpen)=\"onOpen()\"\n  >\n    <odx-icon name=\"chevron-down\"></odx-icon>\n  </button>\n</odx-action-group>\n\n<ng-template #timeList>\n  <div class=\"odx-timepicker__option-list\" role=\"listbox\">\n    <odx-timepicker-option\n      [value]=\"time\"\n      [disabled]=\"!inTimeRange(time)\"\n      *ngFor=\"let time of timeStampsList; trackBy: trackByIndex\"\n      (selected)=\"timeSelected($event)\"\n      >{{ time }}</odx-timepicker-option\n    >\n  </div>\n</ng-template>\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { dropdown: [{
+                type: ViewChild,
+                args: [DropdownDirective]
+            }], options: [{
+                type: ViewChildren,
+                args: [TimepickerOptionComponent, { emitDistinctChangesOnly: true }]
+            }], useLocale: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], step: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], dateField: [{
+                type: ViewChild,
+                args: [TimepickerInputControlDirective]
+            }], handleControllerEvent: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timepicker.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/timepicker/src/lib/timepicker.component.ts","../../../../../../../libs/angular/components/timepicker/src/lib/timepicker.component.html"],"names":[],"mappings":"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","sourcesContent":["import { A11yModule, ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  HostListener,\n  Input,\n  QueryList,\n  ViewChild,\n  ViewChildren,\n  ViewEncapsulation,\n  booleanAttribute,\n  forwardRef,\n  inject,\n  numberAttribute,\n} from '@angular/core';\nimport { DisabledController, ReadonlyController } from '@odx/angular';\nimport { CustomFormControl } from '@odx/angular/cdk/custom-form-control';\nimport { OptionControl } from '@odx/angular/cdk/option-control';\nimport { ActionGroupComponent } from '@odx/angular/components/action-group';\nimport { ButtonComponent } from '@odx/angular/components/button';\nimport { DropdownDirective, DropdownModule } from '@odx/angular/components/dropdown';\nimport { IconComponent } from '@odx/angular/components/icon';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { injectElement, isFunction, trackByIndex, untilDestroyed } from '@odx/angular/utils';\nimport { TimepickerOptionComponent } from './components/timepicker-option.component';\nimport { TimepickerInputControlDirective } from './directives/timepicker-input-control.directive';\nimport { TimepickerService } from './timepicker.service';\nimport { TIMEPICKER_CONTROL } from './timepicker.token';\nimport { generateTimeStamps } from './utils/generate-time-stamps';\n\n/**\n * Represents a time picker component allowing users to select a time from a dropdown list.\n * This component integrates with Angular forms and supports customization for locale, time range, and step intervals.\n *\n * @extends {CustomFormControl<string | null>}\n */\n@CSSComponent('timepicker')\n@Component({\n  standalone: true,\n  selector: 'odx-timepicker',\n  templateUrl: 'timepicker.component.html',\n  providers: [\n    DisabledController.connect(),\n    ReadonlyController.connect(),\n    {\n      provide: TIMEPICKER_CONTROL,\n      useExisting: forwardRef(() => TimepickerComponent),\n    },\n  ],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [A11yModule, ActionGroupComponent, ButtonComponent, DropdownModule, TimepickerOptionComponent, IconComponent, TimepickerInputControlDirective],\n  host: {\n    '[attr.readonly]': 'readonlyController?.readonly || null',\n  },\n})\nexport class TimepickerComponent extends CustomFormControl<string | null> implements AfterViewInit {\n  private readonly timepickerService = inject(TimepickerService);\n  private _useLocale = false;\n  protected keyManager?: ActiveDescendantKeyManager<OptionControl<string>>;\n\n  protected readonly takeUntilDestroyed = untilDestroyed();\n  protected readonly trackByIndex = trackByIndex;\n\n  @ViewChild(DropdownDirective)\n  protected readonly dropdown?: DropdownDirective;\n\n  @ViewChildren(TimepickerOptionComponent, { emitDistinctChangesOnly: true })\n  protected options!: QueryList<TimepickerOptionComponent>;\n\n  public readonly element = injectElement();\n\n  /**\n   * Controls whether the timepicker should use locale-specific time formats AM/PM.\n   * @default false\n   */\n  @Input({ transform: booleanAttribute })\n  public set useLocale(val: boolean) {\n    if (this.value && this.dateField) {\n      const time = this.timepickerService.getLocalizedTimeFormat(this.value, val);\n      this.updateValue(time);\n      this.dateField.nativeElementValue = time;\n    }\n    this._useLocale = val;\n  }\n\n  public get useLocale(): boolean {\n    return this._useLocale;\n  }\n\n  /**\n   * Controls the step interval between time options in minutes.\n   * @default 30\n   */\n  @Input({ transform: numberAttribute })\n  public step = 30;\n\n  /**\n   * Specifies the minimum time value that can be selected ('05:00' or '05:00 AM').\n   * @default '00:00'\n   */\n  @Input()\n  public min = '00:00';\n\n  /**\n   * Specifies the maximum time value that can be selected ('22:00' or '10:00 PM').\n   * @default '23:59'\n   */\n  @Input()\n  public max = '23:59';\n\n  @ViewChild(TimepickerInputControlDirective)\n  public dateField?: TimepickerInputControlDirective;\n\n  constructor() {\n    super(null);\n  }\n\n  public ngAfterViewInit(): void {\n    this.handleDateFieldChanges();\n    this.updateInputValue();\n  }\n\n  public onOpen(): void {\n    this.keyManager = new ActiveDescendantKeyManager<OptionControl<string>>(this.options).withHomeAndEnd();\n    this.setActiveOptionBasedOnCurrentValue();\n  }\n\n  public isTimeOptionSelected(option: TimepickerOptionComponent): boolean {\n    return this.value === option.value;\n  }\n\n  /**\n   * Handles the selection of a time option from the dropdown, updating the input field and closing the dropdown.\n   *\n   * @param {TimepickerOptionComponent} option - The selected time option component.\n   */\n  public timeSelected(option?: TimepickerOptionComponent): void {\n    if (!option || option.disabled) return;\n    const time = this.timepickerService.getLocalizedTimeFormat(option.getLabel(), this.useLocale);\n    this.dateField && (this.dateField.nativeElementValue = time);\n    this.updateValue(time);\n    this.dropdown?.close();\n  }\n\n  /**\n   * Determines whether the specified time is within the allowed time range.\n   *\n   * @param {string} time - The time to check, in 'HH:mm' or 'HH:mm AM/PM' format.\n   * @returns {boolean} True if the time is within the range; otherwise, false.\n   */\n  public inTimeRange(time: string): boolean {\n    return this.timepickerService.maxValidation(time, this.max) && this.timepickerService.minValidation(time, this.min);\n  }\n\n  /**\n   * Generates the list of time options based on the configured step interval and locale settings AM/PM.\n   *\n   * @returns {string[]} An array of time strings in 'HH:mm' format.\n   */\n  public get timeStampsList(): string[] {\n    return generateTimeStamps(this.step, this.useLocale);\n  }\n\n  @HostListener('click', ['$event'])\n  @HostListener('keydown', ['$event'])\n  protected handleControllerEvent(event: KeyboardEvent) {\n    if (this.readonlyController?.readonly) return;\n\n    this.keyManager?.onKeydown(event);\n    const activeOption = this.keyManager?.activeItem as TimepickerOptionComponent;\n    activeOption && this.scrollToActiveOption(activeOption, { behavior: 'smooth' });\n\n    if (event.key === 'Enter' || event.key === ' ' || event.key === 'Spacebar') {\n      event.preventDefault();\n      event.stopImmediatePropagation();\n      this.timeSelected(activeOption);\n    }\n  }\n\n  protected handleDateFieldChanges(): void {\n    this.dateField?.valueChange$.pipe(this.takeUntilDestroyed()).subscribe((time) => this.updateValue(time ?? null));\n  }\n\n  private setActiveOptionBasedOnCurrentValue(): void {\n    const isSelected = this.options.find((option) => option.isSelected);\n    if (isSelected) {\n      this.activateOption(isSelected);\n      return;\n    }\n\n    this.activateNearestTimeOption();\n  }\n\n  private activateOption(option: TimepickerOptionComponent): void {\n    this.keyManager && this.keyManager.setActiveItem(option);\n    this.scrollToActiveOption(option);\n  }\n\n  private activateNearestTimeOption(): void {\n    if (!this.value) {\n      const currentDate = new Date();\n      const isNearest = this.findNearestTimeOption(currentDate);\n      if (isNearest) {\n        this.activateOption(isNearest);\n      }\n    }\n  }\n\n  private findNearestTimeOption(currentDate: Date): TimepickerOptionComponent | undefined {\n    const availableTimeSlots = this.options.filter((option) => !option.disabled);\n    const nearestTimeValue = this.timepickerService.findClosestDate(\n      availableTimeSlots.map((option) => option.value) as string[],\n      `${currentDate.getHours()}:${currentDate.getMinutes()}`,\n    );\n\n    return availableTimeSlots.find((option) => option.value === nearestTimeValue);\n  }\n\n  private updateInputValue(): void {\n    if (this.value && this.dateField) {\n      const time = this.timepickerService.getLocalizedTimeFormat(this.value, this.useLocale);\n      this.dateField.nativeElementValue = time;\n    }\n  }\n\n  private scrollToActiveOption(option: TimepickerOptionComponent, _opts: ScrollIntoViewOptions = {}): void {\n    if (isFunction(option.element.nativeElement.scrollIntoView)) {\n      option.element.nativeElement.scrollIntoView({ block: 'center', ..._opts });\n    }\n  }\n}\n","<div class=\"odx-timepicker__wrapper\">\n  <input [value]=\"value\" odxTimepickerControl type=\"text\" />\n</div>\n\n<odx-action-group class=\"odx-no-margin\">\n  <button\n    #dropdownTrigger\n    class=\"odx-timepicker__trigger\"\n    odxButton\n    size=\"small\"\n    variant=\"ghost\"\n    aria-label=\"Select time\"\n    [odxDropdown]=\"timeList\"\n    [odxDropdownOptions]=\"{ matchReferenceWidth: true, position: 'bottom-start', enableFallback: false }\"\n    [odxDropdownTriggerElement]=\"dropdownTrigger.element.nativeElement\"\n    [odxDropdownReferenceElement]=\"element.nativeElement\"\n    (odxDropdownBeforeClose)=\"onTouched()\"\n    (odxDropdownAfterOpen)=\"onOpen()\"\n  >\n    <odx-icon name=\"chevron-down\"></odx-icon>\n  </button>\n</odx-action-group>\n\n<ng-template #timeList>\n  <div class=\"odx-timepicker__option-list\" role=\"listbox\">\n    <odx-timepicker-option\n      [value]=\"time\"\n      [disabled]=\"!inTimeRange(time)\"\n      *ngFor=\"let time of timeStampsList; trackBy: trackByIndex\"\n      (selected)=\"timeSelected($event)\"\n      >{{ time }}</odx-timepicker-option\n    >\n  </div>\n</ng-template>\n"]}

package/esm2022/components/timepicker/lib/timepicker.module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CoreModule } from '@odx/angular';
+import { TimepickerOptionComponent } from './components/timepicker-option.component';
+import { TimepickerInputControlDirective } from './directives/timepicker-input-control.directive';
+import { TimepickerComponent } from './timepicker.component';
+import * as i0 from "@angular/core";
+const modules = [TimepickerComponent, TimepickerInputControlDirective, TimepickerOptionComponent];
+export class TimepickerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: TimepickerModule, imports: [TimepickerComponent, TimepickerInputControlDirective, TimepickerOptionComponent], exports: [CoreModule, TimepickerComponent, TimepickerInputControlDirective, TimepickerOptionComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerModule, imports: [TimepickerComponent, CoreModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: modules,
+                    exports: [CoreModule, ...modules],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXBpY2tlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy90aW1lcGlja2VyL3NyYy9saWIvdGltZXBpY2tlci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzFDLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLGlEQUFpRCxDQUFDO0FBQ2xHLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDOztBQUU3RCxNQUFNLE9BQU8sR0FBRyxDQUFDLG1CQUFtQixFQUFFLCtCQUErQixFQUFFLHlCQUF5QixDQUFDLENBQUM7QUFLbEcsTUFBTSxPQUFPLGdCQUFnQjsrR0FBaEIsZ0JBQWdCO2dIQUFoQixnQkFBZ0IsWUFMWixtQkFBbUIsRUFBRSwrQkFBK0IsRUFBRSx5QkFBeUIsYUFHcEYsVUFBVSxFQUhMLG1CQUFtQixFQUFFLCtCQUErQixFQUFFLHlCQUF5QjtnSEFLbkYsZ0JBQWdCLFlBTFosbUJBQW1CLEVBR3hCLFVBQVU7OzRGQUVULGdCQUFnQjtrQkFKNUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsT0FBTztvQkFDaEIsT0FBTyxFQUFFLENBQUMsVUFBVSxFQUFFLEdBQUcsT0FBTyxDQUFDO2lCQUNsQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb3JlTW9kdWxlIH0gZnJvbSAnQG9keC9hbmd1bGFyJztcbmltcG9ydCB7IFRpbWVwaWNrZXJPcHRpb25Db21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvdGltZXBpY2tlci1vcHRpb24uY29tcG9uZW50JztcbmltcG9ydCB7IFRpbWVwaWNrZXJJbnB1dENvbnRyb2xEaXJlY3RpdmUgfSBmcm9tICcuL2RpcmVjdGl2ZXMvdGltZXBpY2tlci1pbnB1dC1jb250cm9sLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBUaW1lcGlja2VyQ29tcG9uZW50IH0gZnJvbSAnLi90aW1lcGlja2VyLmNvbXBvbmVudCc7XG5cbmNvbnN0IG1vZHVsZXMgPSBbVGltZXBpY2tlckNvbXBvbmVudCwgVGltZXBpY2tlcklucHV0Q29udHJvbERpcmVjdGl2ZSwgVGltZXBpY2tlck9wdGlvbkNvbXBvbmVudF07XG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBtb2R1bGVzLFxuICBleHBvcnRzOiBbQ29yZU1vZHVsZSwgLi4ubW9kdWxlc10sXG59KVxuZXhwb3J0IGNsYXNzIFRpbWVwaWNrZXJNb2R1bGUge31cbiJdfQ==

package/esm2022/components/timepicker/lib/timepicker.service.mjs

@@ -0,0 +1,92 @@
+import { Injectable, inject } from '@angular/core';
+import { WindowRef } from '@odx/angular';
+import { isAfter, isBefore, isEqual } from 'date-fns';
+import * as i0 from "@angular/core";
+/**
+ * Service to provide utility functions for timepicker components, including validation, placeholder generation, and finding the closest time.
+ * It also handles locale-based time formatting.
+ */
+export class TimepickerService {
+    constructor() {
+        this.windowRef = inject(WindowRef);
+    }
+    /**
+     * Generates a placeholder string for time input fields.
+     *
+     * @param {boolean} apm - Specifies if the placeholder should include AM/PM notation.
+     * @returns {string} The placeholder string.
+     */
+    getPlaceholder(apm = false) {
+        return apm ? '--:-- --' : '--:--';
+    }
+    /**
+     * Validates if the given time is less than or equal to a maximum time constraint.
+     *
+     * @param {string} time - The time to validate.
+     * @param {string} max - The maximum allowable time.
+     * @returns {boolean} True if the time is valid, false otherwise.
+     */
+    maxValidation(time, max) {
+        const [targetValue, maxValue] = this.convertToDates([time, max]);
+        return isBefore(targetValue, maxValue) || isEqual(targetValue, maxValue);
+    }
+    /**
+     * Validates if the given time is greater than or equal to a minimum time constraint.
+     *
+     * @param {string} time - The time to validate.
+     * @param {string} min - The minimum allowable time.
+     * @returns {boolean} True if the time is valid, false otherwise.
+     */
+    minValidation(time, min) {
+        const [targetValue, minValue] = this.convertToDates([time, min]);
+        return isAfter(targetValue, minValue) || isEqual(targetValue, minValue);
+    }
+    /**
+     * Finds the closest time to a target time from a list of times.
+     *
+     * @param {string[]} timeStamps - The list of times to search through.
+     * @param {string} targetTime - The target time to find the closest match for.
+     * @returns {string} The closest time to the target.
+     */
+    findClosestDate(timeStamps, targetTime) {
+        const [target] = this.convertToDates([targetTime]);
+        const datesArray = this.convertToDates(timeStamps);
+        const closestDate = datesArray.reduce((prev, curr) => {
+            return Math.abs(curr.getTime() - target.getTime()) < Math.abs(prev.getTime() - target.getTime()) ? curr : prev;
+        });
+        return this.getLocalizedTimeFormat(`${closestDate.getHours()}:${closestDate.getMinutes()}`);
+    }
+    /**
+     * Formats a time string to a localized time format.
+     *
+     * @param {string} time - The time string to format.
+     * @param {boolean} hour12 - Specifies if the output should use 12-hour format with AM/PM notation.
+     * @returns {string} The formatted time string.
+     */
+    getLocalizedTimeFormat(time, hour12 = false) {
+        const locale = hour12 ? 'en-US' : 'en-GB';
+        const [date] = this.convertToDates([time]);
+        return new this.windowRef.nativeWindow.Intl.DateTimeFormat(locale, {
+            hour: '2-digit',
+            minute: '2-digit',
+            hour12,
+        }).format(date);
+    }
+    /**
+     * Converts an array of time strings to an array of Date objects.
+     *
+     * @param {string[]} times - The time strings to convert.
+     * @returns {Date[]} An array of Date objects corresponding to the input times.
+     * @private
+     */
+    convertToDates(times) {
+        return times.map((time) => new Date(`${time} 2022-12-19`));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimepickerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/timepicker/lib/timepicker.token.mjs

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * An InjectionToken used for injecting an instance of TimepickerComponent.
+ * This token facilitates the decoupling of the TimepickerComponent's implementation from its consumption,
+ * allowing for more flexible and maintainable code, especially in scenarios requiring custom time picker
+ * behavior or appearance.
+ */
+export const TIMEPICKER_CONTROL = new InjectionToken('@odx/angular/components/timepicker::TimepickerComponent');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXBpY2tlci50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9jb21wb25lbnRzL3RpbWVwaWNrZXIvc3JjL2xpYi90aW1lcGlja2VyLnRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHL0M7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBc0IseURBQXlELENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUaW1lcGlja2VyQ29tcG9uZW50IH0gZnJvbSAnLi90aW1lcGlja2VyLmNvbXBvbmVudCc7XG5cbi8qKlxuICogQW4gSW5qZWN0aW9uVG9rZW4gdXNlZCBmb3IgaW5qZWN0aW5nIGFuIGluc3RhbmNlIG9mIFRpbWVwaWNrZXJDb21wb25lbnQuXG4gKiBUaGlzIHRva2VuIGZhY2lsaXRhdGVzIHRoZSBkZWNvdXBsaW5nIG9mIHRoZSBUaW1lcGlja2VyQ29tcG9uZW50J3MgaW1wbGVtZW50YXRpb24gZnJvbSBpdHMgY29uc3VtcHRpb24sXG4gKiBhbGxvd2luZyBmb3IgbW9yZSBmbGV4aWJsZSBhbmQgbWFpbnRhaW5hYmxlIGNvZGUsIGVzcGVjaWFsbHkgaW4gc2NlbmFyaW9zIHJlcXVpcmluZyBjdXN0b20gdGltZSBwaWNrZXJcbiAqIGJlaGF2aW9yIG9yIGFwcGVhcmFuY2UuXG4gKi9cbmV4cG9ydCBjb25zdCBUSU1FUElDS0VSX0NPTlRST0wgPSBuZXcgSW5qZWN0aW9uVG9rZW48VGltZXBpY2tlckNvbXBvbmVudD4oJ0BvZHgvYW5ndWxhci9jb21wb25lbnRzL3RpbWVwaWNrZXI6OlRpbWVwaWNrZXJDb21wb25lbnQnKTtcbiJdfQ==

package/esm2022/components/timepicker/lib/utils/generate-time-stamps.mjs

@@ -0,0 +1,52 @@
+/**
+ * Generates an array of time stamps within a 24-hour period based on the specified step interval.
+ * The time stamps can be formatted in 24-hour format or 12-hour format with AM/PM based on locale preference.
+ *
+ * @param {number} step - The interval, in minutes, between each time stamp.
+ * @param {boolean} useLocale - Determines if the time stamps should use the 12-hour format with AM/PM (`true`) or the 24-hour format (`false`).
+ * @returns {string[]} An array of formatted time stamps as strings.
+ * @example
+ * // Generate time stamps every 30 minutes using 24-hour format
+ * generateTimeStamps(30, false);
+ * // Returns ["00:00", "00:30", "01:00", ..., "23:30"]
+ *
+ * @example
+ * // Generate time stamps every 60 minutes using 12-hour format with AM/PM
+ * generateTimeStamps(60, true);
+ * // Returns ["12:00 AM", "01:00 AM", ..., "11:00 PM"]
+ */
+export function generateTimeStamps(step, useLocale) {
+    const roundedStep = Math.round(step);
+    return Array.from({ length: Math.ceil(24 * (60 / roundedStep)) }, (_, i) => {
+        const hours = Math.floor((i * roundedStep) / 60);
+        const minutes = (i * roundedStep) % 60;
+        return formatTime(hours, minutes, useLocale);
+    });
+}
+/**
+ * Formats a given time as a string based on the specified hour, minute, and locale preference.
+ * Can format time in either 24-hour format or 12-hour format with AM/PM.
+ *
+ * @param {number} hours - The hour component of the time.
+ * @param {number} minutes - The minute component of the time.
+ * @param {boolean} useLocale - Determines if the time should be formatted using the 12-hour format with AM/PM (`true`) or the 24-hour format (`false`).
+ * @returns {string} The formatted time as a string.
+ * @example
+ * // Format time using 24-hour format
+ * formatTime(14, 30, false); // "14:30"
+ *
+ * @example
+ * // Format time using 12-hour format with AM/PM
+ * formatTime(14, 30, true); // "2:30 PM"
+ */
+function formatTime(hours, minutes, useLocale) {
+    if (useLocale) {
+        const period = hours >= 12 ? 'PM' : 'AM';
+        const displayHours = hours % 12 === 0 ? 12 : hours % 12;
+        return `${displayHours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')} ${period}`;
+    }
+    else {
+        return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/timepicker/lib/utils/index.mjs

@@ -0,0 +1,3 @@
+export * from './generate-time-stamps';
+export * from './ngx-mask-helper';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY29tcG9uZW50cy90aW1lcGlja2VyL3NyYy9saWIvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9nZW5lcmF0ZS10aW1lLXN0YW1wcyc7XG5leHBvcnQgKiBmcm9tICcuL25neC1tYXNrLWhlbHBlcic7XG4iXX0=

package/esm2022/components/timepicker/lib/utils/ngx-mask-helper.mjs

@@ -0,0 +1,34 @@
+/**
+ * Processes and formats a time input value based on specific rules. It adjusts the input for valid time format,
+ * especially focusing on single-digit hour inputs, ensuring minute values start with 0 if the last digit is greater
+ * than 5, and appending 'M' to AM/PM indicators.
+ *
+ * @param {string} value - The current input value of the time field.
+ * @param {InputEvent} event - The input event triggered by the user's interaction with the field.
+ * @returns {string} The processed and potentially reformatted value.
+ *
+ * @example
+ * // Prepend 0 to single-digit hours greater than 1
+ * processInputValue("2", { inputType: "insertText" }); // Returns "02"
+ *
+ * @example
+ * // Ensure minute values are within valid ranges
+ * processInputValue("11:8", { inputType: "insertText" }); // Returns "11:08"
+ *
+ * @example
+ * // Append 'M' to AM/PM indicators
+ * processInputValue("2 p", { inputType: "insertText" }); // Returns "2 PM"
+ */
+export function processInputValue(value, event) {
+    if (value.length === 1 && Number(value) > 1) {
+        value = `0${value}`;
+    }
+    else if (value.length === 4 && Number(value.at(-1)) > 5) {
+        value = `${value.slice(0, -1)}0${value.slice(-1)}`;
+    }
+    if (/[AaPp]/.test(value) && event.inputType === 'insertText') {
+        value = `${value.toUpperCase()}M`;
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/timepicker/odx-angular-components-timepicker.mjs

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

package/esm2022/localization/lib/localization.config.mjs

@@ -1,10 +1,11 @@
 import { APP_INITIALIZER, makeEnvironmentProviders } from '@angular/core';
-import { createConfigTokens } from '@odx/angular/utils';
+import { createConfigTokens, getLanguageCode } from '@odx/angular/utils';
 import { LocalizationService } from './localization.service';
-export const DEFAULT_AVAILABLE_LANGUAGES = ['en', 'de', 'es', 'fr', 'ja'];
+export const DEFAULT_AVAILABLE_LOCALES = ['en-US', 'en-GB', 'de-DE', 'es-ES', 'fr-FR', 'fr-CA'];
+export const DEFAULT_AVAILABLE_LANGUAGES = Array.from(new Set(DEFAULT_AVAILABLE_LOCALES.map(getLanguageCode)));
 export const { LocalizationConfig, LocalizationDefaultConfig, injectLocalizationConfig, provideLocalizationConfig } = createConfigTokens('Localization', '@odx/angular/internal/translate', {
     availableLanguages: DEFAULT_AVAILABLE_LANGUAGES,
-    availableLocales: DEFAULT_AVAILABLE_LANGUAGES,
+    availableLocales: DEFAULT_AVAILABLE_LOCALES,
 });
 export function provideLocalization(config, ...features) {
     return makeEnvironmentProviders([
@@ -18,4 +19,4 @@ export function provideLocalization(config, ...features) {
         features,
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemF0aW9uLmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci9sb2NhbGl6YXRpb24vc3JjL2xpYi9sb2NhbGl6YXRpb24uY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQXdCLHdCQUF3QixFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ2hHLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxlQUFlLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN6RSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUc3RCxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBRyxDQUFDLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDaEcsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLEdBQUcsQ0FBQyx5QkFBeUIsQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBUS9HLE1BQU0sQ0FBQyxNQUFNLEVBQUUsa0JBQWtCLEVBQUUseUJBQXlCLEVBQUUsd0JBQXdCLEVBQUUseUJBQXlCLEVBQUUsR0FBRyxrQkFBa0IsQ0FDdEksY0FBYyxFQUNkLGlDQUFpQyxFQUNqQztJQUNFLGtCQUFrQixFQUFFLDJCQUEyQjtJQUMvQyxnQkFBZ0IsRUFBRSx5QkFBeUI7Q0FDdEIsQ0FDeEIsQ0FBQztBQUVGLE1BQU0sVUFBVSxtQkFBbUIsQ0FBQyxNQUFtQyxFQUFFLEdBQUcsUUFBK0I7SUFDekcsT0FBTyx3QkFBd0IsQ0FBQztRQUM5Qix5QkFBeUIsQ0FBQyxNQUFNLENBQUM7UUFDakM7WUFDRSxPQUFPLEVBQUUsZUFBZTtZQUN4QixVQUFVLEVBQUUsQ0FBQyxtQkFBd0MsRUFBRSxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsbUJBQW1CLENBQUMsa0JBQWtCLEVBQUU7WUFDeEcsSUFBSSxFQUFFLENBQUMsbUJBQW1CLENBQUM7WUFDM0IsS0FBSyxFQUFFLElBQUk7U0FDWjtRQUNELFFBQVE7S0FDVCxDQUFDLENBQUM7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQVBQX0lOSVRJQUxJWkVSLCBFbnZpcm9ubWVudFByb3ZpZGVycywgbWFrZUVudmlyb25tZW50UHJvdmlkZXJzIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBjcmVhdGVDb25maWdUb2tlbnMsIGdldExhbmd1YWdlQ29kZSB9IGZyb20gJ0BvZHgvYW5ndWxhci91dGlscyc7XG5pbXBvcnQgeyBMb2NhbGl6YXRpb25TZXJ2aWNlIH0gZnJvbSAnLi9sb2NhbGl6YXRpb24uc2VydmljZSc7XG5pbXBvcnQgeyBMYW5ndWFnZUxvYWRlckZuLCBMb2NhbGl6YXRpb25GZWF0dXJlIH0gZnJvbSAnLi9tb2RlbHMnO1xuXG5leHBvcnQgY29uc3QgREVGQVVMVF9BVkFJTEFCTEVfTE9DQUxFUyA9IFsnZW4tVVMnLCAnZW4tR0InLCAnZGUtREUnLCAnZXMtRVMnLCAnZnItRlInLCAnZnItQ0EnXTtcbmV4cG9ydCBjb25zdCBERUZBVUxUX0FWQUlMQUJMRV9MQU5HVUFHRVMgPSBBcnJheS5mcm9tKG5ldyBTZXQoREVGQVVMVF9BVkFJTEFCTEVfTE9DQUxFUy5tYXAoZ2V0TGFuZ3VhZ2VDb2RlKSkpO1xuXG5leHBvcnQgaW50ZXJmYWNlIExvY2FsaXphdGlvbkNvbmZpZyB7XG4gIGFjdGl2ZUxhbmd1YWdlTG9hZGVyPzogTGFuZ3VhZ2VMb2FkZXJGbjtcbiAgYXZhaWxhYmxlTGFuZ3VhZ2VzOiBzdHJpbmdbXTtcbiAgYXZhaWxhYmxlTG9jYWxlczogc3RyaW5nW107XG59XG5cbmV4cG9ydCBjb25zdCB7IExvY2FsaXphdGlvbkNvbmZpZywgTG9jYWxpemF0aW9uRGVmYXVsdENvbmZpZywgaW5qZWN0TG9jYWxpemF0aW9uQ29uZmlnLCBwcm92aWRlTG9jYWxpemF0aW9uQ29uZmlnIH0gPSBjcmVhdGVDb25maWdUb2tlbnMoXG4gICdMb2NhbGl6YXRpb24nLFxuICAnQG9keC9hbmd1bGFyL2ludGVybmFsL3RyYW5zbGF0ZScsXG4gIHtcbiAgICBhdmFpbGFibGVMYW5ndWFnZXM6IERFRkFVTFRfQVZBSUxBQkxFX0xBTkdVQUdFUyxcbiAgICBhdmFpbGFibGVMb2NhbGVzOiBERUZBVUxUX0FWQUlMQUJMRV9MT0NBTEVTLFxuICB9IGFzIExvY2FsaXphdGlvbkNvbmZpZyxcbik7XG5cbmV4cG9ydCBmdW5jdGlvbiBwcm92aWRlTG9jYWxpemF0aW9uKGNvbmZpZzogUGFydGlhbDxMb2NhbGl6YXRpb25Db25maWc+LCAuLi5mZWF0dXJlczogTG9jYWxpemF0aW9uRmVhdHVyZVtdKTogRW52aXJvbm1lbnRQcm92aWRlcnMge1xuICByZXR1cm4gbWFrZUVudmlyb25tZW50UHJvdmlkZXJzKFtcbiAgICBwcm92aWRlTG9jYWxpemF0aW9uQ29uZmlnKGNvbmZpZyksXG4gICAge1xuICAgICAgcHJvdmlkZTogQVBQX0lOSVRJQUxJWkVSLFxuICAgICAgdXNlRmFjdG9yeTogKGxvY2FsaXphdGlvblNlcnZpY2U6IExvY2FsaXphdGlvblNlcnZpY2UpID0+ICgpID0+IGxvY2FsaXphdGlvblNlcnZpY2UubG9hZEFjdGl2ZUxhbmd1YWdlKCksXG4gICAgICBkZXBzOiBbTG9jYWxpemF0aW9uU2VydmljZV0sXG4gICAgICBtdWx0aTogdHJ1ZSxcbiAgICB9LFxuICAgIGZlYXR1cmVzLFxuICBdKTtcbn1cbiJdfQ==