@fairys/taro-tools-react 0.0.1

package/esm/utils/navigate.d.ts

@@ -0,0 +1,109 @@
+import Taro from '@tarojs/taro';
+declare class NavigateInstance {
+    /**判断是否已登录(方法需要在项目入口文件中进行挂载)*/
+    isAuth: (url: string) => Promise<boolean> | boolean;
+    private _isAuth;
+    /**
+     * 判断是否当前页面
+     */
+    isCurrentPage: (route: string) => boolean;
+    /** 跳转到 tabBar 页面，并关闭其他所有非 tabBar 页面
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @example
+     * ```json
+     * {
+     *   "tabBar": {
+     *     "list": [{
+     *       "pagePath": "index",
+     *       "text": "首页"
+     *     },{
+     *       "pagePath": "other",
+     *       "text": "其他"
+     *     }]
+     *   }
+     * }
+     * ```
+     *
+     * ```tsx
+     * Taro.switchTab({
+     *   url: '/index'
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.switchTab.html
+     */
+    switchTab: (options: Taro.switchTab.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 关闭所有页面，打开到应用内的某个页面
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @example
+     * ```tsx
+     * Taro.reLaunch({
+     *   url: 'test?id=1'
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.reLaunch.html
+     */
+    reLaunch: (options: Taro.reLaunch.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 关闭当前页面，跳转到应用内的某个页面。但是不允许跳转到 tabbar 页面。
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @h5 未针对 tabbar 页面做限制处理
+     * @example
+     * ```tsx
+     * Taro.redirectTo({
+     *   url: 'test?id=1'
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.redirectTo.html
+     */
+    redirectTo: (options: Taro.redirectTo.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 保留当前页面，跳转到应用内的某个页面。但是不能跳到 tabbar 页面。使用 Taro.navigateBack 可以返回到原页面。小程序中页面栈最多十层。
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @h5 未针对 tabbar 页面做限制处理
+     * @example
+     * ```tsx
+     * Taro.navigateTo({
+     *   url: 'test?id=1',
+     *   events: {
+     *     // 为指定事件添加一个监听器，获取被打开页面传送到当前页面的数据
+     *     acceptDataFromOpenedPage: function(data) {
+     *       console.log(data)
+     *     },
+     *     someEvent: function(data) {
+     *       console.log(data)
+     *     }
+     *     ...
+     *   },
+     *   success: function (res) {
+     *     // 通过eventChannel向被打开页面传送数据
+     *     res.eventChannel.emit('acceptDataFromOpenerPage', { data: 'test' })
+     *   }
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.navigateTo.html
+     */
+    navigateTo: (options: Taro.navigateTo.Option) => Promise<TaroGeneral.CallbackResult>;
+    /** 关闭当前页面，返回上一页面或多级页面。可通过 getCurrentPages 获取当前的页面栈，决定需要返回几层。
+     * @supported weapp, h5, rn, tt, harmony, harmony_hybrid
+     * @h5 若入参 delta 大于现有页面数时，返回应用打开的第一个页面（如果想要返回首页请使用 reLaunch 方法）。
+     * @example
+     * ```tsx
+     * // 注意：调用 navigateTo 跳转时，调用该方法的页面会被加入堆栈，而 redirectTo 方法则不会。见下方示例代码
+     * // 此处是A页面
+     * Taro.navigateTo({
+     *   url: 'B?id=1'
+     * })
+     * // 此处是B页面
+     * Taro.navigateTo({
+     *   url: 'C?id=1'
+     * })
+     * // 在C页面内 navigateBack，将返回A页面
+     * Taro.navigateBack({
+     *   delta: 2
+     * })
+     * ```
+     * @see https://developers.weixin.qq.com/miniprogram/dev/api/route/wx.navigateBack.html
+     */
+    navigateBack: (options?: Taro.navigateBack.Option) => Promise<TaroGeneral.CallbackResult>;
+}
+/**路由跳转*/
+export declare const navigate: NavigateInstance;
+export default navigate;

package/esm/utils/navigate.js

@@ -0,0 +1,45 @@
+import taro from "@tarojs/taro";
+class NavigateInstance {
+    isAuth;
+    _isAuth = async (url)=>{
+        let isAuthTo = true;
+        if (url && 'function' == typeof this.isAuth) isAuthTo = await this.isAuth(url);
+        if (false === isAuthTo) {
+            taro.showToast({
+                title: "\u65E0\u6743\u8BBF\u95EE",
+                icon: 'none'
+            });
+            return false;
+        }
+        return true;
+    };
+    isCurrentPage = (route)=>{
+        const _route = route.replace(/^\//, '');
+        const currentPath = (taro.getCurrentInstance().router?.path || '').replace(/^\//, '');
+        return currentPath === _route;
+    };
+    switchTab = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro.switchTab(options);
+    };
+    reLaunch = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro.reLaunch(options);
+    };
+    redirectTo = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro.redirectTo(options);
+    };
+    navigateTo = async (options)=>{
+        const isAuthTo = await this._isAuth(options.url);
+        if (false === isAuthTo) return;
+        return taro.navigateTo(options);
+    };
+    navigateBack = (options)=>taro.navigateBack(options);
+}
+const navigate_navigate = new NavigateInstance();
+const utils_navigate = navigate_navigate;
+export { utils_navigate as default, navigate_navigate as navigate };

package/esm/utils/request.d.ts

@@ -0,0 +1,112 @@
+import Taro from '@tarojs/taro';
+export interface RequestInstanceOptions extends Taro.request.Option<any, any> {
+    /**模块名称*/
+    module?: string;
+    /**是否忽略token*/
+    isIgnoreToken?: boolean;
+    /**是否提示错误信息*/
+    isShowErrorMessage?: boolean;
+}
+export interface RequestInstanceCreateOptions {
+    /**
+     * 本地存储token字段名
+     * @default token
+     */
+    tokenFieldName?: string;
+    /**
+     * 请求头token字段名
+     * @default token
+     */
+    headerTokenName?: string;
+    /**
+     * 公共请求配置
+     * @default {}
+     */
+    commonOptions?: Omit<Taro.request.Option<any, any>, 'url'>;
+    /**
+     * 请求IP地址
+     * @default ''
+     */
+    IP?: string | ((url: string, module?: string, env?: string) => string);
+    /**
+     * 简单的代理配置
+     * @default {}
+     */
+    proxy?: {
+        dev: Record<string, string | {
+            target: string;
+            pathRewrite: Record<string, string>;
+        }>;
+        pro: Record<string, string | {
+            target: string;
+            pathRewrite: Record<string, string>;
+        }>;
+    };
+}
+export declare class RequestInstance {
+    /**请求IP地址*/
+    IP?: string | ((url: string, module?: string, env?: string) => string);
+    /**简单的代理配置*/
+    proxy?: RequestInstanceCreateOptions['proxy'];
+    /**
+     * 本地存储token字段名
+     * @default token
+     */
+    tokenFieldName: string;
+    /**
+     * 请求头token字段名
+     * @default token
+     */
+    headerTokenName: string;
+    /**公共请求配置*/
+    commonOptions: Omit<Taro.request.Option<any, any>, 'url'>;
+    constructor(options?: RequestInstanceCreateOptions);
+    /**创建实例*/
+    static create(options?: RequestInstanceCreateOptions): RequestInstance;
+    /**扩展请求配置*/
+    extends: (options?: RequestInstanceCreateOptions) => this;
+    /**获取请求地址*/
+    getHttpPath: (url: string, module?: string) => string;
+    /**获取转换后地址*/
+    getProxyHost: (url: string, module?: string) => {
+        host: string;
+        url: string;
+    };
+    /**格式化地址*/
+    formatUrl: (url: string, module?: string) => string;
+    /**发送请求，返回 Taro.RequestTask */
+    requestBase: (options: RequestInstanceOptions) => Taro.RequestTask<any>;
+    /**发送请求,返回 Promise */
+    request: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**GET请求*/
+    GET: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**POST请求*/
+    POST: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**发送formData格式数据*/
+    formData: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+    /**发送x-www-form-urlencoded格式数据*/
+    xFormUrlEncoded: (options: RequestInstanceOptions) => Promise<{
+        code?: number;
+        data?: any;
+        message?: string;
+    }>;
+}
+/** 请求*/
+export declare const request: RequestInstance;
+export default request;

package/esm/utils/request.js

@@ -0,0 +1,212 @@
+import taro from "@tarojs/taro";
+import { globalSettingDataInstance } from "../context/global.setting.data.instance.js";
+import { globalDataInstance } from "../context/global.data.instance.js";
+const codeMessage = {
+    400: "\u53D1\u51FA\u7684\u8BF7\u6C42\u9519\u8BEF",
+    401: "\u7528\u6237\u6CA1\u6709\u6743\u9650",
+    403: "\u7528\u6237\u8BBF\u95EE\u88AB\u7981\u6B62",
+    404: "\u8BF7\u6C42\u4E0D\u5B58\u5728\uFF0C\u670D\u52A1\u5668\u6CA1\u6709\u8FDB\u884C\u64CD\u4F5C",
+    406: "\u8BF7\u6C42\u7684\u683C\u5F0F\u9519\u8BEF",
+    410: "\u8D44\u6E90\u88AB\u6C38\u4E45\u5220\u9664",
+    422: "\u9A8C\u8BC1\u9519\u8BEF",
+    500: "\u670D\u52A1\u5668\u53D1\u751F\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u5668",
+    502: "nginx\u5F02\u5E38",
+    503: "\u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u670D\u52A1\u5668\u6682\u65F6\u8FC7\u8F7D\u6216\u7EF4\u62A4",
+    504: "nginx\u8D85\u65F6"
+};
+const requestResponseHandle = (result, options)=>{
+    let msg = '';
+    try {
+        const statusCode = result.statusCode;
+        const code = result?.data?.code;
+        if (result?.data) {
+            if (401 === statusCode || 401 === code) {
+                msg = "\u8BF7\u91CD\u65B0\u767B\u5F55";
+                globalDataInstance.toLoginPage();
+            } else if (![
+                globalSettingDataInstance.store.requestSuccessCode,
+                200
+            ].includes(code)) msg = result?.data?.message || "\u63A5\u53E3\u5F02\u5E38";
+        } else msg = codeMessage[result?.statusCode];
+    } catch (error) {
+        msg = codeMessage[result?.statusCode];
+        console.log(error);
+    }
+    if (msg && options?.isShowErrorMessage !== false) globalDataInstance.showMessage({
+        content: msg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+        type: 'error'
+    });
+};
+class RequestInstance {
+    IP;
+    proxy;
+    tokenFieldName = 'token';
+    headerTokenName = 'token';
+    commonOptions = {};
+    constructor(options = {}){
+        this.extends(options);
+    }
+    static create(options = {}) {
+        const request = new RequestInstance(options);
+        return request;
+    }
+    extends = (options = {})=>{
+        this.IP = options.IP || this.IP;
+        this.proxy = options.proxy || this.proxy;
+        this.tokenFieldName = options.tokenFieldName || this.tokenFieldName;
+        this.headerTokenName = options.headerTokenName || this.headerTokenName;
+        this.commonOptions = {
+            ...this.commonOptions,
+            ...options.commonOptions
+        };
+        return this;
+    };
+    getHttpPath = (url, module)=>{
+        if ('function' == typeof this.IP) return this.IP(url, module, process.env.NODE_ENV) || '';
+        return this.IP || '';
+    };
+    getProxyHost = (url, module)=>{
+        let host = '';
+        let _url = url;
+        if ('h5' === process.env.TARO_ENV) return {
+            host: '',
+            url: _url
+        };
+        if (this.proxy) {
+            const proxy = this.proxy['production' === process.env.NODE_ENV ? 'pro' : 'dev'];
+            if (proxy) for(const key in proxy){
+                const rgx = new RegExp(key);
+                const item = proxy[key];
+                if (rgx.test(url) && item) {
+                    if ('string' == typeof item) host = item;
+                    else if (item?.target) {
+                        host = item.target;
+                        if (item.pathRewrite) for(const key in item.pathRewrite){
+                            const rgx = new RegExp(key);
+                            _url = url.replace(rgx, item.pathRewrite[key]);
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        if (!host) host = this.getHttpPath(url, module);
+        return {
+            host,
+            url: _url
+        };
+    };
+    formatUrl = (url, module)=>{
+        let { host, url: _url } = this.getProxyHost(url, module);
+        if (host) host = host.replace(/\/$/, '');
+        const newUrl = `${_url}`.replace(/^\//, '').replace(/\/$/, '');
+        if (module && 'production' === process.env.NODE_ENV) {
+            const m = `${module}`.replace(/^\//, '').replace(/\/$/, '');
+            return `${host}/${m}/${newUrl}`;
+        }
+        return `${host}/${newUrl}`;
+    };
+    requestBase = (options)=>{
+        const { data, header = {}, module, isIgnoreToken, isShowErrorMessage, ...restOptions } = options;
+        const token = taro.getStorageSync(this.tokenFieldName || 'token');
+        const newHeader = {
+            ...header
+        };
+        if (token) newHeader[this.headerTokenName || 'token'] = token;
+        else if (true !== isIgnoreToken) {
+            if (false !== isShowErrorMessage) globalDataInstance.showMessage({
+                content: "\u672A\u767B\u5F55",
+                type: 'error'
+            });
+            options?.fail?.({
+                errMsg: "\u672A\u767B\u5F55"
+            });
+            globalDataInstance.toLoginPage();
+            return;
+        }
+        return taro.request({
+            ...this.commonOptions,
+            ...restOptions,
+            header: {
+                ...newHeader,
+                ...options?.header || {}
+            },
+            url: this.formatUrl(options.url, module),
+            success: (result)=>{
+                requestResponseHandle(result, options);
+                options?.success?.(result);
+            },
+            fail: (result)=>{
+                if (false !== isShowErrorMessage) globalDataInstance.showMessage({
+                    content: result.errMsg || "\u8BF7\u6C42\u53D1\u751F\u9519\u8BEF",
+                    type: 'error'
+                });
+                options?.fail?.(result);
+            }
+        });
+    };
+    request = (options)=>new Promise((resolve, reject)=>{
+            this.requestBase({
+                ...options,
+                success: (result)=>{
+                    options?.success?.(result);
+                    resolve(result?.data);
+                },
+                fail: (result)=>{
+                    options?.fail?.(result);
+                    reject(result);
+                }
+            });
+        });
+    GET = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'GET'
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    POST = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'POST'
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    formData = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'POST',
+                header: {
+                    'Content-Type': 'multipart/form-data',
+                    ...options.header || {}
+                }
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+    xFormUrlEncoded = (options)=>{
+        try {
+            return this.request({
+                ...options,
+                method: 'POST',
+                header: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    ...options.header || {}
+                }
+            });
+        } catch (error) {
+            throw error;
+        }
+    };
+}
+const request_request = new RequestInstance();
+const utils_request = request_request;
+export { RequestInstance, utils_request as default, request_request as request };

package/esm/utils/useId.d.ts

@@ -0,0 +1,2 @@
+export declare const createUseId: (suffix?: string) => string;
+export declare const useId: (suffix?: string) => string;

package/esm/utils/useId.js

@@ -0,0 +1,13 @@
+import { useMemo, useRef } from "react";
+let localId = 0;
+const createUseId = (suffix = 'D')=>{
+    const count = localId++;
+    return `FAIRYS_TARO_UI_${count.toString(32)}_${suffix}`;
+};
+const useId = (suffix = 'D')=>{
+    const count = useRef(localId++);
+    return useMemo(()=>`FAIRYS_TARO_UI_${count.current.toString(32)}_${suffix}`, [
+        count.current
+    ]);
+};
+export { createUseId, useId };

package/esm/utils/valtio/index.d.ts

@@ -0,0 +1,9 @@
+import { ProxyInstanceObjectBase } from './instance';
+export * from './instance';
+/**创建简单的状态管理*/
+export declare const useValtioState: <T extends object>(inital?: T) => readonly [import("valtio").Snapshot<T>, ProxyInstanceObjectBase<T>, any];
+export declare const useValtioInstaceState: <T extends object = any, K extends ProxyInstanceObjectBase<T> = ProxyInstanceObjectBase<T>, M extends {
+    new (...args: any[]): K;
+} = {
+    new (...args: any[]): K;
+}>(Instance: M) => readonly [import("valtio").Snapshot<T>, K, any];

package/esm/utils/valtio/index.js

@@ -0,0 +1,23 @@
+import { useRef } from "react";
+import { useSnapshot } from "valtio";
+import { ProxyInstanceObjectBase } from "./instance.js";
+export * from "./instance.js";
+const useValtioState = (inital)=>{
+    const instance = useRef(new ProxyInstanceObjectBase()._ctor(inital)).current;
+    const state = useSnapshot(instance.store);
+    return [
+        state,
+        instance,
+        state.__defaultValue
+    ];
+};
+const useValtioInstaceState = (Instance)=>{
+    const instance = useRef(new Instance()).current;
+    const state = useSnapshot(instance.store);
+    return [
+        state,
+        instance,
+        state.__defaultValue
+    ];
+};
+export { useValtioInstaceState, useValtioState };

package/esm/utils/valtio/instance.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 单个proxy对象数据基础实例封装
+ */
+export declare class ProxyInstanceObjectBase<T extends Object = any> {
+    /**proxy 可状态更新字段 */
+    store: T;
+    /**初始化存储值*/
+    _ctor: (inital?: Partial<T>, fields?: string[]) => this;
+    /**更新store数据 循环对象进行存储，当值是对象的时候存储为ref*/
+    _setValues: <K = T>(values: Partial<K>, fields?: string[]) => this;
+    /**删除字段值*/
+    _deleteValue: (names: string | string[]) => this;
+    /**创建 ref 对象 (ref对象不做监听更新)*/
+    _createRef: <K extends Object = any>(inital?: K) => K;
+}

package/esm/utils/valtio/instance.js

@@ -0,0 +1,34 @@
+import { proxy, ref } from "valtio";
+import react from "react";
+class ProxyInstanceObjectBase {
+    store = proxy({});
+    _ctor = (inital, fields)=>{
+        this._setValues(inital || {}, fields);
+        return this;
+    };
+    _setValues = (values, fields)=>{
+        if (!this.store) this.store = proxy({});
+        Object.keys(values).forEach((key)=>{
+            const value = values[key];
+            if (Array.isArray(fields) && fields.includes(key)) this.store[key] = values[key];
+            else if (react.isValidElement(value) || 'function' == typeof value) this.store[key] = ref(values[key]);
+            else if ('object' == typeof value && null !== value) this.store[key] = ref(values[key]);
+            else this.store[key] = values[key];
+        });
+        return this;
+    };
+    _deleteValue = (names)=>{
+        if (Array.isArray(names)) {
+            let cacheValue = this.store;
+            const newNames = [
+                ...names
+            ];
+            const lastField = newNames.pop();
+            for(let index = 0; index < newNames.length; index++)cacheValue = cacheValue[newNames[index]];
+            if (cacheValue && lastField) delete cacheValue[lastField];
+        } else delete this.store[names];
+        return this;
+    };
+    _createRef = (inital)=>ref(inital || {});
+}
+export { ProxyInstanceObjectBase };

package/lib/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_modules__ = {
+    "./components": function(module) {
+        module.exports = require("./components/index.js");
+    },
+    "./context": function(module) {
+        module.exports = require("./context/index.js");
+    },
+    "./utils": function(module) {
+        module.exports = require("./utils/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _components__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./components");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _components__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _components__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _context__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./context");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _context__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _context__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./utils");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _utils__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _utils__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});