@progressio_resources/gravity-design-system 2.6.21 → 2.6.23

package/esm2022/lib/components/gravity-calendar-v2/datepicker/bs-daterangepicker-inline.component.mjs

@@ -0,0 +1,130 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { filter } from 'rxjs/operators';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import { BsDaterangepickerInlineContainerComponent } from './components/bs-daterangepicker-inline-container.component';
+import { checkBsValue, checkRangesWithMaxDate } from './utils/bs-calendar-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./bs-daterangepicker-inline.config";
+import * as i2 from "ngx-bootstrap/component-loader";
+export class BsDaterangepickerInlineDirective {
+    /** Initial value of datepicker */
+    set bsValue(value) {
+        if (this._bsValue === value)
+            return;
+        this._bsValue = value;
+        this.bsValueChange.emit(value);
+    }
+    constructor(_config, _elementRef, _renderer, _viewContainerRef, cis) {
+        this._config = _config;
+        this._elementRef = _elementRef;
+        /** Indicates whether datepicker is enabled or not */
+        this.isDisabled = false;
+        this.isMobile = false;
+        /** Emits when daterangepicker value has been changed */
+        this.bsValueChange = new EventEmitter();
+        this.onApplyEmit = new EventEmitter();
+        this._subs = [];
+        Object.assign(this, this._config);
+        this._datepicker = cis.createLoader(_elementRef, _viewContainerRef, _renderer);
+    }
+    ngOnInit() {
+        this.setConfig();
+        this.initSubscribes();
+    }
+    ngOnChanges(changes) {
+        if (!this._datepickerRef || !this._datepickerRef.instance)
+            return;
+        if (changes["minDate"]) {
+            this._datepickerRef.instance.minDate = this.minDate;
+        }
+        if (changes["maxDate"]) {
+            this._datepickerRef.instance.maxDate = this.maxDate;
+        }
+        if (changes["isDisabled"]) {
+            this._datepickerRef.instance.isDisabled = this.isDisabled;
+        }
+        this.setConfig();
+    }
+    initSubscribes() {
+        this.unsubscribeSubscriptions();
+        // if date changes from external source (model -> view)
+        this._subs.push(this.bsValueChange.subscribe((value) => {
+            if (this._datepickerRef) {
+                this._datepickerRef.instance.value = value;
+            }
+        }));
+        // if date changes from picker (view -> model)
+        if (this._datepickerRef) {
+            this._subs.push(this._datepickerRef.instance.valueChange
+                .pipe(filter((range) => {
+                if (range?.length == 0)
+                    return true;
+                if (range?.length == 2)
+                    return range && range[0] && !!range[1];
+            }))
+                .subscribe((value) => {
+                this.bsValue = value;
+            }));
+            this._subs.push(this._datepickerRef.instance.onApplyChange.subscribe(() => {
+                this.onApplyEmit.emit();
+            }));
+        }
+    }
+    unsubscribeSubscriptions() {
+        if (this._subs?.length) {
+            this._subs.map((sub) => sub.unsubscribe());
+            this._subs.length = 0;
+        }
+    }
+    /** Set config for datepicker */
+    setConfig() {
+        if (this._datepicker) {
+            this._datepicker.hide();
+        }
+        this._config = Object.assign({}, this._config, this.bsConfig, {
+            value: checkBsValue(this._bsValue, this.maxDate || this.bsConfig && this.bsConfig.maxDate),
+            isDisabled: this.isDisabled,
+            isMobile: this.isMobile || this.bsConfig && this.bsConfig.isMobile,
+            minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,
+            maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,
+            ranges: checkRangesWithMaxDate(this.bsConfig && this.bsConfig.ranges, this.maxDate || this.bsConfig && this.bsConfig.maxDate),
+            maxDateRange: this.bsConfig && this.bsConfig.maxDateRange
+        });
+        this._datepickerRef = this._datepicker
+            .provide({ provide: BsDatepickerConfig, useValue: this._config })
+            .attach(BsDaterangepickerInlineContainerComponent)
+            .to(this._elementRef)
+            .show();
+        this.initSubscribes();
+    }
+    ngOnDestroy() {
+        this._datepicker.dispose();
+        this.unsubscribeSubscriptions();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerInlineDirective, deps: [{ token: i1.BsDaterangepickerInlineConfig }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i2.ComponentLoaderFactory }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: BsDaterangepickerInlineDirective, selector: "[gravityRangePickerInline]", inputs: { bsConfig: "bsConfig", isDisabled: "isDisabled", isMobile: "isMobile", maxDate: "maxDate", minDate: "minDate", bsValue: "bsValue" }, outputs: { bsValueChange: "bsValueChange", onApplyEmit: "onApplyEmit" }, exportAs: ["gravityRangePickerInline"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerInlineDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gravityRangePickerInline]',
+                    exportAs: 'gravityRangePickerInline'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BsDaterangepickerInlineConfig }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i2.ComponentLoaderFactory }]; }, propDecorators: { bsConfig: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input
+            }], isMobile: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], bsValueChange: [{
+                type: Output
+            }], onApplyEmit: [{
+                type: Output
+            }], bsValue: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-daterangepicker-inline.component.js","sourceRoot":"","sources":["../../../../../../../projects/gravity-design-system/src/lib/components/gravity-calendar-v2/datepicker/bs-daterangepicker-inline.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  SimpleChanges,\n  ViewContainerRef\n} from '@angular/core';\n\nimport {ComponentLoader, ComponentLoaderFactory} from 'ngx-bootstrap/component-loader';\n\nimport {Subscription} from 'rxjs';\nimport {filter} from 'rxjs/operators';\n\nimport {BsDatepickerConfig} from './bs-datepicker.config';\nimport {BsDaterangepickerInlineConfig} from './bs-daterangepicker-inline.config';\nimport {BsDaterangepickerInlineContainerComponent} from './components/bs-daterangepicker-inline-container.component';\nimport {checkBsValue, checkRangesWithMaxDate} from './utils/bs-calendar-utils';\n\n@Directive({\n  selector: '[gravityRangePickerInline]',\n  exportAs: 'gravityRangePickerInline'\n})\nexport class BsDaterangepickerInlineDirective implements OnInit, OnDestroy, OnChanges {\n  /** Config object for datepicker */\n  @Input() bsConfig?: Partial<BsDaterangepickerInlineConfig>;\n\n  /** Indicates whether datepicker is enabled or not */\n  @Input() isDisabled: boolean = false;\n  @Input() isMobile: boolean = false;\n\n  /** Maximum date which is available for selection */\n  @Input() maxDate?: Date;\n\n  /** Minimum date which is available for selection */\n  @Input() minDate?: Date;\n\n  /** Emits when daterangepicker value has been changed */\n  @Output() bsValueChange: EventEmitter<(Date | undefined)[] | undefined> = new EventEmitter();\n  @Output() onApplyEmit: EventEmitter<void> = new EventEmitter<void>();\n\n  private _bsValue?: (Date | undefined)[] | undefined;\n\n  /** Initial value of datepicker */\n  @Input() set bsValue(value: (Date | undefined)[] | undefined) {\n    if (this._bsValue === value) return;\n\n    this._bsValue = value;\n    this.bsValueChange.emit(value);\n  }\n\n  protected _subs: Subscription[] = [];\n  private _datepickerRef?: ComponentRef<BsDaterangepickerInlineContainerComponent>;\n  private readonly _datepicker: ComponentLoader<BsDaterangepickerInlineContainerComponent>;\n\n  constructor(public _config: BsDaterangepickerInlineConfig, private _elementRef: ElementRef, _renderer: Renderer2, _viewContainerRef: ViewContainerRef, cis: ComponentLoaderFactory) {\n    Object.assign(this, this._config);\n\n    this._datepicker = cis.createLoader<BsDaterangepickerInlineContainerComponent>(_elementRef, _viewContainerRef, _renderer);\n  }\n\n  ngOnInit(): void {\n    this.setConfig();\n    this.initSubscribes();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (!this._datepickerRef || !this._datepickerRef.instance) return;\n\n    if (changes[\"minDate\"]) {\n      this._datepickerRef.instance.minDate = this.minDate;\n    }\n\n    if (changes[\"maxDate\"]) {\n      this._datepickerRef.instance.maxDate = this.maxDate;\n    }\n\n    if (changes[\"isDisabled\"]) {\n      this._datepickerRef.instance.isDisabled = this.isDisabled;\n    }\n\n    this.setConfig();\n  }\n\n  private initSubscribes(): void {\n    this.unsubscribeSubscriptions();\n\n    // if date changes from external source (model -> view)\n    this._subs.push(\n      this.bsValueChange.subscribe((value: Date[]) => {\n        if (this._datepickerRef) {\n          this._datepickerRef.instance.value = value;\n        }\n      })\n    );\n\n    // if date changes from picker (view -> model)\n    if (this._datepickerRef) {\n      this._subs.push(\n        this._datepickerRef.instance.valueChange\n          .pipe(filter((range: Date[]) => {\n            if (range?.length == 0) return true;\n            if (range?.length == 2) return range && range[0] && !!range[1];\n          }))\n          .subscribe((value: Date[]) => {\n            this.bsValue = value;\n          })\n      );\n\n      this._subs.push(\n        this._datepickerRef.instance.onApplyChange.subscribe(() => {\n          this.onApplyEmit.emit();\n        })\n      );\n    }\n  }\n\n  private unsubscribeSubscriptions(): void {\n    if (this._subs?.length) {\n      this._subs.map((sub: Subscription) => sub.unsubscribe());\n      this._subs.length = 0;\n    }\n  }\n\n  /** Set config for datepicker */\n  private setConfig(): void {\n    if (this._datepicker) {\n      this._datepicker.hide();\n    }\n\n    this._config = Object.assign({}, this._config, this.bsConfig, {\n      value: checkBsValue(this._bsValue, this.maxDate || this.bsConfig && this.bsConfig.maxDate),\n      isDisabled: this.isDisabled,\n      isMobile: this.isMobile || this.bsConfig && this.bsConfig.isMobile,\n      minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,\n      maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,\n      ranges: checkRangesWithMaxDate(this.bsConfig && this.bsConfig.ranges, this.maxDate || this.bsConfig && this.bsConfig.maxDate),\n      maxDateRange: this.bsConfig && this.bsConfig.maxDateRange\n    });\n\n    this._datepickerRef = this._datepicker\n      .provide({provide: BsDatepickerConfig, useValue: this._config})\n      .attach(BsDaterangepickerInlineContainerComponent)\n      .to(this._elementRef)\n      .show();\n\n    this.initSubscribes();\n  }\n\n  ngOnDestroy(): void {\n    this._datepicker.dispose();\n    this.unsubscribeSubscriptions();\n  }\n}\n"]}

package/esm2022/lib/components/gravity-calendar-v2/datepicker/bs-daterangepicker-inline.config.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import * as i0 from "@angular/core";
+export class BsDaterangepickerInlineConfig extends BsDatepickerConfig {
+    constructor() {
+        super(...arguments);
+        this.displayMonths = 2;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerInlineConfig, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerInlineConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerInlineConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtZGF0ZXJhbmdlcGlja2VyLWlubGluZS5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ncmF2aXR5LWRlc2lnbi1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2dyYXZpdHktY2FsZW5kYXItdjIvZGF0ZXBpY2tlci9icy1kYXRlcmFuZ2VwaWNrZXItaW5saW5lLmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLHdCQUF3QixDQUFDOztBQUsxRCxNQUFNLE9BQU8sNkJBQThCLFNBQVEsa0JBQWtCO0lBSHJFOztRQUlXLGtCQUFhLEdBQVcsQ0FBQyxDQUFDO0tBQ3BDOytHQUZZLDZCQUE2QjttSEFBN0IsNkJBQTZCLGNBRjVCLE1BQU07OzRGQUVQLDZCQUE2QjtrQkFIekMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGFibGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtCc0RhdGVwaWNrZXJDb25maWd9IGZyb20gJy4vYnMtZGF0ZXBpY2tlci5jb25maWcnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBCc0RhdGVyYW5nZXBpY2tlcklubGluZUNvbmZpZyBleHRlbmRzIEJzRGF0ZXBpY2tlckNvbmZpZyB7XG4gIG92ZXJyaWRlIGRpc3BsYXlNb250aHM6IG51bWJlciA9IDI7XG59XG4iXX0=

package/esm2022/lib/components/gravity-calendar-v2/datepicker/bs-daterangepicker.component.mjs

@@ -0,0 +1,218 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { BsDaterangepickerContainerComponent } from './components/bs-daterangepicker-container.component';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import { checkBsValue, checkRangesWithMaxDate } from './utils/bs-calendar-utils';
+import { BsDatepickerCallbacks } from "./bs-datepicker.callbacks";
+import * as i0 from "@angular/core";
+import * as i1 from "./bs-daterangepicker.config";
+import * as i2 from "ngx-bootstrap/component-loader";
+export let previousDate;
+export class BsDaterangepickerDirective {
+    /** Returns whether or not the daterangepicker is currently being shown */
+    get isOpen() {
+        return this._datepicker.isShown;
+    }
+    set isOpen(value) {
+        this.isOpen$.next(value);
+    }
+    /** Initial value of daterangepicker */
+    set bsValue(value) {
+        if (this._bsValue === value)
+            return;
+        this.initPreviousValue();
+        this._bsValue = value;
+        this.bsValueChange.emit(value);
+    }
+    constructor(_config, _elementRef, _renderer, _viewContainerRef, cis) {
+        this._config = _config;
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        /** A selector specifying the element the daterangepicker should be appended to. */
+        this.container = 'body';
+        /** Indicates whether daterangepicker's content is enabled or not */
+        this.isDisabled = false;
+        this.isMobile = false;
+        /** Emits when daterangepicker value has been changed */
+        this.bsValueChange = new EventEmitter();
+        this.onApplyEmit = new EventEmitter();
+        this._subs = [];
+        this.isDestroy$ = new Subject();
+        this._rangeInputFormat$ = new Subject();
+        Object.assign(this, _config);
+        this._datepicker = cis.createLoader(_elementRef, _viewContainerRef, _renderer);
+        this.isOpen$ = new BehaviorSubject(this.isOpen);
+        this.onHidden = this._datepicker.onHidden;
+        this.onShown = this._datepicker.onShown;
+    }
+    ngOnInit() {
+        this._datepicker.listen({
+            outsideClick: true,
+            outsideEsc: true,
+            triggers: 'click',
+            show: () => this.show()
+        });
+        this.initPreviousValue();
+        this.setConfig();
+    }
+    initPreviousValue() {
+        previousDate = this._bsValue;
+    }
+    ngOnChanges(changes) {
+        if (changes["bsConfig"]) {
+            this.setConfig();
+            this._rangeInputFormat$.next('L');
+        }
+        if (!this._datepickerRef || !this._datepickerRef.instance)
+            return;
+        if (changes["minDate"]) {
+            this._datepickerRef.instance.minDate = this.minDate;
+        }
+        if (changes["maxDate"]) {
+            this._datepickerRef.instance.maxDate = this.maxDate;
+        }
+        if (changes["isDisabled"]) {
+            this._datepickerRef.instance.isDisabled = this.isDisabled;
+        }
+    }
+    ngAfterViewInit() {
+        this.isOpen$.pipe(filter(isOpen => isOpen !== this.isOpen), takeUntil(this.isDestroy$)).subscribe(() => this.toggle());
+    }
+    initSubscribes() {
+        // if date changes from external source (model -> view)
+        this._subs.push(this.bsValueChange.subscribe((value) => {
+            if (this._datepickerRef) {
+                this._datepickerRef.instance.value = value;
+            }
+        }));
+        // if date changes from picker (view -> model)
+        if (this._datepickerRef) {
+            this._subs.push(this._datepickerRef.instance.valueChange
+                .pipe(filter((range) => {
+                if (range.length == 0)
+                    return true;
+                if (range.length == 2)
+                    return range && range[0] && !!range[1];
+            }))
+                .subscribe((value) => {
+                this.initPreviousValue();
+                this.bsValue = value;
+                // TODO ebiazzetti keep modal open after select the dates
+                if (this.keepDatepickerModalOpened())
+                    return;
+                this.hide();
+            }));
+            this._subs.push(this._datepickerRef.instance.onApplyChange.subscribe(() => {
+                this.onApplyEmit.emit();
+            }));
+        }
+    }
+    keepDatepickerModalOpened() {
+        if (!previousDate || !this.bsConfig?.keepDatepickerOpened)
+            return false;
+        return this.isDateSame();
+    }
+    isDateSame() {
+        return ((this._bsValue?.[0]?.getDate() === previousDate?.[0]?.getDate())
+            && (this._bsValue?.[0]?.getMonth() === previousDate?.[0]?.getMonth())
+            && (this._bsValue?.[0]?.getFullYear() === previousDate?.[0]?.getFullYear())
+            && (this._bsValue?.[1]?.getDate() === previousDate?.[1]?.getDate())
+            && (this._bsValue?.[1]?.getMonth() === previousDate?.[1]?.getMonth())
+            && (this._bsValue?.[1]?.getFullYear() === previousDate?.[1]?.getFullYear()));
+    }
+    /** Opens an element’s datepicker. This is considered a “manual” triggering of the datepicker */
+    show() {
+        if (this._datepicker.isShown)
+            return;
+        this.setConfig();
+        const callbacks = new BsDatepickerCallbacks();
+        callbacks.hide = this.hide.bind(this);
+        this._datepickerRef = this._datepicker
+            .provide({ provide: BsDatepickerConfig, useValue: this._config })
+            .provide({ provide: BsDatepickerCallbacks, useValue: callbacks })
+            .attach(BsDaterangepickerContainerComponent)
+            .to(this.container)
+            .position({ attachment: 'bottom' })
+            .show({ placement: 'bottom' });
+        this.initSubscribes();
+    }
+    /** Closes an element’s datepicker. This is considered a “manual” triggering of the datepicker. */
+    hide() {
+        if (this.isOpen) {
+            this._datepicker.hide();
+        }
+        for (const sub of this._subs) {
+            sub.unsubscribe();
+        }
+    }
+    /** Toggles an element’s datepicker. This is considered a “manual” triggering of the datepicker. */
+    toggle() {
+        if (this.isOpen) {
+            return this.hide();
+        }
+        this.show();
+    }
+    /** Set config for daterangepicker */
+    setConfig() {
+        this._config = Object.assign({}, this._config, this.bsConfig, {
+            value: checkBsValue(this._bsValue, this.maxDate || this.bsConfig && this.bsConfig.maxDate),
+            isDisabled: this.isDisabled,
+            isMobile: this.isMobile || this.bsConfig && this.bsConfig.isMobile,
+            minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,
+            maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,
+            ranges: checkRangesWithMaxDate(this.bsConfig && this.bsConfig.ranges, this.maxDate || this.bsConfig && this.bsConfig.maxDate),
+            maxDateRange: this.bsConfig && this.bsConfig.maxDateRange,
+            keepDatepickerOpened: this.bsConfig?.keepDatepickerOpened
+        });
+    }
+    unsubscribeSubscriptions() {
+        if (this._subs?.length) {
+            this._subs.map((sub) => sub.unsubscribe());
+            this._subs.length = 0;
+        }
+    }
+    ngOnDestroy() {
+        this._datepicker.dispose();
+        this.isOpen$.next(false);
+        if (this.isDestroy$) {
+            this.isDestroy$.next(null);
+            this.isDestroy$.complete();
+        }
+        this.unsubscribeSubscriptions();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerDirective, deps: [{ token: i1.BsDaterangepickerConfig }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i2.ComponentLoaderFactory }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: BsDaterangepickerDirective, selector: "[gravityRangePicker]", inputs: { bsConfig: "bsConfig", container: "container", isDisabled: "isDisabled", isMobile: "isMobile", maxDate: "maxDate", minDate: "minDate", isOpen: "isOpen", bsValue: "bsValue" }, outputs: { bsValueChange: "bsValueChange", onApplyEmit: "onApplyEmit", onHidden: "onHidden", onShown: "onShown" }, exportAs: ["gravityRangePicker"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gravityRangePicker]',
+                    exportAs: 'gravityRangePicker'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BsDaterangepickerConfig }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i2.ComponentLoaderFactory }]; }, propDecorators: { bsConfig: [{
+                type: Input
+            }], container: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input
+            }], isMobile: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], bsValueChange: [{
+                type: Output
+            }], onApplyEmit: [{
+                type: Output
+            }], onHidden: [{
+                type: Output
+            }], onShown: [{
+                type: Output
+            }], isOpen: [{
+                type: Input
+            }], bsValue: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-daterangepicker.component.js","sourceRoot":"","sources":["../../../../../../../projects/gravity-design-system/src/lib/components/gravity-calendar-v2/datepicker/bs-daterangepicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  SimpleChanges,\n  ViewContainerRef\n} from '@angular/core';\nimport {BsDaterangepickerConfig} from './bs-daterangepicker.config';\nimport {BsDaterangepickerContainerComponent} from './components/bs-daterangepicker-container.component';\nimport {BehaviorSubject, Subject, Subscription} from 'rxjs';\nimport {filter, takeUntil} from 'rxjs/operators';\nimport {ComponentLoader, ComponentLoaderFactory} from 'ngx-bootstrap/component-loader';\nimport {BsDatepickerConfig} from './bs-datepicker.config';\nimport {checkBsValue, checkRangesWithMaxDate} from './utils/bs-calendar-utils';\nimport {BsDatepickerCallbacks} from \"./bs-datepicker.callbacks\";\n\nexport let previousDate: (Date | undefined)[] | undefined;\n\n@Directive({\n  selector: '[gravityRangePicker]',\n  exportAs: 'gravityRangePicker'\n})\nexport class BsDaterangepickerDirective implements OnInit, OnDestroy, OnChanges, AfterViewInit {\n  /** Config object for daterangepicker */\n  @Input() bsConfig?: Partial<BsDaterangepickerConfig>;\n\n  /** A selector specifying the element the daterangepicker should be appended to. */\n  @Input() container: string = 'body';\n\n  /** Indicates whether daterangepicker's content is enabled or not */\n  @Input() isDisabled: boolean = false;\n  @Input() isMobile: boolean = false;\n\n  /** Maximum date which is available for selection */\n  @Input() maxDate?: Date;\n\n  /** Minimum date which is available for selection */\n  @Input() minDate?: Date;\n\n  /** Emits when daterangepicker value has been changed */\n  @Output() bsValueChange: EventEmitter<((Date | undefined)[] | undefined)> = new EventEmitter<((Date | undefined)[] | undefined)>();\n  @Output() onApplyEmit: EventEmitter<void> = new EventEmitter<void>();\n\n  /** Emits an event when the daterangepicker is hidden */\n  @Output() onHidden: EventEmitter<unknown>;\n\n  /** Emits an event when the daterangepicker is shown */\n  @Output() onShown: EventEmitter<unknown>;\n\n  private isOpen$: BehaviorSubject<boolean>;\n\n  /** Returns whether or not the daterangepicker is currently being shown */\n  @Input() get isOpen(): boolean {\n    return this._datepicker.isShown;\n  }\n\n  set isOpen(value: boolean) {\n    this.isOpen$.next(value);\n  }\n\n  public _bsValue?: (Date | undefined)[];\n\n  /** Initial value of daterangepicker */\n  @Input() set bsValue(value: (Date | undefined)[] | undefined) {\n    if (this._bsValue === value) return;\n\n    this.initPreviousValue();\n    this._bsValue = value;\n    this.bsValueChange.emit(value);\n  }\n\n  protected _subs: Subscription[] = [];\n  private _datepicker: ComponentLoader<BsDaterangepickerContainerComponent>;\n  private _datepickerRef?: ComponentRef<BsDaterangepickerContainerComponent>;\n  private isDestroy$: Subject<unknown> = new Subject();\n  private readonly _rangeInputFormat$ = new Subject<string>();\n\n  constructor(public _config: BsDaterangepickerConfig, private _elementRef: ElementRef, private _renderer: Renderer2, _viewContainerRef: ViewContainerRef, cis: ComponentLoaderFactory) {\n    Object.assign(this, _config);\n\n    this._datepicker = cis.createLoader<BsDaterangepickerContainerComponent>(_elementRef, _viewContainerRef, _renderer);\n\n    this.isOpen$ = new BehaviorSubject(this.isOpen);\n    this.onHidden = this._datepicker.onHidden;\n    this.onShown = this._datepicker.onShown;\n  }\n\n  ngOnInit(): void {\n    this._datepicker.listen({\n      outsideClick: true,\n      outsideEsc: true,\n      triggers: 'click',\n      show: () => this.show()\n    });\n\n    this.initPreviousValue();\n    this.setConfig();\n  }\n\n  private initPreviousValue(): void {\n    previousDate = this._bsValue;\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[\"bsConfig\"]) {\n      this.setConfig();\n      this._rangeInputFormat$.next('L');\n    }\n\n    if (!this._datepickerRef || !this._datepickerRef.instance) return;\n\n    if (changes[\"minDate\"]) {\n      this._datepickerRef.instance.minDate = this.minDate;\n    }\n\n    if (changes[\"maxDate\"]) {\n      this._datepickerRef.instance.maxDate = this.maxDate;\n    }\n\n    if (changes[\"isDisabled\"]) {\n      this._datepickerRef.instance.isDisabled = this.isDisabled;\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.isOpen$.pipe(filter(isOpen => isOpen !== this.isOpen), takeUntil(this.isDestroy$)).subscribe(() => this.toggle());\n  }\n\n  private initSubscribes(): void {\n    // if date changes from external source (model -> view)\n    this._subs.push(\n      this.bsValueChange.subscribe((value: Date[]) => {\n        if (this._datepickerRef) {\n          this._datepickerRef.instance.value = value;\n        }\n      })\n    );\n\n    // if date changes from picker (view -> model)\n    if (this._datepickerRef) {\n      this._subs.push(\n        this._datepickerRef.instance.valueChange\n          .pipe(filter((range: Date[]) => {\n            if (range.length == 0) return true;\n            if (range.length == 2) return range && range[0] && !!range[1];\n          }))\n          .subscribe((value: Date[]) => {\n            this.initPreviousValue();\n            this.bsValue = value;\n\n            // TODO ebiazzetti keep modal open after select the dates\n            if (this.keepDatepickerModalOpened()) return;\n\n            this.hide();\n          })\n      );\n\n      this._subs.push(\n        this._datepickerRef.instance.onApplyChange.subscribe(() => {\n          this.onApplyEmit.emit();\n        })\n      );\n    }\n  }\n\n  private keepDatepickerModalOpened(): boolean {\n    if (!previousDate || !this.bsConfig?.keepDatepickerOpened) return false;\n    return this.isDateSame();\n  }\n\n  private isDateSame(): boolean {\n    return ((this._bsValue?.[0]?.getDate() === previousDate?.[0]?.getDate())\n      && (this._bsValue?.[0]?.getMonth() === previousDate?.[0]?.getMonth())\n      && (this._bsValue?.[0]?.getFullYear() === previousDate?.[0]?.getFullYear())\n      && (this._bsValue?.[1]?.getDate() === previousDate?.[1]?.getDate())\n      && (this._bsValue?.[1]?.getMonth() === previousDate?.[1]?.getMonth())\n      && (this._bsValue?.[1]?.getFullYear() === previousDate?.[1]?.getFullYear())\n    );\n  }\n\n  /** Opens an element’s datepicker. This is considered a “manual” triggering of the datepicker */\n  private show(): void {\n    if (this._datepicker.isShown) return;\n\n    this.setConfig();\n\n    const callbacks: BsDatepickerCallbacks = new BsDatepickerCallbacks();\n    callbacks.hide = this.hide.bind(this);\n\n    this._datepickerRef = this._datepicker\n      .provide({provide: BsDatepickerConfig, useValue: this._config})\n      .provide({provide: BsDatepickerCallbacks, useValue: callbacks})\n      .attach(BsDaterangepickerContainerComponent)\n      .to(this.container)\n      .position({attachment: 'bottom'})\n      .show({placement: 'bottom'});\n\n    this.initSubscribes();\n  }\n\n  /** Closes an element’s datepicker. This is considered a “manual” triggering of the datepicker. */\n  public hide(): void {\n    if (this.isOpen) {\n      this._datepicker.hide();\n    }\n\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n  }\n\n  /** Toggles an element’s datepicker. This is considered a “manual” triggering of the datepicker. */\n  private toggle(): void {\n    if (this.isOpen) {\n      return this.hide();\n    }\n\n    this.show();\n  }\n\n  /** Set config for daterangepicker */\n  private setConfig(): void {\n    this._config = Object.assign({}, this._config, this.bsConfig, {\n      value: checkBsValue(this._bsValue, this.maxDate || this.bsConfig && this.bsConfig.maxDate),\n      isDisabled: this.isDisabled,\n      isMobile: this.isMobile || this.bsConfig && this.bsConfig.isMobile,\n      minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,\n      maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,\n      ranges: checkRangesWithMaxDate(this.bsConfig && this.bsConfig.ranges, this.maxDate || this.bsConfig && this.bsConfig.maxDate),\n      maxDateRange: this.bsConfig && this.bsConfig.maxDateRange,\n      keepDatepickerOpened: this.bsConfig?.keepDatepickerOpened\n    });\n  }\n\n  private unsubscribeSubscriptions(): void {\n    if (this._subs?.length) {\n      this._subs.map((sub: Subscription) => sub.unsubscribe());\n      this._subs.length = 0;\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._datepicker.dispose();\n    this.isOpen$.next(false);\n\n    if (this.isDestroy$) {\n      this.isDestroy$.next(null);\n      this.isDestroy$.complete();\n    }\n\n    this.unsubscribeSubscriptions();\n  }\n}\n"]}

