269 lines
9.2 KiB
JavaScript
269 lines
9.2 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.configureBuildCommand = exports.build = exports.createTargets = exports.coerceTypes = exports.normalizeOptions = exports.createYargs = void 0;
|
|
const builder_util_1 = require("builder-util");
|
|
const chalk = require("chalk");
|
|
const app_builder_lib_1 = require("app-builder-lib");
|
|
const yargs = require("yargs");
|
|
function createYargs() {
|
|
return yargs.parserConfiguration({
|
|
"camel-case-expansion": false,
|
|
});
|
|
}
|
|
exports.createYargs = createYargs;
|
|
/** @private */
|
|
function normalizeOptions(args) {
|
|
if (args.targets != null) {
|
|
return args;
|
|
}
|
|
const targets = new Map();
|
|
function processTargets(platform, types) {
|
|
function commonArch(currentIfNotSpecified) {
|
|
const result = Array();
|
|
if (args.x64) {
|
|
result.push(builder_util_1.Arch.x64);
|
|
}
|
|
if (args.armv7l) {
|
|
result.push(builder_util_1.Arch.armv7l);
|
|
}
|
|
if (args.arm64) {
|
|
result.push(builder_util_1.Arch.arm64);
|
|
}
|
|
if (args.ia32) {
|
|
result.push(builder_util_1.Arch.ia32);
|
|
}
|
|
if (args.universal) {
|
|
result.push(builder_util_1.Arch.universal);
|
|
}
|
|
return result.length === 0 && currentIfNotSpecified ? [(0, builder_util_1.archFromString)(process.arch)] : result;
|
|
}
|
|
let archToType = targets.get(platform);
|
|
if (archToType == null) {
|
|
archToType = new Map();
|
|
targets.set(platform, archToType);
|
|
}
|
|
if (types.length === 0) {
|
|
const defaultTargetValue = args.dir ? [app_builder_lib_1.DIR_TARGET] : [];
|
|
for (const arch of commonArch(args.dir === true)) {
|
|
archToType.set(arch, defaultTargetValue);
|
|
}
|
|
return;
|
|
}
|
|
for (const type of types) {
|
|
const suffixPos = type.lastIndexOf(":");
|
|
if (suffixPos > 0) {
|
|
(0, builder_util_1.addValue)(archToType, (0, builder_util_1.archFromString)(type.substring(suffixPos + 1)), type.substring(0, suffixPos));
|
|
}
|
|
else {
|
|
for (const arch of commonArch(true)) {
|
|
(0, builder_util_1.addValue)(archToType, arch, type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (args.mac != null) {
|
|
processTargets(app_builder_lib_1.Platform.MAC, args.mac);
|
|
}
|
|
if (args.linux != null) {
|
|
processTargets(app_builder_lib_1.Platform.LINUX, args.linux);
|
|
}
|
|
if (args.win != null) {
|
|
processTargets(app_builder_lib_1.Platform.WINDOWS, args.win);
|
|
}
|
|
if (targets.size === 0) {
|
|
processTargets(app_builder_lib_1.Platform.current(), []);
|
|
}
|
|
const result = { ...args };
|
|
result.targets = targets;
|
|
delete result.dir;
|
|
delete result.mac;
|
|
delete result.linux;
|
|
delete result.win;
|
|
const r = result;
|
|
delete r.m;
|
|
delete r.o;
|
|
delete r.l;
|
|
delete r.w;
|
|
delete r.windows;
|
|
delete r.macos;
|
|
delete r.$0;
|
|
delete r._;
|
|
delete r.version;
|
|
delete r.help;
|
|
delete r.c;
|
|
delete r.p;
|
|
delete r.pd;
|
|
delete result.ia32;
|
|
delete result.x64;
|
|
delete result.armv7l;
|
|
delete result.arm64;
|
|
delete result.universal;
|
|
let config = result.config;
|
|
// config is array when combining dot-notation values with a config file value
|
|
// https://github.com/electron-userland/electron-builder/issues/2016
|
|
if (Array.isArray(config)) {
|
|
const newConfig = {};
|
|
for (const configItem of config) {
|
|
if (typeof configItem === "object") {
|
|
(0, builder_util_1.deepAssign)(newConfig, configItem);
|
|
}
|
|
else if (typeof configItem === "string") {
|
|
newConfig.extends = configItem;
|
|
}
|
|
}
|
|
config = newConfig;
|
|
result.config = newConfig;
|
|
}
|
|
// AJV cannot coerce "null" string to null if string is also allowed (because null string is a valid value)
|
|
if (config != null && typeof config !== "string") {
|
|
if (config.extraMetadata != null) {
|
|
coerceTypes(config.extraMetadata);
|
|
}
|
|
// ability to disable code sign using -c.mac.identity=null
|
|
if (config.mac != null) {
|
|
coerceValue(config.mac, "identity");
|
|
}
|
|
// fix Boolean type by coerceTypes
|
|
if (config.nsis != null) {
|
|
coerceTypes(config.nsis);
|
|
}
|
|
if (config.nsisWeb != null) {
|
|
coerceTypes(config.nsisWeb);
|
|
}
|
|
}
|
|
if ("project" in r && !("projectDir" in result)) {
|
|
result.projectDir = r.project;
|
|
}
|
|
delete r.project;
|
|
return result;
|
|
}
|
|
exports.normalizeOptions = normalizeOptions;
|
|
function coerceValue(host, key) {
|
|
const value = host[key];
|
|
if (value === "true") {
|
|
host[key] = true;
|
|
}
|
|
else if (value === "false") {
|
|
host[key] = false;
|
|
}
|
|
else if (value === "null") {
|
|
host[key] = null;
|
|
}
|
|
else if (key === "version" && typeof value === "number") {
|
|
host[key] = value.toString();
|
|
}
|
|
else if (value != null && typeof value === "object") {
|
|
coerceTypes(value);
|
|
}
|
|
}
|
|
/** @private */
|
|
function coerceTypes(host) {
|
|
for (const key of Object.getOwnPropertyNames(host)) {
|
|
coerceValue(host, key);
|
|
}
|
|
return host;
|
|
}
|
|
exports.coerceTypes = coerceTypes;
|
|
function createTargets(platforms, type, arch) {
|
|
const targets = new Map();
|
|
for (const platform of platforms) {
|
|
const archs = arch === "all" ? (platform === app_builder_lib_1.Platform.MAC ? [builder_util_1.Arch.x64, builder_util_1.Arch.arm64, builder_util_1.Arch.universal] : [builder_util_1.Arch.x64, builder_util_1.Arch.ia32]) : [(0, builder_util_1.archFromString)(arch == null ? process.arch : arch)];
|
|
const archToType = new Map();
|
|
targets.set(platform, archToType);
|
|
for (const arch of archs) {
|
|
archToType.set(arch, type == null ? [] : [type]);
|
|
}
|
|
}
|
|
return targets;
|
|
}
|
|
exports.createTargets = createTargets;
|
|
function build(rawOptions) {
|
|
const buildOptions = normalizeOptions(rawOptions || {});
|
|
return (0, app_builder_lib_1.build)(buildOptions, new app_builder_lib_1.Packager(buildOptions));
|
|
}
|
|
exports.build = build;
|
|
/**
|
|
* @private
|
|
*/
|
|
function configureBuildCommand(yargs) {
|
|
const publishGroup = "Publishing:";
|
|
const buildGroup = "Building:";
|
|
return yargs
|
|
.option("mac", {
|
|
group: buildGroup,
|
|
alias: ["m", "o", "macos"],
|
|
description: `Build for macOS, accepts target list (see ${chalk.underline("https://goo.gl/5uHuzj")}).`,
|
|
type: "array",
|
|
})
|
|
.option("linux", {
|
|
group: buildGroup,
|
|
alias: "l",
|
|
description: `Build for Linux, accepts target list (see ${chalk.underline("https://goo.gl/4vwQad")})`,
|
|
type: "array",
|
|
})
|
|
.option("win", {
|
|
group: buildGroup,
|
|
alias: ["w", "windows"],
|
|
description: `Build for Windows, accepts target list (see ${chalk.underline("https://goo.gl/jYsTEJ")})`,
|
|
type: "array",
|
|
})
|
|
.option("x64", {
|
|
group: buildGroup,
|
|
description: "Build for x64",
|
|
type: "boolean",
|
|
})
|
|
.option("ia32", {
|
|
group: buildGroup,
|
|
description: "Build for ia32",
|
|
type: "boolean",
|
|
})
|
|
.option("armv7l", {
|
|
group: buildGroup,
|
|
description: "Build for armv7l",
|
|
type: "boolean",
|
|
})
|
|
.option("arm64", {
|
|
group: buildGroup,
|
|
description: "Build for arm64",
|
|
type: "boolean",
|
|
})
|
|
.option("universal", {
|
|
group: buildGroup,
|
|
description: "Build for universal",
|
|
type: "boolean",
|
|
})
|
|
.option("dir", {
|
|
group: buildGroup,
|
|
description: "Build unpacked dir. Useful to test.",
|
|
type: "boolean",
|
|
})
|
|
.option("publish", {
|
|
group: publishGroup,
|
|
alias: "p",
|
|
description: `Publish artifacts, see ${chalk.underline("https://goo.gl/tSFycD")}`,
|
|
choices: ["onTag", "onTagOrDraft", "always", "never", undefined],
|
|
})
|
|
.option("prepackaged", {
|
|
alias: ["pd"],
|
|
group: buildGroup,
|
|
description: "The path to prepackaged app (to pack in a distributable format)",
|
|
})
|
|
.option("projectDir", {
|
|
alias: ["project"],
|
|
group: buildGroup,
|
|
description: "The path to project directory. Defaults to current working directory.",
|
|
})
|
|
.option("config", {
|
|
alias: ["c"],
|
|
group: buildGroup,
|
|
description: "The path to an electron-builder config. Defaults to `electron-builder.yml` (or `json`, or `json5`, or `js`, or `ts`), see " + chalk.underline("https://goo.gl/YFRJOM"),
|
|
})
|
|
.group(["help", "version"], "Other:")
|
|
.example("electron-builder -mwl", "build for macOS, Windows and Linux")
|
|
.example("electron-builder --linux deb tar.xz", "build deb and tar.xz for Linux")
|
|
.example("electron-builder --win --ia32", "build for Windows ia32")
|
|
.example("electron-builder -c.extraMetadata.foo=bar", "set package.json property `foo` to `bar`")
|
|
.example("electron-builder --config.nsis.unicode=false", "configure unicode options for NSIS");
|
|
}
|
|
exports.configureBuildCommand = configureBuildCommand;
|
|
//# sourceMappingURL=builder.js.map
|