xhs-mp-compiler-cli 1.1.1 → 1.1.2

package/dist/utils/file.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderSize = exports.fileSize = void 0;
+const fs = __importStar(require("fs"));
+const globby_1 = __importDefault(require("globby"));
+const fileSize = (size) => {
+    if (!size)
+        return '';
+    const base = 1024;
+    if (size < base) {
+        return `${size}B`;
+    }
+    if (size < Math.pow(base, 2)) {
+        return `${(size / base).toFixed(2)}KB`;
+    }
+    if (size < Math.pow(base, 3)) {
+        return `${(size / Math.pow(base, 2)).toFixed(2)}MB`;
+    }
+    if (size < Math.pow(base, 4)) {
+        return `${(size / Math.pow(base, 3)).toFixed(2)}GB`;
+    }
+    return `${(size / Math.pow(base, 4)).toFixed(2)}T`;
+};
+exports.fileSize = fileSize;
+const getFolderSize = (folder) => __awaiter(void 0, void 0, void 0, function* () {
+    const _folder = folder.map(f => f.replace(/\\/g, '/')); // 修复windows的路径
+    const folders = yield (0, globby_1.default)(_folder);
+    // eslint-disable-next-line no-return-assign
+    const totalSize = folders.reduce((pre, cur) => (pre += fs.statSync(cur).size), 0);
+    return totalSize;
+});
+exports.getFolderSize = getFolderSize;

package/dist/utils/project.d.ts

@@ -0,0 +1,27 @@
+export interface IZipFactory {
+    outputDir: string;
+    ignore: string[];
+    prefix: string;
+    inputDir: string;
+    type: "v0" | "v1" | "v2";
+    appendFile?: string[];
+    appendBuffer?: {
+        buffer: Buffer;
+        name: string;
+    }[];
+    meta: {
+        root: string;
+    };
+}
+export declare const checkSubPackagesLegality: ({ appJsonContent, rootPath, distDir }: {
+    appJsonContent: any;
+    rootPath: string;
+    distDir: string;
+}) => Promise<any[]>;
+export declare const zipFactory: ({ outputDir, ignore, prefix, inputDir, type, appendFile, appendBuffer, meta, }: IZipFactory) => Promise<{
+    type: "v2" | "v1" | "v0";
+    zipPath: string;
+    zipSize: number;
+    root: string;
+    originSize: number;
+}>;

