blockly 8.0.4 → 8.0.5-beta.0

package/core/events/events_block_move.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Block } from '../block.js';
+import { Coordinate } from '../utils/coordinate.js';
+import { BlockBase } from './events_block_base.js';
+/**
+ * Class for a block move event.  Created before the move.
+ * @alias Blockly.Events.BlockMove
+ */
+export declare class BlockMove extends BlockBase {
+    type: string;
+    oldParentId: string;
+    oldInputName: string;
+    oldCoordinate: Coordinate | null;
+    newParentId: string | null;
+    newInputName: string | null;
+    newCoordinate: Coordinate | null;
+    /** @param opt_block The moved block.  Undefined for a blank event. */
+    constructor(opt_block?: Block);
+    /**
+     * Encode the event as JSON.
+     * @return JSON representation.
+     */
+    toJson(): any;
+    /**
+     * Decode the JSON event.
+     * @param json JSON representation.
+     */
+    fromJson(json: any): void;
+    /** Record the block's new location.  Called after the move. */
+    recordNew(): void;
+    /**
+     * Returns the parentId and input if the block is connected,
+     *   or the XY location if disconnected.
+     * @return Collection of location info.
+     */
+    private currentLocation_;
+    /**
+     * Does this event record any change of state?
+     * @return False if something changed.
+     */
+    isNull(): boolean;
+    /**
+     * Run a move event.
+     * @param forward True if run forward, false if run backward (undo).
+     */
+    run(forward: boolean): void;
+}

package/core/events/{events_block_move.js → events_block_move.ts}

@@ -7,45 +7,57 @@
 /**
  * @fileoverview Class for a block move event.
  */
-'use strict';
 
 /**
  * Class for a block move event.
  * @class
  */
-goog.module('Blockly.Events.BlockMove');
+import * as goog from '../../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Events.BlockMove');
 
-const eventUtils = goog.require('Blockly.Events.utils');
-const registry = goog.require('Blockly.registry');
-const {BlockBase} = goog.require('Blockly.Events.BlockBase');
-/* eslint-disable-next-line no-unused-vars */
-const {Block} = goog.requireType('Blockly.Block');
-const {ConnectionType} = goog.require('Blockly.ConnectionType');
-const {Coordinate} = goog.require('Blockly.utils.Coordinate');
+import type {Block} from '../block.js';
+import {ConnectionType} from '../connection_type.js';
+import * as registry from '../registry.js';
+import {Coordinate} from '../utils/coordinate.js';
 
+import {BlockBase} from './events_block_base.js';
+import * as eventUtils from './utils.js';
+
+
+interface BlockLocation {
+  parentId: string;
+  inputName: string;
+  coordinate: Coordinate|null;
+}  // eslint-disable-line no-unused-vars
 
 /**
  * Class for a block move event.  Created before the move.
- * @extends {BlockBase}
  * @alias Blockly.Events.BlockMove
  */
