@tarojs/plugin-platform-harmony-ets 4.0.0-beta.12 → 4.0.0-beta.121

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

@@ -1,18 +1,18 @@
 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 { shouldBindEvent, getNodeThresholds } from './utils/helper'
 
-import type { TaroLabelElement, TaroElement, TaroAny, TaroRadioElement, TaroCheckboxElement } from '@tarojs/runtime'
+import type { TaroAny, TaroElement, TaroCheckboxElement, TaroLabelElement, TaroRadioElement } from '@tarojs/runtime'
 
 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,49 +34,71 @@ function handleTargetChange (id: string) {
   }
 }
 
-
 @Component
 export default struct TaroLabel {
-  @ObjectLink node:TaroLabelElement
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroLabelElement, layer?: number) => void = this.customBuilder
+  @ObjectLink node: TaroLabelElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
+
+  aboutToAppear(): void {
+    if (this.node) {
+      this.node._instance = this
+    }
+  }
+
   build() {
-    if (FlexManager.isFlexNode(this.node) && FlexManager.flexOptions(this.node).direction !== FlexDirection.Column) {
+    if (FlexManager.useFlexLayout(this.node)) {
+      Flex(FlexManager.flexOptions(this.node)) {
+        this.createLazyChildren(this.node, 0)
+      }
+      .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.toString() || ''
+
+        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() {
-        createLazyChildren(this.node)
+        this.createLazyChildren(this.node, 0)
       }
-      .attributeModifier(commonStyleModify.setNode(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 || ''
+        const id: string = this.node._attrs.for || firstChild?._attrs.id || firstChild?._nid.toString() || ''
 
         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()))
+      .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))
-      .alignItems(FlexManager.flexOptions(this.node).alignItems as VerticalAlign)
-      .justifyContent(FlexManager.flexOptions(this.node).justifyContent)
     } else {
       Column() {
-        createLazyChildren(this.node)
+        this.createLazyChildren(this.node, 0)
       }
-      .attributeModifier(commonStyleModify.setNode(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 || ''
+        const id: string = this.node._attrs.for || firstChild?._attrs.id || firstChild?._nid.toString() || ''
 
         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()))
+      .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))
-      .alignItems(FlexManager.flexOptions(this.node).alignItems as HorizontalAlign)
-      .justifyContent(FlexManager.flexOptions(this.node).justifyContent)
     }
   }
 }

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

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

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

@@ -1,67 +1,126 @@
-import type { TaroMovableAreaElement, TaroStyleType } from '@tarojs/runtime'
-import commonStyleModify from './style'
-import { createLazyChildren } from './render'
+import { isTaroMovableViewElement } from '@tarojs/runtime'
+import commonStyleModify, { rowModify, columnModify } from './style'
 
 import { FlexManager } from './utils/flexManager'
-import { getNormalAttributes } from './utils/helper'
 
