@coolon/angular-ui-powerups 0.0.96 → 0.0.98

package/esm5/lib/interaction/interaction-context.js

@@ -3,8 +3,7 @@
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 import * as tslib_1 from "tslib";
-import { Deferred, DelegatingListModel, Dsl, GarbageCollector } from '@coolon/pectin';
-import * as _ from 'lodash';
+import { EventListenerList, GarbageCollector } from '@coolon/pectin';
 /**
  * @abstract
  */
@@ -14,106 +13,64 @@ var /**
 InteractionContext = /** @class */ (function (_super) {
     tslib_1.__extends(InteractionContext, _super);
     function InteractionContext() {
-        var _this = _super.call(this) || this;
-        /**
-         * 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.
-         */
-        _this._activityListDelegate = new DelegatingListModel();
-        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;
-        when.listOf(_this.activityList).becomesPopulated((/**
-         * @param {?} activities
-         * @return {?}
-         */
-        function (activities) {
-            if (_this.deferredGetCurrentActivity) {
-                _this.deferredGetCurrentActivity.resolve(_.last(activities));
-                _this.deferredGetCurrentActivity = null;
-            }
-        }));
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.activityListeners = new EventListenerList();
         return _this;
     }
     /**
-     * @protected
-     * @param {?} activityList
+     * Returns true if an activity is currently running.
+     */
+    /**
+     * Returns true if an activity is currently running.
      * @return {?}
      */
-    InteractionContext.prototype.setActivityList = /**
-     * @protected
-     * @param {?} activityList
+    InteractionContext.prototype.isActive = /**
+     * Returns true if an activity is currently running.
      * @return {?}
      */
-    function (activityList) {
-        this._activityListDelegate.setDelegate(activityList);
+    function () {
+        return this.active.value;
     };
-    Object.defineProperty(InteractionContext.prototype, "activityList", {
-        get: /**
-         * @return {?}
-         */
-        function () {
-            return this._activityListDelegate.readonly;
-        },
-        enumerable: true,
-        configurable: true
-    });
     /**
-     * Returns the activity that is currently active.
-     * This model is only updated in the next tick after the view has been updated.
+     * @param {?} listener
+     * @return {?}
      */
+    InteractionContext.prototype.addActivityListener = /**
+     * @param {?} listener
+     * @return {?}
+     */
+    function (listener) {
+        return this.activityListeners.add(listener);
+    };
     /**
-     * Returns the activity that is currently active.
-     * This model is only updated in the next tick after the view has been updated.
+     * @protected
      * @return {?}
      */
-    InteractionContext.prototype.getCurrentActivity = /**
-     * Returns the activity that is currently active.
-     * This model is only updated in the next tick after the view has been updated.
+    InteractionContext.prototype.notifyActivityStarted = /**
+     * @protected
      * @return {?}
      */
     function () {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                if (!this.isActive()) {
-                    return [2 /*return*/, Promise.reject('no activity in progress')];
-                }
-                else {
-                    if (this.deferredGetCurrentActivity) {
-                        // we're already waiting then just return the same promise
-                        return [2 /*return*/, this.deferredGetCurrentActivity.promise];
-                    }
-                    else {
-                        if (this.activityList.length < 1) {
-                            this.deferredGetCurrentActivity = Deferred.defer();
-                            return [2 /*return*/, this.deferredGetCurrentActivity.promise];
-                        }
-                        else {
-                            return [2 /*return*/, _.last(this.activityList.value)];
-                        }
-                    }
-                }
-                return [2 /*return*/];
-            });
-        });
+        this.activityListeners.fire((/**
+         * @param {?} l
+         * @return {?}
+         */
+        function (l) { return l.onActivityStarted(); }));
     };
     /**
-     * @param {?} confirm
+     * @protected
      * @return {?}
      */
-    InteractionContext.prototype.confirm = /**
-     * @param {?} confirm
+    InteractionContext.prototype.notifyActivityFinished = /**
+     * @protected
      * @return {?}
      */
-    function (confirm) {
-        // Important: we have to implement confirmOrReject as the main entry point
-        // as the canDeactivation guards need to be able to cancel an interaction
-        // without caring about returning a value.
-        return this.confirmOrReject(confirm).then((/**
-         * @return {?}
-         */
-        function () { return true; })).catch((/**
+    function () {
+        this.activityListeners.fire((/**
+         * @param {?} l
          * @return {?}
          */
-        function () { return false; }));
+        function (l) { return l.onActivityFinished(); }));
     };
     return InteractionContext;
 }(GarbageCollector));