-class BlockMove extends BlockBase {
-  /**
-   * @param {!Block=} opt_block The moved block.  Undefined for a blank
-   *     event.
-   */
-  constructor(opt_block) {
+export class BlockMove extends BlockBase {
+  override type: string;
+  // TODO(b/109816955): remove '!', see go/strict-prop-init-fix.
+  oldParentId!: string;
+  // TODO(b/109816955): remove '!', see go/strict-prop-init-fix.
+  oldInputName!: string;
+  // TODO(b/109816955): remove '!', see go/strict-prop-init-fix.
+  oldCoordinate!: Coordinate|null;
+
+  newParentId: string|null = null;
+  newInputName: string|null = null;
+  newCoordinate: Coordinate|null = null;
+
+  /** @param opt_block The moved block.  Undefined for a blank event. */
+  constructor(opt_block?: Block) {
     super(opt_block);
 
-    /**
-     * Type of this event.
-     * @type {string}
-     */
+    /** Type of this event. */
     this.type = eventUtils.BLOCK_MOVE;
 
     if (!opt_block) {
-      return;  // Blank event to be populated by fromJson.
+      return;
     }
+    // Blank event to be populated by fromJson.
     if (opt_block.isShadow()) {
       // Moving shadow blocks is handled via disconnection.
       this.recordUndo = false;
@@ -55,17 +67,13 @@ class BlockMove extends BlockBase {
     this.oldParentId = location.parentId;
     this.oldInputName = location.inputName;
     this.oldCoordinate = location.coordinate;
-
-    this.newParentId = null;
-    this.newInputName = null;
-    this.newCoordinate = null;
   }
 
   /**
    * Encode the event as JSON.
-   * @return {!Object} JSON representation.
+   * @return JSON representation.
    */
-  toJson() {
+  override toJson(): AnyDuringMigration {
     const json = super.toJson();
     if (this.newParentId) {
       json['newParentId'] = this.newParentId;
@@ -85,9 +93,9 @@ class BlockMove extends BlockBase {
 
   /**
    * Decode the JSON event.
-   * @param {!Object} json JSON representation.
+   * @param json JSON representation.
    */
-  fromJson(json) {
+  override fromJson(json: AnyDuringMigration) {
     super.fromJson(json);
     this.newParentId = json['newParentId'];
     this.newInputName = json['newInputName'];
@@ -100,9 +108,7 @@ class BlockMove extends BlockBase {
     }
   }
 
-  /**
-   * Record the block's new location.  Called after the move.
-   */
+  /** Record the block's new location.  Called after the move. */
   recordNew() {
     const location = this.currentLocation_();
     this.newParentId = location.parentId;
@@ -113,31 +119,32 @@ class BlockMove extends BlockBase {
   /**
    * Returns the parentId and input if the block is connected,
    *   or the XY location if disconnected.
-   * @return {!Object} Collection of location info.
-   * @private
+   * @return Collection of location info.
    */
-  currentLocation_() {
+  private currentLocation_(): BlockLocation {
     const workspace = this.getEventWorkspace_();
     const block = workspace.getBlockById(this.blockId);
-    const location = {};
-    const parent = block.getParent();
+    const location = {} as BlockLocation;
+    const parent = block!.getParent();
     if (parent) {
       location.parentId = parent.id;
-      const input = parent.getInputWithBlock(block);
+      // AnyDuringMigration because:  Argument of type 'Block | null' is not
+      // assignable to parameter of type 'Block'.
+      const input = parent.getInputWithBlock(block as AnyDuringMigration);
       if (input) {
         location.inputName = input.name;
       }
     } else {
-      location.coordinate = block.getRelativeToSurfaceXY();
+      location.coordinate = block!.getRelativeToSurfaceXY();
     }
     return location;
   }
 
   /**
    * Does this event record any change of state?
-   * @return {boolean} False if something changed.
+   * @return False if something changed.
    */
-  isNull() {
+  override isNull(): boolean {
     return this.oldParentId === this.newParentId &&
         this.oldInputName === this.newInputName &&
         Coordinate.equals(this.oldCoordinate, this.newCoordinate);
@@ -145,9 +152,9 @@ class BlockMove extends BlockBase {
 
   /**
    * Run a move event.
-   * @param {boolean} forward True if run forward, false if run backward (undo).
+   * @param forward True if run forward, false if run backward (undo).
    */
-  run(forward) {
+  override run(forward: boolean) {
     const workspace = this.getEventWorkspace_();
     const block = workspace.getBlockById(this.blockId);
     if (!block) {
@@ -157,7 +164,7 @@ class BlockMove extends BlockBase {
     const parentId = forward ? this.newParentId : this.oldParentId;
     const inputName = forward ? this.newInputName : this.oldInputName;
     const coordinate = forward ? this.newCoordinate : this.oldCoordinate;
-    let parentBlock;
+    let parentBlock: Block|null;
     if (parentId) {
       parentBlock = workspace.getBlockById(parentId);
       if (!parentBlock) {
@@ -174,19 +181,18 @@ class BlockMove extends BlockBase {
     } else {
       let blockConnection = block.outputConnection;
       if (!blockConnection ||
-          (block.previousConnection &&
-           block.previousConnection.isConnected())) {
+          block.previousConnection && block.previousConnection.isConnected()) {
         blockConnection = block.previousConnection;
       }
       let parentConnection;
       const connectionType = blockConnection.type;
       if (inputName) {
-        const input = parentBlock.getInput(inputName);
+        const input = parentBlock!.getInput(inputName);
         if (input) {
           parentConnection = input.connection;
         }
       } else if (connectionType === ConnectionType.PREVIOUS_STATEMENT) {
-        parentConnection = parentBlock.nextConnection;
+        parentConnection = parentBlock!.nextConnection;
       }
       if (parentConnection) {
         blockConnection.connect(parentConnection);
@@ -198,5 +204,3 @@ class BlockMove extends BlockBase {
 }
 
 registry.register(registry.Type.EVENT, eventUtils.MOVE, BlockMove);
-
-exports.BlockMove = BlockMove;

package/core/events/events_bubble_open.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { BlockSvg } from '../block_svg.js';
+import { UiBase } from './events_ui_base.js';
+/**
+ * Class for a bubble open event.
+ * @alias Blockly.Events.BubbleOpen
+ */
+export declare class BubbleOpen extends UiBase {
+    blockId: string | null;
+    isOpen?: boolean;
+    bubbleType?: string;
+    type: string;
+    /**
+     * @param opt_block The associated block. Undefined for a blank event.
+     * @param opt_isOpen Whether the bubble is opening (false if closing).
+     *     Undefined for a blank event.
+     * @param opt_bubbleType The type of bubble. One of 'mutator', 'comment' or
+     *     'warning'. Undefined for a blank event.
+     */
+    constructor(opt_block: BlockSvg, opt_isOpen?: boolean, opt_bubbleType?: string);
+    /**
+     * Encode the event as JSON.
+     * @return JSON representation.
+     */
+    toJson(): any;
+    /**
+     * Decode the JSON event.
+     * @param json JSON representation.
+     */
+    fromJson(json: any): void;
+}

package/core/events/events_bubble_open.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Events fired as a result of bubble open.
+ */
+
+/**
+ * Events fired as a result of bubble open.
+ * @class
+ */
+import * as goog from '../../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Events.BubbleOpen');
+
+import type {BlockSvg} from '../block_svg.js';
+import * as registry from '../registry.js';
+
+import {UiBase} from './events_ui_base.js';
+import * as eventUtils from './utils.js';
+
+
+/**
+ * Class for a bubble open event.
+ * @alias Blockly.Events.BubbleOpen
+ */
+export class BubbleOpen extends UiBase {
+  blockId: string|null;
+  isOpen?: boolean;
+  bubbleType?: string;
+  override type: string;
+
+  /**
+   * @param opt_block The associated block. Undefined for a blank event.
+   * @param opt_isOpen Whether the bubble is opening (false if closing).
+   *     Undefined for a blank event.
+   * @param opt_bubbleType The type of bubble. One of 'mutator', 'comment' or
+   *     'warning'. Undefined for a blank event.
+   */
+  constructor(
+      opt_block: BlockSvg, opt_isOpen?: boolean, opt_bubbleType?: string) {
+    const workspaceId = opt_block ? opt_block.workspace.id : undefined;
+    super(workspaceId);
+    this.blockId = opt_block ? opt_block.id : null;
+
+    /** Whether the bubble is opening (false if closing). */
+    this.isOpen = opt_isOpen;
+
+    /** The type of bubble. One of 'mutator', 'comment', or 'warning'. */
+    this.bubbleType = opt_bubbleType;
+
+    /** Type of this event. */
+    this.type = eventUtils.BUBBLE_OPEN;
+  }
+
+  /**
+   * Encode the event as JSON.
+   * @return JSON representation.
+   */
+  override toJson(): AnyDuringMigration {
+    const json = super.toJson();
+    json['isOpen'] = this.isOpen;
+    json['bubbleType'] = this.bubbleType;
+    json['blockId'] = this.blockId;
+    return json;
+  }
+
+  /**
+   * Decode the JSON event.
+   * @param json JSON representation.
+   */
+  override fromJson(json: AnyDuringMigration) {
+    super.fromJson(json);
+    this.isOpen = json['isOpen'];
+    this.bubbleType = json['bubbleType'];
+    this.blockId = json['blockId'];
+  }
+}
+
+registry.register(registry.Type.EVENT, eventUtils.BUBBLE_OPEN, BubbleOpen);

package/core/events/events_click.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Block } from '../block.js';
+import { UiBase } from './events_ui_base.js';
+/**
+ * Class for a click event.
+ * @alias Blockly.Events.Click
+ */
+export declare class Click extends UiBase {
+    blockId: any;
+    targetType?: string;
+    type: string;
+    /**
+     * @param opt_block The affected block. Null for click events that do not have
+     *     an associated block (i.e. workspace click). Undefined for a blank
+     *     event.
+     * @param opt_workspaceId The workspace identifier for this event.
+     *    Not used if block is passed. Undefined for a blank event.
+     * @param opt_targetType The type of element targeted by this click event.
+     *     Undefined for a blank event.
+     */
+    constructor(opt_block?: Block | null, opt_workspaceId?: string | null, opt_targetType?: string);
+    /**
+     * Encode the event as JSON.
+     * @return JSON representation.
+     */
+    toJson(): any;
+    /**
+     * Decode the JSON event.
+     * @param json JSON representation.
+     */
+    fromJson(json: any): void;
+}

package/core/events/{events_click.js → events_click.ts}

@@ -7,37 +7,42 @@
 /**
  * @fileoverview Events fired as a result of UI click in Blockly's editor.
  */
-'use strict';
 
 /**
  * Events fired as a result of UI click in Blockly's editor.
  * @class
  */
-goog.module('Blockly.Events.Click');
+import * as goog from '../../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Events.Click');
 
-const eventUtils = goog.require('Blockly.Events.utils');
-const registry = goog.require('Blockly.registry');
-/* eslint-disable-next-line no-unused-vars */
-const {Block} = goog.requireType('Blockly.Block');
-const {UiBase} = goog.require('Blockly.Events.UiBase');
+import type {Block} from '../block.js';
+import * as registry from '../registry.js';
+
+import {UiBase} from './events_ui_base.js';
+import * as eventUtils from './utils.js';
 
 
 /**
  * Class for a click event.
- * @extends {UiBase}
  * @alias Blockly.Events.Click
  */
-class Click extends UiBase {
+export class Click extends UiBase {
+  blockId: AnyDuringMigration;
+  targetType?: string;
+  override type: string;
+
   /**
-   * @param {?Block=} opt_block The affected block. Null for click events
-   *    that do not have an associated block (i.e. workspace click). Undefined
-   *    for a blank event.
-   * @param {?string=} opt_workspaceId The workspace identifier for this event.
+   * @param opt_block The affected block. Null for click events that do not have
+   *     an associated block (i.e. workspace click). Undefined for a blank
+   *     event.
+   * @param opt_workspaceId The workspace identifier for this event.
    *    Not used if block is passed. Undefined for a blank event.
-   * @param {string=} opt_targetType The type of element targeted by this click
-   *    event. Undefined for a blank event.
+   * @param opt_targetType The type of element targeted by this click event.
+   *     Undefined for a blank event.
    */
-  constructor(opt_block, opt_workspaceId, opt_targetType) {
+  constructor(
+      opt_block?: Block|null, opt_workspaceId?: string|null,
+      opt_targetType?: string) {
     let workspaceId = opt_block ? opt_block.workspace.id : opt_workspaceId;
     if (workspaceId === null) {
       workspaceId = undefined;
@@ -45,24 +50,18 @@ class Click extends UiBase {
     super(workspaceId);
     this.blockId = opt_block ? opt_block.id : null;
 
-    /**
-     * The type of element targeted by this click event.
-     * @type {string|undefined}
-     */
+    /** The type of element targeted by this click event. */
     this.targetType = opt_targetType;
 
-    /**
-     * Type of this event.
-     * @type {string}
-     */
+    /** Type of this event. */
     this.type = eventUtils.CLICK;
   }
 
   /**
    * Encode the event as JSON.
-   * @return {!Object} JSON representation.
+   * @return JSON representation.
    */
-  toJson() {
+  override toJson(): AnyDuringMigration {
     const json = super.toJson();
     json['targetType'] = this.targetType;
     if (this.blockId) {
@@ -73,9 +72,9 @@ class Click extends UiBase {
 
   /**
    * Decode the JSON event.
-   * @param {!Object} json JSON representation.
+   * @param json JSON representation.
    */
-  fromJson(json) {
+  override fromJson(json: AnyDuringMigration) {
     super.fromJson(json);
     this.targetType = json['targetType'];
     this.blockId = json['blockId'];
@@ -83,5 +82,3 @@ class Click extends UiBase {
 }
 
 registry.register(registry.Type.EVENT, eventUtils.CLICK, Click);
-
-exports.Click = Click;

package/core/events/events_comment_base.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { WorkspaceComment } from '../workspace_comment.js';
+import { Abstract as AbstractEvent } from './events_abstract.js';
+import type { CommentCreate } from './events_comment_create.js';
+import type { CommentDelete } from './events_comment_delete.js';
+/**
+ * Abstract class for a comment event.
+ * @alias Blockly.Events.CommentBase
+ */
+export declare class CommentBase extends AbstractEvent {
+    isBlank: boolean;
+    commentId: string;
+    workspaceId: string;
+    /**
+     * @param opt_comment The comment this event corresponds to.  Undefined for a
+     *     blank event.
+     */
+    constructor(opt_comment?: WorkspaceComment);
+    /**
+     * Encode the event as JSON.
+     * @return JSON representation.
+     */
+    toJson(): any;
+    /**
+     * Decode the JSON event.
+     * @param json JSON representation.
+     */
+    fromJson(json: any): void;
+    /**
+     * Helper function for Comment[Create|Delete]
+     * @param event The event to run.
+     * @param create if True then Create, if False then Delete
+     */
+    static CommentCreateDeleteHelper(event: CommentCreate | CommentDelete, create: boolean): void;
+}

package/core/events/events_comment_base.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview Base class for comment events.
+ */
+
+/**
+ * Base class for comment events.
+ * @class
+ */
+import * as goog from '../../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Events.CommentBase');
+
+import * as utilsXml from '../utils/xml.js';
+import type {WorkspaceComment} from '../workspace_comment.js';
+import * as Xml from '../xml.js';
+
+import {Abstract as AbstractEvent} from './events_abstract.js';
+import type {CommentCreate} from './events_comment_create.js';
+import type {CommentDelete} from './events_comment_delete.js';
+import * as eventUtils from './utils.js';
+
+
+/**
+ * Abstract class for a comment event.
+ * @alias Blockly.Events.CommentBase
+ */
+export class CommentBase extends AbstractEvent {
+  override isBlank: boolean;
+  commentId: string;
+  override workspaceId: string;
+
+  /**
+   * @param opt_comment The comment this event corresponds to.  Undefined for a
+   *     blank event.
+   */
+  constructor(opt_comment?: WorkspaceComment) {
+    super();
+    /** Whether or not an event is blank. */
+    this.isBlank = typeof opt_comment === 'undefined';
+
+    /** The ID of the comment this event pertains to. */
+    this.commentId = this.isBlank ? '' : opt_comment!.id;
+
+    /** The workspace identifier for this event. */
+    this.workspaceId = this.isBlank ? '' : opt_comment!.workspace.id;
+
+    /**
+     * The event group id for the group this event belongs to. Groups define
+     * events that should be treated as an single action from the user's
+     * perspective, and should be undone together.
+     */
+    this.group = eventUtils.getGroup();
+
+    /** Sets whether the event should be added to the undo stack. */
+    this.recordUndo = eventUtils.getRecordUndo();
+  }
+
+  /**
+   * Encode the event as JSON.
+   * @return JSON representation.
+   */
+  override toJson(): AnyDuringMigration {
+    const json = super.toJson();
+    if (this.commentId) {
+      json['commentId'] = this.commentId;
+    }
+    return json;
+  }
+
+  /**
+   * Decode the JSON event.
+   * @param json JSON representation.
+   */
+  override fromJson(json: AnyDuringMigration) {
+    super.fromJson(json);
+    this.commentId = json['commentId'];
+  }
+
+  /**
+   * Helper function for Comment[Create|Delete]
+   * @param event The event to run.
+   * @param create if True then Create, if False then Delete
+   */
+  static CommentCreateDeleteHelper(
+      event: CommentCreate|CommentDelete, create: boolean) {
+    const workspace = event.getEventWorkspace_();
+    if (create) {
+      const xmlElement = utilsXml.createElement('xml');
+      xmlElement.appendChild(event.xml);
+      Xml.domToWorkspace(xmlElement, workspace);
+    } else {
+      const comment = workspace.getCommentById(event.commentId);
+      if (comment) {
+        comment.dispose();
+      } else {
+        // Only complain about root-level block.
+        console.warn(
+            'Can\'t uncreate non-existent comment: ' + event.commentId);
+      }
+    }
+  }
+}