ngwr 0.2.0 → 0.3.1

package/_index.scss

@@ -14,9 +14,13 @@
 
 @import 'styles/grid';
 @import 'styles/animations';
+@import 'styles/cdk';
+
+@import 'backdrop/backdrop';
 
 @import 'button/button';
 @import 'checkbox/checkbox';
+@import 'dialog/dialog';
 @import 'divider/divider';
 @import 'form/form';
 @import 'icon/icon';

package/backdrop/backdrop.scss

@@ -0,0 +1,3 @@
+.wr-backdrop {
+  background: rgba(var(--wr-color-black-rgb), 0.875);
+}

package/dialog/dialog-animations.d.ts

@@ -0,0 +1,16 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+export declare const WR_ANIMATION_ZOOM_CLASS_NAME_MAP: {
+    enter: string;
+    enterActive: string;
+    leave: string;
+    leaveActive: string;
+};
+export declare const WR_ANIMATION_FADE_CLASS_NAME_MAP: {
+    enter: string;
+    enterActive: string;
+    leave: string;
+    leaveActive: string;
+};
+export declare const wrDialogAnimations: {
+    readonly dialogContainer: AnimationTriggerMetadata;
+};

package/dialog/dialog-base.d.ts

@@ -0,0 +1,34 @@
+import { AnimationEvent } from '@angular/animations';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { ChangeDetectorRef, ComponentRef, ElementRef, EmbeddedViewRef, EventEmitter, OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { WrDialogConfig } from './dialog-config';
+import { WrDialogRef } from './dialog-ref';
+import * as i0 from "@angular/core";
+export declare class WrDialogBase extends BasePortalOutlet implements OnDestroy {
+    cdr: ChangeDetectorRef;
+    config: WrDialogConfig;
+    protected overlayRef: OverlayRef;
+    portalOutlet: CdkPortalOutlet;
+    dialogElementRef: ElementRef<HTMLDivElement>;
+    dialogRef: WrDialogRef;
+    containerClick: EventEmitter<void>;
+    animationStateChanged: EventEmitter<AnimationEvent>;
+    state: 'void' | 'enter' | 'exit';
+    protected readonly destroyed$: Subject<void>;
+    constructor(cdr: ChangeDetectorRef, config: WrDialogConfig, overlayRef: OverlayRef);
+    ngOnDestroy(): void;
+    onContainerClick(e: MouseEvent): void;
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    private setEnterAnimationClass;
+    private setExitAnimationClass;
+    private setMaskExitAnimationClass;
+    private cleanAnimationClass;
+    onAnimationDone(event: AnimationEvent): void;
+    onAnimationStart(event: AnimationEvent): void;
+    startExitAnimation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrDialogBase, never, never, {}, {}, never, never, false>;
+}

package/dialog/dialog-config.d.ts

@@ -0,0 +1,11 @@
+import { ComponentType, PositionStrategy } from '@angular/cdk/overlay';
+import { ViewContainerRef } from '@angular/core';
+import { SafeAny } from 'ngwr/core/types';
+export declare class WrDialogConfig<T = SafeAny> {
+    id?: string;
+    component?: ComponentType<T>;
+    title?: string;
+    data?: SafeAny;
+    viewContainerRef?: ViewContainerRef;
+    positionStrategy?: PositionStrategy;
+}

package/dialog/dialog-container.d.ts

@@ -0,0 +1,22 @@
+import { AnimationEvent } from '@angular/animations';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { CdkPortalOutlet } from '@angular/cdk/portal';
+import { ChangeDetectorRef, ElementRef } from '@angular/core';
+import { SafeAny } from 'ngwr/core/types';
+import { WrDialogBase } from './dialog-base';
+import { WrDialogConfig } from './dialog-config';
+import * as i0 from "@angular/core";
+export declare class WrDialogContainer extends WrDialogBase {
+    config: WrDialogConfig;
+    portalOutlet: CdkPortalOutlet;
+    dialogElementRef: ElementRef<HTMLDivElement>;
+    state: 'void' | 'enter' | 'exit';
+    onAnimationStart(event: AnimationEvent): void;
+    onAnimationDone(event: AnimationEvent): void;
+    onContainerClick(e: MouseEvent): void;
+    /** Set element classes */
+    get elClasses(): SafeAny;
+    constructor(cdr: ChangeDetectorRef, config: WrDialogConfig, overlayRef: OverlayRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogContainer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrDialogContainer, "wr-dialog-container", ["wrDialogContainer"], {}, {}, never, never, false>;
+}

package/dialog/dialog-content-directives.d.ts

@@ -0,0 +1,31 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { SafeAny } from 'ngwr/core/types';
+import { WrDialogRef } from './dialog-ref';
+import * as i0 from "@angular/core";
+export declare class WrDialogClose {
+    dialogRef: WrDialogRef;
+    _onButtonClick(event: MouseEvent): void;
+    constructor(dialogRef: WrDialogRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogClose, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrDialogClose, "[wr-dialog-close], [wrDialogClose]", ["wrDialogClose"], {}, {}, never, never, false>;
+}
+export declare class WrDialogTitle {
+    get elClasses(): SafeAny;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrDialogTitle, "[wr-dialog-title], [wrDialogTitle]", ["wrtDialogTitle"], {}, {}, never, never, false>;
+}
+export declare class WrDialogContent {
+    get elClasses(): SafeAny;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrDialogContent, "[wr-dialog-content], wr-dialog-content, [wrDialogContent]", never, {}, {}, never, never, false>;
+}
+export declare class WrDialogFooter {
+    private readonly cdr;
+    get position(): 'start' | 'center' | 'end';
+    set position(value: 'start' | 'center' | 'end');
+    private _position;
+    get elClasses(): SafeAny;
+    constructor(cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogFooter, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<WrDialogFooter, "[wr-dialog-footer], wr-dialog-footer, [wrDialogFooter]", never, { "position": "position"; }, {}, never, never, false>;
+}

package/dialog/dialog-module.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog-container";
+import * as i2 from "./dialog-content-directives";
+import * as i3 from "@angular/common";
+import * as i4 from "@angular/cdk/overlay";
+import * as i5 from "@angular/cdk/portal";
+import * as i6 from "ngwr/icon";
+export declare class WrDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<WrDialogModule, [typeof i1.WrDialogContainer, typeof i2.WrDialogClose, typeof i2.WrDialogTitle, typeof i2.WrDialogContent, typeof i2.WrDialogFooter], [typeof i3.CommonModule, typeof i4.OverlayModule, typeof i5.PortalModule, typeof i6.WrIconModule], [typeof i1.WrDialogContainer, typeof i2.WrDialogClose, typeof i2.WrDialogTitle, typeof i2.WrDialogContent, typeof i2.WrDialogFooter]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<WrDialogModule>;
+}

package/dialog/dialog-ref.d.ts

@@ -0,0 +1,20 @@
+import { OverlayRef } from '@angular/cdk/overlay';
+import { Subject } from 'rxjs';
+import { WrAbstractBase } from 'ngwr/core/abstract';
+import { SafeAny } from 'ngwr/core/types';
+import { WrDialogBase } from './dialog-base';
+import { WrDialogConfig } from './dialog-config';
+export declare class WrDialogRef<T = SafeAny, R = SafeAny> extends WrAbstractBase {
+    private readonly config;
+    private readonly overlayRef;
+    containerInstance: WrDialogBase;
+    readonly id?: string;
+    result?: R;
+    componentInstance: T | null;
+    private closeTimeout?;
+    readonly afterClosed: Subject<R | undefined>;
+    readonly afterOpened: Subject<void>;
+    constructor(config: WrDialogConfig<T>, overlayRef: OverlayRef, containerInstance: WrDialogBase);
+    close(result?: R): void;
+    _finishDialogClose(): void;
+}

package/dialog/dialog-service.d.ts

@@ -0,0 +1,27 @@
+import { Overlay } from '@angular/cdk/overlay';
+import { Injector, OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { SafeAny } from 'ngwr/core/types';
+import { WrDialogConfig } from './dialog-config';
+import { WrDialogRef } from './dialog-ref';
+import * as i0 from "@angular/core";
+export declare class WrDialogService implements OnDestroy {
+    private readonly overlay;
+    private readonly injector;
+    private parentModal;
+    private openedDialogsAtThisLevel;
+    private readonly afterAllClosedAtThisLevel;
+    get openedDialogs(): WrDialogRef[];
+    get _afterAllClosed(): Subject<void>;
+    constructor(overlay: Overlay, injector: Injector, parentModal: WrDialogService);
+    ngOnDestroy(): void;
+    open<T = SafeAny, R = SafeAny>(config: WrDialogConfig<T>): WrDialogRef<T, R>;
+    private removeOpenModal;
+    private closeModals;
+    private _defaultPositionStrategy;
+    private _createOverlay;
+    private _attachDialogContainer;
+    private _attachDialogContent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrDialogService, [null, null, { optional: true; skipSelf: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WrDialogService>;
+}

package/dialog/dialog-tokens.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@angular/core';
+export declare const WR_DIALOG_DATA: InjectionToken<any>;

package/dialog/dialog.scss

@@ -0,0 +1,48 @@
+.wr-dialog {
+  &__wrapper {
+    background: var(--wr-dialog-bg);
+    border-radius: var(--wr-border-radius-base);
+    min-width: var(--wr-dialog-min-width);
+    max-height: calc(100vh - calc(var(--wr-grid-gutter) * 2));
+    max-width: calc(100vw - calc(var(--wr-grid-gutter) * 2));
+  }
+
+  &__title,
+  &__content,
+  &__footer {
+    padding: var(--wr-dialog-padding-y) var(--wr-dialog-padding-x);
+  }
+
+  &__title {
+    display: block;
+    color: var(--wr-dialog-title-color);
+    font-size: 1rem;
+    font-weight: 500;
+    line-height: 1rem;
+    border-bottom: 1px solid var(--wr-border-color-base);
+    width: 100%;
+  }
+
+  &__content {
+    overflow: auto;
+    max-height: 80vh;
+  }
+
+  &__footer {
+    display: flex;
+    align-items: center;
+    border-top: 1px solid var(--wr-border-color-base);
+
+    &-start {
+      justify-content: flex-start;
+    }
+
+    &--center {
+      justify-content: center;
+    }
+
+    &--end {
+      justify-content: end;
+    }
+  }
+}

package/dialog/index.d.ts

@@ -0,0 +1,9 @@
+export { wrDialogAnimations, WR_ANIMATION_ZOOM_CLASS_NAME_MAP, WR_ANIMATION_FADE_CLASS_NAME_MAP, } from './dialog-animations';
+export { WrDialogBase } from './dialog-base';
+export { WrDialogConfig } from './dialog-config';
+export { WrDialogContainer } from './dialog-container';
+export { WrDialogClose, WrDialogTitle, WrDialogContent, WrDialogFooter } from './dialog-content-directives';
+export { WrDialogModule } from './dialog-module';
+export { WrDialogRef } from './dialog-ref';
+export { WrDialogService } from './dialog-service';
+export { WR_DIALOG_DATA } from './dialog-tokens';

package/esm2020/dialog/dialog-animations.mjs

@@ -0,0 +1,22 @@
+import { animate, state, style, transition, trigger } from '@angular/animations';
+export const WR_ANIMATION_ZOOM_CLASS_NAME_MAP = {
+    enter: 'wr-animation-zoom-enter',
+    enterActive: 'wr-animation-zoom-enter--active',
+    leave: 'wr-animation-zoom-leave',
+    leaveActive: 'wr-animation-zoom-leave--active',
+};
+export const WR_ANIMATION_FADE_CLASS_NAME_MAP = {
+    enter: 'wr-animation-fade-enter',
+    enterActive: 'wr-animation-fade-enter--active',
+    leave: 'wr-animation-fade-leave',
+    leaveActive: 'wr-animation-fade-leave--active',
+};
+export const wrDialogAnimations = {
+    dialogContainer: trigger('dialogContainer', [
+        state('void, exit', style({})),
+        state('enter', style({})),
+        transition('* => enter', animate('.24s', style({}))),
+        transition('* => void, * => exit', animate('.2s', style({}))),
+    ]),
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dialog/dialog-base.mjs

@@ -0,0 +1,92 @@
+import { BasePortalOutlet } from '@angular/cdk/portal';
+import { Directive, EventEmitter, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { WR_ANIMATION_FADE_CLASS_NAME_MAP, WR_ANIMATION_ZOOM_CLASS_NAME_MAP } from './dialog-animations';
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog-config";
+import * as i2 from "@angular/cdk/overlay";
+export class WrDialogBase extends BasePortalOutlet {
+    constructor(cdr, config, overlayRef) {
+        super();
+        this.cdr = cdr;
+        this.config = config;
+        this.overlayRef = overlayRef;
+        this.containerClick = new EventEmitter();
+        this.animationStateChanged = new EventEmitter();
+        this.state = 'enter';
+        this.destroyed$ = new Subject();
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+        this.destroyed$.complete();
+    }
+    onContainerClick(e) {
+        if (e.target === e.currentTarget || e.target === this.dialogElementRef.nativeElement) {
+            this.containerClick.emit();
+        }
+    }
+    attachComponentPortal(portal) {
+        return this.portalOutlet.attachComponentPortal(portal);
+    }
+    attachTemplatePortal(portal) {
+        return this.portalOutlet.attachTemplatePortal(portal);
+    }
+    setEnterAnimationClass() {
+        const dialogElement = this.dialogElementRef.nativeElement;
+        const backdropElement = this.overlayRef.backdropElement;
+        dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enter);
+        dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enterActive);
+        if (backdropElement) {
+            backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.enter);
+            backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.enterActive);
+        }
+    }
+    setExitAnimationClass() {
+        const dialogElement = this.dialogElementRef.nativeElement;
+        dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leave);
+        dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leaveActive);
+        this.setMaskExitAnimationClass();
+    }
+    setMaskExitAnimationClass() {
+        const backdropElement = this.overlayRef.backdropElement;
+        if (backdropElement) {
+            backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.leave);
+            backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.leaveActive);
+        }
+    }
+    cleanAnimationClass() {
+        const backdropElement = this.overlayRef.backdropElement;
+        const dialogElement = this.dialogElementRef.nativeElement;
+        if (backdropElement) {
+            backdropElement.classList.remove(WR_ANIMATION_FADE_CLASS_NAME_MAP.enter);
+            backdropElement.classList.remove(WR_ANIMATION_FADE_CLASS_NAME_MAP.enterActive);
+        }
+        dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enter);
+        dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enterActive);
+        dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leave);
+        dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leaveActive);
+    }
+    onAnimationDone(event) {
+        this.cleanAnimationClass();
+        this.animationStateChanged.emit(event);
+    }
+    onAnimationStart(event) {
+        if (event.toState === 'enter') {
+            this.setEnterAnimationClass();
+        }
+        else if (event.toState === 'exit') {
+            this.setExitAnimationClass();
+        }
+        this.animationStateChanged.emit(event);
+    }
+    startExitAnimation() {
+        this.state = 'exit';
+        this.cdr.markForCheck();
+    }
+}
+WrDialogBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogBase, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.WrDialogConfig }, { token: i2.OverlayRef }], target: i0.ɵɵFactoryTarget.Directive });
+WrDialogBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.10", type: WrDialogBase, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.WrDialogConfig }, { type: i2.OverlayRef }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-base.js","sourceRoot":"","sources":["../../../../projects/lib/dialog/dialog-base.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAoD,MAAM,qBAAqB,CAAC;AACzG,OAAO,EAGL,SAAS,EAGT,YAAY,GAEb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAE/B,OAAO,EAAE,gCAAgC,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;;;;AAKzG,MAAM,OAAO,YAAa,SAAQ,gBAAgB;IAYhD,YAAmB,GAAsB,EAAS,MAAsB,EAAY,UAAsB;QACxG,KAAK,EAAE,CAAC;QADS,QAAG,GAAH,GAAG,CAAmB;QAAS,WAAM,GAAN,MAAM,CAAgB;QAAY,eAAU,GAAV,UAAU,CAAY;QAP1G,mBAAc,GAAG,IAAI,YAAY,EAAQ,CAAC;QAC1C,0BAAqB,GAAG,IAAI,YAAY,EAAkB,CAAC;QAE3D,UAAK,GAA8B,OAAO,CAAC;QAExB,eAAU,GAAkB,IAAI,OAAO,EAAQ,CAAC;IAInE,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,gBAAgB,CAAC,CAAa;QAC5B,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,aAAa,IAAI,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE;YACpF,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;SAC5B;IACH,CAAC;IAED,qBAAqB,CAAI,MAA0B;QACjD,OAAO,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;IACzD,CAAC;IAED,oBAAoB,CAAI,MAAyB;QAC/C,OAAO,IAAI,CAAC,YAAY,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACxD,CAAC;IAEO,sBAAsB;QAC5B,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;QAC1D,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;QACxD,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;QACpE,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAC;QAC1E,IAAI,eAAe,EAAE;YACnB,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;YACtE,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAC;SAC7E;IACH,CAAC;IAEO,qBAAqB;QAC3B,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;QAC1D,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;QACpE,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAC;QAC1E,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAEO,yBAAyB;QAC/B,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;QACxD,IAAI,eAAe,EAAE;YACnB,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;YACtE,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAC;SAC7E;IACH,CAAC;IAEO,mBAAmB;QACzB,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;QACxD,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC;QAC1D,IAAI,eAAe,EAAE;YACnB,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;YACzE,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAC;SAChF;QACD,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;QACvE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAC;QAC7E,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,gCAAgC,CAAC,KAAK,CAAC,CAAC;QACvE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,gCAAgC,CAAC,WAAW,CAAC,CAAC;IAC/E,CAAC;IAED,eAAe,CAAC,KAAqB;QACnC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,gBAAgB,CAAC,KAAqB;QACpC,IAAI,KAAK,CAAC,OAAO,KAAK,OAAO,EAAE;YAC7B,IAAI,CAAC,sBAAsB,EAAE,CAAC;SAC/B;aAAM,IAAI,KAAK,CAAC,OAAO,KAAK,MAAM,EAAE;YACnC,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC9B;QACD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,kBAAkB;QAChB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;QACpB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;IAC1B,CAAC;;0GA3FU,YAAY;8FAAZ,YAAY;4FAAZ,YAAY;kBADxB,SAAS","sourcesContent":["import { AnimationEvent } from '@angular/animations';\nimport { OverlayRef } from '@angular/cdk/overlay';\nimport { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';\nimport {\n  ChangeDetectorRef,\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EmbeddedViewRef,\n  EventEmitter,\n  OnDestroy,\n} from '@angular/core';\nimport { Subject } from 'rxjs';\n\nimport { WR_ANIMATION_FADE_CLASS_NAME_MAP, WR_ANIMATION_ZOOM_CLASS_NAME_MAP } from './dialog-animations';\nimport { WrDialogConfig } from './dialog-config';\nimport { WrDialogRef } from './dialog-ref';\n\n@Directive()\nexport class WrDialogBase extends BasePortalOutlet implements OnDestroy {\n  portalOutlet!: CdkPortalOutlet;\n  dialogElementRef!: ElementRef<HTMLDivElement>;\n  dialogRef!: WrDialogRef;\n\n  containerClick = new EventEmitter<void>();\n  animationStateChanged = new EventEmitter<AnimationEvent>();\n\n  state: 'void' | 'enter' | 'exit' = 'enter';\n\n  protected readonly destroyed$: Subject<void> = new Subject<void>();\n\n  constructor(public cdr: ChangeDetectorRef, public config: WrDialogConfig, protected overlayRef: OverlayRef) {\n    super();\n  }\n\n  ngOnDestroy(): void {\n    this.destroyed$.next();\n    this.destroyed$.complete();\n  }\n\n  onContainerClick(e: MouseEvent): void {\n    if (e.target === e.currentTarget || e.target === this.dialogElementRef.nativeElement) {\n      this.containerClick.emit();\n    }\n  }\n\n  attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T> {\n    return this.portalOutlet.attachComponentPortal(portal);\n  }\n\n  attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C> {\n    return this.portalOutlet.attachTemplatePortal(portal);\n  }\n\n  private setEnterAnimationClass(): void {\n    const dialogElement = this.dialogElementRef.nativeElement;\n    const backdropElement = this.overlayRef.backdropElement;\n    dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enter);\n    dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enterActive);\n    if (backdropElement) {\n      backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.enter);\n      backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.enterActive);\n    }\n  }\n\n  private setExitAnimationClass(): void {\n    const dialogElement = this.dialogElementRef.nativeElement;\n    dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leave);\n    dialogElement.classList.add(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leaveActive);\n    this.setMaskExitAnimationClass();\n  }\n\n  private setMaskExitAnimationClass(): void {\n    const backdropElement = this.overlayRef.backdropElement;\n    if (backdropElement) {\n      backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.leave);\n      backdropElement.classList.add(WR_ANIMATION_FADE_CLASS_NAME_MAP.leaveActive);\n    }\n  }\n\n  private cleanAnimationClass(): void {\n    const backdropElement = this.overlayRef.backdropElement;\n    const dialogElement = this.dialogElementRef.nativeElement;\n    if (backdropElement) {\n      backdropElement.classList.remove(WR_ANIMATION_FADE_CLASS_NAME_MAP.enter);\n      backdropElement.classList.remove(WR_ANIMATION_FADE_CLASS_NAME_MAP.enterActive);\n    }\n    dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enter);\n    dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.enterActive);\n    dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leave);\n    dialogElement.classList.remove(WR_ANIMATION_ZOOM_CLASS_NAME_MAP.leaveActive);\n  }\n\n  onAnimationDone(event: AnimationEvent): void {\n    this.cleanAnimationClass();\n    this.animationStateChanged.emit(event);\n  }\n\n  onAnimationStart(event: AnimationEvent): void {\n    if (event.toState === 'enter') {\n      this.setEnterAnimationClass();\n    } else if (event.toState === 'exit') {\n      this.setExitAnimationClass();\n    }\n    this.animationStateChanged.emit(event);\n  }\n\n  startExitAnimation(): void {\n    this.state = 'exit';\n    this.cdr.markForCheck();\n  }\n}\n"]}

