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

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

@@ -0,0 +1,105 @@
+import abilityAccessCtrl from '@ohos.abilityAccessCtrl'
+import { Current, eventCenter } from '@tarojs/runtime'
+
+import { ICallbackResult, MethodHandler } from './handler'
+
+import type { FunctionType, IAsyncParams } from './types'
+
+export * from './constant'
+export * from './unit'
+export * from './validate'
+export { MethodHandler }
+export { noop } from '@tarojs/shared'
+
+export function requestPermissions (permissions: string[]) {
+  return new Promise<void>((resolve, reject) => {
+    const context = getContext(Current?.page)
+    const atManager = abilityAccessCtrl.createAtManager()
+
+    atManager.requestPermissionsFromUser(context, permissions, (err, _) => {
+      if (err) {
+        // eslint-disable-next-line prefer-promise-reject-errors
+        reject(`[Taro] 请求用户授权 ${permissions.join('、')} 失败：${JSON.stringify(err)}`)
+      } else {
+        resolve()
+      }
+    })
+  })
+}
+
+export function object2String (obj) {
+  let str = ''
+  for (const item in obj) {
+    str = str + item + ':' + obj[item] + ' \n'
+  }
+  return str
+}
+
+export function temporarilyNotSupport (name: string, recommended?: string) {
+  return (option = {}, ...args) => {
+    const { success, fail, complete } = option as any
+    const handle = new MethodHandler({ name, success, fail, complete })
+    let errMsg = `暂时不支持 API ${name}`
+    if (recommended) {
+      errMsg += `, 请使用 ${recommended}`
+    }
+    eventCenter.trigger('__taroNotSupport', {
+      name,
+      args: [option, ...args],
+      type: 'method',
+      category: 'temporarily',
+    })
+    if (process.env.NODE_ENV === 'production') {
+      console.warn(errMsg)
+      return handle.success({ errMsg })
+    } else {
+      return handle.fail({ errMsg })
+    }
+  }
+}
+
+export function permanentlyNotSupport (name = '') {
+  return (option = {}, ...args: any[]) => {
+    const { success, fail, complete } = option as any
+    const handle = new MethodHandler<ICallbackResult>({ name, success, fail, complete })
+    const errMsg = '不支持 API'
+    eventCenter.trigger('__taroNotSupport', {
+      name,
+      args: [option, ...args],
+      type: 'method',
+      category: 'permanently',
+    })
+    if (process.env.NODE_ENV === 'production') {
+      console.warn(errMsg)
+      return handle.success({ errMsg })
+    } else {
+      return handle.fail({ errMsg })
+    }
+  }
+}
+
+/** @deprecated */
+export function callCallbackSuccess<T extends FunctionType> (res, options?: IAsyncParams<T>) {
+  options?.success?.(res)
+  options?.complete?.(res)
+}
+
+/** @deprecated */
+export function callCallbackFail<T extends FunctionType> (res, options?: IAsyncParams<T>) {
+  options?.fail?.(res)
+  options?.complete?.(res)
+}
+
+/** @deprecated */
+export function callAsyncSuccess<T extends FunctionType> (resolve, res, options?: IAsyncParams<T>) {
+  options?.success?.(res)
+  options?.complete?.(res)
+  resolve(res)
+}
+
+/** @deprecated */
+export function callAsyncFail<T extends FunctionType> (reject, res, options?: IAsyncParams<T>) {
+  options?.fail?.(res)
+  options?.complete?.(res)
+  reject(res)
+}

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

@@ -0,0 +1,6 @@
+export const READ_IMAGEVIDEO_PERMISSIONS = 'ohos.permission.READ_IMAGEVIDEO'
+export const READ_MEDIA_PERMISSIONS = 'ohos.permission.READ_MEDIA'
+export const WRITE_MEDIA_PERMISSIONS = 'ohos.permission.WRITE_MEDIA'
+export const MEDIA_LOCATION_PERMISSIONS = 'ohos.permission.MEDIA_LOCATION'
+
+export const IMAGE_PERMISSION = [READ_IMAGEVIDEO_PERMISSIONS, READ_MEDIA_PERMISSIONS, WRITE_MEDIA_PERMISSIONS, MEDIA_LOCATION_PERMISSIONS]

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

