@netwin/angular-datetime-picker 18.0.0

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

@@ -0,0 +1,245 @@
+/**
+ * dialog.service
+ */
+import { Inject, Injectable, InjectionToken, Optional, SkipSelf, TemplateRef } from '@angular/core';
+import { OwlDialogConfig } from './dialog-config.class';
+import { OwlDialogRef } from './dialog-ref.class';
+import { OwlDialogContainerComponent } from './dialog-container.component';
+import { extendObject } from '../utils';
+import { defer, Subject } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/common";
+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
+};
+/**
+ * Injection 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 {
+    /** 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 beforeOpen() {
+        return this.parentDialog
+            ? this.parentDialog.beforeOpen
+            : this._beforeOpenAtThisLevel;
+    }
+    /** 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;
+    }
+    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._beforeOpenAtThisLevel = new Subject();
+        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
+            : this._afterAllClosed.pipe(startWith(undefined)));
+        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.beforeOpen.next(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;
+        const injectionTokens = new WeakMap();
+        injectionTokens.set(OwlDialogRef, dialogRef);
+        injectionTokens.set(OwlDialogContainerComponent, dialogContainer);
+        injectionTokens.set(OWL_DIALOG_DATA, config.data);
+        return new PortalInjector(userInjector || this.injector, injectionTokens);
+    }
+    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');
+                }
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", 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 }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: OwlDialogService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: OwlDialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Overlay }, { type: i0.Injector }, { type: i2.Location, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [OWL_DIALOG_SCROLL_STRATEGY]
+                }] }, { type: undefined, 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/picker/src/lib/dialog/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * dialog.service\n */\n\nimport {\n    ComponentRef,\n    Inject,\n    Injectable,\n    InjectionToken,\n    Injector,\n    Optional,\n    SkipSelf,\n    TemplateRef\n} from '@angular/core';\nimport { Location } from '@angular/common';\nimport { OwlDialogConfig, OwlDialogConfigInterface } from './dialog-config.class';\nimport { OwlDialogRef } from './dialog-ref.class';\nimport { OwlDialogContainerComponent } from './dialog-container.component';\nimport { extendObject } from '../utils';\nimport { defer, Observable, Subject } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport {\n    Overlay,\n    OverlayConfig,\n    OverlayContainer,\n    OverlayRef,\n    ScrollStrategy\n} from '@angular/cdk/overlay';\nimport {\n    ComponentPortal,\n    ComponentType,\n    PortalInjector\n} from '@angular/cdk/portal';\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/**\n * Injection 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 _beforeOpenAtThisLevel = new Subject<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 beforeOpen(): Subject<OwlDialogRef<any>> {\n        return this.parentDialog\n            ? this.parentDialog.beforeOpen\n            : this._beforeOpenAtThisLevel;\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(): any {\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<{}> = defer(\n        () =>\n            this._openDialogsAtThisLevel.length\n                ? this._afterAllClosed\n                : this._afterAllClosed.pipe(startWith(undefined))\n    );\n\n    private readonly 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: OwlDialogConfigInterface,\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?: OwlDialogConfigInterface\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 \"${\n                    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.beforeOpen.next(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     * @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: OwlDialogConfigInterface\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: OwlDialogConfigInterface,\n        dialogRef: OwlDialogRef<T>,\n        dialogContainer: OwlDialogContainerComponent\n    ) {\n        const userInjector =\n            config &&\n            config.viewContainerRef &&\n            config.viewContainerRef.injector;\n        const injectionTokens = new WeakMap();\n\n        injectionTokens.set(OwlDialogRef, dialogRef);\n        injectionTokens.set(OwlDialogContainerComponent, dialogContainer);\n        injectionTokens.set(OWL_DIALOG_DATA, config.data);\n\n        return new PortalInjector(\n            userInjector || this.injector,\n            injectionTokens\n        );\n    }\n\n    private createOverlay(config: OwlDialogConfigInterface): OverlayRef {\n        const overlayConfig = this.getOverlayConfig(config);\n        return this.overlay.create(overlayConfig);\n    }\n\n    private attachDialogContainer(\n        overlayRef: OverlayRef,\n        config: OwlDialogConfigInterface\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: OwlDialogConfigInterface): 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 * @param config Config to be modified.\n * @param defaultOptions Default config setting\n * @returns The new configuration object.\n */\nfunction applyConfigDefaults(\n    config?: OwlDialogConfigInterface,\n    defaultOptions?: OwlDialogConfigInterface\n): OwlDialogConfig {\n    return extendObject(new OwlDialogConfig(), config, defaultOptions);\n}\n"]}

package/esm2022/lib/utils/array.utils.mjs

