google-closure-compiler 20250412.0.0-nightly → 20250413.0.0

package/lib/gulp/concat-to-json.js

@@ -21,30 +21,42 @@
  * @author Chad Killingsworth (chadkillingsworth@gmail.com)
  */
 
-'use strict';
+import path from 'node:path';
 
-function json_file(src, path, source_map) {
-  const filejson = {
-    src: src
+/**
+ * @param {string} src
+ * @param {string=} path
+ * @param {string=} sourceMap
+ * @return {{
+ *   src: string,
+ *   path: string|undefined,
+ *   sourceMap: string|undefined,
+ * }}
+ */
+const json_file = (src, path, sourceMap) => {
+  return {
+    src: src,
+    ...(path !== undefined ? {path} : undefined),
+    ...(sourceMap !== undefined ? {sourceMap} : undefined),
   };
-
-  if (path) {
-    filejson.path = path;
-  }
-
-  if (source_map) {
-    filejson.sourceMap = source_map;
-  }
-
-  return filejson;
-}
+};
 
 /**
- * @param {Array<Object>} files
+ * @param {!Array<!{
+ *   src: string,
+ *   path: string|undefined,
+ *   sourceMap: string|undefined,
+ * }>} files
  * @return {string}
  */
-module.exports = files => {
-  const path = require('path');
+export default (files) => {
+  /**
+   * @type {!Array<!{
+   *   src: string,
+   *   path: string|undefined,
+   *   sourceMap: string|undefined,
+   * }>}
+   */
   const jsonFiles = [];
   for (let i = 0; i < files.length; i++) {
     jsonFiles.push(

package/lib/gulp/index.js

@@ -26,7 +26,26 @@
  * @author Chad Killingsworth (chadkillingsworth@gmail.com)
  */
 
-'use strict';
+import stream from 'node:stream';
+import {createRequire} from 'node:module';
+import chalk from 'chalk';
+import File from 'vinyl';
+import applySourceMap from 'vinyl-sourcemaps-apply';
+
+import filesToJson from './concat-to-json.js';
+import jsonToVinyl from './json-to-vinyl.js';
+import Compiler from '../node/index.js';
+import {getNativeImagePath, getFirstSupportedPlatform} from '../utils.js';
+
+const require = createRequire(import.meta.url);
+const PLUGIN_NAME = 'gulp-google-closure-compiler';
+
+let gulpLog;
+try {
+  gulpLog = require('gulp-util').log;
+} catch(e) {
+  gulpLog = console;
+}
 
 /**
  * Rethrow an error with a custom message.
@@ -35,221 +54,195 @@
 class CustomError extends Error {
   constructor(plugin, message) {
     if (message instanceof Error) {
-      super(`Error in ${plugin}`);
-      this.original = message;
-      // Compose both the current stack and the original stack
-      this.stack = `${this.stack.split('\n').slice(0,2).join('\n')}\n${message.stack}`;
+      super(`Error in ${plugin}`, {cause: message});
     } else {
       super(`${plugin}: ${message}`);
     }
   }
 }
 
-/**
- * @param {Object<string,string>} initOptions
- * @return {function(Object<string,string>|Array<string>):Object}
- */
-module.exports = function(initOptions) {
-  const filesToJson = require('./concat-to-json');
-  const jsonToVinyl = require('./json-to-vinyl');
-  const stream = require('stream');
-  const {getNativeImagePath, getFirstSupportedPlatform} = require('../utils');
-  /** @const */
-  const PLUGIN_NAME = 'gulp-google-closure-compiler';
-
-  const applySourceMap = require('vinyl-sourcemaps-apply');
-  const chalk = require('chalk');
-  const File = require('vinyl');
-
-  const extraCommandArguments = initOptions ? initOptions.extraArguments : undefined;
-
-  let PluginError;
+const PluginError = (() => {
   try {
-    PluginError = require('gulp-util').PluginError;
-  } catch(e) {
-    PluginError = CustomError;
+    return require('gulp-util').PluginError;
+  } catch {
+    return CustomError;
   }
-
-  let gulpLog;
-  try {
-    gulpLog = require('gulp-util').log;
-  } catch(e) {
-    gulpLog = console;
+})();
+
+class CompilationStream extends stream.Transform {
+  constructor(compilationOptions, pluginOptions = {}) {
+    super({objectMode: true});
+    this.compilationOptions_ = compilationOptions;
+    this.streamMode_ = pluginOptions.streamMode || 'BOTH';
+    this.logger_ = pluginOptions.logger || gulpLog;
+    this.PLUGIN_NAME_ = pluginOptions.pluginName || PLUGIN_NAME;
+    this.extraCommandArgs_ = pluginOptions.extraCommandArguments || [];
+
+    this.fileList_ = [];
+    this._streamInputRequired = pluginOptions.requireStreamInput !== false;
+
+    let platforms = (pluginOptions && pluginOptions.platform) || ['native', 'java'];
+    if (!Array.isArray(platforms)) {
+      platforms = [platforms];
+    }
+    this.platform = getFirstSupportedPlatform(platforms);
   }
 
-  function getCompiler(platform) {
-    return require('../node/closure-compiler');
+  src() {
+    this._streamInputRequired = false;
+    process.nextTick(() => {
+      const stdInStream = new stream.Readable({ read: function() {
+        return new File();
+      }});
+      stdInStream.pipe(this);
+      stdInStream.push(null);
+    });
+    return this;
   }
 
-  class CompilationStream extends stream.Transform {
-    constructor(compilationOptions, pluginOptions) {
-      super({objectMode: true});
-      pluginOptions = pluginOptions || {};
-
-      this.compilationOptions_ = compilationOptions;
-      this.streamMode_ = pluginOptions.streamMode || 'BOTH';
-      this.logger_ = pluginOptions.logger || gulpLog;
-      this.PLUGIN_NAME_ = pluginOptions.pluginName || PLUGIN_NAME;
-
-      this.fileList_ = [];
-      this._streamInputRequired = pluginOptions.requireStreamInput !== false;
-
-      let platforms = (pluginOptions && pluginOptions.platform) || ['native', 'java'];
-      if (!Array.isArray(platforms)) {
-        platforms = [platforms];
-      }
-      this.platform = getFirstSupportedPlatform(platforms);
+  _transform(file, enc, cb) {
+    // ignore empty files
+    if (!file || file.isNull()) {
+      cb();
+      return;
     }
 
-    src() {
-      this._streamInputRequired = false;
-      process.nextTick(() => {
-        const stdInStream = new stream.Readable({ read: function() {
-          return new File();
-        }});
-        stdInStream.pipe(this);
-        stdInStream.push(null);
-      });
-      return this;
+    if (file.isStream()) {
+      cb(new PluginError(this.PLUGIN_NAME_, 'Streaming not supported'));
+      return;
     }
 
-    _transform(file, enc, cb) {
-      // ignore empty files
-      if (!file || file.isNull()) {
-        cb();
-        return;
-      }
+    this.fileList_.push(file);
+    cb();
+  }
 
-      if (file.isStream()) {
-        this.emit('error', new PluginError(this.PLUGIN_NAME_, 'Streaming not supported'));
+  async _flush(cb) {
+    let jsonFiles;
+    if (this.fileList_.length > 0) {
+      // Input files are present. Convert them to a JSON encoded string
+      jsonFiles = filesToJson(this.fileList_);
+    } else {
+      // If files in the stream were required, no compilation needed here.
+      if (this._streamInputRequired) {
+        this.push(null);
         cb();
         return;
       }
 
-      this.fileList_.push(file);
-      cb();
+      // The compiler will always expect something on standard-in. So pass it an empty
+      // list if no files were piped into this plugin.
+      jsonFiles = [];
     }
+    const compiler = new Compiler(this.compilationOptions_, this.extraCommandArgs_);
+    if (this.platform === 'native') {
+      compiler.JAR_PATH = null;
+      compiler.javaPath = getNativeImagePath();
+    }
+    let stdOutData = '';
+    let stdErrData = '';
+
+    // Add the gulp-specific argument so the compiler will understand the JSON encoded input
+    // for gulp, the stream mode will be 'BOTH', but when invoked from grunt, we only use
+    // a stream mode of 'IN'
+    compiler.commandArguments.push('--json_streams', this.streamMode_);
+    const compilerProcess = compiler.run();
+
+    compilerProcess.stdout.on('data', (data) => {
+      stdOutData += data;
+    });
+    compilerProcess.stderr.on('data', (data) => {
+      stdErrData += data;
+    });
+    // Error events occur when there was a problem spawning the compiler process
+    compilerProcess.on('error', async (err) => {
+      this.emit('error', new PluginError(this.PLUGIN_NAME_,
+          `Process spawn error. Is java in the path?\n${err.message}`));
+      cb();
+    });
+    compilerProcess.stdin.on('error', (err) => {
+      stdErrData += `Error writing to stdin of the compiler. ${err.message}`;
+    });
+
+    const compileExecComplete = Promise.all([
+      new Promise((resolve) => compilerProcess.on('close', resolve)),
+      new Promise((resolve) => compilerProcess.stdout.on('end', resolve)),
+      new Promise((resolve) => compilerProcess.stderr.on('end', resolve))
+    ]);
+
+    const stdInStream = new stream.Readable({ read: function() {}});
+    stdInStream.pipe(compilerProcess.stdin);
+    await new Promise((resolve) => {
+      process.nextTick(() => {
+        stdInStream.push(JSON.stringify(jsonFiles));
+        stdInStream.push(null);
+        resolve();
+      });
+    });
 
-    _flush(cb) {
-      let jsonFiles;
-      if (this.fileList_.length > 0) {
-        // Input files are present. Convert them to a JSON encoded string
-        jsonFiles = filesToJson(this.fileList_);
-      } else {
-        // If files in the stream were required, no compilation needed here.
-        if (this._streamInputRequired) {
-          this.push(null);
+    try {
+      const [code] = await compileExecComplete;
+
+      // If present, standard output will be a string of JSON encoded files.
+      // Convert these back to vinyl
+      let outputFiles = [];
+      if (stdOutData.trim().length > 0) {
+        if (code !== 0) {
+          this.emit('error', new PluginError(this.PLUGIN_NAME_, `Compiler error.\n${stdOutData}\n${stdErrData}`));
           cb();
           return;
         }
 
-        // The compiler will always expect something on standard-in. So pass it an empty
-        // list if no files were piped into this plugin.
-        jsonFiles = [];
-      }
-      const Compiler = getCompiler(this.platform);
-      const compiler = new Compiler(this.compilationOptions_, extraCommandArguments);
-      if (this.platform === 'native') {
-        compiler.JAR_PATH = null;
-        compiler.javaPath = getNativeImagePath();
-      }
-      let stdOutData = '';
-      let stdErrData = '';
-
-      // Add the gulp-specific argument so the compiler will understand the JSON encoded input
-      // for gulp, the stream mode will be 'BOTH', but when invoked from grunt, we only use
-      // a stream mode of 'IN'
-      compiler.commandArguments.push('--json_streams', this.streamMode_);
-      const compilerProcess = compiler.run();
-
-      compilerProcess.stdout.on('data', data => {
-        stdOutData += data;
-      });
-      compilerProcess.stderr.on('data', data => {
-        stdErrData += data;
-      });
-      // Error events occur when there was a problem spawning the compiler process
-      compilerProcess.on('error', err => {
-        this.emit('error', new PluginError(this.PLUGIN_NAME_,
-            'Process spawn error. Is java in the path?\n' + err.message));
-        cb();
-      });
-      compilerProcess.stdin.on('error', err => {
-        stdErrData += `Error writing to stdin of the compiler. ${err.message}`;
-      });
-
-      Promise.all([
-        new Promise(resolve => compilerProcess.on('close', resolve)),
-        new Promise(resolve => compilerProcess.stdout.on('end', resolve)),
-        new Promise(resolve => compilerProcess.stderr.on('end', resolve))
-      ]).then(results => {
-        const code = results[0];
-
-        // If present, standard output will be a string of JSON encoded files.
-        // Convert these back to vinyl
-        let outputFiles = [];
-        if (stdOutData.trim().length > 0) {
-          if (code !== 0) {
-            this.emit('error', new PluginError(this.PLUGIN_NAME_, 'Compiler error.\n' + stdOutData + '\n' + stdErrData));
-            cb();
-            return;
-          }
-          
-          // stdOutData = stdOutData.substr(stdOutData.indexOf('{'));
-          try {
-            outputFiles = JSON.parse(stdOutData);
-          } catch (e) {
-            this.emit('error', new PluginError(this.PLUGIN_NAME_, 'Error parsing json encoded files'));
-            cb();
-            return;
-          }
+        // stdOutData = stdOutData.substr(stdOutData.indexOf('{'));
+        try {
+          outputFiles = JSON.parse(stdOutData);
+        } catch (e) {
+          this.emit('error', new PluginError(this.PLUGIN_NAME_, 'Error parsing json encoded files'));
+          cb();
+          return;
         }
+      }
 
-        this._compilationComplete(code, outputFiles, stdErrData);
-        cb();
-      }).catch(err => {
-        this.emit('error', new PluginError(this.PLUGIN_NAME_, err, { showStack: true }));
-        cb();
-      });
-
-      const stdInStream = new stream.Readable({ read: function() {}});
-      stdInStream.pipe(compilerProcess.stdin);
-      process.nextTick(() => {
-        stdInStream.push(JSON.stringify(jsonFiles));
-        stdInStream.push(null);
-      });
+      this._compilationComplete(code, outputFiles, stdErrData);
+      cb();
+    } catch (err) {
+      this.emit('error', new PluginError(this.PLUGIN_NAME_, err, { showStack: true }));
+      cb();
     }
+  }
 
-    /**
-     * @param {number} exitCode
-     * @param {string} compiledJs
-     * @param {string} errors
-     * @private
-     */
-    _compilationComplete(exitCode, compiledJs, errors) {
-      // standard error will contain compilation warnings, log those
-      if (errors && errors.trim().length > 0) {
-        const logger = this.logger_.warn ? this.logger_.warn : this.logger_;
-        logger(`${chalk.yellow(this.PLUGIN_NAME_)}: ${errors}`);
-      }
+  /**
+   * @param {number} exitCode
+   * @param {string} compiledJs
+   * @param {string} errors
+   * @private
+   */
+  _compilationComplete(exitCode, compiledJs, errors) {
+    // standard error will contain compilation warnings, log those
+    if (errors && errors.trim().length > 0) {
+      const logger = this.logger_.warn ? this.logger_.warn : this.logger_;
+      logger(`${chalk.yellow(this.PLUGIN_NAME_)}: ${errors}`);
+    }
 
-      // non-zero exit means a compilation error
-      if (exitCode !== 0) {
-        this.emit('error', new PluginError(this.PLUGIN_NAME_, `Compilation errors occurred`));
-      }
+    // non-zero exit means a compilation error
+    if (exitCode !== 0) {
+      this.emit('error', new PluginError(this.PLUGIN_NAME_, 'Compilation errors occurred'));
+    }
 
-      // If present, standard output will be a string of JSON encoded files.
-      // Convert these back to vinyl
-      let outputFiles = jsonToVinyl(compiledJs);
+    // If present, standard output will be a string of JSON encoded files.
+    // Convert these back to vinyl
+    const outputFiles = jsonToVinyl(compiledJs);
 
-      for (let i = 0; i < outputFiles.length; i++) {
-        if (outputFiles[i].sourceMap) {
-          applySourceMap(outputFiles[i], outputFiles[i].sourceMap);
-        }
-        this.push(outputFiles[i]);
+    for (let i = 0; i < outputFiles.length; i++) {
+      if (outputFiles[i].sourceMap) {
+        applySourceMap(outputFiles[i], outputFiles[i].sourceMap);
       }
+      this.push(outputFiles[i]);
     }
   }
+}
 
-  return (compilationOptions, pluginOptions) => new CompilationStream(compilationOptions, pluginOptions);
-};
+/**
+ * @param {Object<string,string>} initOptions
+ * @return {function(Object<string,string>|Array<string>):Object}
+ */
+export default (compilationOptions, pluginOptions) => new CompilationStream(compilationOptions, pluginOptions);

package/lib/gulp/json-to-vinyl.js

@@ -20,16 +20,17 @@
  *
  * @author Chad Killingsworth (chadkillingsworth@gmail.com)
  */
-
-'use strict';
-
-const File = require('vinyl');
+import File from 'vinyl';
 
 /**
- * @param {string} input string of json encoded files
- * @return {Array<Object>}
+ * @param {!Array<!{
+ *     path: string,
+ *     src: string,
+ *     sourceMap: (string|undefined)
+ *   }>} fileList array of file objects
+ * @return {!Array<!File>}
  */
-module.exports = fileList => {
+export default (fileList) => {
   let outputFiles = [];
   for (let i = 0; i < fileList.length; i++) {
     const file = new File({
@@ -44,4 +45,3 @@ module.exports = fileList => {
 
   return outputFiles;
 };
-

package/lib/node/{closure-compiler.js → index.js}

@@ -20,15 +20,15 @@
  *
  * @author Chad Killingsworth (chadkillingsworth@gmail.com)
  */
+import {spawn} from 'node:child_process';
+import compilerPath from 'google-closure-compiler-java';
 
-'use strict';
-
-const spawn = require('child_process').spawn;
-const compilerPath = require('google-closure-compiler-java');
-const path = require('path');
-const contribPath = path.resolve(__dirname, '../../contrib');
+/**
+ * @type {string}
+ */
+export const javaPath = 'java';
 
-class Compiler {
+export default class Compiler {
   /**
    * @param {Object<string,string>|Array<string>} args
    * @param {Array<String>=} extraCommandArgs
@@ -36,13 +36,11 @@ class Compiler {
   constructor(args, extraCommandArgs) {
     this.commandArguments = [];
     this.extraCommandArgs = extraCommandArgs;
-
-    if (Compiler.JAR_PATH) {
-      this.JAR_PATH = Compiler.JAR_PATH;
-    }
+    this.JAR_PATH = compilerPath;
+    this.javaPath = javaPath;
 
     if (Array.isArray(args)) {
-      this.commandArguments = this.commandArguments.concat(args.slice());
+      this.commandArguments.push(...args);
     } else {
       for (let key in args) {
         if (Array.isArray(args[key])) {
@@ -56,15 +54,18 @@ class Compiler {
         }
       }
     }
+
+    /** @type {function(...*)|null} */
+   this.logger = null;
+
+    /** @type {Object<string, string>} */
+    this.spawnOptions = undefined;
   }
 
-  /**
-   * @param {function(number, string, string)=} callback
-   * @return {child_process.ChildProcess}
-   */
+  /** @param {function(number, string, string)=} callback */
   run(callback) {
     if (this.JAR_PATH) {
-      this.commandArguments.unshift('-jar', Compiler.JAR_PATH);
+      this.commandArguments.unshift('-jar', this.JAR_PATH);
       if (this.extraCommandArgs) {
         this.commandArguments.unshift(...this.extraCommandArgs);
       }
@@ -80,22 +81,22 @@ class Compiler {
     if (callback) {
       if (compileProcess.stdout) {
         compileProcess.stdout.setEncoding('utf8');
-        compileProcess.stdout.on('data', data => {
+        compileProcess.stdout.on('data', (data) => {
           stdOutData += data;
         });
-        compileProcess.stdout.on('error', err => {
+        compileProcess.stdout.on('error', (err) => {
           stdErrData += err.toString();
         });
       }
 
       if (compileProcess.stderr) {
         compileProcess.stderr.setEncoding('utf8');
-        compileProcess.stderr.on('data', data => {
+        compileProcess.stderr.on('data', (data) => {
           stdErrData += data;
         });
       }
 
-      compileProcess.on('close',  code => {
+      compileProcess.on('close',  (code) => {
         if (code !== 0) {
           stdErrData = this.prependFullCommand(stdErrData);
         }
@@ -103,7 +104,7 @@ class Compiler {
         callback(code, stdOutData, stdErrData);
       });
 
-      compileProcess.on('error', err => {
+      compileProcess.on('error', (err) => {
         callback(1, stdOutData,
             this.prependFullCommand('Process spawn error. Is java in the path?\n' + err.message));
       });
@@ -117,7 +118,7 @@ class Compiler {
    * @return {string}
    */
   getFullCommand() {
-    return this.javaPath + ' ' + this.commandArguments.join(' ');
+    return `${this.javaPath} ${this.commandArguments.join(' ')}`;
   }
 
   /**
@@ -125,7 +126,7 @@ class Compiler {
    * @return {string}
    */
   prependFullCommand(msg) {
-    return this.getFullCommand() + '\n\n' + msg + '\n\n';
+    return `${this.getFullCommand()}\n\n${msg}\n\n`;
   }
 
   /**
@@ -134,7 +135,7 @@ class Compiler {
    * @return {string}
    */
   formatArgument(key, val) {
-    let normalizedKey = key.replace(/[A-Z]/g, match => `_${match.toLowerCase()}`);
+    let normalizedKey = key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
     normalizedKey = normalizedKey.replace(/^--/, '');
 
     if (val === undefined || val === null) {
@@ -143,29 +144,4 @@ class Compiler {
 
     return `--${normalizedKey}=${val}`;
   }
-}
-
-/**
- * @const
- * @type {string}
- */
-Compiler.JAR_PATH = compilerPath;
-
-/**
- * @type {string}
- */
-Compiler.prototype.javaPath = 'java';
-
-/** @type {function(...*)|null} */
-Compiler.prototype.logger = null;
-
-/** @type {Object<string, string>} */
-Compiler.prototype.spawnOptions = undefined;
-
-/** @type {string} */
-Compiler.COMPILER_PATH = compilerPath;
-
-/** @type {string} */
-Compiler.CONTRIB_PATH = contribPath;
-
-module.exports = Compiler;
+};