@@ -0,0 +1,12 @@
+type GeneralCallback = (res: any) => void
+
+export type FunctionType = (...args: any) => any
+
+export interface IAsyncParams<T extends FunctionType = GeneralCallback> {
+  /** 接口调用结束的回调函数（调用成功、失败都会执行） */
+  complete?: GeneralCallback
+  /** 接口调用失败的回调函数 */
+  fail?: GeneralCallback
+  /** 接口调用成功的回调函数 */
+  success?: T
+}

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

@@ -0,0 +1,104 @@
+import _display from '@ohos.display'
+import { Current } from '@tarojs/runtime'
+import { isFunction } from '@tarojs/shared'
+
+const defaultDesignWidth = 750
+const defaultDesignRatio: Record<string | number, number> = {
+  640: 2.34 / 2,
+  750: 1,
+  828: 1.81 / 2
+}
+const defaultBaseFontSize = 20
+const defaultUnitPrecision = 5
+const defaultTargetUnit = 'vp'
+
+export function initPxTransform ({
+  designWidth = defaultDesignWidth,
+  deviceRatio = defaultDesignRatio,
+  baseFontSize = defaultBaseFontSize,
+  unitPrecision = defaultUnitPrecision,
+  targetUnit = defaultTargetUnit
+}) {
+  const taro = Current.taro
+
+  if (taro) {
+    taro.config ||= {}
+    const config = taro.config
+    config.designWidth = designWidth
+    config.deviceRatio = deviceRatio
+    config.baseFontSize = baseFontSize
+    config.targetUnit = targetUnit
+    config.unitPrecision = unitPrecision
+  }
+}
+
+const display = _display.getDefaultDisplaySync()
+
+const displayWidth = display.width
+const displayHeight = display.height
+let ratioCache: number | false = false
+let designWidthFunc: (input: number) => number
+let designWidth = defaultDesignWidth
+function getRatio (value: number, customDesignWidth?: number) {
+  // Note: 提前调用 display 可能无法获取正确值
+  if (ratioCache === false || typeof customDesignWidth !== 'undefined') {
+    const config = Current.taro?.config || {}
+    if (!isFunction(designWidthFunc)) {
+      designWidthFunc = isFunction(config.designWidth)
+        ? config.designWidth
+        : () => config.designWidth
+      designWidth = designWidthFunc(value) || defaultDesignWidth
+    }
+    let displayWidth_ = displayWidth
+    if (px2vp(displayWidth) >= 600 && px2vp(displayHeight) <= (600 * 10.8)) {
+      displayWidth_ = displayWidth_ / 2
+    }
+
+    ratioCache = displayWidth_ / (customDesignWidth || designWidth)
+  }
+
+  return ratioCache
+}
+
+// Note: 设置为 style 单位时会自动完成设计稿转换，设计开发者调用 API 时也许抹平差异，例如 pageScrollTo[option.offsetTop]
+export function pxTransformHelper (size: number, unit?: string, isNumber = false): number | string {
+  const config = Current.taro?.config || {}
+  const targetUnit = unit || config.targetUnit || defaultTargetUnit
+
+  if (targetUnit === 'PX') {
+    return px2vp(size * display.scaledDensity) + 'vp'
+  }
+  const ratio = getRatio(size)
+  let val = size * ratio
+
+  switch (targetUnit) {
+    case 'vp':
+      // Note: 在应用创建前调用无效
+      val = px2vp(val)
+      break
+    default:
+  }
+  return isNumber ? val : val + targetUnit
+}
+
+export function pxTransform (size: number, designWidth?: number): number | string {
+  const config = Current.taro?.config || {}
+  const targetUnit = config.targetUnit || defaultTargetUnit
+
+  if (typeof designWidth !== 'undefined') {
+    // 允许动态改变
+    const ratio = getRatio(size, designWidth)
+    let val = size * ratio
+    val = px2vp(val)
+    return val
+  }
+
+  const val = size
+  switch (targetUnit) {
+    case 'vp':
+      return pxTransformHelper(size, 'vp')
+    default:
+      // NOTE: 鸿蒙环境下 style 会自动完成设计稿转换，无需在方法内二次调整
+  }
+  return val + targetUnit
+}

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

