增加eventCenter，迁移Taro API中eventCenter的最小实现 (#48)

Author: EvenZhu

packages/nextjs/taro/src/index.ts

@@ -169,6 +169,8 @@ import {uploadFile} from './network/upload'
 
 import {getLocation} from './location'
 
+import {eventCenter} from './shared'
+
 import {initTaroApp, TaroPage} from './internal'
 
 export {
@@ -306,6 +308,8 @@ export {
 
     getMenuButtonBoundingClientRect,
 
+    eventCenter,
+
     initTaroApp,
     TaroPage
 }
@@ -445,6 +449,8 @@ export default {
 
     getMenuButtonBoundingClientRect,
 
+    eventCenter,
+
     initTaroApp,
     TaroPage
 }

packages/nextjs/taro/src/shared/event-emitter.ts

@@ -0,0 +1,101 @@
+type EventName = string | symbol
+type EventCallbacks = Record<EventName, Record<'next' | 'tail', unknown>>
+
+export class Events {
+  protected callbacks?: EventCallbacks
+  static eventSplitter = ',' // Note: Harmony ACE API 8 开发板不支持使用正则 split 字符串 /\s+/
+
+  constructor (opts?) {
+    this.callbacks = opts?.callbacks ?? {}
+  }
+
+  on (eventName: EventName, callback: (...args: any[]) => void, context?: any): this {
+    let event: EventName | undefined, tail, _eventName: EventName[]
+    if (!callback) {
+      return this
+    }
+    if (typeof eventName === 'symbol') {
+      _eventName = [eventName]
+    } else {
+      _eventName = eventName.split(Events.eventSplitter)
+    }
+    this.callbacks ||= {}
+    const calls = this.callbacks
+    while ((event = _eventName.shift())) {
+      const list = calls[event]
+      const node: any = list ? list.tail : {}
+      node.next = tail = {}
+      node.context = context
+      node.callback = callback
+      calls[event] = {
+        tail,
+        next: list ? list.next : node
+      }
+    }
+    return this
+  }
+
+  once (events: EventName, callback: (...r: any[]) => void, context?: any): this {
+    const wrapper = (...args: any[]) => {
+      callback.apply(this, args)
+      this.off(events, wrapper, context)
+    }
+
+    this.on(events, wrapper, context)
+
+    return this
+  }
+
+  off (events?: EventName, callback?: (...args: any[]) => void, context?: any) {
+    let event: EventName | undefined, calls: EventCallbacks | undefined, _events: EventName[]
+    if (!(calls = this.callbacks)) {
+      return this
+    }
+    if (!(events || callback || context)) {
+      delete this.callbacks
+      return this
+    }
+    if (typeof events === 'symbol') {
+      _events = [events]
+    } else {
+      _events = events ? events.split(Events.eventSplitter) : Object.keys(calls)
+    }
+    while ((event = _events.shift())) {
+      let node: any = calls[event]
+      delete calls[event]
+      if (!node || !(callback || context)) {
+        continue
+      }
+      const tail = node.tail
+      while ((node = node.next) !== tail) {
+        const cb = node.callback
+        const ctx = node.context
+        if ((callback && cb !== callback) || (context && ctx !== context)) {
+          this.on(event, cb, ctx)
+        }
+      }
+    }
+    return this
+  }
+
+  trigger (events: EventName, ...args: any[]) {
+    let event: EventName | undefined, node, calls: EventCallbacks | undefined, _events: EventName[]
+    if (!(calls = this.callbacks)) {
+      return this
+    }
+    if (typeof events === 'symbol') {
+      _events = [events]
+    } else {
+      _events = events.split(Events.eventSplitter)
+    }
+    while ((event = _events.shift())) {
+      if ((node = calls[event])) {
+        const tail = node.tail
+        while ((node = node.next) !== tail) {
+          node.callback.apply(node.context || this, args)
+        }
+      }
+    }
+    return this
+  }
+}

packages/nextjs/taro/src/shared/hooks.ts

@@ -0,0 +1,102 @@
+import { Events } from "./event-emitter"
+import { isFunction } from './is'
+
+// Note: @tarojs/runtime 不依赖 @tarojs/taro, 所以不能改为从 @tarojs/taro 引入 (可能导致循环依赖)
+type TFunc = (...args: any[]) => any
+
+export enum HOOK_TYPE {
+  SINGLE,
+  MULTI,
+  WATERFALL
+}
+
+interface Hook {
+  type: HOOK_TYPE
+  initial?: TFunc | null
+}
+
+interface Node {
+  next: Node
+  context?: any
+  callback?: TFunc
+}
+
+export function TaroHook (type: HOOK_TYPE, initial?: TFunc): Hook {
+  return {
+    type,
+    initial: initial || null
+  }
+}
+
+export class TaroHooks<T extends Record<string, TFunc> = any> extends Events {
+  hooks: Record<keyof T, Hook>
+
+  constructor (hooks: Record<keyof T, Hook>, opts?) {
+    super(opts)
+    this.hooks = hooks
+    for (const hookName in hooks) {
+      const { initial } = hooks[hookName]
+      if (isFunction(initial)) {
+        this.on(hookName, initial)
+      }
+    }
+  }
+
+  private tapOneOrMany<K extends Extract<keyof T, string>> (hookName: K, callback: T[K] | T[K][]) {
+    const list = isFunction(callback) ? [callback] : callback
+    list.forEach(cb => this.on(hookName, cb))
+  }
+
+  tap<K extends Extract<keyof T, string>> (hookName: K, callback: T[K] | T[K][]) {
+    const hooks = this.hooks
+    const { type, initial } = hooks[hookName]
+    if (type === HOOK_TYPE.SINGLE) {
+      this.off(hookName)
+      this.on(hookName, isFunction(callback) ? callback : callback[callback.length - 1])
+    } else {
+      initial && this.off(hookName, initial)
+      this.tapOneOrMany(hookName, callback)
+    }
+  }
+
+  call<K extends Extract<keyof T, string>> (hookName: K, ...rest: Parameters<T[K]>): ReturnType<T[K]> | undefined {
+    const hook = this.hooks[hookName]
+    if (!hook) return
+
+    const { type } = hook
+
+    const calls = this.callbacks
+    if (!calls) return
+
+    const list = calls[hookName] as { tail: Node, next: Node }
+
+    if (list) {
+      const tail = list.tail
+      let node: Node = list.next
+      let args = rest
+      let res
+
+      while (node !== tail) {
+        res = node.callback?.apply(node.context || this, args)
+        if (type === HOOK_TYPE.WATERFALL) {
+          const params: any = [res]
+          args = params
+        }
+        node = node.next
+      }
+      return res
+    }
+  }
+
+  isExist (hookName: string) {
+    return Boolean(this.callbacks?.[hookName])
+  }
+}
+
+type ITaroHooks = {
+    getEventCenter: (EventsClass: typeof Events) => Events
+}
+
+export const hooks = new TaroHooks<ITaroHooks>({
+    getEventCenter: TaroHook(HOOK_TYPE.SINGLE, Events => new Events())
+})

packages/nextjs/taro/src/shared/index.ts

@@ -0,0 +1,7 @@
+import { hooks } from './hooks'
+import { Events } from './event-emitter'
+
+const eventCenter = hooks.call('getEventCenter', Events)!
+
+export type EventsType = typeof Events
+export { eventCenter, Events }

packages/nextjs/taro/src/shared/is.ts

@@ -0,0 +1,38 @@
+export function isString (o: unknown): o is string {
+  return typeof o === 'string'
+}
+
+export function isUndefined (o: unknown): o is undefined {
+  return typeof o === 'undefined'
+}
+
+export function isNull (o: unknown): o is null {
+  return o === null
+}
+
+export function isObject<T> (o: unknown): o is T {
+  return o !== null && typeof o === 'object'
+}
+
+export function isBoolean (o: unknown): o is boolean {
+  return o === true || o === false
+}
+
+export function isFunction (o: unknown): o is (...args: any[]) => any {
+  return typeof o === 'function'
+}
+
+export function isNumber (o: unknown): o is number {
+  if (Number.isFinite) return Number.isFinite(o)
+  return typeof o === 'number'
+}
+
+export function isBooleanStringLiteral (o: unknown): o is string {
+  return o === 'true' || o === 'false' || o === '!0' || o === '!1'
+}
+
+export function isObjectStringLiteral (o: unknown): o is string {
+  return o === '{}'
+}
+
+export const isArray = Array.isArray