electron-builder
Version:
A complete solution to package and build a ready for distribution Electron app for MacOS, Windows and Linux with “auto update” support out of the box
390 lines (340 loc) • 17.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Packager = undefined;
var _bluebirdLstC;
function _load_bluebirdLstC() {
return _bluebirdLstC = require("bluebird-lst-c");
}
var _bluebirdLstC2;
function _load_bluebirdLstC2() {
return _bluebirdLstC2 = _interopRequireDefault(require("bluebird-lst-c"));
}
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
let checkWineVersion = (() => {
var _ref5 = (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* (checkPromise) {
function wineError(prefix) {
return `${ prefix }, please see https://github.com/electron-userland/electron-builder/wiki/Multi-Platform-Build#${ process.platform === "linux" ? "linux" : "os-x" }`;
}
let wineVersion;
try {
wineVersion = (yield checkPromise).trim();
} catch (e) {
if (e.code === "ENOENT") {
throw new Error(wineError("wine is required"));
} else {
throw new Error(`Cannot check wine version: ${ e }`);
}
}
if (wineVersion.startsWith("wine-")) {
wineVersion = wineVersion.substring("wine-".length);
}
if (wineVersion.split(".").length === 2) {
wineVersion += ".0";
}
if ((0, (_semver || _load_semver()).lt)(wineVersion, "1.8.0")) {
throw new Error(wineError(`wine 1.8+ is required, but your version is ${ wineVersion }`));
}
});
return function checkWineVersion(_x) {
return _ref5.apply(this, arguments);
};
})();
exports.normalizePlatforms = normalizePlatforms;
var _path;
function _load_path() {
return _path = _interopRequireWildcard(require("path"));
}
var _util;
function _load_util() {
return _util = require("./util/util");
}
var _promise;
function _load_promise() {
return _promise = require("./util/promise");
}
var _events;
function _load_events() {
return _events = require("events");
}
var _metadata;
function _load_metadata() {
return _metadata = require("./metadata");
}
var _errorMessages;
function _load_errorMessages() {
return _errorMessages = _interopRequireWildcard(require("./errorMessages"));
}
var _util2;
function _load_util2() {
return _util2 = _interopRequireWildcard(require("util"));
}
var _deepAssign;
function _load_deepAssign() {
return _deepAssign = require("./util/deepAssign");
}
var _semver;
function _load_semver() {
return _semver = require("semver");
}
var _log;
function _load_log() {
return _log = require("./util/log");
}
var _appInfo;
function _load_appInfo() {
return _appInfo = require("./appInfo");
}
var _targetFactory;
function _load_targetFactory() {
return _targetFactory = require("./targets/targetFactory");
}
var _readPackageJson;
function _load_readPackageJson() {
return _readPackageJson = require("./util/readPackageJson");
}
var _tmp;
function _load_tmp() {
return _tmp = require("./util/tmp");
}
var _yarn;
function _load_yarn() {
return _yarn = require("./yarn");
}
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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function addHandler(emitter, event, handler) {
emitter.on(event, handler);
}
class Packager {
//noinspection JSUnusedGlobalSymbols
constructor(options) {
this.options = options;
this.isTwoPackageJsonProjectLayoutUsed = true;
this.eventEmitter = new (_events || _load_events()).EventEmitter();
this.tempDirManager = new (_tmp || _load_tmp()).TmpDir();
this.projectDir = options.projectDir == null ? process.cwd() : (_path || _load_path()).resolve(options.projectDir);
}
artifactCreated(handler) {
addHandler(this.eventEmitter, "artifactCreated", handler);
return this;
}
get devPackageFile() {
return (_path || _load_path()).join(this.projectDir, "package.json");
}
build() {
var _this = this;
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
const devPackageFile = _this.devPackageFile;
const extraMetadata = _this.options.extraMetadata;
const extraBuildMetadata = extraMetadata == null ? null : extraMetadata.build;
_this.devMetadata = (0, (_deepAssign || _load_deepAssign()).deepAssign)((yield (0, (_readPackageJson || _load_readPackageJson()).readPackageJson)(devPackageFile)), _this.options.devMetadata);
if (extraMetadata != null) {
if (extraBuildMetadata != null) {
(0, (_deepAssign || _load_deepAssign()).deepAssign)(_this.devMetadata, { build: extraBuildMetadata });
delete extraMetadata.build;
}
if (extraMetadata.directories != null) {
(0, (_deepAssign || _load_deepAssign()).deepAssign)(_this.devMetadata, { directories: extraMetadata.directories });
delete extraMetadata.directories;
}
}
_this.appDir = yield (0, (_util || _load_util()).computeDefaultAppDirectory)(_this.projectDir, (0, (_util || _load_util()).use)(_this.devMetadata.directories, function (it) {
return it.app;
}));
_this.isTwoPackageJsonProjectLayoutUsed = _this.appDir !== _this.projectDir;
const appPackageFile = _this.isTwoPackageJsonProjectLayoutUsed ? (_path || _load_path()).join(_this.appDir, "package.json") : devPackageFile;
if (_this.isTwoPackageJsonProjectLayoutUsed) {
_this.metadata = (0, (_deepAssign || _load_deepAssign()).deepAssign)((yield (0, (_readPackageJson || _load_readPackageJson()).readPackageJson)(appPackageFile)), _this.options.appMetadata, extraMetadata);
} else {
if (_this.options.appMetadata != null) {
(0, (_deepAssign || _load_deepAssign()).deepAssign)(_this.devMetadata, _this.options.appMetadata);
}
if (extraMetadata != null) {
(0, (_deepAssign || _load_deepAssign()).deepAssign)(_this.devMetadata, extraMetadata);
}
_this.metadata = _this.devMetadata;
}
_this.checkMetadata(appPackageFile, devPackageFile);
checkConflictingOptions(_this.devMetadata.build);
_this.electronVersion = yield (0, (_util || _load_util()).getElectronVersion)(_this.devMetadata, devPackageFile);
_this.appInfo = new (_appInfo || _load_appInfo()).AppInfo(_this.metadata, _this.devMetadata);
const cleanupTasks = [];
return (0, (_promise || _load_promise()).executeFinally)(_this.doBuild(cleanupTasks), function () {
return (0, (_promise || _load_promise()).all)(cleanupTasks.map(function (it) {
return it();
}).concat(_this.tempDirManager.cleanup()));
});
})();
}
doBuild(cleanupTasks) {
var _this2 = this;
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
const distTasks = [];
const outDir = (_path || _load_path()).resolve(_this2.projectDir, (0, (_util || _load_util()).use)(_this2.devMetadata.directories, function (it) {
return it.output;
}) || "dist");
const platformToTarget = new Map();
// custom packager - don't check wine
let checkWine = _this2.options.platformPackagerFactory == null;
for (let _ref of _this2.options.targets) {
var _ref2 = _slicedToArray(_ref, 2);
let platform = _ref2[0];
let archToType = _ref2[1];
if (platform === (_metadata || _load_metadata()).Platform.MAC && process.platform === (_metadata || _load_metadata()).Platform.WINDOWS.nodeName) {
throw new Error("Build for MacOS is supported only on MacOS, please see https://github.com/electron-userland/electron-builder/wiki/Multi-Platform-Build");
}
let wineCheck = null;
if (checkWine && process.platform !== "win32" && platform === (_metadata || _load_metadata()).Platform.WINDOWS) {
wineCheck = (0, (_util || _load_util()).exec)("wine", ["--version"]);
}
const helper = _this2.createHelper(platform, cleanupTasks);
const nameToTarget = new Map();
platformToTarget.set(platform, nameToTarget);
for (let _ref3 of archToType) {
var _ref4 = _slicedToArray(_ref3, 2);
let arch = _ref4[0];
let targets = _ref4[1];
yield _this2.installAppDependencies(platform, arch);
if (checkWine && wineCheck != null) {
checkWine = false;
checkWineVersion(wineCheck);
}
yield helper.pack(outDir, arch, (0, (_targetFactory || _load_targetFactory()).createTargets)(nameToTarget, targets, outDir, helper, cleanupTasks), distTasks);
}
for (let target of nameToTarget.values()) {
distTasks.push(target.finishBuild());
}
}
yield (_bluebirdLstC2 || _load_bluebirdLstC2()).default.all(distTasks);
return platformToTarget;
})();
}
createHelper(platform, cleanupTasks) {
if (this.options.platformPackagerFactory != null) {
return this.options.platformPackagerFactory(this, platform, cleanupTasks);
}
switch (platform) {
case (_metadata || _load_metadata()).Platform.MAC:
{
const helperClass = require("./macPackager").default;
return new helperClass(this);
}
case (_metadata || _load_metadata()).Platform.WINDOWS:
{
const helperClass = require("./winPackager").WinPackager;
return new helperClass(this);
}
case (_metadata || _load_metadata()).Platform.LINUX:
return new (require("./linuxPackager").LinuxPackager)(this);
default:
throw new Error(`Unknown platform: ${ platform }`);
}
}
checkMetadata(appPackageFile, devAppPackageFile) {
const reportError = missedFieldName => {
throw new Error(`Please specify '${ missedFieldName }' in the application package.json ('${ appPackageFile }')`);
};
const checkNotEmpty = (name, value) => {
if ((0, (_util || _load_util()).isEmptyOrSpaces)(value)) {
reportError(name);
}
};
const appMetadata = this.metadata;
checkNotEmpty("name", appMetadata.name);
checkNotEmpty("description", appMetadata.description);
checkNotEmpty("version", appMetadata.version);
checkDependencies(this.devMetadata.dependencies);
if (appMetadata !== this.devMetadata) {
checkDependencies(appMetadata.dependencies);
if (appMetadata.build != null) {
throw new Error((_util2 || _load_util2()).format((_errorMessages || _load_errorMessages()).buildInAppSpecified, appPackageFile, devAppPackageFile));
}
}
const build = this.devMetadata.build;
if (build == null) {
throw new Error((_util2 || _load_util2()).format((_errorMessages || _load_errorMessages()).buildIsMissed, devAppPackageFile));
} else {
if (build["osx-sign"] != null) {
throw new Error("osx-sign is deprecated and not supported — please see https://github.com/electron-userland/electron-builder/wiki/Code-Signing");
}
if (build["osx"] != null) {
throw new Error(`"osx" in the "build" is deprecated and not supported — please see use "mac" instead`);
}
const author = appMetadata.author;
if (author == null) {
throw new Error(`Please specify "author" in the application package.json ('${ appPackageFile }') — it is used as company name.`);
}
if (build.name != null) {
throw new Error((_util2 || _load_util2()).format((_errorMessages || _load_errorMessages()).nameInBuildSpecified, appPackageFile));
}
if (build.directories != null) {
throw new Error(`'directories' in the 'build' is not correct. Please move 'directories' from 'build' to root`);
}
if (build.osx != null) {
(0, (_log || _load_log()).warn)('"build.osx" is deprecated — please use "mac" instead of "osx"');
}
if (build.prune != null) {
(0, (_log || _load_log()).warn)("prune is deprecated — development dependencies are never copied in any case");
}
}
}
installAppDependencies(platform, arch) {
var _this3 = this;
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
const options = _this3.devMetadata.build;
if (options.nodeGypRebuild === true) {
(0, (_log || _load_log()).log)(`Executing node-gyp rebuild for arch ${ (_metadata || _load_metadata()).Arch[arch] }`);
yield (0, (_util || _load_util()).exec)(process.platform === "win32" ? "node-gyp.cmd" : "node-gyp", ["rebuild"], {
env: (0, (_yarn || _load_yarn()).getGypEnv)(_this3.electronVersion, (_metadata || _load_metadata()).Arch[arch])
});
}
if (options.npmRebuild === false) {
(0, (_log || _load_log()).log)("Skip app dependencies rebuild because npmRebuild is set to false");
return;
}
if (options.npmSkipBuildFromSource !== true && platform.nodeName !== process.platform) {
(0, (_log || _load_log()).log)("Skip app dependencies rebuild because platform is different");
} else {
yield (0, (_yarn || _load_yarn()).installOrRebuild)(options, _this3.appDir, _this3.electronVersion, (_metadata || _load_metadata()).Arch[arch]);
}
})();
}
}
exports.Packager = Packager;
function normalizePlatforms(rawPlatforms) {
const platforms = rawPlatforms == null || Array.isArray(rawPlatforms) ? rawPlatforms : [rawPlatforms];
if (platforms == null || platforms.length === 0) {
return [(_metadata || _load_metadata()).Platform.fromString(process.platform)];
} else if (platforms[0] === "all") {
if (process.platform === (_metadata || _load_metadata()).Platform.MAC.nodeName) {
return [(_metadata || _load_metadata()).Platform.MAC, (_metadata || _load_metadata()).Platform.LINUX, (_metadata || _load_metadata()).Platform.WINDOWS];
} else if (process.platform === (_metadata || _load_metadata()).Platform.LINUX.nodeName) {
// macOS code sign works only on macOS
return [(_metadata || _load_metadata()).Platform.LINUX, (_metadata || _load_metadata()).Platform.WINDOWS];
} else {
return [(_metadata || _load_metadata()).Platform.WINDOWS];
}
} else {
return platforms.map(it => it instanceof (_metadata || _load_metadata()).Platform ? it : (_metadata || _load_metadata()).Platform.fromString(it));
}
}
function checkConflictingOptions(options) {
for (let name of ["all", "out", "tmpdir", "version", "platform", "dir", "arch", "name", "extra-resource"]) {
if (name in options) {
throw new Error(`Option ${ name } is ignored, do not specify it.`);
}
}
}
function checkDependencies(dependencies) {
if (dependencies == null) {
return;
}
for (let name of ["electron", "electron-prebuilt", "electron-builder"]) {
if (name in dependencies) {
throw new Error(`${ name } must be in the devDependencies`);
}
}
}
//# sourceMappingURL=packager.js.map