blockly 8.0.4-beta.0 → 8.0.5-beta.0

package/core/{flyout_horizontal.js → flyout_horizontal.ts}

@@ -7,51 +7,50 @@
 /**
  * @fileoverview Horizontal flyout tray containing blocks which may be created.
  */
-'use strict';
 
 /**
  * Horizontal flyout tray containing blocks which may be created.
  * @class
  */
-goog.module('Blockly.HorizontalFlyout');
-
-const WidgetDiv = goog.require('Blockly.WidgetDiv');
-const browserEvents = goog.require('Blockly.browserEvents');
-const dropDownDiv = goog.require('Blockly.dropDownDiv');
-const registry = goog.require('Blockly.registry');
-const toolbox = goog.require('Blockly.utils.toolbox');
-/* eslint-disable-next-line no-unused-vars */
-const {Coordinate} = goog.requireType('Blockly.utils.Coordinate');
-const {Flyout} = goog.require('Blockly.Flyout');
-/* eslint-disable-next-line no-unused-vars */
-const {Options} = goog.requireType('Blockly.Options');
-const {Rect} = goog.require('Blockly.utils.Rect');
-const {Scrollbar} = goog.require('Blockly.Scrollbar');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.HorizontalFlyout');
+
+import * as browserEvents from './browser_events.js';
+import * as dropDownDiv from './dropdowndiv.js';
+import {Flyout, FlyoutItem} from './flyout_base.js';
+import type {FlyoutButton} from './flyout_button.js';
+import type {Options} from './options.js';
+import * as registry from './registry.js';
+import {Scrollbar} from './scrollbar.js';
+import type {Coordinate} from './utils/coordinate.js';
+import {Rect} from './utils/rect.js';
+import * as toolbox from './utils/toolbox.js';
+import * as WidgetDiv from './widgetdiv.js';
 
 
 /**
  * Class for a flyout.
- * @extends {Flyout}
  * @alias Blockly.HorizontalFlyout
  */
