@tarojs/shared 3.5.0-alpha.8 → 3.5.0-beta.1

package/dist/template.js

@@ -328,6 +328,9 @@ const nestElements = new Map([
     ['swiper-item', 4]
 ]);
 
+function isString(o) {
+    return typeof o === 'string';
+}
 function isFunction(o) {
     return typeof o === 'function';
 }
@@ -338,6 +341,239 @@ function isBooleanStringLiteral(o) {
     return o === 'true' || o === 'false';
 }
 
+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+/;
+
+var HOOK_TYPE;
+(function (HOOK_TYPE) {
+    HOOK_TYPE[HOOK_TYPE["SINGLE"] = 0] = "SINGLE";
+    HOOK_TYPE[HOOK_TYPE["MULTI"] = 1] = "MULTI";
+    HOOK_TYPE[HOOK_TYPE["WATERFALL"] = 2] = "WATERFALL";
+})(HOOK_TYPE || (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 === 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 === 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]);
+    }
+}
+new TaroHooks({
+    getMiniLifecycle: TaroHook(HOOK_TYPE.SINGLE, defaultConfig => defaultConfig),
+    getMiniLifecycleImpl: TaroHook(HOOK_TYPE.SINGLE, function () {
+        return this.call('getMiniLifecycle', defaultMiniLifecycle);
+    }),
+    getLifecycle: TaroHook(HOOK_TYPE.SINGLE, (instance, lifecycle) => instance[lifecycle]),
+    getPathIndex: TaroHook(HOOK_TYPE.SINGLE, indexOfNode => `[${indexOfNode}]`),
+    getEventCenter: TaroHook(HOOK_TYPE.SINGLE, Events => new Events()),
+    isBubbleEvents: TaroHook(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(HOOK_TYPE.SINGLE, () => ['view', 'text', 'image']),
+    onRemoveAttribute: TaroHook(HOOK_TYPE.SINGLE),
+    batchedEventUpdates: TaroHook(HOOK_TYPE.SINGLE),
+    mergePageInstance: TaroHook(HOOK_TYPE.SINGLE),
+    modifyPageObject: TaroHook(HOOK_TYPE.SINGLE),
+    createPullDownComponent: TaroHook(HOOK_TYPE.SINGLE),
+    getDOMNode: TaroHook(HOOK_TYPE.SINGLE),
+    modifyHydrateData: TaroHook(HOOK_TYPE.SINGLE),
+    modifySetAttrPayload: TaroHook(HOOK_TYPE.SINGLE),
+    modifyRmAttrPayload: TaroHook(HOOK_TYPE.SINGLE),
+    onAddEvent: TaroHook(HOOK_TYPE.SINGLE),
+    modifyMpEvent: TaroHook(HOOK_TYPE.MULTI),
+    modifyMpEventImpl: TaroHook(HOOK_TYPE.SINGLE, function (e) {
+        try {
+            // 有些小程序的事件对象的某些属性只读
+            this.call('modifyMpEvent', e);
+        }
+        catch (error) {
+            console.warn('[Taro modifyMpEvent hook Error]: ', error);
+        }
+    }),
+    modifyTaroEvent: TaroHook(HOOK_TYPE.MULTI),
+    modifyDispatchEvent: TaroHook(HOOK_TYPE.MULTI),
+    initNativeApi: TaroHook(HOOK_TYPE.MULTI),
+    patchElement: TaroHook(HOOK_TYPE.MULTI)
+});
+
 function toDashed(s) {
     return s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
 }
@@ -408,6 +644,7 @@ class BaseTemplate {
     constructor() {
         this.exportExpr = 'module.exports =';
         this.supportXS = false;
+        this.thirdPartyPatcher = {};
         this.Adapter = weixinAdapter;
         /** 组件列表 */
         this.internalComponents = internalComponents;
@@ -553,7 +790,7 @@ class BaseTemplate {
 </template>
 `;
     }
-    buildThirdPartyAttr(attrs) {
+    buildThirdPartyAttr(attrs, patcher = {}) {
         return Array.from(attrs).reduce((str, attr) => {
             if (attr.startsWith('@')) {
                 // vue2
@@ -581,6 +818,13 @@ class BaseTemplate {
             else if (attr === 'style') {
                 return str + `style="{{i.${"st" /* Style */}}}" `;
             }
+            const patchValue = patcher[attr];
+            if (isBooleanStringLiteral(patchValue) || isNumber(patchValue) || isString(patchValue)) {
+                const propValue = this.supportXS
+                    ? `xs.b(i.${toCamelCase(attr)},${patchValue})`
+                    : `i.${toCamelCase(attr)}===undefined?${patchValue}:i.${toCamelCase(attr)}`;
+                return str + `${attr}="{{${propValue}}}" `;
+            }
             return str + `${attr}="{{i.${toCamelCase(attr)}}}" `;
         }, '');
     }
@@ -703,7 +947,7 @@ class BaseTemplate {
                 }
                 template += `
 <template name="tmpl_${level}_${compName}">
-  <${compName} ${this.buildThirdPartyAttr(attrs)} id="{{i.uid||i.sid}}" data-sid="{{i.sid}}">
+  <${compName} ${this.buildThirdPartyAttr(attrs, this.thirdPartyPatcher[compName] || {})} id="{{i.uid||i.sid}}" data-sid="{{i.sid}}">
     <block ${Adapter.for}="{{i.${"cn" /* Childnodes */}}}" ${Adapter.key}="sid">
       ${child}
     </block>
@@ -756,6 +1000,9 @@ class BaseTemplate {
     mergeComponents(ctx, patch) {
         ctx.helper.recursiveMerge(this.internalComponents, patch);
     }
+    mergeThirdPartyComponents(patch) {
+        this.thirdPartyPatcher = patch;
+    }
     buildXSTmplName() {
         return `function (l, n) {
     return 'tmpl_' + l + '_' + n