blockly 8.0.4 → 8.0.5-beta.0

package/core/scrollbar_pair.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2011 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Metrics } from './utils/metrics.js';
+import type { WorkspaceSvg } from './workspace_svg.js';
+/**
+ * Class for a pair of scrollbars.  Horizontal and vertical.
+ * @alias Blockly.ScrollbarPair
+ */
+export declare class ScrollbarPair {
+    private workspace;
+    hScroll: any;
+    vScroll: any;
+    corner_: any;
+    /** Previously recorded metrics from the workspace. */
+    private oldHostMetrics_;
+    /**
+     * @param workspace Workspace to bind the scrollbars to.
+     * @param addHorizontal Whether to add a horizontal scrollbar.
+     *    Defaults to true.
+     * @param addVertical Whether to add a vertical scrollbar. Defaults to true.
+     * @param opt_class A class to be applied to these scrollbars.
+     * @param opt_margin The margin to apply to these scrollbars.
+     */
+    constructor(workspace: WorkspaceSvg, addHorizontal?: boolean, addVertical?: boolean, opt_class?: string, opt_margin?: number);
+    /**
+     * Dispose of this pair of scrollbars.
+     * Unlink from all DOM elements to prevent memory leaks.
+     * @suppress {checkTypes}
+     */
+    dispose(): void;
+    /**
+     * Recalculate both of the scrollbars' locations and lengths.
+     * Also reposition the corner rectangle.
+     */
+    resize(): void;
+    /**
+     * Returns whether scrolling horizontally is enabled.
+     * @return True if horizontal scroll is enabled.
+     */
+    canScrollHorizontally(): boolean;
+    /**
+     * Returns whether scrolling vertically is enabled.
+     * @return True if vertical scroll is enabled.
+     */
+    canScrollVertically(): boolean;
+    /**
+     * Record the origin of the workspace that the scrollbar is in, in pixels
+     * relative to the injection div origin. This is for times when the scrollbar
+     * is used in an object whose origin isn't the same as the main workspace
+     * (e.g. in a flyout.)
+     * @param x The x coordinate of the scrollbar's origin, in CSS pixels.
+     * @param y The y coordinate of the scrollbar's origin, in CSS pixels.
+     * @internal
+     */
+    setOrigin(x: number, y: number): void;
+    /**
+     * Set the handles of both scrollbars.
+     * @param x The horizontal content displacement, relative to the view in
+     *     pixels.
+     * @param y The vertical content displacement, relative to the view in pixels.
+     * @param updateMetrics Whether to update metrics on this set call.
+     *    Defaults to true.
+     */
+    set(x: number, y: number, updateMetrics: boolean): void;
+    /**
+     * Set the handle of the horizontal scrollbar to be at a certain position in
+     *    CSS pixels relative to its parents.
+     * @param x Horizontal scroll value.
+     */
+    setX(x: number): void;
+    /**
+     * Set the handle of the vertical scrollbar to be at a certain position in
+     *    CSS pixels relative to its parents.
+     * @param y Vertical scroll value.
+     */
+    setY(y: number): void;
+    /**
+     * Set whether this scrollbar's container is visible.
+     * @param visible Whether the container is visible.
+     */
+    setContainerVisible(visible: boolean): void;
+    /**
+     * If any of the scrollbars are visible. Non-paired scrollbars may disappear
+     * when they aren't needed.
+     * @return True if visible.
+     */
+    isVisible(): boolean;
+    /**
+     * Recalculates the scrollbars' locations within their path and length.
+     * This should be called when the contents of the workspace have changed.
+     * @param hostMetrics A data structure describing all the required dimensions,
+     *     possibly fetched from the host object.
+     */
+    resizeContent(hostMetrics: Metrics): void;
+    /**
+     * Recalculates the scrollbars' locations on the screen and path length.
+     * This should be called when the layout or size of the window has changed.
+     * @param hostMetrics A data structure describing all the required dimensions,
+     *     possibly fetched from the host object.
+     */
+    resizeView(hostMetrics: Metrics): void;
+}

package/core/{scrollbar_pair.js → scrollbar_pair.ts}

@@ -7,46 +7,45 @@
 /**
  * @fileoverview Object representing a pair of scrollbars.
  */
-'use strict';
 
 /**
  * Object representing a pair of scrollbars.
  * @class
  */
-goog.module('Blockly.ScrollbarPair');
+import * as goog from '../closure/goog/goog.js';
+goog.declareModuleId('Blockly.ScrollbarPair');
 
