blockly 8.20220331.0-beta.1 → 9.0.0-beta.0

package/core/keyboard_nav/{marker.js → marker.ts}

@@ -8,19 +8,19 @@
  * @fileoverview The class representing a marker.
  * Used primarily for keyboard navigation to show a marked location.
  */
-'use strict';
 
 /**
  * The class representing a marker.
  * Used primarily for keyboard navigation to show a marked location.
  * @class
  */
-goog.module('Blockly.Marker');
+import * as goog from '../../closure/goog/goog.js';
+goog.declareModuleId('Blockly.Marker');
 
 /* eslint-disable-next-line no-unused-vars */
-const {ASTNode} = goog.requireType('Blockly.ASTNode');
-/* eslint-disable-next-line no-unused-vars */
-const {MarkerSvg} = goog.requireType('Blockly.blockRendering.MarkerSvg');
+import type {MarkerSvg} from '../renderers/common/marker_svg.js';
+
+import type {ASTNode} from './ast_node.js';
 
 
 /**
@@ -28,63 +28,50 @@ const {MarkerSvg} = goog.requireType('Blockly.blockRendering.MarkerSvg');
  * This is used in keyboard navigation to save a location in the Blockly AST.
  * @alias Blockly.Marker
  */
-class Marker {
+export class Marker {
+  /** The colour of the marker. */
+  colour: string|null = null;
+
+  /** The current location of the marker. */
+  // AnyDuringMigration because:  Type 'null' is not assignable to type
+  // 'ASTNode'.
+  private curNode_: ASTNode = null as AnyDuringMigration;
+
   /**
-   * Constructs a new Marker instance.
+   * The object in charge of drawing the visual representation of the current
+   * node.
    */
-  constructor() {
-    /**
-     * The colour of the marker.
-     * @type {?string}
-     */
-    this.colour = null;
-
-    /**
-     * The current location of the marker.
-     * @type {ASTNode}
-     * @private
-     */
-    this.curNode_ = null;
-
-    /**
-     * The object in charge of drawing the visual representation of the current
-     * node.
-     * @type {MarkerSvg}
-     * @private
-     */
-    this.drawer_ = null;
-
-    /**
-     * The type of the marker.
-     * @type {string}
-     */
-    this.type = 'marker';
-  }
+  // AnyDuringMigration because:  Type 'null' is not assignable to type
+  // 'MarkerSvg'.
+  private drawer_: MarkerSvg = null as AnyDuringMigration;
+
+  /** The type of the marker. */
+  type = 'marker';
+
+  /** Constructs a new Marker instance. */
+  constructor() {}
 
   /**
    * Sets the object in charge of drawing the marker.
-   * @param {MarkerSvg} drawer The object in charge of
-   *     drawing the marker.
+   * @param drawer The object in charge of drawing the marker.
    */
-  setDrawer(drawer) {
+  setDrawer(drawer: MarkerSvg) {
     this.drawer_ = drawer;
   }
 
   /**
    * Get the current drawer for the marker.
-   * @return {MarkerSvg} The object in charge of drawing
-   *     the marker.
+   * @return The object in charge of drawing the marker.
    */
-  getDrawer() {
+  getDrawer(): MarkerSvg {
     return this.drawer_;
   }
 
   /**
    * Gets the current location of the marker.
-   * @return {ASTNode} The current field, connection, or block the marker
-   *     is on.
+   * @return The current field, connection, or block the marker is on.
    */
-  getCurNode() {
+  getCurNode(): ASTNode {
     return this.curNode_;
   }
 
@@ -92,9 +79,9 @@ class Marker {
    * Set the location of the marker and call the update method.
    * Setting isStack to true will only work if the newLocation is the top most
    * output or previous connection on a stack.
-   * @param {ASTNode} newNode The new location of the marker.
+   * @param newNode The new location of the marker.
    */
-  setCurNode(newNode) {
+  setCurNode(newNode: ASTNode) {
     const oldNode = this.curNode_;
     this.curNode_ = newNode;
     if (this.drawer_) {
@@ -104,7 +91,7 @@ class Marker {
 
   /**
    * Redraw the current marker.
-   * @package
+   * @internal
    */
   draw() {
     if (this.drawer_) {
@@ -112,23 +99,17 @@ class Marker {
     }
   }
 
-  /**
-   * Hide the marker SVG.
-   */
+  /** Hide the marker SVG. */
   hide() {
     if (this.drawer_) {
       this.drawer_.hide();
     }
   }
 
-  /**
-   * Dispose of this marker.
-   */
+  /** Dispose of this marker. */
   dispose() {
     if (this.getDrawer()) {
       this.getDrawer().dispose();
     }
   }
 }
-
-exports.Marker = Marker;

package/core/keyboard_nav/tab_navigate_cursor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ASTNode } from './ast_node.js';
+import { BasicCursor } from './basic_cursor.js';
+/**
+ * A cursor for navigating between tab navigable fields.
+ * @alias Blockly.TabNavigateCursor
+ */
+export declare class TabNavigateCursor extends BasicCursor {
+    /**
+     * Skip all nodes except for tab navigable fields.
+     * @param node The AST node to check whether it is valid.
+     * @return True if the node should be visited, false otherwise.
+     */
+    validNode_(node: ASTNode | null): boolean;
+}

package/core/keyboard_nav/{tab_navigate_cursor.js → tab_navigate_cursor.ts}

@@ -8,38 +8,36 @@
  * @fileoverview The class representing a cursor that is used to navigate
  * between tab navigable fields.
  */
-'use strict';
 
 /**
  * The class representing a cursor that is used to navigate
  * between tab navigable fields.
  * @class
  */
-goog.module('Blockly.TabNavigateCursor');
+import * as goog from '../../closure/goog/goog.js';
+goog.declareModuleId('Blockly.TabNavigateCursor');
 
-const {ASTNode} = goog.require('Blockly.ASTNode');
-const {BasicCursor} = goog.require('Blockly.BasicCursor');
-/* eslint-disable-next-line no-unused-vars */
-const {Field} = goog.requireType('Blockly.Field');
+import type {Field} from '../field.js';
+
+import {ASTNode} from './ast_node.js';
+import {BasicCursor} from './basic_cursor.js';
 
 
 /**
  * A cursor for navigating between tab navigable fields.
- * @extends {BasicCursor}
  * @alias Blockly.TabNavigateCursor
  */
-class TabNavigateCursor extends BasicCursor {
+export class TabNavigateCursor extends BasicCursor {
   /**
    * Skip all nodes except for tab navigable fields.
-   * @param {?ASTNode} node The AST node to check whether it is valid.
-   * @return {boolean} True if the node should be visited, false otherwise.
-   * @override
+   * @param node The AST node to check whether it is valid.
+   * @return True if the node should be visited, false otherwise.
    */
-  validNode_(node) {
+  override validNode_(node: ASTNode|null): boolean {
     let isValid = false;
     const type = node && node.getType();
     if (node) {
-      const location = /** @type {Field} */ (node.getLocation());
+      const location = node.getLocation() as Field;
       if (type === ASTNode.types.FIELD && location &&
           location.isTabNavigable() && location.isClickable()) {
         isValid = true;
@@ -48,5 +46,3 @@ class TabNavigateCursor extends BasicCursor {
     return isValid;
   }
 }
-
-exports.TabNavigateCursor = TabNavigateCursor;

package/core/main.d.ts

@@ -0,0 +1,11 @@
+declare const Blockly: any;
+declare const ContextMenu: any;
+declare const Events: any;
+declare const Msg: any;
+declare const Tooltip: any;
+declare const WidgetDiv: any;
+declare const colour: any;
+declare const common: any;
+declare const deprecation: any;
+declare const dialog: any;
+declare const eventUtils: any;

package/core/main.js

@@ -0,0 +1,303 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @fileoverview The entrypoint for blockly_compressed.js.  Provides
+ *     various backwards-compatibility hacks.  Not used when loading
+ *     in uncompiled (uncompressed) mode via bootstrap.js.
+ */
+'use strict';
+
+goog.module('Blockly.main');
+
+const Blockly = goog.require('Blockly');
+const ContextMenu = goog.require('Blockly.ContextMenu');
+const Events = goog.require('Blockly.Events');
+const Msg = goog.require('Blockly.Msg');
+const Tooltip = goog.require('Blockly.Tooltip');
+const WidgetDiv = goog.require('Blockly.WidgetDiv');
+const colour = goog.require('Blockly.utils.colour');
+const common = goog.require('Blockly.common');
+const deprecation = goog.require('Blockly.utils.deprecation');
+const dialog = goog.require('Blockly.dialog');
+const eventUtils = goog.require('Blockly.Events.utils');
+
+/*
+ * Aliased functions and properties that used to be on the Blockly namespace.
+ * Everything in this section is deprecated. Both external and internal code
+ * should avoid using these functions and use the designated replacements.
+ * Everything in this section will be removed in a future version of Blockly.
+ */
+
+// Add accessors for properties on Blockly that have now been deprecated.
+Object.defineProperties(Blockly, {
+  /**
+   * Wrapper to window.alert() that app developers may override to
+   * provide alternatives to the modal browser window.
+   * @name Blockly.alert
+   * @type {!function(string, function()=)}
+   * @deprecated Use Blockly.dialog.alert / .setAlert() instead.
+   *     (December 2021)
+   * @suppress {checkTypes}
+   */
+  alert: {
+    set: function(newAlert) {
+      deprecation.warn('Blockly.alert', 'December 2021', 'December 2022');
+      dialog.setAlert(newAlert);
+    },
+    get: function() {
+      deprecation.warn(
+          'Blockly.alert', 'December 2021', 'December 2022',
+          'Blockly.dialog.alert()');
+      return dialog.alert;
+    },
+  },
+  /**
+   * Wrapper to window.confirm() that app developers may override to
+   * provide alternatives to the modal browser window.
+   * @name Blockly.confirm
+   * @type {!function(string, function()=)}
+   * @deprecated Use Blockly.dialog.confirm / .setConfirm() instead.
+   *     (December 2021)
+   * @suppress {checkTypes}
+   */
+  confirm: {
+    set: function(newConfirm) {
+      deprecation.warn('Blockly.confirm', 'December 2021', 'December 2022');
+      dialog.setConfirm(newConfirm);
+    },
+    get: function() {
+      deprecation.warn(
+          'Blockly.confirm', 'December 2021', 'December 2022',
+          'Blockly.dialog.confirm()');
+      return dialog.confirm;
+    },
+  },
+  /**
+   * The main workspace most recently used.
+   * Set by Blockly.WorkspaceSvg.prototype.markFocused
+   * @name Blockly.mainWorkspace
+   * @type {Workspace}
+   * @suppress {checkTypes}
+   */
+  mainWorkspace: {
+    set: function(x) {
+      deprecation.warn(
+          'Blockly.mainWorkspace', 'August 2022', 'September 2022',
+          'Blockly.getMainWorkspace');
+      common.setMainWorkspace(x);
+    },
+    get: function() {
+      deprecation.warn(
+          'Blockly.mainWorkspace', 'August 2022', 'September 2022',
+          'Blockly.getMainWorkspace');
+      return common.getMainWorkspace();
+    },
+  },
+  /**
+   * Wrapper to window.prompt() that app developers may override to
+   * provide alternatives to the modal browser window. Built-in
+   * browser prompts are often used for better text input experience
+   * on mobile device. We strongly recommend testing mobile when
+   * overriding this.
+   * @name Blockly.prompt
+   * @type {!function(string, string, function()=)}
+   * @deprecated Use Blockly.dialog.prompt / .setPrompt() instead.
+   *     (December 2021)
+   * @suppress {checkTypes}
+   */
+  prompt: {
+    set: function(newPrompt) {
+      deprecation.warn('Blockly.prompt', 'December 2021', 'December 2022');
+      dialog.setPrompt(newPrompt);
+    },
+    get: function() {
+      deprecation.warn(
+          'Blockly.prompt', 'December 2021', 'December 2022',
+          'Blockly.dialog.prompt()');
+      return dialog.prompt;
+    },
+  },
+  /**
+   * Currently selected block.
+   * @name Blockly.selected
+   * @type {?ICopyable}
+   * @suppress {checkTypes}
+   */
+  selected: {
+    get: function() {
+      deprecation.warn(
+          'Blockly.selected', 'August 2022', 'September 2022',
+          'Blockly.getSelected');
+      return common.getSelected();
+    },
+    set: function(newSelection) {
+      deprecation.warn(
+          'Blockly.selected', 'August 2022', 'September 2022',
+          'Blockly.getSelected');
+      common.setSelected(newSelection);
+    },
+  },
+  /**
+   * The richness of block colours, regardless of the hue.
+   * Must be in the range of 0 (inclusive) to 1 (exclusive).
+   * @name Blockly.HSV_SATURATION
+   * @type {number}
+   * @suppress {checkTypes}
+   */
+  HSV_SATURATION: {
+    get: function() {
+      return colour.getHsvSaturation();
+    },
+    set: function(newValue) {
+      colour.setHsvSaturation(newValue);
+    },
+  },
+  /**
+   * The intensity of block colours, regardless of the hue.
+   * Must be in the range of 0 (inclusive) to 1 (exclusive).
+   * @name Blockly.HSV_VALUE
+   * @type {number}
+   * @suppress {checkTypes}
+   */
+  HSV_VALUE: {
+    get: function() {
+      return colour.getHsvValue();
+    },
+    set: function(newValue) {
+      colour.setHsvValue(newValue);
+    },
+  },
+});
+
+// Add accessors for properties on Blockly.ContextMenu that have now
+// been deprecated.
+Object.defineProperties(ContextMenu, {
+  /**
+   * Which block is the context menu attached to?
+   * @name Blockly.ContextMenu.currentBlock
+   * @type {Block}
+   * @deprecated Use Blockly.Tooltip.getCurrentBlock() /
+   *     .setCurrentBlock() instead.  (September 2021)
+   * @suppress {checkTypes}
+   */
+  currentBlock: {
+    get: function() {
+      deprecation.warn(
+          'Blockly.ContextMenu.currentBlock', 'September 2021',
+          'September 2022', 'Blockly.Tooltip.getCurrentBlock()');
+      return ContextMenu.getCurrentBlock();
+    },
+    set: function(block) {
+      deprecation.warn(
+          'Blockly.ContextMenu.currentBlock', 'September 2021',
+          'September 2022', 'Blockly.Tooltip.setCurrentBlock(block)');
+      ContextMenu.setCurrentBlock(block);
+    },
+  },
+});
+
+// Add accessors for properties on Blockly.Events that have now been
+// deprecated.
+Object.defineProperties(Events, {
+  /**
+   * Sets whether the next event should be added to the undo stack.
+   * @name Blockly.Evenents.recordUndo
+   * @type {boolean}
+   * @deprecated Use Blockly.Events.getRecordUndo() and
+   *     .setRecordUndo().  (September 2021)
+   * @suppress {checkTypes}
+   */
+  recordUndo: {
+    get: function() {
+      deprecation.warn(
+          'Blockly.Events.recordUndo', 'September 2021', 'September 2022',
+          'Blockly.Events.getRecordUndo()');
+      return eventUtils.getRecordUndo();
+    },
+    set: function(record) {
+      deprecation.warn(
+          'Blockly.Events.recordUndo', 'September 2021', 'September 2022',
+          'Blockly.Events.setRecordUndo()');
+      eventUtils.setRecordUndo(record);
+    },
+  },
+});
+
+
+// Add accessors for properties on Blockly.Tooltip that have now been
+// deprecated.
+Object.defineProperties(Tooltip, {
+  /**
+   * Is a tooltip currently showing?
+   * @name Blockly.Tooltip.visible
+   * @type {boolean}
+   * @deprecated Use Blockly.Tooltip.isVisible() instead.  (September
+   *     2021)
+   * @suppress {checkTypes}
+   */
+  visible: {
+    get: function() {
+      deprecation.warn(
+          'Blockly.Tooltip.visible', 'September 2021', 'September 2022',
+          'Blockly.Tooltip.isVisible()');
+      return Tooltip.isVisible();
+    },
+  },
+  /**
+   * The HTML container.  Set once by createDom.
+   * @name Blockly.Tooltip.DIV
+   * @type {HTMLDivElement}
+   * @deprecated Use Blockly.Tooltip.getDiv() and .setDiv().
+   *     (September 2021)
+   * @suppress {checkTypes}
+   */
+  DIV: {
+    get: function() {
+      deprecation.warn(
+          'Blockly.Tooltip.DIV', 'September 2021', 'September 2022',
+          'Blockly.Tooltip.getDiv()');
+      return Tooltip.getDiv();
+    },
+  },
+});
+
+// Add accessors for properties on Blockly.WidgetDiv that have now been
+// deprecated.
+Object.defineProperties(WidgetDiv, {
+  /**
+   * The HTML container for popup overlays (e.g. editor widgets).
+   * @name Blockly.WidgetDiv.DIV
+   * @type {?Element}
+   * @deprecated Use Blockly.WidgetDiv.getDiv() and .setDiv().
+   *     (September 2021)
+   * @suppress {checkTypes}
+   */
+  DIV: {
+    get: function() {
+      deprecation.warn(
+          'Blockly.WidgetDiv.DIV', 'September 2021', 'September 2022',
+          'Blockly.WidgetDiv.getDiv()');
+      return WidgetDiv.getDiv();
+    },
+  },
+});
+
+// If Blockly is compiled with ADVANCED_COMPILATION and/or loaded as a
+// CJS or ES module there will not be a Blockly global variable
+// created.  This can cause problems because a very common way of
+// loading translations is to use a <script> tag to load one of
+// msg/js/*.js, which consists of lines like:
+//
+// Blockly.Msg["ADD_COMMENT"] = "Add Comment";
+// Blockly.Msg["CLEAN_UP"] = "Clean up Blocks";
+//
+// This obviously only works if Blockly.Msg is the Msg export from the
+// Blockly.Msg module - so make sure it is, but only if there is not
+// yet a Blockly global variable.
+if (!('Blockly' in globalThis)) {
+  globalThis['Blockly'] = {'Msg': Msg};
+}

package/core/marker_manager.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Cursor } from './keyboard_nav/cursor.js';
+import type { Marker } from './keyboard_nav/marker.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Class to manage the multiple markers and the cursor on a workspace.
+ * @alias Blockly.MarkerManager
+ */
+export declare class MarkerManager {
+    private readonly workspace;
+    /** The name of the local marker. */
+    static readonly LOCAL_MARKER = "local_marker_1";
+    /** The cursor. */
+    private cursor_;
+    /** The cursor's SVG element. */
+    private cursorSvg_;
+    /** The map of markers for the workspace. */
+    private markers;
+    /** The marker's SVG element. */
+    private markerSvg_;
+    /**
+     * @param workspace The workspace for the marker manager.
+     * @internal
+     */
+    constructor(workspace: WorkspaceSvg);
+    /**
+     * Register the marker by adding it to the map of markers.
+     * @param id A unique identifier for the marker.
+     * @param marker The marker to register.
+     */
+    registerMarker(id: string, marker: Marker): void;
+    /**
+     * Unregister the marker by removing it from the map of markers.
+     * @param id The ID of the marker to unregister.
+     */
+    unregisterMarker(id: string): void;
+    /**
+     * Get the cursor for the workspace.
+     * @return The cursor for this workspace.
+     */
+    getCursor(): Cursor | null;
+    /**
+     * Get a single marker that corresponds to the given ID.
+     * @param id A unique identifier for the marker.
+     * @return The marker that corresponds to the given ID, or null if none
+     *     exists.
+     */
+    getMarker(id: string): Marker | null;
+    /**
+     * Sets the cursor and initializes the drawer for use with keyboard
+     * navigation.
+     * @param cursor The cursor used to move around this workspace.
+     */
+    setCursor(cursor: Cursor): void;
+    /**
+     * Add the cursor SVG to this workspace SVG group.
+     * @param cursorSvg The SVG root of the cursor to be added to the workspace
+     *     SVG group.
+     * @internal
+     */
+    setCursorSvg(cursorSvg: SVGElement | null): void;
+    /**
+     * Add the marker SVG to this workspaces SVG group.
+     * @param markerSvg The SVG root of the marker to be added to the workspace
+     *     SVG group.
+     * @internal
+     */
+    setMarkerSvg(markerSvg: SVGElement | null): void;
+    /**
+     * Redraw the attached cursor SVG if needed.
+     * @internal
+     */
+    updateMarkers(): void;
+    /**
+     * Dispose of the marker manager.
+     * Go through and delete all markers associated with this marker manager.
+     * @suppress {checkTypes}
+     * @internal
+     */
+    dispose(): void;
+}