ngx-bootstrap 7.1.2 → 8.0.0-RC.4

package/datepicker/esm2020/bs-daterangepicker.component.mjs

@@ -0,0 +1,256 @@
+import { Directive, ElementRef, EventEmitter, Input, Output, Renderer2, ViewContainerRef } from '@angular/core';
+import { BsDaterangepickerConfig } from './bs-daterangepicker.config';
+import { BsDaterangepickerContainerComponent } from './themes/bs/bs-daterangepicker-container.component';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { filter, takeUntil } from 'rxjs/operators';
+import { ComponentLoaderFactory } from 'ngx-bootstrap/component-loader';
+import { BsDatepickerConfig } from './bs-datepicker.config';
+import { checkBsValue, checkRangesWithMaxDate, setDateRangesCurrentTimeOnDateSelect } from './utils/bs-calendar-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "./bs-daterangepicker.config";
+import * as i2 from "ngx-bootstrap/component-loader";
+export class BsDaterangepickerDirective {
+    constructor(_config, _elementRef, _renderer, _viewContainerRef, cis) {
+        this._config = _config;
+        this._elementRef = _elementRef;
+        this._renderer = _renderer;
+        /**
+         * Placement of a daterangepicker. Accepts: "top", "bottom", "left", "right"
+         */
+        this.placement = 'bottom';
+        /**
+         * Specifies events that should trigger. Supports a space separated list of
+         * event names.
+         */
+        this.triggers = 'click';
+        /**
+         * Close daterangepicker on outside click
+         */
+        this.outsideClick = true;
+        /**
+         * A selector specifying the element the daterangepicker should be appended to.
+         */
+        this.container = 'body';
+        this.outsideEsc = true;
+        this.isDestroy$ = new Subject();
+        /**
+         * Indicates whether daterangepicker's content is enabled or not
+         */
+        this.isDisabled = false;
+        /**
+         * Emits when daterangepicker value has been changed
+         */
+        this.bsValueChange = new EventEmitter();
+        this._subs = [];
+        this._rangeInputFormat$ = new Subject();
+        this._datepicker = cis.createLoader(_elementRef, _viewContainerRef, _renderer);
+        Object.assign(this, _config);
+        this.onShown = this._datepicker.onShown;
+        this.onHidden = this._datepicker.onHidden;
+        this.isOpen$ = new BehaviorSubject(this.isOpen);
+    }
+    /**
+     * 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;
+        }
+        if (value && this.bsConfig?.initCurrentTime) {
+            value = setDateRangesCurrentTimeOnDateSelect(value);
+        }
+        this._bsValue = value;
+        this.bsValueChange.emit(value);
+    }
+    get rangeInputFormat$() {
+        return this._rangeInputFormat$;
+    }
+    ngOnInit() {
+        this.isDestroy$ = new Subject();
+        this._datepicker.listen({
+            outsideClick: this.outsideClick,
+            outsideEsc: this.outsideEsc,
+            triggers: this.triggers,
+            show: () => this.show()
+        });
+        this.setConfig();
+    }
+    ngOnChanges(changes) {
+        if (changes["bsConfig"]) {
+            if (changes["bsConfig"].currentValue?.initCurrentTime && changes["bsConfig"].currentValue?.initCurrentTime !== changes["bsConfig"].previousValue?.initCurrentTime && this._bsValue) {
+                this._bsValue = setDateRangesCurrentTimeOnDateSelect(this._bsValue);
+                this.bsValueChange.emit(this._bsValue);
+            }
+            this.setConfig();
+            this._rangeInputFormat$.next(changes["bsConfig"].currentValue && changes["bsConfig"].currentValue.rangeInputFormat);
+        }
+        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["datesDisabled"]) {
+            this._datepickerRef.instance.datesDisabled = this.datesDisabled;
+        }
+        if (changes["datesEnabled"]) {
+            this._datepickerRef.instance.datesEnabled = this.datesEnabled;
+        }
+        if (changes["daysDisabled"]) {
+            this._datepickerRef.instance.daysDisabled = this.daysDisabled;
+        }
+        if (changes["isDisabled"]) {
+            if (this._elementRef?.nativeElement) {
+                this._elementRef.nativeElement.setAttribute('readonly', this.isDisabled);
+            }
+            this._datepickerRef.instance.isDisabled = this.isDisabled;
+        }
+        if (changes["dateCustomClasses"]) {
+            this._datepickerRef.instance.dateCustomClasses = this.dateCustomClasses;
+        }
+    }
+    ngAfterViewInit() {
+        this.isOpen$.pipe(filter(isOpen => isOpen !== this.isOpen), takeUntil(this.isDestroy$))
+            .subscribe(() => this.toggle());
+    }
+    /**
+     * Opens an element’s datepicker. This is considered a “manual” triggering of
+     * the datepicker.
+     */
+    show() {
+        if (this._datepicker.isShown) {
+            return;
+        }
+        this.setConfig();
+        this._datepickerRef = this._datepicker
+            .provide({ provide: BsDatepickerConfig, useValue: this._config })
+            .attach(BsDaterangepickerContainerComponent)
+            .to(this.container)
+            .position({ attachment: this.placement })
+            .show({ placement: this.placement });
+        // 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) => range && range[0] && !!range[1]))
+                .subscribe((value) => {
+                this.bsValue = value;
+                this.hide();
+            }));
+        }
+    }
+    /**
+     * 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,
+            minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,
+            maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,
+            daysDisabled: this.daysDisabled || this.bsConfig && this.bsConfig.daysDisabled,
+            dateCustomClasses: this.dateCustomClasses || this.bsConfig && this.bsConfig.dateCustomClasses,
+            datesDisabled: this.datesDisabled || this.bsConfig && this.bsConfig.datesDisabled,
+            datesEnabled: this.datesEnabled || this.bsConfig && this.bsConfig.datesEnabled,
+            ranges: checkRangesWithMaxDate(this.bsConfig && this.bsConfig.ranges, this.maxDate || this.bsConfig && this.bsConfig.maxDate),
+            maxDateRange: this.bsConfig && this.bsConfig.maxDateRange,
+            initCurrentTime: this.bsConfig?.initCurrentTime
+        });
+    }
+    /**
+     * 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();
+        }
+        if (this._config.returnFocusToInput) {
+            this._renderer.selectRootElement(this._elementRef.nativeElement).focus();
+        }
+    }
+    /**
+     * Toggles an element’s datepicker. This is considered a “manual” triggering
+     * of the datepicker.
+     */
+    toggle() {
+        if (this.isOpen) {
+            return this.hide();
+        }
+        this.show();
+    }
+    ngOnDestroy() {
+        this._datepicker.dispose();
+        this.isOpen$.next(false);
+        if (this.isDestroy$) {
+            this.isDestroy$.next(null);
+            this.isDestroy$.complete();
+        }
+    }
+}
+BsDaterangepickerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsDaterangepickerDirective, deps: [{ token: i1.BsDaterangepickerConfig }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i2.ComponentLoaderFactory }], target: i0.ɵɵFactoryTarget.Directive });
+BsDaterangepickerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: BsDaterangepickerDirective, selector: "[bsDaterangepicker]", inputs: { placement: "placement", triggers: "triggers", outsideClick: "outsideClick", container: "container", outsideEsc: "outsideEsc", isOpen: "isOpen", bsValue: "bsValue", bsConfig: "bsConfig", isDisabled: "isDisabled", minDate: "minDate", maxDate: "maxDate", dateCustomClasses: "dateCustomClasses", daysDisabled: "daysDisabled", datesDisabled: "datesDisabled", datesEnabled: "datesEnabled" }, outputs: { onShown: "onShown", onHidden: "onHidden", bsValueChange: "bsValueChange" }, exportAs: ["bsDaterangepicker"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsDaterangepickerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bsDaterangepicker]',
+                    exportAs: 'bsDaterangepicker'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BsDaterangepickerConfig }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i2.ComponentLoaderFactory }]; }, propDecorators: { placement: [{
+                type: Input
+            }], triggers: [{
+                type: Input
+            }], outsideClick: [{
+                type: Input
+            }], container: [{
+                type: Input
+            }], outsideEsc: [{
+                type: Input
+            }], isOpen: [{
+                type: Input
+            }], onShown: [{
+                type: Output
+            }], onHidden: [{
+                type: Output
+            }], bsValue: [{
+                type: Input
+            }], bsConfig: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], dateCustomClasses: [{
+                type: Input
+            }], daysDisabled: [{
+                type: Input
+            }], datesDisabled: [{
+                type: Input
+            }], datesEnabled: [{
+                type: Input
+            }], bsValueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bs-daterangepicker.component.js","sourceRoot":"","sources":["../../../../src/datepicker/bs-daterangepicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ComponentRef,\n  Directive, ElementRef, EventEmitter,\n  Input, OnChanges, OnDestroy, OnInit,\n  Output, Renderer2, SimpleChanges,\n  ViewContainerRef\n} from '@angular/core';\nimport { BsDaterangepickerConfig } from './bs-daterangepicker.config';\nimport { BsDaterangepickerContainerComponent } from './themes/bs/bs-daterangepicker-container.component';\nimport { Observable, Subscription, Subject, BehaviorSubject } from 'rxjs';\nimport { filter, takeUntil } from 'rxjs/operators';\nimport { ComponentLoaderFactory, ComponentLoader } from 'ngx-bootstrap/component-loader';\nimport { BsDatepickerConfig } from './bs-datepicker.config';\nimport { DatepickerDateCustomClasses } from './models';\nimport {\n  checkBsValue,\n  checkRangesWithMaxDate,\n  setDateRangesCurrentTimeOnDateSelect\n} from './utils/bs-calendar-utils';\n\n@Directive({\n  selector: '[bsDaterangepicker]',\n  exportAs: 'bsDaterangepicker'\n})\nexport class BsDaterangepickerDirective\n  implements OnInit, OnDestroy, OnChanges, AfterViewInit {\n  /**\n   * Placement of a daterangepicker. Accepts: \"top\", \"bottom\", \"left\", \"right\"\n   */\n  @Input() placement: 'top' | 'bottom' | 'left' | 'right' = 'bottom';\n  /**\n   * Specifies events that should trigger. Supports a space separated list of\n   * event names.\n   */\n  @Input() triggers = 'click';\n  /**\n   * Close daterangepicker on outside click\n   */\n  @Input() outsideClick = true;\n  /**\n   * A selector specifying the element the daterangepicker should be appended to.\n   */\n  @Input() container = 'body';\n\n  @Input() outsideEsc = true;\n\n  /**\n   * Returns whether or not the daterangepicker is currently being shown\n   */\n  @Input()\n  get isOpen(): boolean {\n    return this._datepicker.isShown;\n  }\n\n  set isOpen(value: boolean) {\n    this.isOpen$.next(value);\n  }\n\n  /**\n   * Emits an event when the daterangepicker is shown\n   */\n  @Output() onShown: EventEmitter<unknown>;\n  /**\n   * Emits an event when the daterangepicker is hidden\n   */\n  @Output() onHidden: EventEmitter<unknown>;\n\n  _bsValue?: (Date|undefined)[];\n  isOpen$: BehaviorSubject<boolean>;\n  isDestroy$ = new Subject();\n\n  /**\n   * Initial value of daterangepicker\n   */\n  @Input()\n  set bsValue(value: (Date|undefined)[] | undefined) {\n    if (this._bsValue === value) {\n      return;\n    }\n\n    if (value && this.bsConfig?.initCurrentTime) {\n      value = setDateRangesCurrentTimeOnDateSelect(value);\n    }\n\n    this._bsValue = value;\n    this.bsValueChange.emit(value);\n  }\n\n  /**\n   * Config object for daterangepicker\n   */\n  @Input() bsConfig?: Partial<BsDaterangepickerConfig>;\n  /**\n   * Indicates whether daterangepicker's content is enabled or not\n   */\n  @Input() isDisabled = false;\n  /**\n   * Minimum date which is available for selection\n   */\n  @Input() minDate?: Date;\n  /**\n   * Maximum date which is available for selection\n   */\n  @Input() maxDate?: Date;\n  /**\n   * Date custom classes\n   */\n  @Input() dateCustomClasses?: DatepickerDateCustomClasses[];\n  /**\n   * Disable specific days, e.g. [0,6] will disable all Saturdays and Sundays\n   */\n  @Input() daysDisabled?: number[];\n  /**\n   * Disable specific dates\n   */\n  @Input() datesDisabled?: Date[];\n\n  /**\n   * Enable specific dates\n   */\n  @Input() datesEnabled?: Date[];\n  /**\n   * Emits when daterangepicker value has been changed\n   */\n  @Output() bsValueChange = new EventEmitter<((Date|undefined)[]|undefined)>();\n\n  get rangeInputFormat$(): Observable<string> {\n    return this._rangeInputFormat$;\n  }\n\n  protected _subs: Subscription[] = [];\n  private _datepicker: ComponentLoader<BsDaterangepickerContainerComponent>;\n  private _datepickerRef?: ComponentRef<BsDaterangepickerContainerComponent>;\n  private readonly _rangeInputFormat$ = new Subject<string>();\n\n  constructor(public _config: BsDaterangepickerConfig,\n              private  _elementRef: ElementRef,\n              private  _renderer: Renderer2,\n              _viewContainerRef: ViewContainerRef,\n              cis: ComponentLoaderFactory) {\n    this._datepicker = cis.createLoader<BsDaterangepickerContainerComponent>(\n      _elementRef,\n      _viewContainerRef,\n      _renderer\n    );\n    Object.assign(this, _config);\n    this.onShown = this._datepicker.onShown;\n    this.onHidden = this._datepicker.onHidden;\n    this.isOpen$ = new BehaviorSubject(this.isOpen);\n  }\n\n  ngOnInit(): void {\n    this.isDestroy$ = new Subject();\n    this._datepicker.listen({\n      outsideClick: this.outsideClick,\n      outsideEsc: this.outsideEsc,\n      triggers: this.triggers,\n      show: () => this.show()\n    });\n    this.setConfig();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes[\"bsConfig\"]) {\n      if (changes[\"bsConfig\"].currentValue?.initCurrentTime && changes[\"bsConfig\"].currentValue?.initCurrentTime !== changes[\"bsConfig\"].previousValue?.initCurrentTime && this._bsValue) {\n        this._bsValue = setDateRangesCurrentTimeOnDateSelect(this._bsValue);\n        this.bsValueChange.emit(this._bsValue);\n      }\n\n      this.setConfig();\n      this._rangeInputFormat$.next(changes[\"bsConfig\"].currentValue && changes[\"bsConfig\"].currentValue.rangeInputFormat);\n    }\n\n\n    if (!this._datepickerRef || !this._datepickerRef.instance) {\n      return;\n    }\n    if (changes[\"minDate\"]) {\n      this._datepickerRef.instance.minDate = this.minDate;\n    }\n    if (changes[\"maxDate\"]) {\n      this._datepickerRef.instance.maxDate = this.maxDate;\n    }\n    if (changes[\"datesDisabled\"]) {\n      this._datepickerRef.instance.datesDisabled = this.datesDisabled;\n    }\n    if (changes[\"datesEnabled\"]) {\n      this._datepickerRef.instance.datesEnabled = this.datesEnabled;\n    }\n    if (changes[\"daysDisabled\"]) {\n      this._datepickerRef.instance.daysDisabled = this.daysDisabled;\n    }\n    if (changes[\"isDisabled\"]) {\n      if (this._elementRef?.nativeElement) {\n        this._elementRef.nativeElement.setAttribute('readonly', this.isDisabled);\n      }\n      this._datepickerRef.instance.isDisabled = this.isDisabled;\n    }\n    if (changes[\"dateCustomClasses\"]) {\n      this._datepickerRef.instance.dateCustomClasses = this.dateCustomClasses;\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.isOpen$.pipe(\n      filter(isOpen => isOpen !== this.isOpen),\n      takeUntil(this.isDestroy$)\n    )\n      .subscribe(() => this.toggle());\n  }\n\n  /**\n   * Opens an element’s datepicker. This is considered a “manual” triggering of\n   * the datepicker.\n   */\n  show(): void {\n    if (this._datepicker.isShown) {\n      return;\n    }\n\n    this.setConfig();\n\n    this._datepickerRef = this._datepicker\n      .provide({ provide: BsDatepickerConfig, useValue: this._config })\n      .attach(BsDaterangepickerContainerComponent)\n      .to(this.container)\n      .position({ attachment: this.placement })\n      .show({ placement: this.placement });\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(\n            filter((range: Date[]) => range && range[0] && !!range[1])\n          )\n          .subscribe((value: Date[]) => {\n            this.bsValue = value;\n            this.hide();\n          })\n      );\n    }\n  }\n\n  /**\n   * Set config for daterangepicker\n   */\n  setConfig() {\n    this._config = Object.assign(\n      {},\n      this._config,\n      this.bsConfig,\n      {\n        value: checkBsValue(this._bsValue, this.maxDate || this.bsConfig && this.bsConfig.maxDate),\n        isDisabled: this.isDisabled,\n        minDate: this.minDate || this.bsConfig && this.bsConfig.minDate,\n        maxDate: this.maxDate || this.bsConfig && this.bsConfig.maxDate,\n        daysDisabled: this.daysDisabled || this.bsConfig && this.bsConfig.daysDisabled,\n        dateCustomClasses: this.dateCustomClasses || this.bsConfig && this.bsConfig.dateCustomClasses,\n        datesDisabled: this.datesDisabled || this.bsConfig && this.bsConfig.datesDisabled,\n        datesEnabled: this.datesEnabled || this.bsConfig && this.bsConfig.datesEnabled,\n        ranges: checkRangesWithMaxDate(this.bsConfig && this.bsConfig.ranges, this.maxDate || this.bsConfig && this.bsConfig.maxDate),\n        maxDateRange: this.bsConfig && this.bsConfig.maxDateRange,\n        initCurrentTime: this.bsConfig?.initCurrentTime\n      }\n    );\n  }\n\n  /**\n   * Closes an element’s datepicker. This is considered a “manual” triggering of\n   * the datepicker.\n   */\n  hide(): void {\n    if (this.isOpen) {\n      this._datepicker.hide();\n    }\n    for (const sub of this._subs) {\n      sub.unsubscribe();\n    }\n\n    if (this._config.returnFocusToInput) {\n      this._renderer.selectRootElement(this._elementRef.nativeElement).focus();\n    }\n  }\n\n  /**\n   * Toggles an element’s datepicker. This is considered a “manual” triggering\n   * of the datepicker.\n   */\n  toggle(): void {\n    if (this.isOpen) {\n      return this.hide();\n    }\n\n    this.show();\n  }\n\n  ngOnDestroy(): void {\n    this._datepicker.dispose();\n    this.isOpen$.next(false);\n    if (this.isDestroy$) {\n      this.isDestroy$.next(null);\n      this.isDestroy$.complete();\n    }\n  }\n}\n"]}

package/datepicker/esm2020/bs-daterangepicker.config.mjs

@@ -0,0 +1,19 @@
+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);
+        // DatepickerRenderOptions
+        this.displayMonths = 2;
+    }
+}
+BsDaterangepickerConfig.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsDaterangepickerConfig, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BsDaterangepickerConfig.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsDaterangepickerConfig, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsDaterangepickerConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnMtZGF0ZXJhbmdlcGlja2VyLmNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kYXRlcGlja2VyL2JzLWRhdGVyYW5nZXBpY2tlci5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFLNUQsTUFBTSxPQUFPLHVCQUF3QixTQUFRLGtCQUFrQjtJQUgvRDs7UUFJRSwwQkFBMEI7UUFDakIsa0JBQWEsR0FBRyxDQUFDLENBQUM7S0FDNUI7O29IQUhZLHVCQUF1Qjt3SEFBdkIsdUJBQXVCLGNBRnRCLE1BQU07MkZBRVAsdUJBQXVCO2tCQUhuQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEJzRGF0ZXBpY2tlckNvbmZpZyB9IGZyb20gJy4vYnMtZGF0ZXBpY2tlci5jb25maWcnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBCc0RhdGVyYW5nZXBpY2tlckNvbmZpZyBleHRlbmRzIEJzRGF0ZXBpY2tlckNvbmZpZyB7XG4gIC8vIERhdGVwaWNrZXJSZW5kZXJPcHRpb25zXG4gIG92ZXJyaWRlIGRpc3BsYXlNb250aHMgPSAyO1xufVxuIl19

