@tarojs/plugin-platform-harmony-ets 3.7.0-alpha.27 → 4.0.0-beta.0

package/dist/components-harmony-ets/utils/flexManager.ets

@@ -12,96 +12,11 @@ class FlexManager {
     return {
       direction: flexDirection,
       justifyContent: hmStyle.justifyContent,
-      alignItems: hmStyle.alignItems
+      alignItems: hmStyle.alignItems,
+      wrap: hmStyle.flexWrap,
+      alignContent: hmStyle.alignContent,
     }
   }
-
-  static flexAlign (value: string | number | undefined): FlexAlign {
-    switch (value) {
-      case 'flex-end':
-        return FlexAlign.End
-      case 'center':
-        return FlexAlign.Center
-      case 'space-between':
-        return FlexAlign.SpaceBetween
-      case 'space-around':
-        return FlexAlign.SpaceAround
-      case 'space-evenly':
-        return FlexAlign.SpaceEvenly
-      default:
-        return FlexAlign.Start
-    }
-  }
-
-  static direction (value: string): FlexDirection {
-    switch (value) {
-      case 'row': return FlexDirection.Row;
-      case 'row-reverse': return FlexDirection.RowReverse;
-      case 'column-reverse': return FlexDirection.ColumnReverse;
-      default: return FlexDirection.Column;
-    }
-  }
-
-  static itemAlign (value: string | number | undefined): ItemAlign {
-    switch (value) {
-      case 'flex-start':
-        return ItemAlign.Start
-      case 'flex-end':
-        return ItemAlign.End
-      case 'center':
-        return ItemAlign.Center
-      case 'stretch':
-        return ItemAlign.Stretch
-      case 'baseline':
-        return ItemAlign.Baseline
-      default:
-        return ItemAlign.Auto
-    }
-  }
-
-  static justifyContent (value: string): FlexAlign {
-    return FlexManager.flexAlign(value)
-  }
-
-  static alignItems (value: string): ItemAlign {
-    return FlexManager.itemAlign(value)
-  }
-
-  static alignSelf (value: string): ItemAlign {
-    return FlexManager.itemAlign(value)
-  }
-
-  static flexWrap (value: string): FlexWrap {
-    return value === 'wrap' ? FlexWrap.Wrap : FlexWrap.NoWrap
-  }
-
-  static alignContent (style: Record<string, string | number> = {}): FlexAlign | undefined {
-    if (style.flexWrap !== 'wrap') return undefined
-    const value = style.alignContent
-    return FlexManager.flexAlign(value)
-  }
-
-  static flexSize (style: Record<string, string | number> = {}): [number, number, number | string] {
-    const flex = style.flex
-    const flexGrow = style.flexGrow || 0
-    const flexShrink = style.flexShrink || 0
-    const flexBasis = style.flexBasis || 'auto'
-    let res: [number, number, number | string] = [Number(flexGrow), Number(flexShrink), flexBasis]
-
-    if (typeof flex === 'number') {
-      res = [flex, 1, 0]
-    } else if (flex === 'auto') {
-      res = [1, 1, 'auto']
-    } else if (flex === 'none') {
-      res = [0, 0, 'auto']
-    } else if (typeof flex === 'string') {
-      const FlexList = flex.replace(new RegExp("/\s+/g"), ' ').split(' ')
-      FlexList.forEach((item, index) => {
-        res[index] = index < 2 ? Number(item) : item
-      })
-    }
-    return res
-  }
 }
 
 export { FlexManager }

package/dist/components-harmony-ets/utils/helper.ets

@@ -1,8 +1,7 @@
 import { getNormalAttributes, getFontAttributes } from './styles'
-import { bindAttributesCallback, ObjectAssign } from '@tarojs/runtime'
 
-import type { TaroAny, TaroElement } from '@tarojs/runtime'
 import type { Func } from '@tarojs/runtime/dist/runtime.esm'