-
-@Extend(Row)
-function rowAttrs(style: TaroStyleType) {
-  .constraintSize({
-    minWidth: style.minWidth || style.width,
-    maxWidth: style.maxWidth,
-    minHeight: style.minHeight,
-    maxHeight: style.maxHeight
-  })
-}
-
-@Extend(Column)
-function columnAttrs(style: TaroStyleType) {
-  .constraintSize({
-    minWidth: style.minWidth,
-    maxWidth: style.maxWidth,
-    minHeight: style.minHeight || style.height,
-    maxHeight: style.maxHeight
-  })
-}
+import type { TaroAny, TaroMovableAreaElement } from '@tarojs/runtime'
 
 @Component
 export default struct TaroMovableArea {
+  @Builder
+  customBuilder() {
+  }
+
+  @BuilderParam createLazyChildren: (node: TaroMovableAreaElement, layer?: number) => void = this.customBuilder
   @ObjectLink node: TaroMovableAreaElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
+
+  aboutToAppear(): void {
+    if (this.node) {
+      this.node._instance = this
+    }
+  }
+
+
+
 
-  @Provide areaWidth: Length = 0
-  @Provide areaHeight: Length = 0
 
   build() {
-    if (this.node) {
-      if (FlexManager.isFlexNode(this.node) && FlexManager.flexOptions(this.node).direction !== FlexDirection.Column) {
-        Row() {
-          createLazyChildren(this.node)
-        }
-        .attributeModifier(commonStyleModify.setNode(this.node))
-        .rowAttrs(getNormalAttributes(this.node))
-        .alignItems(FlexManager.flexOptions(this.node).alignItems as VerticalAlign)
-        .justifyContent(FlexManager.flexOptions(this.node).justifyContent)
-        .clip(true)
-        .onAreaChange((oldValue: Area, newValue: Area) => {
-          this.areaWidth = newValue.width
-          this.areaHeight = newValue.height
+    if (FlexManager.useFlexLayout(this.node)) {
+      Flex(FlexManager.flexOptions(this.node)) {
+        this.createLazyChildren(this.node, 0)
+      }
+      .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 {
-        Column() {
-          createLazyChildren(this.node)
-        }
-        .attributeModifier(commonStyleModify.setNode(this.node))
-        .columnAttrs(getNormalAttributes(this.node))
-        .alignItems(FlexManager.flexOptions(this.node).alignItems as HorizontalAlign)
-        .justifyContent(FlexManager.flexOptions(this.node).justifyContent)
-        .clip(true)
-        .onAreaChange((oldValue: Area, newValue: Area) => {
-          this.areaWidth = newValue.width
-          this.areaHeight = newValue.height
+      )
+    } else if (FlexManager.isFlexNode(this.node) && FlexManager.direction(this.node) !== FlexDirection.Column) {
+      Row() {
+        this.createLazyChildren(this.node, 0)
+      }
+      .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, 0)
       }
+      .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

@@ -1,66 +1,93 @@
-import type { TaroMovableViewElement, TaroStyleType } from '@tarojs/runtime'
+import type { TaroAny, TaroMovableViewElement, TaroElement } from '@tarojs/runtime'
 
-import commonStyleModify from './style'
-import { createLazyChildren } from './render'
+import commonStyleModify, { rowModify, columnModify } from './style'
 
 import { FlexManager } from './utils/flexManager'
-import { getNormalAttributes, } from './utils/helper'
-@Extend(Row)
-function rowAttrs(style: TaroStyleType) {
-  .constraintSize({
-    minWidth: style.minWidth || style.width,
-    maxWidth: style.maxWidth,
-    minHeight: style.minHeight,
-    maxHeight: style.maxHeight
-  })
-}
 
-@Extend(Column)
-function columnAttrs(style: TaroStyleType) {
-  .constraintSize({
-    minWidth: style.minWidth,
-    maxWidth: style.maxWidth,
-    minHeight: style.minHeight || style.height,
-    maxHeight: style.maxHeight
-  })
-}
+
 
 @Component
-export default struct TaroMovableArea {
+export default struct TaroMovableView {
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroMovableViewElement, layer?: number) => void = this.customBuilder
   @ObjectLink node: TaroMovableViewElement
+  @State overwriteStyle: Record<string, TaroAny> = {}
 
-  @Provide areaWidth: Length = 0
-  @Provide areaHeight: Length = 0
+  aboutToAppear(): void {
+    if (this.node) {
+      this.node._instance = this
+
+    }
+  }
 
   build() {
-    if (this.node) {
-      if (FlexManager.isFlexNode(this.node) && FlexManager.flexOptions(this.node).direction !== FlexDirection.Column) {
+    Stack() {
+      if (FlexManager.useFlexLayout(this.node)) {
+        Flex(FlexManager.flexOptions(this.node)) {
+          this.createLazyChildren(this.node, 0)
+        }
+        .attributeModifier(commonStyleModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
+      } else if (FlexManager.isFlexNode(this.node) && FlexManager.direction(this.node) !== FlexDirection.Column) {
         Row() {
-          createLazyChildren(this.node)
+          this.createLazyChildren(this.node, 0)
         }
-        .attributeModifier(commonStyleModify.setNode(this.node))
-        .rowAttrs(getNormalAttributes(this.node))
-        .alignItems(FlexManager.flexOptions(this.node).alignItems as VerticalAlign)
-        .justifyContent(FlexManager.flexOptions(this.node).justifyContent)
-        .clip(true)
-        .onAreaChange((oldValue: Area, newValue: Area) => {
-          this.areaWidth = newValue.width
-          this.areaHeight = newValue.height
-        })
+        .attributeModifier(rowModify.setNode(this.node).setAnimationStyle(this.overwriteStyle))
       } else {
         Column() {
-          createLazyChildren(this.node)
+          this.createLazyChildren(this.node, 0)
         }
-        .attributeModifier(commonStyleModify.setNode(this.node))
-        .columnAttrs(getNormalAttributes(this.node))
-        .alignItems(FlexManager.flexOptions(this.node).alignItems as HorizontalAlign)
-        .justifyContent(FlexManager.flexOptions(this.node).justifyContent)
-        .clip(true)
-        .onAreaChange((oldValue: Area, newValue: Area) => {
-          this.areaWidth = newValue.width
-          this.areaHeight = newValue.height
-        })
+        .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
+  })
+}

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

@@ -0,0 +1,65 @@
+import { eventCenter } from '@tarojs/runtime'
+
+import { isTagFirstChild } from './utils/helper'
+
+import type { TaroAny, TaroNavigationBarElement } from '@tarojs/runtime'
+import type { IComponentAttributeUpdateEvents } from './pageMeta'
+
+@Component
+export default struct TaroNavigationBar {
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroNavigationBarElement, layer?: number) => void = this.customBuilder
+  @ObjectLink node: TaroNavigationBarElement
+
+  aboutToAppear(): void {
+    if (!isTagFirstChild(this.node, 'page-meta')) {
+      console.error('NavigationBar 只能是 PageMeta 内的第一个节点。')
+    }
+    if (this.node) {
+      this.node._instance = this
+    }
+
+    // FIXME 在 Harmony 提供 @Watch 文档后，根据 node 实际使用更细粒度的监听
+    eventCenter?.on('__taroComponentAttributeUpdate', this.handleAttributeUpdate)
+    this.handleAttributes(this.node._attrs)
+  }
+
+  aboutToDisappear(): void {
+    eventCenter?.off('__taroComponentAttributeUpdate', this.handleAttributeUpdate)
+  }
+
+  handleAttributeUpdate = (opt: IComponentAttributeUpdateEvents) => {
+    if (opt.id === this.node._nid.toString() && opt.tagName === 'NAVIGATION-BAR') {
+      const attrs: Record<string, TaroAny> = {}
+      attrs[opt.attribute] = opt.value
+      this.handleAttributes(attrs)
+    }
+  }
+
+  handleAttributes (attrs: Record<string, TaroAny>) {
+    const options: Record<string, TaroAny> = {}
+
+    if (attrs.title) {
+      options.title = attrs.title
+    }
+    if (attrs.loading) {
+      options.loading = attrs.loading
+    }
+    if (attrs.backgroundColor) {
+      options.backgroundColor = attrs.backgroundColor
+    }
+    if (attrs.frontColor) {
+      options.frontColor = attrs.frontColor
+    }
+    eventCenter?.trigger('__taroNavigationStyle', options)
+    // FIXME: 以下属性暂时不支持
+    // attrs.colorAnimationDuration
+    // attrs.colorAnimationTimingFunc
+  }
+
+  build() {
+    if (true) {
+      this.createLazyChildren(this.node, 0)
+    }
+  }
+}

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

@@ -0,0 +1,94 @@
+import { APP, eventCenter } from '@tarojs/runtime'
+import { getCurrentInstance, pageScrollTo } from '@tarojs/taro'
+
+import { isTagFirstChild } from './utils/helper'
+
+import type { TaroAny, TaroPageMetaElement } from '@tarojs/runtime'
+
+export interface IComponentAttributeUpdateEvents {
+  id: string
+  tagName: string
+  attribute: string
+  value: TaroAny
+}
+
+@Component
+export default struct TaroPageMeta {
+  @Builder customBuilder() {}
+  @BuilderParam createLazyChildren: (node: TaroPageMetaElement, layer?: number) => void = this.customBuilder
+  @ObjectLink node: TaroPageMetaElement
+
+  page: TaroAny = {}
+
+  aboutToAppear(): void {
+    if (!isTagFirstChild(this.node, APP, 2)) {
+      // PageMeta 只能是页面内的第一个元素
+      console.error('PageMeta 只能是页面内的第一个元素。')
+    }
+
+    this.page = getCurrentInstance().page
+    if (this.node) {
+      this.node._instance = this
+    }
+
+    // FIXME 在 Harmony 提供 @Watch 文档后，根据 node 实际使用更细粒度的监听
+    eventCenter?.on('__taroComponentAttributeUpdate', this.handleAttributeUpdate)
+    this.handleAttributes(this.node._attrs)
+  }
+
+  aboutToDisappear(): void {
+    eventCenter?.off('__taroComponentAttributeUpdate', this.handleAttributeUpdate)
+  }
+
+  handleAttributeUpdate = (opt: IComponentAttributeUpdateEvents) => {
+    if (opt.id === this.node._nid.toString() && opt.tagName === 'PAGE-META') {
+      const attrs: Record<string, TaroAny> = {}
+      attrs[opt.attribute] = opt.value
+      this.handleAttributes(attrs)
+    }
+  }
+
+  handleAttributes (attrs: Record<string, TaroAny>) {
+    const options: Record<string, TaroAny> = {}
+    let triggerStyleEvent = false
+
+    // FIXME 更新类型支持度
+    if (attrs.backgroundColorTop || attrs.rootBackgroundColor || attrs.backgroundColor) {
+      options.backgroundColorContext = attrs.backgroundColorTop || attrs.rootBackgroundColor || attrs.backgroundColor
+      triggerStyleEvent = true
+    }
+    if (attrs.backgroundColorBottom || attrs.backgroundColor) {
+      options.backgroundColor = attrs.backgroundColorBottom || attrs.backgroundColor
+      triggerStyleEvent = true
+    }
+    if (attrs.backgroundTextStyle) {
+      options.backgroundTextStyle = attrs.backgroundTextStyle
+      triggerStyleEvent = true
+    }
+
+    if (this.page === getCurrentInstance().page) {
+      if (attrs.scrollTop || attrs.scrollDuration) {
+        pageScrollTo({
+          scrollTop: attrs.scrollTop || this.node._attrs.scrollTop,
+          duration: attrs.scrollDuration || this.node._attrs.scrollDuration,
+        } as TaroAny)
+      }
+    }
+    // pageStyle
+    // rootFontSize
+    // pageFontSize
+    // pageOrientation
+    if (triggerStyleEvent) {
+      eventCenter?.trigger('__taroPageStyle', options)
+    }
+    // onResize
+    // onScroll
+    // onScrollDone
+  }
+
+  build() {
+    if (true) {
+      this.createLazyChildren(this.node, 0)
+    }
+  }
+}