lyb-pixi-js 1.12.40 → 1.12.41

package/Components/Custom/LibPixiSlider.d.ts

@@ -0,0 +1,82 @@
+import { Container } from "pixi.js";
+import { LibPixiContainer } from "../Base/LibPixiContainer";
+interface LibPixiSliderParams {
+    /** 滑动区域宽度 */
+    width: number;
+    /** 滑动区域高度 */
+    height: number;
+    /** 滑动页列表 */
+    slideList: Container[];
+    /** 是否启用循环滑动 */
+    loop?: boolean;
+    /** 是否启用景深 */
+    enableDepth?: boolean;
+    /** 景深透明度 */
+    depthAlpha?: number;
+    /** 景深缩放 */
+    depthScale?: number;
+    /** 滑动回调 */
+    slideCallback: (pageIndex: number, _pageNum: number) => void;
+}
+/** @description 类似轮播图，但是不会自动轮播
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiSlider-横向滑动图
+ */
+export declare class LibPixiSlider extends LibPixiContainer {
+    /** 当前幻灯片索引 */
+    private _currentIndex;
+    /** 滑动区域宽度 */
+    private _slideWidth;
+    /** 滑动区域高度 */
+    private _slideHeight;
+    /** 是否启用循环 */
+    private _loop;
+    /** 记录拖动开始时的X坐标 */
+    private _startX;
+    /** 偏移量 */
+    private _offsetX;
+    /** 最大索引 */
+    private _pageNum;
+    /** 记录开始时间 */
+    private _startTime;
+    private _isDragging;
+    /** 滑动内容 */
+    private _slideArea;
+    /** 是否启用景深 */
+    private _enableDepth;
+    /** 景深透明度 */
+    private _depthAlpha;
+    /** 景深缩放 */
+    private _depthScale;
+    /** 滑动容器列表 */
+    private _slideList;
+    /** @description 滑动回调 */
+    private slideCallback;
+    /**
+     * @param width 宽度
+     * @param height 高度
+     * @param content 内容
+     * @param slideCallback 滑动结束回调
+     */
+    constructor(params: LibPixiSliderParams);
+    /** @description 上一页 */
+    prev(): void;
+    /** @description 下一页 */
+    next(): void;
+    /** @description 滑动到指定索引
+     * @param index 索引
+     */
+    private _slideTo;
+    /** @description 开始拖动 */
+    private _onDragStart;
+    /** @description 拖动中 */
+    private _onDragMove;
+    /** @description 结束拖动 */
+    private _onDragEnd;
+    /** @description 设置滚动景深
+     * @param containerList 元素列表
+     * @param y 拖动Y坐标
+     * @param startY 内部将y - startY进行计算
+     */
+    private _setDepth;
+}
+export {};

package/Components/Custom/LibPixiSlider.js

