@coolon/angular-ui-powerups 0.0.98 → 0.0.102

package/esm5/lib/interaction/services/interaction.service.js

@@ -0,0 +1,280 @@
+/**
+ * @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 { Dsl, GarbageCollector, lang, MutableListModel, MutableValueModel } from '@coolon/pectin';
+import { assert } from '@coolon/typescript-utilities';
+import { ModalInteractionContextFactory } from './modal-interaction-context.factory';
+import * as i0 from "@angular/core";
+import * as i1 from "./modal-interaction-context.factory";
+/** @type {?} */
+var inplaceMonitorCount = 0;
+var InteractionService = /** @class */ (function () {
+    function InteractionService(modelInteractionContextFactory) {
+        this.modelInteractionContextFactory = modelInteractionContextFactory;
+        this.garbage = new GarbageCollector();
+        this.exclusiveContext = new MutableValueModel();
+        this._activeModalInteractionContextModel = new MutableValueModel();
+        this._activeInlineInteractionContextModel = new MutableValueModel();
+        var _a = Dsl.disposeWith(this.garbage), chain = _a.chain, valueOf = _a.valueOf, before = _a.before, when = _a.when, after = _a.after, observe = _a.observe, switchOn = _a.switchOn;
+        this._activeInteractionContext = chain(this._activeModalInteractionContextModel)
+            .otherwise(this._activeInlineInteractionContextModel)
+            .pluck('interactionContext');
+        this.active = chain(this._activeInteractionContext).isNotNil();
+        this.modelInteractionActive = chain(this._activeModalInteractionContextModel).isNotNil();
+        this.inlineInteractionActive = chain(this._activeInlineInteractionContextModel).isNotNil();
+        // TODO: chain.concat(listOrValueModels) would be nice.
+        this.activeInteractionContextIds = chain(new MutableListModel())
+            .append(this._activeInlineInteractionContextModel)
+            .append(this._activeModalInteractionContextModel)
+            .rejectNil()
+            .pluck('id');
+    }
+    /**
+     * @return {?}
+     */
+    InteractionService.prototype.isActive = /**
+     * @return {?}
+     */
+    function () {
+        return this.active.value;
+    };
+    /**
+     * @return {?}
+     */
+    InteractionService.prototype.isModalActive = /**
+     * @return {?}
+     */
+    function () {
+        return this.modelInteractionActive.value;
+    };
+    /**
+     * @param {?} disposable
+     * @return {?}
+     */
+    InteractionService.prototype.createModalInteractionContextFor = /**
+     * @param {?} disposable
+     * @return {?}
+     */
+    function (disposable) {
+        /** @type {?} */
+        var context = this.modelInteractionContextFactory.createInteractionContext();
+        disposable.registerDisposable(new InteractionService.Monitor('modal', context, this._activeModalInteractionContextModel, this.exclusiveContext));
+        return context;
+    };
+    /**
+     * @param {?} interactionContext
+     * @return {?}
+     */
+    InteractionService.prototype._registerInplaceInteractionContext = /**
+     * @param {?} interactionContext
+     * @return {?}
+     */
+    function (interactionContext) {
+        interactionContext.registerDisposable(new InteractionService.Monitor("ip" + ++inplaceMonitorCount, interactionContext, this._activeInlineInteractionContextModel, this.exclusiveContext));
+    };
+    // @Trace()
+    // @Trace()
+    /**
+     * @return {?}
+     */
+    InteractionService.prototype.getActiveContext = 
+    // @Trace()
+    /**
+     * @return {?}
+     */
+    function () {
+        assert.isTruthy(this.isActive());
+        return this._activeInteractionContext.value;
+    };
+    /**
+     * Creates an interaction context that will prevent any other contexts from starting an
+     * activity until it is disposed.  This is intended for use by the router for passing
+     * to PlaceComponent.canDeactivate(interactionContext).  This ensures components don't
+     * try and interact in a way that we can't track and synchronise with the browser back
+     * button.
+     */
+    /**
+     * Creates an interaction context that will prevent any other contexts from starting an
+     * activity until it is disposed.  This is intended for use by the router for passing
+     * to PlaceComponent.canDeactivate(interactionContext).  This ensures components don't
+     * try and interact in a way that we can't track and synchronise with the browser back
+     * button.
+     * @return {?}
+     */
+    InteractionService.prototype._createExclusiveModalInteractionContext = /**
+     * Creates an interaction context that will prevent any other contexts from starting an
+     * activity until it is disposed.  This is intended for use by the router for passing
+     * to PlaceComponent.canDeactivate(interactionContext).  This ensures components don't
+     * try and interact in a way that we can't track and synchronise with the browser back
+     * button.
+     * @return {?}
+     */
+    function () {
+        this.exclusiveContext.value = this.modelInteractionContextFactory.createInteractionContext();
+        /** @type {?} */
+        var self = this;
+        this.exclusiveContext.value.registerDisposable({
+            dispose: /**
+             * @return {?}
+             */
+            function () {
+                self.exclusiveContext.value = null;
+            }
+        });
+        return this.exclusiveContext.value;
+    };
+    InteractionService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    InteractionService.ctorParameters = function () { return [
+        { type: ModalInteractionContextFactory }
+    ]; };
+    /** @nocollapse */ InteractionService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function InteractionService_Factory() { return new InteractionService(i0.ɵɵinject(i1.ModalInteractionContextFactory)); }, token: InteractionService, providedIn: "root" });
+    return InteractionService;
+}());
+export { InteractionService };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype.garbage;
+    /** @type {?} */
+    InteractionService.prototype.active;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype.exclusiveContext;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype._activeModalInteractionContextModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype._activeInlineInteractionContextModel;
+    /**
+     * @type {?}
+     * @private
+     */
+    InteractionService.prototype._activeInteractionContext;
+    /** @type {?} */
+    InteractionService.prototype.activeInteractionContextIds;
+    /** @type {?} */
+    InteractionService.prototype.modelInteractionActive;
+    /** @type {?} */
+    InteractionService.prototype.inlineInteractionActive;
+    /** @type {?} */
+    InteractionService.prototype.modelInteractionContextFactory;
+}
+(function (InteractionService) {
+    /**
+     * @record
+     */
+    function Callback() { }
+    InteractionService.Callback = Callback;
+    if (false) {
+        /**
+         * @param {?} monitor
+         * @return {?}
+         */
+        Callback.prototype.onStarted = function (monitor) { };
+        /**
+         * @param {?} monitor
+         * @return {?}
+         */
+        Callback.prototype.onFinished = function (monitor) { };
+    }
+    var Monitor = /** @class */ (function (_super) {
+        tslib_1.__extends(Monitor, _super);
+        function Monitor(id, interactionContext, currentActiveMonitor, exclusiveContext) {
+            var _this = _super.call(this) || this;
+            _this.id = id;
+            _this.interactionContext = interactionContext;
+            _this.currentActiveMonitor = currentActiveMonitor;
+            _this.exclusiveContext = exclusiveContext;
+            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.valueOf(interactionContext.active).becomesTruthy((/**
+             * @return {?}
+             */
+            function () { return _this.onStarted(); }));
+            when.valueOf(interactionContext.active).becomesFalsey((/**
+             * @return {?}
+             */
+            function () { return _this.onFinished(); }));
+            interactionContext.registerDisposable(_this);
+            return _this;
+        }
+        /**
+         * @protected
+         * @return {?}
+         */
+        Monitor.prototype.onStarted = /**
+         * @protected
+         * @return {?}
+         */
+        function () {
+            this.assertCanStart();
+            this.currentActiveMonitor.value = this;
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        Monitor.prototype.assertCanStart = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            assert.isFalsey(this.currentActiveMonitor.value);
+            if (this.exclusiveContext.value && this.interactionContext !== this.exclusiveContext.value) {
+                lang.illegalState('Interaction started while exclusive lock active.  This is usually because you using a different context during place.canDeactivate(interactionContext)');
+            }
+        };
+        /**
+         * @protected
+         * @return {?}
+         */
+        Monitor.prototype.onFinished = /**
+         * @protected
+         * @return {?}
+         */
+        function () {
+            this.assertCurrentlyActive();
+            this.currentActiveMonitor.value = null;
+        };
+        /**
+         * @private
+         * @return {?}
+         */
+        Monitor.prototype.assertCurrentlyActive = /**
+         * @private
+         * @return {?}
+         */
+        function () {
+            assert.isTruthy(this.currentActiveMonitor.value === this);
+        };
+        return Monitor;
+    }(GarbageCollector));
+    InteractionService.Monitor = Monitor;
+    if (false) {
+        /** @type {?} */
+        Monitor.prototype.id;
+        /** @type {?} */
+        Monitor.prototype.interactionContext;
+        /** @type {?} */
+        Monitor.prototype.currentActiveMonitor;
+        /** @type {?} */
+        Monitor.prototype.exclusiveContext;
+    }
+})(InteractionService || (InteractionService = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interaction.service.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/interaction/services/interaction.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  BooleanValueModelChain,\n  Disposable,\n  Dsl,\n  GarbageCollector,\n  lang,\n  ListModelChain,\n  MutableListModel,\n  MutableValueModel,\n  ValueModel,\n  ValueModelChain\n} from '@coolon/pectin';\nimport { assert } from '@coolon/typescript-utilities';\nimport { InteractionContext } from '../interaction-context';\n\nimport { ModalInteractionContextFactory } from './modal-interaction-context.factory';\n\nlet inplaceMonitorCount = 0;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class InteractionService {\n\n  private readonly garbage = new GarbageCollector();\n  readonly active: BooleanValueModelChain;\n  private readonly exclusiveContext = new MutableValueModel<InteractionContext>();\n\n  private readonly _activeModalInteractionContextModel = new MutableValueModel<InteractionService.Monitor>();\n  private readonly _activeInlineInteractionContextModel = new MutableValueModel<InteractionService.Monitor>();\n  private readonly _activeInteractionContext: ValueModelChain<InteractionContext>;\n\n  readonly activeInteractionContextIds: ListModelChain<string>;\n  readonly modelInteractionActive: BooleanValueModelChain;\n  readonly inlineInteractionActive: BooleanValueModelChain;\n\n  constructor(readonly modelInteractionContextFactory: ModalInteractionContextFactory) {\n    const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this.garbage);\n\n    this._activeInteractionContext = chain(this._activeModalInteractionContextModel)\n      .otherwise(this._activeInlineInteractionContextModel)\n      .pluck('interactionContext');\n\n    this.active = chain(this._activeInteractionContext).isNotNil();\n    this.modelInteractionActive = chain(this._activeModalInteractionContextModel).isNotNil();\n    this.inlineInteractionActive = chain(this._activeInlineInteractionContextModel).isNotNil();\n\n    // TODO: chain.concat(listOrValueModels) would be nice.\n    this.activeInteractionContextIds = chain(new MutableListModel<InteractionService.Monitor>())\n      .append(this._activeInlineInteractionContextModel)\n      .append(this._activeModalInteractionContextModel)\n      .rejectNil()\n      .pluck('id');\n\n  }\n\n  isActive(): boolean {\n    return this.active.value;\n  }\n\n  isModalActive(): boolean {\n    return this.modelInteractionActive.value;\n  }\n\n  createModalInteractionContextFor(disposable: Disposable.Collector): InteractionContext {\n    const context = this.modelInteractionContextFactory.createInteractionContext();\n    disposable.registerDisposable(new InteractionService.Monitor('modal', context, this._activeModalInteractionContextModel, this.exclusiveContext));\n    return context;\n  }\n\n  _registerInplaceInteractionContext(interactionContext: InteractionContext) {\n    interactionContext.registerDisposable(new InteractionService.Monitor(`ip${++inplaceMonitorCount}`, interactionContext, this._activeInlineInteractionContextModel, this.exclusiveContext));\n  }\n\n  // @Trace()\n  getActiveContext(): InteractionContext {\n    assert.isTruthy(this.isActive());\n    return this._activeInteractionContext.value;\n  }\n\n  /**\n   * Creates an interaction context that will prevent any other contexts from starting an\n   * activity until it is disposed.  This is intended for use by the router for passing\n   * to PlaceComponent.canDeactivate(interactionContext).  This ensures components don't\n   * try and interact in a way that we can't track and synchronise with the browser back\n   * button.\n   */\n  _createExclusiveModalInteractionContext(): InteractionContext {\n    this.exclusiveContext.value = this.modelInteractionContextFactory.createInteractionContext();\n    const self = this;\n    this.exclusiveContext.value.registerDisposable({\n      dispose(): void {\n        self.exclusiveContext.value = null;\n      }\n    });\n    return this.exclusiveContext.value;\n  }\n}\n\nexport namespace InteractionService {\n\n  export interface Callback {\n    onStarted(monitor: Monitor);\n\n    onFinished(monitor: Monitor);\n  }\n\n  export class Monitor extends GarbageCollector {\n    constructor(readonly id: string,\n                readonly interactionContext: InteractionContext,\n                readonly currentActiveMonitor: MutableValueModel<Monitor>,\n                readonly exclusiveContext: ValueModel<InteractionContext>) {\n      super();\n      const { chain, valueOf, before, when, after, observe, switchOn } = Dsl.disposeWith(this);\n      when.valueOf(interactionContext.active).becomesTruthy(() => this.onStarted());\n      when.valueOf(interactionContext.active).becomesFalsey(() => this.onFinished());\n      interactionContext.registerDisposable(this);\n    }\n\n    protected onStarted() {\n      this.assertCanStart();\n      this.currentActiveMonitor.value = this;\n    }\n\n    private assertCanStart() {\n      assert.isFalsey(this.currentActiveMonitor.value);\n      if (this.exclusiveContext.value && this.interactionContext !== this.exclusiveContext.value) {\n        lang.illegalState('Interaction started while exclusive lock active.  This is usually because you using a different context during place.canDeactivate(interactionContext)');\n      }\n    }\n\n    protected onFinished() {\n      this.assertCurrentlyActive();\n      this.currentActiveMonitor.value = null;\n    }\n\n    private assertCurrentlyActive() {\n      assert.isTruthy(this.currentActiveMonitor.value === this);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { MatDialog } from '@angular/material';
+import { MAT_DIALOG_DEFAULT_OPTIONS, MatDialogConfig } from '@angular/material/dialog';
+import { assert } from '@coolon/typescript-utilities';
+import { ModalInteractionContextFactory } from '../modal-interaction-context.factory';
+import { DialogInteractionContext } from './dialog-interaction-context';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+/** @type {?} */
+export var DIALOG_INTERACTION_SERVICE_DEFAULTS = new InjectionToken('DIALOG_INTERACTION_SERVICE_DEFAULTS');
+var DialogInteractionContextFactory = /** @class */ (function (_super) {
+    tslib_1.__extends(DialogInteractionContextFactory, _super);
+    function DialogInteractionContextFactory(dialogService, dialogServiceDefaults, matDialogDefaultConfig) {
+        var _this = _super.call(this) || this;
+        _this.dialogService = dialogService;
+        _this.dialogServiceDefaults = dialogServiceDefaults;
+        _this.matDialogDefaultConfig = matDialogDefaultConfig;
+        assert.notNil(dialogService);
+        return _this;
+    }
+    /**
+     * @return {?}
+     */
+    DialogInteractionContextFactory.prototype.createInteractionContext = /**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var config = tslib_1.__assign({ autoFocus: false, hasBackdrop: true, closeOnNavigation: false }, this.matDialogDefaultConfig, this.dialogServiceDefaults);
+        return new DialogInteractionContext(this.dialogService, config);
+    };
+    DialogInteractionContextFactory.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    /** @nocollapse */
+    DialogInteractionContextFactory.ctorParameters = function () { return [
+        { type: MatDialog },
+        { type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [DIALOG_INTERACTION_SERVICE_DEFAULTS,] }] },
+        { type: MatDialogConfig, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DIALOG_DEFAULT_OPTIONS,] }] }
+    ]; };
+    /** @nocollapse */ DialogInteractionContextFactory.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function DialogInteractionContextFactory_Factory() { return new DialogInteractionContextFactory(i0.ɵɵinject(i1.MatDialog), i0.ɵɵinject(DIALOG_INTERACTION_SERVICE_DEFAULTS, 8), i0.ɵɵinject(i1.MAT_DIALOG_DEFAULT_OPTIONS, 8)); }, token: DialogInteractionContextFactory, providedIn: "root" });
+    return DialogInteractionContextFactory;
+}(ModalInteractionContextFactory));
+export { DialogInteractionContextFactory };
+if (false) {
+    /** @type {?} */
+    DialogInteractionContextFactory.prototype.active;
+    /**
+     * @type {?}
+     * @private
+     */
+    DialogInteractionContextFactory.prototype.dialogService;
+    /** @type {?} */
+    DialogInteractionContextFactory.prototype.dialogServiceDefaults;
+    /** @type {?} */
+    DialogInteractionContextFactory.prototype.matDialogDefaultConfig;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+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';
+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;
+        /** @type {?} */
+        var config = tslib_1.__assign({}, this.config, {
+            data: data,
+            disableClose: disableClose,
+            panelClass: 'dialog-interaction-context'
+        });
+        /** @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 () {
+            self.safelyUpdateActivityListDelegate(null);
+            _this._activeModel.value = false;
+        }));
+    };
+    /**
+     * 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); }));
+    };
+    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,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

package/esm5/lib/interaction/services/modal-interaction-context.factory.js

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @abstract
+ */
+var /**
+ * @abstract
+ */
+ModalInteractionContextFactory = /** @class */ (function () {
+    function ModalInteractionContextFactory() {
+    }
+    return ModalInteractionContextFactory;
+}());
+/**
+ * @abstract
+ */
+export { ModalInteractionContextFactory };
+if (false) {
+    /**
+     * @abstract
+     * @return {?}
+     */
+    ModalInteractionContextFactory.prototype.createInteractionContext = function () { };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtaW50ZXJhY3Rpb24tY29udGV4dC5mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGNvb2xvbi9hbmd1bGFyLXVpLXBvd2VydXBzLyIsInNvdXJjZXMiOlsibGliL2ludGVyYWN0aW9uL3NlcnZpY2VzL21vZGFsLWludGVyYWN0aW9uLWNvbnRleHQuZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBRUE7Ozs7SUFBQTtJQUdBLENBQUM7SUFBRCxxQ0FBQztBQUFELENBQUMsQUFIRCxJQUdDOzs7Ozs7Ozs7O0lBREMsb0ZBQXdEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW50ZXJhY3Rpb25Db250ZXh0IH0gZnJvbSAnLi4vaW50ZXJhY3Rpb24tY29udGV4dCc7XG5cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBNb2RhbEludGVyYWN0aW9uQ29udGV4dEZhY3Rvcnkge1xuXG4gIGFic3RyYWN0IGNyZWF0ZUludGVyYWN0aW9uQ29udGV4dCgpOiBJbnRlcmFjdGlvbkNvbnRleHQ7XG59XG4iXX0=