623 lines
14 KiB
JavaScript
623 lines
14 KiB
JavaScript
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", {
|
||
value: true
|
||
});
|
||
exports.serializeToYaml = serializeToYaml;
|
||
exports.removePassword = removePassword;
|
||
exports.exec = exec;
|
||
exports.doSpawn = doSpawn;
|
||
exports.spawnAndWrite = spawnAndWrite;
|
||
exports.spawn = spawn;
|
||
exports.use = use;
|
||
exports.isEmptyOrSpaces = isEmptyOrSpaces;
|
||
exports.isTokenCharValid = isTokenCharValid;
|
||
exports.addValue = addValue;
|
||
exports.replaceDefault = replaceDefault;
|
||
exports.getPlatformIconFileName = getPlatformIconFileName;
|
||
exports.isPullRequest = isPullRequest;
|
||
exports.isEnvTrue = isEnvTrue;
|
||
exports.executeAppBuilder = executeAppBuilder;
|
||
Object.defineProperty(exports, "safeStringifyJson", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _builderUtilRuntime().safeStringifyJson;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "asArray", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _builderUtilRuntime().asArray;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "log", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _log().log;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "debug", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _log().debug;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "TmpDir", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _tempFile().TmpDir;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "Arch", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _arch().Arch;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "getArchCliNames", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _arch().getArchCliNames;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "toLinuxArchString", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _arch().toLinuxArchString;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "getArchSuffix", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _arch().getArchSuffix;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "archFromString", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _arch().archFromString;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "AsyncTaskManager", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _asyncTaskManager().AsyncTaskManager;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "DebugLogger", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _DebugLogger().DebugLogger;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "copyFile", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _fs().copyFile;
|
||
}
|
||
});
|
||
Object.defineProperty(exports, "deepAssign", {
|
||
enumerable: true,
|
||
get: function () {
|
||
return _deepAssign().deepAssign;
|
||
}
|
||
});
|
||
exports.InvalidConfigurationError = exports.ExecError = exports.debug7z = void 0;
|
||
|
||
function _zipBin() {
|
||
const data = require("7zip-bin");
|
||
|
||
_zipBin = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _appBuilderBin() {
|
||
const data = require("app-builder-bin");
|
||
|
||
_appBuilderBin = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _builderUtilRuntime() {
|
||
const data = require("builder-util-runtime");
|
||
|
||
_builderUtilRuntime = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _chalk() {
|
||
const data = _interopRequireDefault(require("chalk"));
|
||
|
||
_chalk = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _child_process() {
|
||
const data = require("child_process");
|
||
|
||
_child_process = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _crypto() {
|
||
const data = require("crypto");
|
||
|
||
_crypto = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
var _debug2 = _interopRequireDefault(require("debug"));
|
||
|
||
function _jsYaml() {
|
||
const data = require("js-yaml");
|
||
|
||
_jsYaml = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
var path = _interopRequireWildcard(require("path"));
|
||
|
||
require("source-map-support/register");
|
||
|
||
function _log() {
|
||
const data = require("./log");
|
||
|
||
_log = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _tempFile() {
|
||
const data = require("temp-file");
|
||
|
||
_tempFile = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _arch() {
|
||
const data = require("./arch");
|
||
|
||
_arch = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _asyncTaskManager() {
|
||
const data = require("./asyncTaskManager");
|
||
|
||
_asyncTaskManager = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _DebugLogger() {
|
||
const data = require("./DebugLogger");
|
||
|
||
_DebugLogger = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _fs() {
|
||
const data = require("./fs");
|
||
|
||
_fs = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _deepAssign() {
|
||
const data = require("./deepAssign");
|
||
|
||
_deepAssign = function () {
|
||
return data;
|
||
};
|
||
|
||
return data;
|
||
}
|
||
|
||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
const debug7z = (0, _debug2.default)("electron-builder:7z");
|
||
exports.debug7z = debug7z;
|
||
|
||
function serializeToYaml(object, skipInvalid = false, noRefs = false) {
|
||
return (0, _jsYaml().safeDump)(object, {
|
||
lineWidth: 8000,
|
||
skipInvalid,
|
||
noRefs
|
||
});
|
||
}
|
||
|
||
function removePassword(input) {
|
||
return input.replace(/(-String |-P |pass:| \/p |-pass |--secretKey |--accessKey |-p )([^ ]+)/g, (match, p1, p2) => {
|
||
if (p1.trim() === "/p" && p2.startsWith("\\\\Mac\\Host\\\\")) {
|
||
// appx /p
|
||
return `${p1}${p2}`;
|
||
}
|
||
|
||
return `${p1}${(0, _crypto().createHash)("sha256").update(p2).digest("hex")} (sha256 hash)`;
|
||
});
|
||
}
|
||
|
||
function getProcessEnv(env) {
|
||
if (process.platform === "win32") {
|
||
return env == null ? undefined : env;
|
||
}
|
||
|
||
const finalEnv = Object.assign({}, env || process.env); // without LC_CTYPE dpkg can returns encoded unicode symbols
|
||
// set LC_CTYPE to avoid crash https://github.com/electron-userland/electron-builder/issues/503 Even "en_DE.UTF-8" leads to error.
|
||
|
||
const locale = process.platform === "linux" ? process.env.LANG || "C.UTF-8" : "en_US.UTF-8";
|
||
finalEnv.LANG = locale;
|
||
finalEnv.LC_CTYPE = locale;
|
||
finalEnv.LC_ALL = locale;
|
||
return finalEnv;
|
||
}
|
||
|
||
function exec(file, args, options, isLogOutIfDebug = true) {
|
||
if (_log().log.isDebugEnabled) {
|
||
const logFields = {
|
||
file,
|
||
args: args == null ? "" : removePassword(args.join(" "))
|
||
};
|
||
|
||
if (options != null) {
|
||
if (options.cwd != null) {
|
||
logFields.cwd = options.cwd;
|
||
}
|
||
|
||
if (options.env != null) {
|
||
const diffEnv = Object.assign({}, options.env);
|
||
|
||
for (const name of Object.keys(process.env)) {
|
||
if (process.env[name] === options.env[name]) {
|
||
delete diffEnv[name];
|
||
}
|
||
}
|
||
|
||
logFields.env = (0, _builderUtilRuntime().safeStringifyJson)(diffEnv);
|
||
}
|
||
}
|
||
|
||
_log().log.debug(logFields, "executing");
|
||
}
|
||
|
||
return new Promise((resolve, reject) => {
|
||
(0, _child_process().execFile)(file, args, Object.assign({}, options, {
|
||
maxBuffer: 1000 * 1024 * 1024,
|
||
env: getProcessEnv(options == null ? null : options.env)
|
||
}), (error, stdout, stderr) => {
|
||
if (error == null) {
|
||
if (isLogOutIfDebug && _log().log.isDebugEnabled) {
|
||
const logFields = {
|
||
file
|
||
};
|
||
|
||
if (stdout.length > 0) {
|
||
logFields.stdout = stdout;
|
||
}
|
||
|
||
if (stderr.length > 0) {
|
||
logFields.stderr = stderr;
|
||
}
|
||
|
||
_log().log.debug(logFields, "executed");
|
||
}
|
||
|
||
resolve(stdout.toString());
|
||
} else {
|
||
let message = _chalk().default.red(removePassword(`Exit code: ${error.code}. ${error.message}`));
|
||
|
||
if (stdout.length !== 0) {
|
||
if (file.endsWith("wine")) {
|
||
stdout = stdout.toString();
|
||
}
|
||
|
||
message += `\n${_chalk().default.yellow(stdout.toString())}`;
|
||
}
|
||
|
||
if (stderr.length !== 0) {
|
||
if (file.endsWith("wine")) {
|
||
stderr = stderr.toString();
|
||
}
|
||
|
||
message += `\n${_chalk().default.red(stderr.toString())}`;
|
||
}
|
||
|
||
reject(new Error(message));
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
function logSpawn(command, args, options) {
|
||
// use general debug.enabled to log spawn, because it doesn't produce a lot of output (the only line), but important in any case
|
||
if (!_log().log.isDebugEnabled) {
|
||
return;
|
||
}
|
||
|
||
const argsString = removePassword(args.join(" "));
|
||
const logFields = {
|
||
command: command + " " + (command === "docker" ? argsString : removePassword(argsString))
|
||
};
|
||
|
||
if (options != null && options.cwd != null) {
|
||
logFields.cwd = options.cwd;
|
||
}
|
||
|
||
_log().log.debug(logFields, "spawning");
|
||
}
|
||
|
||
function doSpawn(command, args, options, extraOptions) {
|
||
if (options == null) {
|
||
options = {};
|
||
}
|
||
|
||
options.env = getProcessEnv(options.env);
|
||
|
||
if (options.stdio == null) {
|
||
const isDebugEnabled = _log().debug.enabled; // do not ignore stdout/stderr if not debug, because in this case we will read into buffer and print on error
|
||
|
||
|
||
options.stdio = [extraOptions != null && extraOptions.isPipeInput ? "pipe" : "ignore", isDebugEnabled ? "inherit" : "pipe", isDebugEnabled ? "inherit" : "pipe"];
|
||
}
|
||
|
||
logSpawn(command, args, options);
|
||
|
||
try {
|
||
return (0, _child_process().spawn)(command, args, options);
|
||
} catch (e) {
|
||
throw new Error(`Cannot spawn ${command}: ${e.stack || e}`);
|
||
}
|
||
}
|
||
|
||
function spawnAndWrite(command, args, data, options) {
|
||
const childProcess = doSpawn(command, args, options, {
|
||
isPipeInput: true
|
||
});
|
||
const timeout = setTimeout(() => childProcess.kill(), 4 * 60 * 1000);
|
||
return new Promise((resolve, reject) => {
|
||
handleProcess("close", childProcess, command, () => {
|
||
try {
|
||
clearTimeout(timeout);
|
||
} finally {
|
||
resolve();
|
||
}
|
||
}, error => {
|
||
try {
|
||
clearTimeout(timeout);
|
||
} finally {
|
||
reject(error.stack || error.toString());
|
||
}
|
||
});
|
||
childProcess.stdin.end(data);
|
||
});
|
||
}
|
||
|
||
function spawn(command, args, options, extraOptions) {
|
||
return new Promise((resolve, reject) => {
|
||
handleProcess("close", doSpawn(command, args || [], options, extraOptions), command, resolve, reject);
|
||
});
|
||
}
|
||
|
||
function handleProcess(event, childProcess, command, resolve, reject) {
|
||
childProcess.on("error", reject);
|
||
let out = "";
|
||
|
||
if (childProcess.stdout != null) {
|
||
childProcess.stdout.on("data", data => {
|
||
out += data;
|
||
});
|
||
}
|
||
|
||
let errorOut = "";
|
||
|
||
if (childProcess.stderr != null) {
|
||
childProcess.stderr.on("data", data => {
|
||
errorOut += data;
|
||
});
|
||
}
|
||
|
||
childProcess.once(event, code => {
|
||
if (_log().log.isDebugEnabled) {
|
||
const fields = {
|
||
command: path.basename(command),
|
||
code,
|
||
pid: childProcess.pid
|
||
};
|
||
|
||
if (out.length > 0) {
|
||
fields.out = out;
|
||
}
|
||
|
||
_log().log.debug(fields, "exited");
|
||
}
|
||
|
||
if (code === 0) {
|
||
if (resolve != null) {
|
||
resolve(out);
|
||
}
|
||
} else {
|
||
reject(new ExecError(command, code, formatOut(out, "Output"), formatOut(errorOut, "Error output")));
|
||
}
|
||
});
|
||
}
|
||
|
||
function formatOut(text, title) {
|
||
return text.length === 0 ? "" : `\n${title}:\n${text}`;
|
||
}
|
||
|
||
class ExecError extends Error {
|
||
constructor(command, exitCode, out, errorOut, code = "ERR_ELECTRON_BUILDER_CANNOT_EXECUTE") {
|
||
super(`${command} exited with code ${code}${formatOut(out, "Output")}${formatOut(errorOut, "Error output")}`);
|
||
this.exitCode = exitCode;
|
||
this.alreadyLogged = false;
|
||
this.code = code;
|
||
}
|
||
|
||
}
|
||
|
||
exports.ExecError = ExecError;
|
||
|
||
function use(value, task) {
|
||
return value == null ? null : task(value);
|
||
}
|
||
|
||
function isEmptyOrSpaces(s) {
|
||
return s == null || s.trim().length === 0;
|
||
}
|
||
|
||
function isTokenCharValid(token) {
|
||
return /^[\w\/=+-]+$/.test(token);
|
||
}
|
||
|
||
function addValue(map, key, value) {
|
||
const list = map.get(key);
|
||
|
||
if (list == null) {
|
||
map.set(key, [value]);
|
||
} else if (!list.includes(value)) {
|
||
list.push(value);
|
||
}
|
||
}
|
||
|
||
function replaceDefault(inList, defaultList) {
|
||
if (inList == null || inList.length === 1 && inList[0] === "default") {
|
||
return defaultList;
|
||
}
|
||
|
||
const index = inList.indexOf("default");
|
||
|
||
if (index >= 0) {
|
||
const list = inList.slice(0, index);
|
||
list.push(...defaultList);
|
||
|
||
if (index !== inList.length - 1) {
|
||
list.push(...inList.slice(index + 1));
|
||
}
|
||
|
||
inList = list;
|
||
}
|
||
|
||
return inList;
|
||
}
|
||
|
||
function getPlatformIconFileName(value, isMac) {
|
||
if (value === undefined) {
|
||
return undefined;
|
||
}
|
||
|
||
if (value === null) {
|
||
return null;
|
||
}
|
||
|
||
if (!value.includes(".")) {
|
||
return `${value}.${isMac ? "icns" : "ico"}`;
|
||
}
|
||
|
||
return value.replace(isMac ? ".ico" : ".icns", isMac ? ".icns" : ".ico");
|
||
}
|
||
|
||
function isPullRequest() {
|
||
// TRAVIS_PULL_REQUEST is set to the pull request number if the current job is a pull request build, or false if it’s not.
|
||
function isSet(value) {
|
||
// value can be or null, or empty string
|
||
return value && value !== "false";
|
||
}
|
||
|
||
return isSet(process.env.TRAVIS_PULL_REQUEST) || isSet(process.env.CI_PULL_REQUEST) || isSet(process.env.CI_PULL_REQUESTS) || isSet(process.env.BITRISE_PULL_REQUEST) || isSet(process.env.APPVEYOR_PULL_REQUEST_NUMBER);
|
||
}
|
||
|
||
function isEnvTrue(value) {
|
||
if (value != null) {
|
||
value = value.trim();
|
||
}
|
||
|
||
return value === "true" || value === "" || value === "1";
|
||
}
|
||
|
||
class InvalidConfigurationError extends Error {
|
||
constructor(message, code = "ERR_ELECTRON_BUILDER_INVALID_CONFIGURATION") {
|
||
super(message);
|
||
this.code = code;
|
||
}
|
||
|
||
}
|
||
|
||
exports.InvalidConfigurationError = InvalidConfigurationError;
|
||
|
||
function executeAppBuilder(args, childProcessConsumer, extraOptions = {}) {
|
||
return new Promise((resolve, reject) => {
|
||
const command = _appBuilderBin().appBuilderPath;
|
||
|
||
const env = Object.assign({}, process.env, {
|
||
SZA_PATH: _zipBin().path7za,
|
||
FORCE_COLOR: _chalk().default.enabled ? "1" : "0"
|
||
});
|
||
const cacheEnv = process.env.ELECTRON_BUILDER_CACHE;
|
||
|
||
if (cacheEnv != null && cacheEnv.length > 0) {
|
||
env.ELECTRON_BUILDER_CACHE = path.resolve(cacheEnv);
|
||
}
|
||
|
||
if (extraOptions.env != null) {
|
||
Object.assign(env, extraOptions.env);
|
||
}
|
||
|
||
const childProcess = doSpawn(command, args, Object.assign({
|
||
env,
|
||
stdio: ["ignore", "pipe", process.stdout]
|
||
}, extraOptions));
|
||
|
||
if (childProcessConsumer != null) {
|
||
childProcessConsumer(childProcess);
|
||
}
|
||
|
||
handleProcess("close", childProcess, command, resolve, error => {
|
||
if (error instanceof ExecError && error.exitCode === 2) {
|
||
error.alreadyLogged = true;
|
||
}
|
||
|
||
reject(error);
|
||
});
|
||
});
|
||
}
|
||
// __ts-babel@6.0.4
|
||
//# sourceMappingURL=util.js.map
|