blockly 7.20211209.4 → 8.0.0

package/core/events/events_comment_base.js

@@ -15,11 +15,10 @@
  */
 goog.module('Blockly.Events.CommentBase');
 
-const AbstractEvents = goog.require('Blockly.Events.Abstract');
 const Xml = goog.require('Blockly.Xml');
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const utilsXml = goog.require('Blockly.utils.xml');
+const {Abstract: AbstractEvent} = goog.require('Blockly.Events.Abstract');
 /* eslint-disable-next-line no-unused-vars */
 const {CommentCreate} = goog.requireType('Blockly.Events.CommentCreate');
 /* eslint-disable-next-line no-unused-vars */
@@ -30,89 +29,93 @@ const {WorkspaceComment} = goog.requireType('Blockly.WorkspaceComment');
 
 /**
  * Abstract class for a comment event.
- * @param {!WorkspaceComment=} opt_comment The comment this event
- *     corresponds to.  Undefined for a blank event.
- * @extends {AbstractEvents}
- * @constructor
+ * @extends {AbstractEvent}
  * @alias Blockly.Events.CommentBase
  */
-const CommentBase = function(opt_comment) {
+class CommentBase extends AbstractEvent {
   /**
-   * Whether or not an event is blank.
-   * @type {boolean}
+   * @param {!WorkspaceComment=} opt_comment The comment this event
+   *     corresponds to.  Undefined for a blank event.
    */
-  this.isBlank = typeof opt_comment === 'undefined';
+  constructor(opt_comment) {
+    super();
+    /**
+     * Whether or not an event is blank.
+     * @type {boolean}
+     */
+    this.isBlank = typeof opt_comment === 'undefined';
 
-  /**
-   * The ID of the comment this event pertains to.
-   * @type {string}
-   */
-  this.commentId = this.isBlank ? '' : opt_comment.id;
+    /**
+     * The ID of the comment this event pertains to.
+     * @type {string}
+     */
+    this.commentId = this.isBlank ? '' : opt_comment.id;
 
-  /**
-   * The workspace identifier for this event.
-   * @type {string}
-   */
-  this.workspaceId = this.isBlank ? '' : opt_comment.workspace.id;
+    /**
+     * The workspace identifier for this event.
+     * @type {string}
+     */
+    this.workspaceId = this.isBlank ? '' : opt_comment.workspace.id;
+
+    /**
+     * 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();
+  }
 
   /**
-   * 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}
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
    */
-  this.group = eventUtils.getGroup();
+  toJson() {
+    const json = super.toJson();
+    if (this.commentId) {
+      json['commentId'] = this.commentId;
+    }
+    return json;
+  }
 
   /**
-   * Sets whether the event should be added to the undo stack.
-   * @type {boolean}
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
    */
-  this.recordUndo = eventUtils.getRecordUndo();
-};
-object.inherits(CommentBase, AbstractEvents);
-
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-CommentBase.prototype.toJson = function() {
-  const json = CommentBase.superClass_.toJson.call(this);
-  if (this.commentId) {
-    json['commentId'] = this.commentId;
+  fromJson(json) {
+    super.fromJson(json);
+    this.commentId = json['commentId'];
   }
-  return json;
-};
-
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-CommentBase.prototype.fromJson = function(json) {
-  CommentBase.superClass_.fromJson.call(this, json);
-  this.commentId = json['commentId'];
-};
 
-/**
- * Helper function for Comment[Create|Delete]
- * @param {!CommentCreate|!CommentDelete} event
- *     The event to run.
- * @param {boolean} create if True then Create, if False then Delete
- */
-CommentBase.CommentCreateDeleteHelper = function(event, create) {
-  const workspace = event.getEventWorkspace_();
-  if (create) {
-    const xmlElement = utilsXml.createElement('xml');
-    xmlElement.appendChild(event.xml);
-    Xml.domToWorkspace(xmlElement, workspace);
-  } else {
-    const comment = workspace.getCommentById(event.commentId);
-    if (comment) {
-      comment.dispose();
+  /**
+   * Helper function for Comment[Create|Delete]
+   * @param {!CommentCreate|!CommentDelete} event
+   *     The event to run.
+   * @param {boolean} create if True then Create, if False then Delete
+   */
+  static CommentCreateDeleteHelper(event, create) {
+    const workspace = event.getEventWorkspace_();
+    if (create) {
+      const xmlElement = utilsXml.createElement('xml');
+      xmlElement.appendChild(event.xml);
+      Xml.domToWorkspace(xmlElement, workspace);
     } else {
-      // Only complain about root-level block.
-      console.warn('Can\'t uncreate non-existent comment: ' + event.commentId);
+      const comment = workspace.getCommentById(event.commentId);
+      if (comment) {
+        comment.dispose();
+      } else {
+        // Only complain about root-level block.
+        console.warn(
+            'Can\'t uncreate non-existent comment: ' + event.commentId);
+      }
     }
   }
-};
+}
 
 exports.CommentBase = CommentBase;

package/core/events/events_comment_change.js

@@ -16,7 +16,6 @@
 goog.module('Blockly.Events.CommentChange');
 
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {CommentBase} = goog.require('Blockly.Events.CommentBase');
 /* eslint-disable-next-line no-unused-vars */
@@ -25,77 +24,80 @@ const {WorkspaceComment} = goog.requireType('Blockly.WorkspaceComment');
 
 /**
  * Class for a comment change event.
- * @param {!WorkspaceComment=} opt_comment The comment that is being
- *     changed.  Undefined for a blank event.
- * @param {string=} opt_oldContents Previous contents of the comment.
- * @param {string=} opt_newContents New contents of the comment.
  * @extends {CommentBase}
- * @constructor
  * @alias Blockly.Events.CommentChange
  */
-const CommentChange = function(opt_comment, opt_oldContents, opt_newContents) {
-  CommentChange.superClass_.constructor.call(this, opt_comment);
-  if (!opt_comment) {
-    return;  // Blank event to be populated by fromJson.
-  }
+class CommentChange extends CommentBase {
+  /**
+   * @param {!WorkspaceComment=} opt_comment The comment that is being
+   *     changed.  Undefined for a blank event.
+   * @param {string=} opt_oldContents Previous contents of the comment.
+   * @param {string=} opt_newContents New contents of the comment.
+   */
+  constructor(opt_comment, opt_oldContents, opt_newContents) {
+    super(opt_comment);
 
-  this.oldContents_ =
-      typeof opt_oldContents === 'undefined' ? '' : opt_oldContents;
-  this.newContents_ =
-      typeof opt_newContents === 'undefined' ? '' : opt_newContents;
-};
-object.inherits(CommentChange, CommentBase);
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.COMMENT_CHANGE;
 
-/**
- * Type of this event.
- * @type {string}
- */
-CommentChange.prototype.type = eventUtils.COMMENT_CHANGE;
+    if (!opt_comment) {
+      return;  // Blank event to be populated by fromJson.
+    }
 
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-CommentChange.prototype.toJson = function() {
-  const json = CommentChange.superClass_.toJson.call(this);
-  json['oldContents'] = this.oldContents_;
-  json['newContents'] = this.newContents_;
-  return json;
-};
+    this.oldContents_ =
+        typeof opt_oldContents === 'undefined' ? '' : opt_oldContents;
+    this.newContents_ =
+        typeof opt_newContents === 'undefined' ? '' : opt_newContents;
+  }
 
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-CommentChange.prototype.fromJson = function(json) {
-  CommentChange.superClass_.fromJson.call(this, json);
-  this.oldContents_ = json['oldContents'];
-  this.newContents_ = json['newContents'];
-};
+  /**
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
+   */
+  toJson() {
+    const json = super.toJson();
+    json['oldContents'] = this.oldContents_;
+    json['newContents'] = this.newContents_;
+    return json;
+  }
 
-/**
- * Does this event record any change of state?
- * @return {boolean} False if something changed.
- */
-CommentChange.prototype.isNull = function() {
-  return this.oldContents_ === this.newContents_;
-};
+  /**
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
+   */
+  fromJson(json) {
+    super.fromJson(json);
+    this.oldContents_ = json['oldContents'];
+    this.newContents_ = json['newContents'];
+  }
 
-/**
- * Run a change event.
- * @param {boolean} forward True if run forward, false if run backward (undo).
- */
-CommentChange.prototype.run = function(forward) {
-  const workspace = this.getEventWorkspace_();
-  const comment = workspace.getCommentById(this.commentId);
-  if (!comment) {
-    console.warn('Can\'t change non-existent comment: ' + this.commentId);
-    return;
+  /**
+   * Does this event record any change of state?
+   * @return {boolean} False if something changed.
+   */
+  isNull() {
+    return this.oldContents_ === this.newContents_;
   }
-  const contents = forward ? this.newContents_ : this.oldContents_;
 
-  comment.setContent(contents);
-};
+  /**
+   * Run a change event.
+   * @param {boolean} forward True if run forward, false if run backward (undo).
+   */
+  run(forward) {
+    const workspace = this.getEventWorkspace_();
+    const comment = workspace.getCommentById(this.commentId);
+    if (!comment) {
+      console.warn('Can\'t change non-existent comment: ' + this.commentId);
+      return;
+    }
+    const contents = forward ? this.newContents_ : this.oldContents_;
+
+    comment.setContent(contents);
+  }
+}
 
 registry.register(
     registry.Type.EVENT, eventUtils.COMMENT_CHANGE, CommentChange);

package/core/events/events_comment_create.js

@@ -17,7 +17,6 @@ goog.module('Blockly.Events.CommentCreate');
 
 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 {CommentBase} = goog.require('Blockly.Events.CommentBase');
 /* eslint-disable-next-line no-unused-vars */
@@ -26,55 +25,58 @@ const {WorkspaceComment} = goog.requireType('Blockly.WorkspaceComment');
 
 /**
  * Class for a comment creation event.
- * @param {!WorkspaceComment=} opt_comment The created comment.
- *     Undefined for a blank event.
  * @extends {CommentBase}
- * @constructor
  * @alias Blockly.Events.CommentCreate
  */
-const CommentCreate = function(opt_comment) {
-  CommentCreate.superClass_.constructor.call(this, opt_comment);
-  if (!opt_comment) {
-    return;  // Blank event to be populated by fromJson.
-  }
+class CommentCreate extends CommentBase {
+  /**
+   * @param {!WorkspaceComment=} opt_comment The created comment.
+   *     Undefined for a blank event.
+   */
+  constructor(opt_comment) {
+    super(opt_comment);
 
-  this.xml = opt_comment.toXmlWithXY();
-};
-object.inherits(CommentCreate, CommentBase);
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.COMMENT_CREATE;
 
-/**
- * Type of this event.
- * @type {string}
- */
-CommentCreate.prototype.type = eventUtils.COMMENT_CREATE;
+    if (!opt_comment) {
+      return;  // Blank event to be populated by fromJson.
+    }
 
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-// TODO (#1266): "Full" and "minimal" serialization.
-CommentCreate.prototype.toJson = function() {
-  const json = CommentCreate.superClass_.toJson.call(this);
-  json['xml'] = Xml.domToText(this.xml);
-  return json;
-};
+    this.xml = opt_comment.toXmlWithXY();
+  }
 
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-CommentCreate.prototype.fromJson = function(json) {
-  CommentCreate.superClass_.fromJson.call(this, json);
-  this.xml = Xml.textToDom(json['xml']);
-};
+  // TODO (#1266): "Full" and "minimal" serialization.
+  /**
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
+   */
+  toJson() {
+    const json = super.toJson();
+    json['xml'] = Xml.domToText(this.xml);
+    return json;
+  }
 
-/**
- * Run a creation event.
- * @param {boolean} forward True if run forward, false if run backward (undo).
- */
-CommentCreate.prototype.run = function(forward) {
-  CommentBase.CommentCreateDeleteHelper(this, forward);
-};
+  /**
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
+   */
+  fromJson(json) {
+    super.fromJson(json);
+    this.xml = Xml.textToDom(json['xml']);
+  }
+
+  /**
+   * Run a creation event.
+   * @param {boolean} forward True if run forward, false if run backward (undo).
+   */
+  run(forward) {
+    CommentBase.CommentCreateDeleteHelper(this, forward);
+  }
+}
 
 registry.register(
     registry.Type.EVENT, eventUtils.COMMENT_CREATE, CommentCreate);

package/core/events/events_comment_delete.js

@@ -16,7 +16,6 @@
 goog.module('Blockly.Events.CommentDelete');
 
 const eventUtils = goog.require('Blockly.Events.utils');
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {CommentBase} = goog.require('Blockly.Events.CommentBase');
 /* eslint-disable-next-line no-unused-vars */
@@ -25,53 +24,56 @@ const {WorkspaceComment} = goog.requireType('Blockly.WorkspaceComment');
 
 /**
  * Class for a comment deletion event.
- * @param {!WorkspaceComment=} opt_comment The deleted comment.
- *     Undefined for a blank event.
  * @extends {CommentBase}
- * @constructor
  * @alias Blockly.Events.CommentDelete
  */
-const CommentDelete = function(opt_comment) {
-  CommentDelete.superClass_.constructor.call(this, opt_comment);
-  if (!opt_comment) {
-    return;  // Blank event to be populated by fromJson.
-  }
+class CommentDelete extends CommentBase {
+  /**
+   * @param {!WorkspaceComment=} opt_comment The deleted comment.
+   *     Undefined for a blank event.
+   */
+  constructor(opt_comment) {
+    super(opt_comment);
 
-  this.xml = opt_comment.toXmlWithXY();
-};
-object.inherits(CommentDelete, CommentBase);
+    /**
+     * Type of this event.
+     * @type {string}
+     */
+    this.type = eventUtils.COMMENT_DELETE;
 
-/**
- * Type of this event.
- * @type {string}
- */
-CommentDelete.prototype.type = eventUtils.COMMENT_DELETE;
+    if (!opt_comment) {
+      return;  // Blank event to be populated by fromJson.
+    }
 
-/**
- * Encode the event as JSON.
- * @return {!Object} JSON representation.
- */
-// TODO (#1266): "Full" and "minimal" serialization.
-CommentDelete.prototype.toJson = function() {
-  const json = CommentDelete.superClass_.toJson.call(this);
-  return json;
-};
+    this.xml = opt_comment.toXmlWithXY();
+  }
 
-/**
- * Decode the JSON event.
- * @param {!Object} json JSON representation.
- */
-CommentDelete.prototype.fromJson = function(json) {
-  CommentDelete.superClass_.fromJson.call(this, json);
-};
+  // TODO (#1266): "Full" and "minimal" serialization.
+  /**
+   * Encode the event as JSON.
+   * @return {!Object} JSON representation.
+   */
+  toJson() {
+    const json = super.toJson();
+    return json;
+  }
 
-/**
- * Run a creation event.
- * @param {boolean} forward True if run forward, false if run backward (undo).
- */
-CommentDelete.prototype.run = function(forward) {
-  CommentBase.CommentCreateDeleteHelper(this, !forward);
-};
+  /**
+   * Decode the JSON event.
+   * @param {!Object} json JSON representation.
+   */
+  fromJson(json) {
+    super.fromJson(json);
+  }
+
+  /**
+   * Run a creation event.
+   * @param {boolean} forward True if run forward, false if run backward (undo).
+   */
+  run(forward) {
+    CommentBase.CommentCreateDeleteHelper(this, !forward);
+  }
+}
 
 registry.register(
     registry.Type.EVENT, eventUtils.COMMENT_DELETE, CommentDelete);