@coolon/angular-ui-powerups 0.0.1

package/esm2015/lib/directives/focus-binding.directive.js

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { DOCUMENT } from '@angular/common';
+import { Directive, ElementRef, HostListener, Inject, Input, NgZone } from '@angular/core';
+import { Dsl, HasFocusTracking, Logger } from '@coolon/pectin';
+import { DisposableComponent } from '../components/disposable-component';
+export class FocusBindingDirective extends DisposableComponent {
+    /**
+     * @param {?} el
+     * @param {?} ngZone
+     * @param {?} document
+     */
+    constructor(el, ngZone, document) {
+        super();
+        this.el = el;
+        this.ngZone = ngZone;
+        // @see https://stackoverflow.com/questions/49513359/could-not-resolve-type-document-in-angular5/53715642#53715642
+        this.document = (/** @type {?} */ (document));
+    }
+    /**
+     * @return {?}
+     */
+    onFocusIn() {
+        this.pectinFocusBinding.focusCallbacks.notifyFocusIn();
+    }
+    /**
+     * @return {?}
+     */
+    onFocusOut() {
+        this.pectinFocusBinding.focusCallbacks.notifyFocusOut();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        // TODO: Make this also track the current enabled/disabled state.
+        const { chain } = Dsl.disposeWith(this);
+        chain.value(this.pectinFocusBinding.focused).subscribe((/**
+         * @param {?} focused
+         * @return {?}
+         */
+        (focused) => {
+            if (focused && !this.alreadyHasFocus()) {
+                this.tryAndFocus();
+            }
+        }));
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @return {?}
+     */
+    alreadyHasFocus() {
+        return this.isFocused(this.focusTarget);
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @param {?} element
+     * @return {?}
+     */
+    isFocused(element) {
+        return this.document.activeElement === element;
+    }
+    /**
+     * @param {?=} retries
+     * @return {?}
+     */
+    tryAndFocus(retries = 5) {
+        if (this.modelShouldStillHaveFocus() && this.canFocus()) {
+            if (!this.alreadyHasFocus()) {
+                this.focusTarget.focus();
+            }
+            // if we didn't get the focus we try again later.
+            if (!this.alreadyHasFocus()) {
+                Logger.get(this).log(`focus failed, trying ${retries} more times`);
+                if (retries > 0) {
+                    // try again on the next paint
+                    // TODO: is there an angular way of doing this without calling a window function.
+                    requestAnimationFrame((/**
+                     * @return {?}
+                     */
+                    () => {
+                        this.tryAndFocus(retries - 1);
+                    }));
+                }
+                else {
+                    Logger.get(this).warn(`Tried to focus but gave up as the component wasn't enabled or visible.`);
+                }
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    get focusTarget() {
+        return this.focusBindingTarget || this.el.nativeElement;
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @return {?}
+     */
+    modelShouldStillHaveFocus() {
+        return this.pectinFocusBinding.focused.value;
+    }
+    // Hook method for debugging via tracing.
+    /**
+     * @return {?}
+     */
+    canFocus() {
+        /** @type {?} */
+        const dimension = this.focusTarget.getBoundingClientRect();
+        /** @type {?} */
+        const hasSize = dimension.height >= 0 && dimension.height >= 0;
+        // tslint:disable-next-line:no-string-literal
+        return hasSize && !this.focusTarget['disabled'];
+    }
+}
+FocusBindingDirective.decorators = [
+    { type: Directive, args: [{
+                // tslint:disable-next-line:directive-selector
+                selector: '[pectinFocusBinding]'
+            },] }
+];
+/** @nocollapse */
+FocusBindingDirective.ctorParameters = () => [
+    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
+    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] },
+    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+FocusBindingDirective.propDecorators = {
+    pectinFocusBinding: [{ type: Input }],
+    focusBindingTarget: [{ type: Input }],
+    onFocusIn: [{ type: HostListener, args: ['focusin',] }],
+    onFocusOut: [{ type: HostListener, args: ['focusout',] }]
+};
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    FocusBindingDirective.prototype.document;
+    /** @type {?} */
+    FocusBindingDirective.prototype.pectinFocusBinding;
+    /** @type {?} */
+    FocusBindingDirective.prototype.focusBindingTarget;
+    /**
+     * @type {?}
+     * @private
+     */
+    FocusBindingDirective.prototype.el;
+    /**
+     * @type {?}
+     * @private
+     */
+    FocusBindingDirective.prototype.ngZone;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/directives/index.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @file Automatically generated by barrelsby.
+ */
+export { CommandDirective } from "./command.directive";
+export { FocusBindingDirective } from "./focus-binding.directive";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7O0FBSUEsaUNBQWMscUJBQXFCLENBQUM7QUFDcEMsc0NBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBmaWxlIEF1dG9tYXRpY2FsbHkgZ2VuZXJhdGVkIGJ5IGJhcnJlbHNieS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9jb21tYW5kLmRpcmVjdGl2ZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZm9jdXMtYmluZGluZy5kaXJlY3RpdmVcIjtcbiJdfQ==

package/esm2015/lib/interaction/abstract-activity.js

@@ -0,0 +1,129 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { DelegatingValueModel, EventListenerList } from '@coolon/pectin';
+import { DisposableComponent } from '../components/disposable-component';
+/**
+ * @template D, R, E
+ */
+export class AbstractActivity extends DisposableComponent {
+    constructor() {
+        super(...arguments);
+        this._doneListeners = new EventListenerList();
+        this._cancelListeners = new EventListenerList();
+        this._finishListeners = new EventListenerList();
+        this._busyModel = new DelegatingValueModel().withDefault(false);
+    }
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    onDone(callback) {
+        this._doneListeners.add(callback);
+    }
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    onCancel(callback) {
+        this._cancelListeners.add(callback);
+    }
+    /**
+     * @param {?=} result
+     * @return {?}
+     */
+    done(result) {
+        return this._doneListeners
+            .fireAndWait((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l(result)))
+            .finally((/**
+         * @return {?}
+         */
+        () => this.finalizeAndDispose()));
+    }
+    /**
+     * @param {?=} error
+     * @return {?}
+     */
+    cancel(error) {
+        return this._cancelListeners
+            .fireAndWait((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l(error)))
+            .finally((/**
+         * @return {?}
+         */
+        () => this.finalizeAndDispose()));
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    finalizeAndDispose() {
+        // this._activeModel.value = false;
+        this._finishListeners.fire((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l()));
+        // this._interactionContext = null;
+        // this._initialized = false;
+        [
+            this._finishListeners,
+            this._doneListeners,
+            this._cancelListeners
+        ].forEach((/**
+         * @param {?} l
+         * @return {?}
+         */
+        l => l.dispose()));
+    }
+    /**
+     * @return {?}
+     */
+    get busy() {
+        return this._busyModel.readonly;
+    }
+    /**
+     * @param {?} busyModel
+     * @return {?}
+     */
+    busyWhile(busyModel) {
+        this._busyModel.setDelegate(busyModel);
+    }
+    /**
+     * @return {?}
+     */
+    isBusy() {
+        return this._busyModel.value;
+    }
+}
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._doneListeners;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._cancelListeners;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._finishListeners;
+    /**
+     * @type {?}
+     * @private
+     */
+    AbstractActivity.prototype._busyModel;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/interaction/activity.js

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { InjectionToken } from '@angular/core';
+/** @type {?} */
+export const ACTIVITY_DATA = new InjectionToken('InteractionActivityData');
+/**
+ * @record
+ * @template D, R, E
+ */
+export function Activity() { }
+if (false) {
+    /** @type {?} */
+    Activity.prototype.busy;
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    Activity.prototype.onDone = function (callback) { };
+    /**
+     * @param {?} callback
+     * @return {?}
+     */
+    Activity.prototype.onCancel = function (callback) { };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHkuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvaW50ZXJhY3Rpb24vYWN0aXZpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRy9DLE1BQU0sT0FBTyxhQUFhLEdBQUcsSUFBSSxjQUFjLENBQU0seUJBQXlCLENBQUM7Ozs7O0FBRS9FLDhCQU9DOzs7SUFOQyx3QkFBbUM7Ozs7O0lBRW5DLG9EQUF1Qzs7Ozs7SUFFdkMsc0RBQXlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFZhbHVlTW9kZWwgfSBmcm9tICdAY29vbG9uL3BlY3Rpbic7XG5cbmV4cG9ydCBjb25zdCBBQ1RJVklUWV9EQVRBID0gbmV3IEluamVjdGlvblRva2VuPGFueT4oJ0ludGVyYWN0aW9uQWN0aXZpdHlEYXRhJyk7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQWN0aXZpdHk8RCwgUiwgRSA9IGFueT4ge1xuICByZWFkb25seSBidXN5OiBWYWx1ZU1vZGVsPGJvb2xlYW4+O1xuXG4gIG9uRG9uZShjYWxsYmFjazogQWN0aXZpdHkuQ2FsbEJhY2s8Uj4pO1xuXG4gIG9uQ2FuY2VsKGNhbGxiYWNrOiBBY3Rpdml0eS5DYWxsQmFjazxFPik7XG5cbn1cblxuZXhwb3J0IG5hbWVzcGFjZSBBY3Rpdml0eSB7XG4gIGV4cG9ydCB0eXBlIENhbGxCYWNrPFQ+ID0gKHZhbHVlOiBUKSA9PiB2b2lkIHwgUHJvbWlzZTxhbnk+O1xufVxuIl19

package/esm2015/lib/interaction/alert.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ */
+export function Alert() { }
+if (false) {
+    /**
+     * @return {?}
+     */
+    Alert.prototype.title = function () { };
+    /**
+     * @return {?}
+     */
+    Alert.prototype.content = function () { };
+    /**
+     * @return {?}
+     */
+    Alert.prototype.ok = function () { };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvaW50ZXJhY3Rpb24vYWxlcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUNBLDJCQUlDOzs7OztJQUhHLHdDQUFnQjs7OztJQUNoQiwwQ0FBbUI7Ozs7SUFDbkIscUNBQVkiLCJzb3VyY2VzQ29udGVudCI6WyJcbmV4cG9ydCBpbnRlcmZhY2UgQWxlcnQge1xuICAgIHRpdGxlPygpOnN0cmluZztcbiAgICBjb250ZW50KCk6c3RyaW5nW107XG4gICAgb2soKTpzdHJpbmc7XG59XG4iXX0=

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

@@ -0,0 +1,144 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input, ViewChild } from '@angular/core';
+import { MatTabGroup } from '@angular/material';
+import { Dsl, MutableListModel } from '@coolon/pectin';
+import { Deferred } from '@coolon/pectin/lib/promise/deferred.class';
+import { DisposableComponent } from '../../../components/disposable-component';
+import { InteractionContext } from '../../interaction-context';
+import { AlertDialogComponent } from '../alert-dialog/alert-dialog.component';
+import { ConfirmationDialogComponent } from '../confirmation-dialog/confirmation-dialog.component';
+export class ActivityContainerComponent extends DisposableComponent {
+    constructor() {
+        super();
+        this.activityTabs = new MutableListModel();
+        this.obsoleteTabs = [];
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        const { observe } = Dsl.disposeWith(this);
+        observe.valuesFrom(this.tabs.animationDone).subscribe((/**
+         * @return {?}
+         */
+        () => this.cleanUpTabs()));
+    }
+    /**
+     * @template D, R, E
+     * @param {?} options
+     * @return {?}
+     */
+    initialise(options) {
+        this.initialActivity = Object.assign({}, options, { interactionContext: this });
+    }
+    /**
+     * @template D, R, E
+     * @param {?} activityType
+     * @param {?=} data
+     * @return {?}
+     */
+    startActivity(activityType, data) {
+        /** @type {?} */
+        const deferred = Deferred.defer();
+        /** @type {?} */
+        const context = {
+            interactionContext: this,
+            activityClass: activityType,
+            activityData: data,
+            onDone: deferred.resolve,
+            onCancel: deferred.reject
+        };
+        this.activityTabs.push(context);
+        this.tabs.selectedIndex = this.activityTabs.length;
+        return deferred.promise.finally((/**
+         * @return {?}
+         */
+        () => {
+            this.obsoleteTabs.push(context);
+            this.tabs.selectedIndex = this.activityTabs.length - 1;
+        }));
+    }
+    /**
+     * @param {?} alert
+     * @return {?}
+     */
+    alert(alert) {
+        return this.startActivity(AlertDialogComponent, alert);
+    }
+    /**
+     * @param {?} confirm
+     * @return {?}
+     */
+    confirm(confirm) {
+        return this.startActivity(ConfirmationDialogComponent, confirm);
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    cleanUpTabs() {
+        this.activityTabs.value = this.activityTabs.value.filter((/**
+         * @param {?} tab
+         * @return {?}
+         */
+        tab => {
+            return !this.obsoleteTabs.includes(tab);
+        }));
+    }
+}
+ActivityContainerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'angular-ui-powerups-activity-container',
+                template: "<mat-tab-group #tabs no-tab-header [dynamicHeight]=\"true\">\n  <mat-tab>\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\" [activityContext]=\"initialActivity\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n  <mat-tab *ngFor=\"let tab of activityTabs.value\">\n    <angular-ui-powerups-activity-outlet [interactionContext]=\"this\" [activityContext]=\"tab\"></angular-ui-powerups-activity-outlet>\n  </mat-tab>\n</mat-tab-group>\n",
+                styles: [":host{display:block}"]
+            }] }
+];
+/** @nocollapse */
+ActivityContainerComponent.ctorParameters = () => [];
+ActivityContainerComponent.propDecorators = {
+    parentInteractionContext: [{ type: Input }],
+    initialActivity: [{ type: Input }],
+    tabs: [{ type: ViewChild, args: ['tabs', { static: true },] }]
+};
+if (false) {
+    /** @type {?} */
+    ActivityContainerComponent.prototype.parentInteractionContext;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.initialActivity;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.tabs;
+    /** @type {?} */
+    ActivityContainerComponent.prototype.activityTabs;
+    /**
+     * @type {?}
+     * @private
+     */
+    ActivityContainerComponent.prototype.obsoleteTabs;
+}
+(function (ActivityContainerComponent) {
+    /**
+     * @record
+     * @template D, R, E
+     */
+    function ActivityContext() { }
+    ActivityContainerComponent.ActivityContext = ActivityContext;
+    if (false) {
+        /** @type {?} */
+        ActivityContext.prototype.activityClass;
+        /** @type {?} */
+        ActivityContext.prototype.activityData;
+        /** @type {?} */
+        ActivityContext.prototype.onDone;
+        /** @type {?} */
+        ActivityContext.prototype.onCancel;
+    }
+})(ActivityContainerComponent || (ActivityContainerComponent = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/interaction/components/activity-outlet/activity-outlet-context.js

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * @record
+ * @template D, R, E
+ */
+export function ActivityOutletContext() { }
+if (false) {
+    /** @type {?} */
+    ActivityOutletContext.prototype.interactionContext;
+    /** @type {?} */
+    ActivityOutletContext.prototype.activityClass;
+    /** @type {?} */
+    ActivityOutletContext.prototype.activityData;
+    /** @type {?} */
+    ActivityOutletContext.prototype.onDone;
+    /** @type {?} */
+    ActivityOutletContext.prototype.onCancel;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZpdHktb3V0bGV0LWNvbnRleHQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AY29vbG9uL2FuZ3VsYXItdWktcG93ZXJ1cHMvIiwic291cmNlcyI6WyJsaWIvaW50ZXJhY3Rpb24vY29tcG9uZW50cy9hY3Rpdml0eS1vdXRsZXQvYWN0aXZpdHktb3V0bGV0LWNvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFLQSwyQ0FNQzs7O0lBTEMsbURBQXVDOztJQUN2Qyw4Q0FBZ0Q7O0lBQ2hELDZDQUFnQjs7SUFDaEIsdUNBQTRCOztJQUM1Qix5Q0FBNkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25zdHJ1Y3RhYmxlIH0gZnJvbSAnQGNvb2xvbi9wZWN0aW4nO1xuaW1wb3J0IHsgQWN0aXZpdHkgfSBmcm9tICcuLi8uLi9hY3Rpdml0eSc7XG5pbXBvcnQgeyBJbnRlcmFjdGlvbkNvbnRleHQgfSBmcm9tICcuLi8uLi9pbnRlcmFjdGlvbi1jb250ZXh0JztcblxuXG5leHBvcnQgaW50ZXJmYWNlIEFjdGl2aXR5T3V0bGV0Q29udGV4dDxELCBSLCBFPiB7XG4gIGludGVyYWN0aW9uQ29udGV4dDogSW50ZXJhY3Rpb25Db250ZXh0LFxuICBhY3Rpdml0eUNsYXNzOiBDb25zdHJ1Y3RhYmxlPEFjdGl2aXR5PEQsIFIsIEU+PixcbiAgYWN0aXZpdHlEYXRhOiBELFxuICBvbkRvbmU6IChyZXN1bHQ6IFIpID0+IHZvaWQsXG4gIG9uQ2FuY2VsOiAoZXJyb3I6IEUpID0+IHZvaWQsXG59XG4iXX0=