@coolon/angular-ui-powerups 0.0.95 → 0.0.97

package/esm2015/lib/interaction/interaction-context-base.js

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Deferred, DelegatingListModel, Dsl } from '@coolon/pectin';
+import * as _ from 'lodash';
+import { AlertDialogComponent } from './components/alert-dialog/alert-dialog.component';
+import { ConfirmThenDialogComponent } from './components/confirm-then-dialog/confirm-then-dialog.component';
+import { ConfirmationDialogComponent } from './components/confirmation-dialog/confirmation-dialog.component';
+import { InteractionContext } from './interaction-context';
+/**
+ * @abstract
+ */
+export class InteractionContextBase extends InteractionContext {
+    /**
+     * @protected
+     */
+    constructor() {
+        super();
+        /**
+         * 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();
+        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
+        when.listOf(this.activityList).becomesPopulated((/**
+         * @param {?} activities
+         * @return {?}
+         */
+        (activities) => {
+            if (this.deferredGetCurrentActivity) {
+                this.deferredGetCurrentActivity.resolve(_.last(activities));
+                this.deferredGetCurrentActivity = null;
+            }
+        }));
+    }
+    /**
+     * @protected
+     * @param {?} activityList
+     * @return {?}
+     */
+    setActivityList(activityList) {
+        this._activityListDelegate.setDelegate(activityList);
+    }
+    /**
+     * @return {?}
+     */
+    get activityList() {
+        return this._activityListDelegate.readonly;
+    }
+    /**
+     * Returns the activity that is currently active.
+     * This model is only updated in the next tick after the view has been updated.
+     * @return {?}
+     */
+    getCurrentActivity() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!this.isActive()) {
+                return Promise.reject('no activity in progress');
+            }
+            else {
+                if (this.deferredGetCurrentActivity) {
+                    // we're already waiting then just return the same promise
+                    return this.deferredGetCurrentActivity.promise;
+                }
+                else {
+                    if (this.activityList.length < 1) {
+                        this.deferredGetCurrentActivity = Deferred.defer();
+                        return this.deferredGetCurrentActivity.promise;
+                    }
+                    else {
+                        return _.last(this.activityList.value);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?=} data
+     * @return {?}
+     */
+    startActivity(activityType, data) {
+        return this._startActivity(activityType, data);
+    }
+    /**
+     * @param {?} confirm
+     * @return {?}
+     */
+    confirm(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 {?}
+         */
+        () => true)).catch((/**
+         * @return {?}
+         */
+        () => false));
+    }
+    /**
+     * @param {?} alert
+     * @return {?}
+     */
+    alert(alert) {
+        // TODO: Test disableClose === false
+        return this._startActivity(AlertDialogComponent, alert, false);
+    }
+    /**
+     * @param {?} confirm
+     * @return {?}
+     */
+    confirmOrReject(confirm) {
+        return this._startActivity(ConfirmationDialogComponent, confirm, true);
+    }
+    /**
+     * @template D, R, E
+     * @param {?} confirm
+     * @param {?} activityType
+     * @param {?=} data
+     * @return {?}
+     */
+    confirmThen(confirm, activityType, data) {
+        return this._startActivity(ConfirmThenDialogComponent, {
+            confirm,
+            activityType: activityType,
+            data: data
+        }, true);
+    }
+}
+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
+     */
+    InteractionContextBase.prototype._activityListDelegate;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionContextBase.prototype.deferredGetCurrentActivity;
+    /**
+     * @abstract
+     * @protected
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?=} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    InteractionContextBase.prototype._startActivity = function (activityType, data, disableClose) { };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interaction-context-base.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/interaction/interaction-context-base.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Constructable,\n  Deferred,\n  DelegatingListModel, Disposable,\n  Dsl,\n  EventListenerList,\n  GarbageCollector,\n  ListModel\n} from '@coolon/pectin';\nimport * as _ from 'lodash';\nimport { Activity } from './activity';\nimport { Alert } from './alert';\nimport { AlertDialogComponent } from './components/alert-dialog/alert-dialog.component';\nimport { ConfirmThenDialogComponent } from './components/confirm-then-dialog/confirm-then-dialog.component';\nimport { ConfirmationDialogComponent } from './components/confirmation-dialog/confirmation-dialog.component';\nimport { Confirm } from './confirm';\nimport { InteractionContext } from './interaction-context';\n\nexport abstract class InteractionContextBase extends InteractionContext {\n\n  /**\n   * Returns the current list of activities that are in progress.\n   * This model is only updated in the next tick after the view has been updated.\n   */\n  private readonly _activityListDelegate = new DelegatingListModel<Activity<any, any>>();\n\n  private deferredGetCurrentActivity: Deferred<Activity<any, any, any>>;\n\n  protected constructor() {\n    super();\n    const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);\n    when.listOf(this.activityList).becomesPopulated((activities) => {\n      if (this.deferredGetCurrentActivity) {\n        this.deferredGetCurrentActivity.resolve(_.last(activities));\n        this.deferredGetCurrentActivity = null;\n      }\n    });\n  }\n\n  protected setActivityList(activityList: ListModel<Activity<any, any>>) {\n    this._activityListDelegate.setDelegate(activityList);\n  }\n\n  get activityList(): ListModel<Activity<any, any, any>> {\n    return this._activityListDelegate.readonly;\n  }\n\n  /**\n   * Returns the activity that is currently active.\n   * This model is only updated in the next tick after the view has been updated.\n   */\n  async getCurrentActivity(): Promise<Activity<any, any>> {\n    if (!this.isActive()) {\n      return Promise.reject('no activity in progress');\n    } else {\n      if (this.deferredGetCurrentActivity) {\n        // we're already waiting then just return the same promise\n        return this.deferredGetCurrentActivity.promise;\n      } else {\n        if (this.activityList.length < 1) {\n          this.deferredGetCurrentActivity = Deferred.defer();\n          return this.deferredGetCurrentActivity.promise;\n        } else {\n          return _.last(this.activityList.value);\n        }\n      }\n    }\n  }\n  protected abstract _startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D, disableClose?:boolean): Promise<R>;\n\n  startActivity<D, R, E>(activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R> {\n    return this._startActivity(activityType, data);\n  }\n\n  confirm(confirm: Confirm): Promise<boolean> {\n    // Important: we have to implement confirmOrReject as the main entry point\n    // as the canDeactivation guards need to be able to cancel an interaction\n    // without caring about returning a value.\n    return this.confirmOrReject(confirm).then(() => true).catch(() => false);\n  }\n\n  alert(alert: Alert): Promise<void> {\n    // TODO: Test disableClose === false\n    return this._startActivity(AlertDialogComponent, alert, false);\n  }\n\n  confirmOrReject(confirm: Confirm): Promise<void> {\n    return this._startActivity(ConfirmationDialogComponent, confirm, true);\n  }\n\n  confirmThen<D, R, E>(confirm: Confirm, activityType: Constructable<Activity<D, R, E>>, data?: D): Promise<R> {\n    return this._startActivity<ConfirmThenDialogComponent.Data<D, R, E>, R, E>(ConfirmThenDialogComponent, {\n      confirm,\n      activityType: activityType,\n      data: data\n    }, true);\n  }\n\n}\n\n"]}

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

@@ -2,112 +2,69 @@
  * @fileoverview added by tsickle
  * @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
  */
 export class InteractionContext extends GarbageCollector {
-    /**
-     * @protected
-     */
     constructor() {
-        super();
-        /**
-         * 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();
-        const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);
-        when.listOf(this.activityList).becomesPopulated((/**
-         * @param {?} activities
-         * @return {?}
-         */
-        (activities) => {
-            if (this.deferredGetCurrentActivity) {
-                this.deferredGetCurrentActivity.resolve(_.last(activities));
-                this.deferredGetCurrentActivity = null;
-            }
-        }));
+        super(...arguments);
+        this.activityListeners = new EventListenerList();
     }
     /**
-     * @protected
-     * @param {?} activityList
+     * Returns true if an activity is currently running.
      * @return {?}
      */
-    setActivityList(activityList) {
-        this._activityListDelegate.setDelegate(activityList);
+    isActive() {
+        return this.active.value;
     }
     /**
+     * @param {?} listener
      * @return {?}
      */
-    get activityList() {
-        return this._activityListDelegate.readonly;
+    addActivityListener(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 {?}
      */
-    getCurrentActivity() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (!this.isActive()) {
-                return Promise.reject('no activity in progress');
-            }
-            else {
-                if (this.deferredGetCurrentActivity) {
-                    // we're already waiting then just return the same promise
-                    return this.deferredGetCurrentActivity.promise;
-                }
-                else {
-                    if (this.activityList.length < 1) {
-                        this.deferredGetCurrentActivity = Deferred.defer();
-                        return this.deferredGetCurrentActivity.promise;
-                    }
-                    else {
-                        return _.last(this.activityList.value);
-                    }
-                }
-            }
-        });
+    notifyActivityStarted() {
+        this.activityListeners.fire((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l.onActivityStarted()));
     }
     /**
-     * @param {?} confirm
+     * @protected
      * @return {?}
      */
-    confirm(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((/**
+    notifyActivityFinished() {
+        this.activityListeners.fire((/**
+         * @param {?} l
          * @return {?}
          */
-        () => true)).catch((/**
-         * @return {?}
-         */
-        () => false));
+        l => l.onActivityFinished()));
     }
 }
 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;
     /**
      * @type {?}
      * @private
      */