@@ -0,0 +1,12 @@
+/**
+ * array.utils
+ */
+/** Creates an array and fills it with values. */
+export function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkudXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9waWNrZXIvc3JjL2xpYi91dGlscy9hcnJheS51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGlEQUFpRDtBQUNqRCxNQUFNLFVBQVUsS0FBSyxDQUFJLE1BQWMsRUFBRSxhQUFtQztJQUN4RSxNQUFNLFdBQVcsR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDbEMsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQzlCLFdBQVcsQ0FBQyxDQUFDLENBQUMsR0FBRyxhQUFhLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdEMsQ0FBQztJQUNELE9BQU8sV0FBVyxDQUFDO0FBQ3ZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGFycmF5LnV0aWxzXG4gKi9cblxuLyoqIENyZWF0ZXMgYW4gYXJyYXkgYW5kIGZpbGxzIGl0IHdpdGggdmFsdWVzLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJhbmdlPFQ+KGxlbmd0aDogbnVtYmVyLCB2YWx1ZUZ1bmN0aW9uOiAoaW5kZXg6IG51bWJlcikgPT4gVCk6IFRbXSB7XG4gICAgY29uc3QgdmFsdWVzQXJyYXkgPSBBcnJheShsZW5ndGgpO1xuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspIHtcbiAgICAgICAgdmFsdWVzQXJyYXlbaV0gPSB2YWx1ZUZ1bmN0aW9uKGkpO1xuICAgIH1cbiAgICByZXR1cm4gdmFsdWVzQXJyYXk7XG59XG4iXX0=

package/esm2022/lib/utils/constants.mjs

@@ -0,0 +1,55 @@
+/**
+ * constants
+ */
+import { range } from './array.utils';
+/** Whether the browser supports the Intl API. */
+export const SUPPORTS_INTL_API = typeof Intl !== 'undefined';
+/** The default month names to use if Intl API is not available. */
+export const DEFAULT_MONTH_NAMES = {
+    long: [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December'
+    ],
+    short: [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec'
+    ],
+    narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']
+};
+/** The default day of the week names to use if Intl API is not available. */
+export const DEFAULT_DAY_OF_WEEK_NAMES = {
+    long: [
+        'Sunday',
+        'Monday',
+        'Tuesday',
+        'Wednesday',
+        'Thursday',
+        'Friday',
+        'Saturday'
+    ],
+    short: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S']
+};
+/** The default date names to use if Intl API is not available. */
+export const DEFAULT_DATE_NAMES = range(31, i => String(i + 1));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/date.utils.mjs

