@dolphinweex/weex-harmony 0.1.69 → 0.1.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dolphinweex/weex-harmony",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "description": "weex harmony adapter",
   "main": "index.js",
   "files": [

package/src/components/baseSameLayer.vue

@@ -7,8 +7,8 @@
       ref="embedElement"
       :id="embedId"
       :type="embedType"
-      width="100%"
-      height="100%"
+      :width="embedWidth || '100%'"
+      :height="embedHeight || '100%'"
     />
   </div>
 </template>
@@ -47,6 +47,14 @@ export default {
       required: false,
       default: false,
     },
+    embedWidth:{
+      type: String || Number,
+      defalut: '100%'
+    },
+    embedHeight:{
+      type: String || Number,
+      defalut: '100%'
+    }
   },
   data() {
     return {

package/src/components/midea-common-weex-view.vue

@@ -37,7 +37,7 @@ export default {
       embedId: `embedId_iframe_${
         Date.now().toString(36) + Math.random().toString(36).substring(2)
       }`,
-      height: "0px",//iframe有默认高度150px 网络不好的话加载会有明显空白区
+      height: "100%",
     };
   },
   components: {

package/src/components/midea-ijkplayer-view.vue

@@ -1,23 +1,42 @@
 <template>
   <BaseSameLayer
     :hosSameLayerArgs="hosSameLayerArgs"
+    ref="sameLayer"
     embedType="native/midea-ijkplayer-view"
-    :defaultWidth="300"
-    :defaultHeight="300"
+    :defaultWidth="'100%'"
+    :defaultHeight="'100%'"
+    :embedWidth="embedWidth"
+    :embedHeight="embedHeight"
+    :style="
+      embedPosition !== 'fixed'
+        ? { position: embedPosition }
+        : {
+            position: embedPosition,
+            top: 0,
+            left: 0,
+            bottom: 0,
+            right: 0,
+          }
+    "
   ></BaseSameLayer>
 </template>
 
 <script>
-import BaseSameLayer from "./baseSameLayer.vue";
+import BaseSameLayer from './baseSameLayer.vue';
 
 export default {
   data() {
     return {
       width: 0,
       height: 0,
+      embedWidth: '100%',
+      embedHeight: '100%',
+      embedPosition: 'static',
+      defaultWidth: '100%',
+      defaultHeight: '100%',
     };
   },
-  name: "MideaIjkplayerView",
+  name: 'MideaIjkplayerView',
   components: {
     BaseSameLayer,
   },
@@ -34,6 +53,82 @@ export default {
         return {};
       },
     },
+    config: {
+      type: Object,
+      default() {
+        return {};
+      },
+    },
+    muted: {
+      type: Boolean,
+      default: false,
+    },
+    playStatus: {
+      type: String,
+      default: 'normal',
+    },
+    needDownload: {
+      type: Boolean,
+      default: false,
+    },
+    isSupportScale: {
+      type: Boolean,
+      default: false,
+    },
+    videoResize: {
+      type: Number,
+      default: 0,
+    },
+    autoplay: {
+      type: Boolean,
+      default: false,
+    },
+    videoCover: {
+      type: String,
+      default: '',
+    },
+    uiVisible: {
+      type: Object,
+      default() {
+        return {
+          voiceBtnVisible: true,
+          speedBtnVisible: true,
+          captureBtnVisible: true,
+          downloadBtnVisible: true,
+          batteryTimeLayoutVisible: false,
+        };
+      },
+    },
+    speedList: {
+      type: Array,
+      default() {
+        return ['0.5', '1', '1.5', '2'];
+      },
+    },
+    extraInfo: {
+      type: String,
+      default: '',
+    },
+    deleteBtnVisible: {
+      type: Number,
+      default: 0,
+    },
+    downloadDir: {
+      type: String,
+      default: '',
+    },
+    albumName: {
+      type: String,
+      default: '',
+    },
+    src: {
+      type: String,
+      default: '',
+    },
+    isShowTopRightViewOnPortrait: {
+      type: Boolean,
+      default: false,
+    },
   },
   computed: {
     hosSameLayerArgs() {
@@ -41,53 +136,104 @@ export default {
         ...this.hosUniqueProps, // 鸿蒙原生组件独有属性
         width: this.width,
         height: this.height,
+        onFullscreenChange: this.onFullscreenChange,
+        // 视频播放器相关属性
+        config: this.config,
+        muted: this.muted,
+        playStatus: this.playStatus,
+        needDownload: this.needDownload,
+        isSupportScale: this.isSupportScale,
+        videoResize: this.videoResize,
+        autoplay: this.autoplay,
+        videoCover: this.videoCover,
+        uiVisible: this.uiVisible,
+        speedList: this.speedList,
+        extraInfo: this.extraInfo,
+        deleteBtnVisible: this.deleteBtnVisible,
+        downloadDir: this.downloadDir,
+        albumName: this.albumName,
         data: this.data,
+        src: this.src,
+        isShowTopRightViewOnPortrait: this.isShowTopRightViewOnPortrait,
 
+        // 事件回调
         onProgress: this.onProgress,
         onStart: this.onStart,
         onPause: this.onPause,
         finish: this.finish,
         onFail: this.onFail,
-        onReadyToPlay: this.onReadyToPlay
+        onReadyToPlay: this.onReadyToPlay,
+        deleteVideo: this.deleteVideo,
+        onDownloadSuccess: this.onDownloadSuccess,
+        onStartDownload: this.onStartDownload,
+        onPreviewImageClick: this.onPreviewImageClick,
       };
     },
   },
   mounted() {
     this.width = this.$el.clientWidth;
     this.height = this.$el.clientHeight;
+    this.windowWidth = window.innerWidth;
+    this.windowHeight = window.innerHeight;
+    this.$nextTick(() => {
+      this.defaultWidth = this.$refs.sameLayer.$el.clientWidth;
+      this.defaultHeight = this.$refs.sameLayer.$el.clientHeight;
+      this.defaultPosition =
+        this.$refs.sameLayer.$el.style.position || 'static';
+    });
   },
-
   methods: {
+    onFullscreenChange(isFullScreeen) {
+      if (isFullScreeen.flag) {
+        this.embedPosition = 'fixed';
+        this.embedHeight = this.windowWidth;
+        this.embedWidth = this.windowHeight;
+      } else {
+        this.embedPosition = this.defaultPosition;
+        this.embedHeight = this.defaultHeight;
+        this.embedWidth = this.defaultWidth;
+      }
+    },
     // 自定义拓展其它逻辑
     onProgress(res) {
-      // TODO liujun189 暂时不能用finish等内置方法，会被vue-precompiler加入一个undefined的stopPropagation()，导致回调异常
-      this.$emit("onProgress", res);
+      this.$emit('onProgress', res);
     },
 
     onStart(res) {
-      // TODO liujun189 暂时不能用finish等内置方法，会被vue-precompiler加入一个undefined的stopPropagation()，导致回调异常
-      this.$emit("onStart", res);
+      this.$emit('onStart', res);
     },
 
     onPause(res) {
-      // TODO liujun189 暂时不能用finish等内置方法，会被vue-precompiler加入一个undefined的stopPropagation()，导致回调异常
-      this.$emit("onPause", res);
+      this.$emit('onPause', res);
     },
 
     finish(res) {
-      // TODO liujun189 暂时不能用finish等内置方法，会被vue-precompiler加入一个undefined的stopPropagation()，导致回调异常
-      this.$emit("finish", res);
+      this.$emit('finish', res);
     },
 
     onFail(res) {
-      // TODO liujun189 暂时不能用finish等内置方法，会被vue-precompiler加入一个undefined的stopPropagation()，导致回调异常
-      this.$emit("onFail", res);
+      this.$emit('onFail', res);
     },
 
     onReadyToPlay(res) {
-      // TODO liujun189 暂时不能用finish等内置方法，会被vue-precompiler加入一个undefined的stopPropagation()，导致回调异常
-      this.$emit("onReadyToPlay", res);
-    }
+      this.$emit('onReadyToPlay', res);
+    },
+
+    deleteVideo(res) {
+      this.$emit('deleteVideo', res);
+    },
+
+    onDownloadSuccess(res) {
+      this.$emit('onDownloadSuccess', res);
+    },
+
+    onStartDownload(res) {
+      this.$emit('onStartDownload', res);
+    },
+
+    onPreviewImageClick(res) {
+      this.$emit('onPreviewImageClick', res);
+    },
   },
 };
