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

package/dist/apis/utils/index.ts

@@ -0,0 +1,85 @@
+import { eventCenter } from '@tarojs/runtime/dist/runtime.esm'
+
+import { ICallbackResult, MethodHandler } from './handler'
+
+import type { FunctionType, IAsyncParams } from './types'
+
+export * from './validate'
+export { noop } from '@tarojs/shared'
+
+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'
+    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/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/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/apis/wxml/IntersectionObserver.ts

@@ -0,0 +1,119 @@
+import Taro from '@tarojs/api'
+// @ts-ignore
+import { Current, disconnectEvent, findChildNodeWithDFS, getPageScrollerOrNode, setNodeEventCallbackAndTriggerComponentUpdate, TaroElement, VISIBLE_CHANGE_EVENT_NAME } from '@tarojs/runtime'
+
+import { temporarilyNotSupport } from '../utils'
+
+export class IntersectionObserver implements Taro.IntersectionObserver {
+  // 自定义组件实例
+  private _component: any
+  // 监听的nodes
+  private _observerNodes: TaroElement[] | TaroElement | null
+  // 选项
+  private _options = {
+    thresholds: [0],
+    initialRatio: 0,
+    observeAll: false
+  }
+
+  constructor(component: any, options: Taro.createIntersectionObserver.Option = {}) {
+    const taro = (Current as any).taro
+    const page = taro.getCurrentInstance().page
+    const currentPage = getPageScrollerOrNode(page.node, page)
+    this._component = component || currentPage
+    Object.assign(this._options, options)
+  }
+
+  public disconnect (): void {
+    if (this._observerNodes) {
+      if (this._observerNodes instanceof Array) {
+        this._observerNodes.forEach((n: TaroElement & any) => {
+          disconnectEvent(n, VISIBLE_CHANGE_EVENT_NAME)
+          if (n._instance) {
+            // @ts-ignore
+            n._instance?.nodeInfoMap?.[n._nid]?.thresholds = null
+          }
+        })
+      } else {
+        disconnectEvent(this._observerNodes, VISIBLE_CHANGE_EVENT_NAME)
+        // @ts-ignore
+        if (this._observerNodes._instance) {
+          // @ts-ignore
+          this._observerNodes._instance?.nodeInfoMap?.[this._observerNodes._nid]?.thresholds = null
+        }
+      }
+    }
+  }
+
+  public observe (targetSelector: string, callback: Taro.IntersectionObserver.ObserveCallback): void {
+    const { observeAll, thresholds } = this._options
+    const node = findChildNodeWithDFS(this._component, targetSelector, observeAll)
+    this._observerNodes = node
+
+
+    if (node) {
+      if (node instanceof Array) {
+        node.forEach(n => {
+          // @ts-ignore
+          n.awaitAppear.then(() => {
+            // @ts-ignore
+            n._instance?.nodeInfoMap?.[n._nid]?.thresholds = thresholds
+
+            setNodeEventCallbackAndTriggerComponentUpdate(n, VISIBLE_CHANGE_EVENT_NAME, (isVisible: boolean, currentRatio: number) => {
+              callback(this.handleResult(isVisible, currentRatio))
+            })
+          })
+        })
+      } else {
+        // @ts-ignore
+        node.awaitAppear.then(() => {
+          // @ts-ignore
+          node._instance?.nodeInfoMap?.[node._nid]?.thresholds = thresholds
+
+          setNodeEventCallbackAndTriggerComponentUpdate(node, VISIBLE_CHANGE_EVENT_NAME, (isVisible: boolean, currentRatio: number) => {
+            callback(this.handleResult(isVisible, currentRatio))
+          })
+        })
+      }
+    }
+  }
+
+  public relativeTo (): Taro.IntersectionObserver {
+    temporarilyNotSupport('relativeTo')()
+    return this
+  }
+
+  public relativeToViewport (): Taro.IntersectionObserver {
+    temporarilyNotSupport('relativeToViewport')()
+    return this
+  }
+
+  // @ts-ignore
+  private handleResult (isVisible: boolean, currentRatio: number): Taro.IntersectionObserver.ObserveCallbackResult {
+    const result = {
+      intersectionRatio: currentRatio,
+      // TODO 未做，等待能拿到element的info信息
+      boundingClientRect: {
+        left: 0,
+        right: 0,
+        top: 0,
+        bottom: 0,
+        height: 0,
+        width: 0
+      },
+      // TODO 未做，等待能拿到element和监听_component的info信息做运算
+      intersectionRect: {
+        left: 0,
+        right: 0,
+        top: 0,
+        bottom: 0,
+        height: 0,
+        width: 0
+      },
+      // TODO 未做，等待能拿到element和监听_component的info信息做运算
+      relativeRect: { left: 0, right: 0, top: 0, bottom: 0 },
+      time: new Date().getTime()
+    }
+    return result
+  }
+}

package/dist/apis/wxml/index.ts

