@cc-component/cc-ex-component 1.1.6 → 1.1.8

package/assets/lib/collectView/lib-ext/yx-cover-layout.ts

@@ -0,0 +1,405 @@
+import { _decorator, math } from 'cc';
+import { YXBinaryLayout, YXCollectionView, YXIndexPath, YXLayoutAttributes } from '../lib_collect/yx-collection-view';
+
+enum _yx_cover_layout_snap_mode {
+    /**
+     * 无吸附行为，就正常的惯性滚动，停到哪里算哪里    
+     */
+    NONE,
+
+    /**
+     * 在松手时立刻吸附至选中节点  
+     */
+    FAST,
+
+    /**
+     * 正常的惯性滚动，最终吸附至某个节点  
+     */
+    AUTO,
+}
+
+/**
+ * 用来实现突出选中节点效果的布局规则  
+ * 不支持分区排列  
+ */
+export class YXCoverLayout extends YXBinaryLayout {
+
+    /**
+     * @deprecated 已废弃，使用 snapMode 属性代替  
+     */
+    set pagingEnabled(value: boolean) {
+        this.snapMode = value ? _yx_cover_layout_snap_mode.FAST : _yx_cover_layout_snap_mode.NONE
+    }
+
+    /**
+     * 吸附行为模式  
+     * 默认 AUTO  
+     */
+    snapMode: _yx_cover_layout_snap_mode = _yx_cover_layout_snap_mode.AUTO
+    static SnapMode = _yx_cover_layout_snap_mode
+
+    /**
+     * 吸附过渡动画时间  
+     * 默认 0.5  
+     */
+    fastSnapDuration: number = 0.5
+
+    /**
+     * 节点大小
+     */
+    itemSize: math.Size = null
+
+    /**
+     * 间距  
+     * 默认 0  
+     */
+    spacing: number = 0
+
+    /**
+     * 非选中节点的缩放系数  
+     * 默认 0.8  
+     */
+    scaleValue: number = 0.8
+
+    /**
+     * 非选中节点的 x 轴旋转角度
+     * 仅支持 3D 节点  
+     * 默认 0
+     */
+    angleX: number = 0
+
+    /**
+     * 非选中节点的 y 轴旋转角度
+     * 仅支持 3D 节点  
+     * 默认 0  
+     */
+    angleY: number = 0
+
+    /**
+     * 非选中节点的 z 轴旋转角度  
+     * 默认 0  
+     */
+    angleZ: number = 0
+
+    /**
+     * 构造函数，此类布局必须要确定节点大小属性
+     * @param itemSize 
+     */
+    constructor(itemSize: math.Size) {
+        super()
+        this.itemSize = itemSize
+    }
+
+    /**
+     * 获取此刻最靠近屏幕中心的节点索引  
+     * @param collectionView 
+     * @returns 
+     */
+    static getCenterProximal(collectionView: YXCollectionView) {
+        let offset = collectionView.scrollView.getScrollOffset()
+        offset.x = - offset.x
+        let visibleCells = collectionView.getVisibleCellNodes()
+        let target: YXLayoutAttributes = null
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+            let mid = offset.x + collectionView.scrollView.view.width * 0.5
+            visibleCells.forEach((element) => {
+                const attr = collectionView.getElementAttributes(element)
+                let distance1 = Math.abs(attr.frame.center.x - mid)
+                let distance2 = target ? Math.abs(target.frame.center.x - mid) : null
+                if (distance2 == null || distance1 < distance2) {
+                    target = attr
+                }
+            })
+            if (target) { return target.indexPath }
+        }
+
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+            let mid = offset.y + collectionView.scrollView.view.height * 0.5
+            visibleCells.forEach((element) => {
+                const attr = collectionView.getElementAttributes(element)
+                let distance1 = Math.abs(attr.frame.center.y - mid)
+                let distance2 = target ? Math.abs(target.frame.center.y - mid) : null
+                if (distance2 == null || distance1 < distance2) {
+                    target = attr
+                }
+            })
+            if (target) { return target.indexPath }
+        }
+
+        return null
+    }
+
+    prepare(collectionView: YXCollectionView): void {
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+            this._prepare_horizontal(collectionView)
+            return
+        }
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+            this._prepare_vertical(collectionView)
+            return
+        }
+    }
+
+    protected _prepare_horizontal(collectionView: YXCollectionView) {
+        collectionView.scrollView.horizontal = true
+        collectionView.scrollView.vertical = false
+        const nodeSize = collectionView.scrollView.view.contentSize
+        let array = []
+
+        let offset = (nodeSize.width - this.itemSize.width) * 0.5
+        let y = (nodeSize.height - this.itemSize.height) * 0.5
+        let numberOfItems = collectionView.getNumberOfItems(0)
+        for (let item = 0; item < numberOfItems; item++) {
+            let indexPath = new YXIndexPath(0, item)
+            let attr = YXLayoutAttributes.layoutAttributesForCell(indexPath)
+            attr.frame.size = this.itemSize
+            attr.frame.y = y
+            attr.frame.x = offset + (item > 0 ? this.spacing : 0)
+            offset = attr.frame.xMax
+            array.push(attr)
+        }
+
+        this.attributes = array
+        let contentSize = nodeSize.clone()
+        contentSize.width = offset + (nodeSize.width - this.itemSize.width) * 0.5
+        this.contentSize = contentSize
+    }
+
+    protected _prepare_vertical(collectionView: YXCollectionView) {
+        collectionView.scrollView.horizontal = false
+        collectionView.scrollView.vertical = true
+        const nodeSize = collectionView.scrollView.view.contentSize
+        let array = []
+
+        let offset = (nodeSize.height - this.itemSize.height) * 0.5
+        let x = (nodeSize.width - this.itemSize.width) * 0.5
+        let numberOfItems = collectionView.getNumberOfItems(0)
+        for (let item = 0; item < numberOfItems; item++) {
+            let indexPath = new YXIndexPath(0, item)
+            let attr = YXLayoutAttributes.layoutAttributesForCell(indexPath)
+            attr.frame.size = this.itemSize
+            attr.frame.y = offset + (item > 0 ? this.spacing : 0)
+            attr.frame.x = x
+            offset = attr.frame.yMax
+            array.push(attr)
+        }
+
+        this.attributes = array
+        let contentSize = nodeSize.clone()
+        contentSize.height = offset + (nodeSize.height - this.itemSize.height) * 0.5
+        this.contentSize = contentSize
+    }
+
+    initOffset(collectionView: YXCollectionView): void {
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+            collectionView.scrollView.scrollToLeft(0)
+            return
+        }
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+            collectionView.scrollView.scrollToTop(0)
+            return
+        }
+    }
+
+    targetOffset(collectionView: YXCollectionView, touchMoveVelocity: math.Vec3, startOffset: math.Vec2, originTargetOffset: math.Vec2, originScrollDuration: number): { offset: math.Vec2; time?: number; attenuated?: boolean; } | null {
+
+        // 此刻偏移位置  
+        let offset = collectionView.scrollView.getScrollOffset()
+        offset.x = - offset.x
+
+        let maxScrollOffset = collectionView.scrollView.getMaxScrollOffset()
+
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+            if (this.snapMode == _yx_cover_layout_snap_mode.AUTO) {
+                // 计算出停留区域
+                let visibleRect = new math.Rect()
+                visibleRect.origin = originTargetOffset
+                visibleRect.x = - visibleRect.x
+                visibleRect.y = 0
+                if (visibleRect.x < 0) { visibleRect.x = 0 }
+                if (visibleRect.x > maxScrollOffset.x) { visibleRect.x = maxScrollOffset.x }
+                visibleRect.size = collectionView.scrollView.view.contentSize
+
+                // 获取目标区域水平中心位置  
+                let mid = visibleRect.x + collectionView.scrollView.view.width * 0.5
+                // 获取目标区域的节点
+                let result = this.layoutAttributesForElementsInRect(visibleRect, collectionView)
+                // 获取目标区域的最靠近显示范围中心节点
+                let target: YXLayoutAttributes = null
+                result.forEach((element) => {
+                    let distance1 = Math.abs(element.frame.center.x - mid)
+                    let distance2 = target ? Math.abs(target.frame.center.x - mid) : null
+                    if (distance2 == null || distance1 < distance2) {
+                        target = element
+                    }
+                })
+                // 吸附至目标偏移位置
+                if (target) {
+                    offset.x = target.frame.center.x - collectionView.scrollView.view.width * 0.5
+                    return { offset: offset, time: Math.max(originScrollDuration, this.fastSnapDuration) }
+                }
+            }
+
+            if (this.snapMode == _yx_cover_layout_snap_mode.FAST) {
+                // 此刻显示范围
+                let visibleRect = new math.Rect()
+                visibleRect.origin = offset
+                visibleRect.y = 0
+                if (visibleRect.x < 0) { visibleRect.x = 0 }
+                if (visibleRect.x > maxScrollOffset.x) { visibleRect.x = maxScrollOffset.x }
+                visibleRect.size = collectionView.scrollView.view.contentSize
+
+                // 获取目标区域水平中心位置  
+                let mid = visibleRect.x + collectionView.scrollView.view.width * 0.5
+                // 获取目标区域的节点
+                let result = this.layoutAttributesForElementsInRect(visibleRect, collectionView)
+                // 获取目标区域的最靠近显示范围中心节点
+                let target: YXLayoutAttributes = null
+                result.forEach((element) => {
+                    let distance1 = Math.abs(element.frame.center.x - mid)
+                    let distance2 = target ? Math.abs(target.frame.center.x - mid) : null
+                    if (distance2 == null || distance1 < distance2) {
+                        target = element
+                    }
+                })
+                // 吸附至目标偏移位置
+                if (target) {
+                    offset.x = target.frame.center.x - collectionView.scrollView.view.width * 0.5
+                    return { offset: offset, time: this.fastSnapDuration }
+                }
+            }
+        }
+
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+            if (this.snapMode == _yx_cover_layout_snap_mode.AUTO) {
+                // 计算出停留区域
+                let visibleRect = new math.Rect()
+                visibleRect.origin = originTargetOffset
+                visibleRect.x = 0
+                if (visibleRect.y < 0) { visibleRect.y = 0 }
+                if (visibleRect.y > maxScrollOffset.y) { visibleRect.y = maxScrollOffset.y }
+                visibleRect.size = collectionView.scrollView.view.contentSize
+
+                // 获取目标区域垂直中心位置  
+                let mid = visibleRect.y + collectionView.scrollView.view.height * 0.5
+                // 获取目标区域的节点
+                let result = this.layoutAttributesForElementsInRect(visibleRect, collectionView)
+                // 获取目标区域的最靠近显示范围中心节点
+                let target: YXLayoutAttributes = null
+                result.forEach((element) => {
+                    let distance1 = Math.abs(element.frame.center.y - mid)
+                    let distance2 = target ? Math.abs(target.frame.center.y - mid) : null
+                    if (distance2 == null || distance1 < distance2) {
+                        target = element
+                    }
+                })
+                // 吸附至目标偏移位置
+                if (target) {
+                    offset.y = target.frame.center.y - collectionView.scrollView.view.height * 0.5
+                    return { offset: offset, time: Math.max(originScrollDuration, this.fastSnapDuration) }
+                }
+            }
+
+            if (this.snapMode == _yx_cover_layout_snap_mode.FAST) {
+                // 计算出停留区域
+                let visibleRect = new math.Rect()
+                visibleRect.origin = offset
+                visibleRect.x = 0
+                if (visibleRect.y < 0) { visibleRect.y = 0 }
+                if (visibleRect.y > maxScrollOffset.y) { visibleRect.y = maxScrollOffset.y }
+                visibleRect.size = collectionView.scrollView.view.contentSize
+
+                // 获取目标区域垂直中心位置  
+                let mid = visibleRect.y + collectionView.scrollView.view.height * 0.5
+                // 获取目标区域的节点
+                let result = this.layoutAttributesForElementsInRect(visibleRect, collectionView)
+                // 获取目标区域的最靠近显示范围中心节点
+                let target: YXLayoutAttributes = null
+                result.forEach((element) => {
+                    let distance1 = Math.abs(element.frame.center.y - mid)
+                    let distance2 = target ? Math.abs(target.frame.center.y - mid) : null
+                    if (distance2 == null || distance1 < distance2) {
+                        target = element
+                    }
+                })
+                // 吸附至目标偏移位置
+                if (target) {
+                    offset.y = target.frame.center.y - collectionView.scrollView.view.height * 0.5
+                    return { offset: offset, time: this.fastSnapDuration }
+                }
+            }
+        }
+
+        return null
+    }
+
+    scrollTo(indexPath: YXIndexPath, collectionView: YXCollectionView): math.Vec2 {
+        let attr = this.layoutAttributesForItemAtIndexPath(indexPath, collectionView)
+        if (attr) {
+            let offset = attr.frame.origin
+            if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+                offset.x = offset.x - (collectionView.scrollView.view.width - attr.frame.width) * 0.5
+            }
+            if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+                offset.y = offset.y - (collectionView.scrollView.view.height - attr.frame.height) * 0.5
+            }
+            return offset
+        }
+        return null
+    }
+
+    layoutAttributesForElementsInRect(rect: math.Rect, collectionView: YXCollectionView): YXLayoutAttributes[] {
+        let result = super.layoutAttributesForElementsInRect(rect, collectionView)
+        let offset = collectionView.scrollView.getScrollOffset()
+        offset.x = - offset.x
+
+        let scale = this.scaleValue
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+            let mid = offset.x + collectionView.scrollView.view.width * 0.5
+            result.forEach((element) => {
+                let diff = element.frame.center.x - mid
+                let distance = Math.abs(diff)
+                let progress = distance / this.itemSize.width
+                progress = Math.min(1, progress)
+                let scaleValue = 1 - (1 - scale) * progress
+                element.scale = new math.Vec3(scaleValue, scaleValue, 1)
+                element.zIndex = -distance
+
+                let eulerAngles = new math.Vec3()
+                eulerAngles.x = progress * this.angleX * (diff > 0 ? -1 : 1)
+                eulerAngles.y = progress * this.angleY * (diff > 0 ? -1 : 1)
+                eulerAngles.z = progress * this.angleZ * (diff > 0 ? -1 : 1)
+                element.eulerAngles = eulerAngles
+            })
+        }
+
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+            let mid = offset.y + collectionView.scrollView.view.height * 0.5
+            result.forEach((element) => {
+                let diff = element.frame.center.y - mid
+                let distance = Math.abs(diff)
+                let progress = distance / this.itemSize.height
+                progress = Math.min(1, progress)
+                let scaleValue = 1 - (1 - scale) * progress
+                element.scale = new math.Vec3(scaleValue, scaleValue, 1)
+                element.zIndex = 1 - progress
+
+                let eulerAngles = new math.Vec3()
+                eulerAngles.x = progress * this.angleX * (diff > 0 ? -1 : 1)
+                eulerAngles.y = progress * this.angleY * (diff > 0 ? -1 : 1)
+                eulerAngles.z = progress * this.angleZ * (diff > 0 ? -1 : 1)
+                element.eulerAngles = eulerAngles
+            })
+        }
+
+        return result
+    }
+
+    shouldUpdateAttributesZIndex(): boolean {
+        return true
+    }
+
+    shouldUpdateAttributesForBoundsChange(): boolean {
+        return true
+    }
+}

