@tarojs/plugin-platform-harmony-ets 3.7.0-alpha.27

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

@@ -0,0 +1,250 @@
+import { convertNumber2VP, TaroAny } from '@tarojs/runtime'
+import matrix4 from '@ohos.matrix4'
+
+type matrixNums = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number]
+
+interface IRotate {
+  x?: number,
+  y?: number,
+  z?: number,
+  angle: number | string,
+  centerX?: number | string,
+  centerY?: number | string
+}
+
+interface ITranslate {
+  x?: number | string,
+  y?: number | string,
+  z? : number | string
+}
+
+interface IScale {
+  x?: number,
+  y?: number,
+  z?: number,
+  centerX?: number | string,
+  centerY?: number | string
+}
+
+interface ITransform {
+  rotate: IRotate
+  translate: ITranslate
+  scale: IScale
+  transform?: matrix4.Matrix4Transit
+}
+
+class AttributeManager {
+
+  static getNodeStyle<T = TaroAny> (style: TaroAny = {}, name: string, defaultValue?: TaroAny): T {
+    const res: TaroAny = style[name]
+
+    if (res === undefined) return defaultValue
+
+    return res
+  }
+
+  static getTextAlign (style: TaroAny = {}): TextAlign {
+    const value: string = style.textAlign
+    switch (value) {
+      case 'right':
+        return TextAlign.End
+      case 'center':
+        return TextAlign.Center
+      default:
+        return TextAlign.Start
+    }
+  }
+
+  static getNodeAnimationData (style: TaroAny = {}): TaroAny {
+    let res: TaroAny = {}
+    const dataValue: string = AttributeManager.getNodeStyle(style, 'animation')
+
+    if (dataValue) {
+      let values: string[] = dataValue.trim().split(new RegExp("/\s+/"))
+      switch (values.length) {
+        case 4:
+          res = { duration: values[0], curve: values[1], delay: values[2] }
+          break
+        case 8:
+          res = { duration: values[0], curve: values[1], delay: values[2], iterations: values[3], playMode: values[4] }
+          break
+        default:
+          break
+      }
+
+      Object.keys(res).forEach(key => {
+        if (!isNaN(res[key]) && values.length > 1) {
+          res[key] = convertNumber2VP(res[key])
+        }
+      })
+    }
+
+    let playMode: PlayMode
+    switch (AttributeManager.getNodeStyle(style, 'animationDirection') || res.playMode) {
+      case 'reverse':
+        playMode = PlayMode.Reverse
+        break
+      case 'alternate':
+        playMode = PlayMode.Alternate
+        break
+      case 'alternate-reverse':
+        playMode = PlayMode.AlternateReverse
+        break
+      case 'normal':
+      default:
+        playMode = PlayMode.Normal
+    }
+    return {
+      duration: AttributeManager.parseTime2Number(AttributeManager.getNodeStyle(style, 'animationDuration') || res.duration || 1000),
+      tempo: 1,
+      curve: AttributeManager.getNodeStyle(style, 'animationTimingFunction') || res.curve || Curve.EaseInOut,
+      delay: AttributeManager.parseTime2Number(AttributeManager.getNodeStyle(style, 'animationDelay') || res.delay || 0),
+      iterations: Number(AttributeManager.getNodeStyle(style, 'animationIterationCount') || res.iterations) || 1,
+      playMode,
+      // TODO onFinish
+    }
+  }
+
+  static parseTime2Number (time = ''): number {
+    if (typeof time === 'number') return time
+    if (time === 'infinite') return Infinity
+    if (time === 'auto') return 0
+
+    const matchs = time.match(new RegExp("/^(\d*)([a-z]*)$/")) || []
+
+    const value = matchs[1]
+    const unit = matchs[2]
+
+    let ms = Number(value)
+    switch (unit) {
+      case 's':
+        ms *= 1000
+        break
+      case 'ms':
+      default:
+        ms *= 1
+    }
+    return ms
+  }
+
+  static getTransform(style: TaroAny = {}): ITransform {
+    const transform: string = style.transform || ''
+    const transformOrigin: string = AttributeManager.getNodeStyle(style, 'transformOrigin') || '0 0'
+
+    const origin: (string | number)[] = transformOrigin.split(new RegExp("/\s+/")).map(item => item)
+
+    const result: ITransform = {
+      rotate: { angle: 0 },
+      translate: {},
+      scale: {},
+    }
+    let resultTransform: matrix4.Matrix4Transit
+
+    const matches = transform.match(new RegExp("/(\w+)\(([^)]+)\)/g")) || [];
+
+    // 处理matrix
+
+    matches.forEach(match => {
+      const matchs = match.split(new RegExp("/\(|\)/")).filter(Boolean);
+      const name: string = matchs[0]
+      const params: string[] = []
+      for (let i = 1; i < matchs.length; i++) {
+        params.push(matchs[i])
+      }
+
+      switch (name) {
+        case 'translateX':
+          result.translate.x = parseTransformUnit(params[0])
+          break;
+        case 'translateY':
+          result.translate.y = parseTransformUnit(params[0])
+          break;
+        case 'translateZ':
+          result.translate.z = parseTransformUnit(params[0])
+          break;
+        case 'scaleX':
+          result.scale.x = parseFloat(params[0])
+          break;
+        case 'scaleY':
+          result.scale.y = parseFloat(params[0])
+          break;
+        case 'scaleZ':
+          result.scale.z = parseFloat(params[0])
+          break;
+        case 'rotateX':
+          result.rotate.x = parseFloat(params[0])
+          break;
+        case 'rotateY':
+          result.rotate.y = parseFloat(params[0])
+          break;
+        case 'rotateZ':
+          result.rotate.z = parseFloat(params[0])
+          break;
+        case 'translate':
+          const xy = params[0].split(new RegExp("/\s*,\s*/"))
+          result.translate.x = parseTransformUnit(xy[0])
+          result.translate.y = parseTransformUnit(xy[1])
+          break;
+        case 'translate3d':
+          const xyz = params[0].split(new RegExp("/\s*,\s*/"))
+          result.translate.x = parseTransformUnit(xyz[0])
+          result.translate.y = parseTransformUnit(xyz[1])
+          result.translate.z = parseTransformUnit(xyz[2])
+          break;
+        case 'scale':
+          result.scale.x = parseFloat(params[0])
+          result.scale.y = parseFloat(params[1]) || result.scale.x
+          break;
+        case 'scale3d':
+          result.scale.x = parseFloat(params[0])
+          result.scale.y = parseFloat(params[1]) || result.scale.x
+          result.scale.z = parseFloat(params[2]) || result.scale.x
+          break;
+        case 'rotate':
+          const angle = parseFloat(params[0])
+          const axis = parseTransformUnit(params[1]) || 'z';
+          switch (axis) {
+            case 'x': result.rotate.x = angle; break
+            case 'y': result.rotate.y = angle; break
+            case 'z': result.rotate.z = angle; break
+          }
+          break;
+        case 'rotate3d':
+          result.rotate.x = parseFloat(params[0]) || 0
+          result.rotate.y = parseFloat(params[1]) || 0
+          result.rotate.z  = parseFloat(params[2]) || 0
+          break;
+        case 'matrix':
+          const matrixArr: number[] = params[0].split(',').map(item => parseFloat(item))
+          result.transform = matrix4.init(convertMatrixToMatrix3d(matrixArr))
+          break;
+        case 'matrix3d':
+          const matrix3dArr: number[] = params[0].split(',').map(item => parseFloat(item))
+          result.transform = matrix4.init(matrix3dArr as matrixNums)
+          break;
+      }
+    })
+
+    return result
+  }
+}
+
+
+function parseTransformUnit (val: string) {
+  return parseFloat(val) === 0 ? 0 : val
+}
+
+
+// matrix 转 matrix3d
+function convertMatrixToMatrix3d(matrix2d: number[]): matrixNums {
+  const matrix3d: number[] = new Array(16).fill(0);
+  matrix3d[0] = matrix2d[0];
+  matrix3d[5] = matrix2d[3];
+  matrix3d[10] = 1;
+  matrix3d[15] = 1;
+  matrix3d[12] = matrix2d[4];
+  matrix3d[13] = matrix2d[5];
+  return matrix3d as matrixNums;
+}
+
+export { AttributeManager }

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

