@tarojs/plugin-platform-harmony-cpp 4.1.0 → 4.1.1-alpha.0

package/dist/runtime/runtime-cpp/dom/element/movable.ts

@@ -0,0 +1,250 @@
+import { TaroElement } from './element'
+
+import type { MovableAreaProps, MovableViewProps } from '@tarojs/components/types'
+import type { TaroAny, TFunc } from '../../interface'
+
+type Tsize = {
+  w: number
+  h: number
+}
+type Tpoint = {
+  x: number
+  y: number
+}
+
+function calcPosition(postion: number, start: number, end: number) {
+  if (postion <= end && postion >= start) {
+    return postion
+  } else if (postion < start) {
+    return start
+  } else {
+    return end
+  }
+}
+
+export function isTaroMovableViewElement (item: TaroAny): item is TaroMovableViewElement {
+  return item instanceof TaroMovableViewElement
+}
+
+export class TaroMovableViewElement extends TaroElement<MovableViewProps & { animation: undefined }> {
+  _scaleValue = 1
+  _scalevalueTemp = 1
+
+  // 父级区别的大小
+  _area?: Tsize
+  // 自己元素的大小
+  _selfSize?: Tsize
+  _areaInited: boolean
+  _selfSizeInited: boolean
+
+  // 元素的位置
+  _position: Tpoint = {
+    x: 0,
+    y: 0,
+  }
+
+  _positionTemp: Tpoint = {
+    x: 0,
+    y: 0,
+  }
+
+  constructor() {
+    super('MovableView')
+  }
+
+  get _outOfBounds() {
+    if (this.getAttribute('outOfBounds')) {
+      return this.selfSize ? this.selfSize.w / 3 : 0
+    }
+    return 0
+  }
+
+  startScale() {
+    this._scalevalueTemp = this._scaleValue
+  }
+
+  doScale(val: number) {
+    const scale = this.getAttribute('scale')
+
+    // 禁止缩放的时候不生效
+    if (scale) {
+      this.scaleValue = val * this._scalevalueTemp
+    }
+  }
+
+  set scaleValue(val: number) {
+    if (this.checkScaleValueInBounds(val)) {
+      this._scaleValue = val
+
+      this.checkPositionBoundary(this.position, val)
+
+      const scaleFns = this?.__listeners?.scale || []
+      scaleFns.forEach((fn) => {
+        fn({ ...this.position, scale: this.scaleValue })
+      })
+    }
+  }
+
+  get scaleValue () {
+    return this._scaleValue
+  }
+
+  get visibility () {
+    return this._areaInited && this._selfSizeInited ? Visibility.Visible : Visibility.Hidden
+  }
+
+  startMove() {
+    this._positionTemp = this._position
+  }
+
+  doMove(val: Tpoint) {
+    if (!this.area || !this.selfSize) {
+      return
+    }
+    if (this.getAttribute('disabled')) {
+      return
+    }
+    const direction = this.getAttribute('direction')
+
+    // 容器的宽高终点
+    const areaWidthEnd = this.area.w - this.selfSize.w * this.scaleValue
+    const areaHeightEnd = this.area.h - this.selfSize.h * this.scaleValue
+
+    const incrementWidth = (this.scaleValue - 1) * this.selfSize.w
+    const incrementHeight = (this.scaleValue - 1) * this.selfSize.h
+
+    let x = this._positionTemp.x
+    let y = this._positionTemp.y
+    if (['all', 'horizontal'].includes(direction)) {
+      const nextX = this._positionTemp.x + val.x * this.scaleValue
+      x = calcPosition(
+        nextX,
+        incrementWidth * 0.5 - this._outOfBounds,
+        areaWidthEnd + incrementWidth * 0.5 + this._outOfBounds
+      )
+    }
+
+    if (['all', 'vertical'].includes(direction)) {
+      const nextY = this._positionTemp.y + val.y * this.scaleValue
+      y = calcPosition(
+        nextY,
+        incrementHeight * 0.5 - this._outOfBounds,
+        areaHeightEnd + incrementHeight * 0.5 + this._outOfBounds
+      )
+    }
+
+    const changeFns = this?.__listeners?.change || []
+    changeFns.forEach((fn) => {
+      fn({ x, y, source: 'touch' })
+    })
+
+    this.position = {
+      x: x,
+      y: y,
+    }
+  }
+
+  get position() {
+    return this._position
+  }
+
+  set position(val: Tpoint) {
+    this._position = val
+  }
+
+  set area(val: Tsize) {
+    if (val.w === this._area?.w && val.h === this._area?.h) return
+    this._area = val
+    if (!this._areaInited) {
+      this._areaInited = true
+      this.initPositionFromAttribute()
+    }
+  }
+
+  get area(): Tsize | undefined {
+    return this._area
+  }
+
+  set selfSize(val: Tsize) {
+    if (val.w === this._selfSize?.w && val.h === this._selfSize?.h) return
+    this._selfSize = val
+    if (!this._selfSizeInited) {
+      this._selfSizeInited = true
+      this.initPositionFromAttribute()
+    }
+  }
+
+  get selfSize(): Tsize | undefined {
+    return this._selfSize
+  }
+
+  initPositionFromAttribute () {
+    if (!this.area || !this.selfSize) {
+      return
+    }
+    const x = this.getAttribute('x') ? Number(this.getAttribute('x')) : 0
+    const y = this.getAttribute('y') ? Number(this.getAttribute('y')) : 0
+    this.checkPositionBoundary({ x, y }, this.scaleValue)
+  }
+
+  checkPositionBoundary(position: Tpoint, scale: number) {
+    if (!this.area || !this.selfSize) {
+      return { x: 0, y: 0 }
+    }
+
+    const areaWidthEnd = this.area.w - this.selfSize.w * scale
+    const areaHeightEnd = this.area.h - this.selfSize.h * scale
+
+    const incrementWidth = (scale - 1) * this.selfSize.w
+    const incrementHeight = (scale - 1) * this.selfSize.h
+
+    this.position = {
+      x: calcPosition(position.x, incrementWidth * 0.5, areaWidthEnd + incrementWidth * 0.5),
+      y: calcPosition(position.y, incrementHeight * 0.5, areaHeightEnd + incrementHeight * 0.5),
+    }
+  }
+
+  checkScaleValueInBounds(currentScale: number) {
+    const scaleMin = this.getAttribute('scaleMin')
+    const scaleMax = this.getAttribute('scaleMax')
+
+    if (scaleMin && Number(scaleMin) >= 0.1 && currentScale < Number(scaleMin)) {
+      return false
+    } else if (scaleMax && Number(scaleMax) >= 0.1 && currentScale > Number(scaleMax)) {
+      return false
+    }
+
+    return true
+  }
+
+  public setAttribute(name: string, value: any): void {
+    if (name === 'x') {
+      this.checkPositionBoundary({ x: value, y: this.position.y }, this.scaleValue)
+    }
+    if (name === 'y') {
+      this.checkPositionBoundary({ x: this.position.x, y: value }, this.scaleValue)
+    }
+
+    super.setAttribute(name, value)
+  }
+
+  public callTouchEventFnFromGesture(eventName: string, gestureEvent: GestureEvent) {
+    const touchFns = (this?.__listeners?.[eventName] || []) as TFunc[]
+    touchFns.forEach(fn => {
+      fn({
+        _hmEvent: gestureEvent,
+        target: this,
+        changedTouches: gestureEvent.fingerList.map(finger => ({
+          clientX: finger.globalX,
+          clientY: finger.globalY
+        }))
+      })
+    })
+  }
+}
+
+export class TaroMovableAreaElement extends TaroElement<MovableAreaProps> {
+  constructor() {
+    super('MovableArea')
+  }
+}