package/dist/utils/project.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipFactory = exports.checkSubPackagesLegality = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const zip_1 = require("./zip");
+const file_1 = require("./file");
+const ignoreFiles = ['!node_modules'];
+const _getFolderSize = (rootPath) => __awaiter(void 0, void 0, void 0, function* () { return yield (0, file_1.getFolderSize)([rootPath, ...ignoreFiles]); });
+const getCheckSizeFlag = (rootPath) => {
+    const projectConfig = path.resolve(rootPath, 'project.config.json');
+    const content = fs.readJSONSync(projectConfig);
+    return content.skipCheckSize;
+};
+// const SUB_PACKAGE_MAX_SIZE = 2 * 1024 * 1024; // 2M
+// const TOTAL_PACKAGE_MAX_SIZE = 20 * 1024 * 1024; // 20M
+/* 整个小程序体积不能超过 20M。 */
+const checkProjectSize = (rootPath, distDir) => __awaiter(void 0, void 0, void 0, function* () {
+    const totalSize = yield _getFolderSize(distDir);
+    /* 微盟先暂时跳过整包体积校验 */
+    if (getCheckSizeFlag(rootPath) === true) {
+        return totalSize;
+    }
+    /* 跳过体积校验 */
+    // if (totalSize > TOTAL_PACKAGE_MAX_SIZE) {
+    // 	throw new Error(`源码包大小 ${fileSize(totalSize)} 超过 20MB 上限 `);
+    // }
+    return totalSize;
+});
+/* 校验subPagee的root */
+const checkSubPackages = (_a) => __awaiter(void 0, [_a], void 0, function* ({ subPackages, distDir }) {
+    let subSize = 0;
+    const sizeInfo = [];
+    for (let i = 0; i < subPackages.length; i++) {
+        const item = subPackages[i];
+        const fullPath = path.resolve(distDir, item.root);
+        const size = yield _getFolderSize(fullPath);
+        /* 跳过体积校验 */
+        // if (size > SUB_PACKAGE_MAX_SIZE) {
+        // 	throw new Error(`分包 ${item.root} 大小 ${fileSize(size)} 超出 2MB 上限`);
+        // }
+        const info = {
+            originSize: size,
+            root: item.root
+        };
+        sizeInfo.push(info);
+        subSize += size;
+    }
+    return { subSize, sizeInfo };
+});
+/* 主包体积：项目移除分包之后的体积 */
+const checkMainPackages = ({ totalSize, subPkgSize }) => {
+    const mainSize = totalSize - subPkgSize;
+    /* 跳过体积校验 */
+    // if (mainSize > SUB_PACKAGE_MAX_SIZE) {
+    // 	throw new Error(`主包大小 ${fileSize(mainSize)} 超出 2MB 上限`);
+    // }
+    const sizeInfo = {
+        originSize: mainSize,
+        root: '/'
+    };
+    return { mainSize, sizeInfo };
+};
+/* 校验preloadRule的预加载的包 */
+const checkPreloadRule = (_b) => __awaiter(void 0, [_b], void 0, function* ({ preloadRule, subPackages, distDir }) {
+    for (const ruleKey in preloadRule) {
+        let useSize = 0;
+        const rulePackages = preloadRule[ruleKey];
+        const packages = rulePackages.packages;
+        for (let i = 0; i < packages.length; i++) {
+            const pkg = packages[i];
+            if (pkg === "__APP__") {
+                return;
+            }
+            const _pathIten = subPackages.find((v) => pkg === v.name || pkg === v.root);
+            if (!_pathIten)
+                return;
+            const fullPath = path.resolve(distDir, _pathIten.root);
+            const size = yield _getFolderSize(fullPath);
+            useSize += size;
+            /* 跳过体积校验 */
+            // if (useSize > SUB_PACKAGE_MAX_SIZE) {
+            // 	throw new Error(
+            // 		`预加载 ${ruleKey} 包大小 ${fileSize(useSize)} 超出 2MB 上限`
+            // 	);
+            // }
+        }
+    }
+});
+/* 校验子包体积 */
+const checkSubPackagesLegality = (_c) => __awaiter(void 0, [_c], void 0, function* ({ appJsonContent, rootPath, distDir }) {
+    const subPackages = appJsonContent.subPackages || appJsonContent.subpackages;
+    const preloadRule = appJsonContent.preloadRule || {};
+    const totalSize = yield checkProjectSize(rootPath, distDir);
+    if (!subPackages || subPackages.length === 0) {
+        /* 未开启分包 */
+        /* 微盟先暂时跳过整包体积校验 */
+        if (getCheckSizeFlag(rootPath) === true) {
+            return [{ originSize: totalSize, root: '' }];
+        }
+        checkMainPackages({ totalSize, subPkgSize: 0 }); // 校验主包
+        return [{ originSize: totalSize, root: '' }];
+    }
+    const { subSize, sizeInfo } = yield checkSubPackages({ subPackages, distDir });
+    const { sizeInfo: mainSizeInfo } = checkMainPackages({ totalSize, subPkgSize: subSize });
+    yield checkPreloadRule({ preloadRule, subPackages, distDir });
+    return [mainSizeInfo, ...sizeInfo];
+});
+exports.checkSubPackagesLegality = checkSubPackagesLegality;
+/* zip包的工厂函数 */
+const zipFactory = (_d) => __awaiter(void 0, [_d], void 0, function* ({ outputDir, ignore, prefix, inputDir, type, appendFile = [], appendBuffer = [], meta, }) {
+    const zip = new zip_1.Zip({ outputDir });
+    /* 添加文件 */
+    appendFile.forEach((file) => {
+        zip.archive.file(file, {
+            name: path.basename(file),
+            prefix,
+        });
+    });
+    /* 添加文件buffer */
+    appendBuffer.forEach((item) => {
+        zip.archive.append(item.buffer, {
+            name: item.name,
+            prefix,
+        });
+    });
+    zip.archive.glob("**/*", { cwd: inputDir, ignore }, { prefix });
+    yield zip.finalize();
+    const stat = fs.statSync(outputDir);
+    return { type, zipPath: outputDir, zipSize: stat.size, root: meta.root, originSize: 0 };
+});
+exports.zipFactory = zipFactory;