package/esm2022/lib/components/gravity-calendar-v2/datepicker/bs-daterangepicker.config.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import * as i0 from "@angular/core";
+export class BsDaterangepickerConfig extends BsDatepickerConfig {
+    constructor() {
+        super(...arguments);
+        this.displayMonths = 2;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerConfig, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDaterangepickerConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtZGF0ZXJhbmdlcGlja2VyLmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2dyYXZpdHktZGVzaWduLXN5c3RlbS9zcmMvbGliL2NvbXBvbmVudHMvZ3Jhdml0eS1jYWxlbmRhci12Mi9kYXRlcGlja2VyL2JzLWRhdGVyYW5nZXBpY2tlci5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUMsa0JBQWtCLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQzs7QUFLMUQsTUFBTSxPQUFPLHVCQUF3QixTQUFRLGtCQUFrQjtJQUgvRDs7UUFJVyxrQkFBYSxHQUFXLENBQUMsQ0FBQztLQUNwQzsrR0FGWSx1QkFBdUI7bUhBQXZCLHVCQUF1QixjQUZ0QixNQUFNOzs0RkFFUCx1QkFBdUI7a0JBSG5DLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QnNEYXRlcGlja2VyQ29uZmlnfSBmcm9tICcuL2JzLWRhdGVwaWNrZXIuY29uZmlnJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQnNEYXRlcmFuZ2VwaWNrZXJDb25maWcgZXh0ZW5kcyBCc0RhdGVwaWNrZXJDb25maWcge1xuICBvdmVycmlkZSBkaXNwbGF5TW9udGhzOiBudW1iZXIgPSAyO1xufVxuIl19