package/esm2020/dialog/dialog-config.mjs

@@ -0,0 +1,3 @@
+export class WrDialogConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2xpYi9kaWFsb2cvZGlhbG9nLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLE9BQU8sY0FBYztDQU8xQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudFR5cGUsIFBvc2l0aW9uU3RyYXRlZ3kgfSBmcm9tICdAYW5ndWxhci9jZGsvb3ZlcmxheSc7XG5pbXBvcnQgeyBWaWV3Q29udGFpbmVyUmVmIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFNhZmVBbnkgfSBmcm9tICduZ3dyL2NvcmUvdHlwZXMnO1xuXG5leHBvcnQgY2xhc3MgV3JEaWFsb2dDb25maWc8VCA9IFNhZmVBbnk+IHtcbiAgaWQ/OiBzdHJpbmc7XG4gIGNvbXBvbmVudD86IENvbXBvbmVudFR5cGU8VD47XG4gIHRpdGxlPzogc3RyaW5nO1xuICBkYXRhPzogU2FmZUFueTtcbiAgdmlld0NvbnRhaW5lclJlZj86IFZpZXdDb250YWluZXJSZWY7XG4gIHBvc2l0aW9uU3RyYXRlZ3k/OiBQb3NpdGlvblN0cmF0ZWd5O1xufVxuIl19

