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

package/dist/apis/ui/animation.ts

@@ -0,0 +1,222 @@
+import matrix4 from '@ohos.matrix4'
+
+import { temporarilyNotSupport } from '../utils'
+
+import type Taro from '@tarojs/api'
+
+interface IAnimationAttr {
+  duration: number
+  delay: number
+  timingFunction: string
+  transformOrigin: string
+}
+
+type TStep = {
+  delay: number
+  duration: number
+  timingFunction: string
+  transformOrigin: string
+  rule: TRule
+}
+
+type TRule = Record<string, any>
+
+export class Animation implements Taro.Animation {
+
+  unit: string
+  DEFAULT: IAnimationAttr
+
+  // 组合动画
+  steps: TStep[] = []
+  // 属性组合
+  rule: TRule = {}
+
+  constructor({
+    duration = 400,
+    delay = 0,
+    timingFunction = 'linear',
+    transformOrigin = '50% 50% 0',
+    unit = 'px'
+  }: Taro.createAnimation.Option = {}) {
+    this.unit = unit
+    this.setDefault(duration, delay, timingFunction, transformOrigin)
+  }
+
+  // 设置默认值
+  setDefault (duration, delay, timingFunction, transformOrigin) {
+    this.DEFAULT = { duration, delay, timingFunction, transformOrigin }
+  }
+
+  export (): { actions: any[] } {
+    const actions = this.steps.slice()
+    this.steps = []
+    this.rule = {}
+    return {
+      actions
+    }
+  }
+
+  step (arg: Partial<IAnimationAttr> = {}): Taro.Animation {
+    const { DEFAULT } = this
+    const {
+      duration = DEFAULT.duration,
+      delay = DEFAULT.delay,
+      timingFunction = DEFAULT.timingFunction,
+      transformOrigin = DEFAULT.transformOrigin
+    } = arg
+    this.steps.push({
+      duration,
+      delay,
+      timingFunction,
+      transformOrigin,
+      rule: Object.assign({}, this.rule)
+    })
+    return this
+  }
+
+  matrix (a: number, b: number, c: number, d: number, tx: number, ty: number): Taro.Animation {
+    this.rule.transform = matrix4.init([a, b, c, d, tx, ty])
+    return this
+  }
+
+  matrix3d (a1: number, b1: number, c1: number, d1: number, a2: number, b2: number, c2: number, d2: number, a3: number, b3: number, c3: number, d3: number, a4: number, b4: number, c4: number, d4: number): Taro.Animation {
+    this.rule.transform = matrix4.init([a1, b1, c1, d1, a2, b2, c2, d2, a3, b3, c3, d3, a4, b4, c4, d4])
+    return this
+  }
+
+  rotate (angle: number): Taro.Animation {
+    this.rule.rotate = { x: 0, y: 0, z: 1, angle }
+    return this
+  }
+
+  rotate3d (x: number, y?: number | undefined, z?: number | undefined, angle?: number | undefined): Taro.Animation {
+    this.rule.rotate = { x, y, z, angle }
+    return this
+  }
+
+  rotateX (angle: number): Taro.Animation {
+    this.rule.rotate = { x: 1, y: 0, z: 0, angle }
+    return this
+  }
+
+  rotateY (angle: number): Taro.Animation {
+    this.rule.rotate = { x: 0, y: 1, z: 0, angle }
+    return this
+  }
+
+  rotateZ (angle: number): Taro.Animation {
+    this.rule.rotate = { x: 0, y: 0, z: 1, angle }
+    return this
+  }
+
+  scale (sx: number, sy?: number | undefined): Taro.Animation {
+    this.rule.scale = { x: sx, y: sy }
+    return this
+  }
+
+  scale3d (sx: number, sy: number, sz: number): Taro.Animation {
+    this.rule.scale = { x: sx, y: sy, z: sz }
+    return this
+  }
+
+  scaleX (scale: number): Taro.Animation {
+    this.rule.scale = { x: scale }
+    return this
+  }
+
+  scaleY (scale: number): Taro.Animation {
+    this.rule.scale = { y: scale }
+    return this
+  }
+
+  scaleZ (scale: number): Taro.Animation {
+    this.rule.scale = { z: scale }
+    return this
+  }
+
+  skew (ax: number, ay: number): Taro.Animation {
+    this.rule.skew = { x: ax, y: ay }
+    return this
+  }
+
+  skewX (angle: number): Taro.Animation {
+    this.rule.skew = { x: angle }
+    return this
+  }
+
+  skewY (angle: number): Taro.Animation {
+    this.rule.skew = { y: angle }
+    return this
+  }
+
+  translate (tx?: number | undefined, ty?: number | undefined): Taro.Animation {
+    this.rule.translate = { x: tx, y: ty }
+    return this
+  }
+
+  translate3d (tx?: number | undefined, ty?: number | undefined, tz?: number | undefined): Taro.Animation {
+    this.rule.translate = { x: tx, y: ty, z: tz }
+    return this
+  }
+
+  translateX (translation: number): Taro.Animation {
+    this.rule.translate = { x: translation }
+    return this
+  }
+
+  translateY (translation: number): Taro.Animation {
+    this.rule.translate = { y: translation }
+    return this
+  }
+
+  translateZ (translation: number): Taro.Animation {
+    this.rule.translate = { z: translation }
+    return this
+  }
+
+  opacity (value: number): Taro.Animation {
+    this.rule.opacity = value
+    return this
+  }
+
+  backgroundColor (value: string): Taro.Animation {
+    this.rule.backgroundColor = value
+    return this
+  }
+
+  width (value: string | number): Taro.Animation {
+    this.rule.size = {
+      ...this.rule.size,
+      width: value
+    }
+    return this
+  }
+
+  height (value: string | number): Taro.Animation {
+    this.rule.size = {
+      ...this.rule.size,
+      height: value
+    }
+    return this
+  }
+
+  left (value: string | number): Taro.Animation {
+    temporarilyNotSupport('animation.left:' + value)(value)
+    return this
+  }
+
+  right (value: string | number): Taro.Animation {
+    temporarilyNotSupport('animation.right:' + value)(value)
+    return this
+  }
+
+  top (value: string | number): Taro.Animation {
+    temporarilyNotSupport('animation.top:' + value)(value)
+    return this
+  }
+
+  bottom (value: string | number): Taro.Animation {
+    temporarilyNotSupport('animation.bottom:' + value)(value)
+    return this
+  }
+}

