@tarojs/taro-h5 3.3.18 → 3.3.19

package/dist/api/ui/pull-down-refresh.js

@@ -0,0 +1,20 @@
+import Taro from '@tarojs/api';
+import { MethodHandler } from '../utils/handler';
+export const startPullDownRefresh = function ({ success, fail, complete } = {}) {
+    const handle = new MethodHandler({ name: 'startPullDownRefresh', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroStartPullDownRefresh', {
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const stopPullDownRefresh = function ({ success, fail, complete } = {}) {
+    const handle = new MethodHandler({ name: 'stopPullDownRefresh', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroStopPullDownRefresh', {
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};

package/dist/api/ui/scroll/index.js

@@ -0,0 +1,80 @@
+import { Current } from '@tarojs/runtime';
+import { MethodHandler } from '../../utils/handler';
+import { getTimingFunc, easeInOut } from '../../utils';
+let timer;
+const FRAME_DURATION = 17;
+export const pageScrollTo = ({ scrollTop, selector = '', duration = 300, success, fail, complete }) => {
+    let scrollFunc;
+    const handle = new MethodHandler({ name: 'pageScrollTo', success, fail, complete });
+    return new Promise((resolve, reject) => {
+        var _a;
+        try {
+            if (scrollTop === undefined && !selector) {
+                return handle.fail({
+                    errMsg: 'scrollTop" 或 "selector" 需要其之一'
+                }, reject);
+            }
+            const id = (_a = Current.page) === null || _a === void 0 ? void 0 : _a.path;
+            const el = (id
+                ? document.getElementById(id)
+                : document.querySelector('.taro_page') ||
+                    document.querySelector('.taro_router'));
+            if (!scrollFunc) {
+                if (!el) {
+                    scrollFunc = pos => {
+                        if (pos === undefined) {
+                            return window.pageYOffset;
+                        }
+                        else {
+                            window.scrollTo(0, pos);
+                        }
+                    };
+                }
+                else {
+                    scrollFunc = pos => {
+                        if (pos === undefined) {
+                            return el.scrollTop;
+                        }
+                        else {
+                            el.scrollTop = pos;
+                        }
+                    };
+                }
+            }
+            if (scrollTop && selector) {
+                console.warn('"scrollTop" 或 "selector" 建议只设一个值，全部设置会忽略selector');
+            }
+            const from = scrollFunc();
+            let to;
+            if (typeof scrollTop === 'number') {
+                to = scrollTop;
+            }
+            else {
+                const el = document.querySelector(selector);
+                to = (el === null || el === void 0 ? void 0 : el.offsetTop) || 0;
+            }
+            const delta = to - from;
+            const frameCnt = duration / FRAME_DURATION;
+            const easeFunc = getTimingFunc(easeInOut, frameCnt);
+            const scroll = (frame = 0) => {
+                const dest = from + delta * easeFunc(frame);
+                scrollFunc(dest);
+                if (frame < frameCnt) {
+                    timer && clearTimeout(timer);
+                    timer = setTimeout(() => {
+                        scroll(frame + 1);
+                    }, FRAME_DURATION);
+                }
+                else {
+                    return handle.success({}, resolve);
+                }
+            };
+            scroll();
+        }
+        catch (e) {
+            return handle.fail({
+                errMsg: e.message
+            }, reject);
+        }
+    });
+};

package/dist/api/ui/sticky.js

@@ -0,0 +1,2 @@
+import { temporarilyNotSupport } from '../utils';
+export const setTopBarText = temporarilyNotSupport('setTopBarText');

package/dist/api/ui/tab-bar.js

@@ -0,0 +1,250 @@
+import Taro from '@tarojs/api';
+import { shouldBeObject, getParameterError, isValidColor } from '../utils';
+import { MethodHandler } from '../utils/handler';
+let tabConf;
+export function initTabBarApis(config = {}) {
+    tabConf = config.tabBar;
+}
+export const showTabBarRedDot = (options) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `showTabBarRedDot:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { index, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'showTabBarRedDot', success, fail, complete });
+    if (typeof index !== 'number') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'index',
+                correct: 'Number',
+                wrong: index
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroShowTabBarRedDotHandler', {
+            index,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const showTabBar = (options = {}) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `showTabBar:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { animation, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'showTabBar', success, fail, complete });
+    if (options.hasOwnProperty('animation') && typeof animation !== 'boolean') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'animation',
+                correct: 'Boolean',
+                wrong: animation
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroShowTabBar', {
+            animation,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const setTabBarStyle = (options = {}) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `setTabBarStyle:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { color, selectedColor, backgroundColor, borderStyle, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'setTabBarStyle', success, fail, complete });
+    let errMsg;
+    if (color && !isValidColor(color)) {
+        errMsg = 'color';
+    }
+    else if (selectedColor && !isValidColor(selectedColor)) {
+        errMsg = 'selectedColor';
+    }
+    else if (backgroundColor && !isValidColor(backgroundColor)) {
+        errMsg = 'backgroundColor';
+    }
+    else if (borderStyle && !/^(black|white)$/.test(borderStyle)) {
+        errMsg = 'borderStyle';
+    }
+    if (errMsg) {
+        return handle.fail({ errMsg: `invalid ${errMsg}` });
+    }
+    if (!tabConf) {
+        return handle.fail();
+    }
+    const obj = {};
+    if (color)
+        obj.color = color;
+    if (selectedColor)
+        obj.selectedColor = selectedColor;
+    if (backgroundColor)
+        obj.backgroundColor = backgroundColor;
+    if (borderStyle)
+        obj.borderStyle = borderStyle;
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroSetTabBarStyle', {
+            color,
+            selectedColor,
+            backgroundColor,
+            borderStyle,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const setTabBarItem = (options) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `setTabBarItem:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { index, text, iconPath, selectedIconPath, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'setTabBarItem', success, fail, complete });
+    if (typeof index !== 'number') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'index',
+                correct: 'Number',
+                wrong: index
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroSetTabBarItem', {
+            index,
+            text,
+            iconPath,
+            selectedIconPath,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const setTabBarBadge = (options) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `setTabBarBadge:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { index, text, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'setTabBarBadge', success, fail, complete });
+    if (typeof index !== 'number') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'index',
+                correct: 'Number',
+                wrong: index
+            })
+        });
+    }
+    if (typeof text !== 'string') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'text',
+                correct: 'String',
+                wrong: text
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroSetTabBarBadge', {
+            index,
+            text,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const removeTabBarBadge = (options) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `removeTabBarBadge:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { index, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'removeTabBarBadge', success, fail, complete });
+    if (typeof index !== 'number') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'index',
+                correct: 'Number',
+                wrong: index
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroRemoveTabBarBadge', {
+            index,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const hideTabBarRedDot = (options) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `hideTabBarRedDot:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { index, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'hideTabBarRedDot', success, fail, complete });
+    if (typeof index !== 'number') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'index',
+                correct: 'Number',
+                wrong: index
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroHideTabBarRedDotHandler', {
+            index,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};
+export const hideTabBar = (options = {}) => {
+    const isObject = shouldBeObject(options);
+    if (!isObject.flag) {
+        const res = { errMsg: `hideTabBar:fail ${isObject.msg}` };
+        console.error(res.errMsg);
+        return Promise.reject(res);
+    }
+    const { animation, success, fail, complete } = options;
+    const handle = new MethodHandler({ name: 'hideTabBar', success, fail, complete });
+    if (options.hasOwnProperty('animation') && typeof animation !== 'boolean') {
+        return handle.fail({
+            errMsg: getParameterError({
+                para: 'animation',
+                correct: 'Boolean',
+                wrong: animation
+            })
+        });
+    }
+    return new Promise((resolve, reject) => {
+        Taro.eventCenter.trigger('__taroHideTabBar', {
+            animation,
+            successHandler: (res = {}) => handle.success(res, resolve),
+            errorHandler: (res = {}) => handle.fail(res, reject)
+        });
+    });
+};

package/dist/api/ui/window.js

@@ -0,0 +1,22 @@
+import { temporarilyNotSupport } from '../utils';
+import { CallbackManager } from '../utils/handler';
+const callbackManager = new CallbackManager();
+const resizeListener = () => {
+    callbackManager.trigger({
+        windowWidth: window.screen.width,
+        windowHeight: window.screen.height
+    });
+};
+export const setWindowSize = temporarilyNotSupport('setWindowSize');
+export const onWindowResize = callback => {
+    callbackManager.add(callback);
+    if (callbackManager.count() === 1) {
+        window.addEventListener('resize', resizeListener);
+    }
+};
+export const offWindowResize = callback => {
+    callbackManager.remove(callback);
+    if (callbackManager.count() === 0) {
+        window.removeEventListener('resize', resizeListener);
+    }
+};

package/dist/api/utils/handler.js

@@ -0,0 +1,64 @@
+export class MethodHandler {
+    constructor({ name, success, fail, complete }) {
+        this.methodName = name;
+        this.__success = success;
+        this.__fail = fail;
+        this.__complete = complete;
+    }
+    success(res = {}, resolve = Promise.resolve.bind(Promise)) {
+        if (!res.errMsg) {
+            res.errMsg = `${this.methodName}:ok`;
+        }
+        typeof this.__success === 'function' && this.__success(res);
+        typeof this.__complete === 'function' && this.__complete(res);
+        return resolve(res);
+    }
+    fail(res = {}, reject = Promise.reject.bind(Promise)) {
+        if (!res.errMsg) {
+            res.errMsg = `${this.methodName}:fail`;
+        }
+        else {
+            res.errMsg = `${this.methodName}:fail ${res.errMsg}`;
+        }
+        console.error(res.errMsg);
+        typeof this.__fail === 'function' && this.__fail(res);
+        typeof this.__complete === 'function' && this.__complete(res);
+        return reject(res);
+    }
+}
+export class CallbackManager {
+    constructor() {
+        this.callbacks = [];
+    }
+    add(opt) {
+        if (opt)
+            this.callbacks.push(opt);
+    }
+    remove(opt) {
+        if (opt) {
+            let pos = -1;
+            this.callbacks.forEach((callback, k) => {
+                if (callback === opt) {
+                    pos = k;
+                }
+            });
+            if (pos > -1) {
+                this.callbacks.splice(pos, 1);
+            }
+        }
+    }
+    count() {
+        return this.callbacks.length;
+    }
+    trigger(...args) {
+        this.callbacks.forEach(opt => {
+            if (typeof opt === 'function') {
+                opt(...args);
+            }
+            else {
+                const { callback, ctx } = opt;
+                typeof callback === 'function' && callback.call(ctx, ...args);
+            }
+        });
+    }
+}

package/dist/api/utils/index.js

@@ -0,0 +1,141 @@
+import { Current, container, SERVICE_IDENTIFIER } from '@tarojs/runtime';
+export function shouldBeObject(target) {
+    if (target && typeof target === 'object')
+        return { flag: true };
+    return {
+        flag: false,
+        msg: getParameterError({
+            correct: 'Object',
+            wrong: target
+        })
+    };
+}
+export function findDOM(inst) {
+    const runtimeHooks = container.get(SERVICE_IDENTIFIER.Hooks);
+    if (inst) {
+        const find = runtimeHooks.getDOMNode;
+        if (typeof find === 'function') {
+            return find(inst);
+        }
+    }
+    const page = Current.page;
+    const path = page === null || page === void 0 ? void 0 : page.path;
+    const msg = '没有找到已经加载了的页面，请在页面加载完成后时候此 API。';
+    if (path == null) {
+        throw new Error(msg);
+    }
+    const el = document.getElementById(path);
+    if (el == null) {
+        throw new Error('在已加载页面中没有找到对应的容器元素。');
+    }
+    return el;
+}
+export function getParameterError({ name = '', para, correct, wrong }) {
+    const parameter = para ? `parameter.${para}` : 'parameter';
+    const errorType = upperCaseFirstLetter(wrong === null ? 'Null' : typeof wrong);
+    if (name) {
+        return `${name}:fail parameter error: ${parameter} should be ${correct} instead of ${errorType}`;
+    }
+    else {
+        return `parameter error: ${parameter} should be ${correct} instead of ${errorType}`;
+    }
+}
+function upperCaseFirstLetter(string) {
+    if (typeof string !== 'string')
+        return string;
+    string = string.replace(/^./, match => match.toUpperCase());
+    return string;
+}
+export function inlineStyle(style) {
+    let res = '';
+    for (const attr in style)
+        res += `${attr}: ${style[attr]};`;
+    if (res.indexOf('display: flex;') >= 0)
+        res += 'display: -webkit-box;display: -webkit-flex;';
+    res = res.replace(/transform:(.+?);/g, (s, $1) => `${s}-webkit-transform:${$1};`);
+    res = res.replace(/flex-direction:(.+?);/g, (s, $1) => `${s}-webkit-flex-direction:${$1};`);
+    return res;
+}
+export function setTransform(el, val) {
+    el.style.webkitTransform = val;
+    el.style.transform = val;
+}
+export function serializeParams(params) {
+    if (!params) {
+        return '';
+    }
+    return Object.keys(params)
+        .map(key => (`${encodeURIComponent(key)}=${typeof (params[key]) === 'object'
+        ? encodeURIComponent(JSON.stringify(params[key]))
+        : encodeURIComponent(params[key])}`))
+        .join('&');
+}
+export function temporarilyNotSupport(apiName) {
+    return () => {
+        const errMsg = `暂时不支持 API ${apiName}`;
+        console.error(errMsg);
+        return Promise.reject({
+            errMsg
+        });
+    };
+}
+export function weixinCorpSupport(apiName) {
+    return () => {
+        const errMsg = `h5端仅在微信公众号中支持 API ${apiName}`;
+        console.error(errMsg);
+        return Promise.reject({
+            errMsg
+        });
+    };
+}
+export function permanentlyNotSupport(apiName) {
+    return () => {
+        const errMsg = `不支持 API ${apiName}`;
+        console.error(errMsg);
+        return Promise.reject({
+            errMsg
+        });
+    };
+}
+export function isFunction(obj) {
+    return typeof obj === 'function';
+}
+const VALID_COLOR_REG = /^#[0-9a-fA-F]{6}$/;
+export const isValidColor = (color) => {
+    return VALID_COLOR_REG.test(color);
+};
+export function processOpenApi(apiName, defaultOptions, formatResult = res => res, formatParams = options => options) {
+    if (!window.wx) {
+        return weixinCorpSupport(apiName);
+    }
+    return options => {
+        options = options || {};
+        const obj = Object.assign({}, defaultOptions, options);
+        const p = new Promise((resolve, reject) => {
+            ['fail', 'success', 'complete'].forEach(k => {
+                obj[k] = oriRes => {
+                    const res = formatResult(oriRes);
+                    options[k] && options[k](res);
+                    if (k === 'success') {
+                        resolve(res);
+                    }
+                    else if (k === 'fail') {
+                        reject(res);
+                    }
+                };
+            });
+            wx[apiName](formatParams(obj));
+        });
+        return p;
+    };
+}
+export const easeInOut = (t) => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+export const getTimingFunc = (easeFunc, frameCnt) => {
+    return x => {
+        if (frameCnt <= 1) {
+            return easeFunc(1);
+        }
+        const t = x / (frameCnt - 1);
+        return easeFunc(t);
+    };
+};

package/dist/api/worker/index.js

@@ -0,0 +1,2 @@
+import { temporarilyNotSupport } from '../utils';
+export const createWorker = temporarilyNotSupport('createWorker');

package/dist/api/wxml/index.js

@@ -0,0 +1,6 @@
+import { temporarilyNotSupport } from '../utils';
+import { SelectorQuery } from './selectorQuery';
+export const createSelectorQuery = () => {
+    return new SelectorQuery();
+};
+export const createIntersectionObserver = temporarilyNotSupport('createIntersectionObserver');

package/dist/api/wxml/nodesRef.js

@@ -0,0 +1,35 @@
+import { temporarilyNotSupport } from '../utils';
+export class NodesRef {
+    constructor(selector, querySelectorQuery, single) {
+        this.context = temporarilyNotSupport('NodesRef.context');
+        this.node = temporarilyNotSupport('NodesRef.node');
+        this._component = querySelectorQuery._component;
+        this._selector = selector;
+        this._selectorQuery = querySelectorQuery;
+        this._single = single;
+    }
+    boundingClientRect(cb) {
+        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, cb) {
+        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;
+    }
+}