@nativescript-community/ui-pager 13.0.32 → 13.0.35

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [13.0.35](https://github.com/nativescript-community/ui-pager/compare/v13.0.34...v13.0.35) (2022-03-15)
+
+**Note:** Version bump only for package @nativescript-community/ui-pager
+
+
+
+
+
+## [13.0.34](https://github.com/nativescript-community/ui-pager/compare/v13.0.33...v13.0.34) (2022-01-19)
+
+**Note:** Version bump only for package @nativescript-community/ui-pager
+
+
+
+
+
+## [13.0.33](https://github.com/nativescript-community/ui-pager/compare/v13.0.32...v13.0.33) (2021-11-17)
+
+**Note:** Version bump only for package @nativescript-community/ui-pager
+
+
+
+
+
 ## [13.0.32](https://github.com/nativescript-community/ui-pager/compare/v13.0.31...v13.0.32) (2021-11-15)
 
 

package/angular/esm2020/index.mjs

@@ -0,0 +1,55 @@
+import { ChangeDetectionStrategy, Component, ElementRef, IterableDiffers, NO_ERRORS_SCHEMA, NgModule, forwardRef } from '@angular/core';
+import { Pager } from '@nativescript-community/ui-pager';
+import { PagerItemDirective, TEMPLATED_ITEMS_COMPONENT, TemplateKeyDirective, TemplatedItemsComponent } from './pager-items-comp';
+import * as i0 from "@angular/core";
+export { PagerItemDirective, TemplatedItemsComponent, TemplateKeyDirective } from './pager-items-comp';
+export class PagerComponent extends TemplatedItemsComponent {
+    constructor(_elementRef, _iterableDiffers) {
+        super(_elementRef, _iterableDiffers);
+    }
+    get nativeElement() {
+        return this.templatedItemsView;
+    }
+}
+PagerComponent.ɵfac = function PagerComponent_Factory(t) { return new (t || PagerComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.IterableDiffers)); };
+PagerComponent.ɵcmp = i0.ɵɵdefineComponent({ type: PagerComponent, selectors: [["Pager"]], features: [i0.ɵɵProvidersFeature([
+            {
+                provide: TEMPLATED_ITEMS_COMPONENT,
+                useExisting: forwardRef(() => PagerComponent)
+            }
+        ]), i0.ɵɵInheritDefinitionFeature], decls: 3, vars: 0, consts: [["loader", ""]], template: function PagerComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "DetachedContainer");
+        i0.ɵɵelement(1, "Placeholder", null, 0);
+        i0.ɵɵelementEnd();
+    } }, encapsulation: 2, changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PagerComponent, [{
+        type: Component,
+        args: [{
+                selector: 'Pager',
+                template: ` <DetachedContainer>
+        <Placeholder #loader></Placeholder>
+    </DetachedContainer>`,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                providers: [
+                    {
+                        provide: TEMPLATED_ITEMS_COMPONENT,
+                        useExisting: forwardRef(() => PagerComponent)
+                    }
+                ]
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.IterableDiffers }]; }, null); })();
+export class PagerModule {
+}
+PagerModule.ɵfac = function PagerModule_Factory(t) { return new (t || PagerModule)(); };
+PagerModule.ɵmod = i0.ɵɵdefineNgModule({ type: PagerModule });
+PagerModule.ɵinj = i0.ɵɵdefineInjector({});
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PagerModule, [{
+        type: NgModule,
+        args: [{
+                declarations: [PagerComponent, TemplateKeyDirective, PagerItemDirective],
+                exports: [PagerComponent, TemplateKeyDirective, PagerItemDirective],
+                schemas: [NO_ERRORS_SCHEMA]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PagerModule, { declarations: [PagerComponent, TemplateKeyDirective, PagerItemDirective], exports: [PagerComponent, TemplateKeyDirective, PagerItemDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdWktcGFnZXIvYW5ndWxhci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsZ0JBQWdCLEVBQUUsUUFBUSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV4SSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDekQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLHlCQUF5QixFQUFFLG9CQUFvQixFQUFFLHVCQUF1QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7O0FBRWxJLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSx1QkFBdUIsRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBZXZHLE1BQU0sT0FBTyxjQUFlLFNBQVEsdUJBQXVCO0lBT3ZELFlBQVksV0FBdUIsRUFBRSxnQkFBaUM7UUFDbEUsS0FBSyxDQUFDLFdBQVcsRUFBRSxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFSRCxJQUFXLGFBQWE7UUFDcEIsT0FBTyxJQUFJLENBQUMsa0JBQWtCLENBQUM7SUFDbkMsQ0FBQzs7NEVBSFEsY0FBYzttREFBZCxjQUFjLDJEQVBaO1lBQ1A7Z0JBQ0ksT0FBTyxFQUFFLHlCQUF5QjtnQkFDbEMsV0FBVyxFQUFFLFVBQVUsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxjQUFjLENBQUM7YUFDaEQ7U0FDSjtRQVRXLHlDQUFtQjtRQUMzQix1Q0FBbUM7UUFDdkMsaUJBQW9COzt1RkFTWCxjQUFjO2NBYjFCLFNBQVM7ZUFBQztnQkFDUCxRQUFRLEVBQUUsT0FBTztnQkFDakIsUUFBUSxFQUFFOzt5QkFFVztnQkFDckIsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07Z0JBQy9DLFNBQVMsRUFBRTtvQkFDUDt3QkFDSSxPQUFPLEVBQUUseUJBQXlCO3dCQUNsQyxXQUFXLEVBQUUsVUFBVSxDQUFDLEdBQUcsRUFBRSxlQUFlLENBQUM7cUJBQ2hEO2lCQUNKO2FBQ0o7O0FBa0JELE1BQU0sT0FBTyxXQUFXOztzRUFBWCxXQUFXOytDQUFYLFdBQVc7O3VGQUFYLFdBQVc7Y0FMdkIsUUFBUTtlQUFDO2dCQUNOLFlBQVksRUFBRSxDQUFDLGNBQWMsRUFBRSxvQkFBb0IsRUFBRSxrQkFBa0IsQ0FBQztnQkFDeEUsT0FBTyxFQUFFLENBQUMsY0FBYyxFQUFFLG9CQUFvQixFQUFFLGtCQUFrQixDQUFDO2dCQUNuRSxPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQzthQUM5Qjs7d0ZBQ1ksV0FBVyxtQkFqQlgsY0FBYyxFQWFRLG9CQUFvQixFQUFFLGtCQUFrQixhQWI5RCxjQUFjLEVBY0csb0JBQW9CLEVBQUUsa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksIENvbXBvbmVudCwgRWxlbWVudFJlZiwgSXRlcmFibGVEaWZmZXJzLCBOT19FUlJPUlNfU0NIRU1BLCBOZ01vZHVsZSwgZm9yd2FyZFJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBQYWdlciB9IGZyb20gJ0BuYXRpdmVzY3JpcHQtY29tbXVuaXR5L3VpLXBhZ2VyJztcbmltcG9ydCB7IFBhZ2VySXRlbURpcmVjdGl2ZSwgVEVNUExBVEVEX0lURU1TX0NPTVBPTkVOVCwgVGVtcGxhdGVLZXlEaXJlY3RpdmUsIFRlbXBsYXRlZEl0ZW1zQ29tcG9uZW50IH0gZnJvbSAnLi9wYWdlci1pdGVtcy1jb21wJztcblxuZXhwb3J0IHsgUGFnZXJJdGVtRGlyZWN0aXZlLCBUZW1wbGF0ZWRJdGVtc0NvbXBvbmVudCwgVGVtcGxhdGVLZXlEaXJlY3RpdmUgfSBmcm9tICcuL3BhZ2VyLWl0ZW1zLWNvbXAnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ1BhZ2VyJyxcbiAgICB0ZW1wbGF0ZTogYCA8RGV0YWNoZWRDb250YWluZXI+XG4gICAgICAgIDxQbGFjZWhvbGRlciAjbG9hZGVyPjwvUGxhY2Vob2xkZXI+XG4gICAgPC9EZXRhY2hlZENvbnRhaW5lcj5gLFxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICAgIHByb3ZpZGVyczogW1xuICAgICAgICB7XG4gICAgICAgICAgICBwcm92aWRlOiBURU1QTEFURURfSVRFTVNfQ09NUE9ORU5ULFxuICAgICAgICAgICAgdXNlRXhpc3Rpbmc6IGZvcndhcmRSZWYoKCkgPT4gUGFnZXJDb21wb25lbnQpXG4gICAgICAgIH1cbiAgICBdXG59KVxuZXhwb3J0IGNsYXNzIFBhZ2VyQ29tcG9uZW50IGV4dGVuZHMgVGVtcGxhdGVkSXRlbXNDb21wb25lbnQge1xuICAgIHB1YmxpYyBnZXQgbmF0aXZlRWxlbWVudCgpOiBQYWdlciB7XG4gICAgICAgIHJldHVybiB0aGlzLnRlbXBsYXRlZEl0ZW1zVmlldztcbiAgICB9XG5cbiAgICBwcm90ZWN0ZWQgdGVtcGxhdGVkSXRlbXNWaWV3OiBQYWdlcjtcblxuICAgIGNvbnN0cnVjdG9yKF9lbGVtZW50UmVmOiBFbGVtZW50UmVmLCBfaXRlcmFibGVEaWZmZXJzOiBJdGVyYWJsZURpZmZlcnMpIHtcbiAgICAgICAgc3VwZXIoX2VsZW1lbnRSZWYsIF9pdGVyYWJsZURpZmZlcnMpO1xuICAgIH1cbn1cblxuQE5nTW9kdWxlKHtcbiAgICBkZWNsYXJhdGlvbnM6IFtQYWdlckNvbXBvbmVudCwgVGVtcGxhdGVLZXlEaXJlY3RpdmUsIFBhZ2VySXRlbURpcmVjdGl2ZV0sXG4gICAgZXhwb3J0czogW1BhZ2VyQ29tcG9uZW50LCBUZW1wbGF0ZUtleURpcmVjdGl2ZSwgUGFnZXJJdGVtRGlyZWN0aXZlXSxcbiAgICBzY2hlbWFzOiBbTk9fRVJST1JTX1NDSEVNQV1cbn0pXG5leHBvcnQgY2xhc3MgUGFnZXJNb2R1bGUge31cbiJdfQ==

package/angular/esm2020/pager-items-comp.mjs

@@ -0,0 +1,304 @@
+import { Component, ContentChild, Directive, ElementRef, EmbeddedViewRef, EventEmitter, Host, Inject, InjectionToken, Input, IterableDiffers, Output, TemplateRef, ViewChild, ViewContainerRef, ɵisListLikeIterable as isListLikeIterable } from '@angular/core';
+import { Pager, PagerError, PagerItem, PagerLog } from '@nativescript-community/ui-pager';
+import { extractSingleViewRecursive, isInvisibleNode, registerElement } from '@nativescript/angular';
+import { LayoutBase, Trace, View, isIOS } from '@nativescript/core';
+import { ObservableArray } from '@nativescript/core/data/observable-array';
+import { profile } from '@nativescript/core/profiling';
+import * as i0 from "@angular/core";
+const _c0 = ["loader"];
+registerElement('Pager', () => Pager);
+registerElement('PagerItem', () => PagerItem);
+const NG_VIEW = '_ngViewRef';
+export class ItemContext {
+    constructor($implicit, item, index, even, odd) {
+        this.$implicit = $implicit;
+        this.item = item;
+        this.index = index;
+        this.even = even;
+        this.odd = odd;
+    }
+}
+export class TemplatedItemsComponent {
+    constructor(_elementRef, _iterableDiffers) {
+        this._iterableDiffers = _iterableDiffers;
+        this.setupItemView = new EventEmitter();
+        this.templatedItemsView = _elementRef.nativeElement;
+        this.templatedItemsView.on('itemLoading', this.onItemLoading, this);
+        this.templatedItemsView.on('itemDisposing', this.onItemDisposing, this);
+    }
+    get items() {
+        return this._items;
+    }
+    set items(value) {
+        this._items = value;
+        let needDiffer = true;
+        if (value instanceof ObservableArray) {
+            needDiffer = false;
+        }
+        if (needDiffer && !this._differ && isListLikeIterable(value)) {
+            this._differ = this._iterableDiffers.find(this._items).create((_index, item) => item);
+        }
+        this.templatedItemsView.items = this._items;
+    }
+    get selectedIndex() {
+        return this._selectedIndex;
+    }
+    set selectedIndex(value) {
+        this._selectedIndex = value;
+        this.templatedItemsView.selectedIndex = this._selectedIndex;
+    }
+    ngAfterViewInit() {
+        if (!!this._selectedIndex) {
+            setTimeout(() => {
+                if (isIOS) {
+                    this.templatedItemsView.scrollToIndexAnimated(this._selectedIndex, false);
+                }
+                this.templatedItemsView.selectedIndex = this._selectedIndex;
+            });
+        }
+    }
+    ngAfterContentInit() {
+        if (Trace.isEnabled()) {
+            PagerLog('TemplatedItemsView.ngAfterContentInit()');
+        }
+        this.setItemTemplates();
+    }
+    ngOnDestroy() {
+        this.templatedItemsView.off('itemLoading', this.onItemLoading, this);
+        this.templatedItemsView.off('itemDisposing', this.onItemDisposing, this);
+    }
+    setItemTemplates() {
+        if (!this.items)
+            return;
+        this.itemTemplate = this.itemTemplateQuery;
+        if (this._templateMap) {
+            if (Trace.isEnabled()) {
+                PagerLog('Setting templates');
+            }
+            const templates = [];
+            this._templateMap.forEach((value) => {
+                templates.push(value);
+            });
+            this.templatedItemsView.itemTemplates = templates;
+        }
+    }
+    registerTemplate(key, template) {
+        if (Trace.isEnabled()) {
+            PagerLog(`registerTemplate for key: ${key}`);
+        }
+        if (!this._templateMap) {
+            this._templateMap = new Map();
+        }
+        const keyedTemplate = {
+            key,
+            createView: this.getItemTemplateViewFactory(template)
+        };
+        this._templateMap.set(key, keyedTemplate);
+    }
+    onItemLoading(args) {
+        if (!args.view && !this.itemTemplate) {
+            return;
+        }
+        if (!this.items)
+            return;
+        const index = args.index;
+        const items = args.object.items;
+        const currentItem = typeof items.getItem === 'function' ? items.getItem(index) : items[index];
+        let viewRef;
+        if (args.view) {
+            if (Trace.isEnabled()) {
+                PagerLog(`onItemLoading: ${index} - Reusing existing view`);
+            }
+            viewRef = args.view[NG_VIEW];
+            if (!viewRef && args.view instanceof LayoutBase && args.view.getChildrenCount() > 0) {
+                viewRef = args.view.getChildAt(0)[NG_VIEW];
+            }
+            if (!viewRef && Trace.isEnabled()) {
+                PagerError(`ViewReference not found for item ${index}. View recycling is not working`);
+            }
+        }
+        if (!viewRef) {
+            if (Trace.isEnabled()) {
+                PagerLog(`onItemLoading: ${index} - Creating view from template`);
+            }
+            viewRef = this.loader.createEmbeddedView(this.itemTemplate, new ItemContext(), 0);
+            args.view = getItemViewRoot(viewRef);
+            args.view[NG_VIEW] = viewRef;
+        }
+        this.setupViewRef(viewRef, currentItem, index);
+        this.detectChangesOnChild(viewRef, index);
+    }
+    onItemDisposing(args) {
+        if (!args.view) {
+            return;
+        }
+        let viewRef;
+        if (args.view) {
+            if (Trace.isEnabled()) {
+                PagerLog(`onItemDisposing: ${args.index} - Removing angular view`);
+            }
+            viewRef = args.view[NG_VIEW];
+            if (!viewRef && args.view instanceof LayoutBase && args.view.getChildrenCount() > 0) {
+                viewRef = args.view.getChildAt(0)[NG_VIEW];
+            }
+            if (!viewRef && Trace.isEnabled()) {
+                PagerError(`ViewReference not found for item ${args.index}. View disposing is not working`);
+            }
+        }
+        if (viewRef) {
+            if (Trace.isEnabled()) {
+                PagerLog(`onItemDisposing: ${args.index} - Disposing view reference`);
+            }
+            viewRef.destroy();
+        }
+    }
+    setupViewRef(viewRef, data, index) {
+        const context = viewRef.context;
+        context.$implicit = data;
+        context.item = data;
+        context.index = index;
+        context.even = index % 2 === 0;
+        context.odd = !context.even;
+        this.setupItemView.next({
+            view: viewRef,
+            data,
+            index,
+            context
+        });
+    }
+    getItemTemplateViewFactory(template) {
+        return () => {
+            const viewRef = this.loader.createEmbeddedView(template, new ItemContext(), 0);
+            const resultView = getItemViewRoot(viewRef);
+            resultView[NG_VIEW] = viewRef;
+            return resultView;
+        };
+    }
+    detectChangesOnChild(viewRef, index) {
+        if (Trace.isEnabled()) {
+            PagerLog(`Manually detect changes in child: ${index}`);
+        }
+        viewRef.markForCheck();
+        viewRef.detectChanges();
+    }
+    ngDoCheck() {
+        if (this._differ) {
+            if (Trace.isEnabled()) {
+                PagerLog('ngDoCheck() - execute differ');
+            }
+            const changes = this._differ.diff(this._items);
+            if (changes) {
+                if (Trace.isEnabled()) {
+                    PagerLog('ngDoCheck() - refresh');
+                }
+                this.templatedItemsView.refresh();
+            }
+        }
+    }
+}
+TemplatedItemsComponent.ɵfac = function TemplatedItemsComponent_Factory(t) { return new (t || TemplatedItemsComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.IterableDiffers)); };
+TemplatedItemsComponent.ɵcmp = i0.ɵɵdefineComponent({ type: TemplatedItemsComponent, selectors: [["ng-component"]], contentQueries: function TemplatedItemsComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+        i0.ɵɵcontentQuery(dirIndex, TemplateRef, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.itemTemplateQuery = _t.first);
+    } }, viewQuery: function TemplatedItemsComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5, ViewContainerRef);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.loader = _t.first);
+    } }, inputs: { items: "items", selectedIndex: "selectedIndex" }, outputs: { setupItemView: "setupItemView" }, decls: 0, vars: 0, template: function TemplatedItemsComponent_Template(rf, ctx) { }, encapsulation: 2 });
+__decorate([
+    profile
+], TemplatedItemsComponent.prototype, "onItemLoading", null);
+__decorate([
+    profile
+], TemplatedItemsComponent.prototype, "onItemDisposing", null);
+__decorate([
+    profile
+], TemplatedItemsComponent.prototype, "detectChangesOnChild", null);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TemplatedItemsComponent, [{
+        type: Component,
+        args: [{
+                template: ''
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.IterableDiffers }]; }, { loader: [{
+            type: ViewChild,
+            args: ['loader', { read: ViewContainerRef, static: false }]
+        }], setupItemView: [{
+            type: Output
+        }], itemTemplateQuery: [{
+            type: ContentChild,
+            args: [TemplateRef, { static: false }]
+        }], items: [{
+            type: Input
+        }], selectedIndex: [{
+            type: Input
+        }], onItemLoading: [], onItemDisposing: [], detectChangesOnChild: [] }); })();
+export function getItemViewRoot(viewRef, rootLocator = extractSingleViewRecursive) {
+    return rootLocator(viewRef.rootNodes, 0);
+}
+export const TEMPLATED_ITEMS_COMPONENT = new InjectionToken('TemplatedItemsComponent');
+export class PagerItemDirective {
+    constructor(templateRef, owner, viewContainer) {
+        this.templateRef = templateRef;
+        this.owner = owner;
+        this.viewContainer = viewContainer;
+    }
+    ensureItem() {
+        if (!this.item) {
+            this.item = new PagerItem();
+        }
+    }
+    applyConfig() {
+        this.ensureItem();
+    }
+    ngOnInit() {
+        this.applyConfig();
+        const viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
+        const realViews = viewRef.rootNodes.filter((node) => !isInvisibleNode(node));
+        if (realViews.length > 0) {
+            const view = realViews[0];
+            this.item.addChild(view);
+            this.owner.nativeElement._addChildFromBuilder('PagerItem', this.item);
+        }
+    }
+}
+PagerItemDirective.ɵfac = function PagerItemDirective_Factory(t) { return new (t || PagerItemDirective)(i0.ɵɵdirectiveInject(i0.TemplateRef), i0.ɵɵdirectiveInject(TEMPLATED_ITEMS_COMPONENT, 1), i0.ɵɵdirectiveInject(i0.ViewContainerRef)); };
+PagerItemDirective.ɵdir = i0.ɵɵdefineDirective({ type: PagerItemDirective, selectors: [["", "pagerItem", ""]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PagerItemDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[pagerItem]'
+            }]
+    }], function () { return [{ type: i0.TemplateRef }, { type: TemplatedItemsComponent, decorators: [{
+                type: Inject,
+                args: [TEMPLATED_ITEMS_COMPONENT]
+            }, {
+                type: Host
+            }] }, { type: i0.ViewContainerRef }]; }, null); })();
+export class TemplateKeyDirective {
+    constructor(templateRef, comp) {
+        this.templateRef = templateRef;
+        this.comp = comp;
+    }
+    set pagerTemplateKey(value) {
+        if (this.comp && this.templateRef) {
+            this.comp.registerTemplate(value, this.templateRef);
+        }
+    }
+}
+TemplateKeyDirective.ɵfac = function TemplateKeyDirective_Factory(t) { return new (t || TemplateKeyDirective)(i0.ɵɵdirectiveInject(i0.TemplateRef), i0.ɵɵdirectiveInject(TEMPLATED_ITEMS_COMPONENT, 1)); };
+TemplateKeyDirective.ɵdir = i0.ɵɵdefineDirective({ type: TemplateKeyDirective, selectors: [["", "pagerTemplateKey", ""]], inputs: { pagerTemplateKey: "pagerTemplateKey" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TemplateKeyDirective, [{
+        type: Directive,
+        args: [{ selector: '[pagerTemplateKey]' }]
+    }], function () { return [{ type: i0.TemplateRef }, { type: TemplatedItemsComponent, decorators: [{
+                type: Inject,
+                args: [TEMPLATED_ITEMS_COMPONENT]
+            }, {
+                type: Host
+            }] }]; }, { pagerTemplateKey: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pager-items-comp.js","sourceRoot":"","sources":["../../../../src/ui-pager/angular/pager-items-comp.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    Component,\n    ContentChild,\n    Directive,\n    DoCheck,\n    ElementRef,\n    EmbeddedViewRef,\n    EventEmitter,\n    Host,\n    Inject,\n    InjectionToken,\n    Input,\n    IterableDiffer,\n    IterableDiffers,\n    OnDestroy,\n    OnInit,\n    Output,\n    TemplateRef,\n    ViewChild,\n    ViewContainerRef,\n    ɵisListLikeIterable as isListLikeIterable\n} from '@angular/core';\nimport { Pager, PagerError, PagerItem, PagerLog } from '@nativescript-community/ui-pager';\nimport { extractSingleViewRecursive, isInvisibleNode, registerElement } from '@nativescript/angular';\nimport { EventData, KeyedTemplate, LayoutBase, Template, Trace, View, isIOS } from '@nativescript/core';\nimport { ObservableArray } from '@nativescript/core/data/observable-array';\nimport { profile } from '@nativescript/core/profiling';\nimport { ItemEventData, ItemsSource } from '@nativescript/core/ui/list-view';\n\nregisterElement('Pager', () => Pager);\nregisterElement('PagerItem', () => PagerItem);\n\nconst NG_VIEW = '_ngViewRef';\n\nexport interface PagerTemplatedItemsView {\n    items: any[] | ItemsSource;\n    itemTemplate: string | Template;\n    itemTemplates?: string | KeyedTemplate[];\n\n    refresh(): void;\n\n    on(event: 'itemDisposing' | 'itemLoading', callback: (args: ItemEventData) => void, thisArg?: any);\n\n    off(event: 'itemLoading' | 'itemDisposing', callback: (args: EventData) => void, thisArg?: any);\n}\n\nexport class ItemContext {\n    constructor(public $implicit?: any, public item?: any, public index?: number, public even?: boolean, public odd?: boolean) {}\n}\n\nexport interface SetupItemViewArgs {\n    view: EmbeddedViewRef<any>;\n    data: any;\n    index: number;\n    context: ItemContext;\n}\n@Component({\n    template: ''\n})\nexport abstract class TemplatedItemsComponent implements DoCheck, OnDestroy, AfterContentInit {\n    public abstract get nativeElement(): Pager;\n\n    protected templatedItemsView: Pager;\n    protected _items: any;\n    protected _differ: IterableDiffer<KeyedTemplate>;\n    protected _templateMap: Map<string, KeyedTemplate>;\n    private _selectedIndex: number;\n    @ViewChild('loader', { read: ViewContainerRef, static: false }) loader: ViewContainerRef;\n\n    @Output()\n    public setupItemView = new EventEmitter<SetupItemViewArgs>();\n\n    @ContentChild(TemplateRef, { static: false }) itemTemplateQuery: TemplateRef<ItemContext>;\n\n    itemTemplate: TemplateRef<ItemContext>;\n\n    @Input()\n    get items() {\n        return this._items;\n    }\n\n    set items(value: any) {\n        this._items = value;\n        let needDiffer = true;\n        if (value instanceof ObservableArray) {\n            needDiffer = false;\n        }\n        if (needDiffer && !this._differ && isListLikeIterable(value)) {\n            this._differ = this._iterableDiffers.find(this._items).create((_index, item) => item);\n        }\n\n        this.templatedItemsView.items = this._items;\n    }\n\n    @Input()\n    get selectedIndex(): number {\n        return this._selectedIndex;\n    }\n\n    set selectedIndex(value) {\n        this._selectedIndex = value;\n        this.templatedItemsView.selectedIndex = this._selectedIndex;\n    }\n\n    ngAfterViewInit() {\n        if (!!this._selectedIndex) {\n            setTimeout(() => {\n                if (isIOS) {\n                    this.templatedItemsView.scrollToIndexAnimated(this._selectedIndex, false);\n                }\n                this.templatedItemsView.selectedIndex = this._selectedIndex;\n            });\n        }\n    }\n\n    constructor(_elementRef: ElementRef, private _iterableDiffers: IterableDiffers) {\n        this.templatedItemsView = _elementRef.nativeElement;\n\n        this.templatedItemsView.on('itemLoading', this.onItemLoading, this);\n        this.templatedItemsView.on('itemDisposing', this.onItemDisposing, this);\n    }\n\n    ngAfterContentInit() {\n        if (Trace.isEnabled()) {\n            PagerLog('TemplatedItemsView.ngAfterContentInit()');\n        }\n        this.setItemTemplates();\n    }\n\n    ngOnDestroy() {\n        this.templatedItemsView.off('itemLoading', this.onItemLoading, this);\n        this.templatedItemsView.off('itemDisposing', this.onItemDisposing, this);\n    }\n\n    private setItemTemplates() {\n        if (!this.items) return;\n        // The itemTemplateQuery may be changed after list items are added that contain <template> inside,\n        // so cache and use only the original template to avoid errors.\n        this.itemTemplate = this.itemTemplateQuery;\n\n        if (this._templateMap) {\n            if (Trace.isEnabled()) {\n                PagerLog('Setting templates');\n            }\n\n            const templates: KeyedTemplate[] = [];\n            this._templateMap.forEach((value) => {\n                templates.push(value);\n            });\n            this.templatedItemsView.itemTemplates = templates;\n        }\n    }\n\n    public registerTemplate(key: string, template: TemplateRef<ItemContext>) {\n        if (Trace.isEnabled()) {\n            PagerLog(`registerTemplate for key: ${key}`);\n        }\n\n        if (!this._templateMap) {\n            this._templateMap = new Map<string, KeyedTemplate>();\n        }\n\n        const keyedTemplate = {\n            key,\n            createView: this.getItemTemplateViewFactory(template)\n        };\n\n        this._templateMap.set(key, keyedTemplate);\n    }\n\n    @profile\n    public onItemLoading(args: ItemEventData) {\n        if (!args.view && !this.itemTemplate) {\n            return;\n        }\n\n        if (!this.items) return;\n\n        const index = args.index;\n        const items = (args.object as any).items;\n        const currentItem = typeof items.getItem === 'function' ? items.getItem(index) : items[index];\n        let viewRef: EmbeddedViewRef<ItemContext>;\n\n        if (args.view) {\n            if (Trace.isEnabled()) {\n                PagerLog(`onItemLoading: ${index} - Reusing existing view`);\n            }\n\n            viewRef = args.view[NG_VIEW];\n            // Getting angular view from original element (in cases when ProxyViewContainer\n            // is used NativeScript internally wraps it in a StackLayout)\n            if (!viewRef && args.view instanceof LayoutBase && args.view.getChildrenCount() > 0) {\n                viewRef = args.view.getChildAt(0)[NG_VIEW];\n            }\n\n            if (!viewRef && Trace.isEnabled()) {\n                PagerError(`ViewReference not found for item ${index}. View recycling is not working`);\n            }\n        }\n\n        if (!viewRef) {\n            if (Trace.isEnabled()) {\n                PagerLog(`onItemLoading: ${index} - Creating view from template`);\n            }\n\n            viewRef = this.loader.createEmbeddedView(this.itemTemplate, new ItemContext(), 0);\n            args.view = getItemViewRoot(viewRef);\n            args.view[NG_VIEW] = viewRef;\n        }\n\n        this.setupViewRef(viewRef, currentItem, index);\n\n        this.detectChangesOnChild(viewRef, index);\n    }\n\n    @profile\n    public onItemDisposing(args: ItemEventData) {\n        if (!args.view) {\n            return;\n        }\n        let viewRef: EmbeddedViewRef<ItemContext>;\n\n        if (args.view) {\n            if (Trace.isEnabled()) {\n                PagerLog(`onItemDisposing: ${args.index} - Removing angular view`);\n            }\n\n            viewRef = args.view[NG_VIEW];\n            // Getting angular view from original element (in cases when ProxyViewContainer\n            // is used NativeScript internally wraps it in a StackLayout)\n            if (!viewRef && args.view instanceof LayoutBase && args.view.getChildrenCount() > 0) {\n                viewRef = args.view.getChildAt(0)[NG_VIEW];\n            }\n\n            if (!viewRef && Trace.isEnabled()) {\n                PagerError(`ViewReference not found for item ${args.index}. View disposing is not working`);\n            }\n        }\n\n        if (viewRef) {\n            if (Trace.isEnabled()) {\n                PagerLog(`onItemDisposing: ${args.index} - Disposing view reference`);\n            }\n\n            viewRef.destroy();\n        }\n    }\n\n    public setupViewRef(viewRef: EmbeddedViewRef<ItemContext>, data: any, index: number): void {\n        const context = viewRef.context;\n        context.$implicit = data;\n        context.item = data;\n        context.index = index;\n        context.even = index % 2 === 0;\n        context.odd = !context.even;\n\n        this.setupItemView.next({\n            view: viewRef,\n            data,\n            index,\n            context\n        });\n    }\n\n    protected getItemTemplateViewFactory(template: TemplateRef<ItemContext>): () => View {\n        return () => {\n            const viewRef = this.loader.createEmbeddedView(template, new ItemContext(), 0);\n            const resultView = getItemViewRoot(viewRef);\n            resultView[NG_VIEW] = viewRef;\n\n            return resultView;\n        };\n    }\n\n    @profile\n    private detectChangesOnChild(viewRef: EmbeddedViewRef<ItemContext>, index: number) {\n        if (Trace.isEnabled()) {\n            PagerLog(`Manually detect changes in child: ${index}`);\n        }\n\n        viewRef.markForCheck();\n        viewRef.detectChanges();\n    }\n\n    ngDoCheck() {\n        if (this._differ) {\n            if (Trace.isEnabled()) {\n                PagerLog('ngDoCheck() - execute differ');\n            }\n\n            const changes = this._differ.diff(this._items);\n            if (changes) {\n                if (Trace.isEnabled()) {\n                    PagerLog('ngDoCheck() - refresh');\n                }\n\n                this.templatedItemsView.refresh();\n            }\n        }\n    }\n}\n\nexport interface ComponentView {\n    rootNodes: any[];\n\n    destroy(): void;\n}\n\nexport type RootLocator = (nodes: any[], nestLevel: number) => View;\n\nexport function getItemViewRoot(viewRef: ComponentView, rootLocator: RootLocator = extractSingleViewRecursive as any): View {\n    return rootLocator(viewRef.rootNodes, 0);\n}\n\nexport const TEMPLATED_ITEMS_COMPONENT = new InjectionToken<TemplatedItemsComponent>('TemplatedItemsComponent');\n\n@Directive({\n    selector: '[pagerItem]'\n})\nexport class PagerItemDirective implements OnInit {\n    private item: PagerItem;\n\n    constructor(\n        private templateRef: TemplateRef<any>,\n        @Inject(TEMPLATED_ITEMS_COMPONENT)\n        @Host()\n        private owner: TemplatedItemsComponent,\n        private viewContainer: ViewContainerRef\n    ) {}\n\n    private ensureItem() {\n        if (!this.item) {\n            this.item = new PagerItem();\n        }\n    }\n\n    private applyConfig() {\n        this.ensureItem();\n    }\n\n    ngOnInit() {\n        this.applyConfig();\n\n        const viewRef = this.viewContainer.createEmbeddedView(this.templateRef);\n        // Filter out text nodes and comments\n        const realViews = viewRef.rootNodes.filter((node) => !isInvisibleNode(node));\n\n        if (realViews.length > 0) {\n            const view = realViews[0];\n            this.item.addChild(view);\n            this.owner.nativeElement._addChildFromBuilder('PagerItem', this.item);\n        }\n    }\n}\n\n@Directive({ selector: '[pagerTemplateKey]' })\nexport class TemplateKeyDirective {\n    constructor(\n        private templateRef: TemplateRef<any>,\n        @Inject(TEMPLATED_ITEMS_COMPONENT)\n        @Host()\n        private comp: TemplatedItemsComponent\n    ) {}\n\n    @Input()\n    set pagerTemplateKey(value: any) {\n        if (this.comp && this.templateRef) {\n            this.comp.registerTemplate(value, this.templateRef);\n        }\n    }\n}\n"]}