@tarojs/plugin-platform-harmony-ets 4.0.0-alpha.2 → 4.0.0-alpha.21

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

@@ -0,0 +1,92 @@
+import TaroImage, { getImageMode } from './image'
+import TaroText from './text'
+import TaroView from './view'
+import TaroIcon from './icon'
+import TaroForm from './form'
+import TaroLabel from './label'
+import TaroInput from './input'
+import TaroVideo from './video'
+import TaroCanvas from './canvas'
+import TaroButton from './button'
+import TaroPicker from './picker'
+import TaroSlider from './slider'
+import TaroSwitch from './switch'
+import TaroSwiper from './swiper'
+import TaroWebView from './webView'
+import TaroTextArea from './textArea'
+import TaroRichText from './richText'
+import TaroProgress from './progress'
+import TaroInnerHtml from './innerHtml'
+import TaroScrollView from './scrollView'
+import TaroMovableArea from './movableArea'
+import TaroMovableView from './movableView'
+import { TaroRadio, TaroRadioGroup } from './radio'
+import { TaroCheckboxGroup, TaroCheckbox } from './checkbox'
+import TaroPageMeta from './pageMeta'
+import TaroNavigationBar from './navigationBar'
+
+import TaroListView from './listView'
+import TaroStickySection from './stickySection'
+import TaroScrollList from './scrollList'
+
+import commonStyleModify, { rowModify, columnModify, textModify, setNormalTextAttributeIntoInstance } from './style'
+import { getButtonColor } from './button'
+import { FlexManager } from './utils/flexManager'
+import { DynamicCenter } from './utils/DynamicCenter'
+import { TOUCH_EVENT_MAP } from './utils/constant/event'
+import { BUTTON_THEME_COLOR } from './utils/constant/style'
+import { getStyleAttr } from './utils/styles'
+import { shouldBindEvent, getNodeThresholds, getNormalAttributes, getFontAttributes } from './utils/helper'
+
+export {
+  textModify,
+  getStyleAttr,
+  FlexManager,
+  DynamicCenter,
+  getButtonColor,
+  TOUCH_EVENT_MAP,
+  shouldBindEvent,
+  getFontAttributes,
+  commonStyleModify,
+  rowModify,
+  columnModify,
+  getNodeThresholds,
+  BUTTON_THEME_COLOR,
+  getNormalAttributes,
+  setNormalTextAttributeIntoInstance,
+  getImageMode,
+}
+
+export {
+  TaroImage,
+  TaroCanvas,
+  TaroText,
+  TaroView,
+  TaroIcon,
+  TaroForm,
+  TaroLabel,
+  TaroInput,
+  TaroVideo,
+  TaroButton,
+  TaroPicker,
+  TaroSlider,
+  TaroSwitch,
+  TaroSwiper,
+  TaroWebView,
+  TaroTextArea,
+  TaroRichText,
+  TaroProgress,
+  TaroInnerHtml,
+  TaroScrollView,
+  TaroMovableArea,
+  TaroMovableView,
+  TaroRadio,
+  TaroRadioGroup,
+  TaroCheckboxGroup,
+  TaroCheckbox,
+  TaroPageMeta,
+  TaroNavigationBar,
+  TaroListView,
+  TaroStickySection,
+  TaroScrollList
+}

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

@@ -1,11 +1,16 @@
 import htmlParser from './utils/htmlParser'
-import { createChildItem } from './render'
 
-import type { TaroElement } from '@tarojs/runtime'
+import type { TaroElement, TaroInnerHtmlElement } from '@tarojs/runtime'
 