@@ -0,0 +1,48 @@
+import { bindFocus, bindInstanceToNode, bindScrollTo, initComponentNodeInfo, TaroAny, TaroElement } from '@tarojs/runtime'
+
+import { bindAnimation } from './helper'
+
+export class DynamicCenter {
+
+  install (node: TaroElement, parentNode: TaroElement) {
+    if (!parentNode._isCompileMode) return
+
+    this.bindComponentToNodeWithDFS(node, parentNode._instance)
+  }
+
+  uninstall (node: TaroElement) {
+    if (!node._isCompileMode || !node._instance) return
+
+    if (node._attrs?._dynamicID) {
+      node._instance[node._attrs._dynamicID] = null
+    }
+    node._instance = null
+  }
+
+  bindComponentToNodeWithDFS (node: TaroElement, component: TaroAny) {
+    if (!node) return
+
+    const dynamicID = node._attrs?._dynamicID
+
+    // dynamicID 只是为了更新到精准的 node
+    // 而为了让半编译模板中每个 node 都能响应 api 的调用，因此 initComponentNodeInfo、bindInstanceToNode 和各种 bindAttribute 都需要执行
+    initComponentNodeInfo(component, node)
+    bindInstanceToNode(node, component)
+    bindFocus(node)
+    bindAnimation(node)
+    bindScrollTo(node, component)
+
+    node._isCompileMode = true
+
+    if (dynamicID) {
+      node._isDynamicNode = true
+      component[dynamicID] = node
+    }
+
+    if (!node.childNodes || !node.childNodes.length) return
+
+    for (let i = 0; i < node.childNodes.length; i++) {
+      this.bindComponentToNodeWithDFS(node.childNodes[i] as TaroElement, component)
+    }
+  }
+}