@@ -0,0 +1,87 @@
+import { isArray, isNull, isObject, isString } from '@tarojs/shared'
+
+type JSTypes = 'string' | 'number' | 'boolean' | 'undefined' | 'null' | 'bigint' | 'symbol' | 'array' | 'object' | 'function'
+
+type NormalParamSchema = string[]
+type ObjectParamSchema = Record<string, string>
+
+type Schema = NormalParamSchema | ObjectParamSchema
+
+interface ValidateParams {
+  <T>(name: string, params: any, schema: Schema): asserts params is T
+}
+
+export function shouldBeObject (target: unknown) {
+  if (target && typeof target === 'object') return { flag: true }
+  return {
+    flag: false,
+    msg: getParameterError({
+      correct: 'Object',
+      wrong: target
+    })
+  }
+}
+
+interface IParameterErrorParam {
+  name?: string
+  para?: string
+  correct?: string
+  wrong?: unknown
+  level?: 'warn' | 'error' | 'log' | 'info' | 'debug'
+}
+export function getParameterError ({ name = '', para, correct, wrong, level = 'error' }: IParameterErrorParam) {
+  const parameter = para ? `parameter.${para}` : 'parameter'
+  const errorType = upperCaseFirstLetter(wrong === null ? 'Null' : typeof wrong)
+  return `${name ? `${name}:fail ` : ''}parameter ${level}: ${parameter} should be ${correct} instead of ${errorType}`
+}
+
+export function upperCaseFirstLetter (string: string): string {
+  if (!isString(string)) return string
+  string = string.replace(/^./, match => match.toUpperCase())
+  return string
+}
+
+function getType (param: string): JSTypes {
+  if (isNull(param)) {
+    return 'null'
+  } else if (isArray(param)) {
+    return 'array'
+  } else {
+    return typeof param
+  }
+}
+
+export function assertType (target: any, type: string, methodName: string, paramName?: string) {
+  const correct = upperCaseFirstLetter(type)
+  if (correct !== upperCaseFirstLetter(getType(target))) {
+    const err = getParameterError({ name: methodName, para: paramName, correct, wrong: target })
+    throw new Error(err)
+  }
+}
+
+/**
+ * 用于校验方法的参数类型
+ * @param name 方法名称
+ * @param params [array|object] 当前参数
+ * @param schema [array|object] 参数类型规范
+ * @example
+ * ```js
+ * // 例子一：
+ * validateParams(methodA, [key], [string])
+ * // 例子二：
+ * validateParams(methodB, { key: 123 }, { key: number })
+ * ```
+ * @todo 校验可选参数
+ */
+export const validateParams: ValidateParams = function (name, params, schema) {
+  if (isArray(schema) && isString(schema[0])) {
+    schema.forEach((correctType, index) => assertType(params[index], correctType, name, `[${index}]`))
+  } else if (isObject(schema)) {
+    const optionsSchema = schema
+
+    assertType(params, 'object', name)
+    for (const key in optionsSchema) {
+      assertType(params[key], optionsSchema[key], name, key)
+    }
+  }
+}

package/dist/runtime/apis/worker/index.ts

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

package/dist/runtime/apis/wxml/index.ts

@@ -0,0 +1,17 @@
+import { temporarilyNotSupport } from '../utils'
+import { IntersectionObserver } from './intersectionObserver'
+import { SelectorQuery } from './selectorQuery'
+
+import type Taro from '@tarojs/taro/types'
+
+export const createSelectorQuery = () => {
+  return new SelectorQuery()
+}
+
+export const createIntersectionObserver: typeof Taro.createIntersectionObserver = (component, options) => {
+  return new IntersectionObserver(component, options)
+}
+
+export const createMediaQueryObserver = /* @__PURE__ */ temporarilyNotSupport('createMediaQueryObserver')
+
+export { IntersectionObserver }

package/dist/runtime/apis/wxml/intersectionObserver.ts