package/dist/apis/ui/background.ts

@@ -0,0 +1,35 @@
+// import window from '@ohos.window'
+// import { Current } from '@tarojs/runtime'
+import { eventCenter } from '@tarojs/runtime/dist/runtime.esm'
+
+import { MethodHandler } from '../utils/handler'
+
+// import { callAsyncFail, callAsyncSuccess } from '../utils'
+
+
+// const windowClassPromise = (Current as any).contextPromise
+//   .then(context => {
+//     return window.getTopWindow(context)
+//   })
+
+export function setBackgroundColor(options: Taro.setBackgroundColor.Option) {
+  const { success, fail, complete } = options || {}
+  const handle = new MethodHandler({ name: 'setBackgroundColor', success, fail, complete })
+
+  return new Promise((resolve, reject) => {
+    eventCenter.trigger('__taroPageStyle', {
+      backgroundColor: options.backgroundColor || options.backgroundColorTop || options.backgroundColorBottom,
+    })
+
+    return handle.success({}, { resolve, reject })
+    // windowClassPromise.then(windowClass => {
+    //   windowClass.setBackgroundColor(color).then(() => {
+    //     const res = { errMsg: 'setBackgroundColor:ok' }
+    //     callAsyncSuccess(resolve, res, options)
+    //   }, (error) => {
+    //     const res = { errMsg: 'setBackgroundColor:fail' + error }
+    //     callAsyncFail(reject, res, options)
+    //   })
+    // })
+  })
+}

package/dist/apis/ui/index.ts

