@nstudio/ui-collectionview 5.1.9-alpha.3 → 5.1.9-alpha.5

package/angular/collectionview.component.d.ts

@@ -56,7 +56,9 @@ export declare class CollectionViewComponent implements DoCheck, OnDestroy, Afte
     registerTemplateSupplemental(key: string, template: TemplateRef<ItemContext>, type: 'header' | 'footer'): void;
     onItemLoading(args: CollectionViewItemEventData): void;
     onItemRecyclingInternal(args: any): void;
+    onItemDisplayInternal(args: CollectionViewItemEventData): void;
     onItemDisposingInternal(args: any): void;
+    private getNgView;
     setupViewRef(view: EmbeddedViewRef<ItemContext>, data: any, index: number): void;
     getItemTemplateViewFactory(template: TemplateRef<ItemContext>): () => View;
     viewPool: Map<TemplateRef<ItemContext>, {
@@ -73,7 +75,7 @@ export declare class CollectionViewComponent implements DoCheck, OnDestroy, Afte
     private detectChangesOnChild;
     private refresh;
     static ɵfac: i0.ɵɵFactoryDeclaration<CollectionViewComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CollectionViewComponent, "CollectionView", never, { "autoReuseViews": "autoReuseViews"; "itemTemplate": "itemTemplate"; "headerItemTemplate": "headerItemTemplate"; "footerItemTemplate": "footerItemTemplate"; "items": "items"; }, { "setupItemView": "setupItemView"; }, ["itemTemplateQuery"], never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollectionViewComponent, "CollectionView", never, { "autoReuseViews": { "alias": "autoReuseViews"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "headerItemTemplate": { "alias": "headerItemTemplate"; "required": false; }; "footerItemTemplate": { "alias": "footerItemTemplate"; "required": false; }; "items": { "alias": "items"; "required": false; }; }, { "setupItemView": "setupItemView"; }, ["itemTemplateQuery"], never, false, never>;
 }
 export interface ComponentView {
     rootNodes: any[];
@@ -87,7 +89,7 @@ export declare class TemplateKeyDirective {
     constructor(templateRef: TemplateRef<any>, collectionView: CollectionViewComponent);
     set cvTemplateKey(value: any);
     static ɵfac: i0.ɵɵFactoryDeclaration<TemplateKeyDirective, [null, { host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateKeyDirective, "[cvTemplateKey]", never, { "cvTemplateKey": "cvTemplateKey"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateKeyDirective, "[cvTemplateKey]", never, { "cvTemplateKey": { "alias": "cvTemplateKey"; "required": false; }; }, {}, never, never, false, never>;
 }
 export declare class TemplateHeaderDirective {
     private templateRef;
@@ -95,7 +97,7 @@ export declare class TemplateHeaderDirective {
     constructor(templateRef: TemplateRef<any>, collectionView: CollectionViewComponent);
     set cvTemplateHeader(value: any);
     static ɵfac: i0.ɵɵFactoryDeclaration<TemplateHeaderDirective, [null, { host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateHeaderDirective, "[cvTemplateHeader]", never, { "cvTemplateHeader": "cvTemplateHeader"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateHeaderDirective, "[cvTemplateHeader]", never, { "cvTemplateHeader": { "alias": "cvTemplateHeader"; "required": false; }; }, {}, never, never, false, never>;
 }
 export declare class TemplateFooterDirective {
     private templateRef;
@@ -103,5 +105,5 @@ export declare class TemplateFooterDirective {
     constructor(templateRef: TemplateRef<any>, collectionView: CollectionViewComponent);
     set cvTemplateFooter(value: any);
     static ɵfac: i0.ɵɵFactoryDeclaration<TemplateFooterDirective, [null, { host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateFooterDirective, "[cvTemplateFooter]", never, { "cvTemplateFooter": "cvTemplateFooter"; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TemplateFooterDirective, "[cvTemplateFooter]", never, { "cvTemplateFooter": { "alias": "cvTemplateFooter"; "required": false; }; }, {}, never, never, false, never>;
 }

package/angular/esm2022/collectionview.component.mjs

@@ -0,0 +1,525 @@
+import { ChangeDetectionStrategy, Component, ContentChild, Directive, ElementRef, EventEmitter, Host, HostListener, Inject, Input, IterableDiffers, NgZone, Output, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';
+import { CLog, CLogTypes, CollectionView, ViewTemplateType } from '@nstudio/ui-collectionview';
+import { DetachedLoader, NativeScriptRendererFactory, extractSingleViewRecursive, isListLikeIterable, registerElement } from '@nativescript/angular';
+import { LayoutBase, ObservableArray, Trace } from '@nativescript/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@nativescript/angular";
+registerElement('CollectionView', () => CollectionView);
+const NG_VIEW = '_ngViewRef';
+export class ItemContext {
+    $implicit;
+    item;
+    index;
+    even;
+    odd;
+    constructor($implicit, item, index, even, odd) {
+        this.$implicit = $implicit;
+        this.item = item;
+        this.index = index;
+        this.even = even;
+        this.odd = odd;
+    }
+}
+export class CollectionViewComponent {
+    _elementRef;
+    _iterableDiffers;
+    _renderer;
+    _ngZone;
+    get nativeElement() {
+        return this._collectionView;
+    }
+    get listView() {
+        return this._collectionView;
+    }
+    loader;
+    setupItemView = new EventEmitter();
+    itemTemplateQuery;
+    autoReuseViews = false;
+    detachedLoaderFactory() {
+        const ref = this.loader.createComponent(DetachedLoader, {
+            index: 0,
+        });
+        this.loader.detach(0);
+        this._loaders.push(ref);
+        return ref;
+    }
+    get itemTemplate() {
+        return this._itemTemplate;
+    }
+    set itemTemplate(value) {
+        this._itemTemplate = value;
+        // this._collectionView.refresh();
+    }
+    get headerItemTemplate() {
+        return this._headerTemplate;
+    }
+    set headerItemTemplate(value) {
+        this._headerTemplate = value;
+    }
+    get footerItemTemplate() {
+        return this._footerTemplate;
+    }
+    set footerItemTemplate(value) {
+        this._footerTemplate = value;
+    }
+    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._collectionView.items = this._items;
+    }
+    _collectionView;
+    _items;
+    _differ;
+    _itemTemplate;
+    _templateMap;
+    _headerTemplate;
+    _headerTemplateMap;
+    _footerTemplate;
+    _footerTemplateMap;
+    _loaders;
+    constructor(_elementRef, _iterableDiffers, _renderer, _ngZone) {
+        this._elementRef = _elementRef;
+        this._iterableDiffers = _iterableDiffers;
+        this._renderer = _renderer;
+        this._ngZone = _ngZone;
+        this._collectionView = _elementRef.nativeElement;
+        this._collectionView.on(CollectionView.itemLoadingEvent, this.onItemLoading, this);
+        this._collectionView.itemViewLoader = this.itemViewLoader;
+        this._loaders = [];
+    }
+    itemViewLoader = (viewType) => {
+        this._ngZone.run(() => {
+            switch (viewType) {
+                case ViewTemplateType.Item:
+                    if (this._itemTemplate) {
+                        return this.getOrCreate(this._itemTemplate);
+                    }
+                    break;
+                case ViewTemplateType.Header:
+                    if (this._headerTemplate) {
+                        return this.getOrCreate(this._headerTemplate);
+                    }
+                    break;
+                case ViewTemplateType.Footer:
+                    if (this._footerTemplate) {
+                        return this.getOrCreate(this._footerTemplate);
+                    }
+                    break;
+            }
+            return null;
+        });
+    };
+    ngAfterContentInit() {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'CollectionView.ngAfterContentInit()');
+        }
+        this.setItemTemplates();
+    }
+    ngOnDestroy() {
+        this._collectionView.off(CollectionView.itemLoadingEvent, this.onItemLoading, this);
+        this._collectionView = null;
+        this._loaders.forEach((l) => l.destroy());
+        this._loaders = null;
+        this.viewToLoader = null;
+        this.viewToTemplate = null;
+        this.viewPool = null;
+        this._items = null;
+        this._differ = null;
+        this._itemTemplate = null;
+        if (this._templateMap) {
+            this._templateMap.clear();
+        }
+        if (this._headerTemplateMap) {
+            this._headerTemplateMap.clear();
+        }
+        if (this._footerTemplateMap) {
+            this._footerTemplateMap.clear();
+        }
+        this._templateMap = null;
+        this._headerTemplateMap = null;
+        this._footerTemplateMap = null;
+    }
+    ngDoCheck() {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'ngDoCheck() - execute differ? ' + this._differ);
+        }
+        if (this._differ) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, 'ngDoCheck() - execute differ');
+            }
+            const changes = this._differ.diff(this._items);
+            if (changes) {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.info, 'ngDoCheck() - refresh');
+                }
+                this.refresh();
+            }
+        }
+    }
+    registerTemplate(key, template) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'registerTemplate for key: ' + key);
+        }
+        if (!this._templateMap) {
+            this._templateMap = new Map();
+        }
+        const keyedTemplate = {
+            key,
+            createView: this.getItemTemplateViewFactory(template),
+        };
+        this._templateMap.set(key, keyedTemplate);
+    }
+    registerTemplateSupplemental(key, template, type) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'registerTemplate for key: ' + key);
+        }
+        switch (type) {
+            case 'header':
+                // if (!this._headerTemplateMap) {
+                //   this._headerTemplateMap = new Map<string, KeyedTemplate>();
+                // }
+                // this._headerTemplateMap.set(key, keyedTemplate);
+                this._collectionView.headerKey = key;
+                this.headerItemTemplate = template;
+                this._collectionView.headerItemTemplate = this.getItemTemplateViewFactory(template);
+                break;
+            case 'footer':
+                // if (!this._footerTemplateMap) {
+                //   this._footerTemplateMap = new Map<string, KeyedTemplate>();
+                // }
+                // this._footerTemplateMap.set(key, keyedTemplate);
+                this._collectionView.footerKey = key;
+                this.footerItemTemplate = template;
+                this._collectionView.footerItemTemplate = this.getItemTemplateViewFactory(template);
+                break;
+        }
+    }
+    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 (Trace.isEnabled()) {
+            CLog(CLogTypes.info, `onItemLoading: ${index} - Reusing existing view`);
+        }
+        viewRef = this.getNgView(args.view);
+        if (!viewRef && Trace.isEnabled()) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, `ViewReference not found for item ${index}. View recycling is not working`);
+            }
+        }
+        if (!viewRef) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, `onItemLoading: ${index} - Creating view from template`);
+            }
+            viewRef = this.getOrCreate(this.itemTemplate);
+        }
+        this.setupViewRef(viewRef, currentItem, index);
+        this.detectChangesOnChild(viewRef, index);
+    }
+    onItemRecyclingInternal(args) {
+        if (!args.view) {
+            return;
+        }
+        const ngView = this.getNgView(args.view);
+        // console.log('recycling', args.view);
+        if (ngView) {
+            ngView.detach();
+        }
+    }
+    onItemDisplayInternal(args) {
+        if (!args.view) {
+            return;
+        }
+        const ngView = this.getNgView(args.view);
+        if (ngView) {
+            ngView.reattach();
+        }
+    }
+    onItemDisposingInternal(args) {
+        if (!args.view) {
+            return;
+        }
+        const ngView = this.getNgView(args.view);
+        if (ngView) {
+            ngView.detach();
+            this.storeViewRef(ngView);
+        }
+    }
+    getNgView(view) {
+        const ngView = view[NG_VIEW];
+        // Getting angular view from original element (in cases when ProxyViewContainer
+        // is used NativeScript internally wraps it in a StackLayout)
+        if (!ngView && view instanceof LayoutBase && view.getChildrenCount() > 0) {
+            return view.getChildAt(0)[NG_VIEW];
+        }
+        return ngView;
+    }
+    setupViewRef(view, data, index) {
+        const context = view.context;
+        context.$implicit = data;
+        context.item = data;
+        context.index = index;
+        context.even = index % 2 === 0;
+        context.odd = !context.even;
+        this.setupItemView.next({
+            context,
+            data,
+            index,
+            view,
+        });
+    }
+    getItemTemplateViewFactory(template) {
+        return () => {
+            return this.getOrCreate(template);
+        };
+    }
+    viewPool = new Map();
+    storeViewRef(viewRef) {
+        const templateRef = this.viewToTemplate.get(viewRef);
+        if (templateRef) {
+            const scrap = this.viewPool.get(templateRef);
+            if (scrap) {
+                if (scrap.scrapHead.size >= scrap.scrapSize) {
+                    viewRef.destroy();
+                    this.viewToLoader.get(viewRef)?.destroy();
+                }
+                else {
+                    scrap.scrapHead.add(viewRef);
+                }
+            }
+        }
+    }
+    viewToTemplate = new WeakMap();
+    viewToLoader = new WeakMap();
+    getOrCreate(templateRef) {
+        return this._ngZone.run(() => {
+            let viewRef = this.getView(templateRef);
+            if (!viewRef) {
+                const loader = this.detachedLoaderFactory();
+                viewRef = loader.instance.vc.createEmbeddedView(templateRef, new ItemContext(), 0);
+                this.viewToLoader.set(viewRef, loader);
+                this.viewToTemplate.set(viewRef, templateRef);
+            }
+            viewRef.detach();
+            const resultView = getItemViewRoot(viewRef);
+            resultView[NG_VIEW] = viewRef;
+            resultView.reusable = this.autoReuseViews;
+            return resultView;
+        });
+    }
+    getView(templateRef) {
+        const pool = this.getViewPool(templateRef);
+        while (pool.scrapHead.size > 0) {
+            const viewRef = pool.scrapHead.values().next().value;
+            pool.scrapHead.delete(viewRef);
+            if (!viewRef.destroyed) {
+                return viewRef;
+            }
+        }
+        return null;
+    }
+    getViewPool(templateRef) {
+        if (!this.viewPool.has(templateRef)) {
+            this.viewPool.set(templateRef, {
+                scrapSize: this.autoReuseViews ? Infinity : 0,
+                scrapHead: new Set(),
+            });
+        }
+        return this.viewPool.get(templateRef);
+    }
+    setItemTemplates() {
+        // The itemTemplateQuery may be changed after list items are added that contain <template> inside,
+        // so cache and use only the original template to avoid errors.
+        this.itemTemplate = this.itemTemplateQuery;
+        if (this._templateMap) {
+            if (Trace.isEnabled()) {
+                CLog(CLogTypes.info, 'Setting templates');
+            }
+            const templates = [];
+            this._templateMap.forEach((value) => {
+                templates.push(value);
+            });
+            this._collectionView.itemTemplates = templates;
+        }
+        else {
+            // If the map was not initialized this means that there are no named templates, so we register the default one.
+            this._collectionView.itemTemplate = this.getItemTemplateViewFactory(this.itemTemplate);
+        }
+    }
+    detectChangesOnChild(viewRef, index) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'Manually detect changes in child: ' + index);
+        }
+        viewRef.markForCheck();
+        viewRef.detectChanges();
+    }
+    refresh() {
+        if (this._collectionView) {
+            this._collectionView.refresh();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CollectionViewComponent, deps: [{ token: ElementRef }, { token: IterableDiffers }, { token: NativeScriptRendererFactory }, { token: NgZone }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: CollectionViewComponent, selector: "CollectionView", inputs: { autoReuseViews: "autoReuseViews", itemTemplate: "itemTemplate", headerItemTemplate: "headerItemTemplate", footerItemTemplate: "footerItemTemplate", items: "items" }, outputs: { setupItemView: "setupItemView" }, host: { listeners: { "itemLoading": "onItemLoading($event)", "itemRecycling": "onItemRecyclingInternal($event)", "displayItem": "onItemDisplayInternal($event)", "itemDisposing": "onItemDisposingInternal($event)" } }, queries: [{ propertyName: "itemTemplateQuery", first: true, predicate: TemplateRef, descendants: true, read: TemplateRef, static: true }], viewQueries: [{ propertyName: "loader", first: true, predicate: ["loader"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: `
+    <DetachedContainer>
+      <Placeholder #loader></Placeholder>
+    </DetachedContainer>
+  `, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CollectionViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'CollectionView',
+                    template: `
+    <DetachedContainer>
+      <Placeholder #loader></Placeholder>
+    </DetachedContainer>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.IterableDiffers, decorators: [{
+                    type: Inject,
+                    args: [IterableDiffers]
+                }] }, { type: i1.NativeScriptRendererFactory, decorators: [{
+                    type: Inject,
+                    args: [NativeScriptRendererFactory]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }], propDecorators: { loader: [{
+                type: ViewChild,
+                args: ['loader', { read: ViewContainerRef, static: true }]
+            }], setupItemView: [{
+                type: Output
+            }], itemTemplateQuery: [{
+                type: ContentChild,
+                args: [TemplateRef, { read: TemplateRef, static: true }]
+            }], autoReuseViews: [{
+                type: Input
+            }], itemTemplate: [{
+                type: Input
+            }], headerItemTemplate: [{
+                type: Input
+            }], footerItemTemplate: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], onItemLoading: [{
+                type: HostListener,
+                args: ['itemLoading', ['$event']]
+            }], onItemRecyclingInternal: [{
+                type: HostListener,
+                args: ['itemRecycling', ['$event']]
+            }], onItemDisplayInternal: [{
+                type: HostListener,
+                args: ['displayItem', ['$event']]
+            }], onItemDisposingInternal: [{
+                type: HostListener,
+                args: ['itemDisposing', ['$event']]
+            }] } });
+export function getItemViewRoot(viewRef, rootLocator = extractSingleViewRecursive) {
+    const rootView = rootLocator(viewRef.rootNodes, 0);
+    return rootView;
+}
+export class TemplateKeyDirective {
+    templateRef;
+    collectionView;
+    constructor(templateRef, collectionView) {
+        this.templateRef = templateRef;
+        this.collectionView = collectionView;
+    }
+    set cvTemplateKey(value) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'cvTemplateKey: ' + value);
+        }
+        if (this.collectionView && this.templateRef) {
+            this.collectionView.registerTemplate(value.toLowerCase(), this.templateRef);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TemplateKeyDirective, deps: [{ token: i0.TemplateRef }, { token: CollectionViewComponent, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.9", type: TemplateKeyDirective, selector: "[cvTemplateKey]", inputs: { cvTemplateKey: "cvTemplateKey" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TemplateKeyDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[cvTemplateKey]' }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: CollectionViewComponent, decorators: [{
+                    type: Host
+                }] }], propDecorators: { cvTemplateKey: [{
+                type: Input
+            }] } });
+export class TemplateHeaderDirective {
+    templateRef;
+    collectionView;
+    constructor(templateRef, collectionView) {
+        this.templateRef = templateRef;
+        this.collectionView = collectionView;
+    }
+    set cvTemplateHeader(value) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'cvTemplateHeader: ' + value);
+        }
+        if (this.collectionView && this.templateRef) {
+            // TODO: allow keying of multiple headers per section
+            this.collectionView.registerTemplateSupplemental(value || ViewTemplateType.Header, this.templateRef, 'header');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TemplateHeaderDirective, deps: [{ token: i0.TemplateRef }, { token: CollectionViewComponent, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.9", type: TemplateHeaderDirective, selector: "[cvTemplateHeader]", inputs: { cvTemplateHeader: "cvTemplateHeader" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TemplateHeaderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cvTemplateHeader]',
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: CollectionViewComponent, decorators: [{
+                    type: Host
+                }] }], propDecorators: { cvTemplateHeader: [{
+                type: Input
+            }] } });
+export class TemplateFooterDirective {
+    templateRef;
+    collectionView;
+    constructor(templateRef, collectionView) {
+        this.templateRef = templateRef;
+        this.collectionView = collectionView;
+    }
+    set cvTemplateFooter(value) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.info, 'cvTemplateFooter: ' + value);
+        }
+        if (this.collectionView && this.templateRef) {
+            // TODO: allow keying of multiple footers per section
+            this.collectionView.registerTemplateSupplemental(value || ViewTemplateType.Footer, this.templateRef, 'footer');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TemplateFooterDirective, deps: [{ token: i0.TemplateRef }, { token: CollectionViewComponent, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.9", type: TemplateFooterDirective, selector: "[cvTemplateFooter]", inputs: { cvTemplateFooter: "cvTemplateFooter" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TemplateFooterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cvTemplateFooter]',
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }, { type: CollectionViewComponent, decorators: [{
+                    type: Host
+                }] }], propDecorators: { cvTemplateFooter: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collectionview.component.js","sourceRoot":"","sources":["../../../../../packages/ui-collectionview/angular/collectionview.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ChangeDetectionStrategy, Component, ComponentRef, ContentChild, Directive, DoCheck, ElementRef, EmbeddedViewRef, EventEmitter, Host, HostListener, Inject, Input, IterableDiffer, IterableDiffers, NgZone, OnDestroy, Output, TemplateRef, ViewChild, ViewContainerRef } from '@angular/core';\nimport { CLog, CLogTypes, CollectionView, CollectionViewItemEventData, ViewTemplateType } from '@nstudio/ui-collectionview';\nimport { DetachedLoader, NativeScriptRendererFactory, extractSingleViewRecursive, isListLikeIterable, registerElement } from '@nativescript/angular';\nimport { KeyedTemplate, LayoutBase, ObservableArray, Trace, View } from '@nativescript/core';\n\nregisterElement('CollectionView', () => CollectionView);\n\nconst NG_VIEW = '_ngViewRef';\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\n@Component({\n  selector: 'CollectionView',\n  template: `\n    <DetachedContainer>\n      <Placeholder #loader></Placeholder>\n    </DetachedContainer>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CollectionViewComponent implements DoCheck, OnDestroy, AfterContentInit {\n  public get nativeElement() {\n    return this._collectionView;\n  }\n  public get listView() {\n    return this._collectionView;\n  }\n\n  @ViewChild('loader', { read: ViewContainerRef, static: true }) public loader: ViewContainerRef;\n  @Output() public setupItemView = new EventEmitter<SetupItemViewArgs>();\n  @ContentChild(TemplateRef, { read: TemplateRef, static: true }) public itemTemplateQuery: TemplateRef<ItemContext>;\n\n  @Input() autoReuseViews = false;\n\n  detachedLoaderFactory() {\n    const ref = this.loader.createComponent(DetachedLoader, {\n      index: 0,\n    });\n    this.loader.detach(0);\n    this._loaders.push(ref);\n    return ref;\n  }\n\n  @Input()\n  public get itemTemplate() {\n    return this._itemTemplate;\n  }\n  public set itemTemplate(value: TemplateRef<ItemContext>) {\n    this._itemTemplate = value;\n    // this._collectionView.refresh();\n  }\n  @Input()\n  public get headerItemTemplate() {\n    return this._headerTemplate;\n  }\n  public set headerItemTemplate(value: TemplateRef<ItemContext>) {\n    this._headerTemplate = value;\n  }\n  @Input()\n  public get footerItemTemplate() {\n    return this._footerTemplate;\n  }\n  public set footerItemTemplate(value: TemplateRef<ItemContext>) {\n    this._footerTemplate = value;\n  }\n  @Input()\n  public get items() {\n    return this._items;\n  }\n  public 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._collectionView.items = this._items;\n  }\n\n  private _collectionView: CollectionView;\n  private _items: any;\n  private _differ: IterableDiffer<KeyedTemplate>;\n  private _itemTemplate: TemplateRef<ItemContext>;\n  private _templateMap: Map<string, KeyedTemplate>;\n  private _headerTemplate: TemplateRef<ItemContext>;\n  private _headerTemplateMap: Map<string, KeyedTemplate>;\n  private _footerTemplate: TemplateRef<ItemContext>;\n  private _footerTemplateMap: Map<string, KeyedTemplate>;\n  private _loaders: ComponentRef<DetachedLoader>[];\n\n  constructor(@Inject(ElementRef) private _elementRef: ElementRef, @Inject(IterableDiffers) private _iterableDiffers: IterableDiffers, @Inject(NativeScriptRendererFactory) private _renderer: NativeScriptRendererFactory, @Inject(NgZone) private _ngZone: NgZone) {\n    this._collectionView = _elementRef.nativeElement;\n\n    this._collectionView.on(CollectionView.itemLoadingEvent, this.onItemLoading, this);\n    this._collectionView.itemViewLoader = this.itemViewLoader;\n    this._loaders = [];\n  }\n\n  private itemViewLoader = (viewType) => {\n    this._ngZone.run(() => {\n      switch (viewType) {\n        case ViewTemplateType.Item:\n          if (this._itemTemplate) {\n            return this.getOrCreate(this._itemTemplate);\n          }\n          break;\n        case ViewTemplateType.Header:\n          if (this._headerTemplate) {\n            return this.getOrCreate(this._headerTemplate);\n          }\n          break;\n        case ViewTemplateType.Footer:\n          if (this._footerTemplate) {\n            return this.getOrCreate(this._footerTemplate);\n          }\n          break;\n      }\n      return null;\n    });\n  };\n\n  public ngAfterContentInit() {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'CollectionView.ngAfterContentInit()');\n    }\n    this.setItemTemplates();\n  }\n\n  public ngOnDestroy() {\n    this._collectionView.off(CollectionView.itemLoadingEvent, this.onItemLoading, this);\n    this._collectionView = null;\n    this._loaders.forEach((l) => l.destroy());\n    this._loaders = null;\n    this.viewToLoader = null;\n    this.viewToTemplate = null;\n    this.viewPool = null;\n\n    this._items = null;\n    this._differ = null;\n    this._itemTemplate = null;\n    if (this._templateMap) {\n      this._templateMap.clear();\n    }\n    if (this._headerTemplateMap) {\n      this._headerTemplateMap.clear();\n    }\n    if (this._footerTemplateMap) {\n      this._footerTemplateMap.clear();\n    }\n    this._templateMap = null;\n    this._headerTemplateMap = null;\n    this._footerTemplateMap = null;\n  }\n\n  public ngDoCheck() {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'ngDoCheck() - execute differ? ' + this._differ);\n    }\n    if (this._differ) {\n      if (Trace.isEnabled()) {\n        CLog(CLogTypes.info, 'ngDoCheck() - execute differ');\n      }\n      const changes = this._differ.diff(this._items);\n      if (changes) {\n        if (Trace.isEnabled()) {\n          CLog(CLogTypes.info, 'ngDoCheck() - refresh');\n        }\n        this.refresh();\n      }\n    }\n  }\n\n  public registerTemplate(key: string, template: TemplateRef<ItemContext>) {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'registerTemplate for key: ' + key);\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  public registerTemplateSupplemental(key: string, template: TemplateRef<ItemContext>, type: 'header' | 'footer') {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'registerTemplate for key: ' + key);\n    }\n\n    switch (type) {\n      case 'header':\n        // if (!this._headerTemplateMap) {\n        //   this._headerTemplateMap = new Map<string, KeyedTemplate>();\n        // }\n        // this._headerTemplateMap.set(key, keyedTemplate);\n        this._collectionView.headerKey = key;\n        this.headerItemTemplate = template;\n        this._collectionView.headerItemTemplate = this.getItemTemplateViewFactory(template);\n        break;\n      case 'footer':\n        // if (!this._footerTemplateMap) {\n        //   this._footerTemplateMap = new Map<string, KeyedTemplate>();\n        // }\n\n        // this._footerTemplateMap.set(key, keyedTemplate);\n\n        this._collectionView.footerKey = key;\n        this.footerItemTemplate = template;\n        this._collectionView.footerItemTemplate = this.getItemTemplateViewFactory(template);\n        break;\n    }\n  }\n\n  @HostListener('itemLoading', ['$event'])\n  public onItemLoading(args: CollectionViewItemEventData) {\n    if (!args.view && !this.itemTemplate) {\n      return;\n    }\n    if (!this.items) return;\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 (Trace.isEnabled()) {\n      CLog(CLogTypes.info, `onItemLoading: ${index} - Reusing existing view`);\n    }\n\n    viewRef = this.getNgView(args.view);\n\n    if (!viewRef && Trace.isEnabled()) {\n      if (Trace.isEnabled()) {\n        CLog(CLogTypes.info, `ViewReference not found for item ${index}. View recycling is not working`);\n      }\n    }\n\n    if (!viewRef) {\n      if (Trace.isEnabled()) {\n        CLog(CLogTypes.info, `onItemLoading: ${index} - Creating view from template`);\n      }\n      viewRef = this.getOrCreate(this.itemTemplate) as any;\n    }\n    this.setupViewRef(viewRef, currentItem, index);\n    this.detectChangesOnChild(viewRef, index);\n  }\n  @HostListener('itemRecycling', ['$event'])\n  public onItemRecyclingInternal(args: any) {\n    if (!args.view) {\n      return;\n    }\n    const ngView = this.getNgView(args.view);\n    // console.log('recycling', args.view);\n\n    if (ngView) {\n      ngView.detach();\n    }\n  }\n\n  @HostListener('displayItem', ['$event'])\n  public onItemDisplayInternal(args: CollectionViewItemEventData) {\n    if (!args.view) {\n      return;\n    }\n    const ngView = this.getNgView(args.view);\n\n    if (ngView) {\n      ngView.reattach();\n    }\n  }\n\n  @HostListener('itemDisposing', ['$event'])\n  public onItemDisposingInternal(args: any) {\n    if (!args.view) {\n      return;\n    }\n    const ngView = this.getNgView(args.view);\n\n    if (ngView) {\n      ngView.detach();\n      this.storeViewRef(ngView);\n    }\n  }\n\n  private getNgView(view: View): EmbeddedViewRef<unknown> {\n    const ngView = 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 (!ngView && view instanceof LayoutBase && view.getChildrenCount() > 0) {\n      return view.getChildAt(0)[NG_VIEW];\n    }\n    return ngView;\n  }\n\n  public setupViewRef(view: EmbeddedViewRef<ItemContext>, data: any, index: number): void {\n    const context = view.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      context,\n      data,\n      index,\n      view,\n    });\n  }\n\n  getItemTemplateViewFactory(template: TemplateRef<ItemContext>): () => View {\n    return () => {\n      return this.getOrCreate(template);\n    };\n  }\n  viewPool = new Map<\n    TemplateRef<ItemContext>,\n    {\n      scrapSize: number;\n      scrapHead: Set<EmbeddedViewRef<ItemContext>>;\n    }\n  >();\n  private storeViewRef(viewRef: EmbeddedViewRef<any>) {\n    const templateRef = this.viewToTemplate.get(viewRef);\n    if (templateRef) {\n      const scrap = this.viewPool.get(templateRef);\n      if (scrap) {\n        if (scrap.scrapHead.size >= scrap.scrapSize) {\n          viewRef.destroy();\n          this.viewToLoader.get(viewRef)?.destroy();\n        } else {\n          scrap.scrapHead.add(viewRef);\n        }\n      }\n    }\n  }\n  viewToTemplate = new WeakMap<EmbeddedViewRef<any>, TemplateRef<any>>();\n  viewToLoader = new WeakMap<EmbeddedViewRef<any>, ComponentRef<DetachedLoader>>();\n\n  private getOrCreate(templateRef: TemplateRef<ItemContext>) {\n    return this._ngZone.run(() => {\n      let viewRef = this.getView(templateRef);\n      if (!viewRef) {\n        const loader = this.detachedLoaderFactory();\n        viewRef = loader.instance.vc.createEmbeddedView(templateRef, new ItemContext(), 0);\n        this.viewToLoader.set(viewRef, loader);\n        this.viewToTemplate.set(viewRef, templateRef);\n      }\n      viewRef.detach();\n      const resultView = getItemViewRoot(viewRef);\n      resultView[NG_VIEW] = viewRef;\n      resultView.reusable = this.autoReuseViews;\n      return resultView;\n    });\n  }\n  private getView(templateRef: TemplateRef<ItemContext>) {\n    const pool = this.getViewPool(templateRef);\n    while (pool.scrapHead.size > 0) {\n      const viewRef: EmbeddedViewRef<ItemContext> = pool.scrapHead.values().next().value;\n      pool.scrapHead.delete(viewRef);\n      if (!viewRef.destroyed) {\n        return viewRef;\n      }\n    }\n    return null;\n  }\n\n  private getViewPool(templateRef: TemplateRef<ItemContext>) {\n    if (!this.viewPool.has(templateRef)) {\n      this.viewPool.set(templateRef, {\n        scrapSize: this.autoReuseViews ? Infinity : 0,\n        scrapHead: new Set<EmbeddedViewRef<ItemContext>>(),\n      });\n    }\n    return this.viewPool.get(templateRef);\n  }\n\n  private setItemTemplates() {\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        CLog(CLogTypes.info, 'Setting templates');\n      }\n\n      const templates: KeyedTemplate[] = [];\n      this._templateMap.forEach((value) => {\n        templates.push(value);\n      });\n      this._collectionView.itemTemplates = templates;\n    } else {\n      // If the map was not initialized this means that there are no named templates, so we register the default one.\n      this._collectionView.itemTemplate = this.getItemTemplateViewFactory(this.itemTemplate);\n    }\n  }\n\n  private detectChangesOnChild(viewRef: EmbeddedViewRef<ItemContext>, index: number) {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'Manually detect changes in child: ' + index);\n    }\n    viewRef.markForCheck();\n    viewRef.detectChanges();\n  }\n\n  private refresh() {\n    if (this._collectionView) {\n      this._collectionView.refresh();\n    }\n  }\n}\n\nexport interface ComponentView {\n  rootNodes: any[];\n  destroy(): void;\n}\n\nexport type RootLocator = (nodes: any[], nestLevel: number) => View;\n\nexport function getItemViewRoot(viewRef: ComponentView, rootLocator: RootLocator = extractSingleViewRecursive): View {\n  const rootView = rootLocator(viewRef.rootNodes, 0);\n  return rootView;\n}\n\n@Directive({ selector: '[cvTemplateKey]' })\nexport class TemplateKeyDirective {\n  constructor(private templateRef: TemplateRef<any>, @Host() private collectionView: CollectionViewComponent) {}\n\n  @Input()\n  set cvTemplateKey(value: any) {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'cvTemplateKey: ' + value);\n    }\n    if (this.collectionView && this.templateRef) {\n      this.collectionView.registerTemplate(value.toLowerCase(), this.templateRef);\n    }\n  }\n}\n\n@Directive({\n  selector: '[cvTemplateHeader]',\n})\nexport class TemplateHeaderDirective {\n  constructor(private templateRef: TemplateRef<any>, @Host() private collectionView: CollectionViewComponent) {}\n\n  @Input()\n  set cvTemplateHeader(value: any) {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'cvTemplateHeader: ' + value);\n    }\n    if (this.collectionView && this.templateRef) {\n      // TODO: allow keying of multiple headers per section\n      this.collectionView.registerTemplateSupplemental(value || ViewTemplateType.Header, this.templateRef, 'header');\n    }\n  }\n}\n\n@Directive({\n  selector: '[cvTemplateFooter]',\n})\nexport class TemplateFooterDirective {\n  constructor(private templateRef: TemplateRef<any>, @Host() private collectionView: CollectionViewComponent) {}\n\n  @Input()\n  set cvTemplateFooter(value: any) {\n    if (Trace.isEnabled()) {\n      CLog(CLogTypes.info, 'cvTemplateFooter: ' + value);\n    }\n    if (this.collectionView && this.templateRef) {\n      // TODO: allow keying of multiple footers per section\n      this.collectionView.registerTemplateSupplemental(value || ViewTemplateType.Footer, this.templateRef, 'footer');\n    }\n  }\n}\n"]}