nxt-pick-datetime 16.0.0-alpha.6 → 16.0.0

package/esm2022/lib/dialog/dialog.service.mjs

@@ -0,0 +1,252 @@
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Location } from '@angular/common';
+import { Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf, TemplateRef } from '@angular/core';
+import { defer, of, Subject } from 'rxjs';
+import { concatAll } from 'rxjs/operators';
+import { DialogConfig } from '../class/dialog-config.class';
+import { DialogRef } from '../class/dialog-ref.class';
+import { extendObject } from '../utils/object';
+import { DialogContainerComponent } from './dialog-container/dialog-container.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+/** @internal */
+export const NXT_DIALOG_DATA = new InjectionToken('NXT_DIALOG_DATA');
+/**
+ * Injection token that determines the scroll handling while the dialog is open.
+ *
+ * @internal
+ */
+export const NXT_DIALOG_SCROLL_STRATEGY = new InjectionToken('NXT_DIALOG_SCROLL_STRATEGY');
+/** @internal */
+export function NXT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay) {
+    const fn = () => overlay.scrollStrategies.block();
+    return fn;
+}
+/** @internal */
+export const NXT_DIALOG_SCROLL_STRATEGY_PROVIDER = {
+    provide: NXT_DIALOG_SCROLL_STRATEGY,
+    deps: [Overlay],
+    useFactory: NXT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY
+};
+/**
+ * Injection token that can be used to specify default dialog options.
+ *
+ * @internal
+ */
+export const NXT_DIALOG_DEFAULT_OPTIONS = new InjectionToken('NXT_DIALOG_DEFAULT_OPTIONS');
+/** @internal */
+class DialogService {
+    /** 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 isOpen */
+    get afterOpen() {
+        return this.parentDialog
+            ? this.parentDialog.afterOpen
+            : this._afterOpenAtThisLevel;
+    }
+    get _afterAllClosed() {
+        const parent = this.parentDialog;
+        return parent
+            ? parent._afterAllClosed
+            : this._afterAllClosedAtThisLevel;
+    }
+    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());
+        }
+    }
+    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 DialogRef(overlayRef, dialogContainer, config.id, this.location);
+        if (config.hasBackdrop) {
+            overlayRef.backdropClick().subscribe(() => {
+                if (!dialogRef.disableClose) {
+                    dialogRef.close();
+                }
+            });
+        }
+        if (!(componentOrTemplateRef instanceof TemplateRef)) {
+            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: DialogRef, useValue: dialogRef },
+                { provide: DialogContainerComponent, useValue: dialogContainer },
+                { provide: NXT_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(DialogContainerComponent, 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');
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogService, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: Location, optional: true }, { token: NXT_DIALOG_SCROLL_STRATEGY }, { token: NXT_DIALOG_DEFAULT_OPTIONS, optional: true }, { token: DialogService, optional: true, skipSelf: true }, { token: i1.OverlayContainer }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogService }); }
+}
+export { DialogService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [Location]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NXT_DIALOG_SCROLL_STRATEGY]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NXT_DIALOG_DEFAULT_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }, {
+                    type: Inject,
+                    args: [DialogService]
+                }] }, { 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.
+ * @internal
+ */
+function applyConfigDefaults(config, defaultOptions) {
+    return extendObject(new DialogConfig(), config, defaultOptions);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../packages/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, of, Subject } from 'rxjs'\nimport { concatAll } from 'rxjs/operators'\nimport { DialogConfig } from '../class/dialog-config.class'\nimport { DialogRef } from '../class/dialog-ref.class'\nimport { extendObject } from '../utils/object'\nimport { DialogContainerComponent } from './dialog-container/dialog-container.component'\n\n/** @internal */\nexport const NXT_DIALOG_DATA = new InjectionToken<any>('NXT_DIALOG_DATA')\n\n/**\n * Injection token that determines the scroll handling while the dialog is open.\n *\n * @internal\n */\nexport const NXT_DIALOG_SCROLL_STRATEGY = new InjectionToken<\n    () => ScrollStrategy\n>('NXT_DIALOG_SCROLL_STRATEGY')\n\n/** @internal */\nexport function NXT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(\n    overlay: Overlay\n): () => ScrollStrategy {\n    const fn = () => overlay.scrollStrategies.block()\n    return fn\n}\n\n/** @internal */\nexport const NXT_DIALOG_SCROLL_STRATEGY_PROVIDER = {\n    provide: NXT_DIALOG_SCROLL_STRATEGY,\n    deps: [Overlay],\n    useFactory: NXT_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY\n}\n\n/**\n * Injection token that can be used to specify default dialog options.\n *\n * @internal\n */\nexport const NXT_DIALOG_DEFAULT_OPTIONS = new InjectionToken<DialogConfig>(\n    'NXT_DIALOG_DEFAULT_OPTIONS'\n)\n\n/** @internal */\n@Injectable()\nexport class DialogService {\n    private readonly ariaHiddenElements = new Map<Element, string | null>()\n\n    private readonly _openDialogsAtThisLevel: Array<DialogRef<any>> = []\n    private readonly _afterOpenAtThisLevel = new Subject<DialogRef<any>>()\n    private readonly _afterAllClosedAtThisLevel = new Subject<void>()\n\n    /** Keeps track of the currently-open dialogs */\n    get openDialogs(): Array<DialogRef<any>> {\n        return this.parentDialog\n            ? this.parentDialog.openDialogs\n            : this._openDialogsAtThisLevel\n    }\n\n    /** Stream that emits when a dialog has been isOpen */\n    get afterOpen(): Subject<DialogRef<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    readonly afterAllClosed = 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 readonly overlay: Overlay,\n        private readonly injector: Injector,\n        @Optional()\n        @Inject(Location)\n        private readonly location: Location | undefined,\n        @Inject(NXT_DIALOG_SCROLL_STRATEGY)\n        scrollStrategy: () => ScrollStrategy,\n        @Optional()\n        @Inject(NXT_DIALOG_DEFAULT_OPTIONS)\n        private readonly defaultOptions: DialogConfig | undefined,\n        @Optional()\n        @SkipSelf()\n        @Inject(DialogService)\n        private readonly parentDialog: DialogService | undefined,\n        private readonly overlayContainer: OverlayContainer\n    ) {\n        this.scrollStrategy = scrollStrategy\n        if (!parentDialog && location) {\n            location.subscribe(() => this.closeAll())\n        }\n    }\n\n    open<T>(\n        componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n        config?: DialogConfig\n    ): DialogRef<any> {\n        config = applyConfigDefaults(config, this.defaultOptions)\n\n        if (config.id && this.getDialogById(config.id)) {\n            throw Error(`Dialog with id \"${config.id}\" exists already. The dialog id must be unique.`)\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    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    getDialogById(id: string): DialogRef<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: DialogContainerComponent,\n        overlayRef: OverlayRef,\n        config: DialogConfig\n    ) {\n        const dialogRef = new DialogRef<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            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: DialogConfig,\n        dialogRef: DialogRef<T>,\n        dialogContainer: DialogContainerComponent\n    ) {\n        const userInjector =\n            config &&\n            config.viewContainerRef &&\n            config.viewContainerRef.injector\n\n        return Injector.create({\n            providers: [\n                { provide: DialogRef, useValue: dialogRef },\n                { provide: DialogContainerComponent, useValue: dialogContainer },\n                { provide: NXT_DIALOG_DATA, useValue: config.data }\n            ],\n            parent: userInjector || this.injector\n        })\n    }\n\n    private createOverlay(config: DialogConfig): OverlayRef {\n        const overlayConfig = this.getOverlayConfig(config)\n        return this.overlay.create(overlayConfig)\n    }\n\n    private attachDialogContainer(\n        overlayRef: OverlayRef,\n        config: DialogConfig\n    ): DialogContainerComponent {\n        const containerPortal = new ComponentPortal(\n            DialogContainerComponent,\n            config.viewContainerRef\n        )\n        const containerRef: ComponentRef<\n            DialogContainerComponent\n        > = overlayRef.attach(containerPortal)\n        containerRef.instance.setConfig(config)\n\n        return containerRef.instance\n    }\n\n    private getOverlayConfig(dialogConfig: DialogConfig): 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: DialogRef<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 * @internal\n */\nfunction applyConfigDefaults(\n    config?: DialogConfig,\n    defaultOptions?: DialogConfig\n): DialogConfig {\n    return extendObject(new DialogConfig(), config, defaultOptions)\n}\n"]}

package/esm2022/lib/utils/object.mjs

@@ -0,0 +1,24 @@
+/**
+ * Extends an object with the *enumerable* and *own* properties of one or more source objects,
+ * similar to Object.assign.
+ *
+ * @param dest The object which will have properties copied to it.
+ * @param sources The source objects from which properties will be copied.
+ * @internal
+ */
+export function extendObject(dest, ...sources) {
+    if (dest == null || dest == undefined) {
+        throw TypeError('Cannot convert undefined or null to object');
+    }
+    for (const source of sources) {
+        if (source != null && source != undefined) {
+            for (const key in source) {
+                if (source.hasOwnProperty(key)) {
+                    dest[key] = source[key];
+                }
+            }
+        }
+    }
+    return dest;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcGljay1kYXRldGltZS9zcmMvbGliL3V0aWxzL29iamVjdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxJQUFTLEVBQUUsR0FBRyxPQUFjO0lBQ3JELElBQUksSUFBSSxJQUFJLElBQUksSUFBSSxJQUFJLElBQUksU0FBUyxFQUFFO1FBQ25DLE1BQU0sU0FBUyxDQUFDLDRDQUE0QyxDQUFDLENBQUE7S0FDaEU7SUFFRCxLQUFLLE1BQU0sTUFBTSxJQUFJLE9BQU8sRUFBRTtRQUMxQixJQUFJLE1BQU0sSUFBSSxJQUFJLElBQUksTUFBTSxJQUFJLFNBQVMsRUFBRTtZQUN2QyxLQUFLLE1BQU0sR0FBRyxJQUFJLE1BQU0sRUFBRTtnQkFDdEIsSUFBSSxNQUFNLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxFQUFFO29CQUM1QixJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFBO2lCQUMxQjthQUNKO1NBQ0o7S0FDSjtJQUVELE9BQU8sSUFBSSxDQUFBO0FBQ2YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZW5kcyBhbiBvYmplY3Qgd2l0aCB0aGUgKmVudW1lcmFibGUqIGFuZCAqb3duKiBwcm9wZXJ0aWVzIG9mIG9uZSBvciBtb3JlIHNvdXJjZSBvYmplY3RzLFxuICogc2ltaWxhciB0byBPYmplY3QuYXNzaWduLlxuICpcbiAqIEBwYXJhbSBkZXN0IFRoZSBvYmplY3Qgd2hpY2ggd2lsbCBoYXZlIHByb3BlcnRpZXMgY29waWVkIHRvIGl0LlxuICogQHBhcmFtIHNvdXJjZXMgVGhlIHNvdXJjZSBvYmplY3RzIGZyb20gd2hpY2ggcHJvcGVydGllcyB3aWxsIGJlIGNvcGllZC5cbiAqIEBpbnRlcm5hbFxuICovXG5leHBvcnQgZnVuY3Rpb24gZXh0ZW5kT2JqZWN0KGRlc3Q6IGFueSwgLi4uc291cmNlczogYW55W10pOiBhbnkge1xuICAgIGlmIChkZXN0ID09IG51bGwgfHwgZGVzdCA9PSB1bmRlZmluZWQpIHtcbiAgICAgICAgdGhyb3cgVHlwZUVycm9yKCdDYW5ub3QgY29udmVydCB1bmRlZmluZWQgb3IgbnVsbCB0byBvYmplY3QnKVxuICAgIH1cblxuICAgIGZvciAoY29uc3Qgc291cmNlIG9mIHNvdXJjZXMpIHtcbiAgICAgICAgaWYgKHNvdXJjZSAhPSBudWxsICYmIHNvdXJjZSAhPSB1bmRlZmluZWQpIHtcbiAgICAgICAgICAgIGZvciAoY29uc3Qga2V5IGluIHNvdXJjZSkge1xuICAgICAgICAgICAgICAgIGlmIChzb3VyY2UuaGFzT3duUHJvcGVydHkoa2V5KSkge1xuICAgICAgICAgICAgICAgICAgICBkZXN0W2tleV0gPSBzb3VyY2Vba2V5XVxuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBkZXN0XG59XG4iXX0=

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

@@ -0,0 +1,221 @@
+import { Inject, Injectable, InjectionToken, LOCALE_ID, Optional } from '@angular/core';
+import moment from 'moment';
+import { DateTimeAdapter } from 'nxt-pick-datetime';
+import * as i0 from "@angular/core";
+/** InjectionToken for moment date adapter to configure options */
+export const NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS = new InjectionToken('NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS', {
+    providedIn: 'root',
+    factory: NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY
+});
+/** @internal */
+export function NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY() {
+    return {
+        useUtc: false
+    };
+}
+/**
+ * Creates an array and fills it with values.
+ *
+ * @internal
+ */
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+class MomentDateTimeAdapter extends DateTimeAdapter {
+    constructor(dateTimeLocale, options) {
+        super();
+        this.options = options;
+        this._localeData = {};
+        this.setLocale(dateTimeLocale || 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) : undefined;
+    }
+    /**
+     * Returns the given value if given a valid Moment or undefined. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) and valid Date objects into valid Moments and empty
+     * string into undefined. 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 undefined;
+            }
+            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);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MomentDateTimeAdapter, deps: [{ token: LOCALE_ID, optional: true }, { token: NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MomentDateTimeAdapter }); }
+}
+export { MomentDateTimeAdapter };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MomentDateTimeAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-adapter.class.js","sourceRoot":"","sources":["../../../../packages/pick-datetime/moment-adapter/src/date-time-adapter.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, LOCALE_ID, Optional } from '@angular/core'\nimport moment, { Moment } from 'moment'\nimport { DateTimeAdapter } from 'nxt-pick-datetime'\n\n/** Configurable options for {@see MomentDateAdapter} */\nexport interface MomentDateTimeAdapterOptions {\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 NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS = new InjectionToken<MomentDateTimeAdapterOptions>(\n    'NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS', {\n    providedIn: 'root',\n    factory: NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY\n})\n\n/** @internal */\nexport function NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS_FACTORY(): MomentDateTimeAdapterOptions {\n    return {\n        useUtc: false\n    }\n}\n\n/**\n * Creates an array and fills it with values.\n *\n * @internal\n */\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    } = {} as any\n\n    constructor(\n        @Optional()\n        @Inject(LOCALE_ID)\n        dateTimeLocale?: string,\n        @Optional()\n        @Inject(NXT_MOMENT_DATE_TIME_ADAPTER_OPTIONS)\n        private readonly options?: MomentDateTimeAdapterOptions\n    ) {\n        super()\n        this.setLocale(dateTimeLocale || moment.locale())\n    }\n\n    override 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    getYear(date: Moment): number {\n        return this.clone(date).year()\n    }\n\n    getMonth(date: Moment): number {\n        return this.clone(date).month()\n    }\n\n    getDay(date: Moment): number {\n        return this.clone(date).day()\n    }\n\n    getDate(date: Moment): number {\n        return this.clone(date).date()\n    }\n\n    getHours(date: Moment): number {\n        return this.clone(date).hours()\n    }\n\n    getMinutes(date: Moment): number {\n        return this.clone(date).minutes()\n    }\n\n    getSeconds(date: Moment): number {\n        return this.clone(date).seconds()\n    }\n\n    getTime(date: Moment): number {\n        return this.clone(date).valueOf()\n    }\n\n    getNumDaysInMonth(date: Moment): number {\n        return this.clone(date).daysInMonth()\n    }\n\n    differenceInCalendarDays(dateLeft: Moment, dateRight: Moment): number {\n        return this.clone(dateLeft).diff(dateRight, 'days')\n    }\n\n    getYearName(date: Moment): string {\n        return this.clone(date).format('YYYY')\n    }\n\n    getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n        return style === 'long' ? this._localeData.longMonths : this._localeData.shortMonths\n    }\n\n    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    getDateNames(): string[] {\n        return this._localeData.dates\n    }\n\n    toIso8601(date: Moment): string {\n        return this.clone(date).format()\n    }\n\n    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    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    isValid(date: Moment): boolean {\n        return this.clone(date).isValid()\n    }\n\n    invalid(): Moment {\n        return moment.invalid()\n    }\n\n    isDateInstance(obj: any): boolean {\n        return moment.isMoment(obj)\n    }\n\n    addCalendarYears(date: Moment, amount: number): Moment {\n        return this.clone(date).add({ years: amount })\n    }\n\n    addCalendarMonths(date: Moment, amount: number): Moment {\n        return this.clone(date).add({ months: amount })\n    }\n\n    addCalendarDays(date: Moment, amount: number): Moment {\n        return this.clone(date).add({ days: amount })\n    }\n\n    setHours(date: Moment, amount: number): Moment {\n        return this.clone(date).hours(amount)\n    }\n\n    setMinutes(date: Moment, amount: number): Moment {\n        return this.clone(date).minutes(amount)\n    }\n\n    setSeconds(date: Moment, amount: number): Moment {\n        return this.clone(date).seconds(amount)\n    }\n\n    createDate(year: number, month: number, date: number): Moment\n    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    clone(date: Moment): Moment {\n        return this.createMoment(date).clone().locale(this.locale)\n    }\n\n    now(): Moment {\n        return this.createMoment().locale(this.locale)\n    }\n\n    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    parse(value: any, parseFormat: any): Moment | undefined {\n        if (value && typeof value === 'string') {\n            return this.createMoment(value, parseFormat, this.locale)\n        }\n        return value ? this.createMoment(value).locale(this.locale) : undefined\n    }\n\n    /**\n     * Returns the given value if given a valid Moment or undefined. 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 undefined. Returns an invalid date for all other values.\n     */\n    override deserialize(value: any): Moment | undefined {\n        let date\n        if (value instanceof Date) {\n            date = this.createMoment(value)\n        }\n        if (typeof value === 'string') {\n            if (!value) {\n                return undefined\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 → esm2022}/moment-adapter/date-time-format.class.mjs

@@ -1,13 +1,13 @@
-/**
- * @internal
- */
-export const NXT_MOMENT_DATE_TIME_FORMATS = {
-    parseInput: 'l LT',
-    fullPickerInput: 'l LT',
-    datePickerInput: 'l',
-    timePickerInput: 'LT',
-    monthYearLabel: 'MMM YYYY',
-    dateA11yLabel: 'LL',
-    monthYearA11yLabel: 'MMMM YYYY'
-};
+/**
+ * @internal
+ */
+export const NXT_MOMENT_DATE_TIME_FORMATS = {
+    parseInput: 'l LT',
+    fullPickerInput: 'l LT',
+    datePickerInput: 'l',
+    timePickerInput: 'LT',
+    monthYearLabel: 'MMM YYYY',
+    dateA11yLabel: 'LL',
+    monthYearA11yLabel: 'MMMM YYYY'
+};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS10aW1lLWZvcm1hdC5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL3BpY2stZGF0ZXRpbWUvbW9tZW50LWFkYXB0ZXIvc3JjL2RhdGUtdGltZS1mb3JtYXQuY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSw0QkFBNEIsR0FBb0I7SUFDekQsVUFBVSxFQUFFLE1BQU07SUFDbEIsZUFBZSxFQUFFLE1BQU07SUFDdkIsZUFBZSxFQUFFLEdBQUc7SUFDcEIsZUFBZSxFQUFFLElBQUk7SUFDckIsY0FBYyxFQUFFLFVBQVU7SUFDMUIsYUFBYSxFQUFFLElBQUk7SUFDbkIsa0JBQWtCLEVBQUUsV0FBVztDQUNsQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGF0ZVRpbWVGb3JtYXRzIH0gZnJvbSAnbnh0LXBpY2stZGF0ZXRpbWUnXG5cbi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBjb25zdCBOWFRfTU9NRU5UX0RBVEVfVElNRV9GT1JNQVRTOiBEYXRlVGltZUZvcm1hdHMgPSB7XG4gICAgcGFyc2VJbnB1dDogJ2wgTFQnLFxuICAgIGZ1bGxQaWNrZXJJbnB1dDogJ2wgTFQnLFxuICAgIGRhdGVQaWNrZXJJbnB1dDogJ2wnLFxuICAgIHRpbWVQaWNrZXJJbnB1dDogJ0xUJyxcbiAgICBtb250aFllYXJMYWJlbDogJ01NTSBZWVlZJyxcbiAgICBkYXRlQTExeUxhYmVsOiAnTEwnLFxuICAgIG1vbnRoWWVhckExMXlMYWJlbDogJ01NTU0gWVlZWSdcbn1cbiJdfQ==