@progressio_resources/gravity-design-system 2.6.20 → 2.6.22

package/esm2022/lib/components/gravity-calendar-v2/datepicker/base/bs-datepicker-container.mjs

@@ -0,0 +1,66 @@
+import { Subscription } from 'rxjs';
+export class BsDatepickerAbstractComponent {
+    get calendarSize() {
+        if (!this._config.isMobile && (!this.isRangePicker || this._config.displayMonths == 1)) {
+            return this._config.calendarSize;
+        }
+        else {
+            return 'sm';
+        }
+    }
+    get daysCalendar$() {
+        return this._daysCalendar$;
+    }
+    get isDisabled() {
+        return !!this._config.isDisabled;
+    }
+    get isEmpty() {
+        return !this._config.value;
+    }
+    get showNavigationArrows() {
+        return !this.isRangePicker || (this.isRangePicker && this._config.displayMonths == 1);
+    }
+    set daysCalendar$(value) {
+        this._daysCalendar$ = value;
+        this._daysCalendarSub.unsubscribe();
+    }
+    set isDisabled(value) {
+        this._effects?.setDisabled(value);
+    }
+    set maxDate(value) {
+        this._effects?.setMaxDate(value);
+    }
+    set minDate(value) {
+        this._effects?.setMinDate(value);
+    }
+    constructor(_config) {
+        this._config = _config;
+        this._subs = [];
+        this._daysCalendarSub = new Subscription();
+        this.animationState = 'void';
+        this.chosenRange = [];
+    }
+    setViewMode(event) {
+    }
+    navigateTo(event) {
+    }
+    dayHoverHandler(event) {
+    }
+    monthHoverHandler(event) {
+    }
+    yearHoverHandler(event) {
+    }
+    daySelectHandler(day) {
+    }
+    monthSelectHandler(event) {
+    }
+    yearSelectHandler(event) {
+    }
+    setRangeOnCalendar(dates) {
+    }
+    clearDate() {
+    }
+    apply() {
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,129 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import { BsDatepickerInlineContainerComponent } from './components/bs-datepicker-inline-container.component';
+import { checkBsValue } from './utils/bs-calendar-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./bs-datepicker-inline.config";
+import * as i2 from "ngx-bootstrap/component-loader";
+export class BsDatepickerInlineDirective {
+    /** 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 datepicker 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 (changes["bsConfig"]) {
+            this.setConfig();
+        }
+        if (!this._datepickerRef || !this._datepickerRef.instance)
+            return;
+        if (changes["isMobile"]) {
+            this.setConfig();
+        }
+        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.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,
+            minMode: this.minMode || this.bsConfig && this.bsConfig.minMode,
+            minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,
+            maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate
+        });
+        this._datepickerRef = this._datepicker
+            .provide({ provide: BsDatepickerConfig, useValue: this._config })
+            .attach(BsDatepickerInlineContainerComponent)
+            .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: BsDatepickerInlineDirective, deps: [{ token: i1.BsDatepickerInlineConfig }, { 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: BsDatepickerInlineDirective, selector: "[gravityDatePickerInline]", inputs: { bsConfig: "bsConfig", isDisabled: "isDisabled", isMobile: "isMobile", maxDate: "maxDate", minDate: "minDate", minMode: "minMode", bsValue: "bsValue" }, outputs: { bsValueChange: "bsValueChange", onApplyEmit: "onApplyEmit" }, exportAs: ["gravityDatePickerInline"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerInlineDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gravityDatePickerInline]',
+                    exportAs: 'gravityDatePickerInline'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BsDatepickerInlineConfig }, { 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
+            }], minMode: [{
+                type: Input
+            }], bsValueChange: [{
+                type: Output
+            }], onApplyEmit: [{
+                type: Output
+            }], bsValue: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-datepicker-inline.component.js","sourceRoot":"","sources":["../../../../../../../projects/gravity-design-system/src/lib/components/gravity-calendar-v2/datepicker/bs-datepicker-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 {BsDatepickerInlineConfig} from './bs-datepicker-inline.config';\n\nimport {BsDatepickerConfig} from './bs-datepicker.config';\nimport {BsDatepickerInlineContainerComponent} from './components/bs-datepicker-inline-container.component';\nimport {checkBsValue} from './utils/bs-calendar-utils';\nimport {BsDatepickerViewMode} from \"./models\";\n\n@Directive({\n  selector: '[gravityDatePickerInline]',\n  exportAs: 'gravityDatePickerInline'\n})\nexport class BsDatepickerInlineDirective implements OnInit, OnDestroy, OnChanges {\n  /** Config object for datepicker */\n  @Input() bsConfig?: Partial<BsDatepickerInlineConfig>;\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  /** Minimum view mode : day, month, or year */\n  @Input() minMode?: BsDatepickerViewMode;\n\n  /** Emits when datepicker value has been changed */\n  @Output() bsValueChange: EventEmitter<Date> = new EventEmitter();\n  @Output() onApplyEmit: EventEmitter<void> = new EventEmitter<void>();\n\n  private _bsValue?: Date;\n\n  /** Initial value of datepicker */\n  @Input() set bsValue(value: Date | 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<BsDatepickerInlineContainerComponent>;\n  private readonly _datepicker: ComponentLoader<BsDatepickerInlineContainerComponent>;\n\n  constructor(public _config: BsDatepickerInlineConfig, private _elementRef: ElementRef, _renderer: Renderer2, _viewContainerRef: ViewContainerRef, cis: ComponentLoaderFactory) {\n    Object.assign(this, this._config);\n\n    this._datepicker = cis.createLoader<BsDatepickerInlineContainerComponent>(_elementRef, _viewContainerRef, _renderer);\n  }\n\n  ngOnInit(): void {\n    this.setConfig();\n    this.initSubscribes();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[\"bsConfig\"]) {\n      this.setConfig();\n    }\n\n    if (!this._datepickerRef || !this._datepickerRef.instance) return;\n\n    if (changes[\"isMobile\"]) {\n      this.setConfig();\n    }\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.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      minMode: this.minMode || this.bsConfig && this.bsConfig.minMode,\n      minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,\n      maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate\n    });\n\n    this._datepickerRef = this._datepicker\n      .provide({provide: BsDatepickerConfig, useValue: this._config})\n      .attach(BsDatepickerInlineContainerComponent)\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-datepicker-inline.config.mjs

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

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

@@ -0,0 +1,13 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+export class BsDatepickerCallbacks {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerCallbacks, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerCallbacks, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerCallbacks, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtZGF0ZXBpY2tlci5jYWxsYmFja3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ncmF2aXR5LWRlc2lnbi1zeXN0ZW0vc3JjL2xpYi9jb21wb25lbnRzL2dyYXZpdHktY2FsZW5kYXItdjIvZGF0ZXBpY2tlci9icy1kYXRlcGlja2VyLmNhbGxiYWNrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQUt6QyxNQUFNLE9BQU8scUJBQXFCOytHQUFyQixxQkFBcUI7bUhBQXJCLHFCQUFxQixjQUZwQixNQUFNOzs0RkFFUCxxQkFBcUI7a0JBSGpDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBCc0RhdGVwaWNrZXJDYWxsYmFja3Mge1xuICBoaWRlPzogKCkgPT4gdm9pZDtcbn1cbiJdfQ==

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

@@ -0,0 +1,210 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import { BsDatepickerContainerComponent } from './components/bs-datepicker-container.component';
+import { checkBsValue } from './utils/bs-calendar-utils';
+import { BsDatepickerCallbacks } from "./bs-datepicker.callbacks";
+import * as i0 from "@angular/core";
+import * as i1 from "./bs-datepicker.config";
+import * as i2 from "ngx-bootstrap/component-loader";
+export let previousDate;
+export class BsDatepickerDirective {
+    /** Returns whether or not the datepicker is currently being shown */
+    get isOpen() {
+        return this._datepicker.isShown;
+    }
+    set isOpen(value) {
+        this.isOpen$.next(value);
+    }
+    /** Initial value of datepicker */
+    set bsValue(value) {
+        if (this._bsValue && value && this._bsValue.getTime() === value.getTime())
+            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 datepicker should be appended to. */
+        this.container = 'body';
+        /** Indicates whether datepicker's content is enabled or not */
+        this.isDisabled = false;
+        this.isMobile = false;
+        /** Emits when datepicker value has been changed */
+        this.bsValueChange = new EventEmitter();
+        this.onApplyEmit = new EventEmitter();
+        this._subs = [];
+        this.isDestroy$ = new Subject();
+        this._dateInputFormat$ = new Subject();
+        Object.assign(this, 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._dateInputFormat$.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.subscribe((value) => {
+                this.initPreviousValue();
+                this.bsValue = value;
+                // TODO ebiazzetti keep modal open after select a date
+                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 (previousDate instanceof Date
+            && (this._bsValue?.getDate() === previousDate?.getDate())
+            && (this._bsValue?.getMonth() === previousDate?.getMonth())
+            && (this._bsValue?.getFullYear() === previousDate?.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(BsDatepickerContainerComponent)
+            .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 datepicker */
+    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,
+            minMode: this.minMode || this.bsConfig && this.bsConfig.minMode,
+            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: BsDatepickerDirective, deps: [{ token: i1.BsDatepickerConfig }, { 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: BsDatepickerDirective, selector: "[gravityDatePicker]", inputs: { bsConfig: "bsConfig", container: "container", isDisabled: "isDisabled", isMobile: "isMobile", maxDate: "maxDate", minDate: "minDate", minMode: "minMode", isOpen: "isOpen", bsValue: "bsValue" }, outputs: { bsValueChange: "bsValueChange", onApplyEmit: "onApplyEmit", onHidden: "onHidden", onShown: "onShown" }, exportAs: ["gravityDatePicker"], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[gravityDatePicker]',
+                    exportAs: 'gravityDatePicker'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BsDatepickerConfig }, { 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
+            }], minMode: [{
+                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-datepicker.component.js","sourceRoot":"","sources":["../../../../../../../projects/gravity-design-system/src/lib/components/gravity-calendar-v2/datepicker/bs-datepicker.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 {ComponentLoader, ComponentLoaderFactory} from 'ngx-bootstrap/component-loader';\nimport {BehaviorSubject, Subject, Subscription} from 'rxjs';\nimport {filter, takeUntil} from 'rxjs/operators';\nimport {BsDatepickerConfig} from './bs-datepicker.config';\nimport {BsDatepickerViewMode} from './models';\nimport {BsDatepickerContainerComponent} from './components/bs-datepicker-container.component';\nimport {checkBsValue} from './utils/bs-calendar-utils';\nimport {BsDatepickerCallbacks} from \"./bs-datepicker.callbacks\";\n\nexport let previousDate: Date | Date[] | undefined;\n\n@Directive({\n  selector: '[gravityDatePicker]',\n  exportAs: 'gravityDatePicker'\n})\nexport class BsDatepickerDirective implements OnInit, OnDestroy, OnChanges, AfterViewInit {\n  /** Config object for datepicker */\n  @Input() bsConfig?: Partial<BsDatepickerConfig>;\n\n  /** A selector specifying the element the datepicker should be appended to. */\n  @Input() container: string = 'body';\n\n  /** Indicates whether datepicker'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  /** Minimum view mode : day, month, or year */\n  @Input() minMode?: BsDatepickerViewMode;\n\n  /** Emits when datepicker value has been changed */\n  @Output() bsValueChange: EventEmitter<Date> = new EventEmitter<Date>();\n  @Output() onApplyEmit: EventEmitter<void> = new EventEmitter<void>();\n\n  /** Emits an event when the datepicker is hidden */\n  @Output() onHidden: EventEmitter<unknown>;\n\n  /** Emits an event when the datepicker is shown */\n  @Output() onShown: EventEmitter<unknown>;\n\n  private isOpen$: BehaviorSubject<boolean>;\n\n  /** Returns whether or not the datepicker 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;\n\n  /** Initial value of datepicker */\n  @Input() set bsValue(value: Date | undefined) {\n    if (this._bsValue && value && this._bsValue.getTime() === value.getTime()) return;\n\n    this.initPreviousValue();\n    this._bsValue = value;\n    this.bsValueChange.emit(value);\n  }\n\n  protected _subs: Subscription[] = [];\n  private _datepicker: ComponentLoader<BsDatepickerContainerComponent>;\n  private _datepickerRef?: ComponentRef<BsDatepickerContainerComponent>;\n  private isDestroy$: Subject<unknown> = new Subject();\n  private readonly _dateInputFormat$ = new Subject<string | undefined>();\n\n  constructor(public _config: BsDatepickerConfig, private _elementRef: ElementRef, private _renderer: Renderer2, _viewContainerRef: ViewContainerRef, cis: ComponentLoaderFactory) {\n    Object.assign(this, this._config);\n\n    this._datepicker = cis.createLoader<BsDatepickerContainerComponent>(_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._dateInputFormat$.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.subscribe((value: Date) => {\n          this.initPreviousValue();\n          this.bsValue = value;\n\n          // TODO ebiazzetti keep modal open after select a date\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 (previousDate instanceof Date\n      && (this._bsValue?.getDate() === previousDate?.getDate())\n      && (this._bsValue?.getMonth() === previousDate?.getMonth())\n      && (this._bsValue?.getFullYear() === previousDate?.getFullYear()));\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(BsDatepickerContainerComponent)\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 datepicker */\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      minMode: this.minMode || this.bsConfig && this.bsConfig.minMode,\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-datepicker.config.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * For date range picker there are `BsDaterangepickerConfig` which inherits all properties,
+ * except `displayMonths`, for range picker it default to `2`
+ */
+export class BsDatepickerConfig {
+    constructor() {
+        /** Sets use adaptive position */
+        this.adaptivePosition = true;
+        this.calendarLang = 'en';
+        this.calendarSize = 'md';
+        this.clearable = true;
+        this.displayMonths = 1;
+        /** turn on/off animation */
+        this.isAnimated = false;
+        this.isMobile = false;
+        /**
+         * Set rule for datepicker closing.
+         * If value is true datepicker closes only if date is changed, if user changes only time datepicker doesn't close.
+         * It is available only if property withTimepicker is set true
+         */
+        this.keepDatepickerOpened = false;
+        /** Prevents change to next month for right calendar in two calendars view (dateRangePicker only) */
+        this.preventChangeToNextMonth = true;
+        /** Makes dates from other months active */
+        this.selectFromOtherMonth = true;
+        /** The view that the datepicker should start in */
+        this.startView = 'day';
+        // DatepickerFormatOptions
+        this.dayLabel = 'D';
+        this.monthLabel = 'MMMM';
+        this.monthTitle = 'MMMM';
+        this.yearLabel = 'YYYY';
+        this.yearTitle = 'YYYY';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BsDatepickerConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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