package/datepicker/esm2020/bs-locale.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class BsLocaleService {
+    constructor() {
+        this._defaultLocale = 'en';
+        this._locale = new BehaviorSubject(this._defaultLocale);
+        this._localeChange = this._locale.asObservable();
+    }
+    get locale() {
+        return this._locale;
+    }
+    get localeChange() {
+        return this._localeChange;
+    }
+    get currentLocale() {
+        return this._locale.getValue();
+    }
+    use(locale) {
+        if (locale === this.currentLocale) {
+            return;
+        }
+        this._locale.next(locale);
+    }
+}
+BsLocaleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsLocaleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+BsLocaleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsLocaleService, providedIn: 'platform' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BsLocaleService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'platform' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm2020/datepicker-animations.mjs

@@ -0,0 +1,16 @@
+import { animate, style, state, transition, trigger } from '@angular/animations';
+export const DATEPICKER_ANIMATION_TIMING = '220ms cubic-bezier(0, 0, 0.2, 1)';
+export const datepickerAnimation = trigger('datepickerAnimation', [
+    state('animated-down', style({ height: '*', overflow: 'hidden' })),
+    transition('* => animated-down', [
+        style({ height: 0, overflow: 'hidden' }),
+        animate(DATEPICKER_ANIMATION_TIMING)
+    ]),
+    state('animated-up', style({ height: '*', overflow: 'hidden' })),
+    transition('* => animated-up', [
+        style({ height: '*', overflow: 'hidden' }),
+        animate(DATEPICKER_ANIMATION_TIMING)
+    ]),
+    transition('* => unanimated', animate('0s'))
+]);
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm2020/engine/calc-days-calendar.mjs

