diff --git a/build/rollup.config.js b/build/rollup.config.js index f4d73565529d6322031247a184af2d02fbd430d3..2af5d4afbe32024cd110fbe3af67daeeed1ee747 100644 --- a/build/rollup.config.js +++ b/build/rollup.config.js @@ -6,6 +6,10 @@ const PLATFORMS = { 'mp-weixin': { prefix: 'wx', title: '微信小程序' + }, + 'mp-qq': { + prefix: 'wx', + title: 'QQ小程序' }, 'mp-alipay': { prefix: 'my', diff --git a/package.json b/package.json index c14cc43b5ec4579b21ae3b2c2a4f03bfabda9bb8..159c62cc7010eb024cdd20fc248a0870045f0714 100644 --- a/package.json +++ b/package.json @@ -6,7 +6,8 @@ "dev:h5": "npm run lint && cross-env NODE_ENV=production UNI_WATCH=true UNI_PLATFORM=h5 node build/build.js", "build:h5": "npm run lint && cross-env NODE_ENV=production UNI_WATCH=false UNI_PLATFORM=h5 node build/build.js", "build:app-plus": "npm run lint && cross-env UNI_PLATFORM=app-plus rollup -c build/rollup.config.js", - "build:service:legacy": "npm run lint && rollup -c build/rollup.config.service.js", + "build:service:legacy": "npm run lint && rollup -c build/rollup.config.service.js", + "build:mp-qq": "npm run lint && cross-env UNI_PLATFORM=mp-qq rollup -c build/rollup.config.js", "build:mp-weixin": "npm run lint && cross-env UNI_PLATFORM=mp-weixin rollup -c build/rollup.config.js", "build:mp-baidu": "npm run lint && cross-env UNI_PLATFORM=mp-baidu rollup -c build/rollup.config.js", "build:mp-alipay": "npm run lint && cross-env UNI_PLATFORM=mp-alipay rollup -c build/rollup.config.js", diff --git a/packages/uni-mp-qq/LICENSE b/packages/uni-mp-qq/LICENSE new file mode 100755 index 0000000000000000000000000000000000000000..7a4a3ea2424c09fbe48d455aed1eaa94d9124835 --- /dev/null +++ b/packages/uni-mp-qq/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/packages/uni-mp-qq/dist/index.js b/packages/uni-mp-qq/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..58ee21ae7b49e2178995b83b97e348749013d746 --- /dev/null +++ b/packages/uni-mp-qq/dist/index.js @@ -0,0 +1,1298 @@ +import Vue from 'vue'; + +const _toString = Object.prototype.toString; +const hasOwnProperty = Object.prototype.hasOwnProperty; + +function isFn (fn) { + return typeof fn === 'function' +} + +function isStr (str) { + return typeof str === 'string' +} + +function isPlainObject (obj) { + return _toString.call(obj) === '[object Object]' +} + +function hasOwn (obj, key) { + return hasOwnProperty.call(obj, key) +} + +function noop () {} + +/** + * Create a cached version of a pure function. + */ +function cached (fn) { + const cache = Object.create(null); + return function cachedFn (str) { + const hit = cache[str]; + return hit || (cache[str] = fn(str)) + } +} + +/** + * Camelize a hyphen-delimited string. + */ +const camelizeRE = /-(\w)/g; +const camelize = cached((str) => { + return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '') +}); + +const SYNC_API_RE = /^\$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/; + +const CONTEXT_API_RE = /^create|Manager$/; + +const CALLBACK_API_RE = /^on/; + +function isContextApi (name) { + return CONTEXT_API_RE.test(name) +} +function isSyncApi (name) { + return SYNC_API_RE.test(name) +} + +function isCallbackApi (name) { + return CALLBACK_API_RE.test(name) +} + +function handlePromise (promise) { + return promise.then(data => { + return [null, data] + }) + .catch(err => [err]) +} + +function shouldPromise (name) { + if ( + isContextApi(name) || + isSyncApi(name) || + isCallbackApi(name) + ) { + return false + } + return true +} + +function promisify (name, api) { + if (!shouldPromise(name)) { + return api + } + return function promiseApi (options = {}, ...params) { + if (isFn(options.success) || isFn(options.fail) || isFn(options.complete)) { + return api(options, ...params) + } + return handlePromise(new Promise((resolve, reject) => { + api(Object.assign({}, options, { + success: resolve, + fail: reject + }), ...params); + /* eslint-disable no-extend-native */ + if (!Promise.prototype.finally) { + Promise.prototype.finally = function (callback) { + const promise = this.constructor; + return this.then( + value => promise.resolve(callback()).then(() => value), + reason => promise.resolve(callback()).then(() => { + throw reason + }) + ) + }; + } + })) + } +} + +const EPS = 1e-4; +const BASE_DEVICE_WIDTH = 750; +let isIOS = false; +let deviceWidth = 0; +let deviceDPR = 0; + +function checkDeviceWidth () { + const { + platform, + pixelRatio, + windowWidth + } = wx.getSystemInfoSync(); // uni=>wx runtime 编译目标是 uni 对象，内部不允许直接使用 uni + + deviceWidth = windowWidth; + deviceDPR = pixelRatio; + isIOS = platform === 'ios'; +} + +function upx2px (number, newDeviceWidth) { + if (deviceWidth === 0) { + checkDeviceWidth(); + } + + number = Number(number); + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth); + if (result < 0) { + result = -result; + } + result = Math.floor(result + EPS); + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + return 1 + } else { + return 0.5 + } + } + return number < 0 ? -result : result +} + +var previewImage = { + args (fromArgs) { + let currentIndex = parseInt(fromArgs.current); + if (isNaN(currentIndex)) { + return + } + const urls = fromArgs.urls; + if (!Array.isArray(urls)) { + return + } + const len = urls.length; + if (!len) { + return + } + if (currentIndex < 0) { + currentIndex = 0; + } else if (currentIndex >= len) { + currentIndex = len - 1; + } + if (currentIndex > 0) { + fromArgs.current = urls[currentIndex]; + fromArgs.urls = urls.filter( + (item, index) => index < currentIndex ? item !== urls[currentIndex] : true + ); + } else { + fromArgs.current = urls[0]; + } + return { + indicator: false, + loop: false + } + } +}; + +const protocols = { + previewImage +}; +const todos = [ + 'connectSocket', + 'onSocketOpen', + 'onSocketError', + 'sendSocketMessage', + 'onSocketMessage', + 'closeSocket', + 'onSocketClose', + 'createLivePlayerContext', + 'createLivePusherContext', + 'loadFontFace', + 'openDocument', + 'canIUse', + 'onMemoryWarning', + 'onNetworkStatusChange', + 'onAccelerometerChange', + 'startAccelerometer', + 'stopAccelerometer', + 'onCompassChange', + 'startCompass', + 'scanCode', + 'startBeaconDiscovery', + 'stopBeaconDiscovery', + 'getBeacons', + 'onBeaconUpdate', + 'onBeaconServiceChange', + 'setScreenBrightness', + 'getScreenBrightness', + 'setKeepScreenOn', + 'onUserCaptureScreen', + 'vibrateLong', + 'vibrateShort', + 'addPhoneContact', + 'getHCEState', + 'startHCE', + 'stopHCE', + 'onHCEMessage', + 'sendHCEMessage', + 'startWifi', + 'stopWifi', + 'connectWifi', + 'getWifiList', + 'onGetWifiList', + 'setWifiList', + 'onWifiConnected', + 'getConnectedWifi', + 'setNavigationBarColor', + 'setTopBarText', + 'getExtConfig', + 'getExtConfigSync', + 'getPhoneNumber', + 'updateShareMenu', + 'getShareInfo', + 'chooseAddress', + 'addCard', + 'openCard', + 'getWeRunData', + 'launchApp', + 'chooseInvoiceTitle', + 'checkIsSupportSoterAuthentication', + 'startSoterAuthentication', + 'checkIsSoterEnrolledInDevice', + 'createWorker', + 'reportMonitor', + 'getLogManager', + 'onUserCaptureScreen', + 'reportAnalytics' +]; +const canIUses = []; + +const CALLBACKS = ['success', 'fail', 'cancel', 'complete']; + +function processCallback (methodName, method, returnValue) { + return function (res) { + return method(processReturnValue(methodName, res, returnValue)) + } +} + +function processArgs (methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) { + if (isPlainObject(fromArgs)) { // 一般 api 的参数解析 + const toArgs = keepFromArgs === true ? fromArgs : {}; // returnValue 为 false 时，说明是格式化返回值，直接在返回值对象上修改赋值 + if (isFn(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {}; + } + for (let key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key]; + if (isFn(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs); + } + if (!keyOption) { // 不支持的参数 + console.warn(`QQ小程序 ${methodName}暂不支持${key}`); + } else if (isStr(keyOption)) { // 重写参数 key + toArgs[keyOption] = fromArgs[key]; + } else if (isPlainObject(keyOption)) { // {name:newName,value:value}可重新指定参数 key:value + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value; + } + } else if (CALLBACKS.indexOf(key) !== -1) { + toArgs[key] = processCallback(methodName, fromArgs[key], returnValue); + } else { + if (!keepFromArgs) { + toArgs[key] = fromArgs[key]; + } + } + } + return toArgs + } else if (isFn(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue); + } + return fromArgs +} + +function processReturnValue (methodName, res, returnValue, keepReturnValue = false) { + if (isFn(protocols.returnValue)) { // 处理通用 returnValue + res = protocols.returnValue(methodName, res); + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue) +} + +function wrapper (methodName, method) { + if (hasOwn(protocols, methodName)) { + const protocol = protocols[methodName]; + if (!protocol) { // 暂不支持的 api + return function () { + console.error(`QQ小程序 暂不支持${methodName}`); + } + } + return function (arg1, arg2) { // 目前 api 最多两个参数 + let options = protocol; + if (isFn(protocol)) { + options = protocol(arg1); + } + + arg1 = processArgs(methodName, arg1, options.args, options.returnValue); + + const args = [arg1]; + if (typeof arg2 !== 'undefined') { + args.push(arg2); + } + const returnValue = wx[options.name || methodName].apply(wx, args); + if (isSyncApi(methodName)) { // 同步 api + return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName)) + } + return returnValue + } + } + return method +} + +const todoApis = Object.create(null); + +const TODOS = [ + 'subscribePush', + 'unsubscribePush', + 'onPush', + 'offPush', + 'share' +]; + +function createTodoApi (name) { + return function todoApi ({ + fail, + complete + }) { + const res = { + errMsg: `${name}:fail:暂不支持 ${name} 方法` + }; + isFn(fail) && fail(res); + isFn(complete) && complete(res); + } +} + +TODOS.forEach(function (name) { + todoApis[name] = createTodoApi(name); +}); + +var providers = { + oauth: ['qq'], + share: ['qq'], + payment: ['qqpay'], + push: ['qq'] +}; + +function getProvider ({ + service, + success, + fail, + complete +}) { + let res = false; + if (providers[service]) { + res = { + errMsg: 'getProvider:ok', + service, + provider: providers[service] + }; + isFn(success) && success(res); + } else { + res = { + errMsg: 'getProvider:fail:服务[' + service + ']不存在' + }; + isFn(fail) && fail(res); + } + isFn(complete) && complete(res); +} + +var extraApi = /*#__PURE__*/Object.freeze({ + getProvider: getProvider +}); + +const getEmitter = (function () { + if (typeof getUniEmitter === 'function') { + /* eslint-disable no-undef */ + return getUniEmitter + } + let Emitter; + return function getUniEmitter () { + if (!Emitter) { + Emitter = new Vue(); + } + return Emitter + } +})(); + +function apply (ctx, method, args) { + return ctx[method].apply(ctx, args) +} + +function $on () { + return apply(getEmitter(), '$on', [...arguments]) +} +function $off () { + return apply(getEmitter(), '$off', [...arguments]) +} +function $once () { + return apply(getEmitter(), '$once', [...arguments]) +} +function $emit () { + return apply(getEmitter(), '$emit', [...arguments]) +} + + + +var eventApi = /*#__PURE__*/Object.freeze({ + $on: $on, + $off: $off, + $once: $once, + $emit: $emit +}); + + + +var api = /*#__PURE__*/Object.freeze({ + +}); + +const MPPage = Page; +const MPComponent = Component; + +const customizeRE = /:/g; + +const customize = cached((str) => { + return camelize(str.replace(customizeRE, '-')) +}); + +function initTriggerEvent (mpInstance) { + const oldTriggerEvent = mpInstance.triggerEvent; + mpInstance.triggerEvent = function (event, ...args) { + return oldTriggerEvent.apply(mpInstance, [customize(event), ...args]) + }; +} + +function initHook (name, options) { + const oldHook = options[name]; + if (!oldHook) { + options[name] = function () { + initTriggerEvent(this); + }; + } else { + options[name] = function (...args) { + initTriggerEvent(this); + return oldHook.apply(this, args) + }; + } +} + +Page = function (options = {}) { + initHook('onLoad', options); + return MPPage(options) +}; + +Component = function (options = {}) { + initHook('created', options); + return MPComponent(options) +}; + +const PAGE_EVENT_HOOKS = [ + 'onPullDownRefresh', + 'onReachBottom', + 'onShareAppMessage', + 'onPageScroll', + 'onResize', + 'onTabItemTap' +]; + +function initMocks (vm, mocks) { + const mpInstance = vm.$mp[vm.mpType]; + mocks.forEach(mock => { + if (hasOwn(mpInstance, mock)) { + vm[mock] = mpInstance[mock]; + } + }); +} + +function hasHook (hook, vueOptions) { + if (!vueOptions) { + return true + } + + vueOptions = vueOptions.default || vueOptions; + + if (isFn(vueOptions)) { + vueOptions = vueOptions.extendOptions; + } + + if (isFn(vueOptions[hook])) { + return true + } + const mixins = vueOptions.mixins; + if (Array.isArray(mixins)) { + return !!mixins.find(mixin => hasHook(hook, mixin)) + } +} + +function initHooks (mpOptions, hooks, vueOptions) { + hooks.forEach(hook => { + if (hasHook(hook, vueOptions)) { + mpOptions[hook] = function (args) { + return this.$vm && this.$vm.__call_hook(hook, args) + }; + } + }); +} + +function initVueComponent (Vue$$1, vueOptions) { + vueOptions = vueOptions.default || vueOptions; + let VueComponent; + if (isFn(vueOptions)) { + VueComponent = vueOptions; + vueOptions = VueComponent.extendOptions; + } else { + VueComponent = Vue$$1.extend(vueOptions); + } + return [VueComponent, vueOptions] +} + +function initSlots (vm, vueSlots) { + if (Array.isArray(vueSlots) && vueSlots.length) { + const $slots = Object.create(null); + vueSlots.forEach(slotName => { + $slots[slotName] = true; + }); + vm.$scopedSlots = vm.$slots = $slots; + } +} + +function initVueIds (vueIds, mpInstance) { + vueIds = (vueIds || '').split(','); + const len = vueIds.length; + + if (len === 1) { + mpInstance._$vueId = vueIds[0]; + } else if (len === 2) { + mpInstance._$vueId = vueIds[0]; + mpInstance._$vuePid = vueIds[1]; + } +} + +function initData (vueOptions, context) { + let data = vueOptions.data || {}; + const methods = vueOptions.methods || {}; + + if (typeof data === 'function') { + try { + data = data.call(context); // 支持 Vue.prototype 上挂的数据 + } catch (e) { + if (process.env.VUE_APP_DEBUG) { + console.warn('根据 Vue 的 data 函数初始化小程序 data 失败，请尽量确保 data 函数中不访问 vm 对象，否则可能影响首次数据渲染速度。', data); + } + } + } else { + try { + // 对 data 格式化 + data = JSON.parse(JSON.stringify(data)); + } catch (e) {} + } + + if (!isPlainObject(data)) { + data = {}; + } + + Object.keys(methods).forEach(methodName => { + if (context.__lifecycle_hooks__.indexOf(methodName) === -1 && !hasOwn(data, methodName)) { + data[methodName] = methods[methodName]; + } + }); + + return data +} + +const PROP_TYPES = [String, Number, Boolean, Object, Array, null]; + +function createObserver (name) { + return function observer (newVal, oldVal) { + if (this.$vm) { + this.$vm[name] = newVal; // 为了触发其他非 render watcher + } + } +} + +function initBehaviors (vueOptions, initBehavior) { + const vueBehaviors = vueOptions['behaviors']; + const vueExtends = vueOptions['extends']; + const vueMixins = vueOptions['mixins']; + + let vueProps = vueOptions['props']; + + if (!vueProps) { + vueOptions['props'] = vueProps = []; + } + + const behaviors = []; + if (Array.isArray(vueBehaviors)) { + vueBehaviors.forEach(behavior => { + behaviors.push(behavior.replace('uni://', `${"wx"}://`)); + if (behavior === 'uni://form-field') { + if (Array.isArray(vueProps)) { + vueProps.push('name'); + vueProps.push('value'); + } else { + vueProps['name'] = String; + vueProps['value'] = null; + } + } + }); + } + if (isPlainObject(vueExtends) && vueExtends.props) { + behaviors.push( + initBehavior({ + properties: initProperties(vueExtends.props, true) + }) + ); + } + if (Array.isArray(vueMixins)) { + vueMixins.forEach(vueMixin => { + if (isPlainObject(vueMixin) && vueMixin.props) { + behaviors.push( + initBehavior({ + properties: initProperties(vueMixin.props, true) + }) + ); + } + }); + } + return behaviors +} + +function parsePropType (key, type, defaultValue, file) { + // [String]=>String + if (Array.isArray(type) && type.length === 1) { + return type[0] + } + return type +} + +function initProperties (props, isBehavior = false, file = '') { + const properties = {}; + if (!isBehavior) { + properties.vueId = { + type: String, + value: '' + }; + properties.vueSlots = { // 小程序不能直接定义 $slots 的 props，所以通过 vueSlots 转换到 $slots + type: null, + value: [], + observer: function (newVal, oldVal) { + const $slots = Object.create(null); + newVal.forEach(slotName => { + $slots[slotName] = true; + }); + this.setData({ + $slots + }); + } + }; + } + if (Array.isArray(props)) { // ['title'] + props.forEach(key => { + properties[key] = { + type: null, + observer: createObserver(key) + }; + }); + } else if (isPlainObject(props)) { // {title:{type:String,default:''},content:String} + Object.keys(props).forEach(key => { + const opts = props[key]; + if (isPlainObject(opts)) { // title:{type:String,default:''} + let value = opts['default']; + if (isFn(value)) { + value = value(); + } + + opts.type = parsePropType(key, opts.type, value, file); + + properties[key] = { + type: PROP_TYPES.indexOf(opts.type) !== -1 ? opts.type : null, + value, + observer: createObserver(key) + }; + } else { // content:String + const type = parsePropType(key, opts, null, file); + properties[key] = { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null, + observer: createObserver(key) + }; + } + }); + } + return properties +} + +function wrapper$1 (event) { + // TODO 又得兼容 mpvue 的 mp 对象 + try { + event.mp = JSON.parse(JSON.stringify(event)); + } catch (e) {} + + event.stopPropagation = noop; + event.preventDefault = noop; + + event.target = event.target || {}; + + if (!hasOwn(event, 'detail')) { + event.detail = {}; + } + + if (isPlainObject(event.detail)) { + event.target = Object.assign({}, event.target, event.detail); + } + + return event +} + +function getExtraValue (vm, dataPathsArray) { + let context = vm; + dataPathsArray.forEach(dataPathArray => { + const dataPath = dataPathArray[0]; + const value = dataPathArray[2]; + if (dataPath || typeof value !== 'undefined') { // ['','',index,'disable'] + const propPath = dataPathArray[1]; + const valuePath = dataPathArray[3]; + + const vFor = dataPath ? vm.__get_value(dataPath, context) : context; + + if (Number.isInteger(vFor)) { + context = value; + } else if (!propPath) { + context = vFor[value]; + } else { + if (Array.isArray(vFor)) { + context = vFor.find(vForItem => { + return vm.__get_value(propPath, vForItem) === value + }); + } else if (isPlainObject(vFor)) { + context = Object.keys(vFor).find(vForKey => { + return vm.__get_value(propPath, vFor[vForKey]) === value + }); + } else { + console.error('v-for 暂不支持循环数据：', vFor); + } + } + + if (valuePath) { + context = vm.__get_value(valuePath, context); + } + } + }); + return context +} + +function processEventExtra (vm, extra, event) { + const extraObj = {}; + + if (Array.isArray(extra) && extra.length) { + /** + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *'test' + */ + extra.forEach((dataPath, index) => { + if (typeof dataPath === 'string') { + if (!dataPath) { // model,prop.sync + extraObj['$' + index] = vm; + } else { + if (dataPath === '$event') { // $event + extraObj['$' + index] = event; + } else if (dataPath.indexOf('$event.') === 0) { // $event.target.value + extraObj['$' + index] = vm.__get_value(dataPath.replace('$event.', ''), event); + } else { + extraObj['$' + index] = vm.__get_value(dataPath); + } + } + } else { + extraObj['$' + index] = getExtraValue(vm, dataPath); + } + }); + } + + return extraObj +} + +function getObjByArray (arr) { + const obj = {}; + for (let i = 1; i < arr.length; i++) { + const element = arr[i]; + obj[element[0]] = element[1]; + } + return obj +} + +function processEventArgs (vm, event, args = [], extra = [], isCustom, methodName) { + let isCustomMPEvent = false; // wxcomponent 组件，传递原始 event 对象 + if (isCustom) { // 自定义事件 + isCustomMPEvent = event.currentTarget && + event.currentTarget.dataset && + event.currentTarget.dataset.comType === 'wx'; + if (!args.length) { // 无参数，直接传入 event 或 detail 数组 + if (isCustomMPEvent) { + return [event] + } + return event.detail.__args__ || event.detail + } + } + + const extraObj = processEventExtra(vm, extra, event); + + const ret = []; + args.forEach(arg => { + if (arg === '$event') { + if (methodName === '__set_model' && !isCustom) { // input v-model value + ret.push(event.target.value); + } else { + if (isCustom && !isCustomMPEvent) { + ret.push(event.detail.__args__[0]); + } else { // wxcomponent 组件或内置组件 + ret.push(event); + } + } + } else { + if (Array.isArray(arg) && arg[0] === 'o') { + ret.push(getObjByArray(arg)); + } else if (typeof arg === 'string' && hasOwn(extraObj, arg)) { + ret.push(extraObj[arg]); + } else { + ret.push(arg); + } + } + }); + + return ret +} + +const ONCE = '~'; +const CUSTOM = '^'; + +function isMatchEventType (eventType, optType) { + return (eventType === optType) || + ( + optType === 'regionchange' && + ( + eventType === 'begin' || + eventType === 'end' + ) + ) +} + +function handleEvent (event) { + event = wrapper$1(event); + + // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]] + const eventOpts = (event.currentTarget || event.target).dataset.eventOpts; + if (!eventOpts) { + return console.warn(`事件信息不存在`) + } + + // [['handle',[1,2,a]],['handle1',[1,2,a]]] + const eventType = event.type; + eventOpts.forEach(eventOpt => { + let type = eventOpt[0]; + const eventsArray = eventOpt[1]; + + const isCustom = type.charAt(0) === CUSTOM; + type = isCustom ? type.slice(1) : type; + const isOnce = type.charAt(0) === ONCE; + type = isOnce ? type.slice(1) : type; + + if (eventsArray && isMatchEventType(eventType, type)) { + eventsArray.forEach(eventArray => { + const methodName = eventArray[0]; + if (methodName) { + let handlerCtx = this.$vm; + if ( + handlerCtx.$options.generic && + handlerCtx.$parent && + handlerCtx.$parent.$parent + ) { // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots + handlerCtx = handlerCtx.$parent.$parent; + } + const handler = handlerCtx[methodName]; + if (!isFn(handler)) { + throw new Error(` _vm.${methodName} is not a function`) + } + if (isOnce) { + if (handler.once) { + return + } + handler.once = true; + } + handler.apply(handlerCtx, processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + )); + } + }); + } + }); +} + +const hooks = [ + 'onShow', + 'onHide', + 'onError', + 'onPageNotFound' +]; + +function parseBaseApp (vm, { + mocks, + initRefs +}) { + Vue.prototype.mpHost = "mp-qq"; + + Vue.mixin({ + beforeCreate () { + if (!this.$options.mpType) { + return + } + + this.mpType = this.$options.mpType; + + this.$mp = { + data: {}, + [this.mpType]: this.$options.mpInstance + }; + + this.$scope = this.$options.mpInstance; + + delete this.$options.mpType; + delete this.$options.mpInstance; + + if (this.mpType !== 'app') { + initRefs(this); + initMocks(this, mocks); + } + } + }); + + const appOptions = { + onLaunch (args) { + + this.$vm = vm; + + this.$vm.$mp = { + app: this + }; + + this.$vm.$scope = this; + + this.$vm._isMounted = true; + this.$vm.__call_hook('mounted', args); + + this.$vm.__call_hook('onLaunch', args); + } + }; + + // 兼容旧版本 globalData + appOptions.globalData = vm.$options.globalData || {}; + + initHooks(appOptions, hooks); + + return appOptions +} + +const mocks = ['__route__', '__wxExparserNodeId__', '__wxWebviewId__']; + +function findVmByVueId (vm, vuePid) { + const $children = vm.$children; + // 优先查找直属 + let parentVm = $children.find(childVm => childVm.$scope._$vueId === vuePid); + if (parentVm) { + return parentVm + } + // 反向递归查找 + for (let i = $children.length - 1; i >= 0; i--) { + parentVm = findVmByVueId($children[i], vuePid); + if (parentVm) { + return parentVm + } + } +} + +function initBehavior (options) { + return Behavior(options) +} + +function isPage () { + return !!this.route +} + +function initRelation (detail) { + this.triggerEvent('__l', detail); +} + +function initRefs (vm) { + const mpInstance = vm.$scope; + Object.defineProperty(vm, '$refs', { + get () { + const $refs = {}; + const components = mpInstance.selectAllComponents('.vue-ref'); + components.forEach(component => { + const ref = component.dataset.ref; + $refs[ref] = component.$vm || component; + }); + const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for'); + forComponents.forEach(component => { + const ref = component.dataset.ref; + if (!$refs[ref]) { + $refs[ref] = []; + } + $refs[ref].push(component.$vm || component); + }); + return $refs + } + }); +} + +function handleLink (event) { + const { + vuePid, + vueOptions + } = event.detail || event.value; // detail 是微信,value 是百度(dipatch) + + let parentVm; + + if (vuePid) { + parentVm = findVmByVueId(this.$vm, vuePid); + } + + if (!parentVm) { + parentVm = this.$vm; + } + + vueOptions.parent = parentVm; +} + +function parseApp (vm) { + return parseBaseApp(vm, { + mocks, + initRefs + }) +} + +function parseApp$1 (vm) { + return parseApp(vm) +} + +function createApp (vm) { + App(parseApp$1(vm)); + return vm +} + +function parseBaseComponent (vueComponentOptions, { + isPage: isPage$$1, + initRelation: initRelation$$1 +} = {}) { + let [VueComponent, vueOptions] = initVueComponent(Vue, vueComponentOptions); + + const componentOptions = { + options: { + multipleSlots: true, + addGlobalClass: true + }, + data: initData(vueOptions, Vue.prototype), + behaviors: initBehaviors(vueOptions, initBehavior), + properties: initProperties(vueOptions.props, false, vueOptions.__file), + lifetimes: { + attached () { + const properties = this.properties; + + const options = { + mpType: isPage$$1.call(this) ? 'page' : 'component', + mpInstance: this, + propsData: properties + }; + + initVueIds(properties.vueId, this); + + // 处理父子关系 + initRelation$$1.call(this, { + vuePid: this._$vuePid, + vueOptions: options + }); + + // 初始化 vue 实例 + this.$vm = new VueComponent(options); + + // 处理$slots,$scopedSlots（暂不支持动态变化$slots） + initSlots(this.$vm, properties.vueSlots); + + // 触发首次 setData + this.$vm.$mount(); + }, + ready () { + // 当组件 props 默认值为 true，初始化时传入 false 会导致 created,ready 触发, 但 attached 不触发 + // https://developers.weixin.qq.com/community/develop/doc/00066ae2844cc0f8eb883e2a557800 + if (this.$vm) { + this.$vm._isMounted = true; + this.$vm.__call_hook('mounted'); + this.$vm.__call_hook('onReady'); + } + }, + detached () { + this.$vm.$destroy(); + } + }, + pageLifetimes: { + show (args) { + this.$vm && this.$vm.__call_hook('onPageShow', args); + }, + hide () { + this.$vm && this.$vm.__call_hook('onPageHide'); + }, + resize (size) { + this.$vm && this.$vm.__call_hook('onPageResize', size); + } + }, + methods: { + __l: handleLink, + __e: handleEvent + } + }; + + if (isPage$$1) { + return componentOptions + } + return [componentOptions, VueComponent] +} + +function parseComponent (vueComponentOptions) { + return parseBaseComponent(vueComponentOptions, { + isPage, + initRelation + }) +} + +function parseComponent$1 (vueComponentOptions) { + return parseComponent(vueComponentOptions) +} + +const hooks$1 = [ + 'onShow', + 'onHide', + 'onUnload' +]; + +hooks$1.push(...PAGE_EVENT_HOOKS); + +function parseBasePage (vuePageOptions, { + isPage, + initRelation +}) { + const pageOptions = parseComponent$1(vuePageOptions, { + isPage, + initRelation + }); + + initHooks(pageOptions.methods, hooks$1, vuePageOptions); + + pageOptions.methods.onLoad = function (args) { + this.$vm.$mp.query = args; // 兼容 mpvue + this.$vm.__call_hook('onLoad', args); + }; + + return pageOptions +} + +function parsePage (vuePageOptions) { + return parseBasePage(vuePageOptions, { + isPage, + initRelation + }) +} + +function parsePage$1 (vuePageOptions) { + return parsePage(vuePageOptions) +} + +function createPage (vuePageOptions) { + { + return Component(parsePage$1(vuePageOptions)) + } +} + +function createComponent (vueOptions) { + { + return Component(parseComponent$1(vueOptions)) + } +} + +todos.forEach(todoApi => { + protocols[todoApi] = false; +}); + +canIUses.forEach(canIUseApi => { + const apiName = protocols[canIUseApi] && protocols[canIUseApi].name ? protocols[canIUseApi].name + : canIUseApi; + if (!wx.canIUse(apiName)) { + protocols[canIUseApi] = false; + } +}); + +let uni = {}; + +if (typeof Proxy !== 'undefined') { + uni = new Proxy({}, { + get (target, name) { + if (name === 'upx2px') { + return upx2px + } + if (api[name]) { + return promisify(name, api[name]) + } + { + if (extraApi[name]) { + return promisify(name, extraApi[name]) + } + if (todoApis[name]) { + return promisify(name, todoApis[name]) + } + } + if (eventApi[name]) { + return eventApi[name] + } + if (!hasOwn(wx, name) && !hasOwn(protocols, name)) { + return + } + return promisify(name, wrapper(name, wx[name])) + } + }); +} else { + uni.upx2px = upx2px; + + { + Object.keys(todoApis).forEach(name => { + uni[name] = promisify(name, todoApis[name]); + }); + Object.keys(extraApi).forEach(name => { + uni[name] = promisify(name, todoApis[name]); + }); + } + + Object.keys(eventApi).forEach(name => { + uni[name] = eventApi[name]; + }); + + Object.keys(api).forEach(name => { + uni[name] = promisify(name, api[name]); + }); + + Object.keys(wx).forEach(name => { + if (hasOwn(wx, name) || hasOwn(protocols, name)) { + uni[name] = promisify(name, wrapper(name, wx[name])); + } + }); +} + +wx.createApp = createApp; +wx.createPage = createPage; +wx.createComponent = createComponent; + +var uni$1 = uni; + +export default uni$1; +export { createApp, createPage, createComponent }; diff --git a/packages/uni-mp-qq/package.json b/packages/uni-mp-qq/package.json new file mode 100644 index 0000000000000000000000000000000000000000..8a909f40282a915338a857fbcbae100739c726f3 --- /dev/null +++ b/packages/uni-mp-qq/package.json @@ -0,0 +1,11 @@ +{ + "name": "@dcloudio/uni-mp-qq", + "version": "0.0.100", + "description": "uni-app mp-qq", + "main": "dist/index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "author": "fxy060608", + "license": "Apache-2.0" +} diff --git a/src/platforms/mp-qq/runtime/index.js b/src/platforms/mp-qq/runtime/index.js new file mode 100644 index 0000000000000000000000000000000000000000..5a843bc821374df4c1959470c611958c8b82d732 --- /dev/null +++ b/src/platforms/mp-qq/runtime/index.js @@ -0,0 +1 @@ +import '../../mp-weixin/runtime/index' diff --git a/src/platforms/mp-qq/runtime/wrapper/app-parser.js b/src/platforms/mp-qq/runtime/wrapper/app-parser.js new file mode 100644 index 0000000000000000000000000000000000000000..949c23857943ba79ee9206731091c4dedd18e88e --- /dev/null +++ b/src/platforms/mp-qq/runtime/wrapper/app-parser.js @@ -0,0 +1,5 @@ +import parseBaseApp from '../../../mp-weixin/runtime/wrapper/app-parser' + +export default function parseApp (vm) { + return parseBaseApp(vm) +} diff --git a/src/platforms/mp-qq/runtime/wrapper/component-parser.js b/src/platforms/mp-qq/runtime/wrapper/component-parser.js new file mode 100644 index 0000000000000000000000000000000000000000..49f48ab77ac78a39bc37f665775e616a3d43bdfc --- /dev/null +++ b/src/platforms/mp-qq/runtime/wrapper/component-parser.js @@ -0,0 +1,5 @@ +import parseBaseComponent from '../../../mp-weixin/runtime/wrapper/component-parser' + +export default function parseComponent (vueComponentOptions) { + return parseBaseComponent(vueComponentOptions) +} diff --git a/src/platforms/mp-qq/runtime/wrapper/page-parser.js b/src/platforms/mp-qq/runtime/wrapper/page-parser.js new file mode 100644 index 0000000000000000000000000000000000000000..f343fdc3ac986c044bbc8cfccd9f399d45ab207b --- /dev/null +++ b/src/platforms/mp-qq/runtime/wrapper/page-parser.js @@ -0,0 +1,5 @@ +import parseBasePage from '../../../mp-weixin/runtime/wrapper/page-parser' + +export default function parsePage (vuePageOptions) { + return parseBasePage(vuePageOptions) +} diff --git a/src/platforms/mp-qq/service/api/index.js b/src/platforms/mp-qq/service/api/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/platforms/mp-qq/service/api/protocols.js b/src/platforms/mp-qq/service/api/protocols.js new file mode 100644 index 0000000000000000000000000000000000000000..464d4016b4d10995db0708faaa2564f1cb45201d --- /dev/null +++ b/src/platforms/mp-qq/service/api/protocols.js @@ -0,0 +1,73 @@ +import previewImage from '../../../mp-weixin/helpers/normalize-preview-image' +export const protocols = { + previewImage +} +export const todos = [ + 'connectSocket', + 'onSocketOpen', + 'onSocketError', + 'sendSocketMessage', + 'onSocketMessage', + 'closeSocket', + 'onSocketClose', + 'createLivePlayerContext', + 'createLivePusherContext', + 'loadFontFace', + 'openDocument', + 'canIUse', + 'onMemoryWarning', + 'onNetworkStatusChange', + 'onAccelerometerChange', + 'startAccelerometer', + 'stopAccelerometer', + 'onCompassChange', + 'startCompass', + 'scanCode', + 'startBeaconDiscovery', + 'stopBeaconDiscovery', + 'getBeacons', + 'onBeaconUpdate', + 'onBeaconServiceChange', + 'setScreenBrightness', + 'getScreenBrightness', + 'setKeepScreenOn', + 'onUserCaptureScreen', + 'vibrateLong', + 'vibrateShort', + 'addPhoneContact', + 'getHCEState', + 'startHCE', + 'stopHCE', + 'onHCEMessage', + 'sendHCEMessage', + 'startWifi', + 'stopWifi', + 'connectWifi', + 'getWifiList', + 'onGetWifiList', + 'setWifiList', + 'onWifiConnected', + 'getConnectedWifi', + 'setNavigationBarColor', + 'setTopBarText', + 'getExtConfig', + 'getExtConfigSync', + 'getPhoneNumber', + 'updateShareMenu', + 'getShareInfo', + 'chooseAddress', + 'addCard', + 'openCard', + 'getWeRunData', + 'launchApp', + 'chooseInvoiceTitle', + 'checkIsSupportSoterAuthentication', + 'startSoterAuthentication', + 'checkIsSoterEnrolledInDevice', + 'createWorker', + 'reportMonitor', + 'getLogManager', + 'onUserCaptureScreen', + 'reportAnalytics' +] +export const canIUses = [] diff --git a/src/platforms/mp-qq/service/api/providers.js b/src/platforms/mp-qq/service/api/providers.js new file mode 100644 index 0000000000000000000000000000000000000000..8dbb83de2b6ab966c89f4295629e2430a3193148 --- /dev/null +++ b/src/platforms/mp-qq/service/api/providers.js @@ -0,0 +1,6 @@ +export default { + oauth: ['qq'], + share: ['qq'], + payment: ['qqpay'], + push: ['qq'] +}