@flywheel-io/vision 0.3.0 → 0.4.2

package/components/dialog/choice-dialog.component.d.ts

@@ -0,0 +1,24 @@
+import { ThemePalette } from '@angular/material/core';
+interface Choice {
+    color?: ThemePalette;
+    label: string;
+    testId?: string;
+    value: any;
+    variant?: 'raised' | 'stroked' | 'flat';
+}
+export interface FwChoiceDialogData {
+    alignActions: 'start' | 'center' | 'end';
+    choices: Choice[];
+    content: string;
+    title?: string;
+}
+export declare class FwChoiceDialog {
+    private data;
+    alignActions: "center" | "end";
+    choices: Choice[];
+    content: string;
+    title: string;
+    constructor(data: FwChoiceDialogData);
+    getTestId(choice: any): string;
+}
+export {};

package/components/dialog/confirm-dialog.component.d.ts

@@ -0,0 +1,12 @@
+export interface FwConfirmDialogData {
+    title?: string;
+    content?: string;
+    html?: string;
+}
+export declare class FwConfirmDialog {
+    private data;
+    title: string;
+    content: string;
+    html: string;
+    constructor(data: FwConfirmDialogData);
+}

package/components/dialog/dialog.module.d.ts

@@ -0,0 +1,2 @@
+export declare class FwDialogModule {
+}

package/components/dialog/dialog.service.d.ts

@@ -0,0 +1,19 @@
+import { Type } from '@angular/core';
+import { MatDialog, MatDialogConfig, MatDialogRef } from '@angular/material/dialog';
+export declare type StackingStrategy = 'allow' | 'replace' | 'ignore';
+export interface DialogConfig<T> extends MatDialogConfig<T> {
+    multi: StackingStrategy;
+}
+export interface OpenDialog<T> {
+    component: Type<T>;
+    ref: MatDialogRef<T>;
+}
+export declare class FwDialogService {
+    private matDialog;
+    readonly dialogs: OpenDialog<any>[];
+    private config;
+    constructor(matDialog: MatDialog);
+    closeAll(component?: Type<unknown>): void;
+    open<T, D, R>(component: Type<T>, config?: MatDialogConfig<D>): MatDialogRef<T, R>;
+    registerDialog(component: Type<unknown>, config: DialogConfig<unknown>): void;
+}

package/components/dialog/error-dialog.component.d.ts

@@ -0,0 +1,10 @@
+import { MatDialogRef } from '@angular/material/dialog';
+export interface FwErrorDialogData {
+    message: string;
+}
+export declare class FwErrorDialog {
+    private data;
+    private ref;
+    message: string;
+    constructor(data: FwErrorDialogData, ref: MatDialogRef<FwErrorDialog>);
+}

package/components/dialog/portal-dialog.component.d.ts