-</script>
+</script>

package/src/transform-loader.js

@@ -21,9 +21,9 @@ const baseUrl = '../src/components/'
 const componentMap = require("./index")
 
 const componentSet = new Set()
-const vBindMap = new Map()
 // v-for 场景下，将 v-bind 转为方法调用所需的方法映射
 const vBindMethodMap = new Map()
+let vBindMethodCounter = 0
 
 /**
  * 判断是否为windows环境
@@ -69,7 +69,7 @@ function hasTargetElement(tagName) {
  * 遍历html节点，将需要引入的组件添加到componentSet中
  * @param {*} node html节点
  */
-function traverseNode(node, parent = null) {
+function traverseNode(node, parent = null, parentVForContext = false) {
     if (node.type === 'element') {
     const { hasElement, componentName } = hasTargetElement(node.tagName);
     if (hasElement) {
@@ -77,23 +77,22 @@ function traverseNode(node, parent = null) {
     }
 
     // 判断当前或父节点是否处于 v-for 场景
-    const hasVForInParent = parent && parent.attributes && parent.attributes.some(attr => attr.key === 'v-for')
     const hasVForInCurrent = node.attributes && node.attributes.some(attr => attr.key === 'v-for')
-    const isInsideVFor = hasVForInParent || hasVForInCurrent
+    const isInsideVFor = parentVForContext || hasVForInCurrent
 
     if (node.attributes) {
       node.attributes.forEach((attr, index) => {
         if (attr.key === 'v-bind') {
           if (isInsideVFor) {
             // v-for 场景：将 v-bind="expr" 转为 v-bind="customVBindMethodX(expr)"
-            const methodName = `customVBindMethod${index}`;
-            const argExpression = (attr.value || '').trim() || 'arg';
+            const methodName = `customVBindMethod${vBindMethodCounter++}`;
+            const argExpression = (attr.value || '').trim() || 'undefined';
             const paramName = 'arg';
             if (!vBindMethodMap.has(methodName)) {
               vBindMethodMap.set(methodName, { paramName });
             }
             // 更新模板中的属性为方法调用
-            node.attributes[index].value = `${methodName}(${argExpression})`;
+            node.attributes[index].value = `{...${methodName}(${argExpression})}`;
           } else {
             if (
               attr.value.trim().startsWith('{') &&
@@ -120,13 +119,13 @@ function traverseNode(node, parent = null) {
                 value: generator(parsedAst).code,
               };
             } else {
-              const customComputedName = `customVBindComputed${index}`; // 自定义的名字
-              vBindMap.set(customComputedName, {
-                computedName: attr.value,
-                customComputedName,
-              });
-              // 更新属性值为自定义名字
-              node.attributes[index].value = customComputedName;
+              const methodName = `customVBindMethod${vBindMethodCounter++}`;
+              const argExpression = (attr.value || '').trim() || 'undefined';
+              const paramName = 'arg';
+              if (!vBindMethodMap.has(methodName)) {
+                vBindMethodMap.set(methodName, { paramName });
+              }
+              node.attributes[index].value = `{...${methodName}(${argExpression})}`;
             }
           }
         }
@@ -136,7 +135,7 @@ function traverseNode(node, parent = null) {
     // 继续递归处理子节点
     if (node.children) {
       node.children.forEach((child) => {
-        traverseNode(child, node);  // 将当前节点作为 parent 传递给子节点
+        traverseNode(child, node, isInsideVFor);  // 将当前节点作为 parent 传递给子节点
       });
     }
   }
@@ -191,80 +190,6 @@ function getComponentLoc(name) {
   }
 }
 //解决v-bind传的是 a.b.c这种 可能a是空导致报错
-function createComputedProperty(vBindValue, computedName) {
-  // 使用辅助函数创建成员表达式，支持嵌套属性路径
-  const valueExpression = createMemberExpressionFromPath(vBindValue);
-  const styleExpression = t.memberExpression(createMemberExpressionFromPath(vBindValue), t.identifier('style'));
-  
-  // 为嵌套路径创建逐级空值检查（如 a.b.c 需要检查 a && a.b && a.b.c）
-  const parts = vBindValue.split('.');
-  const nullCheckConditions = [];
-  for (let i = 0; i < parts.length; i++) {
-    nullCheckConditions.push(createMemberExpressionFromPath(parts.slice(0, i + 1).join('.')));
-  }
-  
-  // 构建逐级 && 检查表达式
-  let nullCheckExpression = nullCheckConditions[0];
-  for (let i = 1; i < nullCheckConditions.length; i++) {
-    nullCheckExpression = t.logicalExpression('&&', nullCheckExpression, nullCheckConditions[i]);
-  }
-  
-  return t.objectProperty(
-    t.identifier('computed'),  // 为对象添加 computed 属性
-    t.objectExpression([  // 计算属性
-      t.objectProperty(
-        t.identifier(computedName),  // 计算属性的名称
-        t.functionExpression(  // 计算属性的值是一个函数
-          null, //不需要传参
-          [],
-          t.blockStatement([  // 函数体是一个块语句，包含多个语句
-            // 先判断对象本身是否存在（逐级检查），不存在直接返回空对象
-            t.ifStatement(
-              t.unaryExpression('!', nullCheckExpression),
-              t.blockStatement([
-                t.returnStatement(t.objectExpression([]))
-              ])
-            ),
-            t.ifStatement(// if (this.xxx && this.xxx.style)
-              t.logicalExpression(  
-                '&&',  // 使用逻辑"与"操作符
-                valueExpression,
-                styleExpression
-              ),
-              t.blockStatement([  // 如果条件符合
-                t.expressionStatement( 
-                  t.assignmentExpression(
-                    '=',  // 赋值操作
-                    styleExpression,
-                    t.callExpression(
-                      t.memberExpression(t.thisExpression(), t.identifier('_px2rem')),  // this._px2rem 函数
-                      [styleExpression]
-                    )
-                  )
-                )
-              ]),
-            ),
-            t.returnStatement( // 返回展开后的浅拷贝，确保引用变化以触发依赖更新
-              t.objectExpression([
-                t.spreadElement(
-                  t.callExpression(
-                    t.memberExpression(t.identifier('Object'), t.identifier('assign')),
-                    [
-                      t.objectExpression([]),
-                      valueExpression
-                    ]
-                  )
-                )
-              ])
-            )
-          ])
-      )
-    )
-  ])
-  );
-}
-
-
 /**
  * 根据引入的路径获取组件导入的路径
  * @param {*} address 
@@ -284,15 +209,6 @@ function getAbsPath(address){
  * @param {*} propertyPath 属性路径字符串
  * @returns AST 成员表达式节点
  */
-function createMemberExpressionFromPath(propertyPath) {
-  const parts = propertyPath.split('.');
-  let expression = t.memberExpression(t.thisExpression(), t.identifier(parts[0]));
-  for (let i = 1; i < parts.length; i++) {
-    expression = t.memberExpression(expression, t.identifier(parts[i]));
-  }
-  return expression;
-}
-
 /**
  * 生产SFC代码
  * @param {*} moduleResoveRet 
@@ -348,47 +264,7 @@ function addComponentsProperty(data) {
     })
   }
 }
-function addComputedPropertyToScript(scriptAst, vBindMap) {
-  vBindMap.forEach((obj,customComputedName) => {
-    const computedProperty = createComputedProperty(obj.computedName, customComputedName);
-    traverse(scriptAst, {
-      ObjectExpression(path) { //对象key value
-        const computedNode = path.node.properties.find(
-          (property) => property.key && property.key.name === 'computed'
-        );
-        if (computedNode) {  // 如果找到了computed，检查是否已经存在该计算属性
-          const existingProperty = computedNode.value.properties.find(
-            (property) => property.key && property.key.name === customComputedName
-          );
-          
-          if (!existingProperty) {  // 如果没有相同名称的计算属性，插入新计算属性
-            computedNode.value.properties.push(computedProperty.value.properties[0]);
-          }
-        }
-      },
-      // 判断computed是否存在
-      ExportDefaultDeclaration(path) {
-        if (t.isObjectExpression(path.node.declaration)) {
-          const properties = path.node.declaration.properties;
-          let computedPropertyNode = properties.find((item) => item.key.name === 'computed');
-          if (!computedPropertyNode) {//创建
-            computedPropertyNode = t.objectProperty(t.identifier('computed'), t.objectExpression([]));
-            properties.push(computedPropertyNode);
-          }
-          // 继续检查是否已存在相同名称的计算属性
-          const existingProperty = computedPropertyNode.value.properties.find(
-            (property) => property.key && property.key.name === customComputedName
-          );
-          
-          if (!existingProperty) {
-            computedPropertyNode.value.properties.push(computedProperty.value.properties[0]);
-          }
-        }
-      }
-    });
-  });
-}
-// v-for: 注入 v-bind 方法（接收循环项，px2rem，返回新对象）
+// 将 v-bind 表达式转为方法调用（接收源数据，px2rem，返回新对象）
 /**
  * v-for 场景专用：将模板中的 v-bind="expr" 改写为 v-bind="method(expr)"
  * - methodName: 注入到 methods 的方法名
@@ -403,6 +279,12 @@ function createVBindMethod(methodName, paramName) {
     t.identifier(methodName),
     [t.identifier(paramName)],
     t.blockStatement([
+      t.ifStatement(
+        t.unaryExpression('!', t.identifier(paramName)),
+        t.blockStatement([
+          t.returnStatement(t.objectExpression([]))
+        ])
+      ),
       t.ifStatement(
         t.logicalExpression(
           '&&',
@@ -550,13 +432,10 @@ module.exports = function (source) {
       componentSet.clear()
     }
     
-    if (vBindMap.size !== 0) {
-      addComputedPropertyToScript(scriptAst, vBindMap);
-      vBindMap.clear()
-    }
     if (vBindMethodMap.size !== 0) {
       addVBindMethodsToScript(scriptAst, vBindMethodMap)
       vBindMethodMap.clear()
+      vBindMethodCounter = 0
     }
 
     const {