@nativescript-community/ui-collectionview 5.3.8 → 5.3.9

package/index.android.js

@@ -0,0 +1,1247 @@
+var _a, _b;
+/* eslint-disable no-redeclare */
+import { ChangeType, ContentView, CoreTypes, Length, Property, ProxyViewContainer, Trace, Utils, View, ViewBase, booleanConverter, paddingBottomProperty, paddingLeftProperty, paddingRightProperty, paddingTopProperty, profile } from '@nativescript/core';
+import { itemOverlapProperty, reorderLongPressEnabledProperty, reorderingEnabledProperty, reverseLayoutProperty, scrollBarIndicatorVisibleProperty } from '.';
+import { CLog, CLogTypes, CollectionViewBase, ListViewViewTypes, isScrollEnabledProperty, orientationProperty } from './index-common';
+export * from './index-common';
+var SimpleCallback = /** @class */ (function (_super) {
+    __extends(SimpleCallback, _super);
+    function SimpleCallback(param1, param2) {
+        var _this = _super.call(this, param1, param2) || this;
+        _this.startPosition = -1;
+        _this.endPosition = -1;
+        return global.__native(_this);
+    }
+    SimpleCallback.prototype.onMove = function (recyclerview, viewHolder, target) {
+        var _a;
+        var startPosition = viewHolder.getAdapterPosition();
+        var endPosition = target.getAdapterPosition();
+        if (this.startPosition === -1) {
+            this.startPosition = startPosition;
+        }
+        this.endPosition = endPosition;
+        var owner = (_a = this.owner) === null || _a === void 0 ? void 0 : _a.get();
+        if (owner) {
+            owner._reorderItemInSource(startPosition, endPosition);
+            return true;
+        }
+        return false;
+    };
+    SimpleCallback.prototype.onSelectedChanged = function (viewHolder, state) {
+        var _a;
+        if (viewHolder) {
+            if (this.startPosition === -1) {
+                this.startPosition = viewHolder.getAdapterPosition();
+            }
+        }
+        if (!viewHolder) {
+            // this is where we identify the end of the drag and call the end event
+            var owner = (_a = this.owner) === null || _a === void 0 ? void 0 : _a.get();
+            if (this.endPosition === -1) {
+                this.endPosition = this.startPosition;
+            }
+            if (owner) {
+                var item = owner.getItemAtIndex(this.startPosition);
+                owner._callItemReorderedEvent(this.startPosition, this.endPosition, item);
+            }
+            this.startPosition = -1;
+            this.endPosition = -1;
+            owner.isDragging = false;
+        }
+    };
+    SimpleCallback.prototype.onSwiped = function (viewHolder, direction) { };
+    SimpleCallback.prototype.isItemViewSwipeEnabled = function () {
+        // disabled for now
+        return false;
+    };
+    SimpleCallback.prototype.isLongPressDragEnabled = function () {
+        // we use our custom longpress gesture handler
+        return false;
+    };
+    return SimpleCallback;
+}(androidx.recyclerview.widget.ItemTouchHelper.SimpleCallback));
+var LongPressGestureListenerImpl = /** @class */ (function (_super) {
+    __extends(LongPressGestureListenerImpl, _super);
+    function LongPressGestureListenerImpl(_owner) {
+        var _this = _super.call(this) || this;
+        _this._owner = _owner;
+        return global.__native(_this);
+    }
+    LongPressGestureListenerImpl.prototype.onLongPress = function (motionEvent) {
+        var _a;
+        var owner = (_a = this._owner) === null || _a === void 0 ? void 0 : _a.get();
+        if (owner) {
+            owner.onReorderLongPress(motionEvent);
+        }
+    };
+    return LongPressGestureListenerImpl;
+}(android.view.GestureDetector.SimpleOnGestureListener));
+let LayoutParams;
+const extraLayoutSpaceProperty = new Property({
+    name: 'extraLayoutSpace'
+});
+const itemViewCacheSizeProperty = new Property({
+    name: 'itemViewCacheSize'
+});
+const nestedScrollingEnabledProperty = new Property({
+    name: 'nestedScrollingEnabled',
+    defaultValue: true,
+    valueConverter: booleanConverter
+});
+export var SnapPosition;
+(function (SnapPosition) {
+    SnapPosition[SnapPosition["START"] = 0] = "START";
+    SnapPosition[SnapPosition["END"] = 1] = "END";
+})(SnapPosition || (SnapPosition = {}));
+export class CollectionView extends CollectionViewBase {
+    constructor() {
+        super(...arguments);
+        this.templateTypeNumberString = new Map();
+        this.templateStringTypeNumber = new Map();
+        this._currentNativeItemType = 0;
+        this.currentSpanCount = 1;
+        // used to store viewHolder and thus their corresponding Views
+        // used to "destroy" cells when possible
+        this._viewHolders = new Set();
+        this._scrollOrLoadMoreChangeCount = 0;
+        this.scrolling = false;
+        this.needsScrollStartEvent = false;
+        this.animateItemUpdate = false;
+        this.mInPropertiesSet = false;
+        this.mShouldUpdateInnerSize = false;
+        this.mShouldUpdateSpanCount = false;
+        this.mShouldRefresh = false;
+        this.defaultPoolSize = 10;
+        this.desiredPoolSize = new Map();
+        this.isDragging = false;
+        this._layedOut = false;
+        this.bindedViewHolders = new Set();
+    }
+    onResumeNativeUpdates() {
+        // {N} suspends properties update on `_suspendNativeUpdates`. So we only need to do this in onResumeNativeUpdates
+        this.mInPropertiesSet = true;
+        super.onResumeNativeUpdates();
+        this.mInPropertiesSet = false;
+        if (this.mShouldUpdateInnerSize) {
+            this.updateInnerSize();
+        }
+        if (this.mShouldUpdateSpanCount) {
+            this.updateSpanCount();
+        }
+        if (this.mShouldRefresh) {
+            this.refresh();
+        }
+    }
+    createNativeView() {
+        // storing the class in a property for reuse in the future cause a materializing which is pretty slow!
+        if (!CollectionViewRecyclerView) {
+            CollectionViewRecyclerView = com.nativescript.collectionview.RecyclerView;
+        }
+        const recyclerView = CollectionViewRecyclerView.createRecyclerView(this._context);
+        // const expMgr = new RecyclerViewExpandableItemManager(null);
+        // adapter.setDisplayHeadersAtStartUp(true).setStickyHeaders(true); //Make headers sticky
+        // Endless scroll with 1 item threshold
+        // .setLoadingMoreAtStartUp(true)
+        // .setEndlessScrollListener(this, new ProgressItem())
+        // .setEndlessScrollThreshold(1); //Default=1
+        // const fastScroller = new com.l4digital.fastscroll.FastScroller(this._context);
+        // fastScroller.setSectionIndexer(adapter);
+        // fastScroller.attachRecyclerView(recyclerView);
+        return recyclerView;
+    }
+    initNativeView() {
+        super.initNativeView();
+        const nativeView = this.nativeViewProtected;
+        if (!this.recycledViewPool) {
+            this.recycledViewPool = new com.nativescript.collectionview.RecycledViewPool();
+            this.recycledViewPoolDisposeListener = new com.nativescript.collectionview.RecycledViewPool.ViewPoolListener({
+                onViewHolderDisposed: (holder) => {
+                    if (Trace.isEnabled()) {
+                        CLog(CLogTypes.log, 'onViewHolderDisposed', holder);
+                    }
+                    if (this._viewHolders) {
+                        this._viewHolders.delete(holder);
+                    }
+                    const isNonSync = holder['defaultItemView'] === true;
+                    const view = isNonSync ? holder.view.content : holder.view;
+                    this.notifyForItemAtIndex(CollectionViewBase.itemDisposingEvent, view, holder.getAdapterPosition(), view.bindingContext, holder);
+                    if (view && view.isLoaded) {
+                        view.callUnloaded();
+                    }
+                    view._isAddedToNativeVisualTree = false;
+                    //@ts-ignore
+                    view.parent = null;
+                    view._tearDownUI();
+                }
+            });
+            this.recycledViewPool.mListener = this.recycledViewPoolDisposeListener;
+        }
+        if (Trace.isEnabled() || this.hasListeners(CollectionViewBase.itemRecyclingEvent)) {
+            const recyclerListener = (this.recyclerListener = new androidx.recyclerview.widget.RecyclerView.RecyclerListener({
+                onViewRecycled: (holder) => {
+                    if (Trace.isEnabled()) {
+                        CLog(CLogTypes.log, 'onViewRecycled', this, nativeView, holder);
+                    }
+                    const isNonSync = holder['defaultItemView'] === true;
+                    const view = isNonSync ? holder.view.content : holder.view;
+                    this.notifyForItemAtIndex(CollectionViewBase.itemRecyclingEvent, view, holder.getAdapterPosition(), view.bindingContext, holder);
+                }
+            }));
+            nativeView.setRecyclerListener(recyclerListener);
+        }
+        nativeView.setRecycledViewPool(this.recycledViewPool);
+        let layoutManager;
+        if (CollectionViewBase.layoutStyles[this.layoutStyle]) {
+            layoutManager = CollectionViewBase.layoutStyles[this.layoutStyle].createLayout(this);
+        }
+        else {
+            layoutManager = new com.nativescript.collectionview.PreCachingGridLayoutManager(this._context, 1);
+            if (this.hasListeners(CollectionView.layoutCompletedEvent)) {
+                layoutManager.layoutCompletedListener = new com.nativescript.collectionview.GridLayoutManager.LayoutCompletedListener({
+                    onLayoutCompleted: () => {
+                        this.notify({ eventName: CollectionView.layoutCompletedEvent });
+                    }
+                });
+            }
+            // layoutManager = new PreCachingGridLayoutManager(this._context, 1);
+            // (layoutManager as any).owner = new WeakRef(this);
+        }
+        // this.spanSize
+        nativeView.setLayoutManager(layoutManager);
+        nativeView.layoutManager = layoutManager;
+        nativeView.sizeChangedListener = new com.nativescript.collectionview.SizeChangedListener({
+            onLayout: (changed, left, top, right, bottom) => changed && this.onLayout(left, top, right, bottom),
+            onMeasure: (widthMeasureSpec, heightMeasureSpec) => this.onMeasure(widthMeasureSpec, heightMeasureSpec)
+        });
+        this.spanSize = this._getSpanSize;
+        // const animator = new jp.wasabeef.recyclerview.animators.FadeInAnimator();
+        // // animator.setInterpolator(new android.view.animation.OvershootInterpolator());
+        // animator.setMoveDuration(200);
+        // Change animations are enabled by default since support-v7-recyclerview v22.
+        // Need to disable them when using animation indicator.
+        // animator.setSupportsChangeAnimations(false);
+        // nativeView.setItemAnimator(animator);
+        // enforce the first refresh for the collectionview to be ready as soon as possible
+        this.refresh(true);
+    }
+    disposeNativeView() {
+        // this.eachChildView((view) => {
+        //     view.parent._removeView(view);
+        //     return true;
+        // });
+        // this._realizedItems.clear();
+        const nativeView = this.nativeViewProtected;
+        nativeView.setRecyclerListener(null);
+        nativeView.setRecycledViewPool(null);
+        this.recycledViewPoolDisposeListener = null;
+        this.recycledViewPool = null;
+        if (nativeView.scrollListener) {
+            this.nativeView.removeOnScrollListener(nativeView.scrollListener);
+            nativeView.scrollListener = null;
+            this._nScrollListener = null;
+        }
+        nativeView.sizeChangedListener = null;
+        nativeView.layoutManager = null;
+        this._listViewAdapter = null;
+        this._itemTouchHelper = null;
+        this._simpleItemTouchCallback = null;
+        this.disposeViewHolderViews();
+        this.clearTemplateTypes();
+        super.disposeNativeView();
+    }
+    onLoaded() {
+        super.onLoaded();
+        this.attachScrollListener();
+        // this.refresh();
+    }
+    getViewForItemAtIndex(index) {
+        return this.enumerateViewHolders((v) => (v.getAdapterPosition() === index ? v.view : undefined));
+    }
+    //@ts-ignore
+    set spanSize(inter) {
+        if (!(typeof inter === 'function')) {
+            return;
+        }
+        this._getSpanSize = inter;
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager['setSpanSizeLookup']) {
+            if (inter) {
+                layoutManager['setSpanSizeLookup'](new com.nativescript.collectionview.SpanSizeLookup(new com.nativescript.collectionview.SpanSizeLookup.Interface({
+                    getSpanSize: (position) => {
+                        const dataItem = this.getItemAtIndex(position);
+                        return Math.min(inter(dataItem, position), this.currentSpanCount);
+                    }
+                })));
+            }
+            else {
+                layoutManager['setSpanSizeLookup'](null);
+            }
+        }
+    }
+    get spanSize() {
+        return this._getSpanSize;
+    }
+    attachScrollListener() {
+        if (this._scrollOrLoadMoreChangeCount > 0 && this.isLoaded) {
+            const nativeView = this.nativeViewProtected;
+            if (!nativeView.scrollListener) {
+                this._nScrollListener = new com.nativescript.collectionview.OnScrollListener.Listener({
+                    onScrollStateChanged: this.onScrollStateChanged.bind(this),
+                    onScrolled: this.onScrolled.bind(this)
+                });
+                const scrollListener = new com.nativescript.collectionview.OnScrollListener(this._nScrollListener);
+                nativeView.addOnScrollListener(scrollListener);
+                nativeView.scrollListener = scrollListener;
+            }
+        }
+    }
+    detachScrollListener() {
+        if (this._scrollOrLoadMoreChangeCount === 0 && this.isLoaded) {
+            const nativeView = this.nativeViewProtected;
+            if (nativeView.scrollListener) {
+                this.nativeView.removeOnScrollListener(nativeView.scrollListener);
+                nativeView.scrollListener = null;
+                this._nScrollListener = null;
+            }
+        }
+    }
+    computeScrollEventData(view, eventName, dx, dy) {
+        const horizontal = this.isHorizontal();
+        const offset = horizontal ? view.computeHorizontalScrollOffset() : view.computeVerticalScrollOffset();
+        const range = horizontal ? view.computeHorizontalScrollRange() : view.computeVerticalScrollRange();
+        const extent = horizontal ? view.computeHorizontalScrollExtent() : view.computeVerticalScrollExtent();
+        return {
+            object: this,
+            eventName,
+            scrollOffset: offset / Utils.layout.getDisplayDensity(),
+            scrollOffsetPercentage: offset / (range - extent),
+            dx,
+            dy
+        };
+    }
+    onScrolled(view, dx, dy) {
+        if (!this || !this.scrolling) {
+            return;
+        }
+        if (this.needsScrollStartEvent) {
+            this.needsScrollStartEvent = false;
+            if (this.hasListeners(CollectionViewBase.scrollStartEvent)) {
+                this.notify(this.computeScrollEventData(view, CollectionViewBase.scrollStartEvent, dx, dy));
+            }
+        }
+        if (this.hasListeners(CollectionViewBase.scrollEvent)) {
+            this.notify(this.computeScrollEventData(view, CollectionViewBase.scrollEvent, dx, dy));
+        }
+        if (this.hasListeners(CollectionViewBase.loadMoreItemsEvent) && this.items) {
+            const layoutManager = view.getLayoutManager();
+            if (layoutManager['findLastCompletelyVisibleItemPosition']) {
+                const lastVisibleItemPos = layoutManager['findLastCompletelyVisibleItemPosition']();
+                const loadMoreItemIndex = this.items.length - this.loadMoreThreshold;
+                if (lastVisibleItemPos === loadMoreItemIndex) {
+                    this.notify({ eventName: CollectionViewBase.loadMoreItemsEvent });
+                }
+            }
+            else if (layoutManager['findLastCompletelyVisibleItemPositions'] && layoutManager['getSpanCount']) {
+                let positions = Array.create('int', layoutManager['getSpanCount']());
+                positions = layoutManager['findLastCompletelyVisibleItemPositions'](positions);
+                let lastVisibleItemPos = 0;
+                for (let i = 0; i < positions.length; i++) {
+                    if (positions[i] > lastVisibleItemPos) {
+                        lastVisibleItemPos = positions[i];
+                    }
+                }
+                const loadMoreItemIndex = this.items.length - this.loadMoreThreshold;
+                if (lastVisibleItemPos >= loadMoreItemIndex) {
+                    this.notify({ eventName: CollectionViewBase.loadMoreItemsEvent });
+                }
+            }
+        }
+    }
+    onScrollStateChanged(view, newState) {
+        if (this.scrolling && newState === 0) {
+            // SCROLL_STATE_IDLE
+            this.scrolling = false;
+            if (this.hasListeners(CollectionViewBase.scrollEndEvent)) {
+                this.notify(this.computeScrollEventData(view, CollectionViewBase.scrollEndEvent));
+            }
+        }
+        else if (!this.scrolling && newState === 1) {
+            //SCROLL_STATE_DRAGGING
+            this.needsScrollStartEvent = true;
+            this.scrolling = true;
+        }
+    }
+    addEventListener(arg, callback, thisArg) {
+        super.addEventListener(arg, callback, thisArg);
+        if (arg === CollectionViewBase.scrollEvent || arg === CollectionViewBase.scrollStartEvent || arg === CollectionViewBase.scrollEndEvent || arg === CollectionViewBase.loadMoreItemsEvent) {
+            this._scrollOrLoadMoreChangeCount++;
+            this.attachScrollListener();
+        }
+    }
+    removeEventListener(arg, callback, thisArg) {
+        super.removeEventListener(arg, callback, thisArg);
+        if (arg === CollectionViewBase.scrollEvent || arg === CollectionViewBase.scrollStartEvent || arg === CollectionViewBase.scrollEndEvent || arg === CollectionViewBase.loadMoreItemsEvent) {
+            this._scrollOrLoadMoreChangeCount--;
+            this.detachScrollListener();
+        }
+    }
+    //@ts-ignore
+    get android() {
+        return this.nativeView;
+    }
+    get layoutManager() {
+        return this.nativeViewProtected && this.nativeViewProtected.layoutManager;
+    }
+    _getViewLayoutParams() {
+        if (this.isHorizontal()) {
+            if (!this._hlayoutParams) {
+                LayoutParams = LayoutParams || android.view.ViewGroup.LayoutParams;
+                this._hlayoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
+            }
+            return this._hlayoutParams;
+        }
+        else {
+            if (!this._vlayoutParams) {
+                LayoutParams = LayoutParams || android.view.ViewGroup.LayoutParams;
+                this._vlayoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+            }
+            return this._vlayoutParams;
+        }
+    }
+    setNativePoolSize(key, nativeIndex) {
+        if (this.desiredPoolSize.has(key)) {
+            this.nativeViewProtected.getRecycledViewPool().setMaxRecycledViews(nativeIndex, this.desiredPoolSize.get(key));
+        }
+        else {
+            if (this.defaultPoolSize >= 0) {
+                this.nativeViewProtected.getRecycledViewPool().setMaxRecycledViews(nativeIndex, this.defaultPoolSize);
+            }
+        }
+    }
+    setPoolSizes() {
+        if (!this.nativeViewProtected || !this.templateTypeNumberString) {
+            return;
+        }
+        this.desiredPoolSize.forEach((v, k) => {
+            if (this.templateTypeNumberString.has(k)) {
+                this.nativeViewProtected.getRecycledViewPool().setMaxRecycledViews(this.templateTypeNumberString.get(k), v);
+            }
+        });
+    }
+    setPoolSize(key, size) {
+        this.desiredPoolSize.set(key, size);
+        this.setPoolSizes();
+    }
+    [paddingTopProperty.getDefault]() {
+        return { value: this._defaultPaddingTop, unit: 'px' };
+    }
+    [paddingTopProperty.setNative](value) {
+        this._setPadding({ top: this.effectivePaddingTop });
+    }
+    [paddingRightProperty.getDefault]() {
+        return { value: this._defaultPaddingRight, unit: 'px' };
+    }
+    [paddingRightProperty.setNative](value) {
+        this._setPadding({ right: this.effectivePaddingRight });
+    }
+    [paddingBottomProperty.getDefault]() {
+        return { value: this._defaultPaddingBottom, unit: 'px' };
+    }
+    [paddingBottomProperty.setNative](value) {
+        this._setPadding({ bottom: this.effectivePaddingBottom });
+    }
+    [paddingLeftProperty.getDefault]() {
+        return { value: this._defaultPaddingLeft, unit: 'px' };
+    }
+    [paddingLeftProperty.setNative](value) {
+        this._setPadding({ left: this.effectivePaddingLeft });
+    }
+    [itemOverlapProperty.setNative](value) {
+        if (!this.decorator) {
+            this.decorator = new com.nativescript.collectionview.OverlapDecoration();
+            this.nativeViewProtected.addItemDecoration(this.decorator);
+        }
+        this.decorator.top = Length.toDevicePixels(value[0], 0);
+        this.decorator.right = Length.toDevicePixels(value[1], 0);
+        this.decorator.bottom = Length.toDevicePixels(value[2], 0);
+        this.decorator.left = Length.toDevicePixels(value[3], 0);
+    }
+    [orientationProperty.getDefault]() {
+        return 'vertical';
+    }
+    [orientationProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (!layoutManager || !layoutManager['setOrientation']) {
+            return;
+        }
+        if (this.isHorizontal()) {
+            layoutManager['setOrientation'](0);
+        }
+        else {
+            layoutManager['setOrientation'](1);
+        }
+        this.updateScrollBarVisibility(this.scrollBarIndicatorVisible);
+    }
+    [isScrollEnabledProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager.setScrollEnabled) {
+            layoutManager.setScrollEnabled(value);
+        }
+    }
+    [reverseLayoutProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager.setReverseLayout) {
+            layoutManager.setReverseLayout(value);
+            // layoutManager['setStackFromEnd'](value);
+        }
+    }
+    [nestedScrollingEnabledProperty.setNative](value) {
+        this.nativeViewProtected.setNestedScrollingEnabled(value);
+    }
+    [extraLayoutSpaceProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager['setExtraLayoutSpace']) {
+            layoutManager['setExtraLayoutSpace'](value);
+        }
+    }
+    [itemViewCacheSizeProperty.setNative](value) {
+        this.nativeViewProtected.setItemViewCacheSize(value);
+    }
+    [scrollBarIndicatorVisibleProperty.getDefault]() {
+        return true;
+    }
+    [scrollBarIndicatorVisibleProperty.setNative](value) {
+        this.updateScrollBarVisibility(value);
+    }
+    updateScrollBarVisibility(value) {
+        if (!this.nativeViewProtected) {
+            return;
+        }
+        if (this.orientation === 'horizontal') {
+            this.nativeViewProtected.setHorizontalScrollBarEnabled(value);
+        }
+        else {
+            this.nativeViewProtected.setVerticalScrollBarEnabled(value);
+        }
+    }
+    enumerateViewHolders(cb) {
+        let result, v;
+        for (let it = this._viewHolders.values(), cellItemView = null; (cellItemView = it.next().value);) {
+            if (cellItemView['position'] === undefined) {
+                continue;
+            }
+            result = cb(cellItemView);
+            if (result) {
+                return result;
+            }
+        }
+        return result;
+    }
+    async enumerateViewHoldersAsync(cb) {
+        let result, v;
+        for (let it = this._viewHolders.values(), cellItemView = null; (cellItemView = it.next().value);) {
+            if (cellItemView['position'] === undefined) {
+                continue;
+            }
+            result = await cb(cellItemView);
+            if (result) {
+                return result;
+            }
+        }
+        return result;
+    }
+    startDragging(index) {
+        if (this.reorderEnabled && this._itemTouchHelper) {
+            // let viewHolder: CollectionViewCellHolder;
+            const viewHolder = this.enumerateViewHolders((v) => (v.getAdapterPosition() === index ? v : undefined));
+            if (viewHolder) {
+                this.startViewHolderDragging(index, viewHolder);
+            }
+        }
+    }
+    startViewHolderDragging(index, viewHolder) {
+        // isDragging is to prevent longPress from triggering and starting a new drag
+        // when triggered manually
+        if (!this.isDragging && this.shouldMoveItemAtIndex(index)) {
+            this.isDragging = true;
+            this._itemTouchHelper.startDrag(viewHolder);
+        }
+    }
+    onReorderLongPress(motionEvent) {
+        const collectionView = this.nativeViewProtected;
+        if (!collectionView) {
+            return;
+        }
+        const view = collectionView.findChildViewUnder(motionEvent.getX(), motionEvent.getY());
+        const viewHolder = view != null ? collectionView.getChildViewHolder(view) : null;
+        if (viewHolder) {
+            this.startViewHolderDragging(viewHolder.getAdapterPosition(), viewHolder);
+        }
+    }
+    _reorderItemInSource(oldPosition, newPosition) {
+        const adapter = this._listViewAdapter;
+        // 3. Tell adapter to render the model update.
+        adapter.notifyItemMoved(oldPosition, newPosition);
+        // on android _reorderItemInSource is call on every "move" and needs to update the adapter/items
+        // we will call events only at then end
+        super._reorderItemInSource(oldPosition, newPosition, false);
+    }
+    [_a = reorderLongPressEnabledProperty.setNative](value) {
+        if (value) {
+            if (!this._longPressGesture) {
+                this._longPressGesture = new androidx.core.view.GestureDetectorCompat(this._context, new LongPressGestureListenerImpl(new WeakRef(this)));
+                this._itemTouchListerner = new androidx.recyclerview.widget.RecyclerView.OnItemTouchListener({
+                    onInterceptTouchEvent: (view, event) => {
+                        if (this.reorderEnabled && this._longPressGesture) {
+                            this._longPressGesture.onTouchEvent(event);
+                        }
+                        return false;
+                    },
+                    onTouchEvent: (param0, param1) => { },
+                    onRequestDisallowInterceptTouchEvent: (disallowIntercept) => { }
+                });
+            }
+            this.nativeViewProtected.addOnItemTouchListener(this._itemTouchListerner);
+        }
+        else {
+            if (this._itemTouchListerner) {
+                this.nativeViewProtected.removeOnItemTouchListener(this._itemTouchListerner);
+            }
+        }
+    }
+    [_b = reorderingEnabledProperty.setNative](value) {
+        if (value) {
+            if (!this._simpleItemTouchCallback) {
+                const ItemTouchHelper = androidx.recyclerview.widget.ItemTouchHelper;
+                this._simpleItemTouchCallback = new SimpleCallback(ItemTouchHelper.UP | ItemTouchHelper.DOWN | ItemTouchHelper.START | ItemTouchHelper.END, 0);
+                this._simpleItemTouchCallback.owner = new WeakRef(this);
+                this._itemTouchHelper = new androidx.recyclerview.widget.ItemTouchHelper(this._simpleItemTouchCallback);
+                this._itemTouchHelper.attachToRecyclerView(this.nativeViewProtected);
+            }
+        }
+    }
+    onItemViewLoaderChanged() {
+        if (this.itemViewLoader) {
+            this.refresh();
+        }
+    }
+    onItemTemplateSelectorChanged(oldValue, newValue) {
+        super.onItemTemplateSelectorChanged(oldValue, newValue);
+        this.clearTemplateTypes();
+        this.refresh();
+    }
+    onItemTemplateChanged(oldValue, newValue) {
+        super.onItemTemplateChanged(oldValue, newValue); // TODO: update current template with the new one
+        this.refresh();
+    }
+    onItemTemplatesChanged(oldValue, newValue) {
+        super.onItemTemplatesChanged(oldValue, newValue); // TODO: update current template with the new one
+        this.refresh();
+    }
+    updateSpanCount(requestLayout = true) {
+        if (this.mInPropertiesSet) {
+            this.mShouldUpdateSpanCount = true;
+            return false;
+        }
+        this.mShouldUpdateSpanCount = false;
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager['setSpanCount']) {
+            const newValue = (this.currentSpanCount = this.computeSpanCount());
+            if (newValue !== layoutManager['getSpanCount']()) {
+                layoutManager['setSpanCount'](newValue);
+                if (requestLayout) {
+                    layoutManager.requestLayout();
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    updateInnerSize() {
+        if (this.mInPropertiesSet) {
+            this.mShouldUpdateInnerSize = true;
+            return false;
+        }
+        this.mShouldUpdateInnerSize = false;
+        const result = super.updateInnerSize();
+        if (result) {
+            this.updateSpanCount();
+        }
+        // there is no need to call refresh if it was triggered before with same size.
+        // this refresh is just to handle size change
+        const layoutKey = this._innerWidth + '_' + this._innerHeight;
+        if (this._isDataDirty || (this._lastLayoutKey && this._lastLayoutKey !== layoutKey)) {
+            // setTimeout(() => this.refresh(false), 0);
+        }
+        this._lastLayoutKey = layoutKey;
+        return result;
+    }
+    _onColWidthPropertyChanged(oldValue, newValue) {
+        this.updateSpanCount();
+        super._onColWidthPropertyChanged(oldValue, newValue);
+    }
+    _onRowHeightPropertyChanged(oldValue, newValue) {
+        this.updateSpanCount();
+        super._onRowHeightPropertyChanged(oldValue, newValue);
+    }
+    onLayout(left, top, right, bottom) {
+        this._layedOut = true;
+        // super.onLayout(left, top, right, bottom);
+        const p = CollectionViewBase.plugins[this.layoutStyle];
+        if (p && p.onLayout) {
+            p.onLayout(this, left, top, right, bottom);
+        }
+        this.plugins.forEach((k) => {
+            const p = CollectionViewBase.plugins[k];
+            p.onLayout && p.onLayout(this, left, top, right, bottom);
+        });
+    }
+    onMeasure(widthMeasureSpec, heightMeasureSpec) {
+        const lastLayoutKey = this._lastLayoutKey;
+        this.updateInnerSize();
+        if (lastLayoutKey !== this._lastLayoutKey) {
+            //we need to refresh visible cells so that they measure to the new size
+            // for some reason it gets animated even with setSupportsChangeAnimations(false)
+            // so we clear until it is done
+            const nativeView = this.nativeViewProtected;
+            const animator = nativeView.getItemAnimator();
+            nativeView.setItemAnimator(null);
+            this.refreshVisibleItems();
+            setTimeout(() => {
+                nativeView.setItemAnimator(animator);
+            }, 0);
+        }
+        const p = CollectionViewBase.plugins[this.layoutStyle];
+        if (p && p.onMeasure) {
+            p.onMeasure(this, widthMeasureSpec, heightMeasureSpec);
+        }
+        this.plugins.forEach((k) => {
+            const p = CollectionViewBase.plugins[k];
+            p.onMeasure && p.onMeasure(this, widthMeasureSpec, heightMeasureSpec);
+        });
+    }
+    onSourceCollectionChanged(event) {
+        if (!this._listViewAdapter || this._dataUpdatesSuspended) {
+            return;
+        }
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onItemsChanged', event.action, event.index, event.addedCount, event.removed, event.removed && event.removed.length);
+        }
+        switch (event.action) {
+            case ChangeType.Delete: {
+                this._listViewAdapter.notifyItemRangeRemoved(event.index, event.removed.length);
+                return;
+            }
+            case ChangeType.Add: {
+                if (event.addedCount > 0) {
+                    this._listViewAdapter.notifyItemRangeInserted(event.index, event.addedCount);
+                }
+                // Reload the items to avoid duplicate Load on Demand indicators:
+                return;
+            }
+            case ChangeType.Update: {
+                if (event.addedCount > 0) {
+                    this._listViewAdapter.notifyItemRangeChanged(event.index, event.addedCount);
+                }
+                return;
+            }
+            case ChangeType.Splice: {
+                const added = event.addedCount;
+                const removed = (event.removed && event.removed.length) || 0;
+                if (added > 0 && added === removed) {
+                    // notifyItemRangeChanged wont create a fade effect
+                    if (!this.animateItemUpdate) {
+                        this._listViewAdapter.notifyItemRangeChanged(event.index, added);
+                    }
+                    else {
+                        this._listViewAdapter.notifyItemRangeRemoved(event.index, added);
+                        this._listViewAdapter.notifyItemRangeInserted(event.index, added);
+                    }
+                }
+                else {
+                    if (!this.animateItemUpdate) {
+                        if (added > removed) {
+                            if (removed > 0) {
+                                this._listViewAdapter.notifyItemRangeChanged(event.index, removed);
+                            }
+                            this._listViewAdapter.notifyItemRangeInserted(event.index + removed, added - removed);
+                        }
+                        else {
+                            if (added > 0) {
+                                this._listViewAdapter.notifyItemRangeChanged(event.index, added);
+                            }
+                            this._listViewAdapter.notifyItemRangeRemoved(event.index + added, removed - added);
+                        }
+                    }
+                    else {
+                        if (event.removed && event.removed.length > 0) {
+                            this._listViewAdapter.notifyItemRangeRemoved(event.index, event.removed.length);
+                        }
+                        if (event.addedCount > 0) {
+                            this._listViewAdapter.notifyItemRangeInserted(event.index, event.addedCount);
+                        }
+                    }
+                }
+                return;
+            }
+        }
+        this._listViewAdapter.notifyDataSetChanged();
+    }
+    eachChild(callback) {
+        // used for css updates (like theme change)
+        this.enumerateViewHolders((v) => {
+            const view = v.view;
+            if (view) {
+                if (view.parent instanceof CollectionView) {
+                    callback(view);
+                }
+                else {
+                    // in some cases (like item is unloaded from another place (like angular) view.parent becomes undefined)
+                    if (view.parent) {
+                        callback(view.parent);
+                    }
+                }
+            }
+        });
+    }
+    async eachChildAsync(callback) {
+        return this.enumerateViewHoldersAsync(async (v) => {
+            const view = v.view;
+            if (view) {
+                if (view.parent instanceof CollectionView) {
+                    await callback(view);
+                }
+                else {
+                    // in some cases (like item is unloaded from another place (like angular) view.parent becomes undefined)
+                    if (view.parent) {
+                        await callback(view.parent);
+                    }
+                }
+            }
+        });
+    }
+    refreshVisibleItems() {
+        const view = this.nativeViewProtected;
+        if (!view) {
+            return;
+        }
+        const ids = Array.from(this.bindedViewHolders).sort((a, b) => a - b);
+        this._listViewAdapter.notifyItemRangeChanged(ids[0], ids[ids.length - 1] - ids[0] + 1);
+    }
+    isItemAtIndexVisible(index) {
+        const view = this.nativeViewProtected;
+        if (!view) {
+            return false;
+        }
+        const layoutManager = this.layoutManager;
+        if (layoutManager['findFirstVisibleItemPosition']) {
+            const first = layoutManager.findFirstVisibleItemPosition();
+            const last = layoutManager.findLastVisibleItemPosition();
+            return index >= first && index <= last;
+        }
+        return false;
+    }
+    refresh(forceRefresh = false, updateSpanCountRequestsLayout = false) {
+        if (this.mInPropertiesSet) {
+            this.mShouldRefresh = true;
+            return;
+        }
+        this.mShouldRefresh = false;
+        const view = this.nativeViewProtected;
+        if (!view) {
+            return;
+        }
+        // seems like we refresh sooner
+        // not sure why it was needed before and not now.
+        if (!forceRefresh && (!this.isLoaded || !this.nativeView)) {
+            this._isDataDirty = true;
+            return;
+        }
+        this._isDataDirty = false;
+        this._lastLayoutKey = this._innerWidth + '_' + this._innerHeight;
+        let adapter = this._listViewAdapter;
+        if (!adapter) {
+            adapter = this._listViewAdapter = this.createComposedAdapter(view);
+            adapter.setHasStableIds(!!this._itemIdGenerator);
+            view.setAdapter(adapter);
+        }
+        else if (!view.getAdapter()) {
+            view.setAdapter(adapter);
+        }
+        this.updateSpanCount(updateSpanCountRequestsLayout);
+        adapter.notifyDataSetChanged();
+        this.notify({ eventName: CollectionViewBase.dataPopulatedEvent });
+    }
+    //@ts-ignore
+    get scrollOffset() {
+        const view = this.nativeViewProtected;
+        if (!view) {
+            return 0;
+        }
+        return (this.isHorizontal() ? view.computeHorizontalScrollOffset() : view.computeVerticalScrollOffset()) / Utils.layout.getDisplayDensity();
+    }
+    get verticalOffsetX() {
+        const view = this.nativeViewProtected;
+        if (!view) {
+            return 0;
+        }
+        return view.computeHorizontalScrollOffset() / Utils.layout.getDisplayDensity();
+    }
+    get verticalOffsetY() {
+        const view = this.nativeViewProtected;
+        if (!view) {
+            return 0;
+        }
+        return view.computeVerticalScrollOffset() / Utils.layout.getDisplayDensity();
+    }
+    scrollToIndex(index, animated = true, snap = SnapPosition.START) {
+        const view = this.nativeViewProtected;
+        if (!view) {
+            return;
+        }
+        if (animated) {
+            view.smoothScrollToPosition(index, snap);
+        }
+        else {
+            view.scrollToPosition(index);
+        }
+    }
+    scrollToOffset(offSetValue) {
+        const view = this.nativeViewProtected;
+        if (view && this.isScrollEnabled) {
+            if (this.orientation === 'horizontal') {
+                view.scrollBy(offSetValue, 0);
+            }
+            else {
+                view.scrollBy(0, offSetValue);
+            }
+        }
+    }
+    _setPadding(newPadding) {
+        const nativeView = this.nativeViewProtected;
+        const padding = {
+            top: nativeView.getPaddingTop(),
+            right: nativeView.getPaddingRight(),
+            bottom: nativeView.getPaddingBottom(),
+            left: nativeView.getPaddingLeft()
+        };
+        // tslint:disable-next-line:prefer-object-spread
+        const newValue = Object.assign(padding, newPadding);
+        nativeView.setClipToPadding(false);
+        nativeView.setPadding(newValue.left, newValue.top, newValue.right, newValue.bottom);
+        this.updateInnerSize();
+    }
+    createComposedAdapter(recyclerView) {
+        const adapter = new com.nativescript.collectionview.Adapter();
+        adapter.adapterInterface = new com.nativescript.collectionview.AdapterInterface({
+            getItemId: this.getItemId.bind(this),
+            getItemViewType: this.getItemViewType.bind(this),
+            getItemCount: this.getItemCount.bind(this),
+            onCreateViewHolder: this.onCreateViewHolder.bind(this),
+            onBindViewHolder: this.onBindViewHolder.bind(this),
+            onViewRecycled: this.onViewRecycled.bind(this)
+        });
+        // const composedAdapter = new com.h6ah4i.android.widget.advrecyclerview.composedadapter.ComposedAdapter();
+        // composedAdapter.addAdapter(new CollectionViewAdapter(new WeakRef(this)));
+        return adapter;
+    }
+    getItemCount() {
+        return this.items ? this.items.length : 0;
+    }
+    getItem(i) {
+        if (this.items && i < this.items.length) {
+            return this.getItemAtIndex(i);
+        }
+        return null;
+    }
+    getItemId(i) {
+        let id = -1;
+        if (this._itemIdGenerator && this.items) {
+            const item = this.getItemAtIndex(i);
+            id = this._itemIdGenerator(item, i, this.items);
+        }
+        return long(id);
+    }
+    onItemIdGeneratorChanged(oldValue, newValue) {
+        super.onItemIdGeneratorChanged(oldValue, newValue);
+        if (this._listViewAdapter) {
+            this._listViewAdapter.setHasStableIds(!!newValue);
+        }
+    }
+    clearTemplateTypes() {
+        this._currentNativeItemType = 0;
+        this.templateTypeNumberString.clear();
+        this.templateStringTypeNumber.clear();
+    }
+    getItemViewType(position) {
+        let selectorType = 'default';
+        if (this._itemTemplateSelector) {
+            const selector = this._itemTemplateSelector;
+            const dataItem = this.getItemAtIndex(position);
+            if (dataItem) {
+                selectorType = selector.call(this, dataItem, position, this.items);
+            }
+        }
+        return this.templateKeyToNativeItem(selectorType);
+        // if (!this.templateTypeNumberString.has(selectorType)) {
+        //     resultType = this._currentNativeItemType;
+        //     this.templateTypeNumberString.set(selectorType, resultType);
+        //     this.templateStringTypeNumber.set(resultType, selectorType);
+        //     this._currentNativeItemType++;
+        // } else {
+        //     resultType = this.templateTypeNumberString.get(selectorType);
+        // }
+        // return resultType;
+    }
+    templateKeyToNativeItem(key) {
+        if (!this.templateTypeNumberString) {
+            this.templateTypeNumberString = new Map();
+            this._currentNativeItemType = 0;
+            this._itemTemplatesInternal.forEach((v, i) => {
+                this.templateTypeNumberString.set(v.key, this._currentNativeItemType);
+                this.templateStringTypeNumber.set(this._currentNativeItemType, v.key);
+                this.setNativePoolSize(v.key, this._currentNativeItemType);
+                this._currentNativeItemType++;
+            });
+            this._currentNativeItemType = Math.max(this._itemTemplatesInternal.size, 100);
+            // templates will be numbered 0,1,2,3... for named templates
+            // default/unnamed templates will be numbered 100, 101, 102, 103...
+        }
+        if (!this.templateTypeNumberString.has(key)) {
+            this.templateTypeNumberString.set(key, this._currentNativeItemType);
+            this.templateStringTypeNumber.set(this._currentNativeItemType, key);
+            this.setNativePoolSize(key, this._currentNativeItemType);
+            this._currentNativeItemType++;
+        }
+        return this.templateTypeNumberString.get(key);
+    }
+    // public nativeItemToTemplateKey(item: number): string {
+    //     let result: string;
+    //     this.templateTypeNumberString?.forEach((value, key, map) => {
+    //         if (value === item) {
+    //             result = key;
+    //         }
+    //     }, this);
+    //     return result;
+    // }
+    disposeViewHolderViews() {
+        this.enumerateViewHolders((v) => {
+            const view = v.view;
+            if (view) {
+                if (view.isLoaded) {
+                    view.callUnloaded();
+                }
+                view._isAddedToNativeVisualTree = false;
+                view._tearDownUI();
+            }
+            v.view = null;
+            v.clickListener = null;
+        });
+        this._viewHolders = new Set();
+    }
+    getKeyByValue(viewType) {
+        return this.templateStringTypeNumber.get(viewType);
+    }
+    onCreateViewHolder(parent, viewType) {
+        const start = Date.now();
+        let view = this.getViewForViewType(ListViewViewTypes.ItemView, this.getKeyByValue(viewType));
+        const isNonSync = view === undefined;
+        // dont create unecessary StackLayout if template.createView returns. Will happend when not using Vue or angular
+        if (isNonSync || view instanceof ProxyViewContainer) {
+            const parentView = new ContentView();
+            parentView.id = 'collectionViewHolder';
+            view = parentView;
+        }
+        view._setupAsRootView(this._context);
+        view._isAddedToNativeVisualTree = true;
+        //@ts-ignore
+        view.parent = this;
+        view.callLoaded();
+        if (!CollectionViewCellHolder) {
+            CollectionViewCellHolder = com.nativescript.collectionview.CollectionViewCellHolder;
+        }
+        const holder = new CollectionViewCellHolder(view.nativeView);
+        const collectionView = this;
+        const clickListener = new android.view.View.OnClickListener({
+            onClick: () => {
+                const position = holder.getAdapterPosition();
+                collectionView.notify({
+                    eventName: CollectionViewBase.itemTapEvent,
+                    object: collectionView,
+                    index: position,
+                    item: collectionView.getItem(position),
+                    view: holder.view
+                });
+            }
+        });
+        view.nativeView.setOnClickListener(clickListener);
+        holder.clickListener = clickListener;
+        holder.view = view;
+        const layoutParams = this._getViewLayoutParams();
+        view.nativeView.setLayoutParams(layoutParams);
+        if (isNonSync) {
+            holder['defaultItemView'] = true;
+        }
+        this._viewHolders.add(holder);
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onCreateViewHolder', this, this.nativeView, viewType, this.getKeyByValue(viewType), holder, Date.now() - start, 'ms');
+        }
+        return holder;
+    }
+    notifyForItemAtIndex(eventName, view, index, bindingContext, native) {
+        const args = { eventName, object: this, index, view, ios: native, bindingContext };
+        this.notify(args);
+        return args;
+    }
+    onBindViewHolder(holder, position) {
+        const start = Date.now();
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onBindViewHolder', this, this.nativeView, position, holder, holder.view);
+        }
+        let view = holder.view;
+        const isNonSync = holder['defaultItemView'] === true;
+        view = isNonSync ? view.content : view;
+        const bindingContext = this._prepareItem(view, position);
+        if (holder['position'] !== undefined) {
+            this.bindedViewHolders.delete(holder['position']);
+        }
+        holder['position'] = position;
+        this.bindedViewHolders.add(holder['position']);
+        const args = this.notifyForItemAtIndex(CollectionViewBase.itemLoadingEvent, view, position, bindingContext, holder);
+        if (isNonSync && args.view !== view) {
+            view = args.view;
+            // the view has been changed on the event handler
+            holder.view.content = args.view;
+        }
+        view.bindingContext = bindingContext;
+        view.notify({ eventName: CollectionViewBase.bindedEvent });
+        let width = this._effectiveColWidth;
+        let height = this._effectiveRowHeight;
+        if (this._getSpanSize) {
+            const spanSize = this._getSpanSize(bindingContext, position);
+            const horizontal = this.isHorizontal();
+            if (horizontal) {
+                height *= spanSize;
+            }
+            else {
+                width *= spanSize;
+            }
+        }
+        if (width || !view.width) {
+            view.width = Utils.layout.toDeviceIndependentPixels(width);
+        }
+        if (height || !view.height) {
+            view.height = Utils.layout.toDeviceIndependentPixels(height);
+        }
+        // if (this.hasListeners(CollectionViewBase.displayItemEvent) ) {
+        //     this.notify<CollectionViewItemDisplayEventData>({
+        //         eventName: CollectionViewBase.displayItemEvent,
+        //         index:position,
+        //         object: this,
+        //     });
+        // }
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onBindViewHolder done ', position, Date.now() - start, 'ms');
+        }
+    }
+    onViewRecycled(holder) {
+        delete this.bindedViewHolders[holder['position']];
+        holder['position'] = undefined;
+    }
+}
+CollectionView.layoutCompletedEvent = 'layoutCompleted';
+CollectionView.DEFAULT_TEMPLATE_VIEW_TYPE = 0;
+CollectionView.CUSTOM_TEMPLATE_ITEM_TYPE = 1;
+__decorate([
+    profile
+], CollectionView.prototype, "createNativeView", null);
+__decorate([
+    profile
+], CollectionView.prototype, "initNativeView", null);
+__decorate([
+    profile
+], CollectionView.prototype, "disposeNativeView", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onLoaded", null);
+__decorate([
+    profile
+], CollectionView.prototype, "attachScrollListener", null);
+__decorate([
+    profile
+], CollectionView.prototype, "setNativePoolSize", null);
+__decorate([
+    profile
+], CollectionView.prototype, "setPoolSizes", null);
+__decorate([
+    profile
+], CollectionView.prototype, _a, null);
+__decorate([
+    profile
+], CollectionView.prototype, _b, null);
+__decorate([
+    profile
+], CollectionView.prototype, "onItemViewLoaderChanged", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onItemTemplateSelectorChanged", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onItemTemplateChanged", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onItemTemplatesChanged", null);
+__decorate([
+    profile
+], CollectionView.prototype, "updateSpanCount", null);
+__decorate([
+    profile
+], CollectionView.prototype, "updateInnerSize", null);
+__decorate([
+    profile
+], CollectionView.prototype, "_onColWidthPropertyChanged", null);
+__decorate([
+    profile
+], CollectionView.prototype, "_onRowHeightPropertyChanged", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onLayout", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onMeasure", null);
+__decorate([
+    profile
+], CollectionView.prototype, "refresh", null);
+__decorate([
+    profile
+], CollectionView.prototype, "_setPadding", null);
+__decorate([
+    profile
+], CollectionView.prototype, "createComposedAdapter", null);
+__decorate([
+    profile
+], CollectionView.prototype, "clearTemplateTypes", null);
+__decorate([
+    profile
+], CollectionView.prototype, "getItemViewType", null);
+__decorate([
+    profile
+], CollectionView.prototype, "templateKeyToNativeItem", null);
+__decorate([
+    profile
+], CollectionView.prototype, "disposeViewHolderViews", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onCreateViewHolder", null);
+__decorate([
+    profile
+], CollectionView.prototype, "notifyForItemAtIndex", null);
+__decorate([
+    profile
+], CollectionView.prototype, "onBindViewHolder", null);
+let CollectionViewCellHolder;
+let CollectionViewRecyclerView;
+itemViewCacheSizeProperty.register(CollectionViewBase);
+extraLayoutSpaceProperty.register(CollectionViewBase);
+nestedScrollingEnabledProperty.register(CollectionViewBase);
+//# sourceMappingURL=index.android.js.map