@@ -0,0 +1,25 @@
+import { CdkPortalOutletAttachedRef, ComponentType, Portal } from '@angular/cdk/portal';
+import { OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+interface ComponentSpec {
+    type: ComponentType<unknown>;
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, (value: unknown) => void>;
+}
+export interface FwPortalDialogData {
+    component?: ComponentSpec;
+    content?: string;
+    template?: TemplateRef<unknown>;
+    title?: string;
+}
+export declare class FwPortalDialog implements OnDestroy {
+    private data;
+    private viewContainerRef;
+    content: string;
+    portal: Portal<any>;
+    title: string;
+    private destroyed$;
+    constructor(data: FwPortalDialogData, viewContainerRef: ViewContainerRef);
+    ngOnDestroy(): void;
+    attached(ref: CdkPortalOutletAttachedRef): void;
+}
+export {};

package/components/notification/notification-container/notification-container.component.d.ts

@@ -7,12 +7,12 @@ export declare class FwNotificationContainerComponent implements OnDestroy {
     private notificationService;
     limit: number;
     notifications: Notification[];
-    showMore: boolean;
-    showLess: boolean;
+    expanded: boolean;
     private subscriptions;
     constructor(cdr: ChangeDetectorRef, notificationService: FwNotificationService);
     ngOnDestroy(): void;
     notificationClass(index: number): string;
+    getEmptyNotification(notification: Notification): Notification;
     onReady(notification: FwNotificationComponent): void;
     onDismiss(notificationId: string): void;
     clearAll(): void;

package/components/shared/pipes/pipes.module.d.ts

@@ -0,0 +1,4 @@
+import { TranslationService } from '../translation.service';
+export declare class PipesModule {
+}
+export { TranslationService };

package/components/shared/pipes/translate.pipe.d.ts

@@ -0,0 +1,15 @@
+import { ChangeDetectorRef, OnDestroy } from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { TranslationService } from '../translation.service';
+/**
+ * Translate a message given a nested key to a location in the loaded locale copy.
+ */
+export declare class TranslatePipe implements PipeTransform, OnDestroy {
+    private cdr;
+    private translationService;
+    private subscriptions;
+    private messages;
+    constructor(cdr: ChangeDetectorRef, translationService: TranslationService);
+    ngOnDestroy(): void;
+    transform(key: string, silent?: boolean): string;
+}

package/components/shared/pipes/trusthtml.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+export declare class TrustHtmlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(html: string): SafeHtml;
+}

package/components/shared/translation.service.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+export declare abstract class TranslationService {
+    abstract getMessage(key: string, silent?: boolean): Observable<string>;
+}
+/**
+ * Very basic i18n implementation. Consumer apps can provide their own implementation of TranslationService to override.
+ */
+export declare class MinimalTranslationService implements TranslationService {
+    private static messages;
+    getMessage(key: string, silent?: boolean): Observable<string>;
+}

package/esm2015/components/dialog/choice-dialog.component.js

@@ -0,0 +1,52 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+export class FwChoiceDialog {
+    constructor(data) {
+        this.data = data;
+        this.alignActions = this.data.alignActions
+            ? this.data.alignActions === 'start'
+                ? null
+                : this.data.alignActions
+            : 'center';
+        this.choices = this.data.choices;
+        this.content = this.data.content;
+        this.title = this.data.title;
+    }
+    getTestId(choice) {
+        var _a;
+        return choice.testId || `${String((_a = choice.label) !== null && _a !== void 0 ? _a : choice.value).toLowerCase()}-button`;
+    }
+}
+FwChoiceDialog.decorators = [
+    { type: Component, args: [{
+                host: {
+                    class: 'mat-dialog-component',
+                    'test-id': 'choice-dialog',
+                },
+                selector: 'fw-choice-dialog',
+                template: `
+    <h1 mat-dialog-title *ngIf="title">{{ title }}</h1>
+    <div mat-dialog-content>{{ content }}</div>
+    <div mat-dialog-actions [align]="alignActions">
+      <ng-container *ngFor="let choice of choices" [ngSwitch]="choice.variant">
+        <button *ngSwitchCase="'raised'" mat-raised-button [color]="choice.color" [attr.test-id]="getTestId(choice)"
+          [mat-dialog-close]="choice.value">{{ choice.label }}</button>
+        <button *ngSwitchCase="'stroked'" mat-stroked-button [color]="choice.color" [attr.test-id]="getTestId(choice)"
+          [mat-dialog-close]="choice.value">{{ choice.label }}</button>
+        <button *ngSwitchCase="'flat'" mat-flat-button [color]="choice.color" [attr.test-id]="getTestId(choice)"
+          [mat-dialog-close]="choice.value">{{ choice.label }}</button>
+        <ng-container *ngSwitchDefault>
+          <button *ngIf="choice.color" mat-flat-button [color]="choice.color" [attr.test-id]="getTestId(choice)"
+            [mat-dialog-close]="choice.value">{{ choice.label }}</button>
+          <button *ngIf="!choice.color" mat-stroked-button [attr.test-id]="getTestId(choice)"
+            [mat-dialog-close]="choice.value">{{ choice.label }}</button>
+        </ng-container>
+      </ng-container>
+    </div>
+  `
+            },] }
+];
+FwChoiceDialog.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/dialog/confirm-dialog.component.js

@@ -0,0 +1,40 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+export class FwConfirmDialog {
+    constructor(data) {
+        this.data = data;
+        this.title = this.data.title;
+        this.content = this.data.content;
+        this.html = this.data.html;
+    }
+}
+FwConfirmDialog.decorators = [
+    { type: Component, args: [{
+                host: {
+                    class: 'mat-dialog-component',
+                    'test-id': 'confirm-dialog',
+                },
+                selector: 'fw-confirm-dialog',
+                template: `
+    <h1 mat-dialog-title *ngIf="title">{{ title }}</h1>
+    <div mat-dialog-content *ngIf="html" class="markup" [innerHTML]="html | trusthtml"></div>
+    <div mat-dialog-content *ngIf="!html">{{ content || ('confirmDialog.body' | translate ) }}</div>
+    <div mat-dialog-actions align="center">
+      <button test-id="no-button" mat-stroked-button [mat-dialog-close]="false">{{ 'confirmDialog.no' | translate }}</button>
+      <button test-id="yes-button" mat-flat-button color="primary" [mat-dialog-close]="true">{{ 'confirmDialog.yes' | translate }}</button>
+    </div>
+  `,
+                styles: [`
+    [mat-dialog-content] {
+      text-align: center;
+    }
+    [mat-dialog-content].markup {
+      text-align: inherit;
+    }
+  `]
+            },] }
+];
+FwConfirmDialog.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/dialog/dialog.module.js

@@ -0,0 +1,45 @@
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDialogModule, MAT_DIALOG_DEFAULT_OPTIONS } from '@angular/material/dialog';
+import { MatIconModule } from '@angular/material/icon';
+import { FwChoiceDialog } from './choice-dialog.component';
+import { FwConfirmDialog } from './confirm-dialog.component';
+import { FwDialogService } from './dialog.service';
+import { FwErrorDialog } from './error-dialog.component';
+import { FwPortalDialog } from './portal-dialog.component';
+import { PipesModule } from '../shared/pipes/pipes.module';
+const ɵ0 = {
+    disableClose: true,
+    hasBackdrop: true,
+};
+export class FwDialogModule {
+}
+FwDialogModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    FwChoiceDialog,
+                    FwConfirmDialog,
+                    FwErrorDialog,
+                    FwPortalDialog,
+                ],
+                imports: [
+                    CommonModule,
+                    MatButtonModule,
+                    MatDialogModule,
+                    MatIconModule,
+                    PipesModule,
+                    PortalModule,
+                ],
+                providers: [
+                    FwDialogService,
+                    {
+                        provide: MAT_DIALOG_DEFAULT_OPTIONS,
+                        useValue: ɵ0
+                    }
+                ],
+            },] }
+];
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/dialog/dialog.service.js

