blockly 7.20211209.2 → 8.0.0

package/core/events/events.js

@@ -15,9 +15,9 @@
  */
 goog.module('Blockly.Events');
 
-const Abstract = goog.require('Blockly.Events.Abstract');
 const deprecation = goog.require('Blockly.utils.deprecation');
 const eventUtils = goog.require('Blockly.Events.utils');
+const {Abstract: AbstractEvent} = goog.require('Blockly.Events.Abstract');
 const {BlockBase} = goog.require('Blockly.Events.BlockBase');
 const {BlockChange} = goog.require('Blockly.Events.BlockChange');
 const {BlockCreate} = goog.require('Blockly.Events.BlockCreate');
@@ -47,7 +47,7 @@ const {ViewportChange} = goog.require('Blockly.Events.ViewportChange');
 
 
 // Events.
-exports.Abstract = Abstract;
+exports.Abstract = AbstractEvent;
 exports.BubbleOpen = BubbleOpen;
 exports.BlockBase = BlockBase;
 exports.BlockChange = BlockChange;

package/core/events/events_abstract.js

@@ -24,98 +24,110 @@ const {Workspace} = goog.requireType('Blockly.Workspace');
 
 /**
  * Abstract class for an event.
- * @constructor
+ * @abstract
  * @alias Blockly.Events.Abstract
  */
