blockly 8.0.4 → 8.0.5-beta.0

package/core/variables_dynamic.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Workspace } from './workspace.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * String for use in the "custom" attribute of a category in toolbox XML.
+ * This string indicates that the category should be dynamically populated with
+ * variable blocks.
+ * See also Blockly.Variables.CATEGORY_NAME and
+ * Blockly.Procedures.CATEGORY_NAME.
+ * @alias Blockly.VariablesDynamic.CATEGORY_NAME
+ */
+export declare const CATEGORY_NAME = "VARIABLE_DYNAMIC";
+declare function stringButtonClickHandler(button: any): void;
+export declare const onCreateVariableButtonClick_String: typeof stringButtonClickHandler;
+declare function numberButtonClickHandler(button: any): void;
+export declare const onCreateVariableButtonClick_Number: typeof numberButtonClickHandler;
+declare function colourButtonClickHandler(button: any): void;
+export declare const onCreateVariableButtonClick_Colour: typeof colourButtonClickHandler;
+/**
+ * Construct the elements (blocks and button) required by the flyout for the
+ * variable category.
+ * @param workspace The workspace containing variables.
+ * @return Array of XML elements.
+ * @alias Blockly.VariablesDynamic.flyoutCategory
+ */
+export declare function flyoutCategory(workspace: WorkspaceSvg): Element[];
+/**
+ * Construct the blocks required by the flyout for the variable category.
+ * @param workspace The workspace containing variables.
+ * @return Array of XML block elements.
+ * @alias Blockly.VariablesDynamic.flyoutCategoryBlocks
+ */
+export declare function flyoutCategoryBlocks(workspace: Workspace): Element[];
+export {};

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

@@ -6,26 +6,23 @@
 
 /**
  * @fileoverview Utility functions for handling typed variables.
- *
  */
-'use strict';
 
 /**
  * Utility functions for handling typed variables.
  *
  * @namespace Blockly.VariablesDynamic
  */
-goog.module('Blockly.VariablesDynamic');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.VariablesDynamic');
 
-const Variables = goog.require('Blockly.Variables');
-const xml = goog.require('Blockly.utils.xml');
-const {Blocks} = goog.require('Blockly.blocks');
-const {Msg} = goog.require('Blockly.Msg');
-const {VariableModel} = goog.require('Blockly.VariableModel');
-/* eslint-disable-next-line no-unused-vars */
-const {Workspace} = goog.requireType('Blockly.Workspace');
-/* eslint-disable-next-line no-unused-vars */
-const {WorkspaceSvg} = goog.requireType('Blockly.WorkspaceSvg');
+import {Blocks} from './blocks.js';
+import {Msg} from './msg.js';
+import * as xml from './utils/xml.js';
+import {VariableModel} from './variable_model.js';
+import * as Variables from './variables.js';
+import type {Workspace} from './workspace.js';
+import type {WorkspaceSvg} from './workspace_svg.js';
 
 
 /**
@@ -34,39 +31,36 @@ const {WorkspaceSvg} = goog.requireType('Blockly.WorkspaceSvg');
  * variable blocks.
  * See also Blockly.Variables.CATEGORY_NAME and
  * Blockly.Procedures.CATEGORY_NAME.
- * @const {string}
  * @alias Blockly.VariablesDynamic.CATEGORY_NAME
  */
-const CATEGORY_NAME = 'VARIABLE_DYNAMIC';
-exports.CATEGORY_NAME = CATEGORY_NAME;
+export const CATEGORY_NAME = 'VARIABLE_DYNAMIC';
 
-const stringButtonClickHandler = function(button) {
+function stringButtonClickHandler(button: AnyDuringMigration) {
   Variables.createVariableButtonHandler(
       button.getTargetWorkspace(), undefined, 'String');
-};
-exports.onCreateVariableButtonClick_String = stringButtonClickHandler;
-
-const numberButtonClickHandler = function(button) {
+}
+export const onCreateVariableButtonClick_String = stringButtonClickHandler;
+function numberButtonClickHandler(button: AnyDuringMigration) {
   Variables.createVariableButtonHandler(
       button.getTargetWorkspace(), undefined, 'Number');
-};
-exports.onCreateVariableButtonClick_Number = numberButtonClickHandler;
+}
+export const onCreateVariableButtonClick_Number = numberButtonClickHandler;
 
-const colourButtonClickHandler = function(button) {
+function colourButtonClickHandler(button: AnyDuringMigration) {
   Variables.createVariableButtonHandler(
       button.getTargetWorkspace(), undefined, 'Colour');
-};
-exports.onCreateVariableButtonClick_Colour = colourButtonClickHandler;
+}
+export const onCreateVariableButtonClick_Colour = colourButtonClickHandler;
 
 /**
  * Construct the elements (blocks and button) required by the flyout for the
  * variable category.
- * @param {!WorkspaceSvg} workspace The workspace containing variables.
- * @return {!Array<!Element>} Array of XML elements.
+ * @param workspace The workspace containing variables.
+ * @return Array of XML elements.
  * @alias Blockly.VariablesDynamic.flyoutCategory
  */