package/dist/runtime/runtime-cpp/dom/element/normal.ts

@@ -0,0 +1,123 @@
+import { TaroElement } from './element'
+import { TaroScrollViewElement } from './scroll_view'
+
+import type {
+  ButtonProps,
+  IconProps,
+  ImageProps,
+  NavigationBarProps,
+  PageMetaProps,
+  ProgressProps,
+  StandardProps,
+  SwiperItemProps,
+  SwiperProps,
+  ViewProps,
+} from '@tarojs/components/types'
+import type { TaroAny } from '../../interface'
+
+interface FlowSectionProps extends StandardProps {
+  column?: number
+}
+
+@Observed
+export class TaroOtherElement extends TaroElement<ViewProps> {
+  isETS = true
+
+  public setAttribute(name: string, value: TaroAny): void {
+    super.setAttribute(name, value)
+
+    // Note: 使用 @ComponentV2 时，需要在 struct 将参数声明为 @Local 并在此更新
+    if (this._instance) {
+      const attrName = `attr${name.charAt(0).toUpperCase()}${name.slice(1)}`
+      this._instance[attrName] = value
+    }
+  }
+}
+
+export class TaroViewElement extends TaroElement<ViewProps> {
+  constructor() {
+    super('View')
+  }
+}
+
+export class TaroImageElement extends TaroElement<ImageProps> {
+  constructor() {
+    super('Image')
+  }
+}
+
+export class TaroButtonElement extends TaroElement<ButtonProps> {
+  constructor() {
+    super('Button')
+  }
+}
+
+export class TaroIconElement extends TaroElement<IconProps> {
+  constructor() {
+    super('Icon')
+  }
+}
+
+export class TaroSwiperElement extends TaroElement<SwiperProps> {
+  controller: typeof SwiperController = new SwiperController()
+
+  constructor() {
+    super('Swiper')
+  }
+}
+
+export class TaroSwiperItemElement extends TaroElement<SwiperItemProps> {
+  constructor() {
+    super('SwiperItem')
+  }
+}
+
+export class TaroProgressElement extends TaroElement<ProgressProps> {
+  isETS = true
+
+  constructor() {
+    super('Progress')
+  }
+}
+
+@Observed
+export class TaroPageMetaElement extends TaroElement<PageMetaProps> {
+  isETS = true
+
+  constructor() {
+    super('PageMeta')
+  }
+}
+
+@Observed
+export class TaroNavigationBarElement extends TaroElement<NavigationBarProps> {
+  isETS = true
+
+  constructor() {
+    super('NavigationBar')
+  }
+}
+
+export class TaroWaterFlowElement extends TaroScrollViewElement {
+  constructor() {
+    super('WaterFlow')
+  }
+}
+
+export class TaroListElement extends TaroScrollViewElement {
+  constructor() {
+    super('List')
+  }
+}
+
+export class TaroFlowSectionElement extends TaroElement<FlowSectionProps> {
+  constructor() {
+    super('FlowSection')
+  }
+}
+
+export class TaroFlowItemElement extends TaroElement {
+  constructor() {
+    super('FlowItem')
+  }
+}

