@coolon/angular-ui-powerups 0.0.26 → 0.0.27

package/esm2015/lib/directives/command.directive.js

@@ -0,0 +1,135 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Directive, ElementRef, HostListener, Inject, Input } from '@angular/core';
+import { assert, Dsl, GarbageCollector, lang, UnaryCommand } from '@coolon/pectin';
+/**
+ * @template P
+ */
+export class CommandDirective extends GarbageCollector {
+    /**
+     * @param {?} elementRef
+     */
+    constructor(elementRef) {
+        super();
+        this.elementRef = elementRef;
+        this._commandParameterProvided = false;
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    set commandParameter(value) {
+        this._commandParameterProvided = true;
+        this._commandParameter = value;
+    }
+    /**
+     * @return {?}
+     */
+    get commandParameter() {
+        return this._commandParameter;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        assert.notNil(this.pectinCommand);
+        if (this.pectinCommand instanceof UnaryCommand) {
+            if (!this._commandParameterProvided) {
+                lang.illegalState('UnaryCommands required the command parameter to be specified.');
+            }
+        }
+        else {
+            if (this._commandParameterProvided) {
+                lang.illegalState('command parameters are only supported by UnaryCommands');
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        // for some reason mat-buttons kills the disabled host binding.  It works on a regular button but for now
+        // we need to do this.
+        const { chain } = Dsl.disposeWith(this);
+        chain(this.pectinCommand.enabled).subscribe((/**
+         * @param {?} enabled
+         * @return {?}
+         */
+        enabled => {
+            if (enabled) {
+                this.elementRef.nativeElement.removeAttribute('disabled');
+                if (this.elementRef.nativeElement.tagName === 'A') {
+                    this.elementRef.nativeElement.setAttribute('href', 'javascript:void');
+                }
+            }
+            else {
+                this.elementRef.nativeElement.setAttribute('disabled', 'disabled');
+                if (this.elementRef.nativeElement.tagName === 'A') {
+                    this.elementRef.nativeElement.removeAttribute('href');
+                }
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.dispose();
+    }
+    /**
+     * @param {?} $event
+     * @return {?}
+     */
+    notifyClick($event) {
+        $event.preventDefault();
+        $event.stopPropagation();
+        if (this.pectinCommand.enabled.value) {
+            if (this.pectinCommand instanceof UnaryCommand) {
+                this.pectinCommand.withContext({ event: $event }).execute(this.commandParameter);
+            }
+            else {
+                this.pectinCommand.withContext({ event: $event }).execute();
+            }
+        }
+        else {
+            console.warn('disabled command clicked, ignoring.');
+        }
+    }
+}
+CommandDirective.decorators = [
+    { type: Directive, args: [{
+                // tslint:disable-next-line:directive-selector
+                selector: '[pectinCommand]'
+            },] }
+];
+/** @nocollapse */
+CommandDirective.ctorParameters = () => [
+    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] }
+];
+CommandDirective.propDecorators = {
+    pectinCommand: [{ type: Input }],
+    commandParameter: [{ type: Input }],
+    notifyClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+if (false) {
+    /** @type {?} */
+    CommandDirective.prototype.pectinCommand;
+    /**
+     * @type {?}
+     * @private
+     */
+    CommandDirective.prototype._commandParameter;
+    /**
+     * @type {?}
+     * @private
+     */
+    CommandDirective.prototype._commandParameterProvided;
+    /**
+     * @type {?}
+     * @private
+     */
+    CommandDirective.prototype.elementRef;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,179 @@
+/**
+ * @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() {
+        if (this.hasBinding()) {
+            this.pectinFocusBinding.focusContext.notifyFocusIn();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    onFocusOut() {
+        if (this.hasBinding()) {
+            this.pectinFocusBinding.focusContext.notifyFocusOut();
+        }
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        // TODO: Make this also track the current enabled/disabled state.
+        if (this.hasBinding()) {
+            const { chain } = Dsl.disposeWith(this);
+            chain(this.pectinFocusBinding.focusContext.focused).subscribe((/**
+             * @param {?} focused
+             * @return {?}
+             */
+            (focused) => {
+                if (focused && !this.alreadyHasFocus()) {
+                    this.tryAndFocus();
+                }
+            }));
+        }
+        else {
+            Logger.get(this).warn("pectinFocusBinding was nil");
+        }
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    hasBinding() {
+        return !!this.pectinFocusBinding && !!this.pectinFocusBinding.focusContext;
+    }
+    // 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.hasBinding() && this.pectinFocusBinding.focusContext.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,{"version":3,"file":"focus-binding.directive.js","sourceRoot":"ng://@coolon/angular-ui-powerups/","sources":["lib/directives/focus-binding.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {DOCUMENT} from '@angular/common';\nimport {AfterViewInit, Directive, ElementRef, HostListener, Inject, Input, NgZone, OnInit} from '@angular/core';\nimport {Dsl, HasFocusTracking, Logger} from '@coolon/pectin';\nimport {DisposableComponent} from '../components/disposable-component';\n\n\n@Directive({\n  // tslint:disable-next-line:directive-selector\n  selector: '[pectinFocusBinding]'\n})\nexport class FocusBindingDirective extends DisposableComponent implements OnInit, AfterViewInit {\n\n  private readonly document: Document;\n\n  @Input() pectinFocusBinding: HasFocusTracking;\n  @Input() focusBindingTarget: HTMLElement;\n\n  @HostListener('focusin')\n  onFocusIn() {\n    if (this.hasBinding()) {\n      this.pectinFocusBinding.focusContext.notifyFocusIn();\n    }\n  }\n\n  @HostListener('focusout')\n  onFocusOut() {\n    if (this.hasBinding()) {\n      this.pectinFocusBinding.focusContext.notifyFocusOut();\n    }\n  }\n\n  constructor(@Inject(ElementRef) private readonly el: ElementRef,\n              @Inject(NgZone) private readonly ngZone: NgZone,\n              @Inject(DOCUMENT) document: any) {\n    super();\n    // @see https://stackoverflow.com/questions/49513359/could-not-resolve-type-document-in-angular5/53715642#53715642\n    this.document = document as Document;\n  }\n\n  ngOnInit(): void {\n  }\n\n  ngAfterViewInit(): void {\n    // TODO: Make this also track the current enabled/disabled state.\n    if (this.hasBinding()) {\n      const {chain} = Dsl.disposeWith(this);\n      chain(this.pectinFocusBinding.focusContext.focused).subscribe((focused) => {\n        if (focused && !this.alreadyHasFocus()) {\n          this.tryAndFocus();\n        }\n      });\n    } else {\n      Logger.get(this).warn(\"pectinFocusBinding was nil\");\n    }\n  }\n\n  private hasBinding() {\n    return !!this.pectinFocusBinding && !!this.pectinFocusBinding.focusContext;\n  }\n\n// Hook method for debugging via tracing.\n  alreadyHasFocus() {\n    return this.isFocused(this.focusTarget);\n  }\n\n  // Hook method for debugging via tracing.\n  isFocused(element: Element): boolean {\n    return this.document.activeElement === element;\n  }\n\n  tryAndFocus(retries: number = 5) {\n    if (this.modelShouldStillHaveFocus() && this.canFocus()) {\n      if (!this.alreadyHasFocus()) {\n        this.focusTarget.focus();\n      }\n      // if we didn't get the focus we try again later.\n      if (!this.alreadyHasFocus()) {\n        Logger.get(this).log(`focus failed, trying ${retries} more times`);\n        if (retries > 0) {\n          // try again on the next paint\n          // TODO: is there an angular way of doing this without calling a window function.\n          requestAnimationFrame(() => {\n            this.tryAndFocus(retries - 1);\n          });\n        } else {\n          Logger.get(this).warn(`Tried to focus but gave up as the component wasn't enabled or visible.`);\n        }\n      }\n    }\n  }\n\n  get focusTarget(): HTMLElement {\n    return this.focusBindingTarget || this.el.nativeElement;\n  }\n\n  // Hook method for debugging via tracing.\n  modelShouldStillHaveFocus() {\n    return this.hasBinding() && this.pectinFocusBinding.focusContext.focused.value;\n  }\n\n  // Hook method for debugging via tracing.\n  canFocus(): boolean {\n    const dimension = this.focusTarget.getBoundingClientRect();\n    const hasSize = dimension.height >= 0 && dimension.height >= 0;\n    // tslint:disable-next-line:no-string-literal\n    return hasSize && !this.focusTarget['disabled'];\n  }\n}\n"]}

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=