/**
 * @license
 * Copyright 2018 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @fileoverview Gulp script to build Blockly for Node & NPM.
 */

import * as gulp from 'gulp';
import replace from 'gulp-replace';
import rename from 'gulp-rename';
import sourcemaps from 'gulp-sourcemaps';

import * as path from 'path';
import * as fs from 'fs';
import * as fsPromises from 'fs/promises';
import {exec, execSync} from 'child_process';

import {globSync} from 'glob';
import {gulp as closureCompiler} from 'google-closure-compiler';
import yargs from 'yargs';
import {hideBin} from 'yargs/helpers';
import {rimraf} from 'rimraf';

import {BUILD_DIR, LANG_BUILD_DIR, RELEASE_DIR, TSC_OUTPUT_DIR, TYPINGS_BUILD_DIR} from './config.mjs';
import {getPackageJson} from './helper_tasks.mjs';

import {posixPath, quote} from '../helpers.js';

const argv = yargs(hideBin(process.argv)).parse();

////////////////////////////////////////////////////////////
//                        Build                           //
////////////////////////////////////////////////////////////

/**
 * Path to the python runtime.
 * This will normalize the command across platforms (e.g. python3 on Linux and
 * Mac, python on Windows).
 */
const PYTHON = process.platform === 'win32' ? 'python' : 'python3';

/**
 * Posix version of TSC_OUTPUT_DIR
 */
const TSC_OUTPUT_DIR_POSIX = posixPath(TSC_OUTPUT_DIR);

/**
 * Suffix to add to compiled output files.
 */
const COMPILED_SUFFIX = '_compressed';

/**
 * Name of an object to be used as a shared "global" namespace by
 * chunks generated by the Closure Compiler with the
 * --rename_prefix_namespace option (see
 * https://github.com/google/closure-compiler/wiki/Chunk-output-for-dynamic-loading#using-global_namespace-as-the-chunk-output-type
 * for more information.)  The wrapper for the first chunk will create
 * an object with this name and save it; wrappers for other chunks
 * will ensure that the same object is available with this same name.
 * The --rename_prefix_namespace option will then cause the compiled
 * chunks to create properties on this object instead of creating
 * "global" (really chunk-local) variables.  This allows later chunks
 * to depend upon modules from earlier chunks.
 *
 * It can be any value that doesn't clash with a global variable or
 * wrapper argument, but as it will appear many times in the compiled
 * output it is preferable that it be short.
 */
const NAMESPACE_VARIABLE = '$';

/**
 * Property that will be used to store the value of the namespace
 * object on each chunk's exported object.  This is so that dependent
 * chunks can retrieve the namespace object and thereby access modules
 * defined in the parent chunk (or it's parent, etc.).  This should be
 * chosen so as to not collide with any exported name.
 */
const NAMESPACE_PROPERTY = '__namespace__';

/**
 * A list of chunks.  Order matters: later chunks can depend on
 * earlier ones, but not vice-versa.  All chunks are assumed to depend
 * on the first chunk.  Properties are as follows:
 *
 * - .name: the name of the chunk.  Used to label it when describing
 *   it to Closure Compiler and forms the prefix of filename the chunk
 *   will be written to.
 * - .files: A glob or array of globs, relative to TSC_OUTPUT_DIR,
 *   matching the files to include in the chunk.
 * - .entry: the source .js file which is the entrypoint for the
 *   chunk, relative to TSC_OUTPUT_DIR.
 * - .scriptExport: When the chunk is loaded as a script (e.g., via a
 *   <SCRIPT> tag), the chunk's exports object will be made available
 *   at the specified location (which must be a variable name or the
 *   name of a property on an already-existing object) in the global
 *   namespace.
 * - .scriptNamedExports: A map of {location: namedExport} pairs; when
 *   loaded as a script, the specified named exports will be saved at
 *   the specified locations (which again must be global variables or
 *   properties on already-existing objects).  Optional.
 * - .parent: the parent chunk of the given chunk; null for the root
 *   chunk.
 *
 * Output files will be named <chunk.name><COMPILED_SUFFIX>.js.
 */