package/dist/runtime/runtime-cpp/dom/element/scroll_view.ts

@@ -0,0 +1,32 @@
+import { TaroNativeModule } from '../../harmony-library'
+import { TaroElement } from './element'
+
+import type { ScrollViewProps } from '@tarojs/components/types'
+
+export class TaroScrollViewElement extends TaroElement<ScrollViewProps> {
+  constructor(tagName = 'ScrollView') {
+    super(tagName)
+  }
+
+  get scrollTop() {
+    return TaroNativeModule.getCurrentOffset(this)?.yOffset
+  }
+
+  set scrollTop(value: number) {
+    TaroNativeModule.scrollTo(this, {
+      yOffset: value,
+      duration: 0
+    })
+  }
+
+  get scrollLeft() {
+    return TaroNativeModule.getCurrentOffset(this)?.xOffset
+  }
+
+  set scrollLeft(value: number) {
+    TaroNativeModule.scrollTo(this, {
+      xOffset: value,
+      duration: 0
+    })
+  }
+}

package/dist/runtime/runtime-cpp/dom/element/text.ts

@@ -0,0 +1,9 @@
+import { TaroElement } from './element'
+
+import type { TextProps } from '@tarojs/components/types'
+
+export class TaroTextElement extends TaroElement<TextProps> {
+  constructor() {
+    super('Text')
+  }
+}

