@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/dist/checkUpdate.d.ts

@@ -0,0 +1,30 @@
+interface CheckUpdateOptions {
+    inputDir: string;
+    compilerVersion: string;
+    versionType: 'a' | 'r';
+}
+interface CheckUpdatePlatform {
+    appid?: string;
+    dev: number;
+    build: number;
+}
+interface CheckUpdateCache {
+    vid: string;
+    lastCheck: number;
+    newVersion?: string;
+    note?: string;
+    [name: string]: CheckUpdatePlatform | undefined | string | number;
+}
+export declare function checkUpdate(options: CheckUpdateOptions): Promise<void>;
+/**
+ * 检查本地缓存，返回 false 表示需要执行云端检查，返回 true 表示，无需云端检查，返回 string 表示，无需云端检测，且有更新
+ * @param inputDir
+ * @param compilerVersion
+ * @param interval
+ * @returns
+ */
+export declare function checkLocalCache(updateCache: CheckUpdateCache, compilerVersion: string, interval?: number): string | boolean;
+export declare function md5(str: string): string;
+export declare function getMac(): string;
+export declare function createPostData({ versionType, compilerVersion }: CheckUpdateOptions, manifestJson: Record<string, any>, updateCache: CheckUpdateCache): string;
+export {};

package/dist/checkUpdate.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostData = exports.getMac = exports.md5 = exports.checkLocalCache = exports.checkUpdate = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const crypto_1 = __importDefault(require("crypto"));
+const https_1 = require("https");
+const compare_versions_1 = __importDefault(require("compare-versions"));
+const shared_1 = require("@vue/shared");
+const json_1 = require("./json");
+const hbx_1 = require("./hbx");
+const debugCheckUpdate = (0, debug_1.default)('uni:check-update');
+const INTERVAL = 1000 * 60 * 60 * 24;
+async function checkUpdate(options) {
+    if (process.env.CI) {
+        debugCheckUpdate('isInCI');
+        return;
+    }
+    if ((0, hbx_1.isInHBuilderX)()) {
+        debugCheckUpdate('isInHBuilderX');
+        return;
+    }
+    const { inputDir, compilerVersion } = options;
+    const updateCache = readCheckUpdateCache(inputDir);
+    debugCheckUpdate('read.cache', updateCache);
+    const res = checkLocalCache(updateCache, compilerVersion);
+    if (res) {
+        if ((0, shared_1.isString)(res)) {
+            console.log();
+            console.log(res);
+        }
+    }
+    else {
+        await checkVersion(options, normalizeUpdateCache(updateCache, (0, json_1.parseManifestJsonOnce)(inputDir)));
+    }
+    writeCheckUpdateCache(inputDir, statUpdateCache(normalizeUpdateCache(updateCache)));
+}
+exports.checkUpdate = checkUpdate;
+function normalizeUpdateCache(updateCache, manifestJson) {
+    const platform = process.env.UNI_PLATFORM;
+    if (!updateCache[platform]) {
+        updateCache[platform] = {
+            appid: '',
+            dev: 0,
+            build: 0,
+        };
+    }
+    if (manifestJson) {
+        const platformOptions = manifestJson[platform === 'app' ? 'app-plus' : platform];
+        updateCache[platform].appid = platformOptions
+            ? platformOptions.appid || platformOptions.package || ''
+            : '';
+    }
+    return updateCache;
+}
+function statUpdateCache(updateCache) {
+    debugCheckUpdate('stat.before', updateCache);
+    const platform = process.env.UNI_PLATFORM;
+    const type = process.env.NODE_ENV === 'production' ? 'build' : 'dev';
+    const platformOptions = updateCache[platform];
+    platformOptions[type] = (platformOptions[type] || 0) + 1;
+    debugCheckUpdate('stat.after', updateCache);
+    return updateCache;
+}
+function getFilepath(inputDir, filename) {
+    return path_1.default.resolve(os_1.default.tmpdir(), 'uni-app-cli', md5(inputDir), filename);
+}
+function getCheckUpdateFilepath(inputDir) {
+    return getFilepath(inputDir, 'check-update.json');
+}
+function generateVid() {
+    let result = '';
+    for (let i = 0; i < 4; i++) {
+        result += ((65536 * (1 + Math.random())) | 0).toString(16).substring(1);
+    }
+    return 'UNI_' + result.toUpperCase();
+}
+function createCheckUpdateCache(vid = generateVid()) {
+    return {
+        vid: generateVid(),
+        lastCheck: 0,
+    };
+}
+function readCheckUpdateCache(inputDir) {
+    const updateFilepath = getCheckUpdateFilepath(inputDir);
+    debugCheckUpdate('read:', updateFilepath);
+    if (fs_extra_1.default.existsSync(updateFilepath)) {
+        try {
+            return require(updateFilepath);
+        }
+        catch (e) {
+            debugCheckUpdate('read.error', e);
+        }
+    }
+    return createCheckUpdateCache();
+}
+/**
+ * 检查本地缓存，返回 false 表示需要执行云端检查，返回 true 表示，无需云端检查，返回 string 表示，无需云端检测，且有更新
+ * @param inputDir
+ * @param compilerVersion
+ * @param interval
+ * @returns
+ */
+function checkLocalCache(updateCache, compilerVersion, interval = INTERVAL) {
+    if (!updateCache.lastCheck) {
+        debugCheckUpdate('cache: lastCheck not found');
+        return false;
+    }
+    if (Date.now() - updateCache.lastCheck > interval) {
+        debugCheckUpdate('cache: lastCheck > interval');
+        return false;
+    }
+    if (updateCache.newVersion &&
+        (0, compare_versions_1.default)(updateCache.newVersion, compilerVersion) > 0) {
+        debugCheckUpdate('cache: find new version');
+        return updateCache.note;
+    }
+    return true;
+}
+exports.checkLocalCache = checkLocalCache;
+function writeCheckUpdateCache(inputDir, updateCache) {
+    const filepath = getCheckUpdateFilepath(inputDir);
+    debugCheckUpdate('write:', filepath, updateCache);
+    try {
+        fs_extra_1.default.outputFileSync(filepath, JSON.stringify(updateCache));
+    }
+    catch (e) {
+        debugCheckUpdate('write.error', e);
+    }
+}
+function md5(str) {
+    return crypto_1.default.createHash('md5').update(str).digest('hex');
+}
+exports.md5 = md5;
+function getMac() {
+    let mac = '';
+    const network = os_1.default.networkInterfaces();
+    for (const key in network) {
+        const array = network[key];
+        for (let i = 0; i < array.length; i++) {
+            const item = array[i];
+            if (!item.family || (item.mac && item.mac === '00:00:00:00:00:00')) {
+                continue;
+            }
+            if (item.family === 'IPv4' || item.family === 'IPv6') {
+                mac = item.mac;
+                break;
+            }
+        }
+    }
+    return mac;
+}
+exports.getMac = getMac;
+function createPostData({ versionType, compilerVersion }, manifestJson, updateCache) {
+    const data = {
+        vv: 3,
+        device: md5(getMac()),
+        vtype: versionType,
+        vcode: compilerVersion,
+    };
+    if (manifestJson.appid) {
+        data.appid = manifestJson.appid;
+    }
+    else {
+        data.vid = updateCache.vid;
+    }
+    Object.keys(updateCache).forEach((name) => {
+        const value = updateCache[name];
+        if ((0, shared_1.isPlainObject)(value) &&
+            ((0, shared_1.hasOwn)(value, 'dev') || (0, shared_1.hasOwn)(value, 'build'))) {
+            data[name] = value;
+        }
+    });
+    return JSON.stringify(data);
+}
+exports.createPostData = createPostData;
+function handleCheckVersion({ code, isUpdate, newVersion, note }, updateCache) {
+    if (code !== 0) {
+        return;
+    }
+    // clear
+    Object.keys(updateCache).forEach((key) => {
+        if (key !== 'vid')
+            delete updateCache[key];
+    });
+    updateCache.lastCheck = Date.now();
+    if (isUpdate) {
+        updateCache.note = note;
+        updateCache.newVersion = newVersion;
+    }
+    else {
+        delete updateCache.note;
+        delete updateCache.newVersion;
+    }
+}
+const HOSTNAME = 'uniapp.dcloud.net.cn';
+const PATH = '/update/cli';
+function checkVersion(options, updateCache) {
+    return new Promise((resolve) => {
+        const postData = JSON.stringify({
+            id: createPostData(options, (0, json_1.parseManifestJsonOnce)(options.inputDir), updateCache),
+        });
+        let responseData = '';
+        const req = (0, https_1.request)({
+            hostname: HOSTNAME,
+            path: PATH,
+            port: 443,
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': postData.length,
+            },
+        }, (res) => {
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => {
+                responseData += chunk;
+            });
+            res.on('end', () => {
+                debugCheckUpdate('response: ', responseData);
+                try {
+                    handleCheckVersion(JSON.parse(responseData), updateCache);
+                }
+                catch (e) { }
+                resolve(true);
+            });
+            res.on('error', (e) => {
+                debugCheckUpdate('response.error:', e);
+                resolve(false);
+            });
+        }).on('error', (e) => {
+            debugCheckUpdate('request.error:', e);
+            resolve(false);
+        });
+        debugCheckUpdate('request: ', postData);
+        req.write(postData);
+        req.end();
+    });
+}