package/esm2020/dialog/dialog-container.mjs

@@ -0,0 +1,58 @@
+import { CdkPortalOutlet } from '@angular/cdk/portal';
+import { Component, HostBinding, HostListener, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { wrDialogAnimations } from './dialog-animations';
+import { WrDialogBase } from './dialog-base';
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog-config";
+import * as i2 from "@angular/cdk/overlay";
+import * as i3 from "@angular/cdk/portal";
+export class WrDialogContainer extends WrDialogBase {
+    constructor(cdr, config, overlayRef) {
+        super(cdr, config, overlayRef);
+        this.config = config;
+        this.state = 'enter';
+    }
+    onAnimationStart(event) {
+        super.onAnimationStart(event);
+    }
+    onAnimationDone(event) {
+        super.onAnimationDone(event);
+    }
+    onContainerClick(e) {
+        super.onContainerClick(e);
+    }
+    /** Set element classes */
+    get elClasses() {
+        return {
+            'wr-dialog': true,
+        };
+    }
+}
+WrDialogContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogContainer, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.WrDialogConfig }, { token: i2.OverlayRef }], target: i0.ɵɵFactoryTarget.Component });
+WrDialogContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.10", type: WrDialogContainer, selector: "wr-dialog-container", host: { listeners: { "@dialogContainer.start": "onAnimationStart($event)", "@dialogContainer.done": "onAnimationDone($event)", "click": "onContainerClick($event)" }, properties: { "@dialogContainer": "this.state", "class": "this.elClasses" } }, viewQueries: [{ propertyName: "portalOutlet", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }, { propertyName: "dialogElementRef", first: true, predicate: ["dialogElement"], descendants: true, static: true }], exportAs: ["wrDialogContainer"], usesInheritance: true, ngImport: i0, template: "<div class=\"wr-dialog__wrapper\" #dialogElement>\n  <ng-template cdkPortalOutlet></ng-template>\n</div>\n", dependencies: [{ kind: "directive", type: i3.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }], animations: [wrDialogAnimations.dialogContainer], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogContainer, decorators: [{
+            type: Component,
+            args: [{ selector: 'wr-dialog-container', exportAs: 'wrDialogContainer', animations: [wrDialogAnimations.dialogContainer], encapsulation: ViewEncapsulation.None, template: "<div class=\"wr-dialog__wrapper\" #dialogElement>\n  <ng-template cdkPortalOutlet></ng-template>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.WrDialogConfig }, { type: i2.OverlayRef }]; }, propDecorators: { portalOutlet: [{
+                type: ViewChild,
+                args: [CdkPortalOutlet, { static: true }]
+            }], dialogElementRef: [{
+                type: ViewChild,
+                args: ['dialogElement', { static: true }]
+            }], state: [{
+                type: HostBinding,
+                args: ['@dialogContainer']
+            }], onAnimationStart: [{
+                type: HostListener,
+                args: ['@dialogContainer.start', ['$event']]
+            }], onAnimationDone: [{
+                type: HostListener,
+                args: ['@dialogContainer.done', ['$event']]
+            }], onContainerClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], elClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dialog/dialog-content-directives.mjs

@@ -0,0 +1,98 @@
+import { Directive, HostBinding, HostListener, Input, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./dialog-ref";
+export class WrDialogClose {
+    constructor(dialogRef) {
+        this.dialogRef = dialogRef;
+    }
+    _onButtonClick(event) {
+        event.preventDefault();
+        this.dialogRef.close(undefined);
+    }
+}
+WrDialogClose.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogClose, deps: [{ token: i1.WrDialogRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+WrDialogClose.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.10", type: WrDialogClose, selector: "[wr-dialog-close], [wrDialogClose]", host: { listeners: { "click": "_onButtonClick($event)" } }, exportAs: ["wrDialogClose"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogClose, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[wr-dialog-close], [wrDialogClose]',
+                    exportAs: 'wrDialogClose',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.WrDialogRef, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { _onButtonClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+export class WrDialogTitle {
+    get elClasses() {
+        return {
+            'wr-dialog__title': true,
+        };
+    }
+}
+WrDialogTitle.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogTitle, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+WrDialogTitle.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.10", type: WrDialogTitle, selector: "[wr-dialog-title], [wrDialogTitle]", host: { properties: { "class": "this.elClasses" } }, exportAs: ["wrtDialogTitle"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogTitle, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[wr-dialog-title], [wrDialogTitle]',
+                    exportAs: 'wrtDialogTitle',
+                }]
+        }], propDecorators: { elClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+export class WrDialogContent {
+    get elClasses() {
+        return {
+            'wr-dialog__content': true,
+        };
+    }
+}
+WrDialogContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogContent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+WrDialogContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.10", type: WrDialogContent, selector: "[wr-dialog-content], wr-dialog-content, [wrDialogContent]", host: { properties: { "class": "this.elClasses" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogContent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[wr-dialog-content], wr-dialog-content, [wrDialogContent]`,
+                }]
+        }], propDecorators: { elClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+export class WrDialogFooter {
+    constructor(cdr) {
+        this.cdr = cdr;
+        this._position = 'end';
+    }
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        this._position = value;
+        this.cdr.markForCheck();
+    }
+    get elClasses() {
+        return {
+            'wr-dialog__footer': true,
+            'wr-dialog__footer--start': this.position === 'start',
+            'wr-dialog__footer--center': this.position === 'center',
+            'wr-dialog__footer--end': this.position === 'end',
+        };
+    }
+}
+WrDialogFooter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogFooter, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+WrDialogFooter.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.10", type: WrDialogFooter, selector: "[wr-dialog-footer], wr-dialog-footer, [wrDialogFooter]", inputs: { position: "position" }, host: { properties: { "class": "this.elClasses" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogFooter, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[wr-dialog-footer], wr-dialog-footer, [wrDialogFooter]`,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { position: [{
+                type: Input
+            }], elClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dialog/dialog-module.mjs