@@ -0,0 +1,165 @@
+import { Container } from "pixi.js";
+import gsap from "gsap";
+import { LibJsLerp } from "lyb-js/Math/LibJsLerp.js";
+import { libPixiOverflowHidden } from "../../Utils/LibPixiOverflowHidden";
+import { LibPixiContainer } from "../Base/LibPixiContainer";
+import { libPixiEvent } from "../../Utils/LibPixiEvent";
+/** @description 类似轮播图，但是不会自动轮播
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiSlider-横向滑动图
+ */
+export class LibPixiSlider extends LibPixiContainer {
+    /**
+     * @param width 宽度
+     * @param height 高度
+     * @param content 内容
+     * @param slideCallback 滑动结束回调
+     */
+    constructor(params) {
+        const { width, height, slideList, slideCallback, loop = false, enableDepth = false, depthAlpha = 0.5, depthScale = 0.5, } = params;
+        super(width, height);
+        /** 当前幻灯片索引 */
+        this._currentIndex = 0;
+        /** 滑动区域宽度 */
+        this._slideWidth = 0;
+        /** 滑动区域高度 */
+        this._slideHeight = 0;
+        /** 是否启用循环 */
+        this._loop = false;
+        /** 记录拖动开始时的X坐标 */
+        this._startX = 0;
+        /** 偏移量 */
+        this._offsetX = 0;
+        /** 最大索引 */
+        this._pageNum = 0;
+        /** 记录开始时间 */
+        this._startTime = new Date().getTime();
+        /* 是否正在拖动 */
+        this._isDragging = false;
+        libPixiOverflowHidden(this);
+        this._slideArea = new Container();
+        this._slideWidth = width;
+        this._slideHeight = height;
+        this._loop = loop;
+        this._slideList = slideList;
+        this._enableDepth = enableDepth;
+        this._depthAlpha = depthAlpha;
+        this._depthScale = depthScale;
+        this.slideCallback = slideCallback;
+        this._pageNum = slideList.length - 1;
+        this._slideList.forEach((item, index) => {
+            this._slideArea.addChild(item);
+            item.x = index * width + this._slideWidth / 2;
+            item.y = this._slideHeight / 2;
+            item.pivot.set(this._slideWidth / 2, this._slideHeight / 2);
+        });
+        this.addChild(this._slideArea);
+        libPixiEvent(this, "pointerdown", this._onDragStart.bind(this));
+        window.addEventListener("pointermove", this._onDragMove.bind(this));
+        window.addEventListener("pointerup", this._onDragEnd.bind(this));
+    }
+    /** @description 上一页 */
+    prev() {
+        this._slideTo(this._currentIndex - 1);
+    }
+    /** @description 下一页 */
+    next() {
+        this._slideTo(this._currentIndex + 1);
+    }
+    /** @description 滑动到指定索引
+     * @param index 索引
+     */
+    _slideTo(index) {
+        let x = 0;
+        if (this._loop) {
+            this._currentIndex =
+                (index + this._slideList.length) % this._slideList.length;
+            x = -this._currentIndex * this._slideWidth;
+        }
+        else {
+            if (index < 0) {
+                // 回弹到第一张
+                x = 0;
+                this._currentIndex = 0;
+            }
+            else if (index > this._pageNum) {
+                // 回弹到最后一张
+                x = -this._pageNum * this._slideWidth;
+                this._currentIndex = this._pageNum;
+            }
+            else {
+                // 正常滑动
+                x = -index * this._slideWidth;
+                this._currentIndex = index;
+            }
+        }
+        gsap.to(this._slideArea, {
+            x,
+            duration: 0.25,
+            onUpdate: () => {
+                this._setDepth();
+            },
+        });
+        this.slideCallback(this._currentIndex, this._pageNum);
+    }
+    /** @description 开始拖动 */
+    _onDragStart(event) {
+        this._isDragging = true;
+        this._startX = event.global.x;
+        this._offsetX = this._slideArea.x;
+        gsap.killTweensOf(this._slideArea);
+        this._startTime = new Date().getTime();
+    }
+    /** @description 拖动中 */
+    _onDragMove(event) {
+        if (!this._isDragging)
+            return;
+        const moveX = event.pageX - this._startX;
+        this._slideArea.x = this._offsetX + moveX;
+        this._setDepth();
+    }
+    /** @description 结束拖动 */
+    _onDragEnd(event) {
+        if (!this._isDragging)
+            return;
+        this._isDragging = false;
+        const endTime = new Date().getTime() - this._startTime;
+        const slide = this._startX - event.pageX;
+        const slideSpeed = Math.abs(slide) / endTime;
+        //滑动距离阈值，滑动到一半以上必定翻页
+        const slideThreshold = this._slideWidth / 2;
+        //滑动速度阈值，滑动速度大于这个值，必定翻页
+        const speedThreshold = 0.275;
+        //如果滑动距离大于阈值，或速度大于阈值翻页
+        if (Math.abs(slide) > slideThreshold || slideSpeed > speedThreshold) {
+            slide > 0 ? this._currentIndex++ : this._currentIndex--;
+        }
+        this._slideTo(this._currentIndex);
+    }
+    /** @description 设置滚动景深
+     * @param containerList 元素列表
+     * @param y 拖动Y坐标
+     * @param startY 内部将y - startY进行计算
+     */
+    _setDepth() {
+        if (!this._enableDepth)
+            return;
+        const Y = this._slideArea.x;
+        const idx = Math.floor(Math.abs(Y) / this._slideWidth);
+        const t = (Math.abs(Y) % this._slideWidth) / this._slideWidth;
+        const prevIdx = idx - 1;
+        const nextIdx = idx + 1;
+        const curItem = this._slideList[idx];
+        curItem.alpha = LibJsLerp(this._depthAlpha, 1, 1 - t);
+        curItem.scale.set(LibJsLerp(this._depthScale, 1, 1 - t));
+        if (nextIdx < this._slideList.length) {
+            const nextItem = this._slideList[nextIdx];
+            nextItem.alpha = LibJsLerp(this._depthAlpha, 1, t);
+            nextItem.scale.set(LibJsLerp(this._depthScale, 1, t));
+        }
+        if (prevIdx >= 0) {
+            const prevItem = this._slideList[prevIdx];
+            prevItem.alpha = LibJsLerp(this._depthAlpha, 1, 1 - t);
+            prevItem.scale.set(LibJsLerp(this._depthScale, 1, 1 - t));
+        }
+    }
+}