@@ -123,23 +80,21 @@ InteractionContext = /** @class */ (function (_super) {
 export { InteractionContext };
 if (false) {
     /**
-     * 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.
      * @type {?}
      * @private
      */
-    InteractionContext.prototype._activityListDelegate;
+    InteractionContext.prototype.activityListeners;
+    /** @type {?} */
+    InteractionContext.prototype.activityList;
+    /** @type {?} */
+    InteractionContext.prototype.active;
     /**
-     * @type {?}
-     * @private
-     */
-    InteractionContext.prototype.deferredGetCurrentActivity;
-    /**
-     * Returns true if an activity is currently running.
+     * Returns the activity that is currently active.
+     * This model is only updated in the next tick after the view has been updated.
      * @abstract
      * @return {?}
      */
-    InteractionContext.prototype.isActive = function () { };
+    InteractionContext.prototype.getCurrentActivity = function () { };
     /**
      * @abstract
      * @template D, R, E
@@ -148,6 +103,18 @@ if (false) {
      * @return {?}
      */
     InteractionContext.prototype.startActivity = function (activityType, data) { };
+    /**
+     * @abstract
+     * @param {?} alert
+     * @return {?}
+     */
+    InteractionContext.prototype.alert = function (alert) { };
+    /**
+     * @abstract
+     * @param {?} confirm
+     * @return {?}
+     */
+    InteractionContext.prototype.confirm = function (confirm) { };
     /**
      * @abstract
      * @param {?} confirm
@@ -164,11 +131,22 @@ if (false) {
      * @return {?}
      */
     InteractionContext.prototype.confirmThen = function (confirm, activityType, data) { };
+}
+(function (InteractionContext) {
     /**
-     * @abstract
-     * @param {?} alert
-     * @return {?}
+     * @record
      */
-    InteractionContext.prototype.alert = function (alert) { };
-}
-//# sourceMappingURL=data:application/json;base64,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
+    function Listener() { }
+    InteractionContext.Listener = Listener;
+    if (false) {
+        /**
+         * @return {?}
+         */
+        Listener.prototype.onActivityStarted = function () { };
+        /**
+         * @return {?}
+         */
+        Listener.prototype.onActivityFinished = function () { };
+    }
+})(InteractionContext || (InteractionContext = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/interaction/interaction.module.js

@@ -57,4 +57,4 @@ var InteractionModule = /** @class */ (function () {
     return InteractionModule;
 }());
 export { InteractionModule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJhY3Rpb24ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGNvb2xvbi9hbmd1bGFyLXVpLXBvd2VydXBzLyIsInNvdXJjZXMiOlsibGliL2ludGVyYWN0aW9uL2ludGVyYWN0aW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXBGLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSw4REFBOEQsQ0FBQztBQUMxRyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUNqRyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxrREFBa0QsQ0FBQztBQUN4RixPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxnRUFBZ0UsQ0FBQztBQUM1RyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxnRUFBZ0UsQ0FBQztBQUM3RyxPQUFPLEVBQUUsa0NBQWtDLEVBQUUsTUFBTSxnRkFBZ0YsQ0FBQztBQUNwSSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSw4REFBOEQsQ0FBQztBQUMxRyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUVqRjtJQUFBO0lBc0NBLENBQUM7O2dCQXRDQSxRQUFRLFNBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osZUFBZTt3QkFDZixlQUFlO3dCQUNmLGFBQWE7d0JBQ2IsWUFBWTt3QkFDWixZQUFZO3FCQUNiO29CQUNELFlBQVksRUFBRTt3QkFDWiwwQkFBMEI7d0JBQzFCLDJCQUEyQjt3QkFDM0IsMEJBQTBCO3dCQUMxQixvQkFBb0I7d0JBQ3BCLHVCQUF1Qjt3QkFDdkIsMEJBQTBCO3dCQUMxQixrQ0FBa0M7cUJBQ25DO29CQUNELE9BQU8sRUFBRTt3QkFDUCwwQkFBMEI7d0JBQzFCLHVCQUF1Qjt3QkFDdkIsMEJBQTBCO3dCQUMxQixrQ0FBa0M7cUJBQ25DO29CQUNELGVBQWUsRUFBRTt3QkFDZiwwQkFBMEI7d0JBQzFCLDJCQUEyQjt3QkFDM0IsMEJBQTBCO3dCQUMxQixvQkFBb0I7cUJBQ3JCO29CQUNELFNBQVMsRUFBRTt3QkFDVCx3QkFBd0I7cUJBSXpCO2lCQUNGOztJQUVELHdCQUFDO0NBQUEsQUF0Q0QsSUFzQ0M7U0FEWSxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQb3J0YWxNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jZGsvcG9ydGFsJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTWF0QnV0dG9uTW9kdWxlLCBNYXREaWFsb2dNb2R1bGUsIE1hdFRhYnNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbCc7XG5pbXBvcnQgeyBNQVRfVEFCU19DT05GSUcgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC90YWJzJztcbmltcG9ydCB7IFJvdXRlck1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBQbGFjZU1vZHVsZSB9IGZyb20gJy4uL3BsYWNlL3BsYWNlLm1vZHVsZSc7XG5pbXBvcnQgeyBBY3Rpdml0eUNvbnRhaW5lckNvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9hY3Rpdml0eS1jb250YWluZXIvYWN0aXZpdHktY29udGFpbmVyLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBBY3Rpdml0eU91dGxldENvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9hY3Rpdml0eS1vdXRsZXQvYWN0aXZpdHktb3V0bGV0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBBbGVydERpYWxvZ0NvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9hbGVydC1kaWFsb2cvYWxlcnQtZGlhbG9nLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBDb25maXJtVGhlbkRpYWxvZ0NvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9jb25maXJtLXRoZW4tZGlhbG9nL2NvbmZpcm0tdGhlbi1kaWFsb2cuY29tcG9uZW50JztcbmltcG9ydCB7IENvbmZpcm1hdGlvbkRpYWxvZ0NvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9jb25maXJtYXRpb24tZGlhbG9nL2NvbmZpcm1hdGlvbi1kaWFsb2cuY29tcG9uZW50JztcbmltcG9ydCB7IElucGxhY2VJbnRlcmFjdGlvbkNvbnRleHRDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvaW5wbGFjZS1pbnRlcmFjdGlvbi1jb250ZXh0L2lucGxhY2UtaW50ZXJhY3Rpb24tY29udGV4dC5jb21wb25lbnQnO1xuaW1wb3J0IHsgSW50ZXJhY3Rpb25PdXRsZXRDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvaW50ZXJhY3Rpb24tb3V0bGV0L2ludGVyYWN0aW9uLW91dGxldC5jb21wb25lbnQnO1xuaW1wb3J0IHsgRGlhbG9nSW50ZXJhY3Rpb25TZXJ2aWNlIH0gZnJvbSAnLi9zZXJ2aWNlcy9kaWFsb2ctaW50ZXJhY3Rpb24uc2VydmljZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgTWF0QnV0dG9uTW9kdWxlLFxuICAgIE1hdERpYWxvZ01vZHVsZSxcbiAgICBNYXRUYWJzTW9kdWxlLFxuICAgIFBvcnRhbE1vZHVsZSxcbiAgICBSb3V0ZXJNb2R1bGVcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgQWN0aXZpdHlDb250YWluZXJDb21wb25lbnQsXG4gICAgQ29uZmlybWF0aW9uRGlhbG9nQ29tcG9uZW50LFxuICAgIENvbmZpcm1UaGVuRGlhbG9nQ29tcG9uZW50LFxuICAgIEFsZXJ0RGlhbG9nQ29tcG9uZW50LFxuICAgIEFjdGl2aXR5T3V0bGV0Q29tcG9uZW50LFxuICAgIEludGVyYWN0aW9uT3V0bGV0Q29tcG9uZW50LFxuICAgIElucGxhY2VJbnRlcmFjdGlvbkNvbnRleHRDb21wb25lbnRcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIEFjdGl2aXR5Q29udGFpbmVyQ29tcG9uZW50LFxuICAgIEFjdGl2aXR5T3V0bGV0Q29tcG9uZW50LFxuICAgIEludGVyYWN0aW9uT3V0bGV0Q29tcG9uZW50LFxuICAgIElucGxhY2VJbnRlcmFjdGlvbkNvbnRleHRDb21wb25lbnRcbiAgXSxcbiAgZW50cnlDb21wb25lbnRzOiBbXG4gICAgQWN0aXZpdHlDb250YWluZXJDb21wb25lbnQsXG4gICAgQ29uZmlybWF0aW9uRGlhbG9nQ29tcG9uZW50LFxuICAgIENvbmZpcm1UaGVuRGlhbG9nQ29tcG9uZW50LFxuICAgIEFsZXJ0RGlhbG9nQ29tcG9uZW50XG4gIF0sXG4gIHByb3ZpZGVyczogW1xuICAgIERpYWxvZ0ludGVyYWN0aW9uU2VydmljZSxcbiAgICAvLyB7XG4gICAgLy8gICBwcm92aWRlOiBNQVRfVEFCU19DT05GSUcsIHVzZVZhbHVlOiB7IGFuaW1hdGlvbkR1cmF0aW9uOiBcIjJzXCIgfVxuICAgIC8vIH1cbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBJbnRlcmFjdGlvbk1vZHVsZSB7XG59XG4iXX0=

package/esm5/lib/interaction/services/dialog-interaction-context.js

@@ -0,0 +1,188 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material';
+import { MatDialogConfig } from '@angular/material/dialog';
+import { lang, MutableValueModel } from '@coolon/pectin';
+import { assert } from '@coolon/typescript-utilities';
+import { ActivityContainerComponent } from '../components/activity-container/activity-container.component';
+import { InteractionContextBase } from '../interaction-context-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+var DialogInteractionContext = /** @class */ (function (_super) {
+    tslib_1.__extends(DialogInteractionContext, _super);
+    function DialogInteractionContext(dialogService, config) {
+        var _this = _super.call(this) || this;
+        _this.dialogService = dialogService;
+        _this.config = config;
+        _this._activeModel = new MutableValueModel(false);
+        assert.notNil(dialogService);
+        _this.onDispose((/**
+         * @return {?}
+         */
+        function () {
+            if (_this.isActive()) {
+                lang.illegalState('Dispose called while active.');
+            }
+        }));
+        return _this;
+    }
+    Object.defineProperty(DialogInteractionContext.prototype, "active", {
+        get: /**
+         * @return {?}
+         */
+        function () {
+            return this._activeModel.readonly;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @protected
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    DialogInteractionContext.prototype._startActivity = /**
+     * @protected
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    function (activityType, data, disableClose) {
+        var _this = this;
+        if (disableClose === void 0) { disableClose = true; }
+        if (this.isActive()) {
+            lang.illegalState("Activity already in progress: " + this.activityList.value.map((/**
+             * @param {?} a
+             * @return {?}
+             */
+            function (a) { return a.constructor.name; })).join(', '));
+        }
+        this._activeModel.value = true;
+        this.notifyActivityStarted();
+        /** @type {?} */
+        var config = tslib_1.__assign({}, this.config, {
+            data: data,
+            disableClose: disableClose,
+            panelClass: 'dialog-interaction-service'
+        });
+        /** @type {?} */
+        var self = this;
+        /** @type {?} */
+        var matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        function (resolve, reject) {
+            /** @type {?} */
+            var activityContainer = matDialogRef.componentInstance;
+            self.safelyUpdateActivityListDelegate(activityContainer.activityList);
+            activityContainer.initialActivityOutletContext = {
+                activityClass: activityType,
+                activityData: data,
+                onDone: /**
+                 * @param {?} result
+                 * @return {?}
+                 */
+                function (result) {
+                    resolve(result);
+                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
+                },
+                onCancel: /**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) {
+                    reject(error);
+                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
+                }
+            };
+            // we need to check if our onDone/onCancel methods above we called or if we were
+            // closed by the user clicking the backdrop.  If the later then we need to reject
+            // our promise.
+            matDialogRef.afterClosed().subscribe((/**
+             * @param {?} promiseAlreadyFinished
+             * @return {?}
+             */
+            function (promiseAlreadyFinished) {
+                if (!promiseAlreadyFinished) {
+                    reject('auto-closed');
+                }
+            }));
+            matDialogRef.updateSize();
+            matDialogRef.afterOpened().subscribe((/**
+             * @param {?} promiseAlreadyFinished
+             * @return {?}
+             */
+            function (promiseAlreadyFinished) {
+                matDialogRef.updateSize();
+            }));
+        })).finally((/**
+         * @return {?}
+         */
+        function () {
+            _this._activeModel.value = false;
+            _this.notifyActivityFinished();
+            self.safelyUpdateActivityListDelegate(null);
+        }));
+    };
+    /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param delegate
+     */
+    /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param {?} delegate
+     * @return {?}
+     */
+    DialogInteractionContext.prototype.safelyUpdateActivityListDelegate = /**
+     * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.
+     * @param {?} delegate
+     * @return {?}
+     */
+    function (delegate) {
+        var _this = this;
+        setTimeout((/**
+         * @return {?}
+         */
+        function () { return _this.setActivityList(delegate); }));
+    };
+    DialogInteractionContext.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    DialogInteractionContext.ctorParameters = function () { return [
+        { type: MatDialog },
+        { type: MatDialogConfig }
+    ]; };
+    /** @nocollapse */ DialogInteractionContext.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function DialogInteractionContext_Factory() { return new DialogInteractionContext(i0.ɵɵinject(i1.MatDialog), i0.ɵɵinject(i1.MatDialogConfig)); }, token: DialogInteractionContext, providedIn: "root" });
+    return DialogInteractionContext;
+}(InteractionContextBase));
+export { DialogInteractionContext };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContext.prototype._activeModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContext.prototype.dialogService;
+    /** @type {?} */
+    DialogInteractionContext.prototype.config;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog-interaction-context.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/interaction/services/dialog-interaction-context.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { MatDialog, MatDialogRef } from '@angular/material';\nimport { MatDialogConfig } from '@angular/material/dialog';\nimport { Constructable, lang, ListModel, MutableValueModel, ValueModel } from '@coolon/pectin';\nimport { assert } from '@coolon/typescript-utilities';\nimport { Activity } from '../activity';\nimport { ActivityContainerComponent } from '../components/activity-container/activity-container.component';\nimport { InteractionContextBase } from '../interaction-context-base';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DialogInteractionContext extends InteractionContextBase {\n\n  private readonly _activeModel = new MutableValueModel<boolean>(false);\n\n  constructor(private readonly dialogService: MatDialog, readonly config: MatDialogConfig<any>) {\n    super();\n    assert.notNil(dialogService);\n    this.onDispose(() => {\n      if (this.isActive()) {\n        lang.illegalState('Dispose called while active.');\n      }\n    });\n  }\n\n  get active(): ValueModel<boolean> {\n    return this._activeModel.readonly;\n  }\n\n  protected _startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data: D, disableClose: boolean = true) {\n    if (this.isActive()) {\n      lang.illegalState(`Activity already in progress: ${this.activityList.value.map(a => a.constructor.name).join(', ')}`);\n    }\n    this._activeModel.value = true;\n    this.notifyActivityStarted();\n    const config: MatDialogConfig = {\n      ...this.config,\n      ...{\n        data,\n        disableClose,\n        panelClass: 'dialog-interaction-service'\n      }\n    };\n\n    const self = this;\n    const matDialogRef = this.dialogService.open(ActivityContainerComponent, config) as MatDialogRef<ActivityContainerComponent<D, R, E>>;\n    return new Promise<R>((resolve, reject) => {\n      const activityContainer = matDialogRef.componentInstance;\n      self.safelyUpdateActivityListDelegate(activityContainer.activityList);\n\n      activityContainer.initialActivityOutletContext = {\n        activityClass: activityType,\n        activityData: data,\n        onDone(result) {\n          resolve(result);\n          matDialogRef.close(true); // return true to let the after close listener know we've already handled it.\n        },\n        onCancel(error) {\n          reject(error);\n          matDialogRef.close(true); // return true to let the after close listener know we've already handled it.\n        }\n      };\n      // we need to check if our onDone/onCancel methods above we called or if we were\n      // closed by the user clicking the backdrop.  If the later then we need to reject\n      // our promise.\n      matDialogRef.afterClosed().subscribe(promiseAlreadyFinished => {\n        if (!promiseAlreadyFinished) {\n          reject('auto-closed');\n        }\n      });\n      matDialogRef.updateSize();\n      matDialogRef.afterOpened().subscribe(promiseAlreadyFinished => {\n        matDialogRef.updateSize();\n      });\n    }).finally(() => {\n      this._activeModel.value = false;\n      this.notifyActivityFinished();\n      self.safelyUpdateActivityListDelegate(null);\n    });\n  }\n\n  /**\n   * Updates teh delegate on the next tick to avoid modifying state during the current change detection cycle.\n   * @param delegate\n   */\n  safelyUpdateActivityListDelegate(delegate: ListModel<Activity<any, any>>) {\n    setTimeout(() => this.setActivityList(delegate));\n  }\n\n}\n"]}