Converter JS para JAR

Um dispositivo ou programa baseado em Java pode exigir um pacote .jar, enquanto o código-fonte disponível é um arquivo JavaScript .js. A solução correta depende de você precisar apenas arquivar o script ou precisar reescrevê-lo e executá-lo por meio de um JavaScript engine compatível com Java.

O que é o formato JS

Um arquivo .js normalmente contém código-fonte JavaScript usado por web browsers, Node.js, Electron, aplicações Adobe, sistemas de build ou Windows Script Host. JavaScript é executado em um engine como V8, SpiderMonkey, JavaScriptCore ou GraalJS.

JavaScript e Java são linguagens diferentes. Alterar .js para .jar, renomear o arquivo ou colocá-lo em um ZIP não o compila em arquivos de classe Java. Scripts de browser também podem depender de APIs como document e window, enquanto scripts Node.js podem depender de require, pacotes npm ou APIs específicas do Node.

O que é o formato JAR

Um JAR, ou Java ARchive, é um pacote baseado em ZIP para arquivos de classe Java, bibliotecas, recursos e metadados. Aplicações e bibliotecas Java usam JARs porque eles agrupam vários arquivos em um único pacote distribuível, oferecem compressão e podem incluir um manifest em META-INF/MANIFEST.MF. JARs também podem ser assinados para garantir a integridade e verificar o publicador.

Um JAR pode conter JavaScript como um recurso comum, mas um JAR que contém apenas scripts não é automaticamente executável. Um JAR executável precisa de uma classe de entrada Java compilada e de uma entrada de manifest como Main-Class; essa classe deve então iniciar ou interpretar o JavaScript.

Empacotar o arquivo JS em um JAR

Use o utilitário jar incluído em um JDK quando o requisito for simplesmente um arquivo JAR contendo o script original.

1. Instale um JDK, como Eclipse Temurin, Oracle JDK ou outra distribuição compatível; apenas um JRE não fornece as ferramentas normais de empacotamento.
2. Coloque script.js e seus recursos em um diretório de projeto, preservando os caminhos referenciados pelo script.
3. Abra um terminal no diretório do projeto e execute jar --create --file app.jar script.js. Adicione diretórios ou arquivos conforme necessário, por exemplo, jar --create --file app.jar script.js lib config.
4. Verifique o arquivo com jar --list --file app.jar.

Em versões mais antigas do JDK, o comando equivalente é jar cf app.jar script.js. Esse processo preserva o código-fonte JavaScript e o empacota; ele não faz com que java -jar app.jar execute o script.

Criar um wrapper Java executável

Para distribuir uma aplicação Java que execute o script, crie um projeto Java com uma classe launcher. O launcher carrega script.js do JAR, cria um contexto de JavaScript engine, fornece os argumentos ou objetos host necessários e avalia o script.

GraalJS pode ser incorporado por meio da API GraalVM Polyglot e de suas dependências Java. Adicione as dependências necessárias do GraalVM SDK e do JavaScript engine por meio do Maven ou Gradle, escreva o launcher, compile-o e empacote a classe launcher, o script, os recursos e as dependências. A configuração do GraalJS varia conforme a versão do GraalVM e das dependências; portanto, use as versões de dependência compatíveis com o runtime selecionado em vez de copiar um exemplo obsoleto do Nashorn.

O Nashorn foi removido das distribuições padrão do JDK a partir do JDK 15. O código que depende do Nashorn deve usar uma distribuição de compatibilidade mantida separadamente ou ser migrado para outro engine; um JDK atual normalmente não fornece o Nashorn.

No IntelliJ IDEA, uma opção comum de empacotamento para aplicações desktop é File → Project Structure → Artifacts → JAR → From modules with dependencies. Selecione a classe launcher como classe principal, escolha se as dependências devem ser extraídas para um fat JAR ou mantidas ao lado da aplicação e compile o artifact. Um build Maven ou Gradle geralmente é mais reprodutível para projetos com muitas dependências. Execute um pacote configurado corretamente com java -jar app.jar.

Se o arquivo original for uma aplicação Node.js, mantê-lo como um projeto Node.js geralmente é a opção tecnicamente correta. Um wrapper Java pode iniciar node como um processo externo, mas o sistema de destino ainda precisará do Node.js, e o resultado não será uma conversão para bytecode Java.

Opções online e desktop

Não existe um conversor online confiável que traduza arbitrariamente JavaScript em classes Java equivalentes ou em um JAR executável autocontido. Ferramentas online de arquivamento às vezes podem criar um pacote semelhante a ZIP, mas não conseguem inferir um ponto de entrada Java, instalar um JavaScript engine, resolver dependências de npm ou de browser nem testar o comportamento em runtime.

Para um arquivo único não sensível, um criador de ZIP online pode ser usado somente se o destinatário aceitar um arquivo comum e você verificar seu conteúdo posteriormente; renomear um .zip baixado para .jar não substitui sua criação com o JDK. Use o comando local jar do JDK, o IntelliJ IDEA, o Maven ou o Gradle para código-fonte e projetos com vários arquivos, e não envie scripts proprietários para um serviço online.

Verificações de compatibilidade

Teste o script no runtime exato destinado ao JAR. Globais de browser não existem no Node.js ou no GraalJS, módulos Node.js não funcionam automaticamente no GraalJS e o acesso ao host Java pode exigir configuração explícita. Confirme caminhos relativos, permissões de arquivo, codificação de caracteres, bibliotecas nativas, acesso à rede, variáveis de ambiente e todas as dependências de terceiros.

Um JAR contendo apenas script.js é um arquivo. Um pacote executável requer um launcher Java, um JavaScript engine compatível, uma entrada de manifest Main-Class válida e um layout de dependências que funcione no JDK de destino.