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

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

@@ -0,0 +1,198 @@
+import { Current } from '@tarojs/runtime'
+
+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)
+    }
+
+    // @ts-ignore
+    const uiContext = Current?.page?.getUIContext?.()
+
+    if (!uiContext) return
+
+    uiContext.getPromptAction().showToast({
+      message: options.title,
+      duration: options.duration,
+      bottom: options.bottom,
+      showMode: 1 // 设置弹窗显示模式，显示在应用之上。
+    })
+    callAsyncSuccess(resolve, resCallback('showToast'), options)
+  })
+}
+
+export function showModal (options) {
+  const _default = {
+    title: '',
+    content: '',
+    showCancel: true,
+    cancelText: '取消',
+    cancelColor: '#000000',
+    confirmText: '确定',
+    confirmColor: '#3CC51F',
+    backgroundColor: '#ffffff'
+  }
+
+  options = { ..._default, ...options }
+
+  const {
+    title, content, cancelText, confirmText,
+    cancelColor, confirmColor, showCancel, backgroundColor
+  } = 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, reject) => {
+    const modalOptions = {
+      title,
+      message: content,
+      buttons: buttons,
+      backgroundColor
+    }
+
+    // @ts-ignore
+    const uiContext = Current?.page?.getUIContext?.()
+
+    if (!uiContext) return
+
+    uiContext.getPromptAction().showDialog(modalOptions, (error, data) => {
+      if (error) {
+        const res = { errMsg: error }
+        callAsyncFail(reject, res, options)
+      }
+
+      if (data.index === 0 && showCancel) {
+        callAsyncSuccess(
+          resolve,
+          {
+            ...resCallback('showModal'),
+            confirm: false,
+            cancel: true
+          },
+          options
+        )
+      } else {
+        callAsyncSuccess(
+          resolve,
+          {
+            ...resCallback('showModal'),
+            confirm: true,
+            cancel: false,
+            content: null
+          },
+          options
+        )
+      }
+    })
+  })
+}
+
+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
+    }
+
+    // @ts-ignore
+    const uiContext = Current?.page?.getUIContext?.()
+
+    if (!uiContext) return
+
+    uiContext.getPromptAction().showActionMenu(actionSheetOptions, (error, data) => {
+      if (error) {
+        callAsyncFail(
+          reject,
+          {
+            ...data,
+            errMsg: data.errMsg?.replace('showActionMenu', 'showActionSheet')
+          },
+          options
+        )
+      }
+
+      callAsyncSuccess(
+        resolve,
+        {
+          ...data,
+          ...resCallback('showActionSheet')
+        },
+        options
+      )
+    })
+  })
+}
+
+export const hideToast = /* @__PURE__ */ temporarilyNotSupport('hideToast')
+
+export const showLoading = temporarilyNotSupport('showLoading')
+export const hideLoading = temporarilyNotSupport('hideLoading')
+
+export const enableAlertBeforeUnload = /* @__PURE__ */ temporarilyNotSupport('enableAlertBeforeUnload')
+export const disableAlertBeforeUnload = /* @__PURE__ */ temporarilyNotSupport('disableAlertBeforeUnload')

package/dist/runtime/apis/ui/menu.ts

@@ -0,0 +1,4 @@
+import { temporarilyNotSupport } from '../utils'
+
+// 菜单
+export const getMenuButtonBoundingClientRect = /* @__PURE__ */ temporarilyNotSupport('getMenuButtonBoundingClientRect')

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