package/Components/Custom/LibPixiTable.d.ts

@@ -0,0 +1,64 @@
+/** @description 表格绘制并填入数字 */
+import { Container } from "pixi.js";
+export interface LibPixiTableParams {
+    /** 表格数据 */
+    data: (number | string)[][];
+    /** 是否需要表格外框 */
+    outsideBorder?: boolean;
+    /** 单元格宽度 */
+    cellWidth?: number;
+    /** 单元格高度 */
+    cellHeight?: number;
+    /** 字体大小 */
+    fontSize?: number;
+    /** 字体颜色 */
+    fontColor?: string;
+    /** 表格第一列字体颜色 */
+    firstColumnFontColor?: string;
+    /** 是否需要加粗 */
+    fontBold?: boolean;
+    /** 线条厚度 */
+    lineWidth?: number;
+    /** 线条颜色 */
+    lineColor?: string;
+}
+/** @description 绘制表格并填充数字
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiTable-数字表格
+ */
+export declare class LibPixiTable extends Container {
+    /** 行数 */
+    private _rows;
+    /** 列数 */
+    private _cols;
+    /** 单元格宽度 */
+    private _cellWidth;
+    /** 单元格高度 */
+    private _cellHeight;
+    /** 字体大小 */
+    private _fontSize;
+    /** 线条宽度 */
+    private _lineWidth;
+    /** 字体颜色 */
+    private _fontColor;
+    /** 表格第一列字体颜色 */
+    private _firstColumnFontColor;
+    /** 线条颜色 */
+    private _lineColor;
+    /** 是否需要表格外框 */
+    private _outsideBorder;
+    /** 是否需要加粗 */
+    private _fontBold;
+    /** 二维数字数组 */
+    private _data;
+    constructor(params: LibPixiTableParams);
+    /** @description 绘制表格 */
+    private _drawTable;
+    /** @description 填充数字 */
+    private fillNumbers;
+    /** @description 创建数字文本
+     * @param number 数字
+     * @param col 列索引
+     * @param row 行索引
+     */
+    private _createNumberText;
+}

package/Components/Custom/LibPixiTable.js