@@ -0,0 +1,69 @@
+import { Injectable } from '@angular/core';
+import { MatDialog, } from '@angular/material/dialog';
+export class FwDialogService {
+    constructor(matDialog) {
+        this.matDialog = matDialog;
+        this.dialogs = [];
+        this.config = new Map();
+    }
+    closeAll(component) {
+        if (component) {
+            this.dialogs
+                .filter((el) => el.component === component)
+                .forEach((el) => el.ref.close());
+        }
+        else {
+            this.matDialog.closeAll();
+        }
+    }
+    open(component, config) {
+        const index = this.dialogs.findIndex(el => el.component === component);
+        let ref = null;
+        const baseConfig = Object.assign({ multi: 'allow' }, this.config.get(component));
+        switch (baseConfig.multi) {
+            case 'ignore':
+                // if an existing dialog of the same type doesn't exist, open one
+                if (index === -1) {
+                    ref = this.matDialog.open(component, Object.assign(Object.assign({}, baseConfig), config));
+                    this.dialogs.push({ component, ref });
+                }
+                break;
+            case 'replace':
+                // if an existing dialog of the same type exists, replace it.
+                if (index > -1) {
+                    this.dialogs[index].ref.close();
+                    ref = this.matDialog.open(component, Object.assign(Object.assign({}, baseConfig), config));
+                    this.dialogs.splice(index, 1, { component, ref });
+                }
+                else {
+                    ref = this.matDialog.open(component, Object.assign(Object.assign({}, baseConfig), config));
+                    this.dialogs.push({ component, ref });
+                }
+                break;
+            default:
+                ref = this.matDialog.open(component, Object.assign(Object.assign({}, baseConfig), config));
+                this.dialogs.push({ component, ref });
+                break;
+        }
+        if (ref) {
+            ref.afterClosed().subscribe(() => {
+                // clean up open dialog reference
+                const index = this.dialogs.findIndex(el => el.ref === ref);
+                if (index >= 0) {
+                    this.dialogs.splice(index, 1);
+                }
+            });
+        }
+        return ref;
+    }
+    registerDialog(component, config) {
+        this.config.set(component, config);
+    }
+}
+FwDialogService.decorators = [
+    { type: Injectable }
+];
+FwDialogService.ctorParameters = () => [
+    { type: MatDialog }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/dialog/error-dialog.component.js

@@ -0,0 +1,32 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
+export class FwErrorDialog {
+    constructor(data, ref) {
+        this.data = data;
+        this.ref = ref;
+        this.message = this.data.message;
+        this.ref.disableClose = false;
+    }
+}
+FwErrorDialog.decorators = [
+    { type: Component, args: [{
+                host: {
+                    class: 'mat-dialog-component',
+                    'test-id': 'error-dialog',
+                },
+                selector: 'fw-error-dialog',
+                template: `
+    <div mat-dialog-content>{{ message }}</div>
+    <div mat-dialog-actions align="end">
+      <button test-id="close-button" mat-stroked-button mat-dialog-close>
+        {{ 'common.actions.close' | translate }}
+      </button>
+    </div>
+  `
+            },] }
+];
+FwErrorDialog.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] },
+    { type: MatDialogRef }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/dialog/portal-dialog.component.js

