Criar um executável

Para esta demonstração, vamos usar pkg ferramenta de linha de comandos. Você é livre para escolher nexe ou outra de sua escolha, mas eu acho pkg mais fácil de usar. Primeiro de tudo, precisamos de instalar pkg globalmente usando o comando npm. Você também pode instalá-lo localmente para usar a interface CLI programmaticamente.

$ npm install --global pkg

Após o pacote ser instalado globalmente, você recebe o comando pkg para criar executáveis. O comando pkg necessita de um ficheiro de entrada que é um programa JavaScript de entrada que será executado quando o utilizador fizer duplo clique sobre o ficheiro executável gerado. Outras opções de linha de comando controlam como o ficheiro executável é gerado.

Entry File

O caminho do ficheiro de entrada é fornecido através de <input> argumento tal como o comando $ pkg server.js no nosso caso que é um caminho de ficheiro local. Mas também podemos fornecer o caminho para package.json e o comando pkg usará a propriedade bin do arquivo package.json para localizar o caminho do arquivo JavaScript de entrada. Se um caminho de directório for fornecido, então o comando pkg procura o ficheiro package.json desse directório utiliza a sua propriedade bin.

Assets

Assets são recursos estáticos como .html, .js, .css, .png, .json ficheiros que devem ser incluídos no executável. Para instruir pkg a incluir tais arquivos no executável, precisamos fornecer estes caminhos de arquivos através de pkg.assets propriedade do arquivo package.json. Seu valor é um padrão glob ou um array de padrões glob.

💡 Neste caso, o package.json deve ser o caminho de entrada para que pkg possa escolher assets que são necessários para serem incluídos no executável.

Quando um executável é criado, pkg incluirá o arquivo JavaScript de entrada junto com os ativos estáticos em um único arquivo executável. Aqui é onde as coisas ficam um pouco complicadas. Como todos os arquivos de projeto agora estão empacotados em um único arquivo, os caminhos relativos dos arquivos perdem seu significado, assim como a estrutura de pastas.

Mas em tempo de execução (quando o executável está rodando), estes arquivos são organizados em um sistema de arquivos virtual chamado sistema de arquivos snapshot. Normalmente, estes arquivos em tempo de execução têm prefixo /snapshot/ (ou C:\snapshot\ no windows) em seu caminho como se estivessem localizados dentro do diretório /snapshot do sistema.

Mas você pode localizar com segurança um arquivo de ativos no executável (em tempo de execução) usando o método path.join e __dirname variável para construir um caminho relativo como path.join( __dirname, './www/main.js' ). O caminho funcionará muito bem como se você tivesse um caminho de diretório real em um sistema de arquivos real. Para saber mais sobre o sistema de arquivos snapshot, leia esta documentação.

💡 Cuidado. Durante o processo de compilação, pkg olha para as instruções require() no código e inclui automaticamente estes ficheiros como activos estáticos. Portanto, talvez você não precise especificar tais arquivos como ativos estáticos no arquivo package.json. No entanto, existem algumas advertências como explicado aqui.

Targets

Podemos gerar um arquivo executável para um sistema específico usando o sinalizador de linha de comando --targets. O valor desta flag é uma string no formato <node>-<platform>-<arch>. Também pode ser uma lista separada por vírgulas deste padrão para direcionar múltiplas arquiteturas de sistema. Você também poderia usar o campo pkg.targets do package.json para especificar estes valores.

O valor node é uma versão principal do Nó de destino. O valor platform é o nome do sistema operacional de destino e poderia ser um destes freebsd, linux, alpine, macos, win. O arch é a arquitetura do processador de destino e poderia ser um destes x64, x86, armv6, armv7.

Podíamos omitir um destes valores da especificação do destino. Nesse caso, pkg usa o seu valor da configuração atual do sistema. Podemos usar 'host' como o valor para o --targets, neste caso todos estes valores são obtidos a partir da configuração atual do sistema.

Saída

Tentaremos criar arquivos executáveis para os sistemas operacionais MacOS e Windows, especialmente para a arquitetura do processador x64. Como nosso ponto de entrada é server.js, usaremos a propriedade bin do package.json para indicar o caminho do arquivo. Também mencionaremos todo o caminho do arquivo dentro de node_modules e src como ativos estáticos, já que nosso server.js depende dele. Considerando todos esses requisitos, nosso package.json se parece abaixo.

Para gerar os arquivos executáveis binários, precisamos executar o comando pkg . já que queremos pkg usar o arquivo package.json do diretório atual para localizar o arquivo de entrada, ativos e alvos. Também podemos usar o comando pkg package.json que também faz a mesma coisa.

Após este comando ser executado, pkg descarrega os binários apropriados do Node.js baseados nos valores targets e guarda-os em cache num directório especificado pela variável de ambiente PKG_CACHE_PATH para que na próxima vez que os mesmos alvos forem encontrados, pkg possa usar os ficheiros binários em cache.

Após todos os ficheiros binários serem descarregados, pkg gera os ficheiros executáveis no directório actual. O nome e extensão destes ficheiros é decidido por pkg e normalmente parece-se com <package>-<target>.<ext> onde package é o valor name no valor package.json.

No entanto, podemos controlar o esquema de nomes e o directório de saída usando os valores das opções --output ou --out-path. Vamos usar a bandeira --output para especificar o diretório de saída e o nome do arquivo executável.

$ pkg --output build/web .

O comando acima gera os seguintes arquivos dentro do diretório build.

node-js-executable
└── build
├── web-node10-win.exe (37.4mb)
└── web-node12-macos (43.4mb)

Agora pode fazer duplo clique em qualquer um destes ficheiros (conforme a sua máquina) e irá abrir uma página web no browser padrão do sistema mostrando os drivers de fórmula um.