@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/components/base/esm2022/widgets/common/partial-param/partial-param.directive.mjs

@@ -0,0 +1,88 @@
+import { Attribute, Directive, Inject, Self, Input } from '@angular/core';
+import { Subject } from 'rxjs';
+import { $watch } from '@wm/core';
+import { WidgetRef } from '../../framework/types';
+import { get } from "lodash-es";
+import * as i0 from "@angular/core";
+export class PartialParamHandlerDirective {
+    constructor(widgetRef) {
+        this.widgetRef = widgetRef;
+        this.widgetRef.partialParams = {};
+        this.widgetRef.pageParams = this.widgetRef.partialParams;
+        this.widgetRef.params$ = new Subject();
+    }
+    registerParams(name, value, bindExpr, type) {
+        this.widgetRef.partialParams[name] = value;
+        if (!value && bindExpr) {
+            this.widgetRef.registerDestroyListener(
+            //[Todo-CSP]: expr fn should be generated be default
+            $watch(bindExpr, this.widgetRef.getViewParent(), get(this.widgetRef, 'context'), nv => {
+                this.widgetRef.partialParams[name] = nv;
+                // notify the partial container of the param changes
+                this.widgetRef.params$.next();
+            }));
+        }
+        else {
+            this.widgetRef.params$.next();
+        }
+    }
+    ngOnDestroy() {
+        // MEMORY LEAK FIX: Complete the params$ Subject
+        if (this.widgetRef.params$) {
+            this.widgetRef.params$.complete();
+        }
+        // MEMORY LEAK FIX: Clear partial params
+        if (this.widgetRef.partialParams) {
+            Object.keys(this.widgetRef.partialParams).forEach(key => {
+                delete this.widgetRef.partialParams[key];
+            });
+            this.widgetRef.partialParams = null;
+        }
+        // Clear pageParams reference
+        this.widgetRef.pageParams = null;
+    }
+    static { this.ɵfac = function PartialParamHandlerDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || PartialParamHandlerDirective)(i0.ɵɵdirectiveInject(WidgetRef, 2)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PartialParamHandlerDirective, selectors: [["", "partialContainer", ""]], standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PartialParamHandlerDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[partialContainer]',
+            }]
+    }], () => [{ type: undefined, decorators: [{
+                type: Self
+            }, {
+                type: Inject,
+                args: [WidgetRef]
+            }] }], null); })();
+export class PartialParamDirective {
+    constructor(bindValue, type, partialParamsProvider) {
+        this.bindValue = bindValue;
+        this.type = type;
+        this.partialParamsProvider = partialParamsProvider;
+    }
+    ngOnInit() {
+        this.partialParamsProvider.registerParams(this.name, this.value, this.bindValue, this.type);
+    }
+    static { this.ɵfac = function PartialParamDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || PartialParamDirective)(i0.ɵɵinjectAttribute('value.bind'), i0.ɵɵinjectAttribute('type'), i0.ɵɵdirectiveInject(PartialParamHandlerDirective)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PartialParamDirective, selectors: [["", "wmParam", ""]], inputs: { name: "name", value: "value" }, standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PartialParamDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[wmParam]',
+            }]
+    }], () => [{ type: undefined, decorators: [{
+                type: Attribute,
+                args: ['value.bind']
+            }] }, { type: undefined, decorators: [{
+                type: Attribute,
+                args: ['type']
+            }] }, { type: PartialParamHandlerDirective }], { name: [{
+            type: Input
+        }], value: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGlhbC1wYXJhbS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL2Jhc2Uvc3JjL3dpZGdldHMvY29tbW9uL3BhcnRpYWwtcGFyYW0vcGFydGlhbC1wYXJhbS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQXFCLE1BQU0sZUFBZSxDQUFDO0FBRTdGLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFL0IsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUVsQyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDbEQsT0FBTyxFQUFDLEdBQUcsRUFBQyxNQUFNLFdBQVcsQ0FBQzs7QUFNOUIsTUFBTSxPQUFPLDRCQUE0QjtJQUNyQyxZQUFnRCxTQUFTO1FBQVQsY0FBUyxHQUFULFNBQVMsQ0FBQTtRQUNyRCxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsR0FBRyxFQUFFLENBQUM7UUFDbEMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUM7UUFDekQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEdBQUcsSUFBSSxPQUFPLEVBQUUsQ0FBQztJQUMzQyxDQUFDO0lBRUQsY0FBYyxDQUFDLElBQVksRUFBRSxLQUFhLEVBQUUsUUFBZ0IsRUFBRSxJQUFZO1FBQ3RFLElBQUksQ0FBQyxTQUFTLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxHQUFHLEtBQUssQ0FBQztRQUMzQyxJQUFJLENBQUMsS0FBSyxJQUFJLFFBQVEsRUFBRSxDQUFDO1lBQ3JCLElBQUksQ0FBQyxTQUFTLENBQUMsdUJBQXVCO1lBQ2xDLG9EQUFvRDtZQUNwRCxNQUFNLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsYUFBYSxFQUFFLEVBQUUsR0FBRyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsU0FBUyxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUU7Z0JBQ2xGLElBQUksQ0FBQyxTQUFTLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztnQkFFeEMsb0RBQW9EO2dCQUNwRCxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUNsQyxDQUFDLENBQUMsQ0FDTCxDQUFDO1FBQ04sQ0FBQzthQUFNLENBQUM7WUFDSixJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNsQyxDQUFDO0lBRUwsQ0FBQztJQUVELFdBQVc7UUFDUCxnREFBZ0Q7UUFDaEQsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ3pCLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3RDLENBQUM7UUFFRCx3Q0FBd0M7UUFDeEMsSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQy9CLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUU7Z0JBQ3BELE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDN0MsQ0FBQyxDQUFDLENBQUM7WUFDSCxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsR0FBRyxJQUFJLENBQUM7UUFDeEMsQ0FBQztRQUVELDZCQUE2QjtRQUM3QixJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUM7SUFDckMsQ0FBQzs2SEF6Q1EsNEJBQTRCLHVCQUNSLFNBQVM7b0VBRDdCLDRCQUE0Qjs7aUZBQTVCLDRCQUE0QjtjQUp4QyxTQUFTO2VBQUM7Z0JBQ1QsVUFBVSxFQUFFLElBQUk7Z0JBQ2QsUUFBUSxFQUFFLG9CQUFvQjthQUNqQzs7c0JBRWlCLElBQUk7O3NCQUFJLE1BQU07dUJBQUMsU0FBUzs7QUErQzFDLE1BQU0sT0FBTyxxQkFBcUI7SUFLOUIsWUFDb0MsU0FBUyxFQUNmLElBQUksRUFDdEIscUJBQW1EO1FBRjNCLGNBQVMsR0FBVCxTQUFTLENBQUE7UUFDZixTQUFJLEdBQUosSUFBSSxDQUFBO1FBQ3RCLDBCQUFxQixHQUFyQixxQkFBcUIsQ0FBOEI7SUFFL0QsQ0FBQztJQUVELFFBQVE7UUFDSixJQUFJLENBQUMscUJBQXFCLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsU0FBUyxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNoRyxDQUFDO3NIQWRRLHFCQUFxQix1QkFNZixZQUFZLHdCQUNaLE1BQU07b0VBUFoscUJBQXFCOztpRkFBckIscUJBQXFCO2NBSmpDLFNBQVM7ZUFBQztnQkFDUCxVQUFVLEVBQUUsSUFBSTtnQkFDaEIsUUFBUSxFQUFFLFdBQVc7YUFDeEI7O3NCQU9RLFNBQVM7dUJBQUMsWUFBWTs7c0JBQ3RCLFNBQVM7dUJBQUMsTUFBTTs2REFMWixJQUFJO2tCQUFaLEtBQUs7WUFDRyxLQUFLO2tCQUFiLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBdHRyaWJ1dGUsIERpcmVjdGl2ZSwgSW5qZWN0LCBTZWxmLCBJbnB1dCwgT25EZXN0cm95LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyAkd2F0Y2ggfSBmcm9tICdAd20vY29yZSc7XG5cbmltcG9ydCB7IFdpZGdldFJlZiB9IGZyb20gJy4uLy4uL2ZyYW1ld29yay90eXBlcyc7XG5pbXBvcnQge2dldH0gZnJvbSBcImxvZGFzaC1lc1wiO1xuXG5ARGlyZWN0aXZlKHtcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBzZWxlY3RvcjogJ1twYXJ0aWFsQ29udGFpbmVyXScsXG59KVxuZXhwb3J0IGNsYXNzIFBhcnRpYWxQYXJhbUhhbmRsZXJEaXJlY3RpdmUgaW1wbGVtZW50cyBPbkRlc3Ryb3kge1xuICAgIGNvbnN0cnVjdG9yIChAU2VsZigpIEBJbmplY3QoV2lkZ2V0UmVmKSBwcml2YXRlIHdpZGdldFJlZikge1xuICAgICAgICB0aGlzLndpZGdldFJlZi5wYXJ0aWFsUGFyYW1zID0ge307XG4gICAgICAgIHRoaXMud2lkZ2V0UmVmLnBhZ2VQYXJhbXMgPSB0aGlzLndpZGdldFJlZi5wYXJ0aWFsUGFyYW1zO1xuICAgICAgICB0aGlzLndpZGdldFJlZi5wYXJhbXMkID0gbmV3IFN1YmplY3QoKTtcbiAgICB9XG5cbiAgICByZWdpc3RlclBhcmFtcyhuYW1lOiBzdHJpbmcsIHZhbHVlOiBzdHJpbmcsIGJpbmRFeHByOiBzdHJpbmcsIHR5cGU6IHN0cmluZykge1xuICAgICAgICB0aGlzLndpZGdldFJlZi5wYXJ0aWFsUGFyYW1zW25hbWVdID0gdmFsdWU7XG4gICAgICAgIGlmICghdmFsdWUgJiYgYmluZEV4cHIpIHtcbiAgICAgICAgICAgIHRoaXMud2lkZ2V0UmVmLnJlZ2lzdGVyRGVzdHJveUxpc3RlbmVyKFxuICAgICAgICAgICAgICAgIC8vW1RvZG8tQ1NQXTogZXhwciBmbiBzaG91bGQgYmUgZ2VuZXJhdGVkIGJlIGRlZmF1bHRcbiAgICAgICAgICAgICAgICAkd2F0Y2goYmluZEV4cHIsIHRoaXMud2lkZ2V0UmVmLmdldFZpZXdQYXJlbnQoKSwgZ2V0KHRoaXMud2lkZ2V0UmVmLCAnY29udGV4dCcpLCBudiA9PiB7XG4gICAgICAgICAgICAgICAgICAgIHRoaXMud2lkZ2V0UmVmLnBhcnRpYWxQYXJhbXNbbmFtZV0gPSBudjtcblxuICAgICAgICAgICAgICAgICAgICAvLyBub3RpZnkgdGhlIHBhcnRpYWwgY29udGFpbmVyIG9mIHRoZSBwYXJhbSBjaGFuZ2VzXG4gICAgICAgICAgICAgICAgICAgIHRoaXMud2lkZ2V0UmVmLnBhcmFtcyQubmV4dCgpO1xuICAgICAgICAgICAgICAgIH0pXG4gICAgICAgICAgICApO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgdGhpcy53aWRnZXRSZWYucGFyYW1zJC5uZXh0KCk7XG4gICAgICAgIH1cblxuICAgIH1cblxuICAgIG5nT25EZXN0cm95KCkge1xuICAgICAgICAvLyBNRU1PUlkgTEVBSyBGSVg6IENvbXBsZXRlIHRoZSBwYXJhbXMkIFN1YmplY3RcbiAgICAgICAgaWYgKHRoaXMud2lkZ2V0UmVmLnBhcmFtcyQpIHtcbiAgICAgICAgICAgIHRoaXMud2lkZ2V0UmVmLnBhcmFtcyQuY29tcGxldGUoKTtcbiAgICAgICAgfVxuXG4gICAgICAgIC8vIE1FTU9SWSBMRUFLIEZJWDogQ2xlYXIgcGFydGlhbCBwYXJhbXNcbiAgICAgICAgaWYgKHRoaXMud2lkZ2V0UmVmLnBhcnRpYWxQYXJhbXMpIHtcbiAgICAgICAgICAgIE9iamVjdC5rZXlzKHRoaXMud2lkZ2V0UmVmLnBhcnRpYWxQYXJhbXMpLmZvckVhY2goa2V5ID0+IHtcbiAgICAgICAgICAgICAgICBkZWxldGUgdGhpcy53aWRnZXRSZWYucGFydGlhbFBhcmFtc1trZXldO1xuICAgICAgICAgICAgfSk7XG4gICAgICAgICAgICB0aGlzLndpZGdldFJlZi5wYXJ0aWFsUGFyYW1zID0gbnVsbDtcbiAgICAgICAgfVxuXG4gICAgICAgIC8vIENsZWFyIHBhZ2VQYXJhbXMgcmVmZXJlbmNlXG4gICAgICAgIHRoaXMud2lkZ2V0UmVmLnBhZ2VQYXJhbXMgPSBudWxsO1xuICAgIH1cbn1cblxuQERpcmVjdGl2ZSh7XG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBzZWxlY3RvcjogJ1t3bVBhcmFtXScsXG59KVxuZXhwb3J0IGNsYXNzIFBhcnRpYWxQYXJhbURpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCB7XG5cbiAgICBASW5wdXQoKSBuYW1lOiBzdHJpbmc7XG4gICAgQElucHV0KCkgdmFsdWU6IGFueTtcblxuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBAQXR0cmlidXRlKCd2YWx1ZS5iaW5kJykgcHVibGljIGJpbmRWYWx1ZSxcbiAgICAgICAgQEF0dHJpYnV0ZSgndHlwZScpIHB1YmxpYyB0eXBlLFxuICAgICAgICBwcml2YXRlIHBhcnRpYWxQYXJhbXNQcm92aWRlcjogUGFydGlhbFBhcmFtSGFuZGxlckRpcmVjdGl2ZVxuICAgICkge1xuICAgIH1cblxuICAgIG5nT25Jbml0KCkge1xuICAgICAgICB0aGlzLnBhcnRpYWxQYXJhbXNQcm92aWRlci5yZWdpc3RlclBhcmFtcyh0aGlzLm5hbWUsIHRoaXMudmFsdWUsIHRoaXMuYmluZFZhbHVlLCB0aGlzLnR5cGUpO1xuICAgIH1cbn1cbiJdfQ==

package/components/base/esm2022/widgets/common/pull-to-refresh/pull-to-refresh.mjs

@@ -0,0 +1,261 @@
+import { SwipeAnimation } from '@swipey';
+import { isIos, setCSS } from '@wm/core';
+export class PullToRefresh extends SwipeAnimation {
+    constructor($el, app, onPullToRefresh) {
+        super();
+        this.$el = $el;
+        this.app = app;
+        this.onPullToRefresh = onPullToRefresh;
+        this.count = 0;
+        const template = '<div class="refresh-container"></div>';
+        this.$el.prepend(template);
+        this.infoContainer = this.$el.find('.refresh-container');
+        if (isIos()) {
+            this.infoContainer.addClass('ios-refresh-container');
+        }
+        this.init(this.$el);
+    }
+    threshold() {
+        return 10;
+    }
+    direction() {
+        return $.fn.swipey.DIRECTIONS.VERTICAL;
+    }
+    subscribe() {
+        // Subscribing for variable updates, wait till the response and stop the animation.
+        this.cancelSubscription = this.app.subscribe('toggle-variable-state', (data) => {
+            // data.active is true means the variable update has just started whereas false means update has ended.
+            if (data.active && this.animationInProgress) {
+                this.count++;
+                this.wait();
+            }
+            else if (this.count > 0) {
+                this.count--;
+            }
+            // call stop animation only when animation has started.
+            if (!this.count && this.animationInProgress) {
+                this.stopAnimation();
+            }
+        });
+    }
+    bounds($event, $d) {
+        const pageIscroll = this.$el[0].iscroll;
+        // If scroll position is not at the top of the page then do not trigger the animation.
+        if ($d < 0 || (pageIscroll && !isNaN(pageIscroll.y) && pageIscroll.y !== 0)) {
+            return {
+                lower: undefined,
+                upper: undefined
+            };
+        }
+        if (!this.spinner) {
+            this.spinner = isIos() ? new IOSSpinner(this.infoContainer) : new AndroidSpinner(this.infoContainer);
+            this.subscribe();
+        }
+        return {
+            lower: 0,
+            center: 0,
+            upper: isIos() ? 0 : 150,
+            strict: !isIos()
+        };
+    }
+    context() {
+        this.infoContainer.show();
+        if (isIos()) {
+            this.infoContainer.addClass('entry');
+        }
+        return {
+            spin: $d => {
+                this.spinner.setRotation($d * 2);
+            }
+        };
+    }
+    animation() {
+        if (isIos()) {
+            return {
+                css: {
+                    transform: 'translate3d(0, ${{$D + $d}}px, 0)',
+                    spin: '${{spin($d)}}'
+                }
+            };
+        }
+        return {
+            target: this.infoContainer,
+            css: {
+                transform: 'translate3d(0, ${{$D + $d}}px, 0)',
+                spin: '${{spin($d)}}',
+                opacity: '${{min(($D + $d) / 100, 1)}}'
+            }
+        };
+    }
+    // Start the spinner animation and invokes the pulltorefresh event. Stops the animation after the wait time.
+    onAnimation() {
+        this.animationInProgress = true;
+        this.spinner.start();
+        if (this.onPullToRefresh) {
+            this.onPullToRefresh();
+        }
+        setTimeout(() => {
+            // if listenToAnimation is set, then wait for stopAnimation to be invoked. Otherwise call stopAnimation manually.
+            if (this.runAnimation) {
+                return;
+            }
+            this.stopAnimation();
+        });
+    }
+    stopAnimation() {
+        setTimeout(() => {
+            this.runAnimation = false;
+            this.animationInProgress = false;
+            this.spinner.stop();
+            this.infoContainer.hide();
+            setCSS(this.infoContainer[0], 'transform', 'none');
+            if (!isIos()) {
+                setCSS(this.infoContainer[0], 'opacity', 0);
+            }
+            this.infoContainer.removeClass('entry');
+        }, 800);
+    }
+    wait() {
+        this.runAnimation = true;
+    }
+    destroy() {
+        // Unsubscribe from app events
+        if (this.cancelSubscription) {
+            this.cancelSubscription();
+            this.cancelSubscription = null;
+        }
+        // Stop any running animation
+        if (this.animationInProgress) {
+            this.stopAnimation();
+        }
+        // Clean up spinner
+        if (this.spinner) {
+            this.spinner.stop();
+            this.spinner = null;
+        }
+        // Remove DOM elements
+        if (this.infoContainer) {
+            this.infoContainer.remove();
+            this.infoContainer = null;
+        }
+    }
+}
+// Android Spinner implementation
+class AndroidSpinner {
+    constructor($el, options) {
+        this.$el = $el;
+        this.options = options || {};
+    }
+    polarToCartesian(centerX, centerY, radius, angleInDegrees) {
+        const angleInRadians = (angleInDegrees - 90) * Math.PI / 180.0;
+        return {
+            x: centerX + (radius * Math.cos(angleInRadians)),
+            y: centerY + (radius * Math.sin(angleInRadians))
+        };
+    }
+    describeArc(x, y, radius, startAngle, endAngle) {
+        const start = this.polarToCartesian(x, y, radius, endAngle);
+        const end = this.polarToCartesian(x, y, radius, startAngle);
+        const arcSweep = endAngle - startAngle <= 180 ? '0' : '1';
+        return [
+            'M', start.x, start.y,
+            'A', radius, radius, 0, arcSweep, 0, end.x, end.y,
+            'L', end.x, end.y
+        ].join(' ');
+    }
+    init() {
+        if (this.initialized) {
+            return;
+        }
+        // append the svg to the element on which spinner has to be shown.
+        const androidTemplate = $('<svg><path id="arc1"/></svg>');
+        const container = $('<div class="android-spinner"></div>');
+        container.append(androidTemplate);
+        this.$el.append(container);
+        this.cx = container.outerWidth() / 2;
+        this.cy = container.outerHeight() / 2;
+        this.r = this.cx * 0.6;
+        this.path = container.find('path');
+        this.initialized = true;
+        this.container = container;
+    }
+    // sets rotation to the path
+    setRotation(deg) {
+        this.init();
+        this.path.attr('d', this.describeArc(this.cx, this.cy, this.r, 0, deg));
+    }
+    // animate the path to rotate continuously with some interval
+    start() {
+        this.init();
+        const self = this, totalTime = this.options.time || 1800, degreesToTraverse = 10;
+        let i = 0;
+        this.container.addClass('spin');
+        this.intervalId = setInterval(() => {
+            let deg;
+            i = i + degreesToTraverse;
+            if (i > 720) {
+                deg = i = 0;
+            }
+            else if (i > 360) {
+                deg = 720 - i;
+            }
+            else {
+                deg = i;
+            }
+            self.path.attr('d', this.describeArc(self.cx, self.cy, self.r, 0, deg));
+        }, (totalTime * degreesToTraverse / 360));
+    }
+    // Removes the animation by clearing the intervals
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = 0;
+        }
+        this.container.removeClass('spin');
+    }
+}
+// iOS spinner implementation
+class IOSSpinner {
+    constructor($el) {
+        this.$el = $el;
+    }
+    // create the iOS spinner using svg
+    init() {
+        if (this.svg) {
+            return;
+        }
+        const container = $('<div class="ios-spinner"><svg></svg></div>');
+        const svg = container.find('svg');
+        this.$el.append(container);
+        const d = container.width();
+        for (let i = 0; i < 12; i++) {
+            svg[0].innerHTML += `<line y1="${0.15 * d}" y2="${0.3 * d}"
+                                    transform="translate(${0.5 * d}, ${0.5 * d}) rotate(${i * 30})">
+                                </line>`;
+        }
+        container.append(svg);
+        this.svg = svg;
+    }
+    // Sets the svg to rotate depending on "d" value
+    setRotation(d) {
+        this.init();
+        this.svg.css('transform', `rotateZ( ${Math.round(d / 30) * 30}deg)`);
+    }
+    // Triggers the rotation with some interval
+    start() {
+        this.init();
+        let i = 0;
+        this.intervalId = setInterval(() => {
+            i += 10;
+            this.setRotation(i);
+        }, 20);
+    }
+    // Removes the animation by clearing the intervals
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = 0;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pull-to-refresh.js","sourceRoot":"","sources":["../../../../../../../projects/components/base/src/widgets/common/pull-to-refresh/pull-to-refresh.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC,OAAO,EAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAI9C,MAAM,OAAO,aAAc,SAAQ,cAAc;IAQ7C,YAAoB,GAAwB,EAAU,GAAQ,EAAU,eAA2B;QAC/F,KAAK,EAAE,CAAC;QADQ,QAAG,GAAH,GAAG,CAAqB;QAAU,QAAG,GAAH,GAAG,CAAK;QAAU,oBAAe,GAAf,eAAe,CAAY;QAL3F,UAAK,GAAG,CAAC,CAAC;QAOd,MAAM,QAAQ,GAAG,uCAAuC,CAAC;QACzD,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAC3B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAEzD,IAAI,KAAK,EAAE,EAAE,CAAC;YACV,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IAEM,SAAS;QACZ,OAAO,EAAE,CAAC;IACd,CAAC;IAEM,SAAS;QACZ,OAAO,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC;IAC3C,CAAC;IAEO,SAAS;QACb,mFAAmF;QACnF,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,uBAAuB,EAAE,CAAC,IAAI,EAAE,EAAE;YAC3E,uGAAuG;YACvG,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC1C,IAAI,CAAC,KAAK,EAAE,CAAC;gBACb,IAAI,CAAC,IAAI,EAAE,CAAC;YAChB,CAAC;iBAAM,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;gBACxB,IAAI,CAAC,KAAK,EAAE,CAAC;YACjB,CAAC;YACD,uDAAuD;YACvD,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC1C,IAAI,CAAC,aAAa,EAAE,CAAC;YACzB,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,MAAM,CAAC,MAAM,EAAE,EAAE;QACpB,MAAM,WAAW,GAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAS,CAAC,OAAO,CAAC;QACjD,sFAAsF;QACtF,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YAC1E,OAAO;gBACH,KAAK,EAAE,SAAS;gBAChB,KAAK,EAAE,SAAS;aACnB,CAAC;QACN,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAChB,IAAI,CAAC,OAAO,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACrG,IAAI,CAAC,SAAS,EAAE,CAAC;QACrB,CAAC;QAED,OAAO;YACH,KAAK,EAAE,CAAC;YACR,MAAM,EAAE,CAAC;YACT,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG;YACxB,MAAM,EAAE,CAAC,KAAK,EAAE;SACnB,CAAC;IACN,CAAC;IAEM,OAAO;QACV,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;QAC1B,IAAI,KAAK,EAAE,EAAE,CAAC;YACV,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACzC,CAAC;QACD,OAAO;YACH,IAAI,EAAE,EAAE,CAAC,EAAE;gBACP,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;YACrC,CAAC;SACJ,CAAC;IACN,CAAC;IAEM,SAAS;QACZ,IAAI,KAAK,EAAE,EAAE,CAAC;YACV,OAAO;gBACH,GAAG,EAAE;oBACD,SAAS,EAAE,mCAAmC;oBAC9C,IAAI,EAAE,eAAe;iBACxB;aACJ,CAAC;QACN,CAAC;QACD,OAAO;YACH,MAAM,EAAE,IAAI,CAAC,aAAa;YAC1B,GAAG,EAAE;gBACD,SAAS,EAAE,mCAAmC;gBAC9C,IAAI,EAAE,eAAe;gBACrB,OAAO,EAAE,8BAA8B;aAC1C;SACJ,CAAC;IACN,CAAC;IAED,4GAA4G;IACrG,WAAW;QACd,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,EAAE,CAAC;QAC3B,CAAC;QAED,UAAU,CAAC,GAAG,EAAE;YACZ,iHAAiH;YACjH,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACpB,OAAO;YACX,CAAC;YACD,IAAI,CAAC,aAAa,EAAE,CAAC;QACzB,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,aAAa;QAChB,UAAU,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YACjC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACpB,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;YAC1B,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;YACnD,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;gBACX,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YAChD,CAAC;YACD,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC5C,CAAC,EAAE,GAAG,CAAC,CAAC;IACZ,CAAC;IAEM,IAAI;QACP,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC7B,CAAC;IAEM,OAAO;QACV,8BAA8B;QAC9B,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QACnC,CAAC;QAED,6BAA6B;QAC7B,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,IAAI,CAAC,aAAa,EAAE,CAAC;QACzB,CAAC;QAED,mBAAmB;QACnB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACxB,CAAC;QAED,sBAAsB;QACtB,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC;YAC5B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC9B,CAAC;IACL,CAAC;CACJ;AASD,iCAAiC;AACjC,MAAM,cAAc;IAUhB,YAAoB,GAAwB,EAAE,OAAgB;QAA1C,QAAG,GAAH,GAAG,CAAqB;QACxC,IAAI,CAAC,OAAO,GAAG,OAAO,IAAI,EAAE,CAAC;IACjC,CAAC;IAGO,gBAAgB,CAAC,OAAe,EAAE,OAAe,EAAE,MAAc,EAAE,cAAsB;QAC7F,MAAM,cAAc,GAAG,CAAC,cAAc,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,KAAK,CAAC;QAC/D,OAAO;YACH,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;YAChD,CAAC,EAAE,OAAO,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;SACnD,CAAC;IACN,CAAC;IAEO,WAAW,CAAC,CAAS,EAAE,CAAS,EAAE,MAAc,EAAE,UAAkB,EAAE,QAAgB;QAE1F,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QAC5D,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;QAE5D,MAAM,QAAQ,GAAG,QAAQ,GAAG,UAAU,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;QAE1D,OAAO;YACH,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YACrB,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YACjD,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;SACpB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;IAEM,IAAI;QACP,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO;QACX,CAAC;QACD,kEAAkE;QAClE,MAAM,eAAe,GAAG,CAAC,CAAC,8BAA8B,CAAC,CAAC;QAC1D,MAAM,SAAS,GAAG,CAAC,CAAC,qCAAqC,CAAC,CAAC;QAC3D,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAClC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC3B,IAAI,CAAC,EAAE,GAAG,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;QACrC,IAAI,CAAC,EAAE,GAAG,SAAS,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,GAAG,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC/B,CAAC;IAED,4BAA4B;IACrB,WAAW,CAAC,GAAG;QAClB,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,6DAA6D;IACtD,KAAK;QACR,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,MAAM,IAAI,GAAG,IAAI,EACb,SAAS,GAAI,IAAI,CAAC,OAA6B,CAAC,IAAI,IAAI,IAAI,EAC5D,iBAAiB,GAAG,EAAE,CAAC;QAC3B,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAChC,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE;YAC/B,IAAI,GAAG,CAAC;YACR,CAAC,GAAG,CAAC,GAAG,iBAAiB,CAAC;YAC1B,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;gBACV,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;YAChB,CAAC;iBAAM,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC;gBACjB,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;YAClB,CAAC;iBAAM,CAAC;gBACJ,GAAG,GAAG,CAAC,CAAC;YACZ,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QAC5E,CAAC,EAAE,CAAC,SAAS,GAAG,iBAAiB,GAAG,GAAG,CAAC,CAAC,CAAC;IAC9C,CAAC;IAED,kDAAkD;IAC3C,IAAI;QACP,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/B,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;QACxB,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;CACJ;AAED,6BAA6B;AAC7B,MAAM,UAAU;IAIZ,YAAoB,GAAG;QAAH,QAAG,GAAH,GAAG,CAAA;IAAG,CAAC;IAE3B,mCAAmC;IAC3B,IAAI;QACR,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACX,OAAO;QACX,CAAC;QACD,MAAM,SAAS,GAAG,CAAC,CAAC,4CAA4C,CAAC,CAAC;QAClE,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC3B,MAAM,CAAC,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC;QAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1B,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,aAAa,IAAI,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC;2DACV,GAAG,GAAG,CAAC,KAAK,GAAG,GAAG,CAAC,YAAY,CAAC,GAAG,EAAE;wCACxD,CAAC;QACjC,CAAC;QACD,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACnB,CAAC;IAED,gDAAgD;IACzC,WAAW,CAAC,CAAS;QACxB,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,YAAY,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACzE,CAAC;IAED,2CAA2C;IACpC,KAAK;QACR,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,IAAI,CAAC,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE;YAC/B,CAAC,IAAI,EAAE,CAAC;YACR,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACxB,CAAC,EAAE,EAAE,CAAC,CAAC;IACX,CAAC;IAED,kDAAkD;IAC3C,IAAI;QACP,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC/B,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;QACxB,CAAC;IACL,CAAC;CACJ","sourcesContent":["import { SwipeAnimation } from '@swipey';\n\nimport { App, isIos, setCSS } from '@wm/core';\n\ndeclare const $;\n\nexport class PullToRefresh extends SwipeAnimation {\n    private infoContainer: JQuery<HTMLElement>;\n    private runAnimation: boolean;\n    private count = 0;\n    private spinner: Spinner;\n    public cancelSubscription: () => void;\n    private animationInProgress: boolean;\n\n    constructor(private $el: JQuery<HTMLElement>, private app: App, private onPullToRefresh: () => void) {\n        super();\n        const template = '<div class=\"refresh-container\"></div>';\n        this.$el.prepend(template);\n        this.infoContainer = this.$el.find('.refresh-container');\n\n        if (isIos()) {\n            this.infoContainer.addClass('ios-refresh-container');\n        }\n\n        this.init(this.$el);\n    }\n\n    public threshold() {\n        return 10;\n    }\n\n    public direction() {\n        return $.fn.swipey.DIRECTIONS.VERTICAL;\n    }\n\n    private subscribe() {\n        // Subscribing for variable updates, wait till the response and stop the animation.\n        this.cancelSubscription = this.app.subscribe('toggle-variable-state', (data) => {\n            // data.active is true means the variable update has just started whereas false means update has ended.\n            if (data.active && this.animationInProgress) {\n                this.count++;\n                this.wait();\n            } else if (this.count > 0) {\n                this.count--;\n            }\n            // call stop animation only when animation has started.\n            if (!this.count && this.animationInProgress) {\n                this.stopAnimation();\n            }\n        });\n    }\n\n    public bounds($event, $d) {\n        const pageIscroll = (this.$el[0] as any).iscroll;\n        // If scroll position is not at the top of the page then do not trigger the animation.\n        if ($d < 0 || (pageIscroll && !isNaN(pageIscroll.y) && pageIscroll.y !== 0)) {\n            return {\n                lower: undefined,\n                upper: undefined\n            };\n        }\n        if (!this.spinner) {\n            this.spinner = isIos() ? new IOSSpinner(this.infoContainer) : new AndroidSpinner(this.infoContainer);\n            this.subscribe();\n        }\n\n        return {\n            lower: 0,\n            center: 0,\n            upper: isIos() ? 0 : 150,\n            strict: !isIos()\n        };\n    }\n\n    public context(): object {\n        this.infoContainer.show();\n        if (isIos()) {\n            this.infoContainer.addClass('entry');\n        }\n        return {\n            spin: $d => {\n                this.spinner.setRotation($d * 2);\n            }\n        };\n    }\n\n    public animation() {\n        if (isIos()) {\n            return {\n                css: {\n                    transform: 'translate3d(0, ${{$D + $d}}px, 0)',\n                    spin: '${{spin($d)}}'\n                }\n            };\n        }\n        return {\n            target: this.infoContainer,\n            css: {\n                transform: 'translate3d(0, ${{$D + $d}}px, 0)',\n                spin: '${{spin($d)}}',\n                opacity: '${{min(($D + $d) / 100, 1)}}'\n            }\n        };\n    }\n\n    // Start the spinner animation and invokes the pulltorefresh event. Stops the animation after the wait time.\n    public onAnimation() {\n        this.animationInProgress = true;\n        this.spinner.start();\n        if (this.onPullToRefresh) {\n            this.onPullToRefresh();\n        }\n\n        setTimeout(() => {\n            // if listenToAnimation is set, then wait for stopAnimation to be invoked. Otherwise call stopAnimation manually.\n            if (this.runAnimation) {\n                return;\n            }\n            this.stopAnimation();\n        });\n    }\n\n    public stopAnimation() {\n        setTimeout(() => {\n            this.runAnimation = false;\n            this.animationInProgress = false;\n            this.spinner.stop();\n            this.infoContainer.hide();\n            setCSS(this.infoContainer[0], 'transform', 'none');\n            if (!isIos()) {\n                setCSS(this.infoContainer[0], 'opacity', 0);\n            }\n            this.infoContainer.removeClass('entry');\n        }, 800);\n    }\n\n    public wait() {\n        this.runAnimation = true;\n    }\n\n    public destroy() {\n        // Unsubscribe from app events\n        if (this.cancelSubscription) {\n            this.cancelSubscription();\n            this.cancelSubscription = null;\n        }\n        \n        // Stop any running animation\n        if (this.animationInProgress) {\n            this.stopAnimation();\n        }\n        \n        // Clean up spinner\n        if (this.spinner) {\n            this.spinner.stop();\n            this.spinner = null;\n        }\n        \n        // Remove DOM elements\n        if (this.infoContainer) {\n            this.infoContainer.remove();\n            this.infoContainer = null;\n        }\n    }\n}\n\n// Interface for Spinner\ninterface Spinner {\n    start();\n    stop();\n    setRotation(d: number);\n}\n\n// Android Spinner implementation\nclass AndroidSpinner implements Spinner {\n    private options: object;\n    private initialized: boolean;\n    private cx: number;\n    private cy: number;\n    private r: number;\n    private path: JQuery<SVGPathElement>;\n    private intervalId;\n    private container: JQuery<HTMLElement>;\n\n    constructor(private $el: JQuery<HTMLElement>, options?: object) {\n        this.options = options || {};\n    }\n\n\n    private polarToCartesian(centerX: number, centerY: number, radius: number, angleInDegrees: number): { x: number, y: number } {\n        const angleInRadians = (angleInDegrees - 90) * Math.PI / 180.0;\n        return {\n            x: centerX + (radius * Math.cos(angleInRadians)),\n            y: centerY + (radius * Math.sin(angleInRadians))\n        };\n    }\n\n    private describeArc(x: number, y: number, radius: number, startAngle: number, endAngle: number): string {\n\n        const start = this.polarToCartesian(x, y, radius, endAngle);\n        const end = this.polarToCartesian(x, y, radius, startAngle);\n\n        const arcSweep = endAngle - startAngle <= 180 ? '0' : '1';\n\n        return [\n            'M', start.x, start.y,\n            'A', radius, radius, 0, arcSweep, 0, end.x, end.y,\n            'L', end.x, end.y\n        ].join(' ');\n    }\n\n    public init(): void {\n        if (this.initialized) {\n            return;\n        }\n        // append the svg to the element on which spinner has to be shown.\n        const androidTemplate = $('<svg><path id=\"arc1\"/></svg>');\n        const container = $('<div class=\"android-spinner\"></div>');\n        container.append(androidTemplate);\n        this.$el.append(container);\n        this.cx = container.outerWidth() / 2;\n        this.cy = container.outerHeight() / 2;\n        this.r = this.cx * 0.6;\n        this.path = container.find('path');\n        this.initialized = true;\n        this.container = container;\n    }\n\n    // sets rotation to the path\n    public setRotation(deg) {\n        this.init();\n        this.path.attr('d', this.describeArc(this.cx, this.cy, this.r, 0, deg));\n    }\n\n    // animate the path to rotate continuously with some interval\n    public start() {\n        this.init();\n        const self = this,\n            totalTime = (this.options as { time?: number }).time || 1800,\n            degreesToTraverse = 10;\n        let i = 0;\n        this.container.addClass('spin');\n        this.intervalId = setInterval(() => {\n            let deg;\n            i = i + degreesToTraverse;\n            if (i > 720) {\n                deg = i = 0;\n            } else if (i > 360) {\n                deg = 720 - i;\n            } else {\n                deg = i;\n            }\n            self.path.attr('d', this.describeArc(self.cx, self.cy, self.r, 0, deg));\n        }, (totalTime * degreesToTraverse / 360));\n    }\n\n    // Removes the animation by clearing the intervals\n    public stop() {\n        if (this.intervalId) {\n            clearInterval(this.intervalId);\n            this.intervalId = 0;\n        }\n        this.container.removeClass('spin');\n    }\n}\n\n// iOS spinner implementation\nclass IOSSpinner implements Spinner {\n    private svg: JQuery<SVGElement>;\n    private intervalId: any;\n\n    constructor(private $el) {}\n\n    // create the iOS spinner using svg\n    private init() {\n        if (this.svg) {\n            return;\n        }\n        const container = $('<div class=\"ios-spinner\"><svg></svg></div>');\n        const svg = container.find('svg');\n        this.$el.append(container);\n        const d = container.width();\n        for (let i = 0; i < 12; i++) {\n            svg[0].innerHTML += `<line y1=\"${0.15 * d}\" y2=\"${0.3 * d}\"\n                                    transform=\"translate(${0.5 * d}, ${0.5 * d}) rotate(${i * 30})\">\n                                </line>`;\n        }\n        container.append(svg);\n        this.svg = svg;\n    }\n\n    // Sets the svg to rotate depending on \"d\" value\n    public setRotation(d: number): void {\n        this.init();\n        this.svg.css('transform', `rotateZ( ${Math.round(d / 30) * 30}deg)`);\n    }\n\n    // Triggers the rotation with some interval\n    public start() {\n        this.init();\n        let i = 0;\n        this.intervalId = setInterval(() => {\n            i += 10;\n            this.setRotation(i);\n        }, 20);\n    }\n\n    // Removes the animation by clearing the intervals\n    public stop() {\n        if (this.intervalId) {\n            clearInterval(this.intervalId);\n            this.intervalId = 0;\n        }\n    }\n}\n"]}

package/components/base/esm2022/widgets/common/redraw/redrawable.directive.mjs

@@ -0,0 +1,40 @@
+import { Directive, Inject, Self } from '@angular/core';
+import { WidgetRef } from '../../framework/types';
+import * as i0 from "@angular/core";
+export class RedrawableDirective {
+    constructor(widget) {
+        this.redraw = () => {
+            const tabEl = widget.$element.closest("[wmtabpane]");
+            const accordionEl = widget.$element.closest('[wmaccordionpane]').find('.panel-heading');
+            if ((tabEl.length && !tabEl.hasClass('active')) || (accordionEl.length && !accordionEl.hasClass('active'))) {
+                return;
+            }
+            if (widget.widgetType.startsWith('wm-prefab')) {
+                Object.entries(widget.Widgets || {}).forEach(([key, innerWidget]) => {
+                    if (typeof innerWidget.redraw === 'function') {
+                        innerWidget.redraw();
+                    }
+                });
+                return;
+            }
+            else {
+                return widget.redraw && widget.redraw();
+            }
+        };
+    }
+    static { this.ɵfac = function RedrawableDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || RedrawableDirective)(i0.ɵɵdirectiveInject(WidgetRef, 2)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: RedrawableDirective, selectors: [["", "redrawable", ""]], standalone: true }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RedrawableDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[redrawable]'
+            }]
+    }], () => [{ type: undefined, decorators: [{
+                type: Self
+            }, {
+                type: Inject,
+                args: [WidgetRef]
+            }] }], null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVkcmF3YWJsZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL2Jhc2Uvc3JjL3dpZGdldHMvY29tbW9uL3JlZHJhdy9yZWRyYXdhYmxlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFdEQsT0FBTyxFQUF1QixTQUFTLEVBQUMsTUFBTSx1QkFBdUIsQ0FBQzs7QUFNdEUsTUFBTSxPQUFPLG1CQUFtQjtJQUU1QixZQUF1QyxNQUFNO1FBQ3pDLElBQUksQ0FBQyxNQUFNLEdBQUcsR0FBRyxFQUFFO1lBQ2YsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLENBQUM7WUFDckQsTUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztZQUN4RixJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLElBQUksQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDLEVBQUUsQ0FBQztnQkFDekcsT0FBTztZQUNYLENBQUM7WUFDRCxJQUFJLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUM7Z0JBQzVDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxXQUFXLENBQWdCLEVBQUUsRUFBRTtvQkFDL0UsSUFBSSxPQUFPLFdBQVcsQ0FBQyxNQUFNLEtBQUssVUFBVSxFQUFFLENBQUM7d0JBQzNDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsQ0FBQztvQkFDekIsQ0FBQztnQkFDTCxDQUFDLENBQUMsQ0FBQztnQkFDSCxPQUFNO1lBQ1YsQ0FBQztpQkFBTSxDQUFDO2dCQUNSLE9BQU8sTUFBTSxDQUFDLE1BQU0sSUFBSSxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDeEMsQ0FBQztRQUNMLENBQUMsQ0FBQTtJQUNMLENBQUM7b0hBcEJRLG1CQUFtQix1QkFFQSxTQUFTO29FQUY1QixtQkFBbUI7O2lGQUFuQixtQkFBbUI7Y0FKL0IsU0FBUztlQUFDO2dCQUNULFVBQVUsRUFBRSxJQUFJO2dCQUNkLFFBQVEsRUFBRSxjQUFjO2FBQzNCOztzQkFHZ0IsSUFBSTs7c0JBQUksTUFBTTt1QkFBQyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIEluamVjdCwgU2VsZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7SVJlZHJhd2FibGVDb21wb25lbnQsIFdpZGdldFJlZn0gZnJvbSAnLi4vLi4vZnJhbWV3b3JrL3R5cGVzJztcblxuQERpcmVjdGl2ZSh7XG4gIHN0YW5kYWxvbmU6IHRydWUsXG4gICAgc2VsZWN0b3I6ICdbcmVkcmF3YWJsZV0nXG59KVxuZXhwb3J0IGNsYXNzIFJlZHJhd2FibGVEaXJlY3RpdmUgaW1wbGVtZW50cyBJUmVkcmF3YWJsZUNvbXBvbmVudCB7XG4gICAgcmVkcmF3OiBGdW5jdGlvbjtcbiAgICBjb25zdHJ1Y3RvcihAU2VsZigpIEBJbmplY3QoV2lkZ2V0UmVmKSB3aWRnZXQpIHtcbiAgICAgICAgdGhpcy5yZWRyYXcgPSAoKSA9PiB7XG4gICAgICAgICAgICBjb25zdCB0YWJFbCA9IHdpZGdldC4kZWxlbWVudC5jbG9zZXN0KFwiW3dtdGFicGFuZV1cIik7XG4gICAgICAgICAgICBjb25zdCBhY2NvcmRpb25FbCA9IHdpZGdldC4kZWxlbWVudC5jbG9zZXN0KCdbd21hY2NvcmRpb25wYW5lXScpLmZpbmQoJy5wYW5lbC1oZWFkaW5nJyk7XG4gICAgICAgICAgICBpZiAoKHRhYkVsLmxlbmd0aCAmJiAhdGFiRWwuaGFzQ2xhc3MoJ2FjdGl2ZScpKSB8fCAoYWNjb3JkaW9uRWwubGVuZ3RoICYmICFhY2NvcmRpb25FbC5oYXNDbGFzcygnYWN0aXZlJykpKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgaWYgKHdpZGdldC53aWRnZXRUeXBlLnN0YXJ0c1dpdGgoJ3dtLXByZWZhYicpKSB7XG4gICAgICAgICAgICAgICAgT2JqZWN0LmVudHJpZXMod2lkZ2V0LldpZGdldHMgfHwge30pLmZvckVhY2goKFtrZXksIGlubmVyV2lkZ2V0XTogW3N0cmluZywgYW55XSkgPT4ge1xuICAgICAgICAgICAgICAgICAgICBpZiAodHlwZW9mIGlubmVyV2lkZ2V0LnJlZHJhdyA9PT0gJ2Z1bmN0aW9uJykge1xuICAgICAgICAgICAgICAgICAgICAgICAgaW5uZXJXaWRnZXQucmVkcmF3KCk7XG4gICAgICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgICAgICByZXR1cm5cbiAgICAgICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICByZXR1cm4gd2lkZ2V0LnJlZHJhdyAmJiB3aWRnZXQucmVkcmF3KCk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICB9XG59XG4iXX0=