package/dist/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const PUBLIC_DIR = "static";
+export declare const EXTNAME_JS: string[];
+export declare const EXTNAME_TS: string[];
+export declare const EXTNAME_VUE: string[];
+export declare const EXTNAME_VUE_TEMPLATE: string[];
+export declare const EXTNAME_VUE_RE: RegExp;
+export declare const EXTNAME_JS_RE: RegExp;
+export declare const EXTNAME_TS_RE: RegExp;
+export declare const extensions: string[];
+export declare const ASSETS_INLINE_LIMIT: number;
+export declare const APP_SERVICE_FILENAME = "app-service.js";
+export declare const BINDING_COMPONENTS = "__BINDING_COMPONENTS__";
+export declare const PAGE_EXTNAME_APP: string[];
+export declare const PAGE_EXTNAME: string[];
+export declare const H5_API_STYLE_PATH = "@dcloudio/uni-h5/style/api/";
+export declare const H5_FRAMEWORK_STYLE_PATH = "@dcloudio/uni-h5/style/framework/";
+export declare const H5_COMPONENTS_STYLE_PATH = "@dcloudio/uni-h5/style/";
+export declare const BASE_COMPONENTS_STYLE_PATH = "@dcloudio/uni-components/style/";
+export declare const COMMON_EXCLUDE: RegExp[];