@@ -0,0 +1,24 @@
+import { FullscreenOverlayContainer, OverlayContainer, OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { WrIconModule } from 'ngwr/icon';
+import { WrDialogContainer } from './dialog-container';
+import { WrDialogClose, WrDialogContent, WrDialogFooter, WrDialogTitle } from './dialog-content-directives';
+import { WrDialogService } from './dialog-service';
+import * as i0 from "@angular/core";
+export class WrDialogModule {
+}
+WrDialogModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+WrDialogModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.10", ngImport: i0, type: WrDialogModule, declarations: [WrDialogContainer, WrDialogClose, WrDialogTitle, WrDialogContent, WrDialogFooter], imports: [CommonModule, OverlayModule, PortalModule, WrIconModule], exports: [WrDialogContainer, WrDialogClose, WrDialogTitle, WrDialogContent, WrDialogFooter] });
+WrDialogModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogModule, providers: [WrDialogService, { provide: OverlayContainer, useClass: FullscreenOverlayContainer }], imports: [CommonModule, OverlayModule, PortalModule, WrIconModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.10", ngImport: i0, type: WrDialogModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OverlayModule, PortalModule, WrIconModule],
+                    exports: [WrDialogContainer, WrDialogClose, WrDialogTitle, WrDialogContent, WrDialogFooter],
+                    declarations: [WrDialogContainer, WrDialogClose, WrDialogTitle, WrDialogContent, WrDialogFooter],
+                    providers: [WrDialogService, { provide: OverlayContainer, useClass: FullscreenOverlayContainer }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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