@tarojs/shared 3.5.0-beta.0 → 3.5.0-beta.1

package/dist/event-emitter.d.ts

@@ -0,0 +1,27 @@
+declare type Callback1<T1> = (arg1: T1) => any;
+declare type Callback2<T1, T2> = (arg1: T1, arg2: T2) => any;
+declare type Callback3<T1, T2, T3> = (arg1: T1, arg2: T2, arg3: T3) => any;
+declare type Callback4<T1, T2, T3, T4> = (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => any;
+declare type Callback5<T1, T2, T3, T4, T5> = (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => any;
+declare type Callback6Rest<T1, T2, T3, T4, T5, T6> = (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, ...rest: any[]) => any;
+export declare class Events {
+    protected callbacks?: Record<string, unknown>;
+    static eventSplitter: RegExp;
+    constructor(opts?: any);
+    on<T>(event: string, callback: Callback1<T>, context?: any): this;
+    on<T1, T2>(event: string, callback: Callback2<T1, T2>, context?: any): this;
+    on<T1, T2, T3>(event: string, callback: Callback3<T1, T2, T3>, context?: any): this;
+    on<T1, T2, T3, T4>(event: string, callback: Callback4<T1, T2, T3, T4>, comtext: any): this;
+    on<T1, T2, T3, T4, T5>(event: string, callback: Callback5<T1, T2, T3, T4, T5>, context?: any): this;
+    on<T1, T2, T3, T4, T5, T6>(event: string, callback: Callback6Rest<T1, T2, T3, T4, T5, T6>, context?: any): this;
+    once(events: any, callback: any, context: any): this;
+    off(events: any, callback?: any, context?: any): this;
+    trigger(event: string): any;
+    trigger<T1>(event: string, arg: T1): any;
+    trigger<T1, T2>(event: string, arg1: T1, arg2: T2): any;
+    trigger<T1, T2, T3>(event: string, arg1: T1, arg2: T2, arg3: T3): any;
+    trigger<T1, T2, T3, T4>(event: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4): any;
+    trigger<T1, T2, T3, T4, T5>(event: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): any;
+    trigger<T1, T2, T3, T4, T5, T6>(event: string, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, ...rest: any[]): any;
+}
+export {};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './components';
+export * from './event-emitter';
 export * from './is';
 export * from './native-apis';
+export * from './runtime-hooks';
 export { Shortcuts } from './shortcuts';
 export * from './utils';

package/dist/index.js

@@ -338,6 +338,87 @@ const nestElements = new Map([
     ['swiper-item', 4]
 ]);
 
+class Events {
+    constructor(opts) {
+        var _a;
+        this.callbacks = (_a = opts === null || opts === void 0 ? void 0 : opts.callbacks) !== null && _a !== void 0 ? _a : {};
+    }
+    on(eventName, callback, context) {
+        let event, node, tail, list;
+        if (!callback) {
+            return this;
+        }
+        eventName = eventName.split(Events.eventSplitter);
+        this.callbacks || (this.callbacks = {});
+        const calls = this.callbacks;
+        while ((event = eventName.shift())) {
+            list = calls[event];
+            node = list ? list.tail : {};
+            node.next = tail = {};
+            node.context = context;
+            node.callback = callback;
+            calls[event] = {
+                tail,
+                next: list ? list.next : node
+            };
+        }
+        return this;
+    }
+    once(events, callback, context) {
+        const wrapper = (...args) => {
+            callback.apply(this, args);
+            this.off(events, wrapper, context);
+        };
+        this.on(events, wrapper, context);
+        return this;
+    }
+    off(events, callback, context) {
+        let event, calls, node, tail, cb, ctx;
+        if (!(calls = this.callbacks)) {
+            return this;
+        }
+        if (!(events || callback || context)) {
+            delete this.callbacks;
+            return this;
+        }
+        events = events ? events.split(Events.eventSplitter) : Object.keys(calls);
+        while ((event = events.shift())) {
+            node = calls[event];
+            delete calls[event];
+            if (!node || !(callback || context)) {
+                continue;
+            }
+            tail = node.tail;
+            while ((node = node.next) !== tail) {
+                cb = node.callback;
+                ctx = node.context;
+                if ((callback && cb !== callback) || (context && ctx !== context)) {
+                    this.on(event, cb, ctx);
+                }
+            }
+        }
+        return this;
+    }
+    trigger(events) {
+        let event, node, calls, tail;
+        if (!(calls = this.callbacks)) {
+            return this;
+        }
+        events = events.split(Events.eventSplitter);
+        const rest = [].slice.call(arguments, 1);
+        while ((event = events.shift())) {
+            if ((node = calls[event])) {
+                tail = node.tail;
+                while ((node = node.next) !== tail) {
+                    node.callback.apply(node.context || this, rest);
+                }
+            }
+        }
+        return this;
+    }
+}
+Events.eventSplitter = /\s+/;
+
 function isString(o) {
     return typeof o === 'string';
 }
@@ -364,10 +445,161 @@ function isBooleanStringLiteral(o) {
 }
 const isArray = Array.isArray;
 
+exports.HOOK_TYPE = void 0;
+(function (HOOK_TYPE) {
+    HOOK_TYPE[HOOK_TYPE["SINGLE"] = 0] = "SINGLE";
+    HOOK_TYPE[HOOK_TYPE["MULTI"] = 1] = "MULTI";
+    HOOK_TYPE[HOOK_TYPE["WATERFALL"] = 2] = "WATERFALL";
+})(exports.HOOK_TYPE || (exports.HOOK_TYPE = {}));
+const defaultMiniLifecycle = {
+    app: [
+        'onLaunch',
+        'onShow',
+        'onHide'
+    ],
+    page: [
+        'onLoad',
+        'onUnload',
+        'onReady',
+        'onShow',
+        'onHide',
+        [
+            'onPullDownRefresh',
+            'onReachBottom',
+            'onPageScroll',
+            'onResize',
+            'onTabItemTap',
+            'onTitleClick',
+            'onOptionMenuClick',
+            'onPopMenuClick',
+            'onPullIntercept',
+            'onAddToFavorites'
+        ]
+    ]
+};
+function TaroHook(type, initial) {
+    return {
+        type,
+        initial: initial || null
+    };
+}
+class TaroHooks extends Events {
+    constructor(hooks, opts) {
+        super(opts);
+        this.hooks = hooks;
+        for (const hookName in hooks) {
+            const { initial } = hooks[hookName];
+            if (isFunction(initial)) {
+                this.on(hookName, initial);
+            }
+        }
+    }
+    tapOneOrMany(hookName, callback) {
+        const list = isFunction(callback) ? [callback] : callback;
+        list.forEach(cb => this.on(hookName, cb));
+    }
+    tap(hookName, callback) {
+        const hooks = this.hooks;
+        const { type, initial } = hooks[hookName];
+        if (type === exports.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(hookName, ...rest) {
+        var _a;
+        const hook = this.hooks[hookName];
+        if (!hook)
+            return;
+        const { type } = hook;
+        const calls = this.callbacks;
+        if (!calls)
+            return;
+        const list = calls[hookName];
+        if (list) {
+            const tail = list.tail;
+            let node = list.next;
+            let args = rest;
+            let res;
+            while (node !== tail) {
+                res = (_a = node.callback) === null || _a === void 0 ? void 0 : _a.apply(node.context || this, args);
+                if (type === exports.HOOK_TYPE.WATERFALL) {
+                    const params = [res];
+                    args = params;
+                }
+                node = node.next;
+            }
+            return res;
+        }
+    }
+    isExist(hookName) {
+        var _a;
+        return Boolean((_a = this.callbacks) === null || _a === void 0 ? void 0 : _a[hookName]);
+    }
+}
+const hooks = new TaroHooks({
+    getMiniLifecycle: TaroHook(exports.HOOK_TYPE.SINGLE, defaultConfig => defaultConfig),
+    getMiniLifecycleImpl: TaroHook(exports.HOOK_TYPE.SINGLE, function () {
+        return this.call('getMiniLifecycle', defaultMiniLifecycle);
+    }),
+    getLifecycle: TaroHook(exports.HOOK_TYPE.SINGLE, (instance, lifecycle) => instance[lifecycle]),
+    getPathIndex: TaroHook(exports.HOOK_TYPE.SINGLE, indexOfNode => `[${indexOfNode}]`),
+    getEventCenter: TaroHook(exports.HOOK_TYPE.SINGLE, Events => new Events()),
+    isBubbleEvents: TaroHook(exports.HOOK_TYPE.SINGLE, eventName => {
+        /**
+         * 支持冒泡的事件, 除 支付宝小程序外，其余的可冒泡事件都和微信保持一致
+         * 详见 见 https://developers.weixin.qq.com/miniprogram/dev/framework/view/wxml/event.html
+         */
+        const BUBBLE_EVENTS = new Set([
+            'touchstart',
+            'touchmove',
+            'touchcancel',
+            'touchend',
+            'touchforcechange',
+            'tap',
+            'longpress',
+            'longtap',
+            'transitionend',
+            'animationstart',
+            'animationiteration',
+            'animationend'
+        ]);
+        return BUBBLE_EVENTS.has(eventName);
+    }),
+    getSpecialNodes: TaroHook(exports.HOOK_TYPE.SINGLE, () => ['view', 'text', 'image']),
+    onRemoveAttribute: TaroHook(exports.HOOK_TYPE.SINGLE),
+    batchedEventUpdates: TaroHook(exports.HOOK_TYPE.SINGLE),
+    mergePageInstance: TaroHook(exports.HOOK_TYPE.SINGLE),
+    modifyPageObject: TaroHook(exports.HOOK_TYPE.SINGLE),
+    createPullDownComponent: TaroHook(exports.HOOK_TYPE.SINGLE),
+    getDOMNode: TaroHook(exports.HOOK_TYPE.SINGLE),
+    modifyHydrateData: TaroHook(exports.HOOK_TYPE.SINGLE),
+    modifySetAttrPayload: TaroHook(exports.HOOK_TYPE.SINGLE),
+    modifyRmAttrPayload: TaroHook(exports.HOOK_TYPE.SINGLE),
+    onAddEvent: TaroHook(exports.HOOK_TYPE.SINGLE),
+    modifyMpEvent: TaroHook(exports.HOOK_TYPE.MULTI),
+    modifyMpEventImpl: TaroHook(exports.HOOK_TYPE.SINGLE, function (e) {
+        try {
+            // 有些小程序的事件对象的某些属性只读
+            this.call('modifyMpEvent', e);
+        }
+        catch (error) {
+            console.warn('[Taro modifyMpEvent hook Error]: ', error);
+        }
+    }),
+    modifyTaroEvent: TaroHook(exports.HOOK_TYPE.MULTI),
+    modifyDispatchEvent: TaroHook(exports.HOOK_TYPE.MULTI),
+    initNativeApi: TaroHook(exports.HOOK_TYPE.MULTI),
+    patchElement: TaroHook(exports.HOOK_TYPE.MULTI)
+});
+
 const EMPTY_OBJ = {};
 const EMPTY_ARR = [];
 const noop = (..._) => { };
-const defaultReconciler = Object.create(null);
 /**
  * box creates a boxed value.
  *
@@ -491,15 +723,11 @@ function mergeInternalComponents(components) {
         }
     });
 }
-function mergeReconciler(hostConfig) {
-    Object.keys(hostConfig).forEach(key => {
-        const value = hostConfig[key];
-        const raw = defaultReconciler[key];
-        defaultReconciler[key] = !raw
-            ? value
-            : (isArray(raw)
-                ? raw.concat(value)
-                : [raw, value]);
+function mergeReconciler(hostConfig, hooksForTest) {
+    const obj = hooksForTest || hooks;
+    const keys = Object.keys(hostConfig);
+    keys.forEach(key => {
+        obj.tap(key, hostConfig[key]);
     });
 }
 function unsupport(api) {
@@ -874,6 +1102,9 @@ exports.Shortcuts = void 0;
 
 exports.EMPTY_ARR = EMPTY_ARR;
 exports.EMPTY_OBJ = EMPTY_OBJ;
+exports.Events = Events;
+exports.TaroHook = TaroHook;
+exports.TaroHooks = TaroHooks;
 exports.animation = animation;
 exports.box = box;
 exports.cacheDataGet = cacheDataGet;
@@ -881,11 +1112,11 @@ exports.cacheDataHas = cacheDataHas;
 exports.cacheDataSet = cacheDataSet;
 exports.capitalize = capitalize;
 exports.controlledComponent = controlledComponent;
-exports.defaultReconciler = defaultReconciler;
 exports.ensure = ensure;
 exports.focusComponents = focusComponents;
 exports.getUniqueKey = getUniqueKey;
 exports.hasOwn = hasOwn;
+exports.hooks = hooks;
 exports.indent = indent;
 exports.internalComponents = internalComponents;
 exports.isArray = isArray;