blockly 7.20211209.4 → 8.0.0

package/core/events/events_var_delete.js

@@ -16,7 +16,6 @@
 goog.module('Blockly.Events.VarDelete');
 
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {VarBase} = goog.require('Blockly.Events.VarBase');
 /* eslint-disable-next-line no-unused-vars */
@@ -25,62 +24,65 @@ const {VariableModel} = goog.requireType('Blockly.VariableModel');
 
 /**
  * Class for a variable deletion event.
- * @param {!VariableModel=} opt_variable The deleted variable. Undefined
- *     for a blank event.
  * @extends {VarBase}
- * @constructor
  * @alias Blockly.Events.VarDelete
  */
-const VarDelete = function(opt_variable) {
-  VarDelete.superClass_.constructor.call(this, opt_variable);
-  if (!opt_variable) {
-    return;  // Blank event to be populated by fromJson.
-  }
+class VarDelete extends VarBase {
+  /**
+   * @param {!VariableModel=} opt_variable The deleted variable. Undefined
+   *     for a blank event.
+   */
+  constructor(opt_variable) {
+    super(opt_variable);
 
-  this.varType = opt_variable.type;
-  this.varName = opt_variable.name;
-};
-object.inherits(VarDelete, VarBase);
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.VAR_DELETE;
 
-/**
- * Type of this event.
- * @type {string}
- */
-VarDelete.prototype.type = eventUtils.VAR_DELETE;
+    if (!opt_variable) {
+      return;  // Blank event to be populated by fromJson.
+    }
 
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-VarDelete.prototype.toJson = function() {
-  const json = VarDelete.superClass_.toJson.call(this);
-  json['varType'] = this.varType;
-  json['varName'] = this.varName;
-  return json;
-};
+    this.varType = opt_variable.type;
+    this.varName = opt_variable.name;
+  }
 
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-VarDelete.prototype.fromJson = function(json) {
-  VarDelete.superClass_.fromJson.call(this, json);
-  this.varType = json['varType'];
-  this.varName = json['varName'];
-};
+  /**
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
+   */
+  toJson() {
+    const json = super.toJson();
+    json['varType'] = this.varType;
+    json['varName'] = this.varName;
+    return json;
+  }
 
-/**
- * Run a variable deletion event.
- * @param {boolean} forward True if run forward, false if run backward (undo).
- */
-VarDelete.prototype.run = function(forward) {
-  const workspace = this.getEventWorkspace_();
-  if (forward) {
-    workspace.deleteVariableById(this.varId);
-  } else {
-    workspace.createVariable(this.varName, this.varType, this.varId);
+  /**
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
+   */
+  fromJson(json) {
+    super.fromJson(json);
+    this.varType = json['varType'];
+    this.varName = json['varName'];
+  }
+
+  /**
+   * Run a variable deletion event.
+   * @param {boolean} forward True if run forward, false if run backward (undo).
+   */
+  run(forward) {
+    const workspace = this.getEventWorkspace_();
+    if (forward) {
+      workspace.deleteVariableById(this.varId);
+    } else {
+      workspace.createVariable(this.varName, this.varType, this.varId);
+    }
   }
-};
+}
 
 registry.register(registry.Type.EVENT, eventUtils.VAR_DELETE, VarDelete);
 

package/core/events/events_var_rename.js

@@ -16,7 +16,6 @@
 goog.module('Blockly.Events.VarRename');
 
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {VarBase} = goog.require('Blockly.Events.VarBase');
 /* eslint-disable-next-line no-unused-vars */
@@ -25,63 +24,66 @@ const {VariableModel} = goog.requireType('Blockly.VariableModel');
 
 /**
  * Class for a variable rename event.
- * @param {!VariableModel=} opt_variable The renamed variable. Undefined
- *     for a blank event.
- * @param {string=} newName The new name the variable will be changed to.
  * @extends {VarBase}
- * @constructor
  * @alias Blockly.Events.VarRename
  */
-const VarRename = function(opt_variable, newName) {
-  VarRename.superClass_.constructor.call(this, opt_variable);
-  if (!opt_variable) {
-    return;  // Blank event to be populated by fromJson.
-  }
+class VarRename extends VarBase {
+  /**
+   * @param {!VariableModel=} opt_variable The renamed variable. Undefined
+   *     for a blank event.
+   * @param {string=} newName The new name the variable will be changed to.
+   */
+  constructor(opt_variable, newName) {
+    super(opt_variable);
 
-  this.oldName = opt_variable.name;
-  this.newName = typeof newName === 'undefined' ? '' : newName;
-};
-object.inherits(VarRename, VarBase);
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.VAR_RENAME;
 
-/**
- * Type of this event.
- * @type {string}
- */
-VarRename.prototype.type = eventUtils.VAR_RENAME;
+    if (!opt_variable) {
+      return;  // Blank event to be populated by fromJson.
+    }
 
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-VarRename.prototype.toJson = function() {
-  const json = VarRename.superClass_.toJson.call(this);
-  json['oldName'] = this.oldName;
-  json['newName'] = this.newName;
-  return json;
-};
+    this.oldName = opt_variable.name;
+    this.newName = typeof newName === 'undefined' ? '' : newName;
+  }
 
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-VarRename.prototype.fromJson = function(json) {
-  VarRename.superClass_.fromJson.call(this, json);
-  this.oldName = json['oldName'];
-  this.newName = json['newName'];
-};
+  /**
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
+   */
+  toJson() {
+    const json = super.toJson();
+    json['oldName'] = this.oldName;
+    json['newName'] = this.newName;
+    return json;
+  }
 
-/**
- * Run a variable rename event.
- * @param {boolean} forward True if run forward, false if run backward (undo).
- */
-VarRename.prototype.run = function(forward) {
-  const workspace = this.getEventWorkspace_();
-  if (forward) {
-    workspace.renameVariableById(this.varId, this.newName);
-  } else {
-    workspace.renameVariableById(this.varId, this.oldName);
+  /**
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
+   */
+  fromJson(json) {
+    super.fromJson(json);
+    this.oldName = json['oldName'];
+    this.newName = json['newName'];
+  }
+
+  /**
+   * Run a variable rename event.
+   * @param {boolean} forward True if run forward, false if run backward (undo).
+   */
+  run(forward) {
+    const workspace = this.getEventWorkspace_();
+    if (forward) {
+      workspace.renameVariableById(this.varId, this.newName);
+    } else {
+      workspace.renameVariableById(this.varId, this.oldName);
+    }
   }
-};
+}
 
 registry.register(registry.Type.EVENT, eventUtils.VAR_RENAME, VarRename);
 

package/core/events/events_viewport.js

@@ -16,89 +16,90 @@
 goog.module('Blockly.Events.ViewportChange');
 
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {UiBase} = goog.require('Blockly.Events.UiBase');
 
 
 /**
  * Class for a viewport change event.
- * @param {number=} opt_top Top-edge of the visible portion of the workspace,
- *    relative to the workspace origin. Undefined for a blank event.
- * @param {number=} opt_left Left-edge of the visible portion of the workspace,
- *    relative to the workspace origin. Undefined for a blank event.
- * @param {number=} opt_scale The scale of the workspace. Undefined for a blank
- *    event.
- * @param {string=} opt_workspaceId The workspace identifier for this event.
- *    Undefined for a blank event.
- * @param {number=} opt_oldScale The old scale of the workspace. Undefined for a
- *    blank event.
  * @extends {UiBase}
- * @constructor
  * @alias Blockly.Events.ViewportChange
  */
-const ViewportChange = function(
-    opt_top, opt_left, opt_scale, opt_workspaceId, opt_oldScale) {
-  ViewportChange.superClass_.constructor.call(this, opt_workspaceId);
-
+class ViewportChange extends UiBase {
   /**
-   * Top-edge of the visible portion of the workspace, relative to the workspace
-   * origin.
-   * @type {number|undefined}
+   * @param {number=} opt_top Top-edge of the visible portion of the workspace,
+   *    relative to the workspace origin. Undefined for a blank event.
+   * @param {number=} opt_left Left-edge of the visible portion of the
+   *     workspace relative to the workspace origin. Undefined for a blank
+   *     event.
+   * @param {number=} opt_scale The scale of the workspace. Undefined for a
+   *     blank event.
+   * @param {string=} opt_workspaceId The workspace identifier for this event.
+   *    Undefined for a blank event.
+   * @param {number=} opt_oldScale The old scale of the workspace. Undefined for
+   *     a blank event.
    */
-  this.viewTop = opt_top;
+  constructor(opt_top, opt_left, opt_scale, opt_workspaceId, opt_oldScale) {
+    super(opt_workspaceId);
 
-  /**
-   * Left-edge of the visible portion of the workspace, relative to the
-   * workspace origin.
-   * @type {number|undefined}
-   */
-  this.viewLeft = opt_left;
+    /**
+     * Top-edge of the visible portion of the workspace, relative to the
+     * workspace origin.
+     * @type {number|undefined}
+     */
+    this.viewTop = opt_top;
+
+    /**
+     * Left-edge of the visible portion of the workspace, relative to the
+     * workspace origin.
+     * @type {number|undefined}
+     */
+    this.viewLeft = opt_left;
+
+    /**
+     * The scale of the workspace.
+     * @type {number|undefined}
+     */
+    this.scale = opt_scale;
+
+    /**
+     * The old scale of the workspace.
+     * @type {number|undefined}
+     */
+    this.oldScale = opt_oldScale;
+
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.VIEWPORT_CHANGE;
+  }
 
   /**
-   * The scale of the workspace.
-   * @type {number|undefined}
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
    */
-  this.scale = opt_scale;
+  toJson() {
+    const json = super.toJson();
+    json['viewTop'] = this.viewTop;
+    json['viewLeft'] = this.viewLeft;
+    json['scale'] = this.scale;
+    json['oldScale'] = this.oldScale;
+    return json;
+  }
 
   /**
-   * The old scale of the workspace.
-   * @type {number|undefined}
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
    */
-  this.oldScale = opt_oldScale;
-};
-object.inherits(ViewportChange, UiBase);
-
-/**
- * Type of this event.
- * @type {string}
- */
-ViewportChange.prototype.type = eventUtils.VIEWPORT_CHANGE;
-
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-ViewportChange.prototype.toJson = function() {
-  const json = ViewportChange.superClass_.toJson.call(this);
-  json['viewTop'] = this.viewTop;
-  json['viewLeft'] = this.viewLeft;
-  json['scale'] = this.scale;
-  json['oldScale'] = this.oldScale;
-  return json;
-};
-
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-ViewportChange.prototype.fromJson = function(json) {
-  ViewportChange.superClass_.fromJson.call(this, json);
-  this.viewTop = json['viewTop'];
-  this.viewLeft = json['viewLeft'];
-  this.scale = json['scale'];
-  this.oldScale = json['oldScale'];
-};
+  fromJson(json) {
+    super.fromJson(json);
+    this.viewTop = json['viewTop'];
+    this.viewLeft = json['viewLeft'];
+    this.scale = json['scale'];
+    this.oldScale = json['oldScale'];
+  }
+}
 
 registry.register(
     registry.Type.EVENT, eventUtils.VIEWPORT_CHANGE, ViewportChange);

package/core/events/utils.js

@@ -17,11 +17,13 @@
  */
 goog.module('Blockly.Events.utils');
 
-/* eslint-disable-next-line no-unused-vars */
-const Abstract = goog.requireType('Blockly.Events.Abstract');
 const idGenerator = goog.require('Blockly.utils.idGenerator');
 const registry = goog.require('Blockly.registry');
 /* eslint-disable-next-line no-unused-vars */
+const {Abstract} = goog.requireType('Blockly.Events.Abstract');
+/* eslint-disable-next-line no-unused-vars */
+const {BlockChange} = goog.requireType('Blockly.Events.BlockChange');
+/* eslint-disable-next-line no-unused-vars */
 const {BlockCreate} = goog.requireType('Blockly.Events.BlockCreate');
 /* eslint-disable-next-line no-unused-vars */
 const {BlockMove} = goog.requireType('Blockly.Events.BlockMove');
@@ -32,7 +34,11 @@ const {CommentCreate} = goog.requireType('Blockly.Events.CommentCreate');
 /* eslint-disable-next-line no-unused-vars */
 const {CommentMove} = goog.requireType('Blockly.Events.CommentMove');
 /* eslint-disable-next-line no-unused-vars */
+const {ViewportChange} = goog.requireType('Blockly.Events.ViewportChange');
+/* 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');
 
 
 /**
@@ -307,6 +313,7 @@ exports.BUMP_EVENTS = BUMP_EVENTS;
 
 /**
  * List of events queued for firing.
+ * @type {!Array<!Abstract>}
  */
 const FIRE_QUEUE = [];
 
@@ -365,7 +372,9 @@ const filter = function(queueIn, forward) {
     if (!event.isNull()) {
       // Treat all UI events as the same type in hash table.
       const eventType = event.isUiEvent ? UI : event.type;
-      const key = [eventType, event.blockId, event.workspaceId].join(' ');
+      // TODO(#5927): Ceck whether `blockId` exists before accessing it.
+      const blockId = /** @type {*} */ (event).blockId;
+      const key = [eventType, blockId, event.workspaceId].join(' ');
 
       const lastEntry = hash[key];
       const lastEvent = lastEntry ? lastEntry.event : null;
@@ -376,22 +385,25 @@ const filter = function(queueIn, forward) {
         hash[key] = {event: event, index: i};
         mergedQueue.push(event);
       } else if (event.type === MOVE && lastEntry.index === i - 1) {
+        const moveEvent = /** @type {!BlockMove} */ (event);
         // Merge move events.
-        lastEvent.newParentId = event.newParentId;
-        lastEvent.newInputName = event.newInputName;
-        lastEvent.newCoordinate = event.newCoordinate;
+        lastEvent.newParentId = moveEvent.newParentId;
+        lastEvent.newInputName = moveEvent.newInputName;
+        lastEvent.newCoordinate = moveEvent.newCoordinate;
         lastEntry.index = i;
       } else if (
           event.type === CHANGE && event.element === lastEvent.element &&
           event.name === lastEvent.name) {
+        const changeEvent = /** @type {!BlockChange} */ (event);
         // Merge change events.
-        lastEvent.newValue = event.newValue;
+        lastEvent.newValue = changeEvent.newValue;
       } else if (event.type === VIEWPORT_CHANGE) {
+        const viewportEvent = /** @type {!ViewportChange} */ (event);
         // Merge viewport change events.
-        lastEvent.viewTop = event.viewTop;
-        lastEvent.viewLeft = event.viewLeft;
-        lastEvent.scale = event.scale;
-        lastEvent.oldScale = event.oldScale;
+        lastEvent.viewTop = viewportEvent.viewTop;
+        lastEvent.viewLeft = viewportEvent.viewLeft;
+        lastEvent.scale = viewportEvent.scale;
+        lastEvent.oldScale = viewportEvent.oldScale;
       } else if (event.type === CLICK && lastEvent.type === BUBBLE_OPEN) {
         // Drop click events caused by opening/closing bubbles.
       } else {
@@ -546,12 +558,15 @@ exports.get = get;
  */
 const disableOrphans = function(event) {
   if (event.type === MOVE || event.type === CREATE) {
-    if (!event.workspaceId) {
+    const blockEvent = /** @type {!BlockMove|!BlockCreate} */ (event);
+    if (!blockEvent.workspaceId) {
       return;
     }
     const {Workspace} = goog.module.get('Blockly.Workspace');
-    const eventWorkspace = Workspace.getById(event.workspaceId);
-    let block = eventWorkspace.getBlockById(event.blockId);
+    const eventWorkspace =
+        /** @type {!WorkspaceSvg} */ (
+            Workspace.getById(blockEvent.workspaceId));
+    let block = eventWorkspace.getBlockById(blockEvent.blockId);
     if (block) {
       // Changing blocks as part of this event shouldn't be undoable.
       const initialUndoFlag = recordUndo;

package/core/events/workspace_events.js

@@ -15,10 +15,9 @@
  */
 goog.module('Blockly.Events.FinishedLoading');
 
-const Abstract = goog.require('Blockly.Events.Abstract');
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
+const {Abstract: AbstractEvent} = goog.require('Blockly.Events.Abstract');
 /* eslint-disable-next-line no-unused-vars */
 const {Workspace} = goog.requireType('Blockly.Workspace');
 
@@ -28,70 +27,65 @@ const {Workspace} = goog.requireType('Blockly.Workspace');
  * Used to notify the developer when the workspace has finished loading (i.e
  * domToWorkspace).
  * Finished loading events do not record undo or redo.
- * @param {!Workspace=} opt_workspace The workspace that has finished
- *    loading.  Undefined for a blank event.
- * @extends {Abstract}
- * @constructor
+ * @extends {AbstractEvent}
  * @alias Blockly.Events.FinishedLoading
  */
-const FinishedLoading = function(opt_workspace) {
+class FinishedLoading extends AbstractEvent {
   /**
-   * Whether or not the event is blank (to be populated by fromJson).
-   * @type {boolean}
+   * @param {!Workspace=} opt_workspace The workspace that has finished
+   *    loading.  Undefined for a blank event.
    */
-  this.isBlank = typeof opt_workspace === 'undefined';
+  constructor(opt_workspace) {
+    super();
+    /**
+     * Whether or not the event is blank (to be populated by fromJson).
+     * @type {boolean}
+     */
+    this.isBlank = typeof opt_workspace === 'undefined';
+
+    /**
+     * The workspace identifier for this event.
+     * @type {string}
+     */
+    this.workspaceId = opt_workspace ? opt_workspace.id : '';
+
+    // Workspace events do not undo or redo.
+    this.recordUndo = false;
+
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.FINISHED_LOADING;
+  }
 
   /**
-   * The workspace identifier for this event.
-   * @type {string}
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
    */
-  this.workspaceId = opt_workspace ? opt_workspace.id : '';
+  toJson() {
+    const json = {
+      'type': this.type,
+    };
+    if (this.group) {
+      json['group'] = this.group;
+    }
+    if (this.workspaceId) {
+      json['workspaceId'] = this.workspaceId;
+    }
+    return json;
+  }
 
   /**
-   * The event group ID for the group this event belongs to. Groups define
-   * events that should be treated as an single action from the user's
-   * perspective, and should be undone together.
-   * @type {string}
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
    */
-  this.group = eventUtils.getGroup();
-
-  // Workspace events do not undo or redo.
-  this.recordUndo = false;
-};
-object.inherits(FinishedLoading, Abstract);
-
-/**
- * Type of this event.
- * @type {string}
- */
-FinishedLoading.prototype.type = eventUtils.FINISHED_LOADING;
-
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-FinishedLoading.prototype.toJson = function() {
-  const json = {
-    'type': this.type,
-  };
-  if (this.group) {
-    json['group'] = this.group;
+  fromJson(json) {
+    this.isBlank = false;
+    this.workspaceId = json['workspaceId'];
+    this.group = json['group'];
   }
-  if (this.workspaceId) {
-    json['workspaceId'] = this.workspaceId;
-  }
-  return json;
-};
-
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-FinishedLoading.prototype.fromJson = function(json) {
-  this.isBlank = false;
-  this.workspaceId = json['workspaceId'];
-  this.group = json['group'];
-};
+}
 
 registry.register(
     registry.Type.EVENT, eventUtils.FINISHED_LOADING, FinishedLoading);

package/core/extensions.js

@@ -24,6 +24,7 @@ goog.module('Blockly.Extensions');
 const parsing = goog.require('Blockly.utils.parsing');
 /* eslint-disable-next-line no-unused-vars */
 const {Block} = goog.requireType('Blockly.Block');
+const {FieldDropdown} = goog.require('Blockly.FieldDropdown');
 goog.requireType('Blockly.Mutator');
 
 
@@ -454,7 +455,7 @@ exports.buildTooltipForDropdown = buildTooltipForDropdown;
 const checkDropdownOptionsInTable = function(block, dropdownName, lookupTable) {
   // Validate all dropdown options have values.
   const dropdown = block.getField(dropdownName);
-  if (!dropdown.isOptionListDynamic()) {
+  if (dropdown instanceof FieldDropdown && !dropdown.isOptionListDynamic()) {
     const options = dropdown.getOptions();
     for (let i = 0; i < options.length; i++) {
       const optionKey = options[i][1];  // label, then value
@@ -512,11 +513,11 @@ exports.buildTooltipWithFieldText = buildTooltipWithFieldText;
  * @this {Block}
  */
 const extensionParentTooltip = function() {
-  this.tooltipWhenNotConnected = this.tooltip;
+  const tooltipWhenNotConnected = this.tooltip;
   this.setTooltip(function() {
     const parent = this.getParent();
     return (parent && parent.getInputsInline() && parent.tooltip) ||
-        this.tooltipWhenNotConnected;
+        tooltipWhenNotConnected;
   }.bind(this));
 };
 register('parent_tooltip_when_inline', extensionParentTooltip);