google-closure-compiler 20250412.0.0-nightly → 20250413.0.0

package/externs/es6_collections.js

@@ -0,0 +1,323 @@
+/*
+ * Copyright 2014 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.
+ */
+
+/**
+ * @fileoverview Definitions for ECMAScript 6.
+ * @see http://wiki.ecmascript.org/doku.php?id=harmony:specification_drafts
+ * @externs
+ */
+
+// TODO(johnlenz): Use Tuples for the Map and Set iterators where appropriate.
+/**
+ * @interface
+ * @extends {Iterable<!Array<K|V>>}
+ * @template K, V
+ */
+function ReadonlyMap() {}
+
+/**
+ * @return {!IteratorIterable<!Array<K|V>>}
+ * @nosideeffects
+ */
+ReadonlyMap.prototype.entries = function() {};
+
+/**
+ * @param {function(this:THIS, V, K, MAP): ?} callback
+ * @param {THIS=} opt_thisArg
+ * @this {MAP}
+ * @template MAP, THIS
+ * @return {undefined}
+ */
+ReadonlyMap.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {K} key
+ * @return {V|undefined}
+ * @nosideeffects
+ */
+ReadonlyMap.prototype.get = function(key) {};
+
+/**
+ * @param {K} key
+ * @return {boolean}
+ * @nosideeffects
+ */
+ReadonlyMap.prototype.has = function(key) {};
+
+/**
+ * @return {!IteratorIterable<K>}
+ * @nosideeffects
+ */
+ReadonlyMap.prototype.keys = function() {};
+
+/**
+ * @const {number}
+ * @nosideeffects
+ */
+ReadonlyMap.prototype.size;
+
+/**
+ * @return {!IteratorIterable<V>}
+ * @nosideeffects
+ */
+ReadonlyMap.prototype.values = function() {};
+
+/**
+ * @return {!Iterator<!Array<K|V>>}
+ * @nosideeffects
+ */
+ReadonlyMap.prototype[Symbol.iterator] = function() {};
+
+/**
+ * @constructor @struct
+ * @param {Iterable<!Array<K|V>>|!Array<!Array<K|V>>=} opt_iterable
+ * @implements {ReadonlyMap<K, V>}
+ * @template K, V
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
+ */
+function Map(opt_iterable) {}
+
+/** @return {void} */
+Map.prototype.clear = function() {};
+
+/**
+ * @param {K} key
+ * @return {boolean}
+ */
+Map.prototype.delete = function(key) {};
+
+/**
+ * @override
+ * @return {!IteratorIterable<!Array<K|V>>}
+ * @nosideeffects
+ */
+Map.prototype.entries = function() {};
+
+/**
+ * @override
+ * @param {function(this:THIS, V, K, MAP): ?} callback
+ * @param {THIS=} opt_thisArg
+ * @this {MAP}
+ * @template MAP,THIS
+ * @return {undefined}
+ */
+Map.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @override
+ * @param {K} key
+ * @return {V}
+ * @nosideeffects
+ */
+Map.prototype.get = function(key) {};
+
+/**
+ * @override
+ * @param {K} key
+ * @return {boolean}
+ * @nosideeffects
+ */
+Map.prototype.has = function(key) {};
+
+/**
+ * @override
+ * @return {!IteratorIterable<K>}
+ * @nosideeffects
+ */
+Map.prototype.keys = function() {};
+
+/**
+ * @param {K} key
+ * @param {V} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ */
+Map.prototype.set = function(key, value) {};
+
+/**
+ * @override
+ * @type {number}
+ * @nosideeffects
+ */
+Map.prototype.size;
+
+/**
+ * @override
+ * @return {!IteratorIterable<V>}
+ * @nosideeffects
+ */
+Map.prototype.values = function() {};
+
+/**
+ * @override
+ * @return {!Iterator<!Array<K|V>>}
+ * @nosideeffects
+ */
+Map.prototype[Symbol.iterator] = function() {};
+
+
+/**
+ * @constructor @struct
+ * @param {Iterable<!Array<K|V>>|!Array<!Array<K|V>>=} opt_iterable
+ * @template K, V
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
+ */
+function WeakMap(opt_iterable) {}
+
+/** @return {void} */
+WeakMap.prototype.clear = function() {};
+
+/**
+ * @param {K} key
+ * @return {boolean}
+ */
+WeakMap.prototype.delete = function(key) {};
+
+/**
+ * @param {K} key
+ * @return {V}
+ * @nosideeffects
+ */
+WeakMap.prototype.get = function(key) {};
+
+/**
+ * @param {K} key
+ * @return {boolean}
+ * @nosideeffects
+ */
+WeakMap.prototype.has = function(key) {};
+
+/**
+ * @param {K} key
+ * @param {V} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ */
+WeakMap.prototype.set = function(key, value) {};
+
+/**
+ * @constructor @struct
+ * @param {Iterable<VALUE>|Array<VALUE>=} opt_iterable
+ * @implements {Iterable<VALUE>}
+ * @template VALUE
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
+ */
+function Set(opt_iterable) {}
+
+/**
+ * @param {VALUE} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ */
+Set.prototype.add = function(value) {};
+
+/**
+ * @return {void}
+ */
+Set.prototype.clear = function() {};
+
+/**
+ * @param {VALUE} value
+ * @return {boolean}
+ */
+Set.prototype.delete = function(value) {};
+
+/**
+ * @return {!IteratorIterable<!Array<VALUE>>} Where each array has two entries:
+ *     [value, value]
+ * @nosideeffects
+ */
+Set.prototype.entries = function() {};
+
+/**
+ * @param {function(this: THIS, VALUE, VALUE, SET)} callback
+ * @param {THIS=} opt_thisArg
+ * @this {SET}
+ * @template SET,THIS
+ */
+Set.prototype.forEach = function(callback, opt_thisArg) {};
+
+/**
+ * @param {VALUE} value
+ * @return {boolean}
+ * @nosideeffects
+ */
+Set.prototype.has = function(value) {};
+
+/**
+ * @type {number} (readonly)
+ */
+Set.prototype.size;
+
+/**
+ * @return {!IteratorIterable<VALUE>}
+ * @nosideeffects
+ */
+Set.prototype.keys = function() {};
+
+/**
+ * @return {!IteratorIterable<VALUE>}
+ * @nosideeffects
+ */
+Set.prototype.values = function() {};
+
+/**
+ * @return {!Iterator<VALUE>}
+ */
+Set.prototype[Symbol.iterator] = function() {};
+
+
+
+/**
+ * @constructor @struct
+ * @param {Iterable<VALUE>|Array<VALUE>=} opt_iterable
+ * @template VALUE
+ * @nosideeffects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
+ */
+function WeakSet(opt_iterable) {}
+
+/**
+ * @param {VALUE} value
+ * @return {THIS}
+ * @this {THIS}
+ * @template THIS
+ */
+WeakSet.prototype.add = function(value) {};
+
+/**
+ * @return {void}
+ */
+WeakSet.prototype.clear = function() {};
+
+/**
+ * @param {VALUE} value
+ * @return {boolean}
+ */
+WeakSet.prototype.delete = function(value) {};
+
+/**
+ * @param {VALUE} value
+ * @return {boolean}
+ * @nosideeffects
+ */
+WeakSet.prototype.has = function(value) {};