@@ -0,0 +1,72 @@
+import { eventCenter } from '@tarojs/runtime'
+
+import { MethodHandler } from '../../utils/handler'
+
+import type Taro from '@tarojs/taro/types'
+
+export const setNavigationBarTitle: typeof Taro.setNavigationBarTitle = function (options) {
+  const { success, fail, complete } = options || {}
+  const handle = new MethodHandler({ name: 'setNavigationBarTitle', success, fail, complete })
+
+  return new Promise((resolve, reject) => {
+    eventCenter.trigger('__taroNavigationStyle', {
+      title: options.title,
+    })
+
+    return handle.success({}, { resolve, reject })
+  })
+}
+
+export const setNavigationBarColor: typeof Taro.setNavigationBarColor = function (options) {
+  const { success, fail, complete } = options || {}
+  const handle = new MethodHandler({ name: 'setNavigationBarColor', success, fail, complete })
+
+  return new Promise((resolve, reject) => {
+    eventCenter.trigger('__taroNavigationStyle', {
+      animation: options.animation,
+      backgroundColor: options.backgroundColor,
+      frontColor: options.frontColor,
+    })
+
+    return handle.success({}, { resolve, reject })
+  })
+}
+
+export const showNavigationBarLoading: typeof Taro.setNavigationBarColor = function (options) {
+  const { success, fail, complete } = options || {}
+  const handle = new MethodHandler({ name: 'showNavigationBarLoading', success, fail, complete })
+
+  return new Promise((resolve, reject) => {
+    eventCenter.trigger('__taroNavigationStyle', {
+      loading: true,
+    })
+
+    return handle.success({}, { resolve, reject })
+  })
+}
+
+export const hideNavigationBarLoading: typeof Taro.hideNavigationBarLoading = function (options) {
+  const { success, fail, complete } = options || {}
+  const handle = new MethodHandler({ name: 'hideNavigationBarLoading', success, fail, complete })
+
+  return new Promise((resolve, reject) => {
+    eventCenter.trigger('__taroNavigationStyle', {
+      loading: false,
+    })
+
+    return handle.success({}, { resolve, reject })
+  })
+}
+
+export const hideHomeButton: typeof Taro.hideHomeButton = function (options) {
+  const { success, fail, complete } = options || {}
+  const handle = new MethodHandler({ name: 'hideHomeButton', success, fail, complete })
+
+  return new Promise((resolve, reject) => {
+    eventCenter.trigger('__taroNavigationStyle', {
+      home: false,
+    })
+
+    return handle.success({}, { resolve, reject })
+  })
+}

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

