refactor(interfaces): Make type predicates more robust (#9150)

* refactor(interfaces): Use typeof ... === 'function' to test for methods

  Testing for

      'name' in object

  or

      obj.name !== undefined

  only checks for the existence of the property (and in the latter
  case that the property is not set to undefined).  That's fine if
  the interface specifies a property of indeterminate type, but in
  the usual case that the interface member is a method we can do
  one better and check to make sure the property's value is
  callable.

* refactor(interfaces): Always check obj is not null/undefined

  Since most type predicates take an argument of type any but then
  check for the existence of certain properties, explicitly check
  that the argument is not null or undefined (or check implicitly
  by calling another type predicate that does so first, which
  necessitates adding a few casts because tsc infers the type of
  the argument too narrowly).

* fix(interfaces): Add missing check to hasBubble type predicate

  This appears to have inadvertently been omitted in PR #9004.

* fix(interfaces): Fix misplaced typeof

* fix: Fix typos in JSDocs

* fix(tests): Make Mocks conform to corresponding interfaces

  Introduce a new MockFocusable, and add methods to MockIcon,
  MockBubbleIcon and MockComment, so that they fulfil the
  IFocusableNode, IIcon, IHasBubble and ICommentIcon interfaces
  respectively.

* chore(tests): Add assertions verifying mocks conform to predicates

  Add (test) runtime assertions that:

  - isFocusableNode(MockFocusable) returns true
  - isIcon(MockIcon) returns true
  - hasBubble(MockBubbleIcon) returns true
  - isCommentIcon(MockCommentIcon) returns true

  (The latter is currently failing because Blockly is undefined when
  isCommentIcon calls the MockCommentIcon's getType method.)

* fix(tests): Don't rely on Blockly being set in Mock methods

  For some reason the global Blockly binding is not visible at the
  time when isCommentIcon calls MockCommentIcon's getType method,
  and presumably this problem would apply to getBubbleSize too,
  so directly import the required items.

* refactor(tests): Make MockCommentIcon a MockBubbleIcon

  This slightly simplifies it and makes it less likely to accidentally
  stop conforming to IHasBubble.

* fix(interfaces): Fix incorrect check in isSelectable

  Fix an error which caused ISelectable instances to fail
  isSelectable() checks, one of the results of which is that
  Blockly.common.getSelected() would generally return null.

  Whoops!

tests/mocha/block_test.js

@@ -7,7 +7,10 @@
 import {ConnectionType} from '../../build/src/core/connection_type.js';
 import {EventType} from '../../build/src/core/events/type.js';
 import * as eventUtils from '../../build/src/core/events/utils.js';
+import {IconType} from '../../build/src/core/icons/icon_types.js';
 import {EndRowInput} from '../../build/src/core/inputs/end_row_input.js';
+import {isCommentIcon} from '../../build/src/core/interfaces/i_comment_icon.js';
+import {Size} from '../../build/src/core/utils/size.js';
 import {assert} from '../../node_modules/chai/chai.js';
 import {createRenderedBlock} from './test_helpers/block_definitions.js';
 import {
@@ -1426,9 +1429,9 @@ suite('Blocks', function () {
     });
 
     suite('Constructing registered comment classes', function () {
-      class MockComment extends MockIcon {
+      class MockComment extends MockBubbleIcon {
         getType() {
-          return Blockly.icons.IconType.COMMENT;
+          return IconType.COMMENT;
         }
 
         setText() {}
@@ -1440,19 +1443,13 @@ suite('Blocks', function () {
         setBubbleSize() {}
 
         getBubbleSize() {
-          return Blockly.utils.Size(0, 0);
+          return Size(0, 0);
         }
 
         setBubbleLocation() {}
 
         getBubbleLocation() {}
 
-        bubbleIsVisible() {
-          return true;
-        }
-
-        setBubbleVisible() {}
-
         saveState() {
           return {};
         }
@@ -1460,6 +1457,10 @@ suite('Blocks', function () {
         loadState() {}
       }
 
+      if (!isCommentIcon(new MockComment())) {
+        throw new TypeError('MockComment not an ICommentIcon');
+      }
+
       setup(function () {
         this.workspace = Blockly.inject('blocklyDiv', {});
 

tests/mocha/test_helpers/icon_mocks.js

@@ -4,7 +4,24 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-export class MockIcon {
+import {isFocusableNode} from '../../../build/src/core/interfaces/i_focusable_node.js';
+import {hasBubble} from '../../../build/src/core/interfaces/i_has_bubble.js';
+import {isIcon} from '../../../build/src/core/interfaces/i_icon.js';
+import {isSerializable} from '../../../build/src/core/interfaces/i_serializable.js';
+
+export class MockFocusable {
+  getFocusableElement() {}
+  getFocusableTree() {}
+  onNodeFocus() {}
+  onNodeBlur() {}
+  canBeFocused() {}
+}
+
+if (!isFocusableNode(new MockFocusable())) {
+  throw new TypeError('MockFocusable not an IFocuableNode');
+}
+
+export class MockIcon extends MockFocusable {
   getType() {
     return new Blockly.icons.IconType('mock icon');
   }
@@ -52,6 +69,10 @@ export class MockIcon {
   }
 }
 
+if (!isIcon(new MockIcon())) {
+  throw new TypeError('MockIcon not an IIcon');
+}
+
 export class MockSerializableIcon extends MockIcon {
   constructor() {
     super();
@@ -75,6 +96,10 @@ export class MockSerializableIcon extends MockIcon {
   }
 }
 
+if (!isSerializable(new MockSerializableIcon())) {
+  throw new TypeError('MockSerializableIcon not an ISerializable');
+}
+
 export class MockBubbleIcon extends MockIcon {
   constructor() {
     super();
@@ -94,4 +119,12 @@ export class MockBubbleIcon extends MockIcon {
   setBubbleVisible(visible) {
     this.visible = visible;
   }
+
+  getBubble() {
+    return null;
+  }
+}
+
+if (!hasBubble(new MockBubbleIcon())) {
+  throw new TypeError('MockBubbleIcon not an IHasBubble');
 }