nxt-pick-datetime 10.0.0 → 13.0.0

package/esm2020/lib/dialog/dialog.service.mjs

@@ -0,0 +1,240 @@
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, TemplateRef } from '@angular/core';
+import { defer, of, Subject } from 'rxjs';
+import { concatAll } from 'rxjs/operators';
+import { OwlDialogConfig } from '../class/dialog-config.class';
+import { OwlDialogRef } from '../class/dialog-ref.class';
+import { extendObject } from '../utils/object';
+import { OwlDialogContainerComponent } from './dialog-container/dialog-container.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/common";
+import * as i3 from "../class/dialog-config.class";
+export const OWL_DIALOG_DATA = new InjectionToken('OwlDialogData');
+/**
+ * Injection token that determines the scroll handling while the dialog is open.
+ * */
+export const OWL_DIALOG_SCROLL_STRATEGY = new InjectionToken('owl-dialog-scroll-strategy');
+export function OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+    const fn = () => overlay.scrollStrategies.block();
+    return fn;
+}
+/** @docs-private */
+export const OWL_DIALOG_SCROLL_STRATEGY_PROVIDER = {
+    provide: OWL_DIALOG_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY
+};
+/** I
+ * njection token that can be used to specify default dialog options.
+ * */
+export const OWL_DIALOG_DEFAULT_OPTIONS = new InjectionToken('owl-dialog-default-options');
+export class OwlDialogService {
+    constructor(overlay, injector, location, scrollStrategy, defaultOptions, parentDialog, overlayContainer) {
+        this.overlay = overlay;
+        this.injector = injector;
+        this.location = location;
+        this.defaultOptions = defaultOptions;
+        this.parentDialog = parentDialog;
+        this.overlayContainer = overlayContainer;
+        this.ariaHiddenElements = new Map();
+        this._openDialogsAtThisLevel = [];
+        this._afterOpenAtThisLevel = new Subject();
+        this._afterAllClosedAtThisLevel = new Subject();
+        /**
+         * Stream that emits when all open dialog have finished closing.
+         * Will emit on subscribe if there are no open dialogs to begin with.
+         */
+        this.afterAllClosed = defer(() => this._openDialogsAtThisLevel.length
+            ? this._afterAllClosed
+            : of([undefined], this._afterAllClosed).pipe(concatAll()));
+        this.scrollStrategy = scrollStrategy;
+        if (!parentDialog && location) {
+            location.subscribe(() => this.closeAll());
+        }
+    }
+    /** Keeps track of the currently-open dialogs. */
+    get openDialogs() {
+        return this.parentDialog
+            ? this.parentDialog.openDialogs
+            : this._openDialogsAtThisLevel;
+    }
+    /** Stream that emits when a dialog has been opened. */
+    get afterOpen() {
+        return this.parentDialog
+            ? this.parentDialog.afterOpen
+            : this._afterOpenAtThisLevel;
+    }
+    get _afterAllClosed() {
+        const parent = this.parentDialog;
+        return parent
+            ? parent._afterAllClosed
+            : this._afterAllClosedAtThisLevel;
+    }
+    open(componentOrTemplateRef, config) {
+        config = applyConfigDefaults(config, this.defaultOptions);
+        if (config.id && this.getDialogById(config.id)) {
+            throw Error(`Dialog with id "${config.id}" exists already. The dialog id must be unique.`);
+        }
+        const overlayRef = this.createOverlay(config);
+        const dialogContainer = this.attachDialogContainer(overlayRef, config);
+        const dialogRef = this.attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config);
+        if (!this.openDialogs.length) {
+            this.hideNonDialogContentFromAssistiveTechnology();
+        }
+        this.openDialogs.push(dialogRef);
+        dialogRef
+            .afterClosed()
+            .subscribe(() => this.removeOpenDialog(dialogRef));
+        this.afterOpen.next(dialogRef);
+        return dialogRef;
+    }
+    /**
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll() {
+        let i = this.openDialogs.length;
+        while (i--) {
+            this.openDialogs[i].close();
+        }
+    }
+    /**
+     * Finds an open dialog by its id.
+     *
+     * @param id ID to use when looking up the dialog.
+     */
+    getDialogById(id) {
+        return this.openDialogs.find(dialog => dialog.id === id);
+    }
+    attachDialogContent(componentOrTemplateRef, dialogContainer, overlayRef, config) {
+        const dialogRef = new OwlDialogRef(overlayRef, dialogContainer, config.id, this.location);
+        if (config.hasBackdrop) {
+            overlayRef.backdropClick().subscribe(() => {
+                if (!dialogRef.disableClose) {
+                    dialogRef.close();
+                }
+            });
+        }
+        if (componentOrTemplateRef instanceof TemplateRef) {
+        }
+        else {
+            const injector = this.createInjector(config, dialogRef, dialogContainer);
+            const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, undefined, injector));
+            dialogRef.componentInstance = contentRef.instance;
+        }
+        dialogRef
+            .updateSize(config.width, config.height)
+            .updatePosition(config.position);
+        return dialogRef;
+    }
+    createInjector(config, dialogRef, dialogContainer) {
+        const userInjector = config &&
+            config.viewContainerRef &&
+            config.viewContainerRef.injector;
+        return Injector.create({
+            providers: [
+                { provide: OwlDialogRef, useValue: dialogRef },
+                { provide: OwlDialogContainerComponent, useValue: dialogContainer },
+                { provide: OWL_DIALOG_DATA, useValue: config.data }
+            ],
+            parent: userInjector || this.injector
+        });
+    }
+    createOverlay(config) {
+        const overlayConfig = this.getOverlayConfig(config);
+        return this.overlay.create(overlayConfig);
+    }
+    attachDialogContainer(overlayRef, config) {
+        const containerPortal = new ComponentPortal(OwlDialogContainerComponent, config.viewContainerRef);
+        const containerRef = overlayRef.attach(containerPortal);
+        containerRef.instance.setConfig(config);
+        return containerRef.instance;
+    }
+    getOverlayConfig(dialogConfig) {
+        const state = new OverlayConfig({
+            positionStrategy: this.overlay.position().global(),
+            scrollStrategy: dialogConfig.scrollStrategy || this.scrollStrategy(),
+            panelClass: dialogConfig.paneClass,
+            hasBackdrop: dialogConfig.hasBackdrop,
+            minWidth: dialogConfig.minWidth,
+            minHeight: dialogConfig.minHeight,
+            maxWidth: dialogConfig.maxWidth,
+            maxHeight: dialogConfig.maxHeight
+        });
+        if (dialogConfig.backdropClass) {
+            state.backdropClass = dialogConfig.backdropClass;
+        }
+        return state;
+    }
+    removeOpenDialog(dialogRef) {
+        const index = this._openDialogsAtThisLevel.indexOf(dialogRef);
+        if (index > -1) {
+            this.openDialogs.splice(index, 1);
+            // If all the dialogs were closed, remove/restore the `aria-hidden`
+            // to a the siblings and emit to the `afterAllClosed` stream.
+            if (!this.openDialogs.length) {
+                this.ariaHiddenElements.forEach((previousValue, element) => {
+                    if (previousValue) {
+                        element.setAttribute('aria-hidden', previousValue);
+                    }
+                    else {
+                        element.removeAttribute('aria-hidden');
+                    }
+                });
+                this.ariaHiddenElements.clear();
+                this._afterAllClosed.next();
+            }
+        }
+    }
+    /**
+     * Hides all of the content that isn't an overlay from assistive technology.
+     */
+    hideNonDialogContentFromAssistiveTechnology() {
+        const overlayContainer = this.overlayContainer.getContainerElement();
+        // Ensure that the overlay container is attached to the DOM.
+        if (overlayContainer.parentElement) {
+            const siblings = overlayContainer.parentElement.children;
+            for (let i = siblings.length - 1; i > -1; i--) {
+                const sibling = siblings[i];
+                if (sibling !== overlayContainer &&
+                    sibling.nodeName !== 'SCRIPT' &&
+                    sibling.nodeName !== 'STYLE' &&
+                    !sibling.hasAttribute('aria-live')) {
+                    this.ariaHiddenElements.set(sibling, sibling.getAttribute('aria-hidden'));
+                    sibling.setAttribute('aria-hidden', 'true');
+                }
+            }
+        }
+    }
+}
+OwlDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlDialogService, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: i2.Location, optional: true }, { token: OWL_DIALOG_SCROLL_STRATEGY }, { token: OWL_DIALOG_DEFAULT_OPTIONS, optional: true }, { token: OwlDialogService, optional: true, skipSelf: true }, { token: i1.OverlayContainer }], target: i0.ɵɵFactoryTarget.Injectable });
+OwlDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlDialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlDialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.Location, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [OWL_DIALOG_SCROLL_STRATEGY]
+                }] }, { type: i3.OwlDialogConfig, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DIALOG_DEFAULT_OPTIONS]
+                }] }, { type: OwlDialogService, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i1.OverlayContainer }]; } });
+/**
+ * Applies default options to the dialog config.
+ *
+ * @param config Config to be modified.
+ * @param defaultOptions Default config setting
+ * @returns The new configuration object.
+ */
+function applyConfigDefaults(config, defaultOptions) {
+    return extendObject(new OwlDialogConfig(), config, defaultOptions);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../projects/nxt-pick-datetime/src/lib/dialog/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Overlay, OverlayConfig, OverlayContainer, OverlayRef, ScrollStrategy } from '@angular/cdk/overlay'\nimport { ComponentPortal, ComponentType } from '@angular/cdk/portal'\nimport { Location } from '@angular/common'\nimport { ComponentRef, Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, TemplateRef } from '@angular/core'\nimport { defer, Observable, of, Subject } from 'rxjs'\nimport { concatAll } from 'rxjs/operators'\nimport { OwlDialogConfig } from '../class/dialog-config.class'\nimport { OwlDialogRef } from '../class/dialog-ref.class'\nimport { extendObject } from '../utils/object'\nimport { OwlDialogContainerComponent } from './dialog-container/dialog-container.component'\n\nexport const OWL_DIALOG_DATA = new InjectionToken<any>('OwlDialogData')\n\n/**\n * Injection token that determines the scroll handling while the dialog is open.\n * */\nexport const OWL_DIALOG_SCROLL_STRATEGY = new InjectionToken<\n    () => ScrollStrategy\n>('owl-dialog-scroll-strategy')\n\nexport function OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(\n    overlay: Overlay\n): () => ScrollStrategy {\n    const fn = () => overlay.scrollStrategies.block()\n    return fn\n}\n\n/** @docs-private */\nexport const OWL_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n    provide: OWL_DIALOG_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY\n}\n\n/** I\n * njection token that can be used to specify default dialog options.\n * */\nexport const OWL_DIALOG_DEFAULT_OPTIONS = new InjectionToken<OwlDialogConfig>(\n    'owl-dialog-default-options'\n)\n\n@Injectable()\nexport class OwlDialogService {\n    private ariaHiddenElements = new Map<Element, string | null>()\n\n    private _openDialogsAtThisLevel: OwlDialogRef<any>[] = []\n    private _afterOpenAtThisLevel = new Subject<OwlDialogRef<any>>()\n    private _afterAllClosedAtThisLevel = new Subject<void>()\n\n    /** Keeps track of the currently-open dialogs. */\n    get openDialogs(): OwlDialogRef<any>[] {\n        return this.parentDialog\n            ? this.parentDialog.openDialogs\n            : this._openDialogsAtThisLevel\n    }\n\n    /** Stream that emits when a dialog has been opened. */\n    get afterOpen(): Subject<OwlDialogRef<any>> {\n        return this.parentDialog\n            ? this.parentDialog.afterOpen\n            : this._afterOpenAtThisLevel\n    }\n\n    get _afterAllClosed(): Subject<void> {\n        const parent = this.parentDialog\n        return parent\n            ? parent._afterAllClosed\n            : this._afterAllClosedAtThisLevel\n    }\n\n    /**\n     * Stream that emits when all open dialog have finished closing.\n     * Will emit on subscribe if there are no open dialogs to begin with.\n     */\n\n    afterAllClosed: Observable<Record<string, unknown>> = defer(\n        () =>\n            this._openDialogsAtThisLevel.length\n                ? this._afterAllClosed\n                : of([undefined], this._afterAllClosed).pipe(concatAll())\n    )\n\n    private scrollStrategy: () => ScrollStrategy\n\n    constructor(\n        private overlay: Overlay,\n        private injector: Injector,\n        @Optional() private location: Location,\n        @Inject(OWL_DIALOG_SCROLL_STRATEGY) scrollStrategy: any,\n        @Optional()\n        @Inject(OWL_DIALOG_DEFAULT_OPTIONS)\n        private defaultOptions: OwlDialogConfig,\n        @Optional()\n        @SkipSelf()\n        private parentDialog: OwlDialogService,\n        private overlayContainer: OverlayContainer\n    ) {\n        this.scrollStrategy = scrollStrategy\n        if (!parentDialog && location) {\n            location.subscribe(() => this.closeAll())\n        }\n    }\n\n    public open<T>(\n        componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n        config?: OwlDialogConfig\n    ): OwlDialogRef<any> {\n        config = applyConfigDefaults(config, this.defaultOptions)\n\n        if (config.id && this.getDialogById(config.id)) {\n            throw Error(\n                `Dialog with id \"${config.id\n                }\" exists already. The dialog id must be unique.`\n            )\n        }\n\n        const overlayRef = this.createOverlay(config)\n        const dialogContainer = this.attachDialogContainer(overlayRef, config)\n        const dialogRef = this.attachDialogContent<T>(\n            componentOrTemplateRef,\n            dialogContainer,\n            overlayRef,\n            config\n        )\n\n        if (!this.openDialogs.length) {\n            this.hideNonDialogContentFromAssistiveTechnology()\n        }\n\n        this.openDialogs.push(dialogRef)\n        dialogRef\n            .afterClosed()\n            .subscribe(() => this.removeOpenDialog(dialogRef))\n        this.afterOpen.next(dialogRef)\n        return dialogRef\n    }\n\n    /**\n     * Closes all of the currently-open dialogs.\n     */\n    public closeAll(): void {\n        let i = this.openDialogs.length\n\n        while (i--) {\n            this.openDialogs[i].close()\n        }\n    }\n\n    /**\n     * Finds an open dialog by its id.\n     *\n     * @param id ID to use when looking up the dialog.\n     */\n    public getDialogById(id: string): OwlDialogRef<any> | undefined {\n        return this.openDialogs.find(dialog => dialog.id === id)\n    }\n\n    private attachDialogContent<T>(\n        componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n        dialogContainer: OwlDialogContainerComponent,\n        overlayRef: OverlayRef,\n        config: OwlDialogConfig\n    ) {\n        const dialogRef = new OwlDialogRef<T>(\n            overlayRef,\n            dialogContainer,\n            config.id,\n            this.location\n        )\n\n        if (config.hasBackdrop) {\n            overlayRef.backdropClick().subscribe(() => {\n                if (!dialogRef.disableClose) {\n                    dialogRef.close()\n                }\n            })\n        }\n\n        if (componentOrTemplateRef instanceof TemplateRef) {\n        } else {\n            const injector = this.createInjector<T>(\n                config,\n                dialogRef,\n                dialogContainer\n            )\n            const contentRef = dialogContainer.attachComponentPortal(\n                new ComponentPortal(componentOrTemplateRef, undefined, injector)\n            )\n            dialogRef.componentInstance = contentRef.instance\n        }\n\n        dialogRef\n            .updateSize(config.width, config.height)\n            .updatePosition(config.position)\n\n        return dialogRef\n    }\n\n    private createInjector<T>(\n        config: OwlDialogConfig,\n        dialogRef: OwlDialogRef<T>,\n        dialogContainer: OwlDialogContainerComponent\n    ) {\n        const userInjector =\n            config &&\n            config.viewContainerRef &&\n            config.viewContainerRef.injector\n\n        return Injector.create({\n            providers: [\n                { provide: OwlDialogRef, useValue: dialogRef },\n                { provide: OwlDialogContainerComponent, useValue: dialogContainer },\n                { provide: OWL_DIALOG_DATA, useValue: config.data }\n            ],\n            parent: userInjector || this.injector\n        })\n    }\n\n    private createOverlay(config: OwlDialogConfig): OverlayRef {\n        const overlayConfig = this.getOverlayConfig(config)\n        return this.overlay.create(overlayConfig)\n    }\n\n    private attachDialogContainer(\n        overlayRef: OverlayRef,\n        config: OwlDialogConfig\n    ): OwlDialogContainerComponent {\n        const containerPortal = new ComponentPortal(\n            OwlDialogContainerComponent,\n            config.viewContainerRef\n        )\n        const containerRef: ComponentRef<\n            OwlDialogContainerComponent\n        > = overlayRef.attach(containerPortal)\n        containerRef.instance.setConfig(config)\n\n        return containerRef.instance\n    }\n\n    private getOverlayConfig(dialogConfig: OwlDialogConfig): OverlayConfig {\n        const state = new OverlayConfig({\n            positionStrategy: this.overlay.position().global(),\n            scrollStrategy:\n                dialogConfig.scrollStrategy || this.scrollStrategy(),\n            panelClass: dialogConfig.paneClass,\n            hasBackdrop: dialogConfig.hasBackdrop,\n            minWidth: dialogConfig.minWidth,\n            minHeight: dialogConfig.minHeight,\n            maxWidth: dialogConfig.maxWidth,\n            maxHeight: dialogConfig.maxHeight\n        })\n\n        if (dialogConfig.backdropClass) {\n            state.backdropClass = dialogConfig.backdropClass\n        }\n\n        return state\n    }\n\n    private removeOpenDialog(dialogRef: OwlDialogRef<any>): void {\n        const index = this._openDialogsAtThisLevel.indexOf(dialogRef)\n\n        if (index > -1) {\n            this.openDialogs.splice(index, 1)\n            // If all the dialogs were closed, remove/restore the `aria-hidden`\n            // to a the siblings and emit to the `afterAllClosed` stream.\n            if (!this.openDialogs.length) {\n                this.ariaHiddenElements.forEach((previousValue, element) => {\n                    if (previousValue) {\n                        element.setAttribute('aria-hidden', previousValue)\n                    } else {\n                        element.removeAttribute('aria-hidden')\n                    }\n                })\n\n                this.ariaHiddenElements.clear()\n                this._afterAllClosed.next()\n            }\n        }\n    }\n\n    /**\n     * Hides all of the content that isn't an overlay from assistive technology.\n     */\n    private hideNonDialogContentFromAssistiveTechnology() {\n        const overlayContainer = this.overlayContainer.getContainerElement()\n\n        // Ensure that the overlay container is attached to the DOM.\n        if (overlayContainer.parentElement) {\n            const siblings = overlayContainer.parentElement.children\n\n            for (let i = siblings.length - 1; i > -1; i--) {\n                const sibling = siblings[i]\n\n                if (\n                    sibling !== overlayContainer &&\n                    sibling.nodeName !== 'SCRIPT' &&\n                    sibling.nodeName !== 'STYLE' &&\n                    !sibling.hasAttribute('aria-live')\n                ) {\n                    this.ariaHiddenElements.set(\n                        sibling,\n                        sibling.getAttribute('aria-hidden')\n                    )\n                    sibling.setAttribute('aria-hidden', 'true')\n                }\n            }\n        }\n    }\n}\n\n/**\n * Applies default options to the dialog config.\n *\n * @param config Config to be modified.\n * @param defaultOptions Default config setting\n * @returns The new configuration object.\n */\nfunction applyConfigDefaults(\n    config?: OwlDialogConfig,\n    defaultOptions?: OwlDialogConfig\n): OwlDialogConfig {\n    return extendObject(new OwlDialogConfig(), config, defaultOptions)\n}\n"]}

package/esm2020/moment-adapter/date-time-adapter.class.mjs

@@ -0,0 +1,215 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import moment from 'moment';
+import { DateTimeAdapter, OWL_DATE_TIME_LOCALE } from 'nxt-pick-datetime';
+import * as i0 from "@angular/core";
+/** InjectionToken for moment date adapter to configure options. */
+export const OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS = new InjectionToken('OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS', {
+    providedIn: 'root',
+    factory: OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY
+});
+/** @docs-private */
+export function OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY() {
+    return {
+        useUtc: false
+    };
+}
+/** Creates an array and fills it with values. */
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+export class MomentDateTimeAdapter extends DateTimeAdapter {
+    constructor(owlDateTimeLocale, options) {
+        super();
+        this.options = options;
+        this.setLocale(owlDateTimeLocale || moment.locale());
+    }
+    setLocale(locale) {
+        super.setLocale(locale);
+        const momentLocaleData = moment.localeData(locale);
+        this._localeData = {
+            longMonths: momentLocaleData.months(),
+            shortMonths: momentLocaleData.monthsShort(),
+            longDaysOfWeek: momentLocaleData.weekdays(),
+            shortDaysOfWeek: momentLocaleData.weekdaysShort(),
+            narrowDaysOfWeek: momentLocaleData.weekdaysMin(),
+            dates: range(31, (i) => this.createDate(2017, 0, i + 1).format('D'))
+        };
+    }
+    getYear(date) {
+        return this.clone(date).year();
+    }
+    getMonth(date) {
+        return this.clone(date).month();
+    }
+    getDay(date) {
+        return this.clone(date).day();
+    }
+    getDate(date) {
+        return this.clone(date).date();
+    }
+    getHours(date) {
+        return this.clone(date).hours();
+    }
+    getMinutes(date) {
+        return this.clone(date).minutes();
+    }
+    getSeconds(date) {
+        return this.clone(date).seconds();
+    }
+    getTime(date) {
+        return this.clone(date).valueOf();
+    }
+    getNumDaysInMonth(date) {
+        return this.clone(date).daysInMonth();
+    }
+    differenceInCalendarDays(dateLeft, dateRight) {
+        return this.clone(dateLeft).diff(dateRight, 'days');
+    }
+    getYearName(date) {
+        return this.clone(date).format('YYYY');
+    }
+    getMonthNames(style) {
+        return style === 'long' ? this._localeData.longMonths : this._localeData.shortMonths;
+    }
+    getDayOfWeekNames(style) {
+        if (style === 'long') {
+            return this._localeData.longDaysOfWeek;
+        }
+        if (style === 'short') {
+            return this._localeData.shortDaysOfWeek;
+        }
+        return this._localeData.narrowDaysOfWeek;
+    }
+    getDateNames() {
+        return this._localeData.dates;
+    }
+    toIso8601(date) {
+        return this.clone(date).format();
+    }
+    isEqual(dateLeft, dateRight) {
+        if (dateLeft && dateRight) {
+            return this.clone(dateLeft).isSame(this.clone(dateRight));
+        }
+        return dateLeft === dateRight;
+    }
+    isSameDay(dateLeft, dateRight) {
+        if (dateLeft && dateRight) {
+            return this.clone(dateLeft).isSame(this.clone(dateRight), 'day');
+        }
+        return dateLeft === dateRight;
+    }
+    isValid(date) {
+        return this.clone(date).isValid();
+    }
+    invalid() {
+        return moment.invalid();
+    }
+    isDateInstance(obj) {
+        return moment.isMoment(obj);
+    }
+    addCalendarYears(date, amount) {
+        return this.clone(date).add({ years: amount });
+    }
+    addCalendarMonths(date, amount) {
+        return this.clone(date).add({ months: amount });
+    }
+    addCalendarDays(date, amount) {
+        return this.clone(date).add({ days: amount });
+    }
+    setHours(date, amount) {
+        return this.clone(date).hours(amount);
+    }
+    setMinutes(date, amount) {
+        return this.clone(date).minutes(amount);
+    }
+    setSeconds(date, amount) {
+        return this.clone(date).seconds(amount);
+    }
+    createDate(year, month, date, hours = 0, minutes = 0, seconds = 0) {
+        if (month < 0 || month > 11) {
+            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+        }
+        if (date < 1) {
+            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+        }
+        if (hours < 0 || hours > 23) {
+            throw Error(`Invalid hours "${hours}". Hours has to be between 0 and 23.`);
+        }
+        if (minutes < 0 || minutes > 59) {
+            throw Error(`Invalid minutes "${minutes}". Minutes has to between 0 and 59.`);
+        }
+        if (seconds < 0 || seconds > 59) {
+            throw Error(`Invalid seconds "${seconds}". Seconds has to be between 0 and 59.`);
+        }
+        const result = this.createMoment({ year, month, date, hours, minutes, seconds }).locale(this.locale);
+        // If the result isn't valid, the date must have been out of bounds for this month.
+        if (!result.isValid()) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    clone(date) {
+        return this.createMoment(date).clone().locale(this.locale);
+    }
+    now() {
+        return this.createMoment().locale(this.locale);
+    }
+    format(date, displayFormat) {
+        date = this.clone(date);
+        if (!this.isValid(date)) {
+            throw Error('MomentDateTimeAdapter: Cannot format invalid date.');
+        }
+        return date.format(displayFormat);
+    }
+    parse(value, parseFormat) {
+        if (value && typeof value === 'string') {
+            return this.createMoment(value, parseFormat, this.locale);
+        }
+        return value ? this.createMoment(value).locale(this.locale) : null;
+    }
+    /**
+     * Returns the given value if given a valid Moment or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) and valid Date objects into valid Moments and empty
+     * string into null. Returns an invalid date for all other values.
+     */
+    deserialize(value) {
+        let date;
+        if (value instanceof Date) {
+            date = this.createMoment(value);
+        }
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
+            }
+            date = this.createMoment(value, moment.ISO_8601).locale(this.locale);
+        }
+        if (date && this.isValid(date)) {
+            return date;
+        }
+        return super.deserialize(value);
+    }
+    /** Creates a Moment instance while respecting the current UTC settings. */
+    createMoment(...args) {
+        return (this.options && this.options.useUtc) ? moment.utc(...args) : moment(...args);
+    }
+}
+MomentDateTimeAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MomentDateTimeAdapter, deps: [{ token: OWL_DATE_TIME_LOCALE, optional: true }, { token: OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+MomentDateTimeAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MomentDateTimeAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MomentDateTimeAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DATE_TIME_LOCALE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-adapter.class.js","sourceRoot":"","sources":["../../../../projects/nxt-pick-datetime/moment-adapter/src/date-time-adapter.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core'\nimport moment, { Moment } from 'moment'\nimport { DateTimeAdapter, OWL_DATE_TIME_LOCALE } from 'nxt-pick-datetime'\n\n/** Configurable options for {@see MomentDateAdapter}. */\nexport interface OwlMomentDateTimeAdapterOptions {\n    /**\n     * Turns the use of utc dates on or off.\n     * Changing this will change how the DateTimePicker output value.\n     * {@default false}\n     */\n    useUtc: boolean\n}\n\n/** InjectionToken for moment date adapter to configure options. */\nexport const OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS = new InjectionToken<OwlMomentDateTimeAdapterOptions>(\n    'OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS', {\n        providedIn: 'root',\n        factory: OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY\n    })\n\n/** @docs-private */\nexport function OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY(): OwlMomentDateTimeAdapterOptions {\n    return {\n        useUtc: false\n    }\n}\n\n/** Creates an array and fills it with values. */\nfunction range<T>(length: number, valueFunction: (index: number) => T): T[] {\n    const valuesArray = Array(length)\n    for (let i = 0; i < length; i++) {\n        valuesArray[i] = valueFunction(i)\n    }\n    return valuesArray\n}\n\n@Injectable()\nexport class MomentDateTimeAdapter extends DateTimeAdapter<Moment> {\n\n    private _localeData: {\n        longMonths: string[]\n        shortMonths: string[]\n        longDaysOfWeek: string[]\n        shortDaysOfWeek: string[]\n        narrowDaysOfWeek: string[]\n        dates: string[]\n    }\n\n    constructor(\n        @Optional() @Inject(OWL_DATE_TIME_LOCALE)\n        owlDateTimeLocale?: string,\n        @Optional() @Inject(OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS)\n        private options?: OwlMomentDateTimeAdapterOptions\n    ) {\n        super()\n        this.setLocale(owlDateTimeLocale || moment.locale())\n    }\n\n    public setLocale(locale: string) {\n        super.setLocale(locale)\n\n        const momentLocaleData = moment.localeData(locale)\n        this._localeData = {\n            longMonths: momentLocaleData.months(),\n            shortMonths: momentLocaleData.monthsShort(),\n            longDaysOfWeek: momentLocaleData.weekdays(),\n            shortDaysOfWeek: momentLocaleData.weekdaysShort(),\n            narrowDaysOfWeek: momentLocaleData.weekdaysMin(),\n            dates: range(31, (i) => this.createDate(2017, 0, i + 1).format('D'))\n        }\n    }\n\n    public getYear(date: Moment): number {\n        return this.clone(date).year()\n    }\n\n    public getMonth(date: Moment): number {\n        return this.clone(date).month()\n    }\n\n    public getDay(date: Moment): number {\n        return this.clone(date).day()\n    }\n\n    public getDate(date: Moment): number {\n        return this.clone(date).date()\n    }\n\n    public getHours(date: Moment): number {\n        return this.clone(date).hours()\n    }\n\n    public getMinutes(date: Moment): number {\n        return this.clone(date).minutes()\n    }\n\n    public getSeconds(date: Moment): number {\n        return this.clone(date).seconds()\n    }\n\n    public getTime(date: Moment): number {\n        return this.clone(date).valueOf()\n    }\n\n    public getNumDaysInMonth(date: Moment): number {\n        return this.clone(date).daysInMonth()\n    }\n\n    public differenceInCalendarDays(dateLeft: Moment, dateRight: Moment): number {\n        return this.clone(dateLeft).diff(dateRight, 'days')\n    }\n\n    public getYearName(date: Moment): string {\n        return this.clone(date).format('YYYY')\n    }\n\n    public getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n        return style === 'long' ? this._localeData.longMonths : this._localeData.shortMonths\n    }\n\n    public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\n        if (style === 'long') {\n            return this._localeData.longDaysOfWeek\n        }\n        if (style === 'short') {\n            return this._localeData.shortDaysOfWeek\n        }\n        return this._localeData.narrowDaysOfWeek\n    }\n\n    public getDateNames(): string[] {\n        return this._localeData.dates\n    }\n\n    public toIso8601(date: Moment): string {\n        return this.clone(date).format()\n    }\n\n    public isEqual(dateLeft: Moment, dateRight: Moment): boolean {\n\n        if (dateLeft && dateRight) {\n            return this.clone(dateLeft).isSame(this.clone(dateRight))\n        }\n\n        return dateLeft === dateRight\n    }\n\n    public isSameDay(dateLeft: Moment, dateRight: Moment): boolean {\n\n        if (dateLeft && dateRight) {\n            return this.clone(dateLeft).isSame(this.clone(dateRight), 'day')\n        }\n\n        return dateLeft === dateRight\n    }\n\n    public isValid(date: Moment): boolean {\n        return this.clone(date).isValid()\n    }\n\n    public invalid(): Moment {\n        return moment.invalid()\n    }\n\n    public isDateInstance(obj: any): boolean {\n        return moment.isMoment(obj)\n    }\n\n    public addCalendarYears(date: Moment, amount: number): Moment {\n        return this.clone(date).add({ years: amount })\n    }\n\n    public addCalendarMonths(date: Moment, amount: number): Moment {\n        return this.clone(date).add({ months: amount })\n    }\n\n    public addCalendarDays(date: Moment, amount: number): Moment {\n        return this.clone(date).add({ days: amount })\n    }\n\n    public setHours(date: Moment, amount: number): Moment {\n        return this.clone(date).hours(amount)\n    }\n\n    public setMinutes(date: Moment, amount: number): Moment {\n        return this.clone(date).minutes(amount)\n    }\n\n    public setSeconds(date: Moment, amount: number): Moment {\n        return this.clone(date).seconds(amount)\n    }\n\n    public createDate(year: number, month: number, date: number): Moment\n    public createDate(year: number, month: number, date: number, hours: number = 0, minutes: number = 0, seconds: number = 0): Moment {\n        if (month < 0 || month > 11) {\n            throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`)\n        }\n\n        if (date < 1) {\n            throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`)\n        }\n\n        if (hours < 0 || hours > 23) {\n            throw Error(`Invalid hours \"${hours}\". Hours has to be between 0 and 23.`)\n        }\n\n        if (minutes < 0 || minutes > 59) {\n            throw Error(`Invalid minutes \"${minutes}\". Minutes has to between 0 and 59.`)\n        }\n\n        if (seconds < 0 || seconds > 59) {\n            throw Error(`Invalid seconds \"${seconds}\". Seconds has to be between 0 and 59.`)\n        }\n\n        const result = this.createMoment({ year, month, date, hours, minutes, seconds }).locale(this.locale)\n\n        // If the result isn't valid, the date must have been out of bounds for this month.\n        if (!result.isValid()) {\n            throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`)\n        }\n\n        return result\n    }\n\n    public clone(date: Moment): Moment {\n        return this.createMoment(date).clone().locale(this.locale)\n    }\n\n    public now(): Moment {\n        return this.createMoment().locale(this.locale)\n    }\n\n    public format(date: Moment, displayFormat: any): string {\n        date = this.clone(date)\n        if (!this.isValid(date)) {\n            throw Error('MomentDateTimeAdapter: Cannot format invalid date.')\n        }\n        return date.format(displayFormat)\n    }\n\n    public parse(value: any, parseFormat: any): Moment | null {\n        if (value && typeof value === 'string') {\n            return this.createMoment(value, parseFormat, this.locale)\n        }\n        return value ? this.createMoment(value).locale(this.locale) : null\n    }\n\n    /**\n     * Returns the given value if given a valid Moment or null. Deserializes valid ISO 8601 strings\n     * (https://www.ietf.org/rfc/rfc3339.txt) and valid Date objects into valid Moments and empty\n     * string into null. Returns an invalid date for all other values.\n     */\n    deserialize(value: any): Moment | null {\n        let date\n        if (value instanceof Date) {\n            date = this.createMoment(value)\n        }\n        if (typeof value === 'string') {\n            if (!value) {\n                return null\n            }\n            date = this.createMoment(value, moment.ISO_8601).locale(this.locale)\n        }\n        if (date && this.isValid(date)) {\n            return date\n        }\n        return super.deserialize(value)\n    }\n\n    /** Creates a Moment instance while respecting the current UTC settings. */\n    private createMoment(...args: any[]): Moment {\n        return (this.options && this.options.useUtc) ? moment.utc(...args) : moment(...args)\n    }\n}\n"]}

package/esm2020/moment-adapter/moment-adapter.module.mjs

@@ -0,0 +1,41 @@
+import { NgModule } from '@angular/core';
+import { DateTimeAdapter, OWL_DATE_TIME_FORMATS, OWL_DATE_TIME_LOCALE } from 'nxt-pick-datetime';
+import { MomentDateTimeAdapter, OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS } from './date-time-adapter.class';
+import { OWL_MOMENT_DATE_TIME_FORMATS } from './date-time-format.class';
+import * as i0 from "@angular/core";
+export class MomentDateTimeModule {
+}
+MomentDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MomentDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MomentDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MomentDateTimeModule });
+MomentDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MomentDateTimeModule, providers: [
+        {
+            provide: DateTimeAdapter,
+            useClass: MomentDateTimeAdapter,
+            deps: [OWL_DATE_TIME_LOCALE, OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS]
+        }
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: MomentDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        {
+                            provide: DateTimeAdapter,
+                            useClass: MomentDateTimeAdapter,
+                            deps: [OWL_DATE_TIME_LOCALE, OWL_MOMENT_DATE_TIME_ADAPTER_OPTIONS]
+                        }
+                    ]
+                }]
+        }] });
+export class OwlMomentDateTimeModule {
+}
+OwlMomentDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlMomentDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+OwlMomentDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlMomentDateTimeModule, imports: [MomentDateTimeModule] });
+OwlMomentDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlMomentDateTimeModule, providers: [{ provide: OWL_DATE_TIME_FORMATS, useValue: OWL_MOMENT_DATE_TIME_FORMATS }], imports: [[MomentDateTimeModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: OwlMomentDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [MomentDateTimeModule],
+                    providers: [{ provide: OWL_DATE_TIME_FORMATS, useValue: OWL_MOMENT_DATE_TIME_FORMATS }]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/moment-adapter/nxt-pick-datetime-moment-adapter.mjs

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