package/dist/constants.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMON_EXCLUDE = exports.BASE_COMPONENTS_STYLE_PATH = exports.H5_COMPONENTS_STYLE_PATH = exports.H5_FRAMEWORK_STYLE_PATH = exports.H5_API_STYLE_PATH = exports.PAGE_EXTNAME = exports.PAGE_EXTNAME_APP = exports.BINDING_COMPONENTS = exports.APP_SERVICE_FILENAME = exports.ASSETS_INLINE_LIMIT = exports.extensions = exports.EXTNAME_TS_RE = exports.EXTNAME_JS_RE = exports.EXTNAME_VUE_RE = exports.EXTNAME_VUE_TEMPLATE = exports.EXTNAME_VUE = exports.EXTNAME_TS = exports.EXTNAME_JS = exports.PUBLIC_DIR = void 0;
+exports.PUBLIC_DIR = 'static';
+exports.EXTNAME_JS = ['.js', '.ts', '.jsx', '.tsx'];
+exports.EXTNAME_TS = ['.ts', '.tsx'];
+exports.EXTNAME_VUE = ['.vue', '.nvue'];
+exports.EXTNAME_VUE_TEMPLATE = ['.vue', '.nvue', '.jsx', '.tsx'];
+exports.EXTNAME_VUE_RE = /\.(vue|nvue)$/;
+exports.EXTNAME_JS_RE = /\.[jt]sx?$/;
+exports.EXTNAME_TS_RE = /\.tsx?$/;
+exports.extensions = [
+    '.mjs',
+    '.js',
+    '.ts',
+    '.jsx',
+    '.tsx',
+    '.json',
+].concat(exports.EXTNAME_VUE);
+exports.ASSETS_INLINE_LIMIT = 40 * 1024;
+exports.APP_SERVICE_FILENAME = 'app-service.js';
+exports.BINDING_COMPONENTS = '__BINDING_COMPONENTS__';
+// APP 平台解析页面后缀的优先级
+exports.PAGE_EXTNAME_APP = ['.nvue', '.vue', '.tsx', '.jsx', '.js'];
+// 其他平台解析页面后缀的优先级
+exports.PAGE_EXTNAME = ['.vue', '.nvue', '.tsx', '.jsx', '.js'];
+exports.H5_API_STYLE_PATH = '@dcloudio/uni-h5/style/api/';
+exports.H5_FRAMEWORK_STYLE_PATH = '@dcloudio/uni-h5/style/framework/';
+exports.H5_COMPONENTS_STYLE_PATH = '@dcloudio/uni-h5/style/';
+exports.BASE_COMPONENTS_STYLE_PATH = '@dcloudio/uni-components/style/';
+exports.COMMON_EXCLUDE = [
+    /\/pages\.json\.js$/,
+    /\/manifest\.json\.js$/,
+    /\/vite\//,
+    /\/@vue\//,
+    /\/vue-router\//,
+    /\/vuex\//,
+    /\/vue-i18n\//,
+    /\/@dcloudio\/uni-h5-vue/,
+    /\/@dcloudio\/uni-shared/,
+    /\/@dcloudio\/uni-h5\/style/,
+    /\/@dcloudio\/uni-components\/style/,
+];

