nodeskini 1.0.0 → 1.0.2

package/blocklySkini/blockly/core/keyboard_nav/basic_cursor.js

@@ -0,0 +1,208 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The class representing a basic cursor.
+ * Used to demo switching between different cursors.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+'use strict';
+
+goog.provide('Blockly.BasicCursor');
+
+goog.require('Blockly.ASTNode');
+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 {Blockly.Cursor}
+ */
+Blockly.BasicCursor = function() {
+  Blockly.BasicCursor.superClass_.constructor.call(this);
+};
+Blockly.utils.object.inherits(Blockly.BasicCursor, Blockly.Cursor);
+
+/**
+ * Find the next node in the pre order traversal.
+ * @return {Blockly.ASTNode} The next node, or null if the current node is
+ *     not set or there is no next value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.next = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getNextNode_(curNode, this.validNode_);
+
+  if (newNode) {
+    this.setCurNode(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 {Blockly.ASTNode} The next node, or null if the current node is
+ *     not set or there is no next value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.in = function() {
+  return this.next();
+};
+
+/**
+ * Find the previous node in the pre order traversal.
+ * @return {Blockly.ASTNode} The previous node, or null if the current node
+ *     is not set or there is no previous value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.prev = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = this.getPreviousNode_(curNode, this.validNode_);
+
+  if (newNode) {
+    this.setCurNode(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 {Blockly.ASTNode} The previous node, or null if the current node is
+ *     not set or there is no previous value.
+ * @override
+ */
+Blockly.BasicCursor.prototype.out = function() {
+  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 {Blockly.ASTNode} node The current position in the AST.
+ * @param {!function(Blockly.ASTNode) : boolean} isValid A function true/false
+ *     depending on whether the given node should be traversed.
+ * @return {Blockly.ASTNode} The next node in the traversal.
+ * @protected
+ */
+Blockly.BasicCursor.prototype.getNextNode_ = function(node, isValid) {
+  if (!node) {
+    return null;
+  }
+  var newNode = node.in() || node.next();
+  if (isValid(newNode)) {
+    return newNode;
+  } else if (newNode) {
+    return this.getNextNode_(newNode, isValid);
+  }
+  var 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 {Blockly.ASTNode} node The current position in the AST.
+ * @param {!function(Blockly.ASTNode) : boolean} isValid A function true/false
+ *     depending on whether the given node should be traversed.
+ * @return {Blockly.ASTNode} The previous node in the traversal or null if no
+ *     previous node exists.
+ * @protected
+ */
+Blockly.BasicCursor.prototype.getPreviousNode_ = function(node, isValid) {
+  if (!node) {
+    return null;
+  }
+  var 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;
+};
+
+/**
+ * Decides what nodes to traverse and which ones to skip. Currently, it
+ * skips output, stack and workspace nodes.
+ * @param {Blockly.ASTNode} node The AST node to check whether it is valid.
+ * @return {boolean} True if the node should be visited, false otherwise.
+ * @protected
+ */
+Blockly.BasicCursor.prototype.validNode_ = function(node) {
+  var isValid = false;
+  var type = node && node.getType();
+  if (type == Blockly.ASTNode.types.OUTPUT ||
+      type == Blockly.ASTNode.types.INPUT ||
+      type == Blockly.ASTNode.types.FIELD ||
+      type == Blockly.ASTNode.types.NEXT ||
+      type == Blockly.ASTNode.types.PREVIOUS ||
+      type == Blockly.ASTNode.types.WORKSPACE) {
+    isValid = true;
+  }
+  return isValid;
+};
+
+/**
+ * From the given node find either the next valid sibling or parent.
+ * @param {Blockly.ASTNode} node The current position in the AST.
+ * @return {Blockly.ASTNode} The parent AST node or null if there are no
+ *     valid parents.
+ * @private
+ */
+Blockly.BasicCursor.prototype.findSiblingOrParent_ = function(node) {
+  if (!node) {
+    return null;
+  }
+  var nextNode = node.next();
+  if (nextNode) {
+    return nextNode;
+  }
+  return this.findSiblingOrParent_(node.out());
+};
+
+
+/**
+ * Get the right most child of a node.
+ * @param {Blockly.ASTNode} node The node to find the right most child of.
+ * @return {Blockly.ASTNode} The right most child of the given node, or the node
+ *     if no child exists.
+ * @private
+ */
+Blockly.BasicCursor.prototype.getRightMostChild_ = function(node) {
+  if (!node.in()) {
+    return node;
+  }
+  var newNode = node.in();
+  while (newNode.next()) {
+    newNode = newNode.next();
+  }
+  return this.getRightMostChild_(newNode);
+
+};

package/blocklySkini/blockly/core/keyboard_nav/cursor.js

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The class representing a cursor.
+ * Used primarily for keyboard navigation.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+'use strict';
+
+goog.provide('Blockly.Cursor');
+
+goog.require('Blockly.Action');
+goog.require('Blockly.ASTNode');
+goog.require('Blockly.Marker');
+goog.require('Blockly.navigation');
+goog.require('Blockly.utils.object');
+
+goog.requireType('Blockly.IBlocklyActionable');
+
+
+/**
+ * Class for a cursor.
+ * A cursor controls how a user navigates the Blockly AST.
+ * @constructor
+ * @extends {Blockly.Marker}
+ * @implements {Blockly.IBlocklyActionable}
+ */
+Blockly.Cursor = function() {
+  Blockly.Cursor.superClass_.constructor.call(this);
+
+  /**
+   * @override
+   */
+  this.type = 'cursor';
+};
+Blockly.utils.object.inherits(Blockly.Cursor, Blockly.Marker);
+
+/**
+ * Find the next connection, field, or block.
+ * @return {Blockly.ASTNode} The next element, or null if the current node is
+ *     not set or there is no next value.
+ * @protected
+ */
+Blockly.Cursor.prototype.next = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+
+  var newNode = curNode.next();
+  while (newNode && newNode.next() &&
+    (newNode.getType() == Blockly.ASTNode.types.NEXT ||
+    newNode.getType() == Blockly.ASTNode.types.BLOCK)) {
+    newNode = newNode.next();
+  }
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * Find the in connection or field.
+ * @return {Blockly.ASTNode} The in element, or null if the current node is
+ *     not set or there is no in value.
+ * @protected
+ */
+Blockly.Cursor.prototype.in = function() {
+  var 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() == Blockly.ASTNode.types.PREVIOUS ||
+    curNode.getType() == Blockly.ASTNode.types.OUTPUT) {
+    curNode = curNode.next();
+  }
+  var newNode = curNode.in();
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * Find the previous connection, field, or block.
+ * @return {Blockly.ASTNode} The previous element, or null if the current node
+ *     is not set or there is no previous value.
+ * @protected
+ */
+Blockly.Cursor.prototype.prev = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = curNode.prev();
+
+  while (newNode && newNode.prev() &&
+    (newNode.getType() == Blockly.ASTNode.types.NEXT ||
+    newNode.getType() == Blockly.ASTNode.types.BLOCK)) {
+    newNode = newNode.prev();
+  }
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * Find the out connection, field, or block.
+ * @return {Blockly.ASTNode} The out element, or null if the current node is
+ *     not set or there is no out value.
+ * @protected
+ */
+Blockly.Cursor.prototype.out = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = curNode.out();
+
+  if (newNode && newNode.getType() == Blockly.ASTNode.types.BLOCK) {
+    newNode = newNode.prev() || newNode;
+  }
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * Handles the given action.
+ * This is only triggered when keyboard navigation is enabled.
+ * @param {!Blockly.Action} action The action to be handled.
+ * @return {boolean} True if the action has been handled, false otherwise.
+ */
+Blockly.Cursor.prototype.onBlocklyAction = function(action) {
+  // If we are on a field give it the option to handle the action
+  if (this.getCurNode() &&
+      this.getCurNode().getType() === Blockly.ASTNode.types.FIELD &&
+      (/** @type {!Blockly.Field} */ (this.getCurNode().getLocation()))
+          .onBlocklyAction(action)) {
+    return true;
+  }
+  switch (action.name) {
+    case Blockly.navigation.actionNames.PREVIOUS:
+      this.prev();
+      return true;
+    case Blockly.navigation.actionNames.OUT:
+      this.out();
+      return true;
+    case Blockly.navigation.actionNames.NEXT:
+      this.next();
+      return true;
+    case Blockly.navigation.actionNames.IN:
+      this.in();
+      return true;
+    default:
+      return false;
+  }
+};

package/blocklySkini/blockly/core/keyboard_nav/flyout_cursor.js

@@ -0,0 +1,106 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The class representing a cursor used to navigate the flyout.
+ * Used primarily for keyboard navigation.
+ * @author aschmiedt@google.com (Abby Schmiedt)
+ */
+'use strict';
+
+goog.provide('Blockly.FlyoutCursor');
+
+goog.require('Blockly.Cursor');
+goog.require('Blockly.navigation');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Class for a flyout cursor.
+ * This controls how a user navigates blocks in the flyout.
+ * @constructor
+ * @extends {Blockly.Cursor}
+ */
+Blockly.FlyoutCursor = function() {
+  Blockly.FlyoutCursor.superClass_.constructor.call(this);
+};
+Blockly.utils.object.inherits(Blockly.FlyoutCursor, Blockly.Cursor);
+
+/**
+ * Handles the given action.
+ * This is only triggered when keyboard navigation is enabled.
+ * @param {!Blockly.Action} action The action to be handled.
+ * @return {boolean} True if the action has been handled, false otherwise.
+ * @override
+ */
+Blockly.FlyoutCursor.prototype.onBlocklyAction = function(action) {
+  switch (action.name) {
+    case Blockly.navigation.actionNames.PREVIOUS:
+      this.prev();
+      return true;
+    case Blockly.navigation.actionNames.NEXT:
+      this.next();
+      return true;
+    default:
+      return false;
+  }
+};
+
+/**
+ * Find the next connection, field, or block.
+ * @return {Blockly.ASTNode} The next element, or null if the current node is
+ *     not set or there is no next value.
+ * @override
+ */
+Blockly.FlyoutCursor.prototype.next = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = curNode.next();
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * This is a  no-op since a flyout cursor can not go in.
+ * @return {null} Always null.
+ * @override
+ */
+Blockly.FlyoutCursor.prototype.in = function() {
+  return null;
+};
+
+/**
+ * Find the previous connection, field, or block.
+ * @return {Blockly.ASTNode} The previous element, or null if the current node
+ *     is not set or there is no previous value.
+ * @override
+ */
+Blockly.FlyoutCursor.prototype.prev = function() {
+  var curNode = this.getCurNode();
+  if (!curNode) {
+    return null;
+  }
+  var newNode = curNode.prev();
+
+  if (newNode) {
+    this.setCurNode(newNode);
+  }
+  return newNode;
+};
+
+/**
+ * This is a  no-op since a flyout cursor can not go out.
+ * @return {null} Always null.
+ * @override
+ */
+Blockly.FlyoutCursor.prototype.out = function() {
+  return null;
+};

package/blocklySkini/blockly/core/keyboard_nav/key_map.js

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The namespace used to keep track of keyboard actions and the
+ * key codes used to execute those actions.
+ * This is used primarily for keyboard navigation.
+ */
+'use strict';
+
+goog.provide('Blockly.user.keyMap');
+
+// TODO: Fix circular dependency.
+// goog.require('Blockly.navigation');
+goog.require('Blockly.utils.KeyCodes');
+goog.require('Blockly.utils.object');
+
+
+/**
+ * Holds the serialized key to key action mapping.
+ * @type {!Object<string, Blockly.Action>}
+ * @private
+ */
+Blockly.user.keyMap.map_ = {};
+
+/**
+ * Object holding valid modifiers.
+ * @enum {string}
+ */
+Blockly.user.keyMap.modifierKeys = {
+  SHIFT: 'Shift',
+  CONTROL: 'Control',
+  ALT: 'Alt',
+  META: 'Meta'
+};
+
+/**
+ * Update the key map to contain the new action.
+ * @param {string} keyCode The key code serialized by the serializeKeyEvent.
+ * @param {!Blockly.Action} action The action to be executed when the keys
+ *     corresponding to the serialized key code is pressed.
+ */
+Blockly.user.keyMap.setActionForKey = function(keyCode, action) {
+  var oldKey = Blockly.user.keyMap.getKeyByAction(action);
+  // If the action already exists in the key map remove it and add the new mapping.
+  if (oldKey) {
+    delete Blockly.user.keyMap.map_[oldKey];
+  }
+  Blockly.user.keyMap.map_[keyCode] = action;
+};
+
+/**
+ * Creates a new key map.
+ * @param {!Object<string, Blockly.Action>} keyMap The object holding the key
+ *     to action mapping.
+ */
+Blockly.user.keyMap.setKeyMap = function(keyMap) {
+  Blockly.user.keyMap.map_ = keyMap;
+};
+
+/**
+ * Gets the current key map.
+ * @return {Object<string,Blockly.Action>} The object holding the key to
+ *     action mapping.
+ */
+Blockly.user.keyMap.getKeyMap = function() {
+  var map = {};
+  Blockly.utils.object.mixin(map, Blockly.user.keyMap.map_);
+  return map;
+};
+
+/**
+ * Get the action by the serialized key code.
+ * @param {string} keyCode The serialized key code.
+ * @return {Blockly.Action|undefined} The action holding the function to
+ *     call when the given keyCode is used or undefined if no action exists.
+ */
+Blockly.user.keyMap.getActionByKeyCode = function(keyCode) {
+  return Blockly.user.keyMap.map_[keyCode];
+};
+
+/**
+ * Get the serialized key that corresponds to the action.
+ * @param {!Blockly.Action} action The action for which we want to get
+ *     the key.
+ * @return {?string} The serialized key or null if the action does not have
+ *     a key mapping.
+ */
+Blockly.user.keyMap.getKeyByAction = function(action) {
+  var keys = Object.keys(Blockly.user.keyMap.map_);
+  for (var i = 0, key; (key = keys[i]); i++) {
+    if (Blockly.user.keyMap.map_[key].name === action.name) {
+      return key;
+    }
+  }
+  return null;
+};
+
+/**
+ * Serialize the key event.
+ * @param {!KeyboardEvent} e A key up event holding the key code.
+ * @return {string} A string containing the serialized key event.
+ * @package
+ */
+Blockly.user.keyMap.serializeKeyEvent = function(e) {
+  var modifiers = Blockly.utils.object.values(Blockly.user.keyMap.modifierKeys);
+  var key = '';
+  for (var i = 0, keyName; (keyName = modifiers[i]); i++) {
+    if (e.getModifierState(keyName)) {
+      key += keyName;
+    }
+  }
+  key += e.keyCode;
+  return key;
+};
+
+/**
+ * Checks whether any of the given modifiers are not valid.
+ * @param {!Array.<string>} modifiers List of modifiers to be used with the key.
+ * @param {!Array.<string>} validModifiers List of modifiers we support.
+ * @throws {Error} if the modifier is not in the valid modifiers list.
+ * @private
+ */
+Blockly.user.keyMap.checkModifiers_ = function(modifiers, validModifiers) {
+  for (var i = 0, modifier; (modifier = modifiers[i]); i++) {
+    if (validModifiers.indexOf(modifier) < 0) {
+      throw Error(modifier + ' is not a valid modifier key.');
+    }
+  }
+};
+
+/**
+ * Create the serialized key code that will be used in the key map.
+ * @param {number} keyCode Number code representing the key.
+ * @param {!Array.<string>} modifiers List of modifiers to be used with the key.
+ *     All valid modifiers can be found in the Blockly.user.keyMap.modifierKeys.
+ * @return {string} The serialized key code for the given modifiers and key.
+ */
+Blockly.user.keyMap.createSerializedKey = function(keyCode, modifiers) {
+  var key = '';
+  var validModifiers = Blockly.utils.object.values(Blockly.user.keyMap.modifierKeys);
+  Blockly.user.keyMap.checkModifiers_(modifiers, validModifiers);
+  for (var i = 0, validModifier; (validModifier = validModifiers[i]); i++) {
+    if (modifiers.indexOf(validModifier) > -1) {
+      key += validModifier;
+    }
+  }
+  key += keyCode;
+  return key;
+};
+
+/**
+ * Creates the default key map.
+ * @return {!Object<string,Blockly.Action>} An object holding the default key
+ *     to action mapping.
+ */
+Blockly.user.keyMap.createDefaultKeyMap = function() {
+  var map = {};
+  var controlK = Blockly.user.keyMap.createSerializedKey(
+      Blockly.utils.KeyCodes.K, [Blockly.user.keyMap.modifierKeys.CONTROL,
+        Blockly.user.keyMap.modifierKeys.SHIFT]);
+  var shiftW = Blockly.user.keyMap.createSerializedKey(
+      Blockly.utils.KeyCodes.W, [Blockly.user.keyMap.modifierKeys.SHIFT]);
+  var shiftA = Blockly.user.keyMap.createSerializedKey(
+      Blockly.utils.KeyCodes.A, [Blockly.user.keyMap.modifierKeys.SHIFT]);
+  var shiftS = Blockly.user.keyMap.createSerializedKey(
+      Blockly.utils.KeyCodes.S, [Blockly.user.keyMap.modifierKeys.SHIFT]);
+  var shiftD = Blockly.user.keyMap.createSerializedKey(
+      Blockly.utils.KeyCodes.D, [Blockly.user.keyMap.modifierKeys.SHIFT]);
+
+  map[Blockly.utils.KeyCodes.W] = Blockly.navigation.ACTION_PREVIOUS;
+  map[Blockly.utils.KeyCodes.A] = Blockly.navigation.ACTION_OUT;
+  map[Blockly.utils.KeyCodes.S] = Blockly.navigation.ACTION_NEXT;
+  map[Blockly.utils.KeyCodes.D] = Blockly.navigation.ACTION_IN;
+  map[Blockly.utils.KeyCodes.I] = Blockly.navigation.ACTION_INSERT;
+  map[Blockly.utils.KeyCodes.ENTER] = Blockly.navigation.ACTION_MARK;
+  map[Blockly.utils.KeyCodes.X] = Blockly.navigation.ACTION_DISCONNECT;
+  map[Blockly.utils.KeyCodes.T] = Blockly.navigation.ACTION_TOOLBOX;
+  map[Blockly.utils.KeyCodes.E] = Blockly.navigation.ACTION_EXIT;
+  map[Blockly.utils.KeyCodes.ESC] = Blockly.navigation.ACTION_EXIT;
+  map[controlK] = Blockly.navigation.ACTION_TOGGLE_KEYBOARD_NAV;
+  map[shiftW] = Blockly.navigation.ACTION_MOVE_WS_CURSOR_UP;
+  map[shiftA] = Blockly.navigation.ACTION_MOVE_WS_CURSOR_LEFT;
+  map[shiftS] = Blockly.navigation.ACTION_MOVE_WS_CURSOR_DOWN;
+  map[shiftD] = Blockly.navigation.ACTION_MOVE_WS_CURSOR_RIGHT;
+  return map;
+};