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
286 lines (250 loc) • 12.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _bluebirdLstC;
function _load_bluebirdLstC() {
return _bluebirdLstC = require("bluebird-lst-c");
}
var _bluebirdLstC2;
function _load_bluebirdLstC2() {
return _bluebirdLstC2 = _interopRequireDefault(require("bluebird-lst-c"));
}
var _platformPackager;
function _load_platformPackager() {
return _platformPackager = require("./platformPackager");
}
var _metadata;
function _load_metadata() {
return _metadata = require("./metadata");
}
var _path;
function _load_path() {
return _path = _interopRequireWildcard(require("path"));
}
var _log;
function _load_log() {
return _log = require("./util/log");
}
var _codeSign;
function _load_codeSign() {
return _codeSign = require("./codeSign");
}
var _deepAssign;
function _load_deepAssign() {
return _deepAssign = require("./util/deepAssign");
}
var _electronMacosSign;
function _load_electronMacosSign() {
return _electronMacosSign = require("electron-macos-sign");
}
var _dmg;
function _load_dmg() {
return _dmg = require("./targets/dmg");
}
var _targetFactory;
function _load_targetFactory() {
return _targetFactory = require("./targets/targetFactory");
}
var _appInfo;
function _load_appInfo() {
return _appInfo = require("./appInfo");
}
var _pkg;
function _load_pkg() {
return _pkg = require("./targets/pkg");
}
var _util;
function _load_util() {
return _util = require("./util/util");
}
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 }; }
class MacPackager extends (_platformPackager || _load_platformPackager()).PlatformPackager {
constructor(info) {
super(info);
if (this.options.cscLink == null || process.platform !== "darwin") {
this.codeSigningInfo = (_bluebirdLstC2 || _load_bluebirdLstC2()).default.resolve({});
} else {
this.codeSigningInfo = (0, (_codeSign || _load_codeSign()).createKeychain)(info.tempDirManager, this.options.cscLink, this.getCscPassword(), this.options.cscInstallerLink, this.options.cscInstallerKeyPassword);
}
}
prepareAppInfo(appInfo) {
return new (_appInfo || _load_appInfo()).AppInfo(appInfo.metadata, this.devMetadata, this.platformSpecificBuildOptions.bundleVersion);
}
getIconPath() {
var _this = this;
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
let iconPath = _this.platformSpecificBuildOptions.icon || _this.devMetadata.build.icon;
if (iconPath != null && !iconPath.endsWith(".icns")) {
iconPath += ".icns";
}
return iconPath == null ? yield _this.getDefaultIcon("icns") : (_path || _load_path()).resolve(_this.projectDir, iconPath);
})();
}
createTargets(targets, mapper, cleanupTasks) {
for (let name of targets) {
switch (name) {
case (_targetFactory || _load_targetFactory()).DIR_TARGET:
break;
case (_targetFactory || _load_targetFactory()).DEFAULT_TARGET:
mapper("dmg", () => new (_dmg || _load_dmg()).DmgTarget(this));
mapper("zip", () => new (_platformPackager || _load_platformPackager()).Target("zip"));
break;
case "dmg":
mapper("dmg", () => new (_dmg || _load_dmg()).DmgTarget(this));
break;
case "pkg":
mapper("pkg", () => new (_pkg || _load_pkg()).PkgTarget(this));
break;
default:
mapper(name, () => name === "mas" ? new (_platformPackager || _load_platformPackager()).Target(name) : (0, (_targetFactory || _load_targetFactory()).createCommonTarget)(name));
break;
}
}
}
get platform() {
return (_metadata || _load_metadata()).Platform.MAC;
}
pack(outDir, arch, targets, postAsyncTasks) {
var _this2 = this;
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
let nonMasPromise = null;
const hasMas = targets.length !== 0 && targets.some(function (it) {
return it.name === "mas";
});
if (!hasMas || targets.length > 1) {
const appOutDir = _this2.computeAppOutDir(outDir, arch);
nonMasPromise = _this2.doPack(outDir, appOutDir, _this2.platform.nodeName, arch, _this2.platformSpecificBuildOptions).then(function () {
return _this2.sign(appOutDir, null);
}).then(function () {
return _this2.packageInDistributableFormat(appOutDir, targets, postAsyncTasks);
});
}
if (hasMas) {
const appOutDir = (_path || _load_path()).join(outDir, "mas");
const masBuildOptions = (0, (_deepAssign || _load_deepAssign()).deepAssign)({}, _this2.platformSpecificBuildOptions, _this2.devMetadata.build.mas);
yield _this2.doPack(outDir, appOutDir, "mas", arch, masBuildOptions);
yield _this2.sign(appOutDir, masBuildOptions);
}
if (nonMasPromise != null) {
yield nonMasPromise;
}
})();
}
sign(appOutDir, masOptions) {
var _this3 = this;
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
if (process.platform !== "darwin") {
(0, (_log || _load_log()).warn)("macOS application code signing is supported only on macOS, skipping.");
return;
}
const keychainName = (yield _this3.codeSigningInfo).keychainName;
const isMas = masOptions != null;
const masQualifier = isMas ? masOptions.identity || _this3.platformSpecificBuildOptions.identity : null;
let name = yield (0, (_codeSign || _load_codeSign()).findIdentity)(isMas ? "3rd Party Mac Developer Application" : "Developer ID Application", isMas ? masQualifier : _this3.platformSpecificBuildOptions.identity, keychainName);
if (name == null) {
if (!isMas) {
name = yield (0, (_codeSign || _load_codeSign()).findIdentity)("Mac Developer", _this3.platformSpecificBuildOptions.identity, keychainName);
if (name != null) {
(0, (_log || _load_log()).warn)("Mac Developer is used to sign app — it is only for development and testing, not for production");
}
}
if (name == null) {
let message = `App is not signed: cannot find valid ${ isMas ? '"3rd Party Mac Developer Application" identity' : `"Developer ID Application" identity or custom non-Apple code signing certificate` }, see https://github.com/electron-userland/electron-builder/wiki/Code-Signing`;
if (isMas) {
throw new Error(message);
} else {
(0, (_log || _load_log()).warn)(message);
return;
}
}
}
const appPath = (_path || _load_path()).join(appOutDir, `${ _this3.appInfo.productFilename }.app`);
const signOptions = {
identity: name,
platform: isMas ? "mas" : "darwin",
version: _this3.info.electronVersion,
app: appPath,
keychain: keychainName || undefined,
"gatekeeper-assess": (_codeSign || _load_codeSign()).appleCertificatePrefixes.find(function (it) {
return name.startsWith(it);
}) != null
};
const resourceList = yield _this3.resourceList;
if (resourceList.indexOf(`entitlements.osx.plist`) !== -1) {
throw new Error("entitlements.osx.plist is deprecated name, please use entitlements.mac.plist");
}
if (resourceList.indexOf(`entitlements.osx.inherit.plist`) !== -1) {
throw new Error("entitlements.osx.inherit.plist is deprecated name, please use entitlements.mac.inherit.plist");
}
const customSignOptions = masOptions || _this3.platformSpecificBuildOptions;
if (customSignOptions.entitlements == null) {
const p = `entitlements.${ isMas ? "mas" : "mac" }.plist`;
if (resourceList.indexOf(p) !== -1) {
signOptions.entitlements = (_path || _load_path()).join(_this3.buildResourcesDir, p);
}
} else {
signOptions.entitlements = customSignOptions.entitlements;
}
if (customSignOptions.entitlementsInherit == null) {
const p = `entitlements.${ isMas ? "mas" : "mac" }.inherit.plist`;
if (resourceList.indexOf(p) !== -1) {
signOptions["entitlements-inherit"] = (_path || _load_path()).join(_this3.buildResourcesDir, p);
}
} else {
signOptions["entitlements-inherit"] = customSignOptions.entitlementsInherit;
}
yield (0, (_log || _load_log()).task)(`Signing app (identity: ${ name })`, _this3.doSign(signOptions));
if (masOptions != null) {
const pkg = (_path || _load_path()).join(appOutDir, `${ _this3.appInfo.productFilename }-${ _this3.appInfo.version }.pkg`);
yield _this3.doFlat(appPath, pkg, (yield _this3.findInstallerIdentity(true, keychainName)), keychainName);
_this3.dispatchArtifactCreated(pkg, `${ _this3.appInfo.name }-${ _this3.appInfo.version }.pkg`);
}
})();
}
findInstallerIdentity(isMas, keychainName) {
var _this4 = this;
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
const targetSpecificOptions = _this4.devMetadata.build[isMas ? "mas" : "pkg"] || _this4.platformSpecificBuildOptions;
const name = isMas ? "3rd Party Mac Developer Installer" : "Developer ID Installer";
let installerName = yield (0, (_codeSign || _load_codeSign()).findIdentity)(name, targetSpecificOptions.identity, keychainName);
if (installerName != null) {
return installerName;
}
if (isMas) {
throw new Error(`Cannot find valid "${ name }" identity to sign MAS installer, see https://github.com/electron-userland/electron-builder/wiki/Code-Signing`);
} else {
throw new Error(`Cannot find valid "${ name }" to sign standalone installer, see https://github.com/electron-userland/electron-builder/wiki/Code-Signing`);
}
})();
}
//noinspection JSMethodCanBeStatic
doSign(opts) {
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
return (0, (_electronMacosSign || _load_electronMacosSign()).signAsync)(opts);
})();
}
//noinspection JSMethodCanBeStatic
doFlat(appPath, outFile, identity, keychain) {
return (0, (_bluebirdLstC || _load_bluebirdLstC()).coroutine)(function* () {
const args = (0, (_pkg || _load_pkg()).prepareProductBuildArgs)(appPath, identity, keychain);
args.push(outFile);
return (0, (_util || _load_util()).exec)("productbuild", args);
})();
}
packageInDistributableFormat(appOutDir, targets, promises) {
for (let t of targets) {
const target = t.name;
if (t instanceof (_platformPackager || _load_platformPackager()).TargetEx) {
promises.push(t.build(appOutDir, (_metadata || _load_metadata()).Arch.x64));
} else if (target !== "mas") {
(0, (_log || _load_log()).log)(`Building macOS ${ target }`);
// we use app name here - see https://github.com/electron-userland/electron-builder/pull/204
const outFile = (_path || _load_path()).join(appOutDir, this.generateName2(target, "mac", false));
promises.push(this.archiveApp(target, appOutDir, outFile).then(() => this.dispatchArtifactCreated(outFile, this.generateName2(target, "mac", true))));
}
}
}
}
exports.default = MacPackager; //# sourceMappingURL=macPackager.js.map