@@ -0,0 +1,76 @@
+/** @description 表格绘制并填入数字 */
+import { Container, Graphics, Text } from "pixi.js";
+import { libPixiScaleContainer } from '../../Utils/LibPixiScaleContainer';
+/** @description 绘制表格并填充数字
+ * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiTable-数字表格
+ */
+export class LibPixiTable extends Container {
+    constructor(params) {
+        super();
+        const { data, cellWidth = 130, cellHeight = 100, fontColor = "#fff", firstColumnFontColor = "#fff", fontSize = 30, lineWidth = 2, lineColor = "#5b5b5b", outsideBorder = true, fontBold = true, } = params;
+        this._data = data;
+        this._rows = data.length;
+        this._cols = data[0].length;
+        this._cellWidth = cellWidth;
+        this._cellHeight = cellHeight;
+        this._fontColor = fontColor;
+        this._fontSize = fontSize;
+        this._lineWidth = lineWidth;
+        this._lineColor = lineColor;
+        this._outsideBorder = outsideBorder;
+        this._fontBold = fontBold;
+        this._firstColumnFontColor = firstColumnFontColor;
+        this._drawTable();
+        this.fillNumbers();
+    }
+    /** @description 绘制表格 */
+    _drawTable() {
+        const tableWidth = this._cellWidth * this._cols;
+        const tableHeight = this._cellHeight * this._rows;
+        const graphics = new Graphics();
+        graphics.lineStyle(this._lineWidth, this._lineColor);
+        // 绘制表格外框
+        if (this._outsideBorder) {
+            graphics.drawRect(0, 0, tableWidth, tableHeight);
+        }
+        // 绘制横线
+        for (let i = 1; i < this._rows; i++) {
+            graphics.moveTo(0, i * this._cellHeight);
+            graphics.lineTo(tableWidth, i * this._cellHeight);
+        }
+        // 绘制竖线
+        for (let j = 1; j < this._cols; j++) {
+            graphics.moveTo(j * this._cellWidth, 0);
+            graphics.lineTo(j * this._cellWidth, tableHeight);
+        }
+        this.addChild(graphics);
+    }
+    /** @description 填充数字 */
+    fillNumbers() {
+        for (let row = 0; row < this._rows; row++) {
+            for (let col = 0; col < this._cols; col++) {
+                const number = this._data[row][col];
+                this._createNumberText(number, col, row);
+            }
+        }
+    }
+    /** @description 创建数字文本
+     * @param number 数字
+     * @param col 列索引
+     * @param row 行索引
+     */
+    _createNumberText(number, col, row) {
+        const text = new Text(number.toString(), {
+            _fontSize: this._fontSize,
+            fill: col === 0 ? this._firstColumnFontColor : this._fontColor,
+            fontWeight: this._fontBold ? "bold" : "normal",
+        });
+        // 计算文本的居中位置
+        const x = col * this._cellWidth + this._cellWidth / 2;
+        const y = row * this._cellHeight + this._cellHeight / 2;
+        this.addChild(text);
+        text.anchor.set(0.5);
+        text.position.set(x, y);
+        libPixiScaleContainer(text, this._cellWidth * 0.9);
+    }
+}

package/Components/Custom/LibPixiTextGroupWrap.d.ts

@@ -0,0 +1,20 @@
+import { Container, type ITextStyle } from "pixi.js";
+interface TextItem {
+    text: string;
+    style?: Partial<ITextStyle>;
+}
+interface TextGroupOptions {
+    items: TextItem[];
+    defaultStyle?: Partial<ITextStyle>;
+    wordWrapWidth?: number;
+    paddingX?: number;
+    paddingY?: number;
+    align?: "left" | "center" | "right";
+    anchorX?: number;
+    anchorY?: number;
+}
+/** @description 文本组换行 */
+export declare class LibPixiTextGroupWrap extends Container {
+    constructor({ items, defaultStyle, wordWrapWidth, paddingX, paddingY, align, anchorX, anchorY, }: TextGroupOptions);
+}
+export {};

package/Components/Custom/LibPixiTextGroupWrap.js

@@ -0,0 +1,50 @@
+import { Container, Text } from "pixi.js";
+/** @description 文本组换行 */
+export class LibPixiTextGroupWrap extends Container {
+    constructor({ items, defaultStyle = {}, wordWrapWidth, paddingX = 0, paddingY = 0, align = "left", anchorX = 0, anchorY = 0, }) {
+        super();
+        if (!items.length)
+            return;
+        const lineGroups = [];
+        let currentLine = [];
+        let x = 0;
+        // 分行
+        for (const { text, style = {} } of items) {
+            const instance = new Text(text, Object.assign(Object.assign({}, defaultStyle), style));
+            const w = instance.width;
+            if (wordWrapWidth && x + w > wordWrapWidth && x > 0) {
+                lineGroups.push(currentLine);
+                currentLine = [];
+                x = 0;
+            }
+            currentLine.push(instance);
+            x += w + paddingX;
+        }
+        if (currentLine.length)
+            lineGroups.push(currentLine);
+        // 布局每行
+        let y = 0;
+        for (const line of lineGroups) {
+            const totalWidth = line.reduce((sum, i) => sum + i.width + paddingX, -paddingX);
+            let offsetX = 0;
+            if (align === "center" && wordWrapWidth)
+                offsetX = (wordWrapWidth - totalWidth) / 2;
+            else if (align === "right" && wordWrapWidth)
+                offsetX = wordWrapWidth - totalWidth;
+            let currentX = offsetX;
+            let maxHeight = 0;
+            for (const item of line) {
+                item.x = currentX;
+                item.y = y;
+                this.addChild(item);
+                currentX += item.width + paddingX;
+                if (item.height > maxHeight)
+                    maxHeight = item.height;
+            }
+            y += maxHeight + paddingY;
+        }
+        // 根据 anchor 调整整体偏移
+        const bounds = this.getLocalBounds();
+        this.pivot.set(bounds.x + bounds.width * anchorX, bounds.y + bounds.height * anchorY);
+    }
+}

