workflow_launcher/node_modules/electron-builder/out/builder.js
2024-03-12 12:57:14 +01:00

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