@@ -0,0 +1,14 @@
+import { temporarilyNotSupport } from '../utils'
+import { Animation } from './animation'
+
+import type Taro from '@tarojs/api'
+
+export const createAnimation = (option: Taro.createAnimation.Option) => {
+  return new Animation(option)
+}
+export const getMenuButtonBoundingClientRect = temporarilyNotSupport('getMenuButtonBoundingClientRect')
+
+export * from './background'
+export * from './interaction'
+export * from './navigation-bar'
+export * from './pull-down-refresh'

package/dist/apis/ui/interaction/index.ts

@@ -0,0 +1,195 @@
+import prompt from '@ohos.prompt'
+
+import { callAsyncFail, callAsyncSuccess, temporarilyNotSupport, validateParams } from '../../utils'
+
+const resCallback = (res) => {
+  return { errMsg: `${res}:ok` }
+}
+
+const showToastSchema = {
+  title: 'String',
+  duration: 'Number',
+  bottom: 'String'
+}
+
+export function showToast (options) {
+  return new Promise((resolve, reject) => {
+    const _default = {
+      title: '',
+      duration: 1500,
+      bottom: '50%'
+    }
+
+    options = { ..._default, ...options }
+
+    try {
+      validateParams<any>('showToast', options, showToastSchema)
+    } catch (error) {
+      const res = { errMsg: error.message }
+      return callAsyncFail(reject, res, options)
+    }
+
+    prompt.showToast({
+      message: options.title,
+      duration: options.duration,
+      bottom: options.bottom
+    })
+    callAsyncSuccess(resolve, resCallback('showToast'), options)
+  })
+}
+
+export function showModal (options) {
+  const _default = {
+    title: '',
+    content: '',
+    showCancel: true,
+    cancelText: '取消',
+    cancelColor: '#000000',
+    confirmText: '确定',
+    confirmColor: '#3CC51F'
+  }
+
+  options = { ..._default, ...options }
+
+  const {
+    title, content, cancelText, confirmText,
+    cancelColor, confirmColor, showCancel
+  } = options
+
+  const buttons: any = []
+
+  if (cancelText !== '' && showCancel) {
+    buttons.push({
+      text: cancelText,
+      color: cancelColor
+    })
+  }
+
+  if (confirmText !== '') {
+    buttons.push({
+      text: confirmText,
+      color: confirmColor
+    })
+  }
+
+  return new Promise(resolve => {
+    const modalOptions = {
+      title,
+      message: content,
+      buttons: buttons,
+      success: (data) => {
+        if (data.index === 1 || !showCancel) {
+          callAsyncSuccess(
+            resolve,
+            {
+              ...resCallback('showModal'),
+              confirm: true,
+              cancel: false,
+              content: null
+            },
+            options
+          )
+        } else {
+          callAsyncSuccess(
+            resolve,
+            {
+              ...resCallback('showModal'),
+              confirm: false,
+              cancel: true
+            },
+            options
+          )
+        }
+      },
+      // 鸿蒙没有失败方法，只有取消
+      cancel: (_) => {
+        callAsyncSuccess(
+          resolve,
+          {
+            ...resCallback('showModal'),
+            confirm: false,
+            cancel: true
+          },
+          options
+        )
+      }
+    }
+
+    prompt.showDialog(modalOptions)
+  })
+}
+
+const showActionSheetSchema = {
+  title: 'String',
+  itemList: 'Array'
+}
+
+export function showActionSheet (options) {
+  return new Promise((resolve, reject) => {
+    const _default = {
+      title: '',
+      itemList: [],
+      itemColor: '#000000'
+    }
+
+    options = { ..._default, ...options }
+
+    try {
+      validateParams<any>('showActionSheet', options, showActionSheetSchema)
+    } catch (error) {
+      const res = { errMsg: error.message }
+      return callAsyncFail(reject, res, options)
+    }
+
+    const { title, itemList, itemColor } = options
+
+    const buttons = itemList.map(res => {
+      return {
+        text: res,
+        color: itemColor
+      }
+    })
+
+    const actionSheetOptions = {
+      title,
+      buttons,
+      success: (data) => {
+        callAsyncSuccess(
+          resolve,
+          {
+            ...data,
+            ...resCallback('showActionSheet')
+          },
+          options
+        )
+      },
+      // 取消方法，并非失败
+      fail: (data) => {
+        callAsyncFail(
+          reject,
+          {
+            ...data,
+            errMsg: data.errMsg.replace('showActionMenu', 'showActionSheet')
+          },
+          options
+        )
+      }
+    }
+
+    prompt.showActionMenu(actionSheetOptions)
+  })
+}
+
+export function hideToast (options) {
+  return new Promise(resolve => {
+    prompt.showToast({
+      message: '关闭中',
+      duration: 10,
+      bottom: '9999px'
+    })
+    callAsyncSuccess(resolve, resCallback('hideToast'), options)
+  })
+}
+
+export const showLoading = temporarilyNotSupport('showLoading')
+export const hideLoading = temporarilyNotSupport('hideLoading')

