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

package/src/{variables.js → variables.ts}

@@ -26,37 +26,59 @@ import * as Blockly from "blockly/core";
 import {
   LIST_VARIABLE_TYPE,
   BROADCAST_MESSAGE_VARIABLE_TYPE,
-} from "./constants.js";
+} from "./constants";
+import { ScratchVariableModel } from "./scratch_variable_model";
+import { ScratchContinuousToolbox } from "./scratch_continuous_toolbox";
+import { CheckableContinuousFlyout } from "./checkable_continuous_flyout.js";
 
 /**
- * Constant prefix to differentiate cloud variable names from other types
- * of variables.
+ * Constant prefix to differentiate cloud variable names from other types of
+ * variables.
  * This is the \u2601 cloud unicode character followed by a space.
- * @type {string}
- * @package
  */
 const CLOUD_PREFIX = "☁ ";
 
-let prompt = null;
+type PromptType = (
+  message: string,
+  defaultValue: string,
+  callback: (
+    variableName: string,
+    additionalVars: string[],
+    variableOptions?: { scope?: string; isCloud?: boolean }
+  ) => void,
+  title?: string,
+  varType?: string
+) => void;
 
-export function setPromptHandler(handler) {
+let prompt: PromptType | undefined = undefined;
+
+/**
+ * Sets the handler for calls to prompt().
+ *
+ * @param handler The new prompt function.
+ */
+export function setPromptHandler(handler: PromptType) {
   prompt = handler;
 }
 
 /**
  * Create a new variable on the given workspace.
- * @param {!Blockly.Workspace} workspace The workspace on which to create the
- *     variable.
- * @param {function(?string=)=} opt_callback An optional callback function to act
- *     on the id of the variable that is created from the user's input, or null
- *     if the change is to be aborted (cancel button or an invalid name was provided).
- * @param {string} opt_type Optional type of the variable to be created,
- *     like 'string' or 'list'.
+ *
+ * @param workspace The workspace on which to create the variable.
+ * @param opt_callback An optional callback function to act on the id of the
+ *     variable that is created from the user's input, or null if the change is
+ *     to be aborted (cancel button or an invalid name was provided).
+ * @param opt_type Optional type of the variable to be created, like 'string' or
+ *     'list'.
  */
-export function createVariable(workspace, opt_callback, opt_type) {
+export function createVariable(
+  workspace: Blockly.WorkspaceSvg,
+  opt_callback?: (id?: string) => void,
+  opt_type?: string
+) {
   // Decide on a modal message based on the opt_type. If opt_type was not
   // provided, default to the original message for scalar variables.
-  var newMsg, modalTitle;
+  let newMsg, modalTitle;
   if (opt_type === BROADCAST_MESSAGE_VARIABLE_TYPE) {
     newMsg = Blockly.Msg.NEW_BROADCAST_MESSAGE_TITLE;
     modalTitle = Blockly.Msg.BROADCAST_MODAL_TITLE;
@@ -67,29 +89,33 @@ export function createVariable(workspace, opt_callback, opt_type) {
     // Note: this case covers 1) scalar variables, 2) any new type of
     // variable not explicitly checked for above, and 3) a null or undefined
     // opt_type -- turns a falsey opt_type into ''
-    // TODO (#1251) Warn developers that they didn't provide an opt_type/provided
-    // a falsey opt_type
+    // TODO (#1251) Warn developers that they didn't provide an opt_type/
+    // provided a falsey opt_type
     opt_type = opt_type ? opt_type : "";
     newMsg = Blockly.Msg.NEW_VARIABLE_TITLE;
     modalTitle = Blockly.Msg.VARIABLE_MODAL_TITLE;
   }
-  var validate = nameValidator.bind(null, opt_type);
+  const validate = nameValidator.bind(null, opt_type);
 
   // Prompt the user to enter a name for the variable
   prompt(
     newMsg,
     "",
-    function (text, additionalVars, variableOptions) {
+    function (
+      text: string,
+      additionalVars: string[],
+      variableOptions?: { scope?: string; isCloud?: boolean }
+    ) {
       variableOptions = variableOptions || {};
-      var scope = variableOptions.scope;
-      var isLocal = scope === "local" || false;
-      var isCloud = variableOptions.isCloud || false;
+      const scope = variableOptions.scope;
+      const isLocal = scope === "local" || false;
+      const isCloud = variableOptions.isCloud || false;
       // Default to [] if additionalVars is not provided
       additionalVars = additionalVars || [];
       // Only use additionalVars for global variable creation.
-      var additionalVarNames = isLocal ? [] : additionalVars;
+      const additionalVarNames = isLocal ? [] : additionalVars;
 
-      var validatedText = validate(
+      const validatedText = validate(
         text,
         workspace,
         additionalVarNames,
@@ -97,12 +123,7 @@ export function createVariable(workspace, opt_callback, opt_type) {
         opt_callback
       );
       if (validatedText) {
-        const VariableModel = Blockly.registry.getObject(
-          Blockly.registry.Type.VARIABLE_MODEL,
-          Blockly.registry.DEFAULT,
-          true
-        );
-        const variable = new VariableModel(
+        const variable = new ScratchVariableModel(
           workspace,
           validatedText,
           opt_type,
@@ -115,11 +136,17 @@ export function createVariable(workspace, opt_callback, opt_type) {
           new (Blockly.Events.get(Blockly.Events.VAR_CREATE))(variable)
         );
 
-        var flyout = workspace.isFlyout ? workspace : workspace.getFlyout();
-        var variableBlockId = variable.getId();
-        workspace.getToolbox()?.runAfterRerender(() => {
-          flyout.setCheckboxState(variableBlockId, true);
-        });
+        const toolbox = workspace.getToolbox();
+        const flyout = toolbox.getFlyout();
+        const variableBlockId = variable.getId();
+        if (
+          toolbox instanceof ScratchContinuousToolbox &&
+          flyout instanceof CheckableContinuousFlyout
+        ) {
+          toolbox.runAfterRerender(() => {
+            flyout.setCheckboxState(variableBlockId, true);
+          });
+        }
 
         if (opt_callback) {
           opt_callback(variableBlockId);
@@ -137,44 +164,44 @@ export function createVariable(workspace, opt_callback, opt_type) {
 }
 
 /**
- * This function provides a common interface for variable name validation agnostic
- * of type. This is so that functions like Blockly.Variables.createVariable and
- * Blockly.Variables.renameVariable can call a single function (with a single
- * type signature) to validate the user-provided name for a variable.
- * @param {string} type The type of the variable for which the provided name
- *     should be validated.
- * @param {string} text The user-provided text that should be validated as a
- *     variable name.
- * @param {!Blockly.Workspace} workspace The workspace on which to validate the
- *     variable name. This is the workspace used to check whether the variable
- *     already exists.
- * @param {Array<string>} additionalVars A list of additional var names to check
- *     for conflicts against.
- * @param {boolean} isCloud Whether the variable is a cloud variable.
- * @param {function(?string=)=} opt_callback An optional function to be called on
- *     a pre-existing variable of the user-provided name. This function is currently
- *     only used for broadcast messages.
- * @return {string} The validated name according to the parameters given, if
- *     the name is determined to be valid, or null if the name
- *     is determined to be invalid/in-use, and the calling function should not
- *     proceed with creating or renaming the variable.
- * @private
+ * This function provides a common interface for variable name validation
+ * agnostic of type. This is so that functions like  createVariable and
+ * renameVariable can call a single function (with a single type signature) to
+ * validate the user-provided name for a variable.
+ *
+ * @param type The type of the variable for which the provided name should be
+ *     validated.
+ * @param text The user-provided text that should be validated as a variable
+ *     name.
+ * @param workspace The workspace on which to validate the variable name. This
+ *     is the workspace used to check whether the variable already exists.
+ * @param additionalVars A list of additional var names to check for conflicts
+ *     against.
+ * @param isCloud Whether the variable is a cloud variable.
+ * @param opt_callback An optional function to be called on a pre-existing
+ *     variable of the user-provided name. This function is currently only used
+ *     for broadcast messages.
+ * @returns The validated name according to the parameters given, if the name is
+ *     determined to be valid, or null if the name is determined to be invalid/
+ *     in-use, and the calling function should not proceed with creating or
+ *     renaming the variable.
  */
 function nameValidator(
-  type,
-  text,
-  workspace,
-  additionalVars,
-  isCloud,
-  opt_callback
-) {
-  // The validators for the different variable types require slightly different arguments.
-  // For broadcast messages, if a broadcast message of the provided name already exists,
-  // the validator needs to call a function that updates the selected
-  // field option of the dropdown menu of the block that was used to create the new message.
-  // For scalar variables and lists, the validator has the same validation behavior, but needs
-  // to know which type of variable to check for and needs a type-specific error message
-  // that is displayed when a variable of the given name and type already exists.
+  type: string,
+  text: string,
+  workspace: Blockly.WorkspaceSvg,
+  additionalVars: string[],
+  isCloud: boolean,
+  opt_callback?: (id?: string) => void
+): string {
+  // The validators for the different variable types require slightly different
+  // arguments. For broadcast messages, if a broadcast message of the provided
+  // name already exists, the validator needs to call a function that updates
+  // the selected field option of the dropdown menu of the block that was used
+  // to create the new message. For scalar variables and lists, the validator
+  // has the same validation behavior, but needs to know which type of variable
+  // to check for and needs a type-specific error message that is displayed when
+  // a variable of the given name and type already exists.
 
   if (type === BROADCAST_MESSAGE_VARIABLE_TYPE) {
     return validateBroadcastMessageName(text, workspace, opt_callback);
@@ -201,21 +228,24 @@ function nameValidator(
 
 /**
  * Validate the given name as a broadcast message type.
- * @param {string} name The name to validate
- * @param {!Blockly.Workspace} workspace The workspace the name should be validated
- *     against.
- * @param {function(?string=)=} opt_callback An optional function to call if a broadcast
- *     message already exists with the given name. This function will be called on the id
- *     of the existing variable.
- * @return {string} The validated name, or null if invalid.
- * @private
+ *
+ * @param name The name to validate
+ * @param workspace The workspace the name should be validated against.
+ * @param opt_callback An optional function to call if a broadcast message
+ *     already exists with the given name. This function will be called on the
+ *     id of the existing variable.
+ * @returns The validated name, or null if invalid.
  */
-function validateBroadcastMessageName(name, workspace, opt_callback) {
+function validateBroadcastMessageName(
+  name: string,
+  workspace: Blockly.WorkspaceSvg,
+  opt_callback?: (id?: string) => void
+): string | null {
   if (!name) {
     // no name was provided or the user cancelled the prompt
     return null;
   }
-  var variable = workspace.getVariable(name, BROADCAST_MESSAGE_VARIABLE_TYPE);
+  const variable = workspace.getVariable(name, BROADCAST_MESSAGE_VARIABLE_TYPE);
   if (variable) {
     // If the user provided a name for a broadcast message that already exists,
     // use the provided callback function to update the selected option in
@@ -237,27 +267,26 @@ function validateBroadcastMessageName(name, workspace, opt_callback) {
 /**
  * Validate the given name as a scalar variable or list type.
  * This function is also responsible for any user facing error-handling.
- * @param {string} name The name to validate
- * @param {!Blockly.Workspace} workspace The workspace the name should be validated
- *     against.
- * @param {Array<string>} additionalVars A list of additional variable names to check
- *     for conflicts against.
- * @param {boolean} isCloud Whether the variable is a cloud variable.
- * @param {string} type The type to validate the variable as. This should be one of
- *     Blockly.SCALAR_VARIABLE_TYPE or Blockly.LIST_VARIABLE_TYPE.
- * @param {string} errorMsg The type-specific error message the user should see
- *     if a variable of the validated, given name and type already exists.
- * @return {string} The validated name, or null if invalid.
- * @private
+ *
+ * @param name The name to validate
+ * @param workspace The workspace the name should be validated against.
+ * @param additionalVars A list of additional variable names to check for
+ *     conflicts against.
+ * @param isCloud Whether the variable is a cloud variable.
+ * @param type The type to validate the variable as. This should be one of
+ *     SCALAR_VARIABLE_TYPE or LIST_VARIABLE_TYPE.
+ * @param errorMsg The type-specific error message the user should see if a
+ *     variable of the validated, given name and type already exists.
+ * @returns The validated name, or null if invalid.
  */
 function validateScalarVarOrListName(
-  name,
-  workspace,
-  additionalVars,
-  isCloud,
-  type,
-  errorMsg
-) {
+  name: string,
+  workspace: Blockly.WorkspaceSvg,
+  additionalVars: string[],
+  isCloud: boolean,
+  type: string,
+  errorMsg: string
+): string | null {
   // For scalar variables, we don't want leading or trailing white space
   name = name.trim();
   if (!name) {
@@ -278,24 +307,25 @@ function validateScalarVarOrListName(
 
 /**
  * Rename a variable with the given workspace, variableType, and oldName.
- * @param {!Blockly.Workspace} workspace The workspace on which to rename the
- *     variable.
- * @param {Blockly.VariableModel} variable Variable to rename.
- * @param {function(?string=)=} opt_callback A callback. It will
- *     be passed an acceptable new variable name, or null if change is to be
- *     aborted (cancel button), or undefined if an existing variable was chosen.
+ *
+ * @param workspace The workspace on which to rename the variable.
+ * @param variable Variable to rename.
+ * @param opt_callback A callback. It will be passed an acceptable new variable
+ *     name, or null if change is to be aborted (cancel button), or undefined if
+ *     an existing variable was chosen.
  */
-export function renameVariable(workspace, variable, opt_callback) {
+export function renameVariable(
+  workspace: Blockly.WorkspaceSvg,
+  variable: ScratchVariableModel,
+  opt_callback?: (id?: string) => void
+) {
   // Validation and modal message/title depends on the variable type
-  var promptMsg, modalTitle;
-  var varType = variable.type;
+  let promptMsg, modalTitle;
+  const varType = variable.getType();
   if (varType === BROADCAST_MESSAGE_VARIABLE_TYPE) {
     console.warn(
-      "Unexpected attempt to rename a broadcast message with " +
-        "id: " +
-        variable.getId() +
-        " and name: " +
-        variable.name
+      `Unexpected attempt to rename a broadcast message with
+      id: "${variable.getId()} and name: ${variable.getName()}`
     );
     return;
   }
@@ -307,18 +337,18 @@ export function renameVariable(workspace, variable, opt_callback) {
     promptMsg = Blockly.Msg.RENAME_VARIABLE_TITLE;
     modalTitle = Blockly.Msg.RENAME_VARIABLE_MODAL_TITLE;
   }
-  var validate = nameValidator.bind(null, varType);
+  const validate = nameValidator.bind(null, varType);
 
-  var promptText = promptMsg.replace("%1", variable.name);
-  var promptDefaultText = variable.name;
-  if (variable.isCloud && variable.name.indexOf(CLOUD_PREFIX) == 0) {
+  const promptText = promptMsg.replace("%1", variable.getName());
+  let promptDefaultText = variable.getName();
+  if (variable.isCloud && variable.getName().indexOf(CLOUD_PREFIX) == 0) {
     promptDefaultText = promptDefaultText.substring(CLOUD_PREFIX.length);
   }
 
   prompt(
     promptText,
     promptDefaultText,
-    function (newName, additionalVars) {
+    (newName: string, additionalVars: string[]) => {
       if (
         variable.isCloud &&
         newName.length > 0 &&
@@ -328,8 +358,8 @@ export function renameVariable(workspace, variable, opt_callback) {
         // The name validator will add the prefix back
       }
       additionalVars = additionalVars || [];
-      var additionalVarNames = variable.isLocal ? [] : additionalVars;
-      var validatedText = validate(
+      const additionalVarNames = variable.isLocal ? [] : additionalVars;
+      const validatedText = validate(
         newName,
         workspace,
         additionalVarNames,
@@ -352,4 +382,4 @@ export function renameVariable(workspace, variable, opt_callback) {
   );
 }
 
-export { getVariablesCategory } from "./data_category.js";
+export { getVariablesCategory } from "./data_category";

package/tsconfig.json

@@ -1,6 +1,8 @@
 {
-  "exclude": [
-    "./blockly-rc/"
+  "include": [
+    "./src/",
+    "./tests/",
+    "./types/"
   ],
   "compilerOptions": {
     "outDir": "./dist/",

package/src/categories.js

@@ -1,15 +0,0 @@
-const Categories = {
-  motion: "motion",
-  looks: "looks",
-  sound: "sounds",
-  pen: "pen",
-  data: "data",
-  dataLists: "data-lists",
-  event: "events",
-  control: "control",
-  sensing: "sensing",
-  operators: "operators",
-  more: "more",
-};
-
-export { Categories };

package/src/events/events_block_comment_resize.js

@@ -1,52 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Blockly from "blockly/core";
-import { BlockCommentBase } from "./events_block_comment_base.js";
-
-class BlockCommentResize extends BlockCommentBase {
-  constructor(opt_blockComment, oldSize, newSize) {
-    super(opt_blockComment);
-    this.type = "block_comment_resize";
-    this.oldSize = oldSize;
-    this.newSize = newSize;
-  }
-
-  toJson() {
-    return {
-      ...super.toJson(),
-      newSize: this.newSize,
-      oldSize: this.oldSize,
-    };
-  }
-
-  static fromJson(json, workspace, event) {
-    const newEvent = super.fromJson(json, workspace, event);
-    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) {
-    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);
-  }
-}
-
-Blockly.registry.register(
-  Blockly.registry.Type.EVENT,
-  "block_comment_resize",
-  BlockCommentResize
-);

package/src/events/events_block_drag_end.js

@@ -1,33 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Blockly from "blockly/core";
-
-export class BlockDragEnd extends Blockly.Events.BlockBase {
-  constructor(block, isOutside) {
-    super(block);
-    this.type = "endDrag";
-    this.isOutside = isOutside;
-    this.recordUndo = false;
-    this.xml = Blockly.Xml.blockToDom(block, true);
-  }
-
-  toJson() {
-    return {
-      ...super.toJson(),
-      isOutside: this.isOutside,
-      xml: this.xml,
-    };
-  }
-
-  static fromJson(json, workspace, event) {
-    const newEvent = super.fromJson(json, workspace, event);
-    newEvent.isOutside = json["isOutside"];
-    newEvent.xml = json["xml"];
-
-    return newEvent;
-  }
-}

package/src/events/events_block_drag_outside.js

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