package/assets/lib/collectView/lib-ext/yx-cover-layout.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "ad37dbe1-7008-4cc8-939a-dab5bbb38b08",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}

package/assets/lib/collectView/lib-ext/yx-masonry-flow-layout.ts

@@ -0,0 +1,194 @@
+import { _decorator, math, UITransform } from 'cc';
+import { YXBinaryLayout, YXCollectionView, YXEdgeInsets, YXIndexPath, YXLayoutAttributes } from '../lib_collect/yx-collection-view';
+
+/**
+ * 瀑布流布局方案
+ */
+export class YXMasonryFlowLayout extends YXBinaryLayout {
+
+    /**
+     * 分几行(水平滚动模式下)或者几列(垂直滚动模式下)展示
+     */
+    divide: number | ((section: number, layout: YXMasonryFlowLayout, collectionView: YXCollectionView) => number) = 1
+
+    /**
+     * 水平滚动模式下，仅宽度生效
+     * 垂直滚动模式下，仅高度生效
+     */
+    itemSize: math.Size | ((indexPath: YXIndexPath, layout: YXMasonryFlowLayout, collectionView: YXCollectionView) => math.Size) = new math.Size(100, 100);
+    getItemSize(): math.Size {
+        if (this.itemSize instanceof Function == false) {
+            return this.itemSize
+        }
+        throw new Error("YXMasonryFlowLayout: 动态配置的布局参数不支持直接获取，请检查自己的布局逻辑并谨慎的通过动态配置自己获取，注意避免死循环");
+    }
+
+    /**
+     * 元素之间垂直间距
+     */
+    verticalSpacing: number | ((section: number, layout: YXMasonryFlowLayout, collectionView: YXCollectionView) => number) = 0
+    getVerticalSpacing(): number {
+        if (this.verticalSpacing instanceof Function == false) {
+            return this.verticalSpacing
+        }
+        throw new Error("YXMasonryFlowLayout: 动态配置的布局参数不支持直接获取，请检查自己的布局逻辑并谨慎的通过动态配置自己获取，注意避免死循环");
+    }
+
+    /**
+     * 元素之间水平间距
+     */
+    horizontalSpacing: number | ((section: number, layout: YXMasonryFlowLayout, collectionView: YXCollectionView) => number) = 0
+    getHorizontalSpacing(): number {
+        if (this.horizontalSpacing instanceof Function == false) {
+            return this.horizontalSpacing
+        }
+        throw new Error("YXMasonryFlowLayout: 动态配置的布局参数不支持直接获取，请检查自己的布局逻辑并谨慎的通过动态配置自己获取，注意避免死循环");
+    }
+
+    /**
+     * 边距
+     */
+    sectionInset: YXEdgeInsets | ((section: number, layout: YXMasonryFlowLayout, collectionView: YXCollectionView) => YXEdgeInsets) = YXEdgeInsets.ZERO
+    getSectionInset(): YXEdgeInsets {
+        if (this.sectionInset instanceof Function == false) {
+            return this.sectionInset
+        }
+        throw new Error("YXMasonryFlowLayout: 动态配置的布局参数不支持直接获取，请检查自己的布局逻辑并谨慎的通过动态配置自己获取，注意避免死循环");
+    }
+
+    prepare(collectionView: YXCollectionView): void {
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+            this._masonry_horizontal(collectionView)
+            return
+        }
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+            this._masonry_vertical(collectionView)
+            return
+        }
+    }
+
+    private _masonry_horizontal(collectionView: YXCollectionView) {
+        collectionView.scrollView.horizontal = true
+        collectionView.scrollView.vertical = false
+        let contentSize = collectionView.node.getComponent(UITransform).contentSize.clone()
+        let allAttributes: YXLayoutAttributes[] = []
+
+        let numberOfSections = collectionView.getNumberOfSections()
+
+        let sectionMaxX = 0
+        for (let section = 0; section < numberOfSections; section++) {
+            let numberOfItems = collectionView.getNumberOfItems(section)
+            let verticalSpacing = this.verticalSpacing instanceof Function ? this.verticalSpacing(section, this, collectionView) : this.verticalSpacing
+            let horizontalSpacing = this.horizontalSpacing instanceof Function ? this.horizontalSpacing(section, this, collectionView) : this.horizontalSpacing
+            let sectionInset = this.sectionInset instanceof Function ? this.sectionInset(section, this, collectionView) : this.sectionInset
+            let divide = this.divide instanceof Function ? this.divide(section, this, collectionView) : this.divide
+            let itemHeight = (contentSize.height - sectionInset.top - sectionInset.bottom - (divide - 1) * verticalSpacing) / divide
+
+            sectionMaxX += sectionInset.left
+            // 初始化区布局信息，key=行，value=目前此行最右边的位置
+            let sectionInfos = {}
+            for (let divideIdx = 0; divideIdx < divide; divideIdx++) {
+                sectionInfos[`${divideIdx}`] = sectionMaxX
+            }
+
+            for (let item = 0; item < numberOfItems; item++) {
+                let indexPath = new YXIndexPath(section, item)
+                let itemSize = this.itemSize instanceof Function ? this.itemSize(indexPath, this, collectionView) : this.itemSize
+                itemSize.height = itemHeight
+
+                // 查找目前最短的行，在最短的行后面插入节点
+                let x = null
+                let y = null
+                let idx = null
+                for (let divideIdx = 0; divideIdx < divide; divideIdx++) {
+                    let max = sectionInfos[`${divideIdx}`]
+                    if (x == null || max < x) {
+                        idx = divideIdx
+                        x = max
+                        y = sectionInset.top + (itemHeight + verticalSpacing) * divideIdx
+                    }
+                }
+
+                let attributes = YXLayoutAttributes.layoutAttributesForCell(indexPath)
+                attributes.frame.set(x + horizontalSpacing, y, itemSize.width, itemSize.height)
+                allAttributes.push(attributes)
+
+                sectionInfos[`${idx}`] = attributes.frame.xMax
+                sectionMaxX = Math.max(sectionMaxX, attributes.frame.xMax)
+            }
+            sectionMaxX += sectionInset.right
+        }
+
+        this.attributes = allAttributes
+        contentSize.width = Math.max(contentSize.width, sectionMaxX)
+        this.contentSize = contentSize
+    }
+
+    private _masonry_vertical(collectionView: YXCollectionView) {
+        collectionView.scrollView.horizontal = false
+        collectionView.scrollView.vertical = true
+        let contentSize = collectionView.node.getComponent(UITransform).contentSize.clone()
+        let allAttributes: YXLayoutAttributes[] = []
+
+        let numberOfSections = collectionView.getNumberOfSections()
+
+        let sectionMaxY = 0
+        for (let section = 0; section < numberOfSections; section++) {
+            let numberOfItems = collectionView.getNumberOfItems(section)
+            let verticalSpacing = this.verticalSpacing instanceof Function ? this.verticalSpacing(section, this, collectionView) : this.verticalSpacing
+            let horizontalSpacing = this.horizontalSpacing instanceof Function ? this.horizontalSpacing(section, this, collectionView) : this.horizontalSpacing
+            let sectionInset = this.sectionInset instanceof Function ? this.sectionInset(section, this, collectionView) : this.sectionInset
+            let divide = this.divide instanceof Function ? this.divide(section, this, collectionView) : this.divide
+            let itemWidth = (contentSize.width - sectionInset.left - sectionInset.right - (divide - 1) * horizontalSpacing) / divide
+
+            sectionMaxY += sectionInset.top
+            // 初始化区布局信息，key=列，value=目前此列最底部的位置
+            let sectionInfos = {}
+            for (let divideIdx = 0; divideIdx < divide; divideIdx++) {
+                sectionInfos[`${divideIdx}`] = sectionMaxY
+            }
+
+            for (let item = 0; item < numberOfItems; item++) {
+                let indexPath = new YXIndexPath(section, item)
+                let itemSize = this.itemSize instanceof Function ? this.itemSize(indexPath, this, collectionView) : this.itemSize
+                itemSize.width = itemWidth
+
+                // 查找目前最短的列，在最短的列下面插入节点
+                let x = null
+                let y = null
+                let idx = null
+                for (let divideIdx = 0; divideIdx < divide; divideIdx++) {
+                    let max = sectionInfos[`${divideIdx}`]
+                    if (y == null || max < y) {
+                        idx = divideIdx
+                        y = max
+                        x = sectionInset.left + (itemWidth + horizontalSpacing) * divideIdx
+                    }
+                }
+
+                let attributes = YXLayoutAttributes.layoutAttributesForCell(indexPath)
+                attributes.frame.set(x, y + verticalSpacing, itemSize.width, itemSize.height)
+                allAttributes.push(attributes)
+
+                sectionInfos[`${idx}`] = attributes.frame.yMax
+                sectionMaxY = Math.max(sectionMaxY, attributes.frame.yMax)
+            }
+            sectionMaxY += sectionInset.bottom
+        }
+
+        this.attributes = allAttributes
+        contentSize.height = Math.max(contentSize.height, sectionMaxY)
+        this.contentSize = contentSize
+    }
+
+    initOffset(collectionView: YXCollectionView): void {
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.HORIZONTAL) {
+            collectionView.scrollView.scrollToLeft(0)
+            return
+        }
+        if (collectionView.scrollDirection == YXCollectionView.ScrollDirection.VERTICAL) {
+            collectionView.scrollView.scrollToTop(0)
+            return
+        }
+    }
+}

package/assets/lib/collectView/lib-ext/yx-masonry-flow-layout.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "2b51d44c-785f-4b16-82e2-b42cb9c0a5d8",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}