scratch-blocks 2.0.0-spork.2 → 2.0.0-spork.3

package/src/events/{events_block_comment_change.js → events_block_comment_change.ts}

@@ -5,10 +5,21 @@
  */
 
 import * as Blockly from "blockly/core";
-import { BlockCommentBase } from "./events_block_comment_base.js";
+import {
+  BlockCommentBase,
+  BlockCommentBaseJson,
+} from "./events_block_comment_base";
+import type { ScratchCommentBubble } from "../scratch_comment_bubble";
 
 class BlockCommentChange extends BlockCommentBase {
-  constructor(opt_blockComment, oldContents, newContents) {
+  oldContents_: string;
+  newContents_: string;
+
+  constructor(
+    opt_blockComment?: ScratchCommentBubble,
+    oldContents?: string,
+    newContents?: string
+  ) {
     super(opt_blockComment);
     this.type = "block_comment_change";
     this.oldContents_ = oldContents;
@@ -19,7 +30,7 @@ class BlockCommentChange extends BlockCommentBase {
     this.recordUndo = false;
   }
 
-  toJson() {
+  toJson(): BlockCommentChangeJson {
     return {
       ...super.toJson(),
       newContents: this.newContents_,
@@ -27,8 +38,16 @@ class BlockCommentChange extends BlockCommentBase {
     };
   }
 
-  static fromJson(json, workspace, event) {
-    const newEvent = super.fromJson(json, workspace, event);
+  static fromJson(
+    json: BlockCommentChangeJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): BlockCommentChange {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new BlockCommentChange()
+    ) as BlockCommentChange;
     newEvent.newContents_ = json["newContents"];
     newEvent.oldContents_ = json["oldContents"];
 
@@ -36,6 +55,11 @@ class BlockCommentChange extends BlockCommentBase {
   }
 }
 
+interface BlockCommentChangeJson extends BlockCommentBaseJson {
+  newContents: string;
+  oldContents: string;
+}
+
 Blockly.registry.register(
   Blockly.registry.Type.EVENT,
   "block_comment_change",

package/src/events/{events_block_comment_collapse.js → events_block_comment_collapse.ts}

@@ -5,30 +5,44 @@
  */
 
 import * as Blockly from "blockly/core";
-import { BlockCommentBase } from "./events_block_comment_base.js";
+import {
+  BlockCommentBase,
+  BlockCommentBaseJson,
+} from "./events_block_comment_base";
+import type { ScratchCommentBubble } from "../scratch_comment_bubble";
 
 class BlockCommentCollapse extends BlockCommentBase {
-  constructor(opt_blockComment, collapsed) {
+  newCollapsed: boolean;
+
+  constructor(opt_blockComment?: ScratchCommentBubble, collapsed?: boolean) {
     super(opt_blockComment);
     this.type = "block_comment_collapse";
     this.newCollapsed = collapsed;
   }
 
-  toJson() {
+  toJson(): BlockCommentCollapseJson {
     return {
       ...super.toJson(),
       collapsed: this.newCollapsed,
     };
   }
 
-  static fromJson(json, workspace, event) {
-    const newEvent = super.fromJson(json, workspace, event);
+  static fromJson(
+    json: BlockCommentCollapseJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): BlockCommentCollapse {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new BlockCommentCollapse()
+    ) as BlockCommentCollapse;
     newEvent.newCollapsed = json["collapsed"];
 
     return newEvent;
   }
 
-  run(forward) {
+  run(forward: boolean) {
     const workspace = this.getEventWorkspace_();
     const block = workspace.getBlockById(this.blockId);
     const comment = block.getIcon(Blockly.icons.IconType.COMMENT);
@@ -36,6 +50,10 @@ class BlockCommentCollapse extends BlockCommentBase {
   }
 }
 
+interface BlockCommentCollapseJson extends BlockCommentBaseJson {
+  collapsed: boolean;
+}
+
 Blockly.registry.register(
   Blockly.registry.Type.EVENT,
   "block_comment_collapse",

package/src/events/{events_block_comment_create.js → events_block_comment_create.ts}

@@ -5,10 +5,21 @@
  */
 
 import * as Blockly from "blockly/core";
-import { BlockCommentBase } from "./events_block_comment_base.js";
+import {
+  BlockCommentBase,
+  BlockCommentBaseJson,
+} from "./events_block_comment_base";
+import type { ScratchCommentBubble } from "../scratch_comment_bubble";
 
 class BlockCommentCreate extends BlockCommentBase {
-  constructor(opt_blockComment) {
+  json: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+
+  constructor(opt_blockComment?: ScratchCommentBubble) {
     super(opt_blockComment);
     this.type = "block_comment_create";
     const size = opt_blockComment.getSize();
@@ -25,26 +36,41 @@ class BlockCommentCreate extends BlockCommentBase {
     this.recordUndo = false;
   }
 
-  toJson() {
+  toJson(): BlockCommentCreateJson {
     return {
       ...super.toJson(),
-      json: this.json,
+      ...this.json,
     };
   }
 
-  static fromJson(json, workspace, event) {
-    const newEvent = super.fromJson(json, workspace, event);
+  static fromJson(
+    json: BlockCommentCreateJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): BlockCommentCreate {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new BlockCommentCreate()
+    ) as BlockCommentCreate;
     newEvent.json = {
-      x: json["json"]["x"],
-      y: json["json"]["y"],
-      width: json["json"]["width"],
-      height: json["json"]["height"],
+      x: json["x"],
+      y: json["y"],
+      width: json["width"],
+      height: json["height"],
     };
 
     return newEvent;
   }
 }
 
+interface BlockCommentCreateJson extends BlockCommentBaseJson {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
 Blockly.registry.register(
   Blockly.registry.Type.EVENT,
   "block_comment_create",

package/src/events/{events_block_comment_delete.js → events_block_comment_delete.ts}

@@ -5,10 +5,14 @@
  */
 
 import * as Blockly from "blockly/core";
-import { BlockCommentBase } from "./events_block_comment_base.js";
+import { BlockCommentBase } from "./events_block_comment_base";
+import type { ScratchCommentBubble } from "../scratch_comment_bubble";
 
 class BlockCommentDelete extends BlockCommentBase {
-  constructor(opt_blockComment, sourceBlock) {
+  constructor(
+    opt_blockComment?: ScratchCommentBubble,
+    sourceBlock?: Blockly.Block
+  ) {
     super(opt_blockComment);
     this.type = "block_comment_delete";
     this.blockId = sourceBlock.id;

package/src/events/{events_block_comment_move.js → events_block_comment_move.ts}

@@ -5,17 +5,28 @@
  */
 
 import * as Blockly from "blockly/core";
-import { BlockCommentBase } from "./events_block_comment_base.js";
+import {
+  BlockCommentBase,
+  BlockCommentBaseJson,
+} from "./events_block_comment_base";
+import type { ScratchCommentBubble } from "../scratch_comment_bubble";
 
 class BlockCommentMove extends BlockCommentBase {
-  constructor(opt_blockComment, oldCoordinate, newCoordinate) {
+  oldCoordinate_: Blockly.utils.Coordinate;
+  newCoordinate_: Blockly.utils.Coordinate;
+
+  constructor(
+    opt_blockComment?: ScratchCommentBubble,
+    oldCoordinate?: Blockly.utils.Coordinate,
+    newCoordinate?: Blockly.utils.Coordinate
+  ) {
     super(opt_blockComment);
     this.type = "block_comment_move";
     this.oldCoordinate_ = oldCoordinate;
     this.newCoordinate_ = newCoordinate;
   }
 
-  toJson() {
+  toJson(): BlockCommentMoveJson {
     return {
       ...super.toJson(),
       newCoordinate: this.newCoordinate_,
@@ -23,8 +34,16 @@ class BlockCommentMove extends BlockCommentBase {
     };
   }
 
-  static fromJson(json, workspace, event) {
-    const newEvent = super.fromJson(json, workspace, event);
+  static fromJson(
+    json: BlockCommentMoveJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): BlockCommentMove {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new BlockCommentMove()
+    ) as BlockCommentMove;
     newEvent.newCoordinate_ = new Blockly.utils.Coordinate(
       json["newCoordinate"]["x"],
       json["newCoordinate"]["y"]
@@ -37,7 +56,7 @@ class BlockCommentMove extends BlockCommentBase {
     return newEvent;
   }
 
-  run(forward) {
+  run(forward: boolean) {
     const workspace = this.getEventWorkspace_();
     const block = workspace?.getBlockById(this.blockId);
     const comment = block?.getIcon(Blockly.icons.IconType.COMMENT);
@@ -47,6 +66,17 @@ class BlockCommentMove extends BlockCommentBase {
   }
 }
 
+interface BlockCommentMoveJson extends BlockCommentBaseJson {
+  newCoordinate: {
+    x: number;
+    y: number;
+  };
+  oldCoordinate: {
+    x: number;
+    y: number;
+  };
+}
+
 Blockly.registry.register(
   Blockly.registry.Type.EVENT,
   "block_comment_move",

package/src/events/events_block_comment_resize.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Blockly from "blockly/core";
+import {
+  BlockCommentBase,
+  BlockCommentBaseJson,
+} from "./events_block_comment_base";
+import type { ScratchCommentBubble } from "../scratch_comment_bubble";
+
+class BlockCommentResize extends BlockCommentBase {
+  oldSize: Blockly.utils.Size;
+  newSize: Blockly.utils.Size;
+
+  constructor(
+    opt_blockComment?: ScratchCommentBubble,
+    oldSize?: Blockly.utils.Size,
+    newSize?: Blockly.utils.Size
+  ) {
+    super(opt_blockComment);
+    this.type = "block_comment_resize";
+    this.oldSize = oldSize;
+    this.newSize = newSize;
+  }
+
+  toJson(): BlockCommentResizeJson {
+    return {
+      ...super.toJson(),
+      newSize: {
+        width: this.newSize.width,
+        height: this.newSize.height,
+      },
+      oldSize: {
+        width: this.oldSize.width,
+        height: this.oldSize.height,
+      },
+    };
+  }
+
+  static fromJson(
+    json: BlockCommentResizeJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): BlockCommentResize {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new BlockCommentResize()
+    ) as BlockCommentResize;
+    newEvent.newSize = new Blockly.utils.Size(
+      json["newSize"]["width"],
+      json["newSize"]["height"]
+    );
+    newEvent.oldSize = new Blockly.utils.Size(
+      json["oldSize"]["width"],
+      json["oldSize"]["height"]
+    );
+
+    return newEvent;
+  }
+
+  run(forward: boolean) {
+    const workspace = this.getEventWorkspace_();
+    const block = workspace?.getBlockById(this.blockId);
+    const comment = block?.getIcon(Blockly.icons.IconType.COMMENT);
+    comment?.setBubbleSize(forward ? this.newSize : this.oldSize);
+  }
+}
+
+interface BlockCommentResizeJson extends BlockCommentBaseJson {
+  newSize: {
+    width: number;
+    height: number;
+  };
+  oldSize: {
+    width: number;
+    height: number;
+  };
+}
+
+Blockly.registry.register(
+  Blockly.registry.Type.EVENT,
+  "block_comment_resize",
+  BlockCommentResize
+);

package/src/events/events_block_drag_end.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Blockly from "blockly/core";
+
+export class BlockDragEnd extends Blockly.Events.BlockBase {
+  isOutside: boolean;
+  xml: Element | DocumentFragment;
+
+  constructor(block?: Blockly.Block, isOutside?: boolean) {
+    super(block);
+    this.type = "endDrag";
+    this.isOutside = isOutside;
+    this.recordUndo = false;
+    this.xml = Blockly.Xml.blockToDom(block, true);
+  }
+
+  toJson(): BlockDragEndJson {
+    return {
+      ...super.toJson(),
+      isOutside: this.isOutside,
+      xml: Blockly.utils.xml.domToText(this.xml),
+    };
+  }
+
+  static fromJson(
+    json: BlockDragEndJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): BlockDragEnd {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new BlockDragEnd()
+    ) as BlockDragEnd;
+    newEvent.isOutside = json["isOutside"];
+    newEvent.xml = Blockly.utils.xml.textToDom(json["xml"]);
+
+    return newEvent;
+  }
+}
+
+interface BlockDragEndJson extends Blockly.Events.BlockBaseJson {
+  isOutside: boolean;
+  xml: string;
+}

package/src/events/events_block_drag_outside.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Blockly from "blockly/core";
+
+export class BlockDragOutside extends Blockly.Events.BlockBase {
+  isOutside: boolean;
+
+  constructor(block?: Blockly.Block, isOutside?: boolean) {
+    super(block);
+    this.type = "dragOutside";
+    this.isOutside = isOutside;
+    this.recordUndo = false;
+  }
+
+  toJson(): BlockDragOutsideJson {
+    return {
+      ...super.toJson(),
+      isOutside: this.isOutside,
+    };
+  }
+
+  static fromJson(
+    json: BlockDragOutsideJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): BlockDragOutside {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new BlockDragOutside()
+    ) as BlockDragOutside;
+    newEvent.isOutside = json["isOutside"];
+
+    return newEvent;
+  }
+}
+
+interface BlockDragOutsideJson extends Blockly.Events.BlockBaseJson {
+  isOutside: boolean;
+}

package/src/events/{events_scratch_variable_create.js → events_scratch_variable_create.ts}

@@ -5,9 +5,13 @@
  */
 
 import * as Blockly from "blockly/core";
+import { ScratchVariableModel } from "../scratch_variable_model";
 
 class ScratchVariableCreate extends Blockly.Events.VarCreate {
-  constructor(variable) {
+  isLocal: boolean;
+  isCloud: boolean;
+
+  constructor(variable?: ScratchVariableModel) {
     super(variable);
     if (!variable) return;
 
@@ -15,30 +19,34 @@ class ScratchVariableCreate extends Blockly.Events.VarCreate {
     this.isCloud = variable.isCloud;
   }
 
-  toJson() {
-    const json = super.toJson();
-    json["isLocal"] = this.isLocal;
-    json["isCloud"] = this.isCloud;
-    return json;
+  toJson(): ScratchVariableCreateJson {
+    return {
+      ...super.toJson(),
+      isLocal: this.isLocal,
+      isCloud: this.isCloud,
+    };
   }
 
-  static fromJson(json, workspace, event) {
-    const newEvent = super.fromJson(json, workspace, event);
+  static fromJson(
+    json: ScratchVariableCreateJson,
+    workspace: Blockly.Workspace,
+    event?: any
+  ): ScratchVariableCreate {
+    const newEvent = super.fromJson(
+      json,
+      workspace,
+      event ?? new ScratchVariableCreate()
+    ) as ScratchVariableCreate;
     newEvent.isLocal = json["isLocal"];
     newEvent.isCloud = json["isCloud"];
     return newEvent;
   }
 
-  run(forward) {
+  run(forward: boolean) {
     const workspace = this.getEventWorkspace_();
     const variableMap = workspace.getVariableMap();
     if (forward) {
-      const VariableModel = Blockly.registry.getObject(
-        Blockly.registry.Type.VARIABLE_MODEL,
-        Blockly.registry.DEFAULT,
-        true
-      );
-      const variable = new VariableModel(
+      const variable = new ScratchVariableModel(
         workspace,
         this.varName,
         this.varType,
@@ -59,6 +67,11 @@ class ScratchVariableCreate extends Blockly.Events.VarCreate {
   }
 }
 
+interface ScratchVariableCreateJson extends Blockly.Events.VarCreateJson {
+  isCloud: boolean;
+  isLocal: boolean;
+}
+
 Blockly.registry.register(
   Blockly.registry.Type.EVENT,
   Blockly.Events.VAR_CREATE,