package/dist/components-harmony-ets/utils/constant/event.ets

@@ -0,0 +1,25 @@
+export class TOUCH_EVENT_MAP {
+  static readonly TouchTypeUp = 'touchend'
+  static readonly TouchTypeMove = 'touchmove'
+  static readonly TouchTypeDown = 'touchstart'
+  static readonly TouchTypeCancel = 'touchcancel'
+
+  static get (event: TouchType) {
+    switch (event) {
+      case TouchType.Up: return TOUCH_EVENT_MAP.TouchTypeUp
+      case TouchType.Move: return TOUCH_EVENT_MAP.TouchTypeMove
+      case TouchType.Down: return TOUCH_EVENT_MAP.TouchTypeDown
+      case TouchType.Cancel: return TOUCH_EVENT_MAP.TouchTypeCancel
+    }
+    return TOUCH_EVENT_MAP.TouchTypeUp
+  }
+
+  static values () {
+    return [
+      TOUCH_EVENT_MAP.TouchTypeUp,
+      TOUCH_EVENT_MAP.TouchTypeMove,
+      TOUCH_EVENT_MAP.TouchTypeUp,
+      TOUCH_EVENT_MAP.TouchTypeUp,
+    ]
+  }
+}

package/dist/components-harmony-ets/utils/constant/icon.ts

