blockly 8.0.4-beta.0 → 8.0.5-beta.0

package/core/{variables.js → variables.ts}

@@ -7,24 +7,23 @@
 /**
  * @fileoverview Utility functions for handling variables.
  */
-'use strict';
 
 /**
  * Utility functions for handling variables.
  * @namespace Blockly.Variables
  */
-goog.module('Blockly.Variables');
-
-const Xml = goog.require('Blockly.Xml');
-const dialog = goog.require('Blockly.dialog');
-const utilsXml = goog.require('Blockly.utils.xml');
-const {Blocks} = goog.require('Blockly.blocks');
-const {Msg} = goog.require('Blockly.Msg');
-const {VariableModel} = goog.require('Blockly.VariableModel');
-/* eslint-disable-next-line no-unused-vars */
-const {Workspace} = goog.requireType('Blockly.Workspace');
-/* eslint-disable-next-line no-unused-vars */
-const {WorkspaceSvg} = goog.requireType('Blockly.WorkspaceSvg');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Variables');
+
+import {Blocks} from './blocks.js';
+import * as dialog from './dialog.js';
+import {Msg} from './msg.js';
+import * as utilsXml from './utils/xml.js';
+import {VariableModel} from './variable_model.js';
+import type {Workspace} from './workspace.js';
+import type {WorkspaceSvg} from './workspace_svg.js';
+import * as Xml from './xml.js';
+
 
 /**
  * String for use in the "custom" attribute of a category in toolbox XML.
@@ -32,25 +31,23 @@ const {WorkspaceSvg} = goog.requireType('Blockly.WorkspaceSvg');
  * variable blocks.
  * See also Blockly.Procedures.CATEGORY_NAME and
  * Blockly.VariablesDynamic.CATEGORY_NAME.
- * @const {string}
  * @alias Blockly.Variables.CATEGORY_NAME
  */
-const CATEGORY_NAME = 'VARIABLE';
-exports.CATEGORY_NAME = CATEGORY_NAME;
+export const CATEGORY_NAME = 'VARIABLE';
 
 /**
  * Find all user-created variables that are in use in the workspace.
  * For use by generators.
  * To get a list of all variables on a workspace, including unused variables,
  * call Workspace.getAllVariables.
- * @param {!Workspace} ws The workspace to search for variables.
- * @return {!Array<!VariableModel>} Array of variable models.
+ * @param ws The workspace to search for variables.
+ * @return Array of variable models.
  * @alias Blockly.Variables.allUsedVarModels
  */
-const allUsedVarModels = function(ws) {
+export function allUsedVarModels(ws: Workspace): VariableModel[] {
   const blocks = ws.getAllBlocks(false);
-  const variableHash = Object.create(null);
-  // Iterate through every block and add each variable to the hash.
+  const variables = new Set<VariableModel>();
+  // Iterate through every block and add each variable to the set.
   for (let i = 0; i < blocks.length; i++) {
     const blockVariables = blocks[i].getVarModels();
     if (blockVariables) {
@@ -58,24 +55,16 @@ const allUsedVarModels = function(ws) {
         const variable = blockVariables[j];
         const id = variable.getId();
         if (id) {
-          variableHash[id] = variable;
+          variables.add(variable);
         }
       }
     }
   }
-  // Flatten the hash into a list.
-  const variableList = [];
-  for (const id in variableHash) {
-    variableList.push(variableHash[id]);
-  }
-  return variableList;
-};
-exports.allUsedVarModels = allUsedVarModels;
+  // Convert the set into a list.
+  return Array.from(variables.values());
+}
 
-/**
- * @type {Object<string,boolean>}
- */
-const ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE = {};
+const ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE: {[key: string]: boolean} = {};
 
 /**
  * Find all developer variables used by blocks in the workspace.
@@ -84,19 +73,20 @@ const ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE = {};
  * To declare developer variables, define the getDeveloperVariables function on
  * your block and return a list of variable names.
  * For use by generators.
- * @param {!Workspace} workspace The workspace to search.
- * @return {!Array<string>} A list of non-duplicated variable names.
+ * @param workspace The workspace to search.
+ * @return A list of non-duplicated variable names.
  * @alias Blockly.Variables.allDeveloperVariables
  */