-const flyoutCategory = function(workspace) {
-  let xmlList = [];
+export function flyoutCategory(workspace: WorkspaceSvg): Element[] {
+  let xmlList = new Array<Element>();
   let button = document.createElement('button');
   button.setAttribute('text', Msg['NEW_STRING_VARIABLE']);
   button.setAttribute('callbackKey', 'CREATE_VARIABLE_STRING');
@@ -87,20 +81,20 @@ const flyoutCategory = function(workspace) {
   workspace.registerButtonCallback(
       'CREATE_VARIABLE_COLOUR', colourButtonClickHandler);
 
-
-  const blockList = flyoutCategoryBlocks(workspace);
+  // AnyDuringMigration because:  Argument of type 'WorkspaceSvg' is not
+  // assignable to parameter of type 'Workspace'.
+  const blockList = flyoutCategoryBlocks(workspace as AnyDuringMigration);
   xmlList = xmlList.concat(blockList);
   return xmlList;
-};
-exports.flyoutCategory = flyoutCategory;
+}
 
 /**
  * Construct the blocks required by the flyout for the variable category.
- * @param {!Workspace} workspace The workspace containing variables.
- * @return {!Array<!Element>} Array of XML block elements.
+ * @param workspace The workspace containing variables.
+ * @return Array of XML block elements.
  * @alias Blockly.VariablesDynamic.flyoutCategoryBlocks
  */
-const flyoutCategoryBlocks = function(workspace) {
+export function flyoutCategoryBlocks(workspace: Workspace): Element[] {
   const variableModelList = workspace.getAllVariables();
 
   const xmlList = [];
@@ -109,21 +103,31 @@ const flyoutCategoryBlocks = function(workspace) {
       const firstVariable = variableModelList[variableModelList.length - 1];
       const block = xml.createElement('block');
       block.setAttribute('type', 'variables_set_dynamic');
-      block.setAttribute('gap', 24);
-      block.appendChild(Variables.generateVariableFieldDom(firstVariable));
+      // AnyDuringMigration because:  Argument of type 'number' is not
+      // assignable to parameter of type 'string'.
+      block.setAttribute('gap', 24 as AnyDuringMigration);
+      // AnyDuringMigration because:  Argument of type 'Element | null' is not
+      // assignable to parameter of type 'Node'.
+      block.appendChild(
+          Variables.generateVariableFieldDom(firstVariable) as
+          AnyDuringMigration);
       xmlList.push(block);
     }
     if (Blocks['variables_get_dynamic']) {
       variableModelList.sort(VariableModel.compareByName);
-      for (let i = 0, variable; (variable = variableModelList[i]); i++) {
+      for (let i = 0, variable; variable = variableModelList[i]; i++) {
         const block = xml.createElement('block');
         block.setAttribute('type', 'variables_get_dynamic');
-        block.setAttribute('gap', 8);
-        block.appendChild(Variables.generateVariableFieldDom(variable));
+        // AnyDuringMigration because:  Argument of type 'number' is not
+        // assignable to parameter of type 'string'.
+        block.setAttribute('gap', 8 as AnyDuringMigration);
+        // AnyDuringMigration because:  Argument of type 'Element | null' is not
+        // assignable to parameter of type 'Node'.
+        block.appendChild(
+            Variables.generateVariableFieldDom(variable) as AnyDuringMigration);
         xmlList.push(block);
       }
     }
   }
   return xmlList;
-};
-exports.flyoutCategoryBlocks = flyoutCategoryBlocks;
+}

package/core/warning.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2012 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import './events/events_bubble_open.js';
+import type { BlockSvg } from './block_svg.js';
+import { Icon } from './icon.js';
+/**
+ * Class for a warning.
+ * @alias Blockly.Warning
+ */
+export declare class Warning extends Icon {
+    text_: any;
+    /** The top-level node of the warning text, or null if not created. */
+    private paragraphElement_;
+    /** Does this icon get hidden when the block is collapsed? */
+    collapseHidden: boolean;
+    bubble_: any;
+    /** @param block The block associated with this warning. */
+    constructor(block: BlockSvg);
+    /**
+     * Draw the warning icon.
+     * @param group The icon group.
+     */
+    protected drawIcon_(group: Element): void;
+    /**
+     * Show or hide the warning bubble.
+     * @param visible True if the bubble should be visible.
+     */
+    setVisible(visible: boolean): void;
+    /** Show the bubble. */
+    private createBubble_;
+    /** Dispose of the bubble and references to it. */
+    private disposeBubble_;
+    /**
+     * Set this warning's text.
+     * @param text Warning text (or '' to delete). This supports linebreaks.
+     * @param id An ID for this text entry to be able to maintain multiple
+     *     warnings.
+     */
+    setText(text: string, id: string): void;
+    /**
+     * Get this warning's texts.
+     * @return All texts concatenated into one string.
+     */
+    getText(): string;
+    /** Dispose of this warning. */
+    dispose(): void;
+}

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

@@ -7,62 +7,53 @@
 /**
  * @fileoverview Object representing a warning.
  */
-'use strict';
 
 /**
  * Object representing a warning.
  * @class
  */
-goog.module('Blockly.Warning');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Warning');
 
-const dom = goog.require('Blockly.utils.dom');
-const eventUtils = goog.require('Blockly.Events.utils');
-/* eslint-disable-next-line no-unused-vars */
-const {BlockSvg} = goog.requireType('Blockly.BlockSvg');
-const {Bubble} = goog.require('Blockly.Bubble');
-/* eslint-disable-next-line no-unused-vars */
-const {Coordinate} = goog.requireType('Blockly.utils.Coordinate');
-const {Icon} = goog.require('Blockly.Icon');
-const {Svg} = goog.require('Blockly.utils.Svg');
-/** @suppress {extraRequire} */
-goog.require('Blockly.Events.BubbleOpen');
+// Unused import preserved for side-effects. Remove if unneeded.
+import './events/events_bubble_open.js';
+
+import type {BlockSvg} from './block_svg.js';
+import {Bubble} from './bubble.js';
+import * as eventUtils from './events/utils.js';
+import {Icon} from './icon.js';
+import type {Coordinate} from './utils/coordinate.js';
+import * as dom from './utils/dom.js';
+import {Svg} from './utils/svg.js';
 
 
 /**
  * Class for a warning.
- * @extends {Icon}
  * @alias Blockly.Warning
  */
-class Warning extends Icon {
-  /**
-   * @param {!BlockSvg} block The block associated with this warning.
-   */
-  constructor(block) {
+export class Warning extends Icon {
+  text_: AnyDuringMigration;
+
+  /** The top-level node of the warning text, or null if not created. */
+  private paragraphElement_: SVGTextElement|null = null;
+
+  /** Does this icon get hidden when the block is collapsed? */
+  override collapseHidden = false;
+  override bubble_: AnyDuringMigration;
+
+  /** @param block The block associated with this warning. */
+  constructor(block: BlockSvg) {
     super(block);
     this.createIcon();
     // The text_ object can contain multiple warnings.
     this.text_ = Object.create(null);
-
-    /**
-     * The top-level node of the warning text, or null if not created.
-     * @type {?SVGTextElement}
-     * @private
-     */
-    this.paragraphElement_ = null;
-
-    /**
-     * Does this icon get hidden when the block is collapsed?
-     * @type {boolean}
-     */
-    this.collapseHidden = false;
   }
 
   /**
    * Draw the warning icon.
-   * @param {!Element} group The icon group.
-   * @protected
+   * @param group The icon group.
    */
-  drawIcon_(group) {
+  protected override drawIcon_(group: Element) {
     // Triangle with rounded corners.
     dom.createSvgElement(
         Svg.PATH, {
@@ -92,14 +83,16 @@ class Warning extends Icon {
 
   /**
    * Show or hide the warning bubble.
-   * @param {boolean} visible True if the bubble should be visible.
+   * @param visible True if the bubble should be visible.
    */
-  setVisible(visible) {
+  override setVisible(visible: boolean) {
     if (visible === this.isVisible()) {
       return;
     }
-    eventUtils.fire(new (eventUtils.get(eventUtils.BUBBLE_OPEN))(
-        this.block_, visible, 'warning'));
+    // AnyDuringMigration because:  Property 'block_' does not exist on type
+    // 'Warning'.
+    eventUtils.fire(new (eventUtils.get(eventUtils.BUBBLE_OPEN))!
+                    ((this as AnyDuringMigration).block_, visible, 'warning'));
     if (visible) {
       this.createBubble_();
     } else {
@@ -107,23 +100,19 @@ class Warning extends Icon {
     }
   }
 
-  /**
-   * Show the bubble.
-   * @private
-   */
-  createBubble_() {
+  /** Show the bubble. */
+  private createBubble_() {
     this.paragraphElement_ = Bubble.textToDom(this.getText());
+    // AnyDuringMigration because:  Property 'block_' does not exist on type
+    // 'Warning'.
     this.bubble_ = Bubble.createNonEditableBubble(
-        this.paragraphElement_, /** @type {!BlockSvg} */ (this.block_),
-        /** @type {!Coordinate} */ (this.iconXY_));
+        this.paragraphElement_, (this as AnyDuringMigration).block_ as BlockSvg,
+        this.iconXY_ as Coordinate);
     this.applyColour();
   }
 
-  /**
-   * Dispose of the bubble and references to it.
-   * @private
-   */
-  disposeBubble_() {
+  /** Dispose of the bubble and references to it. */
+  private disposeBubble_() {
     this.bubble_.dispose();
     this.bubble_ = null;
     this.paragraphElement_ = null;
@@ -131,12 +120,11 @@ class Warning extends Icon {
 
   /**
    * Set this warning's text.
-   * @param {string} text Warning text (or '' to delete). This supports
-   *    linebreaks.
-   * @param {string} id An ID for this text entry to be able to maintain
-   *     multiple warnings.
+   * @param text Warning text (or '' to delete). This supports linebreaks.
+   * @param id An ID for this text entry to be able to maintain multiple
+   *     warnings.
    */
-  setText(text, id) {
+  setText(text: string, id: string) {
     if (this.text_[id] === text) {
       return;
     }
@@ -153,9 +141,9 @@ class Warning extends Icon {
 
   /**
    * Get this warning's texts.
-   * @return {string} All texts concatenated into one string.
+   * @return All texts concatenated into one string.
    */
-  getText() {
+  getText(): string {
     const allWarnings = [];
     for (const id in this.text_) {
       allWarnings.push(this.text_[id]);
@@ -163,13 +151,11 @@ class Warning extends Icon {
     return allWarnings.join('\n');
   }
 
-  /**
-   * Dispose of this warning.
-   */
-  dispose() {
-    this.block_.warning = null;
-    Icon.prototype.dispose.call(this);
+  /** Dispose of this warning. */
+  override dispose() {
+    // AnyDuringMigration because:  Property 'block_' does not exist on type
+    // 'Warning'.
+    (this as AnyDuringMigration).block_.warning = null;
+    super.dispose();
   }
 }
-
-exports.Warning = Warning;

package/core/widgetdiv.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2013 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Rect } from './utils/rect.js';
+import type { Size } from './utils/size.js';
+/**
+ * Returns the HTML container for editor widgets.
+ * @return The editor widget container.
+ * @alias Blockly.WidgetDiv.getDiv
+ */
+export declare function getDiv(): HTMLDivElement | null;
+/**
+ * Allows unit tests to reset the div.
+ * @param newDiv The new value for the DIV field.
+ * @alias Blockly.WidgetDiv.testOnly_setDiv
+ * @ignore
+ */
+export declare function testOnly_setDiv(newDiv: HTMLDivElement | null): void;
+/**
+ * Create the widget div and inject it onto the page.
+ * @alias Blockly.WidgetDiv.createDom
+ */
+export declare function createDom(): void;
+/**
+ * Initialize and display the widget div.  Close the old one if needed.
+ * @param newOwner The object that will be using this container.
+ * @param rtl Right-to-left (true) or left-to-right (false).
+ * @param newDispose Optional cleanup function to be run when the widget is
+ *     closed.
+ * @alias Blockly.WidgetDiv.show
+ */
+export declare function show(newOwner: any, rtl: boolean, newDispose: Function): void;
+/**
+ * Destroy the widget and hide the div.
+ * @alias Blockly.WidgetDiv.hide
+ */
+export declare function hide(): void;
+/**
+ * Is the container visible?
+ * @return True if visible.
+ * @alias Blockly.WidgetDiv.isVisible
+ */
+export declare function isVisible(): boolean;
+/**
+ * Destroy the widget and hide the div if it is being used by the specified
+ * object.
+ * @param oldOwner The object that was using this container.
+ * @alias Blockly.WidgetDiv.hideIfOwner
+ */
+export declare function hideIfOwner(oldOwner: any): void;
+/**
+ * Position the widget div based on an anchor rectangle.
+ * The widget should be placed adjacent to but not overlapping the anchor
+ * rectangle.  The preferred position is directly below and aligned to the left
+ * (LTR) or right (RTL) side of the anchor.
+ * @param viewportBBox The bounding rectangle of the current viewport, in window
+ *     coordinates.
+ * @param anchorBBox The bounding rectangle of the anchor, in window
+ *     coordinates.
+ * @param widgetSize The size of the widget that is inside the widget div, in
+ *     window coordinates.
+ * @param rtl Whether the workspace is in RTL mode.  This determines horizontal
+ *     alignment.
+ * @alias Blockly.WidgetDiv.positionWithAnchor
+ * @internal
+ */
+export declare function positionWithAnchor(viewportBBox: Rect, anchorBBox: Rect, widgetSize: Size, rtl: boolean): void;