-    InteractionContext.prototype.deferredGetCurrentActivity;
+    InteractionContext.prototype.activityListeners;
+    /** @type {?} */
+    InteractionContext.prototype.activityList;
+    /** @type {?} */
+    InteractionContext.prototype.active;
     /**
-     * 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
@@ -116,6 +73,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
@@ -132,11 +101,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/esm2015/lib/interaction/interaction.module.js

@@ -53,4 +53,4 @@ InteractionModule.decorators = [
                 ]
             },] }
 ];
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+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";
+export class DialogInteractionContext extends InteractionContextBase {
+    /**
+     * @param {?} dialogService
+     * @param {?} config
+     */
+    constructor(dialogService, config) {
+        super();
+        this.dialogService = dialogService;
+        this.config = config;
+        this._activeModel = new MutableValueModel(false);
+        assert.notNil(dialogService);
+        this.onDispose((/**
+         * @return {?}
+         */
+        () => {
+            if (this.isActive()) {
+                lang.illegalState('Dispose called while active.');
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    get active() {
+        return this._activeModel.readonly;
+    }
+    /**
+     * @protected
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?} data
+     * @param {?=} disableClose
+     * @return {?}
+     */
+    _startActivity(activityType, data, disableClose = true) {
+        if (this.isActive()) {
+            lang.illegalState(`Activity already in progress: ${this.activityList.value.map((/**
+             * @param {?} a
+             * @return {?}
+             */
+            a => a.constructor.name)).join(', ')}`);
+        }
+        this._activeModel.value = true;
+        this.notifyActivityStarted();
+        /** @type {?} */
+        const config = Object.assign({}, this.config, {
+            data,
+            disableClose,
+            panelClass: 'dialog-interaction-service'
+        });
+        /** @type {?} */
+        const self = this;
+        /** @type {?} */
+        const matDialogRef = (/** @type {?} */ (this.dialogService.open(ActivityContainerComponent, config)));
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            /** @type {?} */
+            const activityContainer = matDialogRef.componentInstance;
+            self.safelyUpdateActivityListDelegate(activityContainer.activityList);
+            activityContainer.initialActivityOutletContext = {
+                activityClass: activityType,
+                activityData: data,
+                /**
+                 * @param {?} result
+                 * @return {?}
+                 */
+                onDone(result) {
+                    resolve(result);
+                    matDialogRef.close(true); // return true to let the after close listener know we've already handled it.
+                },
+                /**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                onCancel(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 {?}
+             */
+            promiseAlreadyFinished => {
+                if (!promiseAlreadyFinished) {
+                    reject('auto-closed');
+                }
+            }));
+            matDialogRef.updateSize();
+            matDialogRef.afterOpened().subscribe((/**
+             * @param {?} promiseAlreadyFinished
+             * @return {?}
+             */
+            promiseAlreadyFinished => {
+                matDialogRef.updateSize();
+            }));
+        })).finally((/**
+         * @return {?}
+         */
+        () => {
+            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
+     * @return {?}
+     */
+    safelyUpdateActivityListDelegate(delegate) {
+        setTimeout((/**
+         * @return {?}
+         */
+        () => this.setActivityList(delegate)));
+    }
+}
+DialogInteractionContext.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+DialogInteractionContext.ctorParameters = () => [
+    { 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" });
+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"]}