@coolon/angular-ui-powerups 0.0.126 → 0.0.129

package/esm5/lib/interaction/components/activity-container/activity-container.component.js

@@ -3,305 +3,267 @@
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 import * as tslib_1 from "tslib";
-import { Component, EventEmitter, Input, Output, QueryList, ViewChild, ViewChildren } from '@angular/core';
+import { Component, Input, QueryList, ViewChild, ViewChildren } from '@angular/core';
 import { MatTabGroup } from '@angular/material';
-import { assert, Dsl, MutableListModel, MutableStream, MutableValueModel } from '@coolon/pectin';
-import { InteractionContextBase } from '../../interaction-context-base';
-import { ActivityOutletComponent } from '../activity-outlet/activity-outlet.component';
+import { assert, Dsl, GarbageCollector, Trace } from '@coolon/pectin';
+import { lang } from '@coolon/typescript-utilities';
+import _ from 'lodash';
+import { AbstractInteractionContext } from '../../abstract-interaction-context';
+import { ActivityRef } from '../../activity-ref';
+import { ActivityOutletComponent } from './activity-outlet/activity-outlet.component';
 /**
- * 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.
  * @template D, R, E
  */
-var /**
- * 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.
- * @template D, R, E
- */
-TabContext = /** @class */ (function () {
-    function TabContext(activityData, activityClass, interactionContext, activityCallbacks) {
-        this.activityData = activityData;
-        this.activityClass = activityClass;
-        this.interactionContext = interactionContext;
-        this.activityCallbacks = activityCallbacks;
-        this._complete = false;
+var ActivityContainerComponent = /** @class */ (function (_super) {
+    tslib_1.__extends(ActivityContainerComponent, _super);
+    function ActivityContainerComponent() {
+        var _this = _super.call(this) || this;
+        _this.dynamicHeight = false;
+        _this.activityTabs = [];
+        _this.garbage = new GarbageCollector();
+        return _this;
     }
     /**
      * @return {?}
      */
-    TabContext.prototype.isComponentRealised = /**
+    ActivityContainerComponent.prototype.ngOnInit = /**
      * @return {?}
      */
     function () {
-        return !!this._component;
     };
     /**
      * @return {?}
      */
-    TabContext.prototype.isComplete = /**
+    ActivityContainerComponent.prototype.ngAfterViewInit = /**
      * @return {?}
      */
     function () {
-        return this._complete;
+        var _this = this;
+        var _a = Dsl.disposeWith(this), chain = _a.chain, observe = _a.observe;
+        observe.valuesFrom(this.tabs.animationDone).subscribe((/**
+         * @return {?}
+         */
+        function () { return _this.onAnimationFinished(); }));
     };
     /**
-     * @param {?} component
+     * @param {?} identifier
+     * @param {?} api
      * @return {?}
      */
-    TabContext.prototype.componentReady = /**
-     * @param {?} component
+    ActivityContainerComponent.prototype.initialise = /**
+     * @param {?} identifier
+     * @param {?} api
      * @return {?}
      */
-    function (component) {
-        assert.isNil(this._component);
-        this._component = component;
+    function (identifier, api) {
+        assert.isFalsey(this.isInitialised());
+        assert.notNil(identifier);
+        assert.notNil(api);
+        this._identifier = identifier;
+        this.interactionServiceApi = api;
     };
-    Object.defineProperty(TabContext.prototype, "component", {
+    Object.defineProperty(ActivityContainerComponent.prototype, "identifier", {
         get: /**
          * @return {?}
          */
         function () {
-            return this._component;
+            return this._identifier;
         },
         enumerable: true,
         configurable: true
     });
-    // @Trace()
-    // @Trace()
     /**
-     * @param {?} result
      * @return {?}
      */
-    TabContext.prototype.onDone = 
-    // @Trace()
-    /**
-     * @param {?} result
+    ActivityContainerComponent.prototype.isInitialised = /**
      * @return {?}
      */
-    function (result) {
-        this._complete = true;
-        this.activityCallbacks.onDone(result);
+    function () {
+        return !!this.identifier;
     };
-    // @Trace()
-    // @Trace()
     /**
-     * @param {?} error
-     * @return {?}
+     * Returns true if an activity is currently running.
      */
-    TabContext.prototype.onCancel = 
-    // @Trace()
     /**
-     * @param {?} error
+     * Returns true if an activity is currently running.
+     * @return {?}
+     */
+    ActivityContainerComponent.prototype.isActive = /**
+     * Returns true if an activity is currently running.
      * @return {?}
      */
-    function (error) {
-        this._complete = true;
-        this.activityCallbacks.onCancel(error);
+    function () {
+        return this.getActiveActivityCount() > 0;
     };
     /**
+     * @template T
+     * @param {?} disposable
      * @return {?}
      */
-    TabContext.prototype.dispose = /**
+    ActivityContainerComponent.prototype.registerDisposable = /**
+     * @template T
+     * @param {?} disposable
      * @return {?}
      */
-    function () {
-        this.component.dispose();
+    function (disposable) {
+        return this.garbage.registerDisposable(disposable);
     };
-    return TabContext;
-}());
-if (false) {
     /**
-     * @type {?}
-     * @private
+     * @return {?}
      */
-    TabContext.prototype._complete;
-    /**
-     * @type {?}
-     * @private
+    ActivityContainerComponent.prototype.dispose = /**
+     * @return {?}
      */
-    TabContext.prototype._component;
-    /** @type {?} */
-    TabContext.prototype.activityData;
-    /** @type {?} */
-    TabContext.prototype.activityClass;
-    /** @type {?} */
-    TabContext.prototype.interactionContext;
-    /** @type {?} */
-    TabContext.prototype.activityCallbacks;
-}
-/**
- * @template D, R, E
- */
-var ActivityContainerComponent = /** @class */ (function (_super) {
-    tslib_1.__extends(ActivityContainerComponent, _super);
-    function ActivityContainerComponent() {
-        var _this = _super.call(this) || this;
-        _this.throttledNestedActivityFinishEvents = new MutableStream();
-        _this._initialActivityOutletContext = new MutableValueModel();
-        // tslint:disable-next-line:no-output-rename
-        _this.initialActivityOutletContextEvent = new EventEmitter();
-        _this.dynamicHeight = false;
-        _this.activityTabs = new MutableListModel();
-        _this._activityList = new MutableListModel();
-        var _a = Dsl.disposeWith(_this), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe, switchOn = _a.switchOn;
-        chain(_this.throttledNestedActivityFinishEvents).throttle(50).subscribe((/**
-         * @return {?}
-         */
-        function () { return _this.onNestedActivityFinished(); }));
-        _this.setActivityList(_this._activityList.readonly);
-        _this.active = chain(_this._initialActivityOutletContext).isNotNil();
-        return _this;
-    }
-    Object.defineProperty(ActivityContainerComponent.prototype, "initialActivityOutletContext", {
-        get: /**
-         * @return {?}
-         */
-        function () {
-            return this._initialActivityOutletContext.value;
-        },
-        set: /**
-         * @param {?} initialContext
-         * @return {?}
-         */
-        function (initialContext) {
-            assert.isNil(this._initialActivityOutletContext.value);
-            // we clean up at the start as we leave the initial activity in place after it finishes
-            // so that the activity remains visible during the inplace-interaction-context animations.
-            this.activityTabs.value = [];
-            this._activityList.value = [];
-            /** @type {?} */
-            var self = this;
-            if (initialContext) {
-                this._initialActivityOutletContext.value = initialContext;
-                this.activityTabs.push(new TabContext(initialContext.activityData, initialContext.activityClass, this, {
-                    onDone: (/**
-                     * @param {?} result
-                     * @return {?}
-                     */
-                    function (result) {
-                        self.finishInitialActivity();
-                        initialContext.onDone(result);
-                    }),
-                    onCancel: (/**
-                     * @param {?} error
-                     * @return {?}
-                     */
-                    function (error) {
-                        self.finishInitialActivity();
-                        initialContext.onCancel(error);
-                    })
-                }));
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
+    function () {
+        // TODO: think about auto cancelling any outstanding activity on dispose.
+        //       See NavigationState.Navigating for a use-case.
+        assert.isFalsey(this.isActive());
+        this.garbage.dispose();
+    };
     /**
      * @return {?}
      */
-    ActivityContainerComponent.prototype.ngOnInit = /**
+    ActivityContainerComponent.prototype.getActiveActivityRef = /**
      * @return {?}
      */
     function () {
+        if (!this.isActive()) {
+            lang.illegalState('no activity in progress');
+        }
+        return _.findLast(this.activityTabs, (/**
+         * @param {?} tab
+         * @return {?}
+         */
+        function (tab) { return !tab.isComplete(); }));
     };
     /**
+     * Cancels the current activity and returns true the context is no longer active, false if
+     * there is still another activity running.
+     */
+    // @Trace()
+    /**
+     * Cancels the current activity and returns true the context is no longer active, false if
+     * there is still another activity running.
      * @return {?}
      */
-    ActivityContainerComponent.prototype.ngAfterViewInit = /**
+    // @Trace()
+    ActivityContainerComponent.prototype.cancelActiveActivity = /**
+     * Cancels the current activity and returns true the context is no longer active, false if
+     * there is still another activity running.
      * @return {?}
      */
+    // @Trace()
     function () {
-        var _this = this;
-        var _a = Dsl.disposeWith(this), chain = _a.chain, observe = _a.observe;
-        observe.valuesFrom(this.outlets.changes).subscribe((/**
-         * @return {?}
-         */
-        function () { return setTimeout((/**
-         * @return {?}
-         */
-        function () { return _this.updateActivityList(); })); }));
-        observe.valuesFrom(this.tabs.animationDone).subscribe((/**
-         * @return {?}
-         */
-        function () { return _this.onAnimationFinished(); }));
-        this.updateActivityList();
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var activity;
+            return tslib_1.__generator(this, function (_a) {
+                activity = this.getActiveActivityRef();
+                activity.cancel();
+                if (this.isCleaningUp()) {
+                    return [2 /*return*/, this.waitForInteractionContextCleanupToFinish()];
+                }
+                else {
+                    return [2 /*return*/, !this.isActive()];
+                }
+                return [2 /*return*/];
+            });
+        });
     };
+    // TODO: this handling of multiple nested activities is only used by the activity component and is not a general case.
+    // @Trace()
+    // TODO: this handling of multiple nested activities is only used by the activity component and is not a general case.
+    // @Trace()
     /**
+     * @protected
      * @template D1, R1, E1
      * @param {?} activityType
-     * @param {?=} data
+     * @param {?} data
+     * @param {?} disableClose
      * @return {?}
      */
-    ActivityContainerComponent.prototype._startActivity = /**
+    ActivityContainerComponent.prototype.createAndLaunchActivity = 
+    // TODO: this handling of multiple nested activities is only used by the activity component and is not a general case.
+    // @Trace()
+    /**
+     * @protected
      * @template D1, R1, E1
      * @param {?} activityType
-     * @param {?=} data
+     * @param {?} data
+     * @param {?} disableClose
      * @return {?}
      */
-    function (activityType, data) {
+    function (activityType, data, disableClose) {
         var _this = this;
-        this.cleanupStaleNestedActivities();
+        assert.isTruthy(this.isInitialised()); // make sure we've been initialised
+        // make sure we've been initialised
         /** @type {?} */
-        var self = this;
-        return new Promise((/**
-         * @param {?} resolve
-         * @param {?} reject
+        var activityRef = new ActivityRef(activityType, data, (/**
          * @return {?}
          */
-        function (resolve, reject) {
+        function () {
             /** @type {?} */
-            var context = new TabContext(data, activityType, self, {
-                onDone: (/**
-                 * @param {?} result
-                 * @return {?}
-                 */
-                function (result) {
-                    resolve(result);
-                    self.throttledNestedActivityFinishEvents.publish({});
-                }),
-                onCancel: (/**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                function (error) {
-                    reject(error);
-                    self.throttledNestedActivityFinishEvents.publish({});
-                })
-            });
-            self.activityTabs.push(context);
-            self.tabs.selectedIndex = _this.activityTabs.length;
+            var activeActivityCount = _this.getActiveActivityCount() > 0;
+            if (activeActivityCount) {
+                _this.triggerTabSynchronisation();
+            }
+            else {
+                _this.finishAndStartCleanup();
+            }
         }));
+        this.launchActivity(activityRef);
+        // if this is the first activity let the interaction service know.
+        if (this.activityTabs.length === 1) {
+            // console.log('Now active!!!');
+            this.interactionServiceApi.notifyActive(this);
+        }
+        return activityRef.activityResult;
     };
     /**
      * @private
      * @return {?}
      */
-    ActivityContainerComponent.prototype.finishInitialActivity = /**
+    ActivityContainerComponent.prototype.getActiveActivityCount = /**
      * @private
      * @return {?}
      */
     function () {
-        this.updateActivityList();
-        this._initialActivityOutletContext.value = null;
-        this.initialActivityOutletContextEvent.emit(null);
+        return this.activityTabs.filter((/**
+         * @param {?} ref
+         * @return {?}
+         */
+        function (ref) { return !ref.isComplete(); })).length;
     };
-    // @Trace()
-    // @Trace()
     /**
-     * @private
+     * Checks if this interaction context has finished an is in the process of waiting
+     * for all the infrastructure (including route updates) to be completed.
+     */
+    /**
+     * Checks if this interaction context has finished an is in the process of waiting
+     * for all the infrastructure (including route updates) to be completed.
      * @return {?}
      */
-    ActivityContainerComponent.prototype.onNestedActivityFinished = 
-    // @Trace()
+    ActivityContainerComponent.prototype.isCleaningUp = /**
+     * Checks if this interaction context has finished an is in the process of waiting
+     * for all the infrastructure (including route updates) to be completed.
+     * @return {?}
+     */
+    function () {
+        return !!this._deferredCleanUp;
+    };
     /**
-     * @private
+     * @return {?}
+     */
+    ActivityContainerComponent.prototype.waitForInteractionContextCleanupToFinish = /**
      * @return {?}
      */
     function () {
-        this.synchroniseSelectedTabIndex();
-        this.updateActivityList();
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this._deferredCleanUp ?
+                        this._deferredCleanUp :
+                        true];
+            });
+        });
     };
     // @Trace()
     // @Trace()
@@ -309,62 +271,64 @@ var ActivityContainerComponent = /** @class */ (function (_super) {
      * @private
      * @return {?}
      */
-    ActivityContainerComponent.prototype.cleanupStaleNestedActivities = 
+    ActivityContainerComponent.prototype.finishAndStartCleanup = 
     // @Trace()
     /**
      * @private
      * @return {?}
      */
     function () {
-        if (this.tabs.selectedIndex < this.activityTabs.length - 1) {
-            /** @type {?} */
-            var tabs = this.activityTabs.value;
-            /** @type {?} */
-            var remainingActivities_1 = tabs.slice(0, 1 + this.tabs.selectedIndex);
+        var _this = this;
+        if (!this._deferredCleanUp) {
             /** @type {?} */
-            var finishedActivityTabs = tabs.slice(1 + this.tabs.selectedIndex);
-            finishedActivityTabs.forEach((/**
-             * @param {?} a
-             * @return {?}
-             */
-            function (a) { return a.dispose(); }));
-            this.activityTabs.runInTransaction((/**
-             * @param {?} draft
+            var promise = this.interactionServiceApi.notifyFinished(this);
+            this._deferredCleanUp = promise
+                .finally((/**
              * @return {?}
              */
-            function (draft) {
-                draft.value = remainingActivities_1;
+            function () {
+                _this._deferredCleanUp = null;
             }));
         }
     };
-    /**
-     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
-     */
+    // @Trace()
     // @Trace()
     /**
-     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
-     * @private
+     * @template D1, R1, E1
+     * @param {?} activityRef
      * @return {?}
      */
+    ActivityContainerComponent.prototype.launchActivity = 
     // @Trace()
-    ActivityContainerComponent.prototype.synchroniseSelectedTabIndex = /**
-     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
-     * @private
+    /**
+     * @template D1, R1, E1
+     * @param {?} activityRef
      * @return {?}
      */
-    // @Trace()
-    function () {
-        /** @type {?} */
-        var previousIndex = this.tabs.selectedIndex;
+    function (activityRef) {
         /** @type {?} */
-        var newIndex = this.activityTabs.query().findIndex((/**
-         * @param {?} t
+        var cleanedTabs = this.activityTabs.filter((/**
+         * @param {?} tab
          * @return {?}
          */
-        function (t) { return t.isComplete(); })) - 1;
-        this.tabs.selectedIndex = newIndex;
-        return previousIndex === newIndex;
+        function (tab) { return !tab.isComplete(); }));
+        this.activityTabs = cleanedTabs.concat(activityRef);
+        this.tabs.selectedIndex = this.activityTabs.length;
+    };
+    /**
+     * @param {?} index
+     * @param {?} activityRef
+     * @return {?}
+     */
+    ActivityContainerComponent.prototype.activityIndex = /**
+     * @param {?} index
+     * @param {?} activityRef
+     * @return {?}
+     */
+    function (index, activityRef) {
+        return index;
     };
+    ;
     // @Trace()
     // @Trace()
     /**
@@ -379,27 +343,35 @@ var ActivityContainerComponent = /** @class */ (function (_super) {
      */
     function () {
         this.getSelectedOutlet().component.onActivityReady();
-        this.cleanupStaleNestedActivities();
-        this.updateActivityList();
+        this.activityTabs = this.activityTabs.filter((/**
+         * @param {?} tab
+         * @return {?}
+         */
+        function (tab) { return !tab.isComplete(); }));
     };
     /**
+     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
+     */
+    // @Trace()
+    /**
+     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
      * @private
      * @return {?}
      */
-    ActivityContainerComponent.prototype.updateActivityList = /**
+    // @Trace()
+    ActivityContainerComponent.prototype.synchroniseSelectedTabIndex = /**
+     * Synchronises the selected tab index.  Returns true if there was no change to the selected index.
      * @private
      * @return {?}
      */
+    // @Trace()
     function () {
-        this._activityList.value = this.activityTabs.value.filter((/**
-         * @param {?} t
-         * @return {?}
-         */
-        function (t) { return !t.isComplete() && t.isComponentRealised(); })).map((/**
-         * @param {?} t
-         * @return {?}
-         */
-        function (t) { return t.component; }));
+        /** @type {?} */
+        var previousIndex = this.tabs.selectedIndex;
+        /** @type {?} */
+        var newIndex = this.getActiveActivityCount() - 1;
+        this.tabs.selectedIndex = newIndex;
+        return previousIndex === newIndex;
     };
     /**
      * @private
@@ -410,54 +382,90 @@ var ActivityContainerComponent = /** @class */ (function (_super) {
      * @return {?}
      */
     function () {
-        return this.outlets.toArray()[this.tabs.selectedIndex];
+        return this.activityOutlets.toArray()[this.tabs.selectedIndex];
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @private
+     * @return {?}
+     */
+    ActivityContainerComponent.prototype.triggerTabSynchronisation = 
+    // @Trace()
+    /**
+     * @private
+     * @return {?}
+     */
+    function () {
+        var _this = this;
+        if (this.syncSelectedTabTimeout) {
+            clearTimeout(this.syncSelectedTabTimeout);
+        }
+        this.syncSelectedTabTimeout = setTimeout((/**
+         * @return {?}
+         */
+        function () {
+            _this.syncSelectedTabTimeout = null;
+            _this.synchroniseSelectedTabIndex();
+        }), 75);
     };
     ActivityContainerComponent.decorators = [
         { type: Component, args: [{
                     selector: 'aup-activity-container',
-                    template: "<mat-tab-group #tabs no-tab-header [dynamicHeight]=\"dynamicHeight\" [class.full-height-tabs]=\"!dynamicHeight\">\n  <mat-tab *ngFor=\"let tab of activityTabs.value\">\n    <aup-activity-outlet [interactionContext]=\"this\" [activityContext]=\"tab\"></aup-activity-outlet>\n  </mat-tab>\n</mat-tab-group>\n",
+                    template: "<mat-tab-group #tabs no-tab-header [dynamicHeight]=\"dynamicHeight\" [class.full-height-tabs]=\"!dynamicHeight\">\n  <mat-tab *ngFor=\"let tab of activityTabs; trackBy: activityIndex\" >\n    <aup-activity-outlet [nestedInteractionContext]=\"this\" [activityRef]=\"tab\"></aup-activity-outlet>\n  </mat-tab>\n</mat-tab-group>\n",
                     styles: [":host{display:flex;flex-direction:column}mat-tab-group{flex:1}"]
                 }] }
     ];
     /** @nocollapse */
     ActivityContainerComponent.ctorParameters = function () { return []; };
     ActivityContainerComponent.propDecorators = {
-        initialActivityOutletContext: [{ type: Input }],
-        initialActivityOutletContextEvent: [{ type: Output, args: ['initialActivityOutletContext',] }],
         dynamicHeight: [{ type: Input }],
         tabs: [{ type: ViewChild, args: ['tabs', { static: true },] }],
-        outlets: [{ type: ViewChildren, args: [ActivityOutletComponent,] }]
+        activityOutlets: [{ type: ViewChildren, args: [ActivityOutletComponent,] }]
     };
+    tslib_1.__decorate([
+        Trace(),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", []),
+        tslib_1.__metadata("design:returntype", void 0)
+    ], ActivityContainerComponent.prototype, "dispose", null);
     return ActivityContainerComponent;
-}(InteractionContextBase));
+}(AbstractInteractionContext));
 export { ActivityContainerComponent };
 if (false) {
+    /** @type {?} */
+    ActivityContainerComponent.prototype.dynamicHeight;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.tabs;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.activityOutlets;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.activityTabs;
     /**
      * @type {?}
      * @private
      */
-    ActivityContainerComponent.prototype.throttledNestedActivityFinishEvents;
+    ActivityContainerComponent.prototype._identifier;
     /**
      * @type {?}
      * @private
      */
-    ActivityContainerComponent.prototype._initialActivityOutletContext;
-    /** @type {?} */
-    ActivityContainerComponent.prototype.initialActivityOutletContextEvent;
-    /** @type {?} */
-    ActivityContainerComponent.prototype.dynamicHeight;
-    /** @type {?} */
-    ActivityContainerComponent.prototype.tabs;
-    /** @type {?} */
-    ActivityContainerComponent.prototype.outlets;
-    /** @type {?} */
-    ActivityContainerComponent.prototype.activityTabs;
-    /** @type {?} */
-    ActivityContainerComponent.prototype.active;
+    ActivityContainerComponent.prototype._deferredCleanUp;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityContainerComponent.prototype.interactionServiceApi;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityContainerComponent.prototype.garbage;
     /**
      * @type {?}
      * @private
      */
-    ActivityContainerComponent.prototype._activityList;
+    ActivityContainerComponent.prototype.syncSelectedTabTimeout;
+    /* Skipping unhandled member: ;*/
 }
 //# sourceMappingURL=activity-container.component.js.map