tencent.jquery.pix.component 1.0.76 → 1.0.78

package/components/video/videocss.scss

@@ -1,6 +1,9 @@
 $jqpix-video-progress-bold-scale: 2 !default;
+$jqpix-video-progress-handle-bold-scale: 0.5 !default;
 $jqpix-video-primary-color: #ff6429 !default;
 
+@use "sass:math";
+
 .myplayer-shrink1 {
   flex-shrink: 1;
 }
@@ -270,16 +273,20 @@ $jqpix-video-primary-color: #ff6429 !default;
   max-width: 100%;
 }
 
-.myplayer-container .myplayer-subprogress div {
+.myplayer-container .myplayer-subprogress .myplayer-progress-handle {
   content: "";
   position: absolute;
-  width: 0.14rem;
-  height: 0.14rem;
+  width: 0.5rem;
+  height: 0.5rem;
   top: 50%;
-  right: -0.07rem;
-  margin-top: -0.07rem;
-  transform: rotate(45deg);
-  background-color: #e5fd0e;
+  right: -0.25rem;
+  margin-top: -0.25rem;
+  border-radius: 0.25rem;
+  background-color: $jqpix-video-primary-color;
+}
+
+.myplayer-container .myplayer-progress-bold .myplayer-subprogress .myplayer-progress-handle {
+  transform: scaleY($jqpix-video-progress-handle-bold-scale);
 }
 
 .myplayer-container .myplayer-resolution {

package/components/video/videohtml.js

@@ -18,7 +18,7 @@ const html = `
         <div class="myplayer-progress" draggable="true">
           <div class="myplayer-progress-bg"></div>
           <div class="myplayer-subprogress">
-            <!-- <div></div> -->
+            <div class="myplayer-progress-handle"></div>
           </div>
         </div>
       </div>

package/components/video/videoplayer.js

@@ -20,6 +20,7 @@ import VideoHTML from "./videohtml";
  * @param {number} [options.autoHideControlsDelayMs=5000] 自动隐藏控制条延迟时间，单位ms
  * @param {boolean} [options.showProgressBar=true] 是否显示进度条
  * @param {boolean} [options.showVolumeControl=false] 是否显示音量控制
+ * @param {boolean} [options.showProgressHandle=true] 是否显示进度条滑块
  * @param {boolean} [options.clickToPause=false] 点击播放区域是否直接暂停，true: 直接暂停，false: 先展示控制条
  * @param {(this: VideoPlayer, type: VideoPlayerState) => any} [options.stateChanged] 状态变化回调
  */
@@ -59,6 +60,7 @@ VideoPlayer.prototype.init = async function () {
         autoHideControlsDelayMs: 5000,
         showProgressBar: true,
         showVolumeControl: false,
+        showProgressHandle: true,
         clickToPause: false,
         ...this.options
     }
@@ -88,6 +90,11 @@ VideoPlayer.prototype.init = async function () {
         $container.find('.myplayer-progress').hide();
     }
 
+    // 根据showProgressHandle选项控制进度条滑块显示
+    if (!this.options.showProgressHandle) {
+        $container.find('.myplayer-progress-handle').hide();
+    }
+
     // 根据showVolumeControl选项控制音量控件显示
     if (this.options.showVolumeControl) {
         $container.find('.myplayer-volume').show();
@@ -496,11 +503,13 @@ VideoPlayer.prototype.progressDragStart = function (e) {
     if (!this.options.showProgressBar) {
         return;
     }
-
-    this.state.updatingProgress = false;
     if (this.state.playing === true) {
         this.pause();
     }
+
+    // 更新进度条时，不更新播放时间
+    // 这个赋值必须放在最后，因为pause会设置this.state.updatingProgress为true
+    this.state.updatingProgress = false;
 }
 
 /**

package/components/waterfall/waterfall.js

@@ -1,6 +1,6 @@
-import "./waterfall.scss"
-import { getEnv } from "../config.js";
 import { remToPx } from "../../utils/utils.js";
+import { getEnv } from "../config.js";
+import "./waterfall.scss";
 
 let $ = null;
 
@@ -15,7 +15,7 @@ const DEFAULTS = {
     startPoints: [], // 起始点距离
     data: [],              // 数据源
     container: '',                // 容器元素
-    renderItem(data, index) {      // 元素首次渲染时的回调函数, 如果把updateItem设置为空，那么更新时则会兜底触发renderItem
+    renderItem(data, index, $card) {      // 元素首次渲染时的回调函数, 如果把updateItem设置为空，那么更新时则会兜底触发renderItem
         return '<div class="waterfall-item"></div>';
     },
     scrollDom: null, // 滚动元素,如果传入了滚动元素，那么用来计算的窗口高度就以滚动元素的高度为准
@@ -236,10 +236,17 @@ Waterfall.prototype.appendCard = function (data, dataId, { top, left }) {
               data-index="${dataId}"
               style="position: absolute;transform:translate(${left}px,${top}px);"
         >
-        ${options.renderItem(data, dataInfo.originalIndex)}
          </div> `
     );
 
+    $viewport.append($card);
+
+    const str = options.renderItem(data, dataInfo.originalIndex, $card);
+
+    if (str) {
+        $card.html(str);
+    }
+
     this.renderedDataIds.add(dataId);
 
     if (options.columns !== 1) {
@@ -247,7 +254,6 @@ Waterfall.prototype.appendCard = function (data, dataId, { top, left }) {
     }
 
 
-    $viewport.append($card);
     return $card;
 }
 
@@ -287,14 +293,28 @@ Waterfall.prototype.updateCardsInView = async function ({ start, end, force = fa
 
             const data = options.data[dataId]
 
-            // 如果当前这个节点是特殊节点 不用做处理
+            // 如果当前这个节点是特殊节点，只更新位置，不参与节点复用
             // 如果是特殊的静态占用元素卡片，需要指定节点不变更的数据，那么该数据的节点不能被其他数据使用
             let specialNode = false;
             if (options.shouldOccupySpace) {
                 specialNode = options.shouldOccupySpace(data) || false;
             }
             if (specialNode) {
-                continue;
+                // 特殊节点：只更新位置，不参与复用逻辑
+                if (row.$node && row.$node.length) {
+                    // 直接更新特殊节点的位置
+                    row.$node.css({
+                        'transform': `translate(${row.left}px,${row.top}px)`,
+                    }).attr('data-index', dataId);
+
+                    // 如果是强制更新，也重新渲染内容
+                    if (force) {
+                        this.updateRenderUI(row.$node, data, dataId);
+                    }
+                } else {
+                    console.warn('Waterfall: Special node DOM not found for dataId', dataId);
+                }
+                continue; // 跳过普通节点的复用逻辑
             }
 
             // 在可视区域内 进行有关卡片的操作
@@ -531,6 +551,9 @@ Waterfall.prototype.createCards = function ({ end, dataId = -1 }, callback) {
         column.children.push(row);
         row.bottom = column.bottom;
 
+        // 建立 dataIdMap -> row 的引用，用于快速访问布局信息
+        dataInfo.layoutInfo = row;
+
         // 检查是否需要继续创建卡片
         const minHeight = this.getMinHeight();
         const hasMoreData = this.renderedDataIds.size < this.dataIdMap.size;
@@ -590,7 +613,32 @@ Waterfall.prototype.updateRenderUI = function ($node, data, dataId) {
     if (this.hasUpdateItem === true) {
         options.updateItem($node, data, dataInfo.originalIndex)
     } else {
-        $node.html(options.renderItem(data, dataInfo.originalIndex));
+        const str = options.renderItem(data, dataInfo.originalIndex, $node);
+        if (str) {
+            $node.html(str);
+        }
+    }
+}
+
+// 辅助方法：使用 renderItem 渲染节点（用于全新节点）
+Waterfall.prototype.renderUI = function ($node, data, dataId) {
+    const options = this.options;
+
+    // 新方案：基于数据ID的数据验证
+    if (!this.dataIdMap.has(dataId)) {
+        console.error('Waterfall: Invalid dataId in renderUI', dataId);
+        return;
+    }
+
+    const dataInfo = this.dataIdMap.get(dataId);
+    if (!dataInfo || !dataInfo.data) {
+        console.warn('Waterfall: Empty data for dataId', dataId);
+    }
+
+    // 始终使用 renderItem，因为这是全新节点
+    const str = options.renderItem(data, dataInfo.originalIndex, $node);
+    if (str) {
+        $node.html(str);
     }
 }
 
@@ -600,55 +648,367 @@ Waterfall.prototype.updateData = async function (newData) {
     const options = this.options;
     options.data = newData;
 
-    // 新方案：重新建立数据ID映射
-    //this.dataIdMap.clear();
-    //this.renderedDataIds.clear();
-    //this.nextDataId = 0;
+    // 步骤1: 批量获取所有卡片的新高度（只需一次 requestAnimationFrame）
+    const dataIds = this.renderedDataIds;
+    const newHeightsMap = await this.getBatchCardNewHeights(dataIds, newData);
 
-    // 为每个数据项分配唯一ID
-    let bool = true
-    let count = options.data.length - 1;
-    let index = 0;
+    // 步骤2: 收集高度变化
+    const heightChanges = new Map(); // dataId -> {oldHeight, newHeight, heightDiff}
 
-    while (bool) {
-        if (index > count) {
-            bool = false
-            this.updateVisibleItems(true); // 强制更新渲染
-            break;
+    for (let dataId of dataIds) {
+        const oldHeight = this.getCardOldHeight(dataId);
+        const newHeight = newHeightsMap.get(dataId);
+
+        if (oldHeight !== newHeight) {
+            heightChanges.set(dataId, {
+                oldHeight,
+                newHeight,
+                heightDiff: newHeight - oldHeight
+            });
         }
+    }
 
-        const dataId = index;
-        this.dataIdMap.set(dataId, {
-            data: true,
-            originalIndex: dataId,
-            layoutInfo: null
+    // 步骤3: 使用累积差分算法更新每一列的布局
+    for (let i = 0; i < this.columnItems.length; i++) {
+        const column = this.columnItems[i];
+        let accumulatedDiff = 0; // 累积的高度变化
+
+        for (let j = 0; j < column.children.length; j++) {
+            const row = column.children[j];
+            const dataId = row.dataId;
+
+            // 先应用之前累积的差分
+            if (accumulatedDiff !== 0) {
+                row.top += accumulatedDiff;
+                row.bottom += accumulatedDiff;
+            }
+
+            // 如果当前卡片有高度变化，累积到差分中
+            if (heightChanges.has(dataId)) {
+                const change = heightChanges.get(dataId);
+                accumulatedDiff += change.heightDiff;
+                // 更新当前卡片的 bottom
+                row.bottom += change.heightDiff;
+            }
+        }
+
+        // 更新列的总高度
+        if (accumulatedDiff !== 0) {
+            column.bottom += accumulatedDiff;
+        }
+    }
+
+    // 步骤4: 同步视图
+    this.setScrollHeight();
+    this.updateVisibleItems(true); // 这里会处理内容更新和DOM位置同步
+}
+
+// 辅助方法：获取卡片的旧高度（从布局信息）
+Waterfall.prototype.getCardOldHeight = function(dataId) {
+    const dataInfo = this.dataIdMap.get(dataId);
+
+    if (!dataInfo) {
+        // dataId 不存在
+        return 0;
+    }
+
+    if (!dataInfo.layoutInfo) {
+        // 布局信息未初始化（卡片还未创建）
+        return 0;
+    }
+
+    const row = dataInfo.layoutInfo;
+    return row.bottom - row.top;
+}
+
+// 辅助方法：获取特殊节点的 DOM 引用
+Waterfall.prototype.getSpecialNodeDOM = function(dataId) {
+    const dataInfo = this.dataIdMap.get(dataId);
+    if (dataInfo && dataInfo.layoutInfo && dataInfo.layoutInfo.$node) {
+        return dataInfo.layoutInfo.$node;
+    }
+    return null;
+}
+
+// 辅助方法：批量获取卡片的新高度（用于 updateData）
+Waterfall.prototype.getBatchCardNewHeights = async function(dataIds, newData) {
+    const options = this.options;
+    const $ = getEnv().$;
+    const $container = $(options.container);
+    const $viewport = $container.find('.waterfall-list-viewport');
+
+    // 用于记录每个卡片的信息
+    const cardInfos = new Map(); // dataId -> { $node, needCleanup, cleanupType }
+
+    // 记录从节点池借用的节点，需要在完成后归还
+    const borrowedNodes = [];
+    // 记录新创建的临时节点，需要在完成后删除
+    const tempNodesToDelete = [];
+
+    // 第一步：优先处理所有可视区域节点（activeNodes）
+    for (let dataId of dataIds) {
+        if (this.activeNodes.has(dataId)) {
+            const $node = this.activeNodes.get(dataId);
+            const data = newData[dataId];
+
+            // 重新渲染内容
+            this.updateRenderUI($node, data, dataId);
+
+            cardInfos.set(dataId, {
+                $node: $node,
+                needCleanup: false,
+                cleanupType: null
+            });
+        }
+    }
+
+    // 第二步：处理所有非可视区域节点
+    for (let dataId of dataIds) {
+        // 跳过已在第一步处理的可视区域节点
+        if (this.activeNodes.has(dataId)) {
+            continue;
+        }
+
+        const data = newData[dataId];
+
+        // 情况1: 卡片在 allReadyNodes 中
+        if (this.allReadyNodes.has(dataId)) {
+            const $existingNode = this.allReadyNodes.get(dataId);
+
+            // 特殊节点（null）：通过 layoutInfo 获取 DOM 引用
+            if ($existingNode === null) {
+                const $specialNode = this.getSpecialNodeDOM(dataId);
+
+                if ($specialNode) {
+                    // 特殊节点永远独占，无需检查重复
+                    // 直接重新渲染特殊节点的内容
+                    this.updateRenderUI($specialNode, data, dataId);
+
+                    cardInfos.set(dataId, {
+                        $node: $specialNode,
+                        needCleanup: false,
+                        cleanupType: 'special'
+                    });
+                } else {
+                    // 无法获取特殊节点DOM，使用旧高度
+                    console.warn('Waterfall: Special node DOM not found for dataId', dataId);
+                    cardInfos.set(dataId, {
+                        $node: null,
+                        needCleanup: false,
+                        cleanupType: 'special-notfound'
+                    });
+                }
+                continue;
+            }
+
+            // 情况2: 普通节点 - 从节点池获取或创建临时节点
+            let $node = getNodePoolPop(this.nodePool, this.activeNodes);
+
+            if ($node) {
+                // 从节点池借用节点
+                borrowedNodes.push($node);
+
+                // 设置位置和样式
+                $node.css({
+                    'transform': 'translate(-9999px, -9999px)',
+                });
+
+                // 设置宽度
+                if (options.columns !== 1) {
+                    $node.width(this.columnWidth + 'px');
+                }
+
+                // 使用 updateRenderUI（节点池的节点已有结构）
+                this.updateRenderUI($node, data, dataId);
+
+                cardInfos.set(dataId, {
+                    $node: $node,
+                    needCleanup: false,
+                    cleanupType: 'borrowed'
+                });
+            } else {
+                // 节点池空了，创建临时节点
+                $node = $(
+                    `<div class="waterfall-item"
+                          data-index="${dataId}"
+                          style="position: absolute; transform: translate(-9999px, -9999px);"
+                    >
+                     </div>`
+                );
+                $viewport.append($node);
+                tempNodesToDelete.push($node);
+
+                // 设置宽度
+                if (options.columns !== 1) {
+                    $node.width(this.columnWidth + 'px');
+                }
+
+                // 使用 renderUI（临时节点是全新的）
+                this.renderUI($node, data, dataId);
+
+                cardInfos.set(dataId, {
+                    $node: $node,
+                    needCleanup: false,
+                    cleanupType: 'temp'
+                });
+            }
+            continue;
+        }
+
+        // 情况3: 未找到节点，标记为使用旧高度
+        cardInfos.set(dataId, {
+            $node: null,
+            needCleanup: false,
+            cleanupType: 'notfound'
         });
+    }
 
-        await this.createCards({ end: 0, dataId })
+    // 第三步：在单个 requestAnimationFrame 中统一获取所有高度
+    return new Promise(resolve => {
+        window.requestAnimationFrame(() => {
+            const heightMap = new Map(); // dataId -> newHeight
 
-        index += 1;
+            for (let [dataId, info] of cardInfos) {
+                if (info.$node) {
+                    // 从DOM获取高度
+                    heightMap.set(dataId, info.$node.height());
+                } else {
+                    // 使用旧高度
+                    heightMap.set(dataId, this.getCardOldHeight(dataId));
+                }
+            }
+
+            // 清理：归还借用的节点到节点池
+            for (let $node of borrowedNodes) {
+                $node.css('transform', 'translateY(-9999px)');
+                this.nodePool.push($node);
+            }
+
+            // 清理：删除临时节点
+            for (let $node of tempNodesToDelete) {
+                $node.remove();
+            }
+
+            resolve(heightMap);
+        });
+    });
+}
+
+// 辅助方法：获取卡片的新高度（通过渲染）- 用于单卡片更新
+Waterfall.prototype.getCardNewHeight = async function(dataId, data) {
+    const options = this.options;
+    const $ = getEnv().$;
 
+    // 情况1: 卡片在可视区域（activeNodes）
+    if (this.activeNodes.has(dataId)) {
+        const $node = this.activeNodes.get(dataId);
+
+        // 重新渲染内容
+        this.updateRenderUI($node, data, dataId);
+
+        // 等待DOM更新
+        return new Promise(resolve => {
+            window.requestAnimationFrame(() => {
+                resolve($node.height());
+            });
+        });
     }
-    // options.data.forEach((item, index) => {
-    //     const dataId = index; // this.nextDataId++;
-    //     if (!this.allReadyNodes.has(dataId)) {
-    //         this.dataIdMap.set(dataId, {
-    //             data: true,// item,
-    //             originalIndex: index,
-    //             layoutInfo: null // 将在布局时填充
-    //         });
-    //         // 如果没有准备好这个数据，这里要创建一个占位节点
-    //         this.createCards({ end: 0, dataId });
-    //     }
-    // });
 
-    // this.updateVisibleItems(true); // 强制更新渲染
+    // 情况2: 卡片不在可视区域（allReadyNodes）
+    if (this.allReadyNodes.has(dataId)) {
+        const $existingNode = this.allReadyNodes.get(dataId);
+
+        // 特殊节点（null）：通过 layoutInfo 获取 DOM 引用并更新
+        if ($existingNode === null) {
+            const $specialNode = this.getSpecialNodeDOM(dataId);
+
+            if ($specialNode) {
+                // 重新渲染特殊节点的内容
+                this.updateRenderUI($specialNode, data, dataId);
+
+                // 等待DOM更新后获取新高度
+                return new Promise(resolve => {
+                    window.requestAnimationFrame(() => {
+                        resolve($specialNode.height());
+                    });
+                });
+            }
+
+            // 无法获取特殊节点DOM，返回旧高度
+            console.warn('Waterfall: Special node DOM not found for dataId', dataId);
+            return this.getCardOldHeight(dataId);
+        }
 
+        // 普通节点：从节点池获取或创建临时节点
+        const $container = $(options.container);
+        const $viewport = $container.find('.waterfall-list-viewport');
 
+        let $node = getNodePoolPop(this.nodePool, this.activeNodes);
+        let isBorrowed = false;
+
+        if ($node) {
+            // 从节点池借用节点
+            isBorrowed = true;
+
+            // 设置位置和样式
+            $node.css({
+                'transform': 'translate(-9999px, -9999px)',
+            });
+
+            // 设置宽度
+            if (options.columns !== 1) {
+                $node.width(this.columnWidth + 'px');
+            }
+
+            // 使用 updateRenderUI（节点池的节点已有结构）
+            this.updateRenderUI($node, data, dataId);
+        } else {
+            // 节点池空了，创建临时节点
+            $node = $(
+                `<div class="waterfall-item"
+                      data-index="${dataId}"
+                      style="position: absolute; transform: translate(-9999px, -9999px);"
+                >
+                 </div>`
+            );
+            $viewport.append($node);
+
+            // 设置宽度
+            if (options.columns !== 1) {
+                $node.width(this.columnWidth + 'px');
+            }
+
+            // 使用 renderUI（临时节点是全新的）
+            this.renderUI($node, data, dataId);
+        }
+
+        // 等待DOM更新
+        return new Promise(resolve => {
+            window.requestAnimationFrame(() => {
+                const newHeight = $node.height();
+
+                // 清理
+                if (isBorrowed) {
+                    // 归还借用的节点到节点池
+                    $node.css('transform', 'translateY(-9999px)');
+                    this.nodePool.push($node);
+                } else {
+                    // 删除临时节点
+                    $node.remove();
+                }
+
+                resolve(newHeight);
+            });
+        });
+    }
+
+    // 情况3: 未找到节点，返回旧高度
+    return this.getCardOldHeight(dataId);
 }
 
 // 某个数据进行了UI变更，触发高度重新绘制
-Waterfall.prototype.updateCard = function (data) {
+Waterfall.prototype.updateCard = async function (data) {
+    const self = this;
     const options = this.options;
     let dataId = -1;
     if (typeof data === 'number') {
@@ -667,49 +1027,75 @@ Waterfall.prototype.updateCard = function (data) {
         return
     }
 
-    // 从activeNodes中获取该数据的节点
-    if (!this.activeNodes.has(dataId)) {
-        console.log('Waterfall: Invalid dataId in activeNodes');
+    // 检查数据是否已经渲染过
+    if (!this.renderedDataIds.has(dataId)) {
+        console.log('Waterfall: dataId not rendered yet', dataId);
         return
     }
 
-    const $node = this.activeNodes.get(dataId);
-    const height = $node.height();
+    const itemData = options.data[dataId];
+
+    // 获取旧高度
+    const oldHeight = this.getCardOldHeight(dataId);
+
+    // 获取新高度（会自动处理渲染和临时节点）
+    const newHeight = await this.getCardNewHeight(dataId, itemData);
+
+    // 应用高度变化
+    this.applyHeightChange(dataId, oldHeight, newHeight);
+}
+
+// 应用高度变化到布局
+Waterfall.prototype.applyHeightChange = function (dataId, oldHeight, newHeight) {
+    const minus = newHeight - oldHeight;
+
+    // 如果高度没有变化，直接退出
+    if (minus === 0) {
+        console.log('Waterfall: Card height unchanged for dataId', dataId);
+        return;
+    }
+
+    console.log('Waterfall: Card height changed for dataId', dataId, 'from', oldHeight, 'to', newHeight, 'diff', minus);
 
     // 重新计算该数据所在列的卡片位置
-    let needUpdate = false
+    let needUpdate = false;
     const columnItems = this.columnItems;
+
     for (let i = 0; i < columnItems.length; i++) {
         const column = columnItems[i];
-        let bool = false
-        let minus = 0
+        let foundCard = false;
+
         // 这里为了简化，各列的瀑布流保持不动，只更新各列下节点的top位置，不做节点的跨列位移
         for (let j = 0; j < column.children.length; j++) {
             const row = column.children[j];
-            if (row.dataId === dataId) {
-                bool = true
-                const oldHeight = row.bottom - row.top;
 
-                minus = height - oldHeight;
+            if (row.dataId === dataId) {
+                foundCard = true;
+                needUpdate = true;
 
-                if (minus === 0) {
-                    // 找到了原节点数据，对比后没有变更 那么直接退出
-                    return;
-                }
-                needUpdate = true
+                // 更新当前卡片的bottom
                 row.bottom += minus;
-            } else if (minus !== 0) {
+
+            } else if (foundCard) {
+                // 更新该卡片以下所有卡片的位置（同列）
                 row.top += minus;
                 row.bottom += minus;
             }
         }
-        if (bool) {
+
+        if (foundCard) {
+            // 更新列的总高度
             column.bottom += minus;
             break;
         }
     }
+
     if (needUpdate) {
-        this.updateVisibleItems(true); // 强制更新渲染
+        // 更新滚动容器高度
+        this.setScrollHeight();
+
+        // 强制更新渲染（更新所有卡片的实际位置）
+        this.updateVisibleItems(true);
     }
 }
 
@@ -761,11 +1147,11 @@ Waterfall.prototype.showLoading = function (callback = null) {
         let loadingTop = this.getMaxHeight() + options.rowGap
         this.$loadingNode.css('transform', `translate(0px,${loadingTop}px)`);
         $node = this.$loadingNode;
-        window.requestAnimationFrame(() => {
-            setTimeout(() => {
-                this.$scrollDom.scrollTop(loadingTop + this.$loadingNode.height());
-            });
-        });
+        // window.requestAnimationFrame(() => {
+        //     setTimeout(() => {
+        //         this.$scrollDom.scrollTop(loadingTop + this.$loadingNode.height());
+        //     });
+        // });
     }
 
     if (callback) callback($node)
@@ -866,4 +1252,3 @@ function getNodePoolPop(nodePool, actives) {
     }
     return null;
 }
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tencent.jquery.pix.component",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "description": "",
   "main": "index.js",
   "files": [

package/readme.md

@@ -4,7 +4,7 @@
 
 - 用于web浏览器基于正常的jquery版本(1.9系列)
 
-- 用于pix小应用基于@tencent/jquery.pix
+- 用于pix小应用基于tencent.jquery.pix
 
 git 地址