* [Build version management](https://github.com/electron-userland/electron-builder/wiki/Options#build-version-management).

* Numerous target formats:

* All platforms: `7z`, `zip`, `tar.xz`, `tar.lz`, `tar.gz`, `tar.bz2`, `dir` (unpacked directory).

* [Linux](https://github.com/electron-userland/electron-builder/wiki/Options#LinuxBuildOptions-target): `AppImage`, `deb`, `rpm`, `freebsd`, `pacman`, `p5p`, `apk`.

* [Windows](https://github.com/electron-userland/electron-builder/wiki/Options#WinBuildOptions-target): NSIS, Squirrel.Windows.

* [Publishing artifacts](https://github.com/electron-userland/electron-builder/wiki/Publishing-Artifacts) to GitHub Releases and Bintray.

macOS and Windows code signing is supported. Windows is dual code-signed (SHA1 & SHA256 hashing algorithms).

On a macOS development machine valid and appropriate identity from your keychain will be automatically used.

| Env Name | Description

| -------------- | -----------

| `CSC_LINK` | The HTTPS link (or base64-encoded data, or `file://` link) to certificate (`*.p12` or `*.pfx` file).

| `CSC_KEY_PASSWORD` | The password to decrypt the certificate given in `CSC_LINK`.

| `CSC_NAME` | *macOS-only* Name of certificate (to retrieve from login.keychain). Useful on a development machine (not on CI) if you have several identities (otherwise don't specify it).

If you are building Windows on macOS and need to set a different certificate and password (than the ones set in `CSC_*` env vars) you can use `WIN_CSC_LINK` and `WIN_CSC_KEY_PASSWORD`.

3. Select all required certificates (hint: use cmd-click to select several):

* `Developer ID Application:` to sign app for macOS.

* `3rd Party Mac Developer Application:` and `3rd Party Mac Developer Installer:` to sign app for MAS (Mac App Store).

Please note – you can select as many certificates, as need. No restrictions on electron-builder side.

All selected certificates will be imported into temporary keychain on CI server.

| Name | Description

| --- | ---

| category | <a name="MacOptions-category"></a><p>The application category type, as shown in the Finder via *View -&gt; Arrange by Application Category* when viewing the Applications directory.</p> <p>For example, <code>&quot;category&quot;: &quot;public.app-category.developer-tools&quot;</code> will set the application category to *Developer Tools*.</p> <p>Valid values are listed in [Apple’s documentation](https://developer.apple.com/library/ios/documentation/General/Reference/InfoPlistKeyReference/Articles/LaunchServicesKeys.html#//apple_ref/doc/uid/TP40009250-SW8).</p>

| identity | <a name="MacOptions-identity"></a><p>The name of certificate to use when signing. Consider using environment variables [CSC_LINK or CSC_NAME](https://github.com/electron-userland/electron-builder/wiki/Code-Signing). MAS installer identity is specified in the [.build.mas](#MasBuildOptions-identity).</p>

| icon | <a name="MacOptions-icon"></a>The path to application icon. Defaults to `build/icon.icns` (consider using this convention instead of complicating your configuration).

| entitlements | <a name="MacOptions-entitlements"></a><p>The path to entitlements file for signing the app. <code>build/entitlements.mac.plist</code> will be used if exists (it is a recommended way to set). MAS entitlements is specified in the [.build.mas](#MasBuildOptions-entitlements).</p>

import { randomBytes } from "crypto"

import { TmpDir } from "./util/tmp"

export interface CodeSigningInfo {

keychainName?: string | null

import { Platform, Arch } from "./metadata"

import { MasBuildOptions, MacOptions } from "./options/macOptions"

import * as path from "path"

import BluebirdPromise from "bluebird-lst-c"

import { log, warn, task } from "./util/log"

import { createKeychain, CodeSigningInfo, findIdentity } from "./codeSign"

import { deepAssign } from "./util/deepAssign"

import { DmgTarget } from "./targets/dmg"

import { AppInfo } from "./appInfo"

export default class MacPackager extends PlatformPackager<MacOptions> {

constructor(info: BuildInfo) {

super(info)

createTargets(targets: Array<string>, mapper: (name: string, factory: () => Target) => void, cleanupTasks: Array<() => Promise<any>>): void {

for (let name of targets) {

}

}

}

const appOutDir = this.computeAppOutDir(outDir, arch)

nonMasPromise = this.doPack(outDir, appOutDir, this.platform.nodeName, arch, this.platformSpecificBuildOptions)

.then(() => this.sign(appOutDir, null))

}

if (hasMas) {

const appOutDir = path.join(outDir, "mas")

const masBuildOptions = deepAssign({}, this.platformSpecificBuildOptions, (<any>this.devMetadata.build).mas)

await this.doPack(outDir, appOutDir, "mas", arch, masBuildOptions)

await this.sign(appOutDir, masBuildOptions)

}

private async sign(appOutDir: string, masOptions: MasBuildOptions | null): Promise<void> {

if (process.platform !== "darwin") {

return

}

const isMas = masOptions != null

const masQualifier = isMas ? (masOptions!!.identity || this.platformSpecificBuildOptions.identity) : null

}

}

identity: name,

platform: isMas ? "mas" : "darwin",

version: this.info.electronVersion,

const resourceList = await this.resourceList

if (resourceList.includes(`entitlements.osx.plist`)) {

if (masOptions != null) {

const pkg = path.join(appOutDir, `${this.appInfo.productFilename}-${this.appInfo.version}.pkg`)

this.dispatchArtifactCreated(pkg, `${this.appInfo.name}-${this.appInfo.version}.pkg`)

}

}

//noinspection JSMethodCanBeStatic

protected async doSign(opts: SignOptions): Promise<any> {

return signAsync(opts)

}

//noinspection JSMethodCanBeStatic

}

protected packageInDistributableFormat(appOutDir: string, targets: Array<Target>, promises: Array<Promise<any>>): void {

for (let t of targets) {

const target = t.name

}

else if (target !== "mas") {

// we use app name here - see https://github.com/electron-userland/electron-builder/pull/204

const outFile = path.join(appOutDir, this.generateName2(target, "mac", false))

promises.push(this.archiveApp(target, appOutDir, outFile)

import { PlatformSpecificBuildOptions } from "../metadata"

readonly category?: string | null

/*

/*

throw new Error(util.format(errorMessages.buildIsMissed, devAppPackageFile))

}

else {

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.`)

helperNPPlist.CFBundleName = `${appInfo.productName} Helper NP`

helperNPPlist.CFBundleExecutable = `${appFilename} Helper NP`

const protocols = asArray(buildMetadata.protocols).concat(asArray(packager.platformSpecificBuildOptions.protocols))

if (protocols.length > 0) {

export class Target {

}

finishBuild(): Promise<any> {

readonly appInfo: AppInfo

this.devMetadata = info.devMetadata

this.platformSpecificBuildOptions = this.normalizePlatformSpecificBuildOptions((<any>info.devMetadata.build)[this.platform.buildConfigurationKey])

this.appInfo = this.prepareAppInfo(info.appInfo)

import { deepAssign } from "../util/deepAssign"

import * as path from "path"

import { log, warn } from "../util/log"

import { MacOptions, DmgOptions, DmgContent } from "../options/macOptions"

import BluebirdPromise from "bluebird-lst-c"

import { debug, use, exec, statOrNull, isEmptyOrSpaces, spawn } from "../util/util"

import { copy, unlink, outputFile, remove } from "fs-extra-p"

import { executeFinally } from "../util/promise"

import sanitizeFileName from "sanitize-filename"

private helperDir = path.join(__dirname, "..", "..", "templates", "dmg")

constructor(private packager: PlatformPackager<MacOptions>) {

super("dmg")

}

const packager = this.packager

const appInfo = packager.appInfo

const specification = await this.computeDmgOptions()