@@ -0,0 +1,100 @@
+import { Current, document, getPageScrollerOrNode, TaroElement } from '@tarojs/runtime'
+
+import { temporarilyNotSupport } from '../utils'
+
+export class IntersectionObserver {
+  // 自定义组件实例
+  private _component: any
+  // 监听的nodes
+  private _observerNodes: TaroElement[] | TaroElement | null
+  // 选项
+  private _timer
+
+  _options = {
+    thresholds: [0],
+    initialRatio: 0,
+    observeAll: false,
+  }
+
+  _viewportMargins = {
+    left: 0,
+    top: 0,
+    right: 0,
+    bottom: 0
+  }
+
+  constructor(component, options = {}) {
+    const taro = Current.taro
+    const page = taro.getCurrentInstance().page
+
+    // 兼容小程序原本的 getCurrentInstance()?.page 的写法
+    if (component && component.page === page && component.node) {
+      this._component = component.node
+    } else {
+      this._component = component || getPageScrollerOrNode(page?.node, page)
+    }
+
+    Object.assign(this._options, options)
+  }
+
+  disconnect () {
+    if (this._observerNodes && this._component) {
+      if (this._observerNodes instanceof Array) {
+        this._observerNodes.forEach((n) => {
+          Current.nativeModule.disconnectObserve(n)
+        })
+      } else {
+        Current.nativeModule.disconnectObserve(this._observerNodes)
+      }
+
+      if (this._timer) {
+        clearTimeout(this._timer)
+      }
+
+      this._observerNodes = null
+    }
+  }
+
+  observe (targetSelector, callback) {
+    if (!this._component) return
+
+    const { observeAll, thresholds, initialRatio } = this._options
+    const querySelectName = observeAll ? 'querySelectorAll' : 'querySelector'
+    const isComponentHaveSelectFunction = !!this._component[querySelectName]
+    const querySelector = isComponentHaveSelectFunction ? this._component[querySelectName].bind(this._component) : document[querySelectName].bind(document)
+    const node = querySelector(targetSelector)
+    this._observerNodes = node
+
+    if (!node) {
+      callback({
+        errMsg: 'IntersectionObserver.observe:fail cannot find the node for selector.'
+      })
+      return
+    }
+
+    const list = node instanceof Array ? node : [node]
+    list.forEach((item) => {
+      Current.nativeModule.createObserve(item, this._viewportMargins, thresholds, initialRatio, (data) => {
+        this._timer = setTimeout(() => {
+          callback({
+            id: item.id,
+            dataset: item.dataset,
+            time: new Date().getTime(),
+            ...data
+          })
+        }, 20)
+      })
+    })
+  }
+
+  relativeTo () {
+    temporarilyNotSupport('relativeTo')()
+    return this
+  }
+
+  relativeToViewport (option) {
+    this._viewportMargins = Object.assign(this._viewportMargins, option)
+
+    return this
+  }
+}

package/dist/runtime/apis/wxml/nodesRef.ts

@@ -0,0 +1,58 @@
+import { SelectorQuery } from './selectorQuery'
+
+import type Taro from '@tarojs/taro/types'
+
+export class NodesRef implements Taro.NodesRef {
+  _component?: any
+  _selector: string
+  _selectorQuery: SelectorQuery
+  _single: boolean
+
+  constructor (selector: string, querySelectorQuery: SelectorQuery, single: boolean) {
+    this._component = querySelectorQuery._component
+    this._selector = selector
+    this._selectorQuery = querySelectorQuery
+    this._single = single
+  }
+
+  context (cb) {
+    const { _selector, _component, _single, _selectorQuery } = this
+    _selectorQuery._push(_selector, _component, _single, { context: !0 }, cb)
+    return _selectorQuery
+  }
+
+  node (cb?: Taro.NodesRef.NodeCallback) {
+    const { _selector, _component, _single, _selectorQuery } = this
+    _selectorQuery._push(_selector, _component, _single, { nodeCanvasType: !0, node: !0 }, cb)
+    return _selectorQuery
+  }
+
+  boundingClientRect (cb?: Taro.NodesRef.BoundingClientRectCallback) {
+    const { _selector, _component, _single, _selectorQuery } = this
+    _selectorQuery._push(_selector, _component, _single, { id: !0, dataset: !0, rect: !0, size: !0 }, cb)
+    return _selectorQuery
+  }
+
+  scrollOffset (cb) {
+    const { _selector, _component, _single, _selectorQuery } = this
+    _selectorQuery._push(_selector, _component, _single, { id: !0, dataset: !0, scrollOffset: !0 }, cb)
+    return _selectorQuery
+  }
+
+  fields (fields: Taro.NodesRef.Fields & { nodeCanvasType: Taro.NodesRef.Fields['node'] }, cb?: Taro.NodesRef.FieldsCallback) {
+    const { _selector, _component, _single, _selectorQuery } = this
+    const { id, dataset, rect, size, scrollOffset, properties = [], computedStyle = [], node, nodeCanvasType } = fields
+    _selectorQuery._push(_selector, _component, _single, {
+      id,
+      dataset,
+      rect,
+      size,
+      scrollOffset,
+      properties,
+      computedStyle,
+      node,
+      nodeCanvasType,
+    }, cb)
+    return _selectorQuery
+  }
+}