@nativescript-community/ui-collectionview 5.3.7 → 5.3.8

package/index-common.js

@@ -1,692 +0,0 @@
-var CollectionViewBase_1;
-import { Builder, CSSType, ContentView, CoreTypes, Label, Length, Observable, ObservableArray, PercentLength, Property, ProxyViewContainer, Trace, Utils, View, addWeakEventListener, booleanConverter, heightProperty, makeParser, makeValidator, profile, removeWeakEventListener, widthProperty } from '@nativescript/core';
-import { CollectionView as CollectionViewDefinition } from '.';
-export const CollectionViewTraceCategory = 'NativescriptCollectionView';
-// iOS only
-export var ContentInsetAdjustmentBehavior;
-(function (ContentInsetAdjustmentBehavior) {
-    ContentInsetAdjustmentBehavior[ContentInsetAdjustmentBehavior["Always"] = 0] = "Always";
-    ContentInsetAdjustmentBehavior[ContentInsetAdjustmentBehavior["Automatic"] = 1] = "Automatic";
-    ContentInsetAdjustmentBehavior[ContentInsetAdjustmentBehavior["Never"] = 2] = "Never";
-    ContentInsetAdjustmentBehavior[ContentInsetAdjustmentBehavior["ScrollableAxes"] = 3] = "ScrollableAxes";
-})(ContentInsetAdjustmentBehavior || (ContentInsetAdjustmentBehavior = {}));
-export var CLogTypes;
-(function (CLogTypes) {
-    CLogTypes[CLogTypes["log"] = Trace.messageType.log] = "log";
-    CLogTypes[CLogTypes["info"] = Trace.messageType.info] = "info";
-    CLogTypes[CLogTypes["warning"] = Trace.messageType.warn] = "warning";
-    CLogTypes[CLogTypes["error"] = Trace.messageType.error] = "error";
-})(CLogTypes || (CLogTypes = {}));
-export const CLog = (type, ...args) => {
-    Trace.write(args.map((a) => (a && typeof a === 'object' ? a.toString() : a)).join(' '), CollectionViewTraceCategory, type);
-};
-const autoEffectiveRowHeight = 0;
-const autoEffectiveColWidth = 0;
-// export * from 'ui/core/view';
-export var ListViewViewTypes;
-(function (ListViewViewTypes) {
-    ListViewViewTypes[ListViewViewTypes["ItemView"] = 0] = "ItemView";
-})(ListViewViewTypes || (ListViewViewTypes = {}));
-export var knownTemplates;
-(function (knownTemplates) {
-    knownTemplates.itemTemplate = 'itemTemplate';
-})(knownTemplates || (knownTemplates = {}));
-export var knownMultiTemplates;
-(function (knownMultiTemplates) {
-    knownMultiTemplates.itemTemplates = 'itemTemplates';
-})(knownMultiTemplates || (knownMultiTemplates = {}));
-function toDevicePixels(length, auto = Number.NaN, parentAvailableWidth = Number.NaN) {
-    if (length === 'auto') {
-        // tslint:disable-line
-        return auto;
-    }
-    if (typeof length === 'number') {
-        return Math.floor(Utils.layout.toDevicePixels(length));
-    }
-    if (!length) {
-        return auto;
-    }
-    switch (length.unit) {
-        case 'px':
-            return Math.floor(length.value);
-        case '%':
-            return Math.floor(parentAvailableWidth * length.value);
-        case 'dip':
-        default:
-            return Math.floor(Utils.layout.toDevicePixels(length.value));
-    }
-}
-let CollectionViewBase = CollectionViewBase_1 = class CollectionViewBase extends View {
-    static registerPlugin(key, plugin) {
-        this.plugins[key] = plugin;
-    }
-    static registerLayoutStyle(style, generator) {
-        this.layoutStyles[style] = generator;
-    }
-    constructor() {
-        super();
-        this._innerWidth = 0;
-        this._innerHeight = 0;
-        this._dataUpdatesSuspended = false;
-        this.layoutStyle = 'grid';
-        this.plugins = [];
-        // public _itemIdGenerator: (item: any, index: number, items: any) => number = (_item: any, index: number) => index;
-        this._itemIdGenerator = null;
-        this.onSpanSizeChanged = (oldValue, newValue) => {
-            const start = Date.now();
-            this.spanSize = newValue;
-            this.refresh();
-        };
-        this._isDataDirty = false;
-        this._defaultTemplate = {
-            key: 'default',
-            createView: () => {
-                if (this.itemTemplate) {
-                    return Builder.parse(this.itemTemplate, this);
-                }
-                return undefined;
-            }
-        };
-        this._itemTemplatesInternal = new Map();
-        this._itemTemplatesInternal.set(this._defaultTemplate.key, this._defaultTemplate);
-    }
-    notifyForItemAtIndex(eventName, view, index, bindingContext, native) {
-        throw new Error('Method not implemented.');
-    }
-    updateInnerSize() {
-        const lastInnerWidth = this._innerWidth;
-        const lastInnerHeight = this._innerHeight;
-        const width = this.getMeasuredWidth();
-        const height = this.getMeasuredHeight();
-        if (width === 0 || height === 0) {
-            return false;
-        }
-        this._innerWidth = width - this.effectivePaddingLeft - this.effectivePaddingRight;
-        if (this.colWidth) {
-            let newValue = toDevicePixels(this.colWidth, autoEffectiveColWidth, this._innerWidth); // We cannot use 0 for auto as it throws for android.
-            if (global.isAndroid) {
-                newValue = Math.floor(newValue);
-            }
-            if (newValue !== this._effectiveColWidth) {
-                this._effectiveColWidth = newValue;
-            }
-        }
-        this._innerHeight = height - this.effectivePaddingTop - this.effectivePaddingBottom;
-        if (this.rowHeight) {
-            let newValue = toDevicePixels(this.rowHeight, autoEffectiveRowHeight, this._innerHeight);
-            if (global.isAndroid) {
-                newValue = Math.floor(newValue);
-            }
-            if (newValue !== this._effectiveRowHeight) {
-                this._effectiveRowHeight = newValue;
-            }
-        }
-        return lastInnerWidth !== this._innerWidth || lastInnerHeight !== this._innerHeight;
-    }
-    // public onLayout(left: number, top: number, right: number, bottom: number) {
-    //     super.onLayout(left, top, right, bottom);
-    //     // on ios and during device rotation the getMeasuredWidth and getMeasuredHeight are wrong
-    //     // so we use left, top , right, bottom
-    //     this.updateInnerSize();
-    // }
-    onMeasure(widthMeasureSpec, heightMeasureSpec) {
-        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
-        // on ios and during device rotation the getMeasuredWidth and getMeasuredHeight are wrong
-        // so we use left, top , right, bottom
-        this.updateInnerSize();
-    }
-    _prepareItem(view, index) {
-        const context = this.getItemAtIndex(index);
-        if (view) {
-            // we check old bindingContext to see if properties disappeared.
-            // if so we set them to null for the View to update
-            if (view.bindingContext && view.bindingContext !== context && typeof context === 'object') {
-                Object.keys(view.bindingContext).forEach((k) => {
-                    if (!context.hasOwnProperty(k)) {
-                        context[k] = null;
-                    }
-                });
-                view.bindingContext = context;
-            }
-        }
-        return context;
-    }
-    notifyLoading(args) {
-        this.notify(args);
-    }
-    getItemAtIndex(index) {
-        // will be overriden in onItemsChangedInternal
-        const thisItems = this.items;
-        return thisItems.getItem ? thisItems.getItem(index) : thisItems[index];
-    }
-    isHorizontal() {
-        return this.orientation === 'horizontal';
-    }
-    computeSpanCount() {
-        let spanCount = 1;
-        if (this.isHorizontal()) {
-            if (this._effectiveRowHeight) {
-                spanCount = Math.max(Math.floor(this._innerHeight / this._effectiveRowHeight), 1) || 1;
-            }
-        }
-        else {
-            if (this._effectiveColWidth) {
-                spanCount = Math.max(Math.floor(this._innerWidth / this._effectiveColWidth), 1) || 1;
-            }
-        }
-        return spanCount;
-    }
-    _onRowHeightPropertyChanged(oldValue, newValue) {
-        this.refresh();
-    }
-    _onColWidthPropertyChanged(oldValue, newValue) {
-        this.refresh();
-    }
-    onItemViewLoaderChanged() { }
-    get itemViewLoader() {
-        return this._itemViewLoader;
-    }
-    set itemViewLoader(value) {
-        if (this._itemViewLoader !== value) {
-            this._itemViewLoader = value;
-            this.onItemViewLoaderChanged();
-        }
-    }
-    get padding() {
-        return this.style.padding;
-    }
-    set padding(value) {
-        this.style.padding = value;
-    }
-    get paddingTop() {
-        return this.style.paddingTop;
-    }
-    set paddingTop(value) {
-        this.style.paddingTop = value;
-    }
-    get paddingRight() {
-        return this.style.paddingRight;
-    }
-    set paddingRight(value) {
-        this.style.paddingRight = value;
-    }
-    get paddingBottom() {
-        return this.style.paddingBottom;
-    }
-    set paddingBottom(value) {
-        this.style.paddingBottom = value;
-    }
-    get paddingLeft() {
-        return this.style.paddingLeft;
-    }
-    set paddingLeft(value) {
-        this.style.paddingLeft = value;
-    }
-    resolveTemplateView(template) {
-        return Builder.parse(template, this);
-    }
-    _getDefaultItemContent() {
-        const lbl = new Label();
-        lbl['defaultItemView'] = true;
-        lbl.bind({
-            targetProperty: 'text',
-            sourceProperty: '$value'
-        });
-        return lbl;
-    }
-    getTemplateFromSelector(templateKey) {
-        const key = templateKey.toLowerCase();
-        if (this._itemTemplatesInternal.has(key)) {
-            return this._itemTemplatesInternal.get(key);
-        }
-        return this._itemTemplatesInternal.get('default');
-    }
-    getViewForViewType(viewType, templateKey) {
-        let newView;
-        if (templateKey) {
-            const template = this.getTemplateFromSelector(templateKey);
-            newView = template.createView();
-        }
-        if (!newView && this._itemViewLoader !== undefined) {
-            newView = this._itemViewLoader(templateKey);
-        }
-        if (newView) {
-            return newView;
-        }
-        let templateString;
-        switch (viewType) {
-            case ListViewViewTypes.ItemView:
-                templateString = this.itemTemplate;
-                if (templateString === undefined) {
-                    return undefined;
-                    // return this._getDefaultItemContent();
-                }
-                break;
-        }
-        return templateString === undefined ? undefined : this.resolveTemplateView(templateString);
-    }
-    onItemTemplateSelectorChanged(oldValue, newValue) {
-        const start = Date.now();
-        if (typeof newValue === 'string') {
-            if (!this._itemTemplateSelectorBindable) {
-                this._itemTemplateSelectorBindable = new ProxyViewContainer();
-            }
-            this._itemTemplateSelectorBindable.bind({
-                sourceProperty: null,
-                targetProperty: 'templateKey',
-                expression: newValue
-            });
-            this._itemTemplateSelector = function (item, index, items) {
-                item['$index'] = index;
-                this._itemTemplateSelectorBindable.bindingContext = item;
-                return this._itemTemplateSelectorBindable.get('templateKey');
-            };
-        }
-        else if (typeof newValue === 'function') {
-            this._itemTemplateSelector = newValue;
-        }
-    }
-    onItemIdGeneratorChanged(oldValue, newValue) {
-        const start = Date.now();
-        if (typeof newValue === 'string') {
-            if (!this._itemIdGeneratorBindable) {
-                this._itemIdGeneratorBindable = new ProxyViewContainer();
-            }
-            this._itemIdGeneratorBindable.bind({
-                sourceProperty: null,
-                targetProperty: 'itemId',
-                expression: newValue
-            });
-            this._itemIdGenerator = function (item, index, items) {
-                item['$index'] = index;
-                this._itemIdGeneratorBindable.bindingContext = item;
-                return this._itemIdGeneratorBindable.get('itemId');
-            };
-        }
-        else if (typeof newValue === 'function') {
-            this._itemIdGenerator = newValue;
-        }
-    }
-    onTemplateAdded(t) { }
-    onTemplateRemoved(key) { }
-    addTemplate(key, t) {
-        if (!t.key) {
-            t.key = t._key;
-            delete t._key;
-        }
-        this._itemTemplatesInternal.set(t.key.toLowerCase(), t);
-        this.onTemplateAdded(t);
-    }
-    removeTemplate(key) {
-        const didDelete = this._itemTemplatesInternal.delete(key.toLowerCase());
-        if (didDelete) {
-            this.onTemplateRemoved(key);
-        }
-    }
-    onItemTemplatesChanged(oldValue, newValue) {
-        const start = Date.now();
-        this._itemTemplatesInternal = new Map();
-        if (newValue) {
-            newValue.forEach((t) => {
-                if (!t.key) {
-                    t.key = t._key;
-                    delete t._key;
-                }
-                this._itemTemplatesInternal.set(t.key, t);
-            });
-        }
-        if (!this._itemTemplatesInternal.has(this._defaultTemplate.key)) {
-            this._itemTemplatesInternal.set(this._defaultTemplate.key, this._defaultTemplate);
-        }
-    }
-    onItemTemplateChanged(oldValue, newValue) { }
-    // onItemTemplateSelectorPropertyChanged(oldValue, newValue) {
-    //     this.onItemTemplateSelectorChanged(oldValue, newValue);
-    // }
-    getItemSourceAtIndex(index) {
-        return this.items.getItem(index);
-    }
-    getItemArrayAtIndex(index) {
-        return this.items[index];
-    }
-    onItemsChanged(oldValue, newValue) {
-        const start = Date.now();
-        const getItem = newValue && newValue.getItem;
-        this.isItemsSourceIn = typeof getItem === 'function';
-        // we override the method to prevent the test on every getItem
-        this.getItemAtIndex = this.isItemsSourceIn ? this.getItemSourceAtIndex.bind(this) : this.getItemArrayAtIndex.bind(this);
-        if (oldValue instanceof Observable) {
-            removeWeakEventListener(oldValue, ObservableArray.changeEvent, this.onSourceCollectionChangedInternal, this);
-        }
-        if (newValue instanceof Observable) {
-            addWeakEventListener(newValue, ObservableArray.changeEvent, this.onSourceCollectionChangedInternal, this);
-        }
-        this.refresh();
-    }
-    onLoaded() {
-        super.onLoaded();
-        if (this._isDataDirty && this._effectiveColWidth !== undefined && this._effectiveRowHeight !== undefined) {
-            this.refresh();
-        }
-    }
-    onSourceCollectionChanged(event) {
-        this.refresh();
-    }
-    onSourceCollectionChangedInternal(event) {
-        if (this._dataUpdatesSuspended === false) {
-            this.onSourceCollectionChanged(event);
-        }
-    }
-    // onItemsChanged(oldValue, newValue) {
-    //     this.onItemsChangedInternal(oldValue, newValue);
-    // }
-    [widthProperty.getDefault]() {
-        return '100%';
-    }
-    [heightProperty.getDefault]() {
-        return '100%';
-    }
-    suspendUpdates() {
-        this._dataUpdatesSuspended = true;
-    }
-    updatesSuspended() {
-        return this._dataUpdatesSuspended;
-    }
-    resumeUpdates(refresh) {
-        this._dataUpdatesSuspended = false;
-        if (refresh === true) {
-            this.refresh();
-        }
-    }
-    _callItemReorderedEvent(oldPosition, newPosition, item) {
-        const args = {
-            eventName: CollectionViewBase_1.itemReorderedEvent,
-            object: this,
-            index: oldPosition,
-            item,
-            data: { targetIndex: newPosition },
-            view: this.draggingView
-        };
-        this.notify(args);
-        this.draggingView = null;
-    }
-    _reorderItemInSource(oldPosition, newPosition, callEvents = true) {
-        this.suspendUpdates();
-        const ownerSource = this.items;
-        const item = this.getItemAtIndex(oldPosition);
-        ownerSource.splice(oldPosition, 1);
-        ownerSource.splice(newPosition, 0, item);
-        this.resumeUpdates(false);
-        if (callEvents) {
-            this._callItemReorderedEvent(oldPosition, newPosition, item);
-        }
-    }
-    shouldMoveItemAtIndex(index) {
-        if (!this.reorderEnabled) {
-            return false;
-        }
-        const item = this.getItemAtIndex(index);
-        const view = (this.draggingView = this.getViewForItemAtIndex(index));
-        let args = {
-            returnValue: true,
-            eventName: CollectionViewBase_1.itemReorderStartingEvent,
-            object: this,
-            index,
-            item,
-            view
-        };
-        this.notify(args);
-        if (!args.returnValue) {
-            return false;
-        }
-        args = {
-            eventName: CollectionViewBase_1.itemReorderStartedEvent,
-            object: this,
-            index,
-            item,
-            view
-        };
-        this.notify(args);
-        return true;
-    }
-};
-CollectionViewBase.itemLoadingEvent = 'itemLoading';
-CollectionViewBase.itemRecyclingEvent = 'itemRecycling';
-CollectionViewBase.itemDisposingEvent = 'itemDisposing';
-CollectionViewBase.bindedEvent = 'binded';
-CollectionViewBase.scrollEvent = 'scroll';
-CollectionViewBase.scrollStartEvent = 'scrollStart';
-CollectionViewBase.scrollEndEvent = 'scrollEnd';
-CollectionViewBase.itemTapEvent = 'itemTap';
-CollectionViewBase.displayItemEvent = 'displayItem';
-CollectionViewBase.itemReorderedEvent = 'itemReordered';
-CollectionViewBase.itemReorderStartingEvent = 'itemReorderStarting';
-CollectionViewBase.itemReorderStartedEvent = 'itemReorderStarted';
-CollectionViewBase.loadMoreItemsEvent = 'loadMoreItems';
-CollectionViewBase.dataPopulatedEvent = 'dataPopulated';
-CollectionViewBase.knownFunctions = ['itemTemplateSelector', 'itemIdGenerator', 'spanSize']; // See component-builder.ts isKnownFunction
-CollectionViewBase.plugins = {};
-CollectionViewBase.layoutStyles = {};
-__decorate([
-    profile
-], CollectionViewBase.prototype, "_prepareItem", null);
-__decorate([
-    profile
-], CollectionViewBase.prototype, "notifyLoading", null);
-__decorate([
-    profile
-], CollectionViewBase.prototype, "onItemIdGeneratorChanged", null);
-__decorate([
-    profile
-], CollectionViewBase.prototype, "onItemTemplatesChanged", null);
-__decorate([
-    profile
-], CollectionViewBase.prototype, "onItemsChanged", null);
-__decorate([
-    profile
-], CollectionViewBase.prototype, "onSourceCollectionChanged", null);
-__decorate([
-    profile
-], CollectionViewBase.prototype, "onSourceCollectionChangedInternal", null);
-CollectionViewBase = CollectionViewBase_1 = __decorate([
-    CSSType('CollectionView')
-], CollectionViewBase);
-export { CollectionViewBase };
-const defaultRowHeight = 'auto';
-export const rowHeightProperty = new Property({
-    name: 'rowHeight',
-    defaultValue: defaultRowHeight,
-    equalityComparer: PercentLength.equals,
-    valueConverter: PercentLength.parse,
-    valueChanged: (target, oldValue, newValue) => {
-        if (target._innerHeight !== 0) {
-            target._effectiveRowHeight = PercentLength.toDevicePixels(newValue, autoEffectiveRowHeight, target._innerHeight);
-            target._onRowHeightPropertyChanged(oldValue, newValue);
-        }
-    }
-});
-rowHeightProperty.register(CollectionViewBase);
-const defaultColWidth = { unit: '%', value: 1 };
-export const colWidthProperty = new Property({
-    name: 'colWidth',
-    defaultValue: defaultColWidth,
-    equalityComparer: PercentLength.equals,
-    valueConverter: PercentLength.parse,
-    valueChanged: (target, oldValue, newValue) => {
-        if (target._innerWidth !== 0) {
-            target._effectiveColWidth = PercentLength.toDevicePixels(newValue, autoEffectiveColWidth, target._innerWidth);
-            target._onColWidthPropertyChanged(oldValue, newValue);
-        }
-    }
-});
-colWidthProperty.register(CollectionViewBase);
-const converter = makeParser(makeValidator('horizontal', 'vertical'));
-export const orientationProperty = new Property({
-    name: 'orientation',
-    defaultValue: 'vertical',
-    affectsLayout: true,
-    valueChanged: (target, oldValue, newValue) => {
-        target.refresh();
-    },
-    valueConverter: converter
-});
-orientationProperty.register(CollectionViewBase);
-export const itemTemplateProperty = new Property({
-    name: 'itemTemplate',
-    valueChanged(target, oldValue, newValue) {
-        target.onItemTemplateChanged(oldValue, newValue);
-    }
-});
-itemTemplateProperty.register(CollectionViewBase);
-export const itemTemplatesProperty = new Property({
-    name: 'itemTemplates',
-    valueConverter: (value) => {
-        if (typeof value === 'string') {
-            return Builder.parseMultipleTemplates(value);
-        }
-        return value;
-    },
-    valueChanged(target, oldValue, newValue) {
-        target.onItemTemplatesChanged(oldValue, newValue);
-    }
-});
-itemTemplatesProperty.register(CollectionViewBase);
-export const itemTemplateSelectorProperty = new Property({
-    name: 'itemTemplateSelector',
-    defaultValue: undefined,
-    valueChanged(target, oldValue, newValue) {
-        target.onItemTemplateSelectorChanged(oldValue, newValue);
-    }
-});
-itemTemplateSelectorProperty.register(CollectionViewBase);
-export const itemIdGeneratorProperty = new Property({
-    name: 'itemIdGenerator',
-    defaultValue: undefined,
-    valueChanged(target, oldValue, newValue) {
-        target.onItemIdGeneratorChanged(oldValue, newValue);
-    }
-});
-itemIdGeneratorProperty.register(CollectionViewBase);
-export const itemsProperty = new Property({
-    name: 'items',
-    defaultValue: undefined,
-    valueChanged(target, oldValue, newValue) {
-        target.onItemsChanged(oldValue, newValue);
-    }
-});
-itemsProperty.register(CollectionViewBase);
-export const spanSizeProperty = new Property({
-    name: 'spanSize',
-    defaultValue: undefined,
-    valueChanged(target, oldValue, newValue) {
-        target.onSpanSizeChanged(oldValue, newValue);
-    }
-});
-spanSizeProperty.register(CollectionViewBase);
-export const isScrollEnabledProperty = new Property({
-    name: 'isScrollEnabled',
-    defaultValue: true,
-    valueConverter: booleanConverter
-});
-isScrollEnabledProperty.register(CollectionViewBase);
-export const isBounceEnabledProperty = new Property({
-    name: 'isBounceEnabled',
-    defaultValue: true,
-    valueConverter: booleanConverter
-});
-isBounceEnabledProperty.register(CollectionViewBase);
-export const reverseLayoutProperty = new Property({
-    name: 'reverseLayout',
-    defaultValue: false,
-    valueConverter: booleanConverter
-});
-reverseLayoutProperty.register(CollectionViewBase);
-export const loadMoreThresholdProperty = new Property({
-    name: 'loadMoreThreshold',
-    defaultValue: 1,
-    valueConverter: (v) => parseInt(v, 10)
-});
-loadMoreThresholdProperty.register(CollectionViewBase);
-export const reorderingEnabledProperty = new Property({
-    name: 'reorderEnabled',
-    defaultValue: false,
-    valueConverter: booleanConverter
-});
-reorderingEnabledProperty.register(CollectionViewBase);
-export const reorderLongPressEnabledProperty = new Property({
-    name: 'reorderLongPressEnabled',
-    defaultValue: false,
-    valueConverter: booleanConverter
-});
-reorderLongPressEnabledProperty.register(CollectionViewBase);
-export const scrollBarIndicatorVisibleProperty = new Property({
-    name: 'scrollBarIndicatorVisible',
-    defaultValue: true,
-    valueConverter: booleanConverter
-});
-scrollBarIndicatorVisibleProperty.register(CollectionViewBase);
-export const autoReloadItemOnLayoutProperty = new Property({
-    name: 'autoReloadItemOnLayout',
-    defaultValue: false,
-    valueConverter: booleanConverter
-});
-autoReloadItemOnLayoutProperty.register(CollectionViewBase);
-function parseThickness(value) {
-    if (typeof value === 'string') {
-        const arr = value.split(/[ ,]+/);
-        let top;
-        let right;
-        let bottom;
-        let left;
-        if (arr.length === 1) {
-            top = arr[0];
-            right = arr[0];
-            bottom = arr[0];
-            left = arr[0];
-        }
-        else if (arr.length === 2) {
-            top = arr[0];
-            bottom = arr[0];
-            right = arr[1];
-            left = arr[1];
-        }
-        else if (arr.length === 3) {
-            top = arr[0];
-            right = arr[1];
-            left = arr[1];
-            bottom = arr[2];
-        }
-        else if (arr.length === 4) {
-            top = arr[0];
-            right = arr[1];
-            bottom = arr[2];
-            left = arr[3];
-        }
-        else {
-            throw new Error('Expected 1, 2, 3 or 4 parameters. Actual: ' + value);
-        }
-        return {
-            top,
-            right,
-            bottom,
-            left
-        };
-    }
-    else {
-        return value;
-    }
-}
-export const itemOverlapProperty = new Property({
-    name: 'itemOverlap',
-    valueConverter: (value) => {
-        if (typeof value === 'string' && value !== 'auto') {
-            const thickness = parseThickness(value);
-            return [Length.parse(thickness.top), Length.parse(thickness.right), Length.parse(thickness.bottom), Length.parse(thickness.left)];
-        }
-        else {
-            return [value, value, value, value];
-        }
-    }
-});
-itemOverlapProperty.register(CollectionViewBase);
-//# sourceMappingURL=index-common.js.map