@coolon/angular-ui-powerups 0.0.63 → 0.0.66

package/lib/interaction/abstract-activity.d.ts

@@ -1,15 +1,6 @@
-import { ValueModel } from '@coolon/pectin';
-import { DisposableComponent } from '../components/disposable-component';
 import { Activity } from './activity';
-import { ActivityOutletContext } from './components/activity-outlet/activity-outlet-context';
-export declare class AbstractActivity<D, R, E = any> extends DisposableComponent implements Activity<D, R, E> {
-    private readonly _busyModel;
-    private activityContext;
-    initialise(activityContext: ActivityOutletContext<D, R, E>): void;
-    done(result?: R): void;
-    cancel(error?: E): void;
-    onActivityReady(): void;
-    readonly busy: ValueModel<boolean>;
-    busyWhile(busyModel: ValueModel<boolean>): void;
-    isBusy(): boolean;
+/**
+ * Deprecated. You can now extend the Activity class directly.
+ */
+export declare abstract class AbstractActivity<D, R, E = any> extends Activity<D, R, E> {
 }

package/lib/interaction/activity.d.ts

@@ -1,13 +1,20 @@
 import { InjectionToken } from '@angular/core';
-import { ValueModel } from '@coolon/pectin';
-import { ActivityOutletContext } from './components/activity-outlet/activity-outlet-context';
+import { GarbageCollector, ValueModel } from '@coolon/pectin';
 export declare const ACTIVITY_DATA: InjectionToken<any>;
-export interface Activity<D, R, E = any> {
+export declare abstract class Activity<D, R, E = any> extends GarbageCollector {
+    private readonly _busyModel;
+    private _activityContext;
+    initialise(activityContext: Activity.Callbacks<R, E>): void;
+    done(result?: R): void;
+    cancel(error?: E): void;
+    onActivityReady(): void;
     readonly busy: ValueModel<boolean>;
-    initialise(activityContext: ActivityOutletContext<D, R, E>): void;
-    done(result: R): any;
-    cancel(e: E): any;
+    busyWhile(busyModel: ValueModel<boolean>): void;
+    isBusy(): boolean;
 }
 export declare namespace Activity {
-    type CallBack<T> = (value: T) => void | Promise<any>;
+    interface Callbacks<R, E> {
+        onDone: (result: R) => void;
+        onCancel: (error: E) => void;
+    }
 }

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

@@ -1,46 +1,58 @@
 import { AfterViewInit, OnInit, QueryList } from '@angular/core';
 import { MatTabGroup } from '@angular/material';
-import { Constructable, ListModel, MutableListModel, ValueModel } from '@coolon/pectin';
-import { DisposableComponent } from '../../../components/disposable-component';
+import { Constructable, ListModel, MutableListModel } from '@coolon/pectin';
 import { Activity } from '../../activity';
 import { Alert } from '../../alert';
 import { Confirm } from '../../confirm';
 import { InteractionContext } from '../../interaction-context';
 import { ActivityOutletContext } from '../activity-outlet/activity-outlet-context';
 import { ActivityOutletComponent } from '../activity-outlet/activity-outlet.component';
-export declare class ActivityContainerComponent extends DisposableComponent implements OnInit, AfterViewInit, InteractionContext {
+/**
+ * Note: this class is mutable and is stored in a list model.  This is normally a big no no but
+ *  we're manually deriving other models from the list after view state changes.  I.e. we not
+ *  using pectin chains on any of the mutable fields.
+ */
+declare class TabContext<D, R, E> implements ActivityOutletContext<D, R, E> {
+    readonly activityData: D;
+    readonly activityClass: Constructable<Activity<D, R, E>>;
+    readonly interactionContext: InteractionContext;
+    readonly activityCallbacks: Activity.Callbacks<R, E>;
+    private _complete;
+    private _component;
+    constructor(activityData: D, activityClass: Constructable<Activity<D, R, E>>, interactionContext: InteractionContext, activityCallbacks: Activity.Callbacks<R, E>);
+    isComponentRealised(): boolean;
+    isComplete(): boolean;
+    componentReady(component: Activity<D, R, E>): void;
+    readonly component: Activity<D, R, E>;
+    onDone(result: R): void;
+    onCancel(error: E): void;
+}
+export declare class ActivityContainerComponent<D, R, E> extends InteractionContext implements OnInit, AfterViewInit {
+    private readonly activityFinishedEvents;
     parentInteractionContext: InteractionContext;
-    initialActivityOutletContext: ActivityOutletContext<any, any, any>;
-    readonly currentActivity: ValueModel<Activity<any, any>>;
+    initialActivityOutletContext: ActivityOutletContext<D, R, E>;
     tabs: MatTabGroup;
     outlets: QueryList<ActivityOutletComponent<any, any, any>>;
-    readonly activityOutletTabs: MutableListModel<ActivityOutletContext<any, any, any>>;
-    private obsoleteTabs;
+    readonly activityTabs: MutableListModel<TabContext<any, any, any>>;
     private finished;
     private readonly _activityList;
     constructor();
     isActive(): boolean;
-    readonly activityList: ListModel<Activity<any, any>>;
+    readonly activityList: ListModel<Activity<any, 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>;
+    startActivity<D1, R1, E1>(activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
     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>;
+    confirmThen<D1, R1, E1>(confirm: Confirm, activityType: Constructable<Activity<D1, R1, E1>>, data?: D1): Promise<R1>;
+    private onActivityFinished;
+    private cleanupStaleActivities;
+    /**
+     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
+     */
+    private synchroniseSelectedTabIndex;
     private onAnimationFinished;
-    private animateTabs;
-}
-export declare namespace ActivityContainerComponent {
-    interface ActivityContext<D, R, E> {
-        activityClass: Constructable<Activity<D, R, E>>;
-        activityData: D;
-        onDone: (result: R) => void;
-        onCancel: (error: E) => void;
-    }
+    private updateActivityList;
+    private getSelectedOutlet;
 }
+export {};

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

@@ -1,10 +1,7 @@
 import { Constructable } from '@coolon/pectin';
 import { Activity } from '../../activity';
-import { InteractionContext } from '../../interaction-context';
-export interface ActivityOutletContext<D, R, E> {
-    interactionContext: InteractionContext;
+export interface ActivityOutletContext<D, R, E> extends Activity.Callbacks<R, E> {
     activityClass: Constructable<Activity<D, R, E>>;
     activityData: D;
-    onDone: (result: R) => void;
-    onCancel: (error: E) => void;
+    componentReady?(component: Activity<D, R, E>): any;
 }

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

@@ -1,8 +1,5 @@
 import { ComponentFactoryResolver, Injector, OnInit, ViewContainerRef } from '@angular/core';
-import { Constructable } from '@coolon/pectin';
 import { Activity } from '../../activity';
-import { Alert } from '../../alert';
-import { Confirm } from '../../confirm';
 import { InteractionContext } from '../../interaction-context';
 import { ActivityOutletContext } from './activity-outlet-context';
 /**
@@ -17,17 +14,11 @@ export declare class ActivityOutletComponent<D, R, E> implements OnInit {
     private viewContainerRef;
     private injector;
     interactionContext: InteractionContext;
+    private _activityContext;
     activityContext: ActivityOutletContext<D, R, E>;
     private activityComponentRef;
     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 {
 }

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

@@ -1,19 +1,19 @@
-import { Constructable, GarbageCollector, ListModel, ValueModel } from '@coolon/pectin';
+import { Constructable, GarbageCollector, ListModel } from '@coolon/pectin';
 import { Activity } from './activity';
 import { Alert } from './alert';
 import { Confirm } from './confirm';
 export declare abstract class InteractionContext extends GarbageCollector {
     /**
-     * Returns the activity that is currently active.
+     * 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 currentActivity: ValueModel<Activity<any, any>>;
+    abstract readonly activityList: ListModel<Activity<any, any>>;
+    protected constructor();
     /**
-     * Returns the current list of activities that are in progress.
+     * Returns the activity that is currently active.
      * This model is only updated in the next tick after the view has been updated.
      */
-    abstract readonly activityList: ListModel<Activity<any, any>>;
-    constructor();
+    readonly currentActivity: Activity<any, any>;
     /**
      * Returns true if an activity is currently running.
      */

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

@@ -1,8 +1,7 @@
 import { InjectionToken } from '@angular/core';
 import { MatDialog } from '@angular/material';
 import { MatDialogConfig } from '@angular/material/dialog';
-import { Router } from '@angular/router';
-import { Constructable, ListModel, ValueModel } from '@coolon/pectin';
+import { Constructable, ListModel } from '@coolon/pectin';
 import { Activity } from '../activity';
 import { Alert } from '../alert';
 import { Confirm } from '../confirm';
@@ -10,13 +9,12 @@ 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>;
-    readonly currentActivity: ValueModel<Activity<any, any>>;
     private readonly _activityList;
-    private _active;
-    constructor(dialogService: MatDialog, router: Router, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
+    private startingGuard;
+    private currentActivityId;
+    constructor(dialogService: MatDialog, dialogServiceDefaults: MatDialogConfig<any>, matDialogDefaultConfig: MatDialogConfig<any>);
     isActive(): boolean;
     cancelActivity(): void;
     readonly activityList: ListModel<Activity<any, any>>;

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

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

package/lib/place/place-router.d.ts

@@ -1,10 +1,23 @@
+import { Location } from '@angular/common';
 import { ActivatedRoute, ActivatedRouteSnapshot, Router, UrlTree } from '@angular/router';
+import { PlaceComponent } from './place-component';
 import { ParameterSnapshot } from './route/parameter-snapshot';
+declare class NavigationSession {
+    readonly isPopState: boolean;
+    readonly initialUrl: string;
+    private _alreadyAccepted;
+    constructor(isPopState: boolean, initialUrl: string);
+    alreadyAccepted(placeComponent: PlaceComponent): boolean;
+    rememberAcceptanceOf(component: PlaceComponent): void;
+}
 export declare class PlaceRouter {
     private readonly router;
-    constructor(router: Router);
+    private readonly _navigationSession;
+    constructor(router: Router, angularLocation: Location);
+    readonly navigationSession: NavigationSession;
     pushParameterChangesToRoute(activatedRoute: ActivatedRoute, previous: ParameterSnapshot, next: ParameterSnapshot): void;
     getRedirectUrlTree(activatedRoute: ActivatedRouteSnapshot, sanitised: ParameterSnapshot): UrlTree;
     protected getChildPath(activatedRoute: ActivatedRouteSnapshot): any[];
     protected createRouteParameters(parameters: ParameterSnapshot): any[];
 }
+export {};

package/package.json

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