package/dist/runtime/runtime-cpp/dom/element/video.ts

@@ -0,0 +1,66 @@
+import { TaroElement } from './element'
+
+import type { VideoProps } from '@tarojs/components/types'
+import type { TaroAny } from '../../interface'
+
+export class TaroVideoElement extends TaroElement<VideoProps> {
+  controller: VideoController
+
+  isETS = true
+
+  constructor() {
+    super('Video')
+
+    this._nodeInfo._currentTime = 0
+  }
+
+  public setAttribute(name: string, value: TaroAny): void {
+    super.setAttribute(name, value)
+
+    // Note: 使用 @ComponentV2 时，需要在 struct 将参数声明为 @Local 并在此更新
+    if (this._instance) {
+      const attrName = `attr${name.charAt(0).toUpperCase()}${name.slice(1)}`
+      this._instance[attrName] = value
+    }
+  }
+
+  async play() {
+    try {
+      this.controller.start()
+      return Promise.resolve()
+    } catch (e) {
+      return Promise.reject(e)
+    }
+  }
+
+  pause() {
+    try {
+      this.controller.pause()
+      return Promise.resolve()
+    } catch (e) {
+      return Promise.reject(e)
+    }
+  }
+
+  stop() {
+    try {
+      this.controller.stop()
+      return Promise.resolve()
+    } catch (e) {
+      return Promise.reject(e)
+    }
+  }
+
+  get currentTime() {
+    return this._nodeInfo._currentTime
+  }
+
+  set currentTime(val: number) {
+    this._nodeInfo._currentTime = val
+    this.controller.setCurrentTime(val)
+  }
+
+  dispose () {
+    this.controller = null
+  }
+}

package/dist/runtime/runtime-cpp/dom/element/web_view.ts

@@ -0,0 +1,72 @@
+import business_error from '@ohos.base'
+import web_webview from '@ohos.web.webview'
+
+import { TaroElement } from './element'
+
+import type { WebViewProps } from '@tarojs/components/types'
+
+@Observed
+export class TaroInnerHtmlElement extends TaroElement {
+  isETS = true
+
+  constructor() {
+    super('InnerHtml')
+  }
+}
+
+@Observed
+export class TaroWebViewElement extends TaroElement<WebViewProps> {
+  ports: web_webview.WebMessagePort[] = []
+
+  nativePort: web_webview.WebMessagePort | null = null
+
+  message: web_webview.WebMessageExt = new web_webview.WebMessageExt()
+
+  controller: web_webview.WebviewController = new web_webview.WebviewController()
+
+  isETS = true
+
+  constructor() {
+    super('WebView')
+  }
+
+  postMessage (value: string) {
+    if (!this.nativePort) return
+
+    this.message.setString(value)
+    this.nativePort.postMessageEventExt(this.message)
+  }
+
+  handleMessageFromWeb (result: web_webview.WebMessageExt) {
+    try {
+      const type = result.getType()
+      switch (type) {
+        case web_webview.WebMessageType.STRING: {
+          return result.getString()
+        }
+        case web_webview.WebMessageType.NUMBER: {
+          return result.getNumber()
+        }
+        case web_webview.WebMessageType.BOOLEAN: {
+          return result.getBoolean()
+        }
+        case web_webview.WebMessageType.ARRAY_BUFFER: {
+          return result.getArrayBuffer()
+        }
+        case web_webview.WebMessageType.ARRAY: {
+          return result.getArray()
+        }
+        case web_webview.WebMessageType.ERROR: {
+          return result.getError()
+        }
+        default: {
+          return null
+        }
+      }
+    } catch (error) {
+      const e: business_error.BusinessError = error as business_error.BusinessError
+
+      console.error(`ErrorCode: ${e.code},  Message: ${e.message}`)
+    }
+  }
+}

package/dist/runtime/runtime-cpp/dom/event-source.ts

@@ -0,0 +1 @@
+export { eventSource } from '@tarojs/runtime/dist/runtime.esm'