@@ -0,0 +1,88 @@
+import { ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { Component, Inject, SimpleChange, ViewContainerRef } from '@angular/core';
+import { MAT_DIALOG_DATA } from '@angular/material/dialog';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+export class FwPortalDialog {
+    constructor(data, viewContainerRef) {
+        this.data = data;
+        this.viewContainerRef = viewContainerRef;
+        this.content = this.data.content;
+        this.title = this.data.title;
+        this.destroyed$ = new Subject();
+        if (this.data.component) {
+            this.portal = new ComponentPortal(this.data.component.type, this.viewContainerRef);
+        }
+        else if (this.data.template) {
+            this.portal = new TemplatePortal(this.data.template, this.viewContainerRef);
+        }
+        else {
+            throw new Error('One of [component, template] was not provided.');
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+    }
+    attached(ref) {
+        var _a, _b;
+        if (this.data.component) {
+            ref = ref;
+            if (this.data.component.outputs) {
+                for (const [key, observer] of Object.entries(this.data.component.outputs)) {
+                    const output$ = ref[key];
+                    if (typeof (output$ === null || output$ === void 0 ? void 0 : output$.pipe) === 'function' && typeof output$.subscribe === 'function') {
+                        output$.pipe(takeUntil(this.destroyed$)).subscribe(observer);
+                    }
+                }
+            }
+            if (this.data.component.inputs) {
+                const changes = {};
+                for (const [key, value] of Object.entries(this.data.component.inputs)) {
+                    ref.instance[key] = value;
+                    changes[key] = new SimpleChange(value, value, true);
+                }
+                (_b = (_a = ref.instance).ngOnChanges) === null || _b === void 0 ? void 0 : _b.call(_a, changes);
+                ref.changeDetectorRef.markForCheck();
+            }
+        }
+    }
+}
+FwPortalDialog.decorators = [
+    { type: Component, args: [{
+                host: {
+                    class: 'mat-dialog-component',
+                    'test-id': 'portal-dialog',
+                },
+                selector: 'fw-portal-dialog',
+                template: `
+    <ng-container *ngIf="title">
+      <h1 mat-dialog-title>{{ title }}</h1>
+      <button test-id="dialog-close-corner" mat-icon-button mat-dialog-close>
+        <mat-icon>close</mat-icon>
+      </button>
+    </ng-container>
+    <mat-dialog-content>
+      <p *ngIf="content" class="content">{{ content }}</p>
+      <ng-template [cdkPortalOutlet]="portal" (attached)="attached($event)"></ng-template>
+    </mat-dialog-content>
+    <mat-dialog-actions align="end">
+      <button test-id="dialog-close-button" mat-stroked-button mat-dialog-close>
+        {{ 'common.actions.close' | translate }}
+      </button>
+    </mat-dialog-actions>
+  `,
+                styles: [`
+    :host {
+      min-width: 200px;
+    }
+    .content {
+      margin-bottom: 30px;
+    }
+  `]
+            },] }
+];
+FwPortalDialog.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_DIALOG_DATA,] }] },
+    { type: ViewContainerRef }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/notification/notification/notification.component.js

@@ -52,11 +52,11 @@ FwNotificationComponent.decorators = [
                     '(click)': 'onClickDismiss()'
                 },
                 selector: 'fw-notification',
-                template: `<ng-container>{{ notification?.message }}</ng-container>`,
+                template: `{{ notification?.message }}`,
                 providers: [FwNotificationTimerService],
                 encapsulation: ViewEncapsulation.None,
                 changeDetection: ChangeDetectionStrategy.OnPush,
-                styles: ["fw-notification{display:block;border-radius:4px;box-sizing:border-box;margin:5px 24px;max-width:33vw;min-width:344px;padding:14px 16px;height:48px;transform-origin:center;background-color:#2f96b4;border:1px solid hsla(0,0%,100%,.7019607843137254);box-shadow:0 0 12px #999;color:#fff;opacity:.99}fw-notification .notification{display:flex;justify-content:space-between;align-items:center}fw-notification.error{background-color:#bd362f}fw-notification.info{background-color:#2f96b4}fw-notification.success{background-color:#51a351}fw-notification.wait{background-color:#2f96b4}fw-notification.warning{background-color:#f89406}"]
+                styles: ["fw-notification{display:block;border-radius:4px;box-sizing:border-box;margin:5px 24px;max-width:33vw;min-width:344px;padding:14px 16px;transform-origin:center;background-color:#2f96b4;border:1px solid hsla(0,0%,100%,.7019607843);box-shadow:0 0 12px #999;color:#fff;opacity:.99;white-space:pre-wrap}fw-notification.error{background-color:#bd362f}fw-notification.info{background-color:#2f96b4}fw-notification.success{background-color:#51a351}fw-notification.wait{background-color:#2f96b4}fw-notification.warning{background-color:#f89406}"]
             },] }
 ];
 FwNotificationComponent.ctorParameters = () => [
@@ -70,4 +70,4 @@ FwNotificationComponent.propDecorators = {
     dismiss: [{ type: Output }],
     cssClass: [{ type: HostBinding, args: ['class',] }]
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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