const chunks = [
  {
    name: 'blockly',
    files: 'core/**/*.js',
    entry: 'core/blockly.js',
    scriptExport: 'Blockly',
  },
  {
    name: 'blocks',
    files: 'blocks/**/*.js',
    entry: 'blocks/blocks.js',
    scriptExport: 'Blockly.libraryBlocks',
  },
  {
    name: 'javascript',
    files: ['generators/javascript.js', 'generators/javascript/**/*.js'],
    entry: 'generators/javascript.js',
    scriptExport: 'javascript',
    scriptNamedExports: {'Blockly.JavaScript': 'javascriptGenerator'},
  },
  {
    name: 'python',
    files: ['generators/python.js', 'generators/python/**/*.js'],
    entry: 'generators/python.js',
    scriptExport: 'python',
    scriptNamedExports: {'Blockly.Python': 'pythonGenerator'},
  },
  {
    name: 'php',
    files: ['generators/php.js', 'generators/php/**/*.js'],
    entry: 'generators/php.js',
    scriptExport: 'php',
    scriptNamedExports: {'Blockly.PHP': 'phpGenerator'},
  },
  {
    name: 'lua',
    files: ['generators/lua.js', 'generators/lua/**/*.js'],
    entry: 'generators/lua.js',
    scriptExport: 'lua',
    scriptNamedExports: {'Blockly.Lua': 'luaGenerator'},
  },
  {
    name: 'dart',
    files: ['generators/dart.js', 'generators/dart/**/*.js'],
    entry: 'generators/dart.js',
    scriptExport: 'dart',
    scriptNamedExports: {'Blockly.Dart': 'dartGenerator'},
  },
];

chunks[0].parent = null;
for (let i = 1; i < chunks.length; i++) {
  chunks[i].parent = chunks[0];
}

/**
 * Return the name of the module object for the entrypoint of the given chunk,
 * as munged by Closure Compiler.
 */
function modulePath(chunk) {
  const entryPath = path.posix.join(TSC_OUTPUT_DIR_POSIX, chunk.entry);
  return 'module$' + entryPath.replace(/\.js$/, '').replaceAll('/', '$');
}

const licenseRegex = `\\/\\*\\*
 \\* @license
 \\* (Copyright \\d+ (Google LLC|Massachusetts Institute of Technology))
( \\* All rights reserved.
)? \\* SPDX-License-Identifier: Apache-2.0
 \\*\\/`;

/**
 * Helper method for stripping the Google's and MIT's Apache Licenses.
 */
function stripApacheLicense() {
  // Strip out Google's and MIT's Apache licences.
  // Closure Compiler preserves dozens of Apache licences in the Blockly code.
  // Remove these if they belong to Google or MIT.
  // MIT's permission to do this is logged in Blockly issue #2412.
  return replace(new RegExp(licenseRegex, 'g'), '\n\n\n\n');
  // Replace with the same number of lines so that source-maps are not affected.
}

/**
 * Closure Compiler diagnostic groups we want to be treated as errors.
 * These are effected when the --debug or --strict flags are passed.
 * For a full list of Closure Compiler groups, consult the output of
 * google-closure-compiler --help or look in the source  here:
 * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/DiagnosticGroups.java#L117
 *
 * The list in JSCOMP_ERROR contains all the diagnostic groups we know
 * about, but some are commented out if we don't want them, and may
 * appear in JSCOMP_WARNING or JSCOMP_OFF instead.  Items not
 * appearing on any list will default to setting provided by the
 * compiler, which may vary depending on compilation level.
 */