@@ -0,0 +1,12 @@
+import Taro from '@tarojs/taro'
+
+import { IntersectionObserver } from './IntersectionObserver'
+import { SelectorQuery } from './selectorQuery'
+
+export const createSelectorQuery = () => {
+  return new SelectorQuery()
+}
+
+export const createIntersectionObserver: typeof Taro.createIntersectionObserver = (component, options) => {
+  return new IntersectionObserver(component, options)
+}

package/dist/apis/wxml/nodesRef.ts

@@ -0,0 +1,56 @@
+import Taro from '@tarojs/api'
+
+import { SelectorQuery } from './selectorQuery'
+
+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, cb?: Taro.NodesRef.FieldsCallback) {
+    const { _selector, _component, _single, _selectorQuery } = this
+    const { id, dataset, rect, size, scrollOffset, properties = [], computedStyle = [] } = fields
+    _selectorQuery._push(_selector, _component, _single, {
+      id,
+      dataset,
+      rect,
+      size,
+      scrollOffset,
+      properties,
+      computedStyle
+    }, cb)
+    return _selectorQuery
+  }
+}

package/dist/apis/wxml/selectorQuery.ts

@@ -0,0 +1,287 @@
+import { AREA_CHANGE_EVENT_NAME, Current, getPageScrollerOrNode, setNodeEventCallbackAndTriggerComponentUpdate } from '@tarojs/runtime'
+
+import { NodesRef } from './nodesRef'
+
+import type Taro from '@tarojs/api'
+
+interface ISelectorQueryQueue {
+  component: any
+  selector: string
+  single: boolean
+  fields
+}
+
+type TSelectorQueryQueueCallback = (res: ISelectorQueryQueue) => void
+
+let arr: any = []
+
+// 深度搜索 rootDom 下的所有节点，存放在 arr 中
+function traversalDFSDom (rootDom) {
+  if (!rootDom) return
+  arr.push(rootDom)
+
+  if (rootDom.childNodes.length === 0) return
+  for (let i = 0; i < rootDom.childNodes.length; i++) {
+    traversalDFSDom(rootDom.childNodes[i])
+  }
+}
+
+// 从 arr 中寻找所有符合 selector 的节点
+function parseHandler (selector, selectAll) {
+  const domList: any = []
+  if (arr.length === 0) return null
+
+  let selectedId, clsList
+  switch (selector.charAt(0)) {
+    case '#': // id selector
+      selectedId = selector.substring(1)
+      for (let i = 0; i < arr.length; i++) {
+        if (arr[i].id === selectedId) {
+          domList.push(arr[i])
+          if (!selectAll) {
+            break
+          }
+        }
+      }
+      break
+    case '.':
+      clsList = selector.split('.').filter((item) => item !== '')
+      if (clsList.length === 0) break
+
+      for (let i = 0; i < arr.length; i++) {
+        for (let j = 0; j < clsList.length; j++) {
+          if (arr[i].className?.includes(clsList[j])) {
+            domList.push(arr[i])
+            if (!selectAll) {
+              break
+            }
+          }
+        }
+      }
+      break
+    default:
+      console.warn('unSupport selector')
+      break
+  }
+  if (selectAll) {
+    return domList
+  } else if (domList.length > 0) {
+    return [domList[0]]
+  }
+  return []
+}
+
+// 从 TaroNode 里找到对应的 fields 内容
+function filter (fields, dom) {
+  if (!dom) return null
+  const {
+    id,
+    // dataset,
+    rect,
+    size,
+    scrollOffset,
+    properties = [],
+    computedStyle = [],
+    nodeCanvasType,
+    node,
+    context
+  } = fields
+  const res: any = {}
+
+  if (nodeCanvasType && node) { // Node节点获取处理
+    const typeName = dom.nodeName
+    res.node = {
+      id: dom.id,
+      $taroElement: dom
+    }
+    if (/^canvas/i.test(typeName)) {
+      // harmony todo canvas attr type
+      const canvasType = dom._attrs.type || ''
+      res.nodeCanvasType = canvasType
+      if (/^(2d|webgl)/i.test(canvasType) && dom) {
+        res.node = dom
+      } else {
+        res.node = null
+      }
+    } else {
+      // TODO https://developers.weixin.qq.com/miniprogram/dev/component/scroll-view.html
+      // if (/^taro-scroll-view-core/i.test(tagName))
+      res.nodeCanvasType = ''
+      res.node = dom
+    }
+    return res
+  }
+  if (context) {
+    // TODO: 暂未实现获取 context
+    // const typeName = dom.type
+    // if (/^video/i.test(typeName)) {
+    //   return { context: dom }
+    // } else if (/^canvas/i.test(typeName)) {
+    //   const type = dom.type || '2d'
+    //   // harmony todo canvas context
+    //   const ctx = dom?.getContext(type)
+    //   return { context: ctx }
+    // } else if (/^taro-live-player-core/i.test(typeName)) {
+    //   console.error('暂时不支持通过 NodesRef.context 获取 LivePlayerContext')
+    // } else if (/^taro-editor-core/i.test(typeName)) {
+    //   console.error('暂时不支持通过 NodesRef.context 获取 EditorContext')
+    // } else if (/^taro-map-core/i.test(typeName)) {
+    //   console.error('暂时不支持通过 NodesRef.context 获取 MapContext')
+    // }
+  }
+  if (id) res.id = dom.id
+
+  // TODO harmony dataset
+  // if (dataset) res.dataset = Object.assign({}, dom.dataset)
+
+  if (rect || size) {
+    const id = dom?._nid
+    const { areaInfo } = dom?._instance?.nodeInfoMap?.[id] || {}
+
+    if (areaInfo) {
+      if (rect) {
+        res.top = vp2px(areaInfo.globalPosition.y)
+        res.left = vp2px(areaInfo.globalPosition.x)
+        res.right = vp2px(areaInfo.globalPosition.x + areaInfo.width)
+        res.bottom = vp2px(areaInfo.globalPosition.y + areaInfo.height)
+      }
+
+      if (size) {
+        res.width = vp2px(areaInfo.width)
+        res.height = vp2px(areaInfo.height)
+      }
+    }
+  }
+  if (scrollOffset) {
+    const scroller = dom._instance.scroller
+
+    if (scroller) {
+      const { xOffset, yOffset } = scroller.currentOffset()
+
+      res.scrollLeft = vp2px(xOffset)
+      res.scrollTop = vp2px(yOffset)
+    }
+  }
+  if (properties.length) {
+    properties.forEach(prop => {
+      const attrs = dom._attrs
+      if (attrs[prop]) res[prop] = attrs[prop]
+    })
+  }
+  if (computedStyle.length) {
+    const styles = dom._st
+    computedStyle.forEach(key => {
+      const value = styles[key]
+      if (value) res[key] = value
+    })
+  }
+  return res
+}
+
+function querySelector (selector, selectAll) {
+  if (typeof selector === 'string') {
+    return parseHandler(selector, selectAll)
+  }
+  return null
+}
+
+function queryBat (queue, cb) {
+  const result: any = []
+  const taro = (Current as any).taro
+  const page = taro.getCurrentInstance().page
+  const element = getPageScrollerOrNode(page.node, page)
+
+  if (element == null) return null
+
+  arr = []
+  traversalDFSDom(element)
+  queue.forEach(item => {
+    const { selector, single, fields } = item
+    const nodeList = querySelector(selector, !single)
+
+    result.push(nodeList.map(dom => {
+      // eslint-disable-next-line no-async-promise-executor
+      return new Promise(async resolve => {
+        await setNodeEventCallbackAndTriggerComponentUpdate(dom, AREA_CHANGE_EVENT_NAME, null, true)
+
+        resolve(filter(fields, dom))
+      })
+    }))
+  })
+
+  Promise.all(result.map(item => {
+    return Promise.all(item)
+  })).then(data => {
+    cb(data)
+  })
+}
+
+export class SelectorQuery implements Taro.SelectorQuery {
+  _queue: ISelectorQueryQueue[]
+  _queueCb: (TSelectorQueryQueueCallback | null)[]
+  _component?: any
+
+  constructor () {
+    this._queue = []
+    this._queueCb = []
+    // this._component
+  }
+
+  /**
+   * 设置选择器的选取范围
+   * @param component 指定组件
+   * @return selectQuery 返回查询对象
+   */
+  in = (_: any) => {
+    this._component = null
+    console.warn('暂不支持 in 操作')
+    // this._component = component
+    return this
+  }
+
+  /**
+   * 在当前页面下选择第一个匹配选择器selector的节点
+   * @param selector
+   * @return nodesRef 返回一个NodesRef 对象实例，可以用于获取节点信息
+   */
+  select (selector: string) {
+    return new NodesRef(selector, this, true)
+  }
+
+  /**
+   * 在当前页面下选择匹配选择器selector的所有节点
+   * @param selector
+   */
+  selectAll (selector: string) {
+    return new NodesRef(selector, this, false)
+  }
+
+  /**
+   * 选择显示区域。可用于获取显示区域的尺寸、滚动位置等信息
+   */
+  selectViewport () {
+    return new NodesRef('.taro_page', this, true)
+  }
+
+  exec (cb?: (...args: any[]) => any) {
+    queryBat(this._queue, res => {
+      const _queueCb = this._queueCb
+      res.forEach((item, index) => {
+        const cb = _queueCb[index]
+        typeof cb === 'function' && cb.call(this, item)
+      })
+      typeof cb === 'function' && cb.call(this, res)
+    })
+    return this as any
+  }
+
+  _push (selector, component, single, fields, callback: Taro.NodesRef.FieldsCallback | null = null) {
+    this._queue.push({
+      component,
+      selector,
+      single,
+      fields
+    })
+    this._queueCb.push(callback)
+  }
+}