@@ -0,0 +1,47 @@
+import { Current } from '@tarojs/runtime'
+
+import { callAsyncFail, callAsyncSuccess } from '../utils'
+
+import type Taro from '@tarojs/taro/types'
+
+export const startPullDownRefresh: typeof Taro.startPullDownRefresh = function (options) {
+  return new Promise((resolve, reject) => {
+    const taro = Current.taro
+    const page = taro.getCurrentInstance().page
+
+    if (!page) {
+      return callAsyncFail(reject, { errMsg: 'stopPullDownRefresh:fail' }, options)
+    }
+    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, reject) => {
+    const taro = Current.taro
+    const page = taro.getCurrentInstance().page
+
+    if (!page) {
+      return callAsyncFail(reject, { errMsg: 'stopPullDownRefresh:fail' }, options)
+    }
+    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/runtime/apis/ui/scroll/index.ts

@@ -0,0 +1,82 @@
+import { Current, document, getPageScrollerOrNode } from '@tarojs/runtime'
+
+import { MethodHandler, pxTransformHelper } from '../../utils'
+
+import type { TaroAny } from '@tarojs/runtime'
+import type Taro from '@tarojs/taro/types'
+
+export const pageScrollTo: typeof Taro.pageScrollTo = (options) => {
+  const { scrollTop, selector = '', duration = 300, offsetTop = 0, success, fail, complete } = options || {}
+  const handle = new MethodHandler({ name: 'pageScrollTo', success, fail, complete })
+  return new Promise((resolve, reject) => {
+    if (scrollTop === undefined && !selector) {
+      return handle.fail({
+        errMsg: 'scrollTop" 或 "selector" 需要其之一'
+      }, { resolve, reject })
+    }
+
+    if (scrollTop && selector) {
+      console.warn('"scrollTop" 或 "selector" 建议只设一个值, 全部设置会忽略selector')
+    }
+
+    const taro = Current.taro
+    const page = taro.getCurrentInstance().page
+
+    let scrollTopValue = -1
+    let scrollLeftValue = -1
+    let scrollNode: TaroAny = null
+    const currentPageNode = getPageScrollerOrNode(page?.node, page)
+
+    if (scrollTop || typeof scrollTop === 'number') {
+      scrollTopValue = scrollTop
+    } else if (selector) {
+      const node: TaroAny = document.querySelector(selector)
+
+      if (!node) return
+
+      const globalPositionY = node.getComputedStyle().globalY
+
+      let parent = node?.parentNode
+      while (!!parent && parent !== currentPageNode) {
+        if (parent?.nodeName === 'SCROLL-VIEW') {
+          scrollNode = parent
+          break
+        }
+        parent = parent?.parentNode
+      }
+
+      if (!scrollNode) return
+
+      // FIXME 更新为新的获取方式获取组件参数
+      const result = Current.nativeModule.getCurrentOffset(scrollNode)
+
+      if (!result) return
+
+      const { yOffset, xOffset } = result
+      scrollTopValue = globalPositionY + yOffset + pxTransformHelper(offsetTop, 'px', true)
+      scrollLeftValue = xOffset
+    }
+
+    if (scrollTopValue === -1) {
+      return handle.fail({
+        errMsg: '请检查传入的 scrollTop 或 selector 是否合法'
+      }, { resolve, reject })
+    }
+
+    try {
+      Current.nativeModule.scrollTo(currentPageNode, {
+        xOffset: scrollLeftValue,
+        yOffset: scrollTopValue,
+        duration,
+      })
+
+      setTimeout(() => {
+        handle.success({}, { resolve, reject })
+      }, duration)
+    } catch (err) {
+      return handle.fail({
+        errMsg: err.message
+      }, { resolve, reject })
+    }
+  })
+}

package/dist/runtime/apis/ui/sticky.ts

@@ -0,0 +1,4 @@
+import { temporarilyNotSupport } from '../utils'
+
+// 置顶
+export const setTopBarText = /* @__PURE__ */ temporarilyNotSupport('setTopBarText')

package/dist/runtime/apis/ui/tab-bar.ts

@@ -0,0 +1,144 @@
+import { Current, eventCenter } from '@tarojs/runtime'
+
+import { callAsyncFail, callAsyncSuccess } from '../utils'
+
+import type Taro from '@tarojs/taro/types'
+
+interface ShowTabBar {
+  type: 'show'
+  fn: typeof Taro.showTabBar
+}
+
+interface HideTabBar {
+  type: 'hide'
+  fn: typeof Taro.hideTabBar
+}
+
+type ToggleAPIs = ShowTabBar | HideTabBar
+
+const toggleTabBar = function<T extends ToggleAPIs['type']> (type: T): Extract<ToggleAPIs, {type: T}>['fn'] {
+  return function (options) {
+    return new Promise((resolve, reject) => {
+      const taro = Current.taro
+      const page = taro.getCurrentInstance().page
+      const currentData = page?._data?.taroTabBar || page?.tabBar
+      const res = { errMsg: `${type}TabBar:ok` }
+      const error = { errMsg: `${type}TabBar:fail not TabBar page` }
+
+      if (!currentData) {
+        callAsyncFail(reject, error, options)
+      } else {
+        const isShow = type === 'show'
+        const event = isShow ? '__taroShowTabBar' : '__taroHideTabBar'
+        eventCenter.trigger(event, {
+          animation: options?.animation,
+        })
+        page.$set?.('isShowTaroTabBar', isShow)
+        callAsyncSuccess(resolve, res, options)
+      }
+    })
+  }
+}
+
+export const showTabBar = toggleTabBar('show')
+
+export const hideTabBar = toggleTabBar('hide')
+
+export const setTabBarStyle: typeof Taro.setTabBarStyle = function (options = {}) {
+  return new Promise((resolve, reject) => {
+    const taro = Current.taro
+    const page = taro.getCurrentInstance().page
+    const currentData = page?._data?.taroTabBar || page?.tabBar
+    const res = { errMsg: 'setTabBarStyle:ok' }
+    const error = { errMsg: 'setTabBarStyle:fail not TabBar page' }
+
+    if (!currentData) {
+      callAsyncFail(reject, error, options)
+    } else {
+      const data = Object.assign({}, currentData)
+
+      if (options.color) data.color = options.color
+      if (options.selectedColor) data.selectedColor = options.selectedColor
+      if (options.backgroundColor) data.backgroundColor = options.backgroundColor
+      if (options.borderStyle) data.borderStyle = options.borderStyle
+
+      eventCenter.trigger('__taroSetTabBarStyle', options)
+      page.$set?.('taroTabBar', data)
+      callAsyncSuccess(resolve, res, options)
+    }
+  })
+}
+
+export const setTabBarItem: typeof Taro.setTabBarItem = function (options) {
+  return new Promise((resolve, reject) => {
+    const taro = Current.taro
+    const page = taro.getCurrentInstance().page
+    const currentData = page?._data?.taroTabBar || page?.tabBar
+    const res = { errMsg: 'setTabBarItem:ok' }
+    const error = { errMsg: 'setTabBarItem:fail not TabBar page' }
+
+    if (!currentData) {
+      callAsyncFail(reject, error, options)
+    } else {
+      const index = options.index
+      const item = Object.assign({}, currentData.list[index])
+
+      if (options.text) item.text = options.text
+      if (options.iconPath) item.iconPath = options.iconPath
+      if (options.selectedIconPath) item.selectedIconPath = options.selectedIconPath
+
+      const list = [
+        ...currentData.list.slice(0, index),
+        item,
+        ...currentData.list.slice(index + 1)
+      ]
+      const data = Object.assign({}, currentData, { list })
+
+      eventCenter.trigger('__taroSetTabBarItem', options)
+      page.$set?.('taroTabBar', data)
+      callAsyncSuccess(resolve, res, options)
+    }
+  })
+}
+
+export function showTabBarRedDot (options) {
+  const res = { errMsg: 'showTabBarRedDot:ok' }
+  return new Promise((resolve) => {
+    eventCenter.trigger('__taroShowTabBarRedDotHandler', {
+      index: options?.index || 0,
+    })
+    callAsyncSuccess(resolve, res, options)
+  })
+}
+
+export function hideTabBarRedDot (options) {
+  const res = { errMsg: 'hideTabBarRedDot:ok' }
+  return new Promise((resolve) => {
+    eventCenter.trigger('__taroHideTabBarRedDotHandler', {
+      index: options?.index || 0,
+    })
+    callAsyncSuccess(resolve, res, options)
+  })
+}
+
+export function setTabBarBadge (options) {
+  const res = { errMsg: 'setTabBarBadge:ok' }
+  return new Promise((resolve) => {
+    const text = options?.text || ''
+    eventCenter.trigger('__taroSetTabBarBadge', {
+      index: options?.index || 0,
+      text: text.replace(/[\u0391-\uFFE5]/g, 'aa').length > 4 ? '...' : text,
+    })
+    callAsyncSuccess(resolve, res, options)
+  })
+}
+
+export function removeTabBarBadge (options) {
+  const res = { errMsg: 'removeTabBarBadge:ok' }
+  return new Promise((resolve) => {
+    eventCenter.trigger('__taroRemoveTabBarBadge', {
+      index: options?.index || 0,
+    })
+    callAsyncSuccess(resolve, res, options)
+  })
+}

package/dist/runtime/apis/ui/window.ts

@@ -0,0 +1,20 @@
+import { temporarilyNotSupport } from '../utils'
+
+import type Taro from '@tarojs/taro/types'
+
+/**
+ * 设置窗口大小，该接口仅适用于 PC 平台，使用细则请参见指南
+ */
+export const setWindowSize = /* @__PURE__ */ temporarilyNotSupport('setWindowSize')
+
+/**
+ * 监听窗口尺寸变化事件
+ */
+export const onWindowResize: typeof Taro.onWindowResize = /* @__PURE__ */ temporarilyNotSupport('onWindowResize')
+
+/**
+ * 取消监听窗口尺寸变化事件
+ */
+export const offWindowResize: typeof Taro.offWindowResize = /* @__PURE__ */ temporarilyNotSupport('offWindowResize')
+
+export const checkIsPictureInPictureActive = /* @__PURE__ */ temporarilyNotSupport('checkIsPictureInPictureActive')

package/dist/runtime/apis/utils/constant.ts

@@ -0,0 +1 @@
+export const ETS_METHODS_TRIGGER_EVENTNAME = '__taroPluginEtsMethodsTrigger'

package/dist/runtime/apis/utils/handler.ts

@@ -0,0 +1,117 @@
+import { isFunction } from '@tarojs/shared'
+
+import type { TFunc } from '@tarojs/runtime'
+
+export interface ICallbackResult {
+  /** 错误信息 */
+  errMsg: string
+}
+
+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<T | ICallbackResult>
+}
+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<T | ICallbackResult>
+
+  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 as T)
+
+    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 as ICallbackResult)
+
+    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)
+      }
+    })
+  }
+}