const JSCOMP_ERROR = [
  // 'accessControls',  // Deprecated; means same as visibility.
  // 'checkPrototypalTypes',  // override annotations are stripped by tsc.
  'checkRegExp',
  // 'checkTypes',  // Disabled; see note in JSCOMP_OFF.
  'checkVars',
  'conformanceViolations',
  'const',
  'constantProperty',
  'duplicateMessage',
  'es5Strict',
  'externsValidation',
  'extraRequire',  // Undocumented but valid.
  'functionParams',
  // 'globalThis',  // This types are stripped by tsc.
  'invalidCasts',
  'misplacedTypeAnnotation',
  // 'missingOverride',  // There are many of these, which should be fixed.
  'missingPolyfill',
  // 'missingProperties',  // Unset static properties are stripped by tsc.
  'missingProvide',
  'missingRequire',
  'missingReturn',
  // 'missingSourcesWarnings',  // Group of several other options.
  'moduleLoad',
  'msgDescriptions',
  // 'nonStandardJsDocs',  // Disabled; see note in JSCOMP_OFF.
  // 'partialAlias',  // Don't want this to be an error yet; only warning.
  // 'polymer',  // Not applicable.
  // 'reportUnknownTypes',  // VERY verbose.
  // 'strictCheckTypes',  // Use --strict to enable.
  // 'strictMissingProperties',  // Part of strictCheckTypes.
  'strictModuleChecks',  // Undocumented but valid.
  'strictModuleDepCheck',
  // 'strictPrimitiveOperators',  // Part of strictCheckTypes.
  'suspiciousCode',
  'typeInvalidation',
  'undefinedVars',
  'underscore',
  'unknownDefines',
  // 'unusedLocalVariables',  // Disabled; see note in JSCOMP_OFF.
  'uselessCode',
  'untranspilableFeatures',
  // 'visibility',  // Disabled; see note in JSCOMP_OFF.
];

/**
 * Closure Compiler diagnostic groups we want to be treated as warnings.
 * These are effected when the --debug or --strict flags are passed.
 *
 * For most (all?) diagnostic groups this is the default level, so
 * it's generally sufficient to remove them from JSCOMP_ERROR.
 */
const JSCOMP_WARNING = [
  'deprecated',
  'deprecatedAnnotations',
];

/**
 * Closure Compiler diagnostic groups we want to be ignored.  These
 * suppressions are always effected by default.
 *
 * Make sure that anything added here is commented out of JSCOMP_ERROR
 * above, as that takes precedence.)
 */
const JSCOMP_OFF = [
  /* The removal of Closure type system types from our JSDoc
   * annotations means that the Closure Compiler now generates certain
   * diagnostics because it no longer has enough information to be
   * sure that the input code is correct.  The following diagnostic
   * groups are turned off to suppress such errors.
   *
   * When adding additional items to this list it may be helpful to
   * search the compiler source code
   * (https://github.com/google/closure-compiler/) for the JSC_*
   * diagnostic name (omitting the JSC_ prefix) to find the corresponding
   * DiagnosticGroup.
   */
  'checkTypes',
  'nonStandardJsDocs',  // Due to @internal
  'unusedLocalVariables',  // Due to code generated for merged namespaces.

  /* In order to transition to ES modules, modules will need to import
   * one another by relative paths. This means that the previous
   * practice of moving all source files into the same directory for
   * compilation would break imports.
   *
   * Not flattening files in this way breaks our usage
   * of @package however: files were flattened so that all Blockly
   * source files are in the same directory and can use @package to
   * mark methods that are only allowed for use by Blockly, while
   * still allowing access between e.g. core/events/* and
   * core/utils/*. We were downgrading access control violations
   * (including @private) to warnings, but this ends up being so
   * spammy that it makes the compiler output nearly useless.
   *
   * Once ES module migration is complete, they will be re-enabled and
   * an alternative to @package will be established.
   */
  'visibility',
];

/**
 * Builds Blockly as a JS program, by running tsc on all the files in
 * the core directory.
 */
export function tsc(done) {
  execSync(
      `tsc -outDir "${TSC_OUTPUT_DIR}" -declarationDir "${TYPINGS_BUILD_DIR}"`,
      {stdio: 'inherit'});
  execSync(`node scripts/tsick.js "${TSC_OUTPUT_DIR}"`, {stdio: 'inherit'});
  done();
}

/**
 * This task regenerates msg/json/en.js and msg/json/qqq.js from
 * msg/messages.js.
 */
