scratch-blocks 2.0.2 → 2.0.3

package/src/events/events_block_drag_end.ts

@@ -1,21 +1,19 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 export class BlockDragEnd extends Blockly.Events.BlockBase {
-  isOutside!: boolean;
-  xml!: Element | DocumentFragment;
+  isOutside!: boolean
+  xml!: Element | DocumentFragment
 
   constructor(block?: Blockly.Block, isOutside?: boolean) {
-    super(block);
-    this.type = "endDrag";
-    if (isOutside !== undefined) this.isOutside = isOutside;
-    this.recordUndo = false;
-    if (block) this.xml = Blockly.Xml.blockToDom(block, true);
+    super(block)
+    this.type = 'endDrag'
+    if (isOutside !== undefined) this.isOutside = isOutside
+    this.recordUndo = false
+    if (block) this.xml = Blockly.Xml.blockToDom(block, true)
   }
 
   toJson(): BlockDragEndJson {
@@ -23,27 +21,19 @@ export class BlockDragEnd extends Blockly.Events.BlockBase {
       ...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"]);
+  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;
+    return newEvent
   }
 }
 
 interface BlockDragEndJson extends Blockly.Events.BlockBaseJson {
-  isOutside: boolean;
-  xml: string;
+  isOutside: boolean
+  xml: string
 }

package/src/events/events_block_drag_outside.ts

@@ -1,44 +1,34 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
+import * as Blockly from 'blockly/core'
 
 export class BlockDragOutside extends Blockly.Events.BlockBase {
-  isOutside!: boolean;
+  isOutside!: boolean
 
   constructor(block?: Blockly.Block, isOutside?: boolean) {
-    super(block);
-    this.type = "dragOutside";
-    if (isOutside !== undefined) this.isOutside = isOutside;
-    this.recordUndo = false;
+    super(block)
+    this.type = 'dragOutside'
+    if (isOutside !== undefined) 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"];
+  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;
+    return newEvent
   }
 }
 
 interface BlockDragOutsideJson extends Blockly.Events.BlockBaseJson {
-  isOutside: boolean;
+  isOutside: boolean
 }

package/src/events/events_scratch_variable_create.ts

@@ -1,22 +1,20 @@
 /**
- * @license
  * Copyright 2024 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import * as Blockly from "blockly/core";
-import { ScratchVariableModel } from "../scratch_variable_model";
+import * as Blockly from 'blockly/core'
+import { ScratchVariableModel } from '../scratch_variable_model'
 
 class ScratchVariableCreate extends Blockly.Events.VarCreate {
-  isLocal!: boolean;
-  isCloud!: boolean;
+  isLocal!: boolean
+  isCloud!: boolean
 
   constructor(variable?: ScratchVariableModel) {
-    super(variable);
-    if (!variable) return;
+    super(variable)
+    if (!variable) return
 
-    this.isLocal = variable.isLocal;
-    this.isCloud = variable.isCloud;
+    this.isLocal = variable.isLocal
+    this.isCloud = variable.isCloud
   }
 
   toJson(): ScratchVariableCreateJson {
@@ -24,38 +22,27 @@ class ScratchVariableCreate extends Blockly.Events.VarCreate {
       ...super.toJson(),
       isLocal: this.isLocal,
       isCloud: this.isCloud,
-    };
+    }
   }
 
-  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;
+  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: boolean) {
-    const workspace = this.getEventWorkspace_();
-    const variableMap = workspace.getVariableMap();
+    const workspace = this.getEventWorkspace_()
+    const variableMap = workspace.getVariableMap()
     if (forward) {
       if (this.varName == null || this.varType == null || this.varId == null) {
-        console.error(
-          "ScratchVariableCreate.run: missing variable data for create",
-          {
-            varName: this.varName,
-            varType: this.varType,
-            varId: this.varId,
-          }
-        );
-        return;
+        console.error('ScratchVariableCreate.run: missing variable data for create', {
+          varName: this.varName,
+          varType: this.varType,
+          varId: this.varId,
+        })
+        return
       }
       const variable = new ScratchVariableModel(
         workspace,
@@ -63,36 +50,26 @@ class ScratchVariableCreate extends Blockly.Events.VarCreate {
         this.varType,
         this.varId,
         this.isLocal,
-        this.isCloud
-      );
-      variableMap.addVariable(variable);
-      Blockly.Events.fire(
-        new (Blockly.Events.get(Blockly.Events.VAR_CREATE))(variable)
-      );
+        this.isCloud,
+      )
+      variableMap.addVariable(variable)
+      Blockly.Events.fire(new (Blockly.Events.get(Blockly.Events.VAR_CREATE))(variable))
     } else {
       if (this.varId == null) {
-        console.error(
-          "ScratchVariableCreate.run: missing varId for delete",
-          this
-        );
-        return;
+        console.error('ScratchVariableCreate.run: missing varId for delete', this)
+        return
       }
-      const variable = variableMap.getVariableById(this.varId);
+      const variable = variableMap.getVariableById(this.varId)
       if (variable) {
-        variableMap.deleteVariable(variable);
+        variableMap.deleteVariable(variable)
       }
     }
   }
 }
 
 interface ScratchVariableCreateJson extends Blockly.Events.VarCreateJson {
-  isCloud: boolean;
-  isLocal: boolean;
+  isCloud: boolean
+  isLocal: boolean
 }
 
-Blockly.registry.register(
-  Blockly.registry.Type.EVENT,
-  Blockly.Events.VAR_CREATE,
-  ScratchVariableCreate,
-  true
-);
+Blockly.registry.register(Blockly.registry.Type.EVENT, Blockly.Events.VAR_CREATE, ScratchVariableCreate, true)