+import type { TaroElement } from '@tarojs/runtime'
 
 export const parseStyles = (styles = ''): Record<string, string> => {
   const styleObj: Record<string, string> = {}
@@ -21,7 +20,6 @@ export const parseStyles = (styles = ''): Record<string, string> => {
   return styleObj
 }
 
-
 export function shouldBindEvent (cb: Func, node: TaroElement, eventNames: string[], disabled = false) {
   if (!node || node._attrs?.disabled || disabled) return null
   if (!node.__listeners) {
@@ -35,65 +33,7 @@ export function shouldBindEvent (cb: Func, node: TaroElement, eventNames: string
 export function getNodeThresholds (node: TaroElement): number[] | null {
   if (!node) return null
 
-  const id = node._nid
-  const instance: TaroAny = node._instance
-
-  return instance?.nodeInfoMap?.[id]?.thresholds || null
-}
-
-function convertToCamelCase(str: string) {
-  return str.replace(new RegExp("/-(.)/g"), (_, char: string) => char.toUpperCase()).replace(new RegExp("/^\w/"), firstChar => firstChar.toUpperCase())
-}
-
-// 动画绑定
-export function bindAnimation (node: TaroElement) {
-  bindAttributesCallback(node, 'animation', async (animation: TaroAny) => {
-    if (animation && animation.actions) {
-      for (let i = 0; i < animation.actions.length; i++) {
-        const anim: TaroAny = animation.actions[i]
-        // 动画队列
-        await new Promise<TaroAny>((resolve: TaroAny) => {
-          const timingFunction: TaroAny = anim.timingFunction
-          const animateParams: AnimateParam = {
-            duration: anim.duration,
-            delay: anim.delay,
-            tempo: 1,
-            // TODO: ETS转TS
-            playMode: PlayMode.Normal,
-            iterations: 1,
-            onFinish: resolve
-          }
-          if (timingFunction === 'step-start') {
-            animateParams.tempo = 0
-          } else if (timingFunction === 'step-end') {
-            animateParams.tempo = 0
-            animateParams.delay = anim.duration + anim.delay
-            animateParams.duration = 0
-          }
-          animateParams.curve = Curve[convertToCamelCase(timingFunction)] || Curve.EaseInOut
-          animateTo(animateParams, () => {
-            const component: TaroAny = node._instance
-            const transformOrigin: string = anim.transformOrigin
-
-            if (transformOrigin) {
-              const splitOrigin = transformOrigin.split(' ')
-              Object.keys(anim.rule).forEach(key => {
-                if (['scale', 'rotate'].includes(key)) {
-                  anim.rule[key] = ObjectAssign(anim.rule[key], {
-                    centerX: splitOrigin[0],
-                    centerY: splitOrigin[1],
-                  })
-                }
-              })
-            }
-
-            component.nodeInfoMap[node._nid].overwriteStyle = anim.rule
-            node.updateComponent()
-          })
-        })
-      }
-    }
-  })
+  return node?._nodeInfo.thresholds || null
 }
 
 export { getNormalAttributes, getFontAttributes }

package/dist/components-harmony-ets/utils/index.ts

@@ -1,7 +1,7 @@
 import { convertNumber2VP } from '@tarojs/runtime'
 import { isNumber } from '@tarojs/shared'
 
-export function getSingleSelector(ctx, range, rangeKey): any[] {
+export function getSingleSelector(range, rangeKey): any[] {
   return range.map((data) => data[rangeKey])
 }
 

package/dist/components-harmony-ets/utils/styles.ets

@@ -1,10 +1,9 @@
 import { ObjectAssign } from '@tarojs/runtime'
 
-import { AttributeManager } from './AttributeManager'
 import { TEXT_DEFAULT_STYLE } from './constant/style'
 
-import type { TaroAny, TaroElement, TaroStyleType, TaroTextStyleType, HarmonyType, HarmonyStyle } from '@tarojs/runtime'
 import type { StandardProps } from '@tarojs/components/types'
+import type { TaroAny, TaroElement, TaroStyleType, TaroTextStyleType, HarmonyType, HarmonyStyle } from '@tarojs/runtime'
 
 export function getFontAttributes (node: TaroElement): TaroTextStyleType {
   const hmStyle = node.hmStyle
@@ -54,6 +53,7 @@ export function getNormalAttributes (node: TaroElement): TaroStyleType {
     backgroundImage: hmStyle.backgroundImage,
     backgroundImageSize: hmStyle.backgroundImageSize,
     backgroundRepeat: hmStyle.backgroundRepeat,
+    backgroundImagePosition: hmStyle.backgroundImagePosition,
     linearGradient: hmStyle.linearGradient,
     // 变换相关
     rotate: transformRotate,
@@ -71,16 +71,13 @@ export function getNormalAttributes (node: TaroElement): TaroStyleType {
     // 其他
     clip: hmStyle.clip,
     id: _attrs.id || _nid,
+    opacity: hmStyle.opacity,
     // focus: _attrs.focus || false,
   }
 
-
-  const id = node._nid
-  const component: TaroAny = node._instance
-
-  // taro_page 等写死在运行时里的节点，没有 _instance
-  if (component) {
-    const overwriteStyle: TaroStyleType = component.nodeInfoMap[id].overwriteStyle
+  // taro_page 等写死在运行时里的节点，没有 _nodeInfo
+  if (node._nodeInfo) {
+    const overwriteStyle: TaroStyleType = node._nodeInfo?.overwriteStyle
 
     // 处理覆盖属性：如动画的覆盖
     if (overwriteStyle) {

package/dist/components-harmony-ets/video.ets

@@ -1,13 +1,9 @@
-import { bindInstanceToNode, AREA_CHANGE_EVENT_NAME, eventHandler, getComponentEventCallback, VISIBLE_CHANGE_EVENT_NAME, initComponentNodeInfo, getPageScrollerOrNode,
-  TaroEvent, TaroAny } from '@tarojs/runtime'
+import { AREA_CHANGE_EVENT_NAME, eventHandler, getComponentEventCallback, VISIBLE_CHANGE_EVENT_NAME, createTaroEvent } from '@tarojs/runtime'
 
-import TaroComponentWrapper from './base'
 import { TOUCH_EVENT_MAP } from './utils/constant/event'
-import { createTaroEvent } from './utils/events'
-import { getNormalAttributes, shouldBindEvent, getNodeThresholds, bindAnimation } from './utils/helper'
+import { getNormalAttributes, shouldBindEvent, getNodeThresholds } from './utils/helper'
 
-import type { TaroVideoElement } from './element'
-import type { TaroStyleType } from '@tarojs/runtime'
+import type { TaroStyleType, TaroAny, TaroVideoElement, TaroEvent } from '@tarojs/runtime'
 
 export interface VideoOptions {
   src?: string | Resource
@@ -41,6 +37,7 @@ function attrs (style: TaroStyleType) {
   .backgroundColor(style.backgroundColor)
   .backgroundImage(style.backgroundImage, style.backgroundRepeat)
   .backgroundImageSize(style.backgroundImageSize)
+  .backgroundImagePosition(style.backgroundImagePosition)
   .rotate(style.rotate)
   .scale(style.scale)
   .translate(style.translate)
@@ -61,101 +58,75 @@ function props(attr: VideoAttrs) {
   .autoPlay(attr.autoPlay)
   .controls(attr.controls)
   .objectFit(attr.objectFit)
-  .loop(attr.loop)
+  .loop(attr.loop || false)
 }
 
-@Component
-export default struct TaroVideo {
-  nodeInfoMap: TaroAny = {}
+function emitEvent (node: TaroVideoElement, type: string, detail?: TaroAny) {
+  const event: TaroEvent = createTaroEvent(type, { detail }, node)
 
-  @Styles visibleChangeEvent () {
-    .onVisibleAreaChange(getNodeThresholds(this.node) || [0.0, 1.0], getComponentEventCallback(this.node, VISIBLE_CHANGE_EVENT_NAME))
-  }
-
-  @ObjectLink node: TaroVideoElement
-
-  controller: VideoController = new VideoController()
-
-  aboutToAppear () {
-    initComponentNodeInfo(this, this.node)
-    bindInstanceToNode(this.node, this)
-    // 绑定动画
-    bindAnimation(this.node)
-  }
-
-  @Styles defaultEvent () {
-    .onClick((e: ClickEvent) => {
-      eventHandler(e, 'click', this.node)
-    })
-    .onTouch(shouldBindEvent((e: TouchEvent) => eventHandler(e, TOUCH_EVENT_MAP.get(e.type), this.node), this.node, TOUCH_EVENT_MAP.values()))
-    .onAreaChange(getComponentEventCallback(this.node, AREA_CHANGE_EVENT_NAME, res => {
-      const eventResult: TaroAny = res.eventResult
-      this.nodeInfoMap[this.node._nid].areaInfo = eventResult[1]
-    }))
-  }
+  event.stopPropagation()
+  eventHandler(event, type, node)
+}
 
-  emitEvent = (type: string, detail?: TaroAny) => {
-    const event: TaroEvent = createTaroEvent(type, { detail }, this.node)
-    event.stopPropagation()
-    eventHandler(event, type, this.node)
+function getVideoData (node: TaroVideoElement): VideoOptions {
+  const src = node._attrs.src
+  const poster = node._attrs.poster
+  return {
+    src,
+    previewUri: poster,
+    controller: node.controller
   }
+}
 
-
-  getVideoData (): VideoOptions {
-    const src = this.node._attrs.src
-    const poster = this.node._attrs.poster
-    return {
-      src,
-      previewUri: poster,
-      controller: this.controller
-    }
+function getObjectFit (node: TaroVideoElement) {
+  switch (node._attrs.objectFit) {
+    case 'contain': return ImageFit.Contain
+    case 'cover': return ImageFit.Cover
+    case 'fill': return ImageFit.Fill
+    default: return ImageFit.Contain
   }
+}
 
-  getObjectFit () {
-    switch (this.node._attrs.objectFit) {
-      case 'contain': return ImageFit.Contain
-      case 'cover': return ImageFit.Cover
-      case 'fill': return ImageFit.Fill
-      default: return ImageFit.Contain
-    }
+function getVideoProps (node: TaroVideoElement): VideoAttrs {
+  const muted: boolean = node._attrs.muted || false
+  const autoPlay: boolean = node._attrs.autoplay || false
+  const controls: boolean = node._attrs.controls || false
+  const objectFit: ImageFit = getObjectFit(node)
+  const loop: boolean = node._attrs.loop || false
+  return {
+    muted,
+    controls,
+    objectFit,
+    loop,
+    autoPlay
   }
+}
 
-  getVideoProps (): VideoAttrs {
-    const muted: boolean = this.node._attrs.muted || false
-    const autoPlay: boolean = this.node._attrs.autoplay || false
-    const controls: boolean = this.node._attrs.controls || false
-    const objectFit: ImageFit = this.getObjectFit()
-    const loop: boolean = this.node._attrs.loop || false
-    return {
-      muted,
-      controls,
-      objectFit,
-      loop,
-      autoPlay
-    }
-  }
+function handleUpdate (node: TaroVideoElement, e: VideoUpdateEvent) {
+  node._currentTime = e.time
 
-  handleUpdate (e: VideoUpdateEvent) {
-    this.nodeInfoMap[this.node._nid].currentTime = e.time
-    this.emitEvent('timeUpdate', { currentTime: e.time})
-  }
+  emitEvent(node, 'timeUpdate', { currentTime: e.time})
+}
 
-  build() {
-    TaroComponentWrapper({ node: this.node }) {
-      Video(this.getVideoData())
-        .attrs(getNormalAttributes(this.node))
-        .props(this.getVideoProps())
-        .defaultEvent()
-        .visibleChangeEvent()
-        .onStart(shouldBindEvent(() => { this.emitEvent('play') }, this.node, ['play']))
-        .onPause(shouldBindEvent(() => { this.emitEvent('pause') }, this.node, ['pause']))
-        .onFinish(shouldBindEvent(() => { this.emitEvent('ended') }, this.node, ['ended']))
-        .onError(shouldBindEvent(() => { this.emitEvent('error') }, this.node, ['error']))
-        .onUpdate((e) => { this.handleUpdate(e) })
-        .onPrepared(shouldBindEvent((e: TaroAny) => { this.emitEvent('loadedMetaData', { duration: e.duration }) }, this.node, ['loadedmetadata']))
-        .onSeeking(shouldBindEvent((e: TaroAny) => { this.emitEvent('seeking', { duration: e.time }) }, this.node, ['seeking']))
-        .onSeeked(shouldBindEvent(() => { this.emitEvent('seeked') }, this.node, ['seeked']))
-        .onFullscreenChange(shouldBindEvent((e: TaroAny) => { this.emitEvent('fullScreenChange', { fullScreen: e.fullscreen}) }, this.node, ['fullscreenchange']))
-    }
-  }
+@Builder
+export default function TaroVideo (node: TaroVideoElement) {
+  Video(getVideoData(node))
+    .attrs(getNormalAttributes(node))
+    .props(getVideoProps(node))
+    .aspectRatio(4 / 3)
+    .onStart(shouldBindEvent(() => { emitEvent(node, 'play') }, node, ['play']))
+    .onPause(shouldBindEvent(() => { emitEvent(node, 'pause') }, node, ['pause']))
+    .onFinish(shouldBindEvent(() => { emitEvent(node, 'ended') }, node, ['ended']))
+    .onError(shouldBindEvent(() => { emitEvent(node, 'error') }, node, ['error']))
+    .onUpdate((e) => { handleUpdate(node, e) })
+    .onPrepared(shouldBindEvent((e: TaroAny) => { emitEvent(node, 'loadedMetaData', { duration: e.duration }) }, node, ['loadedmetadata']))
+    .onSeeking(shouldBindEvent((e: TaroAny) => { emitEvent(node, 'seeking', { duration: e.time }) }, node, ['seeking']))
+    .onSeeked(shouldBindEvent(() => { emitEvent(node, 'seeked') }, node, ['seeked']))
+    .onFullscreenChange(shouldBindEvent((e: TaroAny) => { emitEvent(node, 'fullScreenChange', { fullScreen: e.fullscreen}) }, node, ['fullscreenchange']))
+    .onClick((e: ClickEvent) => { eventHandler(e, 'click', node) })
+    .onTouch(shouldBindEvent((e: TouchEvent) => eventHandler(e, TOUCH_EVENT_MAP.get(e.type), node), node, TOUCH_EVENT_MAP.values()))
+    .onAreaChange(getComponentEventCallback(node, AREA_CHANGE_EVENT_NAME, (res: TaroAny) => {
+      node._nodeInfo.areaInfo = res[1]
+    }))
+    .onVisibleAreaChange(getNodeThresholds(node) || [0.0, 1.0], getComponentEventCallback(node, VISIBLE_CHANGE_EVENT_NAME))
 }

package/dist/components-harmony-ets/view.ets

@@ -1,30 +1,61 @@
-import { bindInstanceToNode, eventHandler, getComponentEventCallback, AREA_CHANGE_EVENT_NAME, VISIBLE_CHANGE_EVENT_NAME, initComponentNodeInfo, TaroAny } from '@tarojs/runtime'
+import { eventHandler, getComponentEventCallback, AREA_CHANGE_EVENT_NAME, VISIBLE_CHANGE_EVENT_NAME } from '@tarojs/runtime'
 
-import { createNode } from './render'
-import TaroComponentWrapper from './base'
+import { createLazyChildren } from './render'
 import { TOUCH_EVENT_MAP } from './utils/constant/event'
 import { FlexManager } from './utils/FlexManager'
-import { getNodeThresholds, getNormalAttributes, shouldBindEvent, bindAnimation } from './utils/helper'
+import { getNodeThresholds, getNormalAttributes, shouldBindEvent } from './utils/helper'
 
-import type { TaroViewElement, TaroElement } from './element'
-import type { TaroStyleType } from '@tarojs/runtime'
+import type { TaroViewElement, TaroAny, TaroStyleType } from '@tarojs/runtime'
 
 @Extend(Flex)
-function attrs (style: TaroStyleType) {
+function flexAttrs (style: TaroStyleType) {
   .id(style.id)
   .key(style.id)
+  .flexGrow(style.flexGrow)
+  .flexShrink(style.flexShrink)
+  .flexBasis(style.flexBasis)
+  .alignSelf(style.alignSelf)
   .padding(style.padding)
   .margin(style.margin)
   .width(style.width)
   .height(style.height)
   .constraintSize(style.constraintSize)
+  .backgroundColor(style.backgroundColor)
+  .backgroundImage(style.backgroundImage, style.backgroundRepeat)
+  .backgroundImageSize(style.backgroundImageSize)
+  .backgroundImagePosition(style.backgroundImagePosition)
+  .rotate(style.rotate)
+  .scale(style.scale)
+  .translate(style.translate)
+  .transform(style.transform)
+  .borderStyle(style.borderStyle)
+  .borderWidth(style.borderWidth)
+  .borderColor(style.borderColor)
+  .borderRadius(style.borderRadius)
+  .linearGradient(style.linearGradient)
+  .zIndex(style.zIndex)
+  .opacity(style.opacity)
+  .clip(style.clip)
+}
+
+
+@Extend(Column)
+function columnAttrs (style: TaroStyleType) {
+  .id(style.id)
+  .key(style.id)
   .flexGrow(style.flexGrow)
   .flexShrink(style.flexShrink)
   .flexBasis(style.flexBasis)
   .alignSelf(style.alignSelf)
+  .padding(style.padding)
+  .margin(style.margin)
+  .width(style.width)
+  .height(style.height)
+  .constraintSize(style.constraintSize)
   .backgroundColor(style.backgroundColor)
   .backgroundImage(style.backgroundImage, style.backgroundRepeat)
   .backgroundImageSize(style.backgroundImageSize)
+  .backgroundImagePosition(style.backgroundImagePosition)
   .rotate(style.rotate)
   .scale(style.scale)
   .translate(style.translate)
@@ -39,41 +70,35 @@ function attrs (style: TaroStyleType) {
   .clip(style.clip)
 }
 
-@Component
-export default struct TaroView {
-  nodeInfoMap: TaroAny = {}
-
-  @Styles visibleChangeEvent () {
-    .onVisibleAreaChange(getNodeThresholds(this.node) || [0.0, 1.0], getComponentEventCallback(this.node, VISIBLE_CHANGE_EVENT_NAME))
-  }
-
-  @ObjectLink node: TaroViewElement
-
-  aboutToAppear () {
-    initComponentNodeInfo(this, this.node)
-    bindInstanceToNode(this.node, this)
-    // 绑定动画
-    bindAnimation(this.node)
-  }
+function isFlexNode (node: TaroViewElement) {
+  return !!node.hmStyle?.display?.includes('flex')
+}
 
-  @Styles defaultEvent () {
-    .onClick(shouldBindEvent((e: ClickEvent) => eventHandler(e, 'click', this.node), this.node, ['click']))
-    .onTouch(shouldBindEvent((e: TouchEvent) => eventHandler(e, TOUCH_EVENT_MAP.get(e.type), this.node), this.node, TOUCH_EVENT_MAP.values()))
-    .onAreaChange(getComponentEventCallback(this.node, AREA_CHANGE_EVENT_NAME, res => {
-      const eventResult: TaroAny = res.eventResult
-      this.nodeInfoMap[this.node._nid].areaInfo = eventResult[1]
+@Builder
+export default function TaroView (node: TaroViewElement) {
+  if (isFlexNode(node)) {
+    Flex(FlexManager.flexOptions(node)) {
+      createLazyChildren(node)
+    }
+    .flexAttrs(getNormalAttributes(node))
+    .onClick(shouldBindEvent((e: ClickEvent) => eventHandler(e, 'click', node), node, ['click']))
+    .onTouch(shouldBindEvent((e: TouchEvent) => eventHandler(e, TOUCH_EVENT_MAP.get(e.type), node), node, TOUCH_EVENT_MAP.values()))
+    .onAreaChange(getComponentEventCallback(node, AREA_CHANGE_EVENT_NAME, (res: TaroAny) => {
+      node._nodeInfo.areaInfo = res[1]
     }))
-  }
-  build() {
-    TaroComponentWrapper({ node: this.node }) {
-      Flex(FlexManager.flexOptions(this.node)) {
-        ForEach(this.node.childNodes, (item: TaroElement) => {
-          createNode(item)
-        }, (item: TaroElement) => item._nid)
-      }
-      .attrs(getNormalAttributes(this.node))
-      .defaultEvent()
-      .visibleChangeEvent()
+    .onVisibleAreaChange(getNodeThresholds(node) || [0.0, 1.0], getComponentEventCallback(node, VISIBLE_CHANGE_EVENT_NAME))
+  } else {
+    Column() {
+      createLazyChildren(node)
     }
+    .columnAttrs(getNormalAttributes(node))
+    .onClick(shouldBindEvent((e: ClickEvent) => eventHandler(e, 'click', node), node, ['click']))
+    .onTouch(shouldBindEvent((e: TouchEvent) => eventHandler(e, TOUCH_EVENT_MAP.get(e.type), node), node, TOUCH_EVENT_MAP.values()))
+    .onAreaChange(getComponentEventCallback(node, AREA_CHANGE_EVENT_NAME, (res: TaroAny) => {
+      node._nodeInfo.areaInfo = res[1]
+    }))
+    .onVisibleAreaChange(getNodeThresholds(node) || [0.0, 1.0], getComponentEventCallback(node, VISIBLE_CHANGE_EVENT_NAME))
+    .alignItems(HorizontalAlign.Start)
+    .justifyContent(node.hmStyle.justifyContent)
   }
 }

package/dist/index.js

@@ -71,7 +71,7 @@ function __classPrivateFieldSet(receiver, state, value, kind, f) {
 }
 
 const PLATFORM_NAME = 'harmony';
-const PACKAGE_NAME = '@tarojs/plugin-platform-harmony';
+const PACKAGE_NAME = '@tarojs/plugin-platform-harmony-ets';
 const PLUGIN_NAME = 'TaroHarmony';
 const HARMONY_SCOPES = [/^@system\./, /^@ohos\./, /^@hmscore\//];
 
@@ -224,7 +224,7 @@ let Harmony$1 = class Harmony extends TaroPlatformHarmony {
             ['@tarojs/components/types', /^@tarojs[\\/]components[\\/]types/],
             ['@tarojs/components', /^@tarojs[\\/]components([\\/].+)?$/, this.componentLibrary],
             ['@tarojs/react', /^@tarojs[\\/]react$/],
-            ['@tarojs/runtime', /^@tarojs[\\/]runtime$/, this.runtimeLibrary],
+            ['@tarojs/runtime', /^@tarojs[\\/]runtime([\\/]ets[\\/].*)?$/, this.runtimeLibrary],
             ['@tarojs/taro/types', /^@tarojs[\\/]taro[\\/]types/],
             ['@tarojs/taro', /^@tarojs[\\/]taro$/, this.apiLibrary],
             ['@tarojs/plugin-framework-react/dist/runtime', /^@tarojs[\\/]plugin-framework-react[\\/]dist[\\/]runtime$/, this.runtimeFrameworkLibrary],
@@ -236,6 +236,10 @@ let Harmony$1 = class Harmony extends TaroPlatformHarmony {
                 this.modifyViteConfig();
             },
         });
+        ctx.onBuildFinish(() => {
+            const outDir = path__namespace.resolve(process.cwd(), config.outputRoot);
+            this.handleResourceEmit(outDir);
+        });
     }
     get framework() {
         return this.ctx.initialConfig.framework || 'react';
@@ -312,6 +316,7 @@ let Harmony$1 = class Harmony extends TaroPlatformHarmony {
                     basedir,
                     extensions: this.extensions,
                     mainFields: [...helper.defaultMainFields],
+                    preserveSymlinks: false,
                 });
                 if (!typePath) {
                     typeName = path__namespace.join(path__namespace.dirname(lib), `${basename}.d.ts`);
@@ -319,6 +324,7 @@ let Harmony$1 = class Harmony extends TaroPlatformHarmony {
                         basedir,
                         extensions: this.extensions,
                         mainFields: [...helper.defaultMainFields],
+                        preserveSymlinks: false,
                     });
                 }
                 if (typePath) {
@@ -345,7 +351,9 @@ let Harmony$1 = class Harmony extends TaroPlatformHarmony {
                     else {
                         // FIXME 多级目录，可能存在入口不为 index 或者引用一级目录文件的情况，需要额外处理
                         const dir = path__namespace.dirname(pkgPath);
-                        target = path__namespace.join(target, dir);
+                        if (libDir.includes(helper.NODE_MODULES)) {
+                            target = path__namespace.join(target, dir);
+                        }
                         lib = path__namespace.dirname(lib);
                     }
                 }
@@ -378,7 +386,7 @@ let Harmony$1 = class Harmony extends TaroPlatformHarmony {
                     const targetPath = path__namespace.join(outputRoot, helper.NODE_MODULES, p1);
                     const relativePath = parseRelativePath(path__namespace.dirname(target), targetPath);
                     if (HARMONY_SCOPES.every(e => !e.test(p1))) {
-                        if (this.indexOfLibraries(p1) === -1) {
+                        if (this.indexOfLibraries(p1) === -1 && !/\.(d\.ts|flow\.js)$/.test(lib)) {
                             this.externalDeps.push([p1, new RegExp(`^${p1.replace(/([-\\/$])/g, '\\$1')}$`)]);
                             this.moveLibraries(p1, targetPath, path__namespace.dirname(lib), true);
                         }
@@ -533,6 +541,27 @@ function App(props) {
             viteConfig.plugins.push(externalPlugin(), injectLoaderMeta());
         });
     }
+    handleResourceEmit(outDir, basedir = this.ctx.paths.appPath) {
+        const resources = path__namespace.resolve(outDir, '..', 'resources');
+        const mediaPath = 'static/media';
+        const mediaSource = helper.resolveSync(`${PACKAGE_NAME}/${mediaPath}`, {
+            basedir,
+            extensions: this.extensions,
+            mainFields: [...helper.defaultMainFields],
+            preserveSymlinks: false,
+            isFile: (file) => {
+                try {
+                    const stat = helper.fs.lstatSync(file);
+                    return stat.isFile() || (file.endsWith(mediaPath) && stat.isDirectory());
+                }
+                catch (_) { } // eslint-disable-line no-empty
+                return false;
+            }
+        });
+        if (mediaSource) {
+            this.moveLibraries(mediaSource, path__namespace.join(resources, 'base/media'), basedir);
+        }
+    }
 };
 _Harmony_defineConstants = new WeakMap();