-const allDeveloperVariables = function(workspace) {
+export function allDeveloperVariables(workspace: Workspace): string[] {
   const blocks = workspace.getAllBlocks(false);
-  const variableHash = Object.create(null);
-  for (let i = 0, block; (block = blocks[i]); i++) {
+  const variables = new Set<string>();
+  for (let i = 0, block; block = blocks[i]; i++) {
     let getDeveloperVariables = block.getDeveloperVariables;
-    if (!getDeveloperVariables && block.getDeveloperVars) {
+    if (!getDeveloperVariables &&
+        (block as AnyDuringMigration).getDeveloperVars) {
       // August 2018: getDeveloperVars() was deprecated and renamed
       // getDeveloperVariables().
-      getDeveloperVariables = block.getDeveloperVars;
+      getDeveloperVariables = (block as AnyDuringMigration).getDeveloperVars;
       if (!ALL_DEVELOPER_VARS_WARNINGS_BY_BLOCK_TYPE[block.type]) {
         console.warn(
             'Function getDeveloperVars() deprecated. Use ' +
@@ -107,48 +97,50 @@ const allDeveloperVariables = function(workspace) {
     if (getDeveloperVariables) {
       const devVars = getDeveloperVariables();
       for (let j = 0; j < devVars.length; j++) {
-        variableHash[devVars[j]] = true;
+        variables.add(devVars[j]);
       }
     }
   }
-
-  // Flatten the hash into a list.
-  return Object.keys(variableHash);
-};
-exports.allDeveloperVariables = allDeveloperVariables;
+  // Convert the set into a list.
+  return Array.from(variables.values());
+}
 
 /**
  * Construct the elements (blocks and button) required by the flyout for the
  * variable category.
- * @param {!WorkspaceSvg} workspace The workspace containing variables.
- * @return {!Array<!Element>} Array of XML elements.
+ * @param workspace The workspace containing variables.
+ * @return Array of XML elements.
  * @alias Blockly.Variables.flyoutCategory
  */
-const flyoutCategory = function(workspace) {
-  let xmlList = [];
+export function flyoutCategory(workspace: WorkspaceSvg): Element[] {
+  let xmlList = new Array<Element>();
   const button = document.createElement('button');
   button.setAttribute('text', '%{BKY_NEW_VARIABLE}');
   button.setAttribute('callbackKey', 'CREATE_VARIABLE');
 
   workspace.registerButtonCallback('CREATE_VARIABLE', function(button) {
-    createVariableButtonHandler(button.getTargetWorkspace());
+    // AnyDuringMigration because:  Argument of type 'WorkspaceSvg' is not
+    // assignable to parameter of type 'Workspace'.
+    createVariableButtonHandler(
+        button.getTargetWorkspace() as AnyDuringMigration);
   });
 
   xmlList.push(button);
 
-  const blockList = flyoutCategoryBlocks(workspace);
+  // AnyDuringMigration because:  Argument of type 'WorkspaceSvg' is not
+  // assignable to parameter of type 'Workspace'.
+  const blockList = flyoutCategoryBlocks(workspace as AnyDuringMigration);
   xmlList = xmlList.concat(blockList);
   return xmlList;
-};
-exports.flyoutCategory = flyoutCategory;
+}
 
 /**
  * Construct the blocks required by the flyout for the variable category.
- * @param {!Workspace} workspace The workspace containing variables.
- * @return {!Array<!Element>} Array of XML block elements.
+ * @param workspace The workspace containing variables.
+ * @return Array of XML block elements.
  * @alias Blockly.Variables.flyoutCategoryBlocks
  */
-const flyoutCategoryBlocks = function(workspace) {
+export function flyoutCategoryBlocks(workspace: Workspace): Element[] {
   const variableModelList = workspace.getVariablesOfType('');
 
   const xmlList = [];
@@ -158,15 +150,27 @@ const flyoutCategoryBlocks = function(workspace) {
     if (Blocks['variables_set']) {
       const block = utilsXml.createElement('block');
       block.setAttribute('type', 'variables_set');
-      block.setAttribute('gap', Blocks['math_change'] ? 8 : 24);
-      block.appendChild(generateVariableFieldDom(mostRecentVariable));
+      // AnyDuringMigration because:  Argument of type 'number' is not
+      // assignable to parameter of type 'string'.
+      block.setAttribute(
+          'gap', (Blocks['math_change'] ? 8 : 24) as AnyDuringMigration);
+      // AnyDuringMigration because:  Argument of type 'Element | null' is not
+      // assignable to parameter of type 'Node'.
+      block.appendChild(
+          generateVariableFieldDom(mostRecentVariable) as AnyDuringMigration);
       xmlList.push(block);
     }
     if (Blocks['math_change']) {
       const block = utilsXml.createElement('block');
       block.setAttribute('type', 'math_change');
-      block.setAttribute('gap', Blocks['variables_get'] ? 20 : 8);
-      block.appendChild(generateVariableFieldDom(mostRecentVariable));
+      // AnyDuringMigration because:  Argument of type 'number' is not
+      // assignable to parameter of type 'string'.
+      block.setAttribute(
+          'gap', (Blocks['variables_get'] ? 20 : 8) as AnyDuringMigration);
+      // AnyDuringMigration because:  Argument of type 'Element | null' is not
+      // assignable to parameter of type 'Node'.
+      block.appendChild(
+          generateVariableFieldDom(mostRecentVariable) as AnyDuringMigration);
       const value = Xml.textToDom(
           '<value name="DELTA">' +
           '<shadow type="math_number">' +
@@ -179,50 +183,58 @@ const flyoutCategoryBlocks = function(workspace) {
 
     if (Blocks['variables_get']) {
       variableModelList.sort(VariableModel.compareByName);
-      for (let i = 0, variable; (variable = variableModelList[i]); i++) {
+      for (let i = 0, variable; variable = variableModelList[i]; i++) {
         const block = utilsXml.createElement('block');
         block.setAttribute('type', 'variables_get');
-        block.setAttribute('gap', 8);
-        block.appendChild(generateVariableFieldDom(variable));
+        // AnyDuringMigration because:  Argument of type 'number' is not
+        // assignable to parameter of type 'string'.
+        block.setAttribute('gap', 8 as AnyDuringMigration);
+        // AnyDuringMigration because:  Argument of type 'Element | null' is not
+        // assignable to parameter of type 'Node'.
+        block.appendChild(
+            generateVariableFieldDom(variable) as AnyDuringMigration);
         xmlList.push(block);
       }
     }
   }
   return xmlList;
-};
-exports.flyoutCategoryBlocks = flyoutCategoryBlocks;
+}
 
-/**
- * @alias Blockly.Variables.VAR_LETTER_OPTIONS
- */
-const VAR_LETTER_OPTIONS = 'ijkmnopqrstuvwxyzabcdefgh';  // No 'l'.
-exports.VAR_LETTER_OPTIONS = VAR_LETTER_OPTIONS;
+/** @alias Blockly.Variables.VAR_LETTER_OPTIONS */
+export const VAR_LETTER_OPTIONS = 'ijkmnopqrstuvwxyzabcdefgh';
 
 /**
  * Return a new variable name that is not yet being used. This will try to
  * generate single letter variable names in the range 'i' to 'z' to start with.
  * If no unique name is located it will try 'i' to 'z', 'a' to 'h',
  * then 'i2' to 'z2' etc.  Skip 'l'.
- * @param {!Workspace} workspace The workspace to be unique in.
- * @return {string} New variable name.
+ * @param workspace The workspace to be unique in.
+ * @return New variable name.
  * @alias Blockly.Variables.generateUniqueName
  */
-const generateUniqueName = function(workspace) {
+export function generateUniqueName(workspace: Workspace): string {
+  return TEST_ONLY.generateUniqueNameInternal(workspace);
+}
+
+/**
+ * Private version of generateUniqueName for stubbing in tests.
+ */
+function generateUniqueNameInternal(workspace: Workspace): string {
   return generateUniqueNameFromOptions(
       VAR_LETTER_OPTIONS.charAt(0), workspace.getAllVariableNames());
-};
-exports.generateUniqueName = generateUniqueName;
+}
 
 /**
  * Returns a unique name that is not present in the usedNames array. This
  * will try to generate single letter names in the range a -> z (skip l). It
  * will start with the character passed to startChar.
- * @param {string} startChar The character to start the search at.
- * @param {!Array<string>} usedNames A list of all of the used names.
- * @return {string} A unique name that is not present in the usedNames array.
+ * @param startChar The character to start the search at.
+ * @param usedNames A list of all of the used names.
+ * @return A unique name that is not present in the usedNames array.
  * @alias Blockly.Variables.generateUniqueNameFromOptions
  */
-const generateUniqueNameFromOptions = function(startChar, usedNames) {
+export function generateUniqueNameFromOptions(
+    startChar: string, usedNames: string[]): string {
   if (!usedNames.length) {
     return startChar;
   }
@@ -249,12 +261,13 @@ const generateUniqueNameFromOptions = function(startChar, usedNames) {
     if (letterIndex === letters.length) {
       // Reached the end of the character sequence so back to 'i'.
       letterIndex = 0;
-      suffix = Number(suffix) + 1;
+      // AnyDuringMigration because:  Type 'number' is not assignable to type
+      // 'string'.
+      suffix = (Number(suffix) + 1) as AnyDuringMigration;
     }
     potName = letters.charAt(letterIndex) + suffix;
   }
-};
-exports.generateUniqueNameFromOptions = generateUniqueNameFromOptions;
+}
 
 /**
  * Handles "Create Variable" button in the default variables toolbox category.
@@ -265,20 +278,21 @@ exports.generateUniqueNameFromOptions = generateUniqueNameFromOptions;
  * types and after-creation processing. More complex customization (e.g.,
  * prompting for variable type) is beyond the scope of this function.
  *
- * @param {!Workspace} workspace The workspace on which to create the
- *     variable.
- * @param {function(?string=)=} opt_callback A callback. It will be passed an
- *     acceptable new variable name, or null if change is to be aborted (cancel
- *     button), or undefined if an existing variable was chosen.
- * @param {string=} opt_type The type of the variable like 'int', 'string', or
- *     ''. This will default to '', which is a specific type.
+ * @param workspace The workspace on which to create the variable.
+ * @param opt_callback A callback. It will be passed an acceptable new variable
+ *     name, or null if change is to be aborted (cancel button), or undefined if
+ *     an existing variable was chosen.
+ * @param opt_type The type of the variable like 'int', 'string', or ''. This
+ *     will default to '', which is a specific type.
  * @alias Blockly.Variables.createVariableButtonHandler
  */
-const createVariableButtonHandler = function(
-    workspace, opt_callback, opt_type) {
+export function createVariableButtonHandler(
+    workspace: Workspace,
+    opt_callback?: (p1?: string|null) => AnyDuringMigration,
+    opt_type?: string) {
   const type = opt_type || '';
   // This function needs to be named so it can be called recursively.
-  const promptAndCheckWithAlert = function(defaultName) {
+  function promptAndCheckWithAlert(defaultName: AnyDuringMigration) {
     promptName(Msg['NEW_VARIABLE_TITLE'], defaultName, function(text) {
       if (text) {
         const existing = nameUsedWithAnyType(text, workspace);
@@ -291,7 +305,7 @@ const createVariableButtonHandler = function(
             msg = msg.replace('%1', existing.name).replace('%2', existing.type);
           }
           dialog.alert(msg, function() {
-            promptAndCheckWithAlert(text);  // Recurse
+            promptAndCheckWithAlert(text);
           });
         } else {
           // No conflict
@@ -307,26 +321,26 @@ const createVariableButtonHandler = function(
         }
       }
     });
-  };
+  }
   promptAndCheckWithAlert('');
-};
-exports.createVariableButtonHandler = createVariableButtonHandler;
+}
 
 /**
  * Opens a prompt that allows the user to enter a new name for a variable.
  * Triggers a rename if the new name is valid. Or re-prompts if there is a
  * collision.
- * @param {!Workspace} workspace The workspace on which to rename the
- *     variable.
- * @param {!VariableModel} variable Variable to rename.
- * @param {function(?string=)=} opt_callback A callback. It will
- *     be passed an acceptable new variable name, or null if change is to be
- *     aborted (cancel button), or undefined if an existing variable was chosen.
+ * @param workspace The workspace on which to rename the variable.
+ * @param variable Variable to rename.
+ * @param opt_callback A callback. It will be passed an acceptable new variable
+ *     name, or null if change is to be aborted (cancel button), or undefined if
+ *     an existing variable was chosen.
  * @alias Blockly.Variables.renameVariable
  */
-const renameVariable = function(workspace, variable, opt_callback) {
+export function renameVariable(
+    workspace: Workspace, variable: VariableModel,
+    opt_callback?: (p1?: string|null) => AnyDuringMigration) {
   // This function needs to be named so it can be called recursively.
-  const promptAndCheckWithAlert = function(defaultName) {
+  function promptAndCheckWithAlert(defaultName: AnyDuringMigration) {
     const promptText =
         Msg['RENAME_VARIABLE_TITLE'].replace('%1', variable.name);
     promptName(promptText, defaultName, function(newName) {
@@ -338,7 +352,7 @@ const renameVariable = function(workspace, variable, opt_callback) {
                           .replace('%1', existing.name)
                           .replace('%2', existing.type);
           dialog.alert(msg, function() {
-            promptAndCheckWithAlert(newName);  // Recurse
+            promptAndCheckWithAlert(newName);
           });
         } else {
           workspace.renameVariableById(variable.getId(), newName);
@@ -353,20 +367,21 @@ const renameVariable = function(workspace, variable, opt_callback) {
         }
       }
     });
-  };
+  }
   promptAndCheckWithAlert('');
-};
-exports.renameVariable = renameVariable;
+}
 
 /**
  * Prompt the user for a new variable name.
- * @param {string} promptText The string of the prompt.
- * @param {string} defaultText The default value to show in the prompt's field.
- * @param {function(?string)} callback A callback. It will return the new
- *     variable name, or null if the user picked something illegal.
+ * @param promptText The string of the prompt.
+ * @param defaultText The default value to show in the prompt's field.
+ * @param callback A callback. It will return the new variable name, or null if
+ *     the user picked something illegal.
  * @alias Blockly.Variables.promptName
  */
-const promptName = function(promptText, defaultText, callback) {
+export function promptName(
+    promptText: string, defaultText: string,
+    callback: (p1: string|null) => AnyDuringMigration) {
   dialog.prompt(promptText, defaultText, function(newVar) {
     // Merge runs of whitespace.  Strip leading and trailing whitespace.
     // Beyond this, all names are legal.
@@ -379,61 +394,57 @@ const promptName = function(promptText, defaultText, callback) {
     }
     callback(newVar);
   });
-};
-exports.promptName = promptName;
-
+}
 /**
  * Check whether there exists a variable with the given name but a different
  * type.
- * @param {string} name The name to search for.
- * @param {string} type The type to exclude from the search.
- * @param {!Workspace} workspace The workspace to search for the
- *     variable.
- * @return {?VariableModel} The variable with the given name and a
- *     different type, or null if none was found.
+ * @param name The name to search for.
+ * @param type The type to exclude from the search.
+ * @param workspace The workspace to search for the variable.
+ * @return The variable with the given name and a different type, or null if
+ *     none was found.
  */
-const nameUsedWithOtherType = function(name, type, workspace) {
+function nameUsedWithOtherType(
+    name: string, type: string, workspace: Workspace): VariableModel|null {
   const allVariables = workspace.getVariableMap().getAllVariables();
 
   name = name.toLowerCase();
-  for (let i = 0, variable; (variable = allVariables[i]); i++) {
+  for (let i = 0, variable; variable = allVariables[i]; i++) {
     if (variable.name.toLowerCase() === name && variable.type !== type) {
       return variable;
     }
   }
   return null;
-};
+}
 
 /**
  * Check whether there exists a variable with the given name of any type.
- * @param {string} name The name to search for.
- * @param {!Workspace} workspace The workspace to search for the
- *     variable.
- * @return {?VariableModel} The variable with the given name,
- *     or null if none was found.
+ * @param name The name to search for.
+ * @param workspace The workspace to search for the variable.
+ * @return The variable with the given name, or null if none was found.
  * @alias Blockly.Variables.nameUsedWithAnyType
  */
-const nameUsedWithAnyType = function(name, workspace) {
+export function nameUsedWithAnyType(
+    name: string, workspace: Workspace): VariableModel|null {
   const allVariables = workspace.getVariableMap().getAllVariables();
 
   name = name.toLowerCase();
-  for (let i = 0, variable; (variable = allVariables[i]); i++) {
+  for (let i = 0, variable; variable = allVariables[i]; i++) {
     if (variable.name.toLowerCase() === name) {
       return variable;
     }
   }
   return null;
-};
-exports.nameUsedWithAnyType = nameUsedWithAnyType;
+}
 
 /**
  * Generate DOM objects representing a variable field.
- * @param {!VariableModel} variableModel The variable model to
- *     represent.
- * @return {?Element} The generated DOM.
+ * @param variableModel The variable model to represent.
+ * @return The generated DOM.
  * @alias Blockly.Variables.generateVariableFieldDom
  */
-const generateVariableFieldDom = function(variableModel) {
+export function generateVariableFieldDom(variableModel: VariableModel): Element|
+    null {
   /* Generates the following XML:
    * <field name="VAR" id="goKTKmYJ8DhVHpruv" variabletype="int">foo</field>
    */
@@ -444,47 +455,48 @@ const generateVariableFieldDom = function(variableModel) {
   const name = utilsXml.createTextNode(variableModel.name);
   field.appendChild(name);
   return field;
-};
-exports.generateVariableFieldDom = generateVariableFieldDom;
+}
 
 /**
  * Helper function to look up or create a variable on the given workspace.
  * If no variable exists, creates and returns it.
- * @param {!Workspace} workspace The workspace to search for the
- *     variable.  It may be a flyout workspace or main workspace.
- * @param {?string} id The ID to use to look up or create the variable, or null.
- * @param {string=} opt_name The string to use to look up or create the
- *     variable.
- * @param {string=} opt_type The type to use to look up or create the variable.
- * @return {!VariableModel} The variable corresponding to the given ID
- *     or name + type combination.
+ * @param workspace The workspace to search for the variable.  It may be a
+ *     flyout workspace or main workspace.
+ * @param id The ID to use to look up or create the variable, or null.
+ * @param opt_name The string to use to look up or create the variable.
+ * @param opt_type The type to use to look up or create the variable.
+ * @return The variable corresponding to the given ID or name + type
+ *     combination.
  * @alias Blockly.Variables.getOrCreateVariablePackage
  */
-const getOrCreateVariablePackage = function(workspace, id, opt_name, opt_type) {
+export function getOrCreateVariablePackage(
+    workspace: Workspace, id: string|null, opt_name?: string,
+    opt_type?: string): VariableModel {
   let variable = getVariable(workspace, id, opt_name, opt_type);
   if (!variable) {
     variable = createVariable(workspace, id, opt_name, opt_type);
   }
   return variable;
-};
-exports.getOrCreateVariablePackage = getOrCreateVariablePackage;
+}
 
 /**
  * Look up  a variable on the given workspace.
  * Always looks in the main workspace before looking in the flyout workspace.
  * Always prefers lookup by ID to lookup by name + type.
- * @param {!Workspace} workspace The workspace to search for the
- *     variable.  It may be a flyout workspace or main workspace.
- * @param {?string} id The ID to use to look up the variable, or null.
- * @param {string=} opt_name The string to use to look up the variable.
+ * @param workspace The workspace to search for the variable.  It may be a
+ *     flyout workspace or main workspace.
+ * @param id The ID to use to look up the variable, or null.
+ * @param opt_name The string to use to look up the variable.
  *     Only used if lookup by ID fails.
- * @param {string=} opt_type The type to use to look up the variable.
+ * @param opt_type The type to use to look up the variable.
  *     Only used if lookup by ID fails.
- * @return {?VariableModel} The variable corresponding to the given ID
- *     or name + type combination, or null if not found.
+ * @return The variable corresponding to the given ID or name + type
+ *     combination, or null if not found.
  * @alias Blockly.Variables.getVariable
  */
-const getVariable = function(workspace, id, opt_name, opt_type) {
+export function getVariable(
+    workspace: Workspace, id: string|null, opt_name?: string,
+    opt_type?: string): VariableModel|null {
   const potentialVariableMap = workspace.getPotentialVariableMap();
   let variable = null;
   // Try to just get the variable, by ID if possible.
@@ -511,56 +523,59 @@ const getVariable = function(workspace, id, opt_name, opt_type) {
     }
   }
   return variable;
-};
-exports.getVariable = getVariable;
+}
 
 /**
  * Helper function to create a variable on the given workspace.
- * @param {!Workspace} workspace The workspace in which to create the
- * variable.  It may be a flyout workspace or main workspace.
- * @param {?string} id The ID to use to create the variable, or null.
- * @param {string=} opt_name The string to use to create the variable.
- * @param {string=} opt_type The type to use to create the variable.
- * @return {!VariableModel} The variable corresponding to the given ID
- *     or name + type combination.
+ * @param workspace The workspace in which to create the variable.  It may be a
+ *     flyout workspace or main workspace.
+ * @param id The ID to use to create the variable, or null.
+ * @param opt_name The string to use to create the variable.
+ * @param opt_type The type to use to create the variable.
+ * @return The variable corresponding to the given ID or name + type
+ *     combination.
  */
-const createVariable = function(workspace, id, opt_name, opt_type) {
+function createVariable(
+    workspace: Workspace, id: string|null, opt_name?: string,
+    opt_type?: string): VariableModel {
   const potentialVariableMap = workspace.getPotentialVariableMap();
   // Variables without names get uniquely named for this workspace.
   if (!opt_name) {
     const ws =
-        /** @type {!Workspace} */ (
-            workspace.isFlyout ?
-                /** @type {!WorkspaceSvg} */ (workspace).targetWorkspace :
-                workspace);
+        (workspace.isFlyout ? (workspace as WorkspaceSvg).targetWorkspace :
+                              workspace);
     // Must call version on exports to allow for mocking in tests. See #5321
-    opt_name = exports.generateUniqueName(ws);
+    // AnyDuringMigration because:  Argument of type 'Workspace | WorkspaceSvg'
+    // is not assignable to parameter of type 'Workspace'.
+    opt_name = generateUniqueName(ws as AnyDuringMigration);
   }
 
   // Create a potential variable if in the flyout.
   let variable = null;
   if (potentialVariableMap) {
     variable = potentialVariableMap.createVariable(opt_name, opt_type, id);
-  } else {  // In the main workspace, create a real variable.
+  } else {
+    // In the main workspace, create a real variable.
     variable = workspace.createVariable(opt_name, opt_type, id);
   }
   return variable;
-};
+}
 
 /**
  * Helper function to get the list of variables that have been added to the
  * workspace after adding a new block, using the given list of variables that
  * were in the workspace before the new block was added.
- * @param {!Workspace} workspace The workspace to inspect.
- * @param {!Array<!VariableModel>} originalVariables The array of
- *     variables that existed in the workspace before adding the new block.
- * @return {!Array<!VariableModel>} The new array of variables that
- *     were freshly added to the workspace after creating the new block,
- *     or [] if no new variables were added to the workspace.
+ * @param workspace The workspace to inspect.
+ * @param originalVariables The array of variables that existed in the workspace
+ *     before adding the new block.
+ * @return The new array of variables that were freshly added to the workspace
+ *     after creating the new block, or [] if no new variables were added to the
+ *     workspace.
  * @alias Blockly.Variables.getAddedVariables
- * @package
+ * @internal
  */
-const getAddedVariables = function(workspace, originalVariables) {
+export function getAddedVariables(
+    workspace: Workspace, originalVariables: VariableModel[]): VariableModel[] {
   const allCurrentVariables = workspace.getAllVariables();
   const addedVariables = [];
   if (originalVariables.length !== allCurrentVariables.length) {
@@ -574,5 +589,8 @@ const getAddedVariables = function(workspace, originalVariables) {
     }
   }
   return addedVariables;
-};
-exports.getAddedVariables = getAddedVariables;
+}
+
+export const TEST_ONLY = {
+  generateUniqueNameInternal,
+}