package/components/base/esm2022/widgets/common/repeat-template/repeat-template.directive.mjs

@@ -0,0 +1,33 @@
+import { Directive, Inject, Injector, Optional } from '@angular/core';
+import { StylableComponent } from '../base/stylable.component';
+import { registerProps } from './repeat-template.props';
+import { styler } from '../../framework/styler';
+import * as i0 from "@angular/core";
+const DEFAULT_CLS = 'app-repeat-item';
+const WIDGET_CONFIG = {
+    widgetType: 'wm-repeat-template',
+    hostClass: DEFAULT_CLS
+};
+export class RepeatTemplateDirective extends StylableComponent {
+    static { this.initializeProps = registerProps(); }
+    constructor(inj, explicitContext) {
+        super(inj, WIDGET_CONFIG, explicitContext);
+        styler(this.nativeElement, this);
+    }
+    static { this.ɵfac = function RepeatTemplateDirective_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || RepeatTemplateDirective)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject('EXPLICIT_CONTEXT', 8)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: RepeatTemplateDirective, selectors: [["", "wmRepeatTemplate", ""]], exportAs: ["repeatItemRef"], standalone: true, features: [i0.ɵɵInheritDefinitionFeature] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RepeatTemplateDirective, [{
+        type: Directive,
+        args: [{
+                standalone: true,
+                selector: '[wmRepeatTemplate]',
+                exportAs: 'repeatItemRef'
+            }]
+    }], () => [{ type: i0.Injector }, { type: undefined, decorators: [{
+                type: Inject,
+                args: ['EXPLICIT_CONTEXT']
+            }, {
+                type: Optional
+            }] }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/components/base/esm2022/widgets/common/repeat-template/repeat-template.props.mjs

@@ -0,0 +1,7 @@
+import { PROP_BOOLEAN, register } from '../../framework/widget-props';
+export const registerProps = () => {
+    register('wm-repeat-template', new Map([
+        ['show', PROP_BOOLEAN]
+    ]));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVwZWF0LXRlbXBsYXRlLnByb3BzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy9iYXNlL3NyYy93aWRnZXRzL2NvbW1vbi9yZXBlYXQtdGVtcGxhdGUvcmVwZWF0LXRlbXBsYXRlLnByb3BzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsUUFBUSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFdEUsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLEdBQUcsRUFBRTtJQUM5QixRQUFRLENBQ0osb0JBQW9CLEVBQ3BCLElBQUksR0FBRyxDQUNIO1FBQ0ksQ0FBQyxNQUFNLEVBQUUsWUFBWSxDQUFDO0tBQ3pCLENBQ0osQ0FDSixDQUFDO0FBQ04sQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUFJPUF9CT09MRUFOLCByZWdpc3RlciB9IGZyb20gJy4uLy4uL2ZyYW1ld29yay93aWRnZXQtcHJvcHMnO1xuXG5leHBvcnQgY29uc3QgcmVnaXN0ZXJQcm9wcyA9ICgpID0+IHtcbiAgICByZWdpc3RlcihcbiAgICAgICAgJ3dtLXJlcGVhdC10ZW1wbGF0ZScsXG4gICAgICAgIG5ldyBNYXAoXG4gICAgICAgICAgICBbXG4gICAgICAgICAgICAgICAgWydzaG93JywgUFJPUF9CT09MRUFOXVxuICAgICAgICAgICAgXVxuICAgICAgICApXG4gICAgKTtcbn07XG4iXX0=

package/components/base/esm2022/widgets/framework/constants.mjs

@@ -0,0 +1,36 @@
+export const EVENTS_MAP = new Map([
+    // ['enterkeypress', 'keypress.enter']
+    ['tap', 'click']
+]);
+// TODO: Implement touch events for the mobile
+export const DISPLAY_TYPE = {
+    BLOCK: 'block',
+    INLINE_BLOCK: 'inline-block',
+    INLINE: 'inline'
+};
+// set of boolean attrs
+const BOOLEAN_ATTRS = new Set([
+    'readonly', 'autofocus', 'disabled', 'startchecked', 'multiple',
+    'selected', 'required', 'controls', 'autoplay', 'loop', 'muted', 'show'
+]);
+/**
+ * Returns true if the provided key is a boolean attribute
+ * @param {string} key
+ * @returns {boolean}
+ */
+export const isBooleanAttr = (key) => BOOLEAN_ATTRS.has(key);
+const DIMENSION_PROPS = new Set([
+    'width',
+    'height',
+    'iconheight',
+    'iconwidth',
+    'popoverwidth',
+    'popoverheight',
+    'imagewidth',
+    'imageheight'
+]);
+export const isDimensionProp = (key) => DIMENSION_PROPS.has(key);
+export const DEBOUNCE_TIMES = {
+    PAGINATION_DEBOUNCE_TIME: 250
+};
+//# sourceMappingURL=data:application/json;base64,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