@gaoding/gd-tracker/bin/core/zipper.js

Gaoding tracker for sensorsdata(sa), baidu(_hmt), Growing.IO(gio)

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
function _export(target, all) {
    for(var name in all)Object.defineProperty(target, name, {
        enumerable: true,
        get: all[name]
    });
}
_export(exports, {
    ZipEncryptedType: function() {
        return ZipEncryptedType;
    },
    DEFAULT_LEVEL: function() {
        return DEFAULT_LEVEL;
    },
    DEFAULT_METHOD: function() {
        return DEFAULT_METHOD;
    },
    DEFAULT_PASSWORD: function() {
        return DEFAULT_PASSWORD;
    },
    ZipEncryptedOption: function() {
        return ZipEncryptedOption;
    },
    ZipOutputOption: function() {
        return ZipOutputOption;
    },
    ZipArchiveOption: function() {
        return ZipArchiveOption;
    },
    ZipOption: function() {
        return ZipOption;
    },
    zip: function() {
        return zip;
    },
    UnZipOption: function() {
        return UnZipOption;
    },
    unzip: function() {
        return unzip;
    }
});
var _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
var _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
var _archiver = /*#__PURE__*/ _interopRequireDefault(require("archiver"));
var _unzipper = /*#__PURE__*/ _interopRequireDefault(require("unzipper"));
var _rimraf = /*#__PURE__*/ _interopRequireDefault(require("rimraf"));
var _makeDir = /*#__PURE__*/ _interopRequireDefault(require("make-dir"));
var _lodash = require("lodash");
var _index = require("../constants/index");
var _logger = require("./logger");
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
        var info = gen[key](arg);
        var value = info.value;
    } catch (error) {
        reject(error);
        return;
    }
    if (info.done) {
        resolve(value);
    } else {
        Promise.resolve(value).then(_next, _throw);
    }
}
function _asyncToGenerator(fn) {
    return function() {
        var self = this, args = arguments;
        return new Promise(function(resolve, reject) {
            var gen = fn.apply(self, args);
            function _next(value) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
            }
            function _throw(err) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
            }
            _next(undefined);
        });
    };
}
function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
var __generator = (void 0) && (void 0).__generator || function(thisArg, body) {
    var f, y, t, g, _ = {
        label: 0,
        sent: function() {
            if (t[0] & 1) throw t[1];
            return t[1];
        },
        trys: [],
        ops: []
    };
    return(g = {
        next: verb(0),
        "throw": verb(1),
        "return": verb(2)
    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
        return this;
    }), g);
    function verb(n) {
        return function(v) {
            return step([
                n,
                v
            ]);
        };
    }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while(_)try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [
                op[0] & 2,
                t.value
            ];
            switch(op[0]){
                case 0:
                case 1:
                    t = op;
                    break;
                case 4:
                    _.label++;
                    return {
                        value: op[1],
                        done: false
                    };
                case 5:
                    _.label++;
                    y = op[1];
                    op = [
                        0
                    ];
                    continue;
                case 7:
                    op = _.ops.pop();
                    _.trys.pop();
                    continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                        _ = 0;
                        continue;
                    }
                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
                        _.label = op[1];
                        break;
                    }
                    if (op[0] === 6 && _.label < t[1]) {
                        _.label = t[1];
                        t = op;
                        break;
                    }
                    if (t && _.label < t[2]) {
                        _.label = t[2];
                        _.ops.push(op);
                        break;
                    }
                    if (t[2]) _.ops.pop();
                    _.trys.pop();
                    continue;
            }
            op = body.call(thisArg, _);
        } catch (e) {
            op = [
                6,
                e
            ];
            y = 0;
        } finally{
            f = t = 0;
        }
        if (op[0] & 5) throw op[1];
        return {
            value: op[0] ? op[1] : void 0,
            done: true
        };
    }
};
var ZipEncryptedType;
(function(ZipEncryptedType) {
    ZipEncryptedType["AES256"] = "aes256";
    ZipEncryptedType["ZIP20"] = "zip20";
})(ZipEncryptedType || (ZipEncryptedType = {}));
var DEFAULT_LEVEL = 9;
var DEFAULT_METHOD = ZipEncryptedType.ZIP20;
var DEFAULT_PASSWORD = "";
var ZipEncryptedOption = function ZipEncryptedOption(option) {
    "use strict";
    _classCallCheck(this, ZipEncryptedOption);
    this.level = DEFAULT_LEVEL // level: 压缩级别
    ;
    this.type = DEFAULT_METHOD // type: 加密方式
    ;
    this.password = DEFAULT_PASSWORD // password: 压缩密码
    ;
    Object.assign(this, option);
};
// 创建 Archiver 压缩的选项
var createZipOption = function(option) {
    var zeo = new ZipEncryptedOption(option);
    var zlib = {
        level: zeo.level || DEFAULT_LEVEL
    };
    var encryptionMethod = zeo.type || DEFAULT_METHOD;
    var password = zeo.password;
    if (!zeo.password) return {
        zlib: zlib,
        encryptionMethod: encryptionMethod
    };
    if (!(0, _lodash.isString)(password)) return _logger.logger.error("创建 ZIP 文件失败！无效的压缩密码 password:", password).exit();
    var result = {
        zlib: zlib,
        encryptionMethod: encryptionMethod,
        password: password
    };
    return result;
};
var ZipOutputOption = function ZipOutputOption(option) {
    "use strict";
    _classCallCheck(this, ZipOutputOption);
    this.filename = "" // filename: 压缩后的 .zip 的问价路径
    ;
    Object.assign(this, option);
};
// 创建一个输出流
var createOutput = function() {
    var _ref = _asyncToGenerator(function(option) {
        var ref, filename, onSuccess, stream;
        return __generator(this, function(_state) {
            ref = new ZipOutputOption(option), filename = ref.filename, onSuccess = ref.onSuccess;
            stream = _fs.default.createWriteStream(filename, {
                encoding: _index.UTF_8
            });
            if (!(0, _lodash.isFunction)(onSuccess)) return [
                2,
                stream
            ];
            stream.on("close", function() {
                return onSuccess(stream);
            });
            return [
                2,
                stream
            ];
        });
    });
    return function createOutput(option) {
        return _ref.apply(this, arguments);
    };
}();
var ZipArchiveOption = function ZipArchiveOption(option) {
    "use strict";
    _classCallCheck(this, ZipArchiveOption);
    this.dirname = "" // dirname: 要使用 zip 方式压缩的文件夹的路径
    ;
    this.password = "" // password: 压缩 .zip 文件的密码
    ;
    Object.assign(this, option);
};
// 创建一个 Archiver 的实例
var createArchive = function() {
    var _ref = _asyncToGenerator(function(option) {
        var ref, dirname, password, onError, zeo, zo, type, archive;
        return __generator(this, function(_state) {
            ref = new ZipArchiveOption(option), dirname = ref.dirname, password = ref.password, onError = ref.onError;
            _archiver.default.registerFormat("zip-encrypted", require("archiver-zip-encrypted"));
            zeo = new ZipEncryptedOption({
                password: password
            });
            zo = createZipOption(zeo);
            type = zeo.password ? "zip-encrypted" : "zip";
            archive = _archiver.default.create(type, zo);
            archive.directory(dirname, false);
            if ((0, _lodash.isFunction)(onError)) archive.on("error", onError);
            return [
                2,
                archive
            ];
        });
    });
    return function createArchive(option) {
        return _ref.apply(this, arguments);
    };
}();
var ZipOption = function ZipOption(option) {
    "use strict";
    _classCallCheck(this, ZipOption);
    var zeo = new ZipEncryptedOption(option);
    var zoo = new ZipOutputOption(option);
    var zao = new ZipArchiveOption(option);
    Object.assign(this, zeo, zoo, zao);
};
var zip = function() {
    var _ref = _asyncToGenerator(function(option) {
        var zco, dirname, zipdir, output, archive;
        return __generator(this, function(_state) {
            switch(_state.label){
                case 0:
                    zco = new ZipOption(option);
                    dirname = zco.dirname;
                    zipdir = _path.default.dirname(option.filename);
                    if (!_fs.default.existsSync(dirname)) return [
                        2,
                        _logger.logger.error("创建 .zip 文件失败！您正在尝试压缩一个不存在的目录 dirname:", dirname).exit()
                    ];
                    if (!_fs.default.statSync(dirname).isDirectory()) return [
                        2,
                        _logger.logger.error("创建 .zip 文件失败！压缩的路径不是一个目录 dirname:", dirname).exit()
                    ];
                    if (!_fs.default.existsSync(zipdir)) _makeDir.default.sync(zipdir);
                    if (!_fs.default.statSync(zipdir).isDirectory()) {
                        _rimraf.default.sync(zipdir);
                        _makeDir.default.sync(zipdir);
                    }
                    return [
                        4,
                        createOutput(zco)
                    ];
                case 1:
                    output = _state.sent();
                    return [
                        4,
                        createArchive(zco)
                    ];
                case 2:
                    archive = _state.sent();
                    archive.pipe(output);
                    return [
                        4,
                        archive.finalize()
                    ];
                case 3:
                    return [
                        2,
                        _state.sent()
                    ];
            }
        });
    });
    return function zip(option) {
        return _ref.apply(this, arguments);
    };
}();
// 解压文件夹里的子文件夹
var unZipSubDir = function(root, files) {
    var list = Array.isArray(files) ? files : [];
    var subDirs = list.filter(function(item) {
        return (item === null || item === void 0 ? void 0 : item.type) === "Directory";
    });
    subDirs.forEach(function(dir) {
        var name = _path.default.resolve(root, "./".concat(dir.path));
        var isExists = _fs.default.existsSync(name);
        if (isExists) return;
        _makeDir.default.sync(name);
    });
};
// 解压文件夹里的子文件
var unZipSubFile = function(root, files, password) {
    var list = Array.isArray(files) ? files : [];
    var subFiles = list.filter(function(item) {
        return (item === null || item === void 0 ? void 0 : item.type) === "File";
    });
    return subFiles.map(function(file) {
        return new Promise(function(resolve, reject) {
            var name = _path.default.resolve(root, "./".concat(file.path));
            return file.stream(password).pipe(_fs.default.createWriteStream(name, {
                encoding: _index.UTF_8
            })).on("finish", function() {
                return resolve(name);
            }).on("error", reject);
        });
    });
};
// 处理解压 .zip 文件失败
var onUnZipError = function(error, callback) {
    _logger.logger.error("解压 .zip 文件失败！error:", error);
    if ((0, _lodash.isFunction)(callback)) callback(error);
};
var UnZipOption = function UnZipOption(option) {
    "use strict";
    _classCallCheck(this, UnZipOption);
    this.filename = "" // filename: 压缩后的 .zip 的问价路径
    ;
    this.dirname = "" // dirname: 解 .zip 文件后存放的解压文件的路径
    ;
    this.password = "" // password: 解缩 .zip 文件的密码
    ;
    Object.assign(this, option);
};
var unzip = function() {
    var _ref = _asyncToGenerator(function(option) {
        var uzo, filename, dirname, password, onSuccess, onError, dir, promises, error;
        return __generator(this, function(_state) {
            switch(_state.label){
                case 0:
                    uzo = new UnZipOption(option);
                    filename = uzo.filename, dirname = uzo.dirname, password = uzo.password, onSuccess = uzo.onSuccess, onError = uzo.onError;
                    _state.label = 1;
                case 1:
                    _state.trys.push([
                        1,
                        3,
                        ,
                        4
                    ]);
                    _rimraf.default.sync(dirname);
                    _makeDir.default.sync(dirname);
                    return [
                        4,
                        _unzipper.default.Open.file(filename)
                    ];
                case 2:
                    dir = _state.sent();
                    unZipSubDir(dirname, dir === null || dir === void 0 ? void 0 : dir.files);
                    promises = unZipSubFile(dirname, dir === null || dir === void 0 ? void 0 : dir.files, password);
                    Promise.all(promises).then(function(result) {
                        if (!(0, _lodash.isFunction)(onSuccess)) return result;
                        return onSuccess(result);
                    }).catch(function(error) {
                        return onUnZipError(error, onError);
                    });
                    return [
                        3,
                        4
                    ];
                case 3:
                    error = _state.sent();
                    onUnZipError(error, onError);
                    return [
                        3,
                        4
                    ];
                case 4:
                    return [
                        2
                    ];
            }
        });
    });
    return function unzip(option) {
        return _ref.apply(this, arguments);
    };
}();