@coolon/angular-ui-powerups 0.0.60 → 0.0.62

package/lib/interaction/activity.d.ts

@@ -5,6 +5,8 @@ export declare const ACTIVITY_DATA: InjectionToken<any>;
 export interface Activity<D, R, E = any> {
     readonly busy: ValueModel<boolean>;
     initialise(activityContext: ActivityOutletContext<D, R, E>): void;
+    done(result: R): any;
+    cancel(e: E): any;
 }
 export declare namespace Activity {
     type CallBack<T> = (value: T) => void | Promise<any>;

package/lib/interaction/components/activity-container/activity-container.component.d.ts

@@ -1,6 +1,6 @@
 import { AfterViewInit, OnInit, QueryList } from '@angular/core';
 import { MatTabGroup } from '@angular/material';
-import { Constructable, MutableListModel } from '@coolon/pectin';
+import { Constructable, ListModel, MutableListModel, ValueModel } from '@coolon/pectin';
 import { DisposableComponent } from '../../../components/disposable-component';
 import { Activity } from '../../activity';
 import { Alert } from '../../alert';
@@ -11,18 +11,28 @@ import { ActivityOutletComponent } from '../activity-outlet/activity-outlet.comp
 export declare class ActivityContainerComponent extends DisposableComponent implements OnInit, AfterViewInit, InteractionContext {
     parentInteractionContext: InteractionContext;
     initialActivityOutletContext: ActivityOutletContext<any, any, any>;
+    readonly currentActivity: ValueModel<Activity<any, any>>;
     tabs: MatTabGroup;
     outlets: QueryList<ActivityOutletComponent<any, any, any>>;
     readonly activityOutletTabs: MutableListModel<ActivityOutletContext<any, any, any>>;
     private obsoleteTabs;
     private finished;
+    private readonly _activityList;
     constructor();
+    isActive(): boolean;
+    readonly activityList: ListModel<Activity<any, any>>;
     ngOnInit(): void;
     ngAfterViewInit(): void;
+    /**
+     * Update in the next tick to avoid changing state in the current change detection cycle.
+     * @param activities
+     */
+    private safelyUpdateActivityList;
     initialise<D, R, E>(initialContext: ActivityContainerComponent.ActivityContext<D, R, E>): void;
     startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
     alert(alert: Alert): Promise<void>;
     confirm(confirm: Confirm): Promise<void>;
+    confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
     private onAnimationFinished;
     private animateTabs;
 }

package/lib/interaction/components/activity-outlet/activity-outlet.component.d.ts

@@ -12,7 +12,7 @@ import { ActivityOutletContext } from './activity-outlet-context';
  * It might be nice to have wrapper component that allows more declarative use, i.e.
  * <activity-view [activityClass]="...", [activityData]="..." (done)=".." (cancel)="..."></activity-view>
  */
-export declare class ActivityOutletComponent<D, R, E> implements OnInit, InteractionContext {
+export declare class ActivityOutletComponent<D, R, E> implements OnInit {
     private componentFactoryResolver;
     private viewContainerRef;
     private injector;
@@ -22,17 +22,12 @@ export declare class ActivityOutletComponent<D, R, E> implements OnInit, Interac
     constructor(componentFactoryResolver: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, injector: Injector);
     ngOnInit(): void;
     loadActivity(activityContext: ActivityOutletContext<D, R, E>): void;
+    readonly component: Activity<D, R, E>;
     alert(alert: Alert): Promise<void>;
     confirm(confirm: Confirm): Promise<void>;
+    confirmThen<D1, R1, E1>(confirm: Confirm, activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
     startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
     notifyReady(): void;
 }
 export declare namespace ActivityOutletComponent {
-    class OutletInteractionContext<D, R, E> implements InteractionContext {
-        private readonly context;
-        constructor(context: ActivityOutletContext<D, R, E>);
-        alert(alert: Alert): Promise<void>;
-        confirm(confirm: Confirm): Promise<void>;
-        startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
-    }
 }

package/lib/interaction/components/confirm-then-dialog/confirm-then-dialog.component.d.ts

@@ -0,0 +1,22 @@
+import { OnInit } from '@angular/core';
+import { Constructable } from '@coolon/pectin';
+import { AbstractActivity } from '../../abstract-activity';
+import { Activity } from '../../activity';
+import { Confirm } from '../../confirm';
+import { InteractionContext } from '../../interaction-context';
+export declare class ConfirmThenDialogComponent<D, R, E> extends AbstractActivity<ConfirmThenDialogComponent.Data<D, R, E>, R, E> implements OnInit {
+    readonly config: ConfirmThenDialogComponent.Data<D, R, E>;
+    readonly interactionContext: InteractionContext;
+    constructor(config: ConfirmThenDialogComponent.Data<D, R, E>, interactionContext: InteractionContext);
+    ngOnInit(): void;
+    readonly confirm: Confirm;
+    isDestructive(): boolean;
+    onConfirm(): void;
+}
+export declare namespace ConfirmThenDialogComponent {
+    interface Data<D, R, E> {
+        confirm: Confirm;
+        activityType: Constructable<Activity<D, R, E>>;
+        data: D;
+    }
+}

package/lib/interaction/guards/close-interaction.guard.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '@angular/core';
+import { ActivatedRouteSnapshot, CanDeactivate, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { Observable } from 'rxjs';
+import { PlaceComponent } from '../../place/place-component';
+import { InteractionContext } from '../interaction-context';
+export declare class CloseInteractionGuard implements CanDeactivate<PlaceComponent> {
+    private router;
+    private injector;
+    private readonly interactionContext;
+    constructor(router: Router, injector: Injector, interactionContext: InteractionContext);
+    canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+}

package/lib/interaction/index.d.ts

@@ -12,5 +12,7 @@ export * from "./components/activity-container/activity-container.component";
 export * from "./components/activity-outlet/activity-outlet-context";
 export * from "./components/activity-outlet/activity-outlet.component";
 export * from "./components/alert-dialog/alert-dialog.component";
+export * from "./components/confirm-then-dialog/confirm-then-dialog.component";
 export * from "./components/confirmation-dialog/confirmation-dialog.component";
+export * from "./guards/close-interaction.guard";
 export * from "./services/dialog-interaction.service";

package/lib/interaction/interaction-context.d.ts

@@ -1,11 +1,31 @@
-import { InjectionToken } from '@angular/core';
-import { Constructable } from '@coolon/pectin';
+import { Constructable, GarbageCollector, ListModel, ValueModel } from '@coolon/pectin';
 import { Activity } from './activity';
 import { Alert } from './alert';
 import { Confirm } from './confirm';
-export declare const INTERACTION_CONTEXT: InjectionToken<any>;
-export declare abstract class InteractionContext {
+export declare abstract class InteractionContext extends GarbageCollector {
+    /**
+     * Returns the activity that is currently active.
+     * This model is only updated in the next tick after the view has been updated.
+     */
+    abstract readonly currentActivity: ValueModel<Activity<any, any>>;
+    /**
+     * Returns the current list of activities that are in progress.
+     * This model is only updated in the next tick after the view has been updated.
+     */
+    abstract readonly activityList: ListModel<Activity<any, any>>;
+    constructor();
+    /**
+     * Returns true if an activity is currently running.
+     */
+    isActive(): boolean;
     abstract startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
     abstract confirm(confirm: Confirm): Promise<void>;
+    /**
+     * Presents the confirmation to the user and runs the activity only if the user confirms.
+     * @param confirm:Confirm the confirmation to display.
+     * @param activityType the activity to run if confirmed.
+     * @param data the activity data.
+     */
+    abstract confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
     abstract alert(alert: Alert): Promise<void>;
 }

package/lib/interaction/services/dialog-interaction.service.d.ts

@@ -1,7 +1,8 @@
 import { InjectionToken } from '@angular/core';
 import { MatDialog } from '@angular/material';
 import { MatDialogConfig } from '@angular/material/dialog';
-import { Constructable } from '@coolon/pectin';
+import { Router } from '@angular/router';
+import { Constructable, ListModel, ValueModel } from '@coolon/pectin';
 import { Activity } from '../activity';
 import { Alert } from '../alert';
 import { Confirm } from '../confirm';
@@ -9,11 +10,23 @@ import { InteractionContext } from '../interaction-context';
 export declare const DIALOG_INTERACTION_SERVICE_DEFAULTS: InjectionToken<MatDialogConfig<any>>;
 export declare class DialogInteractionService extends InteractionContext {
     private readonly dialogService;
+    private readonly router;
     readonly dialogServiceDefaults: MatDialogConfig<any>;
     readonly matDialogDefaultConfig: MatDialogConfig<any>;
-    constructor(dialogService: MatDialog, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
+    readonly currentActivity: ValueModel<Activity<any, any>>;
+    private readonly _activityList;
+    private _active;
+    constructor(dialogService: MatDialog, router: Router, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
+    cancelActivity(): void;
+    readonly activityList: ListModel<Activity<any, any>>;
     startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
     private _startActivity;
+    /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param delegate
+     */
+    safelyUpdateActivityListDelegate(delegate: ListModel<Activity<any, any>>): void;
     alert(alert: Alert): Promise<void>;
     confirm(confirm: Confirm): Promise<void>;
+    confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R>;
 }

package/lib/place/guards/leave-place.guard.d.ts

@@ -1,10 +1,16 @@
+import { Location } from '@angular/common';
 import { Injector } from '@angular/core';
 import { ActivatedRouteSnapshot, CanDeactivate, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
 import { Observable } from 'rxjs';
+import { InteractionContext } from '../../interaction/interaction-context';
 import { PlaceComponent } from '../place-component';
 export declare class LeavePlaceGuard implements CanDeactivate<PlaceComponent> {
     private router;
     private injector;
-    constructor(router: Router, injector: Injector);
+    readonly interactionContext: InteractionContext;
+    readonly location: Location;
+    private _alreadyAccepted;
+    constructor(router: Router, injector: Injector, interactionContext: InteractionContext, location: Location);
     canDeactivate(component: PlaceComponent, currentRoute: ActivatedRouteSnapshot, currentState: RouterStateSnapshot, nextState?: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;
+    alreadyAccepted(placeComponent: PlaceComponent): boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coolon/angular-ui-powerups",
-  "version": "0.0.60",
+  "version": "0.0.62",
   "schematics": "./schematics/collection.json",
   "dependencies": {
     "ts-morph": "^3.1.3",