package/index.js

@@ -20,21 +20,18 @@
  * @author Chad Killingsworth (chadkillingsworth@gmail.com)
  */
 
-'use strict';
+import path from 'node:path';
+import {fileURLToPath, URL} from 'node:url';
+export {default as JAR_PATH} from 'google-closure-compiler-java';
 
-// defer loading modules. The jscomp file is rather large. Don't load it unless it's actually referenced.
-class Main {
-  static get grunt() {
-    return require('./lib/grunt');
-  }
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+export const CONTRIB_PATH = path.resolve(__dirname, './contrib');
+export const EXTERNS_PATH = path.resolve(__dirname, './externs');
 
-  static get gulp() {
-    return require('./lib/gulp');
-  }
-
-  static get compiler() {
-    return require('./lib/node/closure-compiler');
-  }
-}
-
-module.exports = Main;
+export {default as grunt} from './lib/grunt/index.js';
+export {default as gulp} from './lib/gulp/index.js';
+export {
+  default as compiler,
+  default,
+  javaPath,
+} from './lib/node/index.js';

package/lib/grunt/index.js

@@ -23,36 +23,30 @@
  *
  * @author Chad Killingsworth (chadkillingsworth@gmail.com)
  */
+import {Transform} from 'node:stream';
+import chalk from 'chalk';
+import gulpCompiler from '../gulp/index.js';
+import {getFirstSupportedPlatform} from '../utils.js';
+import VinylStream from './vinyl-stream.js';
 
