@koobiq/components 18.35.0 → 18.36.0

package/esm2022/time-range/time-range-title-as-form-field.mjs

@@ -0,0 +1,59 @@
+import { ChangeDetectionStrategy, Component, Directive, inject } from '@angular/core';
+import { KbqFormFieldControl } from '@koobiq/components/form-field';
+import { Subject } from 'rxjs';
+import { KbqTimeRange } from './time-range';
+import * as i0 from "@angular/core";
+/** Directive for easy using styles of time-range placeholder publicly. */
+export class KbqTimeRangeTitlePlaceholder {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRangeTitlePlaceholder, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: KbqTimeRangeTitlePlaceholder, isStandalone: true, selector: "[kbqTimeRangeTitlePlaceholder]", host: { classAttribute: "kbq-time-range-title__placeholder" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRangeTitlePlaceholder, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[kbqTimeRangeTitlePlaceholder]',
+                    host: {
+                        class: 'kbq-time-range-title__placeholder'
+                    }
+                }]
+        }] });
+/** Component simulates `KbqFormFieldControl` allowing to provide custom content inside `KbqFormField` */
+export class KbqTimeRangeTitleAsControl {
+    constructor() {
+        this.timeRange = inject(KbqTimeRange);
+        this.controlType = 'select';
+        /** @docs-private */
+        this.stateChanges = new Subject();
+        /** @docs-private */
+        this.ngControl = this.timeRange.ngControl;
+    }
+    /** @docs-private */
+    onContainerClick(_event) { }
+    /** @docs-private */
+    focus(_options) { }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRangeTitleAsControl, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: KbqTimeRangeTitleAsControl, isStandalone: true, selector: "kbq-time-range-title-as-control", host: { properties: { "attr.tabindex": "0" }, classAttribute: "kbq-time-range-title-as-form-field" }, providers: [
+            {
+                provide: KbqFormFieldControl,
+                useExisting: KbqTimeRangeTitleAsControl
+            }
+        ], ngImport: i0, template: `
+        <ng-content />
+    `, isInline: true, styles: [":host{display:flex;align-items:center}:host:focus-visible{outline:none}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRangeTitleAsControl, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'kbq-time-range-title-as-control', template: `
+        <ng-content />
+    `, providers: [
+                        {
+                            provide: KbqFormFieldControl,
+                            useExisting: KbqTimeRangeTitleAsControl
+                        }
+                    ], host: {
+                        '[attr.tabindex]': '0',
+                        class: 'kbq-time-range-title-as-form-field'
+                    }, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:flex;align-items:center}:host:focus-visible{outline:none}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/time-range/time-range-title.mjs

@@ -0,0 +1,112 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, computed, inject, Injector, input } from '@angular/core';
+import { KbqIconModule } from '@koobiq/components/icon';
+import { KbqLinkModule } from '@koobiq/components/link';
+import { KbqPopoverTrigger } from '@koobiq/components/popover';
+import { KbqTimeRangeService } from './time-range.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@koobiq/components/link";
+import * as i2 from "@koobiq/components/icon";
+/** @docs-private */
+export class KbqTimeRangeTitle {
+    constructor() {
+        this.timeRangeService = inject(KbqTimeRangeService);
+        this.popover = inject(KbqPopoverTrigger, { host: true });
+        this.injector = inject(Injector);
+        this.timeRange = input.required();
+        this.localeConfiguration = input.required();
+        this.titleTemplate = input();
+        this.context = computed(() => {
+            const timeRange = this.timeRange();
+            if (!timeRange)
+                return undefined;
+            return {
+                ...timeRange,
+                ...this.timeRangeService.getTimeRangeTypeUnits(timeRange.type)
+            };
+        });
+        this.titleContext = computed(() => {
+            const context = this.context();
+            const formattedDate = this.formattedDate();
+            let customizableTitleContext = { formattedDate, popover: this.popover };
+            if (context) {
+                customizableTitleContext = { ...context, ...customizableTitleContext };
+            }
+            return {
+                $implicit: customizableTitleContext,
+                ...customizableTitleContext
+            };
+        });
+        this.formattedDate = computed(() => {
+            const context = this.context();
+            const localeConfiguration = this.localeConfiguration();
+            if (!context) {
+                return localeConfiguration.title.placeholder;
+            }
+            const timeRangeUnit = this.timeRangeService.getTimeRangeUnitByType(context.type);
+            if (timeRangeUnit === 'other') {
+                switch (context.type) {
+                    case 'range': {
+                        return (localeConfiguration.title.for +
+                            ' ' +
+                            this.timeRangeService.dateFormatter.rangeLongDate(this.timeRangeService.dateAdapter.deserialize(context.startDateTime ?? ''), this.timeRangeService.dateAdapter.deserialize(context.endDateTime ?? '')));
+                    }
+                    case 'allTime': {
+                        return localeConfiguration.editor.allTime;
+                    }
+                    case 'currentQuarter': {
+                        return localeConfiguration.editor.currentQuarter;
+                    }
+                    case 'currentYear': {
+                        return localeConfiguration.editor.currentYear;
+                    }
+                    default: {
+                        return '';
+                    }
+                }
+            }
+            if (!context.startDateTime)
+                return '';
+            return (localeConfiguration.title.for +
+                ' ' +
+                this.timeRangeService.dateFormatter.duration(this.timeRangeService.dateAdapter.deserialize(context.startDateTime), this.timeRangeService.dateAdapter.today(), [timeRangeUnit], false, localeConfiguration.durationTemplate.title));
+        });
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRangeTitle, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: KbqTimeRangeTitle, isStandalone: true, selector: "kbq-time-range-title", inputs: { timeRange: { classPropertyName: "timeRange", publicName: "timeRange", isSignal: true, isRequired: true, transformFunction: null }, localeConfiguration: { classPropertyName: "localeConfiguration", publicName: "localeConfiguration", isSignal: true, isRequired: true, transformFunction: null }, titleTemplate: { classPropertyName: "titleTemplate", publicName: "titleTemplate", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+        @if (titleTemplate()) {
+            <ng-container *ngTemplateOutlet="titleTemplate()!; context: titleContext() ?? null; injector: injector" />
+        } @else {
+            <a kbq-link pseudo>
+                <span class="kbq-link__text">{{ formattedDate() }}</span>
+
+                <i kbq-icon="kbq-calendar-o_16"></i>
+            </a>
+        }
+    `, isInline: true, dependencies: [{ kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: KbqLinkModule }, { kind: "directive", type: i1.KbqLink, selector: "[kbq-link]", inputs: ["disabled", "tabIndex", "pseudo", "noUnderline", "big", "compact", "useVisited", "print"], exportAs: ["kbqLink"] }, { kind: "ngmodule", type: KbqIconModule }, { kind: "component", type: i2.KbqIcon, selector: "[kbq-icon]", inputs: ["small", "autoColor", "kbq-icon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRangeTitle, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'kbq-time-range-title',
+                    imports: [
+                        NgTemplateOutlet,
+                        KbqLinkModule,
+                        KbqIconModule
+                    ],
+                    template: `
+        @if (titleTemplate()) {
+            <ng-container *ngTemplateOutlet="titleTemplate()!; context: titleContext() ?? null; injector: injector" />
+        } @else {
+            <a kbq-link pseudo>
+                <span class="kbq-link__text">{{ formattedDate() }}</span>
+
+                <i kbq-icon="kbq-calendar-o_16"></i>
+            </a>
+        }
+    `,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-range-title.js","sourceRoot":"","sources":["../../../../packages/components/time-range/time-range-title.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAe,MAAM,eAAe,CAAC;AAEnH,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;;;;AAG3D,oBAAoB;AAsBpB,MAAM,OAAO,iBAAiB;IArB9B;QAsBqB,qBAAgB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;QAC/C,YAAO,GAAG,MAAM,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAClD,aAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEtC,cAAS,GAAG,KAAK,CAAC,QAAQ,EAA4B,CAAC;QACvD,wBAAmB,GAAG,KAAK,CAAC,QAAQ,EAA4B,CAAC;QACjE,kBAAa,GAAG,KAAK,EAAoB,CAAC;QAEhC,YAAO,GAAG,QAAQ,CAAuC,GAAG,EAAE;YAC7E,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAEnC,IAAI,CAAC,SAAS;gBAAE,OAAO,SAAS,CAAC;YAEjC,OAAO;gBACH,GAAG,SAAS;gBACZ,GAAG,IAAI,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,SAAS,CAAC,IAAI,CAAC;aACjE,CAAC;QACN,CAAC,CAAC,CAAC;QAEgB,iBAAY,GAAG,QAAQ,CAAmD,GAAG,EAAE;YAC9F,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAC/B,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YAE3C,IAAI,wBAAwB,GAAG,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;YAExE,IAAI,OAAO,EAAE,CAAC;gBACV,wBAAwB,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,wBAAwB,EAAE,CAAC;YAC3E,CAAC;YAED,OAAO;gBACH,SAAS,EAAE,wBAAwB;gBACnC,GAAG,wBAAwB;aAC9B,CAAC;QACN,CAAC,CAAC,CAAC;QAEgB,kBAAa,GAAG,QAAQ,CAAC,GAAG,EAAE;YAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAC/B,MAAM,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAEvD,IAAI,CAAC,OAAO,EAAE,CAAC;gBACX,OAAO,mBAAmB,CAAC,KAAK,CAAC,WAAW,CAAC;YACjD,CAAC;YAED,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAEjF,IAAI,aAAa,KAAK,OAAO,EAAE,CAAC;gBAC5B,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;oBACnB,KAAK,OAAO,CAAC,CAAC,CAAC;wBACX,OAAO,CACH,mBAAmB,CAAC,KAAK,CAAC,GAAG;4BAC7B,GAAG;4BACH,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,aAAa,CAC7C,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,aAAa,IAAI,EAAE,CAAC,EAC1E,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,WAAW,IAAI,EAAE,CAAC,CAC3E,CACJ,CAAC;oBACN,CAAC;oBACD,KAAK,SAAS,CAAC,CAAC,CAAC;wBACb,OAAO,mBAAmB,CAAC,MAAM,CAAC,OAAO,CAAC;oBAC9C,CAAC;oBACD,KAAK,gBAAgB,CAAC,CAAC,CAAC;wBACpB,OAAO,mBAAmB,CAAC,MAAM,CAAC,cAAc,CAAC;oBACrD,CAAC;oBACD,KAAK,aAAa,CAAC,CAAC,CAAC;wBACjB,OAAO,mBAAmB,CAAC,MAAM,CAAC,WAAW,CAAC;oBAClD,CAAC;oBACD,OAAO,CAAC,CAAC,CAAC;wBACN,OAAO,EAAE,CAAC;oBACd,CAAC;gBACL,CAAC;YACL,CAAC;YAED,IAAI,CAAC,OAAO,CAAC,aAAa;gBAAE,OAAO,EAAE,CAAC;YAEtC,OAAO,CACH,mBAAmB,CAAC,KAAK,CAAC,GAAG;gBAC7B,GAAG;gBACH,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,QAAQ,CACxC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,aAAa,CAAC,EACpE,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,KAAK,EAAE,EACzC,CAAC,aAAa,CAAC,EACf,KAAK,EACL,mBAAmB,CAAC,gBAAgB,CAAC,KAAK,CAC7C,CACJ,CAAC;QACN,CAAC,CAAC,CAAC;KACN;kIAvFY,iBAAiB;sHAAjB,iBAAiB,ghBAbhB;;;;;;;;;;KAUT,4DAdG,gBAAgB,mJAChB,aAAa,0NACb,aAAa;;4FAeR,iBAAiB;kBArB7B,SAAS;mBAAC;oBACP,UAAU,EAAE,IAAI;oBAChB,QAAQ,EAAE,sBAAsB;oBAChC,OAAO,EAAE;wBACL,gBAAgB;wBAChB,aAAa;wBACb,aAAa;qBAChB;oBACD,QAAQ,EAAE;;;;;;;;;;KAUT;oBACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;iBAClD","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport { ChangeDetectionStrategy, Component, computed, inject, Injector, input, TemplateRef } from '@angular/core';\nimport { KbqTimeRangeLocaleConfig } from '@koobiq/components/core';\nimport { KbqIconModule } from '@koobiq/components/icon';\nimport { KbqLinkModule } from '@koobiq/components/link';\nimport { KbqPopoverTrigger } from '@koobiq/components/popover';\nimport { KbqTimeRangeService } from './time-range.service';\nimport { KbqTimeRangeCustomizableTitleContext, KbqTimeRangeRange, KbqTimeRangeTitleContext } from './types';\n\n/** @docs-private */\n@Component({\n    standalone: true,\n    selector: 'kbq-time-range-title',\n    imports: [\n        NgTemplateOutlet,\n        KbqLinkModule,\n        KbqIconModule\n    ],\n    template: `\n        @if (titleTemplate()) {\n            <ng-container *ngTemplateOutlet=\"titleTemplate()!; context: titleContext() ?? null; injector: injector\" />\n        } @else {\n            <a kbq-link pseudo>\n                <span class=\"kbq-link__text\">{{ formattedDate() }}</span>\n\n                <i kbq-icon=\"kbq-calendar-o_16\"></i>\n            </a>\n        }\n    `,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class KbqTimeRangeTitle {\n    private readonly timeRangeService = inject(KbqTimeRangeService);\n    private readonly popover = inject(KbqPopoverTrigger, { host: true });\n    protected readonly injector = inject(Injector);\n\n    readonly timeRange = input.required<KbqTimeRangeRange | null>();\n    readonly localeConfiguration = input.required<KbqTimeRangeLocaleConfig>();\n    readonly titleTemplate = input<TemplateRef<any>>();\n\n    protected readonly context = computed<KbqTimeRangeTitleContext | undefined>(() => {\n        const timeRange = this.timeRange();\n\n        if (!timeRange) return undefined;\n\n        return {\n            ...timeRange,\n            ...this.timeRangeService.getTimeRangeTypeUnits(timeRange.type)\n        };\n    });\n\n    protected readonly titleContext = computed<KbqTimeRangeCustomizableTitleContext | undefined>(() => {\n        const context = this.context();\n        const formattedDate = this.formattedDate();\n\n        let customizableTitleContext = { formattedDate, popover: this.popover };\n\n        if (context) {\n            customizableTitleContext = { ...context, ...customizableTitleContext };\n        }\n\n        return {\n            $implicit: customizableTitleContext,\n            ...customizableTitleContext\n        };\n    });\n\n    protected readonly formattedDate = computed(() => {\n        const context = this.context();\n        const localeConfiguration = this.localeConfiguration();\n\n        if (!context) {\n            return localeConfiguration.title.placeholder;\n        }\n\n        const timeRangeUnit = this.timeRangeService.getTimeRangeUnitByType(context.type);\n\n        if (timeRangeUnit === 'other') {\n            switch (context.type) {\n                case 'range': {\n                    return (\n                        localeConfiguration.title.for +\n                        ' ' +\n                        this.timeRangeService.dateFormatter.rangeLongDate(\n                            this.timeRangeService.dateAdapter.deserialize(context.startDateTime ?? ''),\n                            this.timeRangeService.dateAdapter.deserialize(context.endDateTime ?? '')\n                        )\n                    );\n                }\n                case 'allTime': {\n                    return localeConfiguration.editor.allTime;\n                }\n                case 'currentQuarter': {\n                    return localeConfiguration.editor.currentQuarter;\n                }\n                case 'currentYear': {\n                    return localeConfiguration.editor.currentYear;\n                }\n                default: {\n                    return '';\n                }\n            }\n        }\n\n        if (!context.startDateTime) return '';\n\n        return (\n            localeConfiguration.title.for +\n            ' ' +\n            this.timeRangeService.dateFormatter.duration(\n                this.timeRangeService.dateAdapter.deserialize(context.startDateTime),\n                this.timeRangeService.dateAdapter.today(),\n                [timeRangeUnit],\n                false,\n                localeConfiguration.durationTemplate.title\n            )\n        );\n    });\n}\n"]}

package/esm2022/time-range/time-range.mjs

@@ -0,0 +1,229 @@
+import { booleanAttribute, ChangeDetectionStrategy, Component, computed, inject, InjectionToken, input, output, signal, ViewEncapsulation } from '@angular/core';
+import { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';
+import { FormControl, NgControl, ReactiveFormsModule } from '@angular/forms';
+import { KbqButtonModule } from '@koobiq/components/button';
+import { KBQ_LOCALE_SERVICE, PopUpPlacements, PopUpSizes, ruRULocaleData } from '@koobiq/components/core';
+import { KbqPopoverModule } from '@koobiq/components/popover';
+import { KbqTimeRangeEditor } from './time-range-editor';
+import { KbqTimeRangeTitle } from './time-range-title';
+import { KbqTimeRangeService } from './time-range.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@koobiq/components/popover";
+import * as i3 from "@koobiq/components/button";
+/** Localization configuration provider. */
+export const KBQ_TIME_RANGE_LOCALE_CONFIGURATION = new InjectionToken('KBQ_TIME_RANGE_LOCALE_CONFIGURATION', { factory: () => ruRULocaleData.timeRange });
+/** Utility provider for `KBQ_TIME_RANGE_LOCALE_CONFIGURATION`. */
+export const kbqTimeRangeLocaleConfigurationProvider = (configuration) => ({
+    provide: KBQ_TIME_RANGE_LOCALE_CONFIGURATION,
+    useValue: configuration
+});
+export class KbqTimeRange {
+    constructor() {
+        this.timeRangeService = inject(KbqTimeRangeService);
+        this.localeService = inject(KBQ_LOCALE_SERVICE, { optional: true });
+        this.ngControl = inject(NgControl, { optional: true, self: true });
+        /** The minimum selectable date. */
+        this.minDate = input();
+        /** The maximum selectable date. */
+        this.maxDate = input();
+        /** provided value of selected range */
+        this.defaultRangeValue = input();
+        /** Preset of selectable ranges */
+        this.availableTimeRangeTypes = input(this.timeRangeService.providedDefaultTimeRangeTypes);
+        /** Customizable trigger output */
+        this.titleTemplate = input();
+        /** Whether to show popover with arrow */
+        this.arrow = input(true, { transform: booleanAttribute });
+        /**
+         * Whether to show range in popover if not provided
+         * @see availableTimeRangeTypes
+         */
+        this.showRangeAsDefault = input(true);
+        /** Whether component should fallback to default value if null provided */
+        this.nonNullable = input(true, { transform: booleanAttribute });
+        /** Emit value update if provided value via formControl wasn't valid */
+        this.valueCorrected = output();
+        /**
+         * Used to calculate time range.
+         * @docs-private */
+        this.normalizedDefaultRangeValue = computed(() => ({
+            ...this.timeRangeService.getDefaultRangeValue(),
+            ...this.defaultRangeValue()
+        }));
+        /** @docs-private */
+        this.popoverSize = PopUpSizes.Medium;
+        /** @docs-private */
+        this.popupPlacement = PopUpPlacements.BottomLeft;
+        /** @docs-private */
+        this.localeConfiguration = signal(inject(KBQ_TIME_RANGE_LOCALE_CONFIGURATION));
+        /** @docs-private */
+        this.onChange = (_value) => { };
+        /** @docs-private */
+        this.onTouch = () => { };
+        this.handleAvailableTypesChange = (types) => {
+            if (types.includes(this.rangeEditorControl.value.type) || this.rangeEditorControl.value.type === 'range') {
+                return;
+            }
+            const timeRangeDefaultValue = this.timeRangeService.getTimeRangeDefaultValue(this.normalizedDefaultRangeValue(), types.length ? types : ['range']);
+            this.titleValue.set(timeRangeDefaultValue);
+            this.rangeEditorControl.setValue(timeRangeDefaultValue);
+            this.onChange(timeRangeDefaultValue);
+        };
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+        const defaultValue = this.timeRangeService.getTimeRangeDefaultValue(this.normalizedDefaultRangeValue(), this.availableTimeRangeTypes());
+        this.titleValue = signal(this.nonNullable() ? defaultValue : null);
+        this.rangeEditorControl = new FormControl(defaultValue, { nonNullable: true });
+        this.localeService?.changes.pipe(takeUntilDestroyed()).subscribe(() => {
+            this.localeConfiguration.set(this.localeService?.getParams('timeRange') ?? ruRULocaleData.timeRange);
+        });
+        toObservable(this.availableTimeRangeTypes)
+            .pipe(takeUntilDestroyed())
+            .subscribe(this.handleAvailableTypesChange);
+    }
+    ngOnInit() {
+        // call again on init, so input signals values will be correct
+        this.writeValue(this.ngControl?.value ?? null);
+    }
+    /** Implemented as part of ControlValueAccessor */
+    writeValue(value) {
+        const nonNullable = this.nonNullable();
+        const availableTimeRangeTypes = this.availableTimeRangeTypes();
+        const corrected = this.timeRangeService.checkAndCorrectTimeRangeValue(value, availableTimeRangeTypes, this.normalizedDefaultRangeValue());
+        if ((value && value.type && !('startDateTime' in value && availableTimeRangeTypes.includes(value.type))) ||
+            (nonNullable && value === null)) {
+            this.valueCorrected.emit(corrected);
+        }
+        this.titleValue.set(nonNullable || value !== null ? corrected : null);
+        this.rangeEditorControl.setValue(corrected);
+    }
+    /** @docs-private */
+    onApply(popover) {
+        this.titleValue.set(this.rangeEditorControl.value);
+        this.onChange(this.rangeEditorControl.value);
+        popover.hide();
+    }
+    /** @docs-private */
+    onCancel(popover) {
+        popover.hide();
+    }
+    onVisibleChange(isVisible) {
+        const titleValue = this.titleValue();
+        if (!isVisible && titleValue) {
+            this.rangeEditorControl.setValue(titleValue);
+        }
+    }
+    /** Implemented as part of ControlValueAccessor */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /** Implemented as part of ControlValueAccessor */
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRange, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: KbqTimeRange, isStandalone: true, selector: "kbq-time-range", inputs: { minDate: { classPropertyName: "minDate", publicName: "minDate", isSignal: true, isRequired: false, transformFunction: null }, maxDate: { classPropertyName: "maxDate", publicName: "maxDate", isSignal: true, isRequired: false, transformFunction: null }, defaultRangeValue: { classPropertyName: "defaultRangeValue", publicName: "defaultRangeValue", isSignal: true, isRequired: false, transformFunction: null }, availableTimeRangeTypes: { classPropertyName: "availableTimeRangeTypes", publicName: "availableTimeRangeTypes", isSignal: true, isRequired: false, transformFunction: null }, titleTemplate: { classPropertyName: "titleTemplate", publicName: "titleTemplate", isSignal: true, isRequired: false, transformFunction: null }, arrow: { classPropertyName: "arrow", publicName: "arrow", isSignal: true, isRequired: false, transformFunction: null }, showRangeAsDefault: { classPropertyName: "showRangeAsDefault", publicName: "showRangeAsDefault", isSignal: true, isRequired: false, transformFunction: null }, nonNullable: { classPropertyName: "nonNullable", publicName: "nonNullable", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { valueCorrected: "valueCorrected" }, host: { classAttribute: "kbq-time-range" }, providers: [KbqTimeRangeService], ngImport: i0, template: `
+        @let localeConfig = localeConfiguration();
+        <kbq-time-range-title
+            #popover="kbqPopover"
+            class="kbq-time-range__trigger"
+            kbqPopover
+            kbqPopoverClass="kbq-time-range__popover"
+            [kbqPopoverSize]="popoverSize"
+            [kbqPopoverContent]="timeRangePopoverContent"
+            [kbqPopoverFooter]="timeRangePopoverFooter"
+            [kbqPopoverPlacement]="popupPlacement"
+            [kbqPopoverArrow]="arrow()"
+            [titleTemplate]="titleTemplate()"
+            [timeRange]="titleValue()"
+            [localeConfiguration]="localeConfig"
+            (kbqPopoverVisibleChange)="onVisibleChange($event)"
+        />
+
+        <ng-template #timeRangePopoverContent>
+            <kbq-time-range-editor
+                [maxDate]="maxDate()"
+                [minDate]="minDate()"
+                [formControl]="rangeEditorControl"
+                [localeConfiguration]="localeConfig"
+                [showRangeAsDefault]="showRangeAsDefault()"
+                [rangeValue]="normalizedDefaultRangeValue()"
+                [availableTimeRangeTypes]="availableTimeRangeTypes()"
+            />
+        </ng-template>
+
+        <ng-template #timeRangePopoverFooter>
+            <div class="kbq-time-range__buttons" role="group">
+                <button
+                    kbq-button
+                    [color]="'contrast'"
+                    [disabled]="rangeEditorControl.invalid"
+                    (click)="onApply(popover)"
+                >
+                    {{ localeConfig.editor.apply }}
+                </button>
+
+                <button kbq-button (click)="onCancel(popover)">{{ localeConfig.editor.cancel }}</button>
+            </div>
+        </ng-template>
+    `, isInline: true, styles: [".kbq-time-range .kbq-time-range__trigger{display:block}.kbq-time-range__popover .kbq-time-range__buttons{display:flex;flex-direction:row;gap:var(--kbq-size-l)}.kbq-time-range__editor{display:block}.kbq-time-range__editor .kbq-time-range-editor__container{width:100%}.kbq-time-range__editor .kbq-time-range-editor__predefined{column-count:2}.kbq-time-range__editor .kbq-time-range-editor__predefined .kbq-time-range-editor__predefined-option{display:block;margin-bottom:var(--kbq-size-s)}.kbq-time-range__editor .kbq-time-range-editor__range{display:flex;flex-direction:column;gap:var(--kbq-size-s)}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__predefined{column-count:2}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__predefined .kbq-time-range-editor__predefined-option{display:block}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__date-time{display:flex;flex-direction:row;justify-content:space-between;gap:var(--kbq-size-s)}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__date-time .kbq-time-range-editor__date-time-prefix{align-self:center;width:57px}.kbq-time-range-title-as-form-field{white-space:nowrap;text-overflow:ellipsis;min-height:calc(var(--kbq-form-field-size-height) - 2 * var(--kbq-size-border-width))}.kbq-time-range-title-as-form-field .kbq-time-range-title__placeholder{color:var(--kbq-foreground-contrast-tertiary)}\n"], dependencies: [{ kind: "ngmodule", type: ReactiveFormsModule }, { 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: KbqPopoverModule }, { kind: "directive", type: i2.KbqPopoverTrigger, selector: "[kbqPopover]", inputs: ["kbqPopoverPreventClose", "defaultPaddings", "kbqPopoverVisible", "kbqPopoverPlacement", "kbqPopoverPlacementPriority", "hasBackdrop", "kbqPopoverHeader", "kbqPopoverContent", "kbqPopoverFooter", "kbqPopoverDisabled", "kbqTrigger", "kbqPopoverSize", "kbqPopoverClass", "hasCloseButton", "closeOnScroll", "backdropClass", "kbqPopoverArrow", "kbqPopoverOffset", "kbqLeaveDelay"], outputs: ["kbqPopoverPlacementChange", "kbqPopoverVisibleChange"], exportAs: ["kbqPopover"] }, { kind: "ngmodule", type: KbqButtonModule }, { kind: "component", type: i3.KbqButton, selector: "[kbq-button]", inputs: ["kbqStyle", "disabled", "tabIndex"] }, { kind: "directive", type: i3.KbqButtonCssStyler, selector: "[kbq-button]" }, { kind: "component", type: KbqTimeRangeEditor, selector: "kbq-time-range-editor", inputs: ["maxDate", "minDate", "availableTimeRangeTypes", "rangeValue", "showRangeAsDefault", "localeConfiguration"] }, { kind: "component", type: KbqTimeRangeTitle, selector: "kbq-time-range-title", inputs: ["timeRange", "localeConfiguration", "titleTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: KbqTimeRange, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'kbq-time-range', template: `
+        @let localeConfig = localeConfiguration();
+        <kbq-time-range-title
+            #popover="kbqPopover"
+            class="kbq-time-range__trigger"
+            kbqPopover
+            kbqPopoverClass="kbq-time-range__popover"
+            [kbqPopoverSize]="popoverSize"
+            [kbqPopoverContent]="timeRangePopoverContent"
+            [kbqPopoverFooter]="timeRangePopoverFooter"
+            [kbqPopoverPlacement]="popupPlacement"
+            [kbqPopoverArrow]="arrow()"
+            [titleTemplate]="titleTemplate()"
+            [timeRange]="titleValue()"
+            [localeConfiguration]="localeConfig"
+            (kbqPopoverVisibleChange)="onVisibleChange($event)"
+        />
+
+        <ng-template #timeRangePopoverContent>
+            <kbq-time-range-editor
+                [maxDate]="maxDate()"
+                [minDate]="minDate()"
+                [formControl]="rangeEditorControl"
+                [localeConfiguration]="localeConfig"
+                [showRangeAsDefault]="showRangeAsDefault()"
+                [rangeValue]="normalizedDefaultRangeValue()"
+                [availableTimeRangeTypes]="availableTimeRangeTypes()"
+            />
+        </ng-template>
+
+        <ng-template #timeRangePopoverFooter>
+            <div class="kbq-time-range__buttons" role="group">
+                <button
+                    kbq-button
+                    [color]="'contrast'"
+                    [disabled]="rangeEditorControl.invalid"
+                    (click)="onApply(popover)"
+                >
+                    {{ localeConfig.editor.apply }}
+                </button>
+
+                <button kbq-button (click)="onCancel(popover)">{{ localeConfig.editor.cancel }}</button>
+            </div>
+        </ng-template>
+    `, imports: [
+                        ReactiveFormsModule,
+                        KbqPopoverModule,
+                        KbqButtonModule,
+                        KbqTimeRangeEditor,
+                        KbqTimeRangeTitle
+                    ], host: {
+                        class: 'kbq-time-range'
+                    }, providers: [KbqTimeRangeService], changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, styles: [".kbq-time-range .kbq-time-range__trigger{display:block}.kbq-time-range__popover .kbq-time-range__buttons{display:flex;flex-direction:row;gap:var(--kbq-size-l)}.kbq-time-range__editor{display:block}.kbq-time-range__editor .kbq-time-range-editor__container{width:100%}.kbq-time-range__editor .kbq-time-range-editor__predefined{column-count:2}.kbq-time-range__editor .kbq-time-range-editor__predefined .kbq-time-range-editor__predefined-option{display:block;margin-bottom:var(--kbq-size-s)}.kbq-time-range__editor .kbq-time-range-editor__range{display:flex;flex-direction:column;gap:var(--kbq-size-s)}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__predefined{column-count:2}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__predefined .kbq-time-range-editor__predefined-option{display:block}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__date-time{display:flex;flex-direction:row;justify-content:space-between;gap:var(--kbq-size-s)}.kbq-time-range__editor .kbq-time-range-editor__range .kbq-time-range-editor__date-time .kbq-time-range-editor__date-time-prefix{align-self:center;width:57px}.kbq-time-range-title-as-form-field{white-space:nowrap;text-overflow:ellipsis;min-height:calc(var(--kbq-form-field-size-height) - 2 * var(--kbq-size-border-width))}.kbq-time-range-title-as-form-field .kbq-time-range-title__placeholder{color:var(--kbq-foreground-contrast-tertiary)}\n"] }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-range.js","sourceRoot":"","sources":["../../../../packages/components/time-range/time-range.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    booleanAttribute,\n    ChangeDetectionStrategy,\n    Component,\n    computed,\n    inject,\n    InjectionToken,\n    input,\n    OnInit,\n    output,\n    Provider,\n    signal,\n    TemplateRef,\n    ViewEncapsulation,\n    WritableSignal\n} from '@angular/core';\nimport { takeUntilDestroyed, toObservable } from '@angular/core/rxjs-interop';\nimport { ControlValueAccessor, FormControl, NgControl, ReactiveFormsModule } from '@angular/forms';\nimport { KbqButtonModule } from '@koobiq/components/button';\nimport {\n    KBQ_LOCALE_SERVICE,\n    KbqTimeRangeLocaleConfig,\n    PopUpPlacements,\n    PopUpSizes,\n    ruRULocaleData\n} from '@koobiq/components/core';\nimport { KbqPopoverModule, KbqPopoverTrigger } from '@koobiq/components/popover';\nimport { KbqTimeRangeEditor } from './time-range-editor';\nimport { KbqTimeRangeTitle } from './time-range-title';\nimport { KbqTimeRangeService } from './time-range.service';\nimport { KbqRangeValue, KbqTimeRangeCustomizableTitleContext, KbqTimeRangeRange, KbqTimeRangeType } from './types';\n\n/** Localization configuration provider. */\nexport const KBQ_TIME_RANGE_LOCALE_CONFIGURATION = new InjectionToken<KbqTimeRangeLocaleConfig>(\n    'KBQ_TIME_RANGE_LOCALE_CONFIGURATION',\n    { factory: () => ruRULocaleData.timeRange }\n);\n\n/** Utility provider for `KBQ_TIME_RANGE_LOCALE_CONFIGURATION`. */\nexport const kbqTimeRangeLocaleConfigurationProvider = (configuration: KbqTimeRangeLocaleConfig): Provider => ({\n    provide: KBQ_TIME_RANGE_LOCALE_CONFIGURATION,\n    useValue: configuration\n});\n\n@Component({\n    standalone: true,\n    selector: 'kbq-time-range',\n    template: `\n        @let localeConfig = localeConfiguration();\n        <kbq-time-range-title\n            #popover=\"kbqPopover\"\n            class=\"kbq-time-range__trigger\"\n            kbqPopover\n            kbqPopoverClass=\"kbq-time-range__popover\"\n            [kbqPopoverSize]=\"popoverSize\"\n            [kbqPopoverContent]=\"timeRangePopoverContent\"\n            [kbqPopoverFooter]=\"timeRangePopoverFooter\"\n            [kbqPopoverPlacement]=\"popupPlacement\"\n            [kbqPopoverArrow]=\"arrow()\"\n            [titleTemplate]=\"titleTemplate()\"\n            [timeRange]=\"titleValue()\"\n            [localeConfiguration]=\"localeConfig\"\n            (kbqPopoverVisibleChange)=\"onVisibleChange($event)\"\n        />\n\n        <ng-template #timeRangePopoverContent>\n            <kbq-time-range-editor\n                [maxDate]=\"maxDate()\"\n                [minDate]=\"minDate()\"\n                [formControl]=\"rangeEditorControl\"\n                [localeConfiguration]=\"localeConfig\"\n                [showRangeAsDefault]=\"showRangeAsDefault()\"\n                [rangeValue]=\"normalizedDefaultRangeValue()\"\n                [availableTimeRangeTypes]=\"availableTimeRangeTypes()\"\n            />\n        </ng-template>\n\n        <ng-template #timeRangePopoverFooter>\n            <div class=\"kbq-time-range__buttons\" role=\"group\">\n                <button\n                    kbq-button\n                    [color]=\"'contrast'\"\n                    [disabled]=\"rangeEditorControl.invalid\"\n                    (click)=\"onApply(popover)\"\n                >\n                    {{ localeConfig.editor.apply }}\n                </button>\n\n                <button kbq-button (click)=\"onCancel(popover)\">{{ localeConfig.editor.cancel }}</button>\n            </div>\n        </ng-template>\n    `,\n    styleUrls: ['./time-range.scss'],\n    imports: [\n        ReactiveFormsModule,\n        KbqPopoverModule,\n        KbqButtonModule,\n        KbqTimeRangeEditor,\n        KbqTimeRangeTitle\n    ],\n    host: {\n        class: 'kbq-time-range'\n    },\n    providers: [KbqTimeRangeService],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None\n})\nexport class KbqTimeRange<T> implements ControlValueAccessor, OnInit {\n    private readonly timeRangeService = inject<KbqTimeRangeService<T>>(KbqTimeRangeService);\n    private readonly localeService = inject(KBQ_LOCALE_SERVICE, { optional: true });\n    readonly ngControl = inject(NgControl, { optional: true, self: true });\n\n    /** The minimum selectable date. */\n    readonly minDate = input<T>();\n    /** The maximum selectable date. */\n    readonly maxDate = input<T>();\n    /** provided value of selected range */\n    readonly defaultRangeValue = input<KbqRangeValue<T>>();\n    /** Preset of selectable ranges */\n    readonly availableTimeRangeTypes = input<KbqTimeRangeType[]>(this.timeRangeService.providedDefaultTimeRangeTypes);\n    /** Customizable trigger output */\n    readonly titleTemplate = input<TemplateRef<KbqTimeRangeCustomizableTitleContext>>();\n    /** Whether to show popover with arrow */\n    readonly arrow = input(true, { transform: booleanAttribute });\n    /**\n     * Whether to show range in popover if not provided\n     * @see availableTimeRangeTypes\n     */\n    readonly showRangeAsDefault = input(true);\n    /** Whether component should fallback to default value if null provided */\n    readonly nonNullable = input(true, { transform: booleanAttribute });\n\n    /** Emit value update if provided value via formControl wasn't valid */\n    readonly valueCorrected = output<KbqTimeRangeRange>();\n\n    /**\n     * Used to calculate time range.\n     * @docs-private */\n    protected readonly normalizedDefaultRangeValue = computed(() => ({\n        ...this.timeRangeService.getDefaultRangeValue(),\n        ...this.defaultRangeValue()\n    }));\n\n    /** @docs-private */\n    protected readonly titleValue: WritableSignal<KbqTimeRangeRange | null>;\n    /** @docs-private */\n    protected readonly rangeEditorControl: FormControl<KbqTimeRangeRange>;\n\n    /** @docs-private */\n    protected readonly popoverSize = PopUpSizes.Medium;\n    /** @docs-private */\n    protected readonly popupPlacement = PopUpPlacements.BottomLeft;\n\n    /** @docs-private */\n    protected readonly localeConfiguration = signal(inject(KBQ_TIME_RANGE_LOCALE_CONFIGURATION));\n\n    constructor() {\n        if (this.ngControl) {\n            this.ngControl.valueAccessor = this;\n        }\n\n        const defaultValue = this.timeRangeService.getTimeRangeDefaultValue(\n            this.normalizedDefaultRangeValue(),\n            this.availableTimeRangeTypes()\n        );\n\n        this.titleValue = signal(this.nonNullable() ? defaultValue : null);\n        this.rangeEditorControl = new FormControl<KbqTimeRangeRange>(defaultValue, { nonNullable: true });\n\n        this.localeService?.changes.pipe(takeUntilDestroyed()).subscribe(() => {\n            this.localeConfiguration.set(this.localeService?.getParams('timeRange') ?? ruRULocaleData.timeRange);\n        });\n\n        toObservable(this.availableTimeRangeTypes)\n            .pipe(takeUntilDestroyed())\n            .subscribe(this.handleAvailableTypesChange);\n    }\n\n    ngOnInit(): void {\n        // call again on init, so input signals values will be correct\n        this.writeValue(this.ngControl?.value ?? null);\n    }\n\n    /** Implemented as part of ControlValueAccessor */\n    writeValue(value: KbqTimeRangeRange | null): void {\n        const nonNullable = this.nonNullable();\n\n        const availableTimeRangeTypes = this.availableTimeRangeTypes();\n\n        const corrected = this.timeRangeService.checkAndCorrectTimeRangeValue(\n            value,\n            availableTimeRangeTypes,\n            this.normalizedDefaultRangeValue()\n        );\n\n        if (\n            (value && value.type && !('startDateTime' in value && availableTimeRangeTypes.includes(value.type))) ||\n            (nonNullable && value === null)\n        ) {\n            this.valueCorrected.emit(corrected);\n        }\n\n        this.titleValue.set(nonNullable || value !== null ? corrected : null);\n        this.rangeEditorControl.setValue(corrected);\n    }\n\n    /** @docs-private */\n    onApply(popover: KbqPopoverTrigger): void {\n        this.titleValue.set(this.rangeEditorControl.value);\n        this.onChange(this.rangeEditorControl.value);\n        popover.hide();\n    }\n\n    /** @docs-private */\n    onCancel(popover: KbqPopoverTrigger): void {\n        popover.hide();\n    }\n\n    onVisibleChange(isVisible: boolean) {\n        const titleValue = this.titleValue();\n\n        if (!isVisible && titleValue) {\n            this.rangeEditorControl.setValue(titleValue);\n        }\n    }\n\n    /** @docs-private */\n    onChange = (_value: KbqTimeRangeRange) => {};\n    /** @docs-private */\n    onTouch = () => {};\n    /** Implemented as part of ControlValueAccessor */\n    registerOnChange(fn: (_value: KbqTimeRangeRange) => void): void {\n        this.onChange = fn;\n    }\n    /** Implemented as part of ControlValueAccessor */\n    registerOnTouched(fn: () => void): void {\n        this.onTouch = fn;\n    }\n\n    private handleAvailableTypesChange = (types: KbqTimeRangeType[]): void => {\n        if (types.includes(this.rangeEditorControl.value.type) || this.rangeEditorControl.value.type === 'range') {\n            return;\n        }\n\n        const timeRangeDefaultValue = this.timeRangeService.getTimeRangeDefaultValue(\n            this.normalizedDefaultRangeValue(),\n            types.length ? types : ['range']\n        );\n\n        this.titleValue.set(timeRangeDefaultValue);\n        this.rangeEditorControl.setValue(timeRangeDefaultValue);\n        this.onChange(timeRangeDefaultValue);\n    };\n}\n"]}