export function messages(done) {
  // Run js_to_json.py
  const jsToJsonCmd = `${PYTHON} scripts/i18n/js_to_json.py \
      --input_file ${path.join('msg', 'messages.js')} \
      --output_dir ${path.join('msg', 'json')} \
      --quiet`;
  execSync(jsToJsonCmd, {stdio: 'inherit'});

  console.log(`
Regenerated several flies in msg/json/.  Now run

    git diff msg/json/*.json

and check that operation has not overwritten any modifications made to
hints, etc. by the TranslateWiki volunteers.  If it has, backport
their changes to msg/messages.js and re-run 'npm run messages'.

Once you are satisfied that any new hints have been backported you may
go ahead and commit the changes, but note that the messages script
will have removed the translator credits - be careful not to commit
this removal!
`);

  done();
}

var languages = null;

/**
 * Get list of languages to build langfiles and/or shims for, based on .json
 * files in msg/json/, skipping certain entries that do not correspond to an
 * actual language).  Results are cached as this is called from both
 * buildLangfiles and buildLangfileShims.
 */
function getLanguages() {
  if (!languages) {
    const skip = /^(keys|synonyms|qqq|constants)\.json$/;
    languages = fs.readdirSync(path.join('msg', 'json'))
        .filter(file => file.endsWith('json') && !skip.test(file))
        .map(file => file.replace(/\.json$/, ''));
  }
  return languages;
}

/**
 * This task builds Blockly's lang files.
 *     msg/*.js
 */
function buildLangfiles(done) {
  // Create output directory.
  fs.mkdirSync(LANG_BUILD_DIR, {recursive: true});

  // Run create_messages.py.
  const inputFiles = getLanguages().map(
      lang => path.join('msg', 'json', `${lang}.json`));

  const createMessagesCmd = `${PYTHON} ./scripts/i18n/create_messages.py \
  --source_lang_file ${path.join('msg', 'json', 'en.json')} \
  --source_synonym_file ${path.join('msg', 'json', 'synonyms.json')} \
  --source_constants_file ${path.join('msg', 'json', 'constants.json')} \
  --key_file ${path.join('msg', 'json', 'keys.json')} \
  --output_dir ${LANG_BUILD_DIR} \
  --quiet ${inputFiles.join(' ')}`;
  execSync(createMessagesCmd, {stdio: 'inherit'});

  done();
}

/**
 * A helper method to return an Closure Compiler chunk wrapper that
 * wraps the compiler output for the given chunk in a Universal Module
 * Definition.
 */
function chunkWrapper(chunk) {
  // Each chunk can have only a single dependency, which is its parent
  // chunk.  It is used only to retrieve the namespace object, which
  // is saved on to the exports object for the chunk so that any child
  // chunk(s) can obtain it.

  // JavaScript expressions for the amd, cjs and browser dependencies.
  let amdDepsExpr = '';
  let cjsDepsExpr = '';
  let scriptDepsExpr = '';
  // Arguments for the factory function.
  let factoryArgs = '';
  // Expression to get or create the namespace object.
  let namespaceExpr = `{}`;

  if (chunk.parent) {
    const parentFilename =
        JSON.stringify(`./${chunk.parent.name}${COMPILED_SUFFIX}.js`);
    amdDepsExpr = parentFilename;
    cjsDepsExpr = `require(${parentFilename})`;
    scriptDepsExpr = `root.${chunk.parent.scriptExport}`;
    factoryArgs = '__parent__';
    namespaceExpr = `${factoryArgs}.${NAMESPACE_PROPERTY}`;
  }

  // Code to save the chunk's exports object at chunk.scriptExport and
  // additionally save individual named exports as directed by
  // chunk.scriptNamedExports.
  const scriptExportStatements = [
    `root.${chunk.scriptExport} = factory(${scriptDepsExpr});`,
  ];
  for (var location in chunk.scriptNamedExports) {
    const namedExport = chunk.scriptNamedExports[location];
    scriptExportStatements.push( 
      `root.${location} = root.${chunk.scriptExport}.${namedExport};`);
  }

  // Note that when loading in a browser the base of the exported path
  // (e.g. Blockly.blocks.all - see issue #5932) might not exist
  // before factory has been executed, so calling factory() and
  // assigning the result are done in separate statements to ensure
  // they are sequenced correctly.
  return `// Do not edit this file; automatically generated.

/* eslint-disable */
;(function(root, factory) {
  if (typeof define === 'function' && define.amd) { // AMD
    define([${amdDepsExpr}], factory);
  } else if (typeof exports === 'object') { // Node.js
    module.exports = factory(${cjsDepsExpr});
  } else { // Script
    ${scriptExportStatements.join('\n    ')}
  }
}(this, function(${factoryArgs}) {
var ${NAMESPACE_VARIABLE}=${namespaceExpr};
%output%
${modulePath(chunk)}.${NAMESPACE_PROPERTY}=${NAMESPACE_VARIABLE};
return ${modulePath(chunk)};
}));
`;
}

