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

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

@@ -4,8 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const DEFAULT_EMPTY_ARRAY = '[]';
 const NO_DEFAULT_VALUE = '';
-const DEFAULT_TRUE = 'true';
-const DEFAULT_FALSE = 'false';
+const DEFAULT_TRUE = '!0';
+const DEFAULT_FALSE = '!1';
 const touchEvents = {
     bindTouchStart: NO_DEFAULT_VALUE,
     bindTouchMove: NO_DEFAULT_VALUE,
@@ -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.
  *
@@ -490,19 +722,55 @@ function mergeInternalComponents(components) {
             internalComponents[name] = components[name];
         }
     });
+    return internalComponents;
+}
+function getComponentsAlias(origin) {
+    const mapping = {};
+    const viewAttrs = origin.View;
+    const extraList = {
+        '#text': {},
+        StaticView: viewAttrs,
+        StaticImage: origin.Image,
+        StaticText: origin.Text,
+        PureView: viewAttrs,
+        CatchView: viewAttrs
+    };
+    origin = Object.assign(Object.assign({}, origin), extraList);
+    Object.keys(origin)
+        .sort((a, b) => {
+        const reg = /^(Static|Pure|Catch)*(View|Image|Text)$/;
+        if (reg.test(a)) {
+            return -1;
+        }
+        else if (reg.test(b)) {
+            return 1;
+        }
+        else {
+            return a >= b ? 1 : -1;
+        }
+    })
+        .forEach((key, num) => {
+        const obj = {
+            _num: String(num)
+        };
+        Object.keys(origin[key])
+            .filter(attr => !(/^bind/.test(attr)) && !['focus', 'blur'].includes(attr))
+            .sort()
+            .forEach((attr, index) => {
+            obj[toCamelCase(attr)] = 'p' + index;
+        });
+        mapping[toDashed(key)] = obj;
+    });
+    return mapping;
 }
-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) {
+function nonsupport(api) {
     return function () {
         console.warn(`小程序暂不支持 ${api}`);
     };
@@ -695,6 +963,7 @@ function getNormalRequest(global) {
             };
             requestTask = global.request(options);
         });
+        equipTaskMethodsIntoPromise(requestTask, p);
         p.abort = (cb) => {
             cb && cb();
             if (requestTask) {
@@ -745,7 +1014,7 @@ function processApis(taro, global, config = {}) {
                     options = transformResult.options;
                     // 新 key 可能不存在
                     if (!global.hasOwnProperty(key)) {
-                        return unsupport(key)();
+                        return nonsupport(key)();
                     }
                 }
                 let task = null;
@@ -782,13 +1051,8 @@ function processApis(taro, global, config = {}) {
                     }
                 });
                 // 给 promise 对象挂载属性
-                if (['request', 'uploadFile', 'downloadFile'].includes(key)) {
-                    const taskMethods = ['abort', 'onHeadersReceived', 'offHeadersReceived', 'onProgressUpdate', 'offProgressUpdate', 'onChunkReceived', 'offChunkReceived'];
-                    task && taskMethods.forEach(method => {
-                        if (method in task) {
-                            p[method] = task[method].bind(task);
-                        }
-                    });
+                if (['uploadFile', 'downloadFile'].includes(key)) {
+                    equipTaskMethodsIntoPromise(task, p);
                     p.progress = cb => {
                         task === null || task === void 0 ? void 0 : task.onProgressUpdate(cb);
                         return p;
@@ -810,7 +1074,7 @@ function processApis(taro, global, config = {}) {
             }
             // API 不存在
             if (!global.hasOwnProperty(platformKey)) {
-                taro[key] = unsupport(key);
+                taro[key] = nonsupport(key);
                 return;
             }
             if (isFunction(global[key])) {
@@ -837,14 +1101,14 @@ function processApis(taro, global, config = {}) {
  */
 function equipCommonApis(taro, global, apis = {}) {
     taro.canIUseWebp = getCanIUseWebp(taro);
-    taro.getCurrentPages = getCurrentPages || unsupport('getCurrentPages');
-    taro.getApp = getApp || unsupport('getApp');
+    taro.getCurrentPages = getCurrentPages || nonsupport('getCurrentPages');
+    taro.getApp = getApp || nonsupport('getApp');
     taro.env = global.env || {};
     try {
-        taro.requirePlugin = requirePlugin || unsupport('requirePlugin');
+        taro.requirePlugin = requirePlugin || nonsupport('requirePlugin');
     }
     catch (error) {
-        taro.requirePlugin = unsupport('requirePlugin');
+        taro.requirePlugin = nonsupport('requirePlugin');
     }
     // request & interceptors
     const request = apis.request || getNormalRequest(global);
@@ -856,6 +1120,21 @@ function equipCommonApis(taro, global, apis = {}) {
     taro.addInterceptor = link.addInterceptor.bind(link);
     taro.cleanInterceptors = link.cleanInterceptors.bind(link);
     taro.miniGlobal = taro.options.miniGlobal = global;
+}
+/**
+ * 将Task对象中的方法挂载到promise对象中，适配小程序api原生返回结果
+ * @param task Task对象 {RequestTask | DownloadTask | UploadTask}
+ * @param promise Promise
+ */
+function equipTaskMethodsIntoPromise(task, promise) {
+    if (!task || !promise)
+        return;
+    const taskMethods = ['abort', 'onHeadersReceived', 'offHeadersReceived', 'onProgressUpdate', 'offProgressUpdate', 'onChunkReceived', 'offChunkReceived'];
+    task && taskMethods.forEach(method => {
+        if (method in task) {
+            promise[method] = task[method].bind(task);
+        }
+    });
 }
 
 // 字符串简写
@@ -874,6 +1153,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 +1163,12 @@ exports.cacheDataHas = cacheDataHas;
 exports.cacheDataSet = cacheDataSet;
 exports.capitalize = capitalize;
 exports.controlledComponent = controlledComponent;
-exports.defaultReconciler = defaultReconciler;
 exports.ensure = ensure;
 exports.focusComponents = focusComponents;
+exports.getComponentsAlias = getComponentsAlias;
 exports.getUniqueKey = getUniqueKey;
 exports.hasOwn = hasOwn;
+exports.hooks = hooks;
 exports.indent = indent;
 exports.internalComponents = internalComponents;
 exports.isArray = isArray;
@@ -900,6 +1183,7 @@ exports.isUndefined = isUndefined;
 exports.mergeInternalComponents = mergeInternalComponents;
 exports.mergeReconciler = mergeReconciler;
 exports.nestElements = nestElements;
+exports.nonsupport = nonsupport;
 exports.noop = noop;
 exports.processApis = processApis;
 exports.queryToJson = queryToJson;
@@ -910,7 +1194,6 @@ exports.toDashed = toDashed;
 exports.toKebabCase = toKebabCase;
 exports.touchEvents = touchEvents;
 exports.unbox = unbox;
-exports.unsupport = unsupport;
 exports.voidElements = voidElements;
 exports.warn = warn;
 //# sourceMappingURL=index.js.map