package/Components/Custom/LibPixiTriangle.d.ts

@@ -0,0 +1,5 @@
+import { Graphics } from "pixi.js";
+/** @description 三角形 */
+export declare class LibPixiTriangle extends Graphics {
+    constructor(dots: [[number, number], [number, number]], color: string);
+}

package/Components/Custom/LibPixiTriangle.js

@@ -0,0 +1,12 @@
+import { Graphics } from "pixi.js";
+/** @description 三角形 */
+export class LibPixiTriangle extends Graphics {
+    constructor(dots, color) {
+        super();
+        this.beginFill(color);
+        this.moveTo(0, 0);
+        this.lineTo(dots[0][0], dots[0][1]);
+        this.lineTo(dots[1][0], dots[1][1]);
+        this.endFill();
+    }
+}

package/Components/Custom/LibPixiTurntable.d.ts

@@ -0,0 +1,6 @@
+/** @description 转盘布局
+ * @param num 份数
+ * @param distance 中心距离
+ * @param layoutCallback 定位计算回调
+ */
+export declare const LibPixiTurntable: (num: number, distance: number, layoutCallback: (x: number, y: number, rotation: number, index: number) => void) => void;

package/Components/Custom/LibPixiTurntable.js

@@ -0,0 +1,14 @@
+import { libJsConvertAngle } from "lyb-js/Math/LibJsConvertAngle.js";
+/** @description 转盘布局
+ * @param num 份数
+ * @param distance 中心距离
+ * @param layoutCallback 定位计算回调
+ */
+export const LibPixiTurntable = (num, distance, layoutCallback) => {
+    for (let i = 0; i < num; i++) {
+        const rotation = libJsConvertAngle((360 / num) * i, "rad");
+        const cos = Math.cos(rotation + libJsConvertAngle(-90, "rad"));
+        const sin = Math.sin(rotation + libJsConvertAngle(-90, "rad"));
+        layoutCallback(cos * distance, sin * distance, rotation, i);
+    }
+};

package/Utils/LibContainerCenter.d.ts

@@ -0,0 +1,3 @@
+import { Container } from "pixi.js";
+/** @description 当前容器在父容器居中 */
+export declare const libContainerCenter: (parent: Container, item: Container, centerType?: "x" | "y" | "xy") => void;

package/Utils/LibContainerCenter.js

@@ -0,0 +1,10 @@
+/** @description 当前容器在父容器居中 */
+export const libContainerCenter = (parent, item, centerType = "xy") => {
+    const xy = centerType === "xy";
+    if (centerType === "x" || xy) {
+        item.x = parent.width / 2 - item.width / 2;
+    }
+    if (centerType === "y" || xy) {
+        item.y = parent.height / 2 - item.height / 2;
+    }
+};

package/Utils/LibControlledDelayedCall.d.ts

@@ -0,0 +1,5 @@
+/** @description 可控延迟调用函数 */
+export declare const libControlledDelayedCall: (time: number) => {
+    start: Promise<void>;
+    stop: () => void;
+};

package/Utils/LibControlledDelayedCall.js

@@ -0,0 +1,20 @@
+import { libPixiTickerTimeout } from "./LibPixiTickerTimeout";
+/** @description 可控延迟调用函数 */
+export const libControlledDelayedCall = (time) => {
+    let _resolve;
+    let timer;
+    const start = new Promise((resolve) => {
+        _resolve = resolve;
+        timer = libPixiTickerTimeout(() => {
+            resolve();
+        }, time);
+    });
+    const stop = () => {
+        timer();
+        _resolve();
+    };
+    return {
+        start,
+        stop,
+    };
+};

package/Utils/LibPixiArrangeLinear.d.ts