package/dist/deps.d.ts

@@ -0,0 +1,19 @@
+export declare const API_DEPS_CSS: {
+    showModal: string[];
+    showToast: string[];
+    showActionSheet: string[];
+    previewImage: string[];
+    openLocation: string[];
+    chooseLocation: string[];
+};
+export declare const COMPONENT_DEPS_CSS: {
+    canvas: string[];
+    image: string[];
+    'movable-area': string[];
+    'picker-view': string[];
+    'picker-view-column': string[];
+    'rich-text': string[];
+    textarea: string[];
+    'web-view': string[];
+    picker: string[];
+};

package/dist/deps.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPONENT_DEPS_CSS = exports.API_DEPS_CSS = void 0;
+const constants_1 = require("./constants");
+const RESIZE_SENSOR_CSS = constants_1.BASE_COMPONENTS_STYLE_PATH + 'resize-sensor.css';
+exports.API_DEPS_CSS = {
+    showModal: [`${constants_1.H5_API_STYLE_PATH}modal.css`],
+    showToast: [`${constants_1.H5_API_STYLE_PATH}toast.css`],
+    showActionSheet: [`${constants_1.H5_API_STYLE_PATH}action-sheet.css`],
+    previewImage: [
+        RESIZE_SENSOR_CSS,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}swiper.css`,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}swiper-item.css`,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}movable-area.css`,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}movable-view.css`,
+    ],
+    openLocation: [`${constants_1.H5_API_STYLE_PATH}location-view.css`],
+    chooseLocation: [
+        `${constants_1.H5_API_STYLE_PATH}/location-picker.css`,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}/input.css`,
+        `${constants_1.H5_COMPONENTS_STYLE_PATH}/map.css`,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}/scroll-view.css`,
+    ],
+};
+exports.COMPONENT_DEPS_CSS = {
+    canvas: [RESIZE_SENSOR_CSS],
+    image: [RESIZE_SENSOR_CSS],
+    'movable-area': [RESIZE_SENSOR_CSS],
+    'picker-view': [RESIZE_SENSOR_CSS],
+    'picker-view-column': [RESIZE_SENSOR_CSS],
+    'rich-text': [RESIZE_SENSOR_CSS],
+    textarea: [RESIZE_SENSOR_CSS],
+    'web-view': [RESIZE_SENSOR_CSS],
+    picker: [
+        RESIZE_SENSOR_CSS,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}picker-view.css`,
+        `${constants_1.BASE_COMPONENTS_STYLE_PATH}picker-view-column.css`,
+    ],
+};

package/dist/easycom.d.ts

@@ -0,0 +1,29 @@
+interface EasycomOption {
+    dirs?: string[];
+    rootDir: string;
+    extensions?: string[];
+    autoscan?: boolean;
+    custom?: EasycomCustom;
+}
+interface EasycomMatcher {
+    pattern: RegExp;
+    replacement: string;
+}
+interface EasycomCustom {
+    [key: string]: string;
+}
+export declare function initEasycoms(inputDir: string, { dirs, platform }: {
+    dirs: string[];
+    platform: UniApp.PLATFORM;
+}): {
+    options: EasycomOption;
+    filter: (id: unknown) => boolean;
+    refresh(): void;
+    easycoms: EasycomMatcher[];
+};
+export declare const initEasycomsOnce: typeof initEasycoms;
+export declare function matchEasycom(tag: string): string | false | undefined;
+export declare function addImportDeclaration(importDeclarations: string[], local: string, source: string, imported?: string): string;
+export declare function genResolveEasycomCode(importDeclarations: string[], code: string, name: string): string;
+export declare const UNI_EASYCOM_EXCLUDE: RegExp[];
+export {};

package/dist/easycom.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNI_EASYCOM_EXCLUDE = exports.genResolveEasycomCode = exports.addImportDeclaration = exports.matchEasycom = exports.initEasycomsOnce = exports.initEasycoms = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const shared_1 = require("@vue/shared");
+const pluginutils_1 = require("@rollup/pluginutils");
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const utils_1 = require("./utils");
+const pages_1 = require("./json/pages");
+const messages_1 = require("./messages");
+const debugEasycom = (0, debug_1.default)('uni:easycom');
+const easycoms = [];
+const easycomsCache = new Map();
+const easycomsInvalidCache = new Set();
+let hasEasycom = false;
+function clearEasycom() {
+    easycoms.length = 0;
+    easycomsCache.clear();
+    easycomsInvalidCache.clear();
+}
+function initEasycoms(inputDir, { dirs, platform }) {
+    const componentsDir = path_1.default.resolve(inputDir, 'components');
+    const uniModulesDir = path_1.default.resolve(inputDir, 'uni_modules');
+    const initEasycomOptions = (pagesJson) => {
+        // 初始化时，从once中读取缓存，refresh时，实时读取
+        const { easycom } = pagesJson || (0, pages_1.parsePagesJson)(inputDir, platform, false);
+        const easycomOptions = {
+            dirs: easycom && easycom.autoscan === false
+                ? [...dirs] // 禁止自动扫描
+                : [
+                    ...dirs,
+                    componentsDir,
+                    ...initUniModulesEasycomDirs(uniModulesDir),
+                ],
+            rootDir: inputDir,
+            autoscan: !!(easycom && easycom.autoscan),
+            custom: (easycom && easycom.custom) || {},
+        };
+        debugEasycom(easycomOptions);
+        return easycomOptions;
+    };
+    const options = initEasycomOptions((0, pages_1.parsePagesJsonOnce)(inputDir, platform));
+    initEasycom(options);
+    const res = {
+        options,
+        filter: (0, pluginutils_1.createFilter)([
+            'components/*/*.(vue|jsx|tsx)',
+            'uni_modules/*/components/*/*.(vue|jsx|tsx)',
+        ], [], {
+            resolve: inputDir,
+        }),
+        refresh() {
+            res.options = initEasycomOptions();
+            initEasycom(res.options);
+        },
+        easycoms,
+    };
+    return res;
+}
+exports.initEasycoms = initEasycoms;
+exports.initEasycomsOnce = (0, uni_shared_1.once)(initEasycoms);
+function initUniModulesEasycomDirs(uniModulesDir) {
+    if (!fs_1.default.existsSync(uniModulesDir)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(uniModulesDir)
+        .map((uniModuleDir) => {
+        const uniModuleComponentsDir = path_1.default.resolve(uniModulesDir, uniModuleDir, 'components');
+        if (fs_1.default.existsSync(uniModuleComponentsDir)) {
+            return uniModuleComponentsDir;
+        }
+    })
+        .filter(Boolean);
+}
+function initEasycom({ dirs, rootDir, custom, extensions = ['.vue', '.jsx', '.tsx'], }) {
+    clearEasycom();
+    const easycomsObj = Object.create(null);
+    if (dirs && dirs.length && rootDir) {
+        (0, shared_1.extend)(easycomsObj, initAutoScanEasycoms(dirs, rootDir, extensions));
+    }
+    if (custom) {
+        Object.keys(custom).forEach((name) => {
+            const componentPath = custom[name];
+            easycomsObj[name] = componentPath.startsWith('@/')
+                ? (0, utils_1.normalizePath)(path_1.default.join(rootDir, componentPath.substr(2)))
+                : componentPath;
+        });
+    }
+    Object.keys(easycomsObj).forEach((name) => {
+        easycoms.push({
+            pattern: new RegExp(name),
+            replacement: easycomsObj[name],
+        });
+    });
+    debugEasycom(easycoms);
+    hasEasycom = !!easycoms.length;
+    return easycoms;
+}
+function matchEasycom(tag) {
+    if (!hasEasycom) {
+        return;
+    }
+    let source = easycomsCache.get(tag);
+    if (source) {
+        return source;
+    }
+    if (easycomsInvalidCache.has(tag)) {
+        return false;
+    }
+    const matcher = easycoms.find((matcher) => matcher.pattern.test(tag));
+    if (!matcher) {
+        easycomsInvalidCache.add(tag);
+        return false;
+    }
+    source = tag.replace(matcher.pattern, matcher.replacement);
+    easycomsCache.set(tag, source);
+    debugEasycom('matchEasycom', tag, source);
+    return source;
+}
+exports.matchEasycom = matchEasycom;
+const isDir = (path) => fs_1.default.lstatSync(path).isDirectory();
+function initAutoScanEasycom(dir, rootDir, extensions) {
+    if (!path_1.default.isAbsolute(dir)) {
+        dir = path_1.default.resolve(rootDir, dir);
+    }
+    const easycoms = Object.create(null);
+    if (!fs_1.default.existsSync(dir)) {
+        return easycoms;
+    }
+    fs_1.default.readdirSync(dir).forEach((name) => {
+        const folder = path_1.default.resolve(dir, name);
+        if (!isDir(folder)) {
+            return;
+        }
+        const importDir = (0, utils_1.normalizePath)(folder);
+        const files = fs_1.default.readdirSync(folder);
+        // 读取文件夹文件列表，比对文件名（fs.existsSync在大小写不敏感的系统会匹配不准确）
+        for (let i = 0; i < extensions.length; i++) {
+            const ext = extensions[i];
+            if (files.includes(name + ext)) {
+                easycoms[`^${name}$`] = `${importDir}/${name}${ext}`;
+                break;
+            }
+        }
+    });
+    return easycoms;
+}
+function initAutoScanEasycoms(dirs, rootDir, extensions) {
+    const conflict = {};
+    const res = dirs.reduce((easycoms, dir) => {
+        const curEasycoms = initAutoScanEasycom(dir, rootDir, extensions);
+        Object.keys(curEasycoms).forEach((name) => {
+            // Use the first component when name conflict
+            const compath = easycoms[name];
+            if (!compath) {
+                easycoms[name] = curEasycoms[name];
+            }
+            else {
+                ;
+                (conflict[compath] || (conflict[compath] = [])).push(normalizeCompath(curEasycoms[name], rootDir));
+            }
+        });
+        return easycoms;
+    }, Object.create(null));
+    const conflictComs = Object.keys(conflict);
+    if (conflictComs.length) {
+        console.warn(messages_1.M['easycom.conflict']);
+        conflictComs.forEach((com) => {
+            console.warn([normalizeCompath(com, rootDir), conflict[com]].join(','));
+        });
+    }
+    return res;
+}
+function normalizeCompath(compath, rootDir) {
+    return (0, utils_1.normalizePath)(path_1.default.relative(rootDir, compath));
+}
+function addImportDeclaration(importDeclarations, local, source, imported) {
+    importDeclarations.push(createImportDeclaration(local, source, imported));
+    return local;
+}
+exports.addImportDeclaration = addImportDeclaration;
+function createImportDeclaration(local, source, imported) {
+    if (imported) {
+        return `import {${imported} as ${local}} from '${source}';`;
+    }
+    return `import ${local} from '${source}';`;
+}
+const RESOLVE_EASYCOM_IMPORT_CODE = `import { resolveDynamicComponent as __resolveDynamicComponent } from 'vue';import { resolveEasycom } from '@dcloudio/uni-app';`;
+function genResolveEasycomCode(importDeclarations, code, name) {
+    if (!importDeclarations.includes(RESOLVE_EASYCOM_IMPORT_CODE)) {
+        importDeclarations.push(RESOLVE_EASYCOM_IMPORT_CODE);
+    }
+    return `resolveEasycom(${code.replace('_resolveComponent', '__resolveDynamicComponent')}, ${name})`;
+}
+exports.genResolveEasycomCode = genResolveEasycomCode;
+exports.UNI_EASYCOM_EXCLUDE = [/App.vue$/, /@dcloudio\/uni-h5/];

package/dist/env/define.d.ts

@@ -0,0 +1,15 @@
+export declare function initDefine(stringifyBoolean?: boolean): {
+    'process.env.NODE_ENV': string;
+    'process.env.UNI_DEBUG': string | boolean;
+    'process.env.UNI_APP_ID': string;
+    'process.env.UNI_APP_NAME': string;
+    'process.env.UNI_PLATFORM': string;
+    'process.env.UNI_MP_PLUGIN': string;
+    'process.env.UNI_SUBPACKAGE': string;
+    'process.env.UNI_COMPILER_VERSION': string;
+    'process.env.RUN_BY_HBUILDERX': string | boolean;
+    'process.env.UNI_AUTOMATOR_WS_ENDPOINT': string;
+    'process.env.UNI_CLOUD_PROVIDER': string;
+    'process.env.UNICLOUD_DEBUG': string;
+    'process.env.VUE_APP_PLATFORM': string;
+};