snowpack-plugin-closure-compiler/util/generators.js

compress your static data in snowpack with the Closure Compiler

const fs = require('fs');
const glob = require('glob');
const { compiler } = require('google-closure-compiler');

module.exports.generateBundle = function (files, config, snowpackOptions, log) {
  // form base path of bundle directory
  const bundleDir = config.mount[config.root + '/src'].url;
  const base = config.root + '/build' + bundleDir;

  // path for intermittent bundle file
  const tempOutputPath = base + '/temp.js';

  // create instance of compiler with user options/defaults
  const instance = new compiler({
    js: files,
    compilation_level: snowpackOptions.compilationLevel || 'SIMPLE',
    js_output_file: tempOutputPath,
    language_in: snowpackOptions.languageIn || 'ECMASCRIPT_NEXT',
    language_out: snowpackOptions.languageOut || 'ECMASCRIPT5',
  });

  // save instance of child process to hang node process
  const compilerProcess = instance.run((exitCode, stdOut, stdErr) => {
    // handle user specified output file
    const writeFilePath =
      base + '/' + (snowpackOptions.outputFile || 'index.js');
    const bundle = fs.readFileSync(tempOutputPath).toString();
    fs.writeFile(writeFilePath, bundle, (err) => {
      // remove older js files
      const deletableFiles = glob.sync(
        config.buildOptions.out +
          `/**/!(${snowpackOptions?.outputFile?.slice(0, -3) || 'index'}).js`
      );
      deletableFiles.forEach((file) => {
        fs.unlinkSync(file, (err) => {
          if (err) log('fs.unlink error');
        });
      });
    });
  });

  // return promise to wait for compiler completion
  return new Promise((res, rej) => {
    compilerProcess.on('exit', res);
    compilerProcess.on('error', rej);
  })
    .then(() => {
      log('closure compiler complete');
    })
    .catch((err) => {
      log('error during compilation', err);
    });
};

module.exports.generateSeparate = function (
  files,
  config,
  snowpackOptions,
  log
) {
  // creates an array of compiler instances for separate file processing
  const compilerInstances = files.map((file, index) => {
    return new compiler({
      js: file,
      compilation_level: snowpackOptions.compilationLevel || 'SIMPLE',
      language_in: snowpackOptions.languageIn || 'ECMASCRIPT_NEXT',
      language_out: snowpackOptions.languageOut || 'ECMASCRIPT5',
    });
  });

  // create an array of promises to feed as argument to Promise.all
  const processPromises = compilerInstances.map((instance, index) => {
    // save instance of child process to hang node process
    const compilerProcess = instance.run((exitCode, stdOut, stdErr) => {
      // handle user specified output file
      // grab from compiler instance
      const inputFile = instance.commandArguments
        .filter((arg) => {
          return arg.startsWith('--js');
        })[0]
        .slice(5);
      // overwrite the current file with stdOut from process
      fs.writeFile(inputFile, stdOut, (err) => {
        if (err) log(err);
      });
    });

    // return promise to wait for compiler completion
    return new Promise((res, rej) => {
      compilerProcess.on('exit', res);
      compilerProcess.on('error', rej);
    });
  });

  return Promise.all(processPromises)
    .then((exitCodes) => {
      log('closure compiler complete');
      log('exit codes', exitCodes);
    })
    .catch((err) => {
      log('error during compilation', err);
    });
};