The top-level dmg key contains set of options instructing electron-builder on how it should build DMG.
What is the difference between the 2 electron-builder targets for Mac OS X: mac vs mas? I understand that mas is for distribution in the Mac App Store, and mac is for distribution outside of it. I configured the build script as 'pack': 'electron-builder -dir -mwl', in script. The issue is, when i run the command npm run pack, it packages the application for all the platform, but for windows there is no single installer file either.exe or '.msi'. Electron-builder builds bunch of files for windows.
background
String - The path to background image (default:build/background.tiff
orbuild/background.png
if exists). The resolution of this file determines the resolution of the installer window. If background is not specified, usewindow.size
. Default locations expected background size to be 540x380. See: DMG with Retina background support.backgroundColor
String - The background color (accepts css colors). Defaults to#ffffff
(white) if no background image.icon
String - The path to DMG icon (volume icon), which will be shown when mounted, relative to the build resources or to the project directory. Defaults to the application icon (build/icon.icns
).iconSize
=80
Number - The size of all the icons inside the DMG.iconTextSize
=12
Number - The size of all the icon texts inside the DMG.title
=${productName} ${version}
String - The title of the produced DMG, which will be shown when mounted (volume name).Macro
${productName}
,${version}
and${name}
are supported.contents
Array - The content — to customize icon locations. The x and y coordinates refer to the position of the center of the icon (at 1x scale), and do not take the label into account.x
Number - The device-independent pixel offset from the left of the window to the center of the icon.y
Number - The device-independent pixel offset from the top of the window to the center of the icon.type
'link' | 'file' | 'dir'name
String - The name of the file within the DMG. Defaults to basename ofpath
.path
String - The path of the file within the DMG.
format
=UDZO
'UDRW' | 'UDRO' | 'UDCO' | 'UDZO' | 'UDBZ' | 'ULFO' - The disk image format.ULFO
(lzfse-compressed image (OS X 10.11+ only)).window
- The DMG windows position and size.x
=400
Number - The X position relative to left of the screen.y
=100
Number - The Y position relative to top of the screen.width
Number - The width. Defaults to background image width or 540.height
Number - The height. Defaults to background image height or 380.
internetEnabled
=false
Boolean - Whether to create internet-enabled disk image (when it is downloaded using a browser it will automatically decompress the image, put the application on the desktop, unmount and remove the disk image file).sign
=false
Boolean - Whether to sign the DMG or not. Signing is not required and will lead to unwanted errors in combination with notarization requirements.
Inherited from TargetSpecificOptions
:
artifactName
String - The artifact file name template.publish
The publish options.
DMG License¶
To add license to DMG, create file license_LANG_CODE.txt
in the build resources. Multiple license files in different languages are supported — use lang postfix (e.g. _de
, _ru
)). For example, create files license_de.txt
and license_en.txt
in the build resources.If OS language is german, license_de.txt
will be displayed. See map of language code to name.
You can also change the default button labels of the DMG by passing a json file named licenseButtons_LANG_CODE.json
. The german file would be named: licenseButtons_de.json
.The contain file should have the following format:
Package your Electron app into OS-specific bundles (.app
, .exe
, etc.) via JavaScript or the command line.
Electron-builder Mac Target Zip Dmg Software
Supported Platforms | Installation | Usage | API | Contributing | Support | Related Apps/Libraries | FAQ | Release Notes
About
Electron Packager is a command line tool and Node.js library that bundles Electron-based application source code with a renamed Electron executable and supporting files into folders ready for distribution.
Electron-builder Mac Target Zip Dmg File
For creating distributables like installers and Linux packages, consider using either Electron Forge (which uses Electron Packager internally), or one of the related Electron tools, which utilizes Electron Packager-created folders as a basis.
Note that packaged Electron applications can be relatively large. A zipped, minimal Electron application is approximately the same size as the zipped prebuilt binary for a given target platform, target arch, and Electron version(files named electron-v${version}-${platform}-${arch}.zip
).
Supported Platforms
Electron-builder Mac Target Zip Dmg
Electron Packager is known to run on the following host platforms:
- Windows (32/64 bit)
- macOS (formerly known as OS X)
- Linux (x86/x86_64)
It generates executables/bundles for the following target platforms:
- Windows (also known as
win32
, for x86, x86_64, and arm64 architectures) - macOS (also known as
darwin
) / Mac App Store (also known asmas
)* (for x86_64 and arm64 architectures) - Linux (for x86, x86_64, armv7l, arm64, and mips64el architectures)
*Note for macOS / Mac App Store target bundles: the .app
bundle can only be signed when building on a host macOS platform.
Installation
This module requires Node.js 10.0 or higher to run.
Building Windows apps from non-Windows platforms
Building an Electron app for the Windows target platform requires editing the Electron.exe
file. Currently, Electron Packager uses node-rcedit to accomplish this. A Windows executable is bundled in that Node package and needs to be run in order for this functionality to work, so on non-Windows host platforms, Wine 1.6 or later needs to be installed. On macOS, it is installable via Homebrew.
Usage
JavaScript API usage can be found in the API documentation.
From the Command Line
Running electron-packager from the command line has this basic form:
This will:
- Find or download the correct release of Electron
- Use that version of Electron to create a app in
/--
(this can be customized via an optional flag)
--platform
and --arch
can be omitted, in two cases:
- If you specify
--all
instead, bundles for all valid combinations of target platforms/architectures will be created. - Otherwise, a single bundle for the host platform/architecture will be created.
For an overview of the other optional flags, run electron-packager --help
or see usage.txt. For detailed descriptions, see the API documentation.
If appname
is omitted, this will use the name specified by 'productName' or 'name' in the nearest package.json.
Characters in the Electron app name which are not allowed in all target platforms' filenames (e.g., /
), will be replaced by hyphens (-
).
You should be able to launch the app on the platform you built for. If not, check your settings and try again.
Be careful not to include node_modules
you don't want into your final app. If you put them in the devDependencies
section of package.json
, by default none of the modules related to those dependencies will be copied in the app bundles. (This behavior can be turned off with the prune: false
API option or --no-prune
CLI flag.) In addition, folders like .git
and node_modules/.bin
will be ignored by default. You can use --ignore
to ignore files and folders via a regular expression (not a glob pattern). Examples include --ignore=.gitignore
or --ignore='.git(ignore|modules)'
.
Example
Let's assume that you have made an app based on the electron-quick-start repository on a macOS host platform with the following file structure:
…and that the following is true:
electron-packager
is installed globallyproductName
inpackage.json
has been set toFoo Bar
- The
electron
module is in thedevDependencies
section ofpackage.json
, and set to the exact version of1.4.15
. npm install
for theFoo Bar
app has been run at least once
When one runs the following command for the first time in the foobar
directory:
electron-packager
will do the following:
- Use the current directory for the
sourcedir
- Infer the
appname
from theproductName
inpackage.json
- Infer the
appVersion
from theversion
inpackage.json
- Infer the
platform
andarch
from the host, in this example,darwin
platform andx64
arch. - Download the darwin x64 build of Electron 1.4.15 (and cache the downloads in
~/.electron
) - Build the macOS
Foo Bar.app
- Place
Foo Bar.app
infoobar/Foo Bar-darwin-x64/
(since anout
directory was not specified, it used the current working directory)
The file structure now looks like:
The Foo Bar.app
folder generated can be executed by a system running macOS, which will start the packaged Electron app. This is also true of the Windows x64 build on a system running a new enough version of Windows for a 64-bit system (via Foo Bar-win32-x64/Foo Bar.exe
), and so on.
Related
- Electron Forge - creates, builds, and distributes modern Electron applications
- electron-packager-interactive - an interactive CLI for electron-packager
- grunt-electron - grunt plugin for electron-packager
Distributable Creators
- electron-installer-zip - creates symlink-compatible ZIP files
Windows:
- electron-winstaller - Squirrel.Windows-based installer from the Electron maintainers group
- electron-windows-store - creates an AppX package for the Windows Store
- electron-wix-msi - creates traditional MSI installers
- electron-installer-windows - alternative Squirrel.Windows-based installer
macOS:
- electron-installer-dmg - creates a DMG
Linux:
- electron-installer-debian - creates a DEB file
- electron-installer-redhat - creates an RPM
- electron-installer-flatpak - creates a Flatpak file
- electron-installer-snap - creates a Snap file
Plugins
These Node modules utilize Electron Packager API hooks:
Electron-builder Mac Target Zip Dmg File
- electron-packager-languages - set the locales available to Electron when packaged, which is used by the Mac App Store, among other places
- electron-packager-plugin-non-proprietary-codecs-ffmpeg - replaces the normal version of FFmpeg in Electron with a version without proprietary codecs
- electron-rebuild - rebuild native Node.js modules against the packaged Electron version