初始化

uni_modules/UniDevTools/node_modules/@dcloudio/uni-mp-weixin/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.

uni_modules/UniDevTools/node_modules/@dcloudio/uni-mp-weixin/dist/uni.compiler.js

@@ -0,0 +1,265 @@
+'use strict';
+
+var uniCliShared = require('@dcloudio/uni-cli-shared');
+var initMiniProgramPlugin = require('@dcloudio/uni-mp-vite');
+var path = require('path');
+var compilerCore = require('@vue/compiler-core');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var initMiniProgramPlugin__default = /*#__PURE__*/_interopDefault(initMiniProgramPlugin);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var uniad_app_json = function (appJson) {
+  if (!appJson.plugins) {
+    appJson.plugins = {};
+  }
+  if (!appJson.plugins['uni-ad']) {
+    appJson.plugins['uni-ad'] = {
+      version: '1.1.10',
+      provider: 'wxf72d316417b6767f',
+    };
+  }
+  if (!appJson.plugins['coral-adv']) {
+    appJson.plugins['coral-adv'] = {
+      version: '1.0.18',
+      provider: 'wx0e203209e27b1e66',
+    };
+  }
+
+  if (!appJson.usingComponents) {
+    appJson.usingComponents = {};
+  }
+  if (!appJson.usingComponents['uniad-plugin']) {
+    appJson.usingComponents['uniad-plugin'] = 'plugin://uni-ad/ad';
+  }
+};
+
+var uniadAppJson = uniad_app_json;
+
+const AD_COMPONENTS = [
+    'uniad',
+    'ad-rewarded-video',
+    'ad-fullscreen-video',
+    'ad-interstitial',
+];
+let appJsonUniadFlag = false;
+function transformAd(node, context) {
+    if (!uniCliShared.isElementNode(node)) {
+        return;
+    }
+    const adpidProp = compilerCore.findProp(node, 'adpid');
+    if (node.tag === 'ad' && adpidProp) {
+        node.tag = 'uniad';
+        node.tagType = 1 /* ElementTypes.COMPONENT */;
+    }
+    if (appJsonUniadFlag) {
+        return;
+    }
+    if (AD_COMPONENTS.indexOf(node.tag) > -1) {
+        appJsonUniadFlag = true;
+        uniadAppJson(uniCliShared.findJsonFile('app'));
+    }
+}
+
+var description = "项目配置文件。";
+var packOptions = {
+	ignore: [
+	]
+};
+var setting = {
+	urlCheck: false,
+	es6: true,
+	postcss: false,
+	minified: false,
+	newFeature: true,
+	bigPackageSizeSupport: true
+};
+var compileType = "miniprogram";
+var libVersion = "";
+var appid = "touristappid";
+var projectname = "";
+var condition = {
+	search: {
+		current: -1,
+		list: [
+		]
+	},
+	conversation: {
+		current: -1,
+		list: [
+		]
+	},
+	game: {
+		current: -1,
+		list: [
+		]
+	},
+	miniprogram: {
+		current: -1,
+		list: [
+		]
+	}
+};
+var source = {
+	description: description,
+	packOptions: packOptions,
+	setting: setting,
+	compileType: compileType,
+	libVersion: libVersion,
+	appid: appid,
+	projectname: projectname,
+	condition: condition
+};
+
+const customElements = [
+    'page-container',
+    'page-meta',
+    'navigation-bar',
+    'match-media',
+    'ad-custom',
+    'share-element',
+    'channel-live',
+    'channel-video',
+    'voip-room',
+    'root-portal',
+    'subscribe',
+    // 手势组件
+    'tap-gesture-handler',
+    'double-tap-gesture-handler',
+    'scale-gesture-handler',
+    'force-press-gesture-handler',
+    'pan-gesture-handler',
+    'vertical-drag-gesture-handler',
+    'horizontal-drag-gesture-handler',
+    'long-press-gesture-handler',
+    'grid-view',
+    'list-view',
+    'sticky-header',
+    'sticky-section',
+];
+const compilerOptions = {
+    nodeTransforms: [uniCliShared.transformRef, uniCliShared.transformComponentLink, transformAd],
+};
+const COMPONENTS_DIR = 'wxcomponents';
+const miniProgram = {
+    class: {
+        array: true,
+    },
+    slot: {
+        fallbackContent: false,
+        dynamicSlotNames: true,
+    },
+    event: {
+        key: true,
+    },
+    directive: 'wx:',
+    lazyElement: {
+        canvas: [
+            { name: 'bind', arg: ['canvas-id', 'id'] },
+            {
+                name: 'on',
+                arg: ['touchstart', 'touchmove', 'touchcancel', 'touchend'],
+            },
+        ],
+        editor: [
+            {
+                name: 'on',
+                arg: ['ready'],
+            },
+        ],
+        'scroll-view': [
+            {
+                name: 'on',
+                arg: ['dragstart', 'dragging', 'dragend'],
+            },
+        ],
+        // iOS 平台需要延迟
+        input: [{ name: 'bind', arg: ['type'] }],
+        textarea: [{ name: 'on', arg: ['input'] }],
+    },
+    component: {
+        dir: COMPONENTS_DIR,
+        vShow: uniCliShared.COMPONENT_CUSTOM_HIDDEN,
+        getPropertySync: false,
+        normalizeName: (name) => name.startsWith('wx-') ? name.replace('wx-', 'weixin-') : name,
+    },
+};
+const projectConfigFilename = 'project.config.json';
+const options = {
+    cdn: 1,
+    vite: {
+        inject: {
+            uni: [path__default.default.resolve(__dirname, 'uni.api.esm.js'), 'default'],
+            wx: [path__default.default.resolve(__dirname, 'uni.api.esm.js'), 'wx'],
+        },
+        alias: {
+            'uni-mp-runtime': path__default.default.resolve(__dirname, 'uni.mp.esm.js'),
+        },
+        copyOptions: {
+            assets: [COMPONENTS_DIR],
+            targets: [
+                ...(process.env.UNI_MP_PLUGIN ? [uniCliShared.copyMiniProgramPluginJson] : []),
+                {
+                    src: [
+                        'sitemap.json',
+                        'ext.json',
+                        'custom-tab-bar',
+                        'functional-pages',
+                        'project.private.config.json',
+                        projectConfigFilename,
+                    ],
+                    get dest() {
+                        return process.env.UNI_OUTPUT_DIR;
+                    },
+                },
+                ...uniCliShared.copyMiniProgramThemeJson(),
+            ],
+        },
+    },
+    global: 'wx',
+    app: {
+        darkmode: true,
+        subpackages: true,
+        plugins: true,
+        usingComponents: true,
+    },
+    project: {
+        filename: projectConfigFilename,
+        config: ['project.wx.json', 'project.config.json'],
+        source,
+    },
+    template: Object.assign(Object.assign({}, miniProgram), { customElements, filter: {
+            extname: '.wxs',
+            lang: 'wxs',
+            generate(filter, filename) {
+                if (filename) {
+                    return `<wxs src="${filename}.wxs" module="${filter.name}"/>`;
+                }
+                return `<wxs module="${filter.name}">
+${filter.code}
+</wxs>`;
+            },
+        }, extname: '.wxml', compilerOptions }),
+    style: {
+        extname: '.wxss',
+    },
+};
+
+const uniMiniProgramWeixinPlugin = {
+    name: 'uni:mp-weixin',
+    config() {
+        return {
+            define: {
+                __VUE_CREATED_DEFERRED__: false,
+            },
+            build: {
+                // css 中不支持引用本地资源
+                assetsInlineLimit: uniCliShared.ASSETS_INLINE_LIMIT,
+            },
+        };
+    },
+};
+var index = [uniMiniProgramWeixinPlugin, ...initMiniProgramPlugin__default.default(options)];
+
+module.exports = index;