@@ -0,0 +1,16 @@
+import type { Container } from "pixi.js";
+/**
+ * @description 线性排列 PIXI.Container 元素（支持横向/纵向排列，多列布局、固定或自定义间隔）
+ * @param items 需要排列的容器数组
+ * @param gap 间隔，可为固定值或数组（数组长度必须等于 items.length - 1）
+ * @param direction 排列方向："x" 横向排列，"y" 纵向排列
+ * @param cols 每行（或每列）最多的元素个数，默认为 Infinity（单行/单列）
+ * @example
+ * // 横向排列
+ * LibPixiArrangeLinear([sprite1, sprite2, sprite3], 10, "x");
+ * // 纵向排列
+ * LibPixiArrangeLinear([sprite1, sprite2, sprite3], 20, "y");
+ * // 两列布局
+ * LibPixiArrangeLinear([sprite1, sprite2, sprite3, sprite4], 10, "x", 2);
+ */
+export declare const LibPixiArrangeLinear: (items: Container[], gap: number | number[], direction?: "x" | "y", cols?: number) => void;

package/Utils/LibPixiArrangeLinear.js

@@ -0,0 +1,62 @@
+/**
+ * @description 线性排列 PIXI.Container 元素（支持横向/纵向排列，多列布局、固定或自定义间隔）
+ * @param items 需要排列的容器数组
+ * @param gap 间隔，可为固定值或数组（数组长度必须等于 items.length - 1）
+ * @param direction 排列方向："x" 横向排列，"y" 纵向排列
+ * @param cols 每行（或每列）最多的元素个数，默认为 Infinity（单行/单列）
+ * @example
+ * // 横向排列
+ * LibPixiArrangeLinear([sprite1, sprite2, sprite3], 10, "x");
+ * // 纵向排列
+ * LibPixiArrangeLinear([sprite1, sprite2, sprite3], 20, "y");
+ * // 两列布局
+ * LibPixiArrangeLinear([sprite1, sprite2, sprite3, sprite4], 10, "x", 2);
+ */
+export const LibPixiArrangeLinear = (items, gap, direction = "x", cols = Infinity) => {
+    // 验证 gap 数组长度是否正确
+    if (Array.isArray(gap)) {
+        if (gap.length !== items.length - 1) {
+            console.error(new Error("间隔的数组长度只能等于元素数组长度-1"));
+            return;
+        }
+    }
+    let lastRowMax = 0; // 当前行（或列）的最大高度（或宽度），用于多行/多列换行时计算偏移
+    let rowOffset = 0; // 累计偏移量，控制换行后的整体偏移位置
+    items.forEach((item, index) => {
+        var _a, _b;
+        const row = Math.floor(index / cols); // 当前行号
+        const col = index % cols; // 当前列号
+        if (direction === "x") {
+            //间隔
+            const gapValue = Array.isArray(gap) ? (_a = gap[index - 1]) !== null && _a !== void 0 ? _a : 0 : gap;
+            //在每行第一列重置列偏移量
+            if (col === 0 && row > 0) {
+                rowOffset += lastRowMax + gapValue;
+                lastRowMax = 0;
+            }
+            // 横向位置 = 前一个元素的右侧 + 间隔；首列则从 0 开始
+            item.x =
+                col === 0 ? 0 : items[index - 1].x + items[index - 1].width + gapValue;
+            // 纵向位置 = 当前累计的行偏移
+            rowOffset && (item.y = rowOffset);
+            // 更新当前行的最大高度
+            lastRowMax = Math.max(lastRowMax, item.height);
+        }
+        else {
+            //间隔
+            const gapValue = Array.isArray(gap) ? (_b = gap[index - 1]) !== null && _b !== void 0 ? _b : 0 : gap;
+            //在每列第一行重置行偏移
+            if (col === 0 && row > 0) {
+                rowOffset += lastRowMax + gapValue;
+                lastRowMax = 0;
+            }
+            // 纵向位置 = 首列则从 0 开始，其余从前一个元素的y坐标 + 高度 + 间隔；
+            item.y =
+                col === 0 ? 0 : items[index - 1].y + items[index - 1].height + gapValue;
+            // 横向位置 = 当前累计的列偏移
+            rowOffset && (item.x = rowOffset);
+            // 更新当前列的最大宽度
+            lastRowMax = Math.max(lastRowMax, item.width);
+        }
+    });
+};