blockly 7.20211209.2 → 8.0.0

package/core/keyboard_nav/basic_cursor.js

@@ -17,7 +17,6 @@
  */
 goog.module('Blockly.BasicCursor');
 
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {ASTNode} = goog.require('Blockly.ASTNode');
 const {Cursor} = goog.require('Blockly.Cursor');
@@ -27,196 +26,198 @@ const {Cursor} = goog.require('Blockly.Cursor');
  * Class for a basic cursor.
  * This will allow the user to get to all nodes in the AST by hitting next or
  * previous.
- * @constructor
  * @extends {Cursor}
  * @alias Blockly.BasicCursor
  */
-const BasicCursor = function() {
-  BasicCursor.superClass_.constructor.call(this);
-};
-object.inherits(BasicCursor, Cursor);
-
-/**
- * Name used for registering a basic cursor.
- * @const {string}
- */
-BasicCursor.registrationName = 'basicCursor';
-
-/**
- * Find the next node in the pre order traversal.
- * @return {?ASTNode} The next node, or null if the current node is
- *     not set or there is no next value.
- * @override
- */
-BasicCursor.prototype.next = function() {
-  const curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
+class BasicCursor extends Cursor {
+  /**
+   * @alias Blockly.BasicCursor
+   */
+  constructor() {
+    super();
   }
-  const newNode = this.getNextNode_(curNode, this.validNode_);
 
-  if (newNode) {
-    this.setCurNode(newNode);
+  /**
+   * Find the next node in the pre order traversal.
+   * @return {?ASTNode} The next node, or null if the current node is
+   *     not set or there is no next value.
+   * @override
+   */
+  next() {
+    const curNode = this.getCurNode();
+    if (!curNode) {
+      return null;
+    }
+    const newNode = this.getNextNode_(curNode, this.validNode_);
+
+    if (newNode) {
+      this.setCurNode(newNode);
+    }
+    return newNode;
   }
-  return newNode;
-};
 
-/**
- * For a basic cursor we only have the ability to go next and previous, so
- * in will also allow the user to get to the next node in the pre order
- * traversal.
- * @return {?ASTNode} The next node, or null if the current node is
- *     not set or there is no next value.
- * @override
- */
-BasicCursor.prototype.in = function() {
-  return this.next();
-};
-
-/**
- * Find the previous node in the pre order traversal.
- * @return {?ASTNode} The previous node, or null if the current node
- *     is not set or there is no previous value.
- * @override
- */
-BasicCursor.prototype.prev = function() {
-  const curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
+  /**
+   * For a basic cursor we only have the ability to go next and previous, so
+   * in will also allow the user to get to the next node in the pre order
+   * traversal.
+   * @return {?ASTNode} The next node, or null if the current node is
+   *     not set or there is no next value.
+   * @override
+   */
+  in() {
+    return this.next();
   }
-  const newNode = this.getPreviousNode_(curNode, this.validNode_);
 
-  if (newNode) {
-    this.setCurNode(newNode);
+  /**
+   * Find the previous node in the pre order traversal.
+   * @return {?ASTNode} The previous node, or null if the current node
+   *     is not set or there is no previous value.
+   * @override
+   */
+  prev() {
+    const curNode = this.getCurNode();
+    if (!curNode) {
+      return null;
+    }
+    const newNode = this.getPreviousNode_(curNode, this.validNode_);
+
+    if (newNode) {
+      this.setCurNode(newNode);
+    }
+    return newNode;
   }
-  return newNode;
-};
 
-/**
- * For a basic cursor we only have the ability to go next and previous, so
- * out will allow the user to get to the previous node in the pre order
- * traversal.
- * @return {?ASTNode} The previous node, or null if the current node is
- *     not set or there is no previous value.
- * @override
- */
-BasicCursor.prototype.out = function() {
-  return this.prev();
-};
+  /**
+   * For a basic cursor we only have the ability to go next and previous, so
+   * out will allow the user to get to the previous node in the pre order
+   * traversal.
+   * @return {?ASTNode} The previous node, or null if the current node is
+   *     not set or there is no previous value.
+   * @override
+   */
+  out() {
+    return this.prev();
+  }
 
-/**
- * Uses pre order traversal to navigate the Blockly AST. This will allow
- * a user to easily navigate the entire Blockly AST without having to go in
- * and out levels on the tree.
- * @param {?ASTNode} node The current position in the AST.
- * @param {!function(ASTNode) : boolean} isValid A function true/false
- *     depending on whether the given node should be traversed.
- * @return {?ASTNode} The next node in the traversal.
- * @protected
- */
-BasicCursor.prototype.getNextNode_ = function(node, isValid) {
-  if (!node) {
+  /**
+   * Uses pre order traversal to navigate the Blockly AST. This will allow
+   * a user to easily navigate the entire Blockly AST without having to go in
+   * and out levels on the tree.
+   * @param {?ASTNode} node The current position in the AST.
+   * @param {!function(ASTNode) : boolean} isValid A function true/false
+   *     depending on whether the given node should be traversed.
+   * @return {?ASTNode} The next node in the traversal.
+   * @protected
+   */
+  getNextNode_(node, isValid) {
+    if (!node) {
+      return null;
+    }
+    const newNode = node.in() || node.next();
+    if (isValid(newNode)) {
+      return newNode;
+    } else if (newNode) {
+      return this.getNextNode_(newNode, isValid);
+    }
+    const siblingOrParent = this.findSiblingOrParent_(node.out());
+    if (isValid(siblingOrParent)) {
+      return siblingOrParent;
+    } else if (siblingOrParent) {
+      return this.getNextNode_(siblingOrParent, isValid);
+    }
     return null;
   }
-  const newNode = node.in() || node.next();
-  if (isValid(newNode)) {
-    return newNode;
-  } else if (newNode) {
-    return this.getNextNode_(newNode, isValid);
-  }
-  const siblingOrParent = this.findSiblingOrParent_(node.out());
-  if (isValid(siblingOrParent)) {
-    return siblingOrParent;
-  } else if (siblingOrParent) {
-    return this.getNextNode_(siblingOrParent, isValid);
-  }
-  return null;
-};
 
-/**
- * Reverses the pre order traversal in order to find the previous node. This
- * will allow a user to easily navigate the entire Blockly AST without having to
- * go in and out levels on the tree.
- * @param {?ASTNode} node The current position in the AST.
- * @param {!function(ASTNode) : boolean} isValid A function true/false
- *     depending on whether the given node should be traversed.
- * @return {?ASTNode} The previous node in the traversal or null if no
- *     previous node exists.
- * @protected
- */
-BasicCursor.prototype.getPreviousNode_ = function(node, isValid) {
-  if (!node) {
+  /**
+   * Reverses the pre order traversal in order to find the previous node. This
+   * will allow a user to easily navigate the entire Blockly AST without having
+   * to go in and out levels on the tree.
+   * @param {?ASTNode} node The current position in the AST.
+   * @param {!function(ASTNode) : boolean} isValid A function true/false
+   *     depending on whether the given node should be traversed.
+   * @return {?ASTNode} The previous node in the traversal or null if no
+   *     previous node exists.
+   * @protected
+   */
+  getPreviousNode_(node, isValid) {
+    if (!node) {
+      return null;
+    }
+    let newNode = node.prev();
+
+    if (newNode) {
+      newNode = this.getRightMostChild_(newNode);
+    } else {
+      newNode = node.out();
+    }
+    if (isValid(newNode)) {
+      return newNode;
+    } else if (newNode) {
+      return this.getPreviousNode_(newNode, isValid);
+    }
     return null;
   }
-  let newNode = node.prev();
 
-  if (newNode) {
-    newNode = this.getRightMostChild_(newNode);
-  } else {
-    newNode = node.out();
-  }
-  if (isValid(newNode)) {
-    return newNode;
-  } else if (newNode) {
-    return this.getPreviousNode_(newNode, isValid);
+  /**
+   * Decides what nodes to traverse and which ones to skip. Currently, it
+   * skips output, stack and workspace nodes.
+   * @param {?ASTNode} node The AST node to check whether it is valid.
+   * @return {boolean} True if the node should be visited, false otherwise.
+   * @protected
+   */
+  validNode_(node) {
+    let isValid = false;
+    const type = node && node.getType();
+    if (type === ASTNode.types.OUTPUT || type === ASTNode.types.INPUT ||
+        type === ASTNode.types.FIELD || type === ASTNode.types.NEXT ||
+        type === ASTNode.types.PREVIOUS || type === ASTNode.types.WORKSPACE) {
+      isValid = true;
+    }
+    return isValid;
   }
-  return null;
-};
 
-/**
- * Decides what nodes to traverse and which ones to skip. Currently, it
- * skips output, stack and workspace nodes.
- * @param {?ASTNode} node The AST node to check whether it is valid.
- * @return {boolean} True if the node should be visited, false otherwise.
- * @protected
- */
-BasicCursor.prototype.validNode_ = function(node) {
-  let isValid = false;
-  const type = node && node.getType();
-  if (type === ASTNode.types.OUTPUT || type === ASTNode.types.INPUT ||
-      type === ASTNode.types.FIELD || type === ASTNode.types.NEXT ||
-      type === ASTNode.types.PREVIOUS || type === ASTNode.types.WORKSPACE) {
-    isValid = true;
+  /**
+   * From the given node find either the next valid sibling or parent.
+   * @param {?ASTNode} node The current position in the AST.
+   * @return {?ASTNode} The parent AST node or null if there are no
+   *     valid parents.
+   * @private
+   */
+  findSiblingOrParent_(node) {
+    if (!node) {
+      return null;
+    }
+    const nextNode = node.next();
+    if (nextNode) {
+      return nextNode;
+    }
+    return this.findSiblingOrParent_(node.out());
   }
-  return isValid;
-};
 
-/**
- * From the given node find either the next valid sibling or parent.
- * @param {?ASTNode} node The current position in the AST.
- * @return {?ASTNode} The parent AST node or null if there are no
- *     valid parents.
- * @private
- */
-BasicCursor.prototype.findSiblingOrParent_ = function(node) {
-  if (!node) {
-    return null;
+  /**
+   * Get the right most child of a node.
+   * @param {?ASTNode} node The node to find the right most child of.
+   * @return {?ASTNode} The right most child of the given node, or the node
+   *     if no child exists.
+   * @private
+   */
+  getRightMostChild_(node) {
+    if (!node.in()) {
+      return node;
+    }
+    let newNode = node.in();
+    while (newNode.next()) {
+      newNode = newNode.next();
+    }
+    return this.getRightMostChild_(newNode);
   }
-  const nextNode = node.next();
-  if (nextNode) {
-    return nextNode;
-  }
-  return this.findSiblingOrParent_(node.out());
-};
-
+}
 
 /**
- * Get the right most child of a node.
- * @param {?ASTNode} node The node to find the right most child of.
- * @return {?ASTNode} The right most child of the given node, or the node
- *     if no child exists.
- * @private
+ * Name used for registering a basic cursor.
+ * @const {string}
  */
-BasicCursor.prototype.getRightMostChild_ = function(node) {
-  if (!node.in()) {
-    return node;
-  }
-  let newNode = node.in();
-  while (newNode.next()) {
-    newNode = newNode.next();
-  }
-  return this.getRightMostChild_(newNode);
-};
+BasicCursor.registrationName = 'basicCursor';
 
 registry.register(
     registry.Type.CURSOR, BasicCursor.registrationName, BasicCursor);

package/core/keyboard_nav/cursor.js

@@ -17,7 +17,6 @@
  */
 goog.module('Blockly.Cursor');
 
-const object = goog.require('Blockly.utils.object');
 const registry = goog.require('Blockly.registry');
 const {ASTNode} = goog.require('Blockly.ASTNode');
 const {Marker} = goog.require('Blockly.Marker');
@@ -25,117 +24,120 @@ const {Marker} = goog.require('Blockly.Marker');
 /**
  * Class for a cursor.
  * A cursor controls how a user navigates the Blockly AST.
- * @constructor
  * @extends {Marker}
  * @alias Blockly.Cursor
  */
-const Cursor = function() {
-  Cursor.superClass_.constructor.call(this);
-
+class Cursor extends Marker {
   /**
-   * @override
+   * @alias Blockly.Cursor
    */
-  this.type = 'cursor';
-};
-object.inherits(Cursor, Marker);
-
-/**
- * Find the next connection, field, or block.
- * @return {ASTNode} The next element, or null if the current node is
- *     not set or there is no next value.
- * @public
- */
-Cursor.prototype.next = function() {
-  const curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
-  }
-
-  let newNode = curNode.next();
-  while (newNode && newNode.next() &&
-         (newNode.getType() === ASTNode.types.NEXT ||
-          newNode.getType() === ASTNode.types.BLOCK)) {
-    newNode = newNode.next();
-  }
-
-  if (newNode) {
-    this.setCurNode(newNode);
-  }
-  return newNode;
-};
-
-/**
- * Find the in connection or field.
- * @return {ASTNode} The in element, or null if the current node is
- *     not set or there is no in value.
- * @public
- */
-Cursor.prototype.in = function() {
-  let curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
-  }
-  // If we are on a previous or output connection, go to the block level before
-  // performing next operation.
-  if (curNode.getType() === ASTNode.types.PREVIOUS ||
-      curNode.getType() === ASTNode.types.OUTPUT) {
-    curNode = curNode.next();
-  }
-  const newNode = curNode.in();
-
-  if (newNode) {
-    this.setCurNode(newNode);
-  }
-  return newNode;
-};
-
-/**
- * Find the previous connection, field, or block.
- * @return {ASTNode} The previous element, or null if the current node
- *     is not set or there is no previous value.
- * @public
- */
-Cursor.prototype.prev = function() {
-  const curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
-  }
-  let newNode = curNode.prev();
+  constructor() {
+    super();
 
-  while (newNode && newNode.prev() &&
-         (newNode.getType() === ASTNode.types.NEXT ||
-          newNode.getType() === ASTNode.types.BLOCK)) {
-    newNode = newNode.prev();
+    /**
+     * @override
+     */
+    this.type = 'cursor';
   }
 
-  if (newNode) {
-    this.setCurNode(newNode);
+  /**
+   * Find the next connection, field, or block.
+   * @return {ASTNode} The next element, or null if the current node is
+   *     not set or there is no next value.
+   * @public
+   */
+  next() {
+    const curNode = this.getCurNode();
+    if (!curNode) {
+      return null;
+    }
+
+    let newNode = curNode.next();
+    while (newNode && newNode.next() &&
+           (newNode.getType() === ASTNode.types.NEXT ||
+            newNode.getType() === ASTNode.types.BLOCK)) {
+      newNode = newNode.next();
+    }
+
+    if (newNode) {
+      this.setCurNode(newNode);
+    }
+    return newNode;
   }
-  return newNode;
-};
 
-/**
- * Find the out connection, field, or block.
- * @return {ASTNode} The out element, or null if the current node is
- *     not set or there is no out value.
- * @public
- */
-Cursor.prototype.out = function() {
-  const curNode = this.getCurNode();
-  if (!curNode) {
-    return null;
+  /**
+   * Find the in connection or field.
+   * @return {ASTNode} The in element, or null if the current node is
+   *     not set or there is no in value.
+   * @public
+   */
+  in() {
+    let curNode = this.getCurNode();
+    if (!curNode) {
+      return null;
+    }
+    // If we are on a previous or output connection, go to the block level
+    // before performing next operation.
+    if (curNode.getType() === ASTNode.types.PREVIOUS ||
+        curNode.getType() === ASTNode.types.OUTPUT) {
+      curNode = curNode.next();
+    }
+    const newNode = curNode.in();
+
+    if (newNode) {
+      this.setCurNode(newNode);
+    }
+    return newNode;
   }
-  let newNode = curNode.out();
 
-  if (newNode && newNode.getType() === ASTNode.types.BLOCK) {
-    newNode = newNode.prev() || newNode;
+  /**
+   * Find the previous connection, field, or block.
+   * @return {ASTNode} The previous element, or null if the current node
+   *     is not set or there is no previous value.
+   * @public
+   */
+  prev() {
+    const curNode = this.getCurNode();
+    if (!curNode) {
+      return null;
+    }
+    let newNode = curNode.prev();
+
+    while (newNode && newNode.prev() &&
+           (newNode.getType() === ASTNode.types.NEXT ||
+            newNode.getType() === ASTNode.types.BLOCK)) {
+      newNode = newNode.prev();
+    }
+
+    if (newNode) {
+      this.setCurNode(newNode);
+    }
+    return newNode;
   }
 
-  if (newNode) {
-    this.setCurNode(newNode);
+  /**
+   * Find the out connection, field, or block.
+   * @return {ASTNode} The out element, or null if the current node is
+   *     not set or there is no out value.
+   * @public
+   */
+  out() {
+    const curNode = this.getCurNode();
+    if (!curNode) {
+      return null;
+    }
+    let newNode = curNode.out();
+
+    if (newNode && newNode.getType() === ASTNode.types.BLOCK) {
+      newNode = newNode.prev() || newNode;
+    }
+
+    if (newNode) {
+      this.setCurNode(newNode);
+    }
+    return newNode;
   }
-  return newNode;
-};
+}
 
 registry.register(registry.Type.CURSOR, registry.DEFAULT, Cursor);