package/dist/apis/ui/navigation-bar/index.ts

@@ -0,0 +1,33 @@
+import { Current } from '@tarojs/runtime'
+
+import { callAsyncSuccess, temporarilyNotSupport } from '../../utils'
+
+import type Taro from '@tarojs/api'
+
+export const setNavigationBarTitle: typeof Taro.setNavigationBarTitle = function (options) {
+  return new Promise(resolve => {
+    const taro = (Current as any).taro
+    const page = taro.getCurrentInstance().page
+    const res = { errMsg: 'setNavigationBarTitle:ok' }
+
+    page.$set?.('taroNavBar.title', options.title)
+    callAsyncSuccess(resolve, res, options)
+  })
+}
+
+export const setNavigationBarColor: typeof Taro.setNavigationBarColor = function (options) {
+  return new Promise(resolve => {
+    const taro = (Current as any).taro
+    const page = taro.getCurrentInstance().page
+    const { frontColor, backgroundColor } = options
+    const res = { errMsg: 'setNavigationBarColor:ok' }
+
+    page.$set?.('taroNavBar.textStyle', frontColor)
+    page.$set?.('taroNavBar.background', backgroundColor)
+    callAsyncSuccess(resolve, res, options)
+  })
+}
+
+export const showNavigationBarLoading = temporarilyNotSupport('showNavigationBarLoading')
+export const hideNavigationBarLoading = temporarilyNotSupport('hideNavigationBarLoading')
+export const hideHomeButton = temporarilyNotSupport('hideHomeButton')

package/dist/apis/ui/pull-down-refresh.ts

@@ -0,0 +1,41 @@
+import { Current } from '@tarojs/runtime'
+
+import { callAsyncSuccess } from '../utils'
+
+import type Taro from '@tarojs/api'
+
+export const startPullDownRefresh: typeof Taro.startPullDownRefresh = function (options) {
+  return new Promise(resolve => {
+    const taro = (Current as any).taro
+    const page = taro.getCurrentInstance().page
+
+    if (page.isRefreshing instanceof Array) {
+      const index = page.tabBarCurrentIndex || 0
+      page.isRefreshing[index] = true
+    } else {
+      page.isRefreshing = true
+    }
+
+    const res = { errMsg: 'startPullDownRefresh:ok' }
+    page.$set?.('isRefreshing', true)
+    callAsyncSuccess(resolve, res, options)
+  })
+}
+
+export const stopPullDownRefresh: typeof Taro.stopPullDownRefresh = function (options) {
+  return new Promise(resolve => {
+    const taro = (Current as any).taro
+    const page = taro.getCurrentInstance().page
+
+    if (page.isRefreshing instanceof Array) {
+      const index = page.tabBarCurrentIndex || 0
+      page.isRefreshing[index] = false
+    } else {
+      page.isRefreshing = false
+    }
+
+    const res = { errMsg: 'stopPullDownRefresh:ok' }
+    page.$set?.('isRefreshing', false)
+    callAsyncSuccess(resolve, res, options)
+  })
+}

package/dist/apis/utils/handler.ts