-'use strict';
-
-module.exports = (grunt, pluginOptions) => {
-  const chalk = require('chalk');
-  const VinylStream = require('./vinyl-stream');
-  const Transform = require('stream').Transform;
+export default (grunt, pluginOptions) => {
   const gulpCompilerOptions = {};
-  const {getFirstSupportedPlatform} = require('../utils');
-
   let extraArguments;
   let platforms;
   let maxParallelCompilations = false;
   if (pluginOptions) {
-    if (Array.isArray(extraArguments)) {
-      extraArguments = pluginOptions;
-    } else {
-      if (pluginOptions.platform) {
-        platforms = Array.isArray(pluginOptions.platform) ? pluginOptions.platform : [pluginOptions.platform];
-      }
-      if (pluginOptions.extraArguments) {
-        extraArguments = pluginOptions.extraArguments;
-      }
-      if (pluginOptions.compile_in_batches && pluginOptions.max_parallel_compilations === undefined) {
-        pluginOptions.max_parallel_compilations = pluginOptions.compile_in_batches;
-        grunt.log.warn('DEPRECATED: compile_in_batches is deprecated. Use max_parallel_compilations.');
-      }
-      if (typeof pluginOptions.max_parallel_compilations === 'number' && pluginOptions.max_parallel_compilations > 0) {
-        maxParallelCompilations = pluginOptions.max_parallel_compilations;
-      }
+    if (pluginOptions.platform) {
+      platforms = Array.isArray(pluginOptions.platform) ? pluginOptions.platform : [pluginOptions.platform];
+    }
+    if (pluginOptions.extraArguments) {
+      extraArguments = pluginOptions.extraArguments;
+    }
+    if (pluginOptions.compile_in_batches && pluginOptions.max_parallel_compilations === undefined) {
+      pluginOptions.max_parallel_compilations = pluginOptions.compile_in_batches;
+      grunt.log.warn('DEPRECATED: compile_in_batches is deprecated. Use max_parallel_compilations.');
+    }
+    if (typeof pluginOptions.max_parallel_compilations === 'number' && pluginOptions.max_parallel_compilations > 0) {
+      maxParallelCompilations = pluginOptions.max_parallel_compilations;
     }
   }
 
@@ -60,31 +54,18 @@ module.exports = (grunt, pluginOptions) => {
     platforms = ['native', 'java'];
   }
   const platform = getFirstSupportedPlatform(platforms);
-
-  class WriteGruntFiles extends Transform {
-    constructor() {
-      super({objectMode: true});
-    }
-
-    _transform(file, enc, cb) {
-      grunt.file.write(file.path, file.contents);
-      this.push(file);
-      cb();
-    }
-  }
-
-  function compilationPromiseGenerator(files, options, pluginOpts) {
-    return () => compilationPromise(files, options, pluginOpts);
-  }
+  const compilationPromiseGenerator =
+      (files, options, pluginOpts) => () => compilationPromise(files, options, pluginOpts);
 
   /**
-   * @param {Array<string>}|null} files
+   * @param {Array<string>|null} files
    * @param {Object<string,string|boolean|Array<string>>|Array<string>} options
+   * @param {?} pluginOpts
    * @return {Promise}
    */
-  function compilationPromise(files, options, pluginOpts) {
+  const compilationPromise = (files, options, pluginOpts) => {
     let hadError = false;
-    function logFile(cb) {
+    const logFile = (cb) => {
       // If an error was encoutered, it will have already been logged
       if (!hadError) {
         if (options.js_output_file) {
@@ -94,7 +75,7 @@ module.exports = (grunt, pluginOptions) => {
         }
       }
       cb();
-    }
+    };
 
     const loggingStream = new Transform({
       objectMode: true,
@@ -102,20 +83,20 @@ module.exports = (grunt, pluginOptions) => {
       flush: logFile
     });
 
-    return new Promise(function(resolve, reject) {
+    return new Promise((resolve, reject) => {
       let stream;
-      const args = {};
-      let gulpOpts = Object.assign({}, gulpCompilerOptions, {
+      let gulpOpts = {
+        ...gulpCompilerOptions,
         streamMode: 'IN',
         logger: grunt.log,
         pluginName: 'grunt-google-closure-compiler',
         requireStreamInput: false
-      });
-      if (extraArguments) {
-        args.extraArguments = extraArguments;
-      }
-      const gulpCompiler = require('../gulp')(args);
-      const compilerOpts = Object.assign({}, gulpOpts, pluginOpts);
+      };
+      const compilerOpts = {
+        ...gulpOpts,
+        ...pluginOpts,
+        ...(extraArguments ? { extraArguments } : {}),
+      };
       if (files) {
         // Source files were provided by grunt. Read these
         // in to a stream of vinyl files and pipe them through
@@ -141,15 +122,41 @@ module.exports = (grunt, pluginOptions) => {
       stream.pipe(loggingStream);
       stream.resume(); //logging stream doesn't output files, so we have to manually resume;
     });
-  }
+  };
+
+  /**
+   * Grabs `ps` as array of promise-returning functions, separates it in `maxParallelCount`
+   * count of sequential processing consumers and runs these consumers in parallel to process
+   * all promises.
+   *
+   * @param {!Array<function():!Promise<undefined>>} ps functions returning promises
+   * @param {!number} maxParallelCount Maximum promises running in parallel
+   * @return {!Promise<undefined>|undefined}
+   */
+  const processPromisesParallel = (ps, maxParallelCount) => {
+    // While ps is not empty grab one function, run promise from it, then repeat. Else resolve to true.
+    const goInSequence = async () => {
+      if (!ps.length) {
+        return true;
+      }
+      await ps.shift()();
+      return goInSequence();
+    };
+
+    let bulk = [];
+    // run `maxParallelCount` or lesser (if array of promises lesser) count of goInSequence
+    for (let i = 0; i < Math.min(maxParallelCount, ps.length); i++) {
+      bulk.push(goInSequence());
+    }
+    return Promise.all(bulk);
+  };
 
   function closureCompilerGruntTask() {
-    const taskObject = this;
     const asyncDone = this.async();
     const compileTasks = [];
 
-    function getCompilerOptions() {
-      const opts = taskObject.options({
+    const getCompilerOptions = () => {
+      const opts = this.options({
         args: undefined
       });
 
@@ -164,12 +171,12 @@ module.exports = (grunt, pluginOptions) => {
     }
 
     // Invoke the compiler once for each set of source files
-    taskObject.files.forEach(function (f) {
+    for (const f of this.files) {
       const options = getCompilerOptions();
 
       const src = f.src.filter(filepath => {
         if (!grunt.file.exists(filepath)) {
-          grunt.log.warn('Source file ' + chalk.cyan(filepath) + ' not found');
+          grunt.log.warn(`Source file ${chalk.cyan(filepath)} not found`);
           return false;
         }
         return true;
@@ -177,19 +184,18 @@ module.exports = (grunt, pluginOptions) => {
 
       // Require source files
       if (src.length === 0) {
-        grunt.log.warn('Destination ' + chalk.cyan(f.dest) +
-            ' not written because src files were empty');
-        return;
+        grunt.log.warn(`Destination ${chalk.cyan(f.dest)} not written because src files were empty`);
+        continue;
       } else {
         options.compilerOpts.js_output_file = f.dest;
       }
 
       compileTasks.push(compilationPromiseGenerator(src, options.args || options.compilerOpts, {platform}));
-    });
+    }
 
     // If the task was invoked without any files provided by grunt, assume that
     // --js flags are present and we want to run the compiler anyway.
-    if (taskObject.files.length === 0) {
+    if (this.files.length === 0) {
       const options = getCompilerOptions();
       compileTasks.push(compilationPromiseGenerator(null, options.args || options.compilerOpts, {platform}));
     }
@@ -197,7 +203,7 @@ module.exports = (grunt, pluginOptions) => {
     // Multiple invocations of the compiler can occur for a single task target. Wait until
     // they are all completed before calling the "done" method.
 
-    return (maxParallelCompilations ? processPromisesParallel(compileTasks, maxParallelCompilations) : Promise.all(compileTasks.map(t => t())))
+    return (maxParallelCompilations ? processPromisesParallel(compileTasks, maxParallelCompilations) : Promise.all(compileTasks.map((t) => t())))
       .then(() => asyncDone())
       .catch((err) => {
         grunt.log.warn(err.message);
@@ -206,33 +212,6 @@ module.exports = (grunt, pluginOptions) => {
       });
   }
 
-  /**
-   * Grabs `ps` as array of promise-returning functions, separates it in `maxParallelCount`
-   * count of sequential processing consumers and runs these consumers in parallel to process
-   * all promises.
-   *
-   * @param {!Array<function():!Promise<undefined>>} ps functions returning promises
-   * @param {!number} maxParallelCount Maximum promises running in parallel
-   * @return {!Promise<undefined>|undefined}
-   */
-  function processPromisesParallel(ps, maxParallelCount) {
-    // While ps is not empty grab one function, run promise from it, then repeat. Else resolve to true.
-    async function goInSequence() {
-      if (!ps.length) {
-        return true;
-      }
-      await ps.shift()();
-      return goInSequence();
-    }
-
-    let bulk = [];
-    // run `maxParallelCount` or lesser (if array of promises lesser) count of goInSequence
-    for (let i = 0; i < Math.min(maxParallelCount, ps.length); i++) {
-      bulk.push(goInSequence());
-    }
-    return Promise.all(bulk);
-  }
-
   grunt.registerMultiTask('closure-compiler',
       'Minify files with Google Closure Compiler',
       closureCompilerGruntTask);

package/lib/grunt/vinyl-stream.js

@@ -20,14 +20,12 @@
  *
  * @author Chad Killingsworth (chadkillingsworth@gmail.com)
  */
-'use strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {Readable} from 'node:stream';
+import File from 'vinyl';
 
-const fs = require('fs');
-const path = require('path');
-const Readable = require('stream').Readable;
-const File = require('vinyl');
-
-class VinylStream extends Readable {
+export default class VinylStream extends Readable {
   constructor(files, opts) {
     super({objectMode: true});
     this._base = path.resolve(opts.base || process.cwd());
@@ -35,26 +33,22 @@ class VinylStream extends Readable {
     this.resume();
   }
 
-  _read() {
+  async _read() {
     if (this._files.length === 0) {
       this.push(null);
       return;
     }
     const filepath = this._files.shift();
     const fullpath = path.resolve(this._base, filepath);
-    fs.readFile(fullpath, (err, data) => {
-      if (err) {
-        this.emit('error', err);
-        return;
-      }
-
+    try {
+      const data = await fs.readFile(fullpath);
       this.push(new File({
         base: this._base,
         path: fullpath,
         contents: data
       }));
-    });
+    } catch (err) {
+      this.emit('error', err);
+    }
   }
-}
-
-module.exports = VinylStream;
+};