uni_modules/UniDevTools/node_modules/@dcloudio/uni-mp-weixin/dist/uni.mp.esm.js

@@ -0,0 +1,914 @@
+import { SLOT_DEFAULT_NAME, invokeArrayFns, MINI_PROGRAM_PAGE_RUNTIME_HOOKS, ON_LOAD, ON_SHOW, ON_HIDE, ON_UNLOAD, ON_RESIZE, ON_TAB_ITEM_TAP, ON_REACH_BOTTOM, ON_PULL_DOWN_REFRESH, ON_ADD_TO_FAVORITES, isUniLifecycleHook, ON_READY, once, ON_LAUNCH, ON_ERROR, ON_THEME_CHANGE, ON_PAGE_NOT_FOUND, ON_UNHANDLE_REJECTION, addLeadingSlash, stringifyQuery, customizeEvent } from '@dcloudio/uni-shared';
+import { isArray, hasOwn, isFunction, extend, isPlainObject, isObject } from '@vue/shared';
+import { ref, findComponentPropsData, toRaw, updateProps, hasQueueJob, invalidateJob, devtoolsComponentAdded, getExposeProxy, pruneComponentPropsCache } from 'vue';
+import { normalizeLocale, LOCALE_EN } from '@dcloudio/uni-i18n';
+
+const MP_METHODS = [
+    'createSelectorQuery',
+    'createIntersectionObserver',
+    'selectAllComponents',
+    'selectComponent',
+];
+function createEmitFn(oldEmit, ctx) {
+    return function emit(event, ...args) {
+        const scope = ctx.$scope;
+        if (scope && event) {
+            const detail = { __args__: args };
+            {
+                scope.triggerEvent(event, detail);
+            }
+        }
+        return oldEmit.apply(this, [event, ...args]);
+    };
+}
+function initBaseInstance(instance, options) {
+    const ctx = instance.ctx;
+    // mp
+    ctx.mpType = options.mpType; // @deprecated
+    ctx.$mpType = options.mpType;
+    ctx.$mpPlatform = "mp-weixin";
+    ctx.$scope = options.mpInstance;
+    // TODO @deprecated
+    ctx.$mp = {};
+    if (__VUE_OPTIONS_API__) {
+        ctx._self = {};
+    }
+    // slots
+    instance.slots = {};
+    if (isArray(options.slots) && options.slots.length) {
+        options.slots.forEach((name) => {
+            instance.slots[name] = true;
+        });
+        if (instance.slots[SLOT_DEFAULT_NAME]) {
+            instance.slots.default = true;
+        }
+    }
+    ctx.getOpenerEventChannel = function () {
+        // 微信小程序使用自身getOpenerEventChannel
+        {
+            return options.mpInstance.getOpenerEventChannel();
+        }
+    };
+    ctx.$hasHook = hasHook;
+    ctx.$callHook = callHook;
+    // $emit
+    instance.emit = createEmitFn(instance.emit, ctx);
+}
+function initComponentInstance(instance, options) {
+    initBaseInstance(instance, options);
+    const ctx = instance.ctx;
+    MP_METHODS.forEach((method) => {
+        ctx[method] = function (...args) {
+            const mpInstance = ctx.$scope;
+            if (mpInstance && mpInstance[method]) {
+                return mpInstance[method].apply(mpInstance, args);
+            }
+        };
+    });
+}
+function initMocks(instance, mpInstance, mocks) {
+    const ctx = instance.ctx;
+    mocks.forEach((mock) => {
+        if (hasOwn(mpInstance, mock)) {
+            instance[mock] = ctx[mock] = mpInstance[mock];
+        }
+    });
+}
+function hasHook(name) {
+    const hooks = this.$[name];
+    if (hooks && hooks.length) {
+        return true;
+    }
+    return false;
+}
+function callHook(name, args) {
+    if (name === 'mounted') {
+        callHook.call(this, 'bm'); // beforeMount
+        this.$.isMounted = true;
+        name = 'm';
+    }
+    const hooks = this.$[name];
+    return hooks && invokeArrayFns(hooks, args);
+}
+
+const PAGE_INIT_HOOKS = [
+    ON_LOAD,
+    ON_SHOW,
+    ON_HIDE,
+    ON_UNLOAD,
+    ON_RESIZE,
+    ON_TAB_ITEM_TAP,
+    ON_REACH_BOTTOM,
+    ON_PULL_DOWN_REFRESH,
+    ON_ADD_TO_FAVORITES,
+    // 'onReady', // lifetimes.ready
+    // 'onPageScroll', // 影响性能，开发者手动注册
+    // 'onShareTimeline', // 右上角菜单，开发者手动注册
+    // 'onShareAppMessage' // 右上角菜单，开发者手动注册
+];
+function findHooks(vueOptions, hooks = new Set()) {
+    if (vueOptions) {
+        Object.keys(vueOptions).forEach((name) => {
+            if (isUniLifecycleHook(name, vueOptions[name])) {
+                hooks.add(name);
+            }
+        });
+        if (__VUE_OPTIONS_API__) {
+            const { extends: extendsOptions, mixins } = vueOptions;
+            if (mixins) {
+                mixins.forEach((mixin) => findHooks(mixin, hooks));
+            }
+            if (extendsOptions) {
+                findHooks(extendsOptions, hooks);
+            }
+        }
+    }
+    return hooks;
+}
+function initHook(mpOptions, hook, excludes) {
+    if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) {
+        mpOptions[hook] = function (args) {
+            return this.$vm && this.$vm.$callHook(hook, args);
+        };
+    }
+}
+const EXCLUDE_HOOKS = [ON_READY];
+function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) {
+    hooks.forEach((hook) => initHook(mpOptions, hook, excludes));
+}
+function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) {
+    findHooks(vueOptions).forEach((hook) => initHook(mpOptions, hook, excludes));
+}
+function initRuntimeHooks(mpOptions, runtimeHooks) {
+    if (!runtimeHooks) {
+        return;
+    }
+    const hooks = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS);
+    hooks.forEach((hook) => {
+        if (runtimeHooks & MINI_PROGRAM_PAGE_RUNTIME_HOOKS[hook]) {
+            initHook(mpOptions, hook, []);
+        }
+    });
+}
+const findMixinRuntimeHooks = /*#__PURE__*/ once(() => {
+    const runtimeHooks = [];
+    const app = isFunction(getApp) && getApp({ allowDefault: true });
+    if (app && app.$vm && app.$vm.$) {
+        const mixins = app.$vm.$.appContext.mixins;
+        if (isArray(mixins)) {
+            const hooks = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS);
+            mixins.forEach((mixin) => {
+                hooks.forEach((hook) => {
+                    if (hasOwn(mixin, hook) && !runtimeHooks.includes(hook)) {
+                        runtimeHooks.push(hook);
+                    }
+                });
+            });
+        }
+    }
+    return runtimeHooks;
+});
+function initMixinRuntimeHooks(mpOptions) {
+    initHooks(mpOptions, findMixinRuntimeHooks());
+}
+
+const HOOKS = [
+    ON_SHOW,
+    ON_HIDE,
+    ON_ERROR,
+    ON_THEME_CHANGE,
+    ON_PAGE_NOT_FOUND,
+    ON_UNHANDLE_REJECTION,
+];
+function parseApp(instance, parseAppOptions) {
+    const internalInstance = instance.$;
+    if (__VUE_PROD_DEVTOOLS__) {
+        // 定制 App 的 $children
+        Object.defineProperty(internalInstance.ctx, '$children', {
+            get() {
+                return getCurrentPages().map((page) => page.$vm);
+            },
+        });
+    }
+    const appOptions = {
+        globalData: (instance.$options && instance.$options.globalData) || {},
+        $vm: instance,
+        onLaunch(options) {
+            this.$vm = instance; // 飞书小程序可能会把 AppOptions 序列化，导致 $vm 对象部分属性丢失
+            const ctx = internalInstance.ctx;
+            if (this.$vm && ctx.$scope) {
+                // 已经初始化过了，主要是为了百度，百度 onShow 在 onLaunch 之前
+                return;
+            }
+            initBaseInstance(internalInstance, {
+                mpType: 'app',
+                mpInstance: this,
+                slots: [],
+            });
+            ctx.globalData = this.globalData;
+            instance.$callHook(ON_LAUNCH, options);
+        },
+    };
+    initLocale(instance);
+    const vueOptions = instance.$.type;
+    initHooks(appOptions, HOOKS);
+    initUnknownHooks(appOptions, vueOptions);
+    if (__VUE_OPTIONS_API__) {
+        const methods = vueOptions.methods;
+        methods && extend(appOptions, methods);
+    }
+    if (parseAppOptions) {
+        parseAppOptions.parse(appOptions);
+    }
+    return appOptions;
+}
+function initCreateApp(parseAppOptions) {
+    return function createApp(vm) {
+        return App(parseApp(vm, parseAppOptions));
+    };
+}
+function initCreateSubpackageApp(parseAppOptions) {
+    return function createApp(vm) {
+        const appOptions = parseApp(vm, parseAppOptions);
+        const app = isFunction(getApp) &&
+            getApp({
+                allowDefault: true,
+            });
+        if (!app)
+            return;
+        vm.$.ctx.$scope = app;
+        const globalData = app.globalData;
+        if (globalData) {
+            Object.keys(appOptions.globalData).forEach((name) => {
+                if (!hasOwn(globalData, name)) {
+                    globalData[name] = appOptions.globalData[name];
+                }
+            });
+        }
+        Object.keys(appOptions).forEach((name) => {
+            if (!hasOwn(app, name)) {
+                app[name] = appOptions[name];
+            }
+        });
+        initAppLifecycle(appOptions, vm);
+        if (process.env.UNI_SUBPACKAGE) {
+            (wx.$subpackages || (wx.$subpackages = {}))[process.env.UNI_SUBPACKAGE] = {
+                $vm: vm,
+            };
+        }
+    };
+}
+function initAppLifecycle(appOptions, vm) {
+    if (isFunction(appOptions.onLaunch)) {
+        const args = wx.getLaunchOptionsSync && wx.getLaunchOptionsSync();
+        appOptions.onLaunch(args);
+    }
+    if (isFunction(appOptions.onShow) && wx.onAppShow) {
+        wx.onAppShow((args) => {
+            vm.$callHook('onShow', args);
+        });
+    }
+    if (isFunction(appOptions.onHide) && wx.onAppHide) {
+        wx.onAppHide((args) => {
+            vm.$callHook('onHide', args);
+        });
+    }
+}
+function initLocale(appVm) {
+    const locale = ref(normalizeLocale(wx.getSystemInfoSync().language) || LOCALE_EN);
+    Object.defineProperty(appVm, '$locale', {
+        get() {
+            return locale.value;
+        },
+        set(v) {
+            locale.value = v;
+        },
+    });
+}
+
+function initVueIds(vueIds, mpInstance) {
+    if (!vueIds) {
+        return;
+    }
+    const ids = vueIds.split(',');
+    const len = ids.length;
+    if (len === 1) {
+        mpInstance._$vueId = ids[0];
+    }
+    else if (len === 2) {
+        mpInstance._$vueId = ids[0];
+        mpInstance._$vuePid = ids[1];
+    }
+}
+const EXTRAS = ['externalClasses'];
+function initExtraOptions(miniProgramComponentOptions, vueOptions) {
+    EXTRAS.forEach((name) => {
+        if (hasOwn(vueOptions, name)) {
+            miniProgramComponentOptions[name] = vueOptions[name];
+        }
+    });
+}
+const WORKLET_RE = /_(.*)_worklet_factory_/;
+function initWorkletMethods(mpMethods, vueMethods) {
+    if (vueMethods) {
+        Object.keys(vueMethods).forEach((name) => {
+            const matches = name.match(WORKLET_RE);
+            if (matches) {
+                const workletName = matches[1];
+                mpMethods[name] = vueMethods[name];
+                mpMethods[workletName] = vueMethods[workletName];
+            }
+        });
+    }
+}
+function initWxsCallMethods(methods, wxsCallMethods) {
+    if (!isArray(wxsCallMethods)) {
+        return;
+    }
+    wxsCallMethods.forEach((callMethod) => {
+        methods[callMethod] = function (args) {
+            return this.$vm[callMethod](args);
+        };
+    });
+}
+function selectAllComponents(mpInstance, selector, $refs) {
+    const components = mpInstance.selectAllComponents(selector);
+    components.forEach((component) => {
+        const ref = component.properties.uR;
+        $refs[ref] = component.$vm || component;
+    });
+}
+function initRefs(instance, mpInstance) {
+    Object.defineProperty(instance, 'refs', {
+        get() {
+            const $refs = {};
+            selectAllComponents(mpInstance, '.r', $refs);
+            const forComponents = mpInstance.selectAllComponents('.r-i-f');
+            forComponents.forEach((component) => {
+                const ref = component.properties.uR;
+                if (!ref) {
+                    return;
+                }
+                if (!$refs[ref]) {
+                    $refs[ref] = [];
+                }
+                $refs[ref].push(component.$vm || component);
+            });
+            return $refs;
+        },
+    });
+}
+function findVmByVueId(instance, vuePid) {
+    // 标准 vue3 中 没有 $children，定制了内核
+    const $children = instance.$children;
+    // 优先查找直属(反向查找:https://github.com/dcloudio/uni-app/issues/1200)
+    for (let i = $children.length - 1; i >= 0; i--) {
+        const childVm = $children[i];
+        if (childVm.$scope._$vueId === vuePid) {
+            return childVm;
+        }
+    }
+    // 反向递归查找
+    let parentVm;
+    for (let i = $children.length - 1; i >= 0; i--) {
+        parentVm = findVmByVueId($children[i], vuePid);
+        if (parentVm) {
+            return parentVm;
+        }
+    }
+}
+
+const builtInProps = [
+    // 百度小程序,快手小程序自定义组件不支持绑定动态事件，动态dataset，故通过props传递事件信息
+    // event-opts
+    'eO',
+    // 组件 ref
+    'uR',
+    // 组件 ref-in-for
+    'uRIF',
+    // 组件 id
+    'uI',
+    // 组件类型 m: 小程序组件
+    'uT',
+    // 组件 props
+    'uP',
+    // 小程序不能直接定义 $slots 的 props，所以通过 vueSlots 转换到 $slots
+    'uS',
+];
+function initDefaultProps(options, isBehavior = false) {
+    const properties = {};
+    if (!isBehavior) {
+        // 均不指定类型，避免微信小程序 property received type-uncompatible value 警告
+        builtInProps.forEach((name) => {
+            properties[name] = {
+                type: null,
+                value: '',
+            };
+        });
+        // 小程序不能直接定义 $slots 的 props，所以通过 vueSlots 转换到 $slots
+        properties.uS = {
+            type: null,
+            value: [],
+            observer: function (newVal) {
+                const $slots = Object.create(null);
+                newVal &&
+                    newVal.forEach((slotName) => {
+                        $slots[slotName] = true;
+                    });
+                this.setData({
+                    $slots,
+                });
+            },
+        };
+    }
+    if (options.behaviors) {
+        // wx://form-field
+        if (options.behaviors.includes('wx://form-field')) {
+            if (!options.properties || !options.properties.name) {
+                properties.name = {
+                    type: null,
+                    value: '',
+                };
+            }
+            if (!options.properties || !options.properties.value) {
+                properties.value = {
+                    type: null,
+                    value: '',
+                };
+            }
+        }
+    }
+    return properties;
+}
+function initVirtualHostProps(options) {
+    const properties = {};
+    {
+        if ((options && options.virtualHost)) {
+            properties.virtualHostStyle = {
+                type: null,
+                value: '',
+            };
+            properties.virtualHostClass = {
+                type: null,
+                value: '',
+            };
+        }
+    }
+    return properties;
+}
+/**
+ *
+ * @param mpComponentOptions
+ * @param isBehavior
+ */
+function initProps(mpComponentOptions) {
+    if (!mpComponentOptions.properties) {
+        mpComponentOptions.properties = {};
+    }
+    extend(mpComponentOptions.properties, initDefaultProps(mpComponentOptions), initVirtualHostProps(mpComponentOptions.options));
+}
+const PROP_TYPES = [String, Number, Boolean, Object, Array, null];
+function parsePropType(type, defaultValue) {
+    // [String]=>String
+    if (isArray(type) && type.length === 1) {
+        return type[0];
+    }
+    return type;
+}
+function normalizePropType(type, defaultValue) {
+    const res = parsePropType(type);
+    return PROP_TYPES.indexOf(res) !== -1 ? res : null;
+}
+/**
+ * 初始化页面 props，方便接收页面参数，类型均为String，默认值均为''
+ * @param param
+ * @param rawProps
+ */
+function initPageProps({ properties }, rawProps) {
+    if (isArray(rawProps)) {
+        rawProps.forEach((key) => {
+            properties[key] = {
+                type: String,
+                value: '',
+            };
+        });
+    }
+    else if (isPlainObject(rawProps)) {
+        Object.keys(rawProps).forEach((key) => {
+            const opts = rawProps[key];
+            if (isPlainObject(opts)) {
+                // title:{type:String,default:''}
+                let value = opts.default;
+                if (isFunction(value)) {
+                    value = value();
+                }
+                const type = opts.type;
+                opts.type = normalizePropType(type);
+                properties[key] = {
+                    type: opts.type,
+                    value,
+                };
+            }
+            else {
+                // content:String
+                properties[key] = {
+                    type: normalizePropType(opts),
+                };
+            }
+        });
+    }
+}
+function findPropsData(properties, isPage) {
+    return ((isPage
+        ? findPagePropsData(properties)
+        : findComponentPropsData(properties.uP)) || {});
+}
+function findPagePropsData(properties) {
+    const propsData = {};
+    if (isPlainObject(properties)) {
+        Object.keys(properties).forEach((name) => {
+            if (builtInProps.indexOf(name) === -1) {
+                propsData[name] = properties[name];
+            }
+        });
+    }
+    return propsData;
+}
+function initFormField(vm) {
+    // 同步 form-field 的 name,value 值
+    const vueOptions = vm.$options;
+    if (isArray(vueOptions.behaviors) &&
+        vueOptions.behaviors.includes('uni://form-field')) {
+        vm.$watch('modelValue', () => {
+            vm.$scope &&
+                vm.$scope.setData({
+                    name: vm.name,
+                    value: vm.modelValue,
+                });
+        }, {
+            immediate: true,
+        });
+    }
+}
+
+function initData(_) {
+    return {};
+}
+function initPropsObserver(componentOptions) {
+    const observe = function observe() {
+        const up = this.properties.uP;
+        if (!up) {
+            return;
+        }
+        if (this.$vm) {
+            updateComponentProps(up, this.$vm.$);
+        }
+        else if (this.properties.uT === 'm') {
+            // 小程序组件
+            updateMiniProgramComponentProperties(up, this);
+        }
+    };
+    {
+        if (!componentOptions.observers) {
+            componentOptions.observers = {};
+        }
+        componentOptions.observers.uP = observe;
+    }
+}
+function updateMiniProgramComponentProperties(up, mpInstance) {
+    const prevProps = mpInstance.properties;
+    const nextProps = findComponentPropsData(up) || {};
+    if (hasPropsChanged(prevProps, nextProps, false)) {
+        mpInstance.setData(nextProps);
+    }
+}
+function updateComponentProps(up, instance) {
+    const prevProps = toRaw(instance.props);
+    const nextProps = findComponentPropsData(up) || {};
+    if (hasPropsChanged(prevProps, nextProps)) {
+        updateProps(instance, nextProps, prevProps, false);
+        if (hasQueueJob(instance.update)) {
+            invalidateJob(instance.update);
+        }
+        {
+            instance.update();
+        }
+    }
+}
+function hasPropsChanged(prevProps, nextProps, checkLen = true) {
+    const nextKeys = Object.keys(nextProps);
+    if (checkLen && nextKeys.length !== Object.keys(prevProps).length) {
+        return true;
+    }
+    for (let i = 0; i < nextKeys.length; i++) {
+        const key = nextKeys[i];
+        if (nextProps[key] !== prevProps[key]) {
+            return true;
+        }
+    }
+    return false;
+}
+function initBehaviors(vueOptions) {
+    const vueBehaviors = vueOptions.behaviors;
+    let vueProps = vueOptions.props;
+    if (!vueProps) {
+        vueOptions.props = vueProps = [];
+    }
+    const behaviors = [];
+    if (isArray(vueBehaviors)) {
+        vueBehaviors.forEach((behavior) => {
+            behaviors.push(behavior.replace('uni://', 'wx://'));
+            if (behavior === 'uni://form-field') {
+                if (isArray(vueProps)) {
+                    vueProps.push('name');
+                    vueProps.push('modelValue');
+                }
+                else {
+                    vueProps.name = {
+                        type: String,
+                        default: '',
+                    };
+                    vueProps.modelValue = {
+                        type: [String, Number, Boolean, Array, Object, Date],
+                        default: '',
+                    };
+                }
+            }
+        });
+    }
+    return behaviors;
+}
+function applyOptions(componentOptions, vueOptions) {
+    componentOptions.data = initData();
+    componentOptions.behaviors = initBehaviors(vueOptions);
+}
+
+function parseComponent(vueOptions, { parse, mocks, isPage, initRelation, handleLink, initLifetimes, }) {
+    vueOptions = vueOptions.default || vueOptions;
+    const options = {
+        multipleSlots: true,
+        // styleIsolation: 'apply-shared',
+        addGlobalClass: true,
+        pureDataPattern: /^uP$/,
+    };
+    if (isArray(vueOptions.mixins)) {
+        vueOptions.mixins.forEach((item) => {
+            if (isObject(item.options)) {
+                extend(options, item.options);
+            }
+        });
+    }
+    if (vueOptions.options) {
+        extend(options, vueOptions.options);
+    }
+    const mpComponentOptions = {
+        options,
+        lifetimes: initLifetimes({ mocks, isPage, initRelation, vueOptions }),
+        pageLifetimes: {
+            show() {
+                if (__VUE_PROD_DEVTOOLS__) {
+                    devtoolsComponentAdded(this.$vm.$);
+                }
+                this.$vm && this.$vm.$callHook('onPageShow');
+            },
+            hide() {
+                this.$vm && this.$vm.$callHook('onPageHide');
+            },
+            resize(size) {
+                this.$vm && this.$vm.$callHook('onPageResize', size);
+            },
+        },
+        methods: {
+            __l: handleLink,
+        },
+    };
+    if (__VUE_OPTIONS_API__) {
+        applyOptions(mpComponentOptions, vueOptions);
+    }
+    initProps(mpComponentOptions);
+    initPropsObserver(mpComponentOptions);
+    initExtraOptions(mpComponentOptions, vueOptions);
+    initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods);
+    {
+        initWorkletMethods(mpComponentOptions.methods, vueOptions.methods);
+    }
+    if (parse) {
+        parse(mpComponentOptions, { handleLink });
+    }
+    return mpComponentOptions;
+}
+function initCreateComponent(parseOptions) {
+    return function createComponent(vueComponentOptions) {
+        return Component(parseComponent(vueComponentOptions, parseOptions));
+    };
+}
+let $createComponentFn;
+let $destroyComponentFn;
+function getAppVm() {
+    if (process.env.UNI_MP_PLUGIN) {
+        return wx.$vm;
+    }
+    if (process.env.UNI_SUBPACKAGE) {
+        return wx.$subpackages[process.env.UNI_SUBPACKAGE].$vm;
+    }
+    return getApp().$vm;
+}
+function $createComponent(initialVNode, options) {
+    if (!$createComponentFn) {
+        $createComponentFn = getAppVm().$createComponent;
+    }
+    const proxy = $createComponentFn(initialVNode, options);
+    return getExposeProxy(proxy.$) || proxy;
+}
+function $destroyComponent(instance) {
+    if (!$destroyComponentFn) {
+        $destroyComponentFn = getAppVm().$destroyComponent;
+    }
+    return $destroyComponentFn(instance);
+}
+
+function parsePage(vueOptions, parseOptions) {
+    const { parse, mocks, isPage, initRelation, handleLink, initLifetimes } = parseOptions;
+    const miniProgramPageOptions = parseComponent(vueOptions, {
+        mocks,
+        isPage,
+        initRelation,
+        handleLink,
+        initLifetimes,
+    });
+    initPageProps(miniProgramPageOptions, (vueOptions.default || vueOptions).props);
+    const methods = miniProgramPageOptions.methods;
+    methods.onLoad = function (query) {
+        this.options = query;
+        this.$page = {
+            fullPath: addLeadingSlash(this.route + stringifyQuery(query)),
+        };
+        return this.$vm && this.$vm.$callHook(ON_LOAD, query);
+    };
+    initHooks(methods, PAGE_INIT_HOOKS);
+    {
+        initUnknownHooks(methods, vueOptions);
+    }
+    initRuntimeHooks(methods, vueOptions.__runtimeHooks);
+    initMixinRuntimeHooks(methods);
+    parse && parse(miniProgramPageOptions, { handleLink });
+    return miniProgramPageOptions;
+}
+function initCreatePage(parseOptions) {
+    return function createPage(vuePageOptions) {
+        return Component(parsePage(vuePageOptions, parseOptions));
+    };
+}
+
+function initCreatePluginApp(parseAppOptions) {
+    return function createApp(vm) {
+        initAppLifecycle(parseApp(vm, parseAppOptions), vm);
+        if (process.env.UNI_MP_PLUGIN) {
+            wx.$vm = vm;
+        }
+    };
+}
+
+const MPPage = Page;
+const MPComponent = Component;
+function initTriggerEvent(mpInstance) {
+    const oldTriggerEvent = mpInstance.triggerEvent;
+    const newTriggerEvent = function (event, ...args) {
+        return oldTriggerEvent.apply(mpInstance, [customizeEvent(event), ...args]);
+    };
+    // 京东小程序triggerEvent为只读属性
+    try {
+        mpInstance.triggerEvent = newTriggerEvent;
+    }
+    catch (error) {
+        mpInstance._triggerEvent = newTriggerEvent;
+    }
+}
+function initMiniProgramHook(name, options, isComponent) {
+    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) {
+    initMiniProgramHook(ON_LOAD, options);
+    return MPPage(options);
+};
+Component = function (options) {
+    initMiniProgramHook('created', options);
+    // 小程序组件
+    const isVueComponent = options.properties && options.properties.uP;
+    if (!isVueComponent) {
+        initProps(options);
+        initPropsObserver(options);
+    }
+    return MPComponent(options);
+};
+
+// @ts-ignore
+function initLifetimes({ mocks, isPage, initRelation, vueOptions, }) {
+    return {
+        attached() {
+            let properties = this.properties;
+            initVueIds(properties.uI, this);
+            const relationOptions = {
+                vuePid: this._$vuePid,
+            };
+            // 处理父子关系
+            initRelation(this, relationOptions);
+            // 初始化 vue 实例
+            const mpInstance = this;
+            const isMiniProgramPage = isPage(mpInstance);
+            let propsData = properties;
+            this.$vm = $createComponent({
+                type: vueOptions,
+                props: findPropsData(propsData, isMiniProgramPage),
+            }, {
+                mpType: isMiniProgramPage ? 'page' : 'component',
+                mpInstance,
+                slots: properties.uS || {},
+                parentComponent: relationOptions.parent && relationOptions.parent.$,
+                onBeforeSetup(instance, options) {
+                    initRefs(instance, mpInstance);
+                    initMocks(instance, mpInstance, mocks);
+                    initComponentInstance(instance, options);
+                },
+            });
+            if (!isMiniProgramPage) {
+                initFormField(this.$vm);
+            }
+        },
+        ready() {
+            // 当组件 props 默认值为 true，初始化时传入 false 会导致 created,ready 触发, 但 attached 不触发
+            // https://developers.weixin.qq.com/community/develop/doc/00066ae2844cc0f8eb883e2a557800
+            if (this.$vm) {
+                {
+                    this.$vm.$callHook('mounted');
+                    this.$vm.$callHook(ON_READY);
+                }
+            }
+        },
+        detached() {
+            if (this.$vm) {
+                pruneComponentPropsCache(this.$vm.$.uid);
+                $destroyComponent(this.$vm);
+            }
+        },
+    };
+}
+
+const mocks = ['__route__', '__wxExparserNodeId__', '__wxWebviewId__'];
+function isPage(mpInstance) {
+    return !!mpInstance.route;
+}
+function initRelation(mpInstance, detail) {
+    mpInstance.triggerEvent('__l', detail);
+}
+function handleLink(event) {
+    // detail 是微信,value 是百度(dipatch)
+    const detail = (event.detail ||
+        event.value);
+    const vuePid = detail.vuePid;
+    let parentVm;
+    if (vuePid) {
+        parentVm = findVmByVueId(this.$vm, vuePid);
+    }
+    if (!parentVm) {
+        parentVm = this.$vm;
+    }
+    detail.parent = parentVm;
+}
+
+var parseOptions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  handleLink: handleLink,
+  initLifetimes: initLifetimes,
+  initRelation: initRelation,
+  isPage: isPage,
+  mocks: mocks
+});
+
+const createApp = initCreateApp();
+const createPage = initCreatePage(parseOptions);
+const createComponent = initCreateComponent(parseOptions);
+const createPluginApp = initCreatePluginApp();
+const createSubpackageApp = initCreateSubpackageApp();
+{
+    wx.createApp = global.createApp = createApp;
+    wx.createPage = createPage;
+    wx.createComponent = createComponent;
+    wx.createPluginApp = global.createPluginApp =
+        createPluginApp;
+    wx.createSubpackageApp = global.createSubpackageApp =
+        createSubpackageApp;
+}
+
+export { createApp, createComponent, createPage, createPluginApp, createSubpackageApp };

