refactor: convert some block generators to goog.module (#5762)

* refactor: convert generators/javascript.js to goog.module

* refactor: convert generators/javascript.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/variables.js to goog.module

* refactor: convert generators/dart/variables.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/variables_dynamic.js to goog.module

* refactor: convert generators/dart/variables_dynamic.js to named requires

* refactor: convert generators/dart/text.js to goog.module

* refactor: convert generators/dart/text.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/procedures.js to goog.module

* refactor: convert generators/dart/procedures.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/math.js to goog.module

* refactor: convert generators/dart/math.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/loops.js to goog.module

* refactor: convert generators/dart/loops.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/logic.js to goog.module

* refactor: convert generators/dart/logic.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/lists.js to goog.module

* refactor: convert generators/dart/lists.js to named requires

* chore: run clang-format

* refactor: convert generators/dart/colour.js to goog.module

* refactor: convert generators/dart/colour.js to named requires

* chore: rebuild deps.js

* chore: lint

generators/javascript.js

@@ -6,28 +6,29 @@
 
 /**
  * @fileoverview Helper functions for generating JavaScript for blocks.
- * @suppress {missingRequire|checkTypes|globalThis}
+ * @suppress {checkTypes|globalThis}
  */
 'use strict';
 
-goog.provide('Blockly.JavaScript');
+goog.module('Blockly.JavaScript');
+goog.module.declareLegacyNamespace();
 
-goog.require('Blockly.Generator');
-goog.require('Blockly.Variables');
-goog.require('Blockly.Names');
-goog.require('Blockly.inputTypes');
-goog.require('Blockly.utils.global');
-goog.require('Blockly.utils.object');
-goog.require('Blockly.utils.string');
-goog.requireType('Blockly.Block');
-goog.requireType('Blockly.Workspace');
+const Variables = goog.require('Blockly.Variables');
+const objectUtils = goog.require('Blockly.utils.object');
+const stringUtils = goog.require('Blockly.utils.string');
+const {Block} = goog.requireType('Blockly.Block');
+const {Generator} = goog.require('Blockly.Generator');
+const {globalThis} = goog.require('Blockly.utils.global');
+const {inputTypes} = goog.require('Blockly.inputTypes');
+const {Names, NameType} = goog.require('Blockly.Names');
+const {Workspace} = goog.requireType('Blockly.Workspace');
 
 
 /**
  * JavaScript code generator.
- * @type {!Blockly.Generator}
+ * @type {!Generator}
  */
-Blockly.JavaScript = new Blockly.Generator('JavaScript');
+const JavaScript = new Generator('JavaScript');
 
 /**
  * List of illegal variable names.
@@ -36,7 +37,7 @@ Blockly.JavaScript = new Blockly.Generator('JavaScript');
  * accidentally clobbering a built-in object or function.
  * @private
  */
-Blockly.JavaScript.addReservedWords(
+JavaScript.addReservedWords(
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords
     'break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,in,instanceof,new,return,super,switch,this,throw,try,typeof,var,void,while,with,yield,' +
     'enum,' +
@@ -46,95 +47,95 @@ Blockly.JavaScript.addReservedWords(
     // Magic variable.
     'arguments,' +
     // Everything in the current environment (835 items in Chrome, 104 in Node).
-    Object.getOwnPropertyNames(Blockly.utils.global.globalThis).join(','));
+    Object.getOwnPropertyNames(globalThis).join(','));
 
 /**
  * Order of operation ENUMs.
  * https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence
  */
-Blockly.JavaScript.ORDER_ATOMIC = 0;           // 0 "" ...
-Blockly.JavaScript.ORDER_NEW = 1.1;            // new
-Blockly.JavaScript.ORDER_MEMBER = 1.2;         // . []
-Blockly.JavaScript.ORDER_FUNCTION_CALL = 2;    // ()
-Blockly.JavaScript.ORDER_INCREMENT = 3;        // ++
-Blockly.JavaScript.ORDER_DECREMENT = 3;        // --
-Blockly.JavaScript.ORDER_BITWISE_NOT = 4.1;    // ~
-Blockly.JavaScript.ORDER_UNARY_PLUS = 4.2;     // +
-Blockly.JavaScript.ORDER_UNARY_NEGATION = 4.3; // -
-Blockly.JavaScript.ORDER_LOGICAL_NOT = 4.4;    // !
-Blockly.JavaScript.ORDER_TYPEOF = 4.5;         // typeof
-Blockly.JavaScript.ORDER_VOID = 4.6;           // void
-Blockly.JavaScript.ORDER_DELETE = 4.7;         // delete
-Blockly.JavaScript.ORDER_AWAIT = 4.8;          // await
-Blockly.JavaScript.ORDER_EXPONENTIATION = 5.0; // **
-Blockly.JavaScript.ORDER_MULTIPLICATION = 5.1; // *
-Blockly.JavaScript.ORDER_DIVISION = 5.2;       // /
-Blockly.JavaScript.ORDER_MODULUS = 5.3;        // %
-Blockly.JavaScript.ORDER_SUBTRACTION = 6.1;    // -
-Blockly.JavaScript.ORDER_ADDITION = 6.2;       // +
-Blockly.JavaScript.ORDER_BITWISE_SHIFT = 7;    // << >> >>>
-Blockly.JavaScript.ORDER_RELATIONAL = 8;       // < <= > >=
-Blockly.JavaScript.ORDER_IN = 8;               // in
-Blockly.JavaScript.ORDER_INSTANCEOF = 8;       // instanceof
-Blockly.JavaScript.ORDER_EQUALITY = 9;         // == != === !==
-Blockly.JavaScript.ORDER_BITWISE_AND = 10;     // &
-Blockly.JavaScript.ORDER_BITWISE_XOR = 11;     // ^
-Blockly.JavaScript.ORDER_BITWISE_OR = 12;      // |
-Blockly.JavaScript.ORDER_LOGICAL_AND = 13;     // &&
-Blockly.JavaScript.ORDER_LOGICAL_OR = 14;      // ||
-Blockly.JavaScript.ORDER_CONDITIONAL = 15;     // ?:
-Blockly.JavaScript.ORDER_ASSIGNMENT = 16;      // = += -= **= *= /= %= <<= >>= ...
-Blockly.JavaScript.ORDER_YIELD = 17;           // yield
-Blockly.JavaScript.ORDER_COMMA = 18;           // ,
-Blockly.JavaScript.ORDER_NONE = 99;            // (...)
+JavaScript.ORDER_ATOMIC = 0;            // 0 "" ...
+JavaScript.ORDER_NEW = 1.1;             // new
+JavaScript.ORDER_MEMBER = 1.2;          // . []
+JavaScript.ORDER_FUNCTION_CALL = 2;     // ()
+JavaScript.ORDER_INCREMENT = 3;         // ++
+JavaScript.ORDER_DECREMENT = 3;         // --
+JavaScript.ORDER_BITWISE_NOT = 4.1;     // ~
+JavaScript.ORDER_UNARY_PLUS = 4.2;      // +
+JavaScript.ORDER_UNARY_NEGATION = 4.3;  // -
+JavaScript.ORDER_LOGICAL_NOT = 4.4;     // !
+JavaScript.ORDER_TYPEOF = 4.5;          // typeof
+JavaScript.ORDER_VOID = 4.6;            // void
+JavaScript.ORDER_DELETE = 4.7;          // delete
+JavaScript.ORDER_AWAIT = 4.8;           // await
+JavaScript.ORDER_EXPONENTIATION = 5.0;  // **
+JavaScript.ORDER_MULTIPLICATION = 5.1;  // *
+JavaScript.ORDER_DIVISION = 5.2;        // /
+JavaScript.ORDER_MODULUS = 5.3;         // %
+JavaScript.ORDER_SUBTRACTION = 6.1;     // -
+JavaScript.ORDER_ADDITION = 6.2;        // +
+JavaScript.ORDER_BITWISE_SHIFT = 7;     // << >> >>>
+JavaScript.ORDER_RELATIONAL = 8;        // < <= > >=
+JavaScript.ORDER_IN = 8;                // in
+JavaScript.ORDER_INSTANCEOF = 8;        // instanceof
+JavaScript.ORDER_EQUALITY = 9;          // == != === !==
+JavaScript.ORDER_BITWISE_AND = 10;      // &
+JavaScript.ORDER_BITWISE_XOR = 11;      // ^
+JavaScript.ORDER_BITWISE_OR = 12;       // |
+JavaScript.ORDER_LOGICAL_AND = 13;      // &&
+JavaScript.ORDER_LOGICAL_OR = 14;       // ||
+JavaScript.ORDER_CONDITIONAL = 15;      // ?:
+JavaScript.ORDER_ASSIGNMENT = 16;       // = += -= **= *= /= %= <<= >>= ...
+JavaScript.ORDER_YIELD = 17;            // yield
+JavaScript.ORDER_COMMA = 18;            // ,
+JavaScript.ORDER_NONE = 99;             // (...)
 
 /**
  * List of outer-inner pairings that do NOT require parentheses.
  * @type {!Array<!Array<number>>}
  */
-Blockly.JavaScript.ORDER_OVERRIDES = [
+JavaScript.ORDER_OVERRIDES = [
   // (foo()).bar -> foo().bar
   // (foo())[0] -> foo()[0]
-  [Blockly.JavaScript.ORDER_FUNCTION_CALL, Blockly.JavaScript.ORDER_MEMBER],
+  [JavaScript.ORDER_FUNCTION_CALL, JavaScript.ORDER_MEMBER],
   // (foo())() -> foo()()
-  [Blockly.JavaScript.ORDER_FUNCTION_CALL, Blockly.JavaScript.ORDER_FUNCTION_CALL],
+  [JavaScript.ORDER_FUNCTION_CALL, JavaScript.ORDER_FUNCTION_CALL],
   // (foo.bar).baz -> foo.bar.baz
   // (foo.bar)[0] -> foo.bar[0]
   // (foo[0]).bar -> foo[0].bar
   // (foo[0])[1] -> foo[0][1]
-  [Blockly.JavaScript.ORDER_MEMBER, Blockly.JavaScript.ORDER_MEMBER],
+  [JavaScript.ORDER_MEMBER, JavaScript.ORDER_MEMBER],
   // (foo.bar)() -> foo.bar()
   // (foo[0])() -> foo[0]()
-  [Blockly.JavaScript.ORDER_MEMBER, Blockly.JavaScript.ORDER_FUNCTION_CALL],
+  [JavaScript.ORDER_MEMBER, JavaScript.ORDER_FUNCTION_CALL],
 
   // !(!foo) -> !!foo
-  [Blockly.JavaScript.ORDER_LOGICAL_NOT, Blockly.JavaScript.ORDER_LOGICAL_NOT],
+  [JavaScript.ORDER_LOGICAL_NOT, JavaScript.ORDER_LOGICAL_NOT],
   // a * (b * c) -> a * b * c
-  [Blockly.JavaScript.ORDER_MULTIPLICATION, Blockly.JavaScript.ORDER_MULTIPLICATION],
+  [JavaScript.ORDER_MULTIPLICATION, JavaScript.ORDER_MULTIPLICATION],
   // a + (b + c) -> a + b + c
-  [Blockly.JavaScript.ORDER_ADDITION, Blockly.JavaScript.ORDER_ADDITION],
+  [JavaScript.ORDER_ADDITION, JavaScript.ORDER_ADDITION],
   // a && (b && c) -> a && b && c
-  [Blockly.JavaScript.ORDER_LOGICAL_AND, Blockly.JavaScript.ORDER_LOGICAL_AND],
+  [JavaScript.ORDER_LOGICAL_AND, JavaScript.ORDER_LOGICAL_AND],
   // a || (b || c) -> a || b || c
-  [Blockly.JavaScript.ORDER_LOGICAL_OR, Blockly.JavaScript.ORDER_LOGICAL_OR]
+  [JavaScript.ORDER_LOGICAL_OR, JavaScript.ORDER_LOGICAL_OR]
 ];
 
 /**
  * Whether the init method has been called.
  * @type {?boolean}
  */
-Blockly.JavaScript.isInitialized = false;
+JavaScript.isInitialized = false;
 
 /**
  * Initialise the database of variable names.
- * @param {!Blockly.Workspace} workspace Workspace to generate code from.
+ * @param {!Workspace} workspace Workspace to generate code from.
  */
-Blockly.JavaScript.init = function(workspace) {
+JavaScript.init = function(workspace) {
   // Call Blockly.Generator's init.
   Object.getPrototypeOf(this).init.call(this);
 
   if (!this.nameDB_) {
-    this.nameDB_ = new Blockly.Names(this.RESERVED_WORDS_);
+    this.nameDB_ = new Names(this.RESERVED_WORDS_);
   } else {
     this.nameDB_.reset();
   }
@@ -145,17 +146,16 @@ Blockly.JavaScript.init = function(workspace) {
 
   const defvars = [];
   // Add developer variables (not created or named by the user).
-  const devVarList = Blockly.Variables.allDeveloperVariables(workspace);
+  const devVarList = Variables.allDeveloperVariables(workspace);
   for (let i = 0; i < devVarList.length; i++) {
-    defvars.push(this.nameDB_.getName(devVarList[i],
-        Blockly.Names.DEVELOPER_VARIABLE_TYPE));
+    defvars.push(
+        this.nameDB_.getName(devVarList[i], NameType.DEVELOPER_VARIABLE));
   }
 
   // Add user variables, but only ones that are being used.
-  const variables = Blockly.Variables.allUsedVarModels(workspace);
+  const variables = Variables.allUsedVarModels(workspace);
   for (let i = 0; i < variables.length; i++) {
-    defvars.push(this.nameDB_.getName(variables[i].getId(),
-        Blockly.VARIABLE_CATEGORY_NAME));
+    defvars.push(this.nameDB_.getName(variables[i].getId(), NameType.VARIABLE));
   }
 
   // Declare all of the variables.
@@ -170,9 +170,9 @@ Blockly.JavaScript.init = function(workspace) {
  * @param {string} code Generated code.
  * @return {string} Completed code.
  */
-Blockly.JavaScript.finish = function(code) {
+JavaScript.finish = function(code) {
   // Convert the definitions dictionary into a list.
-  const definitions = Blockly.utils.object.values(this.definitions_);
+  const definitions = objectUtils.values(this.definitions_);
   // Call Blockly.Generator's finish.
   code = Object.getPrototypeOf(this).finish.call(this, code);
   this.isInitialized = false;
@@ -187,7 +187,7 @@ Blockly.JavaScript.finish = function(code) {
  * @param {string} line Line of generated code.
  * @return {string} Legal line of code.
  */
-Blockly.JavaScript.scrubNakedValue = function(line) {
+JavaScript.scrubNakedValue = function(line) {
   return line + ';\n';
 };
 
@@ -198,12 +198,12 @@ Blockly.JavaScript.scrubNakedValue = function(line) {
  * @return {string} JavaScript string.
  * @protected
  */
-Blockly.JavaScript.quote_ = function(string) {
+JavaScript.quote_ = function(string) {
   // Can't use goog.string.quote since Google's style guide recommends
   // JS string literals use single quotes.
   string = string.replace(/\\/g, '\\\\')
-                 .replace(/\n/g, '\\\n')
-                 .replace(/'/g, '\\\'');
+               .replace(/\n/g, '\\\n')
+               .replace(/'/g, '\\\'');
   return '\'' + string + '\'';
 };
 
@@ -214,7 +214,7 @@ Blockly.JavaScript.quote_ = function(string) {
  * @return {string} JavaScript string.
  * @protected
  */
-Blockly.JavaScript.multiline_quote_ = function(string) {
+JavaScript.multiline_quote_ = function(string) {
   // Can't use goog.string.quote since Google's style guide recommends
   // JS string literals use single quotes.
   const lines = string.split(/\n/g).map(this.quote_);
@@ -225,26 +225,26 @@ Blockly.JavaScript.multiline_quote_ = function(string) {
  * Common tasks for generating JavaScript from blocks.
  * Handles comments for the specified block and any connected value blocks.
  * Calls any statements following this block.
- * @param {!Blockly.Block} block The current block.
+ * @param {!Block} block The current block.
  * @param {string} code The JavaScript code created for this block.
  * @param {boolean=} opt_thisOnly True to generate code for only this statement.
  * @return {string} JavaScript code with comments and subsequent blocks added.
  * @protected
  */
-Blockly.JavaScript.scrub_ = function(block, code, opt_thisOnly) {
+JavaScript.scrub_ = function(block, code, opt_thisOnly) {
   let commentCode = '';
   // Only collect comments for blocks that aren't inline.
   if (!block.outputConnection || !block.outputConnection.targetConnection) {
     // Collect comment for this block.
     let comment = block.getCommentText();
     if (comment) {
-      comment = Blockly.utils.string.wrap(comment, this.COMMENT_WRAP - 3);
+      comment = stringUtils.wrap(comment, this.COMMENT_WRAP - 3);
       commentCode += this.prefixLines(comment + '\n', '// ');
     }
     // Collect comments for all value arguments.
     // Don't collect comments for nested statements.
     for (let i = 0; i < block.inputList.length; i++) {
-      if (block.inputList[i].type === Blockly.inputTypes.VALUE) {
+      if (block.inputList[i].type === inputTypes.VALUE) {
         const childBlock = block.inputList[i].connection.targetBlock();
         if (childBlock) {
           comment = this.allNestedComments(childBlock);
@@ -262,15 +262,15 @@ Blockly.JavaScript.scrub_ = function(block, code, opt_thisOnly) {
 
 /**
  * Gets a property and adjusts the value while taking into account indexing.
- * @param {!Blockly.Block} block The block.
+ * @param {!Block} block The block.
  * @param {string} atId The property ID of the element to get.
  * @param {number=} opt_delta Value to add.
  * @param {boolean=} opt_negate Whether to negate the value.
  * @param {number=} opt_order The highest order acting on this value.
  * @return {string|number}
  */
-Blockly.JavaScript.getAdjusted = function(block, atId, opt_delta, opt_negate,
-    opt_order) {
+JavaScript.getAdjusted = function(
+    block, atId, opt_delta, opt_negate, opt_order) {
   let delta = opt_delta || 0;
   let order = opt_order || this.ORDER_NONE;
   if (block.workspace.options.oneBasedIndex) {
@@ -293,7 +293,7 @@ Blockly.JavaScript.getAdjusted = function(block, atId, opt_delta, opt_negate,
 
   let at = this.valueToCode(block, atId, outerOrder) || defaultAtIndex;
 
-  if (Blockly.utils.string.isNumber(at)) {
+  if (stringUtils.isNumber(at)) {
     // If the index is a naked number, adjust it right now.
     at = Number(at) + delta;
     if (opt_negate) {
@@ -321,3 +321,5 @@ Blockly.JavaScript.getAdjusted = function(block, atId, opt_delta, opt_negate,
   }
   return at;
 };
+
+exports = JavaScript;