/**
 * Compute the chunking options to pass to Closure Compiler.  Output
 * is in the form:
 *
 * {
 *   "chunk": [
 *     "blockly:286",
 *     "blocks:10:blockly",
 *     "javascript:11:blockly",
 *     // ... one per chunk
 *   ],
 *   "js": [
 *     "build/src/core/any_aliases.js",
 *     "build/src/core/block.js",
 *     "build/src/core/block_animations.js",
 *     // ... many more files, in order by chunk
 *   ],
 *   "chunk_wrapper": [
 *     "blockly:// Do not edit this file...",
 *     "blocks:// Do not edit this file...",
 *     // ... one per chunk
 *   ]
 * }
 *
 * This is designed to be passed directly as-is as the options object
 * to the Closure Compiler node API, and be compatible with that
 * emitted by closure-calculate-chunks.
 *
 * @return {{chunk: !Array<string>,
 *           js: !Array<string>,
 *           chunk_wrapper: !Array<string>}}
 *     The chunking options, in the format described above.
 */
function getChunkOptions() {
  const chunkOptions = [];
  const allFiles = [];

  for (const chunk of chunks) {
    const globs = typeof chunk.files === 'string' ? [chunk.files] : chunk.files;
    const files = globs
      .flatMap((glob) => globSync(glob, {cwd: TSC_OUTPUT_DIR_POSIX}))
      .map((file) => path.posix.join(TSC_OUTPUT_DIR_POSIX, file));
    chunkOptions.push(
      `${chunk.name}:${files.length}` +
        (chunk.parent ? `:${chunk.parent.name}` : ''),
    );
    allFiles.push(...files);
  }

  const chunkWrappers = chunks.map(
    (chunk) => `${chunk.name}:${chunkWrapper(chunk)}`,
  );

  return {chunk: chunkOptions, js: allFiles, chunk_wrapper: chunkWrappers};
}

/**
 * RegExp that globally matches path.sep (i.e., "/" or "\").
 */
const pathSepRegExp = new RegExp(path.sep.replace(/\\/, '\\\\'), 'g');

/**
 * Helper method for calling the Closure Compiler, establishing
 * default options (that can be overridden by the caller).
 * @param {*} options Caller-supplied options that will override the
 *     defaultOptions.
 */
function compile(options) {
  const defaultOptions = {
    compilation_level: 'SIMPLE_OPTIMIZATIONS',
    warning_level: argv.verbose ? 'VERBOSE' : 'DEFAULT',
    language_in: 'ECMASCRIPT_2020',
    language_out: 'ECMASCRIPT_2015',
    jscomp_off: [...JSCOMP_OFF],
    rewrite_polyfills: true,
    hide_warnings_for: [
      'node_modules',
    ],
    define: ['COMPILED=true'],
  };
  if (argv.debug || argv.strict) {
    defaultOptions.jscomp_error = [...JSCOMP_ERROR];
    defaultOptions.jscomp_warning = [...JSCOMP_WARNING];
    if (argv.strict) {
      defaultOptions.jscomp_error.push('strictCheckTypes');
    }
  }
  // Extra options for Closure Compiler gulp plugin.
  const platform = ['native', 'java', 'javascript'];

  return closureCompiler({...defaultOptions, ...options}, {platform});
}

