@netwin/angular-datetime-picker 1.0.0-rc.3

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

@@ -0,0 +1,228 @@
+/**
+ * dialog.service
+ */
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import { Inject, Injectable, InjectionToken, Optional, SkipSelf, TemplateRef } from '@angular/core';
+import { Subject, defer } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { extendObject } from '../utils';
+import { OwlDialogConfig } from './dialog-config.class';
+import { OwlDialogContainerComponent } from './dialog-container.component';
+import { OwlDialogRef } from './dialog-ref.class';
+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');
+// eslint-disable-next-line @angular-eslint/use-injectable-provided-in
+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)) {
+            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?.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.2.7", 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.2.7", ngImport: i0, type: OwlDialogService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", 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  BlockScrollStrategy,\n  Overlay,\n  OverlayConfig,\n  OverlayContainer,\n  OverlayRef,\n  ScrollStrategy\n} from '@angular/cdk/overlay';\nimport { ComponentPortal, ComponentType, PortalInjector } from '@angular/cdk/portal';\nimport { Location } from '@angular/common';\nimport {\n  ComponentRef,\n  Inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  Optional,\n  SkipSelf,\n  TemplateRef\n} from '@angular/core';\nimport { Observable, Subject, defer } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport { extendObject } from '../utils';\nimport { OwlDialogConfig, OwlDialogConfigInterface } from './dialog-config.class';\nimport { OwlDialogContainerComponent } from './dialog-container.component';\nimport { OwlDialogRef } from './dialog-ref.class';\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<() => ScrollStrategy>('owl-dialog-scroll-strategy');\n\nexport function OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY(overlay: Overlay): () => ScrollStrategy {\n  const fn = (): BlockScrollStrategy => 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>('owl-dialog-default-options');\n\n// eslint-disable-next-line @angular-eslint/use-injectable-provided-in\n@Injectable()\nexport class OwlDialogService {\n  private ariaHiddenElements = new Map<Element, string | null>();\n\n  private _openDialogsAtThisLevel: Array<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  public get openDialogs(): Array<OwlDialogRef<any>> {\n    return this.parentDialog ? this.parentDialog.openDialogs : this._openDialogsAtThisLevel;\n  }\n\n  /** Stream that emits when a dialog has been opened. */\n  public get beforeOpen(): Subject<OwlDialogRef<any>> {\n    return this.parentDialog ? this.parentDialog.beforeOpen : this._beforeOpenAtThisLevel;\n  }\n\n  /** Stream that emits when a dialog has been opened. */\n  public get afterOpen(): Subject<OwlDialogRef<any>> {\n    return this.parentDialog ? this.parentDialog.afterOpen : this._afterOpenAtThisLevel;\n  }\n\n  get #afterAllClosed(): Subject<void> {\n    const parent = this.parentDialog;\n    return parent ? parent.#afterAllClosed : 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  public afterAllClosed: Observable<void> = defer(() =>\n    this._openDialogsAtThisLevel.length ? this.#afterAllClosed : 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(`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>(componentOrTemplateRef, dialogContainer, overlayRef, config);\n\n    if (!this.openDialogs.length) {\n      this.hideNonDialogContentFromAssistiveTechnology();\n    }\n\n    this.openDialogs.push(dialogRef);\n    dialogRef.afterClosed().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  ): OwlDialogRef<T> {\n    const dialogRef = new OwlDialogRef<T>(overlayRef, dialogContainer, config.id, this.location);\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>(config, dialogRef, dialogContainer);\n      const contentRef = dialogContainer.attachComponentPortal(\n        new ComponentPortal(componentOrTemplateRef, undefined, injector)\n      );\n      dialogRef.componentInstance = contentRef.instance;\n    }\n\n    dialogRef.updateSize(config.width, config.height).updatePosition(config.position);\n\n    return dialogRef;\n  }\n\n  private createInjector<T>(\n    config: OwlDialogConfigInterface,\n    dialogRef: OwlDialogRef<T>,\n    dialogContainer: OwlDialogContainerComponent\n  ): PortalInjector {\n    const userInjector = 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(userInjector || this.injector, injectionTokens);\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(overlayRef: OverlayRef, config: OwlDialogConfigInterface): OwlDialogContainerComponent {\n    const containerPortal = new ComponentPortal(OwlDialogContainerComponent, config.viewContainerRef);\n    const containerRef: ComponentRef<OwlDialogContainerComponent> = 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: 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(): void {\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(sibling, sibling.getAttribute('aria-hidden'));\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXkudXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9waWNrZXIvc3JjL2xpYi91dGlscy9hcnJheS51dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGlEQUFpRDtBQUNqRCxNQUFNLFVBQVUsS0FBSyxDQUFJLE1BQWMsRUFBRSxhQUFtQztJQUMxRSxNQUFNLFdBQVcsR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDbEMsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ2hDLFdBQVcsQ0FBQyxDQUFDLENBQUMsR0FBRyxhQUFhLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDcEMsQ0FBQztJQUNELE9BQU8sV0FBVyxDQUFDO0FBQ3JCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGFycmF5LnV0aWxzXG4gKi9cblxuLyoqIENyZWF0ZXMgYW4gYXJyYXkgYW5kIGZpbGxzIGl0IHdpdGggdmFsdWVzLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJhbmdlPFQ+KGxlbmd0aDogbnVtYmVyLCB2YWx1ZUZ1bmN0aW9uOiAoaW5kZXg6IG51bWJlcikgPT4gVCk6IEFycmF5PFQ+IHtcbiAgY29uc3QgdmFsdWVzQXJyYXkgPSBBcnJheShsZW5ndGgpO1xuICBmb3IgKGxldCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKSB7XG4gICAgdmFsdWVzQXJyYXlbaV0gPSB2YWx1ZUZ1bmN0aW9uKGkpO1xuICB9XG4gIHJldHVybiB2YWx1ZXNBcnJheTtcbn1cbiJdfQ==

package/esm2022/lib/utils/constants.mjs

@@ -0,0 +1,34 @@
+/**
+ * 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 (Object.hasOwn(source, key)) {
+                    dest[key] = source[key];
+                }
+            }
+        }
+    }
+    return dest;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LnV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvcGlja2VyL3NyYy9saWIvdXRpbHMvb2JqZWN0LnV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUg7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBbUIsSUFBTyxFQUFFLEdBQUcsT0FBc0I7SUFDL0UsSUFBSSxJQUFJLElBQUksSUFBSSxFQUFFLENBQUM7UUFDakIsTUFBTSxTQUFTLENBQUMsNENBQTRDLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRUQsS0FBSyxNQUFNLE1BQU0sSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUM3QixJQUFJLE1BQU0sSUFBSSxJQUFJLEVBQUUsQ0FBQztZQUNuQixLQUFLLE1BQU0sR0FBRyxJQUFJLE1BQU0sRUFBRSxDQUFDO2dCQUN6QixJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUM7b0JBQy9CLElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7Z0JBQzFCLENBQUM7WUFDSCxDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUM7SUFFRCxPQUFPLElBQUksQ0FBQztBQUNkLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIG9iamVjdC51dGlsc1xuICovXG5cbi8qKlxuICogRXh0ZW5kcyBhbiBvYmplY3Qgd2l0aCB0aGUgKmVudW1lcmFibGUqIGFuZCAqb3duKiBwcm9wZXJ0aWVzIG9mIG9uZSBvciBtb3JlIHNvdXJjZSBvYmplY3RzLFxuICogc2ltaWxhciB0byBPYmplY3QuYXNzaWduLlxuICpcbiAqIEBwYXJhbSBkZXN0IFRoZSBvYmplY3Qgd2hpY2ggd2lsbCBoYXZlIHByb3BlcnRpZXMgY29waWVkIHRvIGl0LlxuICogQHBhcmFtIHNvdXJjZXMgVGhlIHNvdXJjZSBvYmplY3RzIGZyb20gd2hpY2ggcHJvcGVydGllcyB3aWxsIGJlIGNvcGllZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGV4dGVuZE9iamVjdDxUIGV4dGVuZHMgb2JqZWN0PihkZXN0OiBULCAuLi5zb3VyY2VzOiBBcnJheTxvYmplY3Q+KTogVCB7XG4gIGlmIChkZXN0ID09IG51bGwpIHtcbiAgICB0aHJvdyBUeXBlRXJyb3IoJ0Nhbm5vdCBjb252ZXJ0IHVuZGVmaW5lZCBvciBudWxsIHRvIG9iamVjdCcpO1xuICB9XG5cbiAgZm9yIChjb25zdCBzb3VyY2Ugb2Ygc291cmNlcykge1xuICAgIGlmIChzb3VyY2UgIT0gbnVsbCkge1xuICAgICAgZm9yIChjb25zdCBrZXkgaW4gc291cmNlKSB7XG4gICAgICAgIGlmIChPYmplY3QuaGFzT3duKHNvdXJjZSwga2V5KSkge1xuICAgICAgICAgIGRlc3Rba2V5XSA9IHNvdXJjZVtrZXldO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIGRlc3Q7XG59XG4iXX0=

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 { DateTimeAdapter, OWL_DATE_TIME_LOCALE, OWL_DATE_TIME_LOCALE_PROVIDER } 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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