-class HorizontalFlyout extends Flyout {
-  /**
-   * @param {!Options} workspaceOptions Dictionary of options for the
-   *     workspace.
-   */
-  constructor(workspaceOptions) {
+export class HorizontalFlyout extends Flyout {
+  override horizontalLayout = true;
+  // Record the width for workspace metrics.
+  override width_: AnyDuringMigration;
+
+  // Record the height for workspace metrics and .position.
+  override height_: AnyDuringMigration;
+
+  /** @param workspaceOptions Dictionary of options for the workspace. */
+  constructor(workspaceOptions: Options) {
     super(workspaceOptions);
-    this.horizontalLayout = true;
   }
 
   /**
    * Sets the translation of the flyout to match the scrollbars.
-   * @param {!{x:number,y:number}} xyRatio Contains a y property which is a
-   *     float between 0 and 1 specifying the degree of scrolling and a similar
-   *     x property.
-   * @protected
+   * @param xyRatio Contains a y property which is a float between 0 and 1
+   *     specifying the degree of scrolling and a similar x property.
    */
-  setMetrics_(xyRatio) {
+  protected override setMetrics_(xyRatio: {x: number, y: number}) {
     if (!this.isVisible()) {
       return;
     }
@@ -74,22 +73,22 @@ class HorizontalFlyout extends Flyout {
 
   /**
    * Calculates the x coordinate for the flyout position.
-   * @return {number} X coordinate.
+   * @return X coordinate.
    */
-  getX() {
+  override getX(): number {
     // X is always 0 since this is a horizontal flyout.
     return 0;
   }
 
   /**
    * Calculates the y coordinate for the flyout position.
-   * @return {number} Y coordinate.
+   * @return Y coordinate.
    */
-  getY() {
+  override getY(): number {
     if (!this.isVisible()) {
       return 0;
     }
-    const metricsManager = this.targetWorkspace.getMetricsManager();
+    const metricsManager = this.targetWorkspace!.getMetricsManager();
     const absoluteMetrics = metricsManager.getAbsoluteMetrics();
     const viewMetrics = metricsManager.getViewMetrics();
     const toolboxMetrics = metricsManager.getToolboxMetrics();
@@ -97,15 +96,16 @@ class HorizontalFlyout extends Flyout {
     let y = 0;
     const atTop = this.toolboxPosition_ === toolbox.Position.TOP;
     // If this flyout is not the trashcan flyout (e.g. toolbox or mutator).
-    if (this.targetWorkspace.toolboxPosition === this.toolboxPosition_) {
+    // Trashcan flyout is opposite the main flyout.
+    if (this.targetWorkspace!.toolboxPosition === this.toolboxPosition_) {
       // If there is a category toolbox.
-      if (this.targetWorkspace.getToolbox()) {
+      // Simple (flyout-only) toolbox.
+      if (this.targetWorkspace!.getToolbox()) {
         if (atTop) {
           y = toolboxMetrics.height;
         } else {
           y = viewMetrics.height - this.height_;
         }
-        // Simple (flyout-only) toolbox.
       } else {
         if (atTop) {
           y = 0;
@@ -114,7 +114,6 @@ class HorizontalFlyout extends Flyout {
           y = viewMetrics.height;
         }
       }
-      // Trashcan flyout is opposite the main flyout.
     } else {
       if (atTop) {
         y = 0;
@@ -130,17 +129,13 @@ class HorizontalFlyout extends Flyout {
     return y;
   }
 
-  /**
-   * Move the flyout to the edge of the workspace.
-   */
-  position() {
-    if (!this.isVisible() || !this.targetWorkspace.isVisible()) {
+  /** Move the flyout to the edge of the workspace. */
+  override position() {
+    if (!this.isVisible() || !this.targetWorkspace!.isVisible()) {
       return;
     }
-    const metricsManager = this.targetWorkspace.getMetricsManager();
+    const metricsManager = this.targetWorkspace!.getMetricsManager();
     const targetWorkspaceViewMetrics = metricsManager.getViewMetrics();
-
-    // Record the width for workspace metrics.
     this.width_ = targetWorkspaceViewMetrics.width;
 
     const edgeWidth = targetWorkspaceViewMetrics.width - 2 * this.CORNER_RADIUS;
@@ -155,16 +150,13 @@ class HorizontalFlyout extends Flyout {
 
   /**
    * Create and set the path for the visible boundaries of the flyout.
-   * @param {number} width The width of the flyout, not including the
-   *     rounded corners.
-   * @param {number} height The height of the flyout, not including
-   *     rounded corners.
-   * @private
+   * @param width The width of the flyout, not including the rounded corners.
+   * @param height The height of the flyout, not including rounded corners.
    */
-  setBackgroundPath_(width, height) {
+  private setBackgroundPath_(width: number, height: number) {
     const atTop = this.toolboxPosition_ === toolbox.Position.TOP;
     // Start at top left.
-    const path = ['M 0,' + (atTop ? 0 : this.CORNER_RADIUS)];
+    const path: (string|number)[] = ['M 0,' + (atTop ? 0 : this.CORNER_RADIUS)];
 
     if (atTop) {
       // Top.
@@ -197,22 +189,19 @@ class HorizontalFlyout extends Flyout {
       // Left.
       path.push('z');
     }
-    this.svgBackground_.setAttribute('d', path.join(' '));
+    this.svgBackground_!.setAttribute('d', path.join(' '));
   }
 
-  /**
-   * Scroll the flyout to the top.
-   */
-  scrollToStart() {
+  /** Scroll the flyout to the top. */
+  override scrollToStart() {
     this.workspace_.scrollbar.setX(this.RTL ? Infinity : 0);
   }
 
   /**
    * Scroll the flyout.
-   * @param {!Event} e Mouse wheel scroll event.
-   * @protected
+   * @param e Mouse wheel scroll event.
    */
-  wheel_(e) {
+  protected override wheel_(e: WheelEvent) {
     const scrollDelta = browserEvents.getScrollDeltaPixels(e);
     const delta = scrollDelta.x || scrollDelta.y;
 
@@ -221,14 +210,13 @@ class HorizontalFlyout extends Flyout {
       const scrollMetrics = metricsManager.getScrollMetrics();
       const viewMetrics = metricsManager.getViewMetrics();
 
-      const pos = (viewMetrics.left - scrollMetrics.left) + delta;
+      const pos = viewMetrics.left - scrollMetrics.left + delta;
       this.workspace_.scrollbar.setX(pos);
       // When the flyout moves from a wheel event, hide WidgetDiv and
       // dropDownDiv.
       WidgetDiv.hide();
       dropDownDiv.hideWithoutAnimation();
     }
-
     // Don't scroll the page.
     e.preventDefault();
     // Don't propagate mousewheel event (zooming).
@@ -237,12 +225,11 @@ class HorizontalFlyout extends Flyout {
 
   /**
    * Lay out the blocks in the flyout.
-   * @param {!Array<!Object>} contents The blocks and buttons to lay out.
-   * @param {!Array<number>} gaps The visible gaps between blocks.
-   * @protected
+   * @param contents The blocks and buttons to lay out.
+   * @param gaps The visible gaps between blocks.
    */
-  layout_(contents, gaps) {
-    this.workspace_.scale = this.targetWorkspace.scale;
+  protected override layout_(contents: FlyoutItem[], gaps: number[]) {
+    this.workspace_.scale = this.targetWorkspace!.scale;
     const margin = this.MARGIN;
     let cursorX = margin + this.tabWidth_;
     const cursorY = margin;
@@ -250,37 +237,42 @@ class HorizontalFlyout extends Flyout {
       contents = contents.reverse();
     }
 
-    for (let i = 0, item; (item = contents[i]); i++) {
+    for (let i = 0, item; item = contents[i]; i++) {
       if (item.type === 'block') {
         const block = item.block;
-        const allBlocks = block.getDescendants(false);
-        for (let j = 0, child; (child = allBlocks[j]); j++) {
+        const allBlocks = block!.getDescendants(false);
+        for (let j = 0, child; child = allBlocks[j]; j++) {
           // Mark blocks as being inside a flyout.  This is used to detect and
           // prevent the closure of the flyout if the user right-clicks on such
           // a block.
           child.isInFlyout = true;
         }
-        block.render();
-        const root = block.getSvgRoot();
-        const blockHW = block.getHeightWidth();
-
+        block!.render();
+        const root = block!.getSvgRoot();
+        const blockHW = block!.getHeightWidth();
         // Figure out where to place the block.
-        const tab = block.outputConnection ? this.tabWidth_ : 0;
+        const tab = block!.outputConnection ? this.tabWidth_ : 0;
         let moveX;
         if (this.RTL) {
           moveX = cursorX + blockHW.width;
         } else {
           moveX = cursorX - tab;
         }
-        block.moveBy(moveX, cursorY);
+        block!.moveBy(moveX, cursorY);
 
-        const rect = this.createRect_(block, moveX, cursorY, blockHW, i);
-        cursorX += (blockHW.width + gaps[i]);
+        // AnyDuringMigration because:  Argument of type 'BlockSvg | undefined'
+        // is not assignable to parameter of type 'BlockSvg'.
+        const rect = this.createRect_(
+            block as AnyDuringMigration, moveX, cursorY, blockHW, i);
+        cursorX += blockHW.width + gaps[i];
 
-        this.addBlockListeners_(root, block, rect);
+        // AnyDuringMigration because:  Argument of type 'BlockSvg | undefined'
+        // is not assignable to parameter of type 'BlockSvg'.
+        this.addBlockListeners_(root, block as AnyDuringMigration, rect);
       } else if (item.type === 'button') {
-        this.initFlyoutButton_(item.button, cursorX, cursorY);
-        cursorX += (item.button.width + gaps[i]);
+        const button = item.button as FlyoutButton;
+        this.initFlyoutButton_(button, cursorX, cursorY);
+        cursorX += button.width + gaps[i];
       }
     }
   }
@@ -289,12 +281,12 @@ class HorizontalFlyout extends Flyout {
    * Determine if a drag delta is toward the workspace, based on the position
    * and orientation of the flyout. This is used in determineDragIntention_ to
    * determine if a new block should be created or if the flyout should scroll.
-   * @param {!Coordinate} currentDragDeltaXY How far the pointer has
-   *     moved from the position at mouse down, in pixel units.
-   * @return {boolean} True if the drag is toward the workspace.
-   * @package
+   * @param currentDragDeltaXY How far the pointer has moved from the position
+   *     at mouse down, in pixel units.
+   * @return True if the drag is toward the workspace.
+   * @internal
    */
-  isDragTowardWorkspace(currentDragDeltaXY) {
+  override isDragTowardWorkspace(currentDragDeltaXY: Coordinate): boolean {
     const dx = currentDragDeltaXY.x;
     const dy = currentDragDeltaXY.y;
     // Direction goes from -180 to 180, with 0 toward the right and 90 on top.
@@ -302,8 +294,8 @@ class HorizontalFlyout extends Flyout {
 
     const range = this.dragAngleRange_;
     // Check for up or down dragging.
-    if ((dragDirection < 90 + range && dragDirection > 90 - range) ||
-        (dragDirection > -90 - range && dragDirection < -90 + range)) {
+    if (dragDirection < 90 + range && dragDirection > 90 - range ||
+        dragDirection > -90 - range && dragDirection < -90 + range) {
       return true;
     }
     return false;
@@ -312,10 +304,10 @@ class HorizontalFlyout extends Flyout {
   /**
    * Returns the bounding rectangle of the drag target area in pixel units
    * relative to viewport.
-   * @return {?Rect} The component's bounding box. Null if drag
-   *   target area should be ignored.
+   * @return The component's bounding box. Null if drag target area should be
+   *     ignored.
    */
-  getClientRect() {
+  override getClientRect(): Rect|null {
     if (!this.svgGroup_ || this.autoClose || !this.isVisible()) {
       // The bounding rectangle won't compute correctly if the flyout is closed
       // and auto-close flyouts aren't valid drag targets (or delete areas).
@@ -341,17 +333,16 @@ class HorizontalFlyout extends Flyout {
   /**
    * Compute height of flyout.  toolbox.Position mat under each block.
    * For RTL: Lay out the blocks right-aligned.
-   * @protected
    */
-  reflowInternal_() {
+  protected override reflowInternal_() {
     this.workspace_.scale = this.getFlyoutScale();
     let flyoutHeight = 0;
     const blocks = this.workspace_.getTopBlocks(false);
-    for (let i = 0, block; (block = blocks[i]); i++) {
+    for (let i = 0, block; block = blocks[i]; i++) {
       flyoutHeight = Math.max(flyoutHeight, block.getHeightWidth().height);
     }
     const buttons = this.buttons_;
-    for (let i = 0, button; (button = buttons[i]); i++) {
+    for (let i = 0, button; button = buttons[i]; i++) {
       flyoutHeight = Math.max(flyoutHeight, button.height);
     }
     flyoutHeight += this.MARGIN * 1.5;
@@ -359,27 +350,28 @@ class HorizontalFlyout extends Flyout {
     flyoutHeight += Scrollbar.scrollbarThickness;
 
     if (this.height_ !== flyoutHeight) {
-      for (let i = 0, block; (block = blocks[i]); i++) {
+      for (let i = 0, block; block = blocks[i]; i++) {
         if (this.rectMap_.has(block)) {
-          this.moveRectToBlock_(this.rectMap_.get(block), block);
+          // AnyDuringMigration because:  Argument of type 'SVGElement |
+          // undefined' is not assignable to parameter of type 'SVGElement'.
+          this.moveRectToBlock_(
+              this.rectMap_.get(block) as AnyDuringMigration, block);
         }
       }
 
-      if (this.targetWorkspace.toolboxPosition === this.toolboxPosition_ &&
+      if (this.targetWorkspace!.toolboxPosition === this.toolboxPosition_ &&
           this.toolboxPosition_ === toolbox.Position.TOP &&
-          !this.targetWorkspace.getToolbox()) {
+          !this.targetWorkspace!.getToolbox()) {
         // This flyout is a simple toolbox. Reposition the workspace so that
         // (0,0) is in the correct position relative to the new absolute edge
         // (ie toolbox edge).
-        this.targetWorkspace.translate(
-            this.targetWorkspace.scrollX,
-            this.targetWorkspace.scrollY + flyoutHeight);
+        this.targetWorkspace!.translate(
+            this.targetWorkspace!.scrollX,
+            this.targetWorkspace!.scrollY + flyoutHeight);
       }
-
-      // Record the height for workspace metrics and .position.
       this.height_ = flyoutHeight;
       this.position();
-      this.targetWorkspace.recordDragTargets();
+      this.targetWorkspace!.recordDragTargets();
     }
   }
 }
@@ -387,5 +379,3 @@ class HorizontalFlyout extends Flyout {
 registry.register(
     registry.Type.FLYOUTS_HORIZONTAL_TOOLBOX, registry.DEFAULT,
     HorizontalFlyout);
-
-exports.HorizontalFlyout = HorizontalFlyout;

package/core/flyout_metrics_manager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { IFlyout } from './interfaces/i_flyout.js';
+import { ContainerRegion, MetricsManager } from './metrics_manager.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Calculates metrics for a flyout's workspace.
+ * The metrics are mainly used to size scrollbars for the flyout.
+ * @alias Blockly.FlyoutMetricsManager
+ */
+export declare class FlyoutMetricsManager extends MetricsManager {
+    /** The flyout that owns the workspace to calculate metrics for. */
+    protected flyout_: IFlyout;
+    /**
+     * @param workspace The flyout's workspace.
+     * @param flyout The flyout.
+     */
+    constructor(workspace: WorkspaceSvg, flyout: IFlyout);
+    /**
+     * Gets the bounding box of the blocks on the flyout's workspace.
+     * This is in workspace coordinates.
+     * @return The bounding box of the blocks on the workspace.
+     */
+    private getBoundingBox_;
+    getContentMetrics(opt_getWorkspaceCoordinates: boolean): {
+        height: number;
+        width: number;
+        top: number;
+        left: number;
+    };
+    getScrollMetrics(opt_getWorkspaceCoordinates: boolean, opt_viewMetrics: ContainerRegion, opt_contentMetrics: ContainerRegion): {
+        height: number;
+        width: number;
+        top: number;
+        left: number;
+    };
+}

package/core/{flyout_metrics_manager.js → flyout_metrics_manager.ts}

@@ -7,51 +7,44 @@
 /**
  * @fileoverview Calculates and reports flyout workspace metrics.
  */
-'use strict';
 
 /**
  * Calculates and reports flyout workspace metrics.
  * @class
  */
-goog.module('Blockly.FlyoutMetricsManager');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.FlyoutMetricsManager');
 
-/* eslint-disable-next-line no-unused-vars */
-const {IFlyout} = goog.requireType('Blockly.IFlyout');
-const {MetricsManager} = goog.require('Blockly.MetricsManager');
-/* eslint-disable-next-line no-unused-vars */
-const {WorkspaceSvg} = goog.requireType('Blockly.WorkspaceSvg');
+import type {IFlyout} from './interfaces/i_flyout.js';
+import {ContainerRegion, MetricsManager} from './metrics_manager.js';
+import type {WorkspaceSvg} from './workspace_svg.js';
 
 
 /**
  * Calculates metrics for a flyout's workspace.
  * The metrics are mainly used to size scrollbars for the flyout.
- * @extends {MetricsManager}
  * @alias Blockly.FlyoutMetricsManager
  */
-class FlyoutMetricsManager extends MetricsManager {
+export class FlyoutMetricsManager extends MetricsManager {
+  /** The flyout that owns the workspace to calculate metrics for. */
+  protected flyout_: IFlyout;
+
   /**
-   * @param {!WorkspaceSvg} workspace The flyout's workspace.
-   * @param {!IFlyout} flyout The flyout.
+   * @param workspace The flyout's workspace.
+   * @param flyout The flyout.
    */
-  constructor(workspace, flyout) {
+  constructor(workspace: WorkspaceSvg, flyout: IFlyout) {
     super(workspace);
-
-    /**
-     * The flyout that owns the workspace to calculate metrics for.
-     * @type {!IFlyout}
-     * @protected
-     */
     this.flyout_ = flyout;
   }
 
   /**
    * Gets the bounding box of the blocks on the flyout's workspace.
    * This is in workspace coordinates.
-   * @return {!SVGRect|{height: number, y: number, width: number, x: number}}
-   *     The bounding box of the blocks on the workspace.
-   * @private
+   * @return The bounding box of the blocks on the workspace.
    */
-  getBoundingBox_() {
+  private getBoundingBox_(): SVGRect|
+      {height: number, y: number, width: number, x: number} {
     let blockBoundingBox;
     try {
       blockBoundingBox = this.workspace_.getCanvas().getBBox();
@@ -64,10 +57,7 @@ class FlyoutMetricsManager extends MetricsManager {
     return blockBoundingBox;
   }
 
-  /**
-   * @override
-   */
-  getContentMetrics(opt_getWorkspaceCoordinates) {
+  override getContentMetrics(opt_getWorkspaceCoordinates: boolean) {
     // The bounding box is in workspace coordinates.
     const blockBoundingBox = this.getBoundingBox_();
     const scale = opt_getWorkspaceCoordinates ? 1 : this.workspace_.scale;
@@ -80,12 +70,12 @@ class FlyoutMetricsManager extends MetricsManager {
     };
   }
 
-  /**
-   * @override
-   */
-  getScrollMetrics(
-      opt_getWorkspaceCoordinates, opt_viewMetrics, opt_contentMetrics) {
-    const contentMetrics = opt_contentMetrics || this.getContentMetrics();
+  override getScrollMetrics(
+      opt_getWorkspaceCoordinates: boolean, opt_viewMetrics: ContainerRegion,
+      opt_contentMetrics: ContainerRegion) {
+    // AnyDuringMigration because:  Expected 1 arguments, but got 0.
+    const contentMetrics =
+        opt_contentMetrics || (this.getContentMetrics as AnyDuringMigration)();
     const margin = this.flyout_.MARGIN * this.workspace_.scale;
     const scale = opt_getWorkspaceCoordinates ? this.workspace_.scale : 1;
 
@@ -102,5 +92,3 @@ class FlyoutMetricsManager extends MetricsManager {
     };
   }
 }
-
-exports.FlyoutMetricsManager = FlyoutMetricsManager;

package/core/flyout_vertical.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Flyout, FlyoutItem } from './flyout_base.js';
+import type { Options } from './options.js';
+import type { Coordinate } from './utils/coordinate.js';
+import { Rect } from './utils/rect.js';
+/**
+ * Class for a flyout.
+ * @alias Blockly.VerticalFlyout
+ */
+export declare class VerticalFlyout extends Flyout {
+    /** The name of the vertical flyout in the registry. */
+    static registryName: string;
+    height_: any;
+    width_: any;
+    /** @param workspaceOptions Dictionary of options for the workspace. */
+    constructor(workspaceOptions: Options);
+    /**
+     * Sets the translation of the flyout to match the scrollbars.
+     * @param xyRatio Contains a y property which is a float between 0 and 1
+     *     specifying the degree of scrolling and a similar x property.
+     */
+    protected setMetrics_(xyRatio: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Calculates the x coordinate for the flyout position.
+     * @return X coordinate.
+     */
+    getX(): number;
+    /**
+     * Calculates the y coordinate for the flyout position.
+     * @return Y coordinate.
+     */
+    getY(): number;
+    /** Move the flyout to the edge of the workspace. */
+    position(): void;
+    /**
+     * Create and set the path for the visible boundaries of the flyout.
+     * @param width The width of the flyout, not including the rounded corners.
+     * @param height The height of the flyout, not including rounded corners.
+     */
+    private setBackgroundPath_;
+    /** Scroll the flyout to the top. */
+    scrollToStart(): void;
+    /**
+     * Scroll the flyout.
+     * @param e Mouse wheel scroll event.
+     */
+    protected wheel_(e: WheelEvent): void;
+    /**
+     * Lay out the blocks in the flyout.
+     * @param contents The blocks and buttons to lay out.
+     * @param gaps The visible gaps between blocks.
+     */
+    protected layout_(contents: FlyoutItem[], gaps: number[]): void;
+    /**
+     * Determine if a drag delta is toward the workspace, based on the position
+     * and orientation of the flyout. This is used in determineDragIntention_ to
+     * determine if a new block should be created or if the flyout should scroll.
+     * @param currentDragDeltaXY How far the pointer has moved from the position
+     *     at mouse down, in pixel units.
+     * @return True if the drag is toward the workspace.
+     * @internal
+     */
+    isDragTowardWorkspace(currentDragDeltaXY: Coordinate): boolean;
+    /**
+     * Returns the bounding rectangle of the drag target area in pixel units
+     * relative to viewport.
+     * @return The component's bounding box. Null if drag target area should be
+     *     ignored.
+     */
+    getClientRect(): Rect | null;
+    /**
+     * Compute width of flyout.  toolbox.Position mat under each block.
+     * For RTL: Lay out the blocks and buttons to be right-aligned.
+     */
+    protected reflowInternal_(): void;
+}