google-closure-compiler

What is google-closure-compiler?

The google-closure-compiler npm package is a powerful tool for optimizing JavaScript code. It can be used to minify, transpile, and optimize JavaScript, making it faster and more efficient. It also provides advanced features like dead code elimination, type checking, and more.

What are google-closure-compiler's main functionalities?

Minification

This feature allows you to minify JavaScript files, reducing their size and improving load times. The code sample demonstrates how to use the google-closure-compiler to minify a JavaScript file.

const closureCompiler = require('google-closure-compiler').compiler;
const compiler = new closureCompiler({
  js: 'input.js',
  compilation_level: 'SIMPLE',
  js_output_file: 'output.min.js'
});
compiler.run((exitCode, stdOut, stdErr) => {
  console.log(stdOut);
  console.error(stdErr);
});

Transpilation

This feature allows you to transpile JavaScript code from one version of ECMAScript to another. The code sample demonstrates how to transpile ECMAScript 6 code to ECMAScript 5 using google-closure-compiler.

const closureCompiler = require('google-closure-compiler').compiler;
const compiler = new closureCompiler({
  js: 'input.js',
  language_in: 'ECMASCRIPT6',
  language_out: 'ECMASCRIPT5',
  js_output_file: 'output.transpiled.js'
});
compiler.run((exitCode, stdOut, stdErr) => {
  console.log(stdOut);
  console.error(stdErr);
});

Dead Code Elimination

This feature allows you to eliminate dead code, which is code that is never executed, from your JavaScript files. The code sample demonstrates how to use the google-closure-compiler to perform dead code elimination.

const closureCompiler = require('google-closure-compiler').compiler;
const compiler = new closureCompiler({
  js: 'input.js',
  compilation_level: 'ADVANCED',
  js_output_file: 'output.optimized.js'
});
compiler.run((exitCode, stdOut, stdErr) => {
  console.log(stdOut);
  console.error(stdErr);
});

Type Checking

This feature allows you to perform type checking on your JavaScript code, helping to catch type-related errors. The code sample demonstrates how to enable type checking using google-closure-compiler.

const closureCompiler = require('google-closure-compiler').compiler;
const compiler = new closureCompiler({
  js: 'input.js',
  jscomp_warning: 'checkTypes',
  js_output_file: 'output.checked.js'
});
compiler.run((exitCode, stdOut, stdErr) => {
  console.log(stdOut);
  console.error(stdErr);
});

Other packages similar to google-closure-compiler

terser

Terser is a JavaScript parser and mangler/compressor toolkit for ES6+. It is a popular alternative to google-closure-compiler for minifying JavaScript. Terser is known for its speed and efficiency, but it does not offer the same level of advanced optimizations and type checking as google-closure-compiler.

babel

Babel is a JavaScript compiler that is primarily used to transpile ECMAScript 2015+ code into a backwards-compatible version of JavaScript. While Babel focuses on transpilation, it can also be used in conjunction with other tools for minification and optimization. Unlike google-closure-compiler, Babel does not perform advanced optimizations or type checking.

uglify-js

UglifyJS is a JavaScript parser, minifier, compressor, and beautifier toolkit. It is one of the oldest and most widely used tools for minifying JavaScript. UglifyJS is similar to google-closure-compiler in terms of minification capabilities but lacks advanced features like type checking and dead code elimination.

README

google-closure-compiler

Check, compile, optimize and compress Javascript with Closure-Compiler

This repository tracks issues related to the publication to npmjs.org and associated plugins. Any bugs not related to the plugins themselves should be reported to the main repository.

Note that the installed binary is not actually JavaScript, but native binary or Java jar file depending on the local system.

Getting Started

If you are new to Closure-Compiler, make sure to read and understand the compilation levels as the compiler works very differently depending on the compilation level selected.

For help or questions with the compiler, the best resource is Stack Overflow. Posts there are monitored by multiple Closure Compiler team members.

You may also post in the Closure Compiler Discuss Google Group.

Please don't cross post to both Stack Overflow and Closure Compiler Discuss.

The compiler is distributed as a Java jar or as Mac OS, Linux and Windows native binaries.

Native Binary Version

On Linux, Mac OS and Windows, optional dependencies will install a native binary of the compiler. Native binaries offer faster compile times without requiring Java to be installed and available. Compilations with a very large number of source files may be slightly slower than the java version.

Java Version

Requires java to be installed and in the path. Using the java version typically results in faster compilation times.

Usage

The simplest way to invoke the compiler (e.g. if you're just trying it out) is with npx:

npx google-closure-compiler --js=my_program.js --js_output_file=out.js

The npx version will attempt to detect the best platform to use. You can also specify the platform with the special --platform flag.

Installation

npm install --save google-closure-compiler

Configuration

See the full list of compiler flags.

The build tool plugins take options objects. The option parameters map directly to the compiler flags without the leading '--' characters. You may also use camelCase option names.

Values are either strings or booleans. Options which have multiple values can be arrays.

  {
    js: ['/file-one.js', '/file-two.js'],
    compilation_level: 'ADVANCED',
    js_output_file: 'out.js',
    debug: true
  }

For the java version, some shells (particularly windows) try to do expansion on globs rather than passing the string on to the compiler. To prevent this it is necessary to quote certain arguments:

  {
    js: '"my/quoted/glob/**.js"',
    compilation_level: 'ADVANCED',
    js_output_file: 'out.js',
    debug: true
  }

Build Tool Plugins

The compiler package also includes build tool plugins for Grunt and Gulp. There is also an official webpack plugin.

• Grunt Plugin
• Gulp Plugin
• Webpack Plugin

Community Maintained Plugins

Additionally, community members have created plugins leveraging this library.

• Rollup Plugin

Advanced Java Version Usage

Changing the Path to the Java SDK

Override the path before first use.

const Compiler = require('google-closure-compiler');

Compiler.prototype.javaPath = '/node_modules/MODULE_NAME/jre/jre1.8.0_131.jre/Contents/Home/bin/java';

const compiler = new Compiler({args});

Running the compiler using nailgun

Note: nailgun users are encouraged to try the native binary versions where available.

This gets around the long startup time of Google Closure Compiler using Nailgun, which runs a single java process in the background and keeps all of the classes loaded.

First you need to install closure-gun by running the following command.

npm install closure-gun

Then point the package to use closure-gun rather than the JDK.

const compilerPackage = require('google-closure-compiler');

compilerPackage.compiler.JAR_PATH = undefined;
compilerPackage.compiler.prototype.javaPath = './node_modules/.bin/closure-gun'

Note that when using gulp, Only invocations without gulp.src work with nailgun.

Native Node Usage (for Plugin Authors)

A low-level node class is included to facilitate spawning the compiler jar as a process from Node. In addition, it exposes a static property with the path to the compiler jar file.

Java Version

const ClosureCompiler = require('google-closure-compiler').compiler;

console.log(ClosureCompiler.COMPILER_PATH); // absolute path to the compiler jar
console.log(ClosureCompiler.CONTRIB_PATH); // absolute path to the contrib folder which contain externs

const closureCompiler = new ClosureCompiler({
  js: 'file-one.js',
  compilation_level: 'ADVANCED'
});

const compilerProcess = closureCompiler.run((exitCode, stdOut, stdErr) => {
  //compilation complete
});

License

Copyright 2015 The Closure Compiler Authors

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Version History

Closure Compiler release notes can be found on the main repository wiki.