/**
 * This task compiles the core library, blocks and generators, creating
 * blockly_compressed.js, blocks_compressed.js, etc.
 */
function buildCompiled() {
  // Get chunking.
  const chunkOptions = getChunkOptions();
  // Closure Compiler options.
  const packageJson = getPackageJson();  // For version number.
  const options = {
    // The documentation for @define claims you can't use it on a
    // non-global, but the Closure Compiler turns everything in to a
    // global - you just have to know what the new name is!  With
    // declareLegacyNamespace this was very straightforward.  Without
    // it, we have to rely on implmentation details.  See
    // https://github.com/google/closure-compiler/issues/1601#issuecomment-483452226
    define: `VERSION$$${modulePath(chunks[0])}='${packageJson.version}'`,
    chunk: chunkOptions.chunk,
    chunk_wrapper: chunkOptions.chunk_wrapper,
    rename_prefix_namespace: NAMESPACE_VARIABLE,
    // Don't supply the list of source files in chunkOptions.js as an
    // option to Closure Compiler; instead feed them as input via gulp.src.
  };

  // Fire up compilation pipline.
  return gulp.src(chunkOptions.js, {base: './'})
      .pipe(stripApacheLicense())
      .pipe(sourcemaps.init())
      .pipe(compile(options))
      .pipe(rename({suffix: COMPILED_SUFFIX}))
      .pipe(sourcemaps.write('.'))
      .pipe(gulp.dest(RELEASE_DIR));
}

/**
 * This task builds the ESM wrappers used by the chunk "import"
 * entrypoints declared in package.json.
 *
 * Also builds the shims used by the playgrounds and tests to
 * load Blockly in either compressed or uncompressed mode, creating
 * build/blockly.loader.mjs, blocks.loader.mjs, javascript.loader.mjs,
 * etc.
 *
 * Prerequisite: getChunkOptions (via buildCompiled, for chunks[].parent).
 */
async function buildShims() {
  // Install a package.json file in BUILD_DIR to tell node.js that the
  // .js files therein are ESM not CJS, so we can import the
  // entrypoints to enumerate their exported names.
  const TMP_PACKAGE_JSON = path.join(BUILD_DIR, 'package.json');
  await fsPromises.writeFile(TMP_PACKAGE_JSON, '{"type": "module"}');

  await Promise.all(chunks.map(async (chunk) => {
    // Import chunk entrypoint to get names of exports for chunk.
    const entryPath = path.posix.join(TSC_OUTPUT_DIR_POSIX, chunk.entry);
    const exportedNames = Object.keys(await import(`../../${entryPath}`));

    // Write an ESM wrapper that imports the CJS module and re-exports
    // its named exports.
    const cjsPath = `./${chunk.name}${COMPILED_SUFFIX}.js`;
    const wrapperPath = path.join(RELEASE_DIR, `${chunk.name}.mjs`);
    const importName = chunk.scriptExport.replace(/.*\./, '');

    await fsPromises.writeFile(wrapperPath,
        `import ${importName} from '${cjsPath}';
export const {
${exportedNames.map((name) => `  ${name},`).join('\n')}
} = ${importName};
`);

    // For first chunk, write an additional ESM wrapper for 'blockly'
    // entrypoint since it has the same exports as 'blockly/core'.
    if (chunk.name === 'blockly') {
      await fsPromises.writeFile(path.join(RELEASE_DIR, `index.mjs`),
          `import Blockly from './index.js';
export const {
${exportedNames.map((name) => `  ${name},`).join('\n')}
} = Blockly;
`);
    }

    // Write a loading shim that uses loadChunk to either import the
    // chunk's entrypoint (e.g. build/src/core/blockly.js) or load the
    // compressed chunk (e.g. dist/blockly_compressed.js) as a script.
    const scriptPath =
        path.posix.join(RELEASE_DIR, `${chunk.name}${COMPILED_SUFFIX}.js`);
    const shimPath = path.join(BUILD_DIR, `${chunk.name}.loader.mjs`);
    const parentImport =
        chunk.parent ?
        `import ${quote(`./${chunk.parent.name}.loader.mjs`)};` :
        '';

    await fsPromises.writeFile(shimPath,
        `import {loadChunk} from '../tests/scripts/load.mjs';
${parentImport}

export const {
${exportedNames.map((name) => `  ${name},`).join('\n')}
} = await loadChunk(
  ${quote(entryPath)},
  ${quote(scriptPath)},
  ${quote(chunk.scriptExport)},
);
`);
  }));

  await fsPromises.rm(TMP_PACKAGE_JSON);
}