@@ -0,0 +1,19 @@
+const _ICON_SVG_MAP = {
+  success: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-1.177-7.86l-2.765-2.767L7%2012.431l3.119%203.121a1%201%200%20001.414%200l5.952-5.95-1.062-1.062-5.6%205.6z%22%2F%3E%3C%2Fsvg%3E',
+  success_no_circle: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M8.657%2018.435L3%2012.778l1.414-1.414%204.95%204.95L20.678%205l1.414%201.414-12.02%2012.021a1%201%200%2001-1.415%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E',
+  info: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-.75-12v7h1.5v-7h-1.5zM12%209a1%201%200%20100-2%201%201%200%20000%202z%22%2F%3E%3C%2Fsvg%3E',
+  warn: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm-.763-15.864l.11%207.596h1.305l.11-7.596h-1.525zm.759%2010.967c.512%200%20.902-.383.902-.882%200-.5-.39-.882-.902-.882a.878.878%200%2000-.896.882c0%20.499.396.882.896.882z%22%2F%3E%3C%2Fsvg%3E',
+  waiting: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12.75%2011.38V6h-1.5v6l4.243%204.243%201.06-1.06-3.803-3.804zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E',
+  cancel: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cg%20fill-rule%3D%22evenodd%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6z%22%20fill-rule%3D%22nonzero%22%2F%3E%3Cpath%20d%3D%22M12.849%2012l3.11%203.111-.848.849L12%2012.849l-3.111%203.11-.849-.848L11.151%2012l-3.11-3.111.848-.849L12%2011.151l3.111-3.11.849.848L12.849%2012z%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E',
+  download: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M11.25%2012.04l-1.72-1.72-1.06%201.06%202.828%202.83a1%201%200%20001.414-.001l2.828-2.828-1.06-1.061-1.73%201.73V7h-1.5v5.04zm0-5.04V2h1.5v5h6.251c.55%200%20.999.446.999.996v13.008a.998.998%200%2001-.996.996H4.996A.998.998%200%20014%2021.004V7.996A1%201%200%20014.999%207h6.251z%22%2F%3E%3C%2Fsvg%3E',
+  search: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M16.31%2015.561l4.114%204.115-.848.848-4.123-4.123a7%207%200%2011.857-.84zM16.8%2011a5.8%205.8%200%2010-11.6%200%205.8%205.8%200%200011.6%200z%22%20fill-rule%3D%22evenodd%22%2F%3E%3C%2Fsvg%3E',
+  clear: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M13.06%2012l3.006-3.005-1.06-1.06L12%2010.938%208.995%207.934l-1.06%201.06L10.938%2012l-3.005%203.005%201.06%201.06L12%2013.062l3.005%203.005%201.06-1.06L13.062%2012zM12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010z%22%2F%3E%3C%2Fsvg%3E',
+  circle: 'data:image/svg+xml,%3Csvg%20width%3D%221000%22%20height%3D%221000%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M500%20916.667C269.881%20916.667%2083.333%20730.119%2083.333%20500%2083.333%20269.881%20269.881%2083.333%20500%2083.333c230.119%200%20416.667%20186.548%20416.667%20416.667%200%20230.119-186.548%20416.667-416.667%20416.667zm0-50c202.504%200%20366.667-164.163%20366.667-366.667%200-202.504-164.163-366.667-366.667-366.667-202.504%200-366.667%20164.163-366.667%20366.667%200%20202.504%20164.163%20366.667%20366.667%20366.667z%22%20fill-rule%3D%22evenodd%22%20fill-opacity%3D%22.9%22%2F%3E%3C%2Fsvg%3E',
+  info_circle: 'data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M12%2022C6.477%2022%202%2017.523%202%2012S6.477%202%2012%202s10%204.477%2010%2010-4.477%2010-10%2010zm0-1.2a8.8%208.8%200%20100-17.6%208.8%208.8%200%20000%2017.6zM11.4%2010h1.2v7h-1.2v-7zm.6-1a1%201%200%20110-2%201%201%200%20010%202z%22%2F%3E%3C%2Fsvg%3E',
+}
+
+export class ICON_SVG_MAP {
+  static get (key: string): string {
+    return _ICON_SVG_MAP[key]
+  }
+}

package/dist/components-harmony-ets/utils/constant/style.ets