package/dist/utils/utils.d.ts

@@ -1,3 +1,5 @@
+export declare function getMd5(str: any): any;
+export declare function normalizePath(str: any): any;
 declare const _default: {
     hasFile: (filepath: any) => boolean;
     getTsconfigPath: (config: any) => string | null;

package/dist/utils/utils.js

@@ -3,9 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = exports.getMd5 = void 0;
 // @ts-nocheck
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const crypto = require('crypto');
+function getMd5(str) {
+    const hash = crypto.createHash('md5');
+    hash.update(str);
+    const md5 = hash.digest('hex');
+    return md5;
+}
+exports.getMd5 = getMd5;
+function normalizePath(str) {
+    return str.replace(/\\/g, '/');
+}
+exports.normalizePath = normalizePath;
 const hasFile = filepath => {
     try {
         const stat = fs_1.default.statSync(filepath);

package/dist/utils/zip.d.ts

@@ -0,0 +1,28 @@
+import type { Archiver } from 'archiver';
+import * as fse from 'fs-extra';
+interface IOptions {
+    outputDir: string;
+}
+export declare class Zip {
+    options: IOptions;
+    archive: Archiver;
+    output: fse.WriteStream;
+    constructor(options: IOptions);
+    initOutput(): void;
+    finalize(): Promise<any>;
+}
+/**
+ * 解压 zip 文件 yauzl
+ * @param zipPath string
+ * @param outputDir string
+ * @param options unzipOptions
+ */
+export declare function unzip(zipPath: string, outputDir: string): Promise<void>;
+/**
+ * 解压 zip 文件
+ * @param zipPath string
+ * @param outputDir string
+ */
+export declare function unzipMac(zipPath: string, outputDir: string): Promise<unknown>;
+export declare const genZip: (input: string, output: string, appId?: string) => Promise<void>;
+export {};

package/dist/utils/zip.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genZip = exports.unzipMac = exports.unzip = exports.Zip = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const fse = __importStar(require("fs-extra"));
+const debug = require('debug')('zip');
+const path = require('path');
+const { promisify } = require('util');
+const stream = require('stream');
+const archiver = require('archiver');
+const yauzl = require('yauzl');
+const openZip = promisify(yauzl.open);
+const pipeline = promisify(stream.pipeline);
+class Extractor {
+    constructor(zipPath, opts) {
+        this.zipPath = '';
+        this.opts = null;
+        this.zipfile = null;
+        this.canceled = false;
+        this.zipPath = zipPath;
+        this.opts = opts;
+    }
+    extract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            debug('opening', this.zipPath, 'with opts', this.opts);
+            this.zipfile = yield openZip(this.zipPath, { lazyEntries: true });
+            this.canceled = false;
+            return new Promise((resolve, reject) => {
+                this.zipfile.on('error', err => {
+                    this.canceled = true;
+                    reject(err);
+                });
+                this.zipfile.readEntry();
+                this.zipfile.on('close', () => {
+                    if (!this.canceled) {
+                        debug('zip extraction complete');
+                        resolve();
+                    }
+                });
+                this.zipfile.on('entry', (entry) => __awaiter(this, void 0, void 0, function* () {
+                    /* istanbul ignore if */
+                    if (this.canceled) {
+                        debug('skipping entry', entry.fileName, { cancelled: this.canceled });
+                        return;
+                    }
+                    debug('zipfile entry', entry.fileName);
+                    if (entry.fileName.startsWith('__MACOSX/')) {
+                        this.zipfile.readEntry();
+                        return;
+                    }
+                    const destDir = path.dirname(path.join(this.opts.dir, entry.fileName));
+                    try {
+                        yield fs_1.promises.mkdir(destDir, { recursive: true });
+                        let canonicalDestDir = '';
+                        try {
+                            canonicalDestDir = yield fs_1.promises.realpath(destDir);
+                        }
+                        catch (error) {
+                            canonicalDestDir = path.resolve(destDir);
+                        }
+                        const relativeDestDir = path.relative(this.opts.dir, canonicalDestDir);
+                        if (relativeDestDir.split(path.sep).includes('..')) {
+                            throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
+                        }
+                        yield this.extractEntry(entry);
+                        debug('finished processing', entry.fileName);
+                        this.zipfile.readEntry();
+                    }
+                    catch (err) {
+                        this.canceled = true;
+                        this.zipfile.close();
+                        reject(err);
+                    }
+                }));
+            });
+        });
+    }
+    extractEntry(entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /* istanbul ignore if */
+            if (this.canceled) {
+                debug('skipping entry extraction', entry.fileName, {
+                    cancelled: this.canceled
+                });
+                return;
+            }
+            if (this.opts.onEntry) {
+                this.opts.onEntry(entry, this.zipfile);
+            }
+            const dest = path.join(this.opts.dir, entry.fileName);
+            // convert external file attr int into a fs stat mode int
+            const mode = (entry.externalFileAttributes >> 16) & 0xffff;
+            // check if it's a symlink or dir (using stat mode constants)
+            const IFMT = 61440;
+            const IFDIR = 16384;
+            const IFLNK = 40960;
+            const symlink = (mode & IFMT) === IFLNK;
+            let isDir = (mode & IFMT) === IFDIR;
+            // Failsafe, borrowed from jsZip
+            if (!isDir && entry.fileName.endsWith('/')) {
+                isDir = true;
+            }
+            // check for windows weird way of specifying a directory
+            // https://github.com/maxogden/extract-zip/issues/13#issuecomment-154494566
+            const madeBy = entry.versionMadeBy >> 8;
+            if (!isDir)
+                isDir = madeBy === 0 && entry.externalFileAttributes === 16;
+            debug('extracting entry', {
+                filename: entry.fileName,
+                isDir,
+                isSymlink: symlink
+            });
+            const procMode = this.getExtractedMode(mode, isDir) & 0o777;
+            // always ensure folders are created
+            const destDir = isDir ? dest : path.dirname(dest);
+            const mkdirOptions = { recursive: true };
+            if (isDir) {
+                mkdirOptions.mode = procMode;
+            }
+            debug('mkdir', Object.assign({ dir: destDir }, mkdirOptions));
+            yield fs_1.promises.mkdir(destDir, mkdirOptions);
+            if (isDir)
+                return;
+            debug('opening read stream', dest);
+            const readStream = yield promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+            if (symlink) {
+                // const link = await getStream(readStream)
+                // debug('creating symlink', link, dest)
+                // await fs.symlink(link, dest)
+            }
+            else {
+                yield pipeline(readStream, (0, fs_1.createWriteStream)(dest, { mode: procMode }));
+            }
+        });
+    }
+    getExtractedMode(entryMode, isDir) {
+        let mode = entryMode;
+        // Set defaults, if necessary
+        if (mode === 0) {
+            if (isDir) {
+                if (this.opts.defaultDirMode) {
+                    mode = parseInt(this.opts.defaultDirMode, 10);
+                }
+                if (!mode) {
+                    mode = 0o755;
+                }
+            }
+            else {
+                if (this.opts.defaultFileMode) {
+                    mode = parseInt(this.opts.defaultFileMode, 10);
+                }
+                if (!mode) {
+                    mode = 0o644;
+                }
+            }
+        }
+        return mode;
+    }
+}
+class Zip {
+    constructor(options) {
+        this.options = options;
+        this.archive = archiver('zip', {
+            zlib: { level: 9 } // Sets the compression level.
+        });
+        this.initOutput();
+    }
+    initOutput() {
+        const { outputDir } = this.options;
+        this.output = fse.createWriteStream(outputDir);
+        this.archive.pipe(this.output);
+    }
+    finalize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.archive.finalize();
+        });
+    }
+}
+exports.Zip = Zip;
+/**
+ * 解压 zip 文件 yauzl
+ * @param zipPath string
+ * @param outputDir string
+ * @param options unzipOptions
+ */
+function unzip(zipPath, outputDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        debug('creating target directory', outputDir);
+        if (!path.isAbsolute(outputDir)) {
+            throw new Error('Target directory is expected to be absolute');
+        }
+        yield fs_1.promises.mkdir(outputDir, { recursive: true });
+        const _outputDir = yield fs_1.promises.realpath(outputDir);
+        return new Extractor(zipPath, {
+            dir: _outputDir
+        }).extract();
+    });
+}
+exports.unzip = unzip;
+/**
+ * 解压 zip 文件
+ * @param zipPath string
+ * @param outputDir string
+ */
+function unzipMac(zipPath, outputDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const proc = (0, child_process_1.spawn)('/usr/bin/unzip', [zipPath, '-d', outputDir]);
+            const output = '';
+            proc.on('error', err => {
+                reject(err);
+            });
+            proc.on('exit', (code) => {
+                if (code > 0) {
+                    reject(new Error(`Exited with code ${code}`));
+                }
+                else {
+                    resolve(output);
+                }
+            });
+            proc.stderr.on('data', chunk => {
+                console.error(chunk.toString());
+            });
+            proc.stdout.on('data', chunk => {
+                // console.log(chunk.toString());
+            });
+        });
+    });
+}
+exports.unzipMac = unzipMac;
+const genZip = (input, output, appId) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve, reject) => {
+        const outputStream = (0, fs_1.createWriteStream)(output);
+        const archive = archiver('zip', {
+            zlib: { level: 9 } // Sets the compression level.
+        });
+        outputStream.on('close', () => {
+            resolve();
+        });
+        archive.on('error', error => {
+            console.error('archive error:', error);
+            reject(error);
+        });
+        archive.pipe(outputStream);
+        if (appId) {
+            archive.directory(input, appId);
+        }
+        else {
+            archive.directory(input, './');
+        }
+        archive.finalize();
+    });
+});
+exports.genZip = genZip;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xhs-mp-compiler-cli",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "xhs mp command tool.",
   "preferGlobal": true,
   "category": "esm",