/**
 * This task builds the ESM wrappers used by the langfiles "import"
 * entrypoints declared in package.json.
 */
async function buildLangfileShims() {
  // Create output directory.
  fs.mkdirSync(path.join(RELEASE_DIR, 'msg'), {recursive: true});

  // Get the names of the exports from the langfile by require()ing
  // msg/messages.js and letting it mutate the (global) Blockly.Msg.
  // (We have to do it this way because messages.js is a script and
  // not a CJS module with exports.)
  globalThis.Blockly = {Msg: {}};
  await import('../../msg/messages.js');
  const exportedNames = Object.keys(globalThis.Blockly.Msg);
  delete globalThis.Blockly;

  await Promise.all(getLanguages().map(async (lang) => {
    // Write an ESM wrapper that imports the CJS module and re-exports
    // its named exports.
    const cjsPath = `./${lang}.js`;
    const wrapperPath = path.join(RELEASE_DIR, 'msg', `${lang}.mjs`);
    const safeLang = lang.replace(/-/g, '_');

    await fsPromises.writeFile(wrapperPath,
        `import ${safeLang} from '${cjsPath}';
export const {
${exportedNames.map((name) => `  ${name},`).join('\n')}
} = ${safeLang};
`);
  }));
}

/**
 * This task uses Closure Compiler's ADVANCED_COMPILATION mode to
 * compile together Blockly core, blocks and generators with a simple
 * test app; the purpose is to verify that Blockly is compatible with
 * the ADVANCED_COMPILATION mode.
 *
 * Prerequisite: buildJavaScript.
 */
function compileAdvancedCompilationTest() {
  // If main_compressed.js exists (from a previous run) delete it so that
  // a later browser-based test won't check it should the compile fail.
  try {
    fs.unlinkSync('./tests/compile/main_compressed.js');
  } catch {
    // Probably it didn't exist.
  }

  const srcs = [
    TSC_OUTPUT_DIR + '/**/*.js',
    'tests/compile/main.js',
    'tests/compile/test_blocks.js',
  ];

  // Closure Compiler options.
  const options = {
    dependency_mode: 'PRUNE',
    compilation_level: 'ADVANCED_OPTIMIZATIONS',
    entry_point: './tests/compile/main.js',
    js_output_file: 'main_compressed.js',
  };
  return gulp.src(srcs, {base: './'})
      .pipe(stripApacheLicense())
      .pipe(sourcemaps.init())
      .pipe(compile(options))
      .pipe(sourcemaps.write(
          '.', {includeContent: false, sourceRoot: '../../'}))
      .pipe(gulp.dest('./tests/compile/'));
}

/**
 * This task cleans the build directory (by deleting it).
 */
export function cleanBuildDir() {
  // Sanity check.
  if (BUILD_DIR === '.' || BUILD_DIR === '/') {
    return Promise.reject(`Refusing to rm -rf ${BUILD_DIR}`);
  }
  return rimraf(BUILD_DIR);
}

// Main sequence targets.  Each should invoke any immediate prerequisite(s).
// function cleanBuildDir, above
export const langfiles = gulp.parallel(buildLangfiles, buildLangfileShims);
export const minify = gulp.series(tsc, buildCompiled, buildShims);
// function tsc, above
export const build = gulp.parallel(minify, langfiles);

// Manually-invokable targets, with prerequisites where required.
// function messages, above
export const buildAdvancedCompilationTest =
    gulp.series(tsc, compileAdvancedCompilationTest);