@@ -0,0 +1,88 @@
+// 各种组件的默认样式
+
+export class TEXT_DEFAULT_STYLE {
+  static COLOR = 'black'
+  static FONT_SIZE = '24'
+  static FONT_WEIGHT = FontWeight.Normal
+  static FONT_FAMILY = 'HarmonyOS Sans'
+  static TEXT_ALIGN = TextAlign.Start
+  static TEXT_OVERFLOW = TextOverflow.Clip
+}
+
+interface IBUTTON_THEME_COLOR {
+  text: string
+  background: string
+}
+
+export class BUTTON_THEME_COLOR {
+  static get (type: string): IBUTTON_THEME_COLOR {
+    switch (type) {
+      case 'primary': return {
+        text: '#fff',
+        background: '#1aad19',
+      }
+      case 'warn': return {
+        text: '#fff',
+        background: '#e64340'
+      }
+      default: return {
+        text: '#000',
+        background: '#f7f7f7',
+      }
+    }
+  }
+}
+
+
+export class INPUT_TYPE_MAP {
+  static get (type: string) {
+    switch (type) {
+      case 'text': return InputType.Normal;
+      case 'number': return InputType.Number;
+      case 'idcard': return InputType.Number;
+      case 'safe-password': return InputType.Password;
+    }
+    return InputType.Normal
+  }
+}
+
+export class INPUT_CONFIRM_MAP {
+  static go = EnterKeyType.Go	// 右下角按钮为“前往”
+  static send = EnterKeyType.Send	// 右下角按钮为“发送”
+  static done = EnterKeyType.Done	// 右下角按钮为“完成”
+  static next = EnterKeyType.Next	// 右下角按钮为“下一个”
+  static search = EnterKeyType.Search	// 右下角按钮为“搜索”
+
+  static get (type: string) {
+    switch (type) {
+      case 'go': return EnterKeyType.Go
+      case 'send': return EnterKeyType.Send
+      case 'done': return EnterKeyType.Done
+      case 'next': return EnterKeyType.Next
+      case 'search': return EnterKeyType.Search
+    }
+    return EnterKeyType.Done
+  }
+}
+
+export class CurveMap {
+  static default = Curve.Linear
+  static linear = Curve.Linear
+  static easeInCubic = Curve.EaseIn
+  static easeOutCubic = Curve.EaseOut
+  static easeInOutCubic = Curve.EaseInOut
+}
+
+export class BORDER_STYLE_MAP {
+  static solid = BorderStyle.Solid
+  static dotted = BorderStyle.Dotted
+  static dashed = BorderStyle.Dashed
+
+  static get(type: string): BorderStyle {
+    switch (type) {
+      case 'dotted': return BorderStyle.Dotted;
+      case 'dashed': return BorderStyle.Dashed;
+      default: return BorderStyle.Solid;
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+import { EventOptions, TaroElement, TaroEvent } from '@tarojs/runtime'
+
+export function createTaroEvent(type: string, opts: Partial<EventOptions> = {}, node?: TaroElement) {
+  opts.bubbles ||= true
+  opts.cancelable ||= true
+  const e = new TaroEvent(type, opts as Required<EventOptions>)
+
+  if (node) {
+    const properties: Record<string, PropertyDescriptor> = {}
+    properties.target = properties.currentTarget = {
+      get() {
+        return node
+      }
+    }
+    Object.defineProperties(e, properties)
+  }
+  for (const key in opts) {
+    if (['bubbles', 'cancelable'].includes(key)) {
+      continue
+    }
+    e[key] = opts[key]
+  }
+  return e
+}

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

@@ -0,0 +1,107 @@
+import type { TaroAny, TaroElement } from '@tarojs/runtime'
+
+class FlexManager {
+  static flexOptions (node: TaroElement): FlexOptions {
+    const hmStyle = node.hmStyle
+
+    let flexDirection = hmStyle.direction
+    if (!flexDirection && flexDirection !== 0) {
+      flexDirection = hmStyle.display === 'flex' ? FlexDirection.Row : FlexDirection.Column
+    }
+
+    return {
+      direction: flexDirection,
+      justifyContent: hmStyle.justifyContent,
+      alignItems: hmStyle.alignItems
+    }
+  }
+
+  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

@@ -0,0 +1,99 @@
+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'
+
+export const parseStyles = (styles = ''): Record<string, string> => {
+  const styleObj: Record<string, string> = {}
+  styles
+    .split(';')
+    .filter((style) => style.split(':').length === 2)
+    .map((style) => [
+    style.split(':')[0].trim().replace(new RegExp("/-./g"), c => c.substring(1).toUpperCase()),
+    style.split(':')[1].trim()
+    ])
+    .forEach((style) => {
+      const key = style[0]
+      const value = style[1]
+      styleObj[key] = value
+    })
+  return styleObj
+}
+
+
+export function shouldBindEvent (cb: Func, node: TaroElement, eventNames: string[], disabled = false) {
+  if (!node || node._attrs?.disabled || disabled) return null
+  if (!node.__listeners) {
+    return null
+  }
+  const listeners = Object.keys(node.__listeners)
+  if (listeners.every(e => !eventNames.includes(e))) return null
+  return cb
+}
+
+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()
+          })
+        })
+      }
+    }
+  })
+}
+
+export { getNormalAttributes, getFontAttributes }