@@ -0,0 +1,116 @@
+import { isFunction } from '@tarojs/shared'
+
+export interface ICallbackResult {
+  /** 错误信息 */
+  errMsg: string
+}
+type TFunc = (...args: any[]) => any
+
+type TCallback<T = Partial<ICallbackResult>> = (res: T) => Promise<void> | void
+interface IMethodParam<T = Partial<ICallbackResult>> {
+  name: string
+  success?: TCallback<T & ICallbackResult>
+  fail?: TCallback
+  complete?: TCallback
+}
+interface IMockPromise {
+  resolve?: typeof Promise.resolve | TFunc
+  reject?: typeof Promise.reject | TFunc
+}
+
+export class MethodHandler<T = Partial<ICallbackResult>> {
+  methodName: string
+
+  protected __success?: TCallback<T>
+  protected __fail?: TCallback
+  protected __complete?: TCallback
+
+  protected isHandlerError = false
+
+  constructor ({ name, success, fail, complete }: IMethodParam<T>) {
+    this.methodName = name
+    this.__success = success
+    this.__fail = fail
+    this.__complete = complete
+
+    this.isHandlerError = isFunction(this.__complete) || isFunction(this.__fail)
+  }
+
+  success<U = Record<string, unknown>> (res: Partial<T> & Partial<ICallbackResult> = {}, promise: IMockPromise = {}): Promise<T & U & ICallbackResult> {
+    if (!res.errMsg) {
+      res.errMsg = `${this.methodName}:ok`
+    }
+    isFunction(this.__success) && this.__success(res as T)
+    isFunction(this.__complete) && this.__complete(res)
+
+    const { resolve = Promise.resolve.bind(Promise) } = promise
+    return resolve(res as Required<T & U & ICallbackResult>)
+  }
+
+  fail<U = Record<string, unknown>> (res: Partial<T> & Partial<ICallbackResult> = {}, promise: IMockPromise = {}): Promise<T & U & ICallbackResult> {
+    if (!res.errMsg) {
+      res.errMsg = `${this.methodName}:fail`
+    } else {
+      res.errMsg = `${this.methodName}:fail ${res.errMsg}`
+    }
+    isFunction(this.__fail) && this.__fail(res)
+    isFunction(this.__complete) && this.__complete(res)
+
+    const {
+      resolve = Promise.resolve.bind(Promise),
+      reject = Promise.reject.bind(Promise)
+    } = promise
+    return this.isHandlerError
+      ? resolve(res as Required<T & U & ICallbackResult>)
+      : reject(res)
+  }
+}
+
+type TCallbackManagerFunc<T extends unknown[] = unknown[]> = (...arr: T) => void
+interface ICallbackManagerOption<T extends unknown[] = unknown[]> {
+  callback?: TCallbackManagerFunc<T>
+  ctx?: any
+  [key: string]: unknown
+}
+type TCallbackManagerUnit<T extends unknown[] = unknown[]> = (TCallbackManagerFunc<T> | ICallbackManagerOption<T>)
+
+export class CallbackManager<T extends unknown[] = unknown[]> {
+  callbacks: TCallbackManagerUnit<T>[] = []
+
+  /** 添加回调 */
+  add = (opt?: TCallbackManagerUnit<T>) => {
+    if (opt) this.callbacks.push(opt)
+  }
+
+  /** 移除回调 */
+  remove = (opt?: TCallbackManagerUnit<T>) => {
+    if (opt) {
+      let pos = -1
+      this.callbacks.forEach((callback, k) => {
+        if (callback === opt) {
+          pos = k
+        }
+      })
+      if (pos > -1) {
+        this.callbacks.splice(pos, 1)
+      }
+    }
+  }
+
+  /** 获取回调函数数量 */
+  count = () => {
+    return this.callbacks.length
+  }
+
+  /** 触发回调 */
+  trigger = (...args: T) => {
+    this.callbacks.forEach(opt => {
+      if (isFunction(opt)) {
+        opt(...args)
+      } else {
+        const { callback, ctx } = opt
+        isFunction(callback) && callback.call(ctx, ...args)
+      }
+    })
+  }
+}