-@Builder
-export default function TaroInnerHtml (node: TaroElement) {
-  if (node.innerHTML) {
-    createChildItem(htmlParser(node.innerHTML))
+@Component
+export default struct TaroInnerHtml {
+  @Builder customBuilder() {}
+  @BuilderParam createChildItem: (node: TaroElement, callback?: (node: TaroElement) => void) => void = this.customBuilder
+  @ObjectLink node: TaroInnerHtmlElement
+
+  build() {
+    if (this.node?.hmStyle?.display !== 'none' && this.node.innerHTML) {
+      this.createChildItem(htmlParser(this.node.innerHTML))
+    }
   }
 }

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

@@ -1,13 +1,15 @@
 import { eventHandler, getComponentEventCallback, AREA_CHANGE_EVENT_NAME, VISIBLE_CHANGE_EVENT_NAME, createTaroEvent } from '@tarojs/runtime'
 
 import commonStyleModify from './style'
-import { getNormalAttributes, parseStyles, shouldBindEvent, getNodeThresholds } from './utils/helper'
+import { parseStyles, shouldBindEvent, getNodeThresholds, getStyleAttr } from './utils/helper'
 import { INPUT_TYPE_MAP, INPUT_CONFIRM_MAP } from './utils/constant/style'
 
 import type { TaroStyleType, TaroAny, TaroInputElement, TaroEvent } from '@tarojs/runtime'
 
 interface InputAttrs {
   textAlign?: TextAlign
+  autoFocus?: boolean
+  disabled?: boolean
 }
 
 @Extend(TextInput)
@@ -22,12 +24,15 @@ function styles (style: TaroStyleType) {
 @Extend(TextInput)
 function attrs(attr: InputAttrs) {
   .textAlign(attr.textAlign)
+  .defaultFocus(attr.autoFocus)
+  .enabled(!attr.disabled)
 }
 
-
 function getAttributes(node: TaroInputElement): InputAttrs {
   return {
     textAlign: node.hmStyle.textAlign,
+    autoFocus: node._attrs.autoFocus || node._attrs.focus || false,
+    disabled: node._attrs.disabled || false,
   }
 }
 
@@ -48,7 +53,10 @@ function getPlaceholderColor (node: TaroInputElement): string {
 export default struct TaroInput {
   @State value: string = ''
 
-  node: TaroInputElement | null = null
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroInputElement) => void = this.customBuilder
+  @ObjectLink node: TaroInputElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
 
   aboutToAppear () {
     if (this.node) {
@@ -63,43 +71,43 @@ export default struct TaroInput {
   }
 
   build () {
-    if (this.node) {
-      TextInput({ text: this.value, placeholder: this.node._attrs?.placeholder || '', controller: this.node.controller })
-      .key(this.node._nid)
-      .type(getInputType(this.node))
-      .maxLength(Number(this.node._attrs?.maxlength) || null)
-      .placeholderColor(getPlaceholderColor(this.node))
-      .enterKeyType(INPUT_CONFIRM_MAP.get(this.node._attrs?.confirmType) || EnterKeyType.Done)
-      .attributeModifier(commonStyleModify.setNode(this.node))
-      .styles(getNormalAttributes(this.node))
-      .attrs(getAttributes(this.node))
-      .onChange((value: string) => {
-        const event: TaroEvent = createTaroEvent('input', { detail: { value } }, this.node)
-        
-        this.value = value
-        this.node?.updateFormWidgetValue(value)
-        eventHandler(event, 'input', this.node)
-      })
-      .onSubmit(() => {
-        const event: TaroEvent = createTaroEvent('confirm', { detail: { value: this.value } }, this.node)
-        eventHandler(event, 'confirm', this.node)
-      })
-      .onClick(shouldBindEvent((e: ClickEvent) => eventHandler(e, 'click', this.node), this.node, ['click']))
-      .onBlur(() => {
-        const event: TaroEvent = createTaroEvent('blur', { detail: { value: this.value } }, this.node)
-        eventHandler(event, 'blur', this.node)
-      })
-      .onFocus(() => {
-        const event: TaroEvent = createTaroEvent('focus', { detail: { value: this.value, height: this.node?._height } }, this.node)
-  
-        eventHandler(event, 'focus', this.node)
-      })
-      .onAreaChange(getComponentEventCallback(this.node, AREA_CHANGE_EVENT_NAME, (res: TaroAny) => {
-        if (this.node) {
-          this.node._nodeInfo.areaInfo = res[1]
-        }
-      }))
-      .onVisibleAreaChange(getNodeThresholds(this.node) || [0.0, 1.0], getComponentEventCallback(this.node, VISIBLE_CHANGE_EVENT_NAME))
-    }
+    TextInput({ text: this.value, placeholder: this.node._attrs?.placeholder || '', controller: this.node.controller })
+    .key(this.node._nid)
+    .type(getInputType(this.node))
+    .maxLength(Number(this.node._attrs?.maxlength) || null)
+    .placeholderColor(getPlaceholderColor(this.node))
+    .enterKeyType(INPUT_CONFIRM_MAP.get(this.node._attrs?.confirmType) || EnterKeyType.Done)
+    .padding(0) // Note: 移出 Input 默认 padding 设置
+    .backgroundColor(getStyleAttr(this.node, "backgroundColor"))// 
+    .attributeModifier(commonStyleModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+    .styles(this.node?.hmStyle)
+    .attrs(getAttributes(this.node))
+    .onChange((value: string) => {
+      const event: TaroEvent = createTaroEvent('input', { detail: { value } }, this.node)
+
+      this.value = value
+      this.node?.updateFormWidgetValue(value)
+      eventHandler(event, 'input', this.node)
+    })
+    .onSubmit(() => {
+      const event: TaroEvent = createTaroEvent('confirm', { detail: { value: this.value } }, this.node)
+      eventHandler(event, 'confirm', this.node)
+    })
+    .onClick(shouldBindEvent((e: ClickEvent) => eventHandler(e, 'click', this.node), this.node, ['click']))
+    .onBlur(() => {
+      const event: TaroEvent = createTaroEvent('blur', { detail: { value: this.value } }, this.node)
+      eventHandler(event, 'blur', this.node)
+    })
+    .onFocus(() => {
+      const event: TaroEvent = createTaroEvent('focus', { detail: { value: this.value, height: this.node?._height } }, this.node)
+
+      eventHandler(event, 'focus', this.node)
+    })
+    .onAreaChange(getComponentEventCallback(this.node, AREA_CHANGE_EVENT_NAME, (res: TaroAny) => {
+      if (this.node) {
+        this.node._nodeInfo.areaInfo = res[1]
+      }
+    }))
+    .onVisibleAreaChange(getNodeThresholds(this.node) || [0.0, 1.0], getComponentEventCallback(this.node, VISIBLE_CHANGE_EVENT_NAME))
   }
 }

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

@@ -1,18 +1,19 @@
 import { Current, eventHandler, getComponentEventCallback, VISIBLE_CHANGE_EVENT_NAME, getPageScrollerOrNode, AREA_CHANGE_EVENT_NAME } from '@tarojs/runtime'
 
-import commonStyleModify from './style'
-import { createLazyChildren } from './render'
+import commonStyleModify, { rowModify, columnModify } from './style'
+
 import { TOUCH_EVENT_MAP } from './utils/constant/event'
-import { FlexManager } from './utils/FlexManager'
-import { getNormalAttributes, shouldBindEvent, getNodeThresholds } from './utils/helper'
+import { FlexManager } from './utils/flexManager'
+import { shouldBindEvent, getNodeThresholds } from './utils/helper'
 
 import type { TaroLabelElement, TaroElement, TaroAny, TaroRadioElement, TaroCheckboxElement } from '@tarojs/runtime'
+import { isUndefined } from '@tarojs/shared'
 
 function handleTargetChange (id: string) {
   const taro: TaroAny = Current.taro
   const page: TaroAny = taro.getCurrentInstance().page
-  const currentPageNode: TaroElement = getPageScrollerOrNode(page.node, page)
-  const node: TaroElement | null = currentPageNode.getElementById(id)
+  const currentPageNode: TaroElement = getPageScrollerOrNode(page?.node, page)
+  const node: TaroElement | null = currentPageNode?.getElementById(id)
 
   if (!node) return
 
@@ -34,45 +35,71 @@ function handleTargetChange (id: string) {
   }
 }
 
-@Builder
-export default function TaroLabel (node: TaroLabelElement) {
-  if (FlexManager.isFlexNode(node) && FlexManager.flexOptions(node).direction !== FlexDirection.Column) {
-    Row() {
-      createLazyChildren(node)
+@Component
+export default struct TaroLabel {
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroLabelElement) => void = this.customBuilder
+  @ObjectLink node: TaroLabelElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
+
+  aboutToAppear(): void {
+    if (this.node) {
+      this.node._instance = this
     }
-    .attributeModifier(commonStyleModify.setNode(node))
-    .onClick((e: ClickEvent) => {
-      const firstChild: TaroElement | null = node.childNodes[0] as TaroElement | null
-      const id: string = node._attrs.for || firstChild?._attrs.id || firstChild?._nid || ''
-  
-      handleTargetChange(id)
-      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))
-    .alignItems(FlexManager.flexOptions(node).alignItems as VerticalAlign)
-    .justifyContent(FlexManager.flexOptions(node).justifyContent)
-  } else {
-    Column() {
-      createLazyChildren(node)
+  }
+
+  build() {
+    if (FlexManager.useFlexLayout(this.node)) {
+      Flex(FlexManager.flexOptions(this.node)) {
+        this.createLazyChildren(this.node)
+      }
+      .attributeModifier(commonStyleModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      .onClick((e: ClickEvent) => {
+        const firstChild: TaroElement | null = this.node.childNodes[0] as TaroElement | null
+        const id: string = this.node._attrs.for || firstChild?._attrs.id || firstChild?._nid || ''
+
+        handleTargetChange(id)
+        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: TaroAny) => {
+        this.node._nodeInfo.areaInfo = res[1]
+      }))
+      .onVisibleAreaChange(getNodeThresholds(this.node) || [0.0, 1.0], getComponentEventCallback(this.node, VISIBLE_CHANGE_EVENT_NAME))
+    } else if (FlexManager.isFlexNode(this.node) && FlexManager.direction(this.node) !== FlexDirection.Column) {
+      Row() {
+        this.createLazyChildren(this.node)
+      }
+      .attributeModifier(rowModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      .onClick((e: ClickEvent) => {
+        const firstChild: TaroElement | null = this.node.childNodes[0] as TaroElement | null
+        const id: string = this.node._attrs.for || firstChild?._attrs.id || firstChild?._nid || ''
+
+        handleTargetChange(id)
+        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: TaroAny) => {
+        this.node._nodeInfo.areaInfo = res[1]
+      }))
+      .onVisibleAreaChange(getNodeThresholds(this.node) || [0.0, 1.0], getComponentEventCallback(this.node, VISIBLE_CHANGE_EVENT_NAME))
+    } else {
+      Column() {
+        this.createLazyChildren(this.node)
+      }
+      .attributeModifier(columnModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      .onClick((e: ClickEvent) => {
+        const firstChild: TaroElement | null = this.node.childNodes[0] as TaroElement | null
+        const id: string = this.node._attrs.for || firstChild?._attrs.id || firstChild?._nid || ''
+
+        handleTargetChange(id)
+        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: TaroAny) => {
+        this.node._nodeInfo.areaInfo = res[1]
+      }))
+      .onVisibleAreaChange(getNodeThresholds(this.node) || [0.0, 1.0], getComponentEventCallback(this.node, VISIBLE_CHANGE_EVENT_NAME))
     }
-    .attributeModifier(commonStyleModify.setNode(node))
-    .onClick((e: ClickEvent) => {
-      const firstChild: TaroElement | null = node.childNodes[0] as TaroElement | null
-      const id: string = node._attrs.for || firstChild?._attrs.id || firstChild?._nid || ''
-  
-      handleTargetChange(id)
-      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))
-    .alignItems(FlexManager.flexOptions(node).alignItems as HorizontalAlign)
-    .justifyContent(FlexManager.flexOptions(node).justifyContent)
   }
 }

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

@@ -0,0 +1,26 @@
+import commonStyleModify from './style'
+
+import type { TaroViewElement, TaroAny } from '@tarojs/runtime'
+
+@Component
+export default struct TaroListView {
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroViewElement) => void = this.customBuilder
+  @ObjectLink node: TaroViewElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
+
+  aboutToAppear(): void {
+    if (this.node) {
+      this.node._instance = this
+    }
+  }
+
+  build() {
+    ListItem() {
+      Stack() {
+        this.createLazyChildren(this.node)
+      }
+    }
+    .attributeModifier(commonStyleModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+  }
+}

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

@@ -0,0 +1,126 @@
+import type { TaroAny, TaroMovableAreaElement, TaroMovableViewElement } from '@tarojs/runtime'
+import { isTaroMovableViewElement } from '@tarojs/runtime'
+import commonStyleModify, { rowModify, columnModify } from './style'
+
+import { FlexManager } from './utils/flexManager'
+import { isUndefined } from '@tarojs/shared'
+
+@Component
+export default struct TaroMovableArea {
+  @Builder
+  customBuilder() {
+  }
+
+  @BuilderParam createLazyChildren: (node: TaroMovableAreaElement) => void = this.customBuilder
+  @ObjectLink node: TaroMovableAreaElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
+
+  aboutToAppear(): void {
+    if (this.node) {
+      this.node._instance = this
+    }
+  }
+
+
+
+
+
+  build() {
+    if (FlexManager.useFlexLayout(this.node)) {
+      Flex(FlexManager.flexOptions(this.node)) {
+        this.createLazyChildren(this.node)
+      }
+      .attributeModifier(commonStyleModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      .clip(true)
+      .onSizeChange((oldValue: SizeOptions, newValue: SizeOptions) => {
+        sizeChangeHandle(this.node, newValue)
+      })
+      .gesture(
+        PinchGesture({ fingers: 2 }).onActionStart((event: GestureEvent) => {
+          this.node.childNodes.forEach(item => {
+            if (isTaroMovableViewElement(item)) {
+              item.startScale()
+            }
+          })
+        }).onActionUpdate((event) => {
+          const scaleArea = this.node.getAttribute('scaleArea')
+          if (scaleArea) {
+            this.node.childNodes.forEach(item => {
+              if (isTaroMovableViewElement(item)) {
+                item.doScale(event.scale)
+              }
+            })
+          }
+        })
+      )
+    } else if (FlexManager.isFlexNode(this.node) && FlexManager.direction(this.node) !== FlexDirection.Column) {
+      Row() {
+        this.createLazyChildren(this.node)
+      }
+      .attributeModifier(rowModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      .clip(true)
+      .onSizeChange((oldValue: SizeOptions, newValue: SizeOptions) => {
+        sizeChangeHandle(this.node, newValue)
+      })
+      .gesture(
+        PinchGesture({ fingers: 2 }).onActionStart((event: GestureEvent) => {
+          this.node.childNodes.forEach(item => {
+            if (isTaroMovableViewElement(item)) {
+              item.startScale()
+            }
+          })
+        }).onActionUpdate((event) => {
+          const scaleArea = this.node.getAttribute('scaleArea')
+          if (scaleArea) {
+            this.node.childNodes.forEach(item => {
+              if (isTaroMovableViewElement(item)) {
+                item.doScale(event.scale)
+              }
+            })
+          }
+        })
+      )
+    } else {
+      Column() {
+        this.createLazyChildren(this.node)
+      }
+      .attributeModifier(columnModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      .clip(true)
+      .onSizeChange((oldValue: SizeOptions, newValue: SizeOptions) => {
+        sizeChangeHandle(this.node, newValue)
+      })
+      .gesture(
+        PinchGesture({ fingers: 2 }).onActionStart((event: GestureEvent) => {
+          this.node.childNodes.forEach(item => {
+            if (isTaroMovableViewElement(item)) {
+              item.startScale()
+            }
+          })
+        }).onActionUpdate((event) => {
+          const scaleArea = this.node.getAttribute('scaleArea')
+          if (scaleArea) {
+            this.node.childNodes.forEach(item => {
+              if (isTaroMovableViewElement(item)) {
+                item.doScale(event.scale)
+              }
+            })
+          }
+        })
+      )
+    }
+  }
+}
+
+
+function sizeChangeHandle(node: TaroMovableAreaElement, newValue: Area | SizeOptions) {
+  node.childNodes.forEach(item => {
+    if (isTaroMovableViewElement(item)) {
+      if (item.area?.w !== Number(newValue.width) || item.area?.h !== Number(newValue.height)) {
+        item.area = {
+          w: Number(newValue.width),
+          h: Number(newValue.height)
+        }
+      }
+    }
+  })
+}

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

@@ -0,0 +1,93 @@
+import type { TaroAny, TaroMovableViewElement, TaroElement } from '@tarojs/runtime'
+
+import commonStyleModify, { rowModify, columnModify } from './style'
+
+import { FlexManager } from './utils/flexManager'
+
+
+
+@Component
+export default struct TaroMovableView {
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroMovableViewElement) => void = this.customBuilder
+  @ObjectLink node: TaroMovableViewElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
+
+  aboutToAppear(): void {
+    if (this.node) {
+      this.node._instance = this
+
+    }
+  }
+
+  build() {
+    Stack() {
+      if (FlexManager.useFlexLayout(this.node)) {
+        Flex(FlexManager.flexOptions(this.node)) {
+          this.createLazyChildren(this.node)
+        }
+        .attributeModifier(commonStyleModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      } else if (FlexManager.isFlexNode(this.node) && FlexManager.direction(this.node) !== FlexDirection.Column) {
+        Row() {
+          this.createLazyChildren(this.node)
+        }
+        .attributeModifier(rowModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      } else {
+        Column() {
+          this.createLazyChildren(this.node)
+        }
+        .attributeModifier(columnModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      }
+    }
+    .translate({ x: this.node.position.x, y: this.node.position.y })
+    .scale({ x: this.node.scaleValue, y: this.node.scaleValue })
+    .onSizeChange((oldValue: SizeOptions, newValue: SizeOptions) => {
+      if (this.node.selfSize?.w !== Number(newValue.width) || this.node.selfSize?.h !== Number(newValue.height)) {
+        this.node.selfSize = { w: Number(newValue.width), h: Number(newValue.height) }
+      }
+    })
+    .visibility(this.node.visibility)
+    .gesture(
+      GestureGroup(GestureMode.Parallel,
+        PanGesture(getPanOption(this.node)).onActionStart((e: GestureEvent) => {
+
+          this.node.startMove()
+          this.node.callTouchEventFnFromGesture('touchstart', e)
+        }).onActionUpdate((e: GestureEvent) => {
+          this.node.callTouchEventFnFromGesture('touchmove', e)
+          this.node.doMove({
+            x: e.offsetX,
+            y: e.offsetY
+          })
+
+        }).onActionEnd((e: GestureEvent) => {
+          this.node.callTouchEventFnFromGesture('touchend', e)
+          this.node.checkPositionBoundary(this.node.position, this.node.scaleValue)
+        }),
+        PinchGesture({ fingers: 2 }).onActionStart((event: GestureEvent) => {
+          this.node.startScale()
+        }).onActionUpdate((event) => {
+          this.node.doScale(event.scale)
+        })
+      )
+    )
+  }
+}
+
+
+function getPanOption(node: TaroMovableViewElement) {
+  const attrDirection = node.getAttribute('direction')
+  let panDirection = PanDirection.All
+
+  if(node.getAttribute('disabled')) {
+    panDirection = PanDirection.None
+  } else if(attrDirection === 'horizontal') {
+    panDirection = PanDirection.Horizontal
+  } else if (attrDirection === 'vertical') {
+    panDirection = PanDirection.Vertical
+  }
+  return new PanGestureOptions({
+    direction: panDirection,
+    fingers: 1
+  })
+}