@@ -0,0 +1,49 @@
+/**
+ * date.utils
+ */
+/**
+ * Creates a date with the given year, month, date, hour, minute and second. Does not allow over/under-flow of the
+ * month and date.
+ */
+export function 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 = createDateWithOverflow(year, month, date, hours, minutes, seconds);
+    // Check that the date wasn't above the upper bound for the month, causing the month to overflow
+    // For example, createDate(2017, 1, 31) would try to create a date 2017/02/31 which is invalid
+    if (result.getMonth() !== month) {
+        throw Error(`Invalid date "${date}" for month with index "${month}".`);
+    }
+    return result;
+}
+/**
+ * Gets the number of days in the month of the given date.
+ */
+export function getNumDaysInMonth(date) {
+    const lastDateOfMonth = createDateWithOverflow(date.getFullYear(), date.getMonth() + 1, 0);
+    return lastDateOfMonth.getDate();
+}
+/**
+ * Creates a date but allows the month and date to overflow.
+ */
+function createDateWithOverflow(year, month, date, hours = 0, minutes = 0, seconds = 0) {
+    const result = new Date(year, month, date, hours, minutes, seconds);
+    if (year >= 0 && year < 100) {
+        result.setFullYear(result.getFullYear() - 1900);
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * index
+ */
+export * from './object.utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9waWNrZXIvc3JjL2xpYi91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGluZGV4XG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9vYmplY3QudXRpbHMnO1xuIl19

package/esm2022/lib/utils/object.utils.mjs

@@ -0,0 +1,26 @@
+/**
+ * object.utils
+ */
+/**
+ * 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.
+ */
+export function extendObject(dest, ...sources) {
+    if (dest == null) {
+        throw TypeError('Cannot convert undefined or null to object');
+    }
+    for (const source of sources) {
+        if (source != null) {
+            for (const key in source) {
+                if (source.hasOwnProperty(key)) {
+                    dest[key] = source[key];
+                }
+            }
+        }
+    }
+    return dest;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcGlja2VyL3NyYy9saWIvdXRpbHMvb2JqZWN0LnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBR0g7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBQyxJQUFTLEVBQUUsR0FBRyxPQUFjO0lBQ3JELElBQUksSUFBSSxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ2YsTUFBTSxTQUFTLENBQUMsNENBQTRDLENBQUMsQ0FBQztJQUNsRSxDQUFDO0lBRUQsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUMzQixJQUFJLE1BQU0sSUFBSSxJQUFJLEVBQUUsQ0FBQztZQUNqQixLQUFLLE1BQU0sR0FBRyxJQUFJLE1BQU0sRUFBRSxDQUFDO2dCQUN2QixJQUFJLE1BQU0sQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztvQkFDN0IsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFDNUIsQ0FBQztZQUNMLENBQUM7UUFDTCxDQUFDO0lBQ0wsQ0FBQztJQUVELE9BQU8sSUFBSSxDQUFDO0FBQ2hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIG9iamVjdC51dGlsc1xuICovXG5cblxuLyoqXG4gKiBFeHRlbmRzIGFuIG9iamVjdCB3aXRoIHRoZSAqZW51bWVyYWJsZSogYW5kICpvd24qIHByb3BlcnRpZXMgb2Ygb25lIG9yIG1vcmUgc291cmNlIG9iamVjdHMsXG4gKiBzaW1pbGFyIHRvIE9iamVjdC5hc3NpZ24uXG4gKlxuICogQHBhcmFtIGRlc3QgVGhlIG9iamVjdCB3aGljaCB3aWxsIGhhdmUgcHJvcGVydGllcyBjb3BpZWQgdG8gaXQuXG4gKiBAcGFyYW0gc291cmNlcyBUaGUgc291cmNlIG9iamVjdHMgZnJvbSB3aGljaCBwcm9wZXJ0aWVzIHdpbGwgYmUgY29waWVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZXh0ZW5kT2JqZWN0KGRlc3Q6IGFueSwgLi4uc291cmNlczogYW55W10pOiBhbnkge1xuICAgIGlmIChkZXN0ID09IG51bGwpIHtcbiAgICAgICAgdGhyb3cgVHlwZUVycm9yKCdDYW5ub3QgY29udmVydCB1bmRlZmluZWQgb3IgbnVsbCB0byBvYmplY3QnKTtcbiAgICB9XG5cbiAgICBmb3IgKGNvbnN0IHNvdXJjZSBvZiBzb3VyY2VzKSB7XG4gICAgICAgIGlmIChzb3VyY2UgIT0gbnVsbCkge1xuICAgICAgICAgICAgZm9yIChjb25zdCBrZXkgaW4gc291cmNlKSB7XG4gICAgICAgICAgICAgICAgaWYgKHNvdXJjZS5oYXNPd25Qcm9wZXJ0eShrZXkpKSB7XG4gICAgICAgICAgICAgICAgICAgIGRlc3Rba2V5XSA9IHNvdXJjZVtrZXldO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBkZXN0O1xufVxuIl19

package/esm2022/netwin-angular-datetime-picker.mjs

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

package/esm2022/public_api.mjs

@@ -0,0 +1,25 @@
+/**
+ * picker
+ */
+export { OwlDateTimeModule } from './lib/date-time/date-time.module';
+export { OwlDateTimeIntl } from './lib/date-time/date-time-picker-intl.service';
+export { OwlNativeDateTimeModule } from './lib/date-time/adapter/native-date-time.module';
+export { OWL_DATE_TIME_LOCALE_PROVIDER, OWL_DATE_TIME_LOCALE, DateTimeAdapter, } from './lib/date-time/adapter/date-time-adapter.class';
+export { OWL_DATE_TIME_FORMATS } from './lib/date-time/adapter/date-time-format.class';
+export { UnixTimestampDateTimeAdapter } from './lib/date-time/adapter/unix-timestamp-adapter/unix-timestamp-date-time-adapter.class';
+export { OWL_UNIX_TIMESTAMP_DATE_TIME_FORMATS } from './lib/date-time/adapter/unix-timestamp-adapter/unix-timestamp-date-time-format.class';
+export { OwlDateTimeInlineComponent } from './lib/date-time/date-time-inline.component';
+export { OwlDateTimeComponent } from './lib/date-time/date-time-picker.component';
+export * from './lib/date-time/calendar-body.component';
+export * from './lib/date-time/timer.component';
+export * from './lib/date-time/date-time-picker-trigger.directive';
+export * from './lib/date-time/date-time-picker-input.directive';
+export * from './lib/date-time/calendar-multi-year-view.component';
+export * from './lib/date-time/calendar-year-view.component';
+export * from './lib/date-time/calendar-month-view.component';
+export * from './lib/date-time/calendar.component';
+export * from './lib/date-time/timer.component';
+export { NativeDateTimeAdapter } from './lib/date-time/adapter/native-date-time-adapter.class';
+export * from './lib/date-time/options-provider';
+export { DateView } from './lib/date-time/date-time.class';
+//# sourceMappingURL=data:application/json;base64,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