@@ -0,0 +1,21 @@
+// user and model input should handle parsing and validating input values
+import { getFirstDayOfMonth } from 'ngx-bootstrap/chronos';
+import { getStartingDayOfCalendar } from '../utils/bs-calendar-utils';
+import { createMatrix } from '../utils/matrix-utils';
+export function calcDaysCalendar(startingDate, options) {
+    const firstDay = getFirstDayOfMonth(startingDate);
+    const initialDate = getStartingDayOfCalendar(firstDay, options);
+    // todo test
+    const matrixOptions = {
+        width: options.width || 0,
+        height: options.height || 0,
+        initialDate,
+        shift: { day: 1 }
+    };
+    const daysMatrix = createMatrix(matrixOptions, date => date);
+    return {
+        daysMatrix,
+        month: firstDay
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm2020/engine/flag-days-calendar.mjs

@@ -0,0 +1,93 @@
+import { isAfter, isBefore, isDisabledDay, isSameDay, isSameMonth, shiftDate } from 'ngx-bootstrap/chronos';
+import { isMonthDisabled, isDisabledDate, isEnabledDate } from '../utils/bs-calendar-utils';
+export function flagDaysCalendar(formattedMonth, options) {
+    formattedMonth.weeks.forEach((week) => {
+        week.days.forEach((day, dayIndex) => {
+            // datepicker
+            const isOtherMonth = !isSameMonth(day.date, formattedMonth.month);
+            const isHovered = !isOtherMonth && isSameDay(day.date, options.hoveredDate);
+            // date range picker
+            const isSelectionStart = !isOtherMonth &&
+                options.selectedRange &&
+                isSameDay(day.date, options.selectedRange[0]);
+            const isSelectionEnd = !isOtherMonth &&
+                options.selectedRange &&
+                isSameDay(day.date, options.selectedRange[1]);
+            const isSelected = (!isOtherMonth && isSameDay(day.date, options.selectedDate)) ||
+                isSelectionStart ||
+                isSelectionEnd;
+            const isInRange = !isOtherMonth &&
+                options.selectedRange &&
+                isDateInRange(day.date, options.selectedRange, options.hoveredDate);
+            const isDisabled = options.isDisabled ||
+                isBefore(day.date, options.minDate, 'day') ||
+                isAfter(day.date, options.maxDate, 'day') ||
+                isDisabledDay(day.date, options.daysDisabled) ||
+                isDisabledDate(day.date, options.datesDisabled) ||
+                isEnabledDate(day.date, options.datesEnabled);
+            const currentDate = new Date();
+            const isToday = !isOtherMonth && isSameDay(day.date, currentDate);
+            const customClasses = options.dateCustomClasses && options.dateCustomClasses
+                .map(dcc => isSameDay(day.date, dcc.date) ? dcc.classes : [])
+                .reduce((previousValue, currentValue) => previousValue.concat(currentValue), [])
+                .join(' ')
+                || '';
+            const tooltipText = options.dateTooltipTexts && options.dateTooltipTexts
+                .map(tt => isSameDay(day.date, tt.date) ? tt.tooltipText : '')
+                .reduce((previousValue, currentValue) => {
+                previousValue.push(currentValue);
+                return previousValue;
+            }, [])
+                .join(' ')
+                || '';
+            // decide update or not
+            const newDay = Object.assign({}, day, {
+                isOtherMonth,
+                isHovered,
+                isSelected,
+                isSelectionStart,
+                isSelectionEnd,
+                isInRange,
+                isDisabled,
+                isToday,
+                customClasses,
+                tooltipText
+            });
+            if (day.isOtherMonth !== newDay.isOtherMonth ||
+                day.isHovered !== newDay.isHovered ||
+                day.isSelected !== newDay.isSelected ||
+                day.isSelectionStart !== newDay.isSelectionStart ||
+                day.isSelectionEnd !== newDay.isSelectionEnd ||
+                day.isDisabled !== newDay.isDisabled ||
+                day.isInRange !== newDay.isInRange ||
+                day.customClasses !== newDay.customClasses ||
+                day.tooltipText !== newDay.tooltipText) {
+                week.days[dayIndex] = newDay;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    formattedMonth.hideLeftArrow =
+        options.isDisabled ||
+            (!!options.monthIndex && options.monthIndex > 0 && options.monthIndex !== options.displayMonths);
+    formattedMonth.hideRightArrow =
+        options.isDisabled ||
+            ((!!options.monthIndex || options.monthIndex === 0) && !!options.displayMonths && options.monthIndex < options.displayMonths &&
+                options.monthIndex + 1 !== options.displayMonths);
+    formattedMonth.disableLeftArrow = isMonthDisabled(shiftDate(formattedMonth.month, { month: -1 }), options.minDate, options.maxDate);
+    formattedMonth.disableRightArrow = isMonthDisabled(shiftDate(formattedMonth.month, { month: 1 }), options.minDate, options.maxDate);
+    return formattedMonth;
+}
+function isDateInRange(date, selectedRange, hoveredDate) {
+    if (!date || !selectedRange || !selectedRange[0]) {
+        return false;
+    }
+    if (selectedRange[1]) {
+        return date > selectedRange[0] && date <= selectedRange[1];
+    }
+    if (hoveredDate) {
+        return date > selectedRange[0] && date <= hoveredDate;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flag-days-calendar.js","sourceRoot":"","sources":["../../../../../src/datepicker/engine/flag-days-calendar.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DaysCalendarViewModel,\n  DayViewModel,\n  WeekViewModel,\n  DatepickerDateCustomClasses,\n  DatepickerDateTooltipText\n} from '../models';\n\nimport {\n  isAfter,\n  isBefore,\n  isDisabledDay,\n  isSameDay,\n  isSameMonth,\n  shiftDate\n} from 'ngx-bootstrap/chronos';\n\nimport { isMonthDisabled, isDisabledDate, isEnabledDate } from '../utils/bs-calendar-utils';\n\nexport interface FlagDaysCalendarOptions {\n  isDisabled: boolean;\n  minDate: Date;\n  maxDate: Date;\n  daysDisabled: number[];\n  datesDisabled: Date[];\n  datesEnabled: Date[];\n  hoveredDate: Date;\n  selectedDate: Date;\n  selectedRange: Date[];\n  displayMonths: number;\n  monthIndex: number;\n  dateCustomClasses: DatepickerDateCustomClasses[];\n  dateTooltipTexts: DatepickerDateTooltipText[];\n}\n\nexport function flagDaysCalendar(\n  formattedMonth: DaysCalendarViewModel,\n  options: Partial<FlagDaysCalendarOptions>\n): DaysCalendarViewModel {\n  formattedMonth.weeks.forEach((week: WeekViewModel) => {\n        week.days.forEach((day: DayViewModel, dayIndex: number) => {\n      // datepicker\n      const isOtherMonth = !isSameMonth(day.date, formattedMonth.month);\n\n      const isHovered =\n        !isOtherMonth && isSameDay(day.date, options.hoveredDate);\n      // date range picker\n      const isSelectionStart =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isSameDay(day.date, options.selectedRange[0]);\n      const isSelectionEnd =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isSameDay(day.date, options.selectedRange[1]);\n\n      const isSelected =\n        (!isOtherMonth && isSameDay(day.date, options.selectedDate)) ||\n        isSelectionStart ||\n        isSelectionEnd;\n\n      const isInRange =\n        !isOtherMonth &&\n        options.selectedRange &&\n        isDateInRange(day.date, options.selectedRange, options.hoveredDate);\n\n      const isDisabled =\n        options.isDisabled ||\n        isBefore(day.date, options.minDate, 'day') ||\n        isAfter(day.date, options.maxDate, 'day') ||\n        isDisabledDay(day.date, options.daysDisabled) ||\n        isDisabledDate(day.date, options.datesDisabled) ||\n        isEnabledDate(day.date, options.datesEnabled);\n\n      const currentDate = new Date();\n      const isToday = !isOtherMonth && isSameDay(day.date, currentDate);\n\n      const customClasses = options.dateCustomClasses && options.dateCustomClasses\n        .map(dcc => isSameDay(day.date, dcc.date) ? dcc.classes : [])\n        .reduce((previousValue, currentValue) => previousValue.concat(currentValue), [])\n        .join(' ')\n        || '';\n\n      const tooltipText = options.dateTooltipTexts && options.dateTooltipTexts\n          .map(tt => isSameDay(day.date, tt.date) ? tt.tooltipText : '')\n          .reduce((previousValue, currentValue) => {\n            previousValue.push(currentValue);\n            return previousValue;\n          }, [] as string[])\n          .join(' ')\n        || '';\n\n      // decide update or not\n      const newDay = Object.assign({}, day, {\n        isOtherMonth,\n        isHovered,\n        isSelected,\n        isSelectionStart,\n        isSelectionEnd,\n        isInRange,\n        isDisabled,\n        isToday,\n        customClasses,\n        tooltipText\n      });\n\n      if (\n        day.isOtherMonth !== newDay.isOtherMonth ||\n        day.isHovered !== newDay.isHovered ||\n        day.isSelected !== newDay.isSelected ||\n        day.isSelectionStart !== newDay.isSelectionStart ||\n        day.isSelectionEnd !== newDay.isSelectionEnd ||\n        day.isDisabled !== newDay.isDisabled ||\n        day.isInRange !== newDay.isInRange ||\n        day.customClasses !== newDay.customClasses ||\n        day.tooltipText !== newDay.tooltipText\n      ) {\n        week.days[dayIndex] = newDay;\n      }\n    });\n  });\n\n  // todo: add check for linked calendars\n  formattedMonth.hideLeftArrow =\n    options.isDisabled ||\n    (!!options.monthIndex && options.monthIndex > 0 && options.monthIndex !== options.displayMonths);\n  formattedMonth.hideRightArrow =\n    options.isDisabled ||\n    ((!!options.monthIndex || options.monthIndex === 0) && !!options.displayMonths && options.monthIndex < options.displayMonths &&\n      options.monthIndex + 1 !== options.displayMonths);\n\n  formattedMonth.disableLeftArrow = isMonthDisabled(\n    shiftDate(formattedMonth.month, { month: -1 }),\n    options.minDate,\n    options.maxDate\n  );\n  formattedMonth.disableRightArrow = isMonthDisabled(\n    shiftDate(formattedMonth.month, { month: 1 }),\n    options.minDate,\n    options.maxDate\n  );\n  return formattedMonth;\n}\n\nfunction isDateInRange(\n  date: Date,\n  selectedRange?: Date[],\n  hoveredDate?: Date\n): boolean {\n  if (!date || !selectedRange || !selectedRange[0]) {\n    return false;\n  }\n\n  if (selectedRange[1]) {\n    return date > selectedRange[0] && date <= selectedRange[1];\n  }\n\n  if (hoveredDate) {\n    return date > selectedRange[0] && date <= hoveredDate;\n  }\n\n  return false;\n}\n"]}

package/datepicker/esm2020/engine/flag-months-calendar.mjs

@@ -0,0 +1,45 @@
+import { isSameMonth, shiftDate } from 'ngx-bootstrap/chronos';
+import { isDisabledDate, isEnabledDate, isMonthDisabled, isYearDisabled } from '../utils/bs-calendar-utils';
+export function flagMonthsCalendar(monthCalendar, options) {
+    monthCalendar.months.forEach((months, rowIndex) => {
+        months.forEach((month, monthIndex) => {
+            let isSelected;
+            const isHovered = isSameMonth(month.date, options.hoveredMonth);
+            const isDisabled = options.isDisabled ||
+                isDisabledDate(month.date, options.datesDisabled) ||
+                isEnabledDate(month.date, options.datesEnabled) ||
+                isMonthDisabled(month.date, options.minDate, options.maxDate);
+            if (!options.selectedDate && options.selectedRange) {
+                isSelected = isSameMonth(month.date, options.selectedRange[0]);
+                if (!isSelected) {
+                    isSelected = isSameMonth(month.date, options.selectedRange[1]);
+                }
+            }
+            else {
+                isSelected = isSameMonth(month.date, options.selectedDate);
+            }
+            const newMonth = Object.assign(/*{},*/ month, {
+                isHovered,
+                isDisabled,
+                isSelected
+            });
+            if (month.isHovered !== newMonth.isHovered ||
+                month.isDisabled !== newMonth.isDisabled ||
+                month.isSelected !== newMonth.isSelected) {
+                monthCalendar.months[rowIndex][monthIndex] = newMonth;
+            }
+        });
+    });
+    // todo: add check for linked calendars
+    monthCalendar.hideLeftArrow =
+        !!options.monthIndex && options.monthIndex > 0 && options.monthIndex !== options.displayMonths;
+    monthCalendar.hideRightArrow =
+        (!!options.monthIndex || options.monthIndex === 0)
+            && (!!options.displayMonths || options.displayMonths === 0)
+            && options.monthIndex < options.displayMonths
+            && options.monthIndex + 1 !== options.displayMonths;
+    monthCalendar.disableLeftArrow = isYearDisabled(shiftDate(monthCalendar.months[0][0].date, { year: -1 }), options.minDate, options.maxDate);
+    monthCalendar.disableRightArrow = isYearDisabled(shiftDate(monthCalendar.months[0][0].date, { year: 1 }), options.minDate, options.maxDate);
+    return monthCalendar;
+}
+//# sourceMappingURL=data:application/json;base64,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