@@ -20,6 +20,11 @@
   "author": "zyu1 <fuzhu@xiaohongshu.com>",
   "license": "MIT",
   "dependencies": {
+    "archiver": "^7.0.1",
+    "debug": "^4.3.4",
+    "globby": "^11.1.0",
+    "query-string": "^8.1.0",
+    "yauzl": "^2.10.0",
     "@babel/core": "^7.12.10",
     "@babel/generator": "^7.12.10",
     "@babel/parser": "^7.12.10",
@@ -77,10 +82,11 @@
     "webpack-bundle-analyzer": "^4.4.0",
     "webpack-chain": "^6.5.1",
     "webpack-sources": "^3.2.2",
-    "xhs-mp-compiler-ml-loader": "1.1.0",
-    "xhs-mp-compiler-utils": "1.1.0",
-    "xhs-mp-pack": "^1.1.0",
-    "xhs-mp-project": "^1.1.0"
+    "xhs-mp-compiler-ml-loader": "1.1.1",
+    "xhs-mp-compiler-utils": "1.1.1",
+    "xhs-mp-pack": "^1.1.1",
+    "xhs-mp-project": "^1.1.1",
+    "xhs-mp-utils": "^1.1.1"
   },
   "devDependencies": {
     "@types/babel__generator": "7.6.3",