-const Abstract = function() {
+class Abstract {
   /**
-   * Whether or not the event is blank (to be populated by fromJson).
-   * @type {?boolean}
+   * @alias Blockly.Events.Abstract
    */
-  this.isBlank = null;
+  constructor() {
+    /**
+     * Whether or not the event is blank (to be populated by fromJson).
+     * @type {?boolean}
+     */
+    this.isBlank = null;
+
+    /**
+     * The workspace identifier for this event.
+     * @type {string|undefined}
+     */
+    this.workspaceId = undefined;
+
+    /**
+     * 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}
+     */
+    this.group = eventUtils.getGroup();
+
+    /**
+     * Sets whether the event should be added to the undo stack.
+     * @type {boolean}
+     */
+    this.recordUndo = eventUtils.getRecordUndo();
+
+    /**
+     * Whether or not the event is a UI event.
+     * @type {boolean}
+     */
+    this.isUiEvent = false;
+
+    /**
+     * Type of this event.
+     * @type {string|undefined}
+     */
+    this.type = undefined;
+  }
 
   /**
-   * The workspace identifier for this event.
-   * @type {string|undefined}
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
    */
-  this.workspaceId = undefined;
+  toJson() {
+    const json = {'type': this.type};
+    if (this.group) {
+      json['group'] = this.group;
+    }
+    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();
+  fromJson(json) {
+    this.isBlank = false;
+    this.group = json['group'];
+  }
 
   /**
-   * Sets whether the event should be added to the undo stack.
-   * @type {boolean}
+   * Does this event record any change of state?
+   * @return {boolean} True if null, false if something changed.
    */
-  this.recordUndo = eventUtils.getRecordUndo();
-};
-
-/**
- * Whether or not the event is a UI event.
- * @type {boolean}
- */
-Abstract.prototype.isUiEvent = false;
-
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-Abstract.prototype.toJson = function() {
-  const json = {'type': this.type};
-  if (this.group) {
-    json['group'] = this.group;
+  isNull() {
+    return false;
   }
-  return json;
-};
-
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-Abstract.prototype.fromJson = function(json) {
-  this.isBlank = false;
-  this.group = json['group'];
-};
-
-/**
- * Does this event record any change of state?
- * @return {boolean} True if null, false if something changed.
- */
-Abstract.prototype.isNull = function() {
-  return false;
-};
-
-/**
- * Run an event.
- * @param {boolean} _forward True if run forward, false if run backward (undo).
- */
-Abstract.prototype.run = function(_forward) {
-  // Defined by subclasses.
-};
 
-/**
- * Get workspace the event belongs to.
- * @return {!Workspace} The workspace the event belongs to.
- * @throws {Error} if workspace is null.
- * @protected
- */
-Abstract.prototype.getEventWorkspace_ = function() {
-  let workspace;
-  if (this.workspaceId) {
-    const {Workspace} = goog.module.get('Blockly.Workspace');
-    workspace = Workspace.getById(this.workspaceId);
+  /**
+   * Run an event.
+   * @param {boolean} _forward True if run forward, false if run backward
+   *     (undo).
+   */
+  run(_forward) {
+    // Defined by subclasses.
   }
-  if (!workspace) {
-    throw Error(
-        'Workspace is null. Event must have been generated from real' +
-        ' Blockly events.');
+
+  /**
+   * Get workspace the event belongs to.
+   * @return {!Workspace} The workspace the event belongs to.
+   * @throws {Error} if workspace is null.
+   * @protected
+   */
+  getEventWorkspace_() {
+    let workspace;
+    if (this.workspaceId) {
+      const {Workspace} = goog.module.get('Blockly.Workspace');
+      workspace = Workspace.getById(this.workspaceId);
+    }
+    if (!workspace) {
+      throw Error(
+          'Workspace is null. Event must have been generated from real' +
+          ' Blockly events.');
+    }
+    return workspace;
   }
-  return workspace;
-};
+}
 
-exports = Abstract;
+exports.Abstract = Abstract;

package/core/events/events_block_base.js

@@ -15,55 +15,56 @@
  */
 goog.module('Blockly.Events.BlockBase');
 
-const Abstract = goog.require('Blockly.Events.Abstract');
-const object = goog.require('Blockly.utils.object');
+const {Abstract: AbstractEvent} = goog.require('Blockly.Events.Abstract');
 /* eslint-disable-next-line no-unused-vars */
 const {Block} = goog.requireType('Blockly.Block');
 
 
 /**
  * Abstract class for a block event.
- * @param {!Block=} opt_block The block this event corresponds to.
- *     Undefined for a blank event.
- * @extends {Abstract}
- * @constructor
+ * @extends {AbstractEvent}
  * @alias Blockly.Events.BlockBase
  */
-const BlockBase = function(opt_block) {
-  BlockBase.superClass_.constructor.call(this);
-  this.isBlank = typeof opt_block === 'undefined';
-
+class BlockBase extends AbstractEvent {
   /**
-   * The block ID for the block this event pertains to
-   * @type {string}
+   * @param {!Block=} opt_block The block this event corresponds to.
+   *     Undefined for a blank event.
    */
-  this.blockId = this.isBlank ? '' : opt_block.id;
+  constructor(opt_block) {
+    super();
+    this.isBlank = typeof opt_block === 'undefined';
+
+    /**
+     * The block ID for the block this event pertains to
+     * @type {string}
+     */
+    this.blockId = this.isBlank ? '' : opt_block.id;
+
+    /**
+     * The workspace identifier for this event.
+     * @type {string}
+     */
+    this.workspaceId = this.isBlank ? '' : opt_block.workspace.id;
+  }
 
   /**
-   * The workspace identifier for this event.
-   * @type {string}
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
    */
-  this.workspaceId = this.isBlank ? '' : opt_block.workspace.id;
-};
-object.inherits(BlockBase, Abstract);
-
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-BlockBase.prototype.toJson = function() {
-  const json = BlockBase.superClass_.toJson.call(this);
-  json['blockId'] = this.blockId;
-  return json;
-};
+  toJson() {
+    const json = super.toJson();
+    json['blockId'] = this.blockId;
+    return json;
+  }
 
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-BlockBase.prototype.fromJson = function(json) {
-  BlockBase.superClass_.fromJson.call(this, json);
-  this.blockId = json['blockId'];
-};
+  /**
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
+   */
+  fromJson(json) {
+    super.fromJson(json);
+    this.blockId = json['blockId'];
+  }
+}
 
 exports.BlockBase = BlockBase;

package/core/events/events_block_change.js

@@ -17,7 +17,6 @@ goog.module('Blockly.Events.BlockChange');
 
 const Xml = goog.require('Blockly.Xml');
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {BlockBase} = goog.require('Blockly.Events.BlockBase');
 /* eslint-disable-next-line no-unused-vars */
@@ -28,145 +27,152 @@ const {Block} = goog.requireType('Blockly.Block');
 
 /**
  * Class for a block change event.
- * @param {!Block=} opt_block The changed block.  Undefined for a blank
- *     event.
- * @param {string=} opt_element One of 'field', 'comment', 'disabled', etc.
- * @param {?string=} opt_name Name of input or field affected, or null.
- * @param {*=} opt_oldValue Previous value of element.
- * @param {*=} opt_newValue New value of element.
  * @extends {BlockBase}
- * @constructor
  * @alias Blockly.Events.BlockChange
  */
-const BlockChange = function(
-    opt_block, opt_element, opt_name, opt_oldValue, opt_newValue) {
-  BlockChange.superClass_.constructor.call(this, opt_block);
-  if (!opt_block) {
-    return;  // Blank event to be populated by fromJson.
-  }
-  this.element = typeof opt_element === 'undefined' ? '' : opt_element;
-  this.name = typeof opt_name === 'undefined' ? '' : opt_name;
-  this.oldValue = typeof opt_oldValue === 'undefined' ? '' : opt_oldValue;
-  this.newValue = typeof opt_newValue === 'undefined' ? '' : opt_newValue;
-};
-object.inherits(BlockChange, BlockBase);
+class BlockChange extends BlockBase {
+  /**
+   * @param {!Block=} opt_block The changed block.  Undefined for a blank
+   *     event.
+   * @param {string=} opt_element One of 'field', 'comment', 'disabled', etc.
+   * @param {?string=} opt_name Name of input or field affected, or null.
+   * @param {*=} opt_oldValue Previous value of element.
+   * @param {*=} opt_newValue New value of element.
+   */
+  constructor(opt_block, opt_element, opt_name, opt_oldValue, opt_newValue) {
+    super(opt_block);
 
-/**
- * Type of this event.
- * @type {string}
- */
-BlockChange.prototype.type = eventUtils.BLOCK_CHANGE;
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.BLOCK_CHANGE;
 
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-BlockChange.prototype.toJson = function() {
-  const json = BlockChange.superClass_.toJson.call(this);
-  json['element'] = this.element;
-  if (this.name) {
-    json['name'] = this.name;
+    if (!opt_block) {
+      return;  // Blank event to be populated by fromJson.
+    }
+    this.element = typeof opt_element === 'undefined' ? '' : opt_element;
+    this.name = typeof opt_name === 'undefined' ? '' : opt_name;
+    this.oldValue = typeof opt_oldValue === 'undefined' ? '' : opt_oldValue;
+    this.newValue = typeof opt_newValue === 'undefined' ? '' : opt_newValue;
   }
-  json['oldValue'] = this.oldValue;
-  json['newValue'] = this.newValue;
-  return json;
-};
 
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-BlockChange.prototype.fromJson = function(json) {
-  BlockChange.superClass_.fromJson.call(this, json);
-  this.element = json['element'];
-  this.name = json['name'];
-  this.oldValue = json['oldValue'];
-  this.newValue = json['newValue'];
-};
-
-/**
- * Does this event record any change of state?
- * @return {boolean} False if something changed.
- */
-BlockChange.prototype.isNull = function() {
-  return this.oldValue === this.newValue;
-};
+  /**
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
+   */
+  toJson() {
+    const json = super.toJson();
+    json['element'] = this.element;
+    if (this.name) {
+      json['name'] = this.name;
+    }
+    json['oldValue'] = this.oldValue;
+    json['newValue'] = this.newValue;
+    return json;
+  }
 
-/**
- * Run a change event.
- * @param {boolean} forward True if run forward, false if run backward (undo).
- */
-BlockChange.prototype.run = function(forward) {
-  const workspace = this.getEventWorkspace_();
-  const block = workspace.getBlockById(this.blockId);
-  if (!block) {
-    console.warn('Can\'t change non-existent block: ' + this.blockId);
-    return;
+  /**
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
+   */
+  fromJson(json) {
+    super.fromJson(json);
+    this.element = json['element'];
+    this.name = json['name'];
+    this.oldValue = json['oldValue'];
+    this.newValue = json['newValue'];
   }
-  if (block.mutator) {
-    // Close the mutator (if open) since we don't want to update it.
-    block.mutator.setVisible(false);
+
+  /**
+   * Does this event record any change of state?
+   * @return {boolean} False if something changed.
+   */
+  isNull() {
+    return this.oldValue === this.newValue;
   }
-  const value = forward ? this.newValue : this.oldValue;
-  switch (this.element) {
-    case 'field': {
-      const field = block.getField(this.name);
-      if (field) {
-        field.setValue(value);
-      } else {
-        console.warn('Can\'t set non-existent field: ' + this.name);
-      }
-      break;
+
+  /**
+   * Run a change event.
+   * @param {boolean} forward True if run forward, false if run backward (undo).
+   */
+  run(forward) {
+    const workspace = this.getEventWorkspace_();
+    const block = workspace.getBlockById(this.blockId);
+    if (!block) {
+      console.warn('Can\'t change non-existent block: ' + this.blockId);
+      return;
     }
-    case 'comment':
-      block.setCommentText(/** @type {string} */ (value) || null);
-      break;
-    case 'collapsed':
-      block.setCollapsed(!!value);
-      break;
-    case 'disabled':
-      block.setEnabled(!value);
-      break;
-    case 'inline':
-      block.setInputsInline(!!value);
-      break;
-    case 'mutation': {
-      const oldState = BlockChange.getExtraBlockState_(
-          /** @type {!BlockSvg} */ (block));
-      if (block.loadExtraState) {
-        block.loadExtraState(JSON.parse(/** @type {string} */ (value) || '{}'));
-      } else if (block.domToMutation) {
-        block.domToMutation(
-            Xml.textToDom(/** @type {string} */ (value) || '<mutation/>'));
+
+    // Assume the block is rendered so that then we can check.
+    const blockSvg = /** @type {!BlockSvg} */ (block);
+    if (blockSvg.mutator) {
+      // Close the mutator (if open) since we don't want to update it.
+      blockSvg.mutator.setVisible(false);
+    }
+    const value = forward ? this.newValue : this.oldValue;
+    switch (this.element) {
+      case 'field': {
+        const field = block.getField(this.name);
+        if (field) {
+          field.setValue(value);
+        } else {
+          console.warn('Can\'t set non-existent field: ' + this.name);
+        }
+        break;
+      }
+      case 'comment':
+        block.setCommentText(/** @type {string} */ (value) || null);
+        break;
+      case 'collapsed':
+        block.setCollapsed(!!value);
+        break;
+      case 'disabled':
+        block.setEnabled(!value);
+        break;
+      case 'inline':
+        block.setInputsInline(!!value);
+        break;
+      case 'mutation': {
+        const oldState = BlockChange.getExtraBlockState_(
+            /** @type {!BlockSvg} */ (block));
+        if (block.loadExtraState) {
+          block.loadExtraState(
+              JSON.parse(/** @type {string} */ (value) || '{}'));
+        } else if (block.domToMutation) {
+          block.domToMutation(
+              Xml.textToDom(/** @type {string} */ (value) || '<mutation/>'));
+        }
+        eventUtils.fire(
+            new BlockChange(block, 'mutation', null, oldState, value));
+        break;
       }
-      eventUtils.fire(
-          new BlockChange(block, 'mutation', null, oldState, value));
-      break;
+      default:
+        console.warn('Unknown change type: ' + this.element);
     }
-    default:
-      console.warn('Unknown change type: ' + this.element);
   }
-};
 
-// TODO (#5397): Encapsulate this in the BlocklyMutationChange event when
-//    refactoring change events.
-/**
- * Returns the extra state of the given block (either as XML or a JSO, depending
- * on the block's definition).
- * @param {!BlockSvg} block The block to get the extra state of.
- * @return {string} A stringified version of the extra state of the given block.
- * @package
- */
-BlockChange.getExtraBlockState_ = function(block) {
-  if (block.saveExtraState) {
-    const state = block.saveExtraState();
-    return state ? JSON.stringify(state) : '';
-  } else if (block.mutationToDom) {
-    const state = block.mutationToDom();
-    return state ? Xml.domToText(state) : '';
+  // TODO (#5397): Encapsulate this in the BlocklyMutationChange event when
+  //    refactoring change events.
+  /**
+   * Returns the extra state of the given block (either as XML or a JSO,
+   * depending on the block's definition).
+   * @param {!BlockSvg} block The block to get the extra state of.
+   * @return {string} A stringified version of the extra state of the given
+   *     block.
+   * @package
+   */
+  static getExtraBlockState_(block) {
+    if (block.saveExtraState) {
+      const state = block.saveExtraState();
+      return state ? JSON.stringify(state) : '';
+    } else if (block.mutationToDom) {
+      const state = block.mutationToDom();
+      return state ? Xml.domToText(state) : '';
+    }
+    return '';
   }
-  return '';
-};
+}
 
 registry.register(registry.Type.EVENT, eventUtils.CHANGE, BlockChange);