-const dom = goog.require('Blockly.utils.dom');
-const eventUtils = goog.require('Blockly.Events.utils');
-/* eslint-disable-next-line no-unused-vars */
-const {Metrics} = goog.requireType('Blockly.utils.Metrics');
-const {Scrollbar} = goog.require('Blockly.Scrollbar');
-const {Svg} = goog.require('Blockly.utils.Svg');
-/* eslint-disable-next-line no-unused-vars */
-const {WorkspaceSvg} = goog.requireType('Blockly.WorkspaceSvg');
+import * as eventUtils from './events/utils.js';
+import {Scrollbar} from './scrollbar.js';
+import * as dom from './utils/dom.js';
+import type {Metrics} from './utils/metrics.js';
+import {Svg} from './utils/svg.js';
+import type {WorkspaceSvg} from './workspace_svg.js';
 
 
 /**
  * Class for a pair of scrollbars.  Horizontal and vertical.
  * @alias Blockly.ScrollbarPair
  */
-const ScrollbarPair = class {
+export class ScrollbarPair {
+  hScroll: AnyDuringMigration;
+  vScroll: AnyDuringMigration;
+  corner_: AnyDuringMigration;
+
+  /** Previously recorded metrics from the workspace. */
+  private oldHostMetrics_: Metrics|null = null;
+
   /**
-   * @param {!WorkspaceSvg} workspace Workspace to bind the scrollbars to.
-   * @param {boolean=} addHorizontal Whether to add a horizontal scrollbar.
+   * @param workspace Workspace to bind the scrollbars to.
+   * @param addHorizontal Whether to add a horizontal scrollbar.
    *    Defaults to true.
-   * @param {boolean=} addVertical Whether to add a vertical scrollbar. Defaults
-   *    to true.
-   * @param {string=} opt_class A class to be applied to these scrollbars.
-   * @param {number=} opt_margin The margin to apply to these scrollbars.
+   * @param addVertical Whether to add a vertical scrollbar. Defaults to true.
+   * @param opt_class A class to be applied to these scrollbars.
+   * @param opt_margin The margin to apply to these scrollbars.
    */
-  constructor(workspace, addHorizontal, addVertical, opt_class, opt_margin) {
-    /**
-     * The workspace this scrollbar pair is bound to.
-     * @type {!WorkspaceSvg}
-     * @private
-     */
-    this.workspace_ = workspace;
-
+  constructor(
+      private workspace: WorkspaceSvg, addHorizontal?: boolean,
+      addVertical?: boolean, opt_class?: string, opt_margin?: number) {
     addHorizontal = addHorizontal === undefined ? true : addHorizontal;
     addVertical = addVertical === undefined ? true : addVertical;
     const isPair = addHorizontal && addVertical;
@@ -61,22 +60,13 @@ const ScrollbarPair = class {
     }
 
     if (isPair) {
-      this.corner_ = dom.createSvgElement(
-          Svg.RECT, {
-            'height': Scrollbar.scrollbarThickness,
-            'width': Scrollbar.scrollbarThickness,
-            'class': 'blocklyScrollbarBackground',
-          },
-          null);
+      this.corner_ = dom.createSvgElement(Svg.RECT, {
+        'height': Scrollbar.scrollbarThickness,
+        'width': Scrollbar.scrollbarThickness,
+        'class': 'blocklyScrollbarBackground',
+      });
       dom.insertAfter(this.corner_, workspace.getBubbleCanvas());
     }
-
-    /**
-     * Previously recorded metrics from the workspace.
-     * @type {?Metrics}
-     * @private
-     */
-    this.oldHostMetrics_ = null;
   }
 
   /**
@@ -87,7 +77,9 @@ const ScrollbarPair = class {
   dispose() {
     dom.removeNode(this.corner_);
     this.corner_ = null;
-    this.workspace_ = null;
+    // AnyDuringMigration because:  Type 'null' is not assignable to type
+    // 'WorkspaceSvg'.
+    this.workspace = null as AnyDuringMigration;
     this.oldHostMetrics_ = null;
     if (this.hScroll) {
       this.hScroll.dispose();
@@ -105,7 +97,7 @@ const ScrollbarPair = class {
    */
   resize() {
     // Look up the host metrics once, and use for both scrollbars.
-    const hostMetrics = this.workspace_.getMetrics();
+    const hostMetrics = this.workspace.getMetrics();
     if (!hostMetrics) {
       // Host element is likely not visible.
       return;
@@ -150,7 +142,7 @@ const ScrollbarPair = class {
       } finally {
         eventUtils.enable();
       }
-      this.workspace_.maybeFireViewportChangeEvent();
+      this.workspace.maybeFireViewportChangeEvent();
     }
 
     if (this.hScroll && this.vScroll) {
@@ -173,17 +165,17 @@ const ScrollbarPair = class {
 
   /**
    * Returns whether scrolling horizontally is enabled.
-   * @return {boolean} True if horizontal scroll is enabled.
+   * @return True if horizontal scroll is enabled.
    */
-  canScrollHorizontally() {
+  canScrollHorizontally(): boolean {
     return !!this.hScroll;
   }
 
   /**
    * Returns whether scrolling vertically is enabled.
-   * @return {boolean} True if vertical scroll is enabled.
+   * @return True if vertical scroll is enabled.
    */
-  canScrollVertically() {
+  canScrollVertically(): boolean {
     return !!this.vScroll;
   }
 
@@ -192,13 +184,11 @@ const ScrollbarPair = class {
    * relative to the injection div origin. This is for times when the scrollbar
    * is used in an object whose origin isn't the same as the main workspace
    * (e.g. in a flyout.)
-   * @param {number} x The x coordinate of the scrollbar's origin, in CSS
-   *     pixels.
-   * @param {number} y The y coordinate of the scrollbar's origin, in CSS
-   *     pixels.
-   * @package
+   * @param x The x coordinate of the scrollbar's origin, in CSS pixels.
+   * @param y The y coordinate of the scrollbar's origin, in CSS pixels.
+   * @internal
    */
-  setOrigin(x, y) {
+  setOrigin(x: number, y: number) {
     if (this.hScroll) {
       this.hScroll.setOrigin(x, y);
     }
@@ -209,15 +199,13 @@ const ScrollbarPair = class {
 
   /**
    * Set the handles of both scrollbars.
-   * @param {number} x The horizontal content displacement, relative to the view
-   *    in pixels.
-   * @param {number} y The vertical content displacement, relative to the view
-   *     in
-   *    pixels.
-   * @param {boolean} updateMetrics Whether to update metrics on this set call.
+   * @param x The horizontal content displacement, relative to the view in
+   *     pixels.
+   * @param y The vertical content displacement, relative to the view in pixels.
+   * @param updateMetrics Whether to update metrics on this set call.
    *    Defaults to true.
    */
-  set(x, y, updateMetrics) {
+  set(x: number, y: number, updateMetrics: boolean) {
     // This function is equivalent to:
     //   this.hScroll.set(x);
     //   this.vScroll.set(y);
@@ -235,21 +223,27 @@ const ScrollbarPair = class {
       // Update metrics.
       const xyRatio = {};
       if (this.hScroll) {
-        xyRatio.x = this.hScroll.getRatio_();
+        // AnyDuringMigration because:  Property 'x' does not exist on type
+        // '{}'.
+        (xyRatio as AnyDuringMigration).x = this.hScroll.getRatio_();
       }
       if (this.vScroll) {
-        xyRatio.y = this.vScroll.getRatio_();
+        // AnyDuringMigration because:  Property 'y' does not exist on type
+        // '{}'.
+        (xyRatio as AnyDuringMigration).y = this.vScroll.getRatio_();
       }
-      this.workspace_.setMetrics(xyRatio);
+      // AnyDuringMigration because:  Argument of type '{}' is not assignable to
+      // parameter of type '{ x: number; y: number; }'.
+      this.workspace.setMetrics(xyRatio as AnyDuringMigration);
     }
   }
 
   /**
    * Set the handle of the horizontal scrollbar to be at a certain position in
    *    CSS pixels relative to its parents.
-   * @param {number} x Horizontal scroll value.
+   * @param x Horizontal scroll value.
    */
-  setX(x) {
+  setX(x: number) {
     if (this.hScroll) {
       this.hScroll.set(x, true);
     }
@@ -258,9 +252,9 @@ const ScrollbarPair = class {
   /**
    * Set the handle of the vertical scrollbar to be at a certain position in
    *    CSS pixels relative to its parents.
-   * @param {number} y Vertical scroll value.
+   * @param y Vertical scroll value.
    */
-  setY(y) {
+  setY(y: number) {
     if (this.vScroll) {
       this.vScroll.set(y, true);
     }
@@ -268,9 +262,9 @@ const ScrollbarPair = class {
 
   /**
    * Set whether this scrollbar's container is visible.
-   * @param {boolean} visible Whether the container is visible.
+   * @param visible Whether the container is visible.
    */
-  setContainerVisible(visible) {
+  setContainerVisible(visible: boolean) {
     if (this.hScroll) {
       this.hScroll.setContainerVisible(visible);
     }
@@ -282,9 +276,9 @@ const ScrollbarPair = class {
   /**
    * If any of the scrollbars are visible. Non-paired scrollbars may disappear
    * when they aren't needed.
-   * @return {boolean} True if visible.
+   * @return True if visible.
    */
-  isVisible() {
+  isVisible(): boolean {
     let isVisible = false;
     if (this.hScroll) {
       isVisible = this.hScroll.isVisible();
@@ -298,10 +292,10 @@ const ScrollbarPair = class {
   /**
    * Recalculates the scrollbars' locations within their path and length.
    * This should be called when the contents of the workspace have changed.
-   * @param {!Metrics} hostMetrics A data structure describing all
-   *     the required dimensions, possibly fetched from the host object.
+   * @param hostMetrics A data structure describing all the required dimensions,
+   *     possibly fetched from the host object.
    */
-  resizeContent(hostMetrics) {
+  resizeContent(hostMetrics: Metrics) {
     if (this.hScroll) {
       this.hScroll.resizeContentHorizontal(hostMetrics);
     }
@@ -313,10 +307,10 @@ const ScrollbarPair = class {
   /**
    * Recalculates the scrollbars' locations on the screen and path length.
    * This should be called when the layout or size of the window has changed.
-   * @param {!Metrics} hostMetrics A data structure describing all
-   *     the required dimensions, possibly fetched from the host object.
+   * @param hostMetrics A data structure describing all the required dimensions,
+   *     possibly fetched from the host object.
    */
-  resizeView(hostMetrics) {
+  resizeView(hostMetrics: Metrics) {
     if (this.hScroll) {
       this.hScroll.resizeViewHorizontal(hostMetrics);
     }
@@ -324,6 +318,4 @@ const ScrollbarPair = class {
       this.vScroll.resizeViewVertical(hostMetrics);
     }
   }
-};
-
-exports.ScrollbarPair = ScrollbarPair;
+}

package/core/serialization/blocks.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Block } from '../block.js';
+import type { Connection } from '../connection.js';
+import type { Workspace } from '../workspace.js';
+/**
+ * Represents the state of a connection.
+ * @alias Blockly.serialization.blocks.ConnectionState
+ */
+export interface ConnectionState {
+    shadow: State | undefined;
+    block: State | undefined;
+}
+/**
+ * Represents the state of a given block.
+ * @alias Blockly.serialization.blocks.State
+ */
+export interface State {
+    type: string;
+    id?: string;
+    x?: number;
+    y?: number;
+    collapsed?: boolean;
+    enabled?: boolean;
+    inline?: boolean;
+    data?: string;
+    extraState?: any;
+    icons?: {
+        [key: string]: any;
+    };
+    fields?: {
+        [key: string]: any;
+    };
+    inputs?: {
+        [key: string]: ConnectionState;
+    };
+    next?: ConnectionState;
+}
+/**
+ * Returns the state of the given block as a plain JavaScript object.
+ * @param block The block to serialize.
+ * @param param1 addCoordinates: If true, the coordinates of the block are added
+ *     to the serialized state. False by default. addinputBlocks: If true,
+ *     children of the block which are connected to inputs will be serialized.
+ *     True by default. addNextBlocks: If true, children of the block which are
+ *     connected to the block's next connection (if it exists) will be
+ *     serialized. True by default. doFullSerialization: If true, fields that
+ *     normally just save a reference to some external state (eg variables) will
+ *     instead serialize all of the info about that state. This supports
+ *     deserializing the block into a workspace where that state doesn't yet
+ *     exist. True by default.
+ * @return The serialized state of the block, or null if the block could not be
+ *     serialied (eg it was an insertion marker).
+ * @alias Blockly.serialization.blocks.save
+ */
+export declare function save(block: Block, { addCoordinates, addInputBlocks, addNextBlocks, doFullSerialization }?: {
+    addCoordinates?: boolean;
+    addInputBlocks?: boolean;
+    addNextBlocks?: boolean;
+    doFullSerialization?: boolean;
+}): State | null;
+/**
+ * Loads the block represented by the given state into the given workspace.
+ * @param state The state of a block to deserialize into the workspace.
+ * @param workspace The workspace to add the block to.
+ * @param param1 recordUndo: If true, events triggered by this function will be
+ *     undo-able by the user. False by default.
+ * @return The block that was just loaded.
+ * @alias Blockly.serialization.blocks.append
+ */
+export declare function append(state: State, workspace: Workspace, { recordUndo }?: {
+    recordUndo?: boolean;
+}): Block;
+/**
+ * Loads the block represented by the given state into the given workspace.
+ * This is defined internally so that the extra parameters don't clutter our
+ * external API.
+ * But it is exported so that other places within Blockly can call it directly
+ * with the extra parameters.
+ * @param state The state of a block to deserialize into the workspace.
+ * @param workspace The workspace to add the block to.
+ * @param param1 parentConnection: If provided, the system will attempt to
+ *     connect the block to this connection after it is created. Undefined by
+ *     default. isShadow: If true, the block will be set to a shadow block after
+ *     it is created. False by default. recordUndo: If true, events triggered by
+ *     this function will be undo-able by the user. False by default.
+ * @return The block that was just appended.
+ * @alias Blockly.serialization.blocks.appendInternal
+ * @internal
+ */
+export declare function appendInternal(state: State, workspace: Workspace, { parentConnection, isShadow, recordUndo }?: {
+    parentConnection?: Connection;
+    isShadow?: boolean;
+    recordUndo?: boolean;
+}): Block;