uni_modules/UniDevTools/node_modules/@dcloudio/uni-mp-weixin/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@dcloudio/uni-mp-weixin",
+  "version": "3.0.0-3090520231028001",
+  "description": "uni-app mp-weixin",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcloudio/uni-app.git",
+    "directory": "packages/uni-mp-weixin"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "license": "Apache-2.0",
+  "uni-app": {
+    "name": "mp-weixin",
+    "title": "微信小程序",
+    "apply": [
+      "mp-weixin"
+    ],
+    "main": "dist/uni.compiler.js"
+  },
+  "gitHead": "33e807d66e1fe47e2ee08ad9c59247e37b8884da",
+  "devDependencies": {
+    "@vue/compiler-core": "3.2.47"
+  },
+  "dependencies": {
+    "@dcloudio/uni-cli-shared": "3.0.0-3090520231028001",
+    "@dcloudio/uni-mp-vite": "3.0.0-3090520231028001",
+    "@dcloudio/uni-mp-vue": "3.0.0-3090520231028001",
+    "@dcloudio/uni-shared": "3.0.0-3090520231028001",
+    "@vue/shared": "3.2.47",
+    "jimp": "^0.10.1",
+    "licia": "^1.29.